From c51e5f7f71e42b350097011ce0ad8d6aa5b463f9 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Fri, 24 Nov 2023 04:43:26 +0800
Subject: [PATCH 001/147] Implement rudimentary `PreTyper` and a prototype of
 new UCS desugarer

---
 .../src/main/scala/mlscript/JSBackend.scala   |  15 ++
 shared/src/main/scala/mlscript/Typer.scala    |   7 +-
 .../main/scala/mlscript/codegen/Helpers.scala |   4 +-
 shared/src/main/scala/mlscript/helpers.scala  |  24 ++
 .../scala/mlscript/pretyper/PreTyper.scala    | 186 ++++++++++++++++
 .../main/scala/mlscript/pretyper/Scope.scala  |  47 ++++
 .../main/scala/mlscript/pretyper/Symbol.scala |  77 +++++++
 .../scala/mlscript/pretyper/Traceable.scala   |  39 ++++
 .../mlscript/pretyper/TypeContents.scala      |   5 +
 .../scala/mlscript/pretyper/package.scala     |  14 ++
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |  97 +++++++++
 .../main/scala/mlscript/ucs/Desugarer.scala   |   9 +-
 .../main/scala/mlscript/ucs/PartialTerm.scala |  10 +
 shared/src/main/scala/mlscript/ucs/core.scala |  80 +++++++
 .../src/main/scala/mlscript/ucs/package.scala |  31 +++
 .../mlscript/ucs/stages/Desugaring.scala      | 126 +++++++++++
 .../mlscript/ucs/stages/Normalization.scala   | 205 ++++++++++++++++++
 .../mlscript/ucs/stages/PostProcessing.scala  |  60 +++++
 .../mlscript/ucs/stages/Transformation.scala  | 145 +++++++++++++
 .../scala/mlscript/ucs/stages/package.scala   |   7 +
 .../src/main/scala/mlscript/ucs/syntax.scala  | 152 +++++++++++++
 shared/src/test/diff/mlscript/Basics.mls      |   2 +-
 .../src/test/diff/mlscript/ByNameByValue.mls  |   4 +-
 shared/src/test/diff/mlscript/MultiArgs.mls   |   8 +-
 shared/src/test/diff/mlscript/Ops.mls         |  10 +-
 shared/src/test/diff/mlscript/Repro.mls       |  14 ++
 shared/src/test/diff/nu/LamPatterns.mls       |   2 +-
 shared/src/test/diff/nu/OverrideShorthand.mls |   4 +-
 shared/src/test/diff/nu/RightAssocOps.mls     |   6 +-
 .../src/test/diff/pretyper/Declarations.mls   |  89 ++++++++
 .../src/test/diff/pretyper/ucs/DualOption.mls | 135 ++++++++++++
 .../test/diff/pretyper/ucs/NamePattern.mls    |   9 +
 .../test/diff/pretyper/ucs/RecordPattern.mls  |   8 +
 .../test/diff/pretyper/ucs/TransfromUCS.mls   |  45 ++++
 .../test/diff/pretyper/ucs/TuplePattern.mls   |  10 +
 shared/src/test/diff/pretyper/ucs/Unapply.mls |  13 ++
 .../test/diff/pretyper/ucs/Unconditional.mls  |  26 +++
 .../diff/pretyper/ucs/examples/Option.mls     |  42 ++++
 shared/src/test/diff/ucs/LeadingAnd.mls       |   4 +-
 shared/src/test/diff/ucs/SplitOps.mls         |   4 +-
 .../src/test/scala/mlscript/DiffTests.scala   |  29 ++-
 41 files changed, 1771 insertions(+), 33 deletions(-)
 create mode 100644 shared/src/main/scala/mlscript/pretyper/PreTyper.scala
 create mode 100644 shared/src/main/scala/mlscript/pretyper/Scope.scala
 create mode 100644 shared/src/main/scala/mlscript/pretyper/Symbol.scala
 create mode 100644 shared/src/main/scala/mlscript/pretyper/Traceable.scala
 create mode 100644 shared/src/main/scala/mlscript/pretyper/TypeContents.scala
 create mode 100644 shared/src/main/scala/mlscript/pretyper/package.scala
 create mode 100644 shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
 create mode 100644 shared/src/main/scala/mlscript/ucs/core.scala
 create mode 100644 shared/src/main/scala/mlscript/ucs/package.scala
 create mode 100644 shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
 create mode 100644 shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
 create mode 100644 shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
 create mode 100644 shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
 create mode 100644 shared/src/main/scala/mlscript/ucs/stages/package.scala
 create mode 100644 shared/src/main/scala/mlscript/ucs/syntax.scala
 create mode 100644 shared/src/test/diff/pretyper/Declarations.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/DualOption.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/NamePattern.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/RecordPattern.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/TransfromUCS.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/TuplePattern.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/Unapply.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/Unconditional.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/examples/Option.mls

diff --git a/shared/src/main/scala/mlscript/JSBackend.scala b/shared/src/main/scala/mlscript/JSBackend.scala
index 9ea71bf8ef..d95f31221b 100644
--- a/shared/src/main/scala/mlscript/JSBackend.scala
+++ b/shared/src/main/scala/mlscript/JSBackend.scala
@@ -187,6 +187,8 @@ class JSBackend(allowUnresolvedSymbols: Boolean) {
       JSRecord(fields map { case (key, Fld(_, value)) =>
         key.name -> translateTerm(value)
       })
+    case Sel(receiver, JSBackend.TupleIndex(n)) =>
+      JSField(translateTerm(receiver), n.toString)
     case Sel(receiver, fieldName) =>
       JSField(translateTerm(receiver), fieldName.name)
     // Turn let into an IIFE.
@@ -1576,4 +1578,17 @@ object JSBackend {
 
   def isSafeInteger(value: BigInt): Boolean =
     MinimalSafeInteger <= value && value <= MaximalSafeInteger
+
+    // Temporary measurement until we adopt the new tuple index.
+  object TupleIndex {
+    def unapply(fieldName: Var): Opt[Int] = {
+      val name = fieldName.name
+      if (name.startsWith("_") && name.forall(_.isDigit))
+        name.drop(1).toIntOption match {
+          case S(n) if n > 0 => S(n - 1)
+          case _ => N
+        }
+      else N
+    }
+  }
 }
diff --git a/shared/src/main/scala/mlscript/Typer.scala b/shared/src/main/scala/mlscript/Typer.scala
index 3b11dfca25..c2a75e9627 100644
--- a/shared/src/main/scala/mlscript/Typer.scala
+++ b/shared/src/main/scala/mlscript/Typer.scala
@@ -1207,8 +1207,11 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
         }
         con(s_ty, req, cs_ty)
       case elf: If =>
-        try typeTerm(desugarIf(elf)) catch {
-          case e: ucs.DesugaringException => err(e.messages)
+        elf.desugaredTerm match {
+          case S(desugared) => typeTerm(desugared)
+          case N => try typeTerm(desugarIf(elf)) catch {
+            case e: ucs.DesugaringException => err(e.messages)
+          }
         }
       case AdtMatchWith(cond, arms) =>
         println(s"typed condition term ${cond}")
diff --git a/shared/src/main/scala/mlscript/codegen/Helpers.scala b/shared/src/main/scala/mlscript/codegen/Helpers.scala
index 2ffcbdcf9d..298ec57691 100644
--- a/shared/src/main/scala/mlscript/codegen/Helpers.scala
+++ b/shared/src/main/scala/mlscript/codegen/Helpers.scala
@@ -13,8 +13,8 @@ object Helpers {
     case App(lhs, rhs) => s"App(${inspect(lhs)}, ${inspect(rhs)})"
     case Tup(fields) =>
       val entries = fields map {
-        case (S(name), Fld(_, value)) => s"$name: ${inspect(value)}"
-        case (N, Fld(_, value))       => s"_: ${inspect(value)}"
+        case (S(name), Fld(_, value)) => s"(S(${inspect(name)}), ${inspect(value)})"
+        case (N, Fld(_, value))       => s"(N, ${inspect(value)})"
       }
       s"Tup(${entries mkString ", "})"
     case Rcd(fields) =>
diff --git a/shared/src/main/scala/mlscript/helpers.scala b/shared/src/main/scala/mlscript/helpers.scala
index a6e2784f46..3285c8d8ec 100644
--- a/shared/src/main/scala/mlscript/helpers.scala
+++ b/shared/src/main/scala/mlscript/helpers.scala
@@ -480,6 +480,14 @@ trait TypingUnitImpl extends Located { self: TypingUnit =>
   }.mkString("{", "; ", "}")
   override def toString: String = s"‹${entities.mkString("; ")}›"
   lazy val children: List[Located] = entities
+  def describe: Str = entities.iterator.map {
+    case term: Term => term.describe
+    case NuFunDef(S(rec), nme, _, _, _) =>
+      s"let ${if (rec) "rec " else ""}$nme"
+    case NuFunDef(N, nme, _, _, _) => s"fun $nme"
+    case typ: NuTypeDef => typ.describe
+    case other => "?"
+  }.mkString("{", "; ", "}")
 }
 
 trait ConstructorImpl { self: Constructor =>
@@ -493,6 +501,7 @@ trait TypeNameImpl extends Ordered[TypeName] { self: TypeName =>
   def targs: Ls[Type] = Nil
   def compare(that: TypeName): Int = this.name compare that.name
   lazy val toVar: Var = Var(name).withLocOf(this)
+  var symbol: Opt[pretyper.TypeSymbol] = N
 }
 
 trait FldImpl extends Located { self: Fld =>
@@ -727,6 +736,21 @@ trait VarImpl { self: Var =>
     (name.head.isLetter && name.head.isLower || name.head === '_' || name.head === '$') && name =/= "true" && name =/= "false"
   def toVar: Var = this
   var uid: Opt[Int] = N
+
+  // PreTyper additions
+  import pretyper.{Symbol}
+
+  private var _symbol: Opt[Symbol] = N
+  def symbolOption: Opt[Symbol] = _symbol
+  def symbol: Symbol = _symbol.getOrElse(???)
+  def symbol_=(symbol: Symbol): Unit =
+    _symbol match {
+      case N => _symbol = S(symbol)
+      case S(_) => ???
+    }
+  // TODO: Remove this methods if they are useless.
+  // def withSymbol: Var = { symbol = S(new ValueSymbol(this, false)); this }
+  // def withSymbol(s: TermSymbol): Var = { symbol = S(s); this }
 }
 
 trait TupImpl { self: Tup =>
diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
new file mode 100644
index 0000000000..f76c062874
--- /dev/null
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -0,0 +1,186 @@
+package mlscript.pretyper
+
+import mlscript.ucs.DesugarUCS
+import mlscript._, utils._, shorthands._
+import mlscript.codegen.Helpers.inspect
+
+class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Traceable with DesugarUCS {
+  private def extractParameters(fields: Term): Ls[ValueSymbol] = fields match {
+    case Tup(arguments) =>
+      if (useNewDefs) {
+        arguments.map {
+          case (S(nme: Var), Fld(_, _)) => new ValueSymbol(nme, false)
+          case (_, Fld(_, nme: Var)) => new ValueSymbol(nme, false)
+          case (_, Fld(_, x)) => println(x.toString); ???
+        }
+      } else {
+        arguments.map {
+          case (_, Fld(_, nme: Var)) => new ValueSymbol(nme, false)
+          case (_, Fld(_, x)) => println(x.toString); ???
+        }
+      }
+    case PlainTup(arguments @ _*) =>
+      arguments.map {
+        case nme: Var => new ValueSymbol(nme, false)
+        case other => println("Unknown parameters: " + inspect(other)); ??? // TODO: bad
+      }.toList
+    case other => println("Unknown parameters: " + inspect(other)); ??? // TODO: bad
+  }
+
+  // `visitIf` is meaningless because it represents patterns with terms.
+
+  protected def resolveVar(v: Var)(implicit scope: Scope): Unit =
+    trace(s"resolveVar(name = \"$v\")") {
+      scope.get(v.name) match {
+        case Some(sym: ValueSymbol) =>
+          println(s"Resolve variable $v to a value.", 2)
+          v.symbol = sym
+        case Some(sym: SubValueSymbol) =>
+          println(s"Resolve variable $v to a value.", 2)
+          v.symbol = sym
+        case Some(sym: FunctionSymbol) =>
+          println(s"Resolve variable $v to a function.", 2)
+          v.symbol = sym
+        case Some(sym: TypeSymbol) =>
+          if (sym.defn.kind == Cls) {
+            println(s"Resolve variable $v to a class.", 2)
+            v.symbol = sym
+          } else {
+            throw new Exception(s"Name $v refers to a type")
+          }
+        case None => throw new Exception(s"Variable $v not found in scope")
+      }
+    }()
+
+  protected def visitVar(v: Var)(implicit scope: Scope): Unit =
+    trace(s"visitVar(name = \"$v\")") {
+      v.symbolOption match {
+        case N => resolveVar(v)
+        case S(symbol) => scope.get(v.name) match {
+          case S(other) if other === symbol => ()
+          case S(other) => throw new Exception(s"Variable $v refers to a different symbol")
+          case N => throw new Exception(s"Variable $v not found in scope. It is possibly a free variable.")
+        }
+      }
+    }()
+
+  protected def visitTerm(term: Term)(implicit scope: Scope): Unit =
+    trace(s"visitTerm <== ${shortName(term)}") {
+      term match {
+        case Assign(lhs, rhs) => visitTerm(lhs); visitTerm(rhs)
+        case Bra(_, trm) => visitTerm(trm)
+        case Lam(lhs, rhs) =>
+          visitTerm(rhs)(scope ++ extractParameters(lhs))
+        case Sel(receiver, fieldName) => visitTerm(receiver)
+        case Let(isRec, nme, rhs, body) =>
+          visitTerm(rhs)
+          visitTerm(body)(scope + new ValueSymbol(nme, false))
+        case New(head, body) =>
+        case Tup(fields) => fields.foreach { case (_, Fld(_, t)) => visitTerm(t) }
+        case Asc(trm, ty) => visitTerm(trm)
+        case ef @ If(_, _) => visitIf(ef)(scope)
+        case TyApp(lhs, targs) => // TODO: When?
+        case Eqn(lhs, rhs) => ??? // TODO: How?
+        case Blk(stmts) => stmts.foreach {
+          case t: Term => visitTerm(t)
+          case _ => ??? // TODO: When?
+        }
+        case Subs(arr, idx) => visitTerm(arr); visitTerm(idx)
+        case Bind(lhs, rhs) => visitTerm(lhs); visitTerm(rhs)
+        case Splc(fields) => fields.foreach {
+          case L(t) => visitTerm(t)
+          case R(Fld(_, t)) => visitTerm(t)
+        }
+        case Forall(params, body) => ??? // TODO: When?
+        case Rcd(fields) => fields.foreach { case (_, Fld(_, t)) => visitTerm(t) }
+        case CaseOf(trm, cases) => 
+        case With(trm, fields) => visitTerm(trm); visitTerm(fields)
+        case Where(body, where) => ??? // TODO: When?
+        case App(lhs, rhs) => visitTerm(lhs); visitTerm(rhs)
+        case Test(trm, ty) => visitTerm(trm)
+        case _: Lit | _: Super => ()
+        case v: Var => visitVar(v)
+        case AdtMatchWith(cond, arms) => ??? // TODO: How?
+        case Inst(body) => visitTerm(body)
+      }
+    }(_ => s"visitTerm ==> ${shortName(term)}")
+
+  private def visitNuTypeDef(symbol: TypeSymbol, defn: NuTypeDef)(implicit scope: Scope): Unit =
+    trace(s"visitNuTypeDef <== ${defn.kind} ${defn.nme.name}") {
+      visitTypingUnit(defn.body, defn.nme.name, scope)
+      ()
+    }(_ => s"visitNuTypeDef <== ${defn.kind} ${defn.nme.name}")
+
+  private def visitFunction(symbol: FunctionSymbol, defn: NuFunDef)(implicit scope: Scope): Unit =
+    trace(s"visitFunction <== ${defn.nme.name}") {
+      defn.rhs match {
+        case Left(term) => 
+          val subScope = if (defn.isLetRec == S(false)) scope else scope + symbol
+          visitTerm(term)(subScope)
+        case Right(value) => ()
+      }
+    }(_ => s"visitFunction ==> ${defn.nme.name}")
+
+  private def visitLetBinding(symbol: ValueSymbol, rec: Bool, rhs: Term)(implicit scope: Scope): Unit =
+    trace(s"visitLetBinding(rec = $rec, ${symbol.name})") {
+
+    }()
+
+  private def visitTypingUnit(typingUnit: TypingUnit, name: Str, parentScope: Scope): (Scope, TypeContents) =
+    trace(s"visitTypingUnit <== $name: ${typingUnit.describe}") {
+      import mlscript.{Cls, Trt, Mxn, Als, Mod}
+      // Pass 1: Build a scope with hoisted symbols.
+      val hoistedScope = typingUnit.entities.foldLeft(parentScope.derive) {
+        case (acc, _: Term) => acc // Skip
+        case (acc, defn: NuTypeDef) =>
+          val `var` = Var(defn.nme.name).withLoc(defn.nme.toLoc)
+          // Create a type symbol but do not visit its inner members
+          acc ++ (new TypeSymbol(defn.nme, defn) ::
+            (defn.kind match {
+              case Mod => new ValueSymbol(`var`, true) :: Nil
+              case Als | Cls | Mxn | Trt => Nil
+            }))
+        case (acc, defn: NuFunDef) if defn.isLetRec.isEmpty =>
+          acc + new FunctionSymbol(defn.nme, defn)
+        case (acc, _: NuFunDef) => acc
+        case (acc, _: Constructor | _: DataDefn | _: DatatypeDefn | _: Def | _: LetS | _: TypeDef) => ??? // TODO: When?
+      }
+      println(hoistedScope.symbols.map(_.name).mkString("1. scope = {", ", ", "}"))
+      // Pass 2: Visit non-hoisted and build a complete scope.
+      val completeScope = typingUnit.entities.foldLeft[Scope](hoistedScope) {
+        case (acc, term: Term) => visitTerm(term)(acc); acc
+        case (acc, defn: NuTypeDef) => acc
+        case (acc, defn @ NuFunDef(Some(rec), nme, _, _, L(rhs))) =>
+          val symbol = new ValueSymbol(defn.nme, true)
+          val scopeWithVar = acc + symbol
+          visitLetBinding(symbol, rec, rhs)(if (rec) { scopeWithVar } else { acc })
+          scopeWithVar
+        case (acc, _: NuFunDef) => acc
+        case (acc, _: Constructor | _: DataDefn | _: DatatypeDefn | _: Def | _: LetS | _: TypeDef) => ??? // TODO: When?
+      }
+      println(hoistedScope.symbols.map(_.name).mkString("2. scope = {", ", ", "}"))
+      import pretyper.TypeSymbol
+      // Pass 3: Visit hoisted symbols.
+      completeScope.symbols.foreach {
+        case symbol: TypeSymbol =>
+          val innerScope = symbol.defn.kind match {
+            case Cls =>
+              completeScope.derive ++ (symbol.defn.params match {
+                case N => Nil
+                case S(fields) => extractParameters(fields)
+              })
+            case Als | Mod | Mxn | Trt => completeScope
+          }
+          visitNuTypeDef(symbol, symbol.defn)(innerScope)
+        case symbol: FunctionSymbol => visitFunction(symbol, symbol.defn)(completeScope)
+        case _: ValueSymbol => ()
+        case _: SubValueSymbol => ()
+      }
+      (completeScope, new TypeContents)
+    }({ case (scope, contents) => s"visitTypingUnit ==> ${scope.showLocalSymbols}" })
+
+  def process(typingUnit: TypingUnit, scope: Scope, name: Str): (Scope, TypeContents) =
+    trace(s"process <== $name: ${typingUnit.describe}") {
+      visitTypingUnit(typingUnit, name, scope)
+    }({ case (scope, contents) => s"process ==> ${scope.showLocalSymbols}" })
+}
diff --git a/shared/src/main/scala/mlscript/pretyper/Scope.scala b/shared/src/main/scala/mlscript/pretyper/Scope.scala
new file mode 100644
index 0000000000..e47690a9ff
--- /dev/null
+++ b/shared/src/main/scala/mlscript/pretyper/Scope.scala
@@ -0,0 +1,47 @@
+package mlscript.pretyper
+
+import collection.immutable.Map
+import mlscript.utils._, shorthands._
+import mlscript.Var
+
+class Scope(val enclosing: Opt[Scope], val entries: Map[String, Symbol]) {
+  @inline
+  def get(name: String): Opt[Symbol] = entries.get(name) match {
+    case Some(sym) => S(sym)
+    case None => enclosing.fold(N: Opt[Symbol])(_.get(name))
+  }
+
+  @inline
+  def +(sym: Symbol): Scope = new Scope(S(this), entries + (sym.name -> sym))
+
+  @inline
+  def ++(syms: IterableOnce[Symbol]): Scope =
+    new Scope(S(this), entries ++ syms.iterator.map(sym => sym.name -> sym))
+
+  def withEntries(syms: IterableOnce[Var -> Symbol]): Scope =
+    new Scope(S(this), entries ++ syms.iterator.map {
+      case (nme, sym) => nme.name -> sym
+    })
+
+  @inline
+  def symbols: Iterable[Symbol] = entries.values
+
+  def derive: Scope = new Scope(S(this), Map.empty)
+
+  def showLocalSymbols: Str = entries.iterator.map(_._1).mkString(", ")
+}
+
+object Scope {
+  def from(symbols: IterableOnce[Symbol]): Scope =
+    new Scope(N, Map.from(symbols.iterator.map(sym => sym.name -> sym)))
+
+  val global: Scope = Scope.from(
+    """true,false,document,window,typeof,toString,not,succ,log,discard,negate,
+      |round,add,sub,mul,div,sqrt,lt,le,gt,ge,slt,sle,sgt,sge,length,concat,eq,
+      |ne,error,id,if,emptyArray,+,-,*,%,/,<,>,<=,>=,==,===,<>,&&,||"""
+      .stripMargin
+      .split(",")
+      .iterator
+      .map(name => new ValueSymbol(Var(name), false))
+  )
+}
diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
new file mode 100644
index 0000000000..7cd3d3357f
--- /dev/null
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -0,0 +1,77 @@
+package mlscript.pretyper
+
+import collection.mutable.{Buffer, Map => MutMap}
+import mlscript.{NuFunDef, NuTypeDef, TypeName, Var}
+import mlscript.utils._, shorthands._
+
+sealed abstract class Symbol(val name: String)
+
+final class TypeSymbol(val nme: TypeName, val defn: NuTypeDef) extends Symbol(nme.name) {
+  var containedScope: Opt[Scope] = N
+  var containedContents: Opt[TypeContents] = N
+
+  def scope: Scope = containedScope.getOrElse(throw new Exception("Scope not set"))
+  def contents: TypeContents = containedContents.getOrElse(throw new Exception("TypeContents not set")) 
+
+  def scope_=(s: Scope): Unit = containedScope = S(s)
+  def contents_=(c: TypeContents): Unit = containedContents = S(c)
+}
+
+sealed abstract class TermSymbol(name: String) extends Symbol(name)
+
+final class FunctionSymbol(val nme: Var, val defn: NuFunDef) extends TermSymbol(nme.name) {
+  var containedScope: Opt[Scope] = N
+
+  def scope: Scope = containedScope.getOrElse(throw new Exception("Scope not set"))
+
+  def scope_=(s: Scope): Unit = containedScope = S(s)
+}
+
+sealed abstract class ScrutineeSymbol(name: Str) extends TermSymbol(name) {
+  /**
+    * This map contains the sub-scrutinee symbols when this scrutinee is matched
+    * against class patterns.
+    */
+  val classParameterScrutineeMap: MutMap[Var -> Int, SubValueSymbol] = MutMap.empty
+  val tupleElementScrutineeMap: MutMap[Int, SubValueSymbol] = MutMap.empty
+  val recordValueScrutineeMap: MutMap[Var, SubValueSymbol] = MutMap.empty
+
+  def addSubScrutinee(className: Var, index: Int, parameter: Var): SubValueSymbol =
+    classParameterScrutineeMap.getOrElseUpdate(className -> index, {
+      new SubValueSymbol(this, S(className) -> S(index), parameter.name)
+    })
+
+  def addSubScrutinee(fieldName: Var): SubValueSymbol =
+    recordValueScrutineeMap.getOrElseUpdate(fieldName, {
+      val synthesizedName = s"${name}$$record${fieldName}"
+      new SubValueSymbol(this, S(fieldName) -> N, synthesizedName)
+    })
+  
+  def addSubScrutinee(index: Int): SubValueSymbol =
+    tupleElementScrutineeMap.getOrElseUpdate(index, {
+      val synthesizedName = s"${name}$$tuple${index.toString}"
+      new SubValueSymbol(this, N -> S(index), synthesizedName)
+    })
+
+  /**
+    * This buffer contains alias variables which created by "let" bindings or
+    * alias patterns.
+    */
+  val aliases: Buffer[Var] = Buffer.empty
+}
+
+final class ValueSymbol(val nme: Var, val hoisted: Bool) extends ScrutineeSymbol(nme.name)
+
+final class SubValueSymbol(
+  val parentSymbol: ScrutineeSymbol,
+  /**
+    * TODO: This becomes useless now.
+    * Class patterns: (S(className), S(index))
+    * Record patterns: (S(fieldName), N)
+    * Tuple patterns: (N, S(index))
+    */
+  val accessor: (Opt[Var], Opt[Int]),
+  override val name: Str
+) extends ScrutineeSymbol(name) {
+  lazy val toVar: Var = Var(name)
+}
diff --git a/shared/src/main/scala/mlscript/pretyper/Traceable.scala b/shared/src/main/scala/mlscript/pretyper/Traceable.scala
new file mode 100644
index 0000000000..f707416c98
--- /dev/null
+++ b/shared/src/main/scala/mlscript/pretyper/Traceable.scala
@@ -0,0 +1,39 @@
+package mlscript.pretyper
+
+import mlscript.utils._, shorthands._
+
+trait Traceable {
+  // Override this to change the base indentation level.
+  def baseIndent: Int = 0
+
+  protected val debugLevel: Opt[Int] = N // The number of verbose.
+  protected var indent = baseIndent
+
+  def trace[T](pre: => String)(thunk: => T)(post: T => String = Traceable.noPostTrace): T = {
+    println(pre)
+    indent += 1
+    val res = try thunk finally indent -= 1
+    if (post isnt Traceable.noPostTrace) println(post(res))
+    res
+  }
+
+  @inline def traceNot[T](pre: => String)(thunk: => T)(post: T => String = Traceable.noPostTrace): T =
+    thunk
+  
+  def emitDbg(str: String): Unit = scala.Predef.println(str)
+  
+  @inline
+  protected def println(msg: => Any): Unit = println(msg, 0)
+  
+  @inline 
+  protected def println(msg: => Any, level: Int): Unit =
+    if (debugLevel exists (_ >= level)) printLineByLine(msg)
+
+  @inline
+  private def printLineByLine(msg: => Any): Unit =
+    msg.toString.linesIterator.foreach { line => emitDbg("| " * indent + line) }
+}
+
+object Traceable {
+  val noPostTrace: Any => String = _ => ""
+}
diff --git a/shared/src/main/scala/mlscript/pretyper/TypeContents.scala b/shared/src/main/scala/mlscript/pretyper/TypeContents.scala
new file mode 100644
index 0000000000..fc9e0a9c8a
--- /dev/null
+++ b/shared/src/main/scala/mlscript/pretyper/TypeContents.scala
@@ -0,0 +1,5 @@
+package mlscript.pretyper
+
+class TypeContents {
+  // Stub
+}
diff --git a/shared/src/main/scala/mlscript/pretyper/package.scala b/shared/src/main/scala/mlscript/pretyper/package.scala
new file mode 100644
index 0000000000..06d8773c17
--- /dev/null
+++ b/shared/src/main/scala/mlscript/pretyper/package.scala
@@ -0,0 +1,14 @@
+package mlscript
+
+import mlscript.utils._, shorthands._
+
+package object pretyper {
+  def shortName(term: Term): Str = term match {
+    case Var(name) => s"Var(\"$name\")"
+    case literal: Lit => literal.toString
+    case _ =>
+      val name = term.getClass.getSimpleName
+      val arity = term.children.length // Imprecise
+      if (arity === 0) { name } else s"${name}(${(", _" * arity).drop(2)})"
+  }
+}
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
new file mode 100644
index 0000000000..685d236566
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -0,0 +1,97 @@
+package mlscript.ucs
+
+import collection.mutable.{Map => MutMap}
+import mlscript.ucs.stages._
+import mlscript.pretyper.{PreTyper, Scope, ScrutineeSymbol, Symbol, ValueSymbol}
+import mlscript._, utils._, shorthands._
+import mlscript.codegen.Helpers.inspect
+import mlscript.Message, Message.MessageContext
+
+import mlscript.ucs.core.Pattern.Name
+
+// TODO: Rename to `Desugarer` once the old desugarer is removed.
+trait DesugarUCS extends Transformation with Desugaring with Normalization with PostProcessing { self: PreTyper =>
+  protected def visitIf(`if`: If)(implicit scope: Scope): Unit =
+    trace("visitIf") {
+      // Stage 0: Transformation
+      val transformed = transform(`if`, true)
+      println("Transformed UCS term:")
+      println(transformed.toString, 2)
+      println(ucs.syntax.printTermSplit(transformed))
+      // Stage 1: Desugaring
+      // This stage will generate new names based on the position of the scrutinee.
+      // Therefore, we need to call `visitSplit` to associate these newly generated
+      // names with symbols.
+      val desugared = desugar(transformed)
+      println(desugared.toString, 2)
+      println("Desugared UCS term:")
+      println(ucs.core.printSplit(desugared))
+      visitSplit(desugared)
+      // Stage 2: Normalization
+      val normalized = normalize(desugared)
+      println(normalized.toString, 2)
+      println("Normalized UCS term:")
+      printNormalizedTerm(normalized)
+      // Stage 3: Post-processing
+      val postProcessed = postProcess(normalized)
+      println("Post-processed UCS term:")
+      printNormalizedTerm(postProcessed)
+      // Epilogue
+      `if`.desugaredTerm = S(normalized)
+    }(_ => "visitIf ==> ()")
+  
+  private def visitSplit(split: core.Split)(implicit scope: Scope): Unit =
+    trace(s"visitSplit <== [${scope.showLocalSymbols}]") {
+      import core._
+      split match {
+        case Split.Cons(Branch(scrutinee, pattern, continuation), tail) => 
+          println(s"found branch: $scrutinee is $pattern")
+          visitTerm(scrutinee)
+          val patternSymbols = visitPattern(scrutinee, pattern)
+          visitSplit(continuation)(scope.withEntries(patternSymbols))
+          visitSplit(tail)
+        case Split.Let(_, name, _, tail) =>
+          println(s"found let binding: \"$name\"")
+          visitSplit(tail)(scope + new ValueSymbol(name, false))
+        case Split.Else(default) => visitTerm(default)
+        case Split.Nil => println("the end")
+      }
+    }()
+
+  private def visitPattern(scrutinee: Var, pattern: core.Pattern): List[Var -> Symbol] =
+    trace(s"visitPattern <== $pattern") {
+      lazy val scrutineeSymbol = scrutinee.symbol match {
+        case symbol: ScrutineeSymbol => symbol
+        case other: Symbol =>
+          throw new DesugaringException(msg"Scrutinee is not a scrutinee symbol" -> scrutinee.toLoc :: Nil)
+      }
+      pattern match {
+        case core.Pattern.Literal(literal) => Nil
+        case core.Pattern.Name(nme) =>
+          nme.symbol = scrutineeSymbol
+          nme -> scrutineeSymbol :: Nil
+        case core.Pattern.Class(_, N) => Nil
+        case core.Pattern.Class(nme, S(parameters)) =>
+          parameters.iterator.zipWithIndex.flatMap { 
+            case (N, _) => N
+            case (S(parameter), index) =>
+              val symbol = scrutineeSymbol.addSubScrutinee(nme, index, parameter)
+              parameter.symbol = symbol; S(parameter -> symbol)
+          }.toList
+        case core.Pattern.Tuple(elements) => elements.flatMap {
+          case N => Nil
+          case S(pattern) => elements.iterator.zipWithIndex.flatMap {
+            case (N, _) => N
+            case (S(element), index) =>
+              val symbol = scrutineeSymbol.addSubScrutinee(index)
+              element.symbol = symbol; S(element -> symbol)
+          }.toList
+        }
+        case core.Pattern.Record(entries) =>
+          entries.iterator.zipWithIndex.map { case ((fieldName, bindingName), _) =>
+            val symbol = scrutineeSymbol.addSubScrutinee(fieldName)
+            bindingName.symbol = symbol; bindingName -> symbol
+          }.toList
+      }
+    }(_.iterator.map(_._1.name).mkString("visitPattern ==> [", ", ", "]"))
+}
diff --git a/shared/src/main/scala/mlscript/ucs/Desugarer.scala b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
index 6358f18928..34075afe78 100644
--- a/shared/src/main/scala/mlscript/ucs/Desugarer.scala
+++ b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
@@ -808,7 +808,8 @@ class Desugarer extends TypeDefs { self: Typer =>
                 }
               }
 
-              App(Lam(Tup(
+              // Well, reading the following piece of code is somewhat overwhelming for me.
+              App(Lam(Tup( /* begin params */
                 N -> Fld(FldFlags.empty, Tup(
                   fields.distinctBy(_._1).map {
                     case (_ -> Var(alias)) =>
@@ -816,9 +817,9 @@ class Desugarer extends TypeDefs { self: Typer =>
                       else N -> Fld(FldFlags.empty, Var(alias))
                   }.toList
                 )) :: Nil
-              ), extraAlias.toList.foldRight(consequent)((lt, rs) => Let(false, Var(lt._2), Var(lt._1), rs))),
-                Tup(N -> Fld(FldFlags.empty, App(Sel(className, Var(unapplyMtd.name)),
-                  Tup(N -> Fld(FldFlags.empty, scrutinee.reference) :: Nil))
+              ) /* end params */, extraAlias.toList.foldRight(consequent)((lt, rs) => Let(false, Var(lt._2), Var(lt._1), rs))),
+                Tup(N -> Fld(FldFlags.empty, App(Sel(className, Var(unapplyMtd.name) /* ClassName.unapply */),
+                  Tup(N -> Fld(FldFlags.empty, scrutinee.reference) :: Nil)) /* ClassName.unapply(scrutinee) */
                   ) :: Nil)
               )
             case _ => mkLetFromFields(scrutinee, fields.filter(_._2.name =/= "_").toList, consequent)
diff --git a/shared/src/main/scala/mlscript/ucs/PartialTerm.scala b/shared/src/main/scala/mlscript/ucs/PartialTerm.scala
index 7ce2d6a001..a150714f4e 100644
--- a/shared/src/main/scala/mlscript/ucs/PartialTerm.scala
+++ b/shared/src/main/scala/mlscript/ucs/PartialTerm.scala
@@ -4,6 +4,9 @@ import mlscript._
 import mlscript.utils.shorthands._
 
 import helpers._
+import mlscript.ucs.PartialTerm.Empty
+import mlscript.ucs.PartialTerm.Total
+import mlscript.ucs.PartialTerm.Half
 
 class PartialTermError(term: PartialTerm, message: Str) extends Error(message)
 
@@ -19,6 +22,13 @@ sealed abstract class PartialTerm {
   def addOp(op: Var): PartialTerm.Half
   def addTermOp(term: Term, op: Var, newDefs: Bool): PartialTerm.Half =
     this.addTerm(term, newDefs).addOp(op)
+  def addOpTerm(op: Var, term: Term, newDefs: Bool): PartialTerm.Total =
+    this.addOp(op).addTerm(term, newDefs)
+  def get: Term = this match {
+    case Empty => throw new PartialTermError(this, "expect a term but nothing was given")
+    case Total(term, fragments) => term
+    case Half(lhs, op, fragments) => throw new PartialTermError(this, "expect an operator but nothing was given")
+  }
 }
 
 object PartialTerm {
diff --git a/shared/src/main/scala/mlscript/ucs/core.scala b/shared/src/main/scala/mlscript/ucs/core.scala
new file mode 100644
index 0000000000..5b0dc64009
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/core.scala
@@ -0,0 +1,80 @@
+package mlscript.ucs
+
+import mlscript.{Lit, Located, Term, Var}
+import mlscript.utils._, shorthands._
+
+package object core {
+  sealed abstract class Pattern extends Located {
+    override def toString(): String = this match {
+      case Pattern.Literal(literal) => literal.toString
+      case Pattern.Name(Var(name)) => name
+      case Pattern.Class(Var(name), N) => name
+      case Pattern.Class(Var(name), S(parameters)) =>
+        parameters.iterator.map(_.fold("_")(_.name)).mkString(s"$name(", ", ", ")")
+      case Pattern.Tuple(fields) => fields.iterator.map(_.fold("_")(_.name)).mkString("(", ", ", ")")
+      case Pattern.Record(Nil) => "{}"
+      case Pattern.Record(entries) => entries.iterator.map { case (nme, als) => s"$nme: $als" }.mkString("{ ", ", ", " }")
+    }
+  }
+  object Pattern {
+    final case class Literal(literal: Lit) extends Pattern {
+      override def children: Ls[Located] = literal :: Nil
+    }
+    final case class Name(nme: Var) extends Pattern {
+      override def children: Ls[Located] = nme :: Nil
+    }
+    final case class Class(nme: Var, parameters: Opt[List[Opt[Var]]]) extends Pattern {
+      override def children: Ls[Located] = nme :: parameters.fold(Ls.empty[Located])(_.flatten)
+    }
+    final case class Tuple(elements: List[Opt[Var]]) extends Pattern {
+      override def children: Ls[Located] = elements.flatten
+    }
+    final case class Record(entries: List[(Var -> Var)]) extends Pattern {
+      override def children: Ls[Located] = entries.iterator.flatMap { case (nme, als) => nme :: als :: Nil }.toList
+    }
+  }
+
+  final case class Branch(scrutinee: Var, pattern: Pattern, continuation: Split)
+
+  sealed abstract class Split {
+    def ::(head: Branch): Split = Split.Cons(head, this)
+
+    def ++(that: Split): Split = this match {
+      case me: Split.Cons => me.copy(tail = me.tail ++ that)
+      case me: Split.Let => me.copy(tail = me.tail ++ that)
+      case _: Split.Else => this
+      case Split.Nil => that
+    }
+  }
+
+  object Split {
+    final case class Cons(head: Branch, tail: Split) extends Split
+    final case class Let(rec: Bool, name: Var, term: Term, tail: Split) extends Split
+    final case class Else(default: Term) extends Split
+    final case object Nil extends Split
+
+    def just(term: Term): Split = Else(term)
+  }
+
+  @inline def printSplit(s: Split): Str = showSplit("if", s)
+
+  def showSplit(prefix: Str, s: Split): Str = {
+    // TODO: tailrec
+    def split(s: Split, isFirst: Bool, isTopLevel: Bool): Lines = s match {
+      case Split.Cons(head, tail) => (branch(head) match {
+        case (n, line) :: tail => (n, (if (isTopLevel) "" else "") + s"$line") :: tail
+        case Nil => Nil
+      }) ::: split(tail, false, isTopLevel)
+      case Split.Let(_, nme, rhs, tail) => (0, s"let $nme = $rhs") :: split(tail, false, isTopLevel)
+      case Split.Else(term) => (if (isFirst) (0, s"then $term") else (0, s"else $term")) :: Nil
+      case Split.Nil => Nil
+    }
+    def branch(b: Branch): Lines = {
+      val Branch(scrutinee, pattern, continuation) = b
+      s"$scrutinee is $pattern" #: split(continuation, true, false)
+    }
+    val lines = split(s, true, true)
+    (if (prefix.isEmpty) lines else prefix #: lines)
+      .iterator.map { case (n, line) => "  " * n + line }.mkString("\n")
+  }
+}
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/ucs/package.scala b/shared/src/main/scala/mlscript/ucs/package.scala
new file mode 100644
index 0000000000..21516814d9
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/package.scala
@@ -0,0 +1,31 @@
+package mlscript
+
+import scala.annotation.tailrec
+
+package object ucs {
+  type Lines = List[(Int, String)]
+
+  implicit class LinesOps(private val lines: Lines) extends AnyVal {
+    def indent: Lines = {
+      @tailrec
+      def rec(acc: Lines, lines: Lines): Lines = lines match {
+        case (n, line) :: tail => rec((n + 1, line) :: acc, tail)
+        case Nil => acc.reverse
+      }
+      rec(Nil, lines)
+    }
+    def ##:(prefix: String): Lines = (0, prefix) :: lines.indent
+    def #:(prefix: String): Lines = {
+      lines match {
+        case (0, line) :: lines if lines.forall(_._1 > 0) => (0, s"$prefix $line") :: lines
+        case lines => (0, prefix) :: lines.indent
+      }
+    }
+    def @:(prefix: String): Lines = {
+      lines match {
+        case (_, line) :: Nil => (0, prefix + " " + line) :: Nil
+        case lines => (0, prefix) :: lines.indent
+      }
+    }
+  }
+}
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
new file mode 100644
index 0000000000..dffa403c81
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -0,0 +1,126 @@
+package mlscript.ucs.stages
+
+import mlscript.{Term, Var}
+import mlscript.ucs.{syntax => s, core => c, PartialTerm}
+import mlscript.utils._, shorthands._
+import mlscript.pretyper.{ScrutineeSymbol, SubValueSymbol, ValueSymbol}
+import mlscript.ucs.DesugaringException
+import mlscript.Message, Message.MessageContext
+
+trait Desugaring { self: mlscript.pretyper.Traceable =>
+  @inline def desugar(term: s.TermSplit): c.Split = desugarTermSplit(term)(PartialTerm.Empty)
+
+  private var nextScrutineeIndex: Int = 0
+
+  private def freshName(): Str = {
+    val thisIndex = nextScrutineeIndex
+    nextScrutineeIndex += 1
+    s"scrut$thisIndex" // FIXME: use `freeVars` to avoid name collision.
+  }
+
+  private def freshScrutinee(): Var = Var(freshName())
+
+  private def freshScrutinee(parentScrutinee: Var, parentClassName: Var, index: Int): Var =
+    Var(s"${parentScrutinee}$$${parentClassName}_${index.toString}")
+
+  private val truePattern = c.Pattern.Class(Var("true"), N)
+
+  private def flattenClassParameters(parentScrutinee: Var, parentClassName: Var, parameters: Opt[Ls[Opt[s.Pattern]]]): Opt[Ls[Opt[Var]]] -> Ls[Opt[Var -> s.ClassPattern]] =
+    parameters match {
+      case S(parameters) =>
+        val (a, b) = parameters.zipWithIndex.unzip {
+          case (N, index) => N -> N
+          case (S(s.NamePattern(name)), index) => (S(name), N)
+          case (S(parameterPattern: s.ClassPattern), index) =>
+            val scrutinee = freshScrutinee(parentScrutinee, parentClassName, index)
+            (S(scrutinee), Some((scrutinee, parameterPattern)))
+          case _ => ??? // Other patterns are not implemented yet.
+        }
+        (S(a), b)
+      case N => (N, Nil)
+    }
+
+  private def flattenNestedSplitLet(pattern: s.ClassPattern, term: Var, tail: c.Split): c.Split = {
+    val (parameterBindings, childrenBindings) = flattenClassParameters(term, pattern.nme, pattern.parameters)
+    c.Branch(term, c.Pattern.Class(pattern.nme, parameterBindings), childrenBindings.foldRight(tail){ 
+      case (N, tail) => tail
+      case (S((nme, parameterPattern)), tail) =>
+        flattenNestedSplitLet(parameterPattern, nme, tail)
+    }) :: c.Split.Nil
+  }
+
+  private def desugarTermSplit(split: s.TermSplit)(implicit termPart: PartialTerm): c.Split =
+    split match {
+      case s.Split.Cons(head, tail) => desugarTermBranch(head) ++ desugarTermSplit(tail)
+      case s.Split.Let(rec, nme, rhs, tail) => c.Split.Let(rec, nme, rhs, desugarTermSplit(tail))
+      case s.Split.Else(default) => c.Split.Else(default); 
+      case s.Split.Nil => c.Split.Nil
+    }
+
+  private def desugarTermBranch(branch: s.TermBranch)(implicit termPart: PartialTerm): c.Split =
+    // Note: `Branch` is `(Term, Pattern, Either[Split, Term])`.
+    branch match {
+      case s.TermBranch.Boolean(condition, continuation) =>
+        val `var` = freshScrutinee()
+        c.Split.Let(
+          rec = false,
+          name = `var`,
+          term = condition,
+          tail = c.Branch(`var`, truePattern, desugarTermSplit(continuation)) :: c.Split.Nil
+        )
+      case s.TermBranch.Match(scrutinee, split) =>
+        desugarPatternSplit(split)(termPart.addTerm(scrutinee, true).get)
+      case s.TermBranch.Left(left, continuation) =>
+        desugarOperatorSplit(continuation)(termPart.addTerm(left, true))
+    }
+
+  private def desugarOperatorSplit(split: s.OperatorSplit)(implicit termPart: PartialTerm): c.Split =
+    split match {
+      case s.Split.Cons(head, tail) => desugarOperatorBranch(head) ++ desugarOperatorSplit(tail)
+      case s.Split.Let(rec, nme, rhs, tail) => c.Split.Let(rec, nme, rhs, desugarOperatorSplit(tail))
+      case s.Split.Else(default) => c.Split.Else(default)
+      case s.Split.Nil => c.Split.Nil
+    }
+
+  private def desugarOperatorBranch(branch: s.OperatorBranch)(implicit termPart: PartialTerm): c.Split =
+    branch match {
+      case s.OperatorBranch.Binary(op, split) => desugarTermSplit(split)(termPart.addOp(op))
+      case s.OperatorBranch.Match(_, split) => desugarPatternSplit(split)(termPart.get)
+    }
+
+  private def flattenNestedPattern(pattern: s.ClassPattern, scrutinee: Var, next: c.Split): c.Branch = {
+    val (parameterBindings, subPatterns) = flattenClassParameters(scrutinee, pattern.nme, pattern.parameters)
+    c.Branch(scrutinee, c.Pattern.Class(pattern.nme, parameterBindings), subPatterns.foldRight(next) {
+      case (None, next) => next
+      case (Some((nme, pattern)), next) =>
+        flattenNestedPattern(pattern, nme, next) :: c.Split.Nil
+    })
+  }
+
+  private def desugarPatternBranch(scrutinee: Var, branch: s.PatternBranch): c.Branch = {
+    lazy val continuation = desugarTermSplit(branch.continuation)(PartialTerm.Empty)
+    branch.pattern match {
+      case s.AliasPattern(nme, pattern) => ???
+      case s.LiteralPattern(literal) => ???
+      case s.NamePattern(nme) => c.Branch(scrutinee, c.Pattern.Name(nme), continuation)
+      case pattern @ s.ClassPattern(nme, fields) => flattenNestedPattern(pattern, scrutinee, continuation)
+      case s.TuplePattern(fields) => ???
+      case s.RecordPattern(entries) => ???
+    }
+  }
+
+  private def desugarPatternSplit(split: s.PatternSplit)(implicit scrutinee: Term): c.Split = {
+    def rec(scrutinee: Var, split: s.PatternSplit): c.Split = split match {
+      case s.Split.Cons(head, tail) => desugarPatternBranch(scrutinee, head) :: rec(scrutinee, tail)
+      case s.Split.Let(isRec, nme, rhs, tail) => c.Split.Let(isRec, nme, rhs, rec(scrutinee, tail))
+      case s.Split.Else(default) => c.Split.Else(default)
+      case s.Split.Nil => c.Split.Nil
+    }
+    scrutinee match {
+      case nme: Var => rec(nme, split)
+      case other =>
+        val alias = freshScrutinee()
+        c.Split.Let(false, alias, scrutinee, rec(alias, split))
+    }
+  }
+}
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
new file mode 100644
index 0000000000..9366223680
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -0,0 +1,205 @@
+
+package mlscript.ucs.stages
+
+import mlscript.ucs.{Lines, LinesOps}
+import mlscript.ucs.core._
+import mlscript.ucs.helpers._
+import mlscript.pretyper.Symbol
+import mlscript.{App, CaseOf, Fld, FldFlags, Let, Loc, Sel, Term, Tup, Var, StrLit}
+import mlscript.{CaseBranches, Case, Wildcard, NoCases}
+import mlscript.Message, Message.MessageContext
+import mlscript.utils._, shorthands._
+
+trait Normalization { self: mlscript.pretyper.Traceable =>
+  import Normalization._
+
+  /**
+    * Normalize core abstract syntax to MLscript syntax.
+    *
+    * @param split the split to normalize
+    * @return the normalized term
+    */ 
+  @inline def normalize(split: Split): Term = normalizeToTerm(split)
+
+  private def normalizeToTerm(split: Split): Term = trace("normalizeToTerm") {
+    split match {
+      case Split.Cons(Branch(scrutinee, Pattern.Name(nme), continuation), tail) =>
+        println(s"alias $scrutinee => $nme")
+        Let(false, nme, scrutinee, normalizeToTerm(continuation ++ tail))
+      case Split.Cons(Branch(scrutinee, pattern @ Pattern.Literal(literal), continuation), tail) =>
+        val trueBranch = normalizeToTerm(specialize(continuation ++ tail, Yes)(scrutinee.symbol, pattern))
+        val falseBranch = normalizeToCaseBranches(specialize(tail, No)(scrutinee.symbol, pattern))
+        CaseOf(scrutinee, Case(literal, trueBranch, falseBranch))
+      // No class parameters. Easy
+      case Split.Cons(Branch(scrutinee, pattern @ Pattern.Class(nme, N), continuation), tail) =>
+        println(s"match $scrutinee with $nme")
+        val trueBranch = normalizeToTerm(specialize(continuation ++ tail, Yes)(scrutinee.symbol, pattern))
+        val falseBranch = normalizeToCaseBranches(specialize(tail, No)(scrutinee.symbol, pattern))
+        CaseOf(scrutinee, Case(nme, trueBranch, falseBranch))
+      case Split.Cons(Branch(scrutinee, pattern @ Pattern.Class(nme, S(parameters)), continuation), tail) =>
+        println(s"match $scrutinee with $pattern")
+        val trueBranch = trace("compute true branch"){
+          normalizeToTerm(specialize(continuation ++ tail, Yes)(scrutinee.symbol, pattern))
+        }()
+        val falseBranch = trace("compute false branch"){
+          normalizeToCaseBranches(specialize(tail, No)(scrutinee.symbol, pattern))
+        }()
+        val unappliedVar = Var(s"args_${scrutinee.name}$$${nme.name}")
+        val trueBranchWithBindings = Let(
+          isRec = false,
+          name = unappliedVar,
+          rhs = {
+            val arguments = N -> Fld(FldFlags.empty, scrutinee) :: Nil
+            App(Sel(nme, Var("unapply")), Tup(arguments))
+          }, 
+          body = parameters.zipWithIndex.foldRight(trueBranch) {
+            case ((N, i), next) => next
+            case ((S(parameter), i), next) => Let(false, parameter, Sel(unappliedVar, Var(i.toString)), next)
+          }
+        )
+        CaseOf(scrutinee, Case(nme, trueBranchWithBindings, falseBranch))
+      case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
+        throw new NormalizationException((msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc) :: Nil)
+      case Split.Let(rec, nme, rhs, tail) => Let(rec, nme, rhs, normalizeToTerm(tail))
+      case Split.Else(default) => default
+      case Split.Nil => StrLit("test") // FIXME
+    }
+  }()
+
+  private def normalizeToCaseBranches(split: Split): CaseBranches = trace("normalizeToCaseBranches") {
+    split match {
+      // case Split.Cons(head, Split.Nil) => Case(head.pattern, normalizeToTerm(head.continuation), NoCases)
+      case other @ (Split.Cons(_, _) | Split.Let(_, _, _, _)) => Wildcard(normalizeToTerm(other))
+      case Split.Else(default) => Wildcard(default)
+      case Split.Nil => NoCases
+    }
+  }()
+
+  // Specialize `split` with the assumption that `scrutinee` matches `pattern`.
+  private def specialize
+      (split: Split, matchOrNot: MatchOrNot)
+      (implicit scrutinee: Symbol, pattern: Pattern): Split =
+  trace(s"S${matchOrNot} <== ${scrutinee.name} is ${pattern}") {
+    (matchOrNot, split) match {
+      // Name patterns are translated to let bindings.
+      case (Yes | No, Split.Cons(Branch(otherScrutineeVar, Pattern.Name(alias), continuation), tail)) =>
+        Split.Let(false, alias, otherScrutineeVar, specialize(continuation, matchOrNot))
+      // Class pattern. Positive.
+      case (Yes, split @ Split.Cons(head @ Branch(otherScrutineeVar, Pattern.Class(otherClassName, otherParameters), continuation), tail)) =>
+        val otherScrutinee = otherScrutineeVar.symbol
+        lazy val specializedTail = {
+          println(s"specialized next")
+          specialize(tail, Yes)
+        }
+        if (scrutinee === otherScrutinee) {
+          println(s"scrutinee: ${scrutinee.name} === ${otherScrutinee.name}")
+          pattern match {
+            case Pattern.Class(className, parameters) =>
+              if (className === otherClassName) {
+                println(s"class name: $className === $otherClassName")
+                // TODO: Subsitute parameters to otherParameters
+                specialize(continuation ++ tail, Yes)
+              } else {
+                println(s"class name: $className =/= $otherClassName")
+                specializedTail
+              }
+            case _ => throw new NormalizationException((msg"Incompatible: ${pattern.toString}" -> pattern.toLoc) :: Nil)
+          }
+        } else {
+          println(s"scrutinee: ${scrutinee.name} =/= ${otherScrutinee.name}")
+          if (scrutinee.name === otherScrutinee.name) {
+            println(s"WRONG!!!")
+          }
+          split.copy(
+            head = head.copy(continuation = specialize(continuation, Yes)),
+            tail = specializedTail
+          )
+        }
+      // Class pattern. Negative
+      case (No, split @ Split.Cons(head @ Branch(otherScrutineeVar, Pattern.Class(otherClassName, otherParameters), continuation), tail)) =>
+        val otherScrutinee = otherScrutineeVar.symbol
+        if (scrutinee === otherScrutinee) {
+          println(s"scrutinee: ${scrutinee.name} === ${otherScrutinee.name}")
+          pattern match {
+            case Pattern.Class(className, parameters) =>
+              if (className === otherClassName) {
+                println(s"class name: $className === $otherClassName")
+                specialize(tail, No) // TODO: Subsitute parameters to otherParameters
+              } else {
+                println(s"class name: $className =/= $otherClassName")
+                split.copy(
+                  // head = head.copy(continuation = specialize(continuation, No)),
+                  tail = specialize(tail, No)
+                )
+              }
+            case _ => throw new NormalizationException((msg"Incompatible: ${pattern.toString}" -> pattern.toLoc) :: Nil)
+          }
+        } else {
+          println(s"scrutinee: ${scrutinee.name} =/= ${otherScrutinee.name}")
+          split.copy(
+            head = head.copy(continuation = specialize(continuation, matchOrNot)),
+            tail = specialize(tail, matchOrNot)
+          )
+        }
+      // Other patterns. Not implemented.
+      case (Yes | No, Split.Cons(Branch(otherScrutineeVar, pattern, continuation), tail)) =>
+        throw new NormalizationException((msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc) :: Nil)
+      case (Yes | No, let @ Split.Let(_, _, _, tail)) =>
+        println("let binding, go next")
+        let.copy(tail = specialize(tail, matchOrNot))
+      // Ending cases remain the same.
+      case (Yes | No, end @ (Split.Else(_) | Split.Nil)) => println("the end"); end
+    } // <-- end match
+  }(showSplit(s"S${matchOrNot} ==>", _))
+
+  /**
+    * Print a normalized term with indentation.
+    */
+  @inline protected def printNormalizedTerm(term: Term): Unit =
+    println(showNormalizedTerm(term))
+}
+
+object Normalization {
+  private sealed abstract class MatchOrNot {
+    override def toString(): String = this match {
+      case Yes => "+"
+      case No => "-"
+    }
+  }
+  private final case object Yes extends MatchOrNot
+  private final case object No extends MatchOrNot
+
+  class NormalizationException(val messages: Ls[Message -> Opt[Loc]]) extends Throwable {
+    def this(message: Message, location: Opt[Loc]) = this(message -> location :: Nil)
+  }
+
+  /**
+    * Convert a normalized term to a string with indentation.
+    */
+  def showNormalizedTerm(term: Term): String = {
+    def showTerm(term: Term): Lines = term match {
+      case let: Let => showLet(let)
+      case caseOf: CaseOf => showCaseOf(caseOf)
+      case other => (0, other.toString) :: Nil
+    }
+    def showCaseOf(caseOf: CaseOf): Lines = {
+      val CaseOf(trm, cases) = caseOf
+      s"$trm match" ##: showCaseBranches(cases)
+    }
+    def showCaseBranches(caseBranches: CaseBranches): Lines =
+      caseBranches match {
+        case Case(pat, rhs, tail) =>
+          (s"case $pat =>" @: showTerm(rhs)) ++ showCaseBranches(tail)
+        case Wildcard(term) => s"case _ =>" @: showTerm(term)
+        case NoCases => Nil
+      }
+    def showVar(`var`: Var): Str =
+      // If the variable is associated with a symbol, mark it with an asterisk.
+      `var`.name + (`var`.symbolOption.fold("")(_ => "*"))
+    def showLet(let: Let): Lines = {
+      val Let(rec, nme, rhs, body) = let
+      (0, s"let ${showVar(nme)} = $rhs") :: showTerm(body)
+    }
+    showTerm(term).map { case (n, line) => "  " * n + line }.mkString("\n")
+  }
+}
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
new file mode 100644
index 0000000000..ff8c08ccdb
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -0,0 +1,60 @@
+package mlscript.ucs.stages
+
+import mlscript.{Case, CaseOf, Let, NoCases, Term, Var, Wildcard}
+import mlscript.pretyper.{Symbol}
+import mlscript.utils._, shorthands._
+import mlscript.CaseBranches
+
+trait PostProcessing { self: mlscript.pretyper.Traceable =>
+  def postProcess(term: Term): Term = trace(s"postProcess <== ${term.describe}") {
+    // Normalized terms are constructed using `Let` and `CaseOf`.
+    term match {
+      case top @ CaseOf(scrutinee: Var, fst @ Case(pattern, body, NoCases)) =>
+        println(s"found a UNARY case: $scrutinee is $pattern")
+        top.copy(cases = fst.copy(body = postProcess(body)))
+      case top @ CaseOf(scrutinee: Var, fst @ Case(pattern, trueBranch, snd @ Wildcard(falseBranch))) =>
+        println(s"found a BINARY case: $scrutinee is $pattern")
+        println("post-processing the true branch")
+        val processedTrueBranch = postProcess(trueBranch)
+        println("post-processing the false branch")
+        val processedFalseBranch = postProcess(falseBranch)
+        // Check if the false branch is another `CaseOf` with the same scrutinee.
+        processedFalseBranch match {
+          case CaseOf(otherScrutinee: Var, actualFalseBranch) =>
+            if (scrutinee.symbol === otherScrutinee.symbol) {
+              println(s"identical: $scrutinee === $otherScrutinee")
+              if (scrutinee.name =/= otherScrutinee.name) {
+                // TODO: solve name collision by creating a lifted `Let`
+                ???
+              }
+              println(s"actual false branch: $actualFalseBranch")
+              top.copy(cases = fst.copy(body = processedTrueBranch, rest = actualFalseBranch))
+            } else {
+              println(s"different: $scrutinee =/= $otherScrutinee")
+              top.copy(cases = fst.copy(body = processedTrueBranch, rest = snd.copy(body = processedFalseBranch)))
+            }
+          case other => top
+        }
+      // We recursively process the body of `Let` bindings.
+      case let @ Let(_, _, _, body) => let.copy(body = postProcess(body))
+      // Otherwise, this is not a part of a normalized term.
+      case other => println(s"CANNOT post-process"); other
+    }
+  }()
+
+  private def hasScrutinee(term: Term, symbol: Symbol): Bool = {
+    term match {
+      case CaseOf(scrutinee: Var, Case(pattern, trueBranch, Wildcard(falseBranch))) =>
+        if (scrutinee.symbolOption.exists(_ === symbol)) true
+        else hasScrutinee(trueBranch, symbol) || hasScrutinee(falseBranch, symbol)
+      case Let(_, _, _, body) => hasScrutinee(body, symbol)
+      case _ => false
+    }
+  }
+
+  private def separateCaseBranches(term: Term)(implicit scrutinee: Symbol): (CaseBranches, Term) = ???
+}
+
+object PostProcessing {
+
+}
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
new file mode 100644
index 0000000000..8d34067b17
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -0,0 +1,145 @@
+package mlscript.ucs.stages
+
+import mlscript.ucs.helpers
+import mlscript.{If, IfBody, IfBlock, IfElse, IfLet, IfOpApp, IfOpsApp, IfThen}
+import mlscript.{Term, Var, App, Tup, Lit, Fld, Loc}
+import mlscript.ucs.syntax._
+import mlscript.Message, Message._
+import mlscript.utils._, shorthands._
+import mlscript.NuFunDef
+import mlscript.PlainTup
+import scala.collection.immutable
+
+/**
+  * Transform the parsed AST into an AST similar to the one in the paper.
+  * The parsed AST represents pattern with terms and does not distingiush
+  * `is` and `and` operators.
+  * The AST in the paper is more flexible. For example, it allows interleaved
+  * `let` bindings in operator splits.
+  */
+trait Transformation { self: mlscript.pretyper.Traceable =>
+  import Transformation._
+
+  def transform(`if`: If, useNewDefs: Bool = true): TermSplit =
+    transformIfBody(`if`.body)(useNewDefs) ++ `if`.els.fold(Split.empty)(Split.default)
+
+  import helpers.splitAnd
+
+  private def transformIfBody(body: IfBody)(implicit useNewDefs: Bool): TermSplit = {
+    body match {
+      case IfThen(expr, rhs) =>
+        splitAnd(expr).foldRight(Split.then(rhs)) {
+          case (OperatorIs(scrutinee, pattern), acc) =>
+            TermBranch.Match(scrutinee, PatternBranch(rec(pattern), acc) |> Split.single) |> Split.single
+          case (test, acc) => TermBranch.Boolean(test, acc) |> Split.single
+        }
+      case IfLet(isRec, name, rhs, body) => rare
+      case IfElse(expr) => Split.then(expr)
+      case IfOpApp(lhs, Var("is"), rhs) =>
+        splitAnd(lhs) match {
+          case init :+ last =>
+            init.foldRight[TermSplit](TermBranch.Match(last, transformPatternMatching(rhs)) |> Split.single) {
+              case (OperatorIs(scrutinee, pattern), acc) =>
+                TermBranch.Match(scrutinee, PatternBranch(rec(pattern), acc) |> Split.single) |> Split.single
+              case (test, acc) => TermBranch.Boolean(test, acc) |> Split.single
+            }
+          case _ => rare
+        }
+      case IfOpApp(lhs, op, rhs) => 
+        splitAnd(lhs) match {
+          case init :+ last =>
+            val first = TermBranch.Left(last, OperatorBranch.Binary(op, transformIfBody(rhs)) |> Split.single) |> Split.single
+            init.foldRight[TermSplit](first) {
+              case (OperatorIs(scrutinee, pattern), acc) =>
+                TermBranch.Match(scrutinee, PatternBranch(rec(pattern), acc) |> Split.single) |> Split.single
+              case (test, acc) => TermBranch.Boolean(test, acc) |> Split.single
+            }
+          case _ => rare
+        }
+      case IfBlock(lines) =>
+        lines.foldLeft(Split.empty[TermBranch]) {
+          case (acc, L(body)) => acc ++ transformIfBody(body)
+          case (acc, R(NuFunDef(S(rec), nme, _, _, L(rhs)))) =>
+            acc ++ Split.Let(rec, nme, rhs, Split.Nil)
+          case (acc, R(statement)) =>
+            throw new TransformException(msg"Unexpected statement in an if block", statement.toLoc)
+        }
+      case IfOpsApp(lhs, opsRhss) =>
+        TermBranch.Left(lhs, Split.from(opsRhss.map(transformOperatorBranch))) |> Split.single
+    }
+  }
+  
+  private def transformOperatorBranch(opsRhs: Var -> IfBody)(implicit useNewDefs: Bool): OperatorBranch =
+    opsRhs match {
+      case (op @ Var("is"), rhs) => OperatorBranch.Match(op, transformPatternMatching(rhs))
+      case (op, rhs) => OperatorBranch.Binary(op, transformIfBody(rhs))
+    }
+
+  private def transformPatternMatching(body: IfBody)(implicit useNewDefs: Bool): PatternSplit = {
+    body match {
+      case IfThen(expr, rhs) => 
+        separatePattern(expr) match {
+          case (pattern, S(extraTest)) =>
+            PatternBranch(pattern, transformIfBody(IfThen(extraTest, rhs))) |> Split.single
+          case (pattern, N) =>
+            PatternBranch(pattern, Split.default(rhs)) |> Split.single
+        }
+      case IfOpApp(lhs, Var("and"), rhs) =>
+        separatePattern(lhs) match {
+          case (pattern, S(extraTest)) =>
+            PatternBranch(rec(lhs), ???) |> Split.single
+          case (pattern, N) =>
+            PatternBranch(rec(lhs), transformIfBody(rhs)) |> Split.single
+        }
+      case IfOpApp(lhs, op, rhs) => ???
+      case IfOpsApp(lhs, opsRhss) => ???
+      case IfLet(rec, nme, rhs, body) => rare
+      case IfBlock(lines) => lines.foldLeft(Split.empty[PatternBranch]) {
+        case (acc, L(body)) => acc ++ transformPatternMatching(body)
+        case (acc, R(NuFunDef(S(rec), nme, _, _, L(rhs)))) =>
+          acc ++ Split.Let(rec, nme, rhs, Split.Nil)
+        case (acc, R(statement)) =>
+          throw new TransformException(msg"Unexpected statement in an if block", statement.toLoc)
+      }
+      case IfElse(expr) => Split.default(expr)
+    }
+  }
+
+  private def rec(term: Term)(implicit useNewDefs: Bool): Pattern = term match {
+    case nme @ Var(name) if name.headOption.exists(_.isUpper) => ClassPattern(nme, N)
+    case nme: Var => NamePattern(nme)
+    case literal: Lit => LiteralPattern(literal)
+    case App(classNme @ Var(_), Tup(parameters)) =>
+      ClassPattern(classNme, S(parameters.map {
+        case (_, Fld(_, Var("_"))) => N // Consider "_" as wildcard.
+        case (_, Fld(_, t)) => S(rec(t))
+      }))
+    case Tup(fields) => TuplePattern(fields.map {
+      case _ -> Fld(_, Var("_")) => N // Consider "_" as wildcard.
+      case _ -> Fld(_, t       ) => S(rec(t))
+    })
+    // TODO: Support more patterns.
+    case _ => throw new TransformException(msg"Unknown pattern", term.toLoc)
+  }
+
+  private def separatePattern(term: Term)(implicit useNewDefs: Bool): (Pattern, Opt[Term]) = {
+    val (rawPattern, extraTest) = helpers.separatePattern(term, useNewDefs)
+    (rec(rawPattern), extraTest)
+  }
+
+  private def rare: Nothing = throw new TransformException(msg"Wow, a rare case.", N)
+}
+
+object Transformation {
+  private object OperatorIs {
+    def unapply(term: Term)(implicit useNewDefs: Bool): Opt[(Term, Term)] = term match {
+      case App(App(Var("is"), Tup(_ -> Fld(_, scrutinee) :: Nil)), Tup(_ -> Fld(_, pattern) :: Nil)) if !useNewDefs => S(scrutinee -> pattern)
+      case App(Var("is"), PlainTup(scrutinee, pattern)) => S(scrutinee -> pattern)
+      case _ => N
+    }
+  }
+
+  class TransformException(val messages: Ls[Message -> Opt[Loc]]) extends Throwable {
+    def this(message: Message, location: Opt[Loc]) = this(message -> location :: Nil)
+  }
+}
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/ucs/stages/package.scala b/shared/src/main/scala/mlscript/ucs/stages/package.scala
new file mode 100644
index 0000000000..c0d7c81f41
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/stages/package.scala
@@ -0,0 +1,7 @@
+package mlscript.ucs
+
+import mlscript.{Term, Var}
+import mlscript.pretyper.Symbol
+import mlscript.utils._, shorthands._
+
+package object stages
diff --git a/shared/src/main/scala/mlscript/ucs/syntax.scala b/shared/src/main/scala/mlscript/ucs/syntax.scala
new file mode 100644
index 0000000000..1137baed5e
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/syntax.scala
@@ -0,0 +1,152 @@
+package mlscript.ucs
+
+import mlscript.{Lit, Located, Term, Var}
+import mlscript.utils._, shorthands._
+import scala.annotation.tailrec
+import scala.collection.immutable
+
+package object syntax {
+  sealed abstract class Pattern extends Located {
+    override def toString(): String = this match {
+      case AliasPattern(nme, pattern) => s"$nme @ $pattern"
+      case LiteralPattern(literal) => literal.toString
+      case NamePattern(nme) => nme.toString
+      case ClassPattern(Var(name), N) => name
+      case ClassPattern(Var(name), S(parameters)) =>
+        parameters.iterator.map(_.fold("_")(_.toString)).mkString(s"$name(", ", ", ")")
+      case TuplePattern(fields) => fields.iterator.map(_.fold("_")(_.toString)).mkString("(", ", ", ")")
+      case RecordPattern(Nil) => "{}"
+      case RecordPattern(entries) => entries.iterator.map { case (nme, als) => s"$nme: $als" }.mkString("{ ", ", ", " }")
+    }
+  }
+  final case class AliasPattern(nme: Var, pattern: Pattern) extends Pattern {
+    override def children: List[Located] = nme :: pattern :: Nil
+  }
+  final case class LiteralPattern(literal: Lit) extends Pattern {
+    override def children: List[Located] = literal :: Nil
+  }
+  final case class NamePattern(nme: Var) extends Pattern {
+    override def children: List[Located] = nme :: Nil
+  }
+  final case class ClassPattern(val nme: Var, val parameters: Opt[List[Opt[Pattern]]]) extends Pattern {
+    override def children: List[Located] = nme :: parameters.fold(List.empty[Located])(_.flatten)
+  }
+  final case class TuplePattern(fields: List[Opt[Pattern]]) extends Pattern {
+    override def children: List[Located] = fields.flatten
+  }
+  final case class RecordPattern(entries: List[(Var -> Pattern)]) extends Pattern {
+    override def children: List[Located] = entries.iterator.flatMap { case (nme, als) => nme :: als :: Nil }.toList
+  }
+
+  sealed abstract class Split[+SomeBranch <: Branch] extends Located {
+    def ++[OtherBranch >: SomeBranch <: Branch](that: Split[OtherBranch]): Split[OtherBranch] = this match {
+      case Split.Cons(head, tail) => Split.Cons(head, tail ++ that)
+      case Split.Let(rec, nme, rhs, tail) => Split.Let(rec, nme, rhs, tail ++ that)
+      case Split.Else(_) => this
+      case Split.Nil => that
+    }
+    def ::[OtherBranch >: SomeBranch <: Branch](head: OtherBranch): Split[OtherBranch] = Split.Cons(head, this)
+  }
+  object Split {
+    import immutable.{Nil => LNil}
+    final case class Cons[SomeBranch <: Branch](head: SomeBranch, tail: Split[SomeBranch]) extends Split[SomeBranch] {
+      override def children: List[Located] = head :: tail :: LNil
+    }
+    final case class Let[SomeBranch <: Branch](rec: Bool, nme: Var, rhs: Term, tail: Split[SomeBranch]) extends Split[SomeBranch] {
+      override def children: List[Located] = nme :: rhs :: tail :: LNil
+    }
+    final case class Else(term: Term) extends Split[Nothing] {
+      override def children: List[Located] = term :: LNil
+    }
+    final case object Nil extends Split[Nothing] {
+      override def children: List[Located] = LNil
+    }
+
+    def empty[SomeBranch <: Branch]: Split[SomeBranch] = Nil
+    def single[SomeBranch <: Branch](branch: SomeBranch): Split[SomeBranch] = Cons(branch, Nil)
+    def `then`(term: Term): Split[TermBranch] = Else(term)
+    def default[SomeBranch <: Branch](term: Term): Split[SomeBranch] = Else(term)
+    def from[SomeBranch <: Branch](branches: Iterable[SomeBranch]): Split[SomeBranch] =
+      branches.foldRight(Nil: Split[SomeBranch])(Cons.apply)
+  }
+
+  sealed abstract class Branch extends Located
+
+  sealed abstract class TermBranch extends Branch
+  object TermBranch {
+    final case class Boolean(test: Term, continuation: TermSplit) extends TermBranch {
+      override def children: List[Located] = test :: continuation :: Nil
+    }
+    final case class Match(scrutinee: Term, continuation: PatternSplit) extends TermBranch {
+      override def children: List[Located] = scrutinee :: continuation :: Nil
+    }
+    final case class Left(left: Term, continuation: OperatorSplit) extends TermBranch {
+      override def children: List[Located] = left :: continuation :: Nil
+    }
+  }
+  type TermSplit = Split[TermBranch]
+
+  sealed abstract class OperatorBranch extends Branch {
+    val operator: Var
+  }
+  object OperatorBranch {
+    final case class Match(override val operator: Var, continuation: PatternSplit) extends OperatorBranch {
+      override def children: List[Located] = operator :: continuation :: Nil
+    }
+    final case class Binary(override val operator: Var, continuation: TermSplit) extends OperatorBranch {
+      override def children: List[Located] = operator :: continuation :: Nil
+    }
+  }
+  type OperatorSplit = Split[OperatorBranch]
+
+  final case class PatternBranch(val pattern: Pattern, val continuation: TermSplit) extends Branch {
+    override def children: List[Located] = pattern :: continuation :: Nil
+  }
+  type PatternSplit = Split[PatternBranch]
+
+  def printTermSplit(split: TermSplit): Str = {
+    // TODO: tailrec
+    def termSplit(split: TermSplit, isFirst: Bool, isTopLevel: Bool): Lines = split match {
+      case Split.Cons(head, tail) => (termBranch(head) match {
+        case (n, line) :: tail => (n, (if (isTopLevel) "" else "and ") + s"$line") :: tail
+        case Nil => Nil
+      }) ::: termSplit(tail, false, isTopLevel)
+      case Split.Let(_, nme, rhs, tail) => (0, s"let $nme = $rhs") :: termSplit(tail, false, isTopLevel)
+      case Split.Else(term) => (if (isFirst) (0, s"then $term") else (0, s"else $term")) :: Nil
+      case Split.Nil => Nil
+    }
+    def termBranch(branch: TermBranch): Lines = branch match {
+      case TermBranch.Boolean(test, continuation) => 
+        s"$test" #: termSplit(continuation, true, false)
+      case TermBranch.Match(scrutinee, continuation) =>
+        s"$scrutinee is" #: patternSplit(continuation)
+      case TermBranch.Left(left, continuation) =>
+        s"$left" #: operatorSplit(continuation)
+    }
+    def patternSplit(split: PatternSplit): Lines = split match {
+      case Split.Cons(head, tail) => patternBranch(head) ::: patternSplit(tail)
+      case Split.Let(rec, nme, rhs, tail) => (0, s"let $nme = $rhs") :: patternSplit(tail)
+      case Split.Else(term) => (0, s"else $term") :: Nil
+      case Split.Nil => Nil
+    }
+    def operatorSplit(split: OperatorSplit): Lines = split match {
+      case Split.Cons(head, tail) => operatorBranch(head) ::: operatorSplit(tail)
+      case Split.Let(rec, nme, rhs, tail) => (0, s"let $nme = $rhs") :: operatorSplit(tail)
+      case Split.Else(term) => (0, s"else $term") :: Nil
+      case Split.Nil => Nil
+    }
+    def operatorBranch(branch: OperatorBranch): Lines =
+      s"${branch.operator}" #: (branch match {
+        case OperatorBranch.Match(_, continuation) => patternSplit(continuation)
+        case OperatorBranch.Binary(_, continuation) => termSplit(continuation, true, false)
+      })
+    def patternBranch(branch: PatternBranch): Lines = {
+      val PatternBranch(pattern, continuation) = branch
+      termSplit(continuation, true, false) match {
+        case (0, line) :: lines => (0, s"$pattern $line") :: lines
+        case lines => (0, pattern.toString) :: lines
+      }
+    }
+    ("if" #: termSplit(split, true, true)).iterator.map { case (n, line) => "  " * n + line }.mkString("\n")
+  }
+}
diff --git a/shared/src/test/diff/mlscript/Basics.mls b/shared/src/test/diff/mlscript/Basics.mls
index 2af98bf088..f6ec00c72a 100644
--- a/shared/src/test/diff/mlscript/Basics.mls
+++ b/shared/src/test/diff/mlscript/Basics.mls
@@ -96,7 +96,7 @@ def f (x y z) = add x y
 //│ ╙──      	       ^^^^^
 //│ f: error -> int
 //│ Code generation encountered an error:
-//│   term App(App(Var(x), Tup(_: Var(y))), Tup(_: Var(z))) is not a valid pattern
+//│   term App(App(Var(x), Tup((N, Var(y)))), Tup((N, Var(z)))) is not a valid pattern
 
 f 1
 //│ res: int
diff --git a/shared/src/test/diff/mlscript/ByNameByValue.mls b/shared/src/test/diff/mlscript/ByNameByValue.mls
index 3e87640778..be234e2ca8 100644
--- a/shared/src/test/diff/mlscript/ByNameByValue.mls
+++ b/shared/src/test/diff/mlscript/ByNameByValue.mls
@@ -16,7 +16,7 @@ def incr x = x.a <- x.a + 1
 def gensym = let n = { mut a = 0 } in fun () -> (incr n, n)
 //│ Parsed: def gensym: let n = {mut a: 0} in () => [incr(n,), n,];
 //│ Desugared: def gensym: let n = {mut a: 0} in () => [incr(n,), n,]
-//│ AST: Def(false, gensym, Let(false, n, Rcd(Var(a) = IntLit(0)), Lam(Tup(), Tup(_: App(Var(incr), Tup(_: Var(n))), _: Var(n)))), true)
+//│ AST: Def(false, gensym, Let(false, n, Rcd(Var(a) = IntLit(0)), Lam(Tup(), Tup((N, App(Var(incr), Tup((N, Var(n))))), (N, Var(n))))), true)
 //│ // Query 1
 //│ globalThis.gensym = function gensym() {
 //│   return (((n) => () => [
@@ -35,7 +35,7 @@ def gensym = let n = { mut a = 0 } in fun () -> (incr n, n)
 gensym1 = let n = { mut a = 0 } in fun () -> (incr n, n)
 //│ Parsed: let gensym1 = let n = {mut a: 0} in () => [incr(n,), n,];
 //│ Desugared: def gensym1: let n = {mut a: 0} in () => [incr(n,), n,]
-//│ AST: Def(false, gensym1, Let(false, n, Rcd(Var(a) = IntLit(0)), Lam(Tup(), Tup(_: App(Var(incr), Tup(_: Var(n))), _: Var(n)))), false)
+//│ AST: Def(false, gensym1, Let(false, n, Rcd(Var(a) = IntLit(0)), Lam(Tup(), Tup((N, App(Var(incr), Tup((N, Var(n))))), (N, Var(n))))), false)
 //│ // Query 1
 //│ globalThis.gensym1 = ((n) => () => [
 //│   incr(n),
diff --git a/shared/src/test/diff/mlscript/MultiArgs.mls b/shared/src/test/diff/mlscript/MultiArgs.mls
index 62e7a8090d..0c5f8e7d81 100644
--- a/shared/src/test/diff/mlscript/MultiArgs.mls
+++ b/shared/src/test/diff/mlscript/MultiArgs.mls
@@ -75,9 +75,9 @@ f = fun (x, y) -> add x y
 f(1, 2)
 //│ Parsed: let f = (x, y,) => add(x,)(y,); f(1, 2,);
 //│ Desugared: def f: (x, y,) => add(x,)(y,)
-//│ AST: Def(false, f, Lam(Tup(_: Var(x), _: Var(y)), App(App(Var(add), Tup(_: Var(x))), Tup(_: Var(y)))), false)
+//│ AST: Def(false, f, Lam(Tup((N, Var(x)), (N, Var(y))), App(App(Var(add), Tup((N, Var(x)))), Tup((N, Var(y))))), false)
 //│ Desugared: f(1, 2,)
-//│ AST: App(Var(f), Tup(_: IntLit(1), _: IntLit(2)))
+//│ AST: App(Var(f), Tup((N, IntLit(1)), (N, IntLit(2))))
 //│ f: (int, int,) -> int
 //│  = [Function: f]
 //│ res: int
@@ -119,9 +119,9 @@ f = fun ((x, y)) -> add x y
 f((1, 2))
 //│ Parsed: let f = ('(' [x, y,] ')',) => add(x,)(y,); f('(' [1, 2,] ')',);
 //│ Desugared: def f: ('(' [x, y,] ')',) => add(x,)(y,)
-//│ AST: Def(false, f, Lam(Tup(_: Bra(rcd = false, Tup(_: Var(x), _: Var(y)))), App(App(Var(add), Tup(_: Var(x))), Tup(_: Var(y)))), false)
+//│ AST: Def(false, f, Lam(Tup((N, Bra(rcd = false, Tup((N, Var(x)), (N, Var(y)))))), App(App(Var(add), Tup((N, Var(x)))), Tup((N, Var(y))))), false)
 //│ Desugared: f('(' [1, 2,] ')',)
-//│ AST: App(Var(f), Tup(_: Bra(rcd = false, Tup(_: IntLit(1), _: IntLit(2)))))
+//│ AST: App(Var(f), Tup((N, Bra(rcd = false, Tup((N, IntLit(1)), (N, IntLit(2)))))))
 //│ f: ((int, int,),) -> int
 //│  = [Function: f1]
 //│ res: int
diff --git a/shared/src/test/diff/mlscript/Ops.mls b/shared/src/test/diff/mlscript/Ops.mls
index 837b2c09e6..b278598ee4 100644
--- a/shared/src/test/diff/mlscript/Ops.mls
+++ b/shared/src/test/diff/mlscript/Ops.mls
@@ -3,7 +3,7 @@
 2 + 2
 //│ Parsed: +(2,)(2,);
 //│ Desugared: +(2,)(2,)
-//│ AST: App(App(Var(+), Tup(_: IntLit(2))), Tup(_: IntLit(2)))
+//│ AST: App(App(Var(+), Tup((N, IntLit(2)))), Tup((N, IntLit(2))))
 //│ res: int
 //│    = 4
 
@@ -11,7 +11,7 @@
 1 + 2 * 2 + 3
 //│ Parsed: +(+(1,)(*(2,)(2,),),)(3,);
 //│ Desugared: +(+(1,)(*(2,)(2,),),)(3,)
-//│ AST: App(App(Var(+), Tup(_: App(App(Var(+), Tup(_: IntLit(1))), Tup(_: App(App(Var(*), Tup(_: IntLit(2))), Tup(_: IntLit(2))))))), Tup(_: IntLit(3)))
+//│ AST: App(App(Var(+), Tup((N, App(App(Var(+), Tup((N, IntLit(1)))), Tup((N, App(App(Var(*), Tup((N, IntLit(2)))), Tup((N, IntLit(2)))))))))), Tup((N, IntLit(3))))
 //│ res: int
 //│    = 8
 
@@ -20,7 +20,7 @@
 1 + 2 / 2 + 3
 //│ Parsed: +(+(1,)(/(2,)(2,),),)(3,);
 //│ Desugared: +(+(1,)(/(2,)(2,),),)(3,)
-//│ AST: App(App(Var(+), Tup(_: App(App(Var(+), Tup(_: IntLit(1))), Tup(_: App(App(Var(/), Tup(_: IntLit(2))), Tup(_: IntLit(2))))))), Tup(_: IntLit(3)))
+//│ AST: App(App(Var(+), Tup((N, App(App(Var(+), Tup((N, IntLit(1)))), Tup((N, App(App(Var(/), Tup((N, IntLit(2)))), Tup((N, IntLit(2)))))))))), Tup((N, IntLit(3))))
 //│ ╔══[ERROR] Type mismatch in operator application:
 //│ ║  l.20: 	1 + 2 / 2 + 3
 //│ ║        	^^^^^^^^^
@@ -36,7 +36,7 @@
 1 |> 2 || 3
 //│ Parsed: ||(|>(1,)(2,),)(3,);
 //│ Desugared: ||(|>(1,)(2,),)(3,)
-//│ AST: App(App(Var(||), Tup(_: App(App(Var(|>), Tup(_: IntLit(1))), Tup(_: IntLit(2))))), Tup(_: IntLit(3)))
+//│ AST: App(App(Var(||), Tup((N, App(App(Var(|>), Tup((N, IntLit(1)))), Tup((N, IntLit(2))))))), Tup((N, IntLit(3))))
 //│ ╔══[ERROR] identifier not found: |>
 //│ ║  l.36: 	1 |> 2 || 3
 //│ ╙──      	  ^^
@@ -54,7 +54,7 @@
 true || false && true || false
 //│ Parsed: ||(||(true,)(&&(false,)(true,),),)(false,);
 //│ Desugared: ||(||(true,)(&&(false,)(true,),),)(false,)
-//│ AST: App(App(Var(||), Tup(_: App(App(Var(||), Tup(_: Var(true))), Tup(_: App(App(Var(&&), Tup(_: Var(false))), Tup(_: Var(true))))))), Tup(_: Var(false)))
+//│ AST: App(App(Var(||), Tup((N, App(App(Var(||), Tup((N, Var(true)))), Tup((N, App(App(Var(&&), Tup((N, Var(false)))), Tup((N, Var(true)))))))))), Tup((N, Var(false))))
 //│ res: bool
 //│    = true
 
diff --git a/shared/src/test/diff/mlscript/Repro.mls b/shared/src/test/diff/mlscript/Repro.mls
index 539c23787c..97fb1eace6 100644
--- a/shared/src/test/diff/mlscript/Repro.mls
+++ b/shared/src/test/diff/mlscript/Repro.mls
@@ -1,3 +1,17 @@
 :NewDefs
+:PreTyper
 
+class Point(x: Int, y: Int)
+//│ class Point(x: Int, y: Int)
 
+fun length(p) = if p is Point(x, y) then x + y
+//│ fun length: Point -> Int
+
+let xy = Point.unapply(Point(0, 1))
+xy.1
+//│ let xy: [Int, Int]
+//│ Int
+//│ xy
+//│    = [ 0, 1 ]
+//│ res
+//│     = 1
diff --git a/shared/src/test/diff/nu/LamPatterns.mls b/shared/src/test/diff/nu/LamPatterns.mls
index 58aa85eb8e..c61d5f19b6 100644
--- a/shared/src/test/diff/nu/LamPatterns.mls
+++ b/shared/src/test/diff/nu/LamPatterns.mls
@@ -14,7 +14,7 @@ Some(x) => x
 //│ ╙──     	           ^
 //│ error -> error
 //│ Code generation encountered an error:
-//│   term App(Var(Some), Tup(_: Var(x))) is not a valid pattern
+//│   term App(Var(Some), Tup((N, Var(x)))) is not a valid pattern
 
 :js
 // FIXME type
diff --git a/shared/src/test/diff/nu/OverrideShorthand.mls b/shared/src/test/diff/nu/OverrideShorthand.mls
index 25db2319d8..b6273930c8 100644
--- a/shared/src/test/diff/nu/OverrideShorthand.mls
+++ b/shared/src/test/diff/nu/OverrideShorthand.mls
@@ -10,7 +10,7 @@ class Pair(lhs: Int, rhs: Int)
 :e
 fun f(override Pair(x, y)) = x + y
 //│ |#fun| |f|(|#override| |Pair|(|x|,| |y|)|)| |#=| |x| |+| |y|
-//│ AST: TypingUnit(NuFunDef(None, f, None, [], Lam(Tup(_: Var(_$0)), If(IfOpApp(Var(_$0), Var(is), IfThen(App(Var(Pair), Tup(_: Var(x), _: Var(y))), App(Var(+), Tup(_: Var(x), _: Var(y))), Some(App(Sel(Super(), f), Tup(_: Var(_$0))))))))
+//│ AST: TypingUnit(NuFunDef(None, f, None, [], Lam(Tup((N, Var(_$0))), If(IfOpApp(Var(_$0), Var(is), IfThen(App(Var(Pair), Tup((N, Var(x)), (N, Var(y)))), App(Var(+), Tup((N, Var(x)), (N, Var(y)))), Some(App(Sel(Super(), f), Tup((N, Var(_$0)))))))))
 //│ Parsed: fun f = (_$0,) => if _$0 is (Pair(x, y,)) then +(x, y,) else (super).f(_$0,);
 //│ ╔══[ERROR] identifier not found: super
 //│ ║  l.11: 	fun f(override Pair(x, y)) = x + y
@@ -46,7 +46,7 @@ fun f(override Pair(x, y), z) = x + y
 //│ ╙──      	                                    ^
 //│ fun f: (error, anything) -> Int
 //│ Code generation encountered an error:
-//│   term App(Var(Pair), Tup(_: Var(x), _: Var(y))) is not a valid pattern
+//│   term App(Var(Pair), Tup((N, Var(x)), (N, Var(y)))) is not a valid pattern
 
 
 // TODO
diff --git a/shared/src/test/diff/nu/RightAssocOps.mls b/shared/src/test/diff/nu/RightAssocOps.mls
index 15a34aaad7..46187337df 100644
--- a/shared/src/test/diff/nu/RightAssocOps.mls
+++ b/shared/src/test/diff/nu/RightAssocOps.mls
@@ -30,7 +30,7 @@ fun (++) conc(xs, ys) = [xs, ys]
 :p
 1 +: "a" ++ "b" :+ 2
 //│ |1| |+:| |"a"| |++| |"b"| |:+| |2|
-//│ AST: TypingUnit(App(Var(+:), Tup(_: IntLit(1), _: App(Var(:+), Tup(_: App(Var(++), Tup(_: StrLit(a), _: StrLit(b))), _: IntLit(2))))))
+//│ AST: TypingUnit(App(Var(+:), Tup((N, IntLit(1)), (N, App(Var(:+), Tup((N, App(Var(++), Tup((N, StrLit(a)), (N, StrLit(b))))), (N, IntLit(2))))))))
 //│ Parsed: +:(1, :+(++("a", "b",), 2,),);
 //│ [[Int], [["a", "b"], [Int]]]
 //│ res
@@ -39,7 +39,7 @@ fun (++) conc(xs, ys) = [xs, ys]
 :p
 1 +: "a" :+ 2 ++ "b"
 //│ |1| |+:| |"a"| |:+| |2| |++| |"b"|
-//│ AST: TypingUnit(App(Var(+:), Tup(_: IntLit(1), _: App(Var(++), Tup(_: App(Var(:+), Tup(_: StrLit(a), _: IntLit(2))), _: StrLit(b))))))
+//│ AST: TypingUnit(App(Var(+:), Tup((N, IntLit(1)), (N, App(Var(++), Tup((N, App(Var(:+), Tup((N, StrLit(a)), (N, IntLit(2))))), (N, StrLit(b))))))))
 //│ Parsed: +:(1, ++(:+("a", 2,), "b",),);
 //│ [[Int], [["a", [Int]], "b"]]
 //│ res
@@ -49,7 +49,7 @@ fun (++) conc(xs, ys) = [xs, ys]
 :e
 1 +: "a" ++ 2 +: "b"
 //│ |1| |+:| |"a"| |++| |2| |+:| |"b"|
-//│ AST: TypingUnit(App(Var(+:), Tup(_: IntLit(1), _: App(Var(+:), Tup(_: App(Var(++), Tup(_: StrLit(a), _: IntLit(2))), _: StrLit(b))))))
+//│ AST: TypingUnit(App(Var(+:), Tup((N, IntLit(1)), (N, App(Var(+:), Tup((N, App(Var(++), Tup((N, StrLit(a)), (N, IntLit(2))))), (N, StrLit(b))))))))
 //│ Parsed: +:(1, +:(++("a", 2,), "b",),);
 //│ ╔══[ERROR] Type mismatch in operator application:
 //│ ║  l.50: 	1 +: "a" ++ 2 +: "b"
diff --git a/shared/src/test/diff/pretyper/Declarations.mls b/shared/src/test/diff/pretyper/Declarations.mls
new file mode 100644
index 0000000000..1401303e05
--- /dev/null
+++ b/shared/src/test/diff/pretyper/Declarations.mls
@@ -0,0 +1,89 @@
+:NewDefs
+:PreTyper
+:NoJS
+
+:dpt
+fun test(x, y) = x + y
+//│ process <== <root>: {fun test}
+//│ | visitTypingUnit <== <root>: {fun test}
+//│ | | 1. scope = {test}
+//│ | | 2. scope = {test}
+//│ | | visitFunction <== test
+//│ | | | visitTerm <== Lam(_, _)
+//│ | | | | visitTerm <== App(_, _)
+//│ | | | | | visitTerm <== Var("+")
+//│ | | | | | | visitVar(name = "+")
+//│ | | | | | | | resolveVar(name = "+")
+//│ | | | | | visitTerm ==> Var("+")
+//│ | | | | | visitTerm <== Tup(_, _)
+//│ | | | | | | visitTerm <== Var("x")
+//│ | | | | | | | visitVar(name = "x")
+//│ | | | | | | | | resolveVar(name = "x")
+//│ | | | | | | visitTerm ==> Var("x")
+//│ | | | | | | visitTerm <== Var("y")
+//│ | | | | | | | visitVar(name = "y")
+//│ | | | | | | | | resolveVar(name = "y")
+//│ | | | | | | visitTerm ==> Var("y")
+//│ | | | | | visitTerm ==> Tup(_, _)
+//│ | | | | visitTerm ==> App(_, _)
+//│ | | | visitTerm ==> Lam(_, _)
+//│ | | visitFunction ==> test
+//│ | visitTypingUnit ==> test
+//│ process ==> test
+//│ fun test: (Int, Int) -> Int
+
+:dpt
+// Functions are hoisted.
+let y = id(42)
+fun id(x) = x
+//│ process <== <root>: {let y; fun id}
+//│ | visitTypingUnit <== <root>: {let y; fun id}
+//│ | | 1. scope = {id}
+//│ | | visitLetBinding(rec = false, y)
+//│ | | 2. scope = {id}
+//│ | | visitFunction <== id
+//│ | | | visitTerm <== Lam(_, _)
+//│ | | | | visitTerm <== Var("x")
+//│ | | | | | visitVar(name = "x")
+//│ | | | | | | resolveVar(name = "x")
+//│ | | | | visitTerm ==> Var("x")
+//│ | | | visitTerm ==> Lam(_, _)
+//│ | | visitFunction ==> id
+//│ | visitTypingUnit ==> id, y
+//│ process ==> id, y
+//│ let y: 42 | 'a
+//│ fun id: forall 'b. ('a & 'b) -> (42 | 'b)
+
+:dpt
+// Function bodies can access variables declare after them.
+fun q(x) = x + p
+let p = 0
+//│ process <== <root>: {fun q; let p}
+//│ | visitTypingUnit <== <root>: {fun q; let p}
+//│ | | 1. scope = {q}
+//│ | | visitLetBinding(rec = false, p)
+//│ | | 2. scope = {q}
+//│ | | visitFunction <== q
+//│ | | | visitTerm <== Lam(_, _)
+//│ | | | | visitTerm <== App(_, _)
+//│ | | | | | visitTerm <== Var("+")
+//│ | | | | | | visitVar(name = "+")
+//│ | | | | | | | resolveVar(name = "+")
+//│ | | | | | visitTerm ==> Var("+")
+//│ | | | | | visitTerm <== Tup(_, _)
+//│ | | | | | | visitTerm <== Var("x")
+//│ | | | | | | | visitVar(name = "x")
+//│ | | | | | | | | resolveVar(name = "x")
+//│ | | | | | | visitTerm ==> Var("x")
+//│ | | | | | | visitTerm <== Var("p")
+//│ | | | | | | | visitVar(name = "p")
+//│ | | | | | | | | resolveVar(name = "p")
+//│ | | | | | | visitTerm ==> Var("p")
+//│ | | | | | visitTerm ==> Tup(_, _)
+//│ | | | | visitTerm ==> App(_, _)
+//│ | | | visitTerm ==> Lam(_, _)
+//│ | | visitFunction ==> q
+//│ | visitTypingUnit ==> q, p
+//│ process ==> q, p
+//│ fun q: Int -> Int
+//│ let p: 0
diff --git a/shared/src/test/diff/pretyper/ucs/DualOption.mls b/shared/src/test/diff/pretyper/ucs/DualOption.mls
new file mode 100644
index 0000000000..2ebf1e7530
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/DualOption.mls
@@ -0,0 +1,135 @@
+:NewDefs
+:PreTyper
+
+class Some[T](value: T)
+module None
+type Option[T] = Some[T] | None
+class Pair[A, B](x: A, y: B)
+//│ class Some[T](value: T)
+//│ module None
+//│ type Option[T] = None | Some[T]
+//│ class Pair[A, B](x: A, y: B)
+
+// All `add_n` functions should be inferred to have the same type.
+
+fun add_1(x, y) =
+  if
+    x is Some(xv) and y is Some(yv) then xv + yv
+    x is Some(xv) and y is None     then xv
+    x is None     and y is Some(yv) then yv
+    x is None     and y is None     then 0
+//│ fun add_1: forall 'a. (None | Some[Int], None | Some[Int & 'a]) -> (Int | 'a)
+
+add_1(None, None)
+add_1(Some(5), None)
+add_1(None, Some(9))
+add_1(Some(5), Some(9))
+//│ Int
+//│ res
+//│     = 0
+//│ res
+//│     = 5
+//│ res
+//│     = 9
+//│ res
+//│     = 14
+
+fun add_2(x, y) =
+  if x is
+    Some(xv) and y is
+      Some(yv) then xv + yv
+      None     then xv
+    None and y is
+      Some(yv) then yv
+      None     then 0
+//│ fun add_2: forall 'a. (None | Some[Int], None | Some[Int & 'a]) -> (Int | 'a)
+
+add_2(None, None)
+add_2(Some(5), None)
+add_2(None, Some(9))
+add_2(Some(5), Some(9))
+//│ Int
+//│ res
+//│     = 0
+//│ res
+//│     = 5
+//│ res
+//│     = 9
+//│ res
+//│     = 14
+
+fun add_3(x, y) =
+  if Pair(x, y) is
+    Pair(Some(xv), Some(yv)) then xv + yv
+    Pair(Some(xv), None)     then xv
+    Pair(None,     Some(yv)) then yv
+    Pair(None,     None)     then 0
+//│ fun add_3: forall 'a. (None | Some[Int], None | Some[Int & 'a]) -> (Int | 'a)
+
+add_3(None, None)
+add_3(Some(5), None)
+add_3(None, Some(9))
+add_3(Some(5), Some(9))
+//│ Int
+//│ res
+//│     = 0
+//│ res
+//│     = 5
+//│ res
+//│     = 9
+//│ res
+//│     = 14
+
+fun add_4(x, y) =
+  if
+    x
+      is
+        Some(xv) and
+          y
+            is
+              Some(yv) then xv + yv
+            is
+              None     then xv
+        None and
+          y
+            is
+              Some(yv) then yv
+            is
+              None     then 0
+//│ fun add_4: forall 'a. (None | Some[Int], None | Some[Int & 'a]) -> (Int | 'a)
+
+add_4(None, None)
+add_4(Some(5), None)
+add_4(None, Some(9))
+add_4(Some(5), Some(9))
+//│ Int
+//│ res
+//│     = 0
+//│ res
+//│     = 5
+//│ res
+//│     = 9
+//│ res
+//│     = 14
+
+fun add_5(x, y) =
+  if
+    x is Some(xv) and y is Some(yv) then xv + yv
+    y is None     and x is Some(xv) then xv
+    x is None     and y is Some(yv) then yv
+    y is None     and x is None     then 0
+//│ fun add_5: forall 'a. (None | Some[Int], None | Some[Int & 'a]) -> (Int | 'a)
+
+add_5(None, None)
+add_5(Some(5), None)
+add_5(None, Some(9))
+add_5(Some(5), Some(9))
+//│ Int
+//│ res
+//│     = 0
+//│ res
+//│     = 5
+//│ res
+//│     = 9
+//│ res
+//│     = 14
diff --git a/shared/src/test/diff/pretyper/ucs/NamePattern.mls b/shared/src/test/diff/pretyper/ucs/NamePattern.mls
new file mode 100644
index 0000000000..bbe1fa4020
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/NamePattern.mls
@@ -0,0 +1,9 @@
+:PreTyper
+
+fun id(x) = x
+//│ fun id: forall 'a. 'a -> 'a
+
+if id(0) is t then t
+//│ 0
+//│ res
+//│     = 0
diff --git a/shared/src/test/diff/pretyper/ucs/RecordPattern.mls b/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
new file mode 100644
index 0000000000..ed86bd8af0
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
@@ -0,0 +1,8 @@
+:PreTyper
+
+// FIXME
+fun take_1(p) =
+  if p is
+    { x, y } then x + y
+    else 0
+//│ /!!!\ Uncaught error: mlscript.ucs.stages.Transformation$TransformException
diff --git a/shared/src/test/diff/pretyper/ucs/TransfromUCS.mls b/shared/src/test/diff/pretyper/ucs/TransfromUCS.mls
new file mode 100644
index 0000000000..2facf100a6
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/TransfromUCS.mls
@@ -0,0 +1,45 @@
+:PreTyper
+
+class Some[T](value: T)
+module None
+type Option[T] = Some[T] | None
+//│ class Some[T](value: T)
+//│ module None
+//│ type Option[T] = None | Some[T]
+
+class Cons[T](head: T, tail: List[T])
+module Nil
+type List[T] = Cons[T] | Nil
+//│ class Cons[T](head: T, tail: List[T])
+//│ module Nil
+//│ type List[T] = Cons[T] | Nil
+
+abstract class Either[out A, out B]
+class Left[out A, out B](value: A) extends Either[A, B]
+class Right[out A, out B](value: B) extends Either[A, B]
+//│ abstract class Either[A, B]
+//│ class Left[A, B](value: A) extends Either
+//│ class Right[A, B](value: B) extends Either
+
+class Pair[A, B](x: A, y: B) {
+  fun mapFirst[C](f: A -> C): Pair[C, B] = Pair(f(x), y)
+  fun mapSecond[C](f: B -> C): Pair[A, C] = Pair(x, f(y))
+}
+//│ class Pair[A, B](x: A, y: B) {
+//│   fun mapFirst: forall 'C. (f: A -> 'C) -> Pair['C, B]
+//│   fun mapSecond: forall 'C0. (f: B -> 'C0) -> Pair[A, 'C0]
+//│ }
+
+fun zipWith(f, xs, ys) =
+  if xs is
+    Cons(x, xs) and ys is Cons(y, ys) and zipWith(f, xs, ys) is Some(tail) then Some(Cons(f(x, y), tail))
+    Nil and ys is Nil then Some(Nil)
+  else None
+//│ fun zipWith: forall 'T 'T0 'T1. (('T, 'T0) -> 'T1, Cons['T] | Object & ~#Cons, Cons['T0] | Object & ~#Cons) -> (None | Some[Cons['T1] | Nil])
+
+
+fun getOrElse[T](x: Option[T], default: T): T =
+  if x is
+    Some(value) then value
+    None then default
+//│ fun getOrElse: forall 'T. (x: Option['T], default: 'T) -> 'T
diff --git a/shared/src/test/diff/pretyper/ucs/TuplePattern.mls b/shared/src/test/diff/pretyper/ucs/TuplePattern.mls
new file mode 100644
index 0000000000..99cad895ff
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/TuplePattern.mls
@@ -0,0 +1,10 @@
+:PreTyper
+
+// FIXME
+fun flex(x) =
+  if x is
+    [a, b, c] then
+      a + b + c
+    else
+      0
+//│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing
diff --git a/shared/src/test/diff/pretyper/ucs/Unapply.mls b/shared/src/test/diff/pretyper/ucs/Unapply.mls
new file mode 100644
index 0000000000..3bd099ff0d
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/Unapply.mls
@@ -0,0 +1,13 @@
+:NewDefs
+:PreTyper
+
+class Point(x: Int, y: Int, z: Int)
+//│ class Point(x: Int, y: Int, z: Int)
+
+fun f_0(p) = if p is Point(x, _, z) then x + z
+//│ fun f_0: Point -> Int
+
+f_0(Point(1, 2, 3))
+//│ Int
+//│ res
+//│     = 4
diff --git a/shared/src/test/diff/pretyper/ucs/Unconditional.mls b/shared/src/test/diff/pretyper/ucs/Unconditional.mls
new file mode 100644
index 0000000000..804033b23a
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/Unconditional.mls
@@ -0,0 +1,26 @@
+:PreTyper
+
+class Point(x: Int, y: Int)
+class Rectangle(x: Int, y: Int, width: Int, height: Int)
+//│ class Point(x: Int, y: Int)
+//│ class Rectangle(x: Int, y: Int, width: Int, height: Int)
+
+fun sum(p) = if p is Point(x, y) then x + y
+//│ fun sum: Point -> Int
+
+sum(Point(1, 2))
+//│ Int
+//│ res
+//│     = 3
+
+fun abs(x) = if x < 0 then -x else x
+//│ fun abs: Int -> Int
+
+fun dist(p, q) = if p is Point(x1, y1) and q is Point(x2, y2) then
+  abs(x1 - x2) + abs(y1 - y2)
+//│ fun dist: (Point, Point) -> Int
+
+dist(Point(1, 2), Point(3, 4))
+//│ Int
+//│ res
+//│     = 4
diff --git a/shared/src/test/diff/pretyper/ucs/examples/Option.mls b/shared/src/test/diff/pretyper/ucs/examples/Option.mls
new file mode 100644
index 0000000000..22207938ad
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/examples/Option.mls
@@ -0,0 +1,42 @@
+:PreTyper
+
+class Some[T](value: T)
+module None
+type Option[T] = Some[T] | None
+//│ class Some[T](value: T)
+//│ module None
+//│ type Option[T] = None | Some[T]
+
+fun getOrElse[T](self: Option[T], default: T): T =
+  if self is
+    Some(value) then value
+    None then default
+//│ fun getOrElse: forall 'T. (self: Option['T], default: 'T) -> 'T
+
+getOrElse(None, 0)
+getOrElse(None, "hello")
+getOrElse(None, true)
+//│ true
+//│ res
+//│     = 0
+//│ res
+//│     = 'hello'
+//│ res
+//│     = true
+
+getOrElse(Some(true), false)
+//│ Bool
+//│ res
+//│     = true
+
+fun map[T, U](self: Option[T], f: (T) -> U): Option[U] =
+  if self is
+    Some(value) then Some(f(value))
+    None then None
+//│ fun map: forall 'T 'U. (self: Option['T], f: 'T -> 'U) -> Option['U]
+
+fun flatMap[T, U](self: Option[T], f: (T) -> Option[U]): Option[U] =
+  if self is
+    Some(value) then f(value)
+    None then None
+//│ fun flatMap: forall 'T 'U. (self: Option['T], f: 'T -> Option['U]) -> Option['U]
diff --git a/shared/src/test/diff/ucs/LeadingAnd.mls b/shared/src/test/diff/ucs/LeadingAnd.mls
index faa751e461..ae365f487e 100644
--- a/shared/src/test/diff/ucs/LeadingAnd.mls
+++ b/shared/src/test/diff/ucs/LeadingAnd.mls
@@ -23,7 +23,7 @@ fun f(a, b) = if a is Some(av)
     and b is Some(bv)
     then av + bv
 //│ |#fun| |f|(|a|,| |b|)| |#=| |#if| |a| |is| |Some|(|av|)|→|and| |b| |is| |Some|(|bv|)|↵|#then| |av| |+| |bv|←|
-//│ AST: TypingUnit(NuFunDef(None, f, None, [], Lam(Tup(_: Var(a), _: Var(b)), If(IfOpApp(Var(a), Var(is), I; f; O; p; s; A; p; p; (; A; p; p; (; V; a; r; (; S; o; m; e; ); ,;  ; T; u; p; (; _; :;  ; V; a; r; (; a; v; ); ); ); ,;  ; <; i; t; e; r; a; t; o; r; >, None))))
+//│ AST: TypingUnit(NuFunDef(None, f, None, [], Lam(Tup((N, Var(a)), (N, Var(b))), If(IfOpApp(Var(a), Var(is), I; f; O; p; s; A; p; p; (; A; p; p; (; V; a; r; (; S; o; m; e; ); ,;  ; T; u; p; (; (; N; ,;  ; V; a; r; (; a; v; ); ); ); ); ,;  ; <; i; t; e; r; a; t; o; r; >, None))))
 //│ Parsed: fun f = (a, b,) => if a is Some(av,) ‹· and (is(b, Some(bv,),)) then +(av, bv,)›;
 //│ fun f: (Some[Int], Some[Int]) -> Int
 
@@ -34,7 +34,7 @@ fun f(a, b) = if a is
     and b is Some(bv)
     then av + bv
 //│ |#fun| |f|(|a|,| |b|)| |#=| |#if| |a| |is|→|Some|(|av|)|→|and| |b| |is| |Some|(|bv|)|↵|#then| |av| |+| |bv|←|←|
-//│ AST: TypingUnit(NuFunDef(None, f, None, [], Lam(Tup(_: Var(a), _: Var(b)), If(IfOpApp(Var(a), Var(is), IfBlock(I; f; O; p; s; A; p; p; (; A; p; p; (; V; a; r; (; S; o; m; e; ); ,;  ; T; u; p; (; _; :;  ; V; a; r; (; a; v; ); ); ); ,;  ; <; i; t; e; r; a; t; o; r; >), None))))
+//│ AST: TypingUnit(NuFunDef(None, f, None, [], Lam(Tup((N, Var(a)), (N, Var(b))), If(IfOpApp(Var(a), Var(is), IfBlock(I; f; O; p; s; A; p; p; (; A; p; p; (; V; a; r; (; S; o; m; e; ); ,;  ; T; u; p; (; (; N; ,;  ; V; a; r; (; a; v; ); ); ); ); ,;  ; <; i; t; e; r; a; t; o; r; >), None))))
 //│ Parsed: fun f = (a, b,) => if a is ‹Some(av,) ‹· and (is(b, Some(bv,),)) then +(av, bv,)››;
 //│ ╔══[ERROR] Illegal pattern `and`
 //│ ║  l.34: 	    and b is Some(bv)
diff --git a/shared/src/test/diff/ucs/SplitOps.mls b/shared/src/test/diff/ucs/SplitOps.mls
index 03ee227f54..7171667bbe 100644
--- a/shared/src/test/diff/ucs/SplitOps.mls
+++ b/shared/src/test/diff/ucs/SplitOps.mls
@@ -93,10 +93,10 @@ fun f(a, b, c) =
   if a
     == 0 and b is B() and c is C() then 0
 //│ |#fun| |f|(|a|,| |b|,| |c|)| |#=|→|#if| |a|→|==| |0| |and| |b| |is| |B|(||)| |and| |c| |is| |C|(||)| |#then| |0|←|←|
-//│ AST: TypingUnit(NuFunDef(None, f, None, [], Lam(Tup(_: Var(a), _: Var(b), _: Var(c)), Blk(...))))
+//│ AST: TypingUnit(NuFunDef(None, f, None, [], Lam(Tup((N, Var(a)), (N, Var(b)), (N, Var(c))), Blk(...))))
 //│ Parsed: fun f = (a, b, c,) => {if a ‹· == (and(and(0,)(is(b,)(B(),),),)(is(c,)(C(),),)) then 0›};
 //│ Desugared: rec def f: (a, b, c,) => {if a ‹· == (and(and(0,)(is(b,)(B(),),),)(is(c,)(C(),),)) then 0›}
-//│ AST: Def(true, f, Lam(Tup(_: Var(a), _: Var(b), _: Var(c)), Blk(...)), true)
+//│ AST: Def(true, f, Lam(Tup((N, Var(a)), (N, Var(b)), (N, Var(c))), Blk(...)), true)
 //│ ╔══[ERROR] The case when this is false is not handled: ==(a,)(0,)
 //│ ║  l.93: 	  if a
 //│ ║        	     ^
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index 9d74c269bd..4efc4d6aba 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -12,7 +12,7 @@ import mlscript.codegen.typescript.TsTypegenCodeBuilder
 import org.scalatest.{funsuite, ParallelTestExecution}
 import org.scalatest.time._
 import org.scalatest.concurrent.{TimeLimitedTests, Signaler}
-
+import pretyper.PreTyper
 
 abstract class ModeType {
   def expectTypeErrors: Bool
@@ -138,6 +138,7 @@ class DiffTests
     var declared: Map[Str, typer.ST] = Map.empty
     val failures = mutable.Buffer.empty[Int]
     val unmergedChanges = mutable.Buffer.empty[Int]
+    var preTyperScope = mlscript.pretyper.Scope.global
     
     case class Mode(
       expectTypeErrors: Bool = false,
@@ -150,6 +151,7 @@ class DiffTests
       explainErrors: Bool = false,
       dbg: Bool = false,
       dbgParsing: Bool = false,
+      dbgPreTyper: Opt[Int] = N,
       dbgSimplif: Bool = false,
       dbgUCS: Bool = false,
       fullExceptionStack: Bool = false,
@@ -188,6 +190,7 @@ class DiffTests
     var noRecursiveTypes = false
     var constrainedTypes = false
     var irregularTypes = false
+    var usePreTyper = false
     
     // * This option makes some test cases pass which assume generalization should happen in arbitrary arguments
     // * but it's way too aggressive to be ON by default, as it leads to more extrusion, cycle errors, etc.
@@ -210,6 +213,7 @@ class DiffTests
           case "p" => mode.copy(showParse = true)
           case "d" => mode.copy(dbg = true)
           case "dp" => mode.copy(dbgParsing = true)
+          case PreTyperOption(nv) => mode.copy(dbgPreTyper = S(nv))
           case "ds" => mode.copy(dbgSimplif = true)
           case "ducs" => mode.copy(dbg = true, dbgUCS = true)
           case "s" => mode.copy(fullExceptionStack = true)
@@ -254,6 +258,9 @@ class DiffTests
             // println("'"+line.drop(str.length + 2)+"'")
             typer.startingFuel = line.drop(str.length + 2).toInt; mode
           case "ResetFuel" => typer.startingFuel = typer.defaultStartingFuel; mode
+          // I believe `PreTyper` will become a part of new definition typing.
+          // So, this will be removed after `PreTyper` is done.
+          case "PreTyper" => newParser = true; newDefs = true; usePreTyper = true; mode
           case "ne" => mode.copy(noExecution = true)
           case "ng" => mode.copy(noGeneration = true)
           case "js" => mode.copy(showGeneratedJS = true)
@@ -512,9 +519,16 @@ class DiffTests
             }
             
             val (typeDefs, stmts, newDefsResults) = if (newDefs) {
-              
               val vars: Map[Str, typer.SimpleType] = Map.empty
-              val tpd = typer.typeTypingUnit(TypingUnit(p.tops), N)(ctx, raise, vars)
+              val rootTypingUnit = TypingUnit(p.tops)
+              if (usePreTyper) {
+                val preTyper = new PreTyper(mode.dbgPreTyper, newDefs) {
+                  override def emitDbg(str: String): Unit = output(str)
+                }
+                // This should be passed to code generation somehow.
+                preTyperScope = preTyper.process(rootTypingUnit, preTyperScope, "<root>")._1
+              }
+              val tpd = typer.typeTypingUnit(rootTypingUnit, N)(ctx, raise, vars)
               
               def showTTU(ttu: typer.TypedTypingUnit, ind: Int): Unit = {
                 val indStr = "  " * ind
@@ -1144,4 +1158,13 @@ object DiffTests {
       // name.startsWith("new/")
       // file.segments.toList.init.lastOption.contains("parser")
   }
+
+  object PreTyperOption {
+    def unapply(str: String): Option[Int] = str match {
+      case "dpt" => Some(0)
+      case "dpt:v" => Some(1)
+      case "dpt:vv" => Some(2)
+      case _ => None
+    }
+  }
 }

From fbdbe0be283309430b50926dace7eafc69b25737 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Fri, 24 Nov 2023 14:58:39 +0800
Subject: [PATCH 002/147] Start working on exhaustiveness checking

---
 shared/src/main/scala/mlscript/ucs/DesugarUCS.scala         | 6 +++++-
 .../scala/mlscript/ucs/stages/ExhaustivenessChecking.scala  | 5 +++++
 2 files changed, 10 insertions(+), 1 deletion(-)
 create mode 100644 shared/src/main/scala/mlscript/ucs/stages/ExhaustivenessChecking.scala

diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 685d236566..c19d058ceb 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -10,7 +10,11 @@ import mlscript.Message, Message.MessageContext
 import mlscript.ucs.core.Pattern.Name
 
 // TODO: Rename to `Desugarer` once the old desugarer is removed.
-trait DesugarUCS extends Transformation with Desugaring with Normalization with PostProcessing { self: PreTyper =>
+trait DesugarUCS extends Transformation
+                    with Desugaring
+                    with Normalization
+                    with PostProcessing 
+                    with ExhaustivenessChecking { self: PreTyper =>
   protected def visitIf(`if`: If)(implicit scope: Scope): Unit =
     trace("visitIf") {
       // Stage 0: Transformation
diff --git a/shared/src/main/scala/mlscript/ucs/stages/ExhaustivenessChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/ExhaustivenessChecking.scala
new file mode 100644
index 0000000000..33b17d886e
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/stages/ExhaustivenessChecking.scala
@@ -0,0 +1,5 @@
+package mlscript.ucs.stages
+
+trait ExhaustivenessChecking { self: mlscript.pretyper.Traceable =>
+  
+}

From 84f98f67d2a76faaaff31e544bae94d0acbf9f40 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 25 Nov 2023 03:36:14 +0800
Subject: [PATCH 003/147] An ineffective attempt on the new post-processing

---
 shared/src/main/scala/mlscript/helpers.scala  |   9 +-
 .../scala/mlscript/pretyper/PreTyper.scala    |   2 +-
 .../main/scala/mlscript/pretyper/Symbol.scala |   6 +-
 shared/src/main/scala/mlscript/syntax.scala   |   2 +-
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |   5 +-
 .../mlscript/ucs/stages/Normalization.scala   |   9 -
 .../mlscript/ucs/stages/PostProcessing.scala  | 176 ++++++-
 .../scala/mlscript/ucs/stages/package.scala   |  11 +-
 .../src/test/diff/pretyper/ucs/DualOption.mls | 446 ++++++++++++++++++
 9 files changed, 627 insertions(+), 39 deletions(-)

diff --git a/shared/src/main/scala/mlscript/helpers.scala b/shared/src/main/scala/mlscript/helpers.scala
index 3285c8d8ec..ce8a9a04d4 100644
--- a/shared/src/main/scala/mlscript/helpers.scala
+++ b/shared/src/main/scala/mlscript/helpers.scala
@@ -1040,6 +1040,13 @@ trait BlkImpl { self: Blk =>
   
 }
 
+trait CaseOfImpl extends Located { self: CaseOf =>
+  def isEmpty: Bool = {
+    val CaseOf(scrut, cases) = this
+    cases === NoCases
+  }
+}
+
 trait CaseBranchesImpl extends Located { self: CaseBranches =>
 
   def children: List[Located] = this match {
@@ -1057,7 +1064,7 @@ trait CaseBranchesImpl extends Located { self: CaseBranches =>
       "_ => " + body.print(false)
     case NoCases => ""
   }
-  
+
 }
 
 trait AdtMatchPatImpl extends Located { self: AdtMatchPat =>
diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index f76c062874..d4444507e1 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -115,7 +115,7 @@ class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Trac
     trace(s"visitFunction <== ${defn.nme.name}") {
       defn.rhs match {
         case Left(term) => 
-          val subScope = if (defn.isLetRec == S(false)) scope else scope + symbol
+          val subScope = if (defn.isLetRec === S(false)) scope else scope + symbol
           visitTerm(term)(subScope)
         case Right(value) => ()
       }
diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index 7cd3d3357f..475c33fc25 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -1,6 +1,6 @@
 package mlscript.pretyper
 
-import collection.mutable.{Buffer, Map => MutMap}
+import collection.mutable.{Buffer, Map => MutMap, Set => MutSet}
 import mlscript.{NuFunDef, NuTypeDef, TypeName, Var}
 import mlscript.utils._, shorthands._
 
@@ -28,6 +28,7 @@ final class FunctionSymbol(val nme: Var, val defn: NuFunDef) extends TermSymbol(
 }
 
 sealed abstract class ScrutineeSymbol(name: Str) extends TermSymbol(name) {
+  val matchedClasses: MutSet[Var] = MutSet.empty
   /**
     * This map contains the sub-scrutinee symbols when this scrutinee is matched
     * against class patterns.
@@ -36,10 +37,11 @@ sealed abstract class ScrutineeSymbol(name: Str) extends TermSymbol(name) {
   val tupleElementScrutineeMap: MutMap[Int, SubValueSymbol] = MutMap.empty
   val recordValueScrutineeMap: MutMap[Var, SubValueSymbol] = MutMap.empty
 
-  def addSubScrutinee(className: Var, index: Int, parameter: Var): SubValueSymbol =
+  def addSubScrutinee(className: Var, index: Int, parameter: Var): SubValueSymbol = {
     classParameterScrutineeMap.getOrElseUpdate(className -> index, {
       new SubValueSymbol(this, S(className) -> S(index), parameter.name)
     })
+  }
 
   def addSubScrutinee(fieldName: Var): SubValueSymbol =
     recordValueScrutineeMap.getOrElseUpdate(fieldName, {
diff --git a/shared/src/main/scala/mlscript/syntax.scala b/shared/src/main/scala/mlscript/syntax.scala
index f33023a395..368faca806 100644
--- a/shared/src/main/scala/mlscript/syntax.scala
+++ b/shared/src/main/scala/mlscript/syntax.scala
@@ -77,7 +77,7 @@ final case class Asc(trm: Term, ty: Type)                            extends Ter
 final case class Bind(lhs: Term, rhs: Term)                          extends Term
 final case class Test(trm: Term, ty: Term)                           extends Term
 final case class With(trm: Term, fields: Rcd)                        extends Term
-final case class CaseOf(trm: Term, cases: CaseBranches)              extends Term
+final case class CaseOf(trm: Term, cases: CaseBranches)              extends Term with CaseOfImpl
 final case class Subs(arr: Term, idx: Term)                          extends Term
 final case class Assign(lhs: Term, rhs: Term)                        extends Term
 final case class Splc(fields: Ls[Either[Term, Fld]])                 extends Term
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index c19d058ceb..051541e614 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -74,8 +74,11 @@ trait DesugarUCS extends Transformation
         case core.Pattern.Name(nme) =>
           nme.symbol = scrutineeSymbol
           nme -> scrutineeSymbol :: Nil
-        case core.Pattern.Class(_, N) => Nil
+        case core.Pattern.Class(nme, N) =>
+          scrutineeSymbol.matchedClasses += nme
+          Nil
         case core.Pattern.Class(nme, S(parameters)) =>
+          scrutineeSymbol.matchedClasses += nme
           parameters.iterator.zipWithIndex.flatMap { 
             case (N, _) => N
             case (S(parameter), index) =>
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 9366223680..623f859668 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -160,15 +160,6 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
 }
 
 object Normalization {
-  private sealed abstract class MatchOrNot {
-    override def toString(): String = this match {
-      case Yes => "+"
-      case No => "-"
-    }
-  }
-  private final case object Yes extends MatchOrNot
-  private final case object No extends MatchOrNot
-
   class NormalizationException(val messages: Ls[Message -> Opt[Loc]]) extends Throwable {
     def this(message: Message, location: Opt[Loc]) = this(message -> location :: Nil)
   }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index ff8c08ccdb..f9ae645e0e 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -1,23 +1,163 @@
 package mlscript.ucs.stages
 
-import mlscript.{Case, CaseOf, Let, NoCases, Term, Var, Wildcard}
-import mlscript.pretyper.{Symbol}
+import mlscript.{Case, CaseOf, Let, Loc, NoCases, Term, Var, Wildcard}
+import mlscript.pretyper.{ScrutineeSymbol, Symbol}
 import mlscript.utils._, shorthands._
 import mlscript.CaseBranches
+import mlscript.Message, Message.MessageContext
+import mlscript.pretyper.shortName
 
 trait PostProcessing { self: mlscript.pretyper.Traceable =>
-  def postProcess(term: Term): Term = trace(s"postProcess <== ${term.describe}") {
+  import PostProcessing._
+
+  def postProcess(term: Term): Term = trace(s"postProcess <== ${shortName(term)}") {
+    // Normalized terms are constructed using `Let` and `CaseOf`.
+    term match {
+      case top @ CaseOf(scrutinee: Var, fst @ Case(className: Var, body, NoCases)) =>
+        println(s"found a UNARY case: $scrutinee is $className")
+        println("post-processing the body")
+        top.copy(cases = fst.copy(body = postProcess(body)))
+      case top @ CaseOf(scrutinee: Var, fst @ Case(className: Var, trueBranch, Wildcard(falseBranch))) =>
+        println(s"found a BINARY case: $scrutinee is $className")
+        val scrutineeSymbol = scrutinee.symbol match {
+          case symbol: ScrutineeSymbol => symbol
+          case _ => throw new PostProcessingException(
+            msg"variable ${scrutinee.name} is not a scrutinee" -> N :: Nil
+          )
+        }
+        println(s"`${scrutinee}`'s matched classes: ${scrutineeSymbol.matchedClasses.iterator.map(_.name).mkString("[", ", ", "]")}")
+        // Post-process the first branch body.
+        println("post-processing the first branch")
+        val processedTrueBranch = postProcess(trueBranch)
+        // Post-process the false branch.
+        val (default, cases) = scrutineeSymbol.matchedClasses.iterator.filter(_ =/= className)
+          // For each case class name, distangle case branch body terms from the false branch.
+          .foldLeft[Opt[Term] -> Ls[Var -> Term]](S(falseBranch) -> Nil) {
+            case ((S(remainingTerm), cases), className) =>
+              val (leftoverTerm, caseBranchBodyTerms) = disentangle(remainingTerm, scrutineeSymbol, className)
+              avoidEmptyCaseOf(leftoverTerm) -> (caseBranchBodyTerms match {
+                case Nil =>
+                  println(s"no case branches about $className were found")
+                  cases
+                case terms @ (head :: tail) => 
+                  println(s"found ${terms.length} case branches about $className")
+                  val body = trace(s"merging terms <== ${terms.iterator.map(shortName).mkString("[", ", ", "]")}") {
+                    tail.foldLeft(head)(mergeTerms)
+                  }(t => s"merging terms ==> ${shortName(t)}")
+                  className -> postProcess(body) :: cases
+              })
+            // TODO: Consider either make the first tuple element as non-optional.
+            // TODO: Then, write a new helper function which checks if the term is an empty `CaseOf`.
+            case ((N, cases), _) => (N, cases) 
+          }
+        println(s"found ${cases.length} cases")
+        // Assemble a `CaseBranches`.
+        val actualFalseBranch = cases.foldRight[CaseBranches](
+          default.fold[CaseBranches](NoCases)(Wildcard(_))
+        ) { case (className -> body, rest) => Case(className, body, rest) }
+        // Assemble the final `CaseOf`.
+        top.copy(cases = fst.copy(body = processedTrueBranch, rest = actualFalseBranch))
+      // We recursively process the body of as`Let` bindings.
+      case let @ Let(_, _, _, body) => let.copy(body = postProcess(body))
+      // Otherwise, this is not a part of a normalized term.
+      case other => println(s"CANNOT post-process"); other
+    }
+  }(_ => "postProcess ==> ")
+
+  private def avoidEmptyCaseOf(term: Term): Opt[Term] = term match {
+    case CaseOf(_, NoCases) => println(s"$term is empty"); N
+    case _ => S(term)
+  }
+
+  private def mergeTerms(t1: Term, t2: Term): Term =
+    trace(s"mergeTerms <== ${t1.describe} ${t2.describe}") {
+      t1 match {
+        case t1 @ Let(_, _, _, body) => t1.copy(body = mergeTerms(body, t2))
+        case t1 @ CaseOf(scrutinee: Var, cases) =>
+          t1.copy(cases = mergeTermIntoCaseBranches(t2, cases))
+        case _ => println("CANNOT merge. Discard t2."); t1
+      }
+    }()
+
+  private def mergeTermIntoCaseBranches(term: Term, cases: CaseBranches): CaseBranches =
+    trace(s"mergeTermIntoCaseBranches <== ${term.describe} ${cases}") {
+      cases match {
+        case NoCases => Wildcard(term).withLocOf(term)
+        case Wildcard(body) => Wildcard(mergeTerms(body, term))
+        case cases @ Case(_, _, rest) => cases.copy(rest = mergeTermIntoCaseBranches(term, rest))
+      }
+    }()
+
+  /**
+    * Disentangle case branches that match `scrutinee` against `className` from `term`.
+    * The `term` should be obtained from _normalization_. Because there may exists multiple
+    * `CaseOf`s which contains such case branches, we return a list of disentangled terms.
+    *
+    * @param term the term to disentangle from
+    * @param scrutinee the symbol of the scrutinee variable
+    * @param className the class name
+    * @return the remaining term and the disentangled case branch body terms
+    */
+  def disentangle(term: Term, scrutinee: ScrutineeSymbol, className: Var): (Term, Ls[Term]) =
+    trace[(Term, Ls[Term])](s"disentangle <== ${scrutinee.name}: $className") {
+      term match {
+        case top @ CaseOf(scrutineeVar: Var, cases) =>
+          if (scrutineeVar.symbol match {
+            case s: ScrutineeSymbol => s === scrutinee; case _ => false
+          }) {
+            println(s"found a `CaseOf` that matches on ${scrutinee.name}")
+            def rec(cases: CaseBranches): (CaseBranches, Ls[Term]) = cases match {
+              case NoCases => println("found the end, stop"); NoCases -> Nil
+              case wildcard @ Wildcard(body) =>
+                println("found a wildcard, stop")
+                val (y, ns) = disentangle(body, scrutinee, className)
+                wildcard.copy(body = y) -> ns
+              case kase @ Case(`className`, body, rest) =>
+                println(s"found a case branch matching against $className")
+                val (y, ns) = rec(rest)
+                y -> (ns :+ body)
+              case kase @ Case(otherClassName, body, rest) =>
+                val (y, ns) = rec(rest)
+                kase.copy(rest = y) -> ns
+            }
+            val (y, ns) = rec(cases)
+            top.copy(cases = y) -> ns
+          } else {
+            println(s"found a `CaseOf` that does NOT match on ${scrutinee.name}")
+            def rec(cases: CaseBranches): (CaseBranches, Ls[Term]) = cases match {
+              case NoCases => println("found the end, stop"); NoCases -> Nil
+              case wildcard @ Wildcard(body) =>
+                println("found a wildcard, stop")
+                val (y, ns) = disentangle(body, scrutinee, className)
+                wildcard.copy(body = y) -> ns
+              case kase @ Case(_, body, rest) =>
+                println(s"found a case branch")
+                val (y1, ns1) = disentangle(body, scrutinee, className)
+                val (y2, ns) = rec(rest)
+                kase.copy(body = y1, rest = y2) -> (ns1 ++ ns)
+            }
+            val (y, ns) = rec(cases)
+            top.copy(cases = y) -> ns
+          }
+        case let @ Let(_, _, _, body) =>
+          val (y, ns) = disentangle(body, scrutinee, className)
+          let.copy(body = y) -> ns
+        case other => println(s"CANNOT disentangle"); other -> Nil
+      }
+    }({ case (y, ns) => s"disentangle ==> `${y}` ${ns.length}" })
+
+  def cascadeConsecutiveCaseOf(term: Term): Term = trace(s"cascade consecutive CaseOf <== ${term.describe}") {
     // Normalized terms are constructed using `Let` and `CaseOf`.
     term match {
       case top @ CaseOf(scrutinee: Var, fst @ Case(pattern, body, NoCases)) =>
         println(s"found a UNARY case: $scrutinee is $pattern")
-        top.copy(cases = fst.copy(body = postProcess(body)))
+        top.copy(cases = fst.copy(body = cascadeConsecutiveCaseOf(body)))
       case top @ CaseOf(scrutinee: Var, fst @ Case(pattern, trueBranch, snd @ Wildcard(falseBranch))) =>
         println(s"found a BINARY case: $scrutinee is $pattern")
-        println("post-processing the true branch")
-        val processedTrueBranch = postProcess(trueBranch)
-        println("post-processing the false branch")
-        val processedFalseBranch = postProcess(falseBranch)
+        println("cascading the true branch")
+        val processedTrueBranch = cascadeConsecutiveCaseOf(trueBranch)
+        println("cascading the false branch")
+        val processedFalseBranch = cascadeConsecutiveCaseOf(falseBranch)
         // Check if the false branch is another `CaseOf` with the same scrutinee.
         processedFalseBranch match {
           case CaseOf(otherScrutinee: Var, actualFalseBranch) =>
@@ -36,25 +176,15 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
           case other => top
         }
       // We recursively process the body of `Let` bindings.
-      case let @ Let(_, _, _, body) => let.copy(body = postProcess(body))
+      case let @ Let(_, _, _, body) => let.copy(body = cascadeConsecutiveCaseOf(body))
       // Otherwise, this is not a part of a normalized term.
-      case other => println(s"CANNOT post-process"); other
+      case other => println(s"CANNOT cascade"); other
     }
   }()
-
-  private def hasScrutinee(term: Term, symbol: Symbol): Bool = {
-    term match {
-      case CaseOf(scrutinee: Var, Case(pattern, trueBranch, Wildcard(falseBranch))) =>
-        if (scrutinee.symbolOption.exists(_ === symbol)) true
-        else hasScrutinee(trueBranch, symbol) || hasScrutinee(falseBranch, symbol)
-      case Let(_, _, _, body) => hasScrutinee(body, symbol)
-      case _ => false
-    }
-  }
-
-  private def separateCaseBranches(term: Term)(implicit scrutinee: Symbol): (CaseBranches, Term) = ???
 }
 
 object PostProcessing {
-
+  class PostProcessingException(val messages: Ls[Message -> Opt[Loc]]) extends Throwable {
+    def this(message: Message, location: Opt[Loc]) = this(message -> location :: Nil)
+  }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/package.scala b/shared/src/main/scala/mlscript/ucs/stages/package.scala
index c0d7c81f41..d1c5c2fbe2 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/package.scala
@@ -4,4 +4,13 @@ import mlscript.{Term, Var}
 import mlscript.pretyper.Symbol
 import mlscript.utils._, shorthands._
 
-package object stages
+package object stages {
+  private[stages] sealed abstract class MatchOrNot {
+    override def toString(): String = this match {
+      case Yes => "+"
+      case No => "-"
+    }
+  }
+  private[stages] final case object Yes extends MatchOrNot
+  private[stages] final case object No extends MatchOrNot
+}
diff --git a/shared/src/test/diff/pretyper/ucs/DualOption.mls b/shared/src/test/diff/pretyper/ucs/DualOption.mls
index 2ebf1e7530..9b24553510 100644
--- a/shared/src/test/diff/pretyper/ucs/DualOption.mls
+++ b/shared/src/test/diff/pretyper/ucs/DualOption.mls
@@ -58,6 +58,7 @@ add_2(Some(5), Some(9))
 //│ res
 //│     = 14
 
+
 fun add_3(x, y) =
   if Pair(x, y) is
     Pair(Some(xv), Some(yv)) then xv + yv
@@ -80,6 +81,7 @@ add_3(Some(5), Some(9))
 //│ res
 //│     = 14
 
+
 fun add_4(x, y) =
   if
     x
@@ -98,6 +100,7 @@ fun add_4(x, y) =
               None     then 0
 //│ fun add_4: forall 'a. (None | Some[Int], None | Some[Int & 'a]) -> (Int | 'a)
 
+
 add_4(None, None)
 add_4(Some(5), None)
 add_4(None, Some(9))
@@ -112,12 +115,455 @@ add_4(Some(5), Some(9))
 //│ res
 //│     = 14
 
+:dpt
 fun add_5(x, y) =
   if
     x is Some(xv) and y is Some(yv) then xv + yv
     y is None     and x is Some(xv) then xv
     x is None     and y is Some(yv) then yv
     y is None     and x is None     then 0
+//│ process <== <root>: {fun add_5}
+//│ | visitTypingUnit <== <root>: {fun add_5}
+//│ | | 1. scope = {add_5}
+//│ | | 2. scope = {add_5}
+//│ | | visitFunction <== add_5
+//│ | | | visitTerm <== Lam(_, _)
+//│ | | | | visitTerm <== Blk(_)
+//│ | | | | | visitTerm <== If(_)
+//│ | | | | | | visitIf
+//│ | | | | | | | Transformed UCS term:
+//│ | | | | | | | if
+//│ | | | | | | |   x is Some(xv) and y is Some(yv) then +(xv, yv,)
+//│ | | | | | | |   y is None and x is Some(xv) then xv
+//│ | | | | | | |   x is None and y is Some(yv) then yv
+//│ | | | | | | |   y is None and x is None then 0
+//│ | | | | | | | Desugared UCS term:
+//│ | | | | | | | if
+//│ | | | | | | |   x is Some(xv) y is Some(yv) then +(xv, yv,)
+//│ | | | | | | |   y is None x is Some(xv) then xv
+//│ | | | | | | |   x is None y is Some(yv) then yv
+//│ | | | | | | |   y is None x is None then 0
+//│ | | | | | | | visitSplit <== [add_5, x, y]
+//│ | | | | | | | | found branch: x is Some(xv)
+//│ | | | | | | | | visitTerm <== Var("x")
+//│ | | | | | | | | | visitVar(name = "x")
+//│ | | | | | | | | | | resolveVar(name = "x")
+//│ | | | | | | | | visitTerm ==> Var("x")
+//│ | | | | | | | | visitPattern <== Some(xv)
+//│ | | | | | | | | visitPattern ==> [xv]
+//│ | | | | | | | | visitSplit <== [add_5, x, y, xv]
+//│ | | | | | | | | | found branch: y is Some(yv)
+//│ | | | | | | | | | visitTerm <== Var("y")
+//│ | | | | | | | | | | visitVar(name = "y")
+//│ | | | | | | | | | | | resolveVar(name = "y")
+//│ | | | | | | | | | visitTerm ==> Var("y")
+//│ | | | | | | | | | visitPattern <== Some(yv)
+//│ | | | | | | | | | visitPattern ==> [yv]
+//│ | | | | | | | | | visitSplit <== [x, y, add_5, xv, yv]
+//│ | | | | | | | | | | visitTerm <== App(_, _)
+//│ | | | | | | | | | | | visitTerm <== Var("+")
+//│ | | | | | | | | | | | | visitVar(name = "+")
+//│ | | | | | | | | | | | | | resolveVar(name = "+")
+//│ | | | | | | | | | | | visitTerm ==> Var("+")
+//│ | | | | | | | | | | | visitTerm <== Tup(_, _)
+//│ | | | | | | | | | | | | visitTerm <== Var("xv")
+//│ | | | | | | | | | | | | | visitVar(name = "xv")
+//│ | | | | | | | | | | | | | | resolveVar(name = "xv")
+//│ | | | | | | | | | | | | visitTerm ==> Var("xv")
+//│ | | | | | | | | | | | | visitTerm <== Var("yv")
+//│ | | | | | | | | | | | | | visitVar(name = "yv")
+//│ | | | | | | | | | | | | | | resolveVar(name = "yv")
+//│ | | | | | | | | | | | | visitTerm ==> Var("yv")
+//│ | | | | | | | | | | | visitTerm ==> Tup(_, _)
+//│ | | | | | | | | | | visitTerm ==> App(_, _)
+//│ | | | | | | | | | visitSplit <== [add_5, x, y, xv]
+//│ | | | | | | | | | | the end
+//│ | | | | | | | | visitSplit <== [add_5, x, y]
+//│ | | | | | | | | | found branch: y is None
+//│ | | | | | | | | | visitTerm <== Var("y")
+//│ | | | | | | | | | | visitVar(name = "y")
+//│ | | | | | | | | | | | resolveVar(name = "y")
+//│ | | | | | | | | | visitTerm ==> Var("y")
+//│ | | | | | | | | | visitPattern <== None
+//│ | | | | | | | | | visitPattern ==> []
+//│ | | | | | | | | | visitSplit <== [add_5, x, y]
+//│ | | | | | | | | | | found branch: x is Some(xv)
+//│ | | | | | | | | | | visitTerm <== Var("x")
+//│ | | | | | | | | | | | visitVar(name = "x")
+//│ | | | | | | | | | | | | resolveVar(name = "x")
+//│ | | | | | | | | | | visitTerm ==> Var("x")
+//│ | | | | | | | | | | visitPattern <== Some(xv)
+//│ | | | | | | | | | | visitPattern ==> [xv]
+//│ | | | | | | | | | | visitSplit <== [add_5, x, y, xv]
+//│ | | | | | | | | | | | visitTerm <== Var("xv")
+//│ | | | | | | | | | | | | visitVar(name = "xv")
+//│ | | | | | | | | | | | | | resolveVar(name = "xv")
+//│ | | | | | | | | | | | visitTerm ==> Var("xv")
+//│ | | | | | | | | | | visitSplit <== [add_5, x, y]
+//│ | | | | | | | | | | | the end
+//│ | | | | | | | | | visitSplit <== [add_5, x, y]
+//│ | | | | | | | | | | found branch: x is None
+//│ | | | | | | | | | | visitTerm <== Var("x")
+//│ | | | | | | | | | | | visitVar(name = "x")
+//│ | | | | | | | | | | | | resolveVar(name = "x")
+//│ | | | | | | | | | | visitTerm ==> Var("x")
+//│ | | | | | | | | | | visitPattern <== None
+//│ | | | | | | | | | | visitPattern ==> []
+//│ | | | | | | | | | | visitSplit <== [add_5, x, y]
+//│ | | | | | | | | | | | found branch: y is Some(yv)
+//│ | | | | | | | | | | | visitTerm <== Var("y")
+//│ | | | | | | | | | | | | visitVar(name = "y")
+//│ | | | | | | | | | | | | | resolveVar(name = "y")
+//│ | | | | | | | | | | | visitTerm ==> Var("y")
+//│ | | | | | | | | | | | visitPattern <== Some(yv)
+//│ | | | | | | | | | | | visitPattern ==> [yv]
+//│ | | | | | | | | | | | visitSplit <== [add_5, x, y, yv]
+//│ | | | | | | | | | | | | visitTerm <== Var("yv")
+//│ | | | | | | | | | | | | | visitVar(name = "yv")
+//│ | | | | | | | | | | | | | | resolveVar(name = "yv")
+//│ | | | | | | | | | | | | visitTerm ==> Var("yv")
+//│ | | | | | | | | | | | visitSplit <== [add_5, x, y]
+//│ | | | | | | | | | | | | the end
+//│ | | | | | | | | | | visitSplit <== [add_5, x, y]
+//│ | | | | | | | | | | | found branch: y is None
+//│ | | | | | | | | | | | visitTerm <== Var("y")
+//│ | | | | | | | | | | | | visitVar(name = "y")
+//│ | | | | | | | | | | | | | resolveVar(name = "y")
+//│ | | | | | | | | | | | visitTerm ==> Var("y")
+//│ | | | | | | | | | | | visitPattern <== None
+//│ | | | | | | | | | | | visitPattern ==> []
+//│ | | | | | | | | | | | visitSplit <== [add_5, x, y]
+//│ | | | | | | | | | | | | found branch: x is None
+//│ | | | | | | | | | | | | visitTerm <== Var("x")
+//│ | | | | | | | | | | | | | visitVar(name = "x")
+//│ | | | | | | | | | | | | | | resolveVar(name = "x")
+//│ | | | | | | | | | | | | visitTerm ==> Var("x")
+//│ | | | | | | | | | | | | visitPattern <== None
+//│ | | | | | | | | | | | | visitPattern ==> []
+//│ | | | | | | | | | | | | visitSplit <== [add_5, x, y]
+//│ | | | | | | | | | | | | | visitTerm <== 0
+//│ | | | | | | | | | | | | | visitTerm ==> 0
+//│ | | | | | | | | | | | | visitSplit <== [add_5, x, y]
+//│ | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | visitSplit <== [add_5, x, y]
+//│ | | | | | | | | | | | | the end
+//│ | | | | | | | normalizeToTerm
+//│ | | | | | | | | match x with Some(xv)
+//│ | | | | | | | | compute true branch
+//│ | | | | | | | | | S+ <== x is Some(xv)
+//│ | | | | | | | | | | scrutinee: x =/= y
+//│ | | | | | | | | | | S+ <== x is Some(xv)
+//│ | | | | | | | | | | | the end
+//│ | | | | | | | | | | S+ ==> then +(xv, yv,)
+//│ | | | | | | | | | | specialized next
+//│ | | | | | | | | | | S+ <== x is Some(xv)
+//│ | | | | | | | | | | | scrutinee: x =/= y
+//│ | | | | | | | | | | | S+ <== x is Some(xv)
+//│ | | | | | | | | | | | | scrutinee: x === x
+//│ | | | | | | | | | | | | class name: Some === Some
+//│ | | | | | | | | | | | | S+ <== x is Some(xv)
+//│ | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | S+ ==> then xv
+//│ | | | | | | | | | | | S+ ==> then xv
+//│ | | | | | | | | | | | specialized next
+//│ | | | | | | | | | | | S+ <== x is Some(xv)
+//│ | | | | | | | | | | | | scrutinee: x === x
+//│ | | | | | | | | | | | | class name: Some =/= None
+//│ | | | | | | | | | | | | specialized next
+//│ | | | | | | | | | | | | S+ <== x is Some(xv)
+//│ | | | | | | | | | | | | | scrutinee: x =/= y
+//│ | | | | | | | | | | | | | S+ <== x is Some(xv)
+//│ | | | | | | | | | | | | | | scrutinee: x === x
+//│ | | | | | | | | | | | | | | class name: Some =/= None
+//│ | | | | | | | | | | | | | | specialized next
+//│ | | | | | | | | | | | | | | S+ <== x is Some(xv)
+//│ | | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | | S+ ==>
+//│ | | | | | | | | | | | | | S+ ==>
+//│ | | | | | | | | | | | | | specialized next
+//│ | | | | | | | | | | | | | S+ <== x is Some(xv)
+//│ | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | S+ ==>
+//│ | | | | | | | | | | | | S+ ==> y is None
+//│ | | | | | | | | | | | S+ ==> y is None
+//│ | | | | | | | | | | S+ ==>
+//│ | | | | | | | | | |   y is None then xv
+//│ | | | | | | | | | |   y is None
+//│ | | | | | | | | | S+ ==>
+//│ | | | | | | | | |   y is Some(yv) then +(xv, yv,)
+//│ | | | | | | | | |   y is None then xv
+//│ | | | | | | | | |   y is None
+//│ | | | | | | | | | normalizeToTerm
+//│ | | | | | | | | | | match y with Some(yv)
+//│ | | | | | | | | | | compute true branch
+//│ | | | | | | | | | | | S+ <== y is Some(yv)
+//│ | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | S+ ==> then +(xv, yv,)
+//│ | | | | | | | | | | | normalizeToTerm
+//│ | | | | | | | | | | compute false branch
+//│ | | | | | | | | | | | S- <== y is Some(yv)
+//│ | | | | | | | | | | | | scrutinee: y === y
+//│ | | | | | | | | | | | | class name: Some =/= None
+//│ | | | | | | | | | | | | S- <== y is Some(yv)
+//│ | | | | | | | | | | | | | scrutinee: y === y
+//│ | | | | | | | | | | | | | class name: Some =/= None
+//│ | | | | | | | | | | | | | S- <== y is Some(yv)
+//│ | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | S- ==>
+//│ | | | | | | | | | | | | S- ==> y is None
+//│ | | | | | | | | | | | S- ==>
+//│ | | | | | | | | | | |   y is None then xv
+//│ | | | | | | | | | | |   y is None
+//│ | | | | | | | | | | | normalizeToCaseBranches
+//│ | | | | | | | | | | | | normalizeToTerm
+//│ | | | | | | | | | | | | | match y with None
+//│ | | | | | | | | | | | | | S+ <== y is None
+//│ | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | S+ ==> then xv
+//│ | | | | | | | | | | | | | normalizeToTerm
+//│ | | | | | | | | | | | | | S- <== y is None
+//│ | | | | | | | | | | | | | | scrutinee: y === y
+//│ | | | | | | | | | | | | | | class name: None === None
+//│ | | | | | | | | | | | | | | S- <== y is None
+//│ | | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | | S- ==>
+//│ | | | | | | | | | | | | | S- ==>
+//│ | | | | | | | | | | | | | normalizeToCaseBranches
+//│ | | | | | | | | compute false branch
+//│ | | | | | | | | | S- <== x is Some(xv)
+//│ | | | | | | | | | | scrutinee: x =/= y
+//│ | | | | | | | | | | S- <== x is Some(xv)
+//│ | | | | | | | | | | | scrutinee: x === x
+//│ | | | | | | | | | | | class name: Some === Some
+//│ | | | | | | | | | | | S- <== x is Some(xv)
+//│ | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | S- ==>
+//│ | | | | | | | | | | S- ==>
+//│ | | | | | | | | | | S- <== x is Some(xv)
+//│ | | | | | | | | | | | scrutinee: x === x
+//│ | | | | | | | | | | | class name: Some =/= None
+//│ | | | | | | | | | | | S- <== x is Some(xv)
+//│ | | | | | | | | | | | | scrutinee: x =/= y
+//│ | | | | | | | | | | | | S- <== x is Some(xv)
+//│ | | | | | | | | | | | | | scrutinee: x === x
+//│ | | | | | | | | | | | | | class name: Some =/= None
+//│ | | | | | | | | | | | | | S- <== x is Some(xv)
+//│ | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | S- ==>
+//│ | | | | | | | | | | | | S- ==> x is None then 0
+//│ | | | | | | | | | | | | S- <== x is Some(xv)
+//│ | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | S- ==>
+//│ | | | | | | | | | | | S- ==> y is None x is None then 0
+//│ | | | | | | | | | | S- ==>
+//│ | | | | | | | | | |   x is None y is Some(yv) then yv
+//│ | | | | | | | | | |   y is None x is None then 0
+//│ | | | | | | | | | S- ==>
+//│ | | | | | | | | |   y is None
+//│ | | | | | | | | |   x is None y is Some(yv) then yv
+//│ | | | | | | | | |   y is None x is None then 0
+//│ | | | | | | | | | normalizeToCaseBranches
+//│ | | | | | | | | | | normalizeToTerm
+//│ | | | | | | | | | | | match y with None
+//│ | | | | | | | | | | | S+ <== y is None
+//│ | | | | | | | | | | | | scrutinee: y =/= x
+//│ | | | | | | | | | | | | S+ <== y is None
+//│ | | | | | | | | | | | | | scrutinee: y === y
+//│ | | | | | | | | | | | | | class name: None =/= Some
+//│ | | | | | | | | | | | | | specialized next
+//│ | | | | | | | | | | | | | S+ <== y is None
+//│ | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | S+ ==>
+//│ | | | | | | | | | | | | S+ ==>
+//│ | | | | | | | | | | | | specialized next
+//│ | | | | | | | | | | | | S+ <== y is None
+//│ | | | | | | | | | | | | | scrutinee: y === y
+//│ | | | | | | | | | | | | | class name: None === None
+//│ | | | | | | | | | | | | | S+ <== y is None
+//│ | | | | | | | | | | | | | | scrutinee: y =/= x
+//│ | | | | | | | | | | | | | | S+ <== y is None
+//│ | | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | | S+ ==> then 0
+//│ | | | | | | | | | | | | | | specialized next
+//│ | | | | | | | | | | | | | | S+ <== y is None
+//│ | | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | | S+ ==>
+//│ | | | | | | | | | | | | | S+ ==> x is None then 0
+//│ | | | | | | | | | | | | S+ ==> x is None then 0
+//│ | | | | | | | | | | | S+ ==>
+//│ | | | | | | | | | | |   x is None
+//│ | | | | | | | | | | |   x is None then 0
+//│ | | | | | | | | | | | normalizeToTerm
+//│ | | | | | | | | | | | | match x with None
+//│ | | | | | | | | | | | | S+ <== x is None
+//│ | | | | | | | | | | | | | scrutinee: x === x
+//│ | | | | | | | | | | | | | class name: None === None
+//│ | | | | | | | | | | | | | S+ <== x is None
+//│ | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | S+ ==> then 0
+//│ | | | | | | | | | | | | S+ ==> then 0
+//│ | | | | | | | | | | | | normalizeToTerm
+//│ | | | | | | | | | | | | S- <== x is None
+//│ | | | | | | | | | | | | | scrutinee: x === x
+//│ | | | | | | | | | | | | | class name: None === None
+//│ | | | | | | | | | | | | | S- <== x is None
+//│ | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | S- ==>
+//│ | | | | | | | | | | | | S- ==>
+//│ | | | | | | | | | | | | normalizeToCaseBranches
+//│ | | | | | | | | | | | S- <== y is None
+//│ | | | | | | | | | | | | scrutinee: y =/= x
+//│ | | | | | | | | | | | | S- <== y is None
+//│ | | | | | | | | | | | | | scrutinee: y === y
+//│ | | | | | | | | | | | | | class name: None =/= Some
+//│ | | | | | | | | | | | | | S- <== y is None
+//│ | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | S- ==>
+//│ | | | | | | | | | | | | S- ==> y is Some(yv) then yv
+//│ | | | | | | | | | | | | S- <== y is None
+//│ | | | | | | | | | | | | | scrutinee: y === y
+//│ | | | | | | | | | | | | | class name: None === None
+//│ | | | | | | | | | | | | | S- <== y is None
+//│ | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | S- ==>
+//│ | | | | | | | | | | | | S- ==>
+//│ | | | | | | | | | | | S- ==> x is None y is Some(yv) then yv
+//│ | | | | | | | | | | | normalizeToCaseBranches
+//│ | | | | | | | | | | | | normalizeToTerm
+//│ | | | | | | | | | | | | | match x with None
+//│ | | | | | | | | | | | | | S+ <== x is None
+//│ | | | | | | | | | | | | | | scrutinee: x =/= y
+//│ | | | | | | | | | | | | | | S+ <== x is None
+//│ | | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | | S+ ==> then yv
+//│ | | | | | | | | | | | | | | specialized next
+//│ | | | | | | | | | | | | | | S+ <== x is None
+//│ | | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | | S+ ==>
+//│ | | | | | | | | | | | | | S+ ==> y is Some(yv) then yv
+//│ | | | | | | | | | | | | | normalizeToTerm
+//│ | | | | | | | | | | | | | | match y with Some(yv)
+//│ | | | | | | | | | | | | | | compute true branch
+//│ | | | | | | | | | | | | | | | S+ <== y is Some(yv)
+//│ | | | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | | | S+ ==> then yv
+//│ | | | | | | | | | | | | | | | normalizeToTerm
+//│ | | | | | | | | | | | | | | compute false branch
+//│ | | | | | | | | | | | | | | | S- <== y is Some(yv)
+//│ | | | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | | | S- ==>
+//│ | | | | | | | | | | | | | | | normalizeToCaseBranches
+//│ | | | | | | | | | | | | | S- <== x is None
+//│ | | | | | | | | | | | | | | the end
+//│ | | | | | | | | | | | | | S- ==>
+//│ | | | | | | | | | | | | | normalizeToCaseBranches
+//│ | | | | | | | Normalized UCS term:
+//│ | | | | | | | x match
+//│ | | | | | | |   case Some =>
+//│ | | | | | | |     let args_x$Some = (Some).unapply(x,)
+//│ | | | | | | |     let xv* = (args_x$Some).0
+//│ | | | | | | |     y match
+//│ | | | | | | |       case Some =>
+//│ | | | | | | |         let args_y$Some = (Some).unapply(y,)
+//│ | | | | | | |         let yv* = (args_y$Some).0
+//│ | | | | | | |         +(xv, yv,)
+//│ | | | | | | |       case _ =>
+//│ | | | | | | |         y match
+//│ | | | | | | |           case None => xv
+//│ | | | | | | |   case _ =>
+//│ | | | | | | |     y match
+//│ | | | | | | |       case None =>
+//│ | | | | | | |         x match
+//│ | | | | | | |           case None => 0
+//│ | | | | | | |       case _ =>
+//│ | | | | | | |         x match
+//│ | | | | | | |           case None =>
+//│ | | | | | | |             y match
+//│ | | | | | | |               case Some =>
+//│ | | | | | | |                 let args_y$Some = (Some).unapply(y,)
+//│ | | | | | | |                 let yv* = (args_y$Some).0
+//│ | | | | | | |                 yv
+//│ | | | | | | | postProcess <== CaseOf(_, _)
+//│ | | | | | | | | found a BINARY case: x is Some
+//│ | | | | | | | | `x`'s matched classes: [None, Some]
+//│ | | | | | | | | post-processing the first branch
+//│ | | | | | | | | postProcess <== Let(_, _)
+//│ | | | | | | | | | postProcess <== Let(_, _)
+//│ | | | | | | | | | | postProcess <== CaseOf(_, _)
+//│ | | | | | | | | | | | found a BINARY case: y is Some
+//│ | | | | | | | | | | | `y`'s matched classes: [None, Some]
+//│ | | | | | | | | | | | post-processing the first branch
+//│ | | | | | | | | | | | postProcess <== Let(_, _)
+//│ | | | | | | | | | | | | postProcess <== Let(_, _)
+//│ | | | | | | | | | | | | | postProcess <== App(_, _)
+//│ | | | | | | | | | | | | | | CANNOT post-process
+//│ | | | | | | | | | | | | | postProcess ==> 
+//│ | | | | | | | | | | | | postProcess ==> 
+//│ | | | | | | | | | | | postProcess ==> 
+//│ | | | | | | | | | | | disentangle <== y: None
+//│ | | | | | | | | | | | | found a `CaseOf` that matches on y
+//│ | | | | | | | | | | | | found a case branch matching against None
+//│ | | | | | | | | | | | | found the end, stop
+//│ | | | | | | | | | | | disentangle ==> `case y of {  }` 1
+//│ | | | | | | | | | | | case y of {  } is empty
+//│ | | | | | | | | | | | found 1 case branches about None
+//│ | | | | | | | | | | | merging terms <== [Var("xv")]
+//│ | | | | | | | | | | | merging terms ==> Var("xv")
+//│ | | | | | | | | | | | postProcess <== Var("xv")
+//│ | | | | | | | | | | | | CANNOT post-process
+//│ | | | | | | | | | | | postProcess ==> 
+//│ | | | | | | | | | | | found 1 cases
+//│ | | | | | | | | | | postProcess ==> 
+//│ | | | | | | | | | postProcess ==> 
+//│ | | | | | | | | postProcess ==> 
+//│ | | | | | | | | disentangle <== x: None
+//│ | | | | | | | | | found a `CaseOf` that does NOT match on x
+//│ | | | | | | | | | found a case branch
+//│ | | | | | | | | | disentangle <== x: None
+//│ | | | | | | | | | | found a `CaseOf` that matches on x
+//│ | | | | | | | | | | found a case branch matching against None
+//│ | | | | | | | | | | found the end, stop
+//│ | | | | | | | | | disentangle ==> `case x of {  }` 1
+//│ | | | | | | | | | found a wildcard, stop
+//│ | | | | | | | | | disentangle <== x: None
+//│ | | | | | | | | | | found a `CaseOf` that matches on x
+//│ | | | | | | | | | | found a case branch matching against None
+//│ | | | | | | | | | | found the end, stop
+//│ | | | | | | | | | disentangle ==> `case x of {  }` 1
+//│ | | | | | | | | disentangle ==> `case y of { None => case x of {  }; _ => case x of {  } }` 2
+//│ | | | | | | | | found 2 case branches about None
+//│ | | | | | | | | merging terms <== [0, CaseOf(_, _)]
+//│ | | | | | | | | | mergeTerms <== integer literal `case` expression
+//│ | | | | | | | | | | CANNOT merge. Discard t2.
+//│ | | | | | | | | merging terms ==> 0
+//│ | | | | | | | | postProcess <== 0
+//│ | | | | | | | | | CANNOT post-process
+//│ | | | | | | | | postProcess ==> 
+//│ | | | | | | | | found 1 cases
+//│ | | | | | | | postProcess ==> 
+//│ | | | | | | | Post-processed UCS term:
+//│ | | | | | | | x match
+//│ | | | | | | |   case Some =>
+//│ | | | | | | |     let args_x$Some = (Some).unapply(x,)
+//│ | | | | | | |     let xv* = (args_x$Some).0
+//│ | | | | | | |     y match
+//│ | | | | | | |       case Some =>
+//│ | | | | | | |         let args_y$Some = (Some).unapply(y,)
+//│ | | | | | | |         let yv* = (args_y$Some).0
+//│ | | | | | | |         +(xv, yv,)
+//│ | | | | | | |       case None => xv
+//│ | | | | | | |   case None => 0
+//│ | | | | | | |   case _ =>
+//│ | | | | | | |     y match
+//│ | | | | | | |       case None => x match
+//│ | | | | | | |       case _ => x match
+//│ | | | | | | visitIf ==> ()
+//│ | | | | | visitTerm ==> If(_)
+//│ | | | | visitTerm ==> Blk(_)
+//│ | | | visitTerm ==> Lam(_, _)
+//│ | | visitFunction ==> add_5
+//│ | visitTypingUnit ==> add_5
+//│ process ==> add_5
 //│ fun add_5: forall 'a. (None | Some[Int], None | Some[Int & 'a]) -> (Int | 'a)
 
 add_5(None, None)

From a08eba62a1cac83407b740b566c72bd55274b8d2 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 25 Nov 2023 04:25:55 +0800
Subject: [PATCH 004/147] Fix the disentanglement of case branches in
 post-processing

---
 .../mlscript/ucs/stages/PostProcessing.scala  |  86 ++--
 .../src/test/diff/pretyper/ucs/DualOption.mls | 444 +-----------------
 2 files changed, 50 insertions(+), 480 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index f9ae645e0e..51a0bce008 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -6,6 +6,7 @@ import mlscript.utils._, shorthands._
 import mlscript.CaseBranches
 import mlscript.Message, Message.MessageContext
 import mlscript.pretyper.shortName
+import scala.annotation.tailrec
 
 trait PostProcessing { self: mlscript.pretyper.Traceable =>
   import PostProcessing._
@@ -34,17 +35,14 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
           // For each case class name, distangle case branch body terms from the false branch.
           .foldLeft[Opt[Term] -> Ls[Var -> Term]](S(falseBranch) -> Nil) {
             case ((S(remainingTerm), cases), className) =>
-              val (leftoverTerm, caseBranchBodyTerms) = disentangle(remainingTerm, scrutineeSymbol, className)
-              avoidEmptyCaseOf(leftoverTerm) -> (caseBranchBodyTerms match {
-                case Nil =>
-                  println(s"no case branches about $className were found")
+              val (leftoverTerm, extracted) = disentangle(remainingTerm, scrutineeSymbol, className)
+              avoidEmptyCaseOf(leftoverTerm) -> (extracted match {
+                case N =>
+                  println(s"no extracted term about $className")
                   cases
-                case terms @ (head :: tail) => 
-                  println(s"found ${terms.length} case branches about $className")
-                  val body = trace(s"merging terms <== ${terms.iterator.map(shortName).mkString("[", ", ", "]")}") {
-                    tail.foldLeft(head)(mergeTerms)
-                  }(t => s"merging terms ==> ${shortName(t)}")
-                  className -> postProcess(body) :: cases
+                case terms @ S(extractedTerm) => 
+                  println(s"extracted a term about $className")
+                  className -> postProcess(extractedTerm) :: cases
               })
             // TODO: Consider either make the first tuple element as non-optional.
             // TODO: Then, write a new helper function which checks if the term is an empty `CaseOf`.
@@ -66,6 +64,15 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
 
   private def avoidEmptyCaseOf(term: Term): Opt[Term] = term match {
     case CaseOf(_, NoCases) => println(s"$term is empty"); N
+    case CaseOf(_, cases: Case) =>
+      @tailrec
+      def containsNoWildcard(cases: CaseBranches): Bool = cases match {
+        case NoCases => true
+        case Wildcard(_) => false
+        case Case(_, body, rest) =>
+          avoidEmptyCaseOf(body) === N && containsNoWildcard(rest)
+      }
+      if (containsNoWildcard(cases)) S(term) else N
     case _ => S(term)
   }
 
@@ -91,60 +98,65 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
   /**
     * Disentangle case branches that match `scrutinee` against `className` from `term`.
     * The `term` should be obtained from _normalization_. Because there may exists multiple
-    * `CaseOf`s which contains such case branches, we return a list of disentangled terms.
+    * `CaseOf`s which contains such case branches, we merge them on the fly.
     *
     * @param term the term to disentangle from
     * @param scrutinee the symbol of the scrutinee variable
     * @param className the class name
-    * @return the remaining term and the disentangled case branch body terms
+    * @return the remaining term and the disentangled term
     */
-  def disentangle(term: Term, scrutinee: ScrutineeSymbol, className: Var): (Term, Ls[Term]) =
-    trace[(Term, Ls[Term])](s"disentangle <== ${scrutinee.name}: $className") {
+  def disentangle(term: Term, scrutinee: ScrutineeSymbol, className: Var): (Term, Opt[Term]) =
+    trace[(Term, Opt[Term])](s"disentangle <== ${scrutinee.name}: $className") {
       term match {
         case top @ CaseOf(scrutineeVar: Var, cases) =>
           if (scrutineeVar.symbol match {
             case s: ScrutineeSymbol => s === scrutinee; case _ => false
           }) {
             println(s"found a `CaseOf` that matches on ${scrutinee.name}")
-            def rec(cases: CaseBranches): (CaseBranches, Ls[Term]) = cases match {
-              case NoCases => println("found the end, stop"); NoCases -> Nil
+            def rec(cases: CaseBranches): (CaseBranches, Opt[Term]) = cases match {
+              case NoCases => println("found the end, stop"); NoCases -> N
               case wildcard @ Wildcard(body) =>
                 println("found a wildcard, stop")
-                val (y, ns) = disentangle(body, scrutinee, className)
-                wildcard.copy(body = y) -> ns
+                val (y, n) = disentangle(body, scrutinee, className)
+                wildcard.copy(body = y) -> n
               case kase @ Case(`className`, body, rest) =>
                 println(s"found a case branch matching against $className")
-                val (y, ns) = rec(rest)
-                y -> (ns :+ body)
+                val (y, n) = rec(rest)
+                y -> S(n.fold(body)(mergeTerms(_, body)))
               case kase @ Case(otherClassName, body, rest) =>
-                val (y, ns) = rec(rest)
-                kase.copy(rest = y) -> ns
+                val (y, n) = rec(rest)
+                kase.copy(rest = y) -> n
             }
-            val (y, ns) = rec(cases)
-            top.copy(cases = y) -> ns
+            val (y, n) = rec(cases)
+            top.copy(cases = y) -> n
           } else {
             println(s"found a `CaseOf` that does NOT match on ${scrutinee.name}")
-            def rec(cases: CaseBranches): (CaseBranches, Ls[Term]) = cases match {
-              case NoCases => println("found the end, stop"); NoCases -> Nil
+            def rec(cases: CaseBranches): (CaseBranches, CaseBranches) = cases match {
+              case NoCases =>
+                println("found the end, stop")
+                NoCases -> NoCases
               case wildcard @ Wildcard(body) =>
                 println("found a wildcard, stop")
-                val (y, ns) = disentangle(body, scrutinee, className)
-                wildcard.copy(body = y) -> ns
+                val (y, n) = disentangle(body, scrutinee, className)
+                wildcard.copy(body = y) -> n.fold(NoCases: CaseBranches)(Wildcard(_))
               case kase @ Case(_, body, rest) =>
                 println(s"found a case branch")
-                val (y1, ns1) = disentangle(body, scrutinee, className)
-                val (y2, ns) = rec(rest)
-                kase.copy(body = y1, rest = y2) -> (ns1 ++ ns)
+                val (y1, n1) = disentangle(body, scrutinee, className)
+                val (y2, n2) = rec(rest)
+                kase.copy(body = y1, rest = y2) -> (n1 match {
+                  case S(term) => kase.copy(body = term, rest = n2)
+                  case N => n2
+                })
             }
-            val (y, ns) = rec(cases)
-            top.copy(cases = y) -> ns
+            val (y, n) = rec(cases)
+            top.copy(cases = y) -> (if (n === NoCases) N else S(top.copy(cases = n)))
           }
         case let @ Let(_, _, _, body) =>
-          val (y, ns) = disentangle(body, scrutinee, className)
-          let.copy(body = y) -> ns
-        case other => println(s"CANNOT disentangle"); other -> Nil
+          val (y, n) = disentangle(body, scrutinee, className)
+          let.copy(body = y) -> n.map(t => let.copy(body = t))
+        case other => println(s"CANNOT disentangle"); other -> N
       }
-    }({ case (y, ns) => s"disentangle ==> `${y}` ${ns.length}" })
+    }({ case (y, n) => s"disentangle ==> `${shortName(y)}` and `${n.fold("_")(shortName)}`" })
 
   def cascadeConsecutiveCaseOf(term: Term): Term = trace(s"cascade consecutive CaseOf <== ${term.describe}") {
     // Normalized terms are constructed using `Let` and `CaseOf`.
diff --git a/shared/src/test/diff/pretyper/ucs/DualOption.mls b/shared/src/test/diff/pretyper/ucs/DualOption.mls
index 9b24553510..4460835a2d 100644
--- a/shared/src/test/diff/pretyper/ucs/DualOption.mls
+++ b/shared/src/test/diff/pretyper/ucs/DualOption.mls
@@ -115,455 +115,13 @@ add_4(Some(5), Some(9))
 //│ res
 //│     = 14
 
-:dpt
+
 fun add_5(x, y) =
   if
     x is Some(xv) and y is Some(yv) then xv + yv
     y is None     and x is Some(xv) then xv
     x is None     and y is Some(yv) then yv
     y is None     and x is None     then 0
-//│ process <== <root>: {fun add_5}
-//│ | visitTypingUnit <== <root>: {fun add_5}
-//│ | | 1. scope = {add_5}
-//│ | | 2. scope = {add_5}
-//│ | | visitFunction <== add_5
-//│ | | | visitTerm <== Lam(_, _)
-//│ | | | | visitTerm <== Blk(_)
-//│ | | | | | visitTerm <== If(_)
-//│ | | | | | | visitIf
-//│ | | | | | | | Transformed UCS term:
-//│ | | | | | | | if
-//│ | | | | | | |   x is Some(xv) and y is Some(yv) then +(xv, yv,)
-//│ | | | | | | |   y is None and x is Some(xv) then xv
-//│ | | | | | | |   x is None and y is Some(yv) then yv
-//│ | | | | | | |   y is None and x is None then 0
-//│ | | | | | | | Desugared UCS term:
-//│ | | | | | | | if
-//│ | | | | | | |   x is Some(xv) y is Some(yv) then +(xv, yv,)
-//│ | | | | | | |   y is None x is Some(xv) then xv
-//│ | | | | | | |   x is None y is Some(yv) then yv
-//│ | | | | | | |   y is None x is None then 0
-//│ | | | | | | | visitSplit <== [add_5, x, y]
-//│ | | | | | | | | found branch: x is Some(xv)
-//│ | | | | | | | | visitTerm <== Var("x")
-//│ | | | | | | | | | visitVar(name = "x")
-//│ | | | | | | | | | | resolveVar(name = "x")
-//│ | | | | | | | | visitTerm ==> Var("x")
-//│ | | | | | | | | visitPattern <== Some(xv)
-//│ | | | | | | | | visitPattern ==> [xv]
-//│ | | | | | | | | visitSplit <== [add_5, x, y, xv]
-//│ | | | | | | | | | found branch: y is Some(yv)
-//│ | | | | | | | | | visitTerm <== Var("y")
-//│ | | | | | | | | | | visitVar(name = "y")
-//│ | | | | | | | | | | | resolveVar(name = "y")
-//│ | | | | | | | | | visitTerm ==> Var("y")
-//│ | | | | | | | | | visitPattern <== Some(yv)
-//│ | | | | | | | | | visitPattern ==> [yv]
-//│ | | | | | | | | | visitSplit <== [x, y, add_5, xv, yv]
-//│ | | | | | | | | | | visitTerm <== App(_, _)
-//│ | | | | | | | | | | | visitTerm <== Var("+")
-//│ | | | | | | | | | | | | visitVar(name = "+")
-//│ | | | | | | | | | | | | | resolveVar(name = "+")
-//│ | | | | | | | | | | | visitTerm ==> Var("+")
-//│ | | | | | | | | | | | visitTerm <== Tup(_, _)
-//│ | | | | | | | | | | | | visitTerm <== Var("xv")
-//│ | | | | | | | | | | | | | visitVar(name = "xv")
-//│ | | | | | | | | | | | | | | resolveVar(name = "xv")
-//│ | | | | | | | | | | | | visitTerm ==> Var("xv")
-//│ | | | | | | | | | | | | visitTerm <== Var("yv")
-//│ | | | | | | | | | | | | | visitVar(name = "yv")
-//│ | | | | | | | | | | | | | | resolveVar(name = "yv")
-//│ | | | | | | | | | | | | visitTerm ==> Var("yv")
-//│ | | | | | | | | | | | visitTerm ==> Tup(_, _)
-//│ | | | | | | | | | | visitTerm ==> App(_, _)
-//│ | | | | | | | | | visitSplit <== [add_5, x, y, xv]
-//│ | | | | | | | | | | the end
-//│ | | | | | | | | visitSplit <== [add_5, x, y]
-//│ | | | | | | | | | found branch: y is None
-//│ | | | | | | | | | visitTerm <== Var("y")
-//│ | | | | | | | | | | visitVar(name = "y")
-//│ | | | | | | | | | | | resolveVar(name = "y")
-//│ | | | | | | | | | visitTerm ==> Var("y")
-//│ | | | | | | | | | visitPattern <== None
-//│ | | | | | | | | | visitPattern ==> []
-//│ | | | | | | | | | visitSplit <== [add_5, x, y]
-//│ | | | | | | | | | | found branch: x is Some(xv)
-//│ | | | | | | | | | | visitTerm <== Var("x")
-//│ | | | | | | | | | | | visitVar(name = "x")
-//│ | | | | | | | | | | | | resolveVar(name = "x")
-//│ | | | | | | | | | | visitTerm ==> Var("x")
-//│ | | | | | | | | | | visitPattern <== Some(xv)
-//│ | | | | | | | | | | visitPattern ==> [xv]
-//│ | | | | | | | | | | visitSplit <== [add_5, x, y, xv]
-//│ | | | | | | | | | | | visitTerm <== Var("xv")
-//│ | | | | | | | | | | | | visitVar(name = "xv")
-//│ | | | | | | | | | | | | | resolveVar(name = "xv")
-//│ | | | | | | | | | | | visitTerm ==> Var("xv")
-//│ | | | | | | | | | | visitSplit <== [add_5, x, y]
-//│ | | | | | | | | | | | the end
-//│ | | | | | | | | | visitSplit <== [add_5, x, y]
-//│ | | | | | | | | | | found branch: x is None
-//│ | | | | | | | | | | visitTerm <== Var("x")
-//│ | | | | | | | | | | | visitVar(name = "x")
-//│ | | | | | | | | | | | | resolveVar(name = "x")
-//│ | | | | | | | | | | visitTerm ==> Var("x")
-//│ | | | | | | | | | | visitPattern <== None
-//│ | | | | | | | | | | visitPattern ==> []
-//│ | | | | | | | | | | visitSplit <== [add_5, x, y]
-//│ | | | | | | | | | | | found branch: y is Some(yv)
-//│ | | | | | | | | | | | visitTerm <== Var("y")
-//│ | | | | | | | | | | | | visitVar(name = "y")
-//│ | | | | | | | | | | | | | resolveVar(name = "y")
-//│ | | | | | | | | | | | visitTerm ==> Var("y")
-//│ | | | | | | | | | | | visitPattern <== Some(yv)
-//│ | | | | | | | | | | | visitPattern ==> [yv]
-//│ | | | | | | | | | | | visitSplit <== [add_5, x, y, yv]
-//│ | | | | | | | | | | | | visitTerm <== Var("yv")
-//│ | | | | | | | | | | | | | visitVar(name = "yv")
-//│ | | | | | | | | | | | | | | resolveVar(name = "yv")
-//│ | | | | | | | | | | | | visitTerm ==> Var("yv")
-//│ | | | | | | | | | | | visitSplit <== [add_5, x, y]
-//│ | | | | | | | | | | | | the end
-//│ | | | | | | | | | | visitSplit <== [add_5, x, y]
-//│ | | | | | | | | | | | found branch: y is None
-//│ | | | | | | | | | | | visitTerm <== Var("y")
-//│ | | | | | | | | | | | | visitVar(name = "y")
-//│ | | | | | | | | | | | | | resolveVar(name = "y")
-//│ | | | | | | | | | | | visitTerm ==> Var("y")
-//│ | | | | | | | | | | | visitPattern <== None
-//│ | | | | | | | | | | | visitPattern ==> []
-//│ | | | | | | | | | | | visitSplit <== [add_5, x, y]
-//│ | | | | | | | | | | | | found branch: x is None
-//│ | | | | | | | | | | | | visitTerm <== Var("x")
-//│ | | | | | | | | | | | | | visitVar(name = "x")
-//│ | | | | | | | | | | | | | | resolveVar(name = "x")
-//│ | | | | | | | | | | | | visitTerm ==> Var("x")
-//│ | | | | | | | | | | | | visitPattern <== None
-//│ | | | | | | | | | | | | visitPattern ==> []
-//│ | | | | | | | | | | | | visitSplit <== [add_5, x, y]
-//│ | | | | | | | | | | | | | visitTerm <== 0
-//│ | | | | | | | | | | | | | visitTerm ==> 0
-//│ | | | | | | | | | | | | visitSplit <== [add_5, x, y]
-//│ | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | visitSplit <== [add_5, x, y]
-//│ | | | | | | | | | | | | the end
-//│ | | | | | | | normalizeToTerm
-//│ | | | | | | | | match x with Some(xv)
-//│ | | | | | | | | compute true branch
-//│ | | | | | | | | | S+ <== x is Some(xv)
-//│ | | | | | | | | | | scrutinee: x =/= y
-//│ | | | | | | | | | | S+ <== x is Some(xv)
-//│ | | | | | | | | | | | the end
-//│ | | | | | | | | | | S+ ==> then +(xv, yv,)
-//│ | | | | | | | | | | specialized next
-//│ | | | | | | | | | | S+ <== x is Some(xv)
-//│ | | | | | | | | | | | scrutinee: x =/= y
-//│ | | | | | | | | | | | S+ <== x is Some(xv)
-//│ | | | | | | | | | | | | scrutinee: x === x
-//│ | | | | | | | | | | | | class name: Some === Some
-//│ | | | | | | | | | | | | S+ <== x is Some(xv)
-//│ | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | S+ ==> then xv
-//│ | | | | | | | | | | | S+ ==> then xv
-//│ | | | | | | | | | | | specialized next
-//│ | | | | | | | | | | | S+ <== x is Some(xv)
-//│ | | | | | | | | | | | | scrutinee: x === x
-//│ | | | | | | | | | | | | class name: Some =/= None
-//│ | | | | | | | | | | | | specialized next
-//│ | | | | | | | | | | | | S+ <== x is Some(xv)
-//│ | | | | | | | | | | | | | scrutinee: x =/= y
-//│ | | | | | | | | | | | | | S+ <== x is Some(xv)
-//│ | | | | | | | | | | | | | | scrutinee: x === x
-//│ | | | | | | | | | | | | | | class name: Some =/= None
-//│ | | | | | | | | | | | | | | specialized next
-//│ | | | | | | | | | | | | | | S+ <== x is Some(xv)
-//│ | | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | | S+ ==>
-//│ | | | | | | | | | | | | | S+ ==>
-//│ | | | | | | | | | | | | | specialized next
-//│ | | | | | | | | | | | | | S+ <== x is Some(xv)
-//│ | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | S+ ==>
-//│ | | | | | | | | | | | | S+ ==> y is None
-//│ | | | | | | | | | | | S+ ==> y is None
-//│ | | | | | | | | | | S+ ==>
-//│ | | | | | | | | | |   y is None then xv
-//│ | | | | | | | | | |   y is None
-//│ | | | | | | | | | S+ ==>
-//│ | | | | | | | | |   y is Some(yv) then +(xv, yv,)
-//│ | | | | | | | | |   y is None then xv
-//│ | | | | | | | | |   y is None
-//│ | | | | | | | | | normalizeToTerm
-//│ | | | | | | | | | | match y with Some(yv)
-//│ | | | | | | | | | | compute true branch
-//│ | | | | | | | | | | | S+ <== y is Some(yv)
-//│ | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | S+ ==> then +(xv, yv,)
-//│ | | | | | | | | | | | normalizeToTerm
-//│ | | | | | | | | | | compute false branch
-//│ | | | | | | | | | | | S- <== y is Some(yv)
-//│ | | | | | | | | | | | | scrutinee: y === y
-//│ | | | | | | | | | | | | class name: Some =/= None
-//│ | | | | | | | | | | | | S- <== y is Some(yv)
-//│ | | | | | | | | | | | | | scrutinee: y === y
-//│ | | | | | | | | | | | | | class name: Some =/= None
-//│ | | | | | | | | | | | | | S- <== y is Some(yv)
-//│ | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | S- ==>
-//│ | | | | | | | | | | | | S- ==> y is None
-//│ | | | | | | | | | | | S- ==>
-//│ | | | | | | | | | | |   y is None then xv
-//│ | | | | | | | | | | |   y is None
-//│ | | | | | | | | | | | normalizeToCaseBranches
-//│ | | | | | | | | | | | | normalizeToTerm
-//│ | | | | | | | | | | | | | match y with None
-//│ | | | | | | | | | | | | | S+ <== y is None
-//│ | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | S+ ==> then xv
-//│ | | | | | | | | | | | | | normalizeToTerm
-//│ | | | | | | | | | | | | | S- <== y is None
-//│ | | | | | | | | | | | | | | scrutinee: y === y
-//│ | | | | | | | | | | | | | | class name: None === None
-//│ | | | | | | | | | | | | | | S- <== y is None
-//│ | | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | | S- ==>
-//│ | | | | | | | | | | | | | S- ==>
-//│ | | | | | | | | | | | | | normalizeToCaseBranches
-//│ | | | | | | | | compute false branch
-//│ | | | | | | | | | S- <== x is Some(xv)
-//│ | | | | | | | | | | scrutinee: x =/= y
-//│ | | | | | | | | | | S- <== x is Some(xv)
-//│ | | | | | | | | | | | scrutinee: x === x
-//│ | | | | | | | | | | | class name: Some === Some
-//│ | | | | | | | | | | | S- <== x is Some(xv)
-//│ | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | S- ==>
-//│ | | | | | | | | | | S- ==>
-//│ | | | | | | | | | | S- <== x is Some(xv)
-//│ | | | | | | | | | | | scrutinee: x === x
-//│ | | | | | | | | | | | class name: Some =/= None
-//│ | | | | | | | | | | | S- <== x is Some(xv)
-//│ | | | | | | | | | | | | scrutinee: x =/= y
-//│ | | | | | | | | | | | | S- <== x is Some(xv)
-//│ | | | | | | | | | | | | | scrutinee: x === x
-//│ | | | | | | | | | | | | | class name: Some =/= None
-//│ | | | | | | | | | | | | | S- <== x is Some(xv)
-//│ | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | S- ==>
-//│ | | | | | | | | | | | | S- ==> x is None then 0
-//│ | | | | | | | | | | | | S- <== x is Some(xv)
-//│ | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | S- ==>
-//│ | | | | | | | | | | | S- ==> y is None x is None then 0
-//│ | | | | | | | | | | S- ==>
-//│ | | | | | | | | | |   x is None y is Some(yv) then yv
-//│ | | | | | | | | | |   y is None x is None then 0
-//│ | | | | | | | | | S- ==>
-//│ | | | | | | | | |   y is None
-//│ | | | | | | | | |   x is None y is Some(yv) then yv
-//│ | | | | | | | | |   y is None x is None then 0
-//│ | | | | | | | | | normalizeToCaseBranches
-//│ | | | | | | | | | | normalizeToTerm
-//│ | | | | | | | | | | | match y with None
-//│ | | | | | | | | | | | S+ <== y is None
-//│ | | | | | | | | | | | | scrutinee: y =/= x
-//│ | | | | | | | | | | | | S+ <== y is None
-//│ | | | | | | | | | | | | | scrutinee: y === y
-//│ | | | | | | | | | | | | | class name: None =/= Some
-//│ | | | | | | | | | | | | | specialized next
-//│ | | | | | | | | | | | | | S+ <== y is None
-//│ | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | S+ ==>
-//│ | | | | | | | | | | | | S+ ==>
-//│ | | | | | | | | | | | | specialized next
-//│ | | | | | | | | | | | | S+ <== y is None
-//│ | | | | | | | | | | | | | scrutinee: y === y
-//│ | | | | | | | | | | | | | class name: None === None
-//│ | | | | | | | | | | | | | S+ <== y is None
-//│ | | | | | | | | | | | | | | scrutinee: y =/= x
-//│ | | | | | | | | | | | | | | S+ <== y is None
-//│ | | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | | S+ ==> then 0
-//│ | | | | | | | | | | | | | | specialized next
-//│ | | | | | | | | | | | | | | S+ <== y is None
-//│ | | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | | S+ ==>
-//│ | | | | | | | | | | | | | S+ ==> x is None then 0
-//│ | | | | | | | | | | | | S+ ==> x is None then 0
-//│ | | | | | | | | | | | S+ ==>
-//│ | | | | | | | | | | |   x is None
-//│ | | | | | | | | | | |   x is None then 0
-//│ | | | | | | | | | | | normalizeToTerm
-//│ | | | | | | | | | | | | match x with None
-//│ | | | | | | | | | | | | S+ <== x is None
-//│ | | | | | | | | | | | | | scrutinee: x === x
-//│ | | | | | | | | | | | | | class name: None === None
-//│ | | | | | | | | | | | | | S+ <== x is None
-//│ | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | S+ ==> then 0
-//│ | | | | | | | | | | | | S+ ==> then 0
-//│ | | | | | | | | | | | | normalizeToTerm
-//│ | | | | | | | | | | | | S- <== x is None
-//│ | | | | | | | | | | | | | scrutinee: x === x
-//│ | | | | | | | | | | | | | class name: None === None
-//│ | | | | | | | | | | | | | S- <== x is None
-//│ | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | S- ==>
-//│ | | | | | | | | | | | | S- ==>
-//│ | | | | | | | | | | | | normalizeToCaseBranches
-//│ | | | | | | | | | | | S- <== y is None
-//│ | | | | | | | | | | | | scrutinee: y =/= x
-//│ | | | | | | | | | | | | S- <== y is None
-//│ | | | | | | | | | | | | | scrutinee: y === y
-//│ | | | | | | | | | | | | | class name: None =/= Some
-//│ | | | | | | | | | | | | | S- <== y is None
-//│ | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | S- ==>
-//│ | | | | | | | | | | | | S- ==> y is Some(yv) then yv
-//│ | | | | | | | | | | | | S- <== y is None
-//│ | | | | | | | | | | | | | scrutinee: y === y
-//│ | | | | | | | | | | | | | class name: None === None
-//│ | | | | | | | | | | | | | S- <== y is None
-//│ | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | S- ==>
-//│ | | | | | | | | | | | | S- ==>
-//│ | | | | | | | | | | | S- ==> x is None y is Some(yv) then yv
-//│ | | | | | | | | | | | normalizeToCaseBranches
-//│ | | | | | | | | | | | | normalizeToTerm
-//│ | | | | | | | | | | | | | match x with None
-//│ | | | | | | | | | | | | | S+ <== x is None
-//│ | | | | | | | | | | | | | | scrutinee: x =/= y
-//│ | | | | | | | | | | | | | | S+ <== x is None
-//│ | | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | | S+ ==> then yv
-//│ | | | | | | | | | | | | | | specialized next
-//│ | | | | | | | | | | | | | | S+ <== x is None
-//│ | | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | | S+ ==>
-//│ | | | | | | | | | | | | | S+ ==> y is Some(yv) then yv
-//│ | | | | | | | | | | | | | normalizeToTerm
-//│ | | | | | | | | | | | | | | match y with Some(yv)
-//│ | | | | | | | | | | | | | | compute true branch
-//│ | | | | | | | | | | | | | | | S+ <== y is Some(yv)
-//│ | | | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | | | S+ ==> then yv
-//│ | | | | | | | | | | | | | | | normalizeToTerm
-//│ | | | | | | | | | | | | | | compute false branch
-//│ | | | | | | | | | | | | | | | S- <== y is Some(yv)
-//│ | | | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | | | S- ==>
-//│ | | | | | | | | | | | | | | | normalizeToCaseBranches
-//│ | | | | | | | | | | | | | S- <== x is None
-//│ | | | | | | | | | | | | | | the end
-//│ | | | | | | | | | | | | | S- ==>
-//│ | | | | | | | | | | | | | normalizeToCaseBranches
-//│ | | | | | | | Normalized UCS term:
-//│ | | | | | | | x match
-//│ | | | | | | |   case Some =>
-//│ | | | | | | |     let args_x$Some = (Some).unapply(x,)
-//│ | | | | | | |     let xv* = (args_x$Some).0
-//│ | | | | | | |     y match
-//│ | | | | | | |       case Some =>
-//│ | | | | | | |         let args_y$Some = (Some).unapply(y,)
-//│ | | | | | | |         let yv* = (args_y$Some).0
-//│ | | | | | | |         +(xv, yv,)
-//│ | | | | | | |       case _ =>
-//│ | | | | | | |         y match
-//│ | | | | | | |           case None => xv
-//│ | | | | | | |   case _ =>
-//│ | | | | | | |     y match
-//│ | | | | | | |       case None =>
-//│ | | | | | | |         x match
-//│ | | | | | | |           case None => 0
-//│ | | | | | | |       case _ =>
-//│ | | | | | | |         x match
-//│ | | | | | | |           case None =>
-//│ | | | | | | |             y match
-//│ | | | | | | |               case Some =>
-//│ | | | | | | |                 let args_y$Some = (Some).unapply(y,)
-//│ | | | | | | |                 let yv* = (args_y$Some).0
-//│ | | | | | | |                 yv
-//│ | | | | | | | postProcess <== CaseOf(_, _)
-//│ | | | | | | | | found a BINARY case: x is Some
-//│ | | | | | | | | `x`'s matched classes: [None, Some]
-//│ | | | | | | | | post-processing the first branch
-//│ | | | | | | | | postProcess <== Let(_, _)
-//│ | | | | | | | | | postProcess <== Let(_, _)
-//│ | | | | | | | | | | postProcess <== CaseOf(_, _)
-//│ | | | | | | | | | | | found a BINARY case: y is Some
-//│ | | | | | | | | | | | `y`'s matched classes: [None, Some]
-//│ | | | | | | | | | | | post-processing the first branch
-//│ | | | | | | | | | | | postProcess <== Let(_, _)
-//│ | | | | | | | | | | | | postProcess <== Let(_, _)
-//│ | | | | | | | | | | | | | postProcess <== App(_, _)
-//│ | | | | | | | | | | | | | | CANNOT post-process
-//│ | | | | | | | | | | | | | postProcess ==> 
-//│ | | | | | | | | | | | | postProcess ==> 
-//│ | | | | | | | | | | | postProcess ==> 
-//│ | | | | | | | | | | | disentangle <== y: None
-//│ | | | | | | | | | | | | found a `CaseOf` that matches on y
-//│ | | | | | | | | | | | | found a case branch matching against None
-//│ | | | | | | | | | | | | found the end, stop
-//│ | | | | | | | | | | | disentangle ==> `case y of {  }` 1
-//│ | | | | | | | | | | | case y of {  } is empty
-//│ | | | | | | | | | | | found 1 case branches about None
-//│ | | | | | | | | | | | merging terms <== [Var("xv")]
-//│ | | | | | | | | | | | merging terms ==> Var("xv")
-//│ | | | | | | | | | | | postProcess <== Var("xv")
-//│ | | | | | | | | | | | | CANNOT post-process
-//│ | | | | | | | | | | | postProcess ==> 
-//│ | | | | | | | | | | | found 1 cases
-//│ | | | | | | | | | | postProcess ==> 
-//│ | | | | | | | | | postProcess ==> 
-//│ | | | | | | | | postProcess ==> 
-//│ | | | | | | | | disentangle <== x: None
-//│ | | | | | | | | | found a `CaseOf` that does NOT match on x
-//│ | | | | | | | | | found a case branch
-//│ | | | | | | | | | disentangle <== x: None
-//│ | | | | | | | | | | found a `CaseOf` that matches on x
-//│ | | | | | | | | | | found a case branch matching against None
-//│ | | | | | | | | | | found the end, stop
-//│ | | | | | | | | | disentangle ==> `case x of {  }` 1
-//│ | | | | | | | | | found a wildcard, stop
-//│ | | | | | | | | | disentangle <== x: None
-//│ | | | | | | | | | | found a `CaseOf` that matches on x
-//│ | | | | | | | | | | found a case branch matching against None
-//│ | | | | | | | | | | found the end, stop
-//│ | | | | | | | | | disentangle ==> `case x of {  }` 1
-//│ | | | | | | | | disentangle ==> `case y of { None => case x of {  }; _ => case x of {  } }` 2
-//│ | | | | | | | | found 2 case branches about None
-//│ | | | | | | | | merging terms <== [0, CaseOf(_, _)]
-//│ | | | | | | | | | mergeTerms <== integer literal `case` expression
-//│ | | | | | | | | | | CANNOT merge. Discard t2.
-//│ | | | | | | | | merging terms ==> 0
-//│ | | | | | | | | postProcess <== 0
-//│ | | | | | | | | | CANNOT post-process
-//│ | | | | | | | | postProcess ==> 
-//│ | | | | | | | | found 1 cases
-//│ | | | | | | | postProcess ==> 
-//│ | | | | | | | Post-processed UCS term:
-//│ | | | | | | | x match
-//│ | | | | | | |   case Some =>
-//│ | | | | | | |     let args_x$Some = (Some).unapply(x,)
-//│ | | | | | | |     let xv* = (args_x$Some).0
-//│ | | | | | | |     y match
-//│ | | | | | | |       case Some =>
-//│ | | | | | | |         let args_y$Some = (Some).unapply(y,)
-//│ | | | | | | |         let yv* = (args_y$Some).0
-//│ | | | | | | |         +(xv, yv,)
-//│ | | | | | | |       case None => xv
-//│ | | | | | | |   case None => 0
-//│ | | | | | | |   case _ =>
-//│ | | | | | | |     y match
-//│ | | | | | | |       case None => x match
-//│ | | | | | | |       case _ => x match
-//│ | | | | | | visitIf ==> ()
-//│ | | | | | visitTerm ==> If(_)
-//│ | | | | visitTerm ==> Blk(_)
-//│ | | | visitTerm ==> Lam(_, _)
-//│ | | visitFunction ==> add_5
-//│ | visitTypingUnit ==> add_5
-//│ process ==> add_5
 //│ fun add_5: forall 'a. (None | Some[Int], None | Some[Int & 'a]) -> (Int | 'a)
 
 add_5(None, None)

From 63677a17543706250b924c32710cfc28a5cc0e07 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Mon, 27 Nov 2023 02:06:05 +0800
Subject: [PATCH 005/147] Add a basic coverage checker

---
 .../src/main/scala/mlscript/Diagnostic.scala  |   1 +
 shared/src/main/scala/mlscript/helpers.scala  |  20 +++
 .../scala/mlscript/pretyper/PreTyper.scala    |   2 +
 .../scala/mlscript/pretyper/Traceable.scala   |   1 +
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |  10 +-
 .../ucs/stages/CoverageChecking.scala         | 125 ++++++++++++++++++
 .../ucs/stages/ExhaustivenessChecking.scala   |   5 -
 .../mlscript/ucs/stages/PostProcessing.scala  |   3 +-
 .../scala/mlscript/ucs/stages/package.scala   |  12 +-
 .../pretyper/ucs/coverage/MissingCases.mls    |  45 +++++++
 .../diff/pretyper/ucs/coverage/Tautology.mls  |  27 ++++
 .../src/test/scala/mlscript/DiffTests.scala   |   1 +
 12 files changed, 241 insertions(+), 11 deletions(-)
 create mode 100644 shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
 delete mode 100644 shared/src/main/scala/mlscript/ucs/stages/ExhaustivenessChecking.scala
 create mode 100644 shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/coverage/Tautology.mls

diff --git a/shared/src/main/scala/mlscript/Diagnostic.scala b/shared/src/main/scala/mlscript/Diagnostic.scala
index b552dc7f31..00d59a3b9b 100644
--- a/shared/src/main/scala/mlscript/Diagnostic.scala
+++ b/shared/src/main/scala/mlscript/Diagnostic.scala
@@ -19,6 +19,7 @@ object Diagnostic {
   sealed abstract class Source
   case object Lexing      extends Source
   case object Parsing     extends Source
+  case object PreTyping   extends Source
   case object Typing      extends Source
   case object Compilation extends Source
   case object Runtime     extends Source
diff --git a/shared/src/main/scala/mlscript/helpers.scala b/shared/src/main/scala/mlscript/helpers.scala
index ce8a9a04d4..6f653b3438 100644
--- a/shared/src/main/scala/mlscript/helpers.scala
+++ b/shared/src/main/scala/mlscript/helpers.scala
@@ -6,6 +6,7 @@ import scala.collection.mutable.{Map => MutMap, SortedMap => SortedMutMap, Set =
 import math.Ordered.orderingToOrdered
 
 import mlscript.utils._, shorthands._
+import scala.annotation.tailrec
 
 
 // Auxiliary definitions for types
@@ -1065,6 +1066,25 @@ trait CaseBranchesImpl extends Located { self: CaseBranches =>
     case NoCases => ""
   }
 
+  def foldLeft[A, B](z: A)(f: (A, SimpleTerm -> Term) => A)(e: (A, Opt[Term]) => B): B = {
+    @tailrec
+    def rec(acc: A, current: CaseBranches): B = current match {
+      case Case(pat, body, rest) => rec(f(acc, pat -> body), rest)
+      case Wildcard(body) => e(acc, S(body))
+      case NoCases => e(acc, N)
+    }
+    rec(z, this)
+  }
+
+  def foreach(f: Opt[SimpleTerm] -> Term => Unit): Unit = {
+    @tailrec
+    def rec(current: CaseBranches): Unit = current match {
+      case Case(pat, body, rest) => f(S(pat) -> body); rec(rest)
+      case Wildcard(body) => f(N -> body)
+      case NoCases => ()
+    }
+    rec(this)
+  }
 }
 
 trait AdtMatchPatImpl extends Located { self: AdtMatchPat =>
diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index d4444507e1..07ccacb229 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -5,6 +5,8 @@ import mlscript._, utils._, shorthands._
 import mlscript.codegen.Helpers.inspect
 
 class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Traceable with DesugarUCS {
+  protected def raise(diagnostics: Ls[Diagnostic]): Unit = ()
+
   private def extractParameters(fields: Term): Ls[ValueSymbol] = fields match {
     case Tup(arguments) =>
       if (useNewDefs) {
diff --git a/shared/src/main/scala/mlscript/pretyper/Traceable.scala b/shared/src/main/scala/mlscript/pretyper/Traceable.scala
index f707416c98..781fa8030c 100644
--- a/shared/src/main/scala/mlscript/pretyper/Traceable.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Traceable.scala
@@ -1,5 +1,6 @@
 package mlscript.pretyper
 
+import mlscript.Diagnostic
 import mlscript.utils._, shorthands._
 
 trait Traceable {
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 051541e614..636306f886 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -7,14 +7,14 @@ import mlscript._, utils._, shorthands._
 import mlscript.codegen.Helpers.inspect
 import mlscript.Message, Message.MessageContext
 
-import mlscript.ucs.core.Pattern.Name
-
 // TODO: Rename to `Desugarer` once the old desugarer is removed.
 trait DesugarUCS extends Transformation
                     with Desugaring
                     with Normalization
                     with PostProcessing 
-                    with ExhaustivenessChecking { self: PreTyper =>
+                    with CoverageChecking { self: PreTyper =>
+  
+
   protected def visitIf(`if`: If)(implicit scope: Scope): Unit =
     trace("visitIf") {
       // Stage 0: Transformation
@@ -40,6 +40,10 @@ trait DesugarUCS extends Transformation
       val postProcessed = postProcess(normalized)
       println("Post-processed UCS term:")
       printNormalizedTerm(postProcessed)
+      // Stage 4: Coverage checking
+      val diagnostics = checkCoverage(postProcessed)
+      println(s"Coverage checking result: ${diagnostics.size} errors")
+      raise(diagnostics)
       // Epilogue
       `if`.desugaredTerm = S(normalized)
     }(_ => "visitIf ==> ()")
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
new file mode 100644
index 0000000000..bc0247829d
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -0,0 +1,125 @@
+package mlscript.ucs.stages
+
+import mlscript.{Case, CaseBranches, CaseOf, Let, Loc, NoCases, Term, Var, Wildcard}
+import mlscript.pretyper.{ScrutineeSymbol, Symbol}
+import mlscript.utils._, shorthands._
+import mlscript.Message, Message.MessageContext
+import mlscript.pretyper.shortName
+import scala.annotation.tailrec
+import mlscript.{SimpleTerm, Diagnostic, ErrorReport, WarningReport}
+
+trait CoverageChecking { self: mlscript.pretyper.Traceable =>
+  import CoverageChecking._
+
+  def checkCoverage(term: Term): Ls[Diagnostic] = {
+    val registry = collectRegistry(term)
+    println("collected match register: " + showRegistry(registry))
+    checkCoverage(term, Map.empty, registry, Map.empty)
+  }
+
+  private def collectRegistry(term: Term): MatchRegistry = {
+    @tailrec
+    def rec(acc: MatchRegistry, rest: Ls[Term]): MatchRegistry = rest match {
+      case Nil => acc
+      case head :: tail => head match {
+        case Let(_, _, _, body) => rec(acc, body :: tail)
+        case CaseOf(Scrutinee(_, scrutinee), cases) =>
+          rec(
+            acc.updatedWith(scrutinee)(vs => S(cases.foldLeft(vs.getOrElse(Set.empty))({ 
+              case (acc, (className: Var) -> _) => acc + className
+              case (acc, _) => acc
+            })((x, _) => x))),
+            tail ++ cases.foldLeft(Nil: Ls[Term])({ case (acc, _ -> body) => body :: acc })((x, _) => x)
+          )
+        case _ => rec(acc, tail)
+      }
+    }
+    rec(Map.empty, term :: Nil)
+  }
+
+  private def checkCoverage(
+      term: Term,
+      pending: MatchRegistry,
+      working: MatchRegistry,
+      assumptions: Map[ScrutineeSymbol, Var]
+  ): Ls[Diagnostic] =
+    trace(s"checkCoverage <== ${shortName(term)}, ${pending.size} pending, ${working.size} working") {
+      println(s"assumptions: " + (if (assumptions.isEmpty) "empty" else
+        assumptions.iterator.map { case (k, v) => s"${k.name} is $v" }.mkString(", ")
+      ))
+      term match {
+        case Let(_, _, _, body) => checkCoverage(body, pending, working, assumptions)
+        case CaseOf(Scrutinee(scrutineeVar, scrutinee), cases) =>
+          println(s"scrutinee: ${scrutinee.name}")
+          // If the scrutinee is still pending (i.e., not matched yet), then we
+          // remove it from the pending list. If the scrutinee is matched, and
+          // there are still classes to be matched, then we find the remaining
+          // classes from the working list. If neither of the above is true,
+          // there are two possible cases:
+          // 1. The scrutinee has been never visited, which is an error.
+          // 2. It has been matched to be an instance of some class. Therefore,
+          //    we need to check if this is a contradiction.
+          val (unseenClasses, newPending) = pending.get(scrutinee) match {
+            case S(matchedClasses) => matchedClasses -> (pending - scrutinee)
+            case N => working.get(scrutinee) match {
+              case S(unseenClasses) => unseenClasses -> pending
+              case N => throw new Exception(s"Scrutinee ${scrutinee.name} is not matched.")
+            }
+          }
+          // We keep removing classes from the unseen class list and adding
+          // diagnostics (warnings and errors).
+          cases.foldLeft((unseenClasses, Nil: Ls[Diagnostic]))({
+            case ((red, acc), (className: Var) -> body) =>
+              if (red contains className) {
+                (
+                  // The class is matched. Remove it from the class list.
+                  red - className,
+                  // We remove the scrutinee from the working list and add
+                  // `scrutinee` is `className` to the assumptions.
+                  acc ++ checkCoverage(body, newPending, working - scrutinee, assumptions + (scrutinee -> className))
+                )
+              } else {
+                red -> (acc :+ (assumptions.get(scrutinee) match {
+                  case S(`className`) => WarningReport("tautology", Nil, Diagnostic.PreTyping)
+                  case S(otherClassName) => ErrorReport("contradiction", Nil, Diagnostic.PreTyping)
+                  case N => ErrorReport("unvisited scrutinee", Nil, Diagnostic.PreTyping)
+                }))
+              }
+            case (acc, _ -> _) =>
+              println("CANNOT check literal patterns")
+              acc
+          }) {
+            case ((missingCases, diagnostics), N) =>
+              println("MISSING cases: " + missingCases.iterator.map(className => s"${scrutinee.name} is $className").mkString("[", ", ", "]"))
+              diagnostics ++ (missingCases.iterator.map { className  =>
+                ErrorReport({
+                  val s1 = assumptions.iterator.map {
+                    case (scrutinee, className) => s"${scrutinee.name} is $className"
+                  }.mkString(", ")
+                  val s2 = if (s1.isEmpty) "" else s" $s1, and"
+                  msg"missing a case where$s2 ${scrutinee.name} is ${className.name}" -> N ::
+                    msg"missing the condition" -> className.toLoc ::
+                    assumptions.iterator.zipWithIndex.map({ case (scrutinee, className) -> index =>
+                      msg"${if (index > 0) "and" else "when"} ${scrutinee.name} is ${className.name}" -> className.toLoc
+                    }).toList
+                }, true, Diagnostic.PreTyping)
+              })
+            case ((unseenClasses, diagnostics), S(default)) =>
+              println("wildcard case")
+              checkCoverage(default, newPending, working.updated(scrutinee, unseenClasses), assumptions)
+          }
+        case other => println("STOP"); Nil
+      }
+    }(ls => s"checkCoverage ==> ${ls.length}")
+}
+
+object CoverageChecking {
+  type MatchRegistry = Map[ScrutineeSymbol, Set[Var]]
+
+  /** A helper function that prints entries from the given registry line by line. */
+  def showRegistry(registry: MatchRegistry): Str =
+    if (registry.isEmpty) "empty" else
+      registry.iterator.map { case (scrutinee, matchedClasses) =>
+        matchedClasses.iterator.mkString(s">>> ${scrutinee.name} => [", ", ", "]")
+      }.mkString("\n", "\n", "")
+}
diff --git a/shared/src/main/scala/mlscript/ucs/stages/ExhaustivenessChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/ExhaustivenessChecking.scala
deleted file mode 100644
index 33b17d886e..0000000000
--- a/shared/src/main/scala/mlscript/ucs/stages/ExhaustivenessChecking.scala
+++ /dev/null
@@ -1,5 +0,0 @@
-package mlscript.ucs.stages
-
-trait ExhaustivenessChecking { self: mlscript.pretyper.Traceable =>
-  
-}
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index 51a0bce008..416a329db8 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -1,9 +1,8 @@
 package mlscript.ucs.stages
 
-import mlscript.{Case, CaseOf, Let, Loc, NoCases, Term, Var, Wildcard}
+import mlscript.{Case, CaseBranches, CaseOf, Let, Loc, NoCases, Term, Var, Wildcard}
 import mlscript.pretyper.{ScrutineeSymbol, Symbol}
 import mlscript.utils._, shorthands._
-import mlscript.CaseBranches
 import mlscript.Message, Message.MessageContext
 import mlscript.pretyper.shortName
 import scala.annotation.tailrec
diff --git a/shared/src/main/scala/mlscript/ucs/stages/package.scala b/shared/src/main/scala/mlscript/ucs/stages/package.scala
index d1c5c2fbe2..7e23850f54 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/package.scala
@@ -1,10 +1,20 @@
 package mlscript.ucs
 
 import mlscript.{Term, Var}
-import mlscript.pretyper.Symbol
+import mlscript.pretyper.ScrutineeSymbol
 import mlscript.utils._, shorthands._
 
 package object stages {
+  object Scrutinee {
+    def unapply(term: Term): Opt[(Var, ScrutineeSymbol)] = term match {
+      case v @ Var(_) => v.symbol match {
+        case symbol: ScrutineeSymbol => S(v, symbol)
+        case _ => N
+      }
+      case _ => N
+    }
+  }
+
   private[stages] sealed abstract class MatchOrNot {
     override def toString(): String = this match {
       case Yes => "+"
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls b/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls
new file mode 100644
index 0000000000..b00504986b
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls
@@ -0,0 +1,45 @@
+:PreTyper
+
+class Some[T](value: T)
+module None
+type Option[T] = Some[T] | None
+class Pair[A, B](x: A, y: B)
+//│ class Some[T](value: T)
+//│ module None
+//│ type Option[T] = None | Some[T]
+//│ class Pair[A, B](x: A, y: B)
+
+fun failed_add_1(x, y) =
+  if
+    x is Some(xv) and y is Some(yv) then xv + yv
+    x is Some(xv) and y is None     then xv
+    x is None     and y is Some(yv) then yv
+//│ ╔══[ERROR] missing a case where x is None, and y is None
+//│ ╟── missing the condition
+//│ ║  l.15: 	    x is Some(xv) and y is None     then xv
+//│ ║        	                           ^^^^
+//│ ╟── when x is None
+//│ ║  l.16: 	    x is None     and y is Some(yv) then yv
+//│ ╙──      	         ^^^^
+//│ fun failed_add_1: forall 'a. (None | Some[Int], Some[Int & 'a]) -> (Int | 'a)
+
+fun failed_add_2(x, y) =
+  if
+    x is Some(xv) and y is None     then xv
+    x is None     and y is Some(yv) then yv
+//│ ╔══[ERROR] missing a case where x is Some, and y is Some
+//│ ╟── missing the condition
+//│ ║  l.29: 	    x is None     and y is Some(yv) then yv
+//│ ║        	                           ^^^^
+//│ ╟── when x is Some
+//│ ║  l.28: 	    x is Some(xv) and y is None     then xv
+//│ ╙──      	         ^^^^
+//│ ╔══[ERROR] missing a case where x is None, and y is None
+//│ ╟── missing the condition
+//│ ║  l.28: 	    x is Some(xv) and y is None     then xv
+//│ ║        	                           ^^^^
+//│ ╟── when x is None
+//│ ║  l.29: 	    x is None     and y is Some(yv) then yv
+//│ ╙──      	         ^^^^
+//│ fun failed_add_2: forall 'a. (None | Some['a], nothing) -> 'a
+
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/Tautology.mls b/shared/src/test/diff/pretyper/ucs/coverage/Tautology.mls
new file mode 100644
index 0000000000..b1ef516c82
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/coverage/Tautology.mls
@@ -0,0 +1,27 @@
+:PreTyper
+
+class Some[T](value: T)
+module None
+type Option[T] = Some[T] | None
+class Pair[A, B](x: A, y: B)
+//│ class Some[T](value: T)
+//│ module None
+//│ type Option[T] = None | Some[T]
+//│ class Pair[A, B](x: A, y: B)
+
+// FIXME
+fun useless_negate_1(x) =
+  if
+    x is Some(y) and x is Some(z) then x + z
+//│ ╔══[ERROR] identifier not found: z
+//│ ║  l.15: 	    x is Some(y) and x is Some(z) then x + z
+//│ ╙──      	                                           ^
+//│ ╔══[ERROR] Type mismatch in operator application:
+//│ ║  l.15: 	    x is Some(y) and x is Some(z) then x + z
+//│ ║        	                                       ^^^^^
+//│ ╟── reference of type `Some[?T]` is not an instance of type `Int`
+//│ ║  l.15: 	    x is Some(y) and x is Some(z) then x + z
+//│ ╙──      	                                       ^
+//│ fun useless_negate_1: Some[anything] -> (Int | error)
+//│ Code generation encountered an error:
+//│   unresolved symbol z
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index 4efc4d6aba..8e1191bdea 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -523,6 +523,7 @@ class DiffTests
               val rootTypingUnit = TypingUnit(p.tops)
               if (usePreTyper) {
                 val preTyper = new PreTyper(mode.dbgPreTyper, newDefs) {
+                  override protected def raise(diagnostics: Ls[Diagnostic]): Unit = report(diagnostics)
                   override def emitDbg(str: String): Unit = output(str)
                 }
                 // This should be passed to code generation somehow.

From 86168500069b3379719e8ad431247e9542a28b32 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Thu, 30 Nov 2023 02:55:12 +0800
Subject: [PATCH 006/147] Improve detecting tautology and unreachable cases

---
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |   5 +
 .../main/scala/mlscript/ucs/Desugarer.scala   |  16 +-
 .../main/scala/mlscript/ucs/MutCaseOf.scala   |   2 +-
 shared/src/main/scala/mlscript/ucs/core.scala |  44 +++-
 .../ucs/stages/CoverageChecking.scala         |   7 +-
 .../mlscript/ucs/stages/Normalization.scala   |  37 +++-
 .../main/scala/mlscript/utils/package.scala   |   5 +-
 shared/src/test/diff/codegen/NewMatching.mls  |   2 +-
 .../diff/pretyper/ucs/coverage/Tautology.mls  |  21 +-
 .../pretyper/ucs/coverage/Unreachable.mls     | 193 ++++++++++++++++++
 .../diff/pretyper/ucs/patterns/Literals.mls   |  29 +++
 11 files changed, 330 insertions(+), 31 deletions(-)
 create mode 100644 shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/patterns/Literals.mls

diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 636306f886..c921cd04ea 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -18,6 +18,7 @@ trait DesugarUCS extends Transformation
   protected def visitIf(`if`: If)(implicit scope: Scope): Unit =
     trace("visitIf") {
       // Stage 0: Transformation
+      println("STEP 0")
       val transformed = transform(`if`, true)
       println("Transformed UCS term:")
       println(transformed.toString, 2)
@@ -26,21 +27,25 @@ trait DesugarUCS extends Transformation
       // This stage will generate new names based on the position of the scrutinee.
       // Therefore, we need to call `visitSplit` to associate these newly generated
       // names with symbols.
+      println("STEP 1")
       val desugared = desugar(transformed)
       println(desugared.toString, 2)
       println("Desugared UCS term:")
       println(ucs.core.printSplit(desugared))
       visitSplit(desugared)
       // Stage 2: Normalization
+      println("STEP 2")
       val normalized = normalize(desugared)
       println(normalized.toString, 2)
       println("Normalized UCS term:")
       printNormalizedTerm(normalized)
       // Stage 3: Post-processing
+      println("STEP 3")
       val postProcessed = postProcess(normalized)
       println("Post-processed UCS term:")
       printNormalizedTerm(postProcessed)
       // Stage 4: Coverage checking
+      println("STEP 4")
       val diagnostics = checkCoverage(postProcessed)
       println(s"Coverage checking result: ${diagnostics.size} errors")
       raise(diagnostics)
diff --git a/shared/src/main/scala/mlscript/ucs/Desugarer.scala b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
index 34075afe78..dec70ac76a 100644
--- a/shared/src/main/scala/mlscript/ucs/Desugarer.scala
+++ b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
@@ -269,10 +269,10 @@ class Desugarer extends TypeDefs { self: Typer =>
               throw new DesugaringException({
                 val expected = positionals.length
                 val actual = args.length
-                msg"${kind.str} $className expects ${expected.toString} ${
-                  "parameter".pluralize(expected)
-                } but found ${args.length.toString} ${
-                  "parameter".pluralize(expected)
+                msg"${kind.str} $className expects ${
+                  "parameter".pluralize(expected, true)
+                } but found ${
+                  "parameter".pluralize(args.length, true)
                 }"
               }, app.toLoc)
             }
@@ -305,8 +305,8 @@ class Desugarer extends TypeDefs { self: Typer =>
             val num = td.positionals.length
             throw new DesugaringException({
               val expected = td.positionals.length
-              msg"${td.kind.str} `$op` expects ${expected.toString} ${
-                "parameter".pluralize(expected)
+              msg"${td.kind.str} `$op` expects ${
+                "parameter".pluralize(expected, true)
               } but found two parameters"
             }, app.toLoc)
         }
@@ -749,8 +749,8 @@ class Desugarer extends TypeDefs { self: Typer =>
               throw new DesugaringException({
                 val numMissingCases = missingCases.size
                 (msg"The match is not exhaustive." -> scrutinee.matchRootLoc) ::
-                  (msg"The scrutinee at this position misses ${numMissingCases.toString} ${
-                    "case".pluralize(numMissingCases)
+                  (msg"The scrutinee at this position misses ${
+                    "case".pluralize(numMissingCases, true)
                   }." -> scrutinee.term.toLoc) ::
                   missingCases.iterator.zipWithIndex.flatMap { case ((pattern, locations), index) =>
                     val patternName = pattern match {
diff --git a/shared/src/main/scala/mlscript/ucs/MutCaseOf.scala b/shared/src/main/scala/mlscript/ucs/MutCaseOf.scala
index 199d5619a8..a8bf41fac3 100644
--- a/shared/src/main/scala/mlscript/ucs/MutCaseOf.scala
+++ b/shared/src/main/scala/mlscript/ucs/MutCaseOf.scala
@@ -285,7 +285,7 @@ object MutCaseOf {
   ) extends MutCaseOf {
     def describe: Str = {
       val n = branches.length
-      s"Match($scrutinee, $n ${"branch".pluralize(n, true)}, ${
+      s"Match($scrutinee, ${"branch".pluralize(n, true, true)}, ${
         wildcard.fold("no wildcard")(n => s"wildcard = ${n.kind}")
       })"
     }
diff --git a/shared/src/main/scala/mlscript/ucs/core.scala b/shared/src/main/scala/mlscript/ucs/core.scala
index 5b0dc64009..d788643834 100644
--- a/shared/src/main/scala/mlscript/ucs/core.scala
+++ b/shared/src/main/scala/mlscript/ucs/core.scala
@@ -1,6 +1,7 @@
 package mlscript.ucs
 
-import mlscript.{Lit, Located, Term, Var}
+import collection.mutable.Buffer
+import mlscript.{Diagnostic, Lit, Loc, Located, Message, Term, Var}
 import mlscript.utils._, shorthands._
 
 package object core {
@@ -32,19 +33,60 @@ package object core {
     final case class Record(entries: List[(Var -> Var)]) extends Pattern {
       override def children: Ls[Located] = entries.iterator.flatMap { case (nme, als) => nme :: als :: Nil }.toList
     }
+
+    def getParametersLoc(parameters: List[Opt[Var]]): Opt[Loc] =
+      parameters.foldLeft(None: Opt[Loc]) {
+        case (acc, N) => acc
+        case (N, S(nme)) => nme.toLoc
+        case (S(loc), S(nme)) => S(nme.toLoc.fold(loc)(loc ++ _))
+      }
+    def getParametersLoc(parameters: Opt[List[Opt[Var]]]): Opt[Loc] =
+      parameters.fold(None: Opt[Loc])(getParametersLoc)
+
+    def showParameters(parameters: Opt[List[Opt[Var]]]): Str =
+      parameters.fold("empty")(_.map(_.fold("_")(_.name)).mkString("[", ", ", "]"))
   }
 
   final case class Branch(scrutinee: Var, pattern: Pattern, continuation: Split)
 
   sealed abstract class Split {
+    @inline
     def ::(head: Branch): Split = Split.Cons(head, this)
 
+    /**
+      * Concatenates two splits. Beware that `that` may be discarded if `this`
+      * has an else branch. Make sure to make diagnostics for discarded `that`.
+      */
     def ++(that: Split): Split = this match {
       case me: Split.Cons => me.copy(tail = me.tail ++ that)
       case me: Split.Let => me.copy(tail = me.tail ++ that)
       case _: Split.Else => this
       case Split.Nil => that
     }
+    
+    /**
+      * Returns true if the split has an else branch.
+      */
+    lazy val hasElse: Bool = this match {
+      case Split.Cons(_, tail) => tail.hasElse
+      case Split.Let(_, _, _, tail) => tail.hasElse
+      case Split.Else(_) => true
+      case Split.Nil => false
+    }
+
+    private val diagnostics: Buffer[Message -> Opt[Loc]] = Buffer.empty
+
+    def withDiagnostic(diagnostic: Message -> Opt[Loc]): this.type = {
+      diagnostics += diagnostic
+      this
+    }
+
+    def collectDiagnostics(): Ls[Message -> Opt[Loc]] =
+      diagnostics.toList ++ (this match {
+        case Split.Cons(_, tail) => tail.collectDiagnostics()
+        case Split.Let(_, _, _, tail) => tail.collectDiagnostics()
+        case Split.Else(_) | Split.Nil => Nil
+      })
   }
 
   object Split {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index bc0247829d..0b3d035356 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -13,7 +13,7 @@ trait CoverageChecking { self: mlscript.pretyper.Traceable =>
 
   def checkCoverage(term: Term): Ls[Diagnostic] = {
     val registry = collectRegistry(term)
-    println("collected match register: " + showRegistry(registry))
+    println("collected match registry: " + showRegistry(registry))
     checkCoverage(term, Map.empty, registry, Map.empty)
   }
 
@@ -29,7 +29,10 @@ trait CoverageChecking { self: mlscript.pretyper.Traceable =>
               case (acc, (className: Var) -> _) => acc + className
               case (acc, _) => acc
             })((x, _) => x))),
-            tail ++ cases.foldLeft(Nil: Ls[Term])({ case (acc, _ -> body) => body :: acc })((x, _) => x)
+            tail ++ cases.foldLeft
+              (Nil: Ls[Term])
+              ({ case (acc, _ -> body) => body :: acc })
+              ((acc, els) => els.fold(acc)(_ :: acc))
           )
         case _ => rec(acc, tail)
       }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 623f859668..1d5fa1c507 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -97,8 +97,41 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
             case Pattern.Class(className, parameters) =>
               if (className === otherClassName) {
                 println(s"class name: $className === $otherClassName")
-                // TODO: Subsitute parameters to otherParameters
-                specialize(continuation ++ tail, Yes)
+                (parameters, otherParameters) match {
+                  case (S(parameters), S(otherParameters)) =>
+                    if (parameters.length === otherParameters.length) {
+                      println(s"same number of parameters: ${parameters.length}")
+                      // Check if the class parameters are the same.
+                      // Generate a function that generates bindings.
+                      // TODO: Hygienic problems.
+                      val addLetBindings = parameters.iterator.zip(otherParameters).zipWithIndex.foldLeft[Split => Split](identity) {
+                        case (acc, N -> S(otherParameter) -> index) => ??? // TODO: How can we get the unapplied variable?
+                        case (acc, S(parameter) -> S(otherParameter) -> index) if parameter.name =/= otherParameter.name =>
+                          println(s"different parameter names at $index: ${parameter.name} =/= ${otherParameter.name}")
+                          tail => Split.Let(false, otherParameter, parameter, tail)
+                        case (acc, _) => acc
+                      }
+                      // addLetBindings(specialize(continuation ++ tail, Yes))
+                      val specialized = addLetBindings(specialize(continuation, Yes))
+                      if (specialized.hasElse) {
+                        println("tail is discarded")
+                        specialized.withDiagnostic(
+                          msg"Discarded split because of else branch" -> None // TODO: Synthesize locations
+                        )
+                      } else {
+                        specialized ++ specialize(tail, Yes)
+                      }
+                    } else {
+                      throw new NormalizationException({
+                        msg"Mismatched numbers of parameters of ${className.name}:" -> otherClassName.toLoc ::
+                          msg"There are ${"parameters".pluralize(parameters.length, true)}." -> Pattern.getParametersLoc(parameters) ::
+                          msg"But there are ${"parameters".pluralize(otherParameters.length, true)}." -> Pattern.getParametersLoc(otherParameters) ::
+                          Nil
+                      })
+                    }
+                  // TODO: Other cases
+                  case (_, _) => specialize(continuation ++ tail, Yes)
+                } // END match
               } else {
                 println(s"class name: $className =/= $otherClassName")
                 specializedTail
diff --git a/shared/src/main/scala/mlscript/utils/package.scala b/shared/src/main/scala/mlscript/utils/package.scala
index 212f8cac8c..adb607a6e0 100644
--- a/shared/src/main/scala/mlscript/utils/package.scala
+++ b/shared/src/main/scala/mlscript/utils/package.scala
@@ -45,8 +45,9 @@ package object utils {
     def decapitalize: String =
       if (self.length === 0 || !self.charAt(0).isUpper) self
       else self.updated(0, self.charAt(0).toLower)
-    def pluralize(quantity: Int, es: Boolean = false): String =
-      if (quantity > 1) self + (if (es) "es" else "s") else self
+    def pluralize(quantity: Int, inclusive: Boolean = false, es: Boolean = false): String =
+      (if (inclusive) quantity.toString + " " else "") +
+        (if (quantity > 1 || quantity === 0) self + (if (es) "es" else "s") else self)
     @SuppressWarnings(Array("org.wartremover.warts.Equals"))
     def ===(other: String): Bool = self.equals(other)
   }
diff --git a/shared/src/test/diff/codegen/NewMatching.mls b/shared/src/test/diff/codegen/NewMatching.mls
index 50d2dbc1da..8d270d1550 100644
--- a/shared/src/test/diff/codegen/NewMatching.mls
+++ b/shared/src/test/diff/codegen/NewMatching.mls
@@ -218,7 +218,7 @@ fun ft(x) =
   if x is
     FooBar(x) then x
     _ then 0
-//│ ╔══[ERROR] class FooBar expects 0 parameter but found 1 parameter
+//│ ╔══[ERROR] class FooBar expects 0 parameters but found 1 parameter
 //│ ║  l.219: 	    FooBar(x) then x
 //│ ╙──       	    ^^^^^^^^^
 //│ fun ft: anything -> error
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/Tautology.mls b/shared/src/test/diff/pretyper/ucs/coverage/Tautology.mls
index b1ef516c82..a2b73e9f86 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/Tautology.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/Tautology.mls
@@ -9,19 +9,12 @@ class Pair[A, B](x: A, y: B)
 //│ type Option[T] = None | Some[T]
 //│ class Pair[A, B](x: A, y: B)
 
-// FIXME
 fun useless_negate_1(x) =
   if
-    x is Some(y) and x is Some(z) then x + z
-//│ ╔══[ERROR] identifier not found: z
-//│ ║  l.15: 	    x is Some(y) and x is Some(z) then x + z
-//│ ╙──      	                                           ^
-//│ ╔══[ERROR] Type mismatch in operator application:
-//│ ║  l.15: 	    x is Some(y) and x is Some(z) then x + z
-//│ ║        	                                       ^^^^^
-//│ ╟── reference of type `Some[?T]` is not an instance of type `Int`
-//│ ║  l.15: 	    x is Some(y) and x is Some(z) then x + z
-//│ ╙──      	                                       ^
-//│ fun useless_negate_1: Some[anything] -> (Int | error)
-//│ Code generation encountered an error:
-//│   unresolved symbol z
+    x is Some(y) and x is Some(z) then y + z
+//│ fun useless_negate_1: Some[Int] -> Int
+
+useless_negate_1(Some(1))
+//│ Int
+//│ res
+//│     = 2
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls b/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
new file mode 100644
index 0000000000..1062a28ade
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
@@ -0,0 +1,193 @@
+:PreTyper
+
+class Some[T](value: T)
+module None
+type Option[T] = Some[T] | None
+class Pair[A, B](x: A, y: B)
+//│ class Some[T](value: T)
+//│ module None
+//│ type Option[T] = None | Some[T]
+//│ class Pair[A, B](x: A, y: B)
+
+fun f(x) = if x is Some(xv) and xv === 1 then true else false
+//│ fun f: (Object & ~#Some | Some[Eql[1]]) -> Bool
+
+f(Some(1))
+f(Some(2))
+f(None)
+//│ Bool
+//│ res
+//│     = true
+//│ res
+//│     = false
+//│ res
+//│     = false
+
+fun reachable_1(x) =
+  if x is
+    _ and f(x) then "cos"
+    Some(xv) then "sin"
+    None then "tan"
+//│ fun reachable_1: (None | Some[Eql[1]] | Some[anything] & ~#Some) -> ("cos" | "sin" | "tan")
+
+reachable_1(Some(1))
+reachable_1(Some(2))
+reachable_1(None)
+//│ "cos" | "sin" | "tan"
+//│ res
+//│     = 'cos'
+//│ res
+//│     = 'sin'
+//│ res
+//│     = 'tan'
+
+:dpt
+fun unreachable_1(x) =
+  if x is
+    _ and
+      f(x) then "tmux"
+      else "screen"
+    Some(xv) then "sin"
+    None then "tan"
+//│ process <== <root>: {fun unreachable_1}
+//│ | visitTypingUnit <== <root>: {fun unreachable_1}
+//│ | | 1. scope = {unreachable_1}
+//│ | | 2. scope = {unreachable_1}
+//│ | | visitFunction <== unreachable_1
+//│ | | | visitTerm <== Lam(_, _)
+//│ | | | | visitTerm <== Blk(_)
+//│ | | | | | visitTerm <== If(_)
+//│ | | | | | | visitIf
+//│ | | | | | | | STEP 0
+//│ | | | | | | | Transformed UCS term:
+//│ | | | | | | | if x is
+//│ | | | | | | |   _ and f(x,) then "tmux"
+//│ | | | | | | |   else "screen"
+//│ | | | | | | |   Some(xv) then "sin"
+//│ | | | | | | |   None then "tan"
+//│ | | | | | | | STEP 1
+//│ | | | | | | | Desugared UCS term:
+//│ | | | | | | | if
+//│ | | | | | | |   x is _
+//│ | | | | | | |     let scrut0 = f(x,)
+//│ | | | | | | |     scrut0 is true then "tmux"
+//│ | | | | | | |     else "screen"
+//│ | | | | | | |   x is Some(xv) then "sin"
+//│ | | | | | | |   x is None then "tan"
+//│ | | | | | | | visitSplit <== [unreachable_1, x]
+//│ | | | | | | | | found branch: x is _
+//│ | | | | | | | | visitTerm <== Var("x")
+//│ | | | | | | | | | visitVar(name = "x")
+//│ | | | | | | | | | | resolveVar(name = "x")
+//│ | | | | | | | | visitTerm ==> Var("x")
+//│ | | | | | | | | visitPattern <== _
+//│ | | | | | | | | visitPattern ==> [_]
+//│ | | | | | | | | visitSplit <== [unreachable_1, x, _]
+//│ | | | | | | | | | found let binding: "scrut0"
+//│ | | | | | | | | | visitSplit <== [unreachable_1, x, _, scrut0]
+//│ | | | | | | | | | | found branch: scrut0 is true
+//│ | | | | | | | | | | visitTerm <== Var("scrut0")
+//│ | | | | | | | | | | | visitVar(name = "scrut0")
+//│ | | | | | | | | | | | | resolveVar(name = "scrut0")
+//│ | | | | | | | | | | visitTerm ==> Var("scrut0")
+//│ | | | | | | | | | | visitPattern <== true
+//│ | | | | | | | | | | visitPattern ==> []
+//│ | | | | | | | | | | visitSplit <== [unreachable_1, x, _, scrut0]
+//│ | | | | | | | | | | | visitTerm <== "tmux"
+//│ | | | | | | | | | | | visitTerm ==> "tmux"
+//│ | | | | | | | | | | visitSplit <== [unreachable_1, x, _, scrut0]
+//│ | | | | | | | | | | | visitTerm <== "screen"
+//│ | | | | | | | | | | | visitTerm ==> "screen"
+//│ | | | | | | | | visitSplit <== [unreachable_1, x]
+//│ | | | | | | | | | found branch: x is Some(xv)
+//│ | | | | | | | | | visitTerm <== Var("x")
+//│ | | | | | | | | | | visitVar(name = "x")
+//│ | | | | | | | | | visitTerm ==> Var("x")
+//│ | | | | | | | | | visitPattern <== Some(xv)
+//│ | | | | | | | | | visitPattern ==> [xv]
+//│ | | | | | | | | | visitSplit <== [unreachable_1, x, xv]
+//│ | | | | | | | | | | visitTerm <== "sin"
+//│ | | | | | | | | | | visitTerm ==> "sin"
+//│ | | | | | | | | | visitSplit <== [unreachable_1, x]
+//│ | | | | | | | | | | found branch: x is None
+//│ | | | | | | | | | | visitTerm <== Var("x")
+//│ | | | | | | | | | | | visitVar(name = "x")
+//│ | | | | | | | | | | visitTerm ==> Var("x")
+//│ | | | | | | | | | | visitPattern <== None
+//│ | | | | | | | | | | visitPattern ==> []
+//│ | | | | | | | | | | visitSplit <== [unreachable_1, x]
+//│ | | | | | | | | | | | visitTerm <== "tan"
+//│ | | | | | | | | | | | visitTerm ==> "tan"
+//│ | | | | | | | | | | visitSplit <== [unreachable_1, x]
+//│ | | | | | | | | | | | the end
+//│ | | | | | | | STEP 2
+//│ | | | | | | | normalizeToTerm
+//│ | | | | | | | | alias x => _
+//│ | | | | | | | | normalizeToTerm
+//│ | | | | | | | | | normalizeToTerm
+//│ | | | | | | | | | | match scrut0 with true
+//│ | | | | | | | | | | S+ <== scrut0 is true
+//│ | | | | | | | | | | | the end
+//│ | | | | | | | | | | S+ ==> then "tmux"
+//│ | | | | | | | | | | normalizeToTerm
+//│ | | | | | | | | | | S- <== scrut0 is true
+//│ | | | | | | | | | | | the end
+//│ | | | | | | | | | | S- ==> then "screen"
+//│ | | | | | | | | | | normalizeToCaseBranches
+//│ | | | | | | | Normalized UCS term:
+//│ | | | | | | | let _* = x
+//│ | | | | | | | let scrut0* = f(x,)
+//│ | | | | | | | scrut0 match
+//│ | | | | | | |   case true => "tmux"
+//│ | | | | | | |   case _ => "screen"
+//│ | | | | | | | STEP 3
+//│ | | | | | | | postProcess <== Let(_, _)
+//│ | | | | | | | | postProcess <== Let(_, _)
+//│ | | | | | | | | | postProcess <== CaseOf(_, _)
+//│ | | | | | | | | | | found a BINARY case: scrut0 is true
+//│ | | | | | | | | | | `scrut0`'s matched classes: [true]
+//│ | | | | | | | | | | post-processing the first branch
+//│ | | | | | | | | | | postProcess <== "tmux"
+//│ | | | | | | | | | | | CANNOT post-process
+//│ | | | | | | | | | | postProcess ==> 
+//│ | | | | | | | | | | found 0 cases
+//│ | | | | | | | | | postProcess ==> 
+//│ | | | | | | | | postProcess ==> 
+//│ | | | | | | | postProcess ==> 
+//│ | | | | | | | Post-processed UCS term:
+//│ | | | | | | | let _* = x
+//│ | | | | | | | let scrut0* = f(x,)
+//│ | | | | | | | scrut0 match
+//│ | | | | | | |   case true => "tmux"
+//│ | | | | | | |   case _ => "screen"
+//│ | | | | | | | STEP 4
+//│ | | | | | | | collected match registry: 
+//│ | | | | | | | >>> scrut0 => [true]
+//│ | | | | | | | checkCoverage <== Let(_, _), 0 pending, 1 working
+//│ | | | | | | | | assumptions: empty
+//│ | | | | | | | | checkCoverage <== Let(_, _), 0 pending, 1 working
+//│ | | | | | | | | | assumptions: empty
+//│ | | | | | | | | | checkCoverage <== CaseOf(_, _), 0 pending, 1 working
+//│ | | | | | | | | | | assumptions: empty
+//│ | | | | | | | | | | scrutinee: scrut0
+//│ | | | | | | | | | | checkCoverage <== "tmux", 0 pending, 0 working
+//│ | | | | | | | | | | | assumptions: scrut0 is true
+//│ | | | | | | | | | | | STOP
+//│ | | | | | | | | | | checkCoverage ==> 0
+//│ | | | | | | | | | | wildcard case
+//│ | | | | | | | | | | checkCoverage <== "screen", 0 pending, 1 working
+//│ | | | | | | | | | | | assumptions: empty
+//│ | | | | | | | | | | | STOP
+//│ | | | | | | | | | | checkCoverage ==> 0
+//│ | | | | | | | | | checkCoverage ==> 0
+//│ | | | | | | | | checkCoverage ==> 0
+//│ | | | | | | | checkCoverage ==> 0
+//│ | | | | | | | Coverage checking result: 0 errors
+//│ | | | | | | visitIf ==> ()
+//│ | | | | | visitTerm ==> If(_)
+//│ | | | | visitTerm ==> Blk(_)
+//│ | | | visitTerm ==> Lam(_, _)
+//│ | | visitFunction ==> unreachable_1
+//│ | visitTypingUnit ==> unreachable_1
+//│ process ==> unreachable_1
+//│ fun unreachable_1: (Object & ~#Some | Some[Eql[1]]) -> ("screen" | "tmux")
diff --git a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
new file mode 100644
index 0000000000..815daa3caa
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
@@ -0,0 +1,29 @@
+:PreTyper
+
+class Some[T](value: T)
+module None
+type Option[T] = Some[T] | None
+class Pair[A, B](x: A, y: B)
+//│ class Some[T](value: T)
+//│ module None
+//│ type Option[T] = None | Some[T]
+//│ class Pair[A, B](x: A, y: B)
+
+:dpt
+// FIXME
+fun f(x) = if x is Some(1) then true else false
+//│ process <== <root>: {fun f}
+//│ | visitTypingUnit <== <root>: {fun f}
+//│ | | 1. scope = {f}
+//│ | | 2. scope = {f}
+//│ | | visitFunction <== f
+//│ | | | visitTerm <== Lam(_, _)
+//│ | | | | visitTerm <== If(_, _)
+//│ | | | | | visitIf
+//│ | | | | | | STEP 0
+//│ | | | | | | Transformed UCS term:
+//│ | | | | | | if
+//│ | | | | | |   x is Some(1) then true
+//│ | | | | | |   else false
+//│ | | | | | | STEP 1
+//│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing

From b4e5de3be38a2173c1cee6b358ad6b0e4070c012 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Thu, 30 Nov 2023 10:49:25 +0800
Subject: [PATCH 007/147] Support literal patterns

---
 .../mlscript/ucs/stages/Desugaring.scala      | 27 ++++++++++---------
 .../diff/pretyper/ucs/patterns/Literals.mls   | 18 +------------
 2 files changed, 16 insertions(+), 29 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index dffa403c81..d2c58f5d37 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -1,7 +1,8 @@
 package mlscript.ucs.stages
 
-import mlscript.{Term, Var}
+import mlscript.{App, Fld, Term, Var}
 import mlscript.ucs.{syntax => s, core => c, PartialTerm}
+import mlscript.ucs.helpers.mkBinOp
 import mlscript.utils._, shorthands._
 import mlscript.pretyper.{ScrutineeSymbol, SubValueSymbol, ValueSymbol}
 import mlscript.ucs.DesugaringException
@@ -25,7 +26,7 @@ trait Desugaring { self: mlscript.pretyper.Traceable =>
 
   private val truePattern = c.Pattern.Class(Var("true"), N)
 
-  private def flattenClassParameters(parentScrutinee: Var, parentClassName: Var, parameters: Opt[Ls[Opt[s.Pattern]]]): Opt[Ls[Opt[Var]]] -> Ls[Opt[Var -> s.ClassPattern]] =
+  private def flattenClassParameters(parentScrutinee: Var, parentClassName: Var, parameters: Opt[Ls[Opt[s.Pattern]]]): Opt[Ls[Opt[Var]]] -> Ls[Opt[Var -> s.Pattern]] =
     parameters match {
       case S(parameters) =>
         val (a, b) = parameters.zipWithIndex.unzip {
@@ -34,21 +35,15 @@ trait Desugaring { self: mlscript.pretyper.Traceable =>
           case (S(parameterPattern: s.ClassPattern), index) =>
             val scrutinee = freshScrutinee(parentScrutinee, parentClassName, index)
             (S(scrutinee), Some((scrutinee, parameterPattern)))
+          case (S(parameterPattern: s.LiteralPattern), index) =>
+            val scrutinee = freshScrutinee(parentScrutinee, parentClassName, index)
+            (S(scrutinee), Some((scrutinee, parameterPattern)))
           case _ => ??? // Other patterns are not implemented yet.
         }
         (S(a), b)
       case N => (N, Nil)
     }
 
-  private def flattenNestedSplitLet(pattern: s.ClassPattern, term: Var, tail: c.Split): c.Split = {
-    val (parameterBindings, childrenBindings) = flattenClassParameters(term, pattern.nme, pattern.parameters)
-    c.Branch(term, c.Pattern.Class(pattern.nme, parameterBindings), childrenBindings.foldRight(tail){ 
-      case (N, tail) => tail
-      case (S((nme, parameterPattern)), tail) =>
-        flattenNestedSplitLet(parameterPattern, nme, tail)
-    }) :: c.Split.Nil
-  }
-
   private def desugarTermSplit(split: s.TermSplit)(implicit termPart: PartialTerm): c.Split =
     split match {
       case s.Split.Cons(head, tail) => desugarTermBranch(head) ++ desugarTermSplit(tail)
@@ -92,8 +87,16 @@ trait Desugaring { self: mlscript.pretyper.Traceable =>
     val (parameterBindings, subPatterns) = flattenClassParameters(scrutinee, pattern.nme, pattern.parameters)
     c.Branch(scrutinee, c.Pattern.Class(pattern.nme, parameterBindings), subPatterns.foldRight(next) {
       case (None, next) => next
-      case (Some((nme, pattern)), next) =>
+      case (Some((nme, pattern: s.ClassPattern)), next) =>
         flattenNestedPattern(pattern, nme, next) :: c.Split.Nil
+      case (Some((nme, pattern: s.LiteralPattern)), next) =>
+        val scrutinee = freshScrutinee()
+        c.Split.Let(
+          rec = false,
+          scrutinee,
+          mkBinOp(nme, Var("=="), pattern.literal, true),
+          c.Branch(scrutinee, truePattern, next) :: c.Split.Nil
+        )
     })
   }
 
diff --git a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
index 815daa3caa..4a2cd8576a 100644
--- a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
+++ b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
@@ -9,21 +9,5 @@ class Pair[A, B](x: A, y: B)
 //│ type Option[T] = None | Some[T]
 //│ class Pair[A, B](x: A, y: B)
 
-:dpt
-// FIXME
 fun f(x) = if x is Some(1) then true else false
-//│ process <== <root>: {fun f}
-//│ | visitTypingUnit <== <root>: {fun f}
-//│ | | 1. scope = {f}
-//│ | | 2. scope = {f}
-//│ | | visitFunction <== f
-//│ | | | visitTerm <== Lam(_, _)
-//│ | | | | visitTerm <== If(_, _)
-//│ | | | | | visitIf
-//│ | | | | | | STEP 0
-//│ | | | | | | Transformed UCS term:
-//│ | | | | | | if
-//│ | | | | | |   x is Some(1) then true
-//│ | | | | | |   else false
-//│ | | | | | | STEP 1
-//│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing
+//│ fun f: (Object & ~#Some | Some[Num]) -> Bool

From 2e98bc25fee5c6d925887020ec5b587fe2604076 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Thu, 30 Nov 2023 23:45:29 +0800
Subject: [PATCH 008/147] Address minor issues during mentioned in the meeting

- Rename functions from `visitX` to `traverseX`.
- Add Boolean condition test cases.
- Use dollar symbol in generated variables.
- Add `TupleCase` which currently is commented.
---
 .../scala/mlscript/pretyper/PreTyper.scala    |  88 ++++++------
 shared/src/main/scala/mlscript/syntax.scala   |   1 +
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |  32 ++---
 .../mlscript/ucs/stages/Desugaring.scala      |   2 +-
 .../src/test/diff/pretyper/Declarations.mls   |  98 ++++++-------
 .../pretyper/ucs/coverage/Unreachable.mls     | 134 +++++++++---------
 .../diff/pretyper/ucs/patterns/Literals.mls   |  17 +++
 7 files changed, 195 insertions(+), 177 deletions(-)

diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index 07ccacb229..a3f27e6caf 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -29,7 +29,7 @@ class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Trac
     case other => println("Unknown parameters: " + inspect(other)); ??? // TODO: bad
   }
 
-  // `visitIf` is meaningless because it represents patterns with terms.
+  // `traverseIf` is meaningless because it represents patterns with terms.
 
   protected def resolveVar(v: Var)(implicit scope: Scope): Unit =
     trace(s"resolveVar(name = \"$v\")") {
@@ -54,8 +54,8 @@ class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Trac
       }
     }()
 
-  protected def visitVar(v: Var)(implicit scope: Scope): Unit =
-    trace(s"visitVar(name = \"$v\")") {
+  protected def traverseVar(v: Var)(implicit scope: Scope): Unit =
+    trace(s"traverseVar(name = \"$v\")") {
       v.symbolOption match {
         case N => resolveVar(v)
         case S(symbol) => scope.get(v.name) match {
@@ -66,70 +66,70 @@ class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Trac
       }
     }()
 
-  protected def visitTerm(term: Term)(implicit scope: Scope): Unit =
-    trace(s"visitTerm <== ${shortName(term)}") {
+  protected def traverseTerm(term: Term)(implicit scope: Scope): Unit =
+    trace(s"traverseTerm <== ${shortName(term)}") {
       term match {
-        case Assign(lhs, rhs) => visitTerm(lhs); visitTerm(rhs)
-        case Bra(_, trm) => visitTerm(trm)
+        case Assign(lhs, rhs) => traverseTerm(lhs); traverseTerm(rhs)
+        case Bra(_, trm) => traverseTerm(trm)
         case Lam(lhs, rhs) =>
-          visitTerm(rhs)(scope ++ extractParameters(lhs))
-        case Sel(receiver, fieldName) => visitTerm(receiver)
+          traverseTerm(rhs)(scope ++ extractParameters(lhs))
+        case Sel(receiver, fieldName) => traverseTerm(receiver)
         case Let(isRec, nme, rhs, body) =>
-          visitTerm(rhs)
-          visitTerm(body)(scope + new ValueSymbol(nme, false))
+          traverseTerm(rhs)
+          traverseTerm(body)(scope + new ValueSymbol(nme, false))
         case New(head, body) =>
-        case Tup(fields) => fields.foreach { case (_, Fld(_, t)) => visitTerm(t) }
-        case Asc(trm, ty) => visitTerm(trm)
-        case ef @ If(_, _) => visitIf(ef)(scope)
+        case Tup(fields) => fields.foreach { case (_, Fld(_, t)) => traverseTerm(t) }
+        case Asc(trm, ty) => traverseTerm(trm)
+        case ef @ If(_, _) => traverseIf(ef)(scope)
         case TyApp(lhs, targs) => // TODO: When?
         case Eqn(lhs, rhs) => ??? // TODO: How?
         case Blk(stmts) => stmts.foreach {
-          case t: Term => visitTerm(t)
+          case t: Term => traverseTerm(t)
           case _ => ??? // TODO: When?
         }
-        case Subs(arr, idx) => visitTerm(arr); visitTerm(idx)
-        case Bind(lhs, rhs) => visitTerm(lhs); visitTerm(rhs)
+        case Subs(arr, idx) => traverseTerm(arr); traverseTerm(idx)
+        case Bind(lhs, rhs) => traverseTerm(lhs); traverseTerm(rhs)
         case Splc(fields) => fields.foreach {
-          case L(t) => visitTerm(t)
-          case R(Fld(_, t)) => visitTerm(t)
+          case L(t) => traverseTerm(t)
+          case R(Fld(_, t)) => traverseTerm(t)
         }
         case Forall(params, body) => ??? // TODO: When?
-        case Rcd(fields) => fields.foreach { case (_, Fld(_, t)) => visitTerm(t) }
+        case Rcd(fields) => fields.foreach { case (_, Fld(_, t)) => traverseTerm(t) }
         case CaseOf(trm, cases) => 
-        case With(trm, fields) => visitTerm(trm); visitTerm(fields)
+        case With(trm, fields) => traverseTerm(trm); traverseTerm(fields)
         case Where(body, where) => ??? // TODO: When?
-        case App(lhs, rhs) => visitTerm(lhs); visitTerm(rhs)
-        case Test(trm, ty) => visitTerm(trm)
+        case App(lhs, rhs) => traverseTerm(lhs); traverseTerm(rhs)
+        case Test(trm, ty) => traverseTerm(trm)
         case _: Lit | _: Super => ()
-        case v: Var => visitVar(v)
+        case v: Var => traverseVar(v)
         case AdtMatchWith(cond, arms) => ??? // TODO: How?
-        case Inst(body) => visitTerm(body)
+        case Inst(body) => traverseTerm(body)
       }
-    }(_ => s"visitTerm ==> ${shortName(term)}")
+    }(_ => s"traverseTerm ==> ${shortName(term)}")
 
-  private def visitNuTypeDef(symbol: TypeSymbol, defn: NuTypeDef)(implicit scope: Scope): Unit =
-    trace(s"visitNuTypeDef <== ${defn.kind} ${defn.nme.name}") {
-      visitTypingUnit(defn.body, defn.nme.name, scope)
+  private def traverseNuTypeDef(symbol: TypeSymbol, defn: NuTypeDef)(implicit scope: Scope): Unit =
+    trace(s"traverseNuTypeDef <== ${defn.kind} ${defn.nme.name}") {
+      traverseTypingUnit(defn.body, defn.nme.name, scope)
       ()
-    }(_ => s"visitNuTypeDef <== ${defn.kind} ${defn.nme.name}")
+    }(_ => s"traverseNuTypeDef <== ${defn.kind} ${defn.nme.name}")
 
-  private def visitFunction(symbol: FunctionSymbol, defn: NuFunDef)(implicit scope: Scope): Unit =
-    trace(s"visitFunction <== ${defn.nme.name}") {
+  private def traverseFunction(symbol: FunctionSymbol, defn: NuFunDef)(implicit scope: Scope): Unit =
+    trace(s"traverseFunction <== ${defn.nme.name}") {
       defn.rhs match {
         case Left(term) => 
           val subScope = if (defn.isLetRec === S(false)) scope else scope + symbol
-          visitTerm(term)(subScope)
+          traverseTerm(term)(subScope)
         case Right(value) => ()
       }
-    }(_ => s"visitFunction ==> ${defn.nme.name}")
+    }(_ => s"traverseFunction ==> ${defn.nme.name}")
 
-  private def visitLetBinding(symbol: ValueSymbol, rec: Bool, rhs: Term)(implicit scope: Scope): Unit =
-    trace(s"visitLetBinding(rec = $rec, ${symbol.name})") {
+  private def traverseLetBinding(symbol: ValueSymbol, rec: Bool, rhs: Term)(implicit scope: Scope): Unit =
+    trace(s"traverseLetBinding(rec = $rec, ${symbol.name})") {
 
     }()
 
-  private def visitTypingUnit(typingUnit: TypingUnit, name: Str, parentScope: Scope): (Scope, TypeContents) =
-    trace(s"visitTypingUnit <== $name: ${typingUnit.describe}") {
+  private def traverseTypingUnit(typingUnit: TypingUnit, name: Str, parentScope: Scope): (Scope, TypeContents) =
+    trace(s"traverseTypingUnit <== $name: ${typingUnit.describe}") {
       import mlscript.{Cls, Trt, Mxn, Als, Mod}
       // Pass 1: Build a scope with hoisted symbols.
       val hoistedScope = typingUnit.entities.foldLeft(parentScope.derive) {
@@ -150,12 +150,12 @@ class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Trac
       println(hoistedScope.symbols.map(_.name).mkString("1. scope = {", ", ", "}"))
       // Pass 2: Visit non-hoisted and build a complete scope.
       val completeScope = typingUnit.entities.foldLeft[Scope](hoistedScope) {
-        case (acc, term: Term) => visitTerm(term)(acc); acc
+        case (acc, term: Term) => traverseTerm(term)(acc); acc
         case (acc, defn: NuTypeDef) => acc
         case (acc, defn @ NuFunDef(Some(rec), nme, _, _, L(rhs))) =>
           val symbol = new ValueSymbol(defn.nme, true)
           val scopeWithVar = acc + symbol
-          visitLetBinding(symbol, rec, rhs)(if (rec) { scopeWithVar } else { acc })
+          traverseLetBinding(symbol, rec, rhs)(if (rec) { scopeWithVar } else { acc })
           scopeWithVar
         case (acc, _: NuFunDef) => acc
         case (acc, _: Constructor | _: DataDefn | _: DatatypeDefn | _: Def | _: LetS | _: TypeDef) => ??? // TODO: When?
@@ -173,16 +173,16 @@ class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Trac
               })
             case Als | Mod | Mxn | Trt => completeScope
           }
-          visitNuTypeDef(symbol, symbol.defn)(innerScope)
-        case symbol: FunctionSymbol => visitFunction(symbol, symbol.defn)(completeScope)
+          traverseNuTypeDef(symbol, symbol.defn)(innerScope)
+        case symbol: FunctionSymbol => traverseFunction(symbol, symbol.defn)(completeScope)
         case _: ValueSymbol => ()
         case _: SubValueSymbol => ()
       }
       (completeScope, new TypeContents)
-    }({ case (scope, contents) => s"visitTypingUnit ==> ${scope.showLocalSymbols}" })
+    }({ case (scope, contents) => s"traverseTypingUnit ==> ${scope.showLocalSymbols}" })
 
   def process(typingUnit: TypingUnit, scope: Scope, name: Str): (Scope, TypeContents) =
     trace(s"process <== $name: ${typingUnit.describe}") {
-      visitTypingUnit(typingUnit, name, scope)
+      traverseTypingUnit(typingUnit, name, scope)
     }({ case (scope, contents) => s"process ==> ${scope.showLocalSymbols}" })
 }
diff --git a/shared/src/main/scala/mlscript/syntax.scala b/shared/src/main/scala/mlscript/syntax.scala
index 368faca806..6ac60216a8 100644
--- a/shared/src/main/scala/mlscript/syntax.scala
+++ b/shared/src/main/scala/mlscript/syntax.scala
@@ -110,6 +110,7 @@ object FldFlags { val empty: FldFlags = FldFlags(false, false, false) }
 sealed abstract class CaseBranches extends CaseBranchesImpl
 final case class Case(pat: SimpleTerm, body: Term, rest: CaseBranches) extends CaseBranches
 final case class Wildcard(body: Term) extends CaseBranches
+// final case class TupleCase(numElems: Int, canHaveMore: Bool, body: Term, rest: CaseBranches) extends CaseBranches
 final case object NoCases extends CaseBranches
 
 final case class IntLit(value: BigInt)            extends Lit
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index c921cd04ea..5bee605601 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -15,8 +15,8 @@ trait DesugarUCS extends Transformation
                     with CoverageChecking { self: PreTyper =>
   
 
-  protected def visitIf(`if`: If)(implicit scope: Scope): Unit =
-    trace("visitIf") {
+  protected def traverseIf(`if`: If)(implicit scope: Scope): Unit =
+    trace("traverseIf") {
       // Stage 0: Transformation
       println("STEP 0")
       val transformed = transform(`if`, true)
@@ -25,14 +25,14 @@ trait DesugarUCS extends Transformation
       println(ucs.syntax.printTermSplit(transformed))
       // Stage 1: Desugaring
       // This stage will generate new names based on the position of the scrutinee.
-      // Therefore, we need to call `visitSplit` to associate these newly generated
+      // Therefore, we need to call `traverseSplit` to associate these newly generated
       // names with symbols.
       println("STEP 1")
       val desugared = desugar(transformed)
       println(desugared.toString, 2)
       println("Desugared UCS term:")
       println(ucs.core.printSplit(desugared))
-      visitSplit(desugared)
+      traverseSplit(desugared)
       // Stage 2: Normalization
       println("STEP 2")
       val normalized = normalize(desugared)
@@ -51,28 +51,28 @@ trait DesugarUCS extends Transformation
       raise(diagnostics)
       // Epilogue
       `if`.desugaredTerm = S(normalized)
-    }(_ => "visitIf ==> ()")
+    }(_ => "traverseIf ==> ()")
   
-  private def visitSplit(split: core.Split)(implicit scope: Scope): Unit =
-    trace(s"visitSplit <== [${scope.showLocalSymbols}]") {
+  private def traverseSplit(split: core.Split)(implicit scope: Scope): Unit =
+    trace(s"traverseSplit <== [${scope.showLocalSymbols}]") {
       import core._
       split match {
         case Split.Cons(Branch(scrutinee, pattern, continuation), tail) => 
           println(s"found branch: $scrutinee is $pattern")
-          visitTerm(scrutinee)
-          val patternSymbols = visitPattern(scrutinee, pattern)
-          visitSplit(continuation)(scope.withEntries(patternSymbols))
-          visitSplit(tail)
+          traverseTerm(scrutinee)
+          val patternSymbols = traversePattern(scrutinee, pattern)
+          traverseSplit(continuation)(scope.withEntries(patternSymbols))
+          traverseSplit(tail)
         case Split.Let(_, name, _, tail) =>
           println(s"found let binding: \"$name\"")
-          visitSplit(tail)(scope + new ValueSymbol(name, false))
-        case Split.Else(default) => visitTerm(default)
+          traverseSplit(tail)(scope + new ValueSymbol(name, false))
+        case Split.Else(default) => traverseTerm(default)
         case Split.Nil => println("the end")
       }
     }()
 
-  private def visitPattern(scrutinee: Var, pattern: core.Pattern): List[Var -> Symbol] =
-    trace(s"visitPattern <== $pattern") {
+  private def traversePattern(scrutinee: Var, pattern: core.Pattern): List[Var -> Symbol] =
+    trace(s"traversePattern <== $pattern") {
       lazy val scrutineeSymbol = scrutinee.symbol match {
         case symbol: ScrutineeSymbol => symbol
         case other: Symbol =>
@@ -109,5 +109,5 @@ trait DesugarUCS extends Transformation
             bindingName.symbol = symbol; bindingName -> symbol
           }.toList
       }
-    }(_.iterator.map(_._1.name).mkString("visitPattern ==> [", ", ", "]"))
+    }(_.iterator.map(_._1.name).mkString("traversePattern ==> [", ", ", "]"))
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index d2c58f5d37..6c8301fcca 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -16,7 +16,7 @@ trait Desugaring { self: mlscript.pretyper.Traceable =>
   private def freshName(): Str = {
     val thisIndex = nextScrutineeIndex
     nextScrutineeIndex += 1
-    s"scrut$thisIndex" // FIXME: use `freeVars` to avoid name collision.
+    s"scrut$$$thisIndex" // FIXME: use `freeVars` to avoid name collision.
   }
 
   private def freshScrutinee(): Var = Var(freshName())
diff --git a/shared/src/test/diff/pretyper/Declarations.mls b/shared/src/test/diff/pretyper/Declarations.mls
index 1401303e05..3ba12d9540 100644
--- a/shared/src/test/diff/pretyper/Declarations.mls
+++ b/shared/src/test/diff/pretyper/Declarations.mls
@@ -5,30 +5,30 @@
 :dpt
 fun test(x, y) = x + y
 //│ process <== <root>: {fun test}
-//│ | visitTypingUnit <== <root>: {fun test}
+//│ | traverseTypingUnit <== <root>: {fun test}
 //│ | | 1. scope = {test}
 //│ | | 2. scope = {test}
-//│ | | visitFunction <== test
-//│ | | | visitTerm <== Lam(_, _)
-//│ | | | | visitTerm <== App(_, _)
-//│ | | | | | visitTerm <== Var("+")
-//│ | | | | | | visitVar(name = "+")
+//│ | | traverseFunction <== test
+//│ | | | traverseTerm <== Lam(_, _)
+//│ | | | | traverseTerm <== App(_, _)
+//│ | | | | | traverseTerm <== Var("+")
+//│ | | | | | | traverseVar(name = "+")
 //│ | | | | | | | resolveVar(name = "+")
-//│ | | | | | visitTerm ==> Var("+")
-//│ | | | | | visitTerm <== Tup(_, _)
-//│ | | | | | | visitTerm <== Var("x")
-//│ | | | | | | | visitVar(name = "x")
+//│ | | | | | traverseTerm ==> Var("+")
+//│ | | | | | traverseTerm <== Tup(_, _)
+//│ | | | | | | traverseTerm <== Var("x")
+//│ | | | | | | | traverseVar(name = "x")
 //│ | | | | | | | | resolveVar(name = "x")
-//│ | | | | | | visitTerm ==> Var("x")
-//│ | | | | | | visitTerm <== Var("y")
-//│ | | | | | | | visitVar(name = "y")
+//│ | | | | | | traverseTerm ==> Var("x")
+//│ | | | | | | traverseTerm <== Var("y")
+//│ | | | | | | | traverseVar(name = "y")
 //│ | | | | | | | | resolveVar(name = "y")
-//│ | | | | | | visitTerm ==> Var("y")
-//│ | | | | | visitTerm ==> Tup(_, _)
-//│ | | | | visitTerm ==> App(_, _)
-//│ | | | visitTerm ==> Lam(_, _)
-//│ | | visitFunction ==> test
-//│ | visitTypingUnit ==> test
+//│ | | | | | | traverseTerm ==> Var("y")
+//│ | | | | | traverseTerm ==> Tup(_, _)
+//│ | | | | traverseTerm ==> App(_, _)
+//│ | | | traverseTerm ==> Lam(_, _)
+//│ | | traverseFunction ==> test
+//│ | traverseTypingUnit ==> test
 //│ process ==> test
 //│ fun test: (Int, Int) -> Int
 
@@ -37,19 +37,19 @@ fun test(x, y) = x + y
 let y = id(42)
 fun id(x) = x
 //│ process <== <root>: {let y; fun id}
-//│ | visitTypingUnit <== <root>: {let y; fun id}
+//│ | traverseTypingUnit <== <root>: {let y; fun id}
 //│ | | 1. scope = {id}
-//│ | | visitLetBinding(rec = false, y)
+//│ | | traverseLetBinding(rec = false, y)
 //│ | | 2. scope = {id}
-//│ | | visitFunction <== id
-//│ | | | visitTerm <== Lam(_, _)
-//│ | | | | visitTerm <== Var("x")
-//│ | | | | | visitVar(name = "x")
+//│ | | traverseFunction <== id
+//│ | | | traverseTerm <== Lam(_, _)
+//│ | | | | traverseTerm <== Var("x")
+//│ | | | | | traverseVar(name = "x")
 //│ | | | | | | resolveVar(name = "x")
-//│ | | | | visitTerm ==> Var("x")
-//│ | | | visitTerm ==> Lam(_, _)
-//│ | | visitFunction ==> id
-//│ | visitTypingUnit ==> id, y
+//│ | | | | traverseTerm ==> Var("x")
+//│ | | | traverseTerm ==> Lam(_, _)
+//│ | | traverseFunction ==> id
+//│ | traverseTypingUnit ==> id, y
 //│ process ==> id, y
 //│ let y: 42 | 'a
 //│ fun id: forall 'b. ('a & 'b) -> (42 | 'b)
@@ -59,31 +59,31 @@ fun id(x) = x
 fun q(x) = x + p
 let p = 0
 //│ process <== <root>: {fun q; let p}
-//│ | visitTypingUnit <== <root>: {fun q; let p}
+//│ | traverseTypingUnit <== <root>: {fun q; let p}
 //│ | | 1. scope = {q}
-//│ | | visitLetBinding(rec = false, p)
+//│ | | traverseLetBinding(rec = false, p)
 //│ | | 2. scope = {q}
-//│ | | visitFunction <== q
-//│ | | | visitTerm <== Lam(_, _)
-//│ | | | | visitTerm <== App(_, _)
-//│ | | | | | visitTerm <== Var("+")
-//│ | | | | | | visitVar(name = "+")
+//│ | | traverseFunction <== q
+//│ | | | traverseTerm <== Lam(_, _)
+//│ | | | | traverseTerm <== App(_, _)
+//│ | | | | | traverseTerm <== Var("+")
+//│ | | | | | | traverseVar(name = "+")
 //│ | | | | | | | resolveVar(name = "+")
-//│ | | | | | visitTerm ==> Var("+")
-//│ | | | | | visitTerm <== Tup(_, _)
-//│ | | | | | | visitTerm <== Var("x")
-//│ | | | | | | | visitVar(name = "x")
+//│ | | | | | traverseTerm ==> Var("+")
+//│ | | | | | traverseTerm <== Tup(_, _)
+//│ | | | | | | traverseTerm <== Var("x")
+//│ | | | | | | | traverseVar(name = "x")
 //│ | | | | | | | | resolveVar(name = "x")
-//│ | | | | | | visitTerm ==> Var("x")
-//│ | | | | | | visitTerm <== Var("p")
-//│ | | | | | | | visitVar(name = "p")
+//│ | | | | | | traverseTerm ==> Var("x")
+//│ | | | | | | traverseTerm <== Var("p")
+//│ | | | | | | | traverseVar(name = "p")
 //│ | | | | | | | | resolveVar(name = "p")
-//│ | | | | | | visitTerm ==> Var("p")
-//│ | | | | | visitTerm ==> Tup(_, _)
-//│ | | | | visitTerm ==> App(_, _)
-//│ | | | visitTerm ==> Lam(_, _)
-//│ | | visitFunction ==> q
-//│ | visitTypingUnit ==> q, p
+//│ | | | | | | traverseTerm ==> Var("p")
+//│ | | | | | traverseTerm ==> Tup(_, _)
+//│ | | | | traverseTerm ==> App(_, _)
+//│ | | | traverseTerm ==> Lam(_, _)
+//│ | | traverseFunction ==> q
+//│ | traverseTypingUnit ==> q, p
 //│ process ==> q, p
 //│ fun q: Int -> Int
 //│ let p: 0
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls b/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
index 1062a28ade..d872381360 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
@@ -50,14 +50,14 @@ fun unreachable_1(x) =
     Some(xv) then "sin"
     None then "tan"
 //│ process <== <root>: {fun unreachable_1}
-//│ | visitTypingUnit <== <root>: {fun unreachable_1}
+//│ | traverseTypingUnit <== <root>: {fun unreachable_1}
 //│ | | 1. scope = {unreachable_1}
 //│ | | 2. scope = {unreachable_1}
-//│ | | visitFunction <== unreachable_1
-//│ | | | visitTerm <== Lam(_, _)
-//│ | | | | visitTerm <== Blk(_)
-//│ | | | | | visitTerm <== If(_)
-//│ | | | | | | visitIf
+//│ | | traverseFunction <== unreachable_1
+//│ | | | traverseTerm <== Lam(_, _)
+//│ | | | | traverseTerm <== Blk(_)
+//│ | | | | | traverseTerm <== If(_)
+//│ | | | | | | traverseIf
 //│ | | | | | | | STEP 0
 //│ | | | | | | | Transformed UCS term:
 //│ | | | | | | | if x is
@@ -69,83 +69,83 @@ fun unreachable_1(x) =
 //│ | | | | | | | Desugared UCS term:
 //│ | | | | | | | if
 //│ | | | | | | |   x is _
-//│ | | | | | | |     let scrut0 = f(x,)
-//│ | | | | | | |     scrut0 is true then "tmux"
+//│ | | | | | | |     let scrut$0 = f(x,)
+//│ | | | | | | |     scrut$0 is true then "tmux"
 //│ | | | | | | |     else "screen"
 //│ | | | | | | |   x is Some(xv) then "sin"
 //│ | | | | | | |   x is None then "tan"
-//│ | | | | | | | visitSplit <== [unreachable_1, x]
+//│ | | | | | | | traverseSplit <== [unreachable_1, x]
 //│ | | | | | | | | found branch: x is _
-//│ | | | | | | | | visitTerm <== Var("x")
-//│ | | | | | | | | | visitVar(name = "x")
+//│ | | | | | | | | traverseTerm <== Var("x")
+//│ | | | | | | | | | traverseVar(name = "x")
 //│ | | | | | | | | | | resolveVar(name = "x")
-//│ | | | | | | | | visitTerm ==> Var("x")
-//│ | | | | | | | | visitPattern <== _
-//│ | | | | | | | | visitPattern ==> [_]
-//│ | | | | | | | | visitSplit <== [unreachable_1, x, _]
-//│ | | | | | | | | | found let binding: "scrut0"
-//│ | | | | | | | | | visitSplit <== [unreachable_1, x, _, scrut0]
-//│ | | | | | | | | | | found branch: scrut0 is true
-//│ | | | | | | | | | | visitTerm <== Var("scrut0")
-//│ | | | | | | | | | | | visitVar(name = "scrut0")
-//│ | | | | | | | | | | | | resolveVar(name = "scrut0")
-//│ | | | | | | | | | | visitTerm ==> Var("scrut0")
-//│ | | | | | | | | | | visitPattern <== true
-//│ | | | | | | | | | | visitPattern ==> []
-//│ | | | | | | | | | | visitSplit <== [unreachable_1, x, _, scrut0]
-//│ | | | | | | | | | | | visitTerm <== "tmux"
-//│ | | | | | | | | | | | visitTerm ==> "tmux"
-//│ | | | | | | | | | | visitSplit <== [unreachable_1, x, _, scrut0]
-//│ | | | | | | | | | | | visitTerm <== "screen"
-//│ | | | | | | | | | | | visitTerm ==> "screen"
-//│ | | | | | | | | visitSplit <== [unreachable_1, x]
+//│ | | | | | | | | traverseTerm ==> Var("x")
+//│ | | | | | | | | traversePattern <== _
+//│ | | | | | | | | traversePattern ==> [_]
+//│ | | | | | | | | traverseSplit <== [unreachable_1, x, _]
+//│ | | | | | | | | | found let binding: "scrut$0"
+//│ | | | | | | | | | traverseSplit <== [unreachable_1, x, _, scrut$0]
+//│ | | | | | | | | | | found branch: scrut$0 is true
+//│ | | | | | | | | | | traverseTerm <== Var("scrut$0")
+//│ | | | | | | | | | | | traverseVar(name = "scrut$0")
+//│ | | | | | | | | | | | | resolveVar(name = "scrut$0")
+//│ | | | | | | | | | | traverseTerm ==> Var("scrut$0")
+//│ | | | | | | | | | | traversePattern <== true
+//│ | | | | | | | | | | traversePattern ==> []
+//│ | | | | | | | | | | traverseSplit <== [unreachable_1, x, _, scrut$0]
+//│ | | | | | | | | | | | traverseTerm <== "tmux"
+//│ | | | | | | | | | | | traverseTerm ==> "tmux"
+//│ | | | | | | | | | | traverseSplit <== [unreachable_1, x, _, scrut$0]
+//│ | | | | | | | | | | | traverseTerm <== "screen"
+//│ | | | | | | | | | | | traverseTerm ==> "screen"
+//│ | | | | | | | | traverseSplit <== [unreachable_1, x]
 //│ | | | | | | | | | found branch: x is Some(xv)
-//│ | | | | | | | | | visitTerm <== Var("x")
-//│ | | | | | | | | | | visitVar(name = "x")
-//│ | | | | | | | | | visitTerm ==> Var("x")
-//│ | | | | | | | | | visitPattern <== Some(xv)
-//│ | | | | | | | | | visitPattern ==> [xv]
-//│ | | | | | | | | | visitSplit <== [unreachable_1, x, xv]
-//│ | | | | | | | | | | visitTerm <== "sin"
-//│ | | | | | | | | | | visitTerm ==> "sin"
-//│ | | | | | | | | | visitSplit <== [unreachable_1, x]
+//│ | | | | | | | | | traverseTerm <== Var("x")
+//│ | | | | | | | | | | traverseVar(name = "x")
+//│ | | | | | | | | | traverseTerm ==> Var("x")
+//│ | | | | | | | | | traversePattern <== Some(xv)
+//│ | | | | | | | | | traversePattern ==> [xv]
+//│ | | | | | | | | | traverseSplit <== [unreachable_1, x, xv]
+//│ | | | | | | | | | | traverseTerm <== "sin"
+//│ | | | | | | | | | | traverseTerm ==> "sin"
+//│ | | | | | | | | | traverseSplit <== [unreachable_1, x]
 //│ | | | | | | | | | | found branch: x is None
-//│ | | | | | | | | | | visitTerm <== Var("x")
-//│ | | | | | | | | | | | visitVar(name = "x")
-//│ | | | | | | | | | | visitTerm ==> Var("x")
-//│ | | | | | | | | | | visitPattern <== None
-//│ | | | | | | | | | | visitPattern ==> []
-//│ | | | | | | | | | | visitSplit <== [unreachable_1, x]
-//│ | | | | | | | | | | | visitTerm <== "tan"
-//│ | | | | | | | | | | | visitTerm ==> "tan"
-//│ | | | | | | | | | | visitSplit <== [unreachable_1, x]
+//│ | | | | | | | | | | traverseTerm <== Var("x")
+//│ | | | | | | | | | | | traverseVar(name = "x")
+//│ | | | | | | | | | | traverseTerm ==> Var("x")
+//│ | | | | | | | | | | traversePattern <== None
+//│ | | | | | | | | | | traversePattern ==> []
+//│ | | | | | | | | | | traverseSplit <== [unreachable_1, x]
+//│ | | | | | | | | | | | traverseTerm <== "tan"
+//│ | | | | | | | | | | | traverseTerm ==> "tan"
+//│ | | | | | | | | | | traverseSplit <== [unreachable_1, x]
 //│ | | | | | | | | | | | the end
 //│ | | | | | | | STEP 2
 //│ | | | | | | | normalizeToTerm
 //│ | | | | | | | | alias x => _
 //│ | | | | | | | | normalizeToTerm
 //│ | | | | | | | | | normalizeToTerm
-//│ | | | | | | | | | | match scrut0 with true
-//│ | | | | | | | | | | S+ <== scrut0 is true
+//│ | | | | | | | | | | match scrut$0 with true
+//│ | | | | | | | | | | S+ <== scrut$0 is true
 //│ | | | | | | | | | | | the end
 //│ | | | | | | | | | | S+ ==> then "tmux"
 //│ | | | | | | | | | | normalizeToTerm
-//│ | | | | | | | | | | S- <== scrut0 is true
+//│ | | | | | | | | | | S- <== scrut$0 is true
 //│ | | | | | | | | | | | the end
 //│ | | | | | | | | | | S- ==> then "screen"
 //│ | | | | | | | | | | normalizeToCaseBranches
 //│ | | | | | | | Normalized UCS term:
 //│ | | | | | | | let _* = x
-//│ | | | | | | | let scrut0* = f(x,)
-//│ | | | | | | | scrut0 match
+//│ | | | | | | | let scrut$0* = f(x,)
+//│ | | | | | | | scrut$0 match
 //│ | | | | | | |   case true => "tmux"
 //│ | | | | | | |   case _ => "screen"
 //│ | | | | | | | STEP 3
 //│ | | | | | | | postProcess <== Let(_, _)
 //│ | | | | | | | | postProcess <== Let(_, _)
 //│ | | | | | | | | | postProcess <== CaseOf(_, _)
-//│ | | | | | | | | | | found a BINARY case: scrut0 is true
-//│ | | | | | | | | | | `scrut0`'s matched classes: [true]
+//│ | | | | | | | | | | found a BINARY case: scrut$0 is true
+//│ | | | | | | | | | | `scrut$0`'s matched classes: [true]
 //│ | | | | | | | | | | post-processing the first branch
 //│ | | | | | | | | | | postProcess <== "tmux"
 //│ | | | | | | | | | | | CANNOT post-process
@@ -156,22 +156,22 @@ fun unreachable_1(x) =
 //│ | | | | | | | postProcess ==> 
 //│ | | | | | | | Post-processed UCS term:
 //│ | | | | | | | let _* = x
-//│ | | | | | | | let scrut0* = f(x,)
-//│ | | | | | | | scrut0 match
+//│ | | | | | | | let scrut$0* = f(x,)
+//│ | | | | | | | scrut$0 match
 //│ | | | | | | |   case true => "tmux"
 //│ | | | | | | |   case _ => "screen"
 //│ | | | | | | | STEP 4
 //│ | | | | | | | collected match registry: 
-//│ | | | | | | | >>> scrut0 => [true]
+//│ | | | | | | | >>> scrut$0 => [true]
 //│ | | | | | | | checkCoverage <== Let(_, _), 0 pending, 1 working
 //│ | | | | | | | | assumptions: empty
 //│ | | | | | | | | checkCoverage <== Let(_, _), 0 pending, 1 working
 //│ | | | | | | | | | assumptions: empty
 //│ | | | | | | | | | checkCoverage <== CaseOf(_, _), 0 pending, 1 working
 //│ | | | | | | | | | | assumptions: empty
-//│ | | | | | | | | | | scrutinee: scrut0
+//│ | | | | | | | | | | scrutinee: scrut$0
 //│ | | | | | | | | | | checkCoverage <== "tmux", 0 pending, 0 working
-//│ | | | | | | | | | | | assumptions: scrut0 is true
+//│ | | | | | | | | | | | assumptions: scrut$0 is true
 //│ | | | | | | | | | | | STOP
 //│ | | | | | | | | | | checkCoverage ==> 0
 //│ | | | | | | | | | | wildcard case
@@ -183,11 +183,11 @@ fun unreachable_1(x) =
 //│ | | | | | | | | checkCoverage ==> 0
 //│ | | | | | | | checkCoverage ==> 0
 //│ | | | | | | | Coverage checking result: 0 errors
-//│ | | | | | | visitIf ==> ()
-//│ | | | | | visitTerm ==> If(_)
-//│ | | | | visitTerm ==> Blk(_)
-//│ | | | visitTerm ==> Lam(_, _)
-//│ | | visitFunction ==> unreachable_1
-//│ | visitTypingUnit ==> unreachable_1
+//│ | | | | | | traverseIf ==> ()
+//│ | | | | | traverseTerm ==> If(_)
+//│ | | | | traverseTerm ==> Blk(_)
+//│ | | | traverseTerm ==> Lam(_, _)
+//│ | | traverseFunction ==> unreachable_1
+//│ | traverseTypingUnit ==> unreachable_1
 //│ process ==> unreachable_1
 //│ fun unreachable_1: (Object & ~#Some | Some[Eql[1]]) -> ("screen" | "tmux")
diff --git a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
index 4a2cd8576a..e36980c286 100644
--- a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
+++ b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
@@ -11,3 +11,20 @@ class Pair[A, B](x: A, y: B)
 
 fun f(x) = if x is Some(1) then true else false
 //│ fun f: (Object & ~#Some | Some[Num]) -> Bool
+
+fun g(x) = if x then 1 else 2
+//│ fun g: Object -> (1 | 2)
+
+fun g(x) = if x is true then 1 else 2
+//│ fun g: anything -> 1
+//│ Syntax error:
+//│   Invalid destructuring assignment target
+
+fun g(x) = if x && true is true then 1 else 2
+//│ fun g: Bool -> 1
+//│ Syntax error:
+//│   Invalid destructuring assignment target
+
+fun h(x) = if (x : Bool) then 1 else 2
+//│ fun h: Bool -> (1 | 2)
+

From 3d355f253a375665dd48ad01b074a403b5ea5c1c Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Fri, 1 Dec 2023 18:54:07 +0800
Subject: [PATCH 009/147] Support pattern like `x is true` and constrain tests
 to be Booleans

---
 .../mlscript/ucs/stages/Desugaring.scala      | 35 +++++++++++--------
 .../mlscript/ucs/stages/Transformation.scala  | 19 +++++-----
 .../src/main/scala/mlscript/ucs/syntax.scala  |  4 +++
 .../pretyper/ucs/coverage/Unreachable.mls     |  6 ++--
 .../diff/pretyper/ucs/patterns/Literals.mls   | 18 ++++++----
 5 files changed, 48 insertions(+), 34 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 6c8301fcca..107535e60d 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -1,6 +1,6 @@
 package mlscript.ucs.stages
 
-import mlscript.{App, Fld, Term, Var}
+import mlscript.{App, Asc, Fld, Term, Var, TypeName}
 import mlscript.ucs.{syntax => s, core => c, PartialTerm}
 import mlscript.ucs.helpers.mkBinOp
 import mlscript.utils._, shorthands._
@@ -60,7 +60,7 @@ trait Desugaring { self: mlscript.pretyper.Traceable =>
         c.Split.Let(
           rec = false,
           name = `var`,
-          term = condition,
+          term = Asc(condition, TypeName("Bool")),
           tail = c.Branch(`var`, truePattern, desugarTermSplit(continuation)) :: c.Split.Nil
         )
       case s.TermBranch.Match(scrutinee, split) =>
@@ -100,21 +100,26 @@ trait Desugaring { self: mlscript.pretyper.Traceable =>
     })
   }
 
-  private def desugarPatternBranch(scrutinee: Var, branch: s.PatternBranch): c.Branch = {
-    lazy val continuation = desugarTermSplit(branch.continuation)(PartialTerm.Empty)
-    branch.pattern match {
-      case s.AliasPattern(nme, pattern) => ???
-      case s.LiteralPattern(literal) => ???
-      case s.NamePattern(nme) => c.Branch(scrutinee, c.Pattern.Name(nme), continuation)
-      case pattern @ s.ClassPattern(nme, fields) => flattenNestedPattern(pattern, scrutinee, continuation)
-      case s.TuplePattern(fields) => ???
-      case s.RecordPattern(entries) => ???
-    }
-  }
-
   private def desugarPatternSplit(split: s.PatternSplit)(implicit scrutinee: Term): c.Split = {
     def rec(scrutinee: Var, split: s.PatternSplit): c.Split = split match {
-      case s.Split.Cons(head, tail) => desugarPatternBranch(scrutinee, head) :: rec(scrutinee, tail)
+      case s.Split.Cons(head, tail) => 
+        lazy val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty)
+        head.pattern match {
+          case s.AliasPattern(nme, pattern) => ???
+          case s.LiteralPattern(literal) => ???
+          case s.ConcretePattern(nme) => 
+            val condition = freshScrutinee()
+            c.Split.Let(
+              rec = false,
+              name = condition,
+              term = mkBinOp(scrutinee, Var("==="), nme, true),
+              tail = c.Branch(condition, truePattern, continuation) :: rec(scrutinee, tail)
+            )
+          case s.NamePattern(nme) => c.Branch(scrutinee, c.Pattern.Name(nme), continuation) :: rec(scrutinee, tail)
+          case pattern @ s.ClassPattern(nme, fields) => flattenNestedPattern(pattern, scrutinee, continuation) :: rec(scrutinee, tail)
+          case s.TuplePattern(fields) => ???
+          case s.RecordPattern(entries) => ???
+        }
       case s.Split.Let(isRec, nme, rhs, tail) => c.Split.Let(isRec, nme, rhs, rec(scrutinee, tail))
       case s.Split.Else(default) => c.Split.Else(default)
       case s.Split.Nil => c.Split.Nil
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index 8d34067b17..85952793ad 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -30,7 +30,7 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
       case IfThen(expr, rhs) =>
         splitAnd(expr).foldRight(Split.then(rhs)) {
           case (OperatorIs(scrutinee, pattern), acc) =>
-            TermBranch.Match(scrutinee, PatternBranch(rec(pattern), acc) |> Split.single) |> Split.single
+            TermBranch.Match(scrutinee, PatternBranch(transformPattern(pattern), acc) |> Split.single) |> Split.single
           case (test, acc) => TermBranch.Boolean(test, acc) |> Split.single
         }
       case IfLet(isRec, name, rhs, body) => rare
@@ -40,7 +40,7 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
           case init :+ last =>
             init.foldRight[TermSplit](TermBranch.Match(last, transformPatternMatching(rhs)) |> Split.single) {
               case (OperatorIs(scrutinee, pattern), acc) =>
-                TermBranch.Match(scrutinee, PatternBranch(rec(pattern), acc) |> Split.single) |> Split.single
+                TermBranch.Match(scrutinee, PatternBranch(transformPattern(pattern), acc) |> Split.single) |> Split.single
               case (test, acc) => TermBranch.Boolean(test, acc) |> Split.single
             }
           case _ => rare
@@ -51,7 +51,7 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
             val first = TermBranch.Left(last, OperatorBranch.Binary(op, transformIfBody(rhs)) |> Split.single) |> Split.single
             init.foldRight[TermSplit](first) {
               case (OperatorIs(scrutinee, pattern), acc) =>
-                TermBranch.Match(scrutinee, PatternBranch(rec(pattern), acc) |> Split.single) |> Split.single
+                TermBranch.Match(scrutinee, PatternBranch(transformPattern(pattern), acc) |> Split.single) |> Split.single
               case (test, acc) => TermBranch.Boolean(test, acc) |> Split.single
             }
           case _ => rare
@@ -87,9 +87,9 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
       case IfOpApp(lhs, Var("and"), rhs) =>
         separatePattern(lhs) match {
           case (pattern, S(extraTest)) =>
-            PatternBranch(rec(lhs), ???) |> Split.single
+            PatternBranch(transformPattern(lhs), ???) |> Split.single
           case (pattern, N) =>
-            PatternBranch(rec(lhs), transformIfBody(rhs)) |> Split.single
+            PatternBranch(transformPattern(lhs), transformIfBody(rhs)) |> Split.single
         }
       case IfOpApp(lhs, op, rhs) => ???
       case IfOpsApp(lhs, opsRhss) => ???
@@ -105,18 +105,19 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
     }
   }
 
-  private def rec(term: Term)(implicit useNewDefs: Bool): Pattern = term match {
+  private def transformPattern(term: Term)(implicit useNewDefs: Bool): Pattern = term match {
+    case nme @ Var("true" | "false") => ConcretePattern(nme)
     case nme @ Var(name) if name.headOption.exists(_.isUpper) => ClassPattern(nme, N)
     case nme: Var => NamePattern(nme)
     case literal: Lit => LiteralPattern(literal)
     case App(classNme @ Var(_), Tup(parameters)) =>
       ClassPattern(classNme, S(parameters.map {
         case (_, Fld(_, Var("_"))) => N // Consider "_" as wildcard.
-        case (_, Fld(_, t)) => S(rec(t))
+        case (_, Fld(_, t)) => S(transformPattern(t))
       }))
     case Tup(fields) => TuplePattern(fields.map {
       case _ -> Fld(_, Var("_")) => N // Consider "_" as wildcard.
-      case _ -> Fld(_, t       ) => S(rec(t))
+      case _ -> Fld(_, t       ) => S(transformPattern(t))
     })
     // TODO: Support more patterns.
     case _ => throw new TransformException(msg"Unknown pattern", term.toLoc)
@@ -124,7 +125,7 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
 
   private def separatePattern(term: Term)(implicit useNewDefs: Bool): (Pattern, Opt[Term]) = {
     val (rawPattern, extraTest) = helpers.separatePattern(term, useNewDefs)
-    (rec(rawPattern), extraTest)
+    (transformPattern(rawPattern), extraTest)
   }
 
   private def rare: Nothing = throw new TransformException(msg"Wow, a rare case.", N)
diff --git a/shared/src/main/scala/mlscript/ucs/syntax.scala b/shared/src/main/scala/mlscript/ucs/syntax.scala
index 1137baed5e..61d107bfac 100644
--- a/shared/src/main/scala/mlscript/ucs/syntax.scala
+++ b/shared/src/main/scala/mlscript/ucs/syntax.scala
@@ -10,6 +10,7 @@ package object syntax {
     override def toString(): String = this match {
       case AliasPattern(nme, pattern) => s"$nme @ $pattern"
       case LiteralPattern(literal) => literal.toString
+      case ConcretePattern(nme) => s"`${nme.name}`"
       case NamePattern(nme) => nme.toString
       case ClassPattern(Var(name), N) => name
       case ClassPattern(Var(name), S(parameters)) =>
@@ -25,6 +26,9 @@ package object syntax {
   final case class LiteralPattern(literal: Lit) extends Pattern {
     override def children: List[Located] = literal :: Nil
   }
+  final case class ConcretePattern(nme: Var) extends Pattern {
+    override def children: List[Located] = nme :: Nil
+  }
   final case class NamePattern(nme: Var) extends Pattern {
     override def children: List[Located] = nme :: Nil
   }
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls b/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
index d872381360..ad944a174e 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
@@ -69,7 +69,7 @@ fun unreachable_1(x) =
 //│ | | | | | | | Desugared UCS term:
 //│ | | | | | | | if
 //│ | | | | | | |   x is _
-//│ | | | | | | |     let scrut$0 = f(x,)
+//│ | | | | | | |     let scrut$0 = f(x,) : Bool
 //│ | | | | | | |     scrut$0 is true then "tmux"
 //│ | | | | | | |     else "screen"
 //│ | | | | | | |   x is Some(xv) then "sin"
@@ -136,7 +136,7 @@ fun unreachable_1(x) =
 //│ | | | | | | | | | | normalizeToCaseBranches
 //│ | | | | | | | Normalized UCS term:
 //│ | | | | | | | let _* = x
-//│ | | | | | | | let scrut$0* = f(x,)
+//│ | | | | | | | let scrut$0* = f(x,) : Bool
 //│ | | | | | | | scrut$0 match
 //│ | | | | | | |   case true => "tmux"
 //│ | | | | | | |   case _ => "screen"
@@ -156,7 +156,7 @@ fun unreachable_1(x) =
 //│ | | | | | | | postProcess ==> 
 //│ | | | | | | | Post-processed UCS term:
 //│ | | | | | | | let _* = x
-//│ | | | | | | | let scrut$0* = f(x,)
+//│ | | | | | | | let scrut$0* = f(x,) : Bool
 //│ | | | | | | | scrut$0 match
 //│ | | | | | | |   case true => "tmux"
 //│ | | | | | | |   case _ => "screen"
diff --git a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
index e36980c286..990af73cfe 100644
--- a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
+++ b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
@@ -13,17 +13,21 @@ fun f(x) = if x is Some(1) then true else false
 //│ fun f: (Object & ~#Some | Some[Num]) -> Bool
 
 fun g(x) = if x then 1 else 2
-//│ fun g: Object -> (1 | 2)
+//│ fun g: Bool -> (1 | 2)
+
+:e
+fun test_must_be_boolean(x) = if 0 then 1 else 2
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.19: 	fun test_must_be_boolean(x) = if 0 then 1 else 2
+//│ ║        	                                 ^
+//│ ╙── integer literal of type `0` is not an instance of type `Bool`
+//│ fun test_must_be_boolean: anything -> (1 | 2)
 
 fun g(x) = if x is true then 1 else 2
-//│ fun g: anything -> 1
-//│ Syntax error:
-//│   Invalid destructuring assignment target
+//│ fun g: Eql[true] -> (1 | 2)
 
 fun g(x) = if x && true is true then 1 else 2
-//│ fun g: Bool -> 1
-//│ Syntax error:
-//│   Invalid destructuring assignment target
+//│ fun g: Bool -> (1 | 2)
 
 fun h(x) = if (x : Bool) then 1 else 2
 //│ fun h: Bool -> (1 | 2)

From 8710d4d56329e5fc2e8caaa176c6fd4f16d40a9a Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Fri, 1 Dec 2023 18:58:31 +0800
Subject: [PATCH 010/147] Amend changed files due to the merge

---
 shared/src/test/diff/nu/AbstractClasses.mls | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shared/src/test/diff/nu/AbstractClasses.mls b/shared/src/test/diff/nu/AbstractClasses.mls
index ab09dd59b9..dd80a049ac 100644
--- a/shared/src/test/diff/nu/AbstractClasses.mls
+++ b/shared/src/test/diff/nu/AbstractClasses.mls
@@ -51,7 +51,7 @@ new Foo(1) { fun f = id }
 //│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ error
 //│ Code generation encountered an error:
-//│   cannot generate code for term Rft(App(NuNew(Var(Foo)), Tup(_: IntLit(1))), ...)
+//│   cannot generate code for term Rft(App(NuNew(Var(Foo)), Tup((N, IntLit(1)))), ...)
 
 
 abstract class Bar extends Foo(1)

From 69e8460cd87882e900dfd41d5f2b0ca537684c36 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 20 Dec 2023 01:18:55 +0800
Subject: [PATCH 011/147] Extract the inspect function as a general utility

This commit was cherry-picked from a future commit which changed
many files.
---
 .../scala/mlscript/compiler/ClassLifter.scala |   2 +-
 .../scala/mlscript/compiler/Helpers.scala     |   2 +-
 .../src/main/scala/mlscript/JSBackend.scala   |  11 +-
 .../main/scala/mlscript/codegen/Helpers.scala | 100 ----------
 .../scala/mlscript/pretyper/PreTyper.scala    |   5 +-
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |   1 -
 .../main/scala/mlscript/utils/inspect.scala   | 182 ++++++++++++++++++
 shared/src/test/diff/basics/Blocks.fun        |  10 +-
 shared/src/test/diff/basics/Data.fun          |   4 +-
 shared/src/test/diff/basics/Datatypes.fun     |  14 +-
 shared/src/test/diff/basics/Either.fun        |   4 +-
 shared/src/test/diff/basics/Flow.fun          |   4 +-
 shared/src/test/diff/basics/Operators.fun     |  16 +-
 shared/src/test/diff/basics/Slashes.fun       |   2 +-
 shared/src/test/diff/mlscript/Basics.mls      |   2 +-
 .../src/test/diff/mlscript/ByNameByValue.mls  |   4 +-
 shared/src/test/diff/mlscript/MultiArgs.mls   |   8 +-
 shared/src/test/diff/mlscript/Mut.mls         |   2 +-
 shared/src/test/diff/mlscript/Ops.mls         |  10 +-
 shared/src/test/diff/mlscript/Weird.mls       |   2 +-
 shared/src/test/diff/nu/AbstractClasses.mls   |   2 +-
 shared/src/test/diff/nu/BadBlocks.mls         |   2 +-
 shared/src/test/diff/nu/LamPatterns.mls       |   2 +-
 shared/src/test/diff/nu/LetRec.mls            |   2 +-
 shared/src/test/diff/nu/NewNew.mls            |  10 +-
 shared/src/test/diff/nu/OpLam.mls             |   2 +-
 shared/src/test/diff/nu/OverrideShorthand.mls |   4 +-
 shared/src/test/diff/nu/RightAssocOps.mls     |   6 +-
 shared/src/test/diff/nu/TODO_Classes.mls      |   2 +-
 shared/src/test/diff/ucs/LeadingAnd.mls       |   4 +-
 shared/src/test/diff/ucs/SplitOps.mls         |   4 +-
 .../src/test/scala/mlscript/DiffTests.scala   |   4 +-
 32 files changed, 254 insertions(+), 175 deletions(-)
 delete mode 100644 shared/src/main/scala/mlscript/codegen/Helpers.scala
 create mode 100644 shared/src/main/scala/mlscript/utils/inspect.scala

diff --git a/compiler/shared/main/scala/mlscript/compiler/ClassLifter.scala b/compiler/shared/main/scala/mlscript/compiler/ClassLifter.scala
index 5124a31c56..947db768a7 100644
--- a/compiler/shared/main/scala/mlscript/compiler/ClassLifter.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/ClassLifter.scala
@@ -7,7 +7,7 @@ import scala.collection.mutable.StringBuilder as StringBuilder
 import scala.collection.mutable.Map as MutMap
 import scala.collection.mutable.Set as MutSet
 import scala.collection.mutable.ArrayBuffer as ArrayBuffer
-import mlscript.codegen.Helpers.inspect as showStructure
+import inspect.deep as showStructure
 import mlscript.codegen.CodeGenError
 import mlscript.compiler.mono.MonomorphError
 
diff --git a/compiler/shared/main/scala/mlscript/compiler/Helpers.scala b/compiler/shared/main/scala/mlscript/compiler/Helpers.scala
index 5eb1a526dc..ed842b7049 100644
--- a/compiler/shared/main/scala/mlscript/compiler/Helpers.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/Helpers.scala
@@ -1,7 +1,7 @@
 package mlscript
 package compiler
 
-import mlscript.codegen.Helpers.inspect as showStructure
+import mlscript.utils.inspect.deep as showStructure
 import mlscript.compiler.mono.{Monomorph, MonomorphError}
 import scala.collection.mutable.ArrayBuffer
 
diff --git a/shared/src/main/scala/mlscript/JSBackend.scala b/shared/src/main/scala/mlscript/JSBackend.scala
index 6a3b9e3cc9..621fb7bdcb 100644
--- a/shared/src/main/scala/mlscript/JSBackend.scala
+++ b/shared/src/main/scala/mlscript/JSBackend.scala
@@ -1,7 +1,6 @@
 package mlscript
 
 import mlscript.utils._, shorthands._, algorithms._
-import mlscript.codegen.Helpers._
 import mlscript.codegen._
 import scala.collection.mutable.{ListBuffer, HashMap, HashSet}
 import mlscript.{JSField, JSLit}
@@ -69,7 +68,7 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
     case Inst(bod) => translatePattern(bod)
     case _: Lam | _: App | _: Sel | _: Let | _: Blk | _: Bind | _: Test | _: With | _: CaseOf | _: Subs | _: Assign
         | If(_, _) | New(_, _)  | NuNew(_) | _: Splc | _: Forall | _: Where | _: Super | _: Eqn | _: AdtMatchWith | _: Rft =>
-      throw CodeGenError(s"term ${inspect(t)} is not a valid pattern")
+      throw CodeGenError(s"term ${inspect.deep(t)} is not a valid pattern")
   }
 
   private def translateParams(t: Term)(implicit scope: Scope): Ls[JSPattern] = t match {
@@ -172,7 +171,7 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
       }
       callee(args map { case (_, Fld(_, arg)) => translateTerm(arg) }: _*)
     case App(trm, splice) => ??? // TODO represents `trm(...splice)`
-    case _ => throw CodeGenError(s"ill-formed application ${inspect(term)}")
+    case _ => throw CodeGenError(s"ill-formed application ${inspect.deep(term)}")
   }
 
   /**
@@ -299,7 +298,7 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
         case _: Subs | _: Sel | _: Var =>
           JSCommaExpr(JSAssignExpr(translateTerm(lhs), translateTerm(value)) :: JSArray(Nil) :: Nil)
         case _ =>
-          throw CodeGenError(s"illegal assignemnt left-hand side: ${inspect(lhs)}")
+          throw CodeGenError(s"illegal assignemnt left-hand side: ${inspect.deep(lhs)}")
       }
     case Inst(bod) => translateTerm(bod)
     case iff: If =>
@@ -312,7 +311,7 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
             case n: JSNew => n
             case t => JSNew(t)
           }
-        case _ => throw CodeGenError(s"Unsupported `new` class term: ${inspect(cls)}")
+        case _ => throw CodeGenError(s"Unsupported `new` class term: ${inspect.deep(cls)}")
       }
       // * Would not be quite correct:
       // JSNew(translateTerm(cls))
@@ -330,7 +329,7 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
     case Eqn(Var(name), _) =>
       throw CodeGenError(s"assignment of $name is not supported outside a constructor")
     case _: Bind | _: Test | If(_, _)  | _: Splc | _: Where | _: AdtMatchWith | _: Rft =>
-      throw CodeGenError(s"cannot generate code for term ${inspect(term)}")
+      throw CodeGenError(s"cannot generate code for term ${inspect.deep(term)}")
   }
 
   private def translateCaseBranch(scrut: JSExpr, branch: CaseBranches)(implicit
diff --git a/shared/src/main/scala/mlscript/codegen/Helpers.scala b/shared/src/main/scala/mlscript/codegen/Helpers.scala
deleted file mode 100644
index 5c20613c05..0000000000
--- a/shared/src/main/scala/mlscript/codegen/Helpers.scala
+++ /dev/null
@@ -1,100 +0,0 @@
-package mlscript.codegen
-
-import mlscript._, mlscript.utils.shorthands._
-import scala.collection.immutable.{Map, Set}
-
-object Helpers {
-  /**
-    * Show how a term is actually structured.
-    */
-  def inspect(t: Terms): Str = t match {
-    case Var(name)     => s"Var($name)"
-    case Lam(lhs, rhs) => s"Lam(${inspect(lhs)}, ${inspect(rhs)})"
-    case App(lhs, rhs) => s"App(${inspect(lhs)}, ${inspect(rhs)})"
-    case Tup(fields) =>
-      val entries = fields map {
-        case (S(name), Fld(_, value)) => s"(S(${inspect(name)}), ${inspect(value)})"
-        case (N, Fld(_, value))       => s"(N, ${inspect(value)})"
-      }
-      s"Tup(${entries mkString ", "})"
-    case Rcd(fields) =>
-      val entries = fields.iterator
-        .map { case k -> Fld(_, v) => s"${inspect(k)} = ${inspect(v)}" }
-        .mkString(", ")
-      s"Rcd($entries)"
-    case Sel(receiver, fieldName)    => s"Sel(${inspect(receiver)}, $fieldName)"
-    case Let(isRec, name, rhs, body) => s"Let($isRec, $name, ${inspect(rhs)}, ${inspect(body)})"
-    case Blk(stmts)                  => s"Blk(...)"
-    case Bra(rcd, trm)               => s"Bra(rcd = $rcd, ${inspect(trm)})"
-    case Asc(trm, ty)                => s"Asc(${inspect(trm)}, $ty)"
-    case Bind(lhs, rhs)              => s"Bind(${inspect(lhs)}, ${inspect(rhs)})"
-    case Test(trm, ty)               => s"Test(${inspect(trm)}, ${inspect(ty)})"
-    case With(trm, fields) =>
-      s"With(${inspect(trm)}, ${inspect(fields)})"
-    case CaseOf(trm, cases) =>
-      def inspectCaseBranches(br: CaseBranches): Str = br match {
-        case Case(clsNme, body, rest) =>
-          s"Case($clsNme, ${inspect(body)}, ${inspectCaseBranches(rest)})"
-        case Wildcard(body) => s"Wildcard(${inspect(body)})"
-        case NoCases        => "NoCases"
-      }
-      s"CaseOf(${inspect(trm)}, ${inspectCaseBranches(cases)}"
-    case IntLit(value)  => s"IntLit($value)"
-    case DecLit(value)  => s"DecLit($value)"
-    case StrLit(value)  => s"StrLit($value)"
-    case UnitLit(value)  => s"UnitLit($value)"
-    case Subs(arr, idx) => s"Subs(${inspect(arr)}, ${inspect(idx)})"
-    case Assign(f, v)   => s"Assign(${inspect(f)}, ${inspect(v)})"
-    case Splc(fs)       => 
-      val elems = fs.map{case L(l) => s"...${inspect(l)}" case R(Fld(_, r)) => inspect(r)}.mkString(", ")
-      s"Splc($elems)"
-    case If(bod, els) => s"If(${inspect(bod)}, ${els.map(inspect)})"
-    case New(base, body) => s"New(${base}, ${inspect(body)})"
-    case NuNew(base) => s"NuNew(${inspect(base)})"
-    case TyApp(base, targs) => s"TyApp(${inspect(base)}, ${targs})"
-    case Def(rec, nme, rhs, isByname) =>
-      s"Def($rec, $nme, ${rhs.fold(inspect, "" + _)}, $isByname)"
-    case Where(bod, sts) => s"Where(${inspect(bod)}, ...)"
-    case Forall(ps, bod) => s"Forall($ps, ${inspect(bod)})"
-    case Inst(bod) => s"Inst(${inspect(bod)})"
-    case Eqn(lhs, rhs) => s"Eqn(${inspect(lhs)}, ${inspect(rhs)})"
-    case Super() => "Super()"
-    case AdtMatchWith(cond, arms) =>
-      s"match ${inspect(cond)} with ${arms.map(patmat => s"${inspect(patmat.pat)} -> ${inspect(patmat.rhs)}").mkString(" | ")}"
-    case Rft(bse, tu) => s"Rft(${inspect(bse)}, ...)"
-  }
-
-  def inspect(body: IfBody): Str = body match {
-    case IfElse(expr) => s"IfElse(${inspect(expr)}"
-    case IfThen(expr, rhs) => s"IfThen(${inspect(expr)}, ${inspect(rhs)}"
-    case IfBlock(lines) => s"IfBlock(${
-      lines.iterator.map {
-        case L(body) => inspect(body)
-        case R(NuFunDef(S(isRec), nme, _, _, L(rhs))) =>
-          s"Let($isRec, ${nme.name}, ${inspect(rhs)})"
-        case R(_) => ???
-      }.mkString(";")
-    })"
-    case IfOpsApp(lhs, opsRhss) => s"IfOpsApp(${inspect(lhs)}, ${
-      opsRhss.iterator.map { case (op, body) =>
-        s"$op -> ${inspect(body)}"
-      }
-    }".mkString("; ")
-    case IfLet(isRec, name, rhs, body) => ???
-    case IfOpApp(lhs, op, rhs) =>
-      s"IfOpApp(${inspect(lhs)}, ${inspect(op)}, ${inspect(rhs)}"
-  }
-  def inspect(t: TypingUnit): Str = t.entities.iterator
-    .map {
-      case term: Term => inspect(term)
-      case NuFunDef(lt, nme, symNme, targs, L(term)) =>
-        s"NuFunDef(${lt}, ${nme.name}, $symNme, ${targs.mkString("[", ", ", "]")}, ${inspect(term)})"
-      case NuFunDef(lt, nme, symNme, targs, R(ty)) =>
-        s"NuFunDef(${lt}, ${nme.name}, $symNme, ${targs.mkString("[", ", ", "]")}, $ty)"
-      case NuTypeDef(kind, nme, tparams, params, ctor, sig, parents, sup, ths, body) =>
-        s"NuTypeDef(${kind.str}, ${nme.name}, ${tparams.mkString("(", ", ", ")")}, ${
-          inspect(params.getOrElse(Tup(Nil)))}, ${parents.map(inspect).mkString("(", ", ", ")")}, $sup, $ths, ${inspect(body)})"
-      case others => others.toString()
-    }
-    .mkString("TypingUnit(", ", ", ")")
-}
diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index a3f27e6caf..e4e4cfee08 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -2,7 +2,6 @@ package mlscript.pretyper
 
 import mlscript.ucs.DesugarUCS
 import mlscript._, utils._, shorthands._
-import mlscript.codegen.Helpers.inspect
 
 class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Traceable with DesugarUCS {
   protected def raise(diagnostics: Ls[Diagnostic]): Unit = ()
@@ -24,9 +23,9 @@ class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Trac
     case PlainTup(arguments @ _*) =>
       arguments.map {
         case nme: Var => new ValueSymbol(nme, false)
-        case other => println("Unknown parameters: " + inspect(other)); ??? // TODO: bad
+        case other => println("Unknown parameters: " + inspect.deep(other)); ??? // TODO: bad
       }.toList
-    case other => println("Unknown parameters: " + inspect(other)); ??? // TODO: bad
+    case other => println("Unknown parameters: " + inspect.deep(other)); ??? // TODO: bad
   }
 
   // `traverseIf` is meaningless because it represents patterns with terms.
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 5bee605601..0c09de16a2 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -4,7 +4,6 @@ import collection.mutable.{Map => MutMap}
 import mlscript.ucs.stages._
 import mlscript.pretyper.{PreTyper, Scope, ScrutineeSymbol, Symbol, ValueSymbol}
 import mlscript._, utils._, shorthands._
-import mlscript.codegen.Helpers.inspect
 import mlscript.Message, Message.MessageContext
 
 // TODO: Rename to `Desugarer` once the old desugarer is removed.
diff --git a/shared/src/main/scala/mlscript/utils/inspect.scala b/shared/src/main/scala/mlscript/utils/inspect.scala
new file mode 100644
index 0000000000..3e4fa7d912
--- /dev/null
+++ b/shared/src/main/scala/mlscript/utils/inspect.scala
@@ -0,0 +1,182 @@
+package mlscript.utils
+
+import mlscript._, shorthands._
+
+object inspect {
+  object shallow {
+    def apply(term: Statement): Str = term match {
+      case Var(name) => s"Var(\"$name\")"
+      case literal: Lit => s"Lit(${literal.toString})"
+      case fd: NuFunDef => fd.isLetRec.fold("fun")(if (_) "let rec" else "let") + " " + fd.nme.name
+      case td: NuTypeDef => s"${td.kind.str} ${td.nme.name}"
+      case _ =>
+        val name = term.getClass.getSimpleName
+        val arity = term.children.length // Imprecise
+        if (arity === 0) { name } else s"${name}(${(", _" * arity).drop(2)})"
+    }
+
+    def apply(d: TypingUnit): Str = d.entities.iterator
+      .map(apply)
+      .mkString("{", ", ", "}")
+  }
+
+  object deep {
+    def apply(t: Opt[Located]): Str = t match {
+      case N => "N"
+      case S(l) => s"S(${apply(l)})"
+    }
+
+    def apply(t: Ls[Located]): Str = t match {
+      case Nil => "Nil"
+      case head :: Nil => s"${apply(head)} :: Nil"
+      case first :: second :: Nil => s"${apply(first)} :: ${apply(second)} :: Nil"
+      case _ => t.iterator.map(apply).mkString("Ls(", ", ", ")")
+    }
+
+    def apply[A <: Located, B <: Located](t: Either[A, B]): Str = t match {
+      case L(value) => s"L(${apply(value)})"
+      case R(value) => s"R(${apply(value)})"
+    }
+
+    def apply(t: Located): Str = t match {
+      case st: Statement => statement(st)
+      case fl: Field => field(fl)
+      case ty: TypeLike => typeLike(ty)
+      case ib: IfBody => ifBody(ib)
+      case tu: TypingUnit => typingUnit(tu)
+      case _ => "??"
+    }
+
+    private def statement(statement: Statement): Str = statement match {
+      case Def(rec, nme, rhs, isByname) => s"Def($rec, ${apply(nme)}, ${apply(rhs)}, $isByname)"
+      case TypeDef(kind, nme, tparams, body, mthDecls, mthDefs, positionals, adtInfo) => s"TypeDef(...)"
+      case Var(name)     => s"Var(\"$name\")"
+      case Lam(lhs, rhs) => s"Lam(${apply(lhs)}, ${apply(rhs)})"
+      case App(lhs, rhs) => s"App(${apply(lhs)}, ${apply(rhs)})"
+      case Tup(fields) =>
+        fields.iterator.map {
+          case (S(name), Fld(_, value)) => s"(S(${apply(name)}), ${apply(value)})"
+          case (N, Fld(_, value))       => s"(N, ${apply(value)})"
+        }.mkString("Tup(", ", ", ")")
+      case Rcd(fields) =>
+        fields.iterator.map { case k -> Fld(_, v) => s"${apply(k)} = ${apply(v)}" }.mkString("Rcd(", ", ", ")")
+      case Sel(receiver, fieldName)    => s"Sel(${apply(receiver)}, $fieldName)"
+      case Let(isRec, name, rhs, body) => s"Let($isRec, $name, ${apply(rhs)}, ${apply(body)})"
+      case Blk(stmts)                  => s"Blk(${stmts.iterator.map(apply).mkString(", ")})"
+      case Bra(rcd, trm)               => s"Bra(rcd = $rcd, ${apply(trm)})"
+      case Asc(trm, ty)                => s"Asc(${apply(trm)}, $ty)"
+      case Bind(lhs, rhs)              => s"Bind(${apply(lhs)}, ${apply(rhs)})"
+      case Test(trm, ty)               => s"Test(${apply(trm)}, ${apply(ty)})"
+      case With(trm, fields) =>
+        s"With(${apply(trm)}, ${apply(fields)})"
+      case CaseOf(trm, cases) =>
+        def inspectCaseBranches(br: CaseBranches): Str = br match {
+          case Case(clsNme, body, rest) =>
+            s"Case($clsNme, ${apply(body)}, ${inspectCaseBranches(rest)})"
+          case Wildcard(body) => s"Wildcard(${apply(body)})"
+          case NoCases        => "NoCases"
+        }
+        s"CaseOf(${apply(trm)}, ${inspectCaseBranches(cases)}"
+      case IntLit(value)  => s"IntLit($value)"
+      case DecLit(value)  => s"DecLit($value)"
+      case StrLit(value)  => s"StrLit($value)"
+      case UnitLit(value)  => s"UnitLit($value)"
+      case Subs(arr, idx) => s"Subs(${apply(arr)}, ${apply(idx)})"
+      case Assign(f, v)   => s"Assign(${apply(f)}, ${apply(v)})"
+      case Splc(fs)       => 
+        fs.iterator.map{ case L(l) => s"...${apply(l)}" case R(Fld(_, r)) => apply(r)}.mkString("Splc(", ", ", ")")
+      case If(bod, els) => s"If(${apply(bod)}, ${els.map(apply)})"
+      case New(base, body) => s"New(${base}, ${apply(body)})"
+      case NuNew(base) => s"NuNew(${apply(base)})"
+      case TyApp(base, targs) => s"TyApp(${apply(base)}, ${targs})"
+      case Where(bod, sts) => s"Where(${apply(bod)}, ...)"
+      case Forall(ps, bod) => s"Forall($ps, ${apply(bod)})"
+      case Inst(bod) => s"Inst(${apply(bod)})"
+      case Eqn(lhs, rhs) => s"Eqn(${apply(lhs)}, ${apply(rhs)})"
+      case Super() => "Super()"
+      case AdtMatchWith(cond, arms) =>
+        s"match ${apply(cond)} with ${arms.map(patmat => s"${apply(patmat.pat)} -> ${apply(patmat.rhs)}").mkString(" | ")}"
+      case Rft(bse, tu) => s"Rft(${apply(bse)}, ${apply(tu)})"
+      case LetS(isRec, pat, rhs) => s"LetS($isRec, ${apply(pat)}, ${apply(rhs)})"
+      case DataDefn(body) => s"DataDefn(${apply(body)})"
+      case DatatypeDefn(head, body) => s"DatatypeDefn(${apply(head)}, ${apply(body)})"
+      case NuTypeDef(kind, nme, tparams, params, ctor, sig, parents, superAnnot, thisAnnot, body) =>
+        s"NuTypeDef($kind, ${apply(nme)}, Ls(" +
+          tparams.iterator.map {
+            case (S(vi), tn) => s"S($vi) -> ${apply(tn)}"
+            case (N, tn) => s"N -> ${apply(tn)}"
+          }.mkString(", ") + "), " +
+          apply(params) + ", " +
+          apply(ctor) + ", " +
+          apply(sig) + ", " +
+          parents.iterator.map(apply).mkString("Ls(", ", ", ")") + ", " +
+          apply(superAnnot) + ", " +
+          apply(thisAnnot) + ", " +
+          apply(body) + ")"
+      case NuFunDef(isLetRec, nme, symbolicNme, tparams, rhs) =>
+        s"NuFunDef($isLetRec, ${nme.name}, ${apply(symbolicNme)}, ${apply(tparams)}, ${apply(rhs)})"
+      case Constructor(params, body) => s"Constructor"
+    }
+
+    private def field(field: Field): Str = field match {
+      case Field(nme, value) => s"Fld(${apply(nme)}, ${apply(value)})"
+    }
+
+    private def typeLike(ty: TypeLike): Str = ty match {
+      case Union(lhs, rhs) => s"Union(${apply(lhs)}, ${apply(rhs)})"
+      case Inter(lhs, rhs) => s"Inter(${apply(lhs)}, ${apply(rhs)})"
+      case Function(lhs, rhs) => s"Function(${apply(lhs)}, ${apply(rhs)})"
+      case Record(fields) => s"Record(${fields.iterator.map { case (nme, ty) => s"$nme: ${apply(ty)}" }.mkString(", ")})"
+      case Tuple(fields) => s"Tuple(${fields.iterator.map {
+        case N -> field => s"N -> ${apply(field)}"
+        case S(nme) -> field => s"S($nme) -> ${apply(field)}"
+      }.mkString(", ")})"
+      case Recursive(uv, body) => s"Recursive(${apply(uv)}, ${apply(body)})"
+      case AppliedType(base, targs) => s"AppliedType(${apply(base)}, ${apply(targs)})"
+      case Selection(base, name) => s"Selection(${apply(base)}, $name)"
+      case Neg(base) => s"Neg(${apply(base)})"
+      case Rem(base, names) => s"Rem(${apply(base)}, ${names.iterator.map(apply).mkString(", ")})"
+      case Bounds(lb, ub) => s"Bounds(${apply(lb)}, ${apply(ub)})"
+      case WithExtension(base, rcd) => s"WithExtension(${apply(base)}, ${apply(rcd)})"
+      case Splice(fields) => s"Splice(${fields.iterator.map {
+        case L(l) => s"L(${apply(l)})"
+        case R(f) => s"R(${apply(f)})"
+      }.mkString(", ")})"
+      case Constrained(base, tvBounds, where) => s"Constrained(${apply(base)}, Ls(${tvBounds.iterator.map {
+        case (tv, bounds) => s"${apply(tv)} -> ${apply(bounds)}"
+      }}), ${apply(where)})"
+      case Top => "Top"
+      case Bot => "Bot"
+      case Literal(lit) => s"Literal(${lit.toString})"
+      case TypeName(name) => s"TypeName(\"$name\")"
+      case TypeTag(name) => s"TypeTag($name)"
+      case TypeVar(identifier, nameHint) => s"TypeVar(${identifier match {
+        case L(i) => s"L($i)"
+        case R(n) => s"R($n)"
+      }}, ${nameHint.fold("N")(n => s"S($n)")})"
+      case PolyType(targs, body) => s"PolyType(Ls(${targs.iterator.map(_.fold(apply, apply)).mkString(", ")}), ${apply(body)})"
+      case Signature(members, result) => s"Signature(${members.iterator.map(apply(_: Statement)).mkString("Ls(", ", ", ")")}, ${apply(result)})"
+      case t: NuDecl => apply(t: Statement)
+    }
+
+    private def ifBody(body: IfBody): Str = body match {
+      case IfElse(expr) => s"IfElse(${apply(expr)}"
+      case IfThen(expr, rhs) => s"IfThen(${apply(expr)}, ${apply(rhs)}"
+      case IfBlock(lines) => s"IfBlock(${
+        lines.iterator.map(_.fold(apply, apply)).mkString("Ls(", ", ", ")")
+      })"
+      case IfOpsApp(lhs, opsRhss) => s"IfOpsApp(${apply(lhs)}, ${
+        opsRhss.iterator.map { case (op, body) =>
+          s"$op -> ${apply(body)}"
+        }
+      }".mkString("; ")
+      case IfLet(isRec, name, rhs, body) => ???
+      case IfOpApp(lhs, op, rhs) =>
+        s"IfOpApp(${apply(lhs)}, ${apply(op)}, ${apply(rhs)}"
+    }
+
+    private def typingUnit(t: TypingUnit): Str = t.entities.iterator
+      .map(apply)
+      .mkString("TypingUnit(", ", ", ")")
+  }
+}
\ No newline at end of file
diff --git a/shared/src/test/diff/basics/Blocks.fun b/shared/src/test/diff/basics/Blocks.fun
index 65d88924eb..3d0a46eeb5 100644
--- a/shared/src/test/diff/basics/Blocks.fun
+++ b/shared/src/test/diff/basics/Blocks.fun
@@ -44,7 +44,7 @@ discard / foo
     1
 //│ Parsed: discard(...(foo(...{1})));
 //│ Desugared: discard(...(foo(...{1})))
-//│ AST: App(Var(discard), App(Var(foo), Blk(...)))
+//│ AST: App(Var("discard"), App(Var("foo"), Blk(IntLit(1))))
 
 :e
 discard foo
@@ -81,7 +81,7 @@ id id
   id
 //│ Parsed: id(...id)(...{id});
 //│ Desugared: id(...id)(...{id})
-//│ AST: App(App(Var(id), Var(id)), Blk(...))
+//│ AST: App(App(Var("id"), Var("id")), Blk(Var("id")))
 //│ res: 'a -> 'a
 
 :p
@@ -91,7 +91,7 @@ id id id
       id id id
 //│ Parsed: id(...id)(...id)(...{id(...id)(...id)(...{id(...id)(...id)(...{id(...id)(...id)})})});
 //│ Desugared: id(...id)(...id)(...{id(...id)(...id)(...{id(...id)(...id)(...{id(...id)(...id)})})})
-//│ AST: App(App(App(Var(id), Var(id)), Var(id)), Blk(...))
+//│ AST: App(App(App(Var("id"), Var("id")), Var("id")), Blk(App(App(App(Var("id"), Var("id")), Var("id")), Blk(App(App(App(Var("id"), Var("id")), Var("id")), Blk(App(App(Var("id"), Var("id")), Var("id"))))))))
 //│ res: 'a -> 'a
 
 :p
@@ -100,7 +100,7 @@ id id /
     id id
 //│ Parsed: id(...id)(...{id(...id)(...{id(...id)})});
 //│ Desugared: id(...id)(...{id(...id)(...{id(...id)})})
-//│ AST: App(App(Var(id), Var(id)), Blk(...))
+//│ AST: App(App(Var("id"), Var("id")), Blk(App(App(Var("id"), Var("id")), Blk(App(Var("id"), Var("id"))))))
 //│ res: 'a -> 'a
 
 :p
@@ -109,7 +109,7 @@ id id
   id id
 //│ Parsed: id(...id)(...{id(...id)})(...{id(...id)});
 //│ Desugared: id(...id)(...{id(...id)})(...{id(...id)})
-//│ AST: App(App(App(Var(id), Var(id)), Blk(...)), Blk(...))
+//│ AST: App(App(App(Var("id"), Var("id")), Blk(App(Var("id"), Var("id")))), Blk(App(Var("id"), Var("id"))))
 //│ res: 'a -> 'a
 
 let foo =
diff --git a/shared/src/test/diff/basics/Data.fun b/shared/src/test/diff/basics/Data.fun
index f155732eec..d30a7ba979 100644
--- a/shared/src/test/diff/basics/Data.fun
+++ b/shared/src/test/diff/basics/Data.fun
@@ -4,7 +4,7 @@ data Test a b
 //│ Parsed: data Test(...a)(...b);
 //│ Desugared: class Test[a, b]: {a: a, b: b}
 //│ Desugared: def Test: forall a b. (...a) -> (...b) -> Test[a, b]
-//│ AST: Def(false, Test, PolyType(List(Left(TypeName(a)), Left(TypeName(b))),Function(TypeName(a),Function(TypeName(b),AppliedType(TypeName(Test),List(TypeName(a), TypeName(b)))))), true)
+//│ AST: Def(false, Var("Test"), R(PolyType(Ls(TypeName("a"), TypeName("b")), Function(TypeName("a"), Function(TypeName("b"), AppliedType(TypeName("Test"), TypeName("a") :: TypeName("b") :: Nil))))), true)
 //│ Defined class Test[+a, +b]
 //│ Test: 'a -> 'b -> Test['a, 'b]
 
@@ -13,7 +13,7 @@ data Person(name: string, age: int)
 //│ Parsed: data Person(...'(' {[name: string, age: int,]} ')');
 //│ Desugared: class Person: {age: int, name: string}
 //│ Desugared: def Person: (name: string, age: int) -> Person[]
-//│ AST: Def(false, Person, PolyType(List(),Function(Tuple(List((Some(name),Field(None,TypeName(string))), (Some(age),Field(None,TypeName(int))))),AppliedType(TypeName(Person),List()))), true)
+//│ AST: Def(false, Var("Person"), R(PolyType(Ls(), Function(Tuple(S(name) -> Fld(N, TypeName("string")), S(age) -> Fld(N, TypeName("int"))), AppliedType(TypeName("Person"), Nil)))), true)
 //│ Defined class Person
 //│ Person: (name: string, age: int,) -> Person
 
diff --git a/shared/src/test/diff/basics/Datatypes.fun b/shared/src/test/diff/basics/Datatypes.fun
index 2b2b0e7379..89f0a68995 100644
--- a/shared/src/test/diff/basics/Datatypes.fun
+++ b/shared/src/test/diff/basics/Datatypes.fun
@@ -6,9 +6,9 @@ data type Boolean of Tru, Fals
 //│ Desugared: class Tru: {}
 //│ Desugared: class Fals: {}
 //│ Desugared: def Tru: Tru[]
-//│ AST: Def(false, Tru, PolyType(List(),AppliedType(TypeName(Tru),List())), true)
+//│ AST: Def(false, Var("Tru"), R(PolyType(Ls(), AppliedType(TypeName("Tru"), Nil))), true)
 //│ Desugared: def Fals: Fals[]
-//│ AST: Def(false, Fals, PolyType(List(),AppliedType(TypeName(Fals),List())), true)
+//│ AST: Def(false, Var("Fals"), R(PolyType(Ls(), AppliedType(TypeName("Fals"), Nil))), true)
 //│ Defined type alias Boolean
 //│ Defined class Tru
 //│ Defined class Fals
@@ -29,7 +29,7 @@ data type Bool2 of True2 & False2
 //│ Desugared: type alias Bool2 = &[True2, False2]
 //│ Desugared: class &[True2, False2]: {False2 <: False2, True2 <: True2}
 //│ Desugared: def &: forall True2 False2. (...True2) -> (...False2) -> &[True2, False2]
-//│ AST: Def(false, &, PolyType(List(Left(TypeName(True2)), Left(TypeName(False2))),Function(TypeName(True2),Function(TypeName(False2),AppliedType(TypeName(&),List(TypeName(True2), TypeName(False2)))))), true)
+//│ AST: Def(false, Var("&"), R(PolyType(Ls(TypeName("True2"), TypeName("False2")), Function(TypeName("True2"), Function(TypeName("False2"), AppliedType(TypeName("&"), TypeName("True2") :: TypeName("False2") :: Nil))))), true)
 //│ ╔══[ERROR] type identifier not found: True2
 //│ ║  l.27: 	data type Bool2 of True2 & False2
 //│ ╙──      	                   ^^^^^
@@ -122,9 +122,9 @@ data type List a of
 //│ Desugared: class Nil[a]: {}
 //│ Desugared: class Cons[a]: {head: a, tail: anything}
 //│ Desugared: def Nil: forall a. Nil[a]
-//│ AST: Def(false, Nil, PolyType(List(Left(TypeName(a))),AppliedType(TypeName(Nil),List(TypeName(a)))), true)
+//│ AST: Def(false, Var("Nil"), R(PolyType(Ls(TypeName("a")), AppliedType(TypeName("Nil"), TypeName("a") :: Nil))), true)
 //│ Desugared: def Cons: forall a. (head: a) -> (tail: anything) -> Cons[a]
-//│ AST: Def(false, Cons, PolyType(List(Left(TypeName(a))),Function(Tuple(List((Some(head),Field(None,TypeName(a))))),Function(Tuple(List((Some(tail),Field(None,Top)))),AppliedType(TypeName(Cons),List(TypeName(a)))))), true)
+//│ AST: Def(false, Var("Cons"), R(PolyType(Ls(TypeName("a")), Function(Tuple(S(head) -> Fld(N, TypeName("a"))), Function(Tuple(S(tail) -> Fld(N, Top)), AppliedType(TypeName("Cons"), TypeName("a") :: Nil))))), true)
 //│ Defined type alias List[+a]
 //│ Defined class Nil[±a]
 //│ Defined class Cons[+a]
@@ -144,7 +144,7 @@ data type Ls of LsA a
 //│ Desugared: type alias Ls = LsA[a]
 //│ Desugared: class LsA[a]: {a: a}
 //│ Desugared: def LsA: forall a. (...a) -> LsA[a]
-//│ AST: Def(false, LsA, PolyType(List(Left(TypeName(a))),Function(TypeName(a),AppliedType(TypeName(LsA),List(TypeName(a))))), true)
+//│ AST: Def(false, Var("LsA"), R(PolyType(Ls(TypeName("a")), Function(TypeName("a"), AppliedType(TypeName("LsA"), TypeName("a") :: Nil)))), true)
 //│ ╔══[ERROR] type identifier not found: a
 //│ ║  l.142: 	data type Ls of LsA a
 //│ ╙──       	                    ^
@@ -159,7 +159,7 @@ data type Ls2 of LsA2 `a
 //│ Desugared: type alias Ls2 = LsA2[]
 //│ Desugared: class LsA2: {`a: 'a}
 //│ Desugared: def LsA2: (...'a) -> LsA2[]
-//│ AST: Def(false, LsA2, PolyType(List(),Function(a,AppliedType(TypeName(LsA2),List()))), true)
+//│ AST: Def(false, Var("LsA2"), R(PolyType(Ls(), Function(TypeVar(R(a), N), AppliedType(TypeName("LsA2"), Nil)))), true)
 //│ ╔══[ERROR] cannot inherit from a polymorphic type
 //│ ║  l.157: 	data type Ls2 of LsA2 `a
 //│ ╙──       	                 ^^^^^^^
diff --git a/shared/src/test/diff/basics/Either.fun b/shared/src/test/diff/basics/Either.fun
index 7ea04bae6f..02a3655672 100644
--- a/shared/src/test/diff/basics/Either.fun
+++ b/shared/src/test/diff/basics/Either.fun
@@ -9,9 +9,9 @@ data type Either l r of
 //│ Desugared: class Left[l, r]: {l: l}
 //│ Desugared: class Right[l, r]: {r: r}
 //│ Desugared: def Left: forall l r. (...l) -> Left[l, r]
-//│ AST: Def(false, Left, PolyType(List(Left(TypeName(l)), Left(TypeName(r))),Function(TypeName(l),AppliedType(TypeName(Left),List(TypeName(l), TypeName(r))))), true)
+//│ AST: Def(false, Var("Left"), R(PolyType(Ls(TypeName("l"), TypeName("r")), Function(TypeName("l"), AppliedType(TypeName("Left"), TypeName("l") :: TypeName("r") :: Nil)))), true)
 //│ Desugared: def Right: forall l r. (...r) -> Right[l, r]
-//│ AST: Def(false, Right, PolyType(List(Left(TypeName(l)), Left(TypeName(r))),Function(TypeName(r),AppliedType(TypeName(Right),List(TypeName(l), TypeName(r))))), true)
+//│ AST: Def(false, Var("Right"), R(PolyType(Ls(TypeName("l"), TypeName("r")), Function(TypeName("r"), AppliedType(TypeName("Right"), TypeName("l") :: TypeName("r") :: Nil)))), true)
 //│ Defined type alias Either[+l, +r]
 //│ Defined class Left[+l, ±r]
 //│ Defined class Right[±l, +r]
diff --git a/shared/src/test/diff/basics/Flow.fun b/shared/src/test/diff/basics/Flow.fun
index 5005f8a42c..16b7c5a1d4 100644
--- a/shared/src/test/diff/basics/Flow.fun
+++ b/shared/src/test/diff/basics/Flow.fun
@@ -6,9 +6,9 @@ data R x
 //│ Desugared: class L[x]: {x: x}
 //│ Desugared: class R[x]: {x: x}
 //│ Desugared: def L: forall x. (...x) -> L[x]
-//│ AST: Def(false, L, PolyType(List(Left(TypeName(x))),Function(TypeName(x),AppliedType(TypeName(L),List(TypeName(x))))), true)
+//│ AST: Def(false, Var("L"), R(PolyType(Ls(TypeName("x")), Function(TypeName("x"), AppliedType(TypeName("L"), TypeName("x") :: Nil)))), true)
 //│ Desugared: def R: forall x. (...x) -> R[x]
-//│ AST: Def(false, R, PolyType(List(Left(TypeName(x))),Function(TypeName(x),AppliedType(TypeName(R),List(TypeName(x))))), true)
+//│ AST: Def(false, Var("R"), R(PolyType(Ls(TypeName("x")), Function(TypeName("x"), AppliedType(TypeName("R"), TypeName("x") :: Nil)))), true)
 //│ Defined class L[+x]
 //│ Defined class R[+x]
 //│ L: 'a -> L['a]
diff --git a/shared/src/test/diff/basics/Operators.fun b/shared/src/test/diff/basics/Operators.fun
index bbf5eff5cc..845354e70b 100644
--- a/shared/src/test/diff/basics/Operators.fun
+++ b/shared/src/test/diff/basics/Operators.fun
@@ -16,7 +16,7 @@ a +
   b
 //│ Parsed: +(...a)(...{b});
 //│ Desugared: +(...a)(...{b})
-//│ AST: App(App(Var(+), Var(a)), Blk(...))
+//│ AST: App(App(Var("+"), Var("a")), Blk(Var("b")))
 //│ res: int
 
 :pe
@@ -31,7 +31,7 @@ succ a +
     c
 //│ Parsed: +(...(succ(...a)))(...{+(...b)(...{c})});
 //│ Desugared: +(...(succ(...a)))(...{+(...b)(...{c})})
-//│ AST: App(App(Var(+), App(Var(succ), Var(a))), Blk(...))
+//│ AST: App(App(Var("+"), App(Var("succ"), Var("a"))), Blk(App(App(Var("+"), Var("b")), Blk(Var("c")))))
 //│ res: int
 
 :p
@@ -40,7 +40,7 @@ succ / a +
     c
 //│ Parsed: succ(...(+(...a)(...{+(...b)(...{c})})));
 //│ Desugared: succ(...(+(...a)(...{+(...b)(...{c})})))
-//│ AST: App(Var(succ), App(App(Var(+), Var(a)), Blk(...)))
+//│ AST: App(Var("succ"), App(App(Var("+"), Var("a")), Blk(App(App(Var("+"), Var("b")), Blk(Var("c"))))))
 //│ res: int
 
 :p
@@ -55,11 +55,11 @@ a
   + d
 //│ Parsed: +(...a)(...b); +(...(+(...a)(...b)))(...c); +(...(+(...(+(...a)(...b)))(...c)))(...d);
 //│ Desugared: +(...a)(...b)
-//│ AST: App(App(Var(+), Var(a)), Var(b))
+//│ AST: App(App(Var("+"), Var("a")), Var("b"))
 //│ Desugared: +(...(+(...a)(...b)))(...c)
-//│ AST: App(App(Var(+), App(App(Var(+), Var(a)), Var(b))), Var(c))
+//│ AST: App(App(Var("+"), App(App(Var("+"), Var("a")), Var("b"))), Var("c"))
 //│ Desugared: +(...(+(...(+(...a)(...b)))(...c)))(...d)
-//│ AST: App(App(Var(+), App(App(Var(+), App(App(Var(+), Var(a)), Var(b))), Var(c))), Var(d))
+//│ AST: App(App(Var("+"), App(App(Var("+"), App(App(Var("+"), Var("a")), Var("b"))), Var("c"))), Var("d"))
 //│ res: int
 //│ res: int
 //│ res: int
@@ -74,7 +74,7 @@ a
   + d
 //│ Parsed: +(...(+(...(+(...a)(...b)))(...(+(...(+(...c)(...1)))(...(+(...2)(...3)))))))(...d);
 //│ Desugared: +(...(+(...(+(...a)(...b)))(...(+(...(+(...c)(...1)))(...(+(...2)(...3)))))))(...d)
-//│ AST: App(App(Var(+), App(App(Var(+), App(App(Var(+), Var(a)), Var(b))), App(App(Var(+), App(App(Var(+), Var(c)), IntLit(1))), App(App(Var(+), IntLit(2)), IntLit(3))))), Var(d))
+//│ AST: App(App(Var("+"), App(App(Var("+"), App(App(Var("+"), Var("a")), Var("b"))), App(App(Var("+"), App(App(Var("+"), Var("c")), IntLit(1))), App(App(Var("+"), IntLit(2)), IntLit(3))))), Var("d"))
 //│ res: int
 
 :pe
@@ -112,7 +112,7 @@ succ
   + c
 //│ Parsed: +(...(succ(...{+(...a)(...b)})))(...c);
 //│ Desugared: +(...(succ(...{+(...a)(...b)})))(...c)
-//│ AST: App(App(Var(+), App(Var(succ), Blk(...))), Var(c))
+//│ AST: App(App(Var("+"), App(Var("succ"), Blk(App(App(Var("+"), Var("a")), Var("b"))))), Var("c"))
 //│ res: int
 
 // Maybe allow this as it lets us nicely align the operands?
diff --git a/shared/src/test/diff/basics/Slashes.fun b/shared/src/test/diff/basics/Slashes.fun
index ef7aef7047..09db214d62 100644
--- a/shared/src/test/diff/basics/Slashes.fun
+++ b/shared/src/test/diff/basics/Slashes.fun
@@ -23,7 +23,7 @@ x => succ / succ / x + 1
 foo / x => succ / succ / x
 //│ Parsed: foo(...((...x) => succ(...(succ(...x)))));
 //│ Desugared: foo(...((...x) => succ(...(succ(...x)))))
-//│ AST: App(Var(foo), Lam(Var(x), App(Var(succ), App(Var(succ), Var(x)))))
+//│ AST: App(Var("foo"), Lam(Var("x"), App(Var("succ"), App(Var("succ"), Var("x")))))
 //│ res: int
 
 :e
diff --git a/shared/src/test/diff/mlscript/Basics.mls b/shared/src/test/diff/mlscript/Basics.mls
index f6ec00c72a..2fb3e1b4a0 100644
--- a/shared/src/test/diff/mlscript/Basics.mls
+++ b/shared/src/test/diff/mlscript/Basics.mls
@@ -96,7 +96,7 @@ def f (x y z) = add x y
 //│ ╙──      	       ^^^^^
 //│ f: error -> int
 //│ Code generation encountered an error:
-//│   term App(App(Var(x), Tup((N, Var(y)))), Tup((N, Var(z)))) is not a valid pattern
+//│   term App(App(Var("x"), Tup((N, Var("y")))), Tup((N, Var("z")))) is not a valid pattern
 
 f 1
 //│ res: int
diff --git a/shared/src/test/diff/mlscript/ByNameByValue.mls b/shared/src/test/diff/mlscript/ByNameByValue.mls
index be234e2ca8..5d48161808 100644
--- a/shared/src/test/diff/mlscript/ByNameByValue.mls
+++ b/shared/src/test/diff/mlscript/ByNameByValue.mls
@@ -16,7 +16,7 @@ def incr x = x.a <- x.a + 1
 def gensym = let n = { mut a = 0 } in fun () -> (incr n, n)
 //│ Parsed: def gensym: let n = {mut a: 0} in () => [incr(n,), n,];
 //│ Desugared: def gensym: let n = {mut a: 0} in () => [incr(n,), n,]
-//│ AST: Def(false, gensym, Let(false, n, Rcd(Var(a) = IntLit(0)), Lam(Tup(), Tup((N, App(Var(incr), Tup((N, Var(n))))), (N, Var(n))))), true)
+//│ AST: Def(false, Var("gensym"), L(Let(false, n, Rcd(Var("a") = IntLit(0)), Lam(Tup(), Tup((N, App(Var("incr"), Tup((N, Var("n"))))), (N, Var("n")))))), true)
 //│ // Query 1
 //│ globalThis.gensym = function gensym() {
 //│   return (((n) => () => [
@@ -35,7 +35,7 @@ def gensym = let n = { mut a = 0 } in fun () -> (incr n, n)
 gensym1 = let n = { mut a = 0 } in fun () -> (incr n, n)
 //│ Parsed: let gensym1 = let n = {mut a: 0} in () => [incr(n,), n,];
 //│ Desugared: def gensym1: let n = {mut a: 0} in () => [incr(n,), n,]
-//│ AST: Def(false, gensym1, Let(false, n, Rcd(Var(a) = IntLit(0)), Lam(Tup(), Tup((N, App(Var(incr), Tup((N, Var(n))))), (N, Var(n))))), false)
+//│ AST: Def(false, Var("gensym1"), L(Let(false, n, Rcd(Var("a") = IntLit(0)), Lam(Tup(), Tup((N, App(Var("incr"), Tup((N, Var("n"))))), (N, Var("n")))))), false)
 //│ // Query 1
 //│ globalThis.gensym1 = ((n) => () => [
 //│   incr(n),
diff --git a/shared/src/test/diff/mlscript/MultiArgs.mls b/shared/src/test/diff/mlscript/MultiArgs.mls
index 0c5f8e7d81..738d356769 100644
--- a/shared/src/test/diff/mlscript/MultiArgs.mls
+++ b/shared/src/test/diff/mlscript/MultiArgs.mls
@@ -75,9 +75,9 @@ f = fun (x, y) -> add x y
 f(1, 2)
 //│ Parsed: let f = (x, y,) => add(x,)(y,); f(1, 2,);
 //│ Desugared: def f: (x, y,) => add(x,)(y,)
-//│ AST: Def(false, f, Lam(Tup((N, Var(x)), (N, Var(y))), App(App(Var(add), Tup((N, Var(x)))), Tup((N, Var(y))))), false)
+//│ AST: Def(false, Var("f"), L(Lam(Tup((N, Var("x")), (N, Var("y"))), App(App(Var("add"), Tup((N, Var("x")))), Tup((N, Var("y")))))), false)
 //│ Desugared: f(1, 2,)
-//│ AST: App(Var(f), Tup((N, IntLit(1)), (N, IntLit(2))))
+//│ AST: App(Var("f"), Tup((N, IntLit(1)), (N, IntLit(2))))
 //│ f: (int, int,) -> int
 //│  = [Function: f]
 //│ res: int
@@ -119,9 +119,9 @@ f = fun ((x, y)) -> add x y
 f((1, 2))
 //│ Parsed: let f = ('(' [x, y,] ')',) => add(x,)(y,); f('(' [1, 2,] ')',);
 //│ Desugared: def f: ('(' [x, y,] ')',) => add(x,)(y,)
-//│ AST: Def(false, f, Lam(Tup((N, Bra(rcd = false, Tup((N, Var(x)), (N, Var(y)))))), App(App(Var(add), Tup((N, Var(x)))), Tup((N, Var(y))))), false)
+//│ AST: Def(false, Var("f"), L(Lam(Tup((N, Bra(rcd = false, Tup((N, Var("x")), (N, Var("y")))))), App(App(Var("add"), Tup((N, Var("x")))), Tup((N, Var("y")))))), false)
 //│ Desugared: f('(' [1, 2,] ')',)
-//│ AST: App(Var(f), Tup((N, Bra(rcd = false, Tup((N, IntLit(1)), (N, IntLit(2)))))))
+//│ AST: App(Var("f"), Tup((N, Bra(rcd = false, Tup((N, IntLit(1)), (N, IntLit(2)))))))
 //│ f: ((int, int,),) -> int
 //│  = [Function: f1]
 //│ res: int
diff --git a/shared/src/test/diff/mlscript/Mut.mls b/shared/src/test/diff/mlscript/Mut.mls
index 5abffdda48..20bb9fc22a 100644
--- a/shared/src/test/diff/mlscript/Mut.mls
+++ b/shared/src/test/diff/mlscript/Mut.mls
@@ -613,7 +613,7 @@ b1.x <- 1 + 2 <- 4
 //│ ║  l.550: 	b1.x <- 1 + 2 <- 4
 //│ ╙──       	            ^
 //│ Code generation encountered an error:
-//│   illegal assignemnt left-hand side: Bra(rcd = false, Assign(Sel(Var(mt1), 0), Sel(Var(b1), t)))
+//│   illegal assignemnt left-hand side: Bra(rcd = false, Assign(Sel(Var("mt1"), 0), Sel(Var("b1"), t)))
 
 def f : {mut 0 : int} -> int -> unit
 def g : (mut int, bool) -> int -> unit
diff --git a/shared/src/test/diff/mlscript/Ops.mls b/shared/src/test/diff/mlscript/Ops.mls
index b278598ee4..f0ea6554d8 100644
--- a/shared/src/test/diff/mlscript/Ops.mls
+++ b/shared/src/test/diff/mlscript/Ops.mls
@@ -3,7 +3,7 @@
 2 + 2
 //│ Parsed: +(2,)(2,);
 //│ Desugared: +(2,)(2,)
-//│ AST: App(App(Var(+), Tup((N, IntLit(2)))), Tup((N, IntLit(2))))
+//│ AST: App(App(Var("+"), Tup((N, IntLit(2)))), Tup((N, IntLit(2))))
 //│ res: int
 //│    = 4
 
@@ -11,7 +11,7 @@
 1 + 2 * 2 + 3
 //│ Parsed: +(+(1,)(*(2,)(2,),),)(3,);
 //│ Desugared: +(+(1,)(*(2,)(2,),),)(3,)
-//│ AST: App(App(Var(+), Tup((N, App(App(Var(+), Tup((N, IntLit(1)))), Tup((N, App(App(Var(*), Tup((N, IntLit(2)))), Tup((N, IntLit(2)))))))))), Tup((N, IntLit(3))))
+//│ AST: App(App(Var("+"), Tup((N, App(App(Var("+"), Tup((N, IntLit(1)))), Tup((N, App(App(Var("*"), Tup((N, IntLit(2)))), Tup((N, IntLit(2)))))))))), Tup((N, IntLit(3))))
 //│ res: int
 //│    = 8
 
@@ -20,7 +20,7 @@
 1 + 2 / 2 + 3
 //│ Parsed: +(+(1,)(/(2,)(2,),),)(3,);
 //│ Desugared: +(+(1,)(/(2,)(2,),),)(3,)
-//│ AST: App(App(Var(+), Tup((N, App(App(Var(+), Tup((N, IntLit(1)))), Tup((N, App(App(Var(/), Tup((N, IntLit(2)))), Tup((N, IntLit(2)))))))))), Tup((N, IntLit(3))))
+//│ AST: App(App(Var("+"), Tup((N, App(App(Var("+"), Tup((N, IntLit(1)))), Tup((N, App(App(Var("/"), Tup((N, IntLit(2)))), Tup((N, IntLit(2)))))))))), Tup((N, IntLit(3))))
 //│ ╔══[ERROR] Type mismatch in operator application:
 //│ ║  l.20: 	1 + 2 / 2 + 3
 //│ ║        	^^^^^^^^^
@@ -36,7 +36,7 @@
 1 |> 2 || 3
 //│ Parsed: ||(|>(1,)(2,),)(3,);
 //│ Desugared: ||(|>(1,)(2,),)(3,)
-//│ AST: App(App(Var(||), Tup((N, App(App(Var(|>), Tup((N, IntLit(1)))), Tup((N, IntLit(2))))))), Tup((N, IntLit(3))))
+//│ AST: App(App(Var("||"), Tup((N, App(App(Var("|>"), Tup((N, IntLit(1)))), Tup((N, IntLit(2))))))), Tup((N, IntLit(3))))
 //│ ╔══[ERROR] identifier not found: |>
 //│ ║  l.36: 	1 |> 2 || 3
 //│ ╙──      	  ^^
@@ -54,7 +54,7 @@
 true || false && true || false
 //│ Parsed: ||(||(true,)(&&(false,)(true,),),)(false,);
 //│ Desugared: ||(||(true,)(&&(false,)(true,),),)(false,)
-//│ AST: App(App(Var(||), Tup((N, App(App(Var(||), Tup((N, Var(true)))), Tup((N, App(App(Var(&&), Tup((N, Var(false)))), Tup((N, Var(true)))))))))), Tup((N, Var(false))))
+//│ AST: App(App(Var("||"), Tup((N, App(App(Var("||"), Tup((N, Var("true")))), Tup((N, App(App(Var("&&"), Tup((N, Var("false")))), Tup((N, Var("true")))))))))), Tup((N, Var("false"))))
 //│ res: bool
 //│    = true
 
diff --git a/shared/src/test/diff/mlscript/Weird.mls b/shared/src/test/diff/mlscript/Weird.mls
index 9aa518f720..ffc7a116c3 100644
--- a/shared/src/test/diff/mlscript/Weird.mls
+++ b/shared/src/test/diff/mlscript/Weird.mls
@@ -41,7 +41,7 @@ class C
 def n: C{}
 //│ Parsed: rec def n: C; {};
 //│ Desugared: rec def n: C
-//│ AST: Def(true, n, PolyType(List(),TypeName(C)), true)
+//│ AST: Def(true, Var("n"), R(PolyType(Ls(), TypeName("C"))), true)
 //│ Desugared: {}
 //│ AST: Rcd()
 //│ n: C
diff --git a/shared/src/test/diff/nu/AbstractClasses.mls b/shared/src/test/diff/nu/AbstractClasses.mls
index dd80a049ac..c00679e1b8 100644
--- a/shared/src/test/diff/nu/AbstractClasses.mls
+++ b/shared/src/test/diff/nu/AbstractClasses.mls
@@ -51,7 +51,7 @@ new Foo(1) { fun f = id }
 //│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ error
 //│ Code generation encountered an error:
-//│   cannot generate code for term Rft(App(NuNew(Var(Foo)), Tup((N, IntLit(1)))), ...)
+//│   cannot generate code for term Rft(App(NuNew(Var("Foo")), Tup((N, IntLit(1)))), TypingUnit(NuFunDef(None, f, N, Nil, L(Var("id")))))
 
 
 abstract class Bar extends Foo(1)
diff --git a/shared/src/test/diff/nu/BadBlocks.mls b/shared/src/test/diff/nu/BadBlocks.mls
index eedcd08dfd..03fb69ccfe 100644
--- a/shared/src/test/diff/nu/BadBlocks.mls
+++ b/shared/src/test/diff/nu/BadBlocks.mls
@@ -176,5 +176,5 @@ fun test = (new {
 //│ ╙──       	^
 //│ fun test: error
 //│ Code generation encountered an error:
-//│   Unsupported `new` class term: Bra(rcd = true, Rcd(Var(res) = Var(res)))
+//│   Unsupported `new` class term: Bra(rcd = true, Rcd(Var("res") = Var("res")))
 
diff --git a/shared/src/test/diff/nu/LamPatterns.mls b/shared/src/test/diff/nu/LamPatterns.mls
index 38092d8d97..98bb1511be 100644
--- a/shared/src/test/diff/nu/LamPatterns.mls
+++ b/shared/src/test/diff/nu/LamPatterns.mls
@@ -14,7 +14,7 @@ Some(x) => x
 //│ ╙──     	           ^
 //│ error -> error
 //│ Code generation encountered an error:
-//│   term App(Var(Some), Tup((N, Var(x)))) is not a valid pattern
+//│   term App(Var("Some"), Tup((N, Var("x")))) is not a valid pattern
 
 :js
 // FIXME type
diff --git a/shared/src/test/diff/nu/LetRec.mls b/shared/src/test/diff/nu/LetRec.mls
index 74f8a3f58c..51ad7c37f8 100644
--- a/shared/src/test/diff/nu/LetRec.mls
+++ b/shared/src/test/diff/nu/LetRec.mls
@@ -129,7 +129,7 @@ let rec lol = () => lol
 :p
 let rec f = 1
 //│ |#let| |#rec| |f| |#=| |1|
-//│ AST: TypingUnit(NuFunDef(Some(true), f, None, [], IntLit(1)))
+//│ AST: TypingUnit(NuFunDef(Some(true), f, N, Nil, L(IntLit(1))))
 //│ Parsed: let rec f = 1;
 //│ let rec f: 1
 //│ f
diff --git a/shared/src/test/diff/nu/NewNew.mls b/shared/src/test/diff/nu/NewNew.mls
index 8ab334a692..86753b6e37 100644
--- a/shared/src/test/diff/nu/NewNew.mls
+++ b/shared/src/test/diff/nu/NewNew.mls
@@ -167,7 +167,7 @@ new PoInt['_]
 //│ ╙──       	             ^
 //│ PoInt[nothing] | error
 //│ Code generation encountered an error:
-//│   Unsupported `new` class term: TyApp(Var(PoInt), List('_))
+//│   Unsupported `new` class term: TyApp(Var("PoInt"), List('_))
 
 :e
 new PoInt[Str](0, 0)
@@ -176,7 +176,7 @@ new PoInt[Str](0, 0)
 //│ ╙──       	^^^^^^^^^^^^^^^^^^^^
 //│ PoInt[0]
 //│ Code generation encountered an error:
-//│   Unsupported `new` class term: TyApp(Var(PoInt), List(TypeName(Str)))
+//│   Unsupported `new` class term: TyApp(Var("PoInt"), List(TypeName(Str)))
 
 type T = PoInt[Str]
 //│ type T = PoInt[Str]
@@ -211,7 +211,7 @@ let origin = new PoInt[Int](0, 0)
 //│ ╙──       	             ^^^^^^^^^^^^^^^^^^^^
 //│ let origin: PoInt[0]
 //│ Code generation encountered an error:
-//│   Unsupported `new` class term: TyApp(Var(PoInt), List(TypeName(Int)))
+//│   Unsupported `new` class term: TyApp(Var("PoInt"), List(TypeName(Int)))
 
 
 :e // TODO support
@@ -247,7 +247,7 @@ new
 //│ ╙──       	  ^
 //│ error
 //│ Code generation encountered an error:
-//│   Unsupported `new` class term: Blk(...)
+//│   Unsupported `new` class term: Blk(Asc(Var("x"), Literal(0)))
 
 
 
@@ -302,6 +302,6 @@ module A { class B }
 new A.B
 //│ B
 //│ Code generation encountered an error:
-//│   Unsupported `new` class term: Sel(Var(A), B)
+//│   Unsupported `new` class term: Sel(Var("A"), B)
 
 
diff --git a/shared/src/test/diff/nu/OpLam.mls b/shared/src/test/diff/nu/OpLam.mls
index 15b57dbca7..ec57b8f85a 100644
--- a/shared/src/test/diff/nu/OpLam.mls
+++ b/shared/src/test/diff/nu/OpLam.mls
@@ -107,6 +107,6 @@ x => x.y => y
 //│ ╙──       	            ^
 //│ anything -> error -> error
 //│ Code generation encountered an error:
-//│   term Sel(Var(x), y) is not a valid pattern
+//│   term Sel(Var("x"), y) is not a valid pattern
 
 
diff --git a/shared/src/test/diff/nu/OverrideShorthand.mls b/shared/src/test/diff/nu/OverrideShorthand.mls
index b6273930c8..8383f5a739 100644
--- a/shared/src/test/diff/nu/OverrideShorthand.mls
+++ b/shared/src/test/diff/nu/OverrideShorthand.mls
@@ -10,7 +10,7 @@ class Pair(lhs: Int, rhs: Int)
 :e
 fun f(override Pair(x, y)) = x + y
 //│ |#fun| |f|(|#override| |Pair|(|x|,| |y|)|)| |#=| |x| |+| |y|
-//│ AST: TypingUnit(NuFunDef(None, f, None, [], Lam(Tup((N, Var(_$0))), If(IfOpApp(Var(_$0), Var(is), IfThen(App(Var(Pair), Tup((N, Var(x)), (N, Var(y)))), App(Var(+), Tup((N, Var(x)), (N, Var(y)))), Some(App(Sel(Super(), f), Tup((N, Var(_$0)))))))))
+//│ AST: TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Var("_$0"))), If(IfOpApp(Var("_$0"), Var("is"), IfThen(App(Var("Pair"), Tup((N, Var("x")), (N, Var("y")))), App(Var("+"), Tup((N, Var("x")), (N, Var("y")))), Some(App(Sel(Super(), f), Tup((N, Var("_$0"))))))))))
 //│ Parsed: fun f = (_$0,) => if _$0 is (Pair(x, y,)) then +(x, y,) else (super).f(_$0,);
 //│ ╔══[ERROR] identifier not found: super
 //│ ║  l.11: 	fun f(override Pair(x, y)) = x + y
@@ -46,7 +46,7 @@ fun f(override Pair(x, y), z) = x + y
 //│ ╙──      	                                    ^
 //│ fun f: (error, anything) -> Int
 //│ Code generation encountered an error:
-//│   term App(Var(Pair), Tup((N, Var(x)), (N, Var(y)))) is not a valid pattern
+//│   term App(Var("Pair"), Tup((N, Var("x")), (N, Var("y")))) is not a valid pattern
 
 
 // TODO
diff --git a/shared/src/test/diff/nu/RightAssocOps.mls b/shared/src/test/diff/nu/RightAssocOps.mls
index 46187337df..df59691588 100644
--- a/shared/src/test/diff/nu/RightAssocOps.mls
+++ b/shared/src/test/diff/nu/RightAssocOps.mls
@@ -30,7 +30,7 @@ fun (++) conc(xs, ys) = [xs, ys]
 :p
 1 +: "a" ++ "b" :+ 2
 //│ |1| |+:| |"a"| |++| |"b"| |:+| |2|
-//│ AST: TypingUnit(App(Var(+:), Tup((N, IntLit(1)), (N, App(Var(:+), Tup((N, App(Var(++), Tup((N, StrLit(a)), (N, StrLit(b))))), (N, IntLit(2))))))))
+//│ AST: TypingUnit(App(Var("+:"), Tup((N, IntLit(1)), (N, App(Var(":+"), Tup((N, App(Var("++"), Tup((N, StrLit(a)), (N, StrLit(b))))), (N, IntLit(2))))))))
 //│ Parsed: +:(1, :+(++("a", "b",), 2,),);
 //│ [[Int], [["a", "b"], [Int]]]
 //│ res
@@ -39,7 +39,7 @@ fun (++) conc(xs, ys) = [xs, ys]
 :p
 1 +: "a" :+ 2 ++ "b"
 //│ |1| |+:| |"a"| |:+| |2| |++| |"b"|
-//│ AST: TypingUnit(App(Var(+:), Tup((N, IntLit(1)), (N, App(Var(++), Tup((N, App(Var(:+), Tup((N, StrLit(a)), (N, IntLit(2))))), (N, StrLit(b))))))))
+//│ AST: TypingUnit(App(Var("+:"), Tup((N, IntLit(1)), (N, App(Var("++"), Tup((N, App(Var(":+"), Tup((N, StrLit(a)), (N, IntLit(2))))), (N, StrLit(b))))))))
 //│ Parsed: +:(1, ++(:+("a", 2,), "b",),);
 //│ [[Int], [["a", [Int]], "b"]]
 //│ res
@@ -49,7 +49,7 @@ fun (++) conc(xs, ys) = [xs, ys]
 :e
 1 +: "a" ++ 2 +: "b"
 //│ |1| |+:| |"a"| |++| |2| |+:| |"b"|
-//│ AST: TypingUnit(App(Var(+:), Tup((N, IntLit(1)), (N, App(Var(+:), Tup((N, App(Var(++), Tup((N, StrLit(a)), (N, IntLit(2))))), (N, StrLit(b))))))))
+//│ AST: TypingUnit(App(Var("+:"), Tup((N, IntLit(1)), (N, App(Var("+:"), Tup((N, App(Var("++"), Tup((N, StrLit(a)), (N, IntLit(2))))), (N, StrLit(b))))))))
 //│ Parsed: +:(1, +:(++("a", 2,), "b",),);
 //│ ╔══[ERROR] Type mismatch in operator application:
 //│ ║  l.50: 	1 +: "a" ++ 2 +: "b"
diff --git a/shared/src/test/diff/nu/TODO_Classes.mls b/shared/src/test/diff/nu/TODO_Classes.mls
index bc37f00a70..c3cef2e7fb 100644
--- a/shared/src/test/diff/nu/TODO_Classes.mls
+++ b/shared/src/test/diff/nu/TODO_Classes.mls
@@ -80,7 +80,7 @@ new C { val x = 1 }
 //│ ╙──      	^^^^^^^^^^^^^^^^^^^
 //│ error
 //│ Code generation encountered an error:
-//│   cannot generate code for term Rft(NuNew(Var(C)), ...)
+//│   cannot generate code for term Rft(NuNew(Var("C")), TypingUnit(NuFunDef(Some(false), x, N, Nil, L(IntLit(1)))))
 
 
 
diff --git a/shared/src/test/diff/ucs/LeadingAnd.mls b/shared/src/test/diff/ucs/LeadingAnd.mls
index ae365f487e..f1e65d9f15 100644
--- a/shared/src/test/diff/ucs/LeadingAnd.mls
+++ b/shared/src/test/diff/ucs/LeadingAnd.mls
@@ -23,7 +23,7 @@ fun f(a, b) = if a is Some(av)
     and b is Some(bv)
     then av + bv
 //│ |#fun| |f|(|a|,| |b|)| |#=| |#if| |a| |is| |Some|(|av|)|→|and| |b| |is| |Some|(|bv|)|↵|#then| |av| |+| |bv|←|
-//│ AST: TypingUnit(NuFunDef(None, f, None, [], Lam(Tup((N, Var(a)), (N, Var(b))), If(IfOpApp(Var(a), Var(is), I; f; O; p; s; A; p; p; (; A; p; p; (; V; a; r; (; S; o; m; e; ); ,;  ; T; u; p; (; (; N; ,;  ; V; a; r; (; a; v; ); ); ); ); ,;  ; <; i; t; e; r; a; t; o; r; >, None))))
+//│ AST: TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Var("a")), (N, Var("b"))), If(IfOpApp(Var("a"), Var("is"), I; f; O; p; s; A; p; p; (; A; p; p; (; V; a; r; (; "; S; o; m; e; "; ); ,;  ; T; u; p; (; (; N; ,;  ; V; a; r; (; "; a; v; "; ); ); ); ); ,;  ; <; i; t; e; r; a; t; o; r; >, None)))))
 //│ Parsed: fun f = (a, b,) => if a is Some(av,) ‹· and (is(b, Some(bv,),)) then +(av, bv,)›;
 //│ fun f: (Some[Int], Some[Int]) -> Int
 
@@ -34,7 +34,7 @@ fun f(a, b) = if a is
     and b is Some(bv)
     then av + bv
 //│ |#fun| |f|(|a|,| |b|)| |#=| |#if| |a| |is|→|Some|(|av|)|→|and| |b| |is| |Some|(|bv|)|↵|#then| |av| |+| |bv|←|←|
-//│ AST: TypingUnit(NuFunDef(None, f, None, [], Lam(Tup((N, Var(a)), (N, Var(b))), If(IfOpApp(Var(a), Var(is), IfBlock(I; f; O; p; s; A; p; p; (; A; p; p; (; V; a; r; (; S; o; m; e; ); ,;  ; T; u; p; (; (; N; ,;  ; V; a; r; (; a; v; ); ); ); ); ,;  ; <; i; t; e; r; a; t; o; r; >), None))))
+//│ AST: TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Var("a")), (N, Var("b"))), If(IfOpApp(Var("a"), Var("is"), IfBlock(Ls(I; f; O; p; s; A; p; p; (; A; p; p; (; V; a; r; (; "; S; o; m; e; "; ); ,;  ; T; u; p; (; (; N; ,;  ; V; a; r; (; "; a; v; "; ); ); ); ); ,;  ; <; i; t; e; r; a; t; o; r; >)), None)))))
 //│ Parsed: fun f = (a, b,) => if a is ‹Some(av,) ‹· and (is(b, Some(bv,),)) then +(av, bv,)››;
 //│ ╔══[ERROR] Illegal pattern `and`
 //│ ║  l.34: 	    and b is Some(bv)
diff --git a/shared/src/test/diff/ucs/SplitOps.mls b/shared/src/test/diff/ucs/SplitOps.mls
index 7171667bbe..70e9e05369 100644
--- a/shared/src/test/diff/ucs/SplitOps.mls
+++ b/shared/src/test/diff/ucs/SplitOps.mls
@@ -93,10 +93,10 @@ fun f(a, b, c) =
   if a
     == 0 and b is B() and c is C() then 0
 //│ |#fun| |f|(|a|,| |b|,| |c|)| |#=|→|#if| |a|→|==| |0| |and| |b| |is| |B|(||)| |and| |c| |is| |C|(||)| |#then| |0|←|←|
-//│ AST: TypingUnit(NuFunDef(None, f, None, [], Lam(Tup((N, Var(a)), (N, Var(b)), (N, Var(c))), Blk(...))))
+//│ AST: TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Var("a")), (N, Var("b")), (N, Var("c"))), Blk(If(I; f; O; p; s; A; p; p; (; V; a; r; (; "; a; "; ); ,;  ; <; i; t; e; r; a; t; o; r; >, None))))))
 //│ Parsed: fun f = (a, b, c,) => {if a ‹· == (and(and(0,)(is(b,)(B(),),),)(is(c,)(C(),),)) then 0›};
 //│ Desugared: rec def f: (a, b, c,) => {if a ‹· == (and(and(0,)(is(b,)(B(),),),)(is(c,)(C(),),)) then 0›}
-//│ AST: Def(true, f, Lam(Tup((N, Var(a)), (N, Var(b)), (N, Var(c))), Blk(...)), true)
+//│ AST: Def(true, Var("f"), L(Lam(Tup((N, Var("a")), (N, Var("b")), (N, Var("c"))), Blk(If(I; f; O; p; s; A; p; p; (; V; a; r; (; "; a; "; ); ,;  ; <; i; t; e; r; a; t; o; r; >, None)))), true)
 //│ ╔══[ERROR] The case when this is false is not handled: ==(a,)(0,)
 //│ ║  l.93: 	  if a
 //│ ║        	     ^
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index 73e235e5eb..d8a2cf982e 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -437,7 +437,7 @@ class DiffTests
               output("Parsed: " + res.showDbg)
             
             if (mode.showParse)
-              output("AST: " + mlscript.codegen.Helpers.inspect(res))
+              output("AST: " + inspect.deep(res))
             
             postProcess(mode, basePath, testName, res).foreach(output)
             
@@ -637,7 +637,7 @@ class DiffTests
                 typeDefs.foreach(td => output("Desugared: " + td))
                 stmts.foreach { s =>
                   output("Desugared: " + s)
-                  output("AST: " + mlscript.codegen.Helpers.inspect(s))
+                  output("AST: " + inspect.deep(s))
                 }
               }
               

From 146cebae75f4b0dc87d76b77bf0c27403dc19eda Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 20 Dec 2023 01:25:31 +0800
Subject: [PATCH 012/147] Fix warnings on inexhaustiveness pattern matching

---
 shared/src/main/scala/mlscript/pretyper/PreTyper.scala     | 5 +++++
 shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala | 1 +
 2 files changed, 6 insertions(+)

diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index e4e4cfee08..0b0459ecad 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -103,6 +103,11 @@ class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Trac
         case v: Var => traverseVar(v)
         case AdtMatchWith(cond, arms) => ??? // TODO: How?
         case Inst(body) => traverseTerm(body)
+        case NuNew(cls) => traverseTerm(cls)
+        case Rft(base, decls) => // For object refinement
+          traverseTerm(base)
+          traverseTypingUnit(decls, "Rft", scope)
+          ()
       }
     }(_ => s"traverseTerm ==> ${shortName(term)}")
 
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 107535e60d..b8c1d9883c 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -97,6 +97,7 @@ trait Desugaring { self: mlscript.pretyper.Traceable =>
           mkBinOp(nme, Var("=="), pattern.literal, true),
           c.Branch(scrutinee, truePattern, next) :: c.Split.Nil
         )
+      case (Some((nme, pattern)), next) => ??? // Other patterns are not implemented yet.
     })
   }
 

From cd4770c2b54a6d1b03f4b1a6e3794a119c7b29eb Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Thu, 21 Dec 2023 01:49:07 +0800
Subject: [PATCH 013/147] Improve coverage checking and fix a fatal bug in
 post-processing

---
 shared/src/main/scala/mlscript/helpers.scala  |   7 +-
 .../scala/mlscript/pretyper/DataTypes.scala   |  10 +
 .../scala/mlscript/pretyper/PreTyper.scala    | 185 +++++++++---
 .../main/scala/mlscript/pretyper/Scope.scala  | 114 ++++++--
 .../main/scala/mlscript/pretyper/Symbol.scala | 180 ++++++++----
 .../scala/mlscript/pretyper/package.scala     |  11 +-
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |  50 +++-
 .../ucs/stages/CoverageChecking.scala         | 276 +++++++++++++-----
 .../mlscript/ucs/stages/Desugaring.scala      |   2 +-
 .../mlscript/ucs/stages/Normalization.scala   |  72 +++--
 .../mlscript/ucs/stages/PostProcessing.scala  | 171 +++++++----
 .../mlscript/ucs/stages/Transformation.scala  |   6 +
 .../scala/mlscript/ucs/stages/package.scala   |  18 +-
 .../main/scala/mlscript/utils/inspect.scala   |   2 +-
 shared/src/test/diff/mlscript/Repro.mls       |  16 -
 .../src/test/diff/pretyper/Declarations.mls   |  74 +----
 shared/src/test/diff/pretyper/Repro.mls       |   1 +
 .../src/test/diff/pretyper/ucs/DualOption.mls |  12 +-
 .../src/test/diff/pretyper/ucs/Overlaps.mls   |  76 +++++
 .../pretyper/ucs/coverage/MissingCases.mls    | 146 +++++++--
 .../pretyper/ucs/coverage/SealedClasses.mls   |  58 ++++
 .../pretyper/ucs/coverage/Unreachable.mls     | 142 ---------
 .../pretyper/ucs/examples/EitherOrBoth.mls    | 100 +++++++
 .../diff/pretyper/ucs/examples/Option.mls     |  65 ++---
 24 files changed, 1178 insertions(+), 616 deletions(-)
 create mode 100644 shared/src/main/scala/mlscript/pretyper/DataTypes.scala
 create mode 100644 shared/src/test/diff/pretyper/Repro.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/Overlaps.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/examples/EitherOrBoth.mls

diff --git a/shared/src/main/scala/mlscript/helpers.scala b/shared/src/main/scala/mlscript/helpers.scala
index e9a60f89f1..9bd5d430d6 100644
--- a/shared/src/main/scala/mlscript/helpers.scala
+++ b/shared/src/main/scala/mlscript/helpers.scala
@@ -502,7 +502,7 @@ trait TypeNameImpl extends Ordered[TypeName] { self: TypeName =>
   def targs: Ls[Type] = Nil
   def compare(that: TypeName): Int = this.name compare that.name
   lazy val toVar: Var = Var(name).withLocOf(this)
-  var symbol: Opt[pretyper.TypeSymbol] = N
+  var symbol: Opt[pretyper.symbol.TypeSymbol] = N
 }
 
 trait FldImpl extends Located { self: Fld =>
@@ -743,7 +743,7 @@ trait VarImpl { self: Var =>
   var uid: Opt[Int] = N
 
   // PreTyper additions
-  import pretyper.{Symbol}
+  import pretyper.symbol.Symbol
 
   private var _symbol: Opt[Symbol] = N
   def symbolOption: Opt[Symbol] = _symbol
@@ -753,9 +753,8 @@ trait VarImpl { self: Var =>
       case N => _symbol = S(symbol)
       case S(_) => ???
     }
-  // TODO: Remove this methods if they are useless.
   // def withSymbol: Var = { symbol = S(new ValueSymbol(this, false)); this }
-  // def withSymbol(s: TermSymbol): Var = { symbol = S(s); this }
+  def withSymbol(symbol: Symbol): Var = { this.symbol = symbol; this }
 }
 
 trait TupImpl { self: Tup =>
diff --git a/shared/src/main/scala/mlscript/pretyper/DataTypes.scala b/shared/src/main/scala/mlscript/pretyper/DataTypes.scala
new file mode 100644
index 0000000000..aaebd90165
--- /dev/null
+++ b/shared/src/main/scala/mlscript/pretyper/DataTypes.scala
@@ -0,0 +1,10 @@
+package mlscript.pretyper
+
+import mlscript.{NuFunDef, NuTypeDef, Cls, Trt, Mxn, Als, Mod, Var, TypeName}
+import collection.mutable.{Buffer, Map => MutMap, Set => MutSet}
+import mlscript.utils._, shorthands._
+import scala.annotation.tailrec
+
+trait DataTypes { self: PreTyper =>
+
+}
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index 0b0459ecad..eb3da5087c 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -1,9 +1,16 @@
 package mlscript.pretyper
 
+import collection.mutable.{Set => MutSet}
 import mlscript.ucs.DesugarUCS
+import symbol._
 import mlscript._, utils._, shorthands._
+import scala.annotation.tailrec
+import mlscript.Message, Message.MessageContext
 
 class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Traceable with DesugarUCS {
+  import PreTyper._
+
+  protected def raise(diagnostics: Diagnostic): Unit = ()
   protected def raise(diagnostics: Ls[Diagnostic]): Unit = ()
 
   private def extractParameters(fields: Term): Ls[ValueSymbol] = fields match {
@@ -32,24 +39,28 @@ class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Trac
 
   protected def resolveVar(v: Var)(implicit scope: Scope): Unit =
     trace(s"resolveVar(name = \"$v\")") {
-      scope.get(v.name) match {
-        case Some(sym: ValueSymbol) =>
+      scope.getTermSymbol(v.name) match {
+        case S(sym: ValueSymbol) =>
           println(s"Resolve variable $v to a value.", 2)
           v.symbol = sym
-        case Some(sym: SubValueSymbol) =>
+        case S(sym: SubValueSymbol) =>
           println(s"Resolve variable $v to a value.", 2)
           v.symbol = sym
-        case Some(sym: FunctionSymbol) =>
+        case S(sym: FunctionSymbol) =>
           println(s"Resolve variable $v to a function.", 2)
           v.symbol = sym
-        case Some(sym: TypeSymbol) =>
-          if (sym.defn.kind == Cls) {
-            println(s"Resolve variable $v to a class.", 2)
-            v.symbol = sym
-          } else {
-            throw new Exception(s"Name $v refers to a type")
+        case N => 
+          scope.getTypeSymbol(v.name) match {
+            case S(sym: ClassSymbol) =>
+              if (sym.defn.kind == Cls) {
+                println(s"Resolve variable $v to a class.", 2)
+                v.symbol = sym
+              } else {
+                throw new Exception(s"Name $v refers to a type")
+              }
+            case S(_) => throw new Exception(s"Name $v refers to a type")
+            case N => throw new Exception(s"Variable $v not found in scope")
           }
-        case None => throw new Exception(s"Variable $v not found in scope")
       }
     }()
 
@@ -57,16 +68,16 @@ class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Trac
     trace(s"traverseVar(name = \"$v\")") {
       v.symbolOption match {
         case N => resolveVar(v)
-        case S(symbol) => scope.get(v.name) match {
-          case S(other) if other === symbol => ()
-          case S(other) => throw new Exception(s"Variable $v refers to a different symbol")
-          case N => throw new Exception(s"Variable $v not found in scope. It is possibly a free variable.")
+        case S(symbol) => scope.getSymbols(v.name) match {
+          case Nil => throw new Exception(s"Variable $v not found in scope. It is possibly a free variable.")
+          case symbols if symbols.contains(symbol) => ()
+          case _ => throw new Exception(s"Variable $v refers to a different symbol")
         }
       }
     }()
 
   protected def traverseTerm(term: Term)(implicit scope: Scope): Unit =
-    trace(s"traverseTerm <== ${shortName(term)}") {
+    trace(s"traverseTerm <== ${inspect.shallow(term)}") {
       term match {
         case Assign(lhs, rhs) => traverseTerm(lhs); traverseTerm(rhs)
         case Bra(_, trm) => traverseTerm(trm)
@@ -108,22 +119,28 @@ class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Trac
           traverseTerm(base)
           traverseTypingUnit(decls, "Rft", scope)
           ()
+        case NuNew(cls) => traverseTerm(cls)
+        case Rft(base, decls) =>
+          traverseTerm(base)
+          traverseTypingUnit(decls, "Rft", scope)
+          ()
       }
-    }(_ => s"traverseTerm ==> ${shortName(term)}")
+    }(_ => s"traverseTerm ==> ${inspect.shallow(term)}")
 
-  private def traverseNuTypeDef(symbol: TypeSymbol, defn: NuTypeDef)(implicit scope: Scope): Unit =
-    trace(s"traverseNuTypeDef <== ${defn.kind} ${defn.nme.name}") {
+  private def traverseTypeDefinition(symbol: TypeSymbol, defn: NuTypeDef)(implicit scope: Scope): Unit =
+    trace(s"traverseTypeDefinition <== ${defn.describe}") {
       traverseTypingUnit(defn.body, defn.nme.name, scope)
       ()
-    }(_ => s"traverseNuTypeDef <== ${defn.kind} ${defn.nme.name}")
+    }(_ => s"traverseTypeDefinition <== ${defn.describe}")
 
   private def traverseFunction(symbol: FunctionSymbol, defn: NuFunDef)(implicit scope: Scope): Unit =
     trace(s"traverseFunction <== ${defn.nme.name}") {
+      require(defn.isLetRec.isEmpty) // Make sure it's defined via `fun`.
       defn.rhs match {
         case Left(term) => 
           val subScope = if (defn.isLetRec === S(false)) scope else scope + symbol
           traverseTerm(term)(subScope)
-        case Right(value) => ()
+        case Right(ty) => println(s"found a pure declaration: $ty")
       }
     }(_ => s"traverseFunction ==> ${defn.nme.name}")
 
@@ -141,17 +158,68 @@ class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Trac
         case (acc, defn: NuTypeDef) =>
           val `var` = Var(defn.nme.name).withLoc(defn.nme.toLoc)
           // Create a type symbol but do not visit its inner members
-          acc ++ (new TypeSymbol(defn.nme, defn) ::
+          val symbol = defn.kind match {
+            case Cls => new ClassSymbol(defn)
+            case Als => new TypeAliasSymbol(defn)
+            case Mxn => new MixinSymbol(defn)
+            case Trt => new TraitSymbol(defn)
+            case Mod => new ModuleSymbol(defn)
+          }
+          println("parent types: " + defn.parents.iterator.map(inspect.deep(_)).mkString("; "))
+          acc ++ (symbol ::
             (defn.kind match {
               case Mod => new ValueSymbol(`var`, true) :: Nil
               case Als | Cls | Mxn | Trt => Nil
             }))
-        case (acc, defn: NuFunDef) if defn.isLetRec.isEmpty =>
-          acc + new FunctionSymbol(defn.nme, defn)
+        case (acc, defn: NuFunDef) if defn.isLetRec.isEmpty => acc + new FunctionSymbol(defn)
         case (acc, _: NuFunDef) => acc
         case (acc, _: Constructor | _: DataDefn | _: DatatypeDefn | _: Def | _: LetS | _: TypeDef) => ??? // TODO: When?
       }
-      println(hoistedScope.symbols.map(_.name).mkString("1. scope = {", ", ", "}"))
+      // Resolve base types.
+      val subtypingRelations = typingUnit.entities.foldLeft(Map.empty[Var, Ls[Var]]) {
+        case (acc, defn: NuTypeDef) =>
+          val thisType = Var(defn.nme.name).withLoc(defn.nme.toLoc)
+          val superTypes = extractSuperTypes(defn.parents)
+          acc + (thisType -> superTypes)
+        case (acc, _: Term | _: NuFunDef) => acc
+        case (acc, _: Constructor | _: DataDefn | _: DatatypeDefn | _: Def | _: LetS | _: TypeDef) => ??? // TODO: When?
+      }
+      val superTypes = transitiveClosure(subtypingRelations)
+      printGraph(subtypingRelations, println, "Subtyping relations", "->")
+      superTypes.foreachEntry { case (thisType, baseTypes) =>
+        hoistedScope.getTypeSymbol(thisType.name) match {
+          case S(symbol) => symbol.baseTypes =
+            baseTypes.map(baseType => hoistedScope.getTypeSymbol(baseType.name).getOrElse(???))
+          case N => ???
+        } // FIXME: Generate proper diagnostics.
+      }
+      // Resolve sealed types.
+      println("Resolve sealed signature types")
+      hoistedScope.types.foreachEntry {
+        case _ -> (_: MixinSymbol | _: TypeAliasSymbol) => ()
+        case (name, symbol) => symbol.defn.sig.foreach { unions =>
+          def rec(acc: Ls[TypeName], ty: Type): Ls[TypeName] = ty match {
+            case tn: TypeName => tn :: acc
+            case AppliedType(tn: TypeName, _) => tn :: acc
+            case Union(lhs, tn: TypeName) => rec(tn :: acc, lhs)
+            case Union(lhs, AppliedType(tn: TypeName, _)) => rec(tn :: acc, lhs)
+            case other => println(s"Unknown type: $other"); ???
+          }
+          val derivedTypes = try rec(Nil, unions) catch { case _: NotImplementedError => Nil }
+          symbol.sealedDerivedTypes = derivedTypes.flatMap { derivedType =>
+            val maybeSymbol = hoistedScope.getTypeSymbol(derivedType.name)
+            if (maybeSymbol.isEmpty) raise(ErrorReport(
+              msg"Undefined type $derivedType" -> derivedType.toLoc :: Nil,
+              true,
+              Diagnostic.PreTyping
+            ))
+            maybeSymbol
+          }
+          println(s">>> $name: ${symbol.sealedDerivedTypes.iterator.map(_.name).mkString(", ")}")
+        }
+      }
+      println(hoistedScope.symbols.map(_.name).mkString("(hoisted) scope = {", ", ", "}"))
+      // 
       // Pass 2: Visit non-hoisted and build a complete scope.
       val completeScope = typingUnit.entities.foldLeft[Scope](hoistedScope) {
         case (acc, term: Term) => traverseTerm(term)(acc); acc
@@ -164,29 +232,74 @@ class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Trac
         case (acc, _: NuFunDef) => acc
         case (acc, _: Constructor | _: DataDefn | _: DatatypeDefn | _: Def | _: LetS | _: TypeDef) => ??? // TODO: When?
       }
-      println(hoistedScope.symbols.map(_.name).mkString("2. scope = {", ", ", "}"))
-      import pretyper.TypeSymbol
+      println(hoistedScope.symbols.map(_.name).mkString("(complete) scope = {", ", ", "}"))
       // Pass 3: Visit hoisted symbols.
+      val visitedSymbol = MutSet.empty[FunctionSymbol]
       completeScope.symbols.foreach {
         case symbol: TypeSymbol =>
           val innerScope = symbol.defn.kind match {
             case Cls =>
-              completeScope.derive ++ (symbol.defn.params match {
-                case N => Nil
-                case S(fields) => extractParameters(fields)
-              })
+              completeScope.derive(
+                new ValueSymbol(Var("this"), false) ::
+                  (symbol.defn.params match {
+                    case N => Nil
+                    case S(fields) => extractParameters(fields)
+                  })
+              )
             case Als | Mod | Mxn | Trt => completeScope
           }
-          traverseNuTypeDef(symbol, symbol.defn)(innerScope)
-        case symbol: FunctionSymbol => traverseFunction(symbol, symbol.defn)(completeScope)
-        case _: ValueSymbol => ()
-        case _: SubValueSymbol => ()
+          traverseTypeDefinition(symbol, symbol.defn)(innerScope)
+        case symbol: FunctionSymbol if !visitedSymbol(symbol) =>
+          visitedSymbol += symbol
+          traverseFunction(symbol, symbol.defn)(completeScope)
+        case _: FunctionSymbol | _: ValueSymbol | _: SubValueSymbol => ()
       }
       (completeScope, new TypeContents)
-    }({ case (scope, contents) => s"traverseTypingUnit ==> ${scope.showLocalSymbols}" })
+    }({ case (scope, contents) => s"traverseTypingUnit ==> Scope {${scope.showLocalSymbols}}" })
 
   def process(typingUnit: TypingUnit, scope: Scope, name: Str): (Scope, TypeContents) =
     trace(s"process <== $name: ${typingUnit.describe}") {
       traverseTypingUnit(typingUnit, name, scope)
     }({ case (scope, contents) => s"process ==> ${scope.showLocalSymbols}" })
 }
+
+object PreTyper {
+
+  def extractSuperTypes(parents: Ls[Term]): Ls[Var] = {
+    @tailrec
+    def rec(results: Ls[Var], waitlist: Ls[Term]): Ls[Var] =
+      waitlist match {
+        case Nil => results.reverse
+        case (nme: Var) :: tail => rec(nme :: results, tail)
+        case (TyApp(ty, _)) :: tail => rec(results, ty :: tail)
+        case other :: _ => ???
+      }
+    rec(Nil, parents)
+  }
+
+  def transitiveClosure(graph: Map[Var, List[Var]]): Map[Var, List[Var]] = {
+    def dfs(vertex: Var, visited: Set[Var]): Set[Var] = {
+      if (visited.contains(vertex)) visited
+      else graph.getOrElse(vertex, List())
+        .foldLeft(visited + vertex)((acc, v) => dfs(v, acc))
+    }
+
+    graph.keys.map { vertex =>
+      val closure = dfs(vertex, Set())
+      vertex -> (closure - vertex).toList
+    }.toMap
+  }
+
+  def printGraph(graph: Map[Var, List[Var]], print: (=> Any) => Unit, title: String, arrow: String): Unit = {
+    print(s"• $title")
+    if (graph.isEmpty)
+      print("  + <Empty>")
+    else
+      graph.foreachEntry { (source, targets) =>
+        print(s"  + $source $arrow " + {
+          if (targets.isEmpty) s"{}"
+          else targets.mkString("{ ", ", ", " }")
+        })
+      }
+  }
+}
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/pretyper/Scope.scala b/shared/src/main/scala/mlscript/pretyper/Scope.scala
index e47690a9ff..23e7113ba7 100644
--- a/shared/src/main/scala/mlscript/pretyper/Scope.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Scope.scala
@@ -2,46 +2,102 @@ package mlscript.pretyper
 
 import collection.immutable.Map
 import mlscript.utils._, shorthands._
-import mlscript.Var
+import mlscript.{Mod, NuTypeDef, TypeName, TypingUnit, Var}
+import scala.annotation.tailrec
+import symbol._
 
-class Scope(val enclosing: Opt[Scope], val entries: Map[String, Symbol]) {
-  @inline
-  def get(name: String): Opt[Symbol] = entries.get(name) match {
-    case Some(sym) => S(sym)
-    case None => enclosing.fold(N: Opt[Symbol])(_.get(name))
-  }
+final class Scope(val enclosing: Opt[Scope], val types: Map[Str, TypeSymbol], val terms: Map[Str, TermSymbol]) {
+  import Scope._
+
+
+  @tailrec
+  final def getTypeSymbol(name: Str): Opt[TypeSymbol] =
+    types.get(name) match {
+      case entry @ S(_) => entry
+      case N => enclosing match {
+        case N => N
+        case S(scope) => scope.getTypeSymbol(name)
+      }
+    }
+
+  @tailrec
+  final def getTermSymbol(name: Str): Opt[TermSymbol] =
+    terms.get(name) match {
+      case entry @ S(_) => entry
+      case N => enclosing match {
+        case N => N
+        case S(scope) => scope.getTermSymbol(name)
+      }
+    }
+  
+  final def getSymbols(name: Str): Ls[Symbol] = Ls.concat(getTypeSymbol(name), getTermSymbol(name))
 
   @inline
-  def +(sym: Symbol): Scope = new Scope(S(this), entries + (sym.name -> sym))
+  def +(sym: Symbol): Scope = sym match {
+    case symbol: TypeSymbol => new Scope(enclosing, types + (symbol.name -> symbol), terms)
+    case symbol @ FunctionSymbol(Var(name), S(Var(operator)), _) =>
+        new Scope(enclosing, types, terms + (name -> symbol) + (operator -> symbol))
+    case symbol: TermSymbol => new Scope(enclosing, types, terms + (symbol.name -> symbol))
+  }
 
   @inline
-  def ++(syms: IterableOnce[Symbol]): Scope =
-    new Scope(S(this), entries ++ syms.iterator.map(sym => sym.name -> sym))
+  def ++(symbols: IterableOnce[Symbol]): Scope = {
+    val (newTypes, newTerms) = partitionSymbols((types, terms), symbols)
+    new Scope(enclosing, newTypes, newTerms)
+  }
 
-  def withEntries(syms: IterableOnce[Var -> Symbol]): Scope =
-    new Scope(S(this), entries ++ syms.iterator.map {
-      case (nme, sym) => nme.name -> sym
-    })
+  def withEntries(syms: IterableOnce[Var -> Symbol]): Scope = {
+    val (newTypes, newTerms) = syms.iterator.foldLeft((types, terms)) {
+      case ((types, terms), (nme, symbol: TypeSymbol)) => (types + (nme.name -> symbol), terms)
+      case ((types, terms), (nme, symbol: TermSymbol)) => (types, terms + (nme.name -> symbol))
+    }
+    new Scope(enclosing, newTypes, newTerms)
+  }
 
   @inline
-  def symbols: Iterable[Symbol] = entries.values
+  def symbols: Iterator[Symbol] = Iterator.concat[Symbol](types.values, terms.values)
+
+  def derive: Scope = new Scope(S(this), Map.empty, Map.empty)
 
-  def derive: Scope = new Scope(S(this), Map.empty)
+  def derive(symbols: IterableOnce[Symbol]): Scope = {
+    val (newTypes, newTerms) = partitionSymbols((types, terms), symbols)
+    new Scope(S(this), newTypes, newTerms)
+  }
 
-  def showLocalSymbols: Str = entries.iterator.map(_._1).mkString(", ")
+  def showLocalSymbols: Str = symbols.iterator.map(_.name).mkString(", ")
 }
 
 object Scope {
-  def from(symbols: IterableOnce[Symbol]): Scope =
-    new Scope(N, Map.from(symbols.iterator.map(sym => sym.name -> sym)))
-
-  val global: Scope = Scope.from(
-    """true,false,document,window,typeof,toString,not,succ,log,discard,negate,
-      |round,add,sub,mul,div,sqrt,lt,le,gt,ge,slt,sle,sgt,sge,length,concat,eq,
-      |ne,error,id,if,emptyArray,+,-,*,%,/,<,>,<=,>=,==,===,<>,&&,||"""
-      .stripMargin
-      .split(",")
-      .iterator
-      .map(name => new ValueSymbol(Var(name), false))
-  )
+  def partitionSymbols(
+      z: (Map[Str, TypeSymbol], Map[Str, TermSymbol]),
+      symbols: IterableOnce[Symbol]
+  ): (Map[Str, TypeSymbol], Map[Str, TermSymbol]) =
+    symbols.iterator.foldLeft((z._1, z._2)) {
+      case ((types, terms), symbol: TypeSymbol) => (types + (symbol.name -> symbol), terms)
+      case ((types, terms), symbol @ FunctionSymbol(Var(name), S(Var(operator)), _)) =>
+        (types, terms + (name -> symbol) + (operator -> symbol))
+      case ((types, terms), symbol: TermSymbol) => (types, terms + (symbol.name -> symbol))
+    }
+
+  def from(symbols: IterableOnce[Symbol]): Scope = {
+    val (newTypes, newTerms) = partitionSymbols((Map.empty, Map.empty), symbols)
+    new Scope(N, newTypes, newTerms)
+  }
+
+  val global: Scope = {
+    val trueDefn = NuTypeDef(Mod, TypeName("true"), Nil, N, N, N, Nil, N, N, TypingUnit(Nil))(N, N)
+    val falseDefn = NuTypeDef(Mod, TypeName("false"), Nil, N, N, N, Nil, N, N, TypingUnit(Nil))(N, N)
+    val trueSymbol = new ModuleSymbol(trueDefn)
+    val falseSymbol = new ModuleSymbol(falseDefn)
+    Scope.from(
+      """true,false,document,window,typeof,toString,not,succ,log,discard,negate,
+        |round,add,sub,mul,div,sqrt,lt,le,gt,ge,slt,sle,sgt,sge,length,concat,eq,
+        |ne,error,id,if,emptyArray,+,-,*,%,/,<,>,<=,>=,==,===,<>,&&,||"""
+        .stripMargin
+        .split(",")
+        .iterator
+        .map(name => new ValueSymbol(Var(name), false))
+        .concat(trueSymbol :: falseSymbol :: Nil)
+    )
+  }
 }
diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index 475c33fc25..64d046e23e 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -1,79 +1,133 @@
 package mlscript.pretyper
 
 import collection.mutable.{Buffer, Map => MutMap, Set => MutSet}
-import mlscript.{NuFunDef, NuTypeDef, TypeName, Var}
+import mlscript.{Loc, NuFunDef, NuTypeDef, TypeName, Var}
+import mlscript.{Cls, Trt, Mxn, Als, Mod}
 import mlscript.utils._, shorthands._
 
-sealed abstract class Symbol(val name: String)
+package object symbol {
+  sealed abstract class Symbol(val name: Str) {
+    def typeSymbolOption: Opt[TypeSymbol] = this match {
+      case symbol: TypeSymbol => S(symbol)
+      case _ => N
+    }
+    def termSymbolOption: Opt[TermSymbol] = this match {
+      case symbol: TermSymbol => S(symbol)
+      case _ => N
+    }
+  }
+
+  sealed abstract class TypeSymbol(val defn: NuTypeDef) extends Symbol(defn.name) {
+    def scope: Scope = ???
+    def contents: Map[Str, Symbol] = ???
+
+    def complete(scope: Scope, contents: Map[Str, Symbol]): Unit = ???
+
+    var baseTypes: Ls[TypeSymbol] = Nil
+    var sealedDerivedTypes: Ls[TypeSymbol] = Nil
+
+    @inline def hasSuperType(superType: TypeSymbol): Bool = baseTypes.exists(_ === superType)
+  }
+
+  final class ClassSymbol(/* enclosingScope: Scope, */ defn: NuTypeDef) extends TypeSymbol(defn) {
+    require(defn.kind === Cls)
+    // lazy val (scope, contents) = (enclosingScope.derive, Map.empty[Str, Symbol])
+  }
+
+  final class TraitSymbol(/* enclosingScope: Scope, */ defn: NuTypeDef) extends TypeSymbol(defn) {
+    require(defn.kind === Trt)
+    // lazy val (scope, contents) = (enclosingScope.derive, Map.empty[Str, Symbol])
+  }
+
+  final class MixinSymbol(/* enclosingScope: Scope, */ defn: NuTypeDef) extends TypeSymbol(defn) {
+    require(defn.kind === Mxn)
+    // lazy val (scope, contents) = (enclosingScope.derive, Map.empty[Str, Symbol])
+  }
+
+  final class TypeAliasSymbol(/* enclosingScope: Scope, */ defn: NuTypeDef) extends TypeSymbol(defn) {
+    require(defn.kind === Als)
+    // lazy val (scope, contents) = (enclosingScope.derive, Map.empty[Str, Symbol])
+  }
 
-final class TypeSymbol(val nme: TypeName, val defn: NuTypeDef) extends Symbol(nme.name) {
-  var containedScope: Opt[Scope] = N
-  var containedContents: Opt[TypeContents] = N
+  final class ModuleSymbol(/* enclosingScope: Scope, */ defn: NuTypeDef) extends TypeSymbol(defn) {
+    require(defn.kind === Mod)
+    // lazy val (scope, contents) = (enclosingScope.derive, Map.empty[Str, Symbol])
+  }
 
-  def scope: Scope = containedScope.getOrElse(throw new Exception("Scope not set"))
-  def contents: TypeContents = containedContents.getOrElse(throw new Exception("TypeContents not set")) 
+  sealed abstract class TermSymbol(name: String) extends Symbol(name)
 
-  def scope_=(s: Scope): Unit = containedScope = S(s)
-  def contents_=(c: TypeContents): Unit = containedContents = S(c)
-}
+  final class FunctionSymbol(val defn: NuFunDef) extends TermSymbol(defn.nme.name) {
+    require(defn.isLetRec.isEmpty)
+    val nme: Var = defn.nme
+    val operator: Opt[Var] = defn.symbolicNme
+  }
 
-sealed abstract class TermSymbol(name: String) extends Symbol(name)
+  object FunctionSymbol {
+    def unapply(symbol: TermSymbol): Opt[(Var, Opt[Var], NuFunDef)] =
+      symbol match {
+        case fs: FunctionSymbol => S(fs.nme, fs.operator, fs.defn)
+        case _ => N
+      }
+  }
 
-final class FunctionSymbol(val nme: Var, val defn: NuFunDef) extends TermSymbol(nme.name) {
-  var containedScope: Opt[Scope] = N
+  sealed abstract class ScrutineeSymbol(name: Str) extends TermSymbol(name) {
+    def toLoc: Opt[Loc]
 
-  def scope: Scope = containedScope.getOrElse(throw new Exception("Scope not set"))
+    val matchedClasses: MutMap[TypeSymbol, Buffer[Loc]] = MutMap.empty
 
-  def scope_=(s: Scope): Unit = containedScope = S(s)
-}
+    def addMatchedClass(symbol: TypeSymbol, loc: Opt[Loc]): Unit = {
+      matchedClasses.getOrElseUpdate(symbol, Buffer.empty) ++= loc
+    }
 
-sealed abstract class ScrutineeSymbol(name: Str) extends TermSymbol(name) {
-  val matchedClasses: MutSet[Var] = MutSet.empty
-  /**
-    * This map contains the sub-scrutinee symbols when this scrutinee is matched
-    * against class patterns.
-    */
-  val classParameterScrutineeMap: MutMap[Var -> Int, SubValueSymbol] = MutMap.empty
-  val tupleElementScrutineeMap: MutMap[Int, SubValueSymbol] = MutMap.empty
-  val recordValueScrutineeMap: MutMap[Var, SubValueSymbol] = MutMap.empty
+    /**
+      * This map contains the sub-scrutinee symbols when this scrutinee is matched
+      * against class patterns.
+      */
+    val classParameterScrutineeMap: MutMap[Var -> Int, SubValueSymbol] = MutMap.empty
+    val tupleElementScrutineeMap: MutMap[Int, SubValueSymbol] = MutMap.empty
+    val recordValueScrutineeMap: MutMap[Var, SubValueSymbol] = MutMap.empty
 
-  def addSubScrutinee(className: Var, index: Int, parameter: Var): SubValueSymbol = {
-    classParameterScrutineeMap.getOrElseUpdate(className -> index, {
-      new SubValueSymbol(this, S(className) -> S(index), parameter.name)
-    })
+    def addSubScrutinee(className: Var, index: Int, parameter: Var, loc: Opt[Loc]): SubValueSymbol = {
+      classParameterScrutineeMap.getOrElseUpdate(className -> index, {
+        new SubValueSymbol(this, S(className) -> S(index), parameter.name, loc)
+      })
+    }
+
+    def addSubScrutinee(fieldName: Var, loc: Opt[Loc]): SubValueSymbol =
+      recordValueScrutineeMap.getOrElseUpdate(fieldName, {
+        val synthesizedName = s"${name}$$record${fieldName}"
+        new SubValueSymbol(this, S(fieldName) -> N, synthesizedName, loc)
+      })
+    
+    def addSubScrutinee(index: Int, loc: Opt[Loc]): SubValueSymbol =
+      tupleElementScrutineeMap.getOrElseUpdate(index, {
+        val synthesizedName = s"${name}$$tuple${index.toString}"
+        new SubValueSymbol(this, N -> S(index), synthesizedName, loc)
+      })
+
+    /**
+      * This buffer contains alias variables which created by "let" bindings or
+      * alias patterns.
+      */
+    val aliases: Buffer[Var] = Buffer.empty
   }
 
-  def addSubScrutinee(fieldName: Var): SubValueSymbol =
-    recordValueScrutineeMap.getOrElseUpdate(fieldName, {
-      val synthesizedName = s"${name}$$record${fieldName}"
-      new SubValueSymbol(this, S(fieldName) -> N, synthesizedName)
-    })
-  
-  def addSubScrutinee(index: Int): SubValueSymbol =
-    tupleElementScrutineeMap.getOrElseUpdate(index, {
-      val synthesizedName = s"${name}$$tuple${index.toString}"
-      new SubValueSymbol(this, N -> S(index), synthesizedName)
-    })
-
-  /**
-    * This buffer contains alias variables which created by "let" bindings or
-    * alias patterns.
-    */
-  val aliases: Buffer[Var] = Buffer.empty
-}
-
-final class ValueSymbol(val nme: Var, val hoisted: Bool) extends ScrutineeSymbol(nme.name)
-
-final class SubValueSymbol(
-  val parentSymbol: ScrutineeSymbol,
-  /**
-    * TODO: This becomes useless now.
-    * Class patterns: (S(className), S(index))
-    * Record patterns: (S(fieldName), N)
-    * Tuple patterns: (N, S(index))
-    */
-  val accessor: (Opt[Var], Opt[Int]),
-  override val name: Str
-) extends ScrutineeSymbol(name) {
-  lazy val toVar: Var = Var(name)
-}
+  final class ValueSymbol(val nme: Var, val hoisted: Bool) extends ScrutineeSymbol(nme.name) {
+    override def toLoc: Opt[Loc] = nme.toLoc
+  }
+
+  final class SubValueSymbol(
+    val parentSymbol: ScrutineeSymbol,
+    /**
+      * TODO: This becomes useless now.
+      * Class patterns: (S(className), S(index))
+      * Record patterns: (S(fieldName), N)
+      * Tuple patterns: (N, S(index))
+      */
+    val accessor: (Opt[Var], Opt[Int]),
+    override val name: Str,
+    override val toLoc: Opt[Loc]
+  ) extends ScrutineeSymbol(name) {
+    lazy val toVar: Var = Var(name)
+  }
+}
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/pretyper/package.scala b/shared/src/main/scala/mlscript/pretyper/package.scala
index 06d8773c17..addb94ce08 100644
--- a/shared/src/main/scala/mlscript/pretyper/package.scala
+++ b/shared/src/main/scala/mlscript/pretyper/package.scala
@@ -2,13 +2,4 @@ package mlscript
 
 import mlscript.utils._, shorthands._
 
-package object pretyper {
-  def shortName(term: Term): Str = term match {
-    case Var(name) => s"Var(\"$name\")"
-    case literal: Lit => literal.toString
-    case _ =>
-      val name = term.getClass.getSimpleName
-      val arity = term.children.length // Imprecise
-      if (arity === 0) { name } else s"${name}(${(", _" * arity).drop(2)})"
-  }
-}
+package object pretyper
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 0c09de16a2..1b192a4804 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -2,7 +2,8 @@ package mlscript.ucs
 
 import collection.mutable.{Map => MutMap}
 import mlscript.ucs.stages._
-import mlscript.pretyper.{PreTyper, Scope, ScrutineeSymbol, Symbol, ValueSymbol}
+import mlscript.pretyper.{PreTyper, Scope}
+import mlscript.pretyper.symbol._
 import mlscript._, utils._, shorthands._
 import mlscript.Message, Message.MessageContext
 
@@ -12,7 +13,6 @@ trait DesugarUCS extends Transformation
                     with Normalization
                     with PostProcessing 
                     with CoverageChecking { self: PreTyper =>
-  
 
   protected def traverseIf(`if`: If)(implicit scope: Scope): Unit =
     trace("traverseIf") {
@@ -70,7 +70,7 @@ trait DesugarUCS extends Transformation
       }
     }()
 
-  private def traversePattern(scrutinee: Var, pattern: core.Pattern): List[Var -> Symbol] =
+  private def traversePattern(scrutinee: Var, pattern: core.Pattern)(implicit scope: Scope): List[Var -> Symbol] =
     trace(s"traversePattern <== $pattern") {
       lazy val scrutineeSymbol = scrutinee.symbol match {
         case symbol: ScrutineeSymbol => symbol
@@ -82,29 +82,47 @@ trait DesugarUCS extends Transformation
         case core.Pattern.Name(nme) =>
           nme.symbol = scrutineeSymbol
           nme -> scrutineeSymbol :: Nil
-        case core.Pattern.Class(nme, N) =>
-          scrutineeSymbol.matchedClasses += nme
-          Nil
-        case core.Pattern.Class(nme, S(parameters)) =>
-          scrutineeSymbol.matchedClasses += nme
-          parameters.iterator.zipWithIndex.flatMap { 
-            case (N, _) => N
-            case (S(parameter), index) =>
-              val symbol = scrutineeSymbol.addSubScrutinee(nme, index, parameter)
-              parameter.symbol = symbol; S(parameter -> symbol)
-          }.toList
+        case core.Pattern.Class(nme, maybeParameters) =>
+          println(s"name has location: ${nme.toLoc.isDefined}")
+          // Resolve `nme`. It can either be a class, a trait, or a module.
+          val symbol = scope.getTypeSymbol(nme.name) match {
+            case S(symbol: TraitSymbol) => println(s"${nme.name} is a trait"); symbol
+            case S(symbol: ClassSymbol) => println(s"${nme.name} is a class"); symbol
+            case S(symbol: ModuleSymbol) => println(s"${nme.name} is a module"); symbol
+            case S(symbol: MixinSymbol) =>
+              throw new DesugaringException(msg"Mixins are not allowed in pattern" -> nme.toLoc :: Nil)
+            case S(symbol: TypeAliasSymbol) =>
+              throw new DesugaringException(msg"Type alias is not allowed in pattern" -> nme.toLoc :: Nil)
+            // case S(symbol: TermSymbol) =>
+            //   throw new DesugaringException(msg"Only classes, modules, and traits can be matched against." -> nme.toLoc :: Nil)
+            case N =>
+              throw new DesugaringException(msg"Undefined symbol found in patterns." -> nme.toLoc :: Nil)
+          }
+          nme.symbol = symbol
+          // Add the class to the list of matched classes.
+          scrutineeSymbol.addMatchedClass(symbol, nme.toLoc)
+          maybeParameters match {
+            case N => Nil
+            case S(parameters) =>
+              parameters.iterator.zipWithIndex.flatMap { 
+                case (N, _) => N
+                case (S(parameter), index) =>
+                  val symbol = scrutineeSymbol.addSubScrutinee(nme, index, parameter, parameter.toLoc)
+                  parameter.symbol = symbol; S(parameter -> symbol)
+              }.toList
+          }
         case core.Pattern.Tuple(elements) => elements.flatMap {
           case N => Nil
           case S(pattern) => elements.iterator.zipWithIndex.flatMap {
             case (N, _) => N
             case (S(element), index) =>
-              val symbol = scrutineeSymbol.addSubScrutinee(index)
+              val symbol = scrutineeSymbol.addSubScrutinee(index, element.toLoc)
               element.symbol = symbol; S(element -> symbol)
           }.toList
         }
         case core.Pattern.Record(entries) =>
           entries.iterator.zipWithIndex.map { case ((fieldName, bindingName), _) =>
-            val symbol = scrutineeSymbol.addSubScrutinee(fieldName)
+            val symbol = scrutineeSymbol.addSubScrutinee(fieldName, bindingName.toLoc)
             bindingName.symbol = symbol; bindingName -> symbol
           }.toList
       }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index 0b3d035356..fc157c5c4e 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -1,11 +1,11 @@
 package mlscript.ucs.stages
 
-import mlscript.{Case, CaseBranches, CaseOf, Let, Loc, NoCases, Term, Var, Wildcard}
-import mlscript.pretyper.{ScrutineeSymbol, Symbol}
+import annotation.tailrec
+import collection.mutable.ListBuffer
+import mlscript.{Case, CaseBranches, CaseOf, Let, Lit, Loc, NoCases, Term, Var, Wildcard}
+import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
 import mlscript.Message, Message.MessageContext
-import mlscript.pretyper.shortName
-import scala.annotation.tailrec
 import mlscript.{SimpleTerm, Diagnostic, ErrorReport, WarningReport}
 
 trait CoverageChecking { self: mlscript.pretyper.Traceable =>
@@ -19,24 +19,37 @@ trait CoverageChecking { self: mlscript.pretyper.Traceable =>
 
   private def collectRegistry(term: Term): MatchRegistry = {
     @tailrec
-    def rec(acc: MatchRegistry, rest: Ls[Term]): MatchRegistry = rest match {
-      case Nil => acc
-      case head :: tail => head match {
-        case Let(_, _, _, body) => rec(acc, body :: tail)
-        case CaseOf(Scrutinee(_, scrutinee), cases) =>
-          rec(
-            acc.updatedWith(scrutinee)(vs => S(cases.foldLeft(vs.getOrElse(Set.empty))({ 
-              case (acc, (className: Var) -> _) => acc + className
-              case (acc, _) => acc
-            })((x, _) => x))),
-            tail ++ cases.foldLeft
-              (Nil: Ls[Term])
-              ({ case (acc, _ -> body) => body :: acc })
-              ((acc, els) => els.fold(acc)(_ :: acc))
-          )
-        case _ => rec(acc, tail)
+    def rec(acc: MatchRegistry, rest: Ls[Term]): MatchRegistry =
+      rest match {
+        case Nil => println("end"); acc
+        case head :: tail =>
+          println(s"collect ${inspect.shallow(head)}")
+          head match {
+            case Let(_, _, _, body) =>
+              println(s"continue on ${inspect.shallow(body)}")
+              rec(acc, body :: tail)
+            case CaseOf(Scrutinee(_, scrutinee), cases) =>
+              println(s"scrutinee: ${scrutinee.name}")
+              rec(
+                acc.updatedWith(scrutinee)(vs => S(cases.foldLeft(vs.getOrElse(CaseSet.empty))({ 
+                  case (acc, (className: Var) -> _) =>
+                    println(s"found pattern $className (has location = ${className.toLoc.nonEmpty})")
+                    val classLikeSymbol = className.symbolOption.flatMap(_.typeSymbolOption).getOrElse {
+                      throw new Exception(s"$className is not associated with any type symbol.")
+                    }
+                    acc.add(classLikeSymbol, className.toLoc)
+                  case (acc, (literal: Lit) -> _) =>
+                    println(s"TODO: skipped literal $literal")
+                    acc
+                })((x, _) => x))),
+                tail ++ cases.foldLeft
+                  (Nil: Ls[Term])
+                  ({ case (acc, _ -> body) => body :: acc })
+                  ((acc, els) => els.fold(acc)(_ :: acc))
+              )
+            case _ => rec(acc, tail)
+          }
       }
-    }
     rec(Map.empty, term :: Nil)
   }
 
@@ -44,14 +57,14 @@ trait CoverageChecking { self: mlscript.pretyper.Traceable =>
       term: Term,
       pending: MatchRegistry,
       working: MatchRegistry,
-      assumptions: Map[ScrutineeSymbol, Var]
+      seen: SeenRegistry
   ): Ls[Diagnostic] =
-    trace(s"checkCoverage <== ${shortName(term)}, ${pending.size} pending, ${working.size} working") {
-      println(s"assumptions: " + (if (assumptions.isEmpty) "empty" else
-        assumptions.iterator.map { case (k, v) => s"${k.name} is $v" }.mkString(", ")
+    trace(s"checkCoverage <== ${inspect.shallow(term)}, ${pending.size} pending, ${working.size} working, ${seen.size} seen") {
+      println(s"seen: " + (if (seen.isEmpty) "empty" else
+        seen.iterator.map { case (k, (s, _, _)) => s"${k.name} is ${s.name}" }.mkString(", ")
       ))
       term match {
-        case Let(_, _, _, body) => checkCoverage(body, pending, working, assumptions)
+        case Let(_, _, _, body) => checkCoverage(body, pending, working, seen)
         case CaseOf(Scrutinee(scrutineeVar, scrutinee), cases) =>
           println(s"scrutinee: ${scrutinee.name}")
           // If the scrutinee is still pending (i.e., not matched yet), then we
@@ -62,67 +75,190 @@ trait CoverageChecking { self: mlscript.pretyper.Traceable =>
           // 1. The scrutinee has been never visited, which is an error.
           // 2. It has been matched to be an instance of some class. Therefore,
           //    we need to check if this is a contradiction.
-          val (unseenClasses, newPending) = pending.get(scrutinee) match {
+          val (unseenPatterns, newPending) = pending.get(scrutinee) match {
             case S(matchedClasses) => matchedClasses -> (pending - scrutinee)
             case N => working.get(scrutinee) match {
-              case S(unseenClasses) => unseenClasses -> pending
-              case N => throw new Exception(s"Scrutinee ${scrutinee.name} is not matched.")
+              case S(unseenPatterns) => unseenPatterns -> pending
+              case N =>
+                // Neither in the working list nor in the pending list.
+                seen.get(scrutinee) match {
+                  // The scrutine may have been matched.
+                  case S((_, _, remainingPatterns)) => remainingPatterns -> pending
+                  case N =>
+                    // The scrutinee has never been visited. This should not happen.
+                    println("working list: " + showRegistry(working))
+                    throw new Exception(s"Scrutinee ${scrutinee.name} is not in the working list.")
+                }
             }
           }
-          // We keep removing classes from the unseen class list and adding
-          // diagnostics (warnings and errors).
-          cases.foldLeft((unseenClasses, Nil: Ls[Diagnostic]))({
-            case ((red, acc), (className: Var) -> body) =>
-              if (red contains className) {
-                (
-                  // The class is matched. Remove it from the class list.
-                  red - className,
-                  // We remove the scrutinee from the working list and add
-                  // `scrutinee` is `className` to the assumptions.
-                  acc ++ checkCoverage(body, newPending, working - scrutinee, assumptions + (scrutinee -> className))
-                )
-              } else {
-                red -> (acc :+ (assumptions.get(scrutinee) match {
-                  case S(`className`) => WarningReport("tautology", Nil, Diagnostic.PreTyping)
-                  case S(otherClassName) => ErrorReport("contradiction", Nil, Diagnostic.PreTyping)
-                  case N => ErrorReport("unvisited scrutinee", Nil, Diagnostic.PreTyping)
-                }))
+          // We go through cases and keep removing the current pattern from the
+          // unseen pattern set.
+          // Meanwhile, we keep adding diagnostics if we meet warnings and errors.
+          cases.foldLeft((unseenPatterns, Nil: Ls[Diagnostic]))({
+            case ((unseenPatterns, diagnostics), (className: Var) -> body) =>
+              val classSymbol = className.symbolOption.flatMap(_.typeSymbolOption).getOrElse {
+                throw new Exception(s"$className is not associated with a type symbol")
+              }
+              println(s"class symbol: ${classSymbol.name}")
+              unseenPatterns.split(classSymbol) match {
+                case S((locations, refiningPatterns, remainingPatterns)) =>
+                  println(s"remove ${className} and it's unrelated patterns from working")
+                  println("unseen patterns: " + unseenPatterns.patterns.mkString("[", ", ", "]"))
+                  println("remaining patterns: " + remainingPatterns.patterns.mkString("[", ", ", "]"))
+                  // Remove the scrutinee from the working list.
+                  val newWorking = if (remainingPatterns.isEmpty)
+                    working - scrutinee
+                  else
+                    working.updated(scrutinee, remainingPatterns)
+                  // Add "`scrutinee` is `className`" to the seen registry.
+                  val newSeen = seen + (scrutinee -> (classSymbol, locations, refiningPatterns))
+                  (
+                    remainingPatterns,
+                    diagnostics ++ checkCoverage(body, newPending, newWorking, newSeen)
+                  )
+                case N =>
+                  unseenPatterns -> (diagnostics :+ (seen.get(scrutinee) match {
+                    case S((`classSymbol`, _, _)) => WarningReport("tautology", Nil, Diagnostic.PreTyping)
+                    case S(_) => ErrorReport("contradiction", Nil, Diagnostic.PreTyping)
+                    case N => ErrorReport("unvisited scrutinee", Nil, Diagnostic.PreTyping)
+                  }))
               }
-            case (acc, _ -> _) =>
+            case (diagnostics, (_: Lit) -> _) =>
               println("CANNOT check literal patterns")
-              acc
+              diagnostics
           }) {
             case ((missingCases, diagnostics), N) =>
-              println("MISSING cases: " + missingCases.iterator.map(className => s"${scrutinee.name} is $className").mkString("[", ", ", "]"))
-              diagnostics ++ (missingCases.iterator.map { className  =>
-                ErrorReport({
-                  val s1 = assumptions.iterator.map {
-                    case (scrutinee, className) => s"${scrutinee.name} is $className"
-                  }.mkString(", ")
-                  val s2 = if (s1.isEmpty) "" else s" $s1, and"
-                  msg"missing a case where$s2 ${scrutinee.name} is ${className.name}" -> N ::
-                    msg"missing the condition" -> className.toLoc ::
-                    assumptions.iterator.zipWithIndex.map({ case (scrutinee, className) -> index =>
-                      msg"${if (index > 0) "and" else "when"} ${scrutinee.name} is ${className.name}" -> className.toLoc
-                    }).toList
-                }, true, Diagnostic.PreTyping)
-              })
-            case ((unseenClasses, diagnostics), S(default)) =>
-              println("wildcard case")
-              checkCoverage(default, newPending, working.updated(scrutinee, unseenClasses), assumptions)
+              println("remaining cases should are not covered")
+              println("MISSING cases: " + missingCases.patterns.mkString("[", ", ", "]"))
+              diagnostics ++ explainMissingCases(scrutinee, seen, missingCases)
+            case ((remainingCases, diagnostics), S(default)) =>
+              println("remaining cases should be covered by the wildcard")
+              checkCoverage(default, newPending, working.updated(scrutinee, remainingCases), seen)
           }
         case other => println("STOP"); Nil
       }
-    }(ls => s"checkCoverage ==> ${ls.length}")
+    }(ls => s"checkCoverage ==> ${ls.length} diagnostics")
 }
 
 object CoverageChecking {
-  type MatchRegistry = Map[ScrutineeSymbol, Set[Var]]
+  type MatchRegistry = Map[ScrutineeSymbol, CaseSet]
+
+  type SeenRegistry = Map[ScrutineeSymbol, (TypeSymbol, Ls[Loc], CaseSet)]
+
+  sealed abstract class Pattern {
+    override def toString(): String = this match {
+      case Pattern.ClassLike(symbol) => s"${symbol.defn.kind.str} `${symbol.name}`"
+      case Pattern.Tuple(_) => "tuple"
+      case Pattern.Literal(literal) => s"literal ${inspect.deep(literal)}"
+    }
+  }
+  object Pattern {
+    final case class ClassLike(symbol: TypeSymbol) extends Pattern
+    final case class Tuple(TODO: Nothing) extends Pattern // To be implemented in the near future.
+    final case class Literal(literal: Lit) extends Pattern
+  }
+
+  /**
+    * A `CaseSet` represents all patterns that a particular scrutinee is
+    * being matched with within a UCS expression. Each Pattern is associated
+    * with the locations where these patterns appear.
+    *
+    * @param patterns a set of patterns that the scrutinee is matched with.
+    * @param hasWildcard if the scrutinee is matched with a wildcard pattern.
+    */
+  final case class CaseSet(val cases: Map[Pattern, Ls[Loc]], val hasWildcard: Bool) {
+    /** TODO: This seems useless. */
+    @inline def withWildcard: CaseSet = if (hasWildcard) this else copy(hasWildcard = true)
+
+    /**
+      * Split the pattern set into two pattern sets.
+      * 
+      * For example, let A be the base type of B, C, and D. Plus, class `Z` is
+      * unrelated to any of them. Suppose the initial pattern set is
+      * `{ A, B, C, Z }`. Splitting the set results in two sets, one set
+      * contains classes that are compatible with `A`, and the other set
+      * contains classes that are unrelated to `A`.
+      * 
+      * For example, if we split the set with `A`, then we get `{ B, C }` and
+      * set `{ Z }`. Set `{ B, C }` represents that the scrutinee can be further
+      * refined to class `B` or `class C`. Set `{ Z }` represents that if the
+      * scrutinee is not `A`, then it can be `Z`.
+      * 
+      * If `A` is sealed to `B`, `C`, and `D`, then we get `{ B, C, D }` and
+      * `{ Z }`. Because if the scrutinee is assumed to be `A`, then it can also
+      * be `D` other than `B`, `C`.
+      *
+      * @param classLikeSymbol the type symbol represents the class like type
+      * @return If the pattern set doesn't include the given type symbol, this
+      *         returns `None`. Otherwise, the function returns a triplet of the
+      *         locations where the pattern appears, the related patterns, and
+      *         unrelated patterns.
+      */
+    def split(classLikeSymbol: TypeSymbol): Opt[(Ls[Loc], CaseSet, CaseSet)] = {
+      val classLikePattern = Pattern.ClassLike(classLikeSymbol)
+      cases.get(classLikePattern).map { locations =>
+        val withoutSymbol = cases - classLikePattern
+        val relatedPatterns = withoutSymbol.filter {
+          case (Pattern.ClassLike(otherSymbol), _) => otherSymbol.baseTypes.contains(classLikeSymbol)
+          case (_: Pattern.Tuple | _: Pattern.Literal) -> _ => false
+        } ++ classLikeSymbol.sealedDerivedTypes.iterator.map { symbol =>
+          Pattern.ClassLike(symbol) -> symbol.defn.nme.toLoc.toList
+        }
+        val unrelatedPatterns = withoutSymbol.filter {
+          case (Pattern.ClassLike(otherSymbol), _) => !otherSymbol.baseTypes.contains(classLikeSymbol)
+          case (_: Pattern.Tuple | _: Pattern.Literal) -> _ => true
+        }
+        (locations, copy(relatedPatterns), copy(unrelatedPatterns))
+      }
+    }
+
+    /** Add a type sysmbol as a class like pattern to the set. */
+    def add(classLikeSymbol: TypeSymbol, location: Opt[Loc]): CaseSet = {
+      val classLikePattern = Pattern.ClassLike(classLikeSymbol)
+      copy(cases = cases.updatedWith(classLikePattern) {
+        case N => S(location.toList)
+        case S(locations) => S(location.toList ++ locations)
+      })
+    }
+
+    /** Get an iterator of only patterns. */
+    @inline def patterns: Iterator[Pattern] = cases.iterator.map(_._1)
+
+    @inline def isEmpty: Bool = cases.isEmpty
+
+    @inline def size: Int = cases.size
+  }
+
+  object CaseSet {
+    lazy val empty: CaseSet = CaseSet(Map.empty, false)
+  }
+
+  /** Create an `ErrorReport` that explains missing cases. */
+  private def explainMissingCases(scrutinee: ScrutineeSymbol, seen: SeenRegistry, missingCases: CaseSet): Opt[ErrorReport] =
+    if (missingCases.isEmpty) {
+      N
+    } else {
+      S(ErrorReport({
+        val lines = (msg"Scrutinee `${scrutinee.name}` has ${"missing case".pluralize(missingCases.size, true)}" -> scrutinee.toLoc) ::
+          (missingCases.cases.iterator.flatMap { case (pattern, locations) =>
+            (msg"It can be ${pattern.toString}" -> locations.headOption) :: Nil
+          }.toList)
+        if (seen.isEmpty) {
+          lines
+        } else {
+          seen.iterator.zipWithIndex.map { case ((scrutinee, (classSymbol, locations, cases)), i) =>
+            val prologue = if (i === 0) "When " else ""
+            val epilogue = if (seen.size === 1) "" else if (i === seen.size - 1) ", and" else ","
+            msg"${prologue}scrutinee `${scrutinee.name}` is `${classSymbol.name}`$epilogue" -> locations.headOption
+          }.toList ::: lines
+        }
+      }, true, Diagnostic.PreTyping))
+    }
 
   /** A helper function that prints entries from the given registry line by line. */
-  def showRegistry(registry: MatchRegistry): Str =
+  private def showRegistry(registry: MatchRegistry): Str =
     if (registry.isEmpty) "empty" else
       registry.iterator.map { case (scrutinee, matchedClasses) =>
-        matchedClasses.iterator.mkString(s">>> ${scrutinee.name} => [", ", ", "]")
+        matchedClasses.patterns.mkString(s">>> ${scrutinee.name} => [", ", ", "]")
       }.mkString("\n", "\n", "")
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index b8c1d9883c..7a97e9ed52 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -4,7 +4,7 @@ import mlscript.{App, Asc, Fld, Term, Var, TypeName}
 import mlscript.ucs.{syntax => s, core => c, PartialTerm}
 import mlscript.ucs.helpers.mkBinOp
 import mlscript.utils._, shorthands._
-import mlscript.pretyper.{ScrutineeSymbol, SubValueSymbol, ValueSymbol}
+import mlscript.pretyper.symbol._
 import mlscript.ucs.DesugaringException
 import mlscript.Message, Message.MessageContext
 
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 1d5fa1c507..193933e642 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -4,7 +4,8 @@ package mlscript.ucs.stages
 import mlscript.ucs.{Lines, LinesOps}
 import mlscript.ucs.core._
 import mlscript.ucs.helpers._
-import mlscript.pretyper.Symbol
+import mlscript.pretyper.Scope
+import mlscript.pretyper.symbol._
 import mlscript.{App, CaseOf, Fld, FldFlags, Let, Loc, Sel, Term, Tup, Var, StrLit}
 import mlscript.{CaseBranches, Case, Wildcard, NoCases}
 import mlscript.Message, Message.MessageContext
@@ -19,30 +20,30 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
     * @param split the split to normalize
     * @return the normalized term
     */ 
-  @inline def normalize(split: Split): Term = normalizeToTerm(split)
+  @inline def normalize(split: Split)(implicit scope: Scope): Term = normalizeToTerm(split)
 
-  private def normalizeToTerm(split: Split): Term = trace("normalizeToTerm") {
+  private def normalizeToTerm(split: Split)(implicit scope: Scope): Term = trace("normalizeToTerm") {
     split match {
       case Split.Cons(Branch(scrutinee, Pattern.Name(nme), continuation), tail) =>
         println(s"alias $scrutinee => $nme")
         Let(false, nme, scrutinee, normalizeToTerm(continuation ++ tail))
       case Split.Cons(Branch(scrutinee, pattern @ Pattern.Literal(literal), continuation), tail) =>
-        val trueBranch = normalizeToTerm(specialize(continuation ++ tail, Yes)(scrutinee.symbol, pattern))
-        val falseBranch = normalizeToCaseBranches(specialize(tail, No)(scrutinee.symbol, pattern))
+        val trueBranch = normalizeToTerm(specialize(continuation ++ tail, Yes)(scrutinee.symbol, pattern, scope))
+        val falseBranch = normalizeToCaseBranches(specialize(tail, No)(scrutinee.symbol, pattern, scope))
         CaseOf(scrutinee, Case(literal, trueBranch, falseBranch))
       // No class parameters. Easy
       case Split.Cons(Branch(scrutinee, pattern @ Pattern.Class(nme, N), continuation), tail) =>
-        println(s"match $scrutinee with $nme")
-        val trueBranch = normalizeToTerm(specialize(continuation ++ tail, Yes)(scrutinee.symbol, pattern))
-        val falseBranch = normalizeToCaseBranches(specialize(tail, No)(scrutinee.symbol, pattern))
+        println(s"match $scrutinee with $nme (has location: ${nme.toLoc.isDefined})")
+        val trueBranch = normalizeToTerm(specialize(continuation ++ tail, Yes)(scrutinee.symbol, pattern, scope))
+        val falseBranch = normalizeToCaseBranches(specialize(tail, No)(scrutinee.symbol, pattern, scope))
         CaseOf(scrutinee, Case(nme, trueBranch, falseBranch))
       case Split.Cons(Branch(scrutinee, pattern @ Pattern.Class(nme, S(parameters)), continuation), tail) =>
         println(s"match $scrutinee with $pattern")
         val trueBranch = trace("compute true branch"){
-          normalizeToTerm(specialize(continuation ++ tail, Yes)(scrutinee.symbol, pattern))
+          normalizeToTerm(specialize(continuation ++ tail, Yes)(scrutinee.symbol, pattern, scope))
         }()
         val falseBranch = trace("compute false branch"){
-          normalizeToCaseBranches(specialize(tail, No)(scrutinee.symbol, pattern))
+          normalizeToCaseBranches(specialize(tail, No)(scrutinee.symbol, pattern, scope))
         }()
         val unappliedVar = Var(s"args_${scrutinee.name}$$${nme.name}")
         val trueBranchWithBindings = Let(
@@ -62,11 +63,11 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
         throw new NormalizationException((msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc) :: Nil)
       case Split.Let(rec, nme, rhs, tail) => Let(rec, nme, rhs, normalizeToTerm(tail))
       case Split.Else(default) => default
-      case Split.Nil => StrLit("test") // FIXME
+      case Split.Nil => println("unexpected empty split"); ???
     }
   }()
 
-  private def normalizeToCaseBranches(split: Split): CaseBranches = trace("normalizeToCaseBranches") {
+  private def normalizeToCaseBranches(split: Split)(implicit scope: Scope): CaseBranches = trace("normalizeToCaseBranches") {
     split match {
       // case Split.Cons(head, Split.Nil) => Case(head.pattern, normalizeToTerm(head.continuation), NoCases)
       case other @ (Split.Cons(_, _) | Split.Let(_, _, _, _)) => Wildcard(normalizeToTerm(other))
@@ -78,7 +79,7 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
   // Specialize `split` with the assumption that `scrutinee` matches `pattern`.
   private def specialize
       (split: Split, matchOrNot: MatchOrNot)
-      (implicit scrutinee: Symbol, pattern: Pattern): Split =
+      (implicit scrutinee: Symbol, pattern: Pattern, scope: Scope): Split =
   trace(s"S${matchOrNot} <== ${scrutinee.name} is ${pattern}") {
     (matchOrNot, split) match {
       // Name patterns are translated to let bindings.
@@ -133,8 +134,17 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
                   case (_, _) => specialize(continuation ++ tail, Yes)
                 } // END match
               } else {
-                println(s"class name: $className =/= $otherClassName")
-                specializedTail
+                (otherClassName.symbolOption, className.symbolOption) match {
+                  case (S(otherClassSymbol: TypeSymbol), S(classSymbol: TypeSymbol)) if (
+                    otherClassSymbol.baseTypes contains classSymbol
+                  ) =>
+                    println(s"class name: $otherClassName <: $className")
+                    split
+                  case (there, here) =>
+                    println(s"class name: $className =/= $otherClassName")
+                    println(s"class symbols: ${there.fold("_")(_.name)} ${here.fold("_")(_.name)}")
+                    specializedTail
+                }
               }
             case _ => throw new NormalizationException((msg"Incompatible: ${pattern.toString}" -> pattern.toLoc) :: Nil)
           }
@@ -159,11 +169,20 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
                 println(s"class name: $className === $otherClassName")
                 specialize(tail, No) // TODO: Subsitute parameters to otherParameters
               } else {
-                println(s"class name: $className =/= $otherClassName")
-                split.copy(
-                  // head = head.copy(continuation = specialize(continuation, No)),
-                  tail = specialize(tail, No)
-                )
+                (otherClassName.symbolOption, className.symbolOption) match {
+                  case (S(otherClassSymbol: TypeSymbol), S(classSymbol: TypeSymbol)) if (
+                    otherClassSymbol.baseTypes contains classSymbol
+                  ) =>
+                    println(s"class name: $otherClassName <: $className")
+                    Split.Nil
+                  case (there, here) =>
+                    println(s"class name: $className =/= $otherClassName")
+                    println(s"class symbols: ${there.fold("_")(_.name)} ${here.fold("_")(_.name)}")
+                    split.copy(
+                      // head = head.copy(continuation = specialize(continuation, No)),
+                      tail = specialize(tail, No)
+                    )
+                }
               }
             case _ => throw new NormalizationException((msg"Incompatible: ${pattern.toString}" -> pattern.toLoc) :: Nil)
           }
@@ -198,7 +217,11 @@ object Normalization {
   }
 
   /**
-    * Convert a normalized term to a string with indentation.
+    * Convert a normalized term to a string with indentation. It makes use of
+    * some special markers.
+    *
+    * - `*` if the variable is associated with a symbol,
+    * - `†` if the class name has a location.
     */
   def showNormalizedTerm(term: Term): String = {
     def showTerm(term: Term): Lines = term match {
@@ -213,12 +236,15 @@ object Normalization {
     def showCaseBranches(caseBranches: CaseBranches): Lines =
       caseBranches match {
         case Case(pat, rhs, tail) =>
-          (s"case $pat =>" @: showTerm(rhs)) ++ showCaseBranches(tail)
+          // If the class name has a location, mark it with a dagger †.
+          // This is to track the location information.
+          val marker = if (pat.toLoc.isDefined) "†" else ""
+          (s"case $pat$marker =>" @: showTerm(rhs)) ++ showCaseBranches(tail)
         case Wildcard(term) => s"case _ =>" @: showTerm(term)
         case NoCases => Nil
       }
     def showVar(`var`: Var): Str =
-      // If the variable is associated with a symbol, mark it with an asterisk.
+      // If the variable is associated with a symbol, mark it with an asterisk *.
       `var`.name + (`var`.symbolOption.fold("")(_ => "*"))
     def showLet(let: Let): Lines = {
       val Let(rec, nme, rhs, body) = let
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index 416a329db8..ae4cfaa629 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -1,16 +1,33 @@
 package mlscript.ucs.stages
 
 import mlscript.{Case, CaseBranches, CaseOf, Let, Loc, NoCases, Term, Var, Wildcard}
-import mlscript.pretyper.{ScrutineeSymbol, Symbol}
+import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
 import mlscript.Message, Message.MessageContext
-import mlscript.pretyper.shortName
 import scala.annotation.tailrec
 
 trait PostProcessing { self: mlscript.pretyper.Traceable =>
   import PostProcessing._
 
-  def postProcess(term: Term): Term = trace(s"postProcess <== ${shortName(term)}") {
+  /**
+    * If the given `Var` represents a class name, get its `ClassSymbol`.
+    *
+    * @param className the class name variable
+    */
+  def getClassSymbolFromVar(className: Var): TypeSymbol =
+    trace(s"getClassSymbolFromVar <== ${inspect.shallow(className)}") {
+      className.symbolOption match {
+        case S(symbol: ClassSymbol) => symbol
+        case S(symbol: TraitSymbol) => symbol
+        case S(symbol: ModuleSymbol) => symbol
+        case S(symbol: Symbol) => throw new PostProcessingException(
+          msg"variable ${className.name} is not associated with a class symbol" -> N :: Nil)
+        case N => throw new PostProcessingException(
+          msg"variable ${className.name} is not associated with any symbols" -> N :: Nil)
+      }
+    }(symbol => s"getClassSymbolFromVar ==> ${symbol.name}")
+
+  def postProcess(term: Term): Term = trace(s"postProcess <== ${inspect.shallow(term)}") {
     // Normalized terms are constructed using `Let` and `CaseOf`.
     term match {
       case top @ CaseOf(scrutinee: Var, fst @ Case(className: Var, body, NoCases)) =>
@@ -25,33 +42,40 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
             msg"variable ${scrutinee.name} is not a scrutinee" -> N :: Nil
           )
         }
-        println(s"`${scrutinee}`'s matched classes: ${scrutineeSymbol.matchedClasses.iterator.map(_.name).mkString("[", ", ", "]")}")
-        // Post-process the first branch body.
+        val classSymbol = getClassSymbolFromVar(className)
+        println(s"`${scrutinee}`'s matched classes: ${scrutineeSymbol.matchedClasses.keysIterator.map(_.name).mkString("[", ", ", "]")}")
+        // Post-process the true branch.
         println("post-processing the first branch")
         val processedTrueBranch = postProcess(trueBranch)
         // Post-process the false branch.
-        val (default, cases) = scrutineeSymbol.matchedClasses.iterator.filter(_ =/= className)
+        println("post-processing the false branch")
+        println(s"searching for cases: " + scrutineeSymbol.matchedClasses.keysIterator.filter(_ =/= classSymbol).map(_.name).mkString("[", ", ", "]"))
+        val (default, cases) = scrutineeSymbol.matchedClasses.iterator.filter(_._1 =/= classSymbol)
           // For each case class name, distangle case branch body terms from the false branch.
-          .foldLeft[Opt[Term] -> Ls[Var -> Term]](S(falseBranch) -> Nil) {
-            case ((S(remainingTerm), cases), className) =>
-              val (leftoverTerm, extracted) = disentangle(remainingTerm, scrutineeSymbol, className)
-              avoidEmptyCaseOf(leftoverTerm) -> (extracted match {
+          .foldLeft[Opt[Term] -> Ls[(TypeSymbol, Opt[Loc], Term)]](S(falseBranch) -> Nil) {
+            case ((S(remainingTerm), cases), (classSymbol -> locations)) =>
+              println(s"searching for case: ${classSymbol.name}")
+              val (leftoverTerm, extracted) = disentangle(remainingTerm, scrutineeSymbol, classSymbol)
+              trimEmptyTerm(leftoverTerm) -> (extracted match {
                 case N =>
-                  println(s"no extracted term about $className")
+                  println(s"no extracted term about ${classSymbol.name}")
                   cases
                 case terms @ S(extractedTerm) => 
-                  println(s"extracted a term about $className")
-                  className -> postProcess(extractedTerm) :: cases
+                  println(s"extracted a term about ${classSymbol.name}")
+                  (classSymbol, locations.headOption, postProcess(extractedTerm)) :: cases
               })
-            // TODO: Consider either make the first tuple element as non-optional.
-            // TODO: Then, write a new helper function which checks if the term is an empty `CaseOf`.
             case ((N, cases), _) => (N, cases) 
           }
-        println(s"found ${cases.length} cases")
+        println(s"found ${cases.length} case branches")
+        val postProcessedDefault = default.map(postProcess)
         // Assemble a `CaseBranches`.
         val actualFalseBranch = cases.foldRight[CaseBranches](
-          default.fold[CaseBranches](NoCases)(Wildcard(_))
-        ) { case (className -> body, rest) => Case(className, body, rest) }
+          postProcessedDefault.fold[CaseBranches](NoCases)(Wildcard(_))
+        ) { case ((classSymbol, loc, body), rest) =>
+          // TODO: Why not just keep the class name?
+          val className = Var(classSymbol.name).withLoc(loc).withSymbol(classSymbol)
+          Case(className, body, rest)
+        }
         // Assemble the final `CaseOf`.
         top.copy(cases = fst.copy(body = processedTrueBranch, rest = actualFalseBranch))
       // We recursively process the body of as`Let` bindings.
@@ -61,29 +85,43 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
     }
   }(_ => "postProcess ==> ")
 
-  private def avoidEmptyCaseOf(term: Term): Opt[Term] = term match {
-    case CaseOf(_, NoCases) => println(s"$term is empty"); N
-    case CaseOf(_, cases: Case) =>
-      @tailrec
-      def containsNoWildcard(cases: CaseBranches): Bool = cases match {
-        case NoCases => true
-        case Wildcard(_) => false
-        case Case(_, body, rest) =>
-          avoidEmptyCaseOf(body) === N && containsNoWildcard(rest)
-      }
-      if (containsNoWildcard(cases)) S(term) else N
+  private def trimEmptyTerm(term: Term): Opt[Term] = term match {
+    case k @ CaseOf(_, cases) => trimEmptyCaseBranches(cases).map(c => k.copy(cases = c))
+    case let @ Let(_, _, _, body) => trimEmptyTerm(body).map(t => let.copy(body = t))
     case _ => S(term)
   }
 
+  private def trimEmptyCaseBranches(cases: CaseBranches): Opt[CaseBranches] = cases match {
+    case NoCases => N
+    case w @ Wildcard(body) => trimEmptyTerm(body).map(t => w.copy(body = t))
+    case k @ Case(_, body, rest) =>
+      (trimEmptyTerm(body), trimEmptyCaseBranches(rest)) match {
+        case (N, N) => N
+        case (S(body), N) => S(k.copy(body = body, rest = NoCases))
+        case (N, S(rest)) => S(rest)
+        case (S(body), S(rest)) => S(k.copy(body = body, rest = rest))
+      }
+  }
+
+  private def mergeTerms(t1: Opt[Term], t2: Opt[Term]): Opt[Term] =
+    (t1, t2) match {
+      case (N, N) => N
+      case (S(t1), N) => S(t1)
+      case (N, S(t2)) => S(t2)
+      case (S(t1), S(t2)) => S(mergeTerms(t1, t2))
+    }
+
   private def mergeTerms(t1: Term, t2: Term): Term =
-    trace(s"mergeTerms <== ${t1.describe} ${t2.describe}") {
+    trace(s"mergeTerms <== ${inspect.shallow(t1)} ${inspect.shallow(t2)}") {
       t1 match {
         case t1 @ Let(_, _, _, body) => t1.copy(body = mergeTerms(body, t2))
         case t1 @ CaseOf(scrutinee: Var, cases) =>
           t1.copy(cases = mergeTermIntoCaseBranches(t2, cases))
-        case _ => println("CANNOT merge. Discard t2."); t1
+        case _ =>
+          println(s"CANNOT merge. Discard ${inspect.shallow(t2)}.")
+          t1
       }
-    }()
+    }(merged => s"mergedTerms ==> ${inspect.shallow(merged)}")
 
   private def mergeTermIntoCaseBranches(term: Term, cases: CaseBranches): CaseBranches =
     trace(s"mergeTermIntoCaseBranches <== ${term.describe} ${cases}") {
@@ -104,58 +142,69 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
     * @param className the class name
     * @return the remaining term and the disentangled term
     */
-  def disentangle(term: Term, scrutinee: ScrutineeSymbol, className: Var): (Term, Opt[Term]) =
-    trace[(Term, Opt[Term])](s"disentangle <== ${scrutinee.name}: $className") {
+  def disentangle(term: Term, scrutinee: ScrutineeSymbol, classSymbol: TypeSymbol): (Term, Opt[Term]) =
+    trace[(Term, Opt[Term])](s"disentangle <== ${scrutinee.name}: ${classSymbol.name}") {
       term match {
         case top @ CaseOf(scrutineeVar: Var, cases) =>
           if (scrutineeVar.symbol match {
             case s: ScrutineeSymbol => s === scrutinee; case _ => false
           }) {
-            println(s"found a `CaseOf` that matches on ${scrutinee.name}")
+            println(s"found a `CaseOf` that matches on `${scrutinee.name}`")
             def rec(cases: CaseBranches): (CaseBranches, Opt[Term]) = cases match {
-              case NoCases => println("found the end, stop"); NoCases -> N
+              case NoCases =>
+                println("no cases, STOP")
+                NoCases -> N
               case wildcard @ Wildcard(body) =>
-                println("found a wildcard, stop")
-                val (y, n) = disentangle(body, scrutinee, className)
-                wildcard.copy(body = y) -> n
-              case kase @ Case(`className`, body, rest) =>
+                println("found a wildcard, go deeper")
+                val (n, y) = disentangle(body, scrutinee, classSymbol)
+                wildcard.copy(body = n) -> y
+              case kase @ Case(className: Var, body, rest) =>
                 println(s"found a case branch matching against $className")
-                val (y, n) = rec(rest)
-                y -> S(n.fold(body)(mergeTerms(_, body)))
+                val otherClassSymbol = getClassSymbolFromVar(className)
+                if (otherClassSymbol === classSymbol) {
+                  rest -> S(body)
+                } else {
+                  val (n1, y1) = disentangle(body, scrutinee, classSymbol)
+                  val (n2, y2) = rec(rest)
+                  (kase.copy(body = n1, rest = n2), mergeTerms(y1, y2))
+                }
               case kase @ Case(otherClassName, body, rest) =>
-                val (y, n) = rec(rest)
-                kase.copy(rest = y) -> n
+                println(s"found another case branch matching against $otherClassName")
+                val (n, y) = rec(rest)
+                kase.copy(rest = n) -> y
             }
-            val (y, n) = rec(cases)
-            top.copy(cases = y) -> n
+            val (n, y) = rec(cases)
+            (top.copy(cases = n), y)
           } else {
             println(s"found a `CaseOf` that does NOT match on ${scrutinee.name}")
             def rec(cases: CaseBranches): (CaseBranches, CaseBranches) = cases match {
               case NoCases =>
-                println("found the end, stop")
+                println("no cases, STOP")
                 NoCases -> NoCases
               case wildcard @ Wildcard(body) =>
                 println("found a wildcard, stop")
-                val (y, n) = disentangle(body, scrutinee, className)
-                wildcard.copy(body = y) -> n.fold(NoCases: CaseBranches)(Wildcard(_))
+                val (n, y) = disentangle(body, scrutinee, classSymbol)
+                (wildcard.copy(body = n), y.fold(NoCases: CaseBranches)(Wildcard(_)))
               case kase @ Case(_, body, rest) =>
                 println(s"found a case branch")
-                val (y1, n1) = disentangle(body, scrutinee, className)
-                val (y2, n2) = rec(rest)
-                kase.copy(body = y1, rest = y2) -> (n1 match {
-                  case S(term) => kase.copy(body = term, rest = n2)
-                  case N => n2
-                })
+                val (n1, y1) = disentangle(body, scrutinee, classSymbol)
+                val (n2, y2) = rec(rest)
+                (kase.copy(body = n1, rest = n2), (y1 match {
+                  case S(term) => kase.copy(body = term, rest = y2)
+                  case N => y2
+                }))
             }
-            val (y, n) = rec(cases)
-            top.copy(cases = y) -> (if (n === NoCases) N else S(top.copy(cases = n)))
+            val (n, y) = rec(cases)
+            (top.copy(cases = y), (if (n === NoCases) N else S(top.copy(cases = n))))
           }
         case let @ Let(_, _, _, body) =>
-          val (y, n) = disentangle(body, scrutinee, className)
-          let.copy(body = y) -> n.map(t => let.copy(body = t))
-        case other => println(s"CANNOT disentangle"); other -> N
+          val (n, y) = disentangle(body, scrutinee, classSymbol)
+          (let.copy(body = n), y.map(t => let.copy(body = t)))
+        case other =>
+          println(s"cannot disentangle ${inspect.shallow(other)}. STOP")
+          other -> N
       }
-    }({ case (y, n) => s"disentangle ==> `${shortName(y)}` and `${n.fold("_")(shortName)}`" })
+    }({ case (n, y) => s"disentangle ==> `${inspect.deep(n)}` and `${y.fold("<empty>")(inspect.deep(_))}`" })
 
   def cascadeConsecutiveCaseOf(term: Term): Term = trace(s"cascade consecutive CaseOf <== ${term.describe}") {
     // Normalized terms are constructed using `Let` and `CaseOf`.
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index 85952793ad..cfa6b4d145 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -45,6 +45,12 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
             }
           case _ => rare
         }
+      case IfOpApp(lhs, Var("and"), rhs) =>
+        splitAnd(lhs).foldRight(transformIfBody(rhs)) {
+          case (OperatorIs(scrutinee, pattern), acc) =>
+            TermBranch.Match(scrutinee, PatternBranch(transformPattern(pattern), acc) |> Split.single) |> Split.single
+          case (test, acc) => TermBranch.Boolean(test, acc) |> Split.single
+        }
       case IfOpApp(lhs, op, rhs) => 
         splitAnd(lhs) match {
           case init :+ last =>
diff --git a/shared/src/main/scala/mlscript/ucs/stages/package.scala b/shared/src/main/scala/mlscript/ucs/stages/package.scala
index 7e23850f54..2260c70dcc 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/package.scala
@@ -1,7 +1,7 @@
 package mlscript.ucs
 
-import mlscript.{Term, Var}
-import mlscript.pretyper.ScrutineeSymbol
+import mlscript.{Lit, Term, Var}
+import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
 
 package object stages {
@@ -23,4 +23,18 @@ package object stages {
   }
   private[stages] final case object Yes extends MatchOrNot
   private[stages] final case object No extends MatchOrNot
+
+  sealed abstract class CasePattern {
+    override def toString(): String = this match {
+      case CasePattern.Class(symbol) => symbol.name
+      case CasePattern.Boolean(value) => value.toString
+      case CasePattern.Literal(value) => value.toString
+    }
+  }
+
+  object CasePattern {
+    final case class Class(symbol: TypeSymbol) extends CasePattern
+    final case class Boolean(value: Boolean) extends CasePattern
+    final case class Literal(value: Lit) extends CasePattern
+  }
 }
diff --git a/shared/src/main/scala/mlscript/utils/inspect.scala b/shared/src/main/scala/mlscript/utils/inspect.scala
index 3e4fa7d912..5a88c1f37d 100644
--- a/shared/src/main/scala/mlscript/utils/inspect.scala
+++ b/shared/src/main/scala/mlscript/utils/inspect.scala
@@ -76,7 +76,7 @@ object inspect {
           case Wildcard(body) => s"Wildcard(${apply(body)})"
           case NoCases        => "NoCases"
         }
-        s"CaseOf(${apply(trm)}, ${inspectCaseBranches(cases)}"
+        s"CaseOf(${apply(trm)}, ${inspectCaseBranches(cases)})"
       case IntLit(value)  => s"IntLit($value)"
       case DecLit(value)  => s"DecLit($value)"
       case StrLit(value)  => s"StrLit($value)"
diff --git a/shared/src/test/diff/mlscript/Repro.mls b/shared/src/test/diff/mlscript/Repro.mls
index 97fb1eace6..bf3a52e7ca 100644
--- a/shared/src/test/diff/mlscript/Repro.mls
+++ b/shared/src/test/diff/mlscript/Repro.mls
@@ -1,17 +1 @@
-:NewDefs
 :PreTyper
-
-class Point(x: Int, y: Int)
-//│ class Point(x: Int, y: Int)
-
-fun length(p) = if p is Point(x, y) then x + y
-//│ fun length: Point -> Int
-
-let xy = Point.unapply(Point(0, 1))
-xy.1
-//│ let xy: [Int, Int]
-//│ Int
-//│ xy
-//│    = [ 0, 1 ]
-//│ res
-//│     = 1
diff --git a/shared/src/test/diff/pretyper/Declarations.mls b/shared/src/test/diff/pretyper/Declarations.mls
index 3ba12d9540..450ef6e36b 100644
--- a/shared/src/test/diff/pretyper/Declarations.mls
+++ b/shared/src/test/diff/pretyper/Declarations.mls
@@ -2,88 +2,20 @@
 :PreTyper
 :NoJS
 
-:dpt
+
 fun test(x, y) = x + y
-//│ process <== <root>: {fun test}
-//│ | traverseTypingUnit <== <root>: {fun test}
-//│ | | 1. scope = {test}
-//│ | | 2. scope = {test}
-//│ | | traverseFunction <== test
-//│ | | | traverseTerm <== Lam(_, _)
-//│ | | | | traverseTerm <== App(_, _)
-//│ | | | | | traverseTerm <== Var("+")
-//│ | | | | | | traverseVar(name = "+")
-//│ | | | | | | | resolveVar(name = "+")
-//│ | | | | | traverseTerm ==> Var("+")
-//│ | | | | | traverseTerm <== Tup(_, _)
-//│ | | | | | | traverseTerm <== Var("x")
-//│ | | | | | | | traverseVar(name = "x")
-//│ | | | | | | | | resolveVar(name = "x")
-//│ | | | | | | traverseTerm ==> Var("x")
-//│ | | | | | | traverseTerm <== Var("y")
-//│ | | | | | | | traverseVar(name = "y")
-//│ | | | | | | | | resolveVar(name = "y")
-//│ | | | | | | traverseTerm ==> Var("y")
-//│ | | | | | traverseTerm ==> Tup(_, _)
-//│ | | | | traverseTerm ==> App(_, _)
-//│ | | | traverseTerm ==> Lam(_, _)
-//│ | | traverseFunction ==> test
-//│ | traverseTypingUnit ==> test
-//│ process ==> test
 //│ fun test: (Int, Int) -> Int
 
-:dpt
+
 // Functions are hoisted.
 let y = id(42)
 fun id(x) = x
-//│ process <== <root>: {let y; fun id}
-//│ | traverseTypingUnit <== <root>: {let y; fun id}
-//│ | | 1. scope = {id}
-//│ | | traverseLetBinding(rec = false, y)
-//│ | | 2. scope = {id}
-//│ | | traverseFunction <== id
-//│ | | | traverseTerm <== Lam(_, _)
-//│ | | | | traverseTerm <== Var("x")
-//│ | | | | | traverseVar(name = "x")
-//│ | | | | | | resolveVar(name = "x")
-//│ | | | | traverseTerm ==> Var("x")
-//│ | | | traverseTerm ==> Lam(_, _)
-//│ | | traverseFunction ==> id
-//│ | traverseTypingUnit ==> id, y
-//│ process ==> id, y
 //│ let y: 42 | 'a
 //│ fun id: forall 'b. ('a & 'b) -> (42 | 'b)
 
-:dpt
+
 // Function bodies can access variables declare after them.
 fun q(x) = x + p
 let p = 0
-//│ process <== <root>: {fun q; let p}
-//│ | traverseTypingUnit <== <root>: {fun q; let p}
-//│ | | 1. scope = {q}
-//│ | | traverseLetBinding(rec = false, p)
-//│ | | 2. scope = {q}
-//│ | | traverseFunction <== q
-//│ | | | traverseTerm <== Lam(_, _)
-//│ | | | | traverseTerm <== App(_, _)
-//│ | | | | | traverseTerm <== Var("+")
-//│ | | | | | | traverseVar(name = "+")
-//│ | | | | | | | resolveVar(name = "+")
-//│ | | | | | traverseTerm ==> Var("+")
-//│ | | | | | traverseTerm <== Tup(_, _)
-//│ | | | | | | traverseTerm <== Var("x")
-//│ | | | | | | | traverseVar(name = "x")
-//│ | | | | | | | | resolveVar(name = "x")
-//│ | | | | | | traverseTerm ==> Var("x")
-//│ | | | | | | traverseTerm <== Var("p")
-//│ | | | | | | | traverseVar(name = "p")
-//│ | | | | | | | | resolveVar(name = "p")
-//│ | | | | | | traverseTerm ==> Var("p")
-//│ | | | | | traverseTerm ==> Tup(_, _)
-//│ | | | | traverseTerm ==> App(_, _)
-//│ | | | traverseTerm ==> Lam(_, _)
-//│ | | traverseFunction ==> q
-//│ | traverseTypingUnit ==> q, p
-//│ process ==> q, p
 //│ fun q: Int -> Int
 //│ let p: 0
diff --git a/shared/src/test/diff/pretyper/Repro.mls b/shared/src/test/diff/pretyper/Repro.mls
new file mode 100644
index 0000000000..bf3a52e7ca
--- /dev/null
+++ b/shared/src/test/diff/pretyper/Repro.mls
@@ -0,0 +1 @@
+:PreTyper
diff --git a/shared/src/test/diff/pretyper/ucs/DualOption.mls b/shared/src/test/diff/pretyper/ucs/DualOption.mls
index 4460835a2d..e6e45799c0 100644
--- a/shared/src/test/diff/pretyper/ucs/DualOption.mls
+++ b/shared/src/test/diff/pretyper/ucs/DualOption.mls
@@ -1,13 +1,13 @@
 :NewDefs
 :PreTyper
 
-class Some[T](value: T)
-module None
-type Option[T] = Some[T] | None
+abstract class Option[T]
+class Some[T](value: T) extends Option[T]
+module None extends Option[nothing]
 class Pair[A, B](x: A, y: B)
-//│ class Some[T](value: T)
-//│ module None
-//│ type Option[T] = None | Some[T]
+//│ abstract class Option[T]
+//│ class Some[T](value: T) extends Option
+//│ module None extends Option
 //│ class Pair[A, B](x: A, y: B)
 
 // All `add_n` functions should be inferred to have the same type.
diff --git a/shared/src/test/diff/pretyper/ucs/Overlaps.mls b/shared/src/test/diff/pretyper/ucs/Overlaps.mls
new file mode 100644
index 0000000000..eb65c35e55
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/Overlaps.mls
@@ -0,0 +1,76 @@
+:PreTyper
+
+class Point(x: Int, y: Int)
+abstract class Shape: (Circle | Rectangle | LineSegment)
+class Circle(center: Point, radius: Int) extends Shape
+class Rectangle(position: Point, width: Int, height: Int) extends Shape
+class LineSegment(start: Point, end: Point) extends Shape
+//│ class Point(x: Int, y: Int)
+//│ abstract class Shape: Circle | LineSegment | Rectangle
+//│ class Circle(center: Point, radius: Int) extends Shape
+//│ class Rectangle(position: Point, width: Int, height: Int) extends Shape
+//│ class LineSegment(start: Point, end: Point) extends Shape
+
+fun hidden(p) = if p is Circle then true else false
+//│ fun hidden: Object -> Bool
+
+fun this_is_sealed(x: Shape) =
+  if x is
+    Circle(_, _) then "Circle"
+    Rectangle(_, _, _) then "Rectangle"
+    LineSegment(_, _) then "LineSegment"
+//│ fun this_is_sealed: (x: Shape) -> ("Circle" | "LineSegment" | "Rectangle")
+
+// TODO
+fun missing_a_case(x: Shape) =
+  if x is
+    Circle(_, _) then "Circle"
+    Rectangle(_, _, _) then "Rectangle"
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.26: 	  if x is
+//│ ║        	     ^^^^
+//│ ║  l.27: 	    Circle(_, _) then "Circle"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.28: 	    Rectangle(_, _, _) then "Rectangle"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── type `LineSegment` is not an instance of type `Rectangle`
+//│ ║  l.25: 	fun missing_a_case(x: Shape) =
+//│ ║        	                      ^^^^^
+//│ ╟── but it flows into reference with expected type `Rectangle`
+//│ ║  l.26: 	  if x is
+//│ ║        	     ^
+//│ ╟── Note: constraint arises from class pattern:
+//│ ║  l.28: 	    Rectangle(_, _, _) then "Rectangle"
+//│ ╙──      	    ^^^^^^^^^
+//│ fun missing_a_case: (x: Shape) -> ("Circle" | "Rectangle")
+
+fun missing_a_case(x: Shape) =
+  if x is
+    Circle(_, _) then "Circle"
+    Rectangle(_, _, _) then "Rectangle"
+    else x
+//│ fun missing_a_case: (x: Shape) -> ("Circle" | "Rectangle" | LineSegment)
+
+// TODO
+fun countLineSegments(x) =
+  if x is
+    Shape and hidden(x) then "bro"
+    Rectangle(_, _, _) then "bro"
+    LineSegment(_, _) then "bro"
+    Circle(_, _) then "bro"
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.56: 	  if x is
+//│ ║        	     ^^^^
+//│ ║  l.57: 	    Shape and hidden(x) then "bro"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.58: 	    Rectangle(_, _, _) then "bro"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.59: 	    LineSegment(_, _) then "bro"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.60: 	    Circle(_, _) then "bro"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── expression of type `Shape & ~#LineSegment & ~#Rectangle` is not an instance of type `Circle`
+//│ ╟── Note: constraint arises from class pattern:
+//│ ║  l.60: 	    Circle(_, _) then "bro"
+//│ ╙──      	    ^^^^^^
+//│ fun countLineSegments: Shape -> "bro"
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls b/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls
index b00504986b..099f9dba0d 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls
@@ -9,37 +9,133 @@ class Pair[A, B](x: A, y: B)
 //│ type Option[T] = None | Some[T]
 //│ class Pair[A, B](x: A, y: B)
 
-fun failed_add_1(x, y) =
+fun good_add_1(x, y) =
   if
     x is Some(xv) and y is Some(yv) then xv + yv
     x is Some(xv) and y is None     then xv
     x is None     and y is Some(yv) then yv
-//│ ╔══[ERROR] missing a case where x is None, and y is None
-//│ ╟── missing the condition
-//│ ║  l.15: 	    x is Some(xv) and y is None     then xv
-//│ ║        	                           ^^^^
-//│ ╟── when x is None
-//│ ║  l.16: 	    x is None     and y is Some(yv) then yv
-//│ ╙──      	         ^^^^
-//│ fun failed_add_1: forall 'a. (None | Some[Int], Some[Int & 'a]) -> (Int | 'a)
+    x is None     and y is None     then 0
+//│ fun good_add_1: forall 'a. (None | Some[Int], None | Some[Int & 'a]) -> (Int | 'a)
 
-fun failed_add_2(x, y) =
+:e
+fun bad_add_missing_SS(x, y) =
   if
     x is Some(xv) and y is None     then xv
     x is None     and y is Some(yv) then yv
-//│ ╔══[ERROR] missing a case where x is Some, and y is Some
-//│ ╟── missing the condition
-//│ ║  l.29: 	    x is None     and y is Some(yv) then yv
-//│ ║        	                           ^^^^
-//│ ╟── when x is Some
-//│ ║  l.28: 	    x is Some(xv) and y is None     then xv
-//│ ╙──      	         ^^^^
-//│ ╔══[ERROR] missing a case where x is None, and y is None
-//│ ╟── missing the condition
-//│ ║  l.28: 	    x is Some(xv) and y is None     then xv
-//│ ║        	                           ^^^^
-//│ ╟── when x is None
-//│ ║  l.29: 	    x is None     and y is Some(yv) then yv
-//│ ╙──      	         ^^^^
-//│ fun failed_add_2: forall 'a. (None | Some['a], nothing) -> 'a
+    x is None     and y is None     then 0
+//│ ╔══[ERROR] When scrutinee `x` is `Some`
+//│ ║  l.23: 	    x is Some(xv) and y is None     then xv
+//│ ║        	         ^^^^
+//│ ╟── Scrutinee `y` has 1 missing case
+//│ ║  l.21: 	fun bad_add_missing_SS(x, y) =
+//│ ║        	                          ^
+//│ ╟── It can be class `Some`
+//│ ║  l.24: 	    x is None     and y is Some(yv) then yv
+//│ ╙──      	                           ^^^^
+//│ fun bad_add_missing_SS: forall 'a. (None | Some['a], None) -> (0 | 'a)
 
+:e
+fun bad_add_missing_SN(x, y) =
+  if
+    x is Some(xv) and y is Some(yv) then xv + yv
+    x is None     and y is Some(yv) then yv
+    x is None     and y is None     then 0
+//│ ╔══[ERROR] When scrutinee `x` is `Some`
+//│ ║  l.40: 	    x is Some(xv) and y is Some(yv) then xv + yv
+//│ ║        	         ^^^^
+//│ ╟── Scrutinee `y` has 1 missing case
+//│ ║  l.38: 	fun bad_add_missing_SN(x, y) =
+//│ ║        	                          ^
+//│ ╟── It can be module `None`
+//│ ║  l.42: 	    x is None     and y is None     then 0
+//│ ╙──      	                           ^^^^
+//│ fun bad_add_missing_SN: forall 'a. (None | Some[Int], Some[Int & 'a]) -> (Int | 'a)
+
+:e
+fun bad_add_missing_NS(x, y) =
+  if
+    x is Some(xv) and y is Some(yv) then xv + yv
+    x is Some(xv) and y is None     then xv
+    x is None     and y is None     then 0
+//│ ╔══[ERROR] When scrutinee `x` is `None`
+//│ ║  l.59: 	    x is None     and y is None     then 0
+//│ ║        	         ^^^^
+//│ ╟── Scrutinee `y` has 1 missing case
+//│ ║  l.55: 	fun bad_add_missing_NS(x, y) =
+//│ ║        	                          ^
+//│ ╟── It can be class `Some`
+//│ ║  l.57: 	    x is Some(xv) and y is Some(yv) then xv + yv
+//│ ╙──      	                           ^^^^
+//│ fun bad_add_missing_NS: (None | Some[Int], None) -> Int
+
+:e
+fun bad_add_missing_NN(x, y) =
+  if
+    x is Some(xv) and y is Some(yv) then xv + yv
+    x is Some(xv) and y is None     then xv
+    x is None     and y is Some(yv) then yv
+//│ ╔══[ERROR] When scrutinee `x` is `None`
+//│ ║  l.76: 	    x is None     and y is Some(yv) then yv
+//│ ║        	         ^^^^
+//│ ╟── Scrutinee `y` has 1 missing case
+//│ ║  l.72: 	fun bad_add_missing_NN(x, y) =
+//│ ║        	                          ^
+//│ ╟── It can be module `None`
+//│ ║  l.75: 	    x is Some(xv) and y is None     then xv
+//│ ╙──      	                           ^^^^
+//│ fun bad_add_missing_NN: forall 'a. (None | Some[Int], Some[Int & 'a]) -> (Int | 'a)
+
+:e
+fun bad_add_missing_SS_NN(x, y) =
+  if
+    x is Some(xv) and y is None     then xv
+    x is None     and y is Some(yv) then yv
+//│ ╔══[ERROR] When scrutinee `x` is `Some`
+//│ ║  l.91: 	    x is Some(xv) and y is None     then xv
+//│ ║        	         ^^^^
+//│ ╟── Scrutinee `y` has 1 missing case
+//│ ║  l.89: 	fun bad_add_missing_SS_NN(x, y) =
+//│ ║        	                             ^
+//│ ╟── It can be class `Some`
+//│ ║  l.92: 	    x is None     and y is Some(yv) then yv
+//│ ╙──      	                           ^^^^
+//│ ╔══[ERROR] When scrutinee `x` is `None`
+//│ ║  l.92: 	    x is None     and y is Some(yv) then yv
+//│ ║        	         ^^^^
+//│ ╟── Scrutinee `y` has 1 missing case
+//│ ║  l.89: 	fun bad_add_missing_SS_NN(x, y) =
+//│ ║        	                             ^
+//│ ╟── It can be module `None`
+//│ ║  l.91: 	    x is Some(xv) and y is None     then xv
+//│ ╙──      	                           ^^^^
+//│ fun bad_add_missing_SS_NN: forall 'a. (None | Some['a], nothing) -> 'a
+
+:e
+fun bad_add_missing_SN_NS(x, y) =
+  if
+    x is Some(xv) and y is Some(yv) then xv + yv
+    x is None     and y is None     then 0
+//│ ╔══[ERROR] When scrutinee `x` is `Some`
+//│ ║  l.116: 	    x is Some(xv) and y is Some(yv) then xv + yv
+//│ ║         	         ^^^^
+//│ ╟── Scrutinee `y` has 1 missing case
+//│ ║  l.114: 	fun bad_add_missing_SN_NS(x, y) =
+//│ ║         	                             ^
+//│ ╟── It can be module `None`
+//│ ║  l.117: 	    x is None     and y is None     then 0
+//│ ╙──       	                           ^^^^
+//│ ╔══[ERROR] When scrutinee `x` is `None`
+//│ ║  l.117: 	    x is None     and y is None     then 0
+//│ ║         	         ^^^^
+//│ ╟── Scrutinee `y` has 1 missing case
+//│ ║  l.114: 	fun bad_add_missing_SN_NS(x, y) =
+//│ ║         	                             ^
+//│ ╟── It can be class `Some`
+//│ ║  l.116: 	    x is Some(xv) and y is Some(yv) then xv + yv
+//│ ╙──       	                           ^^^^
+//│ fun bad_add_missing_SN_NS: (None | Some[Int], nothing) -> Int
+
+fun actually_fine_add(x, y) =
+  if
+    x is Some(xv) and y is None then xv
+//│ fun actually_fine_add: forall 'a. (Some['a], None) -> 'a
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
new file mode 100644
index 0000000000..996388f0f9
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
@@ -0,0 +1,58 @@
+:PreTyper
+
+abstract class Term: Abs | App | Var
+class Var(name: Str) extends Term
+class Abs(param: Str, body: Term) extends Term
+class App(func: Term, arg: Term) extends Term
+//│ abstract class Term: Abs | App | Var
+//│ class Var(name: Str) extends Term
+//│ class Abs(param: Str, body: Term) extends Term
+//│ class App(func: Term, arg: Term) extends Term
+
+// FIXME
+fun is_value(term) =
+  if term is Term and term is
+    Abs(_, _) then true
+    Var(_) then false
+    App(_, _) then false
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.14: 	  if term is Term and term is
+//│ ║        	                      ^^^^^^^
+//│ ║  l.15: 	    Abs(_, _) then true
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.16: 	    Var(_) then false
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.17: 	    App(_, _) then false
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── expression of type `Term & ~#Abs & ~#Var` is not an instance of type `App`
+//│ ╟── Note: constraint arises from class pattern:
+//│ ║  l.17: 	    App(_, _) then false
+//│ ╙──      	    ^^^
+//│ fun is_value: Term -> Bool
+
+:e
+fun is_value(term) =
+  if term is Term and term is
+    Abs(_, _) then true
+    Var(_) then false
+//│ ╔══[ERROR] When scrutinee `term` is `Term`
+//│ ║  l.35: 	  if term is Term and term is
+//│ ║        	             ^^^^
+//│ ╟── Scrutinee `term` has 1 missing case
+//│ ║  l.34: 	fun is_value(term) =
+//│ ║        	             ^^^^
+//│ ╟── It can be class `App`
+//│ ║  l.6: 	class App(func: Term, arg: Term) extends Term
+//│ ╙──     	      ^^^
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.35: 	  if term is Term and term is
+//│ ║        	                      ^^^^^^^
+//│ ║  l.36: 	    Abs(_, _) then true
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.37: 	    Var(_) then false
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── expression of type `Term & ~#Abs` is not an instance of type `Var`
+//│ ╟── Note: constraint arises from class pattern:
+//│ ║  l.37: 	    Var(_) then false
+//│ ╙──      	    ^^^
+//│ fun is_value: Term -> Bool
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls b/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
index ad944a174e..a4a1e89789 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
@@ -41,7 +41,6 @@ reachable_1(None)
 //│ res
 //│     = 'tan'
 
-:dpt
 fun unreachable_1(x) =
   if x is
     _ and
@@ -49,145 +48,4 @@ fun unreachable_1(x) =
       else "screen"
     Some(xv) then "sin"
     None then "tan"
-//│ process <== <root>: {fun unreachable_1}
-//│ | traverseTypingUnit <== <root>: {fun unreachable_1}
-//│ | | 1. scope = {unreachable_1}
-//│ | | 2. scope = {unreachable_1}
-//│ | | traverseFunction <== unreachable_1
-//│ | | | traverseTerm <== Lam(_, _)
-//│ | | | | traverseTerm <== Blk(_)
-//│ | | | | | traverseTerm <== If(_)
-//│ | | | | | | traverseIf
-//│ | | | | | | | STEP 0
-//│ | | | | | | | Transformed UCS term:
-//│ | | | | | | | if x is
-//│ | | | | | | |   _ and f(x,) then "tmux"
-//│ | | | | | | |   else "screen"
-//│ | | | | | | |   Some(xv) then "sin"
-//│ | | | | | | |   None then "tan"
-//│ | | | | | | | STEP 1
-//│ | | | | | | | Desugared UCS term:
-//│ | | | | | | | if
-//│ | | | | | | |   x is _
-//│ | | | | | | |     let scrut$0 = f(x,) : Bool
-//│ | | | | | | |     scrut$0 is true then "tmux"
-//│ | | | | | | |     else "screen"
-//│ | | | | | | |   x is Some(xv) then "sin"
-//│ | | | | | | |   x is None then "tan"
-//│ | | | | | | | traverseSplit <== [unreachable_1, x]
-//│ | | | | | | | | found branch: x is _
-//│ | | | | | | | | traverseTerm <== Var("x")
-//│ | | | | | | | | | traverseVar(name = "x")
-//│ | | | | | | | | | | resolveVar(name = "x")
-//│ | | | | | | | | traverseTerm ==> Var("x")
-//│ | | | | | | | | traversePattern <== _
-//│ | | | | | | | | traversePattern ==> [_]
-//│ | | | | | | | | traverseSplit <== [unreachable_1, x, _]
-//│ | | | | | | | | | found let binding: "scrut$0"
-//│ | | | | | | | | | traverseSplit <== [unreachable_1, x, _, scrut$0]
-//│ | | | | | | | | | | found branch: scrut$0 is true
-//│ | | | | | | | | | | traverseTerm <== Var("scrut$0")
-//│ | | | | | | | | | | | traverseVar(name = "scrut$0")
-//│ | | | | | | | | | | | | resolveVar(name = "scrut$0")
-//│ | | | | | | | | | | traverseTerm ==> Var("scrut$0")
-//│ | | | | | | | | | | traversePattern <== true
-//│ | | | | | | | | | | traversePattern ==> []
-//│ | | | | | | | | | | traverseSplit <== [unreachable_1, x, _, scrut$0]
-//│ | | | | | | | | | | | traverseTerm <== "tmux"
-//│ | | | | | | | | | | | traverseTerm ==> "tmux"
-//│ | | | | | | | | | | traverseSplit <== [unreachable_1, x, _, scrut$0]
-//│ | | | | | | | | | | | traverseTerm <== "screen"
-//│ | | | | | | | | | | | traverseTerm ==> "screen"
-//│ | | | | | | | | traverseSplit <== [unreachable_1, x]
-//│ | | | | | | | | | found branch: x is Some(xv)
-//│ | | | | | | | | | traverseTerm <== Var("x")
-//│ | | | | | | | | | | traverseVar(name = "x")
-//│ | | | | | | | | | traverseTerm ==> Var("x")
-//│ | | | | | | | | | traversePattern <== Some(xv)
-//│ | | | | | | | | | traversePattern ==> [xv]
-//│ | | | | | | | | | traverseSplit <== [unreachable_1, x, xv]
-//│ | | | | | | | | | | traverseTerm <== "sin"
-//│ | | | | | | | | | | traverseTerm ==> "sin"
-//│ | | | | | | | | | traverseSplit <== [unreachable_1, x]
-//│ | | | | | | | | | | found branch: x is None
-//│ | | | | | | | | | | traverseTerm <== Var("x")
-//│ | | | | | | | | | | | traverseVar(name = "x")
-//│ | | | | | | | | | | traverseTerm ==> Var("x")
-//│ | | | | | | | | | | traversePattern <== None
-//│ | | | | | | | | | | traversePattern ==> []
-//│ | | | | | | | | | | traverseSplit <== [unreachable_1, x]
-//│ | | | | | | | | | | | traverseTerm <== "tan"
-//│ | | | | | | | | | | | traverseTerm ==> "tan"
-//│ | | | | | | | | | | traverseSplit <== [unreachable_1, x]
-//│ | | | | | | | | | | | the end
-//│ | | | | | | | STEP 2
-//│ | | | | | | | normalizeToTerm
-//│ | | | | | | | | alias x => _
-//│ | | | | | | | | normalizeToTerm
-//│ | | | | | | | | | normalizeToTerm
-//│ | | | | | | | | | | match scrut$0 with true
-//│ | | | | | | | | | | S+ <== scrut$0 is true
-//│ | | | | | | | | | | | the end
-//│ | | | | | | | | | | S+ ==> then "tmux"
-//│ | | | | | | | | | | normalizeToTerm
-//│ | | | | | | | | | | S- <== scrut$0 is true
-//│ | | | | | | | | | | | the end
-//│ | | | | | | | | | | S- ==> then "screen"
-//│ | | | | | | | | | | normalizeToCaseBranches
-//│ | | | | | | | Normalized UCS term:
-//│ | | | | | | | let _* = x
-//│ | | | | | | | let scrut$0* = f(x,) : Bool
-//│ | | | | | | | scrut$0 match
-//│ | | | | | | |   case true => "tmux"
-//│ | | | | | | |   case _ => "screen"
-//│ | | | | | | | STEP 3
-//│ | | | | | | | postProcess <== Let(_, _)
-//│ | | | | | | | | postProcess <== Let(_, _)
-//│ | | | | | | | | | postProcess <== CaseOf(_, _)
-//│ | | | | | | | | | | found a BINARY case: scrut$0 is true
-//│ | | | | | | | | | | `scrut$0`'s matched classes: [true]
-//│ | | | | | | | | | | post-processing the first branch
-//│ | | | | | | | | | | postProcess <== "tmux"
-//│ | | | | | | | | | | | CANNOT post-process
-//│ | | | | | | | | | | postProcess ==> 
-//│ | | | | | | | | | | found 0 cases
-//│ | | | | | | | | | postProcess ==> 
-//│ | | | | | | | | postProcess ==> 
-//│ | | | | | | | postProcess ==> 
-//│ | | | | | | | Post-processed UCS term:
-//│ | | | | | | | let _* = x
-//│ | | | | | | | let scrut$0* = f(x,) : Bool
-//│ | | | | | | | scrut$0 match
-//│ | | | | | | |   case true => "tmux"
-//│ | | | | | | |   case _ => "screen"
-//│ | | | | | | | STEP 4
-//│ | | | | | | | collected match registry: 
-//│ | | | | | | | >>> scrut$0 => [true]
-//│ | | | | | | | checkCoverage <== Let(_, _), 0 pending, 1 working
-//│ | | | | | | | | assumptions: empty
-//│ | | | | | | | | checkCoverage <== Let(_, _), 0 pending, 1 working
-//│ | | | | | | | | | assumptions: empty
-//│ | | | | | | | | | checkCoverage <== CaseOf(_, _), 0 pending, 1 working
-//│ | | | | | | | | | | assumptions: empty
-//│ | | | | | | | | | | scrutinee: scrut$0
-//│ | | | | | | | | | | checkCoverage <== "tmux", 0 pending, 0 working
-//│ | | | | | | | | | | | assumptions: scrut$0 is true
-//│ | | | | | | | | | | | STOP
-//│ | | | | | | | | | | checkCoverage ==> 0
-//│ | | | | | | | | | | wildcard case
-//│ | | | | | | | | | | checkCoverage <== "screen", 0 pending, 1 working
-//│ | | | | | | | | | | | assumptions: empty
-//│ | | | | | | | | | | | STOP
-//│ | | | | | | | | | | checkCoverage ==> 0
-//│ | | | | | | | | | checkCoverage ==> 0
-//│ | | | | | | | | checkCoverage ==> 0
-//│ | | | | | | | checkCoverage ==> 0
-//│ | | | | | | | Coverage checking result: 0 errors
-//│ | | | | | | traverseIf ==> ()
-//│ | | | | | traverseTerm ==> If(_)
-//│ | | | | traverseTerm ==> Blk(_)
-//│ | | | traverseTerm ==> Lam(_, _)
-//│ | | traverseFunction ==> unreachable_1
-//│ | traverseTypingUnit ==> unreachable_1
-//│ process ==> unreachable_1
 //│ fun unreachable_1: (Object & ~#Some | Some[Eql[1]]) -> ("screen" | "tmux")
diff --git a/shared/src/test/diff/pretyper/ucs/examples/EitherOrBoth.mls b/shared/src/test/diff/pretyper/ucs/examples/EitherOrBoth.mls
new file mode 100644
index 0000000000..fbeeeda76f
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/examples/EitherOrBoth.mls
@@ -0,0 +1,100 @@
+:PreTyper
+
+abstract class Option[out T]: (Some[T] | None)
+class Some[out T](value: T) extends Option[T]
+module None extends Option[nothing]
+//│ abstract class Option[T]: None | Some[T]
+//│ class Some[T](value: T) extends Option
+//│ module None extends Option
+
+abstract class EitherOrBoth[out A, out B]: (Left[A, B] | Right[A, B] | Both[A, B])
+class Left[out A, out B](value: A) extends EitherOrBoth[A, B]
+class Right[out A, out B](value: B) extends EitherOrBoth[A, B]
+class Both[out A, out B](left: A, right: B) extends EitherOrBoth[A, B] 
+//│ abstract class EitherOrBoth[A, B]: Both[A, B] | Left[A, B] | Right[A, B]
+//│ class Left[A, B](value: A) extends EitherOrBoth
+//│ class Right[A, B](value: B) extends EitherOrBoth
+//│ class Both[A, B](left: A, right: B) extends EitherOrBoth
+
+type Either[A, B] = Left[A, B] | Right[A, B]
+//│ type Either[A, B] = Left[A, B] | Right[A, B]
+
+fun getLeft[A, B](eob: EitherOrBoth[A, B]): Option[A] =
+  if eob is
+    Left(left) then Some(left)
+    Right(_) then None
+    Both(left, _) then Some(left)
+//│ fun getLeft: forall 'A. (eob: EitherOrBoth['A, anything]) -> Option['A]
+
+fun getRight[A, B](eob: EitherOrBoth[A, B]): Option[B] =
+  if eob is
+    Left(_) then None
+    Right(right) then Some(right)
+    Both(_, right) then Some(right)
+//│ fun getRight: forall 'B. (eob: EitherOrBoth[anything, 'B]) -> Option['B]
+
+fun getBoth[A, B](eob: EitherOrBoth[A, B]): Option[[A, B]] =
+  if eob is
+    Left(_) then None
+    Right(_) then None
+    Both(left, right) then Some([left, right])
+//│ fun getBoth: forall 'A 'B. (eob: EitherOrBoth['A, 'B]) -> Option[['A, 'B]]
+
+fun mapLeft[A, B, C](eob: EitherOrBoth[A, B], f: A -> C): EitherOrBoth[C, B] =
+  if eob is
+    Left(left) then Left(f(left))
+    Right(right) then Right(right)
+    Both(left, right) then Both(f(left), right)
+//│ fun mapLeft: forall 'A 'B 'C. (eob: EitherOrBoth['A, 'B], f: 'A -> 'C) -> EitherOrBoth['C, 'B]
+
+fun mapRight[A, B, C](eob: EitherOrBoth[A, B], f: B -> C): EitherOrBoth[A, C] =
+  if eob is
+    Left(left) then Left(left)
+    Right(right) then Right(f(right))
+    Both(left, right) then Both(left, f(right))
+//│ fun mapRight: forall 'A 'B 'C. (eob: EitherOrBoth['A, 'B], f: 'B -> 'C) -> EitherOrBoth['A, 'C]
+
+fun map[A, B, C, D](eob: EitherOrBoth[A, B], f: A -> C, g: B -> D): EitherOrBoth[C, D] =
+  if eob is
+    Left(left) then Left(f(left))
+    Right(right) then Right(g(right))
+    Both(left, right) then Both(f(left), g(right))
+//│ fun map: forall 'A 'B 'C 'D. (eob: EitherOrBoth['A, 'B], f: 'A -> 'C, g: 'B -> 'D) -> EitherOrBoth['C, 'D]
+
+fun fold[A, B, C](eob: EitherOrBoth[A, B], f: A -> C, g: B -> C, h: [A, B] -> C): C =
+  if eob is
+    Left(left) then f(left)
+    Right(right) then g(right)
+    Both(left, right) then h(left, right)
+//│ fun fold: forall 'A 'B 'C. (eob: EitherOrBoth['A, 'B], f: 'A -> 'C, g: 'B -> 'C, h: ('A, 'B) -> 'C) -> 'C
+
+fun isLeft[A, B](eob: EitherOrBoth[A, B]): Bool =
+  if eob is
+    Left(_) then true
+    Right(_) then false
+    Both(_, _) then false
+//│ fun isLeft: (eob: EitherOrBoth[anything, anything]) -> Bool
+
+fun isRight[A, B](eob: EitherOrBoth[A, B]): Bool =
+  if eob is
+    Left(_) then false
+    Right(_) then true
+    Both(_, _) then false
+//│ fun isRight: (eob: EitherOrBoth[anything, anything]) -> Bool
+
+fun isBoth[A, B](eob: EitherOrBoth[A, B]): Bool =
+  if eob is
+    Left(_) then false
+    Right(_) then false
+    Both(_, _) then true
+//│ fun isBoth: (eob: EitherOrBoth[anything, anything]) -> Bool
+
+fun (++) strcat(a: Str, b: Str): Str = concat(a)(b)
+//│ fun (++) strcat: (a: Str, b: Str) -> Str
+
+fun eobToString[A, B](eob: EitherOrBoth[A, B]): Str =
+  if eob is
+    Left(left) then "Left(" ++ toString(left) ++ ")"
+    Right(right) then "Right(" ++ toString(right) ++ ")"
+    Both(left, right) then "Both(" ++ toString(left) ++ ", " ++ toString(right) ++ ")"
+//│ fun eobToString: (eob: EitherOrBoth[anything, anything]) -> Str
diff --git a/shared/src/test/diff/pretyper/ucs/examples/Option.mls b/shared/src/test/diff/pretyper/ucs/examples/Option.mls
index 22207938ad..7075685566 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/Option.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/Option.mls
@@ -1,42 +1,27 @@
 :PreTyper
 
-class Some[T](value: T)
-module None
-type Option[T] = Some[T] | None
-//│ class Some[T](value: T)
-//│ module None
-//│ type Option[T] = None | Some[T]
-
-fun getOrElse[T](self: Option[T], default: T): T =
-  if self is
-    Some(value) then value
-    None then default
-//│ fun getOrElse: forall 'T. (self: Option['T], default: 'T) -> 'T
-
-getOrElse(None, 0)
-getOrElse(None, "hello")
-getOrElse(None, true)
-//│ true
-//│ res
-//│     = 0
-//│ res
-//│     = 'hello'
-//│ res
-//│     = true
-
-getOrElse(Some(true), false)
-//│ Bool
-//│ res
-//│     = true
-
-fun map[T, U](self: Option[T], f: (T) -> U): Option[U] =
-  if self is
-    Some(value) then Some(f(value))
-    None then None
-//│ fun map: forall 'T 'U. (self: Option['T], f: 'T -> 'U) -> Option['U]
-
-fun flatMap[T, U](self: Option[T], f: (T) -> Option[U]): Option[U] =
-  if self is
-    Some(value) then f(value)
-    None then None
-//│ fun flatMap: forall 'T 'U. (self: Option['T], f: 'T -> Option['U]) -> Option['U]
+// FIXME: Finish this example after the relevant issue is fixed.
+abstract class Option[out T]: (Some[T] | None) {
+  virtual fun filter: (p: T -> Bool) -> Option[T]
+}
+class Some[out T](val value: T) extends Option[T] {
+  fun filter(p) = if p of value then Some(value) else None
+}
+module None extends Option[nothing] {
+  fun filter(_) = None
+}
+//│ ╔══[ERROR] Type `#Some & {Some#T <: ?T}` does not contain member `Option#T`
+//│ ║  l.4: 	abstract class Option[out T]: (Some[T] | None) {
+//│ ╙──     	                          ^
+//│ ╔══[ERROR] Type `#None` does not contain member `Option#T`
+//│ ║  l.4: 	abstract class Option[out T]: (Some[T] | None) {
+//│ ╙──     	                          ^
+//│ abstract class Option[T]: None | Some[T] {
+//│   fun filter: (p: T -> Bool) -> Option[T]
+//│ }
+//│ class Some[T](value: T) extends Option {
+//│   fun filter: (T -> Bool) -> (None | Some[T])
+//│ }
+//│ module None extends Option {
+//│   fun filter: anything -> None
+//│ }

From 8183b6fa0aa97fe1db4d163b99b3fa42ac9842d9 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Thu, 21 Dec 2023 01:50:50 +0800
Subject: [PATCH 014/147] Update a piece of code that uses the inspect function

---
 compiler/shared/test/scala/mlscript/compiler/Test.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/shared/test/scala/mlscript/compiler/Test.scala b/compiler/shared/test/scala/mlscript/compiler/Test.scala
index e0df0d8f00..2e2349bf64 100644
--- a/compiler/shared/test/scala/mlscript/compiler/Test.scala
+++ b/compiler/shared/test/scala/mlscript/compiler/Test.scala
@@ -3,7 +3,7 @@ package mlscript.compiler
 import mlscript.utils.shorthands.*
 import scala.util.control.NonFatal
 import scala.collection.mutable.StringBuilder
-import mlscript.codegen.Helpers.inspect as showStructure
+import mlscript.utils.inspect.deep as showStructure
 import mlscript.{DiffTests, ModeType, TypingUnit}
 import mlscript.compiler.debug.TreeDebug
 import mlscript.compiler.mono.Monomorph

From 3e95aa1d1d2bd765ac0442c5684725614d6dade4 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Thu, 21 Dec 2023 01:53:23 +0800
Subject: [PATCH 015/147] Fix two inexhaustive pattern matching expressions

---
 .../src/main/scala/mlscript/ucs/stages/CoverageChecking.scala | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index fc157c5c4e..4108b8078e 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -200,13 +200,13 @@ object CoverageChecking {
         val withoutSymbol = cases - classLikePattern
         val relatedPatterns = withoutSymbol.filter {
           case (Pattern.ClassLike(otherSymbol), _) => otherSymbol.baseTypes.contains(classLikeSymbol)
-          case (_: Pattern.Tuple | _: Pattern.Literal) -> _ => false
+          case ((_: Pattern.Tuple | _: Pattern.Literal), _) => false
         } ++ classLikeSymbol.sealedDerivedTypes.iterator.map { symbol =>
           Pattern.ClassLike(symbol) -> symbol.defn.nme.toLoc.toList
         }
         val unrelatedPatterns = withoutSymbol.filter {
           case (Pattern.ClassLike(otherSymbol), _) => !otherSymbol.baseTypes.contains(classLikeSymbol)
-          case (_: Pattern.Tuple | _: Pattern.Literal) -> _ => true
+          case ((_: Pattern.Tuple | _: Pattern.Literal), _) => true
         }
         (locations, copy(relatedPatterns), copy(unrelatedPatterns))
       }

From d32d9d809f6bc1177cfdd336f3ec0ceece241807 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Fri, 22 Dec 2023 01:46:22 +0800
Subject: [PATCH 016/147] Add two more interesting examples and fix unifying
 branch parameters

---
 .../scala/mlscript/pretyper/PreTyper.scala    |   4 +
 .../main/scala/mlscript/pretyper/Symbol.scala |   6 +
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |   5 +-
 .../mlscript/ucs/stages/Desugaring.scala      |   2 +-
 .../mlscript/ucs/stages/Normalization.scala   |  45 +-
 .../mlscript/ucs/stages/PostProcessing.scala  |   5 +
 .../mlscript/ucs/stages/Transformation.scala  |   2 +
 .../ucs/examples/BinarySearchTree.mls         | 613 ++++++++++++++++++
 .../pretyper/ucs/examples/LeftistTree.mls     | 185 ++++++
 9 files changed, 859 insertions(+), 8 deletions(-)
 create mode 100644 shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/examples/LeftistTree.mls

diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index eb3da5087c..d6827ea255 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -15,6 +15,7 @@ class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Trac
 
   private def extractParameters(fields: Term): Ls[ValueSymbol] = fields match {
     case Tup(arguments) =>
+      println(s"arguments: ${inspect.deep(fields)}")
       if (useNewDefs) {
         arguments.map {
           case (S(nme: Var), Fld(_, _)) => new ValueSymbol(nme, false)
@@ -229,6 +230,9 @@ class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Trac
           val scopeWithVar = acc + symbol
           traverseLetBinding(symbol, rec, rhs)(if (rec) { scopeWithVar } else { acc })
           scopeWithVar
+        case (acc, defn @ NuFunDef(Some(rec), nme, _, _, R(ty))) =>
+          val symbol = new ValueSymbol(defn.nme, true)
+          acc + symbol
         case (acc, _: NuFunDef) => acc
         case (acc, _: Constructor | _: DataDefn | _: DatatypeDefn | _: Def | _: LetS | _: TypeDef) => ??? // TODO: When?
       }
diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index 64d046e23e..44d86efb25 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -74,11 +74,17 @@ package object symbol {
     def toLoc: Opt[Loc]
 
     val matchedClasses: MutMap[TypeSymbol, Buffer[Loc]] = MutMap.empty
+    val unappliedVarMap: MutMap[TypeSymbol, Var] = MutMap.empty
+    // Hmm, maybe we can merge these two maps into one.
 
     def addMatchedClass(symbol: TypeSymbol, loc: Opt[Loc]): Unit = {
       matchedClasses.getOrElseUpdate(symbol, Buffer.empty) ++= loc
     }
 
+    def addUnappliedVar(symbol: TypeSymbol, nme: Var): Unit = {
+      unappliedVarMap += symbol -> nme
+    }
+
     /**
       * This map contains the sub-scrutinee symbols when this scrutinee is matched
       * against class patterns.
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 1b192a4804..351e5b3f9e 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -82,8 +82,11 @@ trait DesugarUCS extends Transformation
         case core.Pattern.Name(nme) =>
           nme.symbol = scrutineeSymbol
           nme -> scrutineeSymbol :: Nil
+        // case core.Pattern.Class(nme @ Var("true"), N) =>
+        //   println(s"found true pattern")
+        //   nme -> scrutineeSymbol :: Nil
         case core.Pattern.Class(nme, maybeParameters) =>
-          println(s"name has location: ${nme.toLoc.isDefined}")
+          println(s"`$nme` has location: ${nme.toLoc.isDefined}")
           // Resolve `nme`. It can either be a class, a trait, or a module.
           val symbol = scope.getTypeSymbol(nme.name) match {
             case S(symbol: TraitSymbol) => println(s"${nme.name} is a trait"); symbol
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 7a97e9ed52..16fd8b0113 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -24,7 +24,7 @@ trait Desugaring { self: mlscript.pretyper.Traceable =>
   private def freshScrutinee(parentScrutinee: Var, parentClassName: Var, index: Int): Var =
     Var(s"${parentScrutinee}$$${parentClassName}_${index.toString}")
 
-  private val truePattern = c.Pattern.Class(Var("true"), N)
+  private def truePattern = c.Pattern.Class(Var("true"), N)
 
   private def flattenClassParameters(parentScrutinee: Var, parentClassName: Var, parameters: Opt[Ls[Opt[s.Pattern]]]): Opt[Ls[Opt[Var]]] -> Ls[Opt[Var -> s.Pattern]] =
     parameters match {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 193933e642..36dcbe23c2 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -39,13 +39,25 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
         CaseOf(scrutinee, Case(nme, trueBranch, falseBranch))
       case Split.Cons(Branch(scrutinee, pattern @ Pattern.Class(nme, S(parameters)), continuation), tail) =>
         println(s"match $scrutinee with $pattern")
+        val unappliedVar = Var(s"args_${scrutinee.name}$$${nme.name}")
+        println(s"make unapplied var: $unappliedVar")
+        // Update the scrutinee symbol. The variable will be used in merging
+        // branches of the same pattern later.
+        scrutinee.symbol match {
+          case symbol: ScrutineeSymbol =>
+            nme.symbolOption.flatMap(_.typeSymbolOption) match {
+              case N => throw new NormalizationException(msg"class name is not resolved" -> nme.toLoc :: Nil)
+              case S(typeSymbol) =>
+                println(s"add unapplied var for ${typeSymbol.name}")
+                symbol.addUnappliedVar(typeSymbol, unappliedVar)
+            }
+          case _ =>
+            // FIXME: I guess this should not happen.
+            throw new NormalizationException(msg"Scrutinee is not a scrutinee symbol" -> scrutinee.toLoc :: Nil)
+        }
         val trueBranch = trace("compute true branch"){
           normalizeToTerm(specialize(continuation ++ tail, Yes)(scrutinee.symbol, pattern, scope))
         }()
-        val falseBranch = trace("compute false branch"){
-          normalizeToCaseBranches(specialize(tail, No)(scrutinee.symbol, pattern, scope))
-        }()
-        val unappliedVar = Var(s"args_${scrutinee.name}$$${nme.name}")
         val trueBranchWithBindings = Let(
           isRec = false,
           name = unappliedVar,
@@ -58,6 +70,9 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
             case ((S(parameter), i), next) => Let(false, parameter, Sel(unappliedVar, Var(i.toString)), next)
           }
         )
+        val falseBranch = trace("compute false branch"){
+          normalizeToCaseBranches(specialize(tail, No)(scrutinee.symbol, pattern, scope))
+        }()
         CaseOf(scrutinee, Case(nme, trueBranchWithBindings, falseBranch))
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
         throw new NormalizationException((msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc) :: Nil)
@@ -87,6 +102,10 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
         Split.Let(false, alias, otherScrutineeVar, specialize(continuation, matchOrNot))
       // Class pattern. Positive.
       case (Yes, split @ Split.Cons(head @ Branch(otherScrutineeVar, Pattern.Class(otherClassName, otherParameters), continuation), tail)) =>
+        val otherClassSymbol = otherClassName.symbolOption.flatMap(_.typeSymbolOption) match {
+          case N => throw new NormalizationException(msg"class name is not resolved" -> otherClassName.toLoc :: Nil)
+          case S(typeSymbol) => typeSymbol
+        }
         val otherScrutinee = otherScrutineeVar.symbol
         lazy val specializedTail = {
           println(s"specialized next")
@@ -96,7 +115,7 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
           println(s"scrutinee: ${scrutinee.name} === ${otherScrutinee.name}")
           pattern match {
             case Pattern.Class(className, parameters) =>
-              if (className === otherClassName) {
+              if (className === otherClassName) { // FIXME: Use class symbol.
                 println(s"class name: $className === $otherClassName")
                 (parameters, otherParameters) match {
                   case (S(parameters), S(otherParameters)) =>
@@ -106,7 +125,21 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
                       // Generate a function that generates bindings.
                       // TODO: Hygienic problems.
                       val addLetBindings = parameters.iterator.zip(otherParameters).zipWithIndex.foldLeft[Split => Split](identity) {
-                        case (acc, N -> S(otherParameter) -> index) => ??? // TODO: How can we get the unapplied variable?
+                        case (acc, N -> S(otherParameter) -> index) =>
+                          scrutinee match {
+                            case symbol: ScrutineeSymbol =>
+                              symbol.unappliedVarMap.get(otherClassSymbol) match {
+                                case N =>
+                                  println(symbol.unappliedVarMap)
+                                  die
+                                case S(unappliedVar) =>
+                                  println(s"we can create binding for ${otherParameter.name} at $index")
+                                  tail => Split.Let(false, otherParameter, Sel(unappliedVar, Var(index.toString)), tail)
+                              }
+                            case _ =>
+                              println(s"we can't create binding for ${otherParameter.name} at $index")
+                              die
+                          }
                         case (acc, S(parameter) -> S(otherParameter) -> index) if parameter.name =/= otherParameter.name =>
                           println(s"different parameter names at $index: ${parameter.name} =/= ${otherParameter.name}")
                           tail => Split.Let(false, otherParameter, parameter, tail)
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index ae4cfaa629..0299c610c8 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -34,6 +34,11 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
         println(s"found a UNARY case: $scrutinee is $className")
         println("post-processing the body")
         top.copy(cases = fst.copy(body = postProcess(body)))
+      case top @ CaseOf(scrutinee, fst @ Case(Var("true"), trueBranch, Wildcard(falseBranch))) =>
+        println(s"found a if-then-else case: $scrutinee is true")
+        val processedTrueBranch = postProcess(trueBranch)
+        val processedFalseBranch = postProcess(falseBranch)
+        top.copy(cases = fst.copy(body = processedTrueBranch, rest = Wildcard(processedFalseBranch)))
       case top @ CaseOf(scrutinee: Var, fst @ Case(className: Var, trueBranch, Wildcard(falseBranch))) =>
         println(s"found a BINARY case: $scrutinee is $className")
         val scrutineeSymbol = scrutinee.symbol match {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index cfa6b4d145..b3acf72b66 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -31,6 +31,7 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
         splitAnd(expr).foldRight(Split.then(rhs)) {
           case (OperatorIs(scrutinee, pattern), acc) =>
             TermBranch.Match(scrutinee, PatternBranch(transformPattern(pattern), acc) |> Split.single) |> Split.single
+          case (Var("_"), acc) => acc
           case (test, acc) => TermBranch.Boolean(test, acc) |> Split.single
         }
       case IfLet(isRec, name, rhs, body) => rare
@@ -49,6 +50,7 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
         splitAnd(lhs).foldRight(transformIfBody(rhs)) {
           case (OperatorIs(scrutinee, pattern), acc) =>
             TermBranch.Match(scrutinee, PatternBranch(transformPattern(pattern), acc) |> Split.single) |> Split.single
+          case (Var("_"), acc) => acc
           case (test, acc) => TermBranch.Boolean(test, acc) |> Split.single
         }
       case IfOpApp(lhs, op, rhs) => 
diff --git a/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls b/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls
new file mode 100644
index 0000000000..7c58261c5f
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls
@@ -0,0 +1,613 @@
+:PreTyper
+
+fun (|>) pipe(x, f) = f(x)
+fun (~~>) toBe(x, y) = if x === y then () else error
+fun (<?) min(x, y) = if x < y then x else y
+fun (>?) max(x, y) = if x > y then x else y
+fun abs(x) = if x < 0 then -x else x
+//│ fun (|>) pipe: forall 'a 'b. ('a, 'a -> 'b) -> 'b
+//│ fun (~~>) toBe: forall 'c. (Eql['c], 'c) -> ()
+//│ fun (<?) min: forall 'd. (Num & 'd, Num & 'd) -> 'd
+//│ fun (>?) max: forall 'e. (Num & 'e, Num & 'e) -> 'e
+//│ fun abs: Int -> Int
+
+
+abstract class Option[out T]: (Some[T] | None)
+class Some[out T](val value: T) extends Option[T]
+module None extends Option[nothing]
+//│ abstract class Option[T]: None | Some[T]
+//│ class Some[T](value: T) extends Option
+//│ module None extends Option
+
+fun (??) getOrElse(o, v) = if o is
+  Some(v') then v'
+  None then v
+//│ fun (??) getOrElse: forall 'a. (None | Some['a], 'a) -> 'a
+
+fun (++) strcat(s1, s2) = concat(s1)(s2)
+//│ fun (++) strcat: (Str, Str) -> Str
+
+let anyToString = toString
+//│ let anyToString: anything -> Str
+//│ anyToString
+//│             = [Function: toString]
+
+abstract class List[out T]: (Cons[T] | Nil)
+class Cons[out T](val head: T, val tail: List[T]) extends List[T]
+module Nil extends List[nothing]
+//│ abstract class List[T]: Cons[T] | Nil
+//│ class Cons[T](head: T, tail: List[T]) extends List
+//│ module Nil extends List
+
+fun (::) cons(head, tail) = Cons(head, tail)
+//│ fun (::) cons: forall 'T. ('T, List['T]) -> Cons['T]
+
+1 :: 2 :: 3 :: 4 :: Nil
+//│ Cons[1 | 2 | 3 | 4]
+//│ res
+//│     = Cons {}
+
+abstract class Tree[out A]: (Empty | Node[A])
+class Node[A](value: A, left: Tree[A], right: Tree[A]) extends Tree[A]
+module Empty extends Tree[nothing]
+//│ abstract class Tree[A]: Empty | Node[A]
+//│ class Node[A](value: A, left: Tree[A], right: Tree[A]) extends Tree
+//│ module Empty extends Tree
+
+fun single(v) = Node(v, Empty, Empty)
+//│ fun single: forall 'A. 'A -> Node['A]
+
+fun show(t: Tree[anything]): Str = if t is
+  Node(v, l, r) then
+    "(" ++ show(l) ++ " " ++ toString(v) ++ " " ++ show(r) ++ ")"
+  Empty then "•"
+//│ fun show: (t: Tree[anything]) -> Str
+
+show(Empty)
+show(Node(0, Empty, Empty))
+show(Node(1, Node(0, Empty, Empty), Empty))
+show(Node(1, Node(0, Empty, Empty), Node(2, Empty, Empty)))
+//│ Str
+//│ res
+//│     = '•'
+//│ res
+//│     = '(• 0 •)'
+//│ res
+//│     = '((• 0 •) 1 •)'
+//│ res
+//│     = '((• 0 •) 1 (• 2 •))'
+
+fun insert(t, v) = if t is
+  Node(v', l, r) and
+    v < v' then Node(v', insert(l, v), r)
+    v > v' then Node(v', l, insert(r, v))
+    _ then t
+  Empty then Node(v, Empty, Empty)
+//│ fun insert: forall 'A 'A0. (Empty | Node[Num & 'A], Num & 'A & 'A0) -> Node['A | 'A0]
+
+// FIXME
+fun insert'(t, v) = if t is
+  Node(v', l, r) and v
+    < v' then Node(v', insert(l, v), r)
+    > v' then Node(v', l, insert(r, v))
+    else t
+  Empty then Node(v, Empty, Empty)
+//│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing
+
+insert(Empty, 0) |> show
+insert(Node(0, Empty, Empty), 0) |> show
+insert(Node(1, Empty, Empty), 0) |> show
+insert(Node(1, Node(0, Empty, Empty), Empty), 0) |> show
+insert(Node(1, Node(0, Empty, Empty), Empty), 2) |> show
+//│ Str
+//│ res
+//│     = '(• 0 •)'
+//│ res
+//│     = '(• 0 •)'
+//│ res
+//│     = '((• 0 •) 1 •)'
+//│ res
+//│     = '((• 0 •) 1 •)'
+//│ res
+//│     = '((• 0 •) 1 (• 2 •))'
+
+// FIXME
+fun fromList(l) =
+  fun fromList'(t, xs) =
+    if xs is
+      Cons(x, xs') then fromList'(insert(t, x), xs')
+      Nil then Empty
+  fromList'(Empty, l)
+//│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing
+
+fun fromList(t, xs) =
+  if xs is
+    Cons(x, xs') then fromList(insert(t, x), xs')
+    Nil then t
+//│ fun fromList: forall 'a 'A 'A0. ('a & (Empty | Node['A]), Cons[Num & 'A & 'A0] | Nil) -> (Node['A | 'A0] | 'a)
+//│   where
+//│     'A <: Num
+
+fromList(Empty, 1 :: 2 :: 3 :: 4 :: Nil) |> show
+fromList(Empty, 2 :: 1 :: 4 :: 3 :: Nil) |> show
+fromList(Empty, 4 :: 3 :: 2 :: 1 :: Nil) |> show
+let example1 = fromList(Empty, 1 :: 3 :: 2 :: 4 :: Nil)
+example1 |> show
+//│ let example1: Empty | Node[1 | 2 | 3 | 4]
+//│ Str
+//│ res
+//│     = '(• 1 (• 2 (• 3 (• 4 •))))'
+//│ res
+//│     = '((• 1 •) 2 ((• 3 •) 4 •))'
+//│ res
+//│     = '((((• 1 •) 2 •) 3 •) 4 •)'
+//│ example1
+//│          = Node {}
+//│ res
+//│     = '(• 1 ((• 2 •) 3 (• 4 •)))'
+
+fun contains(t, v) = if t is
+  Node(v', l, r) and
+    v < v' then contains(l, v)
+    v > v' then contains(r, v)
+    _ then true
+  Empty then false
+//│ fun contains: (Empty | Node[Num], Num) -> Bool
+
+// Writing tests like this is very interesting.
+contains(Empty, 0) ~~> false
+contains(Node(0, Empty, Empty), 0) ~~> true
+contains(Node(1, Empty, Empty), 0) ~~> false
+//│ ()
+//│ res
+//│     = undefined
+//│ res
+//│     = undefined
+//│ res
+//│     = undefined
+
+fun minValue(t) = if t is
+  Empty then None
+  Node(v, Empty, _) then Some(v)
+  Node(_, l, _) then minValue(l)
+//│ fun minValue: forall 'T. (Empty | Node['T]) -> (None | Some['T])
+
+minValue(Empty) ?? "not found"
+minValue(Node(0, Empty, Empty)) ?? "not found"
+minValue(example1) ?? "not found"
+//│ "not found" | 1 | 2 | 3 | 4
+//│ res
+//│     = 'not found'
+//│ res
+//│     = 0
+//│ res
+//│     = 1
+
+fun maxValue(t) = if t is
+  Empty then None
+  Node(v, _, Empty) then Some(v)
+  Node(_, _, r) then maxValue(r)
+//│ fun maxValue: forall 'T. (Empty | Node['T]) -> (None | Some['T])
+
+maxValue(Empty) ?? "not found"
+maxValue(Node(0, Empty, Empty)) ?? "not found"
+maxValue(example1) ?? "not found"
+//│ "not found" | 1 | 2 | 3 | 4
+//│ res
+//│     = 'not found'
+//│ res
+//│     = 0
+//│ res
+//│     = 4
+
+fun lowerBound(t, v) = if t is
+  Node(v', l, r) and
+    v < v' then lowerBound(l, v)
+    v > v' then Some(lowerBound(r, v) ?? v')
+    _ then Some(v')
+  Empty then None
+//│ fun lowerBound: forall 'a 'T. (Empty | Node[Num & 'a & 'T], Num) -> (None | Some['T | 'a])
+
+lowerBound(Empty, 0) ?? "not found"
+lowerBound(Node(0, Empty, Empty), 0) ?? "not found"
+lowerBound(Node(1, Empty, Empty), 0) ?? "not found"
+lowerBound(Node(-1, Empty, Empty), 0) ?? "not found"
+//│ "not found" | -1
+//│ res
+//│     = 'not found'
+//│ res
+//│     = 0
+//│ res
+//│     = 'not found'
+//│ res
+//│     = -1
+
+lowerBound(example1, 0) ?? "not found"
+lowerBound(example1, 1) ?? "not found"
+lowerBound(example1, 2) ?? "not found"
+lowerBound(example1, 3) ?? "not found"
+lowerBound(example1, 4) ?? "not found"
+lowerBound(example1, 5) ?? "not found"
+//│ "not found" | 1 | 2 | 3 | 4
+//│ res
+//│     = 'not found'
+//│ res
+//│     = 1
+//│ res
+//│     = 2
+//│ res
+//│     = 3
+//│ res
+//│     = 4
+//│ res
+//│     = 4
+
+let example2 = fromList(Empty, 1 :: 5 :: 42 :: 10 :: 23 :: 59 :: 81 :: Nil)
+lowerBound(example2, 0) ?? "not found"
+lowerBound(example2, 25) ?? "not found"
+lowerBound(example2, 99) ?? "not found"
+lowerBound(example2, 7) ?? "not found"
+lowerBound(example2, 32) ?? "not found"
+lowerBound(example2, 41) ?? "not found"
+//│ let example2: Empty | Node[10 | 1 | 23 | 42 | 59 | 5 | 81]
+//│ "not found" | 10 | 1 | 23 | 42 | 59 | 5 | 81
+//│ example2
+//│          = Node {}
+//│ res
+//│     = 'not found'
+//│ res
+//│     = 23
+//│ res
+//│     = 81
+//│ res
+//│     = 5
+//│ res
+//│     = 23
+//│ res
+//│     = 23
+
+fun upperBound(t, v) = if t is
+  Node(v', l, r) and
+    v < v' then Some(upperBound(l, v) ?? v')
+    v > v' then upperBound(r, v)
+    _ then Some(v')
+  Empty then None
+//│ fun upperBound: forall 'a 'T. (Empty | Node[Num & 'a & 'T], Num) -> (None | Some['T | 'a])
+
+upperBound(example2, 0) ?? "not found"
+upperBound(example2, 25) ?? "not found"
+upperBound(example2, 99) ?? "not found"
+upperBound(example2, 7) ?? "not found"
+upperBound(example2, 32) ?? "not found"
+upperBound(example2, 41) ?? "not found"
+//│ "not found" | 10 | 1 | 23 | 42 | 59 | 5 | 81
+//│ res
+//│     = 1
+//│ res
+//│     = 42
+//│ res
+//│     = 'not found'
+//│ res
+//│     = 10
+//│ res
+//│     = 42
+//│ res
+//│     = 42
+
+fun remove(t, v) =
+  if t is
+    Node(v', l, r) and
+      v < v' then Node(v', remove(l, v), r)
+      v > v' then Node(v', l, remove(r, v))
+      minValue(r) is
+        None then l
+        Some(v'') then Node(v'', l, remove(r, v''))
+    Empty then Empty
+//│ fun remove: forall 'A. (Empty | Node['A], Num) -> (Empty | Node['A] | Tree['A])
+//│   where
+//│     'A <: Num
+
+remove(Empty, 0) |> show
+remove(Node(0, Empty, Empty), 0) |> show
+remove(Node(1, Empty, Empty), 0) |> show
+remove(Node(1, Node(0, Empty, Empty), Empty), 0) |> show
+remove(Node(1, Empty, Node(2, Empty, Empty)), 2) |> show
+remove(Node(1, Node(0, Empty, Empty), Node(2, Empty, Empty)), 1) |> show
+//│ Str
+//│ res
+//│     = '•'
+//│ res
+//│     = '•'
+//│ res
+//│     = '(• 1 •)'
+//│ res
+//│     = '(• 1 •)'
+//│ res
+//│     = '(• 1 •)'
+//│ res
+//│     = '((• 0 •) 2 •)'
+
+example1 |> show
+remove(example1, 0) |> show
+remove(example1, 1) |> show
+remove(example1, 2) |> show
+remove(example1, 3) |> show
+remove(example1, 4) |> show
+//│ Str
+//│ res
+//│     = '(• 1 ((• 2 •) 3 (• 4 •)))'
+//│ res
+//│     = '(• 1 ((• 2 •) 3 (• 4 •)))'
+//│ res
+//│     = '(• 2 (• 3 (• 4 •)))'
+//│ res
+//│     = '(• 1 (• 3 (• 4 •)))'
+//│ res
+//│     = '(• 1 ((• 2 •) 4 •))'
+//│ res
+//│     = '(• 1 ((• 2 •) 3 •))'
+
+class Pair[A, B](val first: A, val second: B) {
+  fun mapFirst(f) = Pair(f(first), second)
+  fun mapSecond(f) = Pair(first, f(second))
+}
+//│ class Pair[A, B](first: A, second: B) {
+//│   fun mapFirst: forall 'A. (A -> 'A) -> Pair['A, B]
+//│   fun mapSecond: forall 'B. (B -> 'B) -> Pair[A, 'B]
+//│ }
+
+fun extractMin(t) =
+  if t is
+    Node(v, Empty, r) then Pair(Some(v), r)
+    Node(v, l, r) and
+      extractMin(l) is Pair(m, l') then
+        Pair(m, Node(v, l', r))
+    Empty then Pair(None, Empty)
+//│ fun extractMin: forall 'A. (Empty | Node['A]) -> Pair[None | Some['A], Empty | Node['A] | Tree['A]]
+
+extractMin(example1).first ?? "not found"
+extractMin(example1).second |> show
+//│ Str
+//│ res
+//│     = 1
+//│ res
+//│     = '((• 2 •) 3 (• 4 •))'
+
+fun merge(l, r) =
+  if extractMin(r) is
+    Pair(None, _) then l
+    Pair(Some(m), r') then Node(m, l, r')
+//│ fun merge: forall 'A 'a. (Tree['A] & 'a, Empty | Node['A]) -> (Node['A] | 'a)
+
+merge(Empty, Empty) |> show
+merge(Empty, Node(0, Empty, Empty)) |> show
+merge(Node(0, Empty, Empty), Empty) |> show
+merge(Node(0, Empty, Empty), Node(1, Empty, Empty)) |> show
+merge(Node(0, Empty, Empty), Node(2, Node(1, Empty, Empty), Empty)) |> show
+//│ Str
+//│ res
+//│     = '•'
+//│ res
+//│     = '(• 0 •)'
+//│ res
+//│     = '(• 0 •)'
+//│ res
+//│     = '((• 0 •) 1 •)'
+//│ res
+//│     = '((• 0 •) 1 (• 2 •))'
+
+fun removeGte(t, v) =
+  if t is
+    Node(v', l, r) and
+      v < v' then removeGte(l, v)
+      v > v' then Node(v', l, removeGte(r, v))
+      _ then l // lucky case
+    Empty then Empty
+//│ fun removeGte: forall 'A. (Empty | Node['A], Num) -> (Empty | Node['A] | Tree['A])
+//│   where
+//│     'A <: Num
+
+removeGte(Empty, 0) |> show
+removeGte(example1, 0) |> show
+removeGte(example1, 1) |> show
+removeGte(example1, 2) |> show
+removeGte(example1, 3) |> show
+removeGte(example1, 4) |> show
+removeGte(example1, 5) |> show
+//│ Str
+//│ res
+//│     = '•'
+//│ res
+//│     = '•'
+//│ res
+//│     = '•'
+//│ res
+//│     = '(• 1 •)'
+//│ res
+//│     = '(• 1 (• 2 •))'
+//│ res
+//│     = '(• 1 ((• 2 •) 3 •))'
+//│ res
+//│     = '(• 1 ((• 2 •) 3 (• 4 •)))'
+
+example2 |> show
+removeGte(example2, 10) |> show
+removeGte(example2, 22) |> show
+removeGte(example2, 23) |> show
+removeGte(example2, 24) |> show
+removeGte(example2, 70) |> show
+removeGte(example2, 99) |> show
+//│ Str
+//│ res
+//│     = '(• 1 (• 5 ((• 10 (• 23 •)) 42 (• 59 (• 81 •)))))'
+//│ res
+//│     = '(• 1 (• 5 •))'
+//│ res
+//│     = '(• 1 (• 5 (• 10 •)))'
+//│ res
+//│     = '(• 1 (• 5 (• 10 •)))'
+//│ res
+//│     = '(• 1 (• 5 (• 10 (• 23 •))))'
+//│ res
+//│     = '(• 1 (• 5 ((• 10 (• 23 •)) 42 (• 59 •))))'
+//│ res
+//│     = '(• 1 (• 5 ((• 10 (• 23 •)) 42 (• 59 (• 81 •)))))'
+
+fun removeLt(t, v) =
+  if t is
+    Node(v', l, r) and
+      v' < v then removeLt(r, v)
+      else Node(v', removeLt(l, v), r)
+    Empty then Empty
+//│ fun removeLt: forall 'A. (Empty | Node[Num & 'A], Num) -> (Empty | Node['A])
+
+example2 |> show
+removeLt(example2, 10) |> show
+removeLt(example2, 22) |> show
+removeLt(example2, 23) |> show
+removeLt(example2, 24) |> show
+removeLt(example2, 70) |> show
+removeLt(example2, 99) |> show
+//│ Str
+//│ res
+//│     = '(• 1 (• 5 ((• 10 (• 23 •)) 42 (• 59 (• 81 •)))))'
+//│ res
+//│     = '((• 10 (• 23 •)) 42 (• 59 (• 81 •)))'
+//│ res
+//│     = '((• 23 •) 42 (• 59 (• 81 •)))'
+//│ res
+//│     = '((• 23 •) 42 (• 59 (• 81 •)))'
+//│ res
+//│     = '(• 42 (• 59 (• 81 •)))'
+//│ res
+//│     = '(• 81 •)'
+//│ res
+//│     = '•'
+
+// Remove elements from `begin` until `end`.
+fun removeRange(t, begin, end) =
+  if t is
+    Node(v, l, r) and
+      begin > v then Node(v, l, removeRange(r, begin, end))
+      end <= v then Node(v, removeRange(l, begin, end), r)
+      _ then merge(removeGte(l, begin), removeLt(r, end))
+    Empty then Empty
+//│ fun removeRange: forall 'A. (Empty | Node[Num & 'A], Num, Num) -> (Empty | Node['A] | Tree['A])
+//│   where
+//│     'A <: Num
+
+example2 |> show
+removeRange(example2, 1, 82) |> show
+removeRange(example2, 1, 50) |> show
+removeRange(example2, 50, 81) |> show
+removeRange(example2, 20, 60) |> show
+removeRange(example2, 20, 24) |> show
+removeRange(example2, 59, 60) |> show
+//│ Str
+//│ res
+//│     = '(• 1 (• 5 ((• 10 (• 23 •)) 42 (• 59 (• 81 •)))))'
+//│ res
+//│     = '•'
+//│ res
+//│     = '(• 59 (• 81 •))'
+//│ res
+//│     = '(• 1 (• 5 ((• 10 (• 23 •)) 42 (• 81 •))))'
+//│ res
+//│     = '(• 1 (• 5 ((• 10 •) 81 •)))'
+//│ res
+//│     = '(• 1 (• 5 ((• 10 •) 42 (• 59 (• 81 •)))))'
+//│ res
+//│     = '(• 1 (• 5 ((• 10 (• 23 •)) 42 (• 81 •))))'
+
+fun size(t) =
+  if t is
+    Node(_, l, r) then 1 + size(l) + size(r)
+    Empty then 0
+//│ fun size: (Empty | Node[anything]) -> Int
+
+size(Empty) ~~> 0
+size(Node(0, Empty, Empty)) ~~> 1
+size(example1) ~~> 4
+size(example2) ~~> 7
+//│ ()
+//│ res
+//│     = undefined
+//│ res
+//│     = undefined
+//│ res
+//│     = undefined
+//│ res
+//│     = undefined
+
+fun inverse(t) =
+  if t is
+    Node(v, l, r) then Node(v, inverse(r), inverse(l))
+    Empty then Empty
+//│ fun inverse: forall 'A. (Empty | Node['A]) -> (Empty | Node['A])
+
+inverse(Empty) |> show
+inverse(Node(0, Empty, Empty)) |> show
+inverse(example1) |> show
+inverse(example2) |> show
+//│ Str
+//│ res
+//│     = '•'
+//│ res
+//│     = '(• 0 •)'
+//│ res
+//│     = '(((• 4 •) 3 (• 2 •)) 1 •)'
+//│ res
+//│     = '(((((• 81 •) 59 •) 42 ((• 23 •) 10 •)) 5 •) 1 •)'
+
+fun height(t) =
+  if t is
+    Node(_, l, r) then 1 + max(height(l), height(r))
+    Empty then 0
+//│ fun height: (Empty | Node[anything]) -> Int
+
+height(Empty) ~~> 0
+height(Node(0, Empty, Empty)) ~~> 1
+height(example1) ~~> 3
+height(example2) ~~> 5
+//│ ()
+//│ res
+//│     = undefined
+//│ res
+//│     = undefined
+//│ res
+//│     = undefined
+//│ res
+//│     = undefined
+
+fun isBalanced(t) =
+  if t is
+    Empty then true
+    Node(_, l, r) and height(l) is hl and height(r) is hr then
+      // The precedence of `<=` seems to be broken.
+      (abs(hl - hr) <= 1) && isBalanced(l) && isBalanced(r)
+//│ fun isBalanced: (Empty | Node[anything]) -> Bool
+
+isBalanced(Empty) ~~> true
+isBalanced(Node(0, Empty, Empty)) ~~> true
+isBalanced(example1) ~~> false
+isBalanced(example2) ~~> false
+//│ ()
+//│ res
+//│     = undefined
+//│ res
+//│     = undefined
+//│ res
+//│     = undefined
+//│ res
+//│     = undefined
+
+isBalanced(Node(1, single(-1), single(3))) ~~> true
+isBalanced(Node(1, single(-1), Node(3, single(2), Empty))) ~~> true
+isBalanced(Node(1, single(-1), Node(3, Empty, single(4)))) ~~> true
+//│ ()
+//│ res
+//│     = undefined
+//│ res
+//│     = undefined
+//│ res
+//│     = undefined
diff --git a/shared/src/test/diff/pretyper/ucs/examples/LeftistTree.mls b/shared/src/test/diff/pretyper/ucs/examples/LeftistTree.mls
new file mode 100644
index 0000000000..76b7c420b0
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/examples/LeftistTree.mls
@@ -0,0 +1,185 @@
+:PreTyper
+
+fun (|>) pipe(x, f) = f(x)
+fun (~~>) toBe(x, y) = if x === y then () else error
+fun (<?) min(x, y) = if x < y then x else y
+fun (>?) max(x, y) = if x > y then x else y
+fun abs(x) = if x < 0 then -x else x
+//│ fun (|>) pipe: forall 'a 'b. ('a, 'a -> 'b) -> 'b
+//│ fun (~~>) toBe: forall 'c. (Eql['c], 'c) -> ()
+//│ fun (<?) min: forall 'd. (Num & 'd, Num & 'd) -> 'd
+//│ fun (>?) max: forall 'e. (Num & 'e, Num & 'e) -> 'e
+//│ fun abs: Int -> Int
+
+
+abstract class Option[out T]: (Some[T] | None)
+class Some[out T](val value: T) extends Option[T]
+module None extends Option[nothing]
+//│ abstract class Option[T]: None | Some[T]
+//│ class Some[T](value: T) extends Option
+//│ module None extends Option
+
+fun (??) getOrElse(o, v) = if o is
+  Some(v') then v'
+  None then v
+//│ fun (??) getOrElse: forall 'a. (None | Some['a], 'a) -> 'a
+
+fun (++) strcat(s1, s2) = concat(s1)(s2)
+//│ fun (++) strcat: (Str, Str) -> Str
+
+let anyToString = toString
+//│ let anyToString: anything -> Str
+//│ anyToString
+//│             = [Function: toString]
+
+abstract class List[out T]: (Cons[T] | Nil)
+class Cons[out T](val head: T, val tail: List[T]) extends List[T]
+module Nil extends List[nothing]
+//│ abstract class List[T]: Cons[T] | Nil
+//│ class Cons[T](head: T, tail: List[T]) extends List
+//│ module Nil extends List
+
+fun (::) cons(head, tail) = Cons(head, tail)
+//│ fun (::) cons: forall 'T. ('T, List['T]) -> Cons['T]
+
+abstract class Tree[out A]: (Empty | Node[A])
+class Node[A](value: A, left: Tree[A], right: Tree[A], rank: Int) extends Tree[A]
+module Empty extends Tree[nothing]
+//│ abstract class Tree[A]: Empty | Node[A]
+//│ class Node[A](value: A, left: Tree[A], right: Tree[A], rank: Int) extends Tree
+//│ module Empty extends Tree
+
+fun show(t: Tree[anything]): Str = if t is
+  Node(v, l, r, _) then
+    "(" ++ show(l) ++ " " ++ toString(v) ++ " " ++ show(r) ++ ")"
+  Empty then "•"
+//│ fun show: (t: Tree[anything]) -> Str
+
+fun singleton(x) = Node(x, Empty, Empty, 1)
+fun rank(t) = if t is
+  Empty then 0
+  Node(_, _, _, r) then r
+//│ fun singleton: forall 'A. 'A -> Node['A]
+//│ fun rank: (Empty | Node[anything]) -> Int
+
+// This can be improved. This can be better.
+fun merge(t1: Tree[Num], t2: Tree[Num]): Tree[Num] =
+  if
+    t1 is Node(v1, l1, r1, _) and t2 is Node(v2, _, _, _) and
+      v1 > v2 then merge(t2, t1)
+      _ and merge(r1, t2) is merged and
+        rank(l1) is rank_left and rank(r1) is rank_right and
+          rank_left >= rank_right then Node(v1, l1, merged, rank_right + 1)
+          else Node(v1, merged, l1, rank_left + 1)
+    t1 is Empty and t2 is Node then t2
+    t1 is Node and t2 is Empty then t1
+    t1 is Empty and t2 is Empty then Empty
+//│ fun merge: (t1: Tree[Num], t2: Tree[Num]) -> Tree[Num]
+
+fun insert(t, v) = merge(t, singleton(v))
+//│ fun insert: (Tree[Num], Num) -> Tree[Num]
+
+fun getMin(t) =
+  if t is
+    Empty then None
+    Node(x, _, _, _) then Some(x)
+//│ fun getMin: forall 'T. (Empty | Node['T]) -> (None | Some['T])
+
+fun deleteMin(t) =
+  if t is
+    Empty then Empty
+    Node(_, l, r, _) then merge(l, r)
+//│ fun deleteMin: (Empty | Node[Num]) -> (Empty | Tree[Num])
+
+fun fromList(t, xs) =
+  if xs is
+    Cons(x, xs') then fromList(insert(t, x), xs')
+    Nil then t
+//│ fun fromList: (Tree[Num], Cons[Num] | Nil) -> Tree[Num]
+
+let tree1 = fromList(Empty, 3 :: 4 :: 1 :: 2 :: Nil)
+tree1 |> show
+//│ let tree1: Empty | Tree[Num]
+//│ Str
+//│ tree1
+//│       = Node {}
+//│ res
+//│     = '((• 2 (• 3 (• 4 •))) 1 •)'
+
+// Remove the smallest element. It should be 1.
+getMin(tree1) ?? "nothing"
+let tree1' = deleteMin(tree1)
+tree1' |> show
+//│ let tree1': Empty | Tree[Num]
+//│ Str
+//│ res
+//│     = 1
+//│ tree1'
+//│        = Node {}
+//│ res
+//│     = '(• 2 (• 3 (• 4 •)))'
+
+// Remove one more element. It should be 2.
+getMin(tree1') ?? "nothing"
+let tree1'' = deleteMin(tree1')
+tree1'' |> show
+//│ let tree1'': Empty | Tree[Num]
+//│ Str
+//│ res
+//│     = 2
+//│ tree1''
+//│         = Node {}
+//│ res
+//│     = '(• 3 (• 4 •))'
+
+// Remove one more element. It should be 3.
+getMin(tree1'') ?? "nothing"
+let tree1''' = deleteMin(tree1'')
+tree1''' |> show
+//│ let tree1''': Empty | Tree[Num]
+//│ Str
+//│ res
+//│     = 3
+//│ tree1'''
+//│          = Node {}
+//│ res
+//│     = '(• 4 •)'
+
+// Remove the last element. It should be 4.
+getMin(tree1''') ?? "nothing"
+let tree1'''' = deleteMin(tree1''')
+tree1'''' |> show
+//│ let tree1'''': Empty | Tree[Num]
+//│ Str
+//│ res
+//│     = 4
+//│ tree1''''
+//│           = Empty { class: [class Empty extends Tree] }
+//│ res
+//│     = '•'
+
+// ===========================================================================
+
+fun drain(t) =
+  if getMin(t) is
+    None then Nil
+    Some(x) then x :: drain(deleteMin(t))
+//│ fun drain: forall 'T. (Empty | Node[Num & 'T]) -> (Cons[Num | 'T] | Nil)
+
+fun sorted(xs) = fromList(Empty, xs) |> drain
+//│ fun sorted: (Cons[Num] | Nil) -> (Cons[Num] | Nil)
+
+fun showList(xs) =
+  if xs is
+    Cons(x, Nil) then toString(x)
+    Cons(x, xs') then toString(x) ++ ", " ++ showList(xs')
+    Nil then ""
+//│ fun showList: (Cons[anything] | Nil) -> Str
+
+sorted(3 :: 4 :: 1 :: 2 :: Nil) |> showList
+sorted(42 :: 58 :: 19 :: 37 :: 44 :: 99 :: 68 :: 60 :: 77 :: 61 :: Nil) |> showList
+//│ Str
+//│ res
+//│     = '1, 2, 3, 4'
+//│ res
+//│     = '19, 37, 42, 44, 58, 60, 61, 68, 77, 99'

From 8f8431060023d6f99a89d0223aa937db8c431717 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 23 Dec 2023 00:51:51 +0800
Subject: [PATCH 017/147] Add AVL tree for testing and fix many issues

- Very minor but important: should use post-processed term as the
  desugared term.
- Add incomplete AVL tree test cases which reveals many problems.
- Cache operator split partial terms for efficiency.
- `Traceable` now supports filtering debugging by topics.
- Skip speicalization Boolean condition scrutinees.
---
 .../scala/mlscript/pretyper/PreTyper.scala    |  10 +-
 .../scala/mlscript/pretyper/Traceable.scala   |  36 +-
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |  67 ++--
 .../main/scala/mlscript/ucs/PartialTerm.scala |   7 +-
 .../mlscript/ucs/stages/Desugaring.scala      |  89 +++--
 .../mlscript/ucs/stages/Normalization.scala   |  14 +-
 .../mlscript/ucs/stages/PostProcessing.scala  |   8 +-
 .../mlscript/ucs/stages/Transformation.scala  |  31 +-
 .../src/main/scala/mlscript/ucs/syntax.scala  |  10 +-
 .../main/scala/mlscript/utils/inspect.scala   |   9 +
 .../src/test/diff/pretyper/ucs/Overlaps.mls   |  44 +--
 .../test/diff/pretyper/ucs/TransfromUCS.mls   |   2 +-
 .../pretyper/ucs/coverage/SealedClasses.mls   |  38 ++-
 .../diff/pretyper/ucs/examples/AVLTree.mls    | 309 ++++++++++++++++++
 .../src/test/scala/mlscript/DiffTests.scala   |  25 +-
 15 files changed, 551 insertions(+), 148 deletions(-)
 create mode 100644 shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls

diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index d6827ea255..c48e582e69 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -7,7 +7,7 @@ import mlscript._, utils._, shorthands._
 import scala.annotation.tailrec
 import mlscript.Message, Message.MessageContext
 
-class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Traceable with DesugarUCS {
+class PreTyper(override val debugTopics: Opt[Set[Str]], useNewDefs: Bool) extends Traceable with DesugarUCS {
   import PreTyper._
 
   protected def raise(diagnostics: Diagnostic): Unit = ()
@@ -42,19 +42,19 @@ class PreTyper(override val debugLevel: Opt[Int], useNewDefs: Bool) extends Trac
     trace(s"resolveVar(name = \"$v\")") {
       scope.getTermSymbol(v.name) match {
         case S(sym: ValueSymbol) =>
-          println(s"Resolve variable $v to a value.", 2)
+          println(s"Resolve variable $v to a value.")
           v.symbol = sym
         case S(sym: SubValueSymbol) =>
-          println(s"Resolve variable $v to a value.", 2)
+          println(s"Resolve variable $v to a value.")
           v.symbol = sym
         case S(sym: FunctionSymbol) =>
-          println(s"Resolve variable $v to a function.", 2)
+          println(s"Resolve variable $v to a function.")
           v.symbol = sym
         case N => 
           scope.getTypeSymbol(v.name) match {
             case S(sym: ClassSymbol) =>
               if (sym.defn.kind == Cls) {
-                println(s"Resolve variable $v to a class.", 2)
+                println(s"Resolve variable $v to a class.")
                 v.symbol = sym
               } else {
                 throw new Exception(s"Name $v refers to a type")
diff --git a/shared/src/main/scala/mlscript/pretyper/Traceable.scala b/shared/src/main/scala/mlscript/pretyper/Traceable.scala
index 781fa8030c..206982fede 100644
--- a/shared/src/main/scala/mlscript/pretyper/Traceable.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Traceable.scala
@@ -4,11 +4,15 @@ import mlscript.Diagnostic
 import mlscript.utils._, shorthands._
 
 trait Traceable {
-  // Override this to change the base indentation level.
-  def baseIndent: Int = 0
+  /** The set of topics to debug. Empty set indicates all topics. */
+  protected val debugTopics: Opt[Set[Str]] = N
+  protected var indent = 0
+  private var topic: Opt[Str] = N
 
-  protected val debugLevel: Opt[Int] = N // The number of verbose.
-  protected var indent = baseIndent
+  def emitString(str: String): Unit = scala.Predef.println(str)
+  
+  @inline private def printLineByLine(x: => Any): Unit =
+    x.toString.linesIterator.foreach { line => emitString("| " * indent + line) }
 
   def trace[T](pre: => String)(thunk: => T)(post: T => String = Traceable.noPostTrace): T = {
     println(pre)
@@ -18,21 +22,21 @@ trait Traceable {
     res
   }
 
+  def traceWithTopic[T](topic: Str)(thunk: => T): T = {
+    this.topic = S(topic)
+    val res = thunk
+    this.topic = N
+    res
+  }
+
   @inline def traceNot[T](pre: => String)(thunk: => T)(post: T => String = Traceable.noPostTrace): T =
     thunk
   
-  def emitDbg(str: String): Unit = scala.Predef.println(str)
-  
-  @inline
-  protected def println(msg: => Any): Unit = println(msg, 0)
-  
-  @inline 
-  protected def println(msg: => Any, level: Int): Unit =
-    if (debugLevel exists (_ >= level)) printLineByLine(msg)
-
-  @inline
-  private def printLineByLine(msg: => Any): Unit =
-    msg.toString.linesIterator.foreach { line => emitDbg("| " * indent + line) }
+  @inline protected def println(x: => Any): Unit =
+    topic match {
+      case N => if (debugTopics.isDefined) printLineByLine(x)
+      case S(topic) => if (debugTopics.fold(false)(ts => ts.isEmpty || ts.contains(topic))) printLineByLine(x)
+    }
 }
 
 object Traceable {
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 351e5b3f9e..a9743b5c21 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -17,39 +17,50 @@ trait DesugarUCS extends Transformation
   protected def traverseIf(`if`: If)(implicit scope: Scope): Unit =
     trace("traverseIf") {
       // Stage 0: Transformation
-      println("STEP 0")
-      val transformed = transform(`if`, true)
-      println("Transformed UCS term:")
-      println(transformed.toString, 2)
-      println(ucs.syntax.printTermSplit(transformed))
+      val transformed = traceWithTopic("transform") {
+        println("STEP 0")
+        val transformed = transform(`if`, true)
+        println("Transformed UCS term:")
+        println(ucs.syntax.printTermSplit(transformed))
+        transformed
+      }
       // Stage 1: Desugaring
-      // This stage will generate new names based on the position of the scrutinee.
-      // Therefore, we need to call `traverseSplit` to associate these newly generated
-      // names with symbols.
-      println("STEP 1")
-      val desugared = desugar(transformed)
-      println(desugared.toString, 2)
-      println("Desugared UCS term:")
-      println(ucs.core.printSplit(desugared))
-      traverseSplit(desugared)
+      val desugared = traceWithTopic("desugar") {
+        println("STEP 1")
+        val desugared = desugar(transformed)
+        println("Desugared UCS term:")
+        println(ucs.core.printSplit(desugared))
+        desugared
+      }
+      traceWithTopic("traverse") {
+        println("STEP 1.5")
+        traverseSplit(desugared)
+      }
       // Stage 2: Normalization
-      println("STEP 2")
-      val normalized = normalize(desugared)
-      println(normalized.toString, 2)
-      println("Normalized UCS term:")
-      printNormalizedTerm(normalized)
+      val normalized = traceWithTopic("normalize") {
+        println("STEP 2")
+        val normalized = normalize(desugared)
+        println("Normalized UCS term:")
+        printNormalizedTerm(normalized)
+        normalized
+      }
       // Stage 3: Post-processing
-      println("STEP 3")
-      val postProcessed = postProcess(normalized)
-      println("Post-processed UCS term:")
-      printNormalizedTerm(postProcessed)
+      val postProcessed = traceWithTopic("postprocess") {
+        println("STEP 3")
+        val postProcessed = postProcess(normalized)
+        println("Post-processed UCS term:")
+        printNormalizedTerm(postProcessed)
+        postProcessed
+      }
       // Stage 4: Coverage checking
-      println("STEP 4")
-      val diagnostics = checkCoverage(postProcessed)
-      println(s"Coverage checking result: ${diagnostics.size} errors")
-      raise(diagnostics)
+      traceWithTopic("coverage") {
+        val checked = println("STEP 4")
+        val diagnostics = checkCoverage(postProcessed)
+        println(s"Coverage checking result: ${diagnostics.size} errors")
+        raise(diagnostics)
+      }
       // Epilogue
-      `if`.desugaredTerm = S(normalized)
+      `if`.desugaredTerm = S(postProcessed)
     }(_ => "traverseIf ==> ()")
   
   private def traverseSplit(split: core.Split)(implicit scope: Scope): Unit =
diff --git a/shared/src/main/scala/mlscript/ucs/PartialTerm.scala b/shared/src/main/scala/mlscript/ucs/PartialTerm.scala
index a150714f4e..40a9767aec 100644
--- a/shared/src/main/scala/mlscript/ucs/PartialTerm.scala
+++ b/shared/src/main/scala/mlscript/ucs/PartialTerm.scala
@@ -27,7 +27,12 @@ sealed abstract class PartialTerm {
   def get: Term = this match {
     case Empty => throw new PartialTermError(this, "expect a term but nothing was given")
     case Total(term, fragments) => term
-    case Half(lhs, op, fragments) => throw new PartialTermError(this, "expect an operator but nothing was given")
+    case Half(lhs, op, fragments) => throw new PartialTermError(this, "incomplete term")
+  }
+  override def toString(): String = this match {
+    case Empty => "<empty>"
+    case Total(term, fragments) => s"<total> $term"
+    case Half(lhs, op, fragments) => s"<half> $lhs $op"
   }
 }
 
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 16fd8b0113..9a1a1972fd 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -11,15 +11,11 @@ import mlscript.Message, Message.MessageContext
 trait Desugaring { self: mlscript.pretyper.Traceable =>
   @inline def desugar(term: s.TermSplit): c.Split = desugarTermSplit(term)(PartialTerm.Empty)
 
-  private var nextScrutineeIndex: Int = 0
+  import Desugaring._
 
-  private def freshName(): Str = {
-    val thisIndex = nextScrutineeIndex
-    nextScrutineeIndex += 1
-    s"scrut$$$thisIndex" // FIXME: use `freeVars` to avoid name collision.
-  }
-
-  private def freshScrutinee(): Var = Var(freshName())
+  private val freshCache = new VariableGenerator(cachePrefix)
+  private val freshScrutinee = new VariableGenerator(scrutineePrefix)
+  private val freshTest = new VariableGenerator(testPrefix)
 
   private def freshScrutinee(parentScrutinee: Var, parentClassName: Var, index: Int): Var =
     Var(s"${parentScrutinee}$$${parentClassName}_${index.toString}")
@@ -52,36 +48,49 @@ trait Desugaring { self: mlscript.pretyper.Traceable =>
       case s.Split.Nil => c.Split.Nil
     }
 
+  // This function does not need to can `withCachedTermPart` because all branches assume that
+  // `termPart` is either empty or waiting for an RHS.
   private def desugarTermBranch(branch: s.TermBranch)(implicit termPart: PartialTerm): c.Split =
-    // Note: `Branch` is `(Term, Pattern, Either[Split, Term])`.
-    branch match {
-      case s.TermBranch.Boolean(condition, continuation) =>
-        val `var` = freshScrutinee()
-        c.Split.Let(
-          rec = false,
-          name = `var`,
-          term = Asc(condition, TypeName("Bool")),
-          tail = c.Branch(`var`, truePattern, desugarTermSplit(continuation)) :: c.Split.Nil
-        )
-      case s.TermBranch.Match(scrutinee, split) =>
-        desugarPatternSplit(split)(termPart.addTerm(scrutinee, true).get)
-      case s.TermBranch.Left(left, continuation) =>
-        desugarOperatorSplit(continuation)(termPart.addTerm(left, true))
+    trace(s"desugarTermBranch <== $termPart") {
+      branch match {
+        case s.TermBranch.Boolean(testPart, continuation) =>
+          val test = freshTest()
+          c.Split.Let(
+            rec = false,
+            name = test,
+            term = Asc(termPart.addTerm(testPart, true).get, TypeName("Bool")),
+            tail = c.Branch(test, truePattern, desugarTermSplit(continuation)(PartialTerm.Empty)) :: c.Split.Nil
+          )
+        case s.TermBranch.Match(scrutinee, split) =>
+          desugarPatternSplit(split)(termPart.addTerm(scrutinee, true).get)
+        case s.TermBranch.Left(left, continuation) =>
+          desugarOperatorSplit(continuation)(termPart.addTerm(left, true))
+      }
+    }()
+
+  private def withCachedTermPart[B <: s.Branch](desugar: (PartialTerm) => c.Split)(implicit termPart: PartialTerm): c.Split =
+    termPart.get match {
+      case v: Var => desugar(termPart) // No need to cache variables.
+      case rhs =>
+        val cache = freshCache()
+        c.Split.Let(false, cache, rhs, desugar(PartialTerm.Total(cache, Nil)))
     }
 
   private def desugarOperatorSplit(split: s.OperatorSplit)(implicit termPart: PartialTerm): c.Split =
-    split match {
-      case s.Split.Cons(head, tail) => desugarOperatorBranch(head) ++ desugarOperatorSplit(tail)
-      case s.Split.Let(rec, nme, rhs, tail) => c.Split.Let(rec, nme, rhs, desugarOperatorSplit(tail))
+    withCachedTermPart { termPart => split match {
+      case s.Split.Cons(head, tail) => desugarOperatorBranch(head)(termPart) ++ desugarOperatorSplit(tail)(termPart)
+      case s.Split.Let(rec, nme, rhs, tail) => c.Split.Let(rec, nme, rhs, desugarOperatorSplit(tail)(termPart))
       case s.Split.Else(default) => c.Split.Else(default)
       case s.Split.Nil => c.Split.Nil
-    }
+    }}
 
   private def desugarOperatorBranch(branch: s.OperatorBranch)(implicit termPart: PartialTerm): c.Split =
-    branch match {
-      case s.OperatorBranch.Binary(op, split) => desugarTermSplit(split)(termPart.addOp(op))
-      case s.OperatorBranch.Match(_, split) => desugarPatternSplit(split)(termPart.get)
-    }
+    trace(s"desugarOperatorBranch <== $termPart") {
+      branch match {
+        case s.OperatorBranch.Binary(op, split) => desugarTermSplit(split)(termPart.addOp(op))
+        case s.OperatorBranch.Match(_, split) => desugarPatternSplit(split)(termPart.get)
+      }
+    }()
 
   private def flattenNestedPattern(pattern: s.ClassPattern, scrutinee: Var, next: c.Split): c.Branch = {
     val (parameterBindings, subPatterns) = flattenClassParameters(scrutinee, pattern.nme, pattern.parameters)
@@ -133,3 +142,23 @@ trait Desugaring { self: mlscript.pretyper.Traceable =>
     }
   }
 }
+
+object Desugaring {
+  class VariableGenerator(prefix: Str) {
+    private var nextIndex = 0
+
+    def apply(): Var = {
+      val thisIndex = nextIndex
+      nextIndex += 1
+      Var(s"$prefix$thisIndex")
+    }
+  }
+
+  val cachePrefix = "cache$"
+  val scrutineePrefix = "scrut$"
+  val testPrefix = "test$"
+
+  def isCacheVar(nme: Var): Bool = nme.name.startsWith(cachePrefix)
+  def isScrutineeVar(nme: Var): Bool = nme.name.startsWith(scrutineePrefix)
+  def isTestVar(nme: Var): Bool = nme.name.startsWith(testPrefix)
+}
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 36dcbe23c2..046d2e2cf2 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -22,11 +22,16 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
     */ 
   @inline def normalize(split: Split)(implicit scope: Scope): Term = normalizeToTerm(split)
 
-  private def normalizeToTerm(split: Split)(implicit scope: Scope): Term = trace("normalizeToTerm") {
+  private def normalizeToTerm(split: Split)(implicit scope: Scope): Term = trace("normalizeToTerm <==") {
     split match {
       case Split.Cons(Branch(scrutinee, Pattern.Name(nme), continuation), tail) =>
         println(s"alias $scrutinee => $nme")
         Let(false, nme, scrutinee, normalizeToTerm(continuation ++ tail))
+      // Skip Boolean conditions as scrutinees, because they only appear once.
+      case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true"), N), continuation), tail) if Desugaring.isTestVar(test) =>
+        val trueBranch = normalizeToTerm(continuation ++ tail)
+        val falseBranch = normalizeToCaseBranches(tail)
+        CaseOf(test, Case(nme, trueBranch, falseBranch))
       case Split.Cons(Branch(scrutinee, pattern @ Pattern.Literal(literal), continuation), tail) =>
         val trueBranch = normalizeToTerm(specialize(continuation ++ tail, Yes)(scrutinee.symbol, pattern, scope))
         val falseBranch = normalizeToCaseBranches(specialize(tail, No)(scrutinee.symbol, pattern, scope))
@@ -76,11 +81,12 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
         CaseOf(scrutinee, Case(nme, trueBranchWithBindings, falseBranch))
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
         throw new NormalizationException((msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc) :: Nil)
+      case Split.Let(rec, Var("_"), rhs, tail) => normalizeToTerm(tail)
       case Split.Let(rec, nme, rhs, tail) => Let(rec, nme, rhs, normalizeToTerm(tail))
       case Split.Else(default) => default
       case Split.Nil => println("unexpected empty split"); ???
     }
-  }()
+  }(_ => "normalizeToTerm ==> ")
 
   private def normalizeToCaseBranches(split: Split)(implicit scope: Scope): CaseBranches = trace("normalizeToCaseBranches") {
     split match {
@@ -254,7 +260,7 @@ object Normalization {
     * some special markers.
     *
     * - `*` if the variable is associated with a symbol,
-    * - `†` if the class name has a location.
+    * - `†` if the variable has a location.
     */
   def showNormalizedTerm(term: Term): String = {
     def showTerm(term: Term): Lines = term match {
@@ -278,7 +284,7 @@ object Normalization {
       }
     def showVar(`var`: Var): Str =
       // If the variable is associated with a symbol, mark it with an asterisk *.
-      `var`.name + (`var`.symbolOption.fold("")(_ => "*"))
+      `var`.name + (`var`.symbolOption.fold("")(_ => "*")) + (`var`.toLoc.fold("")(_ => "†"))
     def showLet(let: Let): Lines = {
       val Let(rec, nme, rhs, body) = let
       (0, s"let ${showVar(nme)} = $rhs") :: showTerm(body)
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index 0299c610c8..8ecb313f3f 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -34,8 +34,8 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
         println(s"found a UNARY case: $scrutinee is $className")
         println("post-processing the body")
         top.copy(cases = fst.copy(body = postProcess(body)))
-      case top @ CaseOf(scrutinee, fst @ Case(Var("true"), trueBranch, Wildcard(falseBranch))) =>
-        println(s"found a if-then-else case: $scrutinee is true")
+      case top @ CaseOf(test: Var, fst @ Case(Var("true"), trueBranch, Wildcard(falseBranch))) if Desugaring.isTestVar(test) =>
+        println(s"found a if-then-else case: $test is true")
         val processedTrueBranch = postProcess(trueBranch)
         val processedFalseBranch = postProcess(falseBranch)
         top.copy(cases = fst.copy(body = processedTrueBranch, rest = Wildcard(processedFalseBranch)))
@@ -187,7 +187,7 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
                 println("no cases, STOP")
                 NoCases -> NoCases
               case wildcard @ Wildcard(body) =>
-                println("found a wildcard, stop")
+                println("found a wildcard, go deeper")
                 val (n, y) = disentangle(body, scrutinee, classSymbol)
                 (wildcard.copy(body = n), y.fold(NoCases: CaseBranches)(Wildcard(_)))
               case kase @ Case(_, body, rest) =>
@@ -200,7 +200,7 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
                 }))
             }
             val (n, y) = rec(cases)
-            (top.copy(cases = y), (if (n === NoCases) N else S(top.copy(cases = n))))
+            (top.copy(cases = n), (if (y === NoCases) N else S(top.copy(cases = y))))
           }
         case let @ Let(_, _, _, body) =>
           val (n, y) = disentangle(body, scrutinee, classSymbol)
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index b3acf72b66..531492c564 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -23,9 +23,7 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
   def transform(`if`: If, useNewDefs: Bool = true): TermSplit =
     transformIfBody(`if`.body)(useNewDefs) ++ `if`.els.fold(Split.empty)(Split.default)
 
-  import helpers.splitAnd
-
-  private def transformIfBody(body: IfBody)(implicit useNewDefs: Bool): TermSplit = {
+  private def transformIfBody(body: IfBody)(implicit useNewDefs: Bool): TermSplit = trace(s"transformIfBody <== ${inspect.shallow(body)}") {
     body match {
       case IfThen(expr, rhs) =>
         splitAnd(expr).foldRight(Split.then(rhs)) {
@@ -73,9 +71,18 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
             throw new TransformException(msg"Unexpected statement in an if block", statement.toLoc)
         }
       case IfOpsApp(lhs, opsRhss) =>
-        TermBranch.Left(lhs, Split.from(opsRhss.map(transformOperatorBranch))) |> Split.single
+        splitAnd(lhs) match {
+          case init :+ last =>
+            val first = TermBranch.Left(last, Split.from(opsRhss.map(transformOperatorBranch))) |> Split.single
+            init.foldRight[TermSplit](first) {
+              case (OperatorIs(scrutinee, pattern), acc) =>
+                TermBranch.Match(scrutinee, PatternBranch(transformPattern(pattern), acc) |> Split.single) |> Split.single
+              case (test, acc) => TermBranch.Boolean(test, acc) |> Split.single
+            }
+          case _ => rare
+        }
     }
-  }
+  }(_ => "transformIfBody ==> ")
   
   private def transformOperatorBranch(opsRhs: Var -> IfBody)(implicit useNewDefs: Bool): OperatorBranch =
     opsRhs match {
@@ -137,6 +144,20 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
   }
 
   private def rare: Nothing = throw new TransformException(msg"Wow, a rare case.", N)
+
+  private def splitAnd(t: Term): Ls[Term] = trace(s"splitAnd <== ${inspect.deep(t)}") {
+    t match {
+      case App(
+        App(Var("and"),
+            Tup((_ -> Fld(_, lhs)) :: Nil)),
+        Tup((_ -> Fld(_, rhs)) :: Nil)
+      ) => // * Old-style operators
+        splitAnd(lhs) :+ rhs
+      case App(Var("and"), PlainTup(lhs, rhs)) =>
+        splitAnd(lhs) :+ rhs
+      case _ => t :: Nil
+    }
+  }(r => "splitAnd ==> " + r.iterator.map(_.toString).mkString(" ∧ "))
 }
 
 object Transformation {
diff --git a/shared/src/main/scala/mlscript/ucs/syntax.scala b/shared/src/main/scala/mlscript/ucs/syntax.scala
index 61d107bfac..85b4776521 100644
--- a/shared/src/main/scala/mlscript/ucs/syntax.scala
+++ b/shared/src/main/scala/mlscript/ucs/syntax.scala
@@ -110,12 +110,12 @@ package object syntax {
 
   def printTermSplit(split: TermSplit): Str = {
     // TODO: tailrec
-    def termSplit(split: TermSplit, isFirst: Bool, isTopLevel: Bool): Lines = split match {
+    def termSplit(split: TermSplit, isFirst: Bool, isAfterAnd: Bool): Lines = split match {
       case Split.Cons(head, tail) => (termBranch(head) match {
-        case (n, line) :: tail => (n, (if (isTopLevel) "" else "and ") + s"$line") :: tail
+        case (n, line) :: tail => (n, (if (isAfterAnd) "" else "and ") + s"$line") :: tail
         case Nil => Nil
-      }) ::: termSplit(tail, false, isTopLevel)
-      case Split.Let(_, nme, rhs, tail) => (0, s"let $nme = $rhs") :: termSplit(tail, false, isTopLevel)
+      }) ::: termSplit(tail, false, isAfterAnd)
+      case Split.Let(_, nme, rhs, tail) => (0, s"let $nme = $rhs") :: termSplit(tail, false, isAfterAnd)
       case Split.Else(term) => (if (isFirst) (0, s"then $term") else (0, s"else $term")) :: Nil
       case Split.Nil => Nil
     }
@@ -142,7 +142,7 @@ package object syntax {
     def operatorBranch(branch: OperatorBranch): Lines =
       s"${branch.operator}" #: (branch match {
         case OperatorBranch.Match(_, continuation) => patternSplit(continuation)
-        case OperatorBranch.Binary(_, continuation) => termSplit(continuation, true, false)
+        case OperatorBranch.Binary(_, continuation) => termSplit(continuation, true, true)
       })
     def patternBranch(branch: PatternBranch): Lines = {
       val PatternBranch(pattern, continuation) = branch
diff --git a/shared/src/main/scala/mlscript/utils/inspect.scala b/shared/src/main/scala/mlscript/utils/inspect.scala
index 5a88c1f37d..63a573029b 100644
--- a/shared/src/main/scala/mlscript/utils/inspect.scala
+++ b/shared/src/main/scala/mlscript/utils/inspect.scala
@@ -15,6 +15,15 @@ object inspect {
         if (arity === 0) { name } else s"${name}(${(", _" * arity).drop(2)})"
     }
 
+    def apply(body: IfBody): Str = body match {
+      case IfOpApp(lhs, op, rhs) => s"IfOpApp(${apply(lhs)}, ${apply(op)}, _)"
+      case IfLet(isRec, name, rhs, body) => s"IfLet($isRec, $name, _, _)"
+      case IfThen(expr, rhs) => s"IfThen(${apply(expr)}, _)"
+      case IfOpsApp(lhs, opsRhss) => s"IfOpsApp(${apply(lhs)}, ${opsRhss.map { case (op, body) => s"$op -> _" }.mkString("; ")})"
+      case IfBlock(lines) => s"IfBlock(_)"
+      case IfElse(expr) => s"IfElse(${apply(expr)})"
+    }
+
     def apply(d: TypingUnit): Str = d.entities.iterator
       .map(apply)
       .mkString("{", ", ", "}")
diff --git a/shared/src/test/diff/pretyper/ucs/Overlaps.mls b/shared/src/test/diff/pretyper/ucs/Overlaps.mls
index eb65c35e55..fb78fa1994 100644
--- a/shared/src/test/diff/pretyper/ucs/Overlaps.mls
+++ b/shared/src/test/diff/pretyper/ucs/Overlaps.mls
@@ -21,27 +21,25 @@ fun this_is_sealed(x: Shape) =
     LineSegment(_, _) then "LineSegment"
 //│ fun this_is_sealed: (x: Shape) -> ("Circle" | "LineSegment" | "Rectangle")
 
-// TODO
+// The error message here makes some sense right now.
+:e
 fun missing_a_case(x: Shape) =
   if x is
     Circle(_, _) then "Circle"
     Rectangle(_, _, _) then "Rectangle"
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.26: 	  if x is
+//│ ║  l.27: 	  if x is
 //│ ║        	     ^^^^
-//│ ║  l.27: 	    Circle(_, _) then "Circle"
+//│ ║  l.28: 	    Circle(_, _) then "Circle"
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.28: 	    Rectangle(_, _, _) then "Rectangle"
+//│ ║  l.29: 	    Rectangle(_, _, _) then "Rectangle"
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╟── type `LineSegment` is not an instance of type `Rectangle`
-//│ ║  l.25: 	fun missing_a_case(x: Shape) =
+//│ ╟── type `Circle | LineSegment | Rectangle` does not match type `Circle | Rectangle`
+//│ ║  l.26: 	fun missing_a_case(x: Shape) =
 //│ ║        	                      ^^^^^
-//│ ╟── but it flows into reference with expected type `Rectangle`
-//│ ║  l.26: 	  if x is
-//│ ║        	     ^
-//│ ╟── Note: constraint arises from class pattern:
-//│ ║  l.28: 	    Rectangle(_, _, _) then "Rectangle"
-//│ ╙──      	    ^^^^^^^^^
+//│ ╟── but it flows into reference with expected type `Circle | Rectangle`
+//│ ║  l.27: 	  if x is
+//│ ╙──      	     ^
 //│ fun missing_a_case: (x: Shape) -> ("Circle" | "Rectangle")
 
 fun missing_a_case(x: Shape) =
@@ -51,7 +49,7 @@ fun missing_a_case(x: Shape) =
     else x
 //│ fun missing_a_case: (x: Shape) -> ("Circle" | "Rectangle" | LineSegment)
 
-// TODO
+// TODO: Why doesn't `Shape` match `Circle | Rectangle | LineSegment`?
 fun countLineSegments(x) =
   if x is
     Shape and hidden(x) then "bro"
@@ -59,18 +57,20 @@ fun countLineSegments(x) =
     LineSegment(_, _) then "bro"
     Circle(_, _) then "bro"
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.56: 	  if x is
+//│ ║  l.54: 	  if x is
 //│ ║        	     ^^^^
-//│ ║  l.57: 	    Shape and hidden(x) then "bro"
+//│ ║  l.55: 	    Shape and hidden(x) then "bro"
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.58: 	    Rectangle(_, _, _) then "bro"
+//│ ║  l.56: 	    Rectangle(_, _, _) then "bro"
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.59: 	    LineSegment(_, _) then "bro"
+//│ ║  l.57: 	    LineSegment(_, _) then "bro"
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.60: 	    Circle(_, _) then "bro"
+//│ ║  l.58: 	    Circle(_, _) then "bro"
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╟── expression of type `Shape & ~#LineSegment & ~#Rectangle` is not an instance of type `Circle`
-//│ ╟── Note: constraint arises from class pattern:
-//│ ║  l.60: 	    Circle(_, _) then "bro"
-//│ ╙──      	    ^^^^^^
+//│ ╟── class pattern of type `Shape` does not match type `Circle | LineSegment | Rectangle`
+//│ ║  l.55: 	    Shape and hidden(x) then "bro"
+//│ ║        	    ^^^^^
+//│ ╟── but it flows into reference with expected type `Circle | LineSegment | Rectangle`
+//│ ║  l.54: 	  if x is
+//│ ╙──      	     ^
 //│ fun countLineSegments: Shape -> "bro"
diff --git a/shared/src/test/diff/pretyper/ucs/TransfromUCS.mls b/shared/src/test/diff/pretyper/ucs/TransfromUCS.mls
index 2facf100a6..31eac641ab 100644
--- a/shared/src/test/diff/pretyper/ucs/TransfromUCS.mls
+++ b/shared/src/test/diff/pretyper/ucs/TransfromUCS.mls
@@ -35,7 +35,7 @@ fun zipWith(f, xs, ys) =
     Cons(x, xs) and ys is Cons(y, ys) and zipWith(f, xs, ys) is Some(tail) then Some(Cons(f(x, y), tail))
     Nil and ys is Nil then Some(Nil)
   else None
-//│ fun zipWith: forall 'T 'T0 'T1. (('T, 'T0) -> 'T1, Cons['T] | Object & ~#Cons, Cons['T0] | Object & ~#Cons) -> (None | Some[Cons['T1] | Nil])
+//│ fun zipWith: forall 'T 'T0 'T1. (('T, 'T0) -> 'T1, Cons['T] | Nil | Object & ~#Cons & ~#Nil, Cons['T0] | Object & ~#Cons) -> (None | Some[Cons['T1] | Nil])
 
 
 fun getOrElse[T](x: Option[T], default: T): T =
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
index 996388f0f9..c87fec4683 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
@@ -9,7 +9,7 @@ class App(func: Term, arg: Term) extends Term
 //│ class Abs(param: Str, body: Term) extends Term
 //│ class App(func: Term, arg: Term) extends Term
 
-// FIXME
+// TODO: Why doesn't `Term` match `Abs | App | Var`?
 fun is_value(term) =
   if term is Term and term is
     Abs(_, _) then true
@@ -24,35 +24,39 @@ fun is_value(term) =
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^
 //│ ║  l.17: 	    App(_, _) then false
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╟── expression of type `Term & ~#Abs & ~#Var` is not an instance of type `App`
-//│ ╟── Note: constraint arises from class pattern:
-//│ ║  l.17: 	    App(_, _) then false
-//│ ╙──      	    ^^^
+//│ ╟── class pattern of type `Term` does not match type `Abs | App | Var`
+//│ ║  l.14: 	  if term is Term and term is
+//│ ║        	             ^^^^
+//│ ╟── but it flows into reference with expected type `Abs | App | Var`
+//│ ║  l.14: 	  if term is Term and term is
+//│ ╙──      	                      ^^^^
 //│ fun is_value: Term -> Bool
 
 :e
-fun is_value(term) =
+fun is_value'(term) =
   if term is Term and term is
     Abs(_, _) then true
     Var(_) then false
 //│ ╔══[ERROR] When scrutinee `term` is `Term`
-//│ ║  l.35: 	  if term is Term and term is
+//│ ║  l.37: 	  if term is Term and term is
 //│ ║        	             ^^^^
 //│ ╟── Scrutinee `term` has 1 missing case
-//│ ║  l.34: 	fun is_value(term) =
-//│ ║        	             ^^^^
+//│ ║  l.36: 	fun is_value'(term) =
+//│ ║        	              ^^^^
 //│ ╟── It can be class `App`
 //│ ║  l.6: 	class App(func: Term, arg: Term) extends Term
 //│ ╙──     	      ^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.35: 	  if term is Term and term is
+//│ ║  l.37: 	  if term is Term and term is
 //│ ║        	                      ^^^^^^^
-//│ ║  l.36: 	    Abs(_, _) then true
+//│ ║  l.38: 	    Abs(_, _) then true
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.37: 	    Var(_) then false
+//│ ║  l.39: 	    Var(_) then false
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^
-//│ ╟── expression of type `Term & ~#Abs` is not an instance of type `Var`
-//│ ╟── Note: constraint arises from class pattern:
-//│ ║  l.37: 	    Var(_) then false
-//│ ╙──      	    ^^^
-//│ fun is_value: Term -> Bool
+//│ ╟── class pattern of type `Term` does not match type `Abs | Var`
+//│ ║  l.37: 	  if term is Term and term is
+//│ ║        	             ^^^^
+//│ ╟── but it flows into reference with expected type `Abs | Var`
+//│ ║  l.37: 	  if term is Term and term is
+//│ ╙──      	                      ^^^^
+//│ fun is_value': Term -> Bool
diff --git a/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls b/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls
new file mode 100644
index 0000000000..b04eb2086c
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls
@@ -0,0 +1,309 @@
+:PreTyper
+
+fun (|>) pipe(x, f) = f(x)
+fun (~~>) toBe(x, y) = if x === y then () else error
+fun (<?) min(x, y) = if x < y then x else y
+fun (>?) max(x, y) = if x > y then x else y
+fun abs(x) = if x < 0 then -x else x
+//│ fun (|>) pipe: forall 'a 'b. ('a, 'a -> 'b) -> 'b
+//│ fun (~~>) toBe: forall 'c. (Eql['c], 'c) -> ()
+//│ fun (<?) min: forall 'd. (Num & 'd, Num & 'd) -> 'd
+//│ fun (>?) max: forall 'e. (Num & 'e, Num & 'e) -> 'e
+//│ fun abs: Int -> Int
+
+abstract class Option[out T]: (Some[T] | None)
+class Some[out T](val value: T) extends Option[T]
+module None extends Option[nothing]
+//│ abstract class Option[T]: None | Some[T]
+//│ class Some[T](value: T) extends Option
+//│ module None extends Option
+
+fun (??) getOrElse(o, v) = if o is
+  Some(v') then v'
+  None then v
+//│ fun (??) getOrElse: forall 'a. (None | Some['a], 'a) -> 'a
+
+fun (++) strcat(s1, s2) = concat(s1)(s2)
+//│ fun (++) strcat: (Str, Str) -> Str
+
+let anyToString = toString
+//│ let anyToString: anything -> Str
+//│ anyToString
+//│             = [Function: toString]
+
+abstract class List[out T]: (Cons[T] | Nil)
+class Cons[out T](val head: T, val tail: List[T]) extends List[T]
+module Nil extends List[nothing]
+//│ abstract class List[T]: Cons[T] | Nil
+//│ class Cons[T](head: T, tail: List[T]) extends List
+//│ module Nil extends List
+
+fun (::) cons(head, tail) = Cons(head, tail)
+//│ fun (::) cons: forall 'T. ('T, List['T]) -> Cons['T]
+
+abstract class Tree[out A]: (Empty | Node[A])
+class Node[A](value: A, left: Tree[A], right: Tree[A], height: Int) extends Tree[A]
+module Empty extends Tree[nothing]
+//│ abstract class Tree[A]: Empty | Node[A]
+//│ class Node[A](value: A, left: Tree[A], right: Tree[A], height: Int) extends Tree
+//│ module Empty extends Tree
+
+fun showTree(t: Tree[anything]): Str = if t is
+  Node(v, l, r, _) then
+    "(" ++ showTree(l) ++ " " ++ toString(v) ++ " " ++ showTree(r) ++ ")"
+  Empty then "•"
+//│ fun showTree: (t: Tree[anything]) -> Str
+
+fun showTreeWithHeight(t: Tree[anything]): Str = if t is
+  Node(v, l, r, h) then
+    "(" ++ showTreeWithHeight(l) ++ " " ++ toString(v) ++ " [" ++ toString(h) ++ "]" ++ " " ++ showTreeWithHeight(r) ++ ")"
+  Empty then "•"
+//│ fun showTreeWithHeight: (t: Tree[anything]) -> Str
+
+fun height(t) =
+  if t is
+    Node(_, _, _, h) then h
+    Empty then 0
+//│ fun height: (Empty | Node[anything]) -> Int
+
+let nil = Empty
+fun node(v, l, r) = Node(v, l, r, max(height(l), height(r)) + 1)
+fun single(v) = Node(v, Empty, Empty, 1)
+//│ let nil: Empty
+//│ fun node: forall 'A. ('A, Empty & Tree['A] | Node[anything] & Tree['A], Empty & Tree['A] | Node[anything] & Tree['A]) -> Node['A]
+//│ fun single: forall 'A0. 'A0 -> Node['A0]
+//│ nil
+//│     = Empty { class: [class Empty extends Tree] }
+
+fun isBalanced(t) =
+  if t is
+    Node(t, l, r, _) then
+      (abs(height(l) - height(r)) <= 1) && isBalanced(l) && isBalanced(r)
+    Empty then true
+//│ fun isBalanced: (Empty | Node[anything]) -> Bool
+
+isBalanced(nil) ~~> true
+//│ ()
+//│ res
+//│     = undefined
+
+//      _             _                    _        _
+//  ___(_)_ __   __ _| | ___     _ __ ___ | |_ __ _| |_ ___
+// / __| | '_ \ / _` | |/ _ \   | '__/ _ \| __/ _` | __/ _ \
+// \__ \ | | | | (_| | |  __/   | | | (_) | || (_| | ||  __/
+// |___/_|_| |_|\__, |_|\___|   |_|  \___/ \__\__,_|\__\___|
+//              |___/
+
+fun rotateLeft(t: Tree['A]): Tree['A] =
+  if t is
+    Node(v, l, Node(v', l', r', _), _) and
+      max(height(l), height(l')) + 1 is h and
+        max(h, height(r')) + 1 is h' then
+          Node(v', Node(v, l, l', h), r', h')
+    _ then t
+//│ fun rotateLeft: forall 'A. (t: Tree['A]) -> Tree['A]
+
+rotateLeft(nil) |> showTree
+rotateLeft(single(0)) |> showTree
+//│ Str
+//│ res
+//│     = '•'
+//│ res
+//│     = '(• 0 •)'
+
+let unbalanced1 = node(0, nil, node(1, nil, single(2)))
+isBalanced(unbalanced1) ~~> false
+unbalanced1 |> showTree
+rotateLeft(unbalanced1) |> showTree
+//│ let unbalanced1: Node[0 | 1 | 2]
+//│ Str
+//│ unbalanced1
+//│             = Node {}
+//│ res
+//│     = undefined
+//│ res
+//│     = '(• 0 (• 1 (• 2 •)))'
+//│ res
+//│     = '((• 0 •) 1 (• 2 •))'
+
+fun rotateRight(t: Tree['A]): Tree['A] =
+  if t is
+    Node(v, Node(v', l', r', _), r, _) then
+      Node(v', l', Node(v, r', r, 0), 0)
+    _ then t
+//│ fun rotateRight: forall 'A. (t: Tree['A]) -> Tree['A]
+
+rotateRight(nil) |> showTree
+rotateRight(single(0)) |> showTree
+//│ Str
+//│ res
+//│     = '•'
+//│ res
+//│     = '(• 0 •)'
+
+let unbalanced2 = node(2, node(1, single(0), nil), nil)
+isBalanced(unbalanced2) ~~> false
+unbalanced2 |> showTree
+rotateRight(unbalanced2) |> showTree
+//│ let unbalanced2: Node[0 | 1 | 2]
+//│ Str
+//│ unbalanced2
+//│             = Node {}
+//│ res
+//│     = undefined
+//│ res
+//│     = '(((• 0 •) 1 •) 2 •)'
+//│ res
+//│     = '((• 0 •) 1 (• 2 •))'
+
+//      _             _     _                    _        _
+//   __| | ___  _   _| |__ | | ___     _ __ ___ | |_ __ _| |_ ___
+//  / _` |/ _ \| | | | '_ \| |/ _ \   | '__/ _ \| __/ _` | __/ _ \
+// | (_| | (_) | |_| | |_) | |  __/   | | | (_) | || (_| | ||  __/
+//  \__,_|\___/ \__,_|_.__/|_|\___|   |_|  \___/ \__\__,_|\__\___|
+//
+
+fun rotateRightLeft(t: Tree['A]): Tree['A] =
+  if t is
+    Node(v, t1, Node(v', Node(v'', t2, t3, _), t4, _), _) then
+      Node(v'', Node(v, t1, t2, 0), Node(v', t3, t4, 0), 0)
+    else t
+//│ fun rotateRightLeft: forall 'A. (t: Tree['A]) -> Tree['A]
+
+// Should remain the same.
+rotateRightLeft(nil) |> showTree
+rotateRightLeft(single(0)) |> showTree
+rotateRightLeft(unbalanced1) |> showTree
+rotateRightLeft(unbalanced2) |> showTree
+//│ Str
+//│ res
+//│     = '•'
+//│ res
+//│     = '(• 0 •)'
+//│ res
+//│     = '(• 0 (• 1 (• 2 •)))'
+//│ res
+//│     = '(((• 0 •) 1 •) 2 •)'
+
+let unbalanced3 = node(0, nil, node(3, node(1, nil, single(2)), nil))
+isBalanced(unbalanced3) ~~> false
+unbalanced3 |> showTree
+rotateRightLeft(unbalanced3) |> showTree
+//│ let unbalanced3: Node[0 | 1 | 2 | 3]
+//│ Str
+//│ unbalanced3
+//│             = Node {}
+//│ res
+//│     = undefined
+//│ res
+//│     = '(• 0 ((• 1 (• 2 •)) 3 •))'
+//│ res
+//│     = '((• 0 •) 1 ((• 2 •) 3 •))'
+
+fun rotateLeftRight(t: Tree['A]): Tree['A] =
+  if t is
+    Node(v, Node(v', t1, Node(v'', t2, t3, _), _), t4, _) then
+      Node(v'', Node(v', t1, t2, 0), Node(v, t3, t4, 0), 0)
+    else t
+//│ fun rotateLeftRight: forall 'A. (t: Tree['A]) -> Tree['A]
+
+// Should remain the same.
+rotateLeftRight(nil) |> showTree
+rotateLeftRight(single(0)) |> showTree
+rotateLeftRight(unbalanced1) |> showTree
+rotateLeftRight(unbalanced2) |> showTree
+//│ Str
+//│ res
+//│     = '•'
+//│ res
+//│     = '(• 0 •)'
+//│ res
+//│     = '(• 0 (• 1 (• 2 •)))'
+//│ res
+//│     = '(((• 0 •) 1 •) 2 •)'
+
+let unbalanced4 = node(3, node(0, nil, node(2, single(1), nil)), nil)
+isBalanced(unbalanced4) ~~> false
+unbalanced4 |> showTree
+rotateRightLeft(unbalanced4) |> showTree
+//│ let unbalanced4: Node[0 | 1 | 2 | 3]
+//│ Str
+//│ unbalanced4
+//│             = Node {}
+//│ res
+//│     = undefined
+//│ res
+//│     = '((• 0 ((• 1 •) 2 •)) 3 •)'
+//│ res
+//│     = '((• 0 ((• 1 •) 2 •)) 3 •)'
+
+fun bf(t) =
+  if t is
+    Node(_, l, r, _) then height(l) - height(r)
+    Empty then 0
+//│ fun bf: (Empty | Node[anything]) -> Int
+
+//  _                     _
+// (_)_ __  ___  ___ _ __| |_
+// | | '_ \/ __|/ _ \ '__| __|
+// | | | | \__ \  __/ |  | |_
+// |_|_| |_|___/\___|_|   \__|
+//
+
+// This function does not work for now as it exposed a lot of problems we have
+// in desugaring and normalization. For example:
+// 
+// - [x] We need to mark the Boolean scrutinees and skip the specialization of
+//   these scrutinees in the normalization process, otherwise, it would result
+//   in many futile computations.
+// - [x] We should cache the expressions that are broken by conditional splits,
+//   otherwise, they will be evaluated for more than one time.
+// - [ ] The branches of an operator split should be "chained" rather
+//   than placed in parallel, otherwise, the later branches will appear in the
+//   else branch of all its previous branches. **WORK IN PROGRESS**
+//
+// :dpt:postprocess
+fun balance(t: Tree['A]): Tree['A] =
+  if t is
+    Node(x, l, r, _) and height(r) - height(l)
+      > 1 and r is Node(y, l', r', _) and height(r') - height(l')
+        > 0 then rotateLeft(t)
+        < 0 and l' is Node then rotateRightLeft(t)
+      < 1 and l is Node(y, l', r', _) and height(r') - height(l')
+        > 0 and r' is Node then rotateLeftRight(t)
+        < 0 then rotateRight(t)
+    _ then t
+//│ fun balance: forall 'A. (t: Tree['A]) -> Tree['A]
+
+fun insert(t: Tree[Num], v: Num) = if t is
+  Node(v', l, r, h) and
+    v < v' then Node(v', insert(l, v), r, h) |> balance
+    v > v' then Node(v', l, insert(r, v), h) |> balance
+    _ then t
+  Empty then Node(v, Empty, Empty, 1)
+//│ fun insert: (t: Tree[Num], v: Num) -> (Node[Num] | Tree[Num])
+
+
+insert(nil, 0) |> showTree
+insert(single(0), 1) |> showTree
+insert(single(0), -1) |> showTree
+//│ Str
+//│ res
+//│     = '(• 0 •)'
+//│ res
+//│     = '(• 0 (• 1 •))'
+//│ res
+//│     = '((• -1 •) 0 •)'
+
+insert(node(0, nil, single(1)), 2) |> showTreeWithHeight
+insert(node(0, nil, single(1)), 2) |> showTree
+//│ Str
+//│ res
+//│     = '(• 0 [2] (• 1 [1] (• 2 [1] •)))'
+//│ res
+//│     = '(• 0 (• 1 (• 2 •)))'
+
+insert(unbalanced1, 3) |> showTree
+//│ Str
+//│ res
+//│     = '((• 0 •) 1 (• 2 (• 3 •)))'
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index d8a2cf982e..3dac91445d 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -151,7 +151,7 @@ class DiffTests
       explainErrors: Bool = false,
       dbg: Bool = false,
       dbgParsing: Bool = false,
-      dbgPreTyper: Opt[Int] = N,
+      dbgPreTyper: Opt[Set[Str]] = N,
       dbgSimplif: Bool = false,
       dbgUCS: Bool = false,
       fullExceptionStack: Bool = false,
@@ -215,7 +215,7 @@ class DiffTests
           case "p" => mode.copy(showParse = true)
           case "d" => mode.copy(dbg = true)
           case "dp" => mode.copy(dbgParsing = true)
-          case PreTyperOption(nv) => mode.copy(dbgPreTyper = S(nv))
+          case PreTyperFlags(ts) => mode.copy(dbgPreTyper = S(ts))
           case "ds" => mode.copy(dbgSimplif = true)
           case "ducs" => mode.copy(dbg = true, dbgUCS = true)
           case "s" => mode.copy(fullExceptionStack = true)
@@ -526,7 +526,7 @@ class DiffTests
               if (usePreTyper) {
                 val preTyper = new PreTyper(mode.dbgPreTyper, newDefs) {
                   override protected def raise(diagnostics: Ls[Diagnostic]): Unit = report(diagnostics)
-                  override def emitDbg(str: String): Unit = output(str)
+                  override def emitString(str: String): Unit = output(str)
                 }
                 // This should be passed to code generation somehow.
                 preTyperScope = preTyper.process(rootTypingUnit, preTyperScope, "<root>")._1
@@ -1162,12 +1162,17 @@ object DiffTests {
       // file.segments.toList.init.lastOption.contains("parser")
   }
 
-  object PreTyperOption {
-    def unapply(str: String): Option[Int] = str match {
-      case "dpt" => Some(0)
-      case "dpt:v" => Some(1)
-      case "dpt:vv" => Some(2)
-      case _ => None
-    }
+  object PreTyperFlags {
+    private val pattern = "^dpt(?::\\s*([A-Za-z]+)(,\\s*[A-Za-z]+)*)?$".r
+    def unapply(flags: Str): Opt[Set[Str]] =
+      flags match {
+        case pattern(head, tail) =>
+          (Option(head), Option(tail)) match {
+            case (N, _) => S(Set.empty)
+            case (S(head), N) => S(Set.single(head))
+            case (S(head), S(tail)) => S(Set.from(head :: tail.split(",").drop(1).toList))
+          }
+        case _ => N
+      }
   }
 }

From ddb9f2ca552663c316a78a18eb00a1ab24f99772 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 23 Dec 2023 00:58:34 +0800
Subject: [PATCH 018/147] Remove unreachable code from previous merging stashes

---
 shared/src/main/scala/mlscript/pretyper/PreTyper.scala | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index c48e582e69..a65cf8d78d 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -120,11 +120,6 @@ class PreTyper(override val debugTopics: Opt[Set[Str]], useNewDefs: Bool) extend
           traverseTerm(base)
           traverseTypingUnit(decls, "Rft", scope)
           ()
-        case NuNew(cls) => traverseTerm(cls)
-        case Rft(base, decls) =>
-          traverseTerm(base)
-          traverseTypingUnit(decls, "Rft", scope)
-          ()
       }
     }(_ => s"traverseTerm ==> ${inspect.shallow(term)}")
 

From daeea5986255e516145fb4003bde6fe67ce205e0 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 23 Dec 2023 03:01:00 +0800
Subject: [PATCH 019/147] Add two test cases: list fold functions and list
 permutations

---
 .../scala/mlscript/pretyper/PreTyper.scala    |  65 +++---
 .../main/scala/mlscript/utils/inspect.scala   |  10 +-
 shared/src/test/diff/mlscript/Basics.mls      |   2 +-
 .../src/test/diff/mlscript/ByNameByValue.mls  |   4 +-
 shared/src/test/diff/mlscript/MultiArgs.mls   |   8 +-
 shared/src/test/diff/mlscript/Ops.mls         |  10 +-
 shared/src/test/diff/nu/AbstractClasses.mls   |   2 +-
 shared/src/test/diff/nu/LamPatterns.mls       |   2 +-
 shared/src/test/diff/nu/OverrideShorthand.mls |   4 +-
 shared/src/test/diff/nu/RightAssocOps.mls     |   6 +-
 .../ucs/examples/BinarySearchTree.mls         |  11 +-
 .../diff/pretyper/ucs/examples/ListFold.mls   | 208 ++++++++++++++++++
 .../pretyper/ucs/examples/Permutations.mls    | 127 +++++++++++
 shared/src/test/diff/ucs/LeadingAnd.mls       |   4 +-
 shared/src/test/diff/ucs/SplitOps.mls         |   4 +-
 .../src/test/scala/mlscript/DiffTests.scala   |   2 +-
 16 files changed, 405 insertions(+), 64 deletions(-)
 create mode 100644 shared/src/test/diff/pretyper/ucs/examples/ListFold.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/examples/Permutations.mls

diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index a65cf8d78d..a0311fbe27 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -7,34 +7,30 @@ import mlscript._, utils._, shorthands._
 import scala.annotation.tailrec
 import mlscript.Message, Message.MessageContext
 
-class PreTyper(override val debugTopics: Opt[Set[Str]], useNewDefs: Bool) extends Traceable with DesugarUCS {
+class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with DesugarUCS {
   import PreTyper._
 
   protected def raise(diagnostics: Diagnostic): Unit = ()
   protected def raise(diagnostics: Ls[Diagnostic]): Unit = ()
 
-  private def extractParameters(fields: Term): Ls[ValueSymbol] = fields match {
-    case Tup(arguments) =>
-      println(s"arguments: ${inspect.deep(fields)}")
-      if (useNewDefs) {
-        arguments.map {
-          case (S(nme: Var), Fld(_, _)) => new ValueSymbol(nme, false)
-          case (_, Fld(_, nme: Var)) => new ValueSymbol(nme, false)
-          case (_, Fld(_, x)) => println(x.toString); ???
-        }
-      } else {
-        arguments.map {
-          case (_, Fld(_, nme: Var)) => new ValueSymbol(nme, false)
-          case (_, Fld(_, x)) => println(x.toString); ???
-        }
-      }
-    case PlainTup(arguments @ _*) =>
-      arguments.map {
-        case nme: Var => new ValueSymbol(nme, false)
+  private def extractParameters(fields: Term): Ls[ValueSymbol] =
+    trace(s"extractParameters <== ${inspect.deep(fields)}") {
+      fields match {
+        case Tup(arguments) =>
+          arguments.map {
+            case (S(nme: Var), Fld(_, _)) => new ValueSymbol(nme, false)
+            case (_, Fld(_, nme: Var)) => new ValueSymbol(nme, false)
+            case (_, Fld(_, Bra(false, nme: Var))) => new ValueSymbol(nme, false)
+            case (_, _) => ???
+          }
+        case PlainTup(arguments @ _*) =>
+          arguments.map {
+            case nme: Var => new ValueSymbol(nme, false)
+            case other => println("Unknown parameters: " + inspect.deep(other)); ??? // TODO: bad
+          }.toList
         case other => println("Unknown parameters: " + inspect.deep(other)); ??? // TODO: bad
-      }.toList
-    case other => println("Unknown parameters: " + inspect.deep(other)); ??? // TODO: bad
-  }
+      }
+    }(rs => s"extractParameters ==> ${rs.iterator.map(_.name).mkString(", ")}")
 
   // `traverseIf` is meaningless because it represents patterns with terms.
 
@@ -94,10 +90,9 @@ class PreTyper(override val debugTopics: Opt[Set[Str]], useNewDefs: Bool) extend
         case ef @ If(_, _) => traverseIf(ef)(scope)
         case TyApp(lhs, targs) => // TODO: When?
         case Eqn(lhs, rhs) => ??? // TODO: How?
-        case Blk(stmts) => stmts.foreach {
-          case t: Term => traverseTerm(t)
-          case _ => ??? // TODO: When?
-        }
+        case Blk(stmts) =>
+          traverseStatements(stmts, "block", scope)
+          ()
         case Subs(arr, idx) => traverseTerm(arr); traverseTerm(idx)
         case Bind(lhs, rhs) => traverseTerm(lhs); traverseTerm(rhs)
         case Splc(fields) => fields.foreach {
@@ -118,14 +113,14 @@ class PreTyper(override val debugTopics: Opt[Set[Str]], useNewDefs: Bool) extend
         case NuNew(cls) => traverseTerm(cls)
         case Rft(base, decls) => // For object refinement
           traverseTerm(base)
-          traverseTypingUnit(decls, "Rft", scope)
+          traverseStatements(decls.entities, "Rft", scope)
           ()
       }
     }(_ => s"traverseTerm ==> ${inspect.shallow(term)}")
 
   private def traverseTypeDefinition(symbol: TypeSymbol, defn: NuTypeDef)(implicit scope: Scope): Unit =
     trace(s"traverseTypeDefinition <== ${defn.describe}") {
-      traverseTypingUnit(defn.body, defn.nme.name, scope)
+      traverseStatements(defn.body.entities, defn.nme.name, scope)
       ()
     }(_ => s"traverseTypeDefinition <== ${defn.describe}")
 
@@ -145,11 +140,11 @@ class PreTyper(override val debugTopics: Opt[Set[Str]], useNewDefs: Bool) extend
 
     }()
 
-  private def traverseTypingUnit(typingUnit: TypingUnit, name: Str, parentScope: Scope): (Scope, TypeContents) =
-    trace(s"traverseTypingUnit <== $name: ${typingUnit.describe}") {
+  private def traverseStatements(statements: Ls[Statement], name: Str, parentScope: Scope): (Scope, TypeContents) =
+    trace(s"traverseStatements <== $name: ${"statement".pluralize(statements.size, true)}") {
       import mlscript.{Cls, Trt, Mxn, Als, Mod}
       // Pass 1: Build a scope with hoisted symbols.
-      val hoistedScope = typingUnit.entities.foldLeft(parentScope.derive) {
+      val hoistedScope = statements.foldLeft(parentScope.derive) {
         case (acc, _: Term) => acc // Skip
         case (acc, defn: NuTypeDef) =>
           val `var` = Var(defn.nme.name).withLoc(defn.nme.toLoc)
@@ -172,7 +167,7 @@ class PreTyper(override val debugTopics: Opt[Set[Str]], useNewDefs: Bool) extend
         case (acc, _: Constructor | _: DataDefn | _: DatatypeDefn | _: Def | _: LetS | _: TypeDef) => ??? // TODO: When?
       }
       // Resolve base types.
-      val subtypingRelations = typingUnit.entities.foldLeft(Map.empty[Var, Ls[Var]]) {
+      val subtypingRelations = statements.foldLeft(Map.empty[Var, Ls[Var]]) {
         case (acc, defn: NuTypeDef) =>
           val thisType = Var(defn.nme.name).withLoc(defn.nme.toLoc)
           val superTypes = extractSuperTypes(defn.parents)
@@ -217,7 +212,7 @@ class PreTyper(override val debugTopics: Opt[Set[Str]], useNewDefs: Bool) extend
       println(hoistedScope.symbols.map(_.name).mkString("(hoisted) scope = {", ", ", "}"))
       // 
       // Pass 2: Visit non-hoisted and build a complete scope.
-      val completeScope = typingUnit.entities.foldLeft[Scope](hoistedScope) {
+      val completeScope = statements.foldLeft[Scope](hoistedScope) {
         case (acc, term: Term) => traverseTerm(term)(acc); acc
         case (acc, defn: NuTypeDef) => acc
         case (acc, defn @ NuFunDef(Some(rec), nme, _, _, L(rhs))) =>
@@ -254,11 +249,11 @@ class PreTyper(override val debugTopics: Opt[Set[Str]], useNewDefs: Bool) extend
         case _: FunctionSymbol | _: ValueSymbol | _: SubValueSymbol => ()
       }
       (completeScope, new TypeContents)
-    }({ case (scope, contents) => s"traverseTypingUnit ==> Scope {${scope.showLocalSymbols}}" })
+    }({ case (scope, contents) => s"traverseStatements ==> Scope {${scope.showLocalSymbols}}" })
 
   def process(typingUnit: TypingUnit, scope: Scope, name: Str): (Scope, TypeContents) =
     trace(s"process <== $name: ${typingUnit.describe}") {
-      traverseTypingUnit(typingUnit, name, scope)
+      traverseStatements(typingUnit.entities, name, scope)
     }({ case (scope, contents) => s"process ==> ${scope.showLocalSymbols}" })
 }
 
diff --git a/shared/src/main/scala/mlscript/utils/inspect.scala b/shared/src/main/scala/mlscript/utils/inspect.scala
index 63a573029b..5b095229ec 100644
--- a/shared/src/main/scala/mlscript/utils/inspect.scala
+++ b/shared/src/main/scala/mlscript/utils/inspect.scala
@@ -62,11 +62,13 @@ object inspect {
       case Var(name)     => s"Var(\"$name\")"
       case Lam(lhs, rhs) => s"Lam(${apply(lhs)}, ${apply(rhs)})"
       case App(lhs, rhs) => s"App(${apply(lhs)}, ${apply(rhs)})"
+      case Tup(Nil) => "Tup(Nil)"
       case Tup(fields) =>
-        fields.iterator.map {
-          case (S(name), Fld(_, value)) => s"(S(${apply(name)}), ${apply(value)})"
-          case (N, Fld(_, value))       => s"(N, ${apply(value)})"
-        }.mkString("Tup(", ", ", ")")
+        fields.iterator.map { case (maybeName, Fld(flags, value)) =>
+          val first = maybeName.fold("N") { name => s"S($name)" }
+          val second = s"Fld(_, ${apply(value)})"
+          s"($first, $second)"
+        }.mkString("Tup(", " :: ", " :: Nil)")
       case Rcd(fields) =>
         fields.iterator.map { case k -> Fld(_, v) => s"${apply(k)} = ${apply(v)}" }.mkString("Rcd(", ", ", ")")
       case Sel(receiver, fieldName)    => s"Sel(${apply(receiver)}, $fieldName)"
diff --git a/shared/src/test/diff/mlscript/Basics.mls b/shared/src/test/diff/mlscript/Basics.mls
index 2fb3e1b4a0..26a81c598f 100644
--- a/shared/src/test/diff/mlscript/Basics.mls
+++ b/shared/src/test/diff/mlscript/Basics.mls
@@ -96,7 +96,7 @@ def f (x y z) = add x y
 //│ ╙──      	       ^^^^^
 //│ f: error -> int
 //│ Code generation encountered an error:
-//│   term App(App(Var("x"), Tup((N, Var("y")))), Tup((N, Var("z")))) is not a valid pattern
+//│   term App(App(Var("x"), Tup((N, Fld(_, Var("y"))) :: Nil)), Tup((N, Fld(_, Var("z"))) :: Nil)) is not a valid pattern
 
 f 1
 //│ res: int
diff --git a/shared/src/test/diff/mlscript/ByNameByValue.mls b/shared/src/test/diff/mlscript/ByNameByValue.mls
index 5d48161808..c13304d185 100644
--- a/shared/src/test/diff/mlscript/ByNameByValue.mls
+++ b/shared/src/test/diff/mlscript/ByNameByValue.mls
@@ -16,7 +16,7 @@ def incr x = x.a <- x.a + 1
 def gensym = let n = { mut a = 0 } in fun () -> (incr n, n)
 //│ Parsed: def gensym: let n = {mut a: 0} in () => [incr(n,), n,];
 //│ Desugared: def gensym: let n = {mut a: 0} in () => [incr(n,), n,]
-//│ AST: Def(false, Var("gensym"), L(Let(false, n, Rcd(Var("a") = IntLit(0)), Lam(Tup(), Tup((N, App(Var("incr"), Tup((N, Var("n"))))), (N, Var("n")))))), true)
+//│ AST: Def(false, Var("gensym"), L(Let(false, n, Rcd(Var("a") = IntLit(0)), Lam(Tup(Nil), Tup((N, Fld(_, App(Var("incr"), Tup((N, Fld(_, Var("n"))) :: Nil)))) :: (N, Fld(_, Var("n"))) :: Nil)))), true)
 //│ // Query 1
 //│ globalThis.gensym = function gensym() {
 //│   return (((n) => () => [
@@ -35,7 +35,7 @@ def gensym = let n = { mut a = 0 } in fun () -> (incr n, n)
 gensym1 = let n = { mut a = 0 } in fun () -> (incr n, n)
 //│ Parsed: let gensym1 = let n = {mut a: 0} in () => [incr(n,), n,];
 //│ Desugared: def gensym1: let n = {mut a: 0} in () => [incr(n,), n,]
-//│ AST: Def(false, Var("gensym1"), L(Let(false, n, Rcd(Var("a") = IntLit(0)), Lam(Tup(), Tup((N, App(Var("incr"), Tup((N, Var("n"))))), (N, Var("n")))))), false)
+//│ AST: Def(false, Var("gensym1"), L(Let(false, n, Rcd(Var("a") = IntLit(0)), Lam(Tup(Nil), Tup((N, Fld(_, App(Var("incr"), Tup((N, Fld(_, Var("n"))) :: Nil)))) :: (N, Fld(_, Var("n"))) :: Nil)))), false)
 //│ // Query 1
 //│ globalThis.gensym1 = ((n) => () => [
 //│   incr(n),
diff --git a/shared/src/test/diff/mlscript/MultiArgs.mls b/shared/src/test/diff/mlscript/MultiArgs.mls
index 738d356769..a22d9095d2 100644
--- a/shared/src/test/diff/mlscript/MultiArgs.mls
+++ b/shared/src/test/diff/mlscript/MultiArgs.mls
@@ -75,9 +75,9 @@ f = fun (x, y) -> add x y
 f(1, 2)
 //│ Parsed: let f = (x, y,) => add(x,)(y,); f(1, 2,);
 //│ Desugared: def f: (x, y,) => add(x,)(y,)
-//│ AST: Def(false, Var("f"), L(Lam(Tup((N, Var("x")), (N, Var("y"))), App(App(Var("add"), Tup((N, Var("x")))), Tup((N, Var("y")))))), false)
+//│ AST: Def(false, Var("f"), L(Lam(Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil), App(App(Var("add"), Tup((N, Fld(_, Var("x"))) :: Nil)), Tup((N, Fld(_, Var("y"))) :: Nil)))), false)
 //│ Desugared: f(1, 2,)
-//│ AST: App(Var("f"), Tup((N, IntLit(1)), (N, IntLit(2))))
+//│ AST: App(Var("f"), Tup((N, Fld(_, IntLit(1))) :: (N, Fld(_, IntLit(2))) :: Nil))
 //│ f: (int, int,) -> int
 //│  = [Function: f]
 //│ res: int
@@ -119,9 +119,9 @@ f = fun ((x, y)) -> add x y
 f((1, 2))
 //│ Parsed: let f = ('(' [x, y,] ')',) => add(x,)(y,); f('(' [1, 2,] ')',);
 //│ Desugared: def f: ('(' [x, y,] ')',) => add(x,)(y,)
-//│ AST: Def(false, Var("f"), L(Lam(Tup((N, Bra(rcd = false, Tup((N, Var("x")), (N, Var("y")))))), App(App(Var("add"), Tup((N, Var("x")))), Tup((N, Var("y")))))), false)
+//│ AST: Def(false, Var("f"), L(Lam(Tup((N, Fld(_, Bra(rcd = false, Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil)))) :: Nil), App(App(Var("add"), Tup((N, Fld(_, Var("x"))) :: Nil)), Tup((N, Fld(_, Var("y"))) :: Nil)))), false)
 //│ Desugared: f('(' [1, 2,] ')',)
-//│ AST: App(Var("f"), Tup((N, Bra(rcd = false, Tup((N, IntLit(1)), (N, IntLit(2)))))))
+//│ AST: App(Var("f"), Tup((N, Fld(_, Bra(rcd = false, Tup((N, Fld(_, IntLit(1))) :: (N, Fld(_, IntLit(2))) :: Nil)))) :: Nil))
 //│ f: ((int, int,),) -> int
 //│  = [Function: f1]
 //│ res: int
diff --git a/shared/src/test/diff/mlscript/Ops.mls b/shared/src/test/diff/mlscript/Ops.mls
index f0ea6554d8..8a7682fc39 100644
--- a/shared/src/test/diff/mlscript/Ops.mls
+++ b/shared/src/test/diff/mlscript/Ops.mls
@@ -3,7 +3,7 @@
 2 + 2
 //│ Parsed: +(2,)(2,);
 //│ Desugared: +(2,)(2,)
-//│ AST: App(App(Var("+"), Tup((N, IntLit(2)))), Tup((N, IntLit(2))))
+//│ AST: App(App(Var("+"), Tup((N, Fld(_, IntLit(2))) :: Nil)), Tup((N, Fld(_, IntLit(2))) :: Nil))
 //│ res: int
 //│    = 4
 
@@ -11,7 +11,7 @@
 1 + 2 * 2 + 3
 //│ Parsed: +(+(1,)(*(2,)(2,),),)(3,);
 //│ Desugared: +(+(1,)(*(2,)(2,),),)(3,)
-//│ AST: App(App(Var("+"), Tup((N, App(App(Var("+"), Tup((N, IntLit(1)))), Tup((N, App(App(Var("*"), Tup((N, IntLit(2)))), Tup((N, IntLit(2)))))))))), Tup((N, IntLit(3))))
+//│ AST: App(App(Var("+"), Tup((N, Fld(_, App(App(Var("+"), Tup((N, Fld(_, IntLit(1))) :: Nil)), Tup((N, Fld(_, App(App(Var("*"), Tup((N, Fld(_, IntLit(2))) :: Nil)), Tup((N, Fld(_, IntLit(2))) :: Nil)))) :: Nil)))) :: Nil)), Tup((N, Fld(_, IntLit(3))) :: Nil))
 //│ res: int
 //│    = 8
 
@@ -20,7 +20,7 @@
 1 + 2 / 2 + 3
 //│ Parsed: +(+(1,)(/(2,)(2,),),)(3,);
 //│ Desugared: +(+(1,)(/(2,)(2,),),)(3,)
-//│ AST: App(App(Var("+"), Tup((N, App(App(Var("+"), Tup((N, IntLit(1)))), Tup((N, App(App(Var("/"), Tup((N, IntLit(2)))), Tup((N, IntLit(2)))))))))), Tup((N, IntLit(3))))
+//│ AST: App(App(Var("+"), Tup((N, Fld(_, App(App(Var("+"), Tup((N, Fld(_, IntLit(1))) :: Nil)), Tup((N, Fld(_, App(App(Var("/"), Tup((N, Fld(_, IntLit(2))) :: Nil)), Tup((N, Fld(_, IntLit(2))) :: Nil)))) :: Nil)))) :: Nil)), Tup((N, Fld(_, IntLit(3))) :: Nil))
 //│ ╔══[ERROR] Type mismatch in operator application:
 //│ ║  l.20: 	1 + 2 / 2 + 3
 //│ ║        	^^^^^^^^^
@@ -36,7 +36,7 @@
 1 |> 2 || 3
 //│ Parsed: ||(|>(1,)(2,),)(3,);
 //│ Desugared: ||(|>(1,)(2,),)(3,)
-//│ AST: App(App(Var("||"), Tup((N, App(App(Var("|>"), Tup((N, IntLit(1)))), Tup((N, IntLit(2))))))), Tup((N, IntLit(3))))
+//│ AST: App(App(Var("||"), Tup((N, Fld(_, App(App(Var("|>"), Tup((N, Fld(_, IntLit(1))) :: Nil)), Tup((N, Fld(_, IntLit(2))) :: Nil)))) :: Nil)), Tup((N, Fld(_, IntLit(3))) :: Nil))
 //│ ╔══[ERROR] identifier not found: |>
 //│ ║  l.36: 	1 |> 2 || 3
 //│ ╙──      	  ^^
@@ -54,7 +54,7 @@
 true || false && true || false
 //│ Parsed: ||(||(true,)(&&(false,)(true,),),)(false,);
 //│ Desugared: ||(||(true,)(&&(false,)(true,),),)(false,)
-//│ AST: App(App(Var("||"), Tup((N, App(App(Var("||"), Tup((N, Var("true")))), Tup((N, App(App(Var("&&"), Tup((N, Var("false")))), Tup((N, Var("true")))))))))), Tup((N, Var("false"))))
+//│ AST: App(App(Var("||"), Tup((N, Fld(_, App(App(Var("||"), Tup((N, Fld(_, Var("true"))) :: Nil)), Tup((N, Fld(_, App(App(Var("&&"), Tup((N, Fld(_, Var("false"))) :: Nil)), Tup((N, Fld(_, Var("true"))) :: Nil)))) :: Nil)))) :: Nil)), Tup((N, Fld(_, Var("false"))) :: Nil))
 //│ res: bool
 //│    = true
 
diff --git a/shared/src/test/diff/nu/AbstractClasses.mls b/shared/src/test/diff/nu/AbstractClasses.mls
index c00679e1b8..3aa16ec724 100644
--- a/shared/src/test/diff/nu/AbstractClasses.mls
+++ b/shared/src/test/diff/nu/AbstractClasses.mls
@@ -51,7 +51,7 @@ new Foo(1) { fun f = id }
 //│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ error
 //│ Code generation encountered an error:
-//│   cannot generate code for term Rft(App(NuNew(Var("Foo")), Tup((N, IntLit(1)))), TypingUnit(NuFunDef(None, f, N, Nil, L(Var("id")))))
+//│   cannot generate code for term Rft(App(NuNew(Var("Foo")), Tup((N, Fld(_, IntLit(1))) :: Nil)), TypingUnit(NuFunDef(None, f, N, Nil, L(Var("id")))))
 
 
 abstract class Bar extends Foo(1)
diff --git a/shared/src/test/diff/nu/LamPatterns.mls b/shared/src/test/diff/nu/LamPatterns.mls
index 98bb1511be..a396d13e67 100644
--- a/shared/src/test/diff/nu/LamPatterns.mls
+++ b/shared/src/test/diff/nu/LamPatterns.mls
@@ -14,7 +14,7 @@ Some(x) => x
 //│ ╙──     	           ^
 //│ error -> error
 //│ Code generation encountered an error:
-//│   term App(Var("Some"), Tup((N, Var("x")))) is not a valid pattern
+//│   term App(Var("Some"), Tup((N, Fld(_, Var("x"))) :: Nil)) is not a valid pattern
 
 :js
 // FIXME type
diff --git a/shared/src/test/diff/nu/OverrideShorthand.mls b/shared/src/test/diff/nu/OverrideShorthand.mls
index 8383f5a739..79da224fa8 100644
--- a/shared/src/test/diff/nu/OverrideShorthand.mls
+++ b/shared/src/test/diff/nu/OverrideShorthand.mls
@@ -10,7 +10,7 @@ class Pair(lhs: Int, rhs: Int)
 :e
 fun f(override Pair(x, y)) = x + y
 //│ |#fun| |f|(|#override| |Pair|(|x|,| |y|)|)| |#=| |x| |+| |y|
-//│ AST: TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Var("_$0"))), If(IfOpApp(Var("_$0"), Var("is"), IfThen(App(Var("Pair"), Tup((N, Var("x")), (N, Var("y")))), App(Var("+"), Tup((N, Var("x")), (N, Var("y")))), Some(App(Sel(Super(), f), Tup((N, Var("_$0"))))))))))
+//│ AST: TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Fld(_, Var("_$0"))) :: Nil), If(IfOpApp(Var("_$0"), Var("is"), IfThen(App(Var("Pair"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil)), App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil)), Some(App(Sel(Super(), f), Tup((N, Fld(_, Var("_$0"))) :: Nil))))))))
 //│ Parsed: fun f = (_$0,) => if _$0 is (Pair(x, y,)) then +(x, y,) else (super).f(_$0,);
 //│ ╔══[ERROR] identifier not found: super
 //│ ║  l.11: 	fun f(override Pair(x, y)) = x + y
@@ -46,7 +46,7 @@ fun f(override Pair(x, y), z) = x + y
 //│ ╙──      	                                    ^
 //│ fun f: (error, anything) -> Int
 //│ Code generation encountered an error:
-//│   term App(Var("Pair"), Tup((N, Var("x")), (N, Var("y")))) is not a valid pattern
+//│   term App(Var("Pair"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil)) is not a valid pattern
 
 
 // TODO
diff --git a/shared/src/test/diff/nu/RightAssocOps.mls b/shared/src/test/diff/nu/RightAssocOps.mls
index df59691588..a18e6893f8 100644
--- a/shared/src/test/diff/nu/RightAssocOps.mls
+++ b/shared/src/test/diff/nu/RightAssocOps.mls
@@ -30,7 +30,7 @@ fun (++) conc(xs, ys) = [xs, ys]
 :p
 1 +: "a" ++ "b" :+ 2
 //│ |1| |+:| |"a"| |++| |"b"| |:+| |2|
-//│ AST: TypingUnit(App(Var("+:"), Tup((N, IntLit(1)), (N, App(Var(":+"), Tup((N, App(Var("++"), Tup((N, StrLit(a)), (N, StrLit(b))))), (N, IntLit(2))))))))
+//│ AST: TypingUnit(App(Var("+:"), Tup((N, Fld(_, IntLit(1))) :: (N, Fld(_, App(Var(":+"), Tup((N, Fld(_, App(Var("++"), Tup((N, Fld(_, StrLit(a))) :: (N, Fld(_, StrLit(b))) :: Nil)))) :: (N, Fld(_, IntLit(2))) :: Nil)))) :: Nil)))
 //│ Parsed: +:(1, :+(++("a", "b",), 2,),);
 //│ [[Int], [["a", "b"], [Int]]]
 //│ res
@@ -39,7 +39,7 @@ fun (++) conc(xs, ys) = [xs, ys]
 :p
 1 +: "a" :+ 2 ++ "b"
 //│ |1| |+:| |"a"| |:+| |2| |++| |"b"|
-//│ AST: TypingUnit(App(Var("+:"), Tup((N, IntLit(1)), (N, App(Var("++"), Tup((N, App(Var(":+"), Tup((N, StrLit(a)), (N, IntLit(2))))), (N, StrLit(b))))))))
+//│ AST: TypingUnit(App(Var("+:"), Tup((N, Fld(_, IntLit(1))) :: (N, Fld(_, App(Var("++"), Tup((N, Fld(_, App(Var(":+"), Tup((N, Fld(_, StrLit(a))) :: (N, Fld(_, IntLit(2))) :: Nil)))) :: (N, Fld(_, StrLit(b))) :: Nil)))) :: Nil)))
 //│ Parsed: +:(1, ++(:+("a", 2,), "b",),);
 //│ [[Int], [["a", [Int]], "b"]]
 //│ res
@@ -49,7 +49,7 @@ fun (++) conc(xs, ys) = [xs, ys]
 :e
 1 +: "a" ++ 2 +: "b"
 //│ |1| |+:| |"a"| |++| |2| |+:| |"b"|
-//│ AST: TypingUnit(App(Var("+:"), Tup((N, IntLit(1)), (N, App(Var("+:"), Tup((N, App(Var("++"), Tup((N, StrLit(a)), (N, IntLit(2))))), (N, StrLit(b))))))))
+//│ AST: TypingUnit(App(Var("+:"), Tup((N, Fld(_, IntLit(1))) :: (N, Fld(_, App(Var("+:"), Tup((N, Fld(_, App(Var("++"), Tup((N, Fld(_, StrLit(a))) :: (N, Fld(_, IntLit(2))) :: Nil)))) :: (N, Fld(_, StrLit(b))) :: Nil)))) :: Nil)))
 //│ Parsed: +:(1, +:(++("a", 2,), "b",),);
 //│ ╔══[ERROR] Type mismatch in operator application:
 //│ ║  l.50: 	1 +: "a" ++ 2 +: "b"
diff --git a/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls b/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls
index 7c58261c5f..e7da1db222 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls
@@ -118,7 +118,16 @@ fun fromList(l) =
       Cons(x, xs') then fromList'(insert(t, x), xs')
       Nil then Empty
   fromList'(Empty, l)
-//│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing
+//│ ╔══[ERROR] Cannot use `val` or `fun` in local block; use `let` instead.
+//│ ║  l.116: 	  fun fromList'(t, xs) =
+//│ ║         	  ^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.117: 	    if xs is
+//│ ║         	^^^^^^^^^^^^
+//│ ║  l.118: 	      Cons(x, xs') then fromList'(insert(t, x), xs')
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.119: 	      Nil then Empty
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^
+//│ fun fromList: (Cons[Num] | Nil) -> Empty
 
 fun fromList(t, xs) =
   if xs is
diff --git a/shared/src/test/diff/pretyper/ucs/examples/ListFold.mls b/shared/src/test/diff/pretyper/ucs/examples/ListFold.mls
new file mode 100644
index 0000000000..bde6e1b467
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/examples/ListFold.mls
@@ -0,0 +1,208 @@
+:PreTyper
+
+fun (|>) pipe(x, f) = f(x)
+fun (++) strcat(s1, s2) = concat(s1)(s2)
+//│ fun (|>) pipe: forall 'a 'b. ('a, 'a -> 'b) -> 'b
+//│ fun (++) strcat: (Str, Str) -> Str
+
+abstract class List[out T]: (Cons[T] | Nil)
+class Cons[out T](val head: T, val tail: List[T]) extends List[T]
+module Nil extends List[nothing]
+//│ abstract class List[T]: Cons[T] | Nil
+//│ class Cons[T](head: T, tail: List[T]) extends List
+//│ module Nil extends List
+
+fun (::) cons(head, tail) = Cons(head, tail)
+//│ fun (::) cons: forall 'T. ('T, List['T]) -> Cons['T]
+
+let oneTwoThree = 1 :: 2 :: 3 :: Nil
+//│ let oneTwoThree: Cons[1 | 2 | 3]
+//│ oneTwoThree
+//│             = Cons {}
+
+// Note that JavaScript doesn't have tail call optimization. Therefore, this
+// implementation is still inefficient in practice.
+fun join(sep) =
+  let aux(acc, xs) =
+    if xs is
+      Nil then acc
+      Cons(x, xs') then aux(acc ++ sep ++ toString(x), xs')
+  (xs) =>
+    if xs is
+      Cons(x, xs') then aux(toString(x), xs')
+      Nil then ""
+//│ fun join: Str -> (Cons[anything] | Nil) -> Str
+
+join(", ")(1 :: 2 :: 3 :: Nil)
+(1 :: 2 :: 3 :: Nil) |> join(", ")
+//│ Str
+//│ res
+//│     = '1, 2, 3'
+//│ res
+//│     = '1, 2, 3'
+
+fun showList(xs) = "[" ++ join(", ")(xs) ++ "]"
+//│ fun showList: (Cons[anything] | Nil) -> Str
+
+fun (:::) appendAll(xs, ys) =
+  if xs is
+    Nil then ys
+    Cons(x, xs') then x :: (xs' ::: ys)
+//│ fun (:::) appendAll: forall 'T 'a. (Cons['T] | Nil, List['T] & 'a) -> (Cons['T] | 'a)
+
+((1 :: 2 :: 3 :: Nil) ::: (4 :: 5 :: 6 :: Nil)) |> showList
+//│ Str
+//│ res
+//│     = '[1, 2, 3, 4, 5, 6]'
+
+fun reverse(xs) =
+  let aux(acc, xs) =
+    if xs is
+      Nil then acc
+      Cons(x, xs') then aux(x :: acc, xs')
+  aux(Nil, xs)
+//│ fun reverse: (Cons[anything] | Nil) -> (Cons[nothing] | Nil)
+
+(1 :: 2 :: 3 :: Nil) |> showList
+reverse(1 :: 2 :: 3 :: Nil) |> showList
+//│ Str
+//│ res
+//│     = '[1, 2, 3]'
+//│ res
+//│     = '[3, 2, 1]'
+
+//   __       _     _ _          __ _
+//  / _| ___ | | __| | |    ___ / _| |_
+// | |_ / _ \| |/ _` | |   / _ \ |_| __|
+// |  _| (_) | | (_| | |__|  __/  _| |_
+// |_|  \___/|_|\__,_|_____\___|_|  \__|
+//
+
+fun foldLeft(f)(z) =
+  let aux(acc, xs) =
+    if xs is
+      Nil then acc
+      Cons(x, xs') then aux(f(acc, x), xs')
+  (xs) => aux(z, xs)
+//│ fun foldLeft: forall 'a 'b 'c. (('a, 'b) -> ('a & 'c)) -> ('a & 'c) -> (Cons['b] | Nil) -> 'c
+
+let sum = foldLeft((acc, x) => acc + x)(0)
+sum(Nil)
+sum(1 :: 2 :: 3 :: Nil)
+//│ let sum: (Cons[Int] | Nil) -> Int
+//│ Int
+//│ sum
+//│     = [Function (anonymous)]
+//│ res
+//│     = 0
+//│ res
+//│     = 6
+
+let product = foldLeft((acc, x) => acc * x)(1)
+product(Nil)
+product(1 :: 2 :: 3 :: Nil)
+//│ let product: (Cons[Int] | Nil) -> Int
+//│ Int
+//│ product
+//│         = [Function (anonymous)]
+//│ res
+//│     = 1
+//│ res
+//│     = 6
+
+let length = foldLeft((acc, _) => acc + 1)(0)
+length(Nil)
+length(1 :: 2 :: 3 :: Nil)
+//│ let length: (Cons[anything] | Nil) -> Int
+//│ Int
+//│ length
+//│        = [Function (anonymous)]
+//│ res
+//│     = 0
+//│ res
+//│     = 3
+
+let reverse' = foldLeft((acc, x) => x :: acc)(Nil)
+reverse'(Nil)
+reverse'(1 :: 2 :: 3 :: Nil) |> showList
+//│ let reverse': (Cons['T] | Nil) -> (Cons[1 | 2 | 3 | 'T] | Nil)
+//│ Str
+//│ reverse'
+//│          = [Function (anonymous)]
+//│ res
+//│     = Nil { class: [class Nil extends List] }
+//│ res
+//│     = '[3, 2, 1]'
+
+
+//   __       _     _ ____  _       _     _
+//  / _| ___ | | __| |  _ \(_) __ _| |__ | |_
+// | |_ / _ \| |/ _` | |_) | |/ _` | '_ \| __|
+// |  _| (_) | | (_| |  _ <| | (_| | | | | |_
+// |_|  \___/|_|\__,_|_| \_\_|\__, |_| |_|\__|
+//                            |___/
+
+fun foldRight(f)(z) =
+  let aux(acc, xs) =
+    if xs is
+      Nil then acc
+      Cons(x, xs') then f(x, aux(acc, xs'))
+  (xs) => aux(z, xs)
+//│ fun foldRight: forall 'a 'b. (('a, 'b) -> 'b) -> 'b -> (Cons['a] | Nil) -> 'b
+
+let double = foldRight((x, acc) => x :: x :: acc)(Nil)
+double(Nil) |> showList
+double(1 :: 2 :: 3 :: Nil) |> showList
+//│ let double: (Cons[anything] | Nil) -> (Cons[1 | 2 | 3] | Nil)
+//│ Str
+//│ double
+//│        = [Function (anonymous)]
+//│ res
+//│     = '[]'
+//│ res
+//│     = '[1, 1, 2, 2, 3, 3]'
+
+let flatten = foldRight((xs, acc) => xs ::: acc)(Nil)
+flatten(Nil) |> showList
+flatten(oneTwoThree :: oneTwoThree :: oneTwoThree :: Nil) |> showList
+//│ let flatten: (Cons[Cons['T] | Nil] | Nil) -> (Cons[1 | 2 | 3 | 'T] | Nil)
+//│ Str
+//│ flatten
+//│         = [Function (anonymous)]
+//│ res
+//│     = '[]'
+//│ res
+//│     = '[1, 2, 3, 1, 2, 3, 1, 2, 3]'
+
+fun id(x) = x
+//│ fun id: forall 'a. 'a -> 'a
+
+fun foldLeft'(f: ('A, 'B) -> 'A)(z: 'A) =
+  let g(x, y)(z) = y(f(z, x))
+  (xs) => foldRight(g)(id)(xs)(z)
+//│ fun foldLeft': forall 'A 'B. (f: ('A, 'B) -> 'A) -> (z: 'A) -> (Cons['B] | Nil) -> 'A
+
+let minus = foldLeft'((acc, x) => acc - x)(0)
+minus(Nil)
+minus(1 :: 2 :: 3 :: Nil)
+//│ let minus: (Cons[Int] | Nil) -> Int
+//│ Int
+//│ minus
+//│       = [Function (anonymous)]
+//│ res
+//│     = 0
+//│ res
+//│     = -6
+
+let reverse'' = foldLeft'((acc, x) => x :: acc)(Nil)
+reverse(Nil)
+reverse(1 :: 2 :: 3 :: Nil) |> showList
+//│ let reverse'': (Cons[anything] | Nil) -> (Cons[nothing] | Nil)
+//│ Str
+//│ reverse''
+//│           = [Function (anonymous)]
+//│ res
+//│     = Nil { class: [class Nil extends List] }
+//│ res
+//│     = '[3, 2, 1]'
+
diff --git a/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls b/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls
new file mode 100644
index 0000000000..a42d3237ab
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls
@@ -0,0 +1,127 @@
+:PreTyper
+
+fun (|>) pipe(x, f) = f(x)
+fun (++) strcat(s1, s2) = concat(s1)(s2)
+//│ fun (|>) pipe: forall 'a 'b. ('a, 'a -> 'b) -> 'b
+//│ fun (++) strcat: (Str, Str) -> Str
+
+abstract class List[out T]: (Cons[T] | Nil)
+class Cons[out T](val head: T, val tail: List[T]) extends List[T]
+module Nil extends List[nothing]
+fun (::) cons(head, tail) = Cons(head, tail)
+fun (:::) appendAll(xs: List['A], ys: List['A]): List['A] =
+  if xs is
+    Nil then ys
+    Cons(x, xs') then x :: (xs' ::: ys)
+fun (:+) append(xs, x): List['A] = xs ::: (x :: Nil)
+fun reverse(xs) =
+  let aux(acc, xs) =
+    if xs is
+      Nil then acc
+      Cons(x, xs') then aux(x :: acc, xs')
+  aux(Nil, xs)
+fun join(sep) =
+  let aux(acc, xs) =
+    if xs is
+      Nil then acc
+      Cons(x, xs') then aux(acc ++ sep ++ toString(x), xs')
+  (xs) =>
+    if xs is
+      Cons(x, xs') then aux(toString(x), xs')
+      Nil then ""
+fun showList(xs) = "[" ++ join(", ")(xs) ++ "]"
+fun foldLeft(f)(z) =
+  let aux(acc, xs) =
+    if xs is
+      Nil then acc
+      Cons(x, xs') then aux(f(acc, x), xs')
+  (xs) => aux(z, xs)
+fun map(f, xs) =
+  if xs is
+    Nil then Nil
+    Cons(x, xs') then f(x) :: map(f, xs')
+fun showListList(xs) = "[" ++ join(", ")(map(showList, xs)) ++ "]"
+//│ abstract class List[T]: Cons[T] | Nil
+//│ class Cons[T](head: T, tail: List[T]) extends List
+//│ module Nil extends List
+//│ fun (::) cons: forall 'T. ('T, List['T]) -> Cons['T]
+//│ fun (:::) appendAll: forall 'T0. (xs: List['T0], ys: List['T0]) -> List['T0]
+//│ fun (:+) append: forall 'T1. (List['T1], 'T1) -> List['T1]
+//│ fun reverse: (Cons[anything] | Nil) -> (Cons[nothing] | Nil)
+//│ fun join: Str -> (Cons[anything] | Nil) -> Str
+//│ fun showList: (Cons[anything] | Nil) -> Str
+//│ fun foldLeft: forall 'a 'b 'c. (('a, 'b) -> ('a & 'c)) -> ('a & 'c) -> (Cons['b] | Nil) -> 'c
+//│ fun map: forall 'd 'T2. ('d -> 'T2, Cons['d] | Nil) -> (Cons['T2] | Nil)
+//│ fun showListList: (Cons[Cons[anything] | Nil] | Nil) -> Str
+
+fun insertAllPositions(z) =
+  let aux(prev, acc, xs) =
+    if xs is
+      Nil then ((prev :+ z) :: acc) |> reverse
+      Cons(head, tail) then
+        let nu = ((prev :+ z) ::: xs)
+        aux(prev :+ head, nu :: acc, tail)
+  xs => aux(Nil, Nil, xs)
+//│ fun insertAllPositions: forall 'a. 'a -> (forall 'A. (Cons['A] | Nil) -> (Cons[List['A | 'a]] & {Cons#T <: List['A | 'a]} | Nil))
+
+insertAllPositions(0)(1 :: 2 :: 3 :: Nil) |> showListList
+//│ Str
+//│ res
+//│     = '[[0, 1, 2, 3], [1, 0, 2, 3], [1, 2, 0, 3], [1, 2, 3, 0]]'
+
+fun permutations(xs) =
+  if xs is
+    Nil then Nil
+    Cons(x, Nil) then (x :: Nil) :: Nil
+    Cons(x, xs') then foldLeft((acc, ys) => acc ::: insertAllPositions(x)(ys))(Nil)(permutations(xs'))
+//│ fun permutations: forall 'T 'A. (Cons['T] | Nil) -> (Cons[Cons['T]] | List[List['T & 'A]] | Nil)
+//│   where
+//│     'T <: 'A
+//│     'A := 'T
+
+permutations(Nil) |> showListList
+permutations(1 :: Nil) |> showListList
+permutations(1 :: 2 :: Nil) |> showListList
+permutations(1 :: 2 :: 3 :: Nil) |> showListList
+//│ Str
+//│ res
+//│     = '[]'
+//│ res
+//│     = '[[1]]'
+//│ res
+//│     = '[[1, 2], [2, 1]]'
+//│ res
+//│     = '[[1, 2, 3], [2, 1, 3], [2, 3, 1], [1, 3, 2], [3, 1, 2], [3, 2, 1]]'
+
+fun filterNot(f, xs) =
+  if xs is
+    Nil then Nil
+    Cons(x, xs') then
+      if f(x) then filterNot(f, xs')
+      else x :: filterNot(f, xs')
+//│ fun filterNot: forall 'T. ('T -> Bool, Cons['T] | Nil) -> (Cons['T] | Nil)
+
+fun permutations'(xs) =
+  if xs is
+    Nil then Nil
+    Cons(x, Nil) then (x :: Nil) :: Nil
+    else
+      let f(acc, x) = acc ::: map((ys) => x :: ys, permutations'(filterNot((y) => x === y, xs)))
+      foldLeft(f)(Nil)(xs)
+//│ fun permutations': forall 'T. (Cons['T] | Nil) -> (Cons[Cons['T]] | List[Cons['T]] | Nil)
+//│   where
+//│     'T <: Eql['T]
+
+permutations'(Nil) |> showListList
+permutations'(1 :: Nil) |> showListList
+permutations'(1 :: 2 :: Nil) |> showListList
+permutations'(1 :: 2 :: 3 :: Nil) |> showListList
+//│ Str
+//│ res
+//│     = '[]'
+//│ res
+//│     = '[[1]]'
+//│ res
+//│     = '[[1, 2], [2, 1]]'
+//│ res
+//│     = '[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]'
diff --git a/shared/src/test/diff/ucs/LeadingAnd.mls b/shared/src/test/diff/ucs/LeadingAnd.mls
index f1e65d9f15..dea9201a20 100644
--- a/shared/src/test/diff/ucs/LeadingAnd.mls
+++ b/shared/src/test/diff/ucs/LeadingAnd.mls
@@ -23,7 +23,7 @@ fun f(a, b) = if a is Some(av)
     and b is Some(bv)
     then av + bv
 //│ |#fun| |f|(|a|,| |b|)| |#=| |#if| |a| |is| |Some|(|av|)|→|and| |b| |is| |Some|(|bv|)|↵|#then| |av| |+| |bv|←|
-//│ AST: TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Var("a")), (N, Var("b"))), If(IfOpApp(Var("a"), Var("is"), I; f; O; p; s; A; p; p; (; A; p; p; (; V; a; r; (; "; S; o; m; e; "; ); ,;  ; T; u; p; (; (; N; ,;  ; V; a; r; (; "; a; v; "; ); ); ); ); ,;  ; <; i; t; e; r; a; t; o; r; >, None)))))
+//│ AST: TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Fld(_, Var("a"))) :: (N, Fld(_, Var("b"))) :: Nil), If(IfOpApp(Var("a"), Var("is"), I; f; O; p; s; A; p; p; (; A; p; p; (; V; a; r; (; "; S; o; m; e; "; ); ,;  ; T; u; p; (; (; N; ,;  ; F; l; d; (; _; ,;  ; V; a; r; (; "; a; v; "; ); ); );  ; :; :;  ; N; i; l; ); ); ,;  ; <; i; t; e; r; a; t; o; r; >, None)))))
 //│ Parsed: fun f = (a, b,) => if a is Some(av,) ‹· and (is(b, Some(bv,),)) then +(av, bv,)›;
 //│ fun f: (Some[Int], Some[Int]) -> Int
 
@@ -34,7 +34,7 @@ fun f(a, b) = if a is
     and b is Some(bv)
     then av + bv
 //│ |#fun| |f|(|a|,| |b|)| |#=| |#if| |a| |is|→|Some|(|av|)|→|and| |b| |is| |Some|(|bv|)|↵|#then| |av| |+| |bv|←|←|
-//│ AST: TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Var("a")), (N, Var("b"))), If(IfOpApp(Var("a"), Var("is"), IfBlock(Ls(I; f; O; p; s; A; p; p; (; A; p; p; (; V; a; r; (; "; S; o; m; e; "; ); ,;  ; T; u; p; (; (; N; ,;  ; V; a; r; (; "; a; v; "; ); ); ); ); ,;  ; <; i; t; e; r; a; t; o; r; >)), None)))))
+//│ AST: TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Fld(_, Var("a"))) :: (N, Fld(_, Var("b"))) :: Nil), If(IfOpApp(Var("a"), Var("is"), IfBlock(Ls(I; f; O; p; s; A; p; p; (; A; p; p; (; V; a; r; (; "; S; o; m; e; "; ); ,;  ; T; u; p; (; (; N; ,;  ; F; l; d; (; _; ,;  ; V; a; r; (; "; a; v; "; ); ); );  ; :; :;  ; N; i; l; ); ); ,;  ; <; i; t; e; r; a; t; o; r; >)), None)))))
 //│ Parsed: fun f = (a, b,) => if a is ‹Some(av,) ‹· and (is(b, Some(bv,),)) then +(av, bv,)››;
 //│ ╔══[ERROR] Illegal pattern `and`
 //│ ║  l.34: 	    and b is Some(bv)
diff --git a/shared/src/test/diff/ucs/SplitOps.mls b/shared/src/test/diff/ucs/SplitOps.mls
index 70e9e05369..b0160174d8 100644
--- a/shared/src/test/diff/ucs/SplitOps.mls
+++ b/shared/src/test/diff/ucs/SplitOps.mls
@@ -93,10 +93,10 @@ fun f(a, b, c) =
   if a
     == 0 and b is B() and c is C() then 0
 //│ |#fun| |f|(|a|,| |b|,| |c|)| |#=|→|#if| |a|→|==| |0| |and| |b| |is| |B|(||)| |and| |c| |is| |C|(||)| |#then| |0|←|←|
-//│ AST: TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Var("a")), (N, Var("b")), (N, Var("c"))), Blk(If(I; f; O; p; s; A; p; p; (; V; a; r; (; "; a; "; ); ,;  ; <; i; t; e; r; a; t; o; r; >, None))))))
+//│ AST: TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Fld(_, Var("a"))) :: (N, Fld(_, Var("b"))) :: (N, Fld(_, Var("c"))) :: Nil), Blk(If(I; f; O; p; s; A; p; p; (; V; a; r; (; "; a; "; ); ,;  ; <; i; t; e; r; a; t; o; r; >, None))))))
 //│ Parsed: fun f = (a, b, c,) => {if a ‹· == (and(and(0,)(is(b,)(B(),),),)(is(c,)(C(),),)) then 0›};
 //│ Desugared: rec def f: (a, b, c,) => {if a ‹· == (and(and(0,)(is(b,)(B(),),),)(is(c,)(C(),),)) then 0›}
-//│ AST: Def(true, Var("f"), L(Lam(Tup((N, Var("a")), (N, Var("b")), (N, Var("c"))), Blk(If(I; f; O; p; s; A; p; p; (; V; a; r; (; "; a; "; ); ,;  ; <; i; t; e; r; a; t; o; r; >, None)))), true)
+//│ AST: Def(true, Var("f"), L(Lam(Tup((N, Fld(_, Var("a"))) :: (N, Fld(_, Var("b"))) :: (N, Fld(_, Var("c"))) :: Nil), Blk(If(I; f; O; p; s; A; p; p; (; V; a; r; (; "; a; "; ); ,;  ; <; i; t; e; r; a; t; o; r; >, None)))), true)
 //│ ╔══[ERROR] The case when this is false is not handled: ==(a,)(0,)
 //│ ║  l.93: 	  if a
 //│ ║        	     ^
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index 3dac91445d..99898c7461 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -524,7 +524,7 @@ class DiffTests
               val vars: Map[Str, typer.SimpleType] = Map.empty
               val rootTypingUnit = TypingUnit(p.tops)
               if (usePreTyper) {
-                val preTyper = new PreTyper(mode.dbgPreTyper, newDefs) {
+                val preTyper = new PreTyper(mode.dbgPreTyper) {
                   override protected def raise(diagnostics: Ls[Diagnostic]): Unit = report(diagnostics)
                   override def emitString(str: String): Unit = output(str)
                 }

From 3ab610e4d6a3eeb244813e2362fcf638a00c1b0e Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 23 Dec 2023 12:57:07 +0800
Subject: [PATCH 020/147] Update test file changes in other sub-projects to
 make CI happy

---
 compiler/shared/test/diff/LambLift.mls   |  8 ++--
 compiler/shared/test/diff/LiftType.mls   | 10 ++---
 compiler/shared/test/diff/Lifter.mls     | 30 ++++++-------
 compiler/shared/test/diff/LifterBlks.mls | 36 ++++++++--------
 compiler/shared/test/diff/mono.mls       | 54 ++++++++++++------------
 5 files changed, 69 insertions(+), 69 deletions(-)

diff --git a/compiler/shared/test/diff/LambLift.mls b/compiler/shared/test/diff/LambLift.mls
index c42974bf49..0a85395c86 100644
--- a/compiler/shared/test/diff/LambLift.mls
+++ b/compiler/shared/test/diff/LambLift.mls
@@ -10,7 +10,7 @@ fun foo() =
   local(1)
 foo()
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, foo, None, [], Lam(Tup(), Blk(...))), App(Var(foo), Tup()))
+//│ TypingUnit(NuFunDef(None, foo, N, Nil, L(Lam(Tup(Nil), Blk(NuFunDef(Some(false), local, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(NuTypeDef(Cls, TypeName("Foo"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, bar, N, Nil, L(App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, App(Var("foo"), Tup(Nil)))) :: Nil)))))), Sel(Bra(rcd = false, App(NuNew(Var("Foo")), Tup(Nil))), bar))))), App(Var("local"), Tup((N, Fld(_, IntLit(1))) :: Nil)))))), App(Var("foo"), Tup(Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Foo$1([x,]) {fun bar = () => +((this).x, foo$1(),)}
@@ -28,7 +28,7 @@ fun foo(f) =
   f(1)
 foo(x => x+1)
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, foo, None, [], Lam(Tup(_: Var(f)), Blk(...))), App(Var(foo), Tup(_: Lam(Tup(_: Var(x)), App(Var(+), Tup(_: Var(x), _: IntLit(1)))))))
+//│ TypingUnit(NuFunDef(None, foo, N, Nil, L(Lam(Tup((N, Fld(_, Var("f"))) :: Nil), Blk(App(Var("f"), Tup((N, Fld(_, IntLit(1))) :: Nil)))))), App(Var("foo"), Tup((N, Fld(_, Lam(Tup((N, Fld(_, Var("x"))) :: Nil), App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(1))) :: Nil))))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Lambda1$2$1([]) {fun apply = (x,) => +(x, 1,)}
@@ -46,7 +46,7 @@ fun foo(x) =
   bar(y => y+x)
 foo(1)
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, foo, None, [], Lam(Tup(_: Var(x)), Blk(...))), App(Var(foo), Tup(_: IntLit(1))))
+//│ TypingUnit(NuFunDef(None, foo, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(NuFunDef(Some(false), bar, N, Nil, L(Lam(Tup((N, Fld(_, Var("f"))) :: Nil), Blk(App(Var("f"), Tup((N, Fld(_, Var("x"))) :: Nil)))))), App(Var("bar"), Tup((N, Fld(_, Lam(Tup((N, Fld(_, Var("y"))) :: Nil), App(Var("+"), Tup((N, Fld(_, Var("y"))) :: (N, Fld(_, Var("x"))) :: Nil))))) :: Nil)))))), App(Var("foo"), Tup((N, Fld(_, IntLit(1))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Lambda1$3$1([x,]) {fun apply = (y,) => +(y, (this).x,)}
@@ -68,7 +68,7 @@ fun app(a) =
   foo(z => a.bar(z))
 app(new A(1))
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, foo, None, [], Lam(Tup(_: Var(f)), Blk(...))), NuTypeDef(class, A, (), Tup(y: Var(Int)), (), None, None, TypingUnit(NuFunDef(None, bar, None, [], Lam(Tup(_: Var(z)), App(Var(+), Tup(_: Var(y), _: Var(z))))))), NuFunDef(None, app, None, [], Lam(Tup(_: Var(a)), Blk(...))), App(Var(app), Tup(_: App(NuNew(Var(A)), Tup(_: IntLit(1))))))
+//│ TypingUnit(NuFunDef(None, foo, N, Nil, L(Lam(Tup((N, Fld(_, Var("f"))) :: Nil), Blk(App(Var("f"), Tup((N, Fld(_, IntLit(1))) :: Nil)))))), NuTypeDef(Cls, TypeName("A"), Ls(), S(Tup((S(y), Fld(_, Var("Int"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, bar, N, Nil, L(Lam(Tup((N, Fld(_, Var("z"))) :: Nil), App(Var("+"), Tup((N, Fld(_, Var("y"))) :: (N, Fld(_, Var("z"))) :: Nil))))))), NuFunDef(None, app, N, Nil, L(Lam(Tup((N, Fld(_, Var("a"))) :: Nil), Blk(App(Var("foo"), Tup((N, Fld(_, Lam(Tup((N, Fld(_, Var("z"))) :: Nil), App(Sel(Var("a"), bar), Tup((N, Fld(_, Var("z"))) :: Nil))))) :: Nil)))))), App(Var("app"), Tup((N, Fld(_, App(NuNew(Var("A")), Tup((N, Fld(_, IntLit(1))) :: Nil)))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1([y: Int,]) {fun bar = (z,) => +((this).y, z,)}
diff --git a/compiler/shared/test/diff/LiftType.mls b/compiler/shared/test/diff/LiftType.mls
index 773e24b1e9..dfcd4ee678 100644
--- a/compiler/shared/test/diff/LiftType.mls
+++ b/compiler/shared/test/diff/LiftType.mls
@@ -8,7 +8,7 @@ class CTX{
 //│ |#class| |CTX|{|→|#class| |A| |{||}|↵|#fun| |foo|(|f|#:| |A| |#=>| |A|)|#:| |(|A| |#=>| |A|)| |#=>| |A| |#=| |f|(|#new| |A|)|←|↵|}|
 //│ Parsed: {class CTX {class A {}; fun foo = (f: (A,) => A,) => f(new A,) : (A -> A) -> A}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, CTX, (), Tup(), (), None, None, TypingUnit(NuTypeDef(class, A, (), Tup(), (), None, None, TypingUnit()), NuFunDef(None, foo, None, [], Lam(Tup(f: Lam(Tup(_: Var(A)), Var(A))), Asc(App(Var(f), Tup(_: NuNew(Var(A)))), Function(Tuple(List((None,Field(None,Function(Tuple(List((None,Field(None,TypeName(A))))),TypeName(A)))))),TypeName(A))))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("CTX"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), N, N, N, Ls(), N, N, TypingUnit()), NuFunDef(None, foo, N, Nil, L(Lam(Tup((S(f), Fld(_, Lam(Tup((N, Fld(_, Var("A"))) :: Nil), Var("A")))) :: Nil), Asc(App(Var("f"), Tup((N, Fld(_, NuNew(Var("A")))) :: Nil)), Function(Tuple(List((None,Field(None,Function(Tuple(List((None,Field(None,TypeName(A))))),TypeName(A)))))),TypeName(A)))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class CTX$1_A$2([par$CTX$1,]) {}
@@ -26,7 +26,7 @@ class CTX(x, y){
 //│ |#class| |CTX|(|x|,| |y|)|{|→|#class| |A|{| |#fun| |foo| |#=| |x|}|↵|#class| |B|#:| |A| |{| |#fun| |foo| |#=| |y|}|↵|#fun| |foo|(|any|#:| |[|A|,| |B|]|)|#:| |[|B|,| |A|]| |#=| |[|any|._2|,| |any|._1|]|←|↵|}|
 //│ Parsed: {class CTX(x, y,) {class A {fun foo = x}; class B: A {fun foo = y}; fun foo = (any: [A, B,],) => [(any)._2, (any)._1,] : [B, A]}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, CTX, (), Tup(_: Var(x), _: Var(y)), (), None, None, TypingUnit(NuTypeDef(class, A, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, foo, None, [], Var(x)))), NuTypeDef(class, B, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, foo, None, [], Var(y)))), NuFunDef(None, foo, None, [], Lam(Tup(any: Tup(_: Var(A), _: Var(B))), Asc(Tup(_: Sel(Var(any), _2), _: Sel(Var(any), _1)), Tuple(List((None,Field(None,TypeName(B))), (None,Field(None,TypeName(A)))))))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("CTX"), Ls(), S(Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(Var("x"))))), NuTypeDef(Cls, TypeName("B"), Ls(), N, N, S(TypeName("A")), Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(Var("y"))))), NuFunDef(None, foo, N, Nil, L(Lam(Tup((S(any), Fld(_, Tup((N, Fld(_, Var("A"))) :: (N, Fld(_, Var("B"))) :: Nil))) :: Nil), Asc(Tup((N, Fld(_, Sel(Var("any"), _2))) :: (N, Fld(_, Sel(Var("any"), _1))) :: Nil), Tuple(List((None,Field(None,TypeName(B))), (None,Field(None,TypeName(A))))))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class CTX$1_A$2([par$CTX$1,]) {fun foo = () => ((this).par$CTX$1).x}
@@ -45,7 +45,7 @@ class CTX(x, y){
 //│ |#class| |CTX|(|x|,| |y|)|{|→|#class| |A|{| |#fun| |foo| |#=| |x|}|↵|#class| |B|#:| |A| |{| |#fun| |foo| |#=| |y|}|↵|#fun| |foo|(|any|#:| |{|p1|#:| |A|,| |p2|#:| |B|}|)|#:| |[|B|,| |A|]| |#=| |[|any|.p2|,| |any|.p1|]|←|↵|}|
 //│ Parsed: {class CTX(x, y,) {class A {fun foo = x}; class B: A {fun foo = y}; fun foo = (any: '{' {p1: A, p2: B} '}',) => [(any).p2, (any).p1,] : [B, A]}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, CTX, (), Tup(_: Var(x), _: Var(y)), (), None, None, TypingUnit(NuTypeDef(class, A, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, foo, None, [], Var(x)))), NuTypeDef(class, B, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, foo, None, [], Var(y)))), NuFunDef(None, foo, None, [], Lam(Tup(any: Bra(rcd = true, Rcd(Var(p1) = Var(A), Var(p2) = Var(B)))), Asc(Tup(_: Sel(Var(any), p2), _: Sel(Var(any), p1)), Tuple(List((None,Field(None,TypeName(B))), (None,Field(None,TypeName(A)))))))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("CTX"), Ls(), S(Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(Var("x"))))), NuTypeDef(Cls, TypeName("B"), Ls(), N, N, S(TypeName("A")), Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(Var("y"))))), NuFunDef(None, foo, N, Nil, L(Lam(Tup((S(any), Fld(_, Bra(rcd = true, Rcd(Var("p1") = Var("A"), Var("p2") = Var("B"))))) :: Nil), Asc(Tup((N, Fld(_, Sel(Var("any"), p2))) :: (N, Fld(_, Sel(Var("any"), p1))) :: Nil), Tuple(List((None,Field(None,TypeName(B))), (None,Field(None,TypeName(A))))))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class CTX$1_A$2([par$CTX$1,]) {fun foo = () => ((this).par$CTX$1).x}
@@ -64,7 +64,7 @@ class CTX(x, y){
 //│ |#class| |CTX|(|x|,| |y|)|{|→|#class| |A|{| |#fun| |foo| |#=| |x|}|↵|#class| |B|‹|T|›| |{| |#fun| |foo| |#=| |y|}|↵|#fun| |foo|(|any|#:| |[|A|,| |B|‹|A|›|]|)|#:| |[|[|B|‹|A|›|,| |A|]|,| |A|]| |#=| |[|any|,| |any|._1|]|←|↵|}|
 //│ Parsed: {class CTX(x, y,) {class A {fun foo = x}; class B‹T› {fun foo = y}; fun foo = (any: [A, B‹A›,],) => [any, (any)._1,] : [[B[A], A], A]}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, CTX, (), Tup(_: Var(x), _: Var(y)), (), None, None, TypingUnit(NuTypeDef(class, A, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, foo, None, [], Var(x)))), NuTypeDef(class, B, ((None,TypeName(T))), Tup(), (), None, None, TypingUnit(NuFunDef(None, foo, None, [], Var(y)))), NuFunDef(None, foo, None, [], Lam(Tup(any: Tup(_: Var(A), _: TyApp(Var(B), List(TypeName(A))))), Asc(Tup(_: Var(any), _: Sel(Var(any), _1)), Tuple(List((None,Field(None,Tuple(List((None,Field(None,AppliedType(TypeName(B),List(TypeName(A))))), (None,Field(None,TypeName(A))))))), (None,Field(None,TypeName(A)))))))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("CTX"), Ls(), S(Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(Var("x"))))), NuTypeDef(Cls, TypeName("B"), Ls(N -> TypeName("T")), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(Var("y"))))), NuFunDef(None, foo, N, Nil, L(Lam(Tup((S(any), Fld(_, Tup((N, Fld(_, Var("A"))) :: (N, Fld(_, TyApp(Var("B"), List(TypeName(A))))) :: Nil))) :: Nil), Asc(Tup((N, Fld(_, Var("any"))) :: (N, Fld(_, Sel(Var("any"), _1))) :: Nil), Tuple(List((None,Field(None,Tuple(List((None,Field(None,AppliedType(TypeName(B),List(TypeName(A))))), (None,Field(None,TypeName(A))))))), (None,Field(None,TypeName(A))))))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class CTX$1_A$2([par$CTX$1,]) {fun foo = () => ((this).par$CTX$1).x}
@@ -86,7 +86,7 @@ class CTX{
 //│ |#class| |CTX|{|→|#fun| |ctx|(|x|,|y|)| |#=| |→|#class| |A|{| |#fun| |foo| |#=| |x| |}|↵|#fun| |bar|‹|T|›|(|any|#:| |T|)|#:| |A| |#=| |→|#let| |x| |#=| |#new| |T|↵|#new| |A|←|↵|(|#new| |CTX|)|.bar|‹|CTX|›|←|←|↵|}|
 //│ Parsed: {class CTX {fun ctx = (x, y,) => {class A {fun foo = x}; fun bar = (any: T,) => {let x = new T; new A} : A; ('(' new CTX ')').bar‹CTX›}}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, CTX, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, ctx, None, [], Lam(Tup(_: Var(x), _: Var(y)), Blk(...))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("CTX"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, ctx, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil), Blk(NuTypeDef(Cls, TypeName("A"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(Var("x"))))), NuFunDef(None, bar, N, TypeName("T") :: Nil, L(Lam(Tup((S(any), Fld(_, Var("T"))) :: Nil), Asc(Blk(NuFunDef(Some(false), x, N, Nil, L(NuNew(Var("T")))), NuNew(Var("A"))), TypeName(A))))), TyApp(Sel(Bra(rcd = false, NuNew(Var("CTX"))), bar), List(TypeName(CTX))))))))))
 //│ Lifted:
 //│ Lifting failed: mlscript.codegen.CodeGenError: Cannot find type T. Class values are not supported in lifter. 
 //│ 
diff --git a/compiler/shared/test/diff/Lifter.mls b/compiler/shared/test/diff/Lifter.mls
index fffb3d7252..21b4750d96 100644
--- a/compiler/shared/test/diff/Lifter.mls
+++ b/compiler/shared/test/diff/Lifter.mls
@@ -28,7 +28,7 @@ class A(x) {
 //│ |#class| |A|(|x|)| |{|→|#class| |B|(|y|)| |{|→|#fun| |getX| |#=| |x|↵|#fun| |getB1| |#=| |B1|(|y|)|↵|#class| |C|(|z|)| |{|→|#fun| |inc|(||)| |#=| |x| |+| |1|↵|#fun| |getY| |#=| |y|↵|#fun| |getA| |#=| |A|(|z|)|↵|#fun| |getB|(|w|)| |#=| |B|(|w|)|↵|#fun| |getC| |#=| |#new| |C|(|inc|(||)|)|↵|#fun| |getSelf| |#=| |this|←|↵|}|←|↵|}|↵|#class| |B1|(|y|)| |{|→|#fun| |getX| |#=| |x|↵|#fun| |getY| |#=| |y|↵|#fun| |getB| |#=| |#new| |B|(|y|)|↵|#fun| |getB1| |#=| |#new| |B1|(|y|)|←|↵|}|↵|#fun| |getB| |#=| |#new| |B|(|x|)|↵|#fun| |getB2|(|y|)| |#=| |B1|(|y|)|↵|#fun| |getB3|(|z|)| |#=| |getB2|(|z|)|↵|#fun| |getA| |#=| |A|(|x|)|←|↵|}|
 //│ Parsed: {class A(x,) {class B(y,) {fun getX = x; fun getB1 = B1(y,); class C(z,) {fun inc = () => +(x, 1,); fun getY = y; fun getA = A(z,); fun getB = (w,) => B(w,); fun getC = (new C)(inc(),); fun getSelf = this}}; class B1(y,) {fun getX = x; fun getY = y; fun getB = (new B)(y,); fun getB1 = (new B1)(y,)}; fun getB = (new B)(x,); fun getB2 = (y,) => B1(y,); fun getB3 = (z,) => getB2(z,); fun getA = A(x,)}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, A, (), Tup(_: Var(x)), (), None, None, TypingUnit(NuTypeDef(class, B, (), Tup(_: Var(y)), (), None, None, TypingUnit(NuFunDef(None, getX, None, [], Var(x)), NuFunDef(None, getB1, None, [], App(Var(B1), Tup(_: Var(y)))), NuTypeDef(class, C, (), Tup(_: Var(z)), (), None, None, TypingUnit(NuFunDef(None, inc, None, [], Lam(Tup(), App(Var(+), Tup(_: Var(x), _: IntLit(1))))), NuFunDef(None, getY, None, [], Var(y)), NuFunDef(None, getA, None, [], App(Var(A), Tup(_: Var(z)))), NuFunDef(None, getB, None, [], Lam(Tup(_: Var(w)), App(Var(B), Tup(_: Var(w))))), NuFunDef(None, getC, None, [], App(NuNew(Var(C)), Tup(_: App(Var(inc), Tup())))), NuFunDef(None, getSelf, None, [], Var(this)))))), NuTypeDef(class, B1, (), Tup(_: Var(y)), (), None, None, TypingUnit(NuFunDef(None, getX, None, [], Var(x)), NuFunDef(None, getY, None, [], Var(y)), NuFunDef(None, getB, None, [], App(NuNew(Var(B)), Tup(_: Var(y)))), NuFunDef(None, getB1, None, [], App(NuNew(Var(B1)), Tup(_: Var(y)))))), NuFunDef(None, getB, None, [], App(NuNew(Var(B)), Tup(_: Var(x)))), NuFunDef(None, getB2, None, [], Lam(Tup(_: Var(y)), App(Var(B1), Tup(_: Var(y))))), NuFunDef(None, getB3, None, [], Lam(Tup(_: Var(z)), App(Var(getB2), Tup(_: Var(z))))), NuFunDef(None, getA, None, [], App(Var(A), Tup(_: Var(x)))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), S(Tup((N, Fld(_, Var("x"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuTypeDef(Cls, TypeName("B"), Ls(), S(Tup((N, Fld(_, Var("y"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, getX, N, Nil, L(Var("x"))), NuFunDef(None, getB1, N, Nil, L(App(Var("B1"), Tup((N, Fld(_, Var("y"))) :: Nil)))), NuTypeDef(Cls, TypeName("C"), Ls(), S(Tup((N, Fld(_, Var("z"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, inc, N, Nil, L(Lam(Tup(Nil), App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(1))) :: Nil))))), NuFunDef(None, getY, N, Nil, L(Var("y"))), NuFunDef(None, getA, N, Nil, L(App(Var("A"), Tup((N, Fld(_, Var("z"))) :: Nil)))), NuFunDef(None, getB, N, Nil, L(Lam(Tup((N, Fld(_, Var("w"))) :: Nil), App(Var("B"), Tup((N, Fld(_, Var("w"))) :: Nil))))), NuFunDef(None, getC, N, Nil, L(App(NuNew(Var("C")), Tup((N, Fld(_, App(Var("inc"), Tup(Nil)))) :: Nil)))), NuFunDef(None, getSelf, N, Nil, L(Var("this"))))))), NuTypeDef(Cls, TypeName("B1"), Ls(), S(Tup((N, Fld(_, Var("y"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, getX, N, Nil, L(Var("x"))), NuFunDef(None, getY, N, Nil, L(Var("y"))), NuFunDef(None, getB, N, Nil, L(App(NuNew(Var("B")), Tup((N, Fld(_, Var("y"))) :: Nil)))), NuFunDef(None, getB1, N, Nil, L(App(NuNew(Var("B1")), Tup((N, Fld(_, Var("y"))) :: Nil)))))), NuFunDef(None, getB, N, Nil, L(App(NuNew(Var("B")), Tup((N, Fld(_, Var("x"))) :: Nil)))), NuFunDef(None, getB2, N, Nil, L(Lam(Tup((N, Fld(_, Var("y"))) :: Nil), App(Var("B1"), Tup((N, Fld(_, Var("y"))) :: Nil))))), NuFunDef(None, getB3, N, Nil, L(Lam(Tup((N, Fld(_, Var("z"))) :: Nil), App(Var("getB2"), Tup((N, Fld(_, Var("z"))) :: Nil))))), NuFunDef(None, getA, N, Nil, L(App(Var("A"), Tup((N, Fld(_, Var("x"))) :: Nil)))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1_B$2_C$4([par$A$1_B$2, z, x,]) {
@@ -68,7 +68,7 @@ class A(x) {
 //│ |#class| |A|(|x|)| |{|→|#class| |B|(|y|)| |{|→|#class| |C|(|z|)| |{|→|#fun| |sum| |#=| |x| |+| |y| |+| |z|←|↵|}|←|↵|}|←|↵|}|
 //│ Parsed: {class A(x,) {class B(y,) {class C(z,) {fun sum = +(+(x, y,), z,)}}}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, A, (), Tup(_: Var(x)), (), None, None, TypingUnit(NuTypeDef(class, B, (), Tup(_: Var(y)), (), None, None, TypingUnit(NuTypeDef(class, C, (), Tup(_: Var(z)), (), None, None, TypingUnit(NuFunDef(None, sum, None, [], App(Var(+), Tup(_: App(Var(+), Tup(_: Var(x), _: Var(y))), _: Var(z)))))))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), S(Tup((N, Fld(_, Var("x"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuTypeDef(Cls, TypeName("B"), Ls(), S(Tup((N, Fld(_, Var("y"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuTypeDef(Cls, TypeName("C"), Ls(), S(Tup((N, Fld(_, Var("z"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, sum, N, Nil, L(App(Var("+"), Tup((N, Fld(_, App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil)))) :: (N, Fld(_, Var("z"))) :: Nil)))))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1_B$2_C$3([par$A$1_B$2, z, x,]) {
@@ -108,7 +108,7 @@ new C{
 //│ |#class| |A|(|x|)| |{|→|#class| |B|{|→|#fun| |foo| |#=| |1|↵|#fun| |bar| |#=| |11|←|↵|}|↵|#fun| |getB| |#=| |#new| |B|{|→|#fun| |foo| |#=| |2|↵|#fun| |bar| |#=| |12|←|↵|}|↵|#fun| |bar| |#=| |13|←|↵|}|↵|#class| |C|#:| |A|{|→|#fun| |getB| |#=| |#new| |B|{|→|#fun| |foo| |#=| |3|↵|#fun| |bar| |#=| |14|←|↵|}|↵|#fun| |bar| |#=| |15|←|↵|}|↵|#new| |C|{|→|#fun| |getB| |#=| |#new| |B|{|→|#fun| |foo| |#=| |4|↵|#fun| |bar| |#=| |16|←|↵|}|↵|#fun| |bar| |#=| |17|←|↵|}|
 //│ Parsed: {class A(x,) {class B {fun foo = 1; fun bar = 11}; fun getB = new B { ‹fun foo = 2; fun bar = 12› }; fun bar = 13}; class C: A {fun getB = new B { ‹fun foo = 3; fun bar = 14› }; fun bar = 15}; new C { ‹fun getB = new B { ‹fun foo = 4; fun bar = 16› }; fun bar = 17› }}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, A, (), Tup(_: Var(x)), (), None, None, TypingUnit(NuTypeDef(class, B, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, foo, None, [], IntLit(1)), NuFunDef(None, bar, None, [], IntLit(11)))), NuFunDef(None, getB, None, [], Rft(NuNew(Var(B)), ...)), NuFunDef(None, bar, None, [], IntLit(13)))), NuTypeDef(class, C, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, getB, None, [], Rft(NuNew(Var(B)), ...)), NuFunDef(None, bar, None, [], IntLit(15)))), Rft(NuNew(Var(C)), ...))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), S(Tup((N, Fld(_, Var("x"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuTypeDef(Cls, TypeName("B"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(IntLit(1))), NuFunDef(None, bar, N, Nil, L(IntLit(11))))), NuFunDef(None, getB, N, Nil, L(Rft(NuNew(Var("B")), TypingUnit(NuFunDef(None, foo, N, Nil, L(IntLit(2))), NuFunDef(None, bar, N, Nil, L(IntLit(12))))))), NuFunDef(None, bar, N, Nil, L(IntLit(13))))), NuTypeDef(Cls, TypeName("C"), Ls(), N, N, S(TypeName("A")), Ls(), N, N, TypingUnit(NuFunDef(None, getB, N, Nil, L(Rft(NuNew(Var("B")), TypingUnit(NuFunDef(None, foo, N, Nil, L(IntLit(3))), NuFunDef(None, bar, N, Nil, L(IntLit(14))))))), NuFunDef(None, bar, N, Nil, L(IntLit(15))))), Rft(NuNew(Var("C")), TypingUnit(NuFunDef(None, getB, N, Nil, L(Rft(NuNew(Var("B")), TypingUnit(NuFunDef(None, foo, N, Nil, L(IntLit(4))), NuFunDef(None, bar, N, Nil, L(IntLit(16))))))), NuFunDef(None, bar, N, Nil, L(IntLit(17))))))
 //│ Lifted:
 //│ Lifting failed: mlscript.codegen.CodeGenError: Cannot find type B. Class values are not supported in lifter. 
 //│ 
@@ -125,7 +125,7 @@ class Parent<T, U, V>(x) {
 //│ |#class| |Parent|‹|T|,| |U|,| |V|›|(|x|)| |{| |→|#fun| |foo|(|x|#:| |Int|)|#:| |T| |#=| |x|+|1|↵|#class| |Inner|‹|W|›|(|y|#:| |Int|)|{|→|#fun| |bar|(|z|#:| |U|)| |#=| |foo|(|y|)|↵|#fun| |boo|(|z|#:| |W|)| |#=| |z|←|↵|}|←|↵|}|
 //│ Parsed: {class Parent‹T, U, V›(x,) {fun foo = (x: Int,) => +(x, 1,) : T; class Inner‹W›(y: Int,) {fun bar = (z: U,) => foo(y,); fun boo = (z: W,) => z}}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, Parent, ((None,TypeName(T)), (None,TypeName(U)), (None,TypeName(V))), Tup(_: Var(x)), (), None, None, TypingUnit(NuFunDef(None, foo, None, [], Lam(Tup(x: Var(Int)), Asc(App(Var(+), Tup(_: Var(x), _: IntLit(1))), TypeName(T)))), NuTypeDef(class, Inner, ((None,TypeName(W))), Tup(y: Var(Int)), (), None, None, TypingUnit(NuFunDef(None, bar, None, [], Lam(Tup(z: Var(U)), App(Var(foo), Tup(_: Var(y))))), NuFunDef(None, boo, None, [], Lam(Tup(z: Var(W)), Var(z))))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("Parent"), Ls(N -> TypeName("T"), N -> TypeName("U"), N -> TypeName("V")), S(Tup((N, Fld(_, Var("x"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(Lam(Tup((S(x), Fld(_, Var("Int"))) :: Nil), Asc(App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(1))) :: Nil)), TypeName(T))))), NuTypeDef(Cls, TypeName("Inner"), Ls(N -> TypeName("W")), S(Tup((S(y), Fld(_, Var("Int"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, bar, N, Nil, L(Lam(Tup((S(z), Fld(_, Var("U"))) :: Nil), App(Var("foo"), Tup((N, Fld(_, Var("y"))) :: Nil))))), NuFunDef(None, boo, N, Nil, L(Lam(Tup((S(z), Fld(_, Var("W"))) :: Nil), Var("z")))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Parent$1_Inner$2[W,U]([par$Parent$1, y: Int,]) {
@@ -148,7 +148,7 @@ class A<T, U>(x: Int): ({a1: Int} & B<T> & D(x)) {
 //│ |#class| |B|‹|T|›| |{||}|↵|#class| |C| |{||}|↵|#class| |D|(|y|#:| |Int|)| |{||}|↵|#class| |A|‹|T|,| |U|›|(|x|#:| |Int|)|#:| |(|{|a1|#:| |Int|}| |&| |B|‹|T|›| |&| |D|(|x|)|)| |{|→|#fun| |getA|(||)| |#=| |#new| |C|{|→|#fun| |foo|(|x|#:| |T|)| |#=| |x|←|↵|}|←|↵|}|
 //│ Parsed: {class B‹T› {}; class C {}; class D(y: Int,) {}; class A‹T, U›(x: Int,): {a1: Int} & B[T] & D[x] {fun getA = () => new C { ‹fun foo = (x: T,) => x› }}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, B, ((None,TypeName(T))), Tup(), (), None, None, TypingUnit()), NuTypeDef(class, C, (), Tup(), (), None, None, TypingUnit()), NuTypeDef(class, D, (), Tup(y: Var(Int)), (), None, None, TypingUnit()), NuTypeDef(class, A, ((None,TypeName(T)), (None,TypeName(U))), Tup(x: Var(Int)), (), None, None, TypingUnit(NuFunDef(None, getA, None, [], Lam(Tup(), Rft(NuNew(Var(C)), ...))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("B"), Ls(N -> TypeName("T")), N, N, N, Ls(), N, N, TypingUnit()), NuTypeDef(Cls, TypeName("C"), Ls(), N, N, N, Ls(), N, N, TypingUnit()), NuTypeDef(Cls, TypeName("D"), Ls(), S(Tup((S(y), Fld(_, Var("Int"))) :: Nil)), N, N, Ls(), N, N, TypingUnit()), NuTypeDef(Cls, TypeName("A"), Ls(N -> TypeName("T"), N -> TypeName("U")), S(Tup((S(x), Fld(_, Var("Int"))) :: Nil)), N, S(Inter(Inter(Record(a1: Fld(N, TypeName("Int"))), AppliedType(TypeName("B"), TypeName("T") :: Nil)), AppliedType(TypeName("D"), TypeName("x") :: Nil))), Ls(), N, N, TypingUnit(NuFunDef(None, getA, N, Nil, L(Lam(Tup(Nil), Rft(NuNew(Var("C")), TypingUnit(NuFunDef(None, foo, N, Nil, L(Lam(Tup((S(x), Fld(_, Var("T"))) :: Nil), Var("x"))))))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class B$1[T]([]) {}
@@ -170,7 +170,7 @@ class A<T, U>(x: Int) extends {a1: Int}, B<T>, D(x){
 //│ |#class| |B|‹|T|›| |{||}|↵|#class| |C| |{||}|↵|#class| |D|(|y|#:| |Int|)| |{||}|↵|#class| |A|‹|T|,| |U|›|(|x|#:| |Int|)| |#extends| |{|a1|#:| |Int|}|,| |B|‹|T|›|,| |D|(|x|)|{|→|#fun| |getA|(||)| |#=| |#new| |C|{|→|#fun| |foo|(|x|)| |#=| |x|←|↵|}|←|↵|}|
 //│ Parsed: {class B‹T› {}; class C {}; class D(y: Int,) {}; class A‹T, U›(x: Int,): '{' {a1: Int} '}', B‹T›, D(x,) {fun getA = () => new C { ‹fun foo = (x,) => x› }}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, B, ((None,TypeName(T))), Tup(), (), None, None, TypingUnit()), NuTypeDef(class, C, (), Tup(), (), None, None, TypingUnit()), NuTypeDef(class, D, (), Tup(y: Var(Int)), (), None, None, TypingUnit()), NuTypeDef(class, A, ((None,TypeName(T)), (None,TypeName(U))), Tup(x: Var(Int)), (Bra(rcd = true, Rcd(Var(a1) = Var(Int))), TyApp(Var(B), List(TypeName(T))), App(Var(D), Tup(_: Var(x)))), None, None, TypingUnit(NuFunDef(None, getA, None, [], Lam(Tup(), Rft(NuNew(Var(C)), ...))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("B"), Ls(N -> TypeName("T")), N, N, N, Ls(), N, N, TypingUnit()), NuTypeDef(Cls, TypeName("C"), Ls(), N, N, N, Ls(), N, N, TypingUnit()), NuTypeDef(Cls, TypeName("D"), Ls(), S(Tup((S(y), Fld(_, Var("Int"))) :: Nil)), N, N, Ls(), N, N, TypingUnit()), NuTypeDef(Cls, TypeName("A"), Ls(N -> TypeName("T"), N -> TypeName("U")), S(Tup((S(x), Fld(_, Var("Int"))) :: Nil)), N, N, Ls(Bra(rcd = true, Rcd(Var("a1") = Var("Int"))), TyApp(Var("B"), List(TypeName(T))), App(Var("D"), Tup((N, Fld(_, Var("x"))) :: Nil))), N, N, TypingUnit(NuFunDef(None, getA, N, Nil, L(Lam(Tup(Nil), Rft(NuNew(Var("C")), TypingUnit(NuFunDef(None, foo, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Var("x"))))))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class B$1[T]([]) {}
@@ -190,7 +190,7 @@ class Child<T, U>(x): ({ age: T } & { name: String}) {
 //│ |#class| |Child|‹|T|,| |U|›|(|x|)|#:| |(|{| |age|#:| |T| |}| |&| |{| |name|#:| |String|}|)| |{|→|#class| |Inner|{|→|#fun| |foo| |#=| |age|←|↵|}|↵|#fun| |bar| |#=| |age|↵|#fun| |boo| |#=| |#new| |Inner|←|↵|}|
 //│ Parsed: {class Child‹T, U›(x,): {age: T} & {name: String} {class Inner {fun foo = age}; fun bar = age; fun boo = new Inner}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, Child, ((None,TypeName(T)), (None,TypeName(U))), Tup(_: Var(x)), (), None, None, TypingUnit(NuTypeDef(class, Inner, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, foo, None, [], Var(age)))), NuFunDef(None, bar, None, [], Var(age)), NuFunDef(None, boo, None, [], NuNew(Var(Inner))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("Child"), Ls(N -> TypeName("T"), N -> TypeName("U")), S(Tup((N, Fld(_, Var("x"))) :: Nil)), N, S(Inter(Record(age: Fld(N, TypeName("T"))), Record(name: Fld(N, TypeName("String"))))), Ls(), N, N, TypingUnit(NuTypeDef(Cls, TypeName("Inner"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(Var("age"))))), NuFunDef(None, bar, N, Nil, L(Var("age"))), NuFunDef(None, boo, N, Nil, L(NuNew(Var("Inner")))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Child$1_Inner$2([par$Child$1, age,]) {fun foo = () => (this).age}
@@ -213,7 +213,7 @@ new A(0) {
 //│ |#class| |A|(|x|#:| |Int|)| |{|→|#fun| |getA|#:| |Int| |#=| |0|↵|#fun| |getA1| |#=| |1|←|↵|}|↵|#new| |A|(|0|)| |{|→|#fun| |getA| |#=| |3|↵|#fun| |getA2| |#=| |2|←|↵|}|
 //│ Parsed: {class A(x: Int,) {fun getA = 0 : Int; fun getA1 = 1}; (new A)(0,) { ‹fun getA = 3; fun getA2 = 2› }}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, A, (), Tup(x: Var(Int)), (), None, None, TypingUnit(NuFunDef(None, getA, None, [], Asc(IntLit(0), TypeName(Int))), NuFunDef(None, getA1, None, [], IntLit(1)))), Rft(App(NuNew(Var(A)), Tup(_: IntLit(0))), ...))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), S(Tup((S(x), Fld(_, Var("Int"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, getA, N, Nil, L(Asc(IntLit(0), TypeName(Int)))), NuFunDef(None, getA1, N, Nil, L(IntLit(1))))), Rft(App(NuNew(Var("A")), Tup((N, Fld(_, IntLit(0))) :: Nil)), TypingUnit(NuFunDef(None, getA, N, Nil, L(IntLit(3))), NuFunDef(None, getA2, N, Nil, L(IntLit(2))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1([x: Int,]) {fun getA = () => 0 : Int; fun getA1 = () => 1}
@@ -234,7 +234,7 @@ new A(1) {
 //│ |#class| |A|(|x|)| |{|→|#class| |B|(|y|)| |{| |}|←|↵|}|↵|#new| |A|(|1|)| |{|→|#fun| |getB| |#=| |#new| |B|(|2|)|{|→|#fun| |getB| |#=| |#new| |B|(|3|)|←|↵|}|←|↵|}|
 //│ Parsed: {class A(x,) {class B(y,) {}}; (new A)(1,) { ‹fun getB = (new B)(2,) { ‹fun getB = (new B)(3,)› }› }}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, A, (), Tup(_: Var(x)), (), None, None, TypingUnit(NuTypeDef(class, B, (), Tup(_: Var(y)), (), None, None, TypingUnit()))), Rft(App(NuNew(Var(A)), Tup(_: IntLit(1))), ...))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), S(Tup((N, Fld(_, Var("x"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuTypeDef(Cls, TypeName("B"), Ls(), S(Tup((N, Fld(_, Var("y"))) :: Nil)), N, N, Ls(), N, N, TypingUnit()))), Rft(App(NuNew(Var("A")), Tup((N, Fld(_, IntLit(1))) :: Nil)), TypingUnit(NuFunDef(None, getB, N, Nil, L(Rft(App(NuNew(Var("B")), Tup((N, Fld(_, IntLit(2))) :: Nil)), TypingUnit(NuFunDef(None, getB, N, Nil, L(App(NuNew(Var("B")), Tup((N, Fld(_, IntLit(3))) :: Nil)))))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1_B$2([par$A$1, y,]) {}
@@ -267,7 +267,7 @@ new B{
 //│ |#class| |A| |{|→|#fun| |getA| |#=| |0|↵|#fun| |funcA| |#=| |10|←|↵|}|↵|#class| |B|#:| |A|{|→|#fun| |getA| |#=| |1|↵|#fun| |funcB| |#=| |11|←|↵|}|↵|#new| |A|↵|#new| |B|↵|#fun| |f|(|x|)| |#=| |#if| |x| |is| |A| |#then| |0| |#else| |1|↵|f|(|#new| |A|{|→|#fun| |getA| |#=| |2|←|↵|}|)|↵|#new| |B|{|→|#fun| |getA| |#=| |funcB|←|↵|}|
 //│ Parsed: {class A {fun getA = 0; fun funcA = 10}; class B: A {fun getA = 1; fun funcB = 11}; new A; new B; fun f = (x,) => if (is(x, A,)) then 0 else 1; f(new A { ‹fun getA = 2› },); new B { ‹fun getA = funcB› }}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, A, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, getA, None, [], IntLit(0)), NuFunDef(None, funcA, None, [], IntLit(10)))), NuTypeDef(class, B, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, getA, None, [], IntLit(1)), NuFunDef(None, funcB, None, [], IntLit(11)))), NuNew(Var(A)), NuNew(Var(B)), NuFunDef(None, f, None, [], Lam(Tup(_: Var(x)), If(IfThen(App(Var(is), Tup(_: Var(x), _: Var(A))), IntLit(0), Some(IntLit(1))))), App(Var(f), Tup(_: Rft(NuNew(Var(A)), ...))), Rft(NuNew(Var(B)), ...))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, getA, N, Nil, L(IntLit(0))), NuFunDef(None, funcA, N, Nil, L(IntLit(10))))), NuTypeDef(Cls, TypeName("B"), Ls(), N, N, S(TypeName("A")), Ls(), N, N, TypingUnit(NuFunDef(None, getA, N, Nil, L(IntLit(1))), NuFunDef(None, funcB, N, Nil, L(IntLit(11))))), NuNew(Var("A")), NuNew(Var("B")), NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), If(IfThen(App(Var("is"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("A"))) :: Nil)), IntLit(0), Some(IntLit(1)))))), App(Var("f"), Tup((N, Fld(_, Rft(NuNew(Var("A")), TypingUnit(NuFunDef(None, getA, N, Nil, L(IntLit(2))))))) :: Nil)), Rft(NuNew(Var("B")), TypingUnit(NuFunDef(None, getA, N, Nil, L(Var("funcB"))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1([]) {fun getA = () => 0; fun funcA = () => 10}
@@ -306,7 +306,7 @@ class A{
 //│ |#class| |A|{|→|#class| |B|{|→|#fun| |funB| |#=| |1|↵|#fun| |foo| |#=| |100|←|↵|}|↵|#class| |C|#:| |B|{|→|#fun| |funC| |#=| |2|↵|#fun| |foo| |#=| |1000|←|↵|}|↵|#class| |D|{|→|#fun| |funD| |#=| |3|↵|#fun| |foo| |#=| |10000| |↵|#class| |E|#:| |C|{|→|#fun| |funE| |#=| |4|↵|#fun| |foo| |#=| |100000|←|↵|}|↵|#class| |F|#:| |E|{|→|#fun| |funF| |#=| |5|↵|#fun| |foo| |#=| |1000000|←|↵|}|←|↵|}|←|↵|}|
 //│ Parsed: {class A {class B {fun funB = 1; fun foo = 100}; class C: B {fun funC = 2; fun foo = 1000}; class D {fun funD = 3; fun foo = 10000; class E: C {fun funE = 4; fun foo = 100000}; class F: E {fun funF = 5; fun foo = 1000000}}}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, A, (), Tup(), (), None, None, TypingUnit(NuTypeDef(class, B, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, funB, None, [], IntLit(1)), NuFunDef(None, foo, None, [], IntLit(100)))), NuTypeDef(class, C, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, funC, None, [], IntLit(2)), NuFunDef(None, foo, None, [], IntLit(1000)))), NuTypeDef(class, D, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, funD, None, [], IntLit(3)), NuFunDef(None, foo, None, [], IntLit(10000)), NuTypeDef(class, E, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, funE, None, [], IntLit(4)), NuFunDef(None, foo, None, [], IntLit(100000)))), NuTypeDef(class, F, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, funF, None, [], IntLit(5)), NuFunDef(None, foo, None, [], IntLit(1000000)))))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuTypeDef(Cls, TypeName("B"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, funB, N, Nil, L(IntLit(1))), NuFunDef(None, foo, N, Nil, L(IntLit(100))))), NuTypeDef(Cls, TypeName("C"), Ls(), N, N, S(TypeName("B")), Ls(), N, N, TypingUnit(NuFunDef(None, funC, N, Nil, L(IntLit(2))), NuFunDef(None, foo, N, Nil, L(IntLit(1000))))), NuTypeDef(Cls, TypeName("D"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, funD, N, Nil, L(IntLit(3))), NuFunDef(None, foo, N, Nil, L(IntLit(10000))), NuTypeDef(Cls, TypeName("E"), Ls(), N, N, S(TypeName("C")), Ls(), N, N, TypingUnit(NuFunDef(None, funE, N, Nil, L(IntLit(4))), NuFunDef(None, foo, N, Nil, L(IntLit(100000))))), NuTypeDef(Cls, TypeName("F"), Ls(), N, N, S(TypeName("E")), Ls(), N, N, TypingUnit(NuFunDef(None, funF, N, Nil, L(IntLit(5))), NuFunDef(None, foo, N, Nil, L(IntLit(1000000))))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1_B$2([par$A$1,]) {fun funB = () => 1; fun foo = () => 100}
@@ -349,7 +349,7 @@ class A{
 //│ |#class| |A|{|→|#class| |B|{|→|#fun| |funB| |#=| |1|↵|#fun| |foo| |#=| |100|←|↵|}|↵|#class| |C|#:| |B|{|→|#fun| |funC| |#=| |2|↵|#fun| |foo| |#=| |1000|↵|#fun| |getB| |#=| |#new| |B|←|↵|}|↵|#class| |D|{|→|#fun| |funD| |#=| |3|↵|#fun| |foo| |#=| |10000| |↵|#class| |E|#:| |C|{|→|#fun| |funE| |#=| |4|↵|#fun| |foo| |#=| |100000|↵|#fun| |getD| |#=| |#new| |D|←|↵|}|↵|#class| |F|#:| |E|{|→|#fun| |funF| |#=| |5|↵|#fun| |foo| |#=| |1000000|↵|#fun| |getE| |#=| |#new| |E|{|→|#fun| |foo| |#=| |0|←|↵|}|←|↵|}|←|↵|}|←|↵|}|
 //│ Parsed: {class A {class B {fun funB = 1; fun foo = 100}; class C: B {fun funC = 2; fun foo = 1000; fun getB = new B}; class D {fun funD = 3; fun foo = 10000; class E: C {fun funE = 4; fun foo = 100000; fun getD = new D}; class F: E {fun funF = 5; fun foo = 1000000; fun getE = new E { ‹fun foo = 0› }}}}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, A, (), Tup(), (), None, None, TypingUnit(NuTypeDef(class, B, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, funB, None, [], IntLit(1)), NuFunDef(None, foo, None, [], IntLit(100)))), NuTypeDef(class, C, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, funC, None, [], IntLit(2)), NuFunDef(None, foo, None, [], IntLit(1000)), NuFunDef(None, getB, None, [], NuNew(Var(B))))), NuTypeDef(class, D, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, funD, None, [], IntLit(3)), NuFunDef(None, foo, None, [], IntLit(10000)), NuTypeDef(class, E, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, funE, None, [], IntLit(4)), NuFunDef(None, foo, None, [], IntLit(100000)), NuFunDef(None, getD, None, [], NuNew(Var(D))))), NuTypeDef(class, F, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, funF, None, [], IntLit(5)), NuFunDef(None, foo, None, [], IntLit(1000000)), NuFunDef(None, getE, None, [], Rft(NuNew(Var(E)), ...)))))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuTypeDef(Cls, TypeName("B"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, funB, N, Nil, L(IntLit(1))), NuFunDef(None, foo, N, Nil, L(IntLit(100))))), NuTypeDef(Cls, TypeName("C"), Ls(), N, N, S(TypeName("B")), Ls(), N, N, TypingUnit(NuFunDef(None, funC, N, Nil, L(IntLit(2))), NuFunDef(None, foo, N, Nil, L(IntLit(1000))), NuFunDef(None, getB, N, Nil, L(NuNew(Var("B")))))), NuTypeDef(Cls, TypeName("D"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, funD, N, Nil, L(IntLit(3))), NuFunDef(None, foo, N, Nil, L(IntLit(10000))), NuTypeDef(Cls, TypeName("E"), Ls(), N, N, S(TypeName("C")), Ls(), N, N, TypingUnit(NuFunDef(None, funE, N, Nil, L(IntLit(4))), NuFunDef(None, foo, N, Nil, L(IntLit(100000))), NuFunDef(None, getD, N, Nil, L(NuNew(Var("D")))))), NuTypeDef(Cls, TypeName("F"), Ls(), N, N, S(TypeName("E")), Ls(), N, N, TypingUnit(NuFunDef(None, funF, N, Nil, L(IntLit(5))), NuFunDef(None, foo, N, Nil, L(IntLit(1000000))), NuFunDef(None, getE, N, Nil, L(Rft(NuNew(Var("E")), TypingUnit(NuFunDef(None, foo, N, Nil, L(IntLit(0))))))))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1_B$2([par$A$1,]) {fun funB = () => 1; fun foo = () => 100}
@@ -384,7 +384,7 @@ new A
 //│ |#class| |A|{|→|#class| |B|{|→|#fun| |foo| |#=| |1|←|↵|}|↵|#fun| |bar| |#=| |#new| |B|←|↵|}|↵|#new| |A|
 //│ Parsed: {class A {class B {fun foo = 1}; fun bar = new B}; new A}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, A, (), Tup(), (), None, None, TypingUnit(NuTypeDef(class, B, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, foo, None, [], IntLit(1)))), NuFunDef(None, bar, None, [], NuNew(Var(B))))), NuNew(Var(A)))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuTypeDef(Cls, TypeName("B"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(IntLit(1))))), NuFunDef(None, bar, N, Nil, L(NuNew(Var("B")))))), NuNew(Var("A")))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1_B$2([par$A$1,]) {fun foo = () => 1}
@@ -409,7 +409,7 @@ let x = new A{
 //│ |#class| |A|(|x|)| |{|→|#fun| |foo| |#=| |0|↵|#fun| |bar| |#=| |x|←|↵|}|↵|#let| |x| |#=| |#new| |A|{|→|#fun| |foo| |#=| |1|↵|#fun| |newFun| |#=| |2|↵|#fun| |bar| |#=| |#new| |A|(|foo|)|{|→|#fun| |foo| |#=| |bar| |+| |1|↵|#fun| |bar2| |#=| |newFun| |+| |1|←|↵|}|←|↵|}|
 //│ Parsed: {class A(x,) {fun foo = 0; fun bar = x}; let x = new A { ‹fun foo = 1; fun newFun = 2; fun bar = (new A)(foo,) { ‹fun foo = +(bar, 1,); fun bar2 = +(newFun, 1,)› }› }}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, A, (), Tup(_: Var(x)), (), None, None, TypingUnit(NuFunDef(None, foo, None, [], IntLit(0)), NuFunDef(None, bar, None, [], Var(x)))), NuFunDef(Some(false), x, None, [], Rft(NuNew(Var(A)), ...)))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), S(Tup((N, Fld(_, Var("x"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(IntLit(0))), NuFunDef(None, bar, N, Nil, L(Var("x"))))), NuFunDef(Some(false), x, N, Nil, L(Rft(NuNew(Var("A")), TypingUnit(NuFunDef(None, foo, N, Nil, L(IntLit(1))), NuFunDef(None, newFun, N, Nil, L(IntLit(2))), NuFunDef(None, bar, N, Nil, L(Rft(App(NuNew(Var("A")), Tup((N, Fld(_, Var("foo"))) :: Nil)), TypingUnit(NuFunDef(None, foo, N, Nil, L(App(Var("+"), Tup((N, Fld(_, Var("bar"))) :: (N, Fld(_, IntLit(1))) :: Nil)))), NuFunDef(None, bar2, N, Nil, L(App(Var("+"), Tup((N, Fld(_, Var("newFun"))) :: (N, Fld(_, IntLit(1))) :: Nil)))))))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1([x,]) {fun foo = () => 0; fun bar = () => (this).x}
@@ -437,7 +437,7 @@ new A{
 //│ |#class| |A| |{||}|↵|#new| |A|{|→|#fun| |foo| |#=| |1|↵|#fun| |bar| |#=| |#new| |A|{|→|#fun| |foo1| |#=| |foo|↵|#fun| |bar1| |#=| |#new| |A|{|→|#fun| |foo2| |#=| |foo|↵|#fun| |bar2| |#=| |#new| |A|{|→|#fun| |foo3| |#=| |foo|↵|#fun| |bar3| |#=| |#new| |A|{|→|#fun| |foo4| |#=| |foo|↵|#fun| |bar4| |#=| |0|←|↵|}|←|↵|}|←|↵|}|←|↵|}|←|↵|}|
 //│ Parsed: {class A {}; new A { ‹fun foo = 1; fun bar = new A { ‹fun foo1 = foo; fun bar1 = new A { ‹fun foo2 = foo; fun bar2 = new A { ‹fun foo3 = foo; fun bar3 = new A { ‹fun foo4 = foo; fun bar4 = 0› }› }› }› }› }}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, A, (), Tup(), (), None, None, TypingUnit()), Rft(NuNew(Var(A)), ...))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), N, N, N, Ls(), N, N, TypingUnit()), Rft(NuNew(Var("A")), TypingUnit(NuFunDef(None, foo, N, Nil, L(IntLit(1))), NuFunDef(None, bar, N, Nil, L(Rft(NuNew(Var("A")), TypingUnit(NuFunDef(None, foo1, N, Nil, L(Var("foo"))), NuFunDef(None, bar1, N, Nil, L(Rft(NuNew(Var("A")), TypingUnit(NuFunDef(None, foo2, N, Nil, L(Var("foo"))), NuFunDef(None, bar2, N, Nil, L(Rft(NuNew(Var("A")), TypingUnit(NuFunDef(None, foo3, N, Nil, L(Var("foo"))), NuFunDef(None, bar3, N, Nil, L(Rft(NuNew(Var("A")), TypingUnit(NuFunDef(None, foo4, N, Nil, L(Var("foo"))), NuFunDef(None, bar4, N, Nil, L(IntLit(0))))))))))))))))))))))
 //│ Lifted:
 //│ TypingUnit {class A$1([]) {}; Code(List(new A$1([]) {}))}
 //│ 
diff --git a/compiler/shared/test/diff/LifterBlks.mls b/compiler/shared/test/diff/LifterBlks.mls
index 414d4109b4..4738cf4cf9 100644
--- a/compiler/shared/test/diff/LifterBlks.mls
+++ b/compiler/shared/test/diff/LifterBlks.mls
@@ -7,7 +7,7 @@ fun foo =
 //│ |#fun| |foo| |#=|→|print|(|"ok"|)|↵|print|(|"ko"|)|←|
 //│ Parsed: {fun foo = {print("ok",); print("ko",)}}
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, foo, None, [], Blk(...)))
+//│ TypingUnit(NuFunDef(None, foo, N, Nil, L(Blk(App(Var("print"), Tup((N, Fld(_, StrLit(ok))) :: Nil)), App(Var("print"), Tup((N, Fld(_, StrLit(ko))) :: Nil))))))
 //│ Lifted:
 //│ TypingUnit {fun foo$1 = () => {print("ok",); print("ko",)}}
 //│ 
@@ -19,7 +19,7 @@ class A{
 //│ |#class| |A|{|→|#class| |B| |{||}|↵|#fun| |foo|(|x|#:| |B|)| |#=| |(|x| |#:| |B|)|←|↵|}|
 //│ Parsed: {class A {class B {}; fun foo = (x: B,) => '(' x : B ')'}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, A, (), Tup(), (), None, None, TypingUnit(NuTypeDef(class, B, (), Tup(), (), None, None, TypingUnit()), NuFunDef(None, foo, None, [], Lam(Tup(x: Var(B)), Bra(rcd = false, Asc(Var(x), TypeName(B))))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuTypeDef(Cls, TypeName("B"), Ls(), N, N, N, Ls(), N, N, TypingUnit()), NuFunDef(None, foo, N, Nil, L(Lam(Tup((S(x), Fld(_, Var("B"))) :: Nil), Bra(rcd = false, Asc(Var("x"), TypeName(B)))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1_B$2([par$A$1,]) {}
@@ -41,7 +41,7 @@ fun foo =
 //│ |#fun| |foo| |#=|→|#let| |local|(|x|)| |#=|→|#class| |Foo| |{|→|#fun| |bar| |#=| |x| |+| |1|←|↵|}|↵|Foo|(||)|.bar|←|↵|print| |#of| |local|(|0|)| |+| |local|(|1|)|↵|print| |#of| |(|local| |#of| |0|)| |+| |local| |#of| |1|↵|#fun| |tmp| |#=| |1|↵|print| |#of| |local| |#of| |0| |+| |local| |#of| |1|↵|#fun| |tmp| |#=| |2|←|
 //│ Parsed: {fun foo = {let local = (x,) => {class Foo {fun bar = +(x, 1,)}; (Foo()).bar}; print(+(local(0,), local(1,),),); print(+('(' local(0,) ')', local(1,),),); fun tmp = 1; print(local(+(0, local(1,),),),); fun tmp = 2}}
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, foo, None, [], Blk(...)))
+//│ TypingUnit(NuFunDef(None, foo, N, Nil, L(Blk(NuFunDef(Some(false), local, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(NuTypeDef(Cls, TypeName("Foo"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, bar, N, Nil, L(App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(1))) :: Nil)))))), Sel(App(Var("Foo"), Tup(Nil)), bar))))), App(Var("print"), Tup((N, Fld(_, App(Var("+"), Tup((N, Fld(_, App(Var("local"), Tup((N, Fld(_, IntLit(0))) :: Nil)))) :: (N, Fld(_, App(Var("local"), Tup((N, Fld(_, IntLit(1))) :: Nil)))) :: Nil)))) :: Nil)), App(Var("print"), Tup((N, Fld(_, App(Var("+"), Tup((N, Fld(_, Bra(rcd = false, App(Var("local"), Tup((N, Fld(_, IntLit(0))) :: Nil))))) :: (N, Fld(_, App(Var("local"), Tup((N, Fld(_, IntLit(1))) :: Nil)))) :: Nil)))) :: Nil)), NuFunDef(None, tmp, N, Nil, L(IntLit(1))), App(Var("print"), Tup((N, Fld(_, App(Var("local"), Tup((N, Fld(_, App(Var("+"), Tup((N, Fld(_, IntLit(0))) :: (N, Fld(_, App(Var("local"), Tup((N, Fld(_, IntLit(1))) :: Nil)))) :: Nil)))) :: Nil)))) :: Nil)), NuFunDef(None, tmp, N, Nil, L(IntLit(2)))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Foo$1([x,]) {fun bar = () => +((this).x, 1,)}
@@ -57,7 +57,7 @@ f(0)
 //│ |#class| |A|(|y|)|{||}|↵|#let| |f| |#=| |x| |#=>| |#new| |A|(|0|)|{|#fun| |bar| |#=| |x|+|y|}|↵|f|(|0|)|
 //│ Parsed: {class A(y,) {}; let f = (x,) => (new A)(0,) { ‹fun bar = +(x, y,)› }; f(0,)}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, A, (), Tup(_: Var(y)), (), None, None, TypingUnit()), NuFunDef(Some(false), f, None, [], Lam(Tup(_: Var(x)), Rft(App(NuNew(Var(A)), Tup(_: IntLit(0))), ...))), App(Var(f), Tup(_: IntLit(0))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), S(Tup((N, Fld(_, Var("y"))) :: Nil)), N, N, Ls(), N, N, TypingUnit()), NuFunDef(Some(false), f, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Rft(App(NuNew(Var("A")), Tup((N, Fld(_, IntLit(0))) :: Nil)), TypingUnit(NuFunDef(None, bar, N, Nil, L(App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil))))))))), App(Var("f"), Tup((N, Fld(_, IntLit(0))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1([y,]) {}
@@ -80,7 +80,7 @@ class A(x){
 //│ |#class| |A|(|x|)|{|→|#fun| |w| |#=| |x|↵|#fun| |foo|(|y|)| |#=| |→|#class| |B|(|z|)|{|→|#fun| |bar| |#=| |x|+|y|+|z|←|↵|}|↵|#new| |B|(|0|)|{|→|#fun| |bar| |#=| |w|+|y|+|z|←|↵|}|←|←|↵|}|
 //│ Parsed: {class A(x,) {fun w = x; fun foo = (y,) => {class B(z,) {fun bar = +(+(x, y,), z,)}; (new B)(0,) { ‹fun bar = +(+(w, y,), z,)› }}}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, A, (), Tup(_: Var(x)), (), None, None, TypingUnit(NuFunDef(None, w, None, [], Var(x)), NuFunDef(None, foo, None, [], Lam(Tup(_: Var(y)), Blk(...))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), S(Tup((N, Fld(_, Var("x"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, w, N, Nil, L(Var("x"))), NuFunDef(None, foo, N, Nil, L(Lam(Tup((N, Fld(_, Var("y"))) :: Nil), Blk(NuTypeDef(Cls, TypeName("B"), Ls(), S(Tup((N, Fld(_, Var("z"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, bar, N, Nil, L(App(Var("+"), Tup((N, Fld(_, App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil)))) :: (N, Fld(_, Var("z"))) :: Nil)))))), Rft(App(NuNew(Var("B")), Tup((N, Fld(_, IntLit(0))) :: Nil)), TypingUnit(NuFunDef(None, bar, N, Nil, L(App(Var("+"), Tup((N, Fld(_, App(Var("+"), Tup((N, Fld(_, Var("w"))) :: (N, Fld(_, Var("y"))) :: Nil)))) :: (N, Fld(_, Var("z"))) :: Nil)))))))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1_B$2([par$A$1, z, y,]) {
@@ -111,7 +111,7 @@ fun f(x,y,z) =
 //│ |#fun| |f|(|x|,|y|,|z|)| |#=| |→|#class| |A|{|→|#fun| |foo| |#=| |#new| |B|↵|#fun| |bar1| |#=| |x|←|↵|}|↵|#class| |B|{|→|#fun| |foo| |#=| |#new| |A|↵|#fun| |bar2| |#=| |y|←|↵|}|↵|#class| |C| |#extends| |A|,| |B| |{|→|#fun| |bar| |#=| |bar1| |+| |bar2|←|↵|}|←|
 //│ Parsed: {fun f = (x, y, z,) => {class A {fun foo = new B; fun bar1 = x}; class B {fun foo = new A; fun bar2 = y}; class C: A, B {fun bar = +(bar1, bar2,)}}}
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, f, None, [], Lam(Tup(_: Var(x), _: Var(y), _: Var(z)), Blk(...))))
+//│ TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: (N, Fld(_, Var("z"))) :: Nil), Blk(NuTypeDef(Cls, TypeName("A"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(NuNew(Var("B")))), NuFunDef(None, bar1, N, Nil, L(Var("x"))))), NuTypeDef(Cls, TypeName("B"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(NuNew(Var("A")))), NuFunDef(None, bar2, N, Nil, L(Var("y"))))), NuTypeDef(Cls, TypeName("C"), Ls(), N, N, N, Ls(Var("A"), Var("B")), N, N, TypingUnit(NuFunDef(None, bar, N, Nil, L(App(Var("+"), Tup((N, Fld(_, Var("bar1"))) :: (N, Fld(_, Var("bar2"))) :: Nil)))))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1([x, y,]) {
@@ -142,7 +142,7 @@ fun f(x,y,z) =
 //│ |#fun| |f|(|x|,|y|,|z|)| |#=| |→|#class| |C|{|→|#class| |A|{|→|#fun| |foo| |#=| |#new| |B|↵|#fun| |bar1| |#=| |x|←|↵|}|↵|#class| |B|{|→|#fun| |foo| |#=| |#new| |A|↵|#fun| |bar2| |#=| |y|←|↵|}|↵|#fun| |boo| |#=| |(|#new| |A|)|.bar1| |+| |B|(||)|.bar2| |+| |z|←|↵|}|←|
 //│ Parsed: {fun f = (x, y, z,) => {class C {class A {fun foo = new B; fun bar1 = x}; class B {fun foo = new A; fun bar2 = y}; fun boo = +(+(('(' new A ')').bar1, (B()).bar2,), z,)}}}
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, f, None, [], Lam(Tup(_: Var(x), _: Var(y), _: Var(z)), Blk(...))))
+//│ TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: (N, Fld(_, Var("z"))) :: Nil), Blk(NuTypeDef(Cls, TypeName("C"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(NuNew(Var("B")))), NuFunDef(None, bar1, N, Nil, L(Var("x"))))), NuTypeDef(Cls, TypeName("B"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(NuNew(Var("A")))), NuFunDef(None, bar2, N, Nil, L(Var("y"))))), NuFunDef(None, boo, N, Nil, L(App(Var("+"), Tup((N, Fld(_, App(Var("+"), Tup((N, Fld(_, Sel(Bra(rcd = false, NuNew(Var("A"))), bar1))) :: (N, Fld(_, Sel(App(Var("B"), Tup(Nil)), bar2))) :: Nil)))) :: (N, Fld(_, Var("z"))) :: Nil)))))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class C$1_A$2([par$C$1,]) {
@@ -168,7 +168,7 @@ fun f(y) =
 //│ |#fun| |f|(|y|)| |#=|→|#let| |g|(|x|)| |#=| |x| |+| |y| |+| |1|↵|#class| |Foo|(|x|)| |{|→|#fun| |h| |#=| |g|(|x|)|←|↵|}|←|
 //│ Parsed: {fun f = (y,) => {let g = (x,) => +(+(x, y,), 1,); class Foo(x,) {fun h = g(x,)}}}
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, f, None, [], Lam(Tup(_: Var(y)), Blk(...))))
+//│ TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Fld(_, Var("y"))) :: Nil), Blk(NuFunDef(Some(false), g, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), App(Var("+"), Tup((N, Fld(_, App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil)))) :: (N, Fld(_, IntLit(1))) :: Nil))))), NuTypeDef(Cls, TypeName("Foo"), Ls(), S(Tup((N, Fld(_, Var("x"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, h, N, Nil, L(App(Var("g"), Tup((N, Fld(_, Var("x"))) :: Nil)))))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Foo$1([x, y,]) {fun h = () => g$2((this).x, y,)}
@@ -180,7 +180,7 @@ fun f(y) =
 //│ | |Foo|(|1|)|.h|
 //│ Parsed: {(Foo(1,)).h}
 //│ Parsed:
-//│ TypingUnit(Sel(App(Var(Foo), Tup(_: IntLit(1))), h))
+//│ TypingUnit(Sel(App(Var("Foo"), Tup((N, Fld(_, IntLit(1))) :: Nil)), h))
 //│ Lifted:
 //│ TypingUnit {Code(List((Foo(1,)).h))}
 //│ 
@@ -188,7 +188,7 @@ fun f(y) =
 //│ | |Foo|(|x|)|.h|
 //│ Parsed: {(Foo(x,)).h}
 //│ Parsed:
-//│ TypingUnit(Sel(App(Var(Foo), Tup(_: Var(x))), h))
+//│ TypingUnit(Sel(App(Var("Foo"), Tup((N, Fld(_, Var("x"))) :: Nil)), h))
 //│ Lifted:
 //│ TypingUnit {Code(List((Foo(x,)).h))}
 //│ 
@@ -204,7 +204,7 @@ fun f(x) =
 //│ |#fun| |f|(|x|)| |#=|→|#let| |g|(|x|)| |#=| |→|#let| |h|(|x|)| |#=| |x| |+| |2|↵|Foo|(|h|(|x|)|,| |x|)|.bar|←|↵|#class| |Foo|(|x|,| |y|)| |{|→|#fun| |bar| |#=| |g|(|x|)|+|y|←|↵|}|↵|Foo|(|x|,| |x|)|.bar|←|
 //│ Parsed: {fun f = (x,) => {let g = (x,) => {let h = (x,) => +(x, 2,); (Foo(h(x,), x,)).bar}; class Foo(x, y,) {fun bar = +(g(x,), y,)}; (Foo(x, x,)).bar}}
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, f, None, [], Lam(Tup(_: Var(x)), Blk(...))))
+//│ TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(NuFunDef(Some(false), g, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(NuFunDef(Some(false), h, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(2))) :: Nil))))), Sel(App(Var("Foo"), Tup((N, Fld(_, App(Var("h"), Tup((N, Fld(_, Var("x"))) :: Nil)))) :: (N, Fld(_, Var("x"))) :: Nil)), bar))))), NuTypeDef(Cls, TypeName("Foo"), Ls(), S(Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, bar, N, Nil, L(App(Var("+"), Tup((N, Fld(_, App(Var("g"), Tup((N, Fld(_, Var("x"))) :: Nil)))) :: (N, Fld(_, Var("y"))) :: Nil)))))), Sel(App(Var("Foo"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("x"))) :: Nil)), bar))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Foo$1([x, y,]) {fun bar = () => +(g$2((this).x,), (this).y,)}
@@ -218,7 +218,7 @@ class Foo(x, y) extends Bar(y, x), Baz(x + y)
 //│ |#class| |Foo|(|x|,| |y|)| |#extends| |Bar|(|y|,| |x|)|,| |Baz|(|x| |+| |y|)|
 //│ Parsed: {class Foo(x, y,): Bar(y, x,), Baz(+(x, y,),) {}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, Foo, (), Tup(_: Var(x), _: Var(y)), (App(Var(Bar), Tup(_: Var(y), _: Var(x))), App(Var(Baz), Tup(_: App(Var(+), Tup(_: Var(x), _: Var(y)))))), None, None, TypingUnit()))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("Foo"), Ls(), S(Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil)), N, N, Ls(App(Var("Bar"), Tup((N, Fld(_, Var("y"))) :: (N, Fld(_, Var("x"))) :: Nil)), App(Var("Baz"), Tup((N, Fld(_, App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil)))) :: Nil))), N, N, TypingUnit()))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Foo$1([x, y,]): Bar((this).y, (this).x,), Baz(+((this).x, (this).y,),) {}
@@ -233,7 +233,7 @@ fun foo<T, U>(x: T): string =
 //│ |#fun| |foo|‹|T|,| |U|›|(|x|#:| |T|)|#:| |string| |#=| |→|#class| |A|(|y|)| |#extends| |B|‹|T|›|,| |C|(|y|#:| |U|)| |{|→|#fun| |bar| |#=| |this|←|↵|}|↵|"rua"|←|
 //│ Parsed: {fun foo = (x: T,) => {class A(y,): B‹T›, C(y: U,) {fun bar = this}; "rua"} : string}
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, foo, None, [TypeName(T), TypeName(U)], Lam(Tup(x: Var(T)), Asc(Blk(...), TypeName(string)))))
+//│ TypingUnit(NuFunDef(None, foo, N, TypeName("T") :: TypeName("U") :: Nil, L(Lam(Tup((S(x), Fld(_, Var("T"))) :: Nil), Asc(Blk(NuTypeDef(Cls, TypeName("A"), Ls(), S(Tup((N, Fld(_, Var("y"))) :: Nil)), N, N, Ls(TyApp(Var("B"), List(TypeName(T))), App(Var("C"), Tup((S(y), Fld(_, Var("U"))) :: Nil))), N, N, TypingUnit(NuFunDef(None, bar, N, Nil, L(Var("this"))))), StrLit(rua)), TypeName(string))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1[T,U]([y,]): B‹T›, C(y: U,) {fun bar = () => this}
@@ -250,7 +250,7 @@ class A<T>{
 //│ |#class| |A|‹|T|›|{|→|#class| |B|{|→|#fun| |f| |#=| |x| |#=>| |y| |#=>| |x|↵|#fun| |g|#:| |T| |#=>| |B| |#=>| |T|←|↵|}|←|↵|}|
 //│ Parsed: {class A‹T› {class B {fun f = (x,) => (y,) => x; fun g: T -> B -> T}}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, A, ((None,TypeName(T))), Tup(), (), None, None, TypingUnit(NuTypeDef(class, B, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, f, None, [], Lam(Tup(_: Var(x)), Lam(Tup(_: Var(y)), Var(x)))), NuFunDef(None, g, None, [], PolyType(List(),Function(Tuple(List((None,Field(None,TypeName(T))))),Function(Tuple(List((None,Field(None,TypeName(B))))),TypeName(T))))))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(N -> TypeName("T")), N, N, N, Ls(), N, N, TypingUnit(NuTypeDef(Cls, TypeName("B"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Lam(Tup((N, Fld(_, Var("y"))) :: Nil), Var("x"))))), NuFunDef(None, g, N, Nil, R(PolyType(Ls(), Function(Tuple(N -> Fld(N, TypeName("T"))), Function(Tuple(N -> Fld(N, TypeName("B"))), TypeName("T")))))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1_B$2_Lambda1$1$3([par$A$1_B$2, x,]) {fun apply = (y,) => (this).x}
@@ -270,7 +270,7 @@ class Foo<T>{
 //│ |#class| |Foo|‹|T|›|{|→|#class| |RectangleBox|#:| |Box|‹|T|›| |&| |{| |breadth|#:| |T| |}|↵|#class| |StackedRectangleBoxes|‹|N|›| |#:| |RectangleBox|‹|T|›| |&| |{| |size|#:| |N| |}|↵|#class| |Bar|#:| |{|any|#:| |RectangleBox| |#=>| |StackedRectangleBoxes|}|←|↵|}|
 //│ Parsed: {class Foo‹T› {class RectangleBox: Box[T] & {breadth: T} {}; class StackedRectangleBoxes‹N›: RectangleBox[T] & {size: N} {}; class Bar: {any: RectangleBox -> StackedRectangleBoxes} {}}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, Foo, ((None,TypeName(T))), Tup(), (), None, None, TypingUnit(NuTypeDef(class, RectangleBox, (), Tup(), (), None, None, TypingUnit()), NuTypeDef(class, StackedRectangleBoxes, ((None,TypeName(N))), Tup(), (), None, None, TypingUnit()), NuTypeDef(class, Bar, (), Tup(), (), None, None, TypingUnit()))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("Foo"), Ls(N -> TypeName("T")), N, N, N, Ls(), N, N, TypingUnit(NuTypeDef(Cls, TypeName("RectangleBox"), Ls(), N, N, S(Inter(AppliedType(TypeName("Box"), TypeName("T") :: Nil), Record(breadth: Fld(N, TypeName("T"))))), Ls(), N, N, TypingUnit()), NuTypeDef(Cls, TypeName("StackedRectangleBoxes"), Ls(N -> TypeName("N")), N, N, S(Inter(AppliedType(TypeName("RectangleBox"), TypeName("T") :: Nil), Record(size: Fld(N, TypeName("N"))))), Ls(), N, N, TypingUnit()), NuTypeDef(Cls, TypeName("Bar"), Ls(), N, N, S(Record(any: Fld(N, Function(Tuple(N -> Fld(N, TypeName("RectangleBox"))), TypeName("StackedRectangleBoxes"))))), Ls(), N, N, TypingUnit()))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Foo$1_RectangleBox$2([par$Foo$1,]) {}
@@ -293,7 +293,7 @@ fun ctx(a,b) =
 //│ |#class| |Func|‹|T|,| |U|›| |{|→|#fun| |apply|#:| |T| |#=>| |U|←|↵|}|↵|#class| |Lambda|‹|T|,| |U|›| |#:| |Func|‹|T|,| |U|›| |{||}|↵|#fun| |ctx|(|a|,|b|)| |#=|→|#fun| |foo|(|f|#:| |Func|,| |x|)| |#=| |→|f|.apply|(|x|)|←|↵|foo|(|#new| |Lambda|{|→|#fun| |apply|(|x|)| |#=| |a|+|x|←|↵|}|,| |b|)|←|
 //│ Parsed: {class Func‹T, U› {fun apply: T -> U}; class Lambda‹T, U›: Func[T, U] {}; fun ctx = (a, b,) => {fun foo = (f: Func, x,) => {(f).apply(x,)}; foo(new Lambda { ‹fun apply = (x,) => +(a, x,)› }, b,)}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, Func, ((None,TypeName(T)), (None,TypeName(U))), Tup(), (), None, None, TypingUnit(NuFunDef(None, apply, None, [], PolyType(List(),Function(Tuple(List((None,Field(None,TypeName(T))))),TypeName(U)))))), NuTypeDef(class, Lambda, ((None,TypeName(T)), (None,TypeName(U))), Tup(), (), None, None, TypingUnit()), NuFunDef(None, ctx, None, [], Lam(Tup(_: Var(a), _: Var(b)), Blk(...))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("Func"), Ls(N -> TypeName("T"), N -> TypeName("U")), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, apply, N, Nil, R(PolyType(Ls(), Function(Tuple(N -> Fld(N, TypeName("T"))), TypeName("U"))))))), NuTypeDef(Cls, TypeName("Lambda"), Ls(N -> TypeName("T"), N -> TypeName("U")), N, N, S(AppliedType(TypeName("Func"), TypeName("T") :: TypeName("U") :: Nil)), Ls(), N, N, TypingUnit()), NuFunDef(None, ctx, N, Nil, L(Lam(Tup((N, Fld(_, Var("a"))) :: (N, Fld(_, Var("b"))) :: Nil), Blk(NuFunDef(None, foo, N, Nil, L(Lam(Tup((S(f), Fld(_, Var("Func"))) :: (N, Fld(_, Var("x"))) :: Nil), Blk(App(Sel(Var("f"), apply), Tup((N, Fld(_, Var("x"))) :: Nil)))))), App(Var("foo"), Tup((N, Fld(_, Rft(NuNew(Var("Lambda")), TypingUnit(NuFunDef(None, apply, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), App(Var("+"), Tup((N, Fld(_, Var("a"))) :: (N, Fld(_, Var("x"))) :: Nil))))))))) :: (N, Fld(_, Var("b"))) :: Nil)))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Func$1[T,U]([]) {fun apply = T -> U}
@@ -309,7 +309,7 @@ f(MyClass)
 //│ |#fun| |f|(|T|)| |#=| |→|#new| |T|(||)|←|↵|f|(|MyClass|)|
 //│ Parsed: {fun f = (T,) => {(new T)()}; f(MyClass,)}
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, f, None, [], Lam(Tup(_: Var(T)), Blk(...))), App(Var(f), Tup(_: Var(MyClass))))
+//│ TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Fld(_, Var("T"))) :: Nil), Blk(App(NuNew(Var("T")), Tup(Nil)))))), App(Var("f"), Tup((N, Fld(_, Var("MyClass"))) :: Nil)))
 //│ Lifted:
 //│ Lifting failed: mlscript.codegen.CodeGenError: Cannot find type T. Class values are not supported in lifter. 
 //│ 
@@ -322,7 +322,7 @@ class A {
 //│ |#class| |A| |{|→|#fun| |foo| |#=| |→|#fun| |bar| |#=| |foo|(||)|↵|bar|(||)|←|←|↵|}|
 //│ Parsed: {class A {fun foo = {fun bar = foo(); bar()}}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, A, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, foo, None, [], Blk(...)))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("A"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(Blk(NuFunDef(None, bar, N, Nil, L(App(Var("foo"), Tup(Nil)))), App(Var("bar"), Tup(Nil))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1([]) {fun foo = () => {bar$1(this,)}}
diff --git a/compiler/shared/test/diff/mono.mls b/compiler/shared/test/diff/mono.mls
index 780851b8a1..8514285f00 100644
--- a/compiler/shared/test/diff/mono.mls
+++ b/compiler/shared/test/diff/mono.mls
@@ -4,7 +4,7 @@
 :mono
 fun f(x: Int) = if x then 42 else 1337
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, f, None, [], Lam(Tup(x: Var(Int)), If(IfThen(Var(x), IntLit(42), Some(IntLit(1337))))))
+//│ TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((S(x), Fld(_, Var("Int"))) :: Nil), If(IfThen(Var("x"), IntLit(42), Some(IntLit(1337)))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   fun f$1 = (x: Int,) => if (x) then 42 else 1337
@@ -19,7 +19,7 @@ fun f(x: Int) = if x then 42 else 1337
 :mono
 fun foo() = 42
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, foo, None, [], Lam(Tup(), IntLit(42))))
+//│ TypingUnit(NuFunDef(None, foo, N, Nil, L(Lam(Tup(Nil), IntLit(42)))))
 //│ Lifted:
 //│ TypingUnit {fun foo$1 = () => 42}
 //│ Mono:
@@ -34,7 +34,7 @@ fun foo(x, #b) = if b then x else 1337
 let a = foo(42, true)
 let b = foo(23, false)
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, foo, None, [], Lam(Tup(_: Var(x), _: Var(b)), If(IfThen(Var(b), Var(x), Some(IntLit(1337))))), NuFunDef(Some(false), a, None, [], App(Var(foo), Tup(_: IntLit(42), _: Var(true)))), NuFunDef(Some(false), b, None, [], App(Var(foo), Tup(_: IntLit(23), _: Var(false)))))
+//│ TypingUnit(NuFunDef(None, foo, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("b"))) :: Nil), If(IfThen(Var("b"), Var("x"), Some(IntLit(1337)))))), NuFunDef(Some(false), a, N, Nil, L(App(Var("foo"), Tup((N, Fld(_, IntLit(42))) :: (N, Fld(_, Var("true"))) :: Nil)))), NuFunDef(Some(false), b, N, Nil, L(App(Var("foo"), Tup((N, Fld(_, IntLit(23))) :: (N, Fld(_, Var("false"))) :: Nil)))))
 //│ Lifted:
 //│ TypingUnit {
 //│   fun foo$3 = (x, #b,) => if (b) then x else 1337
@@ -61,7 +61,7 @@ let b = foo(23, false)
 :mono
 let x = 42 + 1337
 //│ Parsed:
-//│ TypingUnit(NuFunDef(Some(false), x, None, [], App(Var(+), Tup(_: IntLit(42), _: IntLit(1337)))))
+//│ TypingUnit(NuFunDef(Some(false), x, N, Nil, L(App(Var("+"), Tup((N, Fld(_, IntLit(42))) :: (N, Fld(_, IntLit(1337))) :: Nil)))))
 //│ Lifted:
 //│ TypingUnit {let x$1 = () => +(42, 1337,)}
 //│ Mono:
@@ -99,7 +99,7 @@ let x = 42 + 1337
 if true then 1 else 0
 if 1+1 > 1 then 1 - 1 else 1*1
 //│ Parsed:
-//│ TypingUnit(If(IfThen(Var(true), IntLit(1), Some(IntLit(0))), If(IfThen(App(Var(>), Tup(_: App(Var(+), Tup(_: IntLit(1), _: IntLit(1))), _: IntLit(1))), App(Var(-), Tup(_: IntLit(1), _: IntLit(1))), Some(App(Var(*), Tup(_: IntLit(1), _: IntLit(1))))))
+//│ TypingUnit(If(IfThen(Var("true"), IntLit(1), Some(IntLit(0))), If(IfThen(App(Var(">"), Tup((N, Fld(_, App(Var("+"), Tup((N, Fld(_, IntLit(1))) :: (N, Fld(_, IntLit(1))) :: Nil)))) :: (N, Fld(_, IntLit(1))) :: Nil)), App(Var("-"), Tup((N, Fld(_, IntLit(1))) :: (N, Fld(_, IntLit(1))) :: Nil)), Some(App(Var("*"), Tup((N, Fld(_, IntLit(1))) :: (N, Fld(_, IntLit(1))) :: Nil)))))
 //│ Lifted:
 //│ TypingUnit {
 //│   Code(List(if (true) then 1 else 0))
@@ -123,7 +123,7 @@ if 1+1 > 1 then 1 - 1 else 1*1
 :mono
 if(b) then 1 else 2
 //│ Parsed:
-//│ TypingUnit(If(IfThen(Bra(rcd = false, Var(b)), IntLit(1), Some(IntLit(2))))
+//│ TypingUnit(If(IfThen(Bra(rcd = false, Var("b")), IntLit(1), Some(IntLit(2))))
 //│ Lifted:
 //│ TypingUnit {Code(List(if ('(' b ')') then 1 else 2))}
 //│ Mono:
@@ -139,7 +139,7 @@ if(b) then 1 else 2
 :mono
 ((f, g) => f(g))(f => f, true)
 //│ Parsed:
-//│ TypingUnit(App(Bra(rcd = false, Lam(Tup(_: Var(f), _: Var(g)), App(Var(f), Tup(_: Var(g))))), Tup(_: Lam(Tup(_: Var(f)), Var(f)), _: Var(true))))
+//│ TypingUnit(App(Bra(rcd = false, Lam(Tup((N, Fld(_, Var("f"))) :: (N, Fld(_, Var("g"))) :: Nil), App(Var("f"), Tup((N, Fld(_, Var("g"))) :: Nil)))), Tup((N, Fld(_, Lam(Tup((N, Fld(_, Var("f"))) :: Nil), Var("f")))) :: (N, Fld(_, Var("true"))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Lambda2$1$1([]) {fun apply = (f, g,) => f(g,)}
@@ -168,7 +168,7 @@ if(b) then 1 else 2
 :mono
 (b => if b then true else false) (true)
 //│ Parsed:
-//│ TypingUnit(App(Bra(rcd = false, Lam(Tup(_: Var(b)), If(IfThen(Var(b), Var(true), Some(Var(false))))), Tup(_: Var(true))))
+//│ TypingUnit(App(Bra(rcd = false, Lam(Tup((N, Fld(_, Var("b"))) :: Nil), If(IfThen(Var("b"), Var("true"), Some(Var("false"))))), Tup((N, Fld(_, Var("true"))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Lambda1$1$1([]) {fun apply = (b,) => if (b) then true else false}
@@ -193,7 +193,7 @@ fun f(x) =
   if(x > 0) then x+1 else x - 1
 f(2)+3
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, f, None, [], Lam(Tup(_: Var(x)), Blk(...))), App(Var(+), Tup(_: App(Var(f), Tup(_: IntLit(2))), _: IntLit(3))))
+//│ TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(If(IfThen(Bra(rcd = false, App(Var(">"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(0))) :: Nil))), App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(1))) :: Nil)), Some(App(Var("-"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(1))) :: Nil)))))))), App(Var("+"), Tup((N, Fld(_, App(Var("f"), Tup((N, Fld(_, IntLit(2))) :: Nil)))) :: (N, Fld(_, IntLit(3))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   fun f$1 = (x,) => {if ('(' >(x, 0,) ')') then +(x, 1,) else -(x, 1,)}
@@ -217,7 +217,7 @@ fun fac(n) =
   if (n > 1) then fac(n - 1) * n else 1
 fac(2)
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, fac, None, [], Lam(Tup(_: Var(n)), Blk(...))), App(Var(fac), Tup(_: IntLit(2))))
+//│ TypingUnit(NuFunDef(None, fac, N, Nil, L(Lam(Tup((N, Fld(_, Var("n"))) :: Nil), Blk(If(IfThen(Bra(rcd = false, App(Var(">"), Tup((N, Fld(_, Var("n"))) :: (N, Fld(_, IntLit(1))) :: Nil))), App(Var("*"), Tup((N, Fld(_, App(Var("fac"), Tup((N, Fld(_, App(Var("-"), Tup((N, Fld(_, Var("n"))) :: (N, Fld(_, IntLit(1))) :: Nil)))) :: Nil)))) :: (N, Fld(_, Var("n"))) :: Nil)), Some(IntLit(1))))))), App(Var("fac"), Tup((N, Fld(_, IntLit(2))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   fun fac$1 = (n,) => {if ('(' >(n, 1,) ')') then *(fac$1(-(n, 1,),), n,) else 1}
@@ -246,7 +246,7 @@ fun count(lst) =
   else 0
 count(new List(new List(new Nil(undefined, false), true), true))
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, List, (), Tup(l: App(Var(|), Tup(_: App(Var(|), Tup(_: Var(List), _: Var(Nil))), _: UnitLit(true))), hasTail: Var(Bool)), (), None, None, TypingUnit()), NuTypeDef(class, Nil, (), Tup(l: App(Var(|), Tup(_: App(Var(|), Tup(_: Var(List), _: Var(Nil))), _: UnitLit(true))), hasTail: Var(Bool)), (), None, None, TypingUnit()), NuFunDef(None, count, None, [], Lam(Tup(_: Var(lst)), Blk(...))), App(Var(count), Tup(_: App(NuNew(Var(List)), Tup(_: App(NuNew(Var(List)), Tup(_: App(NuNew(Var(Nil)), Tup(_: UnitLit(true), _: Var(false))), _: Var(true))), _: Var(true))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("List"), Ls(), S(Tup((S(l), Fld(_, App(Var("|"), Tup((N, Fld(_, App(Var("|"), Tup((N, Fld(_, Var("List"))) :: (N, Fld(_, Var("Nil"))) :: Nil)))) :: (N, Fld(_, UnitLit(true))) :: Nil)))) :: (S(hasTail), Fld(_, Var("Bool"))) :: Nil)), N, N, Ls(), N, N, TypingUnit()), NuTypeDef(Cls, TypeName("Nil"), Ls(), S(Tup((S(l), Fld(_, App(Var("|"), Tup((N, Fld(_, App(Var("|"), Tup((N, Fld(_, Var("List"))) :: (N, Fld(_, Var("Nil"))) :: Nil)))) :: (N, Fld(_, UnitLit(true))) :: Nil)))) :: (S(hasTail), Fld(_, Var("Bool"))) :: Nil)), N, N, Ls(), N, N, TypingUnit()), NuFunDef(None, count, N, Nil, L(Lam(Tup((N, Fld(_, Var("lst"))) :: Nil), Blk(If(IfThen(Sel(Var("lst"), hasTail), Blk(NuFunDef(Some(false), l, N, Nil, L(Sel(Var("lst"), l))), If(IfThen(App(Var("is"), Tup((N, Fld(_, Var("l"))) :: (N, Fld(_, UnitLit(true))) :: Nil)), IntLit(1), Some(App(Var("+"), Tup((N, Fld(_, App(Var("count"), Tup((N, Fld(_, Var("l"))) :: Nil)))) :: (N, Fld(_, IntLit(1))) :: Nil))))), Some(IntLit(0))))))), App(Var("count"), Tup((N, Fld(_, App(NuNew(Var("List")), Tup((N, Fld(_, App(NuNew(Var("List")), Tup((N, Fld(_, App(NuNew(Var("Nil")), Tup((N, Fld(_, UnitLit(true))) :: (N, Fld(_, Var("false"))) :: Nil)))) :: (N, Fld(_, Var("true"))) :: Nil)))) :: (N, Fld(_, Var("true"))) :: Nil)))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class List$1([val l: |(|(List, Nil,), undefined,), val hasTail: Bool,]) {}
@@ -303,7 +303,7 @@ class Nil() {
 fun add2(x) = x+2
 (new List(1, new List(2, new Nil()))).map(x => x+1).map(x => add2(x))
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, List, (), Tup(e: Var(Int), tail: App(Var(|), Tup(_: Var(List), _: Var(Nil)))), (), None, None, TypingUnit(NuFunDef(None, map, None, [], PolyType(List(),Function(Tuple(List((None,Field(None,Function(Tuple(List((None,Field(None,TypeName(Int))))),TypeName(Int)))))),TypeName(List)))), NuFunDef(None, map, None, [], Lam(Tup(_: Var(f)), App(NuNew(Var(List)), Tup(_: App(Var(f), Tup(_: Var(e))), _: App(Sel(Var(tail), map), Tup(_: Var(f))))))), NuFunDef(None, count, None, [], PolyType(List(),Function(Tuple(List()),TypeName(Int)))), NuFunDef(None, count, None, [], Lam(Tup(), App(Var(+), Tup(_: IntLit(1), _: App(Sel(Var(tail), count), Tup()))))))), NuTypeDef(class, Nil, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, map, None, [], Lam(Tup(_: Var(f)), Var(this))), NuFunDef(None, count, None, [], Lam(Tup(), IntLit(0))))), NuFunDef(None, add2, None, [], Lam(Tup(_: Var(x)), App(Var(+), Tup(_: Var(x), _: IntLit(2))))), App(Sel(App(Sel(Bra(rcd = false, App(NuNew(Var(List)), Tup(_: IntLit(1), _: App(NuNew(Var(List)), Tup(_: IntLit(2), _: App(NuNew(Var(Nil)), Tup())))))), map), Tup(_: Lam(Tup(_: Var(x)), App(Var(+), Tup(_: Var(x), _: IntLit(1)))))), map), Tup(_: Lam(Tup(_: Var(x)), App(Var(add2), Tup(_: Var(x)))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("List"), Ls(), S(Tup((S(e), Fld(_, Var("Int"))) :: (S(tail), Fld(_, App(Var("|"), Tup((N, Fld(_, Var("List"))) :: (N, Fld(_, Var("Nil"))) :: Nil)))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, map, N, Nil, R(PolyType(Ls(), Function(Tuple(N -> Fld(N, Function(Tuple(N -> Fld(N, TypeName("Int"))), TypeName("Int")))), TypeName("List"))))), NuFunDef(None, map, N, Nil, L(Lam(Tup((N, Fld(_, Var("f"))) :: Nil), App(NuNew(Var("List")), Tup((N, Fld(_, App(Var("f"), Tup((N, Fld(_, Var("e"))) :: Nil)))) :: (N, Fld(_, App(Sel(Var("tail"), map), Tup((N, Fld(_, Var("f"))) :: Nil)))) :: Nil))))), NuFunDef(None, count, N, Nil, R(PolyType(Ls(), Function(Tuple(), TypeName("Int"))))), NuFunDef(None, count, N, Nil, L(Lam(Tup(Nil), App(Var("+"), Tup((N, Fld(_, IntLit(1))) :: (N, Fld(_, App(Sel(Var("tail"), count), Tup(Nil)))) :: Nil))))))), NuTypeDef(Cls, TypeName("Nil"), Ls(), S(Tup(Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, map, N, Nil, L(Lam(Tup((N, Fld(_, Var("f"))) :: Nil), Var("this")))), NuFunDef(None, count, N, Nil, L(Lam(Tup(Nil), IntLit(0)))))), NuFunDef(None, add2, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(2))) :: Nil))))), App(Sel(App(Sel(Bra(rcd = false, App(NuNew(Var("List")), Tup((N, Fld(_, IntLit(1))) :: (N, Fld(_, App(NuNew(Var("List")), Tup((N, Fld(_, IntLit(2))) :: (N, Fld(_, App(NuNew(Var("Nil")), Tup(Nil)))) :: Nil)))) :: Nil))), map), Tup((N, Fld(_, Lam(Tup((N, Fld(_, Var("x"))) :: Nil), App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(1))) :: Nil))))) :: Nil)), map), Tup((N, Fld(_, Lam(Tup((N, Fld(_, Var("x"))) :: Nil), App(Var("add2"), Tup((N, Fld(_, Var("x"))) :: Nil))))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class List$1([e: Int, tail: |(List, Nil,),]) {
@@ -370,7 +370,7 @@ fun generate(x) =
 foo(new List(1, new List(2, new Nil())))
 foo(generate(1))
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, List, (), Tup(e: Var(Int), tail: App(Var(|), Tup(_: Var(List), _: Var(Nil)))), (), None, None, TypingUnit(NuFunDef(None, count, None, [], PolyType(List(),Function(Tuple(List()),TypeName(Int)))), NuFunDef(None, count, None, [], Lam(Tup(), App(Var(+), Tup(_: IntLit(1), _: App(Sel(Var(tail), count), Tup()))))))), NuTypeDef(class, Nil, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, count, None, [], Lam(Tup(), IntLit(0))))), NuFunDef(None, foo, None, [], Lam(Tup(_: Var(x)), App(Sel(Var(x), count), Tup()))), NuFunDef(None, generate, None, [], Lam(Tup(_: Var(x)), Blk(...))), App(Var(foo), Tup(_: App(NuNew(Var(List)), Tup(_: IntLit(1), _: App(NuNew(Var(List)), Tup(_: IntLit(2), _: App(NuNew(Var(Nil)), Tup()))))))), App(Var(foo), Tup(_: App(Var(generate), Tup(_: IntLit(1))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("List"), Ls(), S(Tup((S(e), Fld(_, Var("Int"))) :: (S(tail), Fld(_, App(Var("|"), Tup((N, Fld(_, Var("List"))) :: (N, Fld(_, Var("Nil"))) :: Nil)))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, count, N, Nil, R(PolyType(Ls(), Function(Tuple(), TypeName("Int"))))), NuFunDef(None, count, N, Nil, L(Lam(Tup(Nil), App(Var("+"), Tup((N, Fld(_, IntLit(1))) :: (N, Fld(_, App(Sel(Var("tail"), count), Tup(Nil)))) :: Nil))))))), NuTypeDef(Cls, TypeName("Nil"), Ls(), S(Tup(Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, count, N, Nil, L(Lam(Tup(Nil), IntLit(0)))))), NuFunDef(None, foo, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), App(Sel(Var("x"), count), Tup(Nil))))), NuFunDef(None, generate, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(If(IfThen(App(Var(">"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(0))) :: Nil)), App(NuNew(Var("List")), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, App(Var("generate"), Tup((N, Fld(_, App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(1))) :: Nil)))) :: Nil)))) :: Nil)), Some(App(NuNew(Var("Nil")), Tup(Nil)))))))), App(Var("foo"), Tup((N, Fld(_, App(NuNew(Var("List")), Tup((N, Fld(_, IntLit(1))) :: (N, Fld(_, App(NuNew(Var("List")), Tup((N, Fld(_, IntLit(2))) :: (N, Fld(_, App(NuNew(Var("Nil")), Tup(Nil)))) :: Nil)))) :: Nil)))) :: Nil)), App(Var("foo"), Tup((N, Fld(_, App(Var("generate"), Tup((N, Fld(_, IntLit(1))) :: Nil)))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class List$1([e: Int, tail: |(List, Nil,),]) {
@@ -424,7 +424,7 @@ fun foo(x) =
   (f => f(x))(z => z+1)
 foo(2)
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, foo, None, [], Lam(Tup(_: Var(x)), Blk(...))), App(Var(foo), Tup(_: IntLit(2))))
+//│ TypingUnit(NuFunDef(None, foo, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(App(Bra(rcd = false, Lam(Tup((N, Fld(_, Var("f"))) :: Nil), App(Var("f"), Tup((N, Fld(_, Var("x"))) :: Nil)))), Tup((N, Fld(_, Lam(Tup((N, Fld(_, Var("z"))) :: Nil), App(Var("+"), Tup((N, Fld(_, Var("z"))) :: (N, Fld(_, IntLit(1))) :: Nil))))) :: Nil)))))), App(Var("foo"), Tup((N, Fld(_, IntLit(2))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Lambda1$2$1([x,]) {fun apply = (f,) => f((this).x,)}
@@ -458,7 +458,7 @@ fun f(x) =
   (y => f(x+y))(x+1)
 f(1)
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, f, None, [], Lam(Tup(_: Var(x)), Blk(...))), App(Var(f), Tup(_: IntLit(1))))
+//│ TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(App(Bra(rcd = false, Lam(Tup((N, Fld(_, Var("y"))) :: Nil), App(Var("f"), Tup((N, Fld(_, App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil)))) :: Nil)))), Tup((N, Fld(_, App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(1))) :: Nil)))) :: Nil)))))), App(Var("f"), Tup((N, Fld(_, IntLit(1))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Lambda1$2$1([x,]) {fun apply = (y,) => f$1(+((this).x, y,),)}
@@ -489,7 +489,7 @@ fun f(x) = f(x)
 f(0)
 f(1)
 //│ Parsed:
-//│ TypingUnit(NuFunDef(None, f, None, [], Lam(Tup(_: Var(x)), App(Var(f), Tup(_: Var(x))))), App(Var(f), Tup(_: IntLit(0))), App(Var(f), Tup(_: IntLit(1))))
+//│ TypingUnit(NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), App(Var("f"), Tup((N, Fld(_, Var("x"))) :: Nil))))), App(Var("f"), Tup((N, Fld(_, IntLit(0))) :: Nil)), App(Var("f"), Tup((N, Fld(_, IntLit(1))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   fun f$1 = (x,) => f$1(x,)
@@ -537,7 +537,7 @@ fun foo(x) =
 foo(new Lambda())
 foo(new Lambda2(2))
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, Cons, (), Tup(e: Var('A), tail: App(Var(|), Tup(_: Var(Cons), _: Var(Nil)))), (), None, None, TypingUnit(NuFunDef(None, count, None, [], PolyType(List(),Function(Tuple(List()),TypeName(Int)))), NuFunDef(None, count, None, [], Lam(Tup(), App(Var(+), Tup(_: IntLit(1), _: App(Sel(Var(tail), count), Tup()))))))), NuTypeDef(class, Nil, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, count, None, [], Lam(Tup(), IntLit(0))))), NuTypeDef(class, Lambda, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, apply, None, [], Lam(Tup(_: Var(l)), Blk(...))))), NuTypeDef(class, Lambda2, (), Tup(a: Var(Int)), (), None, None, TypingUnit(NuFunDef(None, apply, None, [], Lam(Tup(_: Var(l)), Blk(...))))), NuFunDef(None, foo, None, [], Lam(Tup(_: Var(x)), Blk(...))), App(Var(foo), Tup(_: App(NuNew(Var(Lambda)), Tup()))), App(Var(foo), Tup(_: App(NuNew(Var(Lambda2)), Tup(_: IntLit(2))))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("Cons"), Ls(), S(Tup((S(e), Fld(_, Var("'A"))) :: (S(tail), Fld(_, App(Var("|"), Tup((N, Fld(_, Var("Cons"))) :: (N, Fld(_, Var("Nil"))) :: Nil)))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, count, N, Nil, R(PolyType(Ls(), Function(Tuple(), TypeName("Int"))))), NuFunDef(None, count, N, Nil, L(Lam(Tup(Nil), App(Var("+"), Tup((N, Fld(_, IntLit(1))) :: (N, Fld(_, App(Sel(Var("tail"), count), Tup(Nil)))) :: Nil))))))), NuTypeDef(Cls, TypeName("Nil"), Ls(), S(Tup(Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, count, N, Nil, L(Lam(Tup(Nil), IntLit(0)))))), NuTypeDef(Cls, TypeName("Lambda"), Ls(), S(Tup(Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, apply, N, Nil, L(Lam(Tup((N, Fld(_, Var("l"))) :: Nil), Blk(App(Sel(Var("l"), count), Tup(Nil)))))))), NuTypeDef(Cls, TypeName("Lambda2"), Ls(), S(Tup((S(a), Fld(_, Var("Int"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, apply, N, Nil, L(Lam(Tup((N, Fld(_, Var("l"))) :: Nil), Blk(App(Sel(Bra(rcd = false, App(NuNew(Var("Cons")), Tup((N, Fld(_, Var("a"))) :: (N, Fld(_, Var("l"))) :: Nil))), count), Tup(Nil)))))))), NuFunDef(None, foo, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(App(Var("+"), Tup((N, Fld(_, App(Sel(Var("x"), apply), Tup((N, Fld(_, App(NuNew(Var("Cons")), Tup((N, Fld(_, IntLit(1))) :: (N, Fld(_, App(NuNew(Var("Nil")), Tup(Nil)))) :: Nil)))) :: Nil)))) :: (N, Fld(_, App(Sel(Var("x"), apply), Tup((N, Fld(_, App(NuNew(Var("Nil")), Tup(Nil)))) :: Nil)))) :: Nil)))))), App(Var("foo"), Tup((N, Fld(_, App(NuNew(Var("Lambda")), Tup(Nil)))) :: Nil)), App(Var("foo"), Tup((N, Fld(_, App(NuNew(Var("Lambda2")), Tup((N, Fld(_, IntLit(2))) :: Nil)))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Cons$1([e: 'A, tail: |(Cons, Nil,),]) {
@@ -612,7 +612,7 @@ fun foo(x) =
 foo(l => l.count())
 foo(l => (new Cons(2, l)).count())
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, Cons, (), Tup(e: Var(Int), tail: App(Var(|), Tup(_: Var(Cons), _: Var(Nil)))), (), None, None, TypingUnit(NuFunDef(None, count, None, [], PolyType(List(),Function(Tuple(List()),TypeName(Int)))), NuFunDef(None, count, None, [], Lam(Tup(), App(Var(+), Tup(_: IntLit(1), _: App(Sel(Var(tail), count), Tup()))))))), NuTypeDef(class, Nil, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, count, None, [], Lam(Tup(), IntLit(0))))), NuFunDef(None, foo, None, [], Lam(Tup(_: Var(x)), Blk(...))), App(Var(foo), Tup(_: Lam(Tup(_: Var(l)), App(Sel(Var(l), count), Tup())))), App(Var(foo), Tup(_: Lam(Tup(_: Var(l)), App(Sel(Bra(rcd = false, App(NuNew(Var(Cons)), Tup(_: IntLit(2), _: Var(l)))), count), Tup())))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("Cons"), Ls(), S(Tup((S(e), Fld(_, Var("Int"))) :: (S(tail), Fld(_, App(Var("|"), Tup((N, Fld(_, Var("Cons"))) :: (N, Fld(_, Var("Nil"))) :: Nil)))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, count, N, Nil, R(PolyType(Ls(), Function(Tuple(), TypeName("Int"))))), NuFunDef(None, count, N, Nil, L(Lam(Tup(Nil), App(Var("+"), Tup((N, Fld(_, IntLit(1))) :: (N, Fld(_, App(Sel(Var("tail"), count), Tup(Nil)))) :: Nil))))))), NuTypeDef(Cls, TypeName("Nil"), Ls(), S(Tup(Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, count, N, Nil, L(Lam(Tup(Nil), IntLit(0)))))), NuFunDef(None, foo, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(App(Var("+"), Tup((N, Fld(_, App(Var("x"), Tup((N, Fld(_, App(NuNew(Var("Cons")), Tup((N, Fld(_, IntLit(1))) :: (N, Fld(_, App(NuNew(Var("Nil")), Tup(Nil)))) :: Nil)))) :: Nil)))) :: (N, Fld(_, App(Var("x"), Tup((N, Fld(_, App(NuNew(Var("Nil")), Tup(Nil)))) :: Nil)))) :: Nil)))))), App(Var("foo"), Tup((N, Fld(_, Lam(Tup((N, Fld(_, Var("l"))) :: Nil), App(Sel(Var("l"), count), Tup(Nil))))) :: Nil)), App(Var("foo"), Tup((N, Fld(_, Lam(Tup((N, Fld(_, Var("l"))) :: Nil), App(Sel(Bra(rcd = false, App(NuNew(Var("Cons")), Tup((N, Fld(_, IntLit(2))) :: (N, Fld(_, Var("l"))) :: Nil))), count), Tup(Nil))))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Cons$1([e: Int, tail: |(Cons, Nil,),]) {
@@ -707,7 +707,7 @@ class C(e1: Exp, e2: Exp) extends Exp {
 }
 (new C(new Ch(1), new A(new Ch(2), new Ch(3)))).derive(0).isEmpty()
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, Exp, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, derive, None, [], PolyType(List(),Function(Tuple(List((Some(x),Field(None,TypeName(Int))))),TypeName(Exp)))), NuFunDef(None, derive, None, [], Lam(Tup(x: Var(Int)), App(Var(Exp), Tup()))), NuFunDef(None, isEmpty, None, [], PolyType(List(),Function(Tuple(List()),TypeName(Bool)))), NuFunDef(None, isEmpty, None, [], Lam(Tup(), Var(false))))), NuTypeDef(class, E, (), Tup(), (Var(Exp)), None, None, TypingUnit(NuFunDef(None, derive, None, [], Lam(Tup(_: Var(x)), Blk(...))), NuFunDef(None, isEmpty, None, [], Lam(Tup(), Blk(...))))), NuTypeDef(class, Ep, (), Tup(), (Var(Exp)), None, None, TypingUnit(NuFunDef(None, derive, None, [], Lam(Tup(_: Var(x)), Blk(...))), NuFunDef(None, isEmpty, None, [], Lam(Tup(), Blk(...))))), NuTypeDef(class, Ch, (), Tup(i: Var(Int)), (Var(Exp)), None, None, TypingUnit(NuFunDef(None, derive, None, [], Lam(Tup(_: Var(x)), Blk(...))), NuFunDef(None, isEmpty, None, [], Lam(Tup(), Blk(...))))), NuTypeDef(class, A, (), Tup(e1: Var(Exp), e2: Var(Exp)), (Var(Exp)), None, None, TypingUnit(NuFunDef(None, derive, None, [], Lam(Tup(_: Var(x)), Blk(...))), NuFunDef(None, isEmpty, None, [], Lam(Tup(), Blk(...))))), NuTypeDef(class, C, (), Tup(e1: Var(Exp), e2: Var(Exp)), (Var(Exp)), None, None, TypingUnit(NuFunDef(None, derive, None, [], Lam(Tup(_: Var(x)), Blk(...))), NuFunDef(None, isEmpty, None, [], Lam(Tup(), Blk(...))))), App(Sel(App(Sel(Bra(rcd = false, App(NuNew(Var(C)), Tup(_: App(NuNew(Var(Ch)), Tup(_: IntLit(1))), _: App(NuNew(Var(A)), Tup(_: App(NuNew(Var(Ch)), Tup(_: IntLit(2))), _: App(NuNew(Var(Ch)), Tup(_: IntLit(3)))))))), derive), Tup(_: IntLit(0))), isEmpty), Tup()))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("Exp"), Ls(), S(Tup(Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, derive, N, Nil, R(PolyType(Ls(), Function(Tuple(S(x) -> Fld(N, TypeName("Int"))), TypeName("Exp"))))), NuFunDef(None, derive, N, Nil, L(Lam(Tup((S(x), Fld(_, Var("Int"))) :: Nil), App(Var("Exp"), Tup(Nil))))), NuFunDef(None, isEmpty, N, Nil, R(PolyType(Ls(), Function(Tuple(), TypeName("Bool"))))), NuFunDef(None, isEmpty, N, Nil, L(Lam(Tup(Nil), Var("false")))))), NuTypeDef(Cls, TypeName("E"), Ls(), S(Tup(Nil)), N, N, Ls(Var("Exp")), N, N, TypingUnit(NuFunDef(None, derive, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(NuNew(Var("E")))))), NuFunDef(None, isEmpty, N, Nil, L(Lam(Tup(Nil), Blk(Var("false"))))))), NuTypeDef(Cls, TypeName("Ep"), Ls(), S(Tup(Nil)), N, N, Ls(Var("Exp")), N, N, TypingUnit(NuFunDef(None, derive, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(NuNew(Var("E")))))), NuFunDef(None, isEmpty, N, Nil, L(Lam(Tup(Nil), Blk(Var("true"))))))), NuTypeDef(Cls, TypeName("Ch"), Ls(), S(Tup((S(i), Fld(_, Var("Int"))) :: Nil)), N, N, Ls(Var("Exp")), N, N, TypingUnit(NuFunDef(None, derive, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(If(IfThen(App(Var("=="), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("i"))) :: Nil)), NuNew(Var("Ep")), Some(NuNew(Var("E")))))))), NuFunDef(None, isEmpty, N, Nil, L(Lam(Tup(Nil), Blk(Var("false"))))))), NuTypeDef(Cls, TypeName("A"), Ls(), S(Tup((S(e1), Fld(_, Var("Exp"))) :: (S(e2), Fld(_, Var("Exp"))) :: Nil)), N, N, Ls(Var("Exp")), N, N, TypingUnit(NuFunDef(None, derive, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(App(NuNew(Var("A")), Tup((N, Fld(_, App(Sel(Var("e1"), derive), Tup((N, Fld(_, Var("x"))) :: Nil)))) :: (N, Fld(_, App(Sel(Var("e2"), derive), Tup((N, Fld(_, Var("x"))) :: Nil)))) :: Nil)))))), NuFunDef(None, isEmpty, N, Nil, L(Lam(Tup(Nil), Blk(App(Var("||"), Tup((N, Fld(_, App(Sel(Var("e1"), isEmpty), Tup(Nil)))) :: (N, Fld(_, App(Sel(Var("e2"), isEmpty), Tup(Nil)))) :: Nil)))))))), NuTypeDef(Cls, TypeName("C"), Ls(), S(Tup((S(e1), Fld(_, Var("Exp"))) :: (S(e2), Fld(_, Var("Exp"))) :: Nil)), N, N, Ls(Var("Exp")), N, N, TypingUnit(NuFunDef(None, derive, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(If(IfThen(App(Sel(Var("e1"), isEmpty), Tup(Nil)), App(NuNew(Var("A")), Tup((N, Fld(_, App(NuNew(Var("C")), Tup((N, Fld(_, App(Sel(Var("e1"), derive), Tup((N, Fld(_, Var("x"))) :: Nil)))) :: (N, Fld(_, Var("e2"))) :: Nil)))) :: (N, Fld(_, App(Sel(Var("e2"), derive), Tup((N, Fld(_, Var("x"))) :: Nil)))) :: Nil)), Some(App(NuNew(Var("C")), Tup((N, Fld(_, App(Sel(Var("e1"), derive), Tup((N, Fld(_, Var("x"))) :: Nil)))) :: (N, Fld(_, Var("e2"))) :: Nil)))))))), NuFunDef(None, isEmpty, N, Nil, L(Lam(Tup(Nil), Blk(App(Var("&&"), Tup((N, Fld(_, App(Sel(Var("e1"), isEmpty), Tup(Nil)))) :: (N, Fld(_, App(Sel(Var("e2"), isEmpty), Tup(Nil)))) :: Nil)))))))), App(Sel(App(Sel(Bra(rcd = false, App(NuNew(Var("C")), Tup((N, Fld(_, App(NuNew(Var("Ch")), Tup((N, Fld(_, IntLit(1))) :: Nil)))) :: (N, Fld(_, App(NuNew(Var("A")), Tup((N, Fld(_, App(NuNew(Var("Ch")), Tup((N, Fld(_, IntLit(2))) :: Nil)))) :: (N, Fld(_, App(NuNew(Var("Ch")), Tup((N, Fld(_, IntLit(3))) :: Nil)))) :: Nil)))) :: Nil))), derive), Tup((N, Fld(_, IntLit(0))) :: Nil)), isEmpty), Tup(Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Exp$1([]) {
@@ -809,7 +809,7 @@ fun gen() =
   if anyUnknown then new List(gen(), true) else new Nil(false)
 gen()
 //│ Parsed:
-//│ TypingUnit(NuFunDef(Some(false), anyUnknown, None, [], Var(false)), NuTypeDef(class, List, (), Tup(l: App(Var(|), Tup(_: Var(List), _: Var(Nil))), hasTail: Var(Bool)), (), None, None, TypingUnit()), NuTypeDef(class, Nil, (), Tup(hasTail: Var(Bool)), (), None, None, TypingUnit()), NuFunDef(None, gen, None, [], Lam(Tup(), Blk(...))), App(Var(gen), Tup()))
+//│ TypingUnit(NuFunDef(Some(false), anyUnknown, N, Nil, L(Var("false"))), NuTypeDef(Cls, TypeName("List"), Ls(), S(Tup((S(l), Fld(_, App(Var("|"), Tup((N, Fld(_, Var("List"))) :: (N, Fld(_, Var("Nil"))) :: Nil)))) :: (S(hasTail), Fld(_, Var("Bool"))) :: Nil)), N, N, Ls(), N, N, TypingUnit()), NuTypeDef(Cls, TypeName("Nil"), Ls(), S(Tup((S(hasTail), Fld(_, Var("Bool"))) :: Nil)), N, N, Ls(), N, N, TypingUnit()), NuFunDef(None, gen, N, Nil, L(Lam(Tup(Nil), Blk(If(IfThen(Var("anyUnknown"), App(NuNew(Var("List")), Tup((N, Fld(_, App(Var("gen"), Tup(Nil)))) :: (N, Fld(_, Var("true"))) :: Nil)), Some(App(NuNew(Var("Nil")), Tup((N, Fld(_, Var("false"))) :: Nil)))))))), App(Var("gen"), Tup(Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class List$1([l: |(List, Nil,), hasTail: Bool,]) {}
@@ -851,7 +851,7 @@ class Foo(x: Int){
 }
 (new Foo(1)).boo(2)
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, Foo, (), Tup(x: Var(Int)), (), None, None, TypingUnit(NuFunDef(None, bar, None, [], Lam(Tup(_: Var(y)), App(Var(+), Tup(_: Var(x), _: Var(y))))), NuFunDef(None, boo, None, [], Lam(Tup(_: Var(z)), App(Var(+), Tup(_: App(Var(bar), Tup(_: Var(z))), _: Var(x))))))), App(Sel(Bra(rcd = false, App(NuNew(Var(Foo)), Tup(_: IntLit(1)))), boo), Tup(_: IntLit(2))))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("Foo"), Ls(), S(Tup((S(x), Fld(_, Var("Int"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, bar, N, Nil, L(Lam(Tup((N, Fld(_, Var("y"))) :: Nil), App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil))))), NuFunDef(None, boo, N, Nil, L(Lam(Tup((N, Fld(_, Var("z"))) :: Nil), App(Var("+"), Tup((N, Fld(_, App(Var("bar"), Tup((N, Fld(_, Var("z"))) :: Nil)))) :: (N, Fld(_, Var("x"))) :: Nil))))))), App(Sel(Bra(rcd = false, App(NuNew(Var("Foo")), Tup((N, Fld(_, IntLit(1))) :: Nil))), boo), Tup((N, Fld(_, IntLit(2))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Foo$1([x: Int,]) {
@@ -888,7 +888,7 @@ class OneInt(a: Int){
 }
 (new OneInt(10)).fac()
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, OneInt, (), Tup(a: Var(Int)), (), None, None, TypingUnit(NuFunDef(None, fac, None, [], PolyType(List(),Function(Tuple(List()),TypeName(Int)))), NuFunDef(None, fac, None, [], Lam(Tup(), Blk(...))))), App(Sel(Bra(rcd = false, App(NuNew(Var(OneInt)), Tup(_: IntLit(10)))), fac), Tup()))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("OneInt"), Ls(), S(Tup((S(a), Fld(_, Var("Int"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, fac, N, Nil, R(PolyType(Ls(), Function(Tuple(), TypeName("Int"))))), NuFunDef(None, fac, N, Nil, L(Lam(Tup(Nil), Blk(If(IfThen(Bra(rcd = false, App(Var(">"), Tup((N, Fld(_, Var("a"))) :: (N, Fld(_, IntLit(0))) :: Nil))), App(Sel(Bra(rcd = false, App(NuNew(Var("OneInt")), Tup((N, Fld(_, App(Var("-"), Tup((N, Fld(_, Var("a"))) :: (N, Fld(_, IntLit(1))) :: Nil)))) :: Nil))), fac), Tup(Nil)), Some(IntLit(1))))))))), App(Sel(Bra(rcd = false, App(NuNew(Var("OneInt")), Tup((N, Fld(_, IntLit(10))) :: Nil))), fac), Tup(Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class OneInt$1([a: Int,]) {
@@ -938,7 +938,7 @@ fun g(x) =
   else f(x - 2)
 g(1)
 //│ Parsed:
-//│ TypingUnit(NuFunDef(Some(false), any, None, [], IntLit(-20)), NuFunDef(None, f, None, [], Lam(Tup(_: Var(x)), Blk(...))), NuFunDef(None, g, None, [], Lam(Tup(_: Var(x)), Blk(...))), App(Var(g), Tup(_: IntLit(1))))
+//│ TypingUnit(NuFunDef(Some(false), any, N, Nil, L(IntLit(-20))), NuFunDef(None, f, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(If(IfThen(App(Var(">"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("any"))) :: Nil)), IntLit(0), Some(App(Var("g"), Tup((N, Fld(_, App(Var("-"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(1))) :: Nil)))) :: Nil)))))))), NuFunDef(None, g, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Blk(If(IfThen(App(Var(">"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("any"))) :: Nil)), App(Var("g"), Tup((N, Fld(_, App(Var("-"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(1))) :: Nil)))) :: Nil)), Some(App(Var("f"), Tup((N, Fld(_, App(Var("-"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(2))) :: Nil)))) :: Nil)))))))), App(Var("g"), Tup((N, Fld(_, IntLit(1))) :: Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   let any$3 = () => -20
@@ -977,7 +977,7 @@ class OneBool(b: Bool){
 }
 (if b then new OneInt(1) else new OneBool(true)).get()
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, OneInt, (), Tup(a: Var(Int)), (), None, None, TypingUnit(NuFunDef(None, get, None, [], Lam(Tup(), Var(a))))), NuTypeDef(class, OneBool, (), Tup(b: Var(Bool)), (), None, None, TypingUnit(NuFunDef(None, get, None, [], Lam(Tup(), Var(b))))), App(Sel(Bra(rcd = false, If(IfThen(Var(b), App(NuNew(Var(OneInt)), Tup(_: IntLit(1))), Some(App(NuNew(Var(OneBool)), Tup(_: Var(true)))))), get), Tup()))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("OneInt"), Ls(), S(Tup((S(a), Fld(_, Var("Int"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, get, N, Nil, L(Lam(Tup(Nil), Var("a")))))), NuTypeDef(Cls, TypeName("OneBool"), Ls(), S(Tup((S(b), Fld(_, Var("Bool"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, get, N, Nil, L(Lam(Tup(Nil), Var("b")))))), App(Sel(Bra(rcd = false, If(IfThen(Var("b"), App(NuNew(Var("OneInt")), Tup((N, Fld(_, IntLit(1))) :: Nil)), Some(App(NuNew(Var("OneBool")), Tup((N, Fld(_, Var("true"))) :: Nil))))), get), Tup(Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class OneInt$1([a: Int,]) {fun get = () => (this).a}
@@ -1023,7 +1023,7 @@ baz(bar)
 (new Car()).da(Bar(1337))
 bar.car
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, Bar, (), Tup(x: Var(Int)), (), None, None, TypingUnit(NuFunDef(None, foo, None, [], Lam(Tup(_: Var(x)), Var(x))), NuFunDef(None, FooMinus, None, [], Lam(Tup(y: Var(Int)), App(Var(+), Tup(_: Var(x), _: Var(y))))), NuFunDef(None, car, None, [], App(Var(foo), Tup(_: IntLit(2)))))), NuTypeDef(class, Car, (), Tup(), (), None, None, TypingUnit(NuFunDef(None, da, None, [], Lam(Tup(b: Var(Bar)), App(Sel(Var(b), foo), Tup(_: IntLit(2))))))), NuFunDef(None, baz, None, [], Lam(Tup(b: Var(Bar)), App(Sel(Var(b), foo), Tup(_: IntLit(2))))), NuFunDef(Some(false), bar, None, [], App(Var(Bar), Tup(_: IntLit(42)))), App(Var(baz), Tup(_: Var(bar))), App(Sel(Bra(rcd = false, App(NuNew(Var(Car)), Tup())), da), Tup(_: App(Var(Bar), Tup(_: IntLit(1337))))), Sel(Var(bar), car))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("Bar"), Ls(), S(Tup((S(x), Fld(_, Var("Int"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(Lam(Tup((N, Fld(_, Var("x"))) :: Nil), Var("x")))), NuFunDef(None, FooMinus, N, Nil, L(Lam(Tup((S(y), Fld(_, Var("Int"))) :: Nil), App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, Var("y"))) :: Nil))))), NuFunDef(None, car, N, Nil, L(App(Var("foo"), Tup((N, Fld(_, IntLit(2))) :: Nil)))))), NuTypeDef(Cls, TypeName("Car"), Ls(), N, N, N, Ls(), N, N, TypingUnit(NuFunDef(None, da, N, Nil, L(Lam(Tup((S(b), Fld(_, Var("Bar"))) :: Nil), App(Sel(Var("b"), foo), Tup((N, Fld(_, IntLit(2))) :: Nil))))))), NuFunDef(None, baz, N, Nil, L(Lam(Tup((S(b), Fld(_, Var("Bar"))) :: Nil), App(Sel(Var("b"), foo), Tup((N, Fld(_, IntLit(2))) :: Nil))))), NuFunDef(Some(false), bar, N, Nil, L(App(Var("Bar"), Tup((N, Fld(_, IntLit(42))) :: Nil)))), App(Var("baz"), Tup((N, Fld(_, Var("bar"))) :: Nil)), App(Sel(Bra(rcd = false, App(NuNew(Var("Car")), Tup(Nil))), da), Tup((N, Fld(_, App(Var("Bar"), Tup((N, Fld(_, IntLit(1337))) :: Nil)))) :: Nil)), Sel(Var("bar"), car))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Bar$1([x: Int,]) {
@@ -1094,7 +1094,7 @@ class Sub2(c: Int) extends Sub(c+c){
 (new Sub(10)).foo()
 (new Sub2(c)).foo()
 //│ Parsed:
-//│ TypingUnit(NuFunDef(Some(false), c, None, [], IntLit(5)), NuTypeDef(class, Sup, (), Tup(a: Var(Int)), (), None, None, TypingUnit(NuFunDef(None, foo, None, [], Lam(Tup(), Var(a))))), NuTypeDef(class, Sub, (), Tup(b: Var(Int)), (App(Var(Sup), Tup(_: App(Var(+), Tup(_: Var(b), _: Var(b)))))), None, None, TypingUnit()), NuTypeDef(class, Sub2, (), Tup(c: Var(Int)), (App(Var(Sub), Tup(_: App(Var(+), Tup(_: Var(c), _: Var(c)))))), None, None, TypingUnit(NuFunDef(None, foo, None, [], Lam(Tup(), App(Var(+), Tup(_: Var(a), _: Var(c))))))), App(Sel(Bra(rcd = false, App(NuNew(Var(Sub)), Tup(_: IntLit(10)))), foo), Tup()), App(Sel(Bra(rcd = false, App(NuNew(Var(Sub2)), Tup(_: Var(c)))), foo), Tup()))
+//│ TypingUnit(NuFunDef(Some(false), c, N, Nil, L(IntLit(5))), NuTypeDef(Cls, TypeName("Sup"), Ls(), S(Tup((S(a), Fld(_, Var("Int"))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(Lam(Tup(Nil), Var("a")))))), NuTypeDef(Cls, TypeName("Sub"), Ls(), S(Tup((S(b), Fld(_, Var("Int"))) :: Nil)), N, N, Ls(App(Var("Sup"), Tup((N, Fld(_, App(Var("+"), Tup((N, Fld(_, Var("b"))) :: (N, Fld(_, Var("b"))) :: Nil)))) :: Nil))), N, N, TypingUnit()), NuTypeDef(Cls, TypeName("Sub2"), Ls(), S(Tup((S(c), Fld(_, Var("Int"))) :: Nil)), N, N, Ls(App(Var("Sub"), Tup((N, Fld(_, App(Var("+"), Tup((N, Fld(_, Var("c"))) :: (N, Fld(_, Var("c"))) :: Nil)))) :: Nil))), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(Lam(Tup(Nil), App(Var("+"), Tup((N, Fld(_, Var("a"))) :: (N, Fld(_, Var("c"))) :: Nil))))))), App(Sel(Bra(rcd = false, App(NuNew(Var("Sub")), Tup((N, Fld(_, IntLit(10))) :: Nil))), foo), Tup(Nil)), App(Sel(Bra(rcd = false, App(NuNew(Var("Sub2")), Tup((N, Fld(_, Var("c"))) :: Nil))), foo), Tup(Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Sup$1([a: Int,]) {fun foo = () => (this).a}
@@ -1152,7 +1152,7 @@ class F2() extends Foo(x => x+2){}
 (new F1()).foo()
 (new F2()).foo()
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, Foo, (), Tup(f: App(Var(->), Tup(_: Var(Int), _: Var(Int)))), (), None, None, TypingUnit(NuFunDef(None, foo, None, [], Lam(Tup(), App(Var(f), Tup(_: IntLit(1))))))), NuTypeDef(class, F1, (), Tup(), (App(Var(Foo), Tup(_: Lam(Tup(_: Var(x)), App(Var(+), Tup(_: Var(x), _: IntLit(1))))))), None, None, TypingUnit()), NuTypeDef(class, F2, (), Tup(), (App(Var(Foo), Tup(_: Lam(Tup(_: Var(x)), App(Var(+), Tup(_: Var(x), _: IntLit(2))))))), None, None, TypingUnit()), App(Sel(Bra(rcd = false, App(NuNew(Var(F1)), Tup())), foo), Tup()), App(Sel(Bra(rcd = false, App(NuNew(Var(F2)), Tup())), foo), Tup()))
+//│ TypingUnit(NuTypeDef(Cls, TypeName("Foo"), Ls(), S(Tup((S(f), Fld(_, App(Var("->"), Tup((N, Fld(_, Var("Int"))) :: (N, Fld(_, Var("Int"))) :: Nil)))) :: Nil)), N, N, Ls(), N, N, TypingUnit(NuFunDef(None, foo, N, Nil, L(Lam(Tup(Nil), App(Var("f"), Tup((N, Fld(_, IntLit(1))) :: Nil))))))), NuTypeDef(Cls, TypeName("F1"), Ls(), S(Tup(Nil)), N, N, Ls(App(Var("Foo"), Tup((N, Fld(_, Lam(Tup((N, Fld(_, Var("x"))) :: Nil), App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(1))) :: Nil))))) :: Nil))), N, N, TypingUnit()), NuTypeDef(Cls, TypeName("F2"), Ls(), S(Tup(Nil)), N, N, Ls(App(Var("Foo"), Tup((N, Fld(_, Lam(Tup((N, Fld(_, Var("x"))) :: Nil), App(Var("+"), Tup((N, Fld(_, Var("x"))) :: (N, Fld(_, IntLit(2))) :: Nil))))) :: Nil))), N, N, TypingUnit()), App(Sel(Bra(rcd = false, App(NuNew(Var("F1")), Tup(Nil))), foo), Tup(Nil)), App(Sel(Bra(rcd = false, App(NuNew(Var("F2")), Tup(Nil))), foo), Tup(Nil)))
 //│ Lifted:
 //│ TypingUnit {
 //│   class Foo$1([f: ->(Int, Int,),]) {fun foo = () => (this).f(1,)}

From abc352f9f38aabcc8e91a698e18a18ec0ec5b6ad Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 23 Dec 2023 13:23:50 +0800
Subject: [PATCH 021/147] Fix missing let bindings when merging branches during
 specialization

and clean up some code...
---
 .../scala/mlscript/pretyper/PreTyper.scala    |   3 +-
 .../main/scala/mlscript/pretyper/Symbol.scala |   6 -
 .../mlscript/ucs/stages/Normalization.scala   | 124 ++++++++----------
 .../scala/mlscript/ucs/stages/package.scala   |  13 +-
 .../pretyper/ucs/SpecilizationCollision.mls   |  50 +++++++
 5 files changed, 115 insertions(+), 81 deletions(-)
 create mode 100644 shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls

diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index a0311fbe27..55b1e7721a 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -266,7 +266,8 @@ object PreTyper {
         case Nil => results.reverse
         case (nme: Var) :: tail => rec(nme :: results, tail)
         case (TyApp(ty, _)) :: tail => rec(results, ty :: tail)
-        case other :: _ => ???
+        case (App(nme @ Var(_), Tup(_))) :: tail => rec(nme :: results, tail)
+        case other :: _ => println(s"Unknown parent type: ${inspect.deep(other)}"); ???
       }
     rec(Nil, parents)
   }
diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index 44d86efb25..1630f72152 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -110,12 +110,6 @@ package object symbol {
         val synthesizedName = s"${name}$$tuple${index.toString}"
         new SubValueSymbol(this, N -> S(index), synthesizedName, loc)
       })
-
-    /**
-      * This buffer contains alias variables which created by "let" bindings or
-      * alias patterns.
-      */
-    val aliases: Buffer[Var] = Buffer.empty
   }
 
   final class ValueSymbol(val nme: Var, val hoisted: Bool) extends ScrutineeSymbol(nme.name) {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 046d2e2cf2..def15d0bcd 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -33,14 +33,14 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
         val falseBranch = normalizeToCaseBranches(tail)
         CaseOf(test, Case(nme, trueBranch, falseBranch))
       case Split.Cons(Branch(scrutinee, pattern @ Pattern.Literal(literal), continuation), tail) =>
-        val trueBranch = normalizeToTerm(specialize(continuation ++ tail, Yes)(scrutinee.symbol, pattern, scope))
-        val falseBranch = normalizeToCaseBranches(specialize(tail, No)(scrutinee.symbol, pattern, scope))
+        val trueBranch = normalizeToTerm(specialize(continuation ++ tail, true)(scrutinee.symbol, pattern, scope))
+        val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutinee.symbol, pattern, scope))
         CaseOf(scrutinee, Case(literal, trueBranch, falseBranch))
-      // No class parameters. Easy
+      // false class parameters. Easy
       case Split.Cons(Branch(scrutinee, pattern @ Pattern.Class(nme, N), continuation), tail) =>
         println(s"match $scrutinee with $nme (has location: ${nme.toLoc.isDefined})")
-        val trueBranch = normalizeToTerm(specialize(continuation ++ tail, Yes)(scrutinee.symbol, pattern, scope))
-        val falseBranch = normalizeToCaseBranches(specialize(tail, No)(scrutinee.symbol, pattern, scope))
+        val trueBranch = normalizeToTerm(specialize(continuation ++ tail, true)(scrutinee.symbol, pattern, scope))
+        val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutinee.symbol, pattern, scope))
         CaseOf(scrutinee, Case(nme, trueBranch, falseBranch))
       case Split.Cons(Branch(scrutinee, pattern @ Pattern.Class(nme, S(parameters)), continuation), tail) =>
         println(s"match $scrutinee with $pattern")
@@ -61,7 +61,7 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
             throw new NormalizationException(msg"Scrutinee is not a scrutinee symbol" -> scrutinee.toLoc :: Nil)
         }
         val trueBranch = trace("compute true branch"){
-          normalizeToTerm(specialize(continuation ++ tail, Yes)(scrutinee.symbol, pattern, scope))
+          normalizeToTerm(specialize(continuation ++ tail, true)(scrutinee.symbol, pattern, scope))
         }()
         val trueBranchWithBindings = Let(
           isRec = false,
@@ -76,7 +76,7 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
           }
         )
         val falseBranch = trace("compute false branch"){
-          normalizeToCaseBranches(specialize(tail, No)(scrutinee.symbol, pattern, scope))
+          normalizeToCaseBranches(specialize(tail, false)(scrutinee.symbol, pattern, scope))
         }()
         CaseOf(scrutinee, Case(nme, trueBranchWithBindings, falseBranch))
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
@@ -99,40 +99,34 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
 
   // Specialize `split` with the assumption that `scrutinee` matches `pattern`.
   private def specialize
-      (split: Split, matchOrNot: MatchOrNot)
+      (split: Split, matchOrNot: Bool)
       (implicit scrutinee: Symbol, pattern: Pattern, scope: Scope): Split =
-  trace(s"S${matchOrNot} <== ${scrutinee.name} is ${pattern}") {
+  trace(s"S${if (matchOrNot) "+" else "-"} <== ${scrutinee.name} is ${pattern}") {
     (matchOrNot, split) match {
       // Name patterns are translated to let bindings.
-      case (Yes | No, Split.Cons(Branch(otherScrutineeVar, Pattern.Name(alias), continuation), tail)) =>
+      case (true | false, Split.Cons(Branch(otherScrutineeVar, Pattern.Name(alias), continuation), tail)) =>
         Split.Let(false, alias, otherScrutineeVar, specialize(continuation, matchOrNot))
       // Class pattern. Positive.
-      case (Yes, split @ Split.Cons(head @ Branch(otherScrutineeVar, Pattern.Class(otherClassName, otherParameters), continuation), tail)) =>
-        val otherClassSymbol = otherClassName.symbolOption.flatMap(_.typeSymbolOption) match {
-          case N => throw new NormalizationException(msg"class name is not resolved" -> otherClassName.toLoc :: Nil)
-          case S(typeSymbol) => typeSymbol
-        }
-        val otherScrutinee = otherScrutineeVar.symbol
+      case (true, split @ Split.Cons(head @ Branch(ScrutineeOnly(otherScrutinee), Pattern.Class(otherClassName, otherParameters), continuation), tail)) =>
+        val otherClassSymbol = getClassLikeSymbol(otherClassName)
         lazy val specializedTail = {
           println(s"specialized next")
-          specialize(tail, Yes)
+          specialize(tail, true)
         }
         if (scrutinee === otherScrutinee) {
           println(s"scrutinee: ${scrutinee.name} === ${otherScrutinee.name}")
           pattern match {
             case Pattern.Class(className, parameters) =>
-              if (className === otherClassName) { // FIXME: Use class symbol.
-                println(s"class name: $className === $otherClassName")
+              val classSymbol = getClassLikeSymbol(className)
+              if (classSymbol === otherClassSymbol) {
+                println(s"Case 1: class name: $className === $otherClassName")
                 (parameters, otherParameters) match {
                   case (S(parameters), S(otherParameters)) =>
                     if (parameters.length === otherParameters.length) {
                       println(s"same number of parameters: ${parameters.length}")
-                      // Check if the class parameters are the same.
-                      // Generate a function that generates bindings.
-                      // TODO: Hygienic problems.
                       val addLetBindings = parameters.iterator.zip(otherParameters).zipWithIndex.foldLeft[Split => Split](identity) {
                         case (acc, N -> S(otherParameter) -> index) =>
-                          scrutinee match {
+                          scrutinee match { // Well, it's a mistake to create a dedicated symbol for scrutinees.
                             case symbol: ScrutineeSymbol =>
                               symbol.unappliedVarMap.get(otherClassSymbol) match {
                                 case N =>
@@ -140,7 +134,7 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
                                   die
                                 case S(unappliedVar) =>
                                   println(s"we can create binding for ${otherParameter.name} at $index")
-                                  tail => Split.Let(false, otherParameter, Sel(unappliedVar, Var(index.toString)), tail)
+                                  tail => Split.Let(false, otherParameter, Sel(unappliedVar, Var(index.toString)), acc(tail))
                               }
                             case _ =>
                               println(s"we can't create binding for ${otherParameter.name} at $index")
@@ -148,18 +142,20 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
                           }
                         case (acc, S(parameter) -> S(otherParameter) -> index) if parameter.name =/= otherParameter.name =>
                           println(s"different parameter names at $index: ${parameter.name} =/= ${otherParameter.name}")
-                          tail => Split.Let(false, otherParameter, parameter, tail)
-                        case (acc, _) => acc
+                          tail => Split.Let(false, otherParameter, parameter, acc(tail))
+                        case (acc, _) =>
+                          println(s"other cases")
+                          acc
                       }
-                      // addLetBindings(specialize(continuation ++ tail, Yes))
-                      val specialized = addLetBindings(specialize(continuation, Yes))
+                      // addLetBindings(specialize(continuation ++ tail, true))
+                      val specialized = addLetBindings(specialize(continuation, true))
                       if (specialized.hasElse) {
                         println("tail is discarded")
                         specialized.withDiagnostic(
                           msg"Discarded split because of else branch" -> None // TODO: Synthesize locations
                         )
                       } else {
-                        specialized ++ specialize(tail, Yes)
+                        specialized ++ specialize(tail, true)
                       }
                     } else {
                       throw new NormalizationException({
@@ -170,58 +166,44 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
                       })
                     }
                   // TODO: Other cases
-                  case (_, _) => specialize(continuation ++ tail, Yes)
+                  case (_, _) => specialize(continuation ++ tail, true)
                 } // END match
+              } else if (otherClassSymbol.baseTypes contains classSymbol) {
+                println(s"Case 2: $otherClassName <: $className")
+                split
               } else {
-                (otherClassName.symbolOption, className.symbolOption) match {
-                  case (S(otherClassSymbol: TypeSymbol), S(classSymbol: TypeSymbol)) if (
-                    otherClassSymbol.baseTypes contains classSymbol
-                  ) =>
-                    println(s"class name: $otherClassName <: $className")
-                    split
-                  case (there, here) =>
-                    println(s"class name: $className =/= $otherClassName")
-                    println(s"class symbols: ${there.fold("_")(_.name)} ${here.fold("_")(_.name)}")
-                    specializedTail
-                }
+                println(s"Case 3: $className and $otherClassName are unrelated")
+                specializedTail
               }
             case _ => throw new NormalizationException((msg"Incompatible: ${pattern.toString}" -> pattern.toLoc) :: Nil)
           }
         } else {
           println(s"scrutinee: ${scrutinee.name} =/= ${otherScrutinee.name}")
-          if (scrutinee.name === otherScrutinee.name) {
-            println(s"WRONG!!!")
-          }
           split.copy(
-            head = head.copy(continuation = specialize(continuation, Yes)),
+            head = head.copy(continuation = specialize(continuation, true)),
             tail = specializedTail
           )
         }
       // Class pattern. Negative
-      case (No, split @ Split.Cons(head @ Branch(otherScrutineeVar, Pattern.Class(otherClassName, otherParameters), continuation), tail)) =>
-        val otherScrutinee = otherScrutineeVar.symbol
+      case (false, split @ Split.Cons(head @ Branch(ScrutineeOnly(otherScrutinee), Pattern.Class(otherClassName, otherParameters), continuation), tail)) =>
+        val otherClassSymbol = getClassLikeSymbol(otherClassName)
         if (scrutinee === otherScrutinee) {
           println(s"scrutinee: ${scrutinee.name} === ${otherScrutinee.name}")
           pattern match {
             case Pattern.Class(className, parameters) =>
+              val classSymbol = getClassLikeSymbol(className)
               if (className === otherClassName) {
-                println(s"class name: $className === $otherClassName")
-                specialize(tail, No) // TODO: Subsitute parameters to otherParameters
+                println(s"Case 1: class name: $otherClassName === $className")
+                println(s"parameters:")
+                println(s"  LHS: ${otherParameters.fold("N")(_.iterator.map(_.fold("N")(_.name)).mkString(", "))}")
+                println(s"  RHS: ${parameters.fold("N")(_.iterator.map(_.fold("N")(_.name)).mkString(", "))}")
+                specialize(tail, false) // TODO: Subsitute parameters to otherParameters
+              } else if (otherClassSymbol.baseTypes contains classSymbol) {
+                println(s"Case 2: class name: $otherClassName <: $className")
+                Split.Nil
               } else {
-                (otherClassName.symbolOption, className.symbolOption) match {
-                  case (S(otherClassSymbol: TypeSymbol), S(classSymbol: TypeSymbol)) if (
-                    otherClassSymbol.baseTypes contains classSymbol
-                  ) =>
-                    println(s"class name: $otherClassName <: $className")
-                    Split.Nil
-                  case (there, here) =>
-                    println(s"class name: $className =/= $otherClassName")
-                    println(s"class symbols: ${there.fold("_")(_.name)} ${here.fold("_")(_.name)}")
-                    split.copy(
-                      // head = head.copy(continuation = specialize(continuation, No)),
-                      tail = specialize(tail, No)
-                    )
-                }
+                println(s"Case 3: class name: $otherClassName and $className are unrelated")
+                split.copy(tail = specialize(tail, false))
               }
             case _ => throw new NormalizationException((msg"Incompatible: ${pattern.toString}" -> pattern.toLoc) :: Nil)
           }
@@ -233,15 +215,15 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
           )
         }
       // Other patterns. Not implemented.
-      case (Yes | No, Split.Cons(Branch(otherScrutineeVar, pattern, continuation), tail)) =>
+      case (true | false, Split.Cons(Branch(otherScrutineeVar, pattern, continuation), tail)) =>
         throw new NormalizationException((msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc) :: Nil)
-      case (Yes | No, let @ Split.Let(_, _, _, tail)) =>
+      case (true | false, let @ Split.Let(_, _, _, tail)) =>
         println("let binding, go next")
         let.copy(tail = specialize(tail, matchOrNot))
       // Ending cases remain the same.
-      case (Yes | No, end @ (Split.Else(_) | Split.Nil)) => println("the end"); end
-    } // <-- end match
-  }(showSplit(s"S${matchOrNot} ==>", _))
+      case (true | false, end @ (Split.Else(_) | Split.Nil)) => println("the end"); end
+    }
+  }(showSplit(s"S${if (matchOrNot) "+" else "-"} ==>", _))
 
   /**
     * Print a normalized term with indentation.
@@ -251,6 +233,12 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
 }
 
 object Normalization {
+  private def getClassLikeSymbol(className: Var): TypeSymbol =
+    className.symbolOption.flatMap(_.typeSymbolOption) match {
+      case N => throw new NormalizationException(msg"class name is not resolved" -> className.toLoc :: Nil)
+      case S(typeSymbol) => typeSymbol
+    }
+
   class NormalizationException(val messages: Ls[Message -> Opt[Loc]]) extends Throwable {
     def this(message: Message, location: Opt[Loc]) = this(message -> location :: Nil)
   }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/package.scala b/shared/src/main/scala/mlscript/ucs/stages/package.scala
index 2260c70dcc..825b3cbb0c 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/package.scala
@@ -15,14 +15,15 @@ package object stages {
     }
   }
 
-  private[stages] sealed abstract class MatchOrNot {
-    override def toString(): String = this match {
-      case Yes => "+"
-      case No => "-"
+  object ScrutineeOnly {
+    def unapply(term: Term): Opt[ScrutineeSymbol] = term match {
+      case v: Var => v.symbol match {
+        case symbol: ScrutineeSymbol => S(symbol)
+        case _ => N
+      }
+      case _ => N
     }
   }
-  private[stages] final case object Yes extends MatchOrNot
-  private[stages] final case object No extends MatchOrNot
 
   sealed abstract class CasePattern {
     override def toString(): String = this match {
diff --git a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
new file mode 100644
index 0000000000..759e3ae215
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
@@ -0,0 +1,50 @@
+:PreTyper
+
+// This test file is to track possible name collision during specialization.
+
+class Pair[out A, out B](val first: A, val second: B)
+//│ class Pair[A, B](first: A, second: B)
+
+fun p1(x) = x < 0
+fun p2(x) = x > 0
+fun p3(x) = x == 0
+//│ fun p1: Num -> Bool
+//│ fun p2: Num -> Bool
+//│ fun p3: Num -> Bool
+
+fun example1(p) =
+  if p is
+    Pair(x, y) and p1(x) and p1(y) then "both negative"
+    Pair(a, b) and p2(a) and p2(b) then "both positive"
+    else "nah"
+//│ fun example1: (Object & ~#Pair | Pair[Num, Num]) -> ("both negative" | "both positive" | "nah")
+
+// FIXME: The error should be handled gracefully.
+fun example2(p) =
+  if p is
+    Pair(x, y) and p1(x) and p1(y) then "both negative"
+    Pair(a, b) and p2(a) and p2(b) then x + y
+    else "nah"
+//│ /!!!\ Uncaught error: java.lang.Exception: Variable x not found in scope
+
+// Next, let's check the name collision between a class and its super class.
+
+class Base(x: Int)
+class Derived(y: Int) extends Base(y + 1)
+//│ class Base(x: Int)
+//│ class Derived(y: Int) extends Base
+
+fun example3(t) =
+  if t is
+    Base(x) and p1(x) then x
+    Derived(y) then y
+    else 42
+//│ fun example3: Base -> Int
+
+// FIXME
+fun example4(t, x) =
+  if t is
+    Base(x) and p1(x) then x
+    Derived(y) then y + x // Oh no, x is captured by Base! Because this branch is absorbed by the previous one.
+    else 42
+//│ fun example4: (Base, anything) -> Int

From 2c0a27f57c3a95d4e71f34030840986f83438287 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sun, 24 Dec 2023 04:51:41 +0800
Subject: [PATCH 022/147] Add a failed case where variable was accidentally
 captured

---
 .../pretyper/ucs/SpecilizationCollision.mls   | 23 +++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
index 759e3ae215..97039e5238 100644
--- a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
+++ b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
@@ -2,7 +2,9 @@
 
 // This test file is to track possible name collision during specialization.
 
+fun (~~>) check(x, y) = if x === y then "passed" else error
 class Pair[out A, out B](val first: A, val second: B)
+//│ fun (~~>) check: forall 'a. (Eql['a], 'a) -> "passed"
 //│ class Pair[A, B](first: A, second: B)
 
 fun p1(x) = x < 0
@@ -41,10 +43,27 @@ fun example3(t) =
     else 42
 //│ fun example3: Base -> Int
 
-// FIXME
 fun example4(t, x) =
   if t is
     Base(x) and p1(x) then x
-    Derived(y) then y + x // Oh no, x is captured by Base! Because this branch is absorbed by the previous one.
+    Derived(y) then y + x
+    //                  ^
+    // Oh no, x is captured by x from Base!
+    // Because the branch is absorbed by the previous one.
     else 42
 //│ fun example4: (Base, anything) -> Int
+
+example4(Base(-1), 0) ~~> -1
+example4(Base(1), 2) ~~> 42
+//│ "passed"
+//│ res
+//│     = 'passed'
+//│ res
+//│     = 'passed'
+
+// FIXME: Caused by variable shadowing during speicalization.
+example4(Derived(1), 4) ~~> 5
+//│ "passed"
+//│ res
+//│ Runtime error:
+//│   Error: an error was thrown

From b47dea45cd4e872e1205d7561976835484bb1c03 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Mon, 25 Dec 2023 23:13:14 +0800
Subject: [PATCH 023/147] Generate let bindings for class parameters during
 desugaring

We used to generate let bindings which destruct class parameters
during normalization. This works fine but it exposes some
inflexibility. For example, in the previous commit, I added a case
where free variables from a absorbed case branch are shadowed.
If we moving let bindings generation to desugaring stage, the
problem can be solved easily. This change also paves the road for
duplicated branch lifting.
---
 shared/src/main/scala/mlscript/helpers.scala  |  12 +
 .../scala/mlscript/pretyper/PreTyper.scala    |   5 +-
 .../main/scala/mlscript/pretyper/Symbol.scala |  72 ++---
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |  56 +---
 shared/src/main/scala/mlscript/ucs/core.scala |  29 +-
 .../src/main/scala/mlscript/ucs/package.scala |   5 +
 .../mlscript/ucs/stages/Desugaring.scala      | 298 ++++++++++++++----
 .../mlscript/ucs/stages/Normalization.scala   |  56 +++-
 .../pretyper/ucs/SpecilizationCollision.mls   |   6 +-
 9 files changed, 359 insertions(+), 180 deletions(-)

diff --git a/shared/src/main/scala/mlscript/helpers.scala b/shared/src/main/scala/mlscript/helpers.scala
index 9bd5d430d6..524cae27e1 100644
--- a/shared/src/main/scala/mlscript/helpers.scala
+++ b/shared/src/main/scala/mlscript/helpers.scala
@@ -751,6 +751,7 @@ trait VarImpl { self: Var =>
   def symbol_=(symbol: Symbol): Unit =
     _symbol match {
       case N => _symbol = S(symbol)
+      case S(`symbol`) => ()
       case S(_) => ???
     }
   // def withSymbol: Var = { symbol = S(new ValueSymbol(this, false)); this }
@@ -787,6 +788,17 @@ trait Located {
   
   lazy val freeVars: Set[Var] = this match {
     case v: Var => Set.single(v)
+    case Let(true, nme, rhs, body) => body.freeVars ++ rhs.freeVars - nme
+    case Let(false, nme, rhs, body) => body.freeVars - nme ++ rhs.freeVars
+    case Lam(tup: Tup, body) => body.freeVars -- tup.freeVars
+    case Tup(fields) => fields.iterator.flatMap(_._2.value.freeVars.iterator).toSet
+    case Blk(stmts) => stmts.iterator.foldRight(Set.empty[Var]) {
+      case (NuFunDef(isLetRec, nme, _, _, L(rhs)), fvs) => fvs - nme ++ (isLetRec match {
+        case N | S(true) => rhs.freeVars - nme
+        case S(false) => rhs.freeVars
+      })
+      case (statement, fvs) => fvs ++ statement.freeVars
+    }
     case _ => children.iterator.flatMap(_.freeVars.iterator).toSet
   }
   
diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index 55b1e7721a..361dea79cc 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -40,9 +40,6 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
         case S(sym: ValueSymbol) =>
           println(s"Resolve variable $v to a value.")
           v.symbol = sym
-        case S(sym: SubValueSymbol) =>
-          println(s"Resolve variable $v to a value.")
-          v.symbol = sym
         case S(sym: FunctionSymbol) =>
           println(s"Resolve variable $v to a function.")
           v.symbol = sym
@@ -246,7 +243,7 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
         case symbol: FunctionSymbol if !visitedSymbol(symbol) =>
           visitedSymbol += symbol
           traverseFunction(symbol, symbol.defn)(completeScope)
-        case _: FunctionSymbol | _: ValueSymbol | _: SubValueSymbol => ()
+        case _: FunctionSymbol | _: ValueSymbol => ()
       }
       (completeScope, new TypeContents)
     }({ case (scope, contents) => s"traverseStatements ==> Scope {${scope.showLocalSymbols}}" })
diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index 1630f72152..543d4fecbc 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -70,64 +70,54 @@ package object symbol {
       }
   }
 
+  // FIXME:
+  // We should remove `ScrutineeSymbol` ASAP. There are too many reasons. The
+  // most important one I can remember right now is that multiple variables
+  // may share the same scrutinee symbol. But for now symbol must have a unique
+  // name. We should use a dedicated symbol for tracking scrutinees.
   sealed abstract class ScrutineeSymbol(name: Str) extends TermSymbol(name) {
     def toLoc: Opt[Loc]
 
     val matchedClasses: MutMap[TypeSymbol, Buffer[Loc]] = MutMap.empty
     val unappliedVarMap: MutMap[TypeSymbol, Var] = MutMap.empty
-    // Hmm, maybe we can merge these two maps into one.
+    val subScrutineeMap: MutMap[TypeSymbol, MutMap[Int, MutMap[Var, ValueSymbol]]] = MutMap.empty
+    // Hmm, maybe we can merge these three maps into one.
+    // Urgh, let's do this in the next refactor.
+    // I really should move these imperative and stateful functions to a
+    // separate class!
+
+    def getSubScrutineeSymbolOrElse(
+        classLikeSymbol: TypeSymbol,
+        index: Int,
+        name: Var, // <-- Remove this parameter after we remove `ScrutineeSymbol`.
+        default: => ValueSymbol
+    ): ValueSymbol =
+      subScrutineeMap.getOrElseUpdate(classLikeSymbol, MutMap.empty)
+                     .getOrElseUpdate(index, MutMap.empty)
+                     .getOrElseUpdate(name, default)
 
     def addMatchedClass(symbol: TypeSymbol, loc: Opt[Loc]): Unit = {
       matchedClasses.getOrElseUpdate(symbol, Buffer.empty) ++= loc
     }
 
+    def getUnappliedVarOrElse(classLikeSymbol: TypeSymbol, default: => Var): Var =
+      unappliedVarMap.getOrElseUpdate(classLikeSymbol, default)
+
     def addUnappliedVar(symbol: TypeSymbol, nme: Var): Unit = {
       unappliedVarMap += symbol -> nme
     }
 
-    /**
-      * This map contains the sub-scrutinee symbols when this scrutinee is matched
-      * against class patterns.
-      */
-    val classParameterScrutineeMap: MutMap[Var -> Int, SubValueSymbol] = MutMap.empty
-    val tupleElementScrutineeMap: MutMap[Int, SubValueSymbol] = MutMap.empty
-    val recordValueScrutineeMap: MutMap[Var, SubValueSymbol] = MutMap.empty
-
-    def addSubScrutinee(className: Var, index: Int, parameter: Var, loc: Opt[Loc]): SubValueSymbol = {
-      classParameterScrutineeMap.getOrElseUpdate(className -> index, {
-        new SubValueSymbol(this, S(className) -> S(index), parameter.name, loc)
-      })
-    }
-
-    def addSubScrutinee(fieldName: Var, loc: Opt[Loc]): SubValueSymbol =
-      recordValueScrutineeMap.getOrElseUpdate(fieldName, {
-        val synthesizedName = s"${name}$$record${fieldName}"
-        new SubValueSymbol(this, S(fieldName) -> N, synthesizedName, loc)
-      })
-    
-    def addSubScrutinee(index: Int, loc: Opt[Loc]): SubValueSymbol =
-      tupleElementScrutineeMap.getOrElseUpdate(index, {
-        val synthesizedName = s"${name}$$tuple${index.toString}"
-        new SubValueSymbol(this, N -> S(index), synthesizedName, loc)
-      })
+    // Store the symbol of the parent scrutinee. I doubt if this is necessary.
+    private var maybeParentSymbol: Opt[ScrutineeSymbol] = N
+    def parentSymbol: Opt[ScrutineeSymbol] = maybeParentSymbol
+    def withParentSymbol(parentSymbol: ScrutineeSymbol): this.type =
+      maybeParentSymbol match {
+        case N => maybeParentSymbol = S(parentSymbol); this
+        case S(_) => throw new IllegalStateException("Parent symbol is already set.")
+      }
   }
 
   final class ValueSymbol(val nme: Var, val hoisted: Bool) extends ScrutineeSymbol(nme.name) {
     override def toLoc: Opt[Loc] = nme.toLoc
   }
-
-  final class SubValueSymbol(
-    val parentSymbol: ScrutineeSymbol,
-    /**
-      * TODO: This becomes useless now.
-      * Class patterns: (S(className), S(index))
-      * Record patterns: (S(fieldName), N)
-      * Tuple patterns: (N, S(index))
-      */
-    val accessor: (Opt[Var], Opt[Int]),
-    override val name: Str,
-    override val toLoc: Opt[Loc]
-  ) extends ScrutineeSymbol(name) {
-    lazy val toVar: Var = Var(name)
-  }
 }
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index a9743b5c21..0dcbd4565d 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -75,7 +75,7 @@ trait DesugarUCS extends Transformation
           traverseSplit(tail)
         case Split.Let(_, name, _, tail) =>
           println(s"found let binding: \"$name\"")
-          traverseSplit(tail)(scope + new ValueSymbol(name, false))
+          traverseSplit(tail)(scope + name.symbol)
         case Split.Else(default) => traverseTerm(default)
         case Split.Nil => println("the end")
       }
@@ -90,55 +90,11 @@ trait DesugarUCS extends Transformation
       }
       pattern match {
         case core.Pattern.Literal(literal) => Nil
-        case core.Pattern.Name(nme) =>
-          nme.symbol = scrutineeSymbol
-          nme -> scrutineeSymbol :: Nil
-        // case core.Pattern.Class(nme @ Var("true"), N) =>
-        //   println(s"found true pattern")
-        //   nme -> scrutineeSymbol :: Nil
-        case core.Pattern.Class(nme, maybeParameters) =>
-          println(s"`$nme` has location: ${nme.toLoc.isDefined}")
-          // Resolve `nme`. It can either be a class, a trait, or a module.
-          val symbol = scope.getTypeSymbol(nme.name) match {
-            case S(symbol: TraitSymbol) => println(s"${nme.name} is a trait"); symbol
-            case S(symbol: ClassSymbol) => println(s"${nme.name} is a class"); symbol
-            case S(symbol: ModuleSymbol) => println(s"${nme.name} is a module"); symbol
-            case S(symbol: MixinSymbol) =>
-              throw new DesugaringException(msg"Mixins are not allowed in pattern" -> nme.toLoc :: Nil)
-            case S(symbol: TypeAliasSymbol) =>
-              throw new DesugaringException(msg"Type alias is not allowed in pattern" -> nme.toLoc :: Nil)
-            // case S(symbol: TermSymbol) =>
-            //   throw new DesugaringException(msg"Only classes, modules, and traits can be matched against." -> nme.toLoc :: Nil)
-            case N =>
-              throw new DesugaringException(msg"Undefined symbol found in patterns." -> nme.toLoc :: Nil)
-          }
-          nme.symbol = symbol
-          // Add the class to the list of matched classes.
-          scrutineeSymbol.addMatchedClass(symbol, nme.toLoc)
-          maybeParameters match {
-            case N => Nil
-            case S(parameters) =>
-              parameters.iterator.zipWithIndex.flatMap { 
-                case (N, _) => N
-                case (S(parameter), index) =>
-                  val symbol = scrutineeSymbol.addSubScrutinee(nme, index, parameter, parameter.toLoc)
-                  parameter.symbol = symbol; S(parameter -> symbol)
-              }.toList
-          }
-        case core.Pattern.Tuple(elements) => elements.flatMap {
-          case N => Nil
-          case S(pattern) => elements.iterator.zipWithIndex.flatMap {
-            case (N, _) => N
-            case (S(element), index) =>
-              val symbol = scrutineeSymbol.addSubScrutinee(index, element.toLoc)
-              element.symbol = symbol; S(element -> symbol)
-          }.toList
-        }
-        case core.Pattern.Record(entries) =>
-          entries.iterator.zipWithIndex.map { case ((fieldName, bindingName), _) =>
-            val symbol = scrutineeSymbol.addSubScrutinee(fieldName, bindingName.toLoc)
-            bindingName.symbol = symbol; bindingName -> symbol
-          }.toList
+        case core.Pattern.Name(nme) => nme -> nme.symbol :: Nil
+        // For now, there should only be parameter-less class patterns.
+        case core.Pattern.Class(nme, maybeParameters) => Nil
+        case core.Pattern.Tuple(_) => ???
+        case core.Pattern.Record(_) => ???
       }
     }(_.iterator.map(_._1.name).mkString("traversePattern ==> [", ", ", "]"))
 }
diff --git a/shared/src/main/scala/mlscript/ucs/core.scala b/shared/src/main/scala/mlscript/ucs/core.scala
index d788643834..94af18ace2 100644
--- a/shared/src/main/scala/mlscript/ucs/core.scala
+++ b/shared/src/main/scala/mlscript/ucs/core.scala
@@ -3,6 +3,10 @@ package mlscript.ucs
 import collection.mutable.Buffer
 import mlscript.{Diagnostic, Lit, Loc, Located, Message, Term, Var}
 import mlscript.utils._, shorthands._
+import mlscript.ucs.core.Split.Cons
+import mlscript.ucs.core.Split.Let
+import mlscript.ucs.core.Split.Else
+import mlscript.ucs.stages.Desugaring
 
 package object core {
   sealed abstract class Pattern extends Located {
@@ -74,6 +78,27 @@ package object core {
       case Split.Nil => false
     }
 
+    lazy val freeVars: Set[Var] = this match {
+      case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
+        // FIXME: It is safe to ignore `pattern` for now.
+        continuation.freeVars ++ tail.freeVars
+      case Split.Let(true, nme, rhs, tail) => tail.freeVars ++ rhs.freeVars - nme
+      case Split.Let(false, nme, rhs, tail) => tail.freeVars - nme ++ rhs.freeVars
+      case Split.Else(term) => term.freeVars
+      case Split.Nil => Set.empty
+    }
+
+    /**
+      * Remove duplicated bindings.
+      */
+    def withoutBindings(vars: Set[Var]): Split = this match {
+      case self @ Cons(head @ Branch(_, _, continuation), tail) =>
+        self.copy(head.copy(continuation = continuation.withoutBindings(vars)), tail.withoutBindings(vars))
+      case self @ Let(_, name, _, tail) if vars contains name => tail.withoutBindings(vars)
+      case self @ Let(_, _, _, tail) => self.copy(tail = tail.withoutBindings(vars))
+      case Else(_) | Split.Nil => this
+    }
+
     private val diagnostics: Buffer[Message -> Opt[Loc]] = Buffer.empty
 
     def withDiagnostic(diagnostic: Message -> Opt[Loc]): this.type = {
@@ -107,13 +132,13 @@ package object core {
         case (n, line) :: tail => (n, (if (isTopLevel) "" else "") + s"$line") :: tail
         case Nil => Nil
       }) ::: split(tail, false, isTopLevel)
-      case Split.Let(_, nme, rhs, tail) => (0, s"let $nme = $rhs") :: split(tail, false, isTopLevel)
+      case Split.Let(_, nme, rhs, tail) => (0, s"let ${showVar(nme)} = $rhs") :: split(tail, false, isTopLevel)
       case Split.Else(term) => (if (isFirst) (0, s"then $term") else (0, s"else $term")) :: Nil
       case Split.Nil => Nil
     }
     def branch(b: Branch): Lines = {
       val Branch(scrutinee, pattern, continuation) = b
-      s"$scrutinee is $pattern" #: split(continuation, true, false)
+      s"${showVar(scrutinee)} is $pattern" #: split(continuation, true, false)
     }
     val lines = split(s, true, true)
     (if (prefix.isEmpty) lines else prefix #: lines)
diff --git a/shared/src/main/scala/mlscript/ucs/package.scala b/shared/src/main/scala/mlscript/ucs/package.scala
index 21516814d9..bf4df92ef7 100644
--- a/shared/src/main/scala/mlscript/ucs/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/package.scala
@@ -28,4 +28,9 @@ package object ucs {
       }
     }
   }
+
+  /** If the variable is associated with a symbol, mark it with an asterisk.
+    * If the variable has a location, mark it with a dagger. */
+  private[ucs] def showVar(`var`: Var): String =
+    `var`.name + (`var`.symbolOption.fold("")(_ => "*")) + (`var`.toLoc.fold("")(_ => "†"))
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 9a1a1972fd..75526abc32 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -1,144 +1,312 @@
 package mlscript.ucs.stages
 
-import mlscript.{App, Asc, Fld, Term, Var, TypeName}
+import mlscript.{App, Asc, Fld, FldFlags, Lit, Sel, Term, Tup, TypeName, Var}
 import mlscript.ucs.{syntax => s, core => c, PartialTerm}
 import mlscript.ucs.helpers.mkBinOp
 import mlscript.utils._, shorthands._
 import mlscript.pretyper.symbol._
+import mlscript.pretyper.{PreTyper, Scope}
 import mlscript.ucs.DesugaringException
 import mlscript.Message, Message.MessageContext
 
-trait Desugaring { self: mlscript.pretyper.Traceable =>
-  @inline def desugar(term: s.TermSplit): c.Split = desugarTermSplit(term)(PartialTerm.Empty)
+/**
+  * The desugaring stage of UCS. In this stage, we transform the source abstract
+  * syntax into core abstract syntax, which is more concise. We will make
+  * following changes during this stage:
+  * 
+  * 1. Flatten nested patterns and generated bindings for nameless parameters.
+  * 2. Desugar variable patterns to plain let bindings.
+  * 3. Desugar literal patterns to equivalent boolean expressions.
+  * 4. Reassemble partial terms that are broken by "conditional splits".
+  * 5. Associate each scrutinee with a unique "scrutinee symbol".
+  *    TODO: `ScrutineeSymbol` will be removed in the future.
+  * 
+  * Desugared UCS terms (core abstract syntax) are in the form of `Split`, which
+  * is a list of branches. Each branch consists of a scrutinee, a pattern, and a
+  * continuation.
+  */
+trait Desugaring { self: PreTyper =>
+  @inline def desugar(term: s.TermSplit)(implicit scope: Scope): c.Split =
+    desugarTermSplit(term)(PartialTerm.Empty, scope)
 
   import Desugaring._
 
+  // Call these objects to generate fresh variables for different purposes.
+  // I plan to mix the unique identifiers of UCS expressions into the prefixes.
+  // So that the generated variables will definitely not conflict with others.
   private val freshCache = new VariableGenerator(cachePrefix)
   private val freshScrutinee = new VariableGenerator(scrutineePrefix)
   private val freshTest = new VariableGenerator(testPrefix)
 
-  private def freshScrutinee(parentScrutinee: Var, parentClassName: Var, index: Int): Var =
+  /**
+    * Coin a fresh name for a destructed parameter. The name consists of three
+    * parts: the name of the parent scrutinee, the name of matched class, and
+    * the index of the parameter. For example, if variable `x` is matched as
+    * `Cons(hd, tl)`, then the name of `hd` will be `x$Cons_0` and the name of
+    * `tl` will be `x$Cons_1`.
+    */
+  private def freshScrutinee(parentScrutinee: Var, parentClassName: Str, index: Int): Var =
     Var(s"${parentScrutinee}$$${parentClassName}_${index.toString}")
 
-  private def truePattern = c.Pattern.Class(Var("true"), N)
+  /**
+    * Coin a fresh name for the result of `unapply` method. The name begins with
+    * `args_`, followed by the name of the scrutinee, and finally ends with the
+    * name of the matched class. For example, if variable `x` is matched as
+    * `Cons(hd, tl)`, then the name of `Cons.unapply(x)` will be `args_x$Cons`.
+    * Parameters `hd` and `tl` are obtained by selecting `.1` and `.2` from
+    * `args_x$Cons`.
+    */
+  private def makeUnappliedVar(scrutinee: Var, className: Var): Var =
+    Var(s"args_${scrutinee.name}$$${className.name}")
 
-  private def flattenClassParameters(parentScrutinee: Var, parentClassName: Var, parameters: Opt[Ls[Opt[s.Pattern]]]): Opt[Ls[Opt[Var]]] -> Ls[Opt[Var -> s.Pattern]] =
-    parameters match {
-      case S(parameters) =>
-        val (a, b) = parameters.zipWithIndex.unzip {
-          case (N, index) => N -> N
-          case (S(s.NamePattern(name)), index) => (S(name), N)
-          case (S(parameterPattern: s.ClassPattern), index) =>
-            val scrutinee = freshScrutinee(parentScrutinee, parentClassName, index)
-            (S(scrutinee), Some((scrutinee, parameterPattern)))
-          case (S(parameterPattern: s.LiteralPattern), index) =>
-            val scrutinee = freshScrutinee(parentScrutinee, parentClassName, index)
-            (S(scrutinee), Some((scrutinee, parameterPattern)))
-          case _ => ??? // Other patterns are not implemented yet.
-        }
-        (S(a), b)
-      case N => (N, Nil)
+  // I plan to integrate scrutinee symbols into a field of `ValueSymbol`.
+  // Because each `ValueSymbol` can be matched in multiple UCS expressions.
+  private implicit class VarOps(nme: Var) {
+    def withFreshSymbol: Var = nme.withSymbol(freshSymbol(nme))
+
+    def getScrutineeSymbol: ScrutineeSymbol = nme.symbolOption match {
+      case S(symbol: ScrutineeSymbol) => symbol
+      case S(otherSymbol) => throw new DesugaringException(
+        msg"Expected scrutinee symbol, found ${nme.symbol.name}" -> nme.toLoc :: Nil
+      )
+      case N => throw new DesugaringException(
+        msg"Scrutinee symbol not found" -> nme.toLoc :: Nil
+      )
+    }
+
+    def withResolvedTypeSymbol(implicit scope: Scope): Var = {
+      nme.symbol = nme.resolveTypeSymbol
+      nme
     }
 
-  private def desugarTermSplit(split: s.TermSplit)(implicit termPart: PartialTerm): c.Split =
+    def resolveTypeSymbol(implicit scope: Scope): TypeSymbol = scope.getTypeSymbol(nme.name) match {
+      case S(symbol: TraitSymbol) =>
+        println(s"resolveTypeSymbol ${nme} ==> trait")
+        nme.symbol = symbol
+        symbol
+      case S(symbol: ClassSymbol) =>
+        println(s"resolveTypeSymbol ${nme} ==> class")
+        nme.symbol = symbol
+        symbol
+      case S(symbol: ModuleSymbol) =>
+        println(s"resolveTypeSymbol ${nme} ==> module")
+        nme.symbol = symbol
+        symbol
+      case S(symbol: MixinSymbol) =>
+        throw new DesugaringException(msg"Mixins are not allowed in pattern" -> nme.toLoc :: Nil)
+      case S(symbol: TypeAliasSymbol) =>
+        throw new DesugaringException(msg"Type alias is not allowed in pattern" -> nme.toLoc :: Nil)
+      case N =>
+        throw new DesugaringException(msg"Undefined symbol found in patterns." -> nme.toLoc :: Nil)
+    }
+  }
+
+  /**
+    * A shorthand for making a true pattern, which is useful in desugaring
+    * Boolean conditions.
+    */
+  private def truePattern(implicit scope: Scope) = c.Pattern.Class(Var("true").withResolvedTypeSymbol, N)
+
+  private def freshSymbol(nme: Var): ValueSymbol = new ValueSymbol(nme, false)
+
+  private def desugarTermSplit(split: s.TermSplit)(implicit termPart: PartialTerm, scope: Scope): c.Split =
     split match {
       case s.Split.Cons(head, tail) => desugarTermBranch(head) ++ desugarTermSplit(tail)
-      case s.Split.Let(rec, nme, rhs, tail) => c.Split.Let(rec, nme, rhs, desugarTermSplit(tail))
+      case s.Split.Let(rec, nme, rhs, tail) =>
+        c.Split.Let(rec, nme, rhs, desugarTermSplit(tail)(termPart, scope + nme.withFreshSymbol.symbol)) // <-- Weird use.
       case s.Split.Else(default) => c.Split.Else(default); 
       case s.Split.Nil => c.Split.Nil
     }
 
   // This function does not need to can `withCachedTermPart` because all branches assume that
   // `termPart` is either empty or waiting for an RHS.
-  private def desugarTermBranch(branch: s.TermBranch)(implicit termPart: PartialTerm): c.Split =
+  private def desugarTermBranch(branch: s.TermBranch)(implicit termPart: PartialTerm, scope: Scope): c.Split =
     trace(s"desugarTermBranch <== $termPart") {
       branch match {
         case s.TermBranch.Boolean(testPart, continuation) =>
-          val test = freshTest()
+          val test = freshTest().withFreshSymbol
           c.Split.Let(
             rec = false,
             name = test,
             term = Asc(termPart.addTerm(testPart, true).get, TypeName("Bool")),
-            tail = c.Branch(test, truePattern, desugarTermSplit(continuation)(PartialTerm.Empty)) :: c.Split.Nil
+            tail = c.Branch(test, truePattern, desugarTermSplit(continuation)(PartialTerm.Empty, scope + test.symbol)) :: c.Split.Nil
           )
         case s.TermBranch.Match(scrutinee, split) =>
-          desugarPatternSplit(split)(termPart.addTerm(scrutinee, true).get)
+          desugarPatternSplit(split)(termPart.addTerm(scrutinee, true).get, scope)
         case s.TermBranch.Left(left, continuation) =>
-          desugarOperatorSplit(continuation)(termPart.addTerm(left, true))
+          desugarOperatorSplit(continuation)(termPart.addTerm(left, true), scope)
       }
     }()
 
-  private def withCachedTermPart[B <: s.Branch](desugar: (PartialTerm) => c.Split)(implicit termPart: PartialTerm): c.Split =
+  private def withCachedTermPart[B <: s.Branch](desugar: (PartialTerm, Scope) => c.Split)(implicit termPart: PartialTerm, scope: Scope): c.Split =
     termPart.get match {
-      case v: Var => desugar(termPart) // No need to cache variables.
+      case v: Var => desugar(termPart, scope) // No need to cache variables.
       case rhs =>
-        val cache = freshCache()
-        c.Split.Let(false, cache, rhs, desugar(PartialTerm.Total(cache, Nil)))
+        val cache = freshCache().withFreshSymbol
+        c.Split.Let(false, cache, rhs, desugar(PartialTerm.Total(cache, Nil), scope + cache.symbol))
     }
 
-  private def desugarOperatorSplit(split: s.OperatorSplit)(implicit termPart: PartialTerm): c.Split =
-    withCachedTermPart { termPart => split match {
-      case s.Split.Cons(head, tail) => desugarOperatorBranch(head)(termPart) ++ desugarOperatorSplit(tail)(termPart)
-      case s.Split.Let(rec, nme, rhs, tail) => c.Split.Let(rec, nme, rhs, desugarOperatorSplit(tail)(termPart))
+  private def desugarOperatorSplit(split: s.OperatorSplit)(implicit termPart: PartialTerm, scope: Scope): c.Split =
+    withCachedTermPart { (termPart, scope) => split match {
+      case s.Split.Cons(head, tail) => desugarOperatorBranch(head)(termPart, scope) ++ desugarOperatorSplit(tail)(termPart, scope)
+      case s.Split.Let(rec, nme, rhs, tail) =>
+        c.Split.Let(rec, nme, rhs, desugarOperatorSplit(tail)(termPart, scope + nme.withFreshSymbol.symbol)) // <-- Weird use.
       case s.Split.Else(default) => c.Split.Else(default)
       case s.Split.Nil => c.Split.Nil
     }}
 
-  private def desugarOperatorBranch(branch: s.OperatorBranch)(implicit termPart: PartialTerm): c.Split =
+  private def desugarOperatorBranch(branch: s.OperatorBranch)(implicit termPart: PartialTerm, scope: Scope): c.Split =
     trace(s"desugarOperatorBranch <== $termPart") {
       branch match {
-        case s.OperatorBranch.Binary(op, split) => desugarTermSplit(split)(termPart.addOp(op))
-        case s.OperatorBranch.Match(_, split) => desugarPatternSplit(split)(termPart.get)
+        case s.OperatorBranch.Binary(op, split) => desugarTermSplit(split)(termPart.addOp(op), scope)
+        case s.OperatorBranch.Match(_, split) => desugarPatternSplit(split)(termPart.get, scope)
       }
     }()
 
-  private def flattenNestedPattern(pattern: s.ClassPattern, scrutinee: Var, next: c.Split): c.Branch = {
-    val (parameterBindings, subPatterns) = flattenClassParameters(scrutinee, pattern.nme, pattern.parameters)
-    c.Branch(scrutinee, c.Pattern.Class(pattern.nme, parameterBindings), subPatterns.foldRight(next) {
-      case (None, next) => next
-      case (Some((nme, pattern: s.ClassPattern)), next) =>
-        flattenNestedPattern(pattern, nme, next) :: c.Split.Nil
-      case (Some((nme, pattern: s.LiteralPattern)), next) =>
-        val scrutinee = freshScrutinee()
-        c.Split.Let(
-          rec = false,
-          scrutinee,
-          mkBinOp(nme, Var("=="), pattern.literal, true),
-          c.Branch(scrutinee, truePattern, next) :: c.Split.Nil
+  /** Make a term like `ClassName.unapply(scrutinee)`. */
+  private def makeUnapplyCall(scrutinee: Var, className: Var) = 
+    App(Sel(className, Var("unapply")), Tup(N -> Fld(FldFlags.empty, scrutinee) :: Nil))
+
+  private def makeLiteralTest(test: Var, scrutinee: Var, literal: Lit)(implicit scope: Scope): c.Split => c.Split =
+    next => c.Split.Let(
+      rec = false,
+      name = scrutinee,
+      term = mkBinOp(scrutinee, Var("=="), literal, true),
+      tail = c.Branch(scrutinee, truePattern, next) :: c.Split.Nil
+    )
+
+  private def flattenClassParameters(parentScrutinee: Var, parentClassLikeSymbol: TypeSymbol, parameters: Ls[Opt[s.Pattern]]): Ls[Opt[Var -> Opt[s.Pattern]]] =
+    parameters.zipWithIndex.map {
+      case (N, _) => N
+      case (S(s.NamePattern(name)), index) =>
+        val symbol = parentScrutinee.getScrutineeSymbol.getSubScrutineeSymbolOrElse(
+          parentClassLikeSymbol, index, name, new ValueSymbol(name, false)
         )
-      case (Some((nme, pattern)), next) => ??? // Other patterns are not implemented yet.
-    })
+        S(name.withSymbol(symbol) -> N)
+      case (S(parameterPattern @ (s.ClassPattern(_, _) | s.LiteralPattern(_))), index) =>
+        val scrutinee = freshScrutinee(parentScrutinee, parentClassLikeSymbol.name, index)
+        val symbol = parentScrutinee.getScrutineeSymbol.getSubScrutineeSymbolOrElse(
+          parentClassLikeSymbol, index, scrutinee, new ValueSymbol(scrutinee, false)
+        )
+        S(scrutinee.withSymbol(symbol) -> S(parameterPattern))
+      case _ => ??? // Other patterns are not implemented yet.
+    }
+
+  /**
+    * Recursively decompose and flatten a possibly nested class pattern. Any
+    * user-declared and generated variables will be added to the given scope and
+    * a augmented scope will be returned. Meanwhile, it produces a function that
+    * wrap a split with all bindings and matches.
+    * 
+    * This function involves some higher-order function's compose operation, so
+    * it is somewhat convoluted to read. However, this is a necessary
+    * complication, as we need information from the scope when generating
+    * variable names.
+    *
+    * @param pattern the class pattern
+    * @param scrutinee the scrutinee of the pattern. The caller should make sure
+    *                  that the scrutinee is associated with a symbol in the
+    *                  given scope.
+    * @param initialScope the scope before flattening the class pattern
+    * @return a tuple of the augmented scope and a function that wrap a split
+    */
+  private def flattenClassPattern(pattern: s.ClassPattern, scrutinee: Var, initialScope: Scope): (Scope, c.Split => c.Branch) = {
+    val scrutineeSymbol = scrutinee.getScrutineeSymbol
+    val patternClassSymbol = pattern.nme.resolveTypeSymbol(initialScope)
+    // Most importantly, we need to add the class to the list of matched classes.
+    scrutineeSymbol.addMatchedClass(patternClassSymbol, pattern.nme.toLoc)
+    val (scopeWithAll, bindAll) = pattern.parameters match {
+      case S(parameters) =>
+        // Before processing sub-patterns, we need to generate a variable that
+        // holds the result of `unapply` method. Such variable might have been
+        // generated by a previous branches. We MUST reuse so that we can merge
+        // duplicated bindings during normalization.
+        val unapp = scrutineeSymbol.getUnappliedVarOrElse(patternClassSymbol, {
+          val vari = makeUnappliedVar(scrutinee, pattern.nme)
+          vari.withSymbol(new ValueSymbol(vari, false))
+        })
+        val nestedPatterns = flattenClassParameters(scrutinee, patternClassSymbol, parameters)
+        // First, handle bindings of parameters of the current class pattern.
+        val bindClassParameters = nestedPatterns.iterator.zipWithIndex.foldRight[c.Split => c.Split](identity) {
+          case ((N, _), bindNextParameter) => bindNextParameter
+          case ((S(parameter -> _), index), bindNextParameter) => 
+            bindNextParameter.andThen { c.Split.Let(false, parameter, Sel(unapp, Var(index.toString)), _) }
+        }.andThen { c.Split.Let(false, unapp, makeUnapplyCall(scrutinee, pattern.nme), _): c.Split }
+        val scopeWithClassParameters = initialScope ++ (unapp.symbol :: nestedPatterns.flatMap(_.map(_._1.symbol)))
+        // Second, collect bindings from sub-patterns and accumulate a function
+        // that add let bindings to a split (we call it "binder").
+        nestedPatterns.foldLeft((scopeWithClassParameters, bindClassParameters)) {
+          // If this parameter is not matched with a sub-pattern, then we do
+          // nothing and pass on scope and binder.
+          case (acc, S(_ -> N)) => acc
+          // If this sub-pattern is a class pattern, we need to recursively flatten
+          // the class pattern. We will get a scope with all bindings and a function
+          // that adds all bindings to a split. The scope can be passed on to the
+          // next sub-pattern. The binder needs to be composed with the previous
+          // binder.
+          case ((scope, bindPrevious), S(nme -> S(pattern: s.ClassPattern))) =>
+            val (scopeWithNestedAll, bindNestedAll) = flattenClassPattern(pattern, nme, scope)
+            (scopeWithNestedAll, split => bindPrevious(bindNestedAll(split) :: c.Split.Nil))
+          case ((scope, bindPrevious), S(nme -> S(pattern: s.LiteralPattern))) =>
+            val test = freshTest().withFreshSymbol
+            (scope + test.symbol, makeLiteralTest(test, nme, pattern.literal)(scope).andThen(bindPrevious))
+          // Well, other patterns are not supported yet.
+          case (acc, S((nme, pattern))) => ???
+          // If this parameter is empty (e.g. produced by wildcard), then we do
+          // nothing and pass on scope and binder.
+          case (acc, N) => acc
+        }
+      // If there is no parameter, then we are done.
+      case N => (initialScope, identity(_: c.Split))
+    }
+    // Last, return the scope with all bindings and a function that adds all matches and bindings to a split.
+    (scopeWithAll, split => c.Branch(scrutinee, c.Pattern.Class(pattern.nme, N), bindAll(split)))
   }
 
-  private def desugarPatternSplit(split: s.PatternSplit)(implicit scrutinee: Term): c.Split = {
-    def rec(scrutinee: Var, split: s.PatternSplit): c.Split = split match {
+  private def desugarPatternSplit(split: s.PatternSplit)(implicit scrutinee: Term, scope: Scope): c.Split = {
+    def rec(scrutinee: Var, split: s.PatternSplit)(implicit scope: Scope): c.Split = split match {
       case s.Split.Cons(head, tail) => 
-        lazy val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty)
         head.pattern match {
           case s.AliasPattern(nme, pattern) => ???
           case s.LiteralPattern(literal) => ???
           case s.ConcretePattern(nme) => 
-            val condition = freshScrutinee()
+            val test = freshTest().withFreshSymbol
             c.Split.Let(
               rec = false,
-              name = condition,
+              name = test,
               term = mkBinOp(scrutinee, Var("==="), nme, true),
-              tail = c.Branch(condition, truePattern, continuation) :: rec(scrutinee, tail)
+              tail = c.Branch(
+                scrutinee = test,
+                pattern = truePattern,
+                continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope + test.symbol)
+              ) :: rec(scrutinee, tail)
             )
-          case s.NamePattern(nme) => c.Branch(scrutinee, c.Pattern.Name(nme), continuation) :: rec(scrutinee, tail)
-          case pattern @ s.ClassPattern(nme, fields) => flattenNestedPattern(pattern, scrutinee, continuation) :: rec(scrutinee, tail)
+          case s.NamePattern(Var("_")) =>
+            desugarTermSplit(head.continuation)(PartialTerm.Empty, scope) ++ rec(scrutinee, tail)
+          case s.NamePattern(nme) =>
+            // Share the scrutinee's symbol with its aliases.
+            nme.symbol = scrutinee.symbol
+            val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope + nme.symbol)
+            c.Branch(scrutinee, c.Pattern.Name(nme), continuation) :: rec(scrutinee, tail)
+          case pattern @ s.ClassPattern(nme, fields) =>
+            println(s"find term symbol of $scrutinee in ${scope.showLocalSymbols}")
+            scrutinee.symbol = scope.getTermSymbol(scrutinee.name).getOrElse(???)
+            val (scopeWithAll, bindAll) = flattenClassPattern(pattern, scrutinee, scope)
+            val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scopeWithAll)
+            bindAll(continuation) :: rec(scrutinee, tail)
           case s.TuplePattern(fields) => ???
           case s.RecordPattern(entries) => ???
         }
-      case s.Split.Let(isRec, nme, rhs, tail) => c.Split.Let(isRec, nme, rhs, rec(scrutinee, tail))
+      case s.Split.Let(isRec, nme, rhs, tail) =>
+        c.Split.Let(isRec, nme, rhs, rec(scrutinee, tail)(scope + nme.withFreshSymbol.symbol)) // <-- Weird use.
       case s.Split.Else(default) => c.Split.Else(default)
       case s.Split.Nil => c.Split.Nil
     }
     scrutinee match {
       case nme: Var => rec(nme, split)
       case other =>
-        val alias = freshScrutinee()
-        c.Split.Let(false, alias, scrutinee, rec(alias, split))
+        val alias = freshScrutinee().withFreshSymbol
+        c.Split.Let(false, alias, scrutinee, rec(alias, split)(scope + alias.symbol))
     }
   }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index def15d0bcd..7f9953711f 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -1,7 +1,7 @@
 
 package mlscript.ucs.stages
 
-import mlscript.ucs.{Lines, LinesOps}
+import mlscript.ucs.{showVar, Lines, LinesOps}
 import mlscript.ucs.core._
 import mlscript.ucs.helpers._
 import mlscript.pretyper.Scope
@@ -14,6 +14,28 @@ import mlscript.utils._, shorthands._
 trait Normalization { self: mlscript.pretyper.Traceable =>
   import Normalization._
 
+  private val freshShadowed = new Desugaring.VariableGenerator("shadowed$")
+
+  def concat(lhs: Split, rhs: Split): Split = traceNot(s"concat <== ${printSplit(lhs)} ${printSplit(rhs)}") {
+    def rec(these: Split, those: Split)(implicit vars: Set[Var]): Split = {
+      these match {
+        case these @ Split.Cons(_, tail) => these.copy(tail = rec(tail, those))
+        case these @ Split.Let(_, nme, _, tail) =>
+          if (those.freeVars contains nme) {
+            val fresh = freshShadowed()
+            val thoseWithShadowed = Split.Let(false, nme, fresh, those)
+            val concatenated = these.copy(tail = rec(tail, thoseWithShadowed))
+            Split.Let(false, fresh, nme, concatenated)
+          } else {
+            these.copy(tail = rec(tail, those)(vars + nme))
+          }
+        case _: Split.Else => these
+        case Split.Nil => those.withoutBindings(vars)
+      }
+    }
+    rec(lhs, rhs)(Set.empty)
+  }(sp => s"concat => ${printSplit(sp)}")
+
   /**
     * Normalize core abstract syntax to MLscript syntax.
     *
@@ -26,20 +48,20 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
     split match {
       case Split.Cons(Branch(scrutinee, Pattern.Name(nme), continuation), tail) =>
         println(s"alias $scrutinee => $nme")
-        Let(false, nme, scrutinee, normalizeToTerm(continuation ++ tail))
+        Let(false, nme, scrutinee, normalizeToTerm(concat(continuation, tail)))
       // Skip Boolean conditions as scrutinees, because they only appear once.
       case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true"), N), continuation), tail) if Desugaring.isTestVar(test) =>
-        val trueBranch = normalizeToTerm(continuation ++ tail)
+        val trueBranch = normalizeToTerm(concat(continuation, tail))
         val falseBranch = normalizeToCaseBranches(tail)
         CaseOf(test, Case(nme, trueBranch, falseBranch))
       case Split.Cons(Branch(scrutinee, pattern @ Pattern.Literal(literal), continuation), tail) =>
-        val trueBranch = normalizeToTerm(specialize(continuation ++ tail, true)(scrutinee.symbol, pattern, scope))
+        val trueBranch = normalizeToTerm(specialize(concat(continuation, tail), true)(scrutinee.symbol, pattern, scope))
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutinee.symbol, pattern, scope))
         CaseOf(scrutinee, Case(literal, trueBranch, falseBranch))
       // false class parameters. Easy
       case Split.Cons(Branch(scrutinee, pattern @ Pattern.Class(nme, N), continuation), tail) =>
         println(s"match $scrutinee with $nme (has location: ${nme.toLoc.isDefined})")
-        val trueBranch = normalizeToTerm(specialize(continuation ++ tail, true)(scrutinee.symbol, pattern, scope))
+        val trueBranch = normalizeToTerm(specialize(concat(continuation, tail), true)(scrutinee.symbol, pattern, scope))
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutinee.symbol, pattern, scope))
         CaseOf(scrutinee, Case(nme, trueBranch, falseBranch))
       case Split.Cons(Branch(scrutinee, pattern @ Pattern.Class(nme, S(parameters)), continuation), tail) =>
@@ -61,7 +83,7 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
             throw new NormalizationException(msg"Scrutinee is not a scrutinee symbol" -> scrutinee.toLoc :: Nil)
         }
         val trueBranch = trace("compute true branch"){
-          normalizeToTerm(specialize(continuation ++ tail, true)(scrutinee.symbol, pattern, scope))
+          normalizeToTerm(specialize(concat(continuation, tail), true)(scrutinee.symbol, pattern, scope))
         }()
         val trueBranchWithBindings = Let(
           isRec = false,
@@ -166,7 +188,16 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
                       })
                     }
                   // TODO: Other cases
-                  case (_, _) => specialize(continuation ++ tail, true)
+                  case (_, _) =>
+                    val specialized = specialize(continuation, true)
+                    if (specialized.hasElse) {
+                      println("tail is discarded")
+                      specialized.withDiagnostic(
+                        msg"Discarded split because of else branch" -> None // TODO: Synthesize locations
+                      )
+                    } else {
+                      specialized ++ specialize(tail, true)
+                    }
                 } // END match
               } else if (otherClassSymbol.baseTypes contains classSymbol) {
                 println(s"Case 2: $otherClassName <: $className")
@@ -215,13 +246,13 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
           )
         }
       // Other patterns. Not implemented.
-      case (true | false, Split.Cons(Branch(otherScrutineeVar, pattern, continuation), tail)) =>
+      case (_, Split.Cons(Branch(otherScrutineeVar, pattern, continuation), tail)) =>
         throw new NormalizationException((msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc) :: Nil)
-      case (true | false, let @ Split.Let(_, _, _, tail)) =>
-        println("let binding, go next")
+      case (_, let @ Split.Let(_, nme, _, tail)) =>
+        println(s"let binding $nme, go next")
         let.copy(tail = specialize(tail, matchOrNot))
       // Ending cases remain the same.
-      case (true | false, end @ (Split.Else(_) | Split.Nil)) => println("the end"); end
+      case (_, end @ (Split.Else(_) | Split.Nil)) => println("the end"); end
     }
   }(showSplit(s"S${if (matchOrNot) "+" else "-"} ==>", _))
 
@@ -270,9 +301,6 @@ object Normalization {
         case Wildcard(term) => s"case _ =>" @: showTerm(term)
         case NoCases => Nil
       }
-    def showVar(`var`: Var): Str =
-      // If the variable is associated with a symbol, mark it with an asterisk *.
-      `var`.name + (`var`.symbolOption.fold("")(_ => "*")) + (`var`.toLoc.fold("")(_ => "†"))
     def showLet(let: Let): Lines = {
       val Let(rec, nme, rhs, body) = let
       (0, s"let ${showVar(nme)} = $rhs") :: showTerm(body)
diff --git a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
index 97039e5238..1a5264977d 100644
--- a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
+++ b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
@@ -51,7 +51,7 @@ fun example4(t, x) =
     // Oh no, x is captured by x from Base!
     // Because the branch is absorbed by the previous one.
     else 42
-//│ fun example4: (Base, anything) -> Int
+//│ fun example4: (Base, Int) -> Int
 
 example4(Base(-1), 0) ~~> -1
 example4(Base(1), 2) ~~> 42
@@ -61,9 +61,7 @@ example4(Base(1), 2) ~~> 42
 //│ res
 //│     = 'passed'
 
-// FIXME: Caused by variable shadowing during speicalization.
 example4(Derived(1), 4) ~~> 5
 //│ "passed"
 //│ res
-//│ Runtime error:
-//│   Error: an error was thrown
+//│     = 'passed'

From 6c9cc89c59dc91fa4d1acf2b3c8ceec7f6a1158a Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Mon, 25 Dec 2023 23:36:06 +0800
Subject: [PATCH 024/147] Remove useless code due to previous commit

Normalization stage is greatly simplified from now!
---
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |   2 +-
 shared/src/main/scala/mlscript/ucs/core.scala |   8 +-
 .../mlscript/ucs/stages/Desugaring.scala      |   4 +-
 .../mlscript/ucs/stages/Normalization.scala   | 120 +++---------------
 4 files changed, 22 insertions(+), 112 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 0dcbd4565d..f33baa12f9 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -92,7 +92,7 @@ trait DesugarUCS extends Transformation
         case core.Pattern.Literal(literal) => Nil
         case core.Pattern.Name(nme) => nme -> nme.symbol :: Nil
         // For now, there should only be parameter-less class patterns.
-        case core.Pattern.Class(nme, maybeParameters) => Nil
+        case core.Pattern.Class(nme) => Nil
         case core.Pattern.Tuple(_) => ???
         case core.Pattern.Record(_) => ???
       }
diff --git a/shared/src/main/scala/mlscript/ucs/core.scala b/shared/src/main/scala/mlscript/ucs/core.scala
index 94af18ace2..65a194a322 100644
--- a/shared/src/main/scala/mlscript/ucs/core.scala
+++ b/shared/src/main/scala/mlscript/ucs/core.scala
@@ -13,9 +13,7 @@ package object core {
     override def toString(): String = this match {
       case Pattern.Literal(literal) => literal.toString
       case Pattern.Name(Var(name)) => name
-      case Pattern.Class(Var(name), N) => name
-      case Pattern.Class(Var(name), S(parameters)) =>
-        parameters.iterator.map(_.fold("_")(_.name)).mkString(s"$name(", ", ", ")")
+      case Pattern.Class(Var(name)) => name
       case Pattern.Tuple(fields) => fields.iterator.map(_.fold("_")(_.name)).mkString("(", ", ", ")")
       case Pattern.Record(Nil) => "{}"
       case Pattern.Record(entries) => entries.iterator.map { case (nme, als) => s"$nme: $als" }.mkString("{ ", ", ", " }")
@@ -28,8 +26,8 @@ package object core {
     final case class Name(nme: Var) extends Pattern {
       override def children: Ls[Located] = nme :: Nil
     }
-    final case class Class(nme: Var, parameters: Opt[List[Opt[Var]]]) extends Pattern {
-      override def children: Ls[Located] = nme :: parameters.fold(Ls.empty[Located])(_.flatten)
+    final case class Class(nme: Var) extends Pattern {
+      override def children: Ls[Located] = nme :: Nil
     }
     final case class Tuple(elements: List[Opt[Var]]) extends Pattern {
       override def children: Ls[Located] = elements.flatten
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 75526abc32..5bfecc01b9 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -105,7 +105,7 @@ trait Desugaring { self: PreTyper =>
     * A shorthand for making a true pattern, which is useful in desugaring
     * Boolean conditions.
     */
-  private def truePattern(implicit scope: Scope) = c.Pattern.Class(Var("true").withResolvedTypeSymbol, N)
+  private def truePattern(implicit scope: Scope) = c.Pattern.Class(Var("true").withResolvedTypeSymbol)
 
   private def freshSymbol(nme: Var): ValueSymbol = new ValueSymbol(nme, false)
 
@@ -260,7 +260,7 @@ trait Desugaring { self: PreTyper =>
       case N => (initialScope, identity(_: c.Split))
     }
     // Last, return the scope with all bindings and a function that adds all matches and bindings to a split.
-    (scopeWithAll, split => c.Branch(scrutinee, c.Pattern.Class(pattern.nme, N), bindAll(split)))
+    (scopeWithAll, split => c.Branch(scrutinee, c.Pattern.Class(pattern.nme), bindAll(split)))
   }
 
   private def desugarPatternSplit(split: s.PatternSplit)(implicit scrutinee: Term, scope: Scope): c.Split = {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 7f9953711f..0ccf28cbd0 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -50,7 +50,7 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
         println(s"alias $scrutinee => $nme")
         Let(false, nme, scrutinee, normalizeToTerm(concat(continuation, tail)))
       // Skip Boolean conditions as scrutinees, because they only appear once.
-      case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true"), N), continuation), tail) if Desugaring.isTestVar(test) =>
+      case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true")), continuation), tail) if Desugaring.isTestVar(test) =>
         val trueBranch = normalizeToTerm(concat(continuation, tail))
         val falseBranch = normalizeToCaseBranches(tail)
         CaseOf(test, Case(nme, trueBranch, falseBranch))
@@ -59,48 +59,11 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutinee.symbol, pattern, scope))
         CaseOf(scrutinee, Case(literal, trueBranch, falseBranch))
       // false class parameters. Easy
-      case Split.Cons(Branch(scrutinee, pattern @ Pattern.Class(nme, N), continuation), tail) =>
+      case Split.Cons(Branch(scrutinee, pattern @ Pattern.Class(nme), continuation), tail) =>
         println(s"match $scrutinee with $nme (has location: ${nme.toLoc.isDefined})")
         val trueBranch = normalizeToTerm(specialize(concat(continuation, tail), true)(scrutinee.symbol, pattern, scope))
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutinee.symbol, pattern, scope))
         CaseOf(scrutinee, Case(nme, trueBranch, falseBranch))
-      case Split.Cons(Branch(scrutinee, pattern @ Pattern.Class(nme, S(parameters)), continuation), tail) =>
-        println(s"match $scrutinee with $pattern")
-        val unappliedVar = Var(s"args_${scrutinee.name}$$${nme.name}")
-        println(s"make unapplied var: $unappliedVar")
-        // Update the scrutinee symbol. The variable will be used in merging
-        // branches of the same pattern later.
-        scrutinee.symbol match {
-          case symbol: ScrutineeSymbol =>
-            nme.symbolOption.flatMap(_.typeSymbolOption) match {
-              case N => throw new NormalizationException(msg"class name is not resolved" -> nme.toLoc :: Nil)
-              case S(typeSymbol) =>
-                println(s"add unapplied var for ${typeSymbol.name}")
-                symbol.addUnappliedVar(typeSymbol, unappliedVar)
-            }
-          case _ =>
-            // FIXME: I guess this should not happen.
-            throw new NormalizationException(msg"Scrutinee is not a scrutinee symbol" -> scrutinee.toLoc :: Nil)
-        }
-        val trueBranch = trace("compute true branch"){
-          normalizeToTerm(specialize(concat(continuation, tail), true)(scrutinee.symbol, pattern, scope))
-        }()
-        val trueBranchWithBindings = Let(
-          isRec = false,
-          name = unappliedVar,
-          rhs = {
-            val arguments = N -> Fld(FldFlags.empty, scrutinee) :: Nil
-            App(Sel(nme, Var("unapply")), Tup(arguments))
-          }, 
-          body = parameters.zipWithIndex.foldRight(trueBranch) {
-            case ((N, i), next) => next
-            case ((S(parameter), i), next) => Let(false, parameter, Sel(unappliedVar, Var(i.toString)), next)
-          }
-        )
-        val falseBranch = trace("compute false branch"){
-          normalizeToCaseBranches(specialize(tail, false)(scrutinee.symbol, pattern, scope))
-        }()
-        CaseOf(scrutinee, Case(nme, trueBranchWithBindings, falseBranch))
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
         throw new NormalizationException((msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc) :: Nil)
       case Split.Let(rec, Var("_"), rhs, tail) => normalizeToTerm(tail)
@@ -123,13 +86,13 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
   private def specialize
       (split: Split, matchOrNot: Bool)
       (implicit scrutinee: Symbol, pattern: Pattern, scope: Scope): Split =
-  trace(s"S${if (matchOrNot) "+" else "-"} <== ${scrutinee.name} is ${pattern}") {
+  trace[Split](s"S${if (matchOrNot) "+" else "-"} <== ${scrutinee.name} is ${pattern}") {
     (matchOrNot, split) match {
       // Name patterns are translated to let bindings.
       case (true | false, Split.Cons(Branch(otherScrutineeVar, Pattern.Name(alias), continuation), tail)) =>
         Split.Let(false, alias, otherScrutineeVar, specialize(continuation, matchOrNot))
       // Class pattern. Positive.
-      case (true, split @ Split.Cons(head @ Branch(ScrutineeOnly(otherScrutinee), Pattern.Class(otherClassName, otherParameters), continuation), tail)) =>
+      case (true, split @ Split.Cons(head @ Branch(ScrutineeOnly(otherScrutinee), Pattern.Class(otherClassName), continuation), tail)) =>
         val otherClassSymbol = getClassLikeSymbol(otherClassName)
         lazy val specializedTail = {
           println(s"specialized next")
@@ -138,67 +101,19 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
         if (scrutinee === otherScrutinee) {
           println(s"scrutinee: ${scrutinee.name} === ${otherScrutinee.name}")
           pattern match {
-            case Pattern.Class(className, parameters) =>
+            case Pattern.Class(className) =>
               val classSymbol = getClassLikeSymbol(className)
               if (classSymbol === otherClassSymbol) {
                 println(s"Case 1: class name: $className === $otherClassName")
-                (parameters, otherParameters) match {
-                  case (S(parameters), S(otherParameters)) =>
-                    if (parameters.length === otherParameters.length) {
-                      println(s"same number of parameters: ${parameters.length}")
-                      val addLetBindings = parameters.iterator.zip(otherParameters).zipWithIndex.foldLeft[Split => Split](identity) {
-                        case (acc, N -> S(otherParameter) -> index) =>
-                          scrutinee match { // Well, it's a mistake to create a dedicated symbol for scrutinees.
-                            case symbol: ScrutineeSymbol =>
-                              symbol.unappliedVarMap.get(otherClassSymbol) match {
-                                case N =>
-                                  println(symbol.unappliedVarMap)
-                                  die
-                                case S(unappliedVar) =>
-                                  println(s"we can create binding for ${otherParameter.name} at $index")
-                                  tail => Split.Let(false, otherParameter, Sel(unappliedVar, Var(index.toString)), acc(tail))
-                              }
-                            case _ =>
-                              println(s"we can't create binding for ${otherParameter.name} at $index")
-                              die
-                          }
-                        case (acc, S(parameter) -> S(otherParameter) -> index) if parameter.name =/= otherParameter.name =>
-                          println(s"different parameter names at $index: ${parameter.name} =/= ${otherParameter.name}")
-                          tail => Split.Let(false, otherParameter, parameter, acc(tail))
-                        case (acc, _) =>
-                          println(s"other cases")
-                          acc
-                      }
-                      // addLetBindings(specialize(continuation ++ tail, true))
-                      val specialized = addLetBindings(specialize(continuation, true))
-                      if (specialized.hasElse) {
-                        println("tail is discarded")
-                        specialized.withDiagnostic(
-                          msg"Discarded split because of else branch" -> None // TODO: Synthesize locations
-                        )
-                      } else {
-                        specialized ++ specialize(tail, true)
-                      }
-                    } else {
-                      throw new NormalizationException({
-                        msg"Mismatched numbers of parameters of ${className.name}:" -> otherClassName.toLoc ::
-                          msg"There are ${"parameters".pluralize(parameters.length, true)}." -> Pattern.getParametersLoc(parameters) ::
-                          msg"But there are ${"parameters".pluralize(otherParameters.length, true)}." -> Pattern.getParametersLoc(otherParameters) ::
-                          Nil
-                      })
-                    }
-                  // TODO: Other cases
-                  case (_, _) =>
-                    val specialized = specialize(continuation, true)
-                    if (specialized.hasElse) {
-                      println("tail is discarded")
-                      specialized.withDiagnostic(
-                        msg"Discarded split because of else branch" -> None // TODO: Synthesize locations
-                      )
-                    } else {
-                      specialized ++ specialize(tail, true)
-                    }
-                } // END match
+                val specialized = specialize(continuation, true)
+                if (specialized.hasElse) {
+                  println("tail is discarded")
+                  specialized.withDiagnostic(
+                    msg"Discarded split because of else branch" -> None // TODO: Synthesize locations
+                  )
+                } else {
+                  specialized ++ specialize(tail, true)
+                }
               } else if (otherClassSymbol.baseTypes contains classSymbol) {
                 println(s"Case 2: $otherClassName <: $className")
                 split
@@ -216,18 +131,15 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
           )
         }
       // Class pattern. Negative
-      case (false, split @ Split.Cons(head @ Branch(ScrutineeOnly(otherScrutinee), Pattern.Class(otherClassName, otherParameters), continuation), tail)) =>
+      case (false, split @ Split.Cons(head @ Branch(ScrutineeOnly(otherScrutinee), Pattern.Class(otherClassName), continuation), tail)) =>
         val otherClassSymbol = getClassLikeSymbol(otherClassName)
         if (scrutinee === otherScrutinee) {
           println(s"scrutinee: ${scrutinee.name} === ${otherScrutinee.name}")
           pattern match {
-            case Pattern.Class(className, parameters) =>
+            case Pattern.Class(className) =>
               val classSymbol = getClassLikeSymbol(className)
               if (className === otherClassName) {
                 println(s"Case 1: class name: $otherClassName === $className")
-                println(s"parameters:")
-                println(s"  LHS: ${otherParameters.fold("N")(_.iterator.map(_.fold("N")(_.name)).mkString(", "))}")
-                println(s"  RHS: ${parameters.fold("N")(_.iterator.map(_.fold("N")(_.name)).mkString(", "))}")
                 specialize(tail, false) // TODO: Subsitute parameters to otherParameters
               } else if (otherClassSymbol.baseTypes contains classSymbol) {
                 println(s"Case 2: class name: $otherClassName <: $className")

From dbf627e867254608dce732e892ba45cf7a054d9e Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 26 Dec 2023 16:09:23 +0800
Subject: [PATCH 025/147] Add calculator example and fix a bug in
 transformation

also support traversing let bindings
---
 shared/src/main/scala/mlscript/helpers.scala  |   1 +
 .../scala/mlscript/pretyper/PreTyper.scala    |   2 +-
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |   4 +-
 .../mlscript/ucs/stages/Desugaring.scala      |   8 +-
 .../mlscript/ucs/stages/Transformation.scala  |  69 +--
 .../diff/pretyper/ucs/examples/Calculator.mls | 440 ++++++++++++++++++
 .../pretyper/ucs/examples/Permutations.mls    |   2 +-
 7 files changed, 490 insertions(+), 36 deletions(-)
 create mode 100644 shared/src/test/diff/pretyper/ucs/examples/Calculator.mls

diff --git a/shared/src/main/scala/mlscript/helpers.scala b/shared/src/main/scala/mlscript/helpers.scala
index 524cae27e1..bbf2a826af 100644
--- a/shared/src/main/scala/mlscript/helpers.scala
+++ b/shared/src/main/scala/mlscript/helpers.scala
@@ -788,6 +788,7 @@ trait Located {
   
   lazy val freeVars: Set[Var] = this match {
     case v: Var => Set.single(v)
+    case Sel(receiver, _) => receiver.freeVars
     case Let(true, nme, rhs, body) => body.freeVars ++ rhs.freeVars - nme
     case Let(false, nme, rhs, body) => body.freeVars - nme ++ rhs.freeVars
     case Lam(tup: Tup, body) => body.freeVars -- tup.freeVars
diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index 361dea79cc..140cfd2b84 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -134,7 +134,7 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
 
   private def traverseLetBinding(symbol: ValueSymbol, rec: Bool, rhs: Term)(implicit scope: Scope): Unit =
     trace(s"traverseLetBinding(rec = $rec, ${symbol.name})") {
-
+      traverseTerm(rhs)(scope + symbol)
     }()
 
   private def traverseStatements(statements: Ls[Statement], name: Str, parentScope: Scope): (Scope, TypeContents) =
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index f33baa12f9..3b44067688 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -73,8 +73,10 @@ trait DesugarUCS extends Transformation
           val patternSymbols = traversePattern(scrutinee, pattern)
           traverseSplit(continuation)(scope.withEntries(patternSymbols))
           traverseSplit(tail)
-        case Split.Let(_, name, _, tail) =>
+        case Split.Let(_, name, rhs, tail) =>
           println(s"found let binding: \"$name\"")
+          println(s"traverse rhs: $rhs")
+          traverseTerm(rhs)
           traverseSplit(tail)(scope + name.symbol)
         case Split.Else(default) => traverseTerm(default)
         case Split.Nil => println("the end")
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 5bfecc01b9..ab0bc7b24f 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -14,7 +14,8 @@ import mlscript.Message, Message.MessageContext
   * syntax into core abstract syntax, which is more concise. We will make
   * following changes during this stage:
   * 
-  * 1. Flatten nested patterns and generated bindings for nameless parameters.
+  * 1. Flatten nested patterns and generated bindings for nameless scrutinees
+  *    and parameters of class-like patterns.
   * 2. Desugar variable patterns to plain let bindings.
   * 3. Desugar literal patterns to equivalent boolean expressions.
   * 4. Reassemble partial terms that are broken by "conditional splits".
@@ -285,9 +286,10 @@ trait Desugaring { self: PreTyper =>
             desugarTermSplit(head.continuation)(PartialTerm.Empty, scope) ++ rec(scrutinee, tail)
           case s.NamePattern(nme) =>
             // Share the scrutinee's symbol with its aliases.
-            nme.symbol = scrutinee.symbol
+            // nme.symbol = scrutinee.symbol // <-- This currently causes a bug, reuse this line after we remove `ScrutineeSymbol`.
+            nme.symbol = new ValueSymbol(nme, false)
             val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope + nme.symbol)
-            c.Branch(scrutinee, c.Pattern.Name(nme), continuation) :: rec(scrutinee, tail)
+            c.Branch(scrutinee, c.Pattern.Name(nme), continuation) :: rec(scrutinee, tail)(scope + nme.symbol)
           case pattern @ s.ClassPattern(nme, fields) =>
             println(s"find term symbol of $scrutinee in ${scope.showLocalSymbols}")
             scrutinee.symbol = scope.getTermSymbol(scrutinee.name).getOrElse(???)
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index 531492c564..9b5005565d 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -36,8 +36,8 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
       case IfElse(expr) => Split.then(expr)
       case IfOpApp(lhs, Var("is"), rhs) =>
         splitAnd(lhs) match {
-          case init :+ last =>
-            init.foldRight[TermSplit](TermBranch.Match(last, transformPatternMatching(rhs)) |> Split.single) {
+          case tests :+ scrutinee =>
+            tests.foldRight[TermSplit](TermBranch.Match(scrutinee, transformPatternMatching(rhs)) |> Split.single) {
               case (OperatorIs(scrutinee, pattern), acc) =>
                 TermBranch.Match(scrutinee, PatternBranch(transformPattern(pattern), acc) |> Split.single) |> Split.single
               case (test, acc) => TermBranch.Boolean(test, acc) |> Split.single
@@ -90,35 +90,40 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
       case (op, rhs) => OperatorBranch.Binary(op, transformIfBody(rhs))
     }
 
-  private def transformPatternMatching(body: IfBody)(implicit useNewDefs: Bool): PatternSplit = {
-    body match {
-      case IfThen(expr, rhs) => 
-        separatePattern(expr) match {
-          case (pattern, S(extraTest)) =>
-            PatternBranch(pattern, transformIfBody(IfThen(extraTest, rhs))) |> Split.single
-          case (pattern, N) =>
-            PatternBranch(pattern, Split.default(rhs)) |> Split.single
-        }
-      case IfOpApp(lhs, Var("and"), rhs) =>
-        separatePattern(lhs) match {
-          case (pattern, S(extraTest)) =>
-            PatternBranch(transformPattern(lhs), ???) |> Split.single
-          case (pattern, N) =>
-            PatternBranch(transformPattern(lhs), transformIfBody(rhs)) |> Split.single
+  /**
+    * Transform an `IfBody` into a `PatternSplit`.
+    */
+  private def transformPatternMatching(body: IfBody)(implicit useNewDefs: Bool): PatternSplit =
+    trace(s"transformPatternMatching <== ${inspect.shallow(body)}") {
+      body match {
+        case IfThen(expr, rhs) => 
+          separatePattern(expr) match {
+            case (pattern, S(extraTest)) =>
+              PatternBranch(pattern, transformIfBody(IfThen(extraTest, rhs))) |> Split.single
+            case (pattern, N) =>
+              PatternBranch(pattern, Split.default(rhs)) |> Split.single
+          }
+        case IfOpApp(lhs, Var("and"), rhs) =>
+          println(s"lhs: ${inspect.deep(lhs)}")
+          separatePattern(lhs) match {
+            case (pattern, S(extraTest)) =>
+              PatternBranch(pattern, TermBranch.Boolean(extraTest, transformIfBody(rhs)) |> Split.single) |> Split.single
+            case (pattern, N) =>
+              PatternBranch(pattern, transformIfBody(rhs)) |> Split.single
+          }
+        case IfOpApp(lhs, op, rhs) => ??? // <-- Syntactic split of patterns are not supported.
+        case IfOpsApp(lhs, opsRhss) => ??? // <-- Syntactic split of patterns are not supported.
+        case IfLet(rec, nme, rhs, body) => rare
+        case IfBlock(lines) => lines.foldLeft(Split.empty[PatternBranch]) {
+          case (acc, L(body)) => acc ++ transformPatternMatching(body)
+          case (acc, R(NuFunDef(S(rec), nme, _, _, L(rhs)))) =>
+            acc ++ Split.Let(rec, nme, rhs, Split.Nil)
+          case (acc, R(statement)) =>
+            throw new TransformException(msg"Unexpected statement in an if block", statement.toLoc)
         }
-      case IfOpApp(lhs, op, rhs) => ???
-      case IfOpsApp(lhs, opsRhss) => ???
-      case IfLet(rec, nme, rhs, body) => rare
-      case IfBlock(lines) => lines.foldLeft(Split.empty[PatternBranch]) {
-        case (acc, L(body)) => acc ++ transformPatternMatching(body)
-        case (acc, R(NuFunDef(S(rec), nme, _, _, L(rhs)))) =>
-          acc ++ Split.Let(rec, nme, rhs, Split.Nil)
-        case (acc, R(statement)) =>
-          throw new TransformException(msg"Unexpected statement in an if block", statement.toLoc)
+        case IfElse(expr) => Split.default(expr)
       }
-      case IfElse(expr) => Split.default(expr)
-    }
-  }
+    }(_ => "transformPatternMatching ==>")
 
   private def transformPattern(term: Term)(implicit useNewDefs: Bool): Pattern = term match {
     case nme @ Var("true" | "false") => ConcretePattern(nme)
@@ -135,11 +140,15 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
       case _ -> Fld(_, t       ) => S(transformPattern(t))
     })
     // TODO: Support more patterns.
-    case _ => throw new TransformException(msg"Unknown pattern", term.toLoc)
+    case _ =>
+      println(s"unknown pattern: $term")
+      throw new TransformException(msg"Unknown pattern", term.toLoc)
   }
 
   private def separatePattern(term: Term)(implicit useNewDefs: Bool): (Pattern, Opt[Term]) = {
     val (rawPattern, extraTest) = helpers.separatePattern(term, useNewDefs)
+    println("rawPattern: " + inspect.deep(rawPattern))
+    println("extraTest: " + inspect.deep(extraTest))
     (transformPattern(rawPattern), extraTest)
   }
 
diff --git a/shared/src/test/diff/pretyper/ucs/examples/Calculator.mls b/shared/src/test/diff/pretyper/ucs/examples/Calculator.mls
new file mode 100644
index 0000000000..ff2005edbe
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/examples/Calculator.mls
@@ -0,0 +1,440 @@
+:PreTyper
+
+// This test file explores implementing a calculator using UCS.
+
+fun (++) concatOp(a, b) = concat(a)(b)
+fun (|>) pipe(a, f) = f(a)
+fun (!==) notEqual(x, y) = not(x === y)
+let anyToString = toString
+//│ fun (++) concatOp: (Str, Str) -> Str
+//│ fun (|>) pipe: forall 'a 'b. ('a, 'a -> 'b) -> 'b
+//│ fun (!==) notEqual: forall 'c. (Eql['c], 'c) -> Bool
+//│ let anyToString: anything -> Str
+//│ anyToString
+//│             = [Function: toString]
+
+fun par(s, p) = if p then "(" ++ s ++ ")" else s
+//│ fun par: (Str, Bool) -> Str
+
+type StringOps = {
+  length: Int,
+  charAt: Int => Str,
+  charCodeAt: Int => Int,
+  slice: Int => Str
+}
+declare fun String: nothing
+let toStringOps: anything => StringOps = String
+//│ type StringOps = {charAt: Int -> Str, charCodeAt: Int -> Int, length: Int, slice: Int -> Str}
+//│ let toStringOps: anything -> StringOps
+//│ fun String: nothing
+//│ toStringOps
+//│             = [Function: String]
+
+type Option[A] = Some[A] | None
+class Some[A](value: A)
+module None
+//│ type Option[A] = None | Some[A]
+//│ class Some[A](value: A)
+//│ module None
+
+fun showOption(x) = if x is
+  Some(value) then "Some(" ++ toString(value) ++ ")"
+  None then "None"
+fun mapOption(f, x) = if x is
+  Some(value) then Some(f(value))
+  None then None
+fun (??) getOrElse(x, default) = if x is
+  Some(value) then value
+  None then default
+fun flatten(x) = if x is
+  Some(value) then value
+  other then other
+//│ fun showOption: (None | Some[anything]) -> Str
+//│ fun mapOption: forall 'a 'A. ('a -> 'A, None | Some['a]) -> (None | Some['A])
+//│ fun (??) getOrElse: forall 'b. (None | Some['b], 'b) -> 'b
+//│ fun flatten: forall 'c. (Object & 'c & ~#Some | Some['c]) -> 'c
+
+type List[A] = Cons[A] | Nil
+class Cons[A](head: A, tail: List[A])
+module Nil
+fun (::) cons(head, tail) = Cons(head, tail)
+fun reverse(xs) =
+  let aux(acc, xs) =
+    if xs is
+      Nil then acc
+      Cons(x, xs') then aux(x :: acc, xs')
+  aux(Nil, xs)
+fun join(sep) =
+  let aux(acc, xs) =
+    if xs is
+      Nil then acc
+      Cons(x, xs') then aux(acc ++ sep ++ toString(x), xs')
+  (xs) =>
+    if xs is
+      Cons(x, xs') then aux(toString(x), xs')
+      Nil then ""
+fun showList(xs) = "[" ++ join(", ")(xs) ++ "]"
+//│ type List[A] = Cons[A] | Nil
+//│ class Cons[A](head: A, tail: List[A])
+//│ module Nil
+//│ fun (::) cons: forall 'A. ('A, List['A]) -> Cons['A]
+//│ fun reverse: forall 'A0 'A1. (Cons['A0] | Nil) -> (Cons['A1] | Nil)
+//│ fun join: Str -> (forall 'A2. (Cons['A2] | Nil) -> Str)
+//│ fun showList: forall 'A3. (Cons['A3] | Nil) -> Str
+//│ where
+//│   'A0 <: 'A1
+
+//  _
+// | |    _____  _____ _ __
+// | |   / _ \ \/ / _ \ '__|
+// | |__|  __/>  <  __/ |
+// |_____\___/_/\_\___|_|
+// 
+
+fun isDigit(n) = (48 <= n) && (n <= 57)
+fun isBlank(n) = (n === 32) || (n === 9) || (n === 10) || (n === 13)
+//│ fun isDigit: Num -> Bool
+//│ fun isBlank: Eql[10 | 13 | 32 | 9] -> Bool
+
+fun scanInt(text: StringOps, at: Int): Option[[Int, Int]] =
+  let aux(acc, i: Int): Option[[Int, Int]] = if
+    i < 0 then None
+    i >= text.length then mapOption(n => [n, i], acc)
+    let c = text.charCodeAt(i)
+    isDigit(c) then aux(Some((acc ?? 0) * 10 + c - 48), i + 1)
+    else mapOption(n => [n, i], acc)
+  aux(None, at)
+//│ fun scanInt: (text: StringOps, at: Int) -> Option[[Int, Int]]
+
+scanInt("a123" |> toStringOps, 0) |> showOption
+scanInt("a123" |> toStringOps, 1) |> showOption
+scanInt("a123" |> toStringOps, 2) |> showOption
+scanInt("a123" |> toStringOps, 3) |> showOption
+scanInt("a123" |> toStringOps, 4) |> showOption
+//│ Str
+//│ res
+//│     = 'None'
+//│ res
+//│     = 'Some(123,4)'
+//│ res
+//│     = 'Some(23,4)'
+//│ res
+//│     = 'Some(3,4)'
+//│ res
+//│     = 'None'
+
+fun skipBlank(text: StringOps, at: Int): Int =
+  let aux(i: Int): Int = if
+    i >= text.length then i
+    isBlank(text.charCodeAt(i)) then aux(i + 1)
+    else i
+  aux(at)
+//│ fun skipBlank: (text: StringOps, at: Int) -> Int
+
+skipBlank("abc" |> toStringOps, 0)
+skipBlank("abc" |> toStringOps, 1)
+skipBlank("abc" |> toStringOps, 2)
+skipBlank("  \t\n\r123" |> toStringOps, 0)
+//│ Int
+//│ res
+//│     = 0
+//│ res
+//│     = 1
+//│ res
+//│     = 2
+//│ res
+//│     = 5
+
+class Span(val start: Int, val end: Int)
+//│ class Span(start: Int, end: Int)
+
+abstract class Token(val span: Span)
+class IntegerLiteral(value: Int, span2: Span) extends Token(span2) { // It seems that constructor parameters is not sanitized
+  fun toString(): Str = "IntegerLiteral(" ++ anyToString(value) ++ ")"
+}
+class LeftParen(at: Int) extends Token(Span(at, at + 1)) {
+  fun toString(): Str = "LeftParen"
+}
+class RightParen(at: Int) extends Token(Span(at, at + 1)) {
+  fun toString(): Str = "RightParen"
+}
+class BinaryOperator(value: Str, val bp: Int, at: Int) extends Token(Span(at, at + 1)) {
+  fun toString(): Str = "BinaryOperator(" ++ value ++ ", " ++ anyToString(bp) ++ ")"
+}
+class EndOfInput(at: Int) extends Token(Span(at, at)) {
+  fun toString(): Str = "EndOfInput"
+}
+class UnknownInput(rest: Str, at: Int, length: Int) extends Token(Span(at, at + length)) {
+  fun toString(): Str = "UnknownInput(" ++ rest ++ ")"
+}
+//│ abstract class Token(span: Span)
+//│ class IntegerLiteral(value: Int, span2: Span) extends Token {
+//│   fun toString: () -> Str
+//│ }
+//│ class LeftParen(at: Int) extends Token {
+//│   fun toString: () -> Str
+//│ }
+//│ class RightParen(at: Int) extends Token {
+//│   fun toString: () -> Str
+//│ }
+//│ class BinaryOperator(value: Str, bp: Int, at: Int) extends Token {
+//│   fun toString: () -> Str
+//│ }
+//│ class EndOfInput(at: Int) extends Token {
+//│   fun toString: () -> Str
+//│ }
+//│ class UnknownInput(rest: Str, at: Int, length: Int) extends Token {
+//│   fun toString: () -> Str
+//│ }
+
+fun scanToken(text: StringOps, at: Int): [Token, Int] =
+  if
+    let at' = skipBlank(text, at)
+    at' >= text.length then [EndOfInput(at'), at']
+    let head = text.charCodeAt(at')
+    head ===
+      37 then [BinaryOperator("%", 20, at'), at' + 1]
+      40 then [LeftParen(at'), at' + 1]
+      41 then [RightParen(at'), at' + 1]
+      42 then [BinaryOperator("*", 20, at'), at' + 1]
+      43 then [BinaryOperator("+", 10, at'), at' + 1]
+      45 then [BinaryOperator("-", 10, at'), at' + 1]
+      47 then [BinaryOperator("/", 20, at'), at' + 1]
+    (48 <= head) && (head <= 57) and
+      scanInt(text, at') is Some(res) then
+        let at'' = res.1
+        [IntegerLiteral(res.0, Span(at', at'')), at'']
+    else [UnknownInput(text.slice(at'), at', text.length - at'), at']
+//│ fun scanToken: (text: StringOps, at: Int) -> [Token, Int]
+
+scanToken("bruh" |> toStringOps, 0)
+scanToken("1" |> toStringOps, 0)
+scanToken("+" |> toStringOps, 0)
+scanToken("  42" |> toStringOps, 0)
+//│ [Token, Int]
+//│ res
+//│     = [ UnknownInput {}, 0 ]
+//│ res
+//│     = [ IntegerLiteral {}, 1 ]
+//│ res
+//│     = [ BinaryOperator {}, 1 ]
+//│ res
+//│     = [ IntegerLiteral {}, 4 ]
+
+fun tokenize(str: Str): List[Token] =
+  let text = str |> toStringOps
+  let aux(acc, at) = if
+    let res = scanToken(text, at) // TODO: Tuple pattern
+    let token = res.0
+    let at' = res.1
+    token is
+      UnknownInput then (token :: acc) |> reverse
+      EndOfInput then acc |> reverse
+      else aux(token :: acc, at')
+  aux(Nil, 0)
+//│ fun tokenize: (str: Str) -> List[Token]
+
+tokenize("0") |> showList
+tokenize("1 + 2 * 3") |> showList
+tokenize("bruh") |> showList
+//│ Str
+//│ res
+//│     = '[IntegerLiteral(0)]'
+//│ res
+//│     = '[IntegerLiteral(1), BinaryOperator(+, 10), IntegerLiteral(2), BinaryOperator(*, 20), IntegerLiteral(3)]'
+//│ res
+//│     = '[UnknownInput(bruh)]'
+
+//  ____                _
+// |  _ \ __ _ _ __ ___(_)_ __   __ _
+// | |_) / _` | '__/ __| | '_ \ / _` |
+// |  __/ (_| | |  \__ \ | | | | (_| |
+// |_|   \__,_|_|  |___/_|_| |_|\__, |
+//                              |___/
+
+type Expression = IntegerLiteral | BinaryExpression
+class BinaryExpression(op: BinaryOperator, left: Expression, right: Expression)
+//│ type Expression = BinaryExpression | IntegerLiteral
+//│ class BinaryExpression(op: BinaryOperator, left: Expression, right: Expression)
+
+fun bindingPower(t: Expression): Int =
+  if t is
+    IntegerLiteral then 30
+    BinaryExpression(op, _, _) then op.bp
+//│ fun bindingPower: (t: Expression) -> Int
+
+fun showExpression(t: Expression): Str =
+  if t is
+    IntegerLiteral(n) then anyToString(n)
+    BinaryExpression(BinaryOperator(op, bp), left, right) then
+      let lbp = bindingPower of left
+      let rbp = bindingPower of right
+      par(showExpression(left), lbp < bp) ++ " " ++ op ++ " " ++ par(showExpression(right), rbp < bp)
+//│ fun showExpression: (t: Expression) -> Str
+
+let s = Span(0, 0)
+IntegerLiteral(42, s) |> showExpression
+let t1 = BinaryExpression(BinaryOperator("+", 10, 0), IntegerLiteral(1, s), IntegerLiteral(2, s))
+t1 |> showExpression
+let t2 = BinaryExpression(BinaryOperator("*", 20, 0), t1, IntegerLiteral(3, s))
+t2 |> showExpression
+let t3 = BinaryExpression(BinaryOperator("*", 20, 0), t2, IntegerLiteral(4, s))
+t3 |> showExpression
+//│ let s: Span
+//│ let t1: BinaryExpression
+//│ let t2: BinaryExpression
+//│ let t3: BinaryExpression
+//│ Str
+//│ s
+//│   = Span {}
+//│ res
+//│     = '42'
+//│ t1
+//│    = BinaryExpression {}
+//│ res
+//│     = '1 + 2'
+//│ t2
+//│    = BinaryExpression {}
+//│ res
+//│     = '(1 + 2) * 3'
+//│ t3
+//│    = BinaryExpression {}
+//│ res
+//│     = '(1 + 2) * 3 * 4'
+
+type ParseResult[A] = Some[A] | Failed
+class Failed(message: Str)
+fun showParseResult(r: ParseResult['A]) = if r is
+  Some(value) then "Some(" ++ toString(value) ++ ")"
+  Failed(message) then "Failed(" ++ message ++ ")"
+fun (?>) mapParseResult(x, f) = if x is
+  Some(value) then Some(f(value))
+  failed then failed
+//│ type ParseResult[A] = Failed | Some[A]
+//│ class Failed(message: Str)
+//│ fun showParseResult: forall 'A. (r: ParseResult['A]) -> Str
+//│ fun (?>) mapParseResult: forall 'a 'b 'A0. (Object & 'a & ~#Some | Some['b], 'b -> 'A0) -> (Some['A0] | 'a)
+
+fun showParsedExpression(r: ParseResult[Expression]) = if r is
+  Some(value) then "Some(" ++ showExpression(value) ++ ")"
+  Failed(message) then "Failed(" ++ message ++ ")"
+//│ fun showParsedExpression: (r: ParseResult[Expression]) -> Str
+
+fun lastPosition(t: Expression): Int =
+  if t is
+    IntegerLiteral(_, span) then span.end
+    BinaryExpression(_, _, right) then lastPosition(right)
+//│ fun lastPosition: (t: Expression) -> Int
+
+fun parseAtom(ts: List[Token]): ParseResult[[Expression, List[Token]]] =
+  if ts is
+    Cons(IntegerLiteral(n, span), ts') then Some([IntegerLiteral(n, span), ts'])
+    Cons(LeftParen, ts') and parseExpression(0, ts') is
+      Some(res) and res.1 is
+        Cons(RightParen, ts'') then Some([res.0, ts''])
+        else Failed("Expected a right parenthesis at " ++ toString(lastPosition of res.0))
+      failed then failed
+    Cons(token, _) then Failed("Unexpected token " ++ toString(token) ++ " at " ++ toString(token.span.start))
+    Nil then Failed("Unexpected end of input")
+fun parseExpression(bp: Int, ts: List[Token]): ParseResult[[Expression, List[Token]]] =
+  if parseAtom(ts) is
+    Some(res) then
+      let aux(left, ts) = if ts is
+        Cons(BinaryOperator(op, bp', opAt), ts') and bp < bp' and
+          parseExpression(bp', ts') is
+            Some(res) then
+              let right = res.0
+              let ts'' = res.1
+              aux(BinaryExpression(BinaryOperator(op, bp', opAt), left, right), ts'')
+            failed then failed
+        else Some([left, ts])
+      let leftmost = res.0
+      let ts' = res.1
+      aux(leftmost, ts')
+    failed then failed
+fun parse(source: Str): ParseResult[Expression] =
+  if parseExpression(0, tokenize(source)) is
+    Some(res) and res.1 is
+      Nil then Some(res.0)
+      else Failed("Unexpected token: " ++ showList(res.1) ++ " at " ++ toString(lastPosition of res.0))
+    failed then failed
+//│ fun parseAtom: (ts: List[Token]) -> ParseResult[[Expression, List[Token]]]
+//│ fun parseExpression: (bp: Int, ts: List[Token]) -> ParseResult[[Expression, List[Token]]]
+//│ fun parse: (source: Str) -> ParseResult[Expression]
+
+parse("1 + 2 * 3") |> showParsedExpression
+parse("(1 + 2) * 3") |> showParsedExpression
+parse("2 * (1 + 3 + 5 + 7 + 9 + 11) - 2 - 4 - 6") |> showParsedExpression
+parse("2 * (1 + 3) * (5 + 7) * (9 - 11)") |> showParsedExpression
+parse("(((((((((42)))))))))") |> showParsedExpression
+//│ Str
+//│ res
+//│     = 'Some(1 + 2 * 3)'
+//│ res
+//│     = 'Some((1 + 2) * 3)'
+//│ res
+//│     = 'Some(2 * (1 + 3 + 5 + 7 + 9 + 11) - 2 - 4 - 6)'
+//│ res
+//│     = 'Some(2 * (1 + 3) * (5 + 7) * (9 - 11))'
+//│ res
+//│     = 'Some(42)'
+
+parse("1 + ") |> showParsedExpression
+parse("1 bruh") |> showParsedExpression
+parse("1 * (2 + 3") |> showParsedExpression
+parse("1 - bruh") |> showParsedExpression
+//│ Str
+//│ res
+//│     = 'Failed(Unexpected end of input)'
+//│ res
+//│     = 'Failed(Unexpected token: [UnknownInput(bruh)] at 1)'
+//│ res
+//│     = 'Failed(Expected a right parenthesis at 10)'
+//│ res
+//│     = 'Failed(Unexpected token UnknownInput(bruh) at 4)'
+
+//  _____            _             _   _
+// | ____|_   ____ _| |_   _  __ _| |_(_) ___  _ __
+// |  _| \ \ / / _` | | | | |/ _` | __| |/ _ \| '_ \
+// | |___ \ V / (_| | | |_| | (_| | |_| | (_) | | | |
+// |_____| \_/ \__,_|_|\__,_|\__,_|\__|_|\___/|_| |_|
+//
+
+fun evaluate(t: Expression): Option[Int] =
+  if t is
+    IntegerLiteral(n) then Some(n)
+    BinaryExpression(BinaryOperator(op, _, _), left, right) and
+      evaluate(left) is Some(leftResult) and
+        evaluate(right) is Some(rightResult) and op ===
+          "+" then Some(leftResult + rightResult)
+          "-" then Some(leftResult - rightResult)
+          "*" then Some(leftResult * rightResult)
+          // "/" then Some(leftResult / rightResult)
+          "%" then Some(leftResult % rightResult)
+    else None
+//│ fun evaluate: (t: Expression) -> Option[Int]
+
+fun evaluation(source: Str): Str =
+  if parse(source) is
+    Some(expression) and evaluate(expression) is
+      Some(result) then toString(result)
+      None then "Evaluation failed"
+    Failed(message) then "Parsing failed: " ++ message
+//│ fun evaluation: (source: Str) -> Str
+
+evaluation("1 + 2 * 3")
+evaluation("(((((42)))))")
+evaluation("1 * (3 + 4) - 5")
+evaluation("1 + ")
+evaluation("1 bruh")
+//│ Str
+//│ res
+//│     = '7'
+//│ res
+//│     = '42'
+//│ res
+//│     = '2'
+//│ res
+//│     = 'Parsing failed: Unexpected end of input'
+//│ res
+//│     = 'Parsing failed: Unexpected token: [UnknownInput(bruh)] at 1'
diff --git a/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls b/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls
index a42d3237ab..0497d87388 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls
@@ -62,7 +62,7 @@ fun insertAllPositions(z) =
         let nu = ((prev :+ z) ::: xs)
         aux(prev :+ head, nu :: acc, tail)
   xs => aux(Nil, Nil, xs)
-//│ fun insertAllPositions: forall 'a. 'a -> (forall 'A. (Cons['A] | Nil) -> (Cons[List['A | 'a]] & {Cons#T <: List['A | 'a]} | Nil))
+//│ fun insertAllPositions: forall 'a. 'a -> (forall 'A. (Cons['A] | Nil) -> (Cons[List['a | 'A]] & {Cons#T <: List['a | 'A]} | Nil))
 
 insertAllPositions(0)(1 :: 2 :: 3 :: Nil) |> showListList
 //│ Str

From 9cce6241f62b72753f2fe86c1befe217171317d9 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 26 Dec 2023 21:50:35 +0800
Subject: [PATCH 026/147] Support simple tuple patterns which is good for
 making examples

---
 .../scala/mlscript/pretyper/PreTyper.scala    |  11 +-
 .../main/scala/mlscript/pretyper/Symbol.scala |  12 ++
 .../mlscript/ucs/stages/Desugaring.scala      | 123 +++++++++++++-----
 .../mlscript/ucs/stages/Normalization.scala   |  88 ++++++++-----
 .../src/test/diff/pretyper/ucs/DualOption.mls |  23 ++++
 .../test/diff/pretyper/ucs/TuplePattern.mls   |   3 +-
 .../diff/pretyper/ucs/examples/Calculator.mls |  30 ++---
 .../pretyper/ucs/patterns/SimpleTuple.mls     |  94 +++++++++++++
 8 files changed, 292 insertions(+), 92 deletions(-)
 create mode 100644 shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls

diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index 140cfd2b84..2cfcaaaa8f 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -17,11 +17,12 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
     trace(s"extractParameters <== ${inspect.deep(fields)}") {
       fields match {
         case Tup(arguments) =>
-          arguments.map {
-            case (S(nme: Var), Fld(_, _)) => new ValueSymbol(nme, false)
-            case (_, Fld(_, nme: Var)) => new ValueSymbol(nme, false)
-            case (_, Fld(_, Bra(false, nme: Var))) => new ValueSymbol(nme, false)
-            case (_, _) => ???
+          arguments.flatMap {
+            case (S(nme: Var), Fld(_, _)) => new ValueSymbol(nme, false) :: Nil
+            case (_, Fld(_, nme: Var)) => new ValueSymbol(nme, false) :: Nil
+            case (_, Fld(_, Bra(false, nme: Var))) => new ValueSymbol(nme, false) :: Nil
+            case (_, Fld(_, tuple @ Tup(_))) => extractParameters(tuple)
+            case (_, Fld(_, _)) => ???
           }
         case PlainTup(arguments @ _*) =>
           arguments.map {
diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index 543d4fecbc..5763876f95 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -85,6 +85,10 @@ package object symbol {
     // Urgh, let's do this in the next refactor.
     // I really should move these imperative and stateful functions to a
     // separate class!
+    val tupleSubScrutineeMap: MutMap[Int, MutMap[Var, ValueSymbol]] = MutMap.empty
+    // Note that the innermost map is a map from variable names to symbols.
+    // Sometimes a class parameter may have many names. We maintain the
+    // uniqueness of the symbol for now.
 
     def getSubScrutineeSymbolOrElse(
         classLikeSymbol: TypeSymbol,
@@ -95,6 +99,14 @@ package object symbol {
       subScrutineeMap.getOrElseUpdate(classLikeSymbol, MutMap.empty)
                      .getOrElseUpdate(index, MutMap.empty)
                      .getOrElseUpdate(name, default)
+    
+    def getTupleSubScrutineeSymbolOrElse(
+        index: Int,
+        name: Var, // <-- Remove this parameter after we remove `ScrutineeSymbol`.
+        default: => ValueSymbol
+    ): ValueSymbol =
+      tupleSubScrutineeMap.getOrElseUpdate(index, MutMap.empty)
+                          .getOrElseUpdate(name, default)
 
     def addMatchedClass(symbol: TypeSymbol, loc: Opt[Loc]): Unit = {
       matchedClasses.getOrElseUpdate(symbol, Buffer.empty) ++= loc
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index ab0bc7b24f..a68ca224b3 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -58,7 +58,7 @@ trait Desugaring { self: PreTyper =>
     * `args_x$Cons`.
     */
   private def makeUnappliedVar(scrutinee: Var, className: Var): Var =
-    Var(s"args_${scrutinee.name}$$${className.name}")
+    Var(s"$unappliedPrefix${scrutinee.name}$$${className.name}")
 
   // I plan to integrate scrutinee symbols into a field of `ValueSymbol`.
   // Because each `ValueSymbol` can be matched in multiple UCS expressions.
@@ -177,21 +177,21 @@ trait Desugaring { self: PreTyper =>
     )
 
   private def flattenClassParameters(parentScrutinee: Var, parentClassLikeSymbol: TypeSymbol, parameters: Ls[Opt[s.Pattern]]): Ls[Opt[Var -> Opt[s.Pattern]]] =
-    parameters.zipWithIndex.map {
+    parameters.iterator.zipWithIndex.map {
       case (N, _) => N
       case (S(s.NamePattern(name)), index) =>
         val symbol = parentScrutinee.getScrutineeSymbol.getSubScrutineeSymbolOrElse(
           parentClassLikeSymbol, index, name, new ValueSymbol(name, false)
         )
         S(name.withSymbol(symbol) -> N)
-      case (S(parameterPattern @ (s.ClassPattern(_, _) | s.LiteralPattern(_))), index) =>
+      case (S(parameterPattern @ (s.ClassPattern(_, _) | s.LiteralPattern(_) | s.TuplePattern(_))), index) =>
         val scrutinee = freshScrutinee(parentScrutinee, parentClassLikeSymbol.name, index)
         val symbol = parentScrutinee.getScrutineeSymbol.getSubScrutineeSymbolOrElse(
           parentClassLikeSymbol, index, scrutinee, new ValueSymbol(scrutinee, false)
         )
         S(scrutinee.withSymbol(symbol) -> S(parameterPattern))
       case _ => ??? // Other patterns are not implemented yet.
-    }
+    }.toList
 
   /**
     * Recursively decompose and flatten a possibly nested class pattern. Any
@@ -211,7 +211,7 @@ trait Desugaring { self: PreTyper =>
     * @param initialScope the scope before flattening the class pattern
     * @return a tuple of the augmented scope and a function that wrap a split
     */
-  private def flattenClassPattern(pattern: s.ClassPattern, scrutinee: Var, initialScope: Scope): (Scope, c.Split => c.Branch) = {
+  private def desugarClassPattern(pattern: s.ClassPattern, scrutinee: Var, initialScope: Scope): (Scope, c.Split => c.Branch) = {
     val scrutineeSymbol = scrutinee.getScrutineeSymbol
     val patternClassSymbol = pattern.nme.resolveTypeSymbol(initialScope)
     // Most importantly, we need to add the class to the list of matched classes.
@@ -234,29 +234,7 @@ trait Desugaring { self: PreTyper =>
             bindNextParameter.andThen { c.Split.Let(false, parameter, Sel(unapp, Var(index.toString)), _) }
         }.andThen { c.Split.Let(false, unapp, makeUnapplyCall(scrutinee, pattern.nme), _): c.Split }
         val scopeWithClassParameters = initialScope ++ (unapp.symbol :: nestedPatterns.flatMap(_.map(_._1.symbol)))
-        // Second, collect bindings from sub-patterns and accumulate a function
-        // that add let bindings to a split (we call it "binder").
-        nestedPatterns.foldLeft((scopeWithClassParameters, bindClassParameters)) {
-          // If this parameter is not matched with a sub-pattern, then we do
-          // nothing and pass on scope and binder.
-          case (acc, S(_ -> N)) => acc
-          // If this sub-pattern is a class pattern, we need to recursively flatten
-          // the class pattern. We will get a scope with all bindings and a function
-          // that adds all bindings to a split. The scope can be passed on to the
-          // next sub-pattern. The binder needs to be composed with the previous
-          // binder.
-          case ((scope, bindPrevious), S(nme -> S(pattern: s.ClassPattern))) =>
-            val (scopeWithNestedAll, bindNestedAll) = flattenClassPattern(pattern, nme, scope)
-            (scopeWithNestedAll, split => bindPrevious(bindNestedAll(split) :: c.Split.Nil))
-          case ((scope, bindPrevious), S(nme -> S(pattern: s.LiteralPattern))) =>
-            val test = freshTest().withFreshSymbol
-            (scope + test.symbol, makeLiteralTest(test, nme, pattern.literal)(scope).andThen(bindPrevious))
-          // Well, other patterns are not supported yet.
-          case (acc, S((nme, pattern))) => ???
-          // If this parameter is empty (e.g. produced by wildcard), then we do
-          // nothing and pass on scope and binder.
-          case (acc, N) => acc
-        }
+        desugarNestedPatterns(nestedPatterns, scopeWithClassParameters, bindClassParameters)
       // If there is no parameter, then we are done.
       case N => (initialScope, identity(_: c.Split))
     }
@@ -264,6 +242,78 @@ trait Desugaring { self: PreTyper =>
     (scopeWithAll, split => c.Branch(scrutinee, c.Pattern.Class(pattern.nme), bindAll(split)))
   }
 
+  /**
+    * This function collects bindings from nested patterns and accumulate a
+    * function that add let bindings to a split (we call such function a
+    * "binder"). This function is supposed to be called from pattern desugaring
+    * functions.
+    *
+    * @param nestedPatterns nested patterns are a list of sub-scrutinees and 
+    *                       corresponding sub-patterns
+    * @param scopeWithScrutinees a scope with all sub-scrutinees
+    * @param bindScrutinees a function that adds all bindings to a split
+    */
+  private def desugarNestedPatterns(
+      nestedPatterns: Ls[Opt[Var -> Opt[s.Pattern]]],
+      scopeWithScrutinees: Scope,
+      bindScrutinees: c.Split => c.Split
+  ): (Scope, c.Split => c.Split) = {
+    nestedPatterns.foldLeft((scopeWithScrutinees, bindScrutinees)) {
+      // If this parameter is not matched with a sub-pattern, then we do
+      // nothing and pass on scope and binder.
+      case (acc, S(_ -> N)) => acc
+      // If this sub-pattern is a class pattern, we need to recursively flatten
+      // the class pattern. We will get a scope with all bindings and a function
+      // that adds all bindings to a split. The scope can be passed on to the
+      // next sub-pattern. The binder needs to be composed with the previous
+      // binder.
+      case ((scope, bindPrevious), S(nme -> S(pattern: s.ClassPattern))) =>
+        val (scopeWithNestedAll, bindNestedAll) = desugarClassPattern(pattern, nme, scope)
+        (scopeWithNestedAll, split => bindPrevious(bindNestedAll(split) :: c.Split.Nil))
+      case ((scope, bindPrevious), S(nme -> S(pattern: s.LiteralPattern))) =>
+        val test = freshTest().withFreshSymbol
+        (scope + test.symbol, makeLiteralTest(test, nme, pattern.literal)(scope).andThen(bindPrevious))
+      case ((scope, bindPrevious), S(nme -> S(s.TuplePattern(fields)))) =>
+        val (scopeWithNestedAll, bindNestedAll) = desugarTuplePattern(fields, nme, scope)
+        (scopeWithNestedAll, bindNestedAll.andThen(bindPrevious))
+      // Well, other patterns are not supported yet.
+      case (acc, S((nme, pattern))) => ???
+      // If this parameter is empty (e.g. produced by wildcard), then we do
+      // nothing and pass on scope and binder.
+      case (acc, N) => acc
+    }
+  }
+
+  private def flattenTupleFields(parentScrutinee: Var, fields: Ls[Opt[s.Pattern]]): Ls[Opt[Var -> Opt[s.Pattern]]] =
+    fields.iterator.zipWithIndex.map {
+      case (N, _) => N
+      case (S(s.NamePattern(name)), index) =>
+        val symbol = parentScrutinee.getScrutineeSymbol.getTupleSubScrutineeSymbolOrElse(
+          index, name, new ValueSymbol(name, false)
+        )
+        S(name.withSymbol(symbol) -> N)
+      case (S(parameterPattern @ (s.ClassPattern(_, _) | s.LiteralPattern(_) | s.TuplePattern(_))), index) =>
+        val scrutinee = freshScrutinee(parentScrutinee, "Tuple$2", index)
+        val symbol = parentScrutinee.getScrutineeSymbol.getTupleSubScrutineeSymbolOrElse(
+          index, scrutinee, new ValueSymbol(scrutinee, false)
+        )
+        S(scrutinee.withSymbol(symbol) -> S(parameterPattern))
+      case _ => ???
+    }.toList
+
+  private def desugarTuplePattern(fields: Ls[Opt[s.Pattern]], scrutinee: Var, initialScope: Scope): (Scope, c.Split => c.Split) = {
+    val scrutineeSymbol = scrutinee.getScrutineeSymbol
+    val nestedPatterns = flattenTupleFields(scrutinee, fields)
+    val bindTupleFields = nestedPatterns.iterator.zipWithIndex.foldRight[c.Split => c.Split](identity) {
+      case ((N, _), bindNextField) => bindNextField
+      case ((S(parameter -> _), index), bindNextField) => 
+        val indexVar = Var(index.toString).withLoc(parameter.toLoc)
+        bindNextField.andThen { c.Split.Let(false, parameter, Sel(scrutinee, indexVar), _) }
+    }
+    val scopeWithTupleFields = initialScope ++ nestedPatterns.flatMap(_.map(_._1.symbol))
+    desugarNestedPatterns(nestedPatterns, scopeWithTupleFields, bindTupleFields)
+  }
+
   private def desugarPatternSplit(split: s.PatternSplit)(implicit scrutinee: Term, scope: Scope): c.Split = {
     def rec(scrutinee: Var, split: s.PatternSplit)(implicit scope: Scope): c.Split = split match {
       case s.Split.Cons(head, tail) => 
@@ -293,10 +343,19 @@ trait Desugaring { self: PreTyper =>
           case pattern @ s.ClassPattern(nme, fields) =>
             println(s"find term symbol of $scrutinee in ${scope.showLocalSymbols}")
             scrutinee.symbol = scope.getTermSymbol(scrutinee.name).getOrElse(???)
-            val (scopeWithAll, bindAll) = flattenClassPattern(pattern, scrutinee, scope)
+            val (scopeWithAll, bindAll) = desugarClassPattern(pattern, scrutinee, scope)
             val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scopeWithAll)
             bindAll(continuation) :: rec(scrutinee, tail)
-          case s.TuplePattern(fields) => ???
+          case s.TuplePattern(fields) =>
+            scrutinee.symbol = scope.getTermSymbol(scrutinee.name).getOrElse(???)
+            val (scopeWithAll, bindAll) = desugarTuplePattern(fields, scrutinee, scope)
+            val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scopeWithAll)
+            val withBindings = bindAll(continuation)
+            if (withBindings.hasElse) {
+              withBindings
+            } else {
+              withBindings ++ rec(scrutinee, tail)
+            }
           case s.RecordPattern(entries) => ???
         }
       case s.Split.Let(isRec, nme, rhs, tail) =>
@@ -327,8 +386,12 @@ object Desugaring {
   val cachePrefix = "cache$"
   val scrutineePrefix = "scrut$"
   val testPrefix = "test$"
+  val unappliedPrefix = "args_"
 
   def isCacheVar(nme: Var): Bool = nme.name.startsWith(cachePrefix)
   def isScrutineeVar(nme: Var): Bool = nme.name.startsWith(scrutineePrefix)
   def isTestVar(nme: Var): Bool = nme.name.startsWith(testPrefix)
+  def isUnappliedVar(nme: Var): Bool = nme.name.startsWith(unappliedPrefix)
+  def isGeneratedVar(nme: Var): Bool =
+    isCacheVar(nme) || isScrutineeVar(nme) || isTestVar(nme) || isUnappliedVar(nme)
 }
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 0ccf28cbd0..ba6c2e3798 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -16,25 +16,28 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
 
   private val freshShadowed = new Desugaring.VariableGenerator("shadowed$")
 
-  def concat(lhs: Split, rhs: Split): Split = traceNot(s"concat <== ${printSplit(lhs)} ${printSplit(rhs)}") {
-    def rec(these: Split, those: Split)(implicit vars: Set[Var]): Split = {
-      these match {
-        case these @ Split.Cons(_, tail) => these.copy(tail = rec(tail, those))
-        case these @ Split.Let(_, nme, _, tail) =>
-          if (those.freeVars contains nme) {
-            val fresh = freshShadowed()
-            val thoseWithShadowed = Split.Let(false, nme, fresh, those)
-            val concatenated = these.copy(tail = rec(tail, thoseWithShadowed))
-            Split.Let(false, fresh, nme, concatenated)
-          } else {
-            these.copy(tail = rec(tail, those)(vars + nme))
-          }
-        case _: Split.Else => these
-        case Split.Nil => those.withoutBindings(vars)
-      }
-    }
-    rec(lhs, rhs)(Set.empty)
-  }(sp => s"concat => ${printSplit(sp)}")
+  def concatImpl(these: Split, those: Split)(implicit generatedVars: Set[Var]): Split =
+    if (these.hasElse) these else (these match {
+      case these @ Split.Cons(_, tail) => these.copy(tail = concatImpl(tail, those))
+      case these @ Split.Let(_, nme, _, tail) =>
+        if (those.freeVars contains nme) {
+          val fresh = freshShadowed()
+          val thoseWithShadowed = Split.Let(false, nme, fresh, those)
+          val concatenated = these.copy(tail = concatImpl(tail, thoseWithShadowed))
+          Split.Let(false, fresh, nme, concatenated)
+        } else {
+          these.copy(tail = concatImpl(tail, those)(generatedVars + nme))
+        }
+      case _: Split.Else => these
+      case Split.Nil => those.withoutBindings(generatedVars)
+    })
+  
+  def concat(these: Split, those: Split)(implicit vars: Set[Var]): Split =
+    trace(s"concat <== ${vars.mkString("{", ", ", "}")}") {
+      println(s"these: ${printSplit(these)}")
+      println(s"those: ${printSplit(those)}")
+      concatImpl(these, those)
+    }(sp => s"concat => ${printSplit(sp)}")
 
   /**
     * Normalize core abstract syntax to MLscript syntax.
@@ -42,9 +45,9 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
     * @param split the split to normalize
     * @return the normalized term
     */ 
-  @inline def normalize(split: Split)(implicit scope: Scope): Term = normalizeToTerm(split)
+  @inline protected def normalize(split: Split): Term = normalizeToTerm(split)(Set.empty)
 
-  private def normalizeToTerm(split: Split)(implicit scope: Scope): Term = trace("normalizeToTerm <==") {
+  private def normalizeToTerm(split: Split)(implicit generatedVars: Set[Var]): Term = trace("normalizeToTerm <==") {
     split match {
       case Split.Cons(Branch(scrutinee, Pattern.Name(nme), continuation), tail) =>
         println(s"alias $scrutinee => $nme")
@@ -55,37 +58,52 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
         val falseBranch = normalizeToCaseBranches(tail)
         CaseOf(test, Case(nme, trueBranch, falseBranch))
       case Split.Cons(Branch(scrutinee, pattern @ Pattern.Literal(literal), continuation), tail) =>
-        val trueBranch = normalizeToTerm(specialize(concat(continuation, tail), true)(scrutinee.symbol, pattern, scope))
-        val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutinee.symbol, pattern, scope))
+        val trueBranch = normalizeToTerm(specialize(concat(continuation, tail), true)(scrutinee.symbol, pattern))
+        val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutinee.symbol, pattern))
         CaseOf(scrutinee, Case(literal, trueBranch, falseBranch))
       // false class parameters. Easy
       case Split.Cons(Branch(scrutinee, pattern @ Pattern.Class(nme), continuation), tail) =>
         println(s"match $scrutinee with $nme (has location: ${nme.toLoc.isDefined})")
-        val trueBranch = normalizeToTerm(specialize(concat(continuation, tail), true)(scrutinee.symbol, pattern, scope))
-        val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutinee.symbol, pattern, scope))
+        val trueBranch = normalizeToTerm(specialize(concat(continuation, tail), true)(scrutinee.symbol, pattern))
+        val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutinee.symbol, pattern))
         CaseOf(scrutinee, Case(nme, trueBranch, falseBranch))
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
         throw new NormalizationException((msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc) :: Nil)
       case Split.Let(rec, Var("_"), rhs, tail) => normalizeToTerm(tail)
-      case Split.Let(rec, nme, rhs, tail) => Let(rec, nme, rhs, normalizeToTerm(tail))
+      case Split.Let(_, nme, _, tail) if Desugaring.isScrutineeVar(nme) && generatedVars.contains(nme) =>
+        normalizeToTerm(tail)
+      case Split.Let(rec, nme, rhs, tail) =>
+        val newDeclaredBindings = if (Desugaring.isGeneratedVar(nme)) generatedVars + nme else generatedVars
+        Let(rec, nme, rhs, normalizeToTerm(tail)(newDeclaredBindings))
       case Split.Else(default) => default
       case Split.Nil => println("unexpected empty split"); ???
     }
   }(_ => "normalizeToTerm ==> ")
 
-  private def normalizeToCaseBranches(split: Split)(implicit scope: Scope): CaseBranches = trace("normalizeToCaseBranches") {
-    split match {
-      // case Split.Cons(head, Split.Nil) => Case(head.pattern, normalizeToTerm(head.continuation), NoCases)
-      case other @ (Split.Cons(_, _) | Split.Let(_, _, _, _)) => Wildcard(normalizeToTerm(other))
-      case Split.Else(default) => Wildcard(default)
-      case Split.Nil => NoCases
-    }
-  }()
+  private def normalizeToCaseBranches(split: Split)(implicit generatedVars: Set[Var]): CaseBranches =
+    trace("normalizeToCaseBranches") {
+      split match {
+        // case Split.Cons(head, Split.Nil) => Case(head.pattern, normalizeToTerm(head.continuation), NoCases)
+        case other: Split.Cons => Wildcard(normalizeToTerm(other))
+        case Split.Let(rec, Var("_"), rhs, tail) => normalizeToCaseBranches(tail)
+        case Split.Let(_, nme, _, tail) if Desugaring.isScrutineeVar(nme) && generatedVars.contains(nme) =>
+          normalizeToCaseBranches(tail)
+        case Split.Let(rec, nme, rhs, tail) =>
+          val newDeclaredBindings = if (Desugaring.isGeneratedVar(nme)) generatedVars + nme else generatedVars
+          normalizeToCaseBranches(tail)(newDeclaredBindings) match {
+            case NoCases => Wildcard(rhs)
+            case Wildcard(term) => Wildcard(Let(rec, nme, rhs, term))
+            case _: Case => die
+          }
+        case Split.Else(default) => Wildcard(default)
+        case Split.Nil => NoCases
+      }
+    }()
 
   // Specialize `split` with the assumption that `scrutinee` matches `pattern`.
   private def specialize
       (split: Split, matchOrNot: Bool)
-      (implicit scrutinee: Symbol, pattern: Pattern, scope: Scope): Split =
+      (implicit scrutinee: Symbol, pattern: Pattern): Split =
   trace[Split](s"S${if (matchOrNot) "+" else "-"} <== ${scrutinee.name} is ${pattern}") {
     (matchOrNot, split) match {
       // Name patterns are translated to let bindings.
diff --git a/shared/src/test/diff/pretyper/ucs/DualOption.mls b/shared/src/test/diff/pretyper/ucs/DualOption.mls
index e6e45799c0..d7a09632a0 100644
--- a/shared/src/test/diff/pretyper/ucs/DualOption.mls
+++ b/shared/src/test/diff/pretyper/ucs/DualOption.mls
@@ -137,3 +137,26 @@ add_5(Some(5), Some(9))
 //│     = 9
 //│ res
 //│     = 14
+
+
+fun add_6(x, y) =
+  if [x, y] is
+    [Some(xv), Some(yv)] then xv + yv
+    [Some(xv), None]     then xv
+    [None,     Some(yv)] then yv
+    [None,     None]     then 0
+//│ fun add_6: forall 'a. (None | Some[Int], None | Some[Int & 'a]) -> (Int | 'a)
+
+add_6(None, None)
+add_6(Some(5), None)
+add_6(None, Some(9))
+add_6(Some(5), Some(9))
+//│ Int
+//│ res
+//│     = 0
+//│ res
+//│     = 5
+//│ res
+//│     = 9
+//│ res
+//│     = 14
diff --git a/shared/src/test/diff/pretyper/ucs/TuplePattern.mls b/shared/src/test/diff/pretyper/ucs/TuplePattern.mls
index 99cad895ff..880c790848 100644
--- a/shared/src/test/diff/pretyper/ucs/TuplePattern.mls
+++ b/shared/src/test/diff/pretyper/ucs/TuplePattern.mls
@@ -1,10 +1,9 @@
 :PreTyper
 
-// FIXME
 fun flex(x) =
   if x is
     [a, b, c] then
       a + b + c
     else
       0
-//│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing
+//│ fun flex: {0: Int, 1: Int, 2: Int} -> Int
diff --git a/shared/src/test/diff/pretyper/ucs/examples/Calculator.mls b/shared/src/test/diff/pretyper/ucs/examples/Calculator.mls
index ff2005edbe..3b8df255b3 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/Calculator.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/Calculator.mls
@@ -201,9 +201,8 @@ fun scanToken(text: StringOps, at: Int): [Token, Int] =
       45 then [BinaryOperator("-", 10, at'), at' + 1]
       47 then [BinaryOperator("/", 20, at'), at' + 1]
     (48 <= head) && (head <= 57) and
-      scanInt(text, at') is Some(res) then
-        let at'' = res.1
-        [IntegerLiteral(res.0, Span(at', at'')), at'']
+      scanInt(text, at') is Some([n, at'']) then
+        [IntegerLiteral(n, Span(at', at'')), at'']
     else [UnknownInput(text.slice(at'), at', text.length - at'), at']
 //│ fun scanToken: (text: StringOps, at: Int) -> [Token, Int]
 
@@ -223,11 +222,8 @@ scanToken("  42" |> toStringOps, 0)
 
 fun tokenize(str: Str): List[Token] =
   let text = str |> toStringOps
-  let aux(acc, at) = if
-    let res = scanToken(text, at) // TODO: Tuple pattern
-    let token = res.0
-    let at' = res.1
-    token is
+  let aux(acc, at) =
+    if scanToken(text, at) is [token, at'] and token is
       UnknownInput then (token :: acc) |> reverse
       EndOfInput then acc |> reverse
       else aux(token :: acc, at')
@@ -330,33 +326,27 @@ fun parseAtom(ts: List[Token]): ParseResult[[Expression, List[Token]]] =
   if ts is
     Cons(IntegerLiteral(n, span), ts') then Some([IntegerLiteral(n, span), ts'])
     Cons(LeftParen, ts') and parseExpression(0, ts') is
-      Some(res) and res.1 is
-        Cons(RightParen, ts'') then Some([res.0, ts''])
-        else Failed("Expected a right parenthesis at " ++ toString(lastPosition of res.0))
+      Some([body, Cons(RightParen, ts'')]) then Some([body, ts''])
+      Some([body, _]) then Failed("Expected a right parenthesis at " ++ toString(lastPosition of body))
       failed then failed
     Cons(token, _) then Failed("Unexpected token " ++ toString(token) ++ " at " ++ toString(token.span.start))
     Nil then Failed("Unexpected end of input")
 fun parseExpression(bp: Int, ts: List[Token]): ParseResult[[Expression, List[Token]]] =
   if parseAtom(ts) is
-    Some(res) then
+    Some([leftmost, ts']) then
       let aux(left, ts) = if ts is
         Cons(BinaryOperator(op, bp', opAt), ts') and bp < bp' and
           parseExpression(bp', ts') is
-            Some(res) then
-              let right = res.0
-              let ts'' = res.1
+            Some([right, ts'']) then
               aux(BinaryExpression(BinaryOperator(op, bp', opAt), left, right), ts'')
             failed then failed
         else Some([left, ts])
-      let leftmost = res.0
-      let ts' = res.1
       aux(leftmost, ts')
     failed then failed
 fun parse(source: Str): ParseResult[Expression] =
   if parseExpression(0, tokenize(source)) is
-    Some(res) and res.1 is
-      Nil then Some(res.0)
-      else Failed("Unexpected token: " ++ showList(res.1) ++ " at " ++ toString(lastPosition of res.0))
+    Some([expr, Nil]) then Some(expr)
+    Some([expr, rest]) then Failed("Unexpected token: " ++ showList(rest) ++ " at " ++ toString(lastPosition of expr))
     failed then failed
 //│ fun parseAtom: (ts: List[Token]) -> ParseResult[[Expression, List[Token]]]
 //│ fun parseExpression: (bp: Int, ts: List[Token]) -> ParseResult[[Expression, List[Token]]]
diff --git a/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls b/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls
new file mode 100644
index 0000000000..3b0e199666
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls
@@ -0,0 +1,94 @@
+:PreTyper
+
+// We test the support for simple tuple patterns in this file.
+// Splice tuple patterns will be implement in the future.
+
+fun sum(x, y) = x + y
+sum(1, 2)
+//│ fun sum: (Int, Int) -> Int
+//│ Int
+//│ res
+//│     = 3
+
+fun sum'([x, y]) = x + y
+sum'([1, 2])
+//│ fun sum': ([Int, Int]) -> Int
+//│ Int
+//│ res
+//│     = 3
+
+fun sum''(pair) =
+  if pair is [x, y] then x + y
+sum'([1, 2])
+//│ fun sum'': {0: Int, 1: Int} -> Int
+//│ Int
+//│ res
+//│     = 3
+
+// We need native support for tuple patterns in MLscript syntax.
+// Otherwise the following cases work.
+
+fun test(thing) =
+  if thing is [] then 0
+test("")
+test(12)
+//│ fun test: anything -> 0
+//│ 0
+//│ res
+//│     = 0
+//│ res
+//│     = 0
+
+// Since pattern destruction is desugared to let bindings, matching with other
+// classes after the tuple pattern will not work.
+class Point(x: Int, y: Int)
+fun discarded_cases(thing) =
+  if thing is
+    [x, y] then x + y
+    Point(x, y) then x + y
+//│ class Point(x: Int, y: Int)
+//│ fun discarded_cases: {0: Int, 1: Int} -> Int
+
+:e
+discarded_cases(Point(0, 0))
+//│ ╔══[ERROR] Type `Point` does not contain member `1`
+//│ ║  l.47: 	    [x, y] then x + y
+//│ ╙──      	        ^
+//│ Int | error
+//│ res
+//│     = NaN
+
+// A workaround is to move the tuple pattern to the last case.
+fun working_cases(thing) =
+  if thing is
+    Point(x, y) then x + y
+    [x, y] then x + y
+//│ fun working_cases: (Object & {0: Int, 1: Int} & ~#Point | Point) -> Int
+
+working_cases(Point(0, 0))
+//│ Int
+//│ res
+//│     = 0
+
+// However, the `Object` type forbids tuples to be used.
+:e
+working_cases([0, 0])
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.75: 	working_cases([0, 0])
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── tuple literal of type `[0, 0]` is not an instance of type `Object`
+//│ ║  l.75: 	working_cases([0, 0])
+//│ ║        	              ^^^^^^
+//│ ╟── Note: constraint arises from `case` expression:
+//│ ║  l.63: 	  if thing is
+//│ ║        	     ^^^^^^^^
+//│ ║  l.64: 	    Point(x, y) then x + y
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.65: 	    [x, y] then x + y
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── from reference:
+//│ ║  l.63: 	  if thing is
+//│ ╙──      	     ^^^^^
+//│ Int | error
+//│ res
+//│     = 0

From 9874ac9d8dda6c0cfa22d744b344644aa32be96c Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 27 Dec 2023 11:28:24 +0800
Subject: [PATCH 027/147] Add UCS context and facilities to replace
 `ScrutineeSymbol`

This is a refactor and not test changes were found.
---
 .../src/main/scala/mlscript/ucs/Context.scala |  37 ++++++
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |   6 +-
 .../scala/mlscript/ucs/ScrutineeData.scala    |  64 +++++++++++
 .../src/main/scala/mlscript/ucs/package.scala |  10 ++
 .../mlscript/ucs/stages/Desugaring.scala      | 106 +++++++-----------
 .../mlscript/ucs/stages/Normalization.scala   |  34 +++---
 .../mlscript/ucs/stages/PostProcessing.scala  |   5 +-
 .../mlscript/ucs/stages/Transformation.scala  |  20 ++--
 8 files changed, 185 insertions(+), 97 deletions(-)
 create mode 100644 shared/src/main/scala/mlscript/ucs/Context.scala
 create mode 100644 shared/src/main/scala/mlscript/ucs/ScrutineeData.scala

diff --git a/shared/src/main/scala/mlscript/ucs/Context.scala b/shared/src/main/scala/mlscript/ucs/Context.scala
new file mode 100644
index 0000000000..1065a238a7
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/Context.scala
@@ -0,0 +1,37 @@
+package mlscript.ucs
+
+import collection.mutable.{Buffer, Map => MutMap, SortedMap => MutSortedMap, Set => MutSet}
+import mlscript.{If, Loc, NuFunDef, NuTypeDef, TypeName, Var}
+import mlscript.{Cls, Trt, Mxn, Als, Mod}
+import mlscript.pretyper.symbol.TypeSymbol
+import mlscript.pretyper.Scope
+import mlscript.utils._, shorthands._
+
+class Context(originalTerm: If) {
+  val prefix: Str = Context.freshPrefix().name
+
+  private val cachePrefix = prefix + "$cache$"
+  private val scrutineePrefix = prefix + "$scrut$"
+  private val testPrefix = prefix + "$test$"
+  private val shadowPrefix = prefix + "$shadow$"
+  val unappliedPrefix: Str = prefix + "$args_"
+
+  def isCacheVar(nme: Var): Bool = nme.name.startsWith(cachePrefix)
+  def isScrutineeVar(nme: Var): Bool = nme.name.startsWith(scrutineePrefix)
+  def isTestVar(nme: Var): Bool = nme.name.startsWith(testPrefix)
+  def isUnappliedVar(nme: Var): Bool = nme.name.startsWith(unappliedPrefix)
+  def isGeneratedVar(nme: Var): Bool =
+    isCacheVar(nme) || isScrutineeVar(nme) || isTestVar(nme) || isUnappliedVar(nme)
+
+  // Call these objects to generate fresh variables for different purposes.
+  // I plan to mix the unique identifiers of UCS expressions into the prefixes.
+  // So that the generated variables will definitely not conflict with others.
+  val freshCache: VariableGenerator = new VariableGenerator(cachePrefix)
+  val freshScrutinee: VariableGenerator = new VariableGenerator(scrutineePrefix)
+  val freshTest: VariableGenerator = new VariableGenerator(testPrefix)
+  val freshShadowed: VariableGenerator = new VariableGenerator("shadowed$")
+}
+
+object Context {
+  private val freshPrefix = new VariableGenerator("ucs")
+}
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 3b44067688..944bca1c6f 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -14,12 +14,13 @@ trait DesugarUCS extends Transformation
                     with PostProcessing 
                     with CoverageChecking { self: PreTyper =>
 
-  protected def traverseIf(`if`: If)(implicit scope: Scope): Unit =
+  protected def traverseIf(`if`: If)(implicit scope: Scope): Unit = {
+    implicit val context: Context = new Context(`if`)
     trace("traverseIf") {
       // Stage 0: Transformation
       val transformed = traceWithTopic("transform") {
         println("STEP 0")
-        val transformed = transform(`if`, true)
+        val transformed = transform(`if`)
         println("Transformed UCS term:")
         println(ucs.syntax.printTermSplit(transformed))
         transformed
@@ -62,6 +63,7 @@ trait DesugarUCS extends Transformation
       // Epilogue
       `if`.desugaredTerm = S(postProcessed)
     }(_ => "traverseIf ==> ()")
+  }
   
   private def traverseSplit(split: core.Split)(implicit scope: Scope): Unit =
     trace(s"traverseSplit <== [${scope.showLocalSymbols}]") {
diff --git a/shared/src/main/scala/mlscript/ucs/ScrutineeData.scala b/shared/src/main/scala/mlscript/ucs/ScrutineeData.scala
new file mode 100644
index 0000000000..2b259b99a4
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/ScrutineeData.scala
@@ -0,0 +1,64 @@
+package mlscript.ucs
+
+import collection.mutable.{Buffer, Map => MutMap, SortedMap => MutSortedMap, Set => MutSet}
+import mlscript.{Loc, NuFunDef, NuTypeDef, TypeName, Var}
+import mlscript.{Cls, Trt, Mxn, Als, Mod}
+import mlscript.pretyper.symbol.TypeSymbol
+import mlscript.utils._, shorthands._
+
+class ClassPatternInfo(scrutinee: ScrutineeData) {
+  private val locations: Buffer[Loc] = Buffer.empty
+  private var unappliedVarOpt: Opt[Var] = N
+  private val parameters: MutSortedMap[Int, ScrutineeData] = MutSortedMap.empty
+
+  def getParameter(index: Int): ScrutineeData =
+    parameters.getOrElse(index, new ScrutineeData(S(scrutinee)))
+
+  def addLocation(location: Opt[Loc]): Unit = locations ++= location
+
+  def getUnappliedVar(default: => Var): Var =
+    unappliedVarOpt.getOrElse {
+      val unappliedVar = default
+      unappliedVarOpt = S(unappliedVar)
+      unappliedVar
+    }
+}
+
+class TuplePatternInfo(scrutinee: ScrutineeData) {
+  private val locations: Buffer[Loc] = Buffer.empty
+  private val fields: MutSortedMap[Int, ScrutineeData] = MutSortedMap.empty
+
+  def getField(index: Int): ScrutineeData =
+    fields.getOrElse(index, new ScrutineeData(S(scrutinee)))
+}
+
+class ScrutineeData(parent: Opt[ScrutineeData]) {
+  private var generatedVarOpt: Opt[Var] = N
+  private val classLikePatterns: MutMap[TypeSymbol, ClassPatternInfo] = MutMap.empty
+  // Currently we only support simple tuple patterns, so there is only _one_
+  // slot for tuple patterns. After we support complex tuple patterns, we need
+  // to extend this fields to a map from tuple arity to `TuplePatternInfo`.
+  //    private val tuplePatterns: MutMap[Int, TuplePatternInfo] = MutMap.empty
+  // If we support tuple pattern splice, we need a more expressive key in the
+  // map's type.
+  private var tuplePatternOpt: Opt[TuplePatternInfo] = N
+
+  def getClassUnappliedVar(classLikeSymbol: TypeSymbol, default: => Var): Var =
+    classLikePatterns.getOrElse(classLikeSymbol, new ClassPatternInfo(this)).getUnappliedVar(default)
+
+  def getClassLikeParameter(classLikeSymbol: TypeSymbol, index: Int, location: Opt[Loc]): ScrutineeData = {
+    val classPattern = classLikePatterns.getOrElse(classLikeSymbol, new ClassPatternInfo(this))
+    classPattern.addLocation(location)
+    classPattern.getParameter(index)
+  }
+
+  def getClassLikeParameter(classLikeSymbol: TypeSymbol, index: Int): ScrutineeData =
+    classLikePatterns.getOrElse(classLikeSymbol, new ClassPatternInfo(this)).getParameter(index)
+
+  def getTupleField(index: Int): ScrutineeData =
+    tuplePatternOpt.getOrElse {
+      val tuplePattern = new TuplePatternInfo(this)
+      tuplePatternOpt = S(tuplePattern)
+      tuplePattern
+    }.getField(index)
+}
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/ucs/package.scala b/shared/src/main/scala/mlscript/ucs/package.scala
index bf4df92ef7..e284d52070 100644
--- a/shared/src/main/scala/mlscript/ucs/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/package.scala
@@ -3,6 +3,16 @@ package mlscript
 import scala.annotation.tailrec
 
 package object ucs {
+  class VariableGenerator(prefix: String) {
+    private var nextIndex = 0
+
+    def apply(): Var = {
+      val thisIndex = nextIndex
+      nextIndex += 1
+      Var(s"$prefix$thisIndex")
+    }
+  }
+
   type Lines = List[(Int, String)]
 
   implicit class LinesOps(private val lines: Lines) extends AnyVal {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index a68ca224b3..f2d69e381a 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -1,7 +1,7 @@
 package mlscript.ucs.stages
 
 import mlscript.{App, Asc, Fld, FldFlags, Lit, Sel, Term, Tup, TypeName, Var}
-import mlscript.ucs.{syntax => s, core => c, PartialTerm}
+import mlscript.ucs.{syntax => s, core => c, Context, PartialTerm}
 import mlscript.ucs.helpers.mkBinOp
 import mlscript.utils._, shorthands._
 import mlscript.pretyper.symbol._
@@ -27,17 +27,17 @@ import mlscript.Message, Message.MessageContext
   * continuation.
   */
 trait Desugaring { self: PreTyper =>
-  @inline def desugar(term: s.TermSplit)(implicit scope: Scope): c.Split =
-    desugarTermSplit(term)(PartialTerm.Empty, scope)
-
-  import Desugaring._
-
-  // Call these objects to generate fresh variables for different purposes.
-  // I plan to mix the unique identifiers of UCS expressions into the prefixes.
-  // So that the generated variables will definitely not conflict with others.
-  private val freshCache = new VariableGenerator(cachePrefix)
-  private val freshScrutinee = new VariableGenerator(scrutineePrefix)
-  private val freshTest = new VariableGenerator(testPrefix)
+  /**
+    * The entry point of the desugaring stage.
+    *
+    * @param term the root of source abstrax syntax term, obtained from the
+    *             transformation stage
+    * @param context the scope is for resolving type symbols. The scope should
+    *              contains a TypeSymbol for `true` literal.
+    * @return the root of desugared core abstract syntax term
+    */
+  @inline def desugar(term: s.TermSplit)(implicit scope: Scope, context: Context): c.Split =
+    desugarTermSplit(term)(PartialTerm.Empty, scope, context)
 
   /**
     * Coin a fresh name for a destructed parameter. The name consists of three
@@ -57,8 +57,8 @@ trait Desugaring { self: PreTyper =>
     * Parameters `hd` and `tl` are obtained by selecting `.1` and `.2` from
     * `args_x$Cons`.
     */
-  private def makeUnappliedVar(scrutinee: Var, className: Var): Var =
-    Var(s"$unappliedPrefix${scrutinee.name}$$${className.name}")
+  private def makeUnappliedVar(scrutinee: Var, className: Var)(implicit context: Context): Var =
+    Var(s"${context.unappliedPrefix}${scrutinee.name}$$${className.name}")
 
   // I plan to integrate scrutinee symbols into a field of `ValueSymbol`.
   // Because each `ValueSymbol` can be matched in multiple UCS expressions.
@@ -110,57 +110,57 @@ trait Desugaring { self: PreTyper =>
 
   private def freshSymbol(nme: Var): ValueSymbol = new ValueSymbol(nme, false)
 
-  private def desugarTermSplit(split: s.TermSplit)(implicit termPart: PartialTerm, scope: Scope): c.Split =
+  private def desugarTermSplit(split: s.TermSplit)(implicit termPart: PartialTerm, scope: Scope, context: Context): c.Split =
     split match {
       case s.Split.Cons(head, tail) => desugarTermBranch(head) ++ desugarTermSplit(tail)
       case s.Split.Let(rec, nme, rhs, tail) =>
-        c.Split.Let(rec, nme, rhs, desugarTermSplit(tail)(termPart, scope + nme.withFreshSymbol.symbol)) // <-- Weird use.
+        c.Split.Let(rec, nme, rhs, desugarTermSplit(tail)(termPart, scope + nme.withFreshSymbol.symbol, context)) // <-- Weird use.
       case s.Split.Else(default) => c.Split.Else(default); 
       case s.Split.Nil => c.Split.Nil
     }
 
   // This function does not need to can `withCachedTermPart` because all branches assume that
   // `termPart` is either empty or waiting for an RHS.
-  private def desugarTermBranch(branch: s.TermBranch)(implicit termPart: PartialTerm, scope: Scope): c.Split =
+  private def desugarTermBranch(branch: s.TermBranch)(implicit termPart: PartialTerm, scope: Scope, context: Context): c.Split =
     trace(s"desugarTermBranch <== $termPart") {
       branch match {
         case s.TermBranch.Boolean(testPart, continuation) =>
-          val test = freshTest().withFreshSymbol
+          val test = context.freshTest().withFreshSymbol
           c.Split.Let(
             rec = false,
             name = test,
             term = Asc(termPart.addTerm(testPart, true).get, TypeName("Bool")),
-            tail = c.Branch(test, truePattern, desugarTermSplit(continuation)(PartialTerm.Empty, scope + test.symbol)) :: c.Split.Nil
+            tail = c.Branch(test, truePattern, desugarTermSplit(continuation)(PartialTerm.Empty, scope + test.symbol, context)) :: c.Split.Nil
           )
         case s.TermBranch.Match(scrutinee, split) =>
-          desugarPatternSplit(split)(termPart.addTerm(scrutinee, true).get, scope)
+          desugarPatternSplit(termPart.addTerm(scrutinee, true).get, split)
         case s.TermBranch.Left(left, continuation) =>
-          desugarOperatorSplit(continuation)(termPart.addTerm(left, true), scope)
+          desugarOperatorSplit(continuation)(termPart.addTerm(left, true), scope, context)
       }
     }()
 
-  private def withCachedTermPart[B <: s.Branch](desugar: (PartialTerm, Scope) => c.Split)(implicit termPart: PartialTerm, scope: Scope): c.Split =
+  private def withCachedTermPart[B <: s.Branch](desugar: (PartialTerm, Scope) => c.Split)(implicit termPart: PartialTerm, scope: Scope, context: Context): c.Split =
     termPart.get match {
       case v: Var => desugar(termPart, scope) // No need to cache variables.
       case rhs =>
-        val cache = freshCache().withFreshSymbol
+        val cache = context.freshCache().withFreshSymbol
         c.Split.Let(false, cache, rhs, desugar(PartialTerm.Total(cache, Nil), scope + cache.symbol))
     }
 
-  private def desugarOperatorSplit(split: s.OperatorSplit)(implicit termPart: PartialTerm, scope: Scope): c.Split =
+  private def desugarOperatorSplit(split: s.OperatorSplit)(implicit termPart: PartialTerm, scope: Scope, context: Context): c.Split =
     withCachedTermPart { (termPart, scope) => split match {
-      case s.Split.Cons(head, tail) => desugarOperatorBranch(head)(termPart, scope) ++ desugarOperatorSplit(tail)(termPart, scope)
+      case s.Split.Cons(head, tail) => desugarOperatorBranch(head)(termPart, scope, context) ++ desugarOperatorSplit(tail)(termPart, scope, context)
       case s.Split.Let(rec, nme, rhs, tail) =>
-        c.Split.Let(rec, nme, rhs, desugarOperatorSplit(tail)(termPart, scope + nme.withFreshSymbol.symbol)) // <-- Weird use.
+        c.Split.Let(rec, nme, rhs, desugarOperatorSplit(tail)(termPart, scope + nme.withFreshSymbol.symbol, context)) // <-- Weird use.
       case s.Split.Else(default) => c.Split.Else(default)
       case s.Split.Nil => c.Split.Nil
     }}
 
-  private def desugarOperatorBranch(branch: s.OperatorBranch)(implicit termPart: PartialTerm, scope: Scope): c.Split =
+  private def desugarOperatorBranch(branch: s.OperatorBranch)(implicit termPart: PartialTerm, scope: Scope, context: Context): c.Split =
     trace(s"desugarOperatorBranch <== $termPart") {
       branch match {
-        case s.OperatorBranch.Binary(op, split) => desugarTermSplit(split)(termPart.addOp(op), scope)
-        case s.OperatorBranch.Match(_, split) => desugarPatternSplit(split)(termPart.get, scope)
+        case s.OperatorBranch.Binary(op, split) => desugarTermSplit(split)(termPart.addOp(op), scope, context)
+        case s.OperatorBranch.Match(_, split) => desugarPatternSplit(termPart.get, split)(scope, context)
       }
     }()
 
@@ -211,7 +211,7 @@ trait Desugaring { self: PreTyper =>
     * @param initialScope the scope before flattening the class pattern
     * @return a tuple of the augmented scope and a function that wrap a split
     */
-  private def desugarClassPattern(pattern: s.ClassPattern, scrutinee: Var, initialScope: Scope): (Scope, c.Split => c.Branch) = {
+  private def desugarClassPattern(pattern: s.ClassPattern, scrutinee: Var, initialScope: Scope)(implicit context: Context): (Scope, c.Split => c.Branch) = {
     val scrutineeSymbol = scrutinee.getScrutineeSymbol
     val patternClassSymbol = pattern.nme.resolveTypeSymbol(initialScope)
     // Most importantly, we need to add the class to the list of matched classes.
@@ -257,7 +257,7 @@ trait Desugaring { self: PreTyper =>
       nestedPatterns: Ls[Opt[Var -> Opt[s.Pattern]]],
       scopeWithScrutinees: Scope,
       bindScrutinees: c.Split => c.Split
-  ): (Scope, c.Split => c.Split) = {
+  )(implicit context: Context): (Scope, c.Split => c.Split) = {
     nestedPatterns.foldLeft((scopeWithScrutinees, bindScrutinees)) {
       // If this parameter is not matched with a sub-pattern, then we do
       // nothing and pass on scope and binder.
@@ -271,7 +271,7 @@ trait Desugaring { self: PreTyper =>
         val (scopeWithNestedAll, bindNestedAll) = desugarClassPattern(pattern, nme, scope)
         (scopeWithNestedAll, split => bindPrevious(bindNestedAll(split) :: c.Split.Nil))
       case ((scope, bindPrevious), S(nme -> S(pattern: s.LiteralPattern))) =>
-        val test = freshTest().withFreshSymbol
+        val test = context.freshTest().withFreshSymbol
         (scope + test.symbol, makeLiteralTest(test, nme, pattern.literal)(scope).andThen(bindPrevious))
       case ((scope, bindPrevious), S(nme -> S(s.TuplePattern(fields)))) =>
         val (scopeWithNestedAll, bindNestedAll) = desugarTuplePattern(fields, nme, scope)
@@ -301,7 +301,7 @@ trait Desugaring { self: PreTyper =>
       case _ => ???
     }.toList
 
-  private def desugarTuplePattern(fields: Ls[Opt[s.Pattern]], scrutinee: Var, initialScope: Scope): (Scope, c.Split => c.Split) = {
+  private def desugarTuplePattern(fields: Ls[Opt[s.Pattern]], scrutinee: Var, initialScope: Scope)(implicit context: Context): (Scope, c.Split => c.Split) = {
     val scrutineeSymbol = scrutinee.getScrutineeSymbol
     val nestedPatterns = flattenTupleFields(scrutinee, fields)
     val bindTupleFields = nestedPatterns.iterator.zipWithIndex.foldRight[c.Split => c.Split](identity) {
@@ -314,14 +314,14 @@ trait Desugaring { self: PreTyper =>
     desugarNestedPatterns(nestedPatterns, scopeWithTupleFields, bindTupleFields)
   }
 
-  private def desugarPatternSplit(split: s.PatternSplit)(implicit scrutinee: Term, scope: Scope): c.Split = {
+  private def desugarPatternSplit(scrutinee: Term, split: s.PatternSplit)(implicit scope: Scope, context: Context): c.Split = {
     def rec(scrutinee: Var, split: s.PatternSplit)(implicit scope: Scope): c.Split = split match {
       case s.Split.Cons(head, tail) => 
         head.pattern match {
           case s.AliasPattern(nme, pattern) => ???
           case s.LiteralPattern(literal) => ???
           case s.ConcretePattern(nme) => 
-            val test = freshTest().withFreshSymbol
+            val test = context.freshTest().withFreshSymbol
             c.Split.Let(
               rec = false,
               name = test,
@@ -329,27 +329,27 @@ trait Desugaring { self: PreTyper =>
               tail = c.Branch(
                 scrutinee = test,
                 pattern = truePattern,
-                continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope + test.symbol)
+                continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope + test.symbol, context)
               ) :: rec(scrutinee, tail)
             )
           case s.NamePattern(Var("_")) =>
-            desugarTermSplit(head.continuation)(PartialTerm.Empty, scope) ++ rec(scrutinee, tail)
+            desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context) ++ rec(scrutinee, tail)
           case s.NamePattern(nme) =>
             // Share the scrutinee's symbol with its aliases.
             // nme.symbol = scrutinee.symbol // <-- This currently causes a bug, reuse this line after we remove `ScrutineeSymbol`.
             nme.symbol = new ValueSymbol(nme, false)
-            val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope + nme.symbol)
+            val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope + nme.symbol, context)
             c.Branch(scrutinee, c.Pattern.Name(nme), continuation) :: rec(scrutinee, tail)(scope + nme.symbol)
           case pattern @ s.ClassPattern(nme, fields) =>
             println(s"find term symbol of $scrutinee in ${scope.showLocalSymbols}")
             scrutinee.symbol = scope.getTermSymbol(scrutinee.name).getOrElse(???)
             val (scopeWithAll, bindAll) = desugarClassPattern(pattern, scrutinee, scope)
-            val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scopeWithAll)
+            val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scopeWithAll, context)
             bindAll(continuation) :: rec(scrutinee, tail)
           case s.TuplePattern(fields) =>
             scrutinee.symbol = scope.getTermSymbol(scrutinee.name).getOrElse(???)
             val (scopeWithAll, bindAll) = desugarTuplePattern(fields, scrutinee, scope)
-            val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scopeWithAll)
+            val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scopeWithAll, context)
             val withBindings = bindAll(continuation)
             if (withBindings.hasElse) {
               withBindings
@@ -366,32 +366,8 @@ trait Desugaring { self: PreTyper =>
     scrutinee match {
       case nme: Var => rec(nme, split)
       case other =>
-        val alias = freshScrutinee().withFreshSymbol
+        val alias = context.freshScrutinee().withFreshSymbol
         c.Split.Let(false, alias, scrutinee, rec(alias, split)(scope + alias.symbol))
     }
   }
 }
-
-object Desugaring {
-  class VariableGenerator(prefix: Str) {
-    private var nextIndex = 0
-
-    def apply(): Var = {
-      val thisIndex = nextIndex
-      nextIndex += 1
-      Var(s"$prefix$thisIndex")
-    }
-  }
-
-  val cachePrefix = "cache$"
-  val scrutineePrefix = "scrut$"
-  val testPrefix = "test$"
-  val unappliedPrefix = "args_"
-
-  def isCacheVar(nme: Var): Bool = nme.name.startsWith(cachePrefix)
-  def isScrutineeVar(nme: Var): Bool = nme.name.startsWith(scrutineePrefix)
-  def isTestVar(nme: Var): Bool = nme.name.startsWith(testPrefix)
-  def isUnappliedVar(nme: Var): Bool = nme.name.startsWith(unappliedPrefix)
-  def isGeneratedVar(nme: Var): Bool =
-    isCacheVar(nme) || isScrutineeVar(nme) || isTestVar(nme) || isUnappliedVar(nme)
-}
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index ba6c2e3798..34e06d518d 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -1,7 +1,7 @@
 
 package mlscript.ucs.stages
 
-import mlscript.ucs.{showVar, Lines, LinesOps}
+import mlscript.ucs.{showVar, Context, Lines, LinesOps, VariableGenerator}
 import mlscript.ucs.core._
 import mlscript.ucs.helpers._
 import mlscript.pretyper.Scope
@@ -14,26 +14,24 @@ import mlscript.utils._, shorthands._
 trait Normalization { self: mlscript.pretyper.Traceable =>
   import Normalization._
 
-  private val freshShadowed = new Desugaring.VariableGenerator("shadowed$")
-
-  def concatImpl(these: Split, those: Split)(implicit generatedVars: Set[Var]): Split =
+  private def concatImpl(these: Split, those: Split)(implicit context: Context, generatedVars: Set[Var]): Split =
     if (these.hasElse) these else (these match {
       case these @ Split.Cons(_, tail) => these.copy(tail = concatImpl(tail, those))
       case these @ Split.Let(_, nme, _, tail) =>
         if (those.freeVars contains nme) {
-          val fresh = freshShadowed()
+          val fresh = context.freshShadowed()
           val thoseWithShadowed = Split.Let(false, nme, fresh, those)
           val concatenated = these.copy(tail = concatImpl(tail, thoseWithShadowed))
           Split.Let(false, fresh, nme, concatenated)
         } else {
-          these.copy(tail = concatImpl(tail, those)(generatedVars + nme))
+          these.copy(tail = concatImpl(tail, those)(context, generatedVars + nme))
         }
       case _: Split.Else => these
       case Split.Nil => those.withoutBindings(generatedVars)
     })
   
-  def concat(these: Split, those: Split)(implicit vars: Set[Var]): Split =
-    trace(s"concat <== ${vars.mkString("{", ", ", "}")}") {
+  private def concat(these: Split, those: Split)(implicit context: Context, generatedVars: Set[Var]): Split =
+    trace(s"concat <== ${generatedVars.mkString("{", ", ", "}")}") {
       println(s"these: ${printSplit(these)}")
       println(s"those: ${printSplit(those)}")
       concatImpl(these, those)
@@ -45,15 +43,15 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
     * @param split the split to normalize
     * @return the normalized term
     */ 
-  @inline protected def normalize(split: Split): Term = normalizeToTerm(split)(Set.empty)
+  @inline protected def normalize(split: Split)(implicit context: Context): Term = normalizeToTerm(split)(context, Set.empty)
 
-  private def normalizeToTerm(split: Split)(implicit generatedVars: Set[Var]): Term = trace("normalizeToTerm <==") {
+  private def normalizeToTerm(split: Split)(implicit context: Context, generatedVars: Set[Var]): Term = trace("normalizeToTerm <==") {
     split match {
       case Split.Cons(Branch(scrutinee, Pattern.Name(nme), continuation), tail) =>
         println(s"alias $scrutinee => $nme")
         Let(false, nme, scrutinee, normalizeToTerm(concat(continuation, tail)))
       // Skip Boolean conditions as scrutinees, because they only appear once.
-      case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true")), continuation), tail) if Desugaring.isTestVar(test) =>
+      case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true")), continuation), tail) if context.isTestVar(test) =>
         val trueBranch = normalizeToTerm(concat(continuation, tail))
         val falseBranch = normalizeToCaseBranches(tail)
         CaseOf(test, Case(nme, trueBranch, falseBranch))
@@ -70,27 +68,27 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
         throw new NormalizationException((msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc) :: Nil)
       case Split.Let(rec, Var("_"), rhs, tail) => normalizeToTerm(tail)
-      case Split.Let(_, nme, _, tail) if Desugaring.isScrutineeVar(nme) && generatedVars.contains(nme) =>
+      case Split.Let(_, nme, _, tail) if context.isScrutineeVar(nme) && generatedVars.contains(nme) =>
         normalizeToTerm(tail)
       case Split.Let(rec, nme, rhs, tail) =>
-        val newDeclaredBindings = if (Desugaring.isGeneratedVar(nme)) generatedVars + nme else generatedVars
-        Let(rec, nme, rhs, normalizeToTerm(tail)(newDeclaredBindings))
+        val newDeclaredBindings = if (context.isGeneratedVar(nme)) generatedVars + nme else generatedVars
+        Let(rec, nme, rhs, normalizeToTerm(tail)(context, newDeclaredBindings))
       case Split.Else(default) => default
       case Split.Nil => println("unexpected empty split"); ???
     }
   }(_ => "normalizeToTerm ==> ")
 
-  private def normalizeToCaseBranches(split: Split)(implicit generatedVars: Set[Var]): CaseBranches =
+  private def normalizeToCaseBranches(split: Split)(implicit context: Context, generatedVars: Set[Var]): CaseBranches =
     trace("normalizeToCaseBranches") {
       split match {
         // case Split.Cons(head, Split.Nil) => Case(head.pattern, normalizeToTerm(head.continuation), NoCases)
         case other: Split.Cons => Wildcard(normalizeToTerm(other))
         case Split.Let(rec, Var("_"), rhs, tail) => normalizeToCaseBranches(tail)
-        case Split.Let(_, nme, _, tail) if Desugaring.isScrutineeVar(nme) && generatedVars.contains(nme) =>
+        case Split.Let(_, nme, _, tail) if context.isScrutineeVar(nme) && generatedVars.contains(nme) =>
           normalizeToCaseBranches(tail)
         case Split.Let(rec, nme, rhs, tail) =>
-          val newDeclaredBindings = if (Desugaring.isGeneratedVar(nme)) generatedVars + nme else generatedVars
-          normalizeToCaseBranches(tail)(newDeclaredBindings) match {
+          val newDeclaredBindings = if (context.isGeneratedVar(nme)) generatedVars + nme else generatedVars
+          normalizeToCaseBranches(tail)(context, newDeclaredBindings) match {
             case NoCases => Wildcard(rhs)
             case Wildcard(term) => Wildcard(Let(rec, nme, rhs, term))
             case _: Case => die
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index 8ecb313f3f..60028ef729 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -1,6 +1,7 @@
 package mlscript.ucs.stages
 
 import mlscript.{Case, CaseBranches, CaseOf, Let, Loc, NoCases, Term, Var, Wildcard}
+import mlscript.ucs.Context
 import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
 import mlscript.Message, Message.MessageContext
@@ -27,14 +28,14 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
       }
     }(symbol => s"getClassSymbolFromVar ==> ${symbol.name}")
 
-  def postProcess(term: Term): Term = trace(s"postProcess <== ${inspect.shallow(term)}") {
+  def postProcess(term: Term)(implicit context: Context): Term = trace(s"postProcess <== ${inspect.shallow(term)}") {
     // Normalized terms are constructed using `Let` and `CaseOf`.
     term match {
       case top @ CaseOf(scrutinee: Var, fst @ Case(className: Var, body, NoCases)) =>
         println(s"found a UNARY case: $scrutinee is $className")
         println("post-processing the body")
         top.copy(cases = fst.copy(body = postProcess(body)))
-      case top @ CaseOf(test: Var, fst @ Case(Var("true"), trueBranch, Wildcard(falseBranch))) if Desugaring.isTestVar(test) =>
+      case top @ CaseOf(test: Var, fst @ Case(Var("true"), trueBranch, Wildcard(falseBranch))) if context.isTestVar(test) =>
         println(s"found a if-then-else case: $test is true")
         val processedTrueBranch = postProcess(trueBranch)
         val processedFalseBranch = postProcess(falseBranch)
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index 9b5005565d..64f5ede3a4 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -20,10 +20,10 @@ import scala.collection.immutable
 trait Transformation { self: mlscript.pretyper.Traceable =>
   import Transformation._
 
-  def transform(`if`: If, useNewDefs: Bool = true): TermSplit =
-    transformIfBody(`if`.body)(useNewDefs) ++ `if`.els.fold(Split.empty)(Split.default)
+  def transform(`if`: If): TermSplit =
+    transformIfBody(`if`.body) ++ `if`.els.fold(Split.empty)(Split.default)
 
-  private def transformIfBody(body: IfBody)(implicit useNewDefs: Bool): TermSplit = trace(s"transformIfBody <== ${inspect.shallow(body)}") {
+  private def transformIfBody(body: IfBody): TermSplit = trace(s"transformIfBody <== ${inspect.shallow(body)}") {
     body match {
       case IfThen(expr, rhs) =>
         splitAnd(expr).foldRight(Split.then(rhs)) {
@@ -84,7 +84,7 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
     }
   }(_ => "transformIfBody ==> ")
   
-  private def transformOperatorBranch(opsRhs: Var -> IfBody)(implicit useNewDefs: Bool): OperatorBranch =
+  private def transformOperatorBranch(opsRhs: Var -> IfBody): OperatorBranch =
     opsRhs match {
       case (op @ Var("is"), rhs) => OperatorBranch.Match(op, transformPatternMatching(rhs))
       case (op, rhs) => OperatorBranch.Binary(op, transformIfBody(rhs))
@@ -93,7 +93,7 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
   /**
     * Transform an `IfBody` into a `PatternSplit`.
     */
-  private def transformPatternMatching(body: IfBody)(implicit useNewDefs: Bool): PatternSplit =
+  private def transformPatternMatching(body: IfBody): PatternSplit =
     trace(s"transformPatternMatching <== ${inspect.shallow(body)}") {
       body match {
         case IfThen(expr, rhs) => 
@@ -125,7 +125,7 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
       }
     }(_ => "transformPatternMatching ==>")
 
-  private def transformPattern(term: Term)(implicit useNewDefs: Bool): Pattern = term match {
+  private def transformPattern(term: Term): Pattern = term match {
     case nme @ Var("true" | "false") => ConcretePattern(nme)
     case nme @ Var(name) if name.headOption.exists(_.isUpper) => ClassPattern(nme, N)
     case nme: Var => NamePattern(nme)
@@ -145,8 +145,8 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
       throw new TransformException(msg"Unknown pattern", term.toLoc)
   }
 
-  private def separatePattern(term: Term)(implicit useNewDefs: Bool): (Pattern, Opt[Term]) = {
-    val (rawPattern, extraTest) = helpers.separatePattern(term, useNewDefs)
+  private def separatePattern(term: Term): (Pattern, Opt[Term]) = {
+    val (rawPattern, extraTest) = helpers.separatePattern(term, true)
     println("rawPattern: " + inspect.deep(rawPattern))
     println("extraTest: " + inspect.deep(extraTest))
     (transformPattern(rawPattern), extraTest)
@@ -171,8 +171,8 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
 
 object Transformation {
   private object OperatorIs {
-    def unapply(term: Term)(implicit useNewDefs: Bool): Opt[(Term, Term)] = term match {
-      case App(App(Var("is"), Tup(_ -> Fld(_, scrutinee) :: Nil)), Tup(_ -> Fld(_, pattern) :: Nil)) if !useNewDefs => S(scrutinee -> pattern)
+    def unapply(term: Term): Opt[(Term, Term)] = term match {
+      // case App(App(Var("is"), Tup(_ -> Fld(_, scrutinee) :: Nil)), Tup(_ -> Fld(_, pattern) :: Nil)) if !useNewDefs => S(scrutinee -> pattern)
       case App(Var("is"), PlainTup(scrutinee, pattern)) => S(scrutinee -> pattern)
       case _ => N
     }

From 5e9df42aa5c9012401b407901304125673fef862 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 27 Dec 2023 18:14:19 +0800
Subject: [PATCH 028/147] Track scrutiness with contexts and decouple
 scrutinees from symbols

Finally! I made this. In this commit, we track and store the
information of scrutinee through the context of per-UCS-term;
at the same time, we decouple the scrutinee and term symbol.
This has the following advantages.

1. The symbol corresponding to each variable can store information
   from different UCS terms.
2. The error location of the scrutinee is more precise.
3. This enables coverage checking to take advantage of previously
   collected patterns, eliminating the need to traverse the term
   again.

In addition, there are a few minor changes.

1. All functions used for pretty printing have been extracted into
   a separate package, namely `mlscript.ucs.display`.
2. Common operations about `Var` have been extracted into an
   implicit class in `DesugarUCS` base class.
---
 .../main/scala/mlscript/pretyper/Symbol.scala |  81 ++----
 .../src/main/scala/mlscript/ucs/Context.scala |  40 ++-
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |  93 ++++++-
 .../scala/mlscript/ucs/ScrutineeData.scala    | 139 ++++++++--
 .../scala/mlscript/ucs/context/CaseSet.scala  |  97 +++++++
 .../scala/mlscript/ucs/context/package.scala  |  13 +
 shared/src/main/scala/mlscript/ucs/core.scala |  22 --
 .../src/main/scala/mlscript/ucs/display.scala | 133 +++++++++
 .../src/main/scala/mlscript/ucs/package.scala |   7 +-
 .../ucs/stages/CoverageChecking.scala         | 175 ++----------
 .../mlscript/ucs/stages/Desugaring.scala      | 262 ++++++++----------
 .../mlscript/ucs/stages/Normalization.scala   |  94 +++----
 .../mlscript/ucs/stages/PostProcessing.scala  |  90 +++---
 .../scala/mlscript/ucs/stages/package.scala   |  20 --
 .../src/main/scala/mlscript/ucs/syntax.scala  |  46 ---
 .../pretyper/ucs/coverage/MissingCases.mls    |  32 +--
 .../pretyper/ucs/coverage/SealedClasses.mls   |   4 +-
 17 files changed, 729 insertions(+), 619 deletions(-)
 create mode 100644 shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
 create mode 100644 shared/src/main/scala/mlscript/ucs/context/package.scala
 create mode 100644 shared/src/main/scala/mlscript/ucs/display.scala

diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index 5763876f95..c25fd1da2d 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -4,6 +4,7 @@ import collection.mutable.{Buffer, Map => MutMap, Set => MutSet}
 import mlscript.{Loc, NuFunDef, NuTypeDef, TypeName, Var}
 import mlscript.{Cls, Trt, Mxn, Als, Mod}
 import mlscript.utils._, shorthands._
+import mlscript.ucs.{Context, ScrutineeData}
 
 package object symbol {
   sealed abstract class Symbol(val name: Str) {
@@ -54,7 +55,22 @@ package object symbol {
     // lazy val (scope, contents) = (enclosingScope.derive, Map.empty[Str, Symbol])
   }
 
-  sealed abstract class TermSymbol(name: String) extends Symbol(name)
+  sealed abstract class TermSymbol(name: String) extends Symbol(name) {
+    private val scrutinees: MutMap[Context, ScrutineeData] = MutMap.empty
+    
+    def getOrCreateScrutinee(implicit context: Context): ScrutineeData =
+      scrutinees.getOrElseUpdate(context, context.freshScrutinee)
+
+    def getScrutinee(implicit context: Context): Opt[ScrutineeData] =
+      scrutinees.get(context)
+
+    def isScrutinee(implicit context: Context): Bool = scrutinees.contains(context)
+
+    def addScrutinee(scrutinee: ScrutineeData)(implicit context: Context): Unit = {
+      require(!isScrutinee)
+      scrutinees += context -> scrutinee
+    }
+  }
 
   final class FunctionSymbol(val defn: NuFunDef) extends TermSymbol(defn.nme.name) {
     require(defn.isLetRec.isEmpty)
@@ -70,66 +86,5 @@ package object symbol {
       }
   }
 
-  // FIXME:
-  // We should remove `ScrutineeSymbol` ASAP. There are too many reasons. The
-  // most important one I can remember right now is that multiple variables
-  // may share the same scrutinee symbol. But for now symbol must have a unique
-  // name. We should use a dedicated symbol for tracking scrutinees.
-  sealed abstract class ScrutineeSymbol(name: Str) extends TermSymbol(name) {
-    def toLoc: Opt[Loc]
-
-    val matchedClasses: MutMap[TypeSymbol, Buffer[Loc]] = MutMap.empty
-    val unappliedVarMap: MutMap[TypeSymbol, Var] = MutMap.empty
-    val subScrutineeMap: MutMap[TypeSymbol, MutMap[Int, MutMap[Var, ValueSymbol]]] = MutMap.empty
-    // Hmm, maybe we can merge these three maps into one.
-    // Urgh, let's do this in the next refactor.
-    // I really should move these imperative and stateful functions to a
-    // separate class!
-    val tupleSubScrutineeMap: MutMap[Int, MutMap[Var, ValueSymbol]] = MutMap.empty
-    // Note that the innermost map is a map from variable names to symbols.
-    // Sometimes a class parameter may have many names. We maintain the
-    // uniqueness of the symbol for now.
-
-    def getSubScrutineeSymbolOrElse(
-        classLikeSymbol: TypeSymbol,
-        index: Int,
-        name: Var, // <-- Remove this parameter after we remove `ScrutineeSymbol`.
-        default: => ValueSymbol
-    ): ValueSymbol =
-      subScrutineeMap.getOrElseUpdate(classLikeSymbol, MutMap.empty)
-                     .getOrElseUpdate(index, MutMap.empty)
-                     .getOrElseUpdate(name, default)
-    
-    def getTupleSubScrutineeSymbolOrElse(
-        index: Int,
-        name: Var, // <-- Remove this parameter after we remove `ScrutineeSymbol`.
-        default: => ValueSymbol
-    ): ValueSymbol =
-      tupleSubScrutineeMap.getOrElseUpdate(index, MutMap.empty)
-                          .getOrElseUpdate(name, default)
-
-    def addMatchedClass(symbol: TypeSymbol, loc: Opt[Loc]): Unit = {
-      matchedClasses.getOrElseUpdate(symbol, Buffer.empty) ++= loc
-    }
-
-    def getUnappliedVarOrElse(classLikeSymbol: TypeSymbol, default: => Var): Var =
-      unappliedVarMap.getOrElseUpdate(classLikeSymbol, default)
-
-    def addUnappliedVar(symbol: TypeSymbol, nme: Var): Unit = {
-      unappliedVarMap += symbol -> nme
-    }
-
-    // Store the symbol of the parent scrutinee. I doubt if this is necessary.
-    private var maybeParentSymbol: Opt[ScrutineeSymbol] = N
-    def parentSymbol: Opt[ScrutineeSymbol] = maybeParentSymbol
-    def withParentSymbol(parentSymbol: ScrutineeSymbol): this.type =
-      maybeParentSymbol match {
-        case N => maybeParentSymbol = S(parentSymbol); this
-        case S(_) => throw new IllegalStateException("Parent symbol is already set.")
-      }
-  }
-
-  final class ValueSymbol(val nme: Var, val hoisted: Bool) extends ScrutineeSymbol(nme.name) {
-    override def toLoc: Opt[Loc] = nme.toLoc
-  }
+  final class ValueSymbol(val nme: Var, val hoisted: Bool) extends TermSymbol(nme.name)
 }
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/ucs/Context.scala b/shared/src/main/scala/mlscript/ucs/Context.scala
index 1065a238a7..ad94bc1b64 100644
--- a/shared/src/main/scala/mlscript/ucs/Context.scala
+++ b/shared/src/main/scala/mlscript/ucs/Context.scala
@@ -1,15 +1,15 @@
 package mlscript.ucs
 
-import collection.mutable.{Buffer, Map => MutMap, SortedMap => MutSortedMap, Set => MutSet}
+import collection.mutable.{Buffer, Map => MutMap, SortedMap => MutSortedMap}
 import mlscript.{If, Loc, NuFunDef, NuTypeDef, TypeName, Var}
 import mlscript.{Cls, Trt, Mxn, Als, Mod}
 import mlscript.pretyper.symbol.TypeSymbol
 import mlscript.pretyper.Scope
 import mlscript.utils._, shorthands._
+import mlscript.ucs.context.MatchRegistry
 
 class Context(originalTerm: If) {
-  val prefix: Str = Context.freshPrefix().name
-
+  private val prefix = Context.freshPrefix()
   private val cachePrefix = prefix + "$cache$"
   private val scrutineePrefix = prefix + "$scrut$"
   private val testPrefix = prefix + "$test$"
@@ -27,11 +27,39 @@ class Context(originalTerm: If) {
   // I plan to mix the unique identifiers of UCS expressions into the prefixes.
   // So that the generated variables will definitely not conflict with others.
   val freshCache: VariableGenerator = new VariableGenerator(cachePrefix)
-  val freshScrutinee: VariableGenerator = new VariableGenerator(scrutineePrefix)
+  val freshScrutineeVar: VariableGenerator = new VariableGenerator(scrutineePrefix)
   val freshTest: VariableGenerator = new VariableGenerator(testPrefix)
   val freshShadowed: VariableGenerator = new VariableGenerator("shadowed$")
+
+  /** The buffer contains all `ScrutineeData` created within this context. */
+  private val scrutineeBuffer: Buffer[ScrutineeData] = Buffer.empty
+
+  // TODO: Mark this two files as package private.
+  def freshScrutinee: ScrutineeData = {
+    val scrutinee = new ScrutineeData(this, N)
+    scrutineeBuffer += scrutinee
+    scrutinee
+  }
+
+  // TODO: Mark this two files as package private.
+  def freshScrutinee(parent: ScrutineeData): ScrutineeData = {
+    val scrutinee = new ScrutineeData(this, S(parent))
+    scrutineeBuffer += scrutinee
+    scrutinee
+  }
+
+  /**
+    * Create a `MatchRegistry` from the current context.
+    */
+  def toMatchRegistry: MatchRegistry =
+    scrutineeBuffer.iterator.flatMap { scrutinee =>
+      val caseSet = scrutinee.toCaseSet
+      scrutinee.aliasesIterator.map(alias => (alias -> scrutinee) -> caseSet)
+    }.toMap
 }
 
 object Context {
-  private val freshPrefix = new VariableGenerator("ucs")
-}
+  // TODO: Generate fresh prefix in a determinstic way. I tried to use a counter,
+  // but the produced value is not stable across different runs.
+  def freshPrefix(): Str = "ucs"
+}
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 944bca1c6f..116ee0fc19 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -2,10 +2,12 @@ package mlscript.ucs
 
 import collection.mutable.{Map => MutMap}
 import mlscript.ucs.stages._
+import mlscript.ucs.display.showNormalizedTerm
 import mlscript.pretyper.{PreTyper, Scope}
 import mlscript.pretyper.symbol._
 import mlscript._, utils._, shorthands._
 import mlscript.Message, Message.MessageContext
+import mlscript.ucs.display.showSplit
 
 // TODO: Rename to `Desugarer` once the old desugarer is removed.
 trait DesugarUCS extends Transformation
@@ -14,6 +16,84 @@ trait DesugarUCS extends Transformation
                     with PostProcessing 
                     with CoverageChecking { self: PreTyper =>
 
+  protected def freshSymbol(nme: Var): ValueSymbol = new ValueSymbol(nme, false)
+
+  /** Common operations of `Var` which can be shared within all stages. */
+  protected implicit class VarOps(nme: Var) {
+    /** Associate the given `Var` with a fresh `ValueSymbol`. */
+    def withFreshSymbol: Var = nme.withSymbol(freshSymbol(nme))
+
+    /**
+      * If the given `Var` represents a class name, get its associated `ClassSymbol`.
+      *
+      * @param className the class name variable
+      */
+    def getClassLikeSymbol: TypeSymbol =
+      trace(s"getClassLikeSymbol <== ${inspect.shallow(nme)}") {
+        nme.symbolOption match {
+          case S(symbol: ClassSymbol) => symbol
+          case S(symbol: TraitSymbol) => symbol
+          case S(symbol: ModuleSymbol) => symbol
+          case S(symbol: Symbol) => throw new DesugaringException(
+            msg"variable ${nme.name} is not associated with a class symbol" -> N :: Nil)
+          case N => throw new DesugaringException(
+            msg"variable ${nme.name} is not associated with any symbols" -> N :: Nil)
+        }
+      }(symbol => s"getClassLikeSymbol ==> ${symbol.name}")
+
+    /**
+      * A short hand for `nme.symbol.getScrutinee` but add a diagnostic message
+      * to a local diagnostic archive (TODO) if there's any error.
+      */
+    def getOrCreateScrutinee(implicit context: Context): ScrutineeData = nme.symbolOption match {
+      case S(symbol: TermSymbol) => symbol.getOrCreateScrutinee
+      case S(otherSymbol) => throw new DesugaringException(
+        msg"Expected scrutinee symbol, found ${nme.symbol.name}" -> nme.toLoc :: Nil
+      )
+      case N => throw new DesugaringException(
+        msg"Scrutinee symbol not found" -> nme.toLoc :: Nil
+      )
+    }
+
+    def withScrutinee(scrutinee: ScrutineeData)(implicit context: Context): Var = nme.symbolOption match {
+      case S(symbol: TermSymbol) =>
+        symbol.addScrutinee(scrutinee)
+        nme
+      case S(otherSymbol) => throw new DesugaringException(
+        msg"Expected scrutinee symbol, found ${nme.symbol.name}" -> nme.toLoc :: Nil
+      )
+      case N => throw new DesugaringException(
+        msg"Scrutinee symbol not found" -> nme.toLoc :: Nil
+      )
+    }
+
+    def withResolvedTypeSymbol(implicit scope: Scope): Var = {
+      nme.symbol = nme.resolveTypeSymbol
+      nme
+    }
+
+    def resolveTypeSymbol(implicit scope: Scope): TypeSymbol = scope.getTypeSymbol(nme.name) match {
+      case S(symbol: TraitSymbol) =>
+        println(s"resolveTypeSymbol ${nme} ==> trait")
+        nme.symbol = symbol
+        symbol
+      case S(symbol: ClassSymbol) =>
+        println(s"resolveTypeSymbol ${nme} ==> class")
+        nme.symbol = symbol
+        symbol
+      case S(symbol: ModuleSymbol) =>
+        println(s"resolveTypeSymbol ${nme} ==> module")
+        nme.symbol = symbol
+        symbol
+      case S(symbol: MixinSymbol) =>
+        throw new DesugaringException(msg"Mixins are not allowed in pattern" -> nme.toLoc :: Nil)
+      case S(symbol: TypeAliasSymbol) =>
+        throw new DesugaringException(msg"Type alias is not allowed in pattern" -> nme.toLoc :: Nil)
+      case N =>
+        throw new DesugaringException(msg"Undefined symbol found in patterns." -> nme.toLoc :: Nil)
+    }
+  }
+
   protected def traverseIf(`if`: If)(implicit scope: Scope): Unit = {
     implicit val context: Context = new Context(`if`)
     trace("traverseIf") {
@@ -22,7 +102,7 @@ trait DesugarUCS extends Transformation
         println("STEP 0")
         val transformed = transform(`if`)
         println("Transformed UCS term:")
-        println(ucs.syntax.printTermSplit(transformed))
+        println(showSplit(transformed))
         transformed
       }
       // Stage 1: Desugaring
@@ -30,7 +110,7 @@ trait DesugarUCS extends Transformation
         println("STEP 1")
         val desugared = desugar(transformed)
         println("Desugared UCS term:")
-        println(ucs.core.printSplit(desugared))
+        println(showSplit(desugared))
         desugared
       }
       traceWithTopic("traverse") {
@@ -42,7 +122,7 @@ trait DesugarUCS extends Transformation
         println("STEP 2")
         val normalized = normalize(desugared)
         println("Normalized UCS term:")
-        printNormalizedTerm(normalized)
+        println(showNormalizedTerm(normalized))
         normalized
       }
       // Stage 3: Post-processing
@@ -50,7 +130,7 @@ trait DesugarUCS extends Transformation
         println("STEP 3")
         val postProcessed = postProcess(normalized)
         println("Post-processed UCS term:")
-        printNormalizedTerm(postProcessed)
+        println(showNormalizedTerm(postProcessed))
         postProcessed
       }
       // Stage 4: Coverage checking
@@ -87,11 +167,6 @@ trait DesugarUCS extends Transformation
 
   private def traversePattern(scrutinee: Var, pattern: core.Pattern)(implicit scope: Scope): List[Var -> Symbol] =
     trace(s"traversePattern <== $pattern") {
-      lazy val scrutineeSymbol = scrutinee.symbol match {
-        case symbol: ScrutineeSymbol => symbol
-        case other: Symbol =>
-          throw new DesugaringException(msg"Scrutinee is not a scrutinee symbol" -> scrutinee.toLoc :: Nil)
-      }
       pattern match {
         case core.Pattern.Literal(literal) => Nil
         case core.Pattern.Name(nme) => nme -> nme.symbol :: Nil
diff --git a/shared/src/main/scala/mlscript/ucs/ScrutineeData.scala b/shared/src/main/scala/mlscript/ucs/ScrutineeData.scala
index 2b259b99a4..3925e4460c 100644
--- a/shared/src/main/scala/mlscript/ucs/ScrutineeData.scala
+++ b/shared/src/main/scala/mlscript/ucs/ScrutineeData.scala
@@ -1,20 +1,32 @@
 package mlscript.ucs
 
-import collection.mutable.{Buffer, Map => MutMap, SortedMap => MutSortedMap, Set => MutSet}
-import mlscript.{Loc, NuFunDef, NuTypeDef, TypeName, Var}
+import collection.mutable.{Buffer, Map => MutMap, SortedMap => MutSortedMap, SortedSet => MutSortedSet}
+import mlscript.{Loc, Located, NuFunDef, NuTypeDef, TypeName, Var}
 import mlscript.{Cls, Trt, Mxn, Als, Mod}
 import mlscript.pretyper.symbol.TypeSymbol
 import mlscript.utils._, shorthands._
+import mlscript.ucs.context.CaseSet
 
 class ClassPatternInfo(scrutinee: ScrutineeData) {
-  private val locations: Buffer[Loc] = Buffer.empty
+  private val locationsBuffer: Buffer[Loc] = Buffer.empty
   private var unappliedVarOpt: Opt[Var] = N
   private val parameters: MutSortedMap[Int, ScrutineeData] = MutSortedMap.empty
 
-  def getParameter(index: Int): ScrutineeData =
-    parameters.getOrElse(index, new ScrutineeData(S(scrutinee)))
+  /**
+    * Get or create a sub-scrutinee for the given parameter index.
+    *
+    * @param index the index of the parameter.
+    * @return a `ScrutineeData` for the parameter whose parent scrutinee is the
+    *         current scrutinee
+    */
+  def getParameter(index: Int): ScrutineeData = {
+    require(index >= 0)
+    parameters.getOrElseUpdate(index, scrutinee.freshSubScrutinee)
+  }
+
+  def addLocation(located: Located): Unit = located.getLoc.foreach(locationsBuffer += _)
 
-  def addLocation(location: Opt[Loc]): Unit = locations ++= location
+  def addLocation(location: Opt[Loc]): Unit = locationsBuffer ++= location
 
   def getUnappliedVar(default: => Var): Var =
     unappliedVarOpt.getOrElse {
@@ -22,17 +34,28 @@ class ClassPatternInfo(scrutinee: ScrutineeData) {
       unappliedVarOpt = S(unappliedVar)
       unappliedVar
     }
+
+  def arity: Opt[Int] = parameters.keysIterator.maxOption.map(_ + 1)
+
+  def firstOccurrence: Option[Loc] = locationsBuffer.headOption
+
+  def locations: Ls[Loc] = locationsBuffer.toList
 }
 
 class TuplePatternInfo(scrutinee: ScrutineeData) {
-  private val locations: Buffer[Loc] = Buffer.empty
+  private val locationsBuffer: Buffer[Loc] = Buffer.empty
   private val fields: MutSortedMap[Int, ScrutineeData] = MutSortedMap.empty
 
   def getField(index: Int): ScrutineeData =
-    fields.getOrElse(index, new ScrutineeData(S(scrutinee)))
+    fields.getOrElseUpdate(index, scrutinee.freshSubScrutinee)
+
+  def arity: Opt[Int] = fields.keysIterator.maxOption.map(_ + 1)
+
+  def locations: Ls[Loc] = locationsBuffer.toList
 }
 
-class ScrutineeData(parent: Opt[ScrutineeData]) {
+class ScrutineeData(val context: Context, parent: Opt[ScrutineeData]) {
+  private val locations: Buffer[Loc] = Buffer.empty
   private var generatedVarOpt: Opt[Var] = N
   private val classLikePatterns: MutMap[TypeSymbol, ClassPatternInfo] = MutMap.empty
   // Currently we only support simple tuple patterns, so there is only _one_
@@ -42,23 +65,99 @@ class ScrutineeData(parent: Opt[ScrutineeData]) {
   // If we support tuple pattern splice, we need a more expressive key in the
   // map's type.
   private var tuplePatternOpt: Opt[TuplePatternInfo] = N
+  private var alisesSet: MutSortedSet[Var] = MutSortedSet.empty
 
-  def getClassUnappliedVar(classLikeSymbol: TypeSymbol, default: => Var): Var =
-    classLikePatterns.getOrElse(classLikeSymbol, new ClassPatternInfo(this)).getUnappliedVar(default)
+  def +=(alias: Var): Unit = alisesSet += alias
 
-  def getClassLikeParameter(classLikeSymbol: TypeSymbol, index: Int, location: Opt[Loc]): ScrutineeData = {
-    val classPattern = classLikePatterns.getOrElse(classLikeSymbol, new ClassPatternInfo(this))
-    classPattern.addLocation(location)
-    classPattern.getParameter(index)
-  }
+  def withAlias(alias: Var): ScrutineeData = { this += alias; this }
+
+  def aliasesIterator: Iterator[Var] = alisesSet.iterator
 
-  def getClassLikeParameter(classLikeSymbol: TypeSymbol, index: Int): ScrutineeData =
-    classLikePatterns.getOrElse(classLikeSymbol, new ClassPatternInfo(this)).getParameter(index)
+  /**
+    * If there is already a `ClassPatternInfo` for the given symbol, return it.
+    * Otherwise, create a new `ClassPatternInfo` and return it.
+    */
+  def getOrCreateClassPattern(classLikeSymbol: TypeSymbol): ClassPatternInfo =
+    classLikePatterns.getOrElseUpdate(classLikeSymbol, new ClassPatternInfo(this))
 
-  def getTupleField(index: Int): ScrutineeData =
+  /**
+    * Get the class pattern but DO NOT create a new one if there isn't. This
+    * function is mainly used in post-processing because we don't want to
+    * accidentally create new patterns.
+    */
+  def getClassPattern(classLikeSymbol: TypeSymbol): Opt[ClassPatternInfo] =
+    classLikePatterns.get(classLikeSymbol)
+
+  /**
+   * If there is already a `TuplePatternInfo`, return it. Otherwise, create a
+   * new `TuplePatternInfo` and return it.
+   * 
+   * **NOTE**: There's only one slot for tuple patterns because we cannot
+   * differentiate tuple types in underlying MLscript case terms. In the future,
+   * we will support complex tuple patterns, so we need to extend this method to
+   * a signature like this.
+   * 
+   * ```scala
+   * def getOrCreateTuplePattern(dimension: TupleDimension): TuplePatternInfo
+   * case class TupleDimension(knownArity: Int, hasSplice: Bool)
+   * ```
+   */
+  def getOrCreateTuplePattern: TuplePatternInfo =
     tuplePatternOpt.getOrElse {
       val tuplePattern = new TuplePatternInfo(this)
       tuplePatternOpt = S(tuplePattern)
       tuplePattern
-    }.getField(index)
+    }
+
+  def classLikePatternsIterator: Iterator[TypeSymbol -> ClassPatternInfo] = classLikePatterns.iterator
+
+  /** Get the name representation of patterns. Only for debugging. */
+  def patterns: Iterator[Str] = {
+    val classLikePatternsStr = classLikePatterns.iterator.map { case (symbol, pattern) =>
+      s"${symbol.name}(${pattern.arity.fold("?")(_.toString)})"
+    }
+    val tuplePatternStr = tuplePatternOpt.iterator.map { tuplePattern =>
+      s"tuple(${tuplePattern.arity.fold("?")(_.toString)})"
+    }
+    classLikePatternsStr ++ tuplePatternStr
+  }
+
+  def freshSubScrutinee: ScrutineeData = context.freshScrutinee(this)
+
+  def toCaseSet: CaseSet = {
+    import mlscript.ucs.context.Pattern
+    val cases = classLikePatterns.iterator.map { case (symbol, pattern) =>
+      Pattern.ClassLike(symbol) -> pattern.locations
+    }.toMap[Pattern, Ls[Loc]]
+    val tuplePattern = tuplePatternOpt.map { tuplePattern =>
+      Pattern.Tuple() -> tuplePattern.locations
+    }.toMap[Pattern, Ls[Loc]]
+    CaseSet(cases ++ tuplePattern, false)
+  }
+}
+
+object ScrutineeData {
+  // We might need to move these method to a private `VarOps` because they may
+  // emit diagnostics.
+
+  import mlscript.Term
+  import mlscript.pretyper.symbol.TermSymbol
+
+  def unapply(term: Term)(implicit context: Context): Opt[ScrutineeData] = term match {
+    case v: Var => v.symbol match {
+      case symbol: TermSymbol => symbol.getScrutinee
+      case _ => N
+    }
+    case _ => N
+  }
+
+  object WithVar {
+    def unapply(term: Term)(implicit context: Context): Opt[(ScrutineeData, Var)] = term match {
+      case v @ Var(_) => v.symbol match {
+        case symbol: TermSymbol => symbol.getScrutinee.map(_ -> v)
+        case _ => N
+      }
+      case _ => N
+    }
+  }
 }
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala b/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
new file mode 100644
index 0000000000..a3fc6fdf6c
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
@@ -0,0 +1,97 @@
+package mlscript.ucs.context
+
+import mlscript.{Lit, Loc}
+import mlscript.pretyper.symbol.TypeSymbol
+import mlscript.utils._, shorthands._
+
+sealed abstract class Pattern {
+  override def toString(): String = this match {
+    case Pattern.ClassLike(symbol) => s"${symbol.defn.kind.str} `${symbol.name}`"
+    case Pattern.Tuple() => "tuple"
+    case Pattern.Literal(literal) => s"literal ${inspect.deep(literal)}"
+  }
+}
+
+object Pattern {
+  final case class ClassLike(symbol: TypeSymbol) extends Pattern
+  // Currently, there is only simple tuple pattern, so we cannot differentiate
+  // between tuple patterns of different arity. That's why the parameter list
+  // is empty for now.
+  final case class Tuple() extends Pattern
+  final case class Literal(literal: Lit) extends Pattern
+}
+
+/**
+  * A `CaseSet` represents all patterns that a particular scrutinee is
+  * being matched with within a UCS expression. Each Pattern is associated
+  * with the locations where these patterns appear.
+  *
+  * @param patterns a set of patterns that the scrutinee is matched with.
+  * @param hasWildcard if the scrutinee is matched with a wildcard pattern.
+  */
+final case class CaseSet(val cases: Map[Pattern, Ls[Loc]], val hasWildcard: Bool) {
+  /** TODO: This seems useless. */
+  @inline def withWildcard: CaseSet = if (hasWildcard) this else copy(hasWildcard = true)
+
+  /**
+    * Split the pattern set into two pattern sets.
+    * 
+    * For example, let A be the base type of B, C, and D. Plus, class `Z` is
+    * unrelated to any of them. Suppose the initial pattern set is
+    * `{ A, B, C, Z }`. Splitting the set results in two sets, one set
+    * contains classes that are compatible with `A`, and the other set
+    * contains classes that are unrelated to `A`.
+    * 
+    * For example, if we split the set with `A`, then we get `{ B, C }` and
+    * set `{ Z }`. Set `{ B, C }` represents that the scrutinee can be further
+    * refined to class `B` or `class C`. Set `{ Z }` represents that if the
+    * scrutinee is not `A`, then it can be `Z`.
+    * 
+    * If `A` is sealed to `B`, `C`, and `D`, then we get `{ B, C, D }` and
+    * `{ Z }`. Because if the scrutinee is assumed to be `A`, then it can also
+    * be `D` other than `B`, `C`.
+    *
+    * @param classLikeSymbol the type symbol represents the class like type
+    * @return If the pattern set doesn't include the given type symbol, this
+    *         returns `None`. Otherwise, the function returns a triplet of the
+    *         locations where the pattern appears, the related patterns, and
+    *         unrelated patterns.
+    */
+  def split(classLikeSymbol: TypeSymbol): Opt[(Ls[Loc], CaseSet, CaseSet)] = {
+    val classLikePattern = Pattern.ClassLike(classLikeSymbol)
+    cases.get(classLikePattern).map { locations =>
+      val withoutSymbol = cases - classLikePattern
+      val relatedPatterns = withoutSymbol.filter {
+        case (Pattern.ClassLike(otherSymbol), _) => otherSymbol.baseTypes.contains(classLikeSymbol)
+        case ((_: Pattern.Tuple | _: Pattern.Literal), _) => false
+      } ++ classLikeSymbol.sealedDerivedTypes.iterator.map { symbol =>
+        Pattern.ClassLike(symbol) -> symbol.defn.nme.toLoc.toList
+      }
+      val unrelatedPatterns = withoutSymbol.filter {
+        case (Pattern.ClassLike(otherSymbol), _) => !otherSymbol.baseTypes.contains(classLikeSymbol)
+        case ((_: Pattern.Tuple | _: Pattern.Literal), _) => true
+      }
+      (locations, copy(relatedPatterns), copy(unrelatedPatterns))
+    }
+  }
+
+  /** Add a type sysmbol as a class like pattern to the set. */
+  def add(classLikeSymbol: TypeSymbol, location: Opt[Loc]): CaseSet = {
+    val classLikePattern = Pattern.ClassLike(classLikeSymbol)
+    copy(cases = cases.updatedWith(classLikePattern) {
+      case N => S(location.toList)
+      case S(locations) => S(location.toList ++ locations)
+    })
+  }
+
+  /** Get an iterator of only patterns. */
+  @inline def patterns: Iterator[Pattern] = cases.iterator.map(_._1)
+
+  @inline def isEmpty: Bool = cases.isEmpty
+
+  @inline def size: Int = cases.size
+}
+
+object CaseSet {
+  lazy val empty: CaseSet = CaseSet(Map.empty, false)
+}
diff --git a/shared/src/main/scala/mlscript/ucs/context/package.scala b/shared/src/main/scala/mlscript/ucs/context/package.scala
new file mode 100644
index 0000000000..03a1e46b9c
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/context/package.scala
@@ -0,0 +1,13 @@
+package mlscript.ucs
+
+import mlscript.{Loc, Var}
+import mlscript.pretyper.symbol.TypeSymbol
+import mlscript.utils._, shorthands._
+
+package object context {
+  type NamedScrutineeData = (Var -> ScrutineeData)
+
+  type MatchRegistry = Map[NamedScrutineeData, CaseSet]
+
+  type SeenRegistry = Map[NamedScrutineeData, (TypeSymbol, Ls[Loc], CaseSet)]  
+}
diff --git a/shared/src/main/scala/mlscript/ucs/core.scala b/shared/src/main/scala/mlscript/ucs/core.scala
index 65a194a322..14b1577f6c 100644
--- a/shared/src/main/scala/mlscript/ucs/core.scala
+++ b/shared/src/main/scala/mlscript/ucs/core.scala
@@ -120,26 +120,4 @@ package object core {
 
     def just(term: Term): Split = Else(term)
   }
-
-  @inline def printSplit(s: Split): Str = showSplit("if", s)
-
-  def showSplit(prefix: Str, s: Split): Str = {
-    // TODO: tailrec
-    def split(s: Split, isFirst: Bool, isTopLevel: Bool): Lines = s match {
-      case Split.Cons(head, tail) => (branch(head) match {
-        case (n, line) :: tail => (n, (if (isTopLevel) "" else "") + s"$line") :: tail
-        case Nil => Nil
-      }) ::: split(tail, false, isTopLevel)
-      case Split.Let(_, nme, rhs, tail) => (0, s"let ${showVar(nme)} = $rhs") :: split(tail, false, isTopLevel)
-      case Split.Else(term) => (if (isFirst) (0, s"then $term") else (0, s"else $term")) :: Nil
-      case Split.Nil => Nil
-    }
-    def branch(b: Branch): Lines = {
-      val Branch(scrutinee, pattern, continuation) = b
-      s"${showVar(scrutinee)} is $pattern" #: split(continuation, true, false)
-    }
-    val lines = split(s, true, true)
-    (if (prefix.isEmpty) lines else prefix #: lines)
-      .iterator.map { case (n, line) => "  " * n + line }.mkString("\n")
-  }
 }
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/ucs/display.scala b/shared/src/main/scala/mlscript/ucs/display.scala
new file mode 100644
index 0000000000..63fb23a58b
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/display.scala
@@ -0,0 +1,133 @@
+package mlscript.ucs
+
+import mlscript.ucs.{Context, Lines, LinesOps, ScrutineeData}
+import mlscript.ucs.{core, syntax}
+import mlscript.pretyper.symbol.{TermSymbol, TypeSymbol}
+import mlscript.{App, CaseOf, Fld, FldFlags, Let, Loc, Sel, SimpleTerm, Term, Tup, Var}
+import mlscript.{CaseBranches, Case, Wildcard, NoCases}
+import mlscript.utils._, shorthands._
+
+/** All the pretty-printing stuff go here. */
+package object display {
+
+  /** If the variable has a location, mark it with an asterisk.
+    * If the variable is associated with a term symbol, mark it with an asterisk.
+    * If the variable is associated with a term symbol and has a scrutinee, mark it with a double dagger. */
+  private def showVar(`var`: Var)(implicit context: Context): String = {
+    val postfix = `var`.symbolOption match {
+      case S(symbol: TermSymbol) if symbol.isScrutinee => "‡"
+      case S(_: TermSymbol) => "†"
+      case S(_: TypeSymbol) => "◊"
+      case N => ""
+    }
+    `var`.name + (`var`.symbolOption.fold("")(_ => "*")) + postfix
+  }
+
+  def showSplit(split: syntax.TermSplit)(implicit context: Context): Str = {
+    // TODO: tailrec
+    def termSplit(split: syntax.TermSplit, isFirst: Bool, isAfterAnd: Bool): Lines = split match {
+      case syntax.Split.Cons(head, tail) => (termBranch(head) match {
+        case (n, line) :: tail => (n, (if (isAfterAnd) "" else "and ") + s"$line") :: tail
+        case Nil => Nil
+      }) ::: termSplit(tail, false, isAfterAnd)
+      case syntax.Split.Let(_, nme, rhs, tail) => (0, s"let $nme = $rhs") :: termSplit(tail, false, isAfterAnd)
+      case syntax.Split.Else(term) => (if (isFirst) (0, s"then $term") else (0, s"else $term")) :: Nil
+      case syntax.Split.Nil => Nil
+    }
+    def termBranch(branch: syntax.TermBranch): Lines = branch match {
+      case syntax.TermBranch.Boolean(test, continuation) => 
+        s"$test" #: termSplit(continuation, true, false)
+      case syntax.TermBranch.Match(scrutinee, continuation) =>
+        s"$scrutinee is" #: patternSplit(continuation)
+      case syntax.TermBranch.Left(left, continuation) =>
+        s"$left" #: operatorSplit(continuation)
+    }
+    def patternSplit(split: syntax.PatternSplit): Lines = split match {
+      case syntax.Split.Cons(head, tail) => patternBranch(head) ::: patternSplit(tail)
+      case syntax.Split.Let(rec, nme, rhs, tail) => (0, s"let $nme = $rhs") :: patternSplit(tail)
+      case syntax.Split.Else(term) => (0, s"else $term") :: Nil
+      case syntax.Split.Nil => Nil
+    }
+    def operatorSplit(split: syntax.OperatorSplit): Lines = split match {
+      case syntax.Split.Cons(head, tail) => operatorBranch(head) ::: operatorSplit(tail)
+      case syntax.Split.Let(rec, nme, rhs, tail) => (0, s"let $nme = $rhs") :: operatorSplit(tail)
+      case syntax.Split.Else(term) => (0, s"else $term") :: Nil
+      case syntax.Split.Nil => Nil
+    }
+    def operatorBranch(branch: syntax.OperatorBranch): Lines =
+      s"${branch.operator}" #: (branch match {
+        case syntax.OperatorBranch.Match(_, continuation) => patternSplit(continuation)
+        case syntax.OperatorBranch.Binary(_, continuation) => termSplit(continuation, true, true)
+      })
+    def patternBranch(branch: syntax.PatternBranch): Lines = {
+      val syntax.PatternBranch(pattern, continuation) = branch
+      termSplit(continuation, true, false) match {
+        case (0, line) :: lines => (0, s"$pattern $line") :: lines
+        case lines => (0, pattern.toString) :: lines
+      }
+    }
+    ("if" #: termSplit(split, true, true)).iterator.map { case (n, line) => "  " * n + line }.mkString("\n")
+  }
+
+  @inline def showSplit(s: core.Split)(implicit context: Context): Str = showSplit("if", s)
+
+  def showSplit(prefix: Str, s: core.Split)(implicit context: Context): Str = {
+    // TODO: tailrec
+    def split(s: core.Split, isFirst: Bool, isTopLevel: Bool): Lines = s match {
+      case core.Split.Cons(head, tail) => (branch(head) match {
+        case (n, line) :: tail => (n, (if (isTopLevel) "" else "") + s"$line") :: tail
+        case Nil => Nil
+      }) ::: split(tail, false, isTopLevel)
+      case core.Split.Let(_, nme, rhs, tail) => (0, s"let ${showVar(nme)} = $rhs") :: split(tail, false, isTopLevel)
+      case core.Split.Else(term) => (if (isFirst) (0, s"then $term") else (0, s"else $term")) :: Nil
+      case core.Split.Nil => Nil
+    }
+    def branch(b: core.Branch): Lines = {
+      val core.Branch(scrutinee, pattern, continuation) = b
+      s"${showVar(scrutinee)} is $pattern" #: split(continuation, true, false)
+    }
+    val lines = split(s, true, true)
+    (if (prefix.isEmpty) lines else prefix #: lines)
+      .iterator.map { case (n, line) => "  " * n + line }.mkString("\n")
+  }
+
+  /**
+    * Convert a normalized term to a string with indentation. It makes use of
+    * some special markers.
+    *
+    * - `*` if the variable has a location.
+    * - `†` if the variable is associated with a term symbol.
+    * - `‡` if the variable is associated with a term symbol and has a scrutinee.
+    */
+  def showNormalizedTerm(term: Term)(implicit context: Context): String = {
+    def showTerm(term: Term): Lines = term match {
+      case let: Let => showLet(let)
+      case caseOf: CaseOf => showCaseOf(caseOf)
+      case other => (0, other.toString) :: Nil
+    }
+    def showScrutinee(term: Term): Str = term match {
+      case vari: Var => showVar(vari)
+      case _ => term.toString
+    }
+    def showPattern(pat: SimpleTerm): Str = pat match {
+      case vari: Var => showVar(vari)
+      case _ => pat.toString
+    }
+    def showCaseOf(caseOf: CaseOf): Lines = {
+      val CaseOf(trm, cases) = caseOf
+      s"case ${showScrutinee(trm)} of" ##: showCaseBranches(cases)
+    }
+    def showCaseBranches(caseBranches: CaseBranches): Lines =
+      caseBranches match {
+        case Case(pat, rhs, tail) =>
+          (s"${showPattern(pat)} ->" @: showTerm(rhs)) ++ showCaseBranches(tail)
+        case Wildcard(term) => s"_ ->" @: showTerm(term)
+        case NoCases => Nil
+      }
+    def showLet(let: Let): Lines = {
+      val Let(rec, nme, rhs, body) = let
+      (0, s"let ${showVar(nme)} = $rhs") :: showTerm(body)
+    }
+    showTerm(term).map { case (n, line) => "  " * n + line }.mkString("\n")
+  }
+}
diff --git a/shared/src/main/scala/mlscript/ucs/package.scala b/shared/src/main/scala/mlscript/ucs/package.scala
index e284d52070..7cd468c469 100644
--- a/shared/src/main/scala/mlscript/ucs/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/package.scala
@@ -11,6 +11,8 @@ package object ucs {
       nextIndex += 1
       Var(s"$prefix$thisIndex")
     }
+
+    def reset(): Unit = nextIndex = 0
   }
 
   type Lines = List[(Int, String)]
@@ -38,9 +40,4 @@ package object ucs {
       }
     }
   }
-
-  /** If the variable is associated with a symbol, mark it with an asterisk.
-    * If the variable has a location, mark it with a dagger. */
-  private[ucs] def showVar(`var`: Var): String =
-    `var`.name + (`var`.symbolOption.fold("")(_ => "*")) + (`var`.toLoc.fold("")(_ => "†"))
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index 4108b8078e..851535cb85 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -3,70 +3,36 @@ package mlscript.ucs.stages
 import annotation.tailrec
 import collection.mutable.ListBuffer
 import mlscript.{Case, CaseBranches, CaseOf, Let, Lit, Loc, NoCases, Term, Var, Wildcard}
+import mlscript.ucs.{Context, ScrutineeData}
 import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
 import mlscript.Message, Message.MessageContext
 import mlscript.{SimpleTerm, Diagnostic, ErrorReport, WarningReport}
+import mlscript.ucs.context.{CaseSet, NamedScrutineeData, MatchRegistry, SeenRegistry}
 
 trait CoverageChecking { self: mlscript.pretyper.Traceable =>
   import CoverageChecking._
 
-  def checkCoverage(term: Term): Ls[Diagnostic] = {
-    val registry = collectRegistry(term)
+  def checkCoverage(term: Term)(implicit context: Context): Ls[Diagnostic] = {
+    val registry = context.toMatchRegistry
     println("collected match registry: " + showRegistry(registry))
     checkCoverage(term, Map.empty, registry, Map.empty)
   }
 
-  private def collectRegistry(term: Term): MatchRegistry = {
-    @tailrec
-    def rec(acc: MatchRegistry, rest: Ls[Term]): MatchRegistry =
-      rest match {
-        case Nil => println("end"); acc
-        case head :: tail =>
-          println(s"collect ${inspect.shallow(head)}")
-          head match {
-            case Let(_, _, _, body) =>
-              println(s"continue on ${inspect.shallow(body)}")
-              rec(acc, body :: tail)
-            case CaseOf(Scrutinee(_, scrutinee), cases) =>
-              println(s"scrutinee: ${scrutinee.name}")
-              rec(
-                acc.updatedWith(scrutinee)(vs => S(cases.foldLeft(vs.getOrElse(CaseSet.empty))({ 
-                  case (acc, (className: Var) -> _) =>
-                    println(s"found pattern $className (has location = ${className.toLoc.nonEmpty})")
-                    val classLikeSymbol = className.symbolOption.flatMap(_.typeSymbolOption).getOrElse {
-                      throw new Exception(s"$className is not associated with any type symbol.")
-                    }
-                    acc.add(classLikeSymbol, className.toLoc)
-                  case (acc, (literal: Lit) -> _) =>
-                    println(s"TODO: skipped literal $literal")
-                    acc
-                })((x, _) => x))),
-                tail ++ cases.foldLeft
-                  (Nil: Ls[Term])
-                  ({ case (acc, _ -> body) => body :: acc })
-                  ((acc, els) => els.fold(acc)(_ :: acc))
-              )
-            case _ => rec(acc, tail)
-          }
-      }
-    rec(Map.empty, term :: Nil)
-  }
-
   private def checkCoverage(
       term: Term,
       pending: MatchRegistry,
       working: MatchRegistry,
       seen: SeenRegistry
-  ): Ls[Diagnostic] =
+  )(implicit context: Context): Ls[Diagnostic] =
     trace(s"checkCoverage <== ${inspect.shallow(term)}, ${pending.size} pending, ${working.size} working, ${seen.size} seen") {
       println(s"seen: " + (if (seen.isEmpty) "empty" else
-        seen.iterator.map { case (k, (s, _, _)) => s"${k.name} is ${s.name}" }.mkString(", ")
+        seen.iterator.map { case ((k, _), (s, _, _)) => s"${k.name} is ${s.name}" }.mkString(", ")
       ))
       term match {
         case Let(_, _, _, body) => checkCoverage(body, pending, working, seen)
-        case CaseOf(Scrutinee(scrutineeVar, scrutinee), cases) =>
-          println(s"scrutinee: ${scrutinee.name}")
+        case CaseOf(ScrutineeData.WithVar(scrutinee, scrutineeVar), cases) =>
+          println(s"scrutinee: ${scrutineeVar.name}")
           // If the scrutinee is still pending (i.e., not matched yet), then we
           // remove it from the pending list. If the scrutinee is matched, and
           // there are still classes to be matched, then we find the remaining
@@ -75,19 +41,20 @@ trait CoverageChecking { self: mlscript.pretyper.Traceable =>
           // 1. The scrutinee has been never visited, which is an error.
           // 2. It has been matched to be an instance of some class. Therefore,
           //    we need to check if this is a contradiction.
-          val (unseenPatterns, newPending) = pending.get(scrutinee) match {
-            case S(matchedClasses) => matchedClasses -> (pending - scrutinee)
-            case N => working.get(scrutinee) match {
+          val namedScrutinee = scrutineeVar -> scrutinee
+          val (unseenPatterns, newPending) = pending.get(namedScrutinee) match {
+            case S(matchedClasses) => matchedClasses -> (pending - namedScrutinee)
+            case N => working.get(namedScrutinee) match {
               case S(unseenPatterns) => unseenPatterns -> pending
               case N =>
                 // Neither in the working list nor in the pending list.
-                seen.get(scrutinee) match {
+                seen.get(namedScrutinee) match {
                   // The scrutine may have been matched.
                   case S((_, _, remainingPatterns)) => remainingPatterns -> pending
                   case N =>
                     // The scrutinee has never been visited. This should not happen.
                     println("working list: " + showRegistry(working))
-                    throw new Exception(s"Scrutinee ${scrutinee.name} is not in the working list.")
+                    throw new Exception(s"Scrutinee ${scrutineeVar.name} is not in the working list.")
                 }
             }
           }
@@ -107,17 +74,17 @@ trait CoverageChecking { self: mlscript.pretyper.Traceable =>
                   println("remaining patterns: " + remainingPatterns.patterns.mkString("[", ", ", "]"))
                   // Remove the scrutinee from the working list.
                   val newWorking = if (remainingPatterns.isEmpty)
-                    working - scrutinee
+                    working - namedScrutinee
                   else
-                    working.updated(scrutinee, remainingPatterns)
+                    working.updated(namedScrutinee, remainingPatterns)
                   // Add "`scrutinee` is `className`" to the seen registry.
-                  val newSeen = seen + (scrutinee -> (classSymbol, locations, refiningPatterns))
+                  val newSeen = seen + (namedScrutinee -> (classSymbol, locations, refiningPatterns))
                   (
                     remainingPatterns,
                     diagnostics ++ checkCoverage(body, newPending, newWorking, newSeen)
                   )
                 case N =>
-                  unseenPatterns -> (diagnostics :+ (seen.get(scrutinee) match {
+                  unseenPatterns -> (diagnostics :+ (seen.get(namedScrutinee) match {
                     case S((`classSymbol`, _, _)) => WarningReport("tautology", Nil, Diagnostic.PreTyping)
                     case S(_) => ErrorReport("contradiction", Nil, Diagnostic.PreTyping)
                     case N => ErrorReport("unvisited scrutinee", Nil, Diagnostic.PreTyping)
@@ -130,10 +97,10 @@ trait CoverageChecking { self: mlscript.pretyper.Traceable =>
             case ((missingCases, diagnostics), N) =>
               println("remaining cases should are not covered")
               println("MISSING cases: " + missingCases.patterns.mkString("[", ", ", "]"))
-              diagnostics ++ explainMissingCases(scrutinee, seen, missingCases)
+              diagnostics ++ explainMissingCases(namedScrutinee, seen, missingCases)
             case ((remainingCases, diagnostics), S(default)) =>
               println("remaining cases should be covered by the wildcard")
-              checkCoverage(default, newPending, working.updated(scrutinee, remainingCases), seen)
+              checkCoverage(default, newPending, working.updated(namedScrutinee, remainingCases), seen)
           }
         case other => println("STOP"); Nil
       }
@@ -141,105 +108,13 @@ trait CoverageChecking { self: mlscript.pretyper.Traceable =>
 }
 
 object CoverageChecking {
-  type MatchRegistry = Map[ScrutineeSymbol, CaseSet]
-
-  type SeenRegistry = Map[ScrutineeSymbol, (TypeSymbol, Ls[Loc], CaseSet)]
-
-  sealed abstract class Pattern {
-    override def toString(): String = this match {
-      case Pattern.ClassLike(symbol) => s"${symbol.defn.kind.str} `${symbol.name}`"
-      case Pattern.Tuple(_) => "tuple"
-      case Pattern.Literal(literal) => s"literal ${inspect.deep(literal)}"
-    }
-  }
-  object Pattern {
-    final case class ClassLike(symbol: TypeSymbol) extends Pattern
-    final case class Tuple(TODO: Nothing) extends Pattern // To be implemented in the near future.
-    final case class Literal(literal: Lit) extends Pattern
-  }
-
-  /**
-    * A `CaseSet` represents all patterns that a particular scrutinee is
-    * being matched with within a UCS expression. Each Pattern is associated
-    * with the locations where these patterns appear.
-    *
-    * @param patterns a set of patterns that the scrutinee is matched with.
-    * @param hasWildcard if the scrutinee is matched with a wildcard pattern.
-    */
-  final case class CaseSet(val cases: Map[Pattern, Ls[Loc]], val hasWildcard: Bool) {
-    /** TODO: This seems useless. */
-    @inline def withWildcard: CaseSet = if (hasWildcard) this else copy(hasWildcard = true)
-
-    /**
-      * Split the pattern set into two pattern sets.
-      * 
-      * For example, let A be the base type of B, C, and D. Plus, class `Z` is
-      * unrelated to any of them. Suppose the initial pattern set is
-      * `{ A, B, C, Z }`. Splitting the set results in two sets, one set
-      * contains classes that are compatible with `A`, and the other set
-      * contains classes that are unrelated to `A`.
-      * 
-      * For example, if we split the set with `A`, then we get `{ B, C }` and
-      * set `{ Z }`. Set `{ B, C }` represents that the scrutinee can be further
-      * refined to class `B` or `class C`. Set `{ Z }` represents that if the
-      * scrutinee is not `A`, then it can be `Z`.
-      * 
-      * If `A` is sealed to `B`, `C`, and `D`, then we get `{ B, C, D }` and
-      * `{ Z }`. Because if the scrutinee is assumed to be `A`, then it can also
-      * be `D` other than `B`, `C`.
-      *
-      * @param classLikeSymbol the type symbol represents the class like type
-      * @return If the pattern set doesn't include the given type symbol, this
-      *         returns `None`. Otherwise, the function returns a triplet of the
-      *         locations where the pattern appears, the related patterns, and
-      *         unrelated patterns.
-      */
-    def split(classLikeSymbol: TypeSymbol): Opt[(Ls[Loc], CaseSet, CaseSet)] = {
-      val classLikePattern = Pattern.ClassLike(classLikeSymbol)
-      cases.get(classLikePattern).map { locations =>
-        val withoutSymbol = cases - classLikePattern
-        val relatedPatterns = withoutSymbol.filter {
-          case (Pattern.ClassLike(otherSymbol), _) => otherSymbol.baseTypes.contains(classLikeSymbol)
-          case ((_: Pattern.Tuple | _: Pattern.Literal), _) => false
-        } ++ classLikeSymbol.sealedDerivedTypes.iterator.map { symbol =>
-          Pattern.ClassLike(symbol) -> symbol.defn.nme.toLoc.toList
-        }
-        val unrelatedPatterns = withoutSymbol.filter {
-          case (Pattern.ClassLike(otherSymbol), _) => !otherSymbol.baseTypes.contains(classLikeSymbol)
-          case ((_: Pattern.Tuple | _: Pattern.Literal), _) => true
-        }
-        (locations, copy(relatedPatterns), copy(unrelatedPatterns))
-      }
-    }
-
-    /** Add a type sysmbol as a class like pattern to the set. */
-    def add(classLikeSymbol: TypeSymbol, location: Opt[Loc]): CaseSet = {
-      val classLikePattern = Pattern.ClassLike(classLikeSymbol)
-      copy(cases = cases.updatedWith(classLikePattern) {
-        case N => S(location.toList)
-        case S(locations) => S(location.toList ++ locations)
-      })
-    }
-
-    /** Get an iterator of only patterns. */
-    @inline def patterns: Iterator[Pattern] = cases.iterator.map(_._1)
-
-    @inline def isEmpty: Bool = cases.isEmpty
-
-    @inline def size: Int = cases.size
-  }
-
-  object CaseSet {
-    lazy val empty: CaseSet = CaseSet(Map.empty, false)
-  }
-
   /** Create an `ErrorReport` that explains missing cases. */
-  private def explainMissingCases(scrutinee: ScrutineeSymbol, seen: SeenRegistry, missingCases: CaseSet): Opt[ErrorReport] =
+  private def explainMissingCases(scrutinee: NamedScrutineeData, seen: SeenRegistry, missingCases: CaseSet): Opt[ErrorReport] =
     if (missingCases.isEmpty) {
       N
     } else {
       S(ErrorReport({
-        val lines = (msg"Scrutinee `${scrutinee.name}` has ${"missing case".pluralize(missingCases.size, true)}" -> scrutinee.toLoc) ::
+        val lines = (msg"Scrutinee `${scrutinee._1.name}` has ${"missing case".pluralize(missingCases.size, true)}" -> scrutinee._1.toLoc) ::
           (missingCases.cases.iterator.flatMap { case (pattern, locations) =>
             (msg"It can be ${pattern.toString}" -> locations.headOption) :: Nil
           }.toList)
@@ -249,7 +124,7 @@ object CoverageChecking {
           seen.iterator.zipWithIndex.map { case ((scrutinee, (classSymbol, locations, cases)), i) =>
             val prologue = if (i === 0) "When " else ""
             val epilogue = if (seen.size === 1) "" else if (i === seen.size - 1) ", and" else ","
-            msg"${prologue}scrutinee `${scrutinee.name}` is `${classSymbol.name}`$epilogue" -> locations.headOption
+            msg"${prologue}scrutinee `${scrutinee._1.name}` is `${classSymbol.name}`$epilogue" -> locations.headOption
           }.toList ::: lines
         }
       }, true, Diagnostic.PreTyping))
@@ -258,7 +133,7 @@ object CoverageChecking {
   /** A helper function that prints entries from the given registry line by line. */
   private def showRegistry(registry: MatchRegistry): Str =
     if (registry.isEmpty) "empty" else
-      registry.iterator.map { case (scrutinee, matchedClasses) =>
-        matchedClasses.patterns.mkString(s">>> ${scrutinee.name} => [", ", ", "]")
+      registry.iterator.map { case (scrutineeVar -> scrutinee, matchedClasses) =>
+        matchedClasses.patterns.mkString(s">>> ${scrutineeVar.name} => [", ", ", "]")
       }.mkString("\n", "\n", "")
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index f2d69e381a..752ec1adab 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -8,6 +8,7 @@ import mlscript.pretyper.symbol._
 import mlscript.pretyper.{PreTyper, Scope}
 import mlscript.ucs.DesugaringException
 import mlscript.Message, Message.MessageContext
+import mlscript.ucs.ScrutineeData
 
 /**
   * The desugaring stage of UCS. In this stage, we transform the source abstract
@@ -27,6 +28,8 @@ import mlscript.Message, Message.MessageContext
   * continuation.
   */
 trait Desugaring { self: PreTyper =>
+  import Desugaring._
+
   /**
     * The entry point of the desugaring stage.
     *
@@ -46,7 +49,7 @@ trait Desugaring { self: PreTyper =>
     * `Cons(hd, tl)`, then the name of `hd` will be `x$Cons_0` and the name of
     * `tl` will be `x$Cons_1`.
     */
-  private def freshScrutinee(parentScrutinee: Var, parentClassName: Str, index: Int): Var =
+  private def freshSubScrutinee(parentScrutinee: Var, parentClassName: Str, index: Int): Var =
     Var(s"${parentScrutinee}$$${parentClassName}_${index.toString}")
 
   /**
@@ -60,56 +63,12 @@ trait Desugaring { self: PreTyper =>
   private def makeUnappliedVar(scrutinee: Var, className: Var)(implicit context: Context): Var =
     Var(s"${context.unappliedPrefix}${scrutinee.name}$$${className.name}")
 
-  // I plan to integrate scrutinee symbols into a field of `ValueSymbol`.
-  // Because each `ValueSymbol` can be matched in multiple UCS expressions.
-  private implicit class VarOps(nme: Var) {
-    def withFreshSymbol: Var = nme.withSymbol(freshSymbol(nme))
-
-    def getScrutineeSymbol: ScrutineeSymbol = nme.symbolOption match {
-      case S(symbol: ScrutineeSymbol) => symbol
-      case S(otherSymbol) => throw new DesugaringException(
-        msg"Expected scrutinee symbol, found ${nme.symbol.name}" -> nme.toLoc :: Nil
-      )
-      case N => throw new DesugaringException(
-        msg"Scrutinee symbol not found" -> nme.toLoc :: Nil
-      )
-    }
-
-    def withResolvedTypeSymbol(implicit scope: Scope): Var = {
-      nme.symbol = nme.resolveTypeSymbol
-      nme
-    }
-
-    def resolveTypeSymbol(implicit scope: Scope): TypeSymbol = scope.getTypeSymbol(nme.name) match {
-      case S(symbol: TraitSymbol) =>
-        println(s"resolveTypeSymbol ${nme} ==> trait")
-        nme.symbol = symbol
-        symbol
-      case S(symbol: ClassSymbol) =>
-        println(s"resolveTypeSymbol ${nme} ==> class")
-        nme.symbol = symbol
-        symbol
-      case S(symbol: ModuleSymbol) =>
-        println(s"resolveTypeSymbol ${nme} ==> module")
-        nme.symbol = symbol
-        symbol
-      case S(symbol: MixinSymbol) =>
-        throw new DesugaringException(msg"Mixins are not allowed in pattern" -> nme.toLoc :: Nil)
-      case S(symbol: TypeAliasSymbol) =>
-        throw new DesugaringException(msg"Type alias is not allowed in pattern" -> nme.toLoc :: Nil)
-      case N =>
-        throw new DesugaringException(msg"Undefined symbol found in patterns." -> nme.toLoc :: Nil)
-    }
-  }
-
   /**
     * A shorthand for making a true pattern, which is useful in desugaring
     * Boolean conditions.
     */
   private def truePattern(implicit scope: Scope) = c.Pattern.Class(Var("true").withResolvedTypeSymbol)
 
-  private def freshSymbol(nme: Var): ValueSymbol = new ValueSymbol(nme, false)
-
   private def desugarTermSplit(split: s.TermSplit)(implicit termPart: PartialTerm, scope: Scope, context: Context): c.Split =
     split match {
       case s.Split.Cons(head, tail) => desugarTermBranch(head) ++ desugarTermSplit(tail)
@@ -164,34 +123,35 @@ trait Desugaring { self: PreTyper =>
       }
     }()
 
-  /** Make a term like `ClassName.unapply(scrutinee)`. */
-  private def makeUnapplyCall(scrutinee: Var, className: Var) = 
-    App(Sel(className, Var("unapply")), Tup(N -> Fld(FldFlags.empty, scrutinee) :: Nil))
-
   private def makeLiteralTest(test: Var, scrutinee: Var, literal: Lit)(implicit scope: Scope): c.Split => c.Split =
     next => c.Split.Let(
       rec = false,
-      name = scrutinee,
+      name = test,
       term = mkBinOp(scrutinee, Var("=="), literal, true),
-      tail = c.Branch(scrutinee, truePattern, next) :: c.Split.Nil
+      tail = c.Branch(test, truePattern, next) :: c.Split.Nil
     )
 
-  private def flattenClassParameters(parentScrutinee: Var, parentClassLikeSymbol: TypeSymbol, parameters: Ls[Opt[s.Pattern]]): Ls[Opt[Var -> Opt[s.Pattern]]] =
-    parameters.iterator.zipWithIndex.map {
-      case (N, _) => N
-      case (S(s.NamePattern(name)), index) =>
-        val symbol = parentScrutinee.getScrutineeSymbol.getSubScrutineeSymbolOrElse(
-          parentClassLikeSymbol, index, name, new ValueSymbol(name, false)
-        )
-        S(name.withSymbol(symbol) -> N)
-      case (S(parameterPattern @ (s.ClassPattern(_, _) | s.LiteralPattern(_) | s.TuplePattern(_))), index) =>
-        val scrutinee = freshScrutinee(parentScrutinee, parentClassLikeSymbol.name, index)
-        val symbol = parentScrutinee.getScrutineeSymbol.getSubScrutineeSymbolOrElse(
-          parentClassLikeSymbol, index, scrutinee, new ValueSymbol(scrutinee, false)
-        )
-        S(scrutinee.withSymbol(symbol) -> S(parameterPattern))
-      case _ => ??? // Other patterns are not implemented yet.
-    }.toList
+  private def flattenClassParameters(
+      parentScrutineeVar: Var,
+      parentClassLikeSymbol: TypeSymbol,
+      parameters: Ls[Opt[s.Pattern]]
+  )(implicit context: Context): Ls[Opt[Var -> Opt[s.Pattern]]] =
+    trace(s"flattenClassParameters <== ${parentScrutineeVar.name} is ${parentClassLikeSymbol.name}") {
+      // Make it `lazy` so that it will not be created if all fields are wildcards.
+      lazy val classPattern = parentScrutineeVar.getOrCreateScrutinee.getOrCreateClassPattern(parentClassLikeSymbol)
+      parameters.iterator.zipWithIndex.map {
+        case (N, _) => N
+        case (S(s.NamePattern(name)), index) =>
+          val subScrutinee = classPattern.getParameter(index).withAlias(name)
+          S(name.withFreshSymbol.withScrutinee(subScrutinee) -> N)
+        case (S(parameterPattern @ (s.ClassPattern(_, _) | s.LiteralPattern(_) | s.TuplePattern(_))), index) =>
+          val subScrutineeVar = freshSubScrutinee(parentScrutineeVar, parentClassLikeSymbol.name, index)
+          val symbol = new ValueSymbol(subScrutineeVar, false)
+          symbol.addScrutinee(classPattern.getParameter(index).withAlias(subScrutineeVar))
+          S(subScrutineeVar.withSymbol(symbol) -> S(parameterPattern))
+        case _ => ??? // Other patterns are not implemented yet.
+      }.toList
+    }(r => s"flattenClassParameters ==> ${r.mkString(", ")}")
 
   /**
     * Recursively decompose and flatten a possibly nested class pattern. Any
@@ -211,35 +171,40 @@ trait Desugaring { self: PreTyper =>
     * @param initialScope the scope before flattening the class pattern
     * @return a tuple of the augmented scope and a function that wrap a split
     */
-  private def desugarClassPattern(pattern: s.ClassPattern, scrutinee: Var, initialScope: Scope)(implicit context: Context): (Scope, c.Split => c.Branch) = {
-    val scrutineeSymbol = scrutinee.getScrutineeSymbol
+  private def desugarClassPattern(pattern: s.ClassPattern, scrutineeVar: Var, initialScope: Scope)(implicit context: Context): (Scope, c.Split => c.Branch) = {
+    val scrutinee = scrutineeVar.getOrCreateScrutinee.withAlias(scrutineeVar)
     val patternClassSymbol = pattern.nme.resolveTypeSymbol(initialScope)
-    // Most importantly, we need to add the class to the list of matched classes.
-    scrutineeSymbol.addMatchedClass(patternClassSymbol, pattern.nme.toLoc)
+    val classPattern = scrutinee.getOrCreateClassPattern(patternClassSymbol)
+    println(s"desugarClassPattern: ${scrutineeVar.name} is ${pattern.nme.name}")
+    classPattern.addLocation(pattern.nme)
     val (scopeWithAll, bindAll) = pattern.parameters match {
       case S(parameters) =>
         // Before processing sub-patterns, we need to generate a variable that
         // holds the result of `unapply` method. Such variable might have been
         // generated by a previous branches. We MUST reuse so that we can merge
         // duplicated bindings during normalization.
-        val unapp = scrutineeSymbol.getUnappliedVarOrElse(patternClassSymbol, {
-          val vari = makeUnappliedVar(scrutinee, pattern.nme)
+        lazy val unapp = classPattern.getUnappliedVar {
+          val vari = makeUnappliedVar(scrutineeVar, pattern.nme)
           vari.withSymbol(new ValueSymbol(vari, false))
-        })
-        val nestedPatterns = flattenClassParameters(scrutinee, patternClassSymbol, parameters)
+        }
+        val nestedPatterns = flattenClassParameters(scrutineeVar, patternClassSymbol, parameters)
         // First, handle bindings of parameters of the current class pattern.
-        val bindClassParameters = nestedPatterns.iterator.zipWithIndex.foldRight[c.Split => c.Split](identity) {
+        val bindParameters = nestedPatterns.iterator.zipWithIndex.foldRight[c.Split => c.Split](identity) {
           case ((N, _), bindNextParameter) => bindNextParameter
           case ((S(parameter -> _), index), bindNextParameter) => 
             bindNextParameter.andThen { c.Split.Let(false, parameter, Sel(unapp, Var(index.toString)), _) }
-        }.andThen { c.Split.Let(false, unapp, makeUnapplyCall(scrutinee, pattern.nme), _): c.Split }
+        }
+        val bindAll = if (bindParameters === identity) bindParameters else bindParameters.andThen {
+          c.Split.Let(false, unapp, makeUnapplyCall(scrutineeVar, pattern.nme), _): c.Split
+        }
         val scopeWithClassParameters = initialScope ++ (unapp.symbol :: nestedPatterns.flatMap(_.map(_._1.symbol)))
-        desugarNestedPatterns(nestedPatterns, scopeWithClassParameters, bindClassParameters)
+        desugarNestedPatterns(nestedPatterns, scopeWithClassParameters, bindAll)
       // If there is no parameter, then we are done.
       case N => (initialScope, identity(_: c.Split))
     }
+    println(s"${scrutineeVar.name}: ${scrutinee.patterns.mkString(", ")}")
     // Last, return the scope with all bindings and a function that adds all matches and bindings to a split.
-    (scopeWithAll, split => c.Branch(scrutinee, c.Pattern.Class(pattern.nme), bindAll(split)))
+    (scopeWithAll, split => c.Branch(scrutineeVar, c.Pattern.Class(pattern.nme), bindAll(split)))
   }
 
   /**
@@ -257,65 +222,68 @@ trait Desugaring { self: PreTyper =>
       nestedPatterns: Ls[Opt[Var -> Opt[s.Pattern]]],
       scopeWithScrutinees: Scope,
       bindScrutinees: c.Split => c.Split
-  )(implicit context: Context): (Scope, c.Split => c.Split) = {
-    nestedPatterns.foldLeft((scopeWithScrutinees, bindScrutinees)) {
-      // If this parameter is not matched with a sub-pattern, then we do
-      // nothing and pass on scope and binder.
-      case (acc, S(_ -> N)) => acc
-      // If this sub-pattern is a class pattern, we need to recursively flatten
-      // the class pattern. We will get a scope with all bindings and a function
-      // that adds all bindings to a split. The scope can be passed on to the
-      // next sub-pattern. The binder needs to be composed with the previous
-      // binder.
-      case ((scope, bindPrevious), S(nme -> S(pattern: s.ClassPattern))) =>
-        val (scopeWithNestedAll, bindNestedAll) = desugarClassPattern(pattern, nme, scope)
-        (scopeWithNestedAll, split => bindPrevious(bindNestedAll(split) :: c.Split.Nil))
-      case ((scope, bindPrevious), S(nme -> S(pattern: s.LiteralPattern))) =>
-        val test = context.freshTest().withFreshSymbol
-        (scope + test.symbol, makeLiteralTest(test, nme, pattern.literal)(scope).andThen(bindPrevious))
-      case ((scope, bindPrevious), S(nme -> S(s.TuplePattern(fields)))) =>
-        val (scopeWithNestedAll, bindNestedAll) = desugarTuplePattern(fields, nme, scope)
-        (scopeWithNestedAll, bindNestedAll.andThen(bindPrevious))
-      // Well, other patterns are not supported yet.
-      case (acc, S((nme, pattern))) => ???
-      // If this parameter is empty (e.g. produced by wildcard), then we do
-      // nothing and pass on scope and binder.
-      case (acc, N) => acc
-    }
-  }
+  )(implicit context: Context): (Scope, c.Split => c.Split) =
+    trace("desugarNestedPatterns") {
+      nestedPatterns.foldLeft((scopeWithScrutinees, bindScrutinees)) {
+        // If this parameter is not matched with a sub-pattern, then we do
+        // nothing and pass on scope and binder.
+        case (acc, S(_ -> N)) => acc
+        // If this sub-pattern is a class pattern, we need to recursively flatten
+        // the class pattern. We will get a scope with all bindings and a function
+        // that adds all bindings to a split. The scope can be passed on to the
+        // next sub-pattern. The binder needs to be composed with the previous
+        // binder.
+        case ((scope, bindPrevious), S(nme -> S(pattern: s.ClassPattern))) =>
+          println(s"${nme.name} is ${pattern.nme.name}")
+          val (scopeWithNestedAll, bindNestedAll) = desugarClassPattern(pattern, nme, scope)
+          (scopeWithNestedAll, split => bindPrevious(bindNestedAll(split) :: c.Split.Nil))
+        case ((scope, bindPrevious), S(nme -> S(pattern: s.LiteralPattern))) =>
+          val test = context.freshTest().withFreshSymbol
+          println(s"fresh test var: ${test.name}")
+          (scope + test.symbol, makeLiteralTest(test, nme, pattern.literal)(scope).andThen(bindPrevious))
+        case ((scope, bindPrevious), S(nme -> S(s.TuplePattern(fields)))) =>
+          val (scopeWithNestedAll, bindNestedAll) = desugarTuplePattern(fields, nme, scope)
+          (scopeWithNestedAll, bindNestedAll.andThen(bindPrevious))
+        // Well, other patterns are not supported yet.
+        case (acc, S((nme, pattern))) => ???
+        // If this parameter is empty (e.g. produced by wildcard), then we do
+        // nothing and pass on scope and binder.
+        case (acc, N) => acc
+      }
+    }()
 
-  private def flattenTupleFields(parentScrutinee: Var, fields: Ls[Opt[s.Pattern]]): Ls[Opt[Var -> Opt[s.Pattern]]] =
+  private def flattenTupleFields(parentScrutineeVar: Var, fields: Ls[Opt[s.Pattern]])(implicit context: Context): Ls[Opt[Var -> Opt[s.Pattern]]] = {
+    // Make it `lazy` so that it will not be created if all fields are wildcards.
+    lazy val tuplePattern = parentScrutineeVar.getOrCreateScrutinee.getOrCreateTuplePattern
     fields.iterator.zipWithIndex.map {
       case (N, _) => N
       case (S(s.NamePattern(name)), index) =>
-        val symbol = parentScrutinee.getScrutineeSymbol.getTupleSubScrutineeSymbolOrElse(
-          index, name, new ValueSymbol(name, false)
-        )
-        S(name.withSymbol(symbol) -> N)
+        S(name.withFreshSymbol.withScrutinee(tuplePattern.getField(index)) -> N)
       case (S(parameterPattern @ (s.ClassPattern(_, _) | s.LiteralPattern(_) | s.TuplePattern(_))), index) =>
-        val scrutinee = freshScrutinee(parentScrutinee, "Tuple$2", index)
-        val symbol = parentScrutinee.getScrutineeSymbol.getTupleSubScrutineeSymbolOrElse(
-          index, scrutinee, new ValueSymbol(scrutinee, false)
-        )
-        S(scrutinee.withSymbol(symbol) -> S(parameterPattern))
+        val arity = fields.length
+        val subScrutineeVar = freshSubScrutinee(parentScrutineeVar, s"Tuple$$$arity", index)
+        val symbol = new ValueSymbol(subScrutineeVar, false)
+        symbol.addScrutinee(tuplePattern.getField(index).withAlias(subScrutineeVar))
+        S(subScrutineeVar.withSymbol(symbol) -> S(parameterPattern))
       case _ => ???
     }.toList
+  }
 
-  private def desugarTuplePattern(fields: Ls[Opt[s.Pattern]], scrutinee: Var, initialScope: Scope)(implicit context: Context): (Scope, c.Split => c.Split) = {
-    val scrutineeSymbol = scrutinee.getScrutineeSymbol
-    val nestedPatterns = flattenTupleFields(scrutinee, fields)
-    val bindTupleFields = nestedPatterns.iterator.zipWithIndex.foldRight[c.Split => c.Split](identity) {
+  private def desugarTuplePattern(fields: Ls[Opt[s.Pattern]], scrutineeVar: Var, initialScope: Scope)(implicit context: Context): (Scope, c.Split => c.Split) = {
+    val scrutinee = scrutineeVar.getOrCreateScrutinee.withAlias(scrutineeVar)
+    val nestedPatterns = flattenTupleFields(scrutineeVar, fields)
+    val bindFields = nestedPatterns.iterator.zipWithIndex.foldRight[c.Split => c.Split](identity) {
       case ((N, _), bindNextField) => bindNextField
       case ((S(parameter -> _), index), bindNextField) => 
         val indexVar = Var(index.toString).withLoc(parameter.toLoc)
-        bindNextField.andThen { c.Split.Let(false, parameter, Sel(scrutinee, indexVar), _) }
+        bindNextField.andThen { c.Split.Let(false, parameter, Sel(scrutineeVar, indexVar), _) }
     }
-    val scopeWithTupleFields = initialScope ++ nestedPatterns.flatMap(_.map(_._1.symbol))
-    desugarNestedPatterns(nestedPatterns, scopeWithTupleFields, bindTupleFields)
+    val scopeWithFields = initialScope ++ nestedPatterns.flatMap(_.map(_._1.symbol))
+    desugarNestedPatterns(nestedPatterns, scopeWithFields, bindFields)
   }
 
-  private def desugarPatternSplit(scrutinee: Term, split: s.PatternSplit)(implicit scope: Scope, context: Context): c.Split = {
-    def rec(scrutinee: Var, split: s.PatternSplit)(implicit scope: Scope): c.Split = split match {
+  private def desugarPatternSplit(scrutineeTerm: Term, split: s.PatternSplit)(implicit scope: Scope, context: Context): c.Split = {
+    def rec(scrutineeVar: Var, split: s.PatternSplit)(implicit scope: Scope): c.Split = split match {
       case s.Split.Cons(head, tail) => 
         head.pattern match {
           case s.AliasPattern(nme, pattern) => ???
@@ -325,49 +293,59 @@ trait Desugaring { self: PreTyper =>
             c.Split.Let(
               rec = false,
               name = test,
-              term = mkBinOp(scrutinee, Var("==="), nme, true),
+              term = mkBinOp(scrutineeVar, Var("==="), nme, true),
               tail = c.Branch(
                 scrutinee = test,
                 pattern = truePattern,
                 continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope + test.symbol, context)
-              ) :: rec(scrutinee, tail)
+              ) :: rec(scrutineeVar, tail)
             )
           case s.NamePattern(Var("_")) =>
-            desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context) ++ rec(scrutinee, tail)
+            desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context) ++ rec(scrutineeVar, tail)
           case s.NamePattern(nme) =>
-            // Share the scrutinee's symbol with its aliases.
-            // nme.symbol = scrutinee.symbol // <-- This currently causes a bug, reuse this line after we remove `ScrutineeSymbol`.
-            nme.symbol = new ValueSymbol(nme, false)
+            // Create a symbol for the binding.
+            val symbol = new ValueSymbol(nme, false)
+            // Share the scrutineeVar's symbol with its aliases.
+            symbol.addScrutinee(scrutineeVar.getOrCreateScrutinee.withAlias(nme))
+            // Associate the symbol with the binding.
+            nme.symbol = symbol
+            // Whoosh! Done.
             val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope + nme.symbol, context)
-            c.Branch(scrutinee, c.Pattern.Name(nme), continuation) :: rec(scrutinee, tail)(scope + nme.symbol)
+            c.Branch(scrutineeVar, c.Pattern.Name(nme), continuation) :: rec(scrutineeVar, tail)(scope + nme.symbol)
           case pattern @ s.ClassPattern(nme, fields) =>
-            println(s"find term symbol of $scrutinee in ${scope.showLocalSymbols}")
-            scrutinee.symbol = scope.getTermSymbol(scrutinee.name).getOrElse(???)
-            val (scopeWithAll, bindAll) = desugarClassPattern(pattern, scrutinee, scope)
+            println(s"find term symbol of $scrutineeVar in ${scope.showLocalSymbols}")
+            scrutineeVar.symbol = scope.getTermSymbol(scrutineeVar.name).getOrElse(???)
+            val (scopeWithAll, bindAll) = desugarClassPattern(pattern, scrutineeVar, scope)
             val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scopeWithAll, context)
-            bindAll(continuation) :: rec(scrutinee, tail)
+            bindAll(continuation) :: rec(scrutineeVar, tail)
           case s.TuplePattern(fields) =>
-            scrutinee.symbol = scope.getTermSymbol(scrutinee.name).getOrElse(???)
-            val (scopeWithAll, bindAll) = desugarTuplePattern(fields, scrutinee, scope)
+            scrutineeVar.symbol = scope.getTermSymbol(scrutineeVar.name).getOrElse(???)
+            val (scopeWithAll, bindAll) = desugarTuplePattern(fields, scrutineeVar, scope)
             val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scopeWithAll, context)
             val withBindings = bindAll(continuation)
             if (withBindings.hasElse) {
               withBindings
             } else {
-              withBindings ++ rec(scrutinee, tail)
+              withBindings ++ rec(scrutineeVar, tail)
             }
           case s.RecordPattern(entries) => ???
         }
       case s.Split.Let(isRec, nme, rhs, tail) =>
-        c.Split.Let(isRec, nme, rhs, rec(scrutinee, tail)(scope + nme.withFreshSymbol.symbol)) // <-- Weird use.
+        c.Split.Let(isRec, nme, rhs, rec(scrutineeVar, tail)(scope + nme.withFreshSymbol.symbol)) // <-- Weird use.
       case s.Split.Else(default) => c.Split.Else(default)
       case s.Split.Nil => c.Split.Nil
     }
-    scrutinee match {
+    scrutineeTerm match {
       case nme: Var => rec(nme, split)
       case other =>
-        val alias = context.freshScrutinee().withFreshSymbol
-        c.Split.Let(false, alias, scrutinee, rec(alias, split)(scope + alias.symbol))
+        val alias = context.freshScrutineeVar().withFreshSymbol
+        c.Split.Let(false, alias, other, rec(alias, split)(scope + alias.symbol))
     }
   }
 }
+
+object Desugaring {
+  /** Make a term like `ClassName.unapply(scrutinee)`. */
+  private def makeUnapplyCall(scrutinee: Var, className: Var) = 
+    App(Sel(className, Var("unapply").withLocOf(className)), Tup(N -> Fld(FldFlags.empty, scrutinee) :: Nil))
+}
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 34e06d518d..0fb201184c 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -1,15 +1,17 @@
 
 package mlscript.ucs.stages
 
-import mlscript.ucs.{showVar, Context, Lines, LinesOps, VariableGenerator}
+import mlscript.ucs.{Context, Lines, LinesOps, ScrutineeData, VariableGenerator}
 import mlscript.ucs.core._
 import mlscript.ucs.helpers._
+import mlscript.ucs.display.showNormalizedTerm
 import mlscript.pretyper.Scope
 import mlscript.pretyper.symbol._
 import mlscript.{App, CaseOf, Fld, FldFlags, Let, Loc, Sel, Term, Tup, Var, StrLit}
 import mlscript.{CaseBranches, Case, Wildcard, NoCases}
 import mlscript.Message, Message.MessageContext
 import mlscript.utils._, shorthands._
+import mlscript.ucs.display.showSplit
 
 trait Normalization { self: mlscript.pretyper.Traceable =>
   import Normalization._
@@ -32,10 +34,10 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
   
   private def concat(these: Split, those: Split)(implicit context: Context, generatedVars: Set[Var]): Split =
     trace(s"concat <== ${generatedVars.mkString("{", ", ", "}")}") {
-      println(s"these: ${printSplit(these)}")
-      println(s"those: ${printSplit(those)}")
+      println(s"these: ${showSplit(these)}")
+      println(s"those: ${showSplit(those)}")
       concatImpl(these, those)
-    }(sp => s"concat => ${printSplit(sp)}")
+    }(sp => s"concat => ${showSplit(sp)}")
 
   /**
     * Normalize core abstract syntax to MLscript syntax.
@@ -55,16 +57,16 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
         val trueBranch = normalizeToTerm(concat(continuation, tail))
         val falseBranch = normalizeToCaseBranches(tail)
         CaseOf(test, Case(nme, trueBranch, falseBranch))
-      case Split.Cons(Branch(scrutinee, pattern @ Pattern.Literal(literal), continuation), tail) =>
-        val trueBranch = normalizeToTerm(specialize(concat(continuation, tail), true)(scrutinee.symbol, pattern))
-        val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutinee.symbol, pattern))
-        CaseOf(scrutinee, Case(literal, trueBranch, falseBranch))
+      case Split.Cons(Branch(ScrutineeData.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Literal(literal), continuation), tail) =>
+        val trueBranch = normalizeToTerm(specialize(concat(continuation, tail), true)(scrutineeVar, scrutinee, pattern, context))
+        val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context))
+        CaseOf(scrutineeVar, Case(literal, trueBranch, falseBranch))
       // false class parameters. Easy
-      case Split.Cons(Branch(scrutinee, pattern @ Pattern.Class(nme), continuation), tail) =>
-        println(s"match $scrutinee with $nme (has location: ${nme.toLoc.isDefined})")
-        val trueBranch = normalizeToTerm(specialize(concat(continuation, tail), true)(scrutinee.symbol, pattern))
-        val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutinee.symbol, pattern))
-        CaseOf(scrutinee, Case(nme, trueBranch, falseBranch))
+      case Split.Cons(Branch(ScrutineeData.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Class(nme), continuation), tail) =>
+        println(s"match ${scrutineeVar.name} with $nme (has location: ${nme.toLoc.isDefined})")
+        val trueBranch = normalizeToTerm(specialize(concat(continuation, tail), true)(scrutineeVar, scrutinee, pattern, context))
+        val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context))
+        CaseOf(scrutineeVar, Case(nme, trueBranch, falseBranch))
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
         throw new NormalizationException((msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc) :: Nil)
       case Split.Let(rec, Var("_"), rhs, tail) => normalizeToTerm(tail)
@@ -101,21 +103,26 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
   // Specialize `split` with the assumption that `scrutinee` matches `pattern`.
   private def specialize
       (split: Split, matchOrNot: Bool)
-      (implicit scrutinee: Symbol, pattern: Pattern): Split =
-  trace[Split](s"S${if (matchOrNot) "+" else "-"} <== ${scrutinee.name} is ${pattern}") {
+      (implicit scrutineeVar: Var, scrutinee: ScrutineeData, pattern: Pattern, context: Context): Split =
+  trace[Split](s"S${if (matchOrNot) "+" else "-"} <== ${scrutineeVar.name} is ${pattern}") {
     (matchOrNot, split) match {
       // Name patterns are translated to let bindings.
-      case (true | false, Split.Cons(Branch(otherScrutineeVar, Pattern.Name(alias), continuation), tail)) =>
+      case (_, Split.Cons(Branch(otherScrutineeVar, Pattern.Name(alias), continuation), tail)) =>
         Split.Let(false, alias, otherScrutineeVar, specialize(continuation, matchOrNot))
+      case (_, split @ Split.Cons(head @ Branch(test, Pattern.Class(Var("true")), continuation), tail)) if context.isTestVar(test) =>
+        println(s"found a Boolean test: $test is true")
+        val trueBranch = specialize(continuation, matchOrNot)
+        val falseBranch = specialize(tail, matchOrNot)
+        split.copy(head = head.copy(continuation = trueBranch), tail = falseBranch)
       // Class pattern. Positive.
-      case (true, split @ Split.Cons(head @ Branch(ScrutineeOnly(otherScrutinee), Pattern.Class(otherClassName), continuation), tail)) =>
+      case (true, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName), continuation), tail)) =>
         val otherClassSymbol = getClassLikeSymbol(otherClassName)
         lazy val specializedTail = {
           println(s"specialized next")
           specialize(tail, true)
         }
         if (scrutinee === otherScrutinee) {
-          println(s"scrutinee: ${scrutinee.name} === ${otherScrutinee.name}")
+          println(s"scrutinee: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
           pattern match {
             case Pattern.Class(className) =>
               val classSymbol = getClassLikeSymbol(className)
@@ -140,23 +147,23 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
             case _ => throw new NormalizationException((msg"Incompatible: ${pattern.toString}" -> pattern.toLoc) :: Nil)
           }
         } else {
-          println(s"scrutinee: ${scrutinee.name} =/= ${otherScrutinee.name}")
+          println(s"scrutinee: ${scrutineeVar.name} =/= ${otherScrutineeVar.name}")
           split.copy(
             head = head.copy(continuation = specialize(continuation, true)),
             tail = specializedTail
           )
         }
       // Class pattern. Negative
-      case (false, split @ Split.Cons(head @ Branch(ScrutineeOnly(otherScrutinee), Pattern.Class(otherClassName), continuation), tail)) =>
+      case (false, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName), continuation), tail)) =>
         val otherClassSymbol = getClassLikeSymbol(otherClassName)
         if (scrutinee === otherScrutinee) {
-          println(s"scrutinee: ${scrutinee.name} === ${otherScrutinee.name}")
+          println(s"scrutinee: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
           pattern match {
             case Pattern.Class(className) =>
               val classSymbol = getClassLikeSymbol(className)
               if (className === otherClassName) {
                 println(s"Case 1: class name: $otherClassName === $className")
-                specialize(tail, false) // TODO: Subsitute parameters to otherParameters
+                specialize(tail, false)
               } else if (otherClassSymbol.baseTypes contains classSymbol) {
                 println(s"Case 2: class name: $otherClassName <: $className")
                 Split.Nil
@@ -167,7 +174,7 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
             case _ => throw new NormalizationException((msg"Incompatible: ${pattern.toString}" -> pattern.toLoc) :: Nil)
           }
         } else {
-          println(s"scrutinee: ${scrutinee.name} =/= ${otherScrutinee.name}")
+          println(s"scrutinee: ${scrutineeVar.name} =/= ${otherScrutineeVar.name}")
           split.copy(
             head = head.copy(continuation = specialize(continuation, matchOrNot)),
             tail = specialize(tail, matchOrNot)
@@ -175,6 +182,7 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
         }
       // Other patterns. Not implemented.
       case (_, Split.Cons(Branch(otherScrutineeVar, pattern, continuation), tail)) =>
+        println(s"unsupported pattern: $pattern")
         throw new NormalizationException((msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc) :: Nil)
       case (_, let @ Split.Let(_, nme, _, tail)) =>
         println(s"let binding $nme, go next")
@@ -183,12 +191,6 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
       case (_, end @ (Split.Else(_) | Split.Nil)) => println("the end"); end
     }
   }(showSplit(s"S${if (matchOrNot) "+" else "-"} ==>", _))
-
-  /**
-    * Print a normalized term with indentation.
-    */
-  @inline protected def printNormalizedTerm(term: Term): Unit =
-    println(showNormalizedTerm(term))
 }
 
 object Normalization {
@@ -201,38 +203,4 @@ object Normalization {
   class NormalizationException(val messages: Ls[Message -> Opt[Loc]]) extends Throwable {
     def this(message: Message, location: Opt[Loc]) = this(message -> location :: Nil)
   }
-
-  /**
-    * Convert a normalized term to a string with indentation. It makes use of
-    * some special markers.
-    *
-    * - `*` if the variable is associated with a symbol,
-    * - `†` if the variable has a location.
-    */
-  def showNormalizedTerm(term: Term): String = {
-    def showTerm(term: Term): Lines = term match {
-      case let: Let => showLet(let)
-      case caseOf: CaseOf => showCaseOf(caseOf)
-      case other => (0, other.toString) :: Nil
-    }
-    def showCaseOf(caseOf: CaseOf): Lines = {
-      val CaseOf(trm, cases) = caseOf
-      s"$trm match" ##: showCaseBranches(cases)
-    }
-    def showCaseBranches(caseBranches: CaseBranches): Lines =
-      caseBranches match {
-        case Case(pat, rhs, tail) =>
-          // If the class name has a location, mark it with a dagger †.
-          // This is to track the location information.
-          val marker = if (pat.toLoc.isDefined) "†" else ""
-          (s"case $pat$marker =>" @: showTerm(rhs)) ++ showCaseBranches(tail)
-        case Wildcard(term) => s"case _ =>" @: showTerm(term)
-        case NoCases => Nil
-      }
-    def showLet(let: Let): Lines = {
-      val Let(rec, nme, rhs, body) = let
-      (0, s"let ${showVar(nme)} = $rhs") :: showTerm(body)
-    }
-    showTerm(term).map { case (n, line) => "  " * n + line }.mkString("\n")
-  }
 }
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index 60028ef729..f0db405c32 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -1,38 +1,20 @@
 package mlscript.ucs.stages
 
 import mlscript.{Case, CaseBranches, CaseOf, Let, Loc, NoCases, Term, Var, Wildcard}
-import mlscript.ucs.Context
+import mlscript.ucs.{Context, DesugarUCS, ScrutineeData}
 import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
 import mlscript.Message, Message.MessageContext
 import scala.annotation.tailrec
 
-trait PostProcessing { self: mlscript.pretyper.Traceable =>
+trait PostProcessing { self: DesugarUCS with mlscript.pretyper.Traceable =>
   import PostProcessing._
 
-  /**
-    * If the given `Var` represents a class name, get its `ClassSymbol`.
-    *
-    * @param className the class name variable
-    */
-  def getClassSymbolFromVar(className: Var): TypeSymbol =
-    trace(s"getClassSymbolFromVar <== ${inspect.shallow(className)}") {
-      className.symbolOption match {
-        case S(symbol: ClassSymbol) => symbol
-        case S(symbol: TraitSymbol) => symbol
-        case S(symbol: ModuleSymbol) => symbol
-        case S(symbol: Symbol) => throw new PostProcessingException(
-          msg"variable ${className.name} is not associated with a class symbol" -> N :: Nil)
-        case N => throw new PostProcessingException(
-          msg"variable ${className.name} is not associated with any symbols" -> N :: Nil)
-      }
-    }(symbol => s"getClassSymbolFromVar ==> ${symbol.name}")
-
   def postProcess(term: Term)(implicit context: Context): Term = trace(s"postProcess <== ${inspect.shallow(term)}") {
     // Normalized terms are constructed using `Let` and `CaseOf`.
     term match {
-      case top @ CaseOf(scrutinee: Var, fst @ Case(className: Var, body, NoCases)) =>
-        println(s"found a UNARY case: $scrutinee is $className")
+      case top @ CaseOf(scrutineeVar: Var, fst @ Case(className: Var, body, NoCases)) =>
+        println(s"found a UNARY case: $scrutineeVar is $className")
         println("post-processing the body")
         top.copy(cases = fst.copy(body = postProcess(body)))
       case top @ CaseOf(test: Var, fst @ Case(Var("true"), trueBranch, Wildcard(falseBranch))) if context.isTestVar(test) =>
@@ -40,35 +22,34 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
         val processedTrueBranch = postProcess(trueBranch)
         val processedFalseBranch = postProcess(falseBranch)
         top.copy(cases = fst.copy(body = processedTrueBranch, rest = Wildcard(processedFalseBranch)))
-      case top @ CaseOf(scrutinee: Var, fst @ Case(className: Var, trueBranch, Wildcard(falseBranch))) =>
-        println(s"found a BINARY case: $scrutinee is $className")
-        val scrutineeSymbol = scrutinee.symbol match {
-          case symbol: ScrutineeSymbol => symbol
-          case _ => throw new PostProcessingException(
-            msg"variable ${scrutinee.name} is not a scrutinee" -> N :: Nil
+      case top @ CaseOf(ScrutineeData.WithVar(scrutinee, scrutineeVar), fst @ Case(className: Var, trueBranch, Wildcard(falseBranch))) =>
+        println(s"found a BINARY case: $scrutineeVar is $className")
+        val classSymbol = className.getClassLikeSymbol
+        println(s"matched classes: ${scrutinee.patterns.mkString(", ")}")
+        val classPattern = scrutinee.getClassPattern(classSymbol).getOrElse {
+          throw new PostProcessingException(
+            msg"cannot find class pattern for ${className.name}" -> className.toLoc :: Nil
           )
         }
-        val classSymbol = getClassSymbolFromVar(className)
-        println(s"`${scrutinee}`'s matched classes: ${scrutineeSymbol.matchedClasses.keysIterator.map(_.name).mkString("[", ", ", "]")}")
+        println(s"patterns of `${scrutineeVar}`: ${scrutinee.patterns.mkString("{", ", ", "}")}")
         // Post-process the true branch.
         println("post-processing the first branch")
         val processedTrueBranch = postProcess(trueBranch)
         // Post-process the false branch.
         println("post-processing the false branch")
-        println(s"searching for cases: " + scrutineeSymbol.matchedClasses.keysIterator.filter(_ =/= classSymbol).map(_.name).mkString("[", ", ", "]"))
-        val (default, cases) = scrutineeSymbol.matchedClasses.iterator.filter(_._1 =/= classSymbol)
+        val (default, cases) = scrutinee.classLikePatternsIterator.filter(_._1 =/= classSymbol)
           // For each case class name, distangle case branch body terms from the false branch.
           .foldLeft[Opt[Term] -> Ls[(TypeSymbol, Opt[Loc], Term)]](S(falseBranch) -> Nil) {
-            case ((S(remainingTerm), cases), (classSymbol -> locations)) =>
+            case ((S(remainingTerm), cases), (classSymbol -> classPattern)) =>
               println(s"searching for case: ${classSymbol.name}")
-              val (leftoverTerm, extracted) = disentangle(remainingTerm, scrutineeSymbol, classSymbol)
+              val (leftoverTerm, extracted) = disentangle(remainingTerm, scrutineeVar, scrutinee, classSymbol)
               trimEmptyTerm(leftoverTerm) -> (extracted match {
                 case N =>
                   println(s"no extracted term about ${classSymbol.name}")
                   cases
                 case terms @ S(extractedTerm) => 
                   println(s"extracted a term about ${classSymbol.name}")
-                  (classSymbol, locations.headOption, postProcess(extractedTerm)) :: cases
+                  (classSymbol, classPattern.firstOccurrence, postProcess(extractedTerm)) :: cases
               })
             case ((N, cases), _) => (N, cases) 
           }
@@ -148,29 +129,27 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
     * @param className the class name
     * @return the remaining term and the disentangled term
     */
-  def disentangle(term: Term, scrutinee: ScrutineeSymbol, classSymbol: TypeSymbol): (Term, Opt[Term]) =
-    trace[(Term, Opt[Term])](s"disentangle <== ${scrutinee.name}: ${classSymbol.name}") {
+  def disentangle(term: Term, scrutineeVar: Var, scrutinee: ScrutineeData, classSymbol: TypeSymbol)(implicit context: Context): (Term, Opt[Term]) =
+    trace[(Term, Opt[Term])](s"disentangle <== ${scrutineeVar.name}: ${classSymbol.name}") {
       term match {
-        case top @ CaseOf(scrutineeVar: Var, cases) =>
-          if (scrutineeVar.symbol match {
-            case s: ScrutineeSymbol => s === scrutinee; case _ => false
-          }) {
-            println(s"found a `CaseOf` that matches on `${scrutinee.name}`")
+        case top @ CaseOf(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), cases) =>
+          if (scrutinee === otherScrutinee) {
+            println(s"found a `CaseOf` that matches on `${scrutineeVar.name}`")
             def rec(cases: CaseBranches): (CaseBranches, Opt[Term]) = cases match {
               case NoCases =>
                 println("no cases, STOP")
                 NoCases -> N
               case wildcard @ Wildcard(body) =>
                 println("found a wildcard, go deeper")
-                val (n, y) = disentangle(body, scrutinee, classSymbol)
+                val (n, y) = disentangle(body, scrutineeVar, scrutinee, classSymbol)
                 wildcard.copy(body = n) -> y
               case kase @ Case(className: Var, body, rest) =>
                 println(s"found a case branch matching against $className")
-                val otherClassSymbol = getClassSymbolFromVar(className)
+                val otherClassSymbol = className.getClassLikeSymbol
                 if (otherClassSymbol === classSymbol) {
                   rest -> S(body)
                 } else {
-                  val (n1, y1) = disentangle(body, scrutinee, classSymbol)
+                  val (n1, y1) = disentangle(body, scrutineeVar, scrutinee, classSymbol)
                   val (n2, y2) = rec(rest)
                   (kase.copy(body = n1, rest = n2), mergeTerms(y1, y2))
                 }
@@ -182,18 +161,18 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
             val (n, y) = rec(cases)
             (top.copy(cases = n), y)
           } else {
-            println(s"found a `CaseOf` that does NOT match on ${scrutinee.name}")
+            println(s"found a `CaseOf` that does NOT match on ${scrutineeVar.name}")
             def rec(cases: CaseBranches): (CaseBranches, CaseBranches) = cases match {
               case NoCases =>
                 println("no cases, STOP")
                 NoCases -> NoCases
               case wildcard @ Wildcard(body) =>
                 println("found a wildcard, go deeper")
-                val (n, y) = disentangle(body, scrutinee, classSymbol)
+                val (n, y) = disentangle(body, scrutineeVar, scrutinee, classSymbol)
                 (wildcard.copy(body = n), y.fold(NoCases: CaseBranches)(Wildcard(_)))
               case kase @ Case(_, body, rest) =>
                 println(s"found a case branch")
-                val (n1, y1) = disentangle(body, scrutinee, classSymbol)
+                val (n1, y1) = disentangle(body, scrutineeVar, scrutinee, classSymbol)
                 val (n2, y2) = rec(rest)
                 (kase.copy(body = n1, rest = n2), (y1 match {
                   case S(term) => kase.copy(body = term, rest = y2)
@@ -204,7 +183,7 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
             (top.copy(cases = n), (if (y === NoCases) N else S(top.copy(cases = y))))
           }
         case let @ Let(_, _, _, body) =>
-          val (n, y) = disentangle(body, scrutinee, classSymbol)
+          val (n, y) = disentangle(body, scrutineeVar, scrutinee, classSymbol)
           (let.copy(body = n), y.map(t => let.copy(body = t)))
         case other =>
           println(s"cannot disentangle ${inspect.shallow(other)}. STOP")
@@ -212,18 +191,19 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
       }
     }({ case (n, y) => s"disentangle ==> `${inspect.deep(n)}` and `${y.fold("<empty>")(inspect.deep(_))}`" })
 
-  def cascadeConsecutiveCaseOf(term: Term): Term = trace(s"cascade consecutive CaseOf <== ${term.describe}") {
+  // FIXME: What? Is this seemingly useful function useless?
+  def cascadeCaseTerm(term: Term): Term = trace(s"cascadeCaseTerm <== ${term.describe}") {
     // Normalized terms are constructed using `Let` and `CaseOf`.
     term match {
       case top @ CaseOf(scrutinee: Var, fst @ Case(pattern, body, NoCases)) =>
         println(s"found a UNARY case: $scrutinee is $pattern")
-        top.copy(cases = fst.copy(body = cascadeConsecutiveCaseOf(body)))
+        top.copy(cases = fst.copy(body = cascadeCaseTerm(body)))
       case top @ CaseOf(scrutinee: Var, fst @ Case(pattern, trueBranch, snd @ Wildcard(falseBranch))) =>
         println(s"found a BINARY case: $scrutinee is $pattern")
         println("cascading the true branch")
-        val processedTrueBranch = cascadeConsecutiveCaseOf(trueBranch)
+        val processedTrueBranch = cascadeCaseTerm(trueBranch)
         println("cascading the false branch")
-        val processedFalseBranch = cascadeConsecutiveCaseOf(falseBranch)
+        val processedFalseBranch = cascadeCaseTerm(falseBranch)
         // Check if the false branch is another `CaseOf` with the same scrutinee.
         processedFalseBranch match {
           case CaseOf(otherScrutinee: Var, actualFalseBranch) =>
@@ -242,11 +222,11 @@ trait PostProcessing { self: mlscript.pretyper.Traceable =>
           case other => top
         }
       // We recursively process the body of `Let` bindings.
-      case let @ Let(_, _, _, body) => let.copy(body = cascadeConsecutiveCaseOf(body))
+      case let @ Let(_, _, _, body) => let.copy(body = cascadeCaseTerm(body))
       // Otherwise, this is not a part of a normalized term.
       case other => println(s"CANNOT cascade"); other
     }
-  }()
+  }(_ => "cascadeCaseTerm ==> ")
 }
 
 object PostProcessing {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/package.scala b/shared/src/main/scala/mlscript/ucs/stages/package.scala
index 825b3cbb0c..0fa9fde470 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/package.scala
@@ -5,26 +5,6 @@ import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
 
 package object stages {
-  object Scrutinee {
-    def unapply(term: Term): Opt[(Var, ScrutineeSymbol)] = term match {
-      case v @ Var(_) => v.symbol match {
-        case symbol: ScrutineeSymbol => S(v, symbol)
-        case _ => N
-      }
-      case _ => N
-    }
-  }
-
-  object ScrutineeOnly {
-    def unapply(term: Term): Opt[ScrutineeSymbol] = term match {
-      case v: Var => v.symbol match {
-        case symbol: ScrutineeSymbol => S(symbol)
-        case _ => N
-      }
-      case _ => N
-    }
-  }
-
   sealed abstract class CasePattern {
     override def toString(): String = this match {
       case CasePattern.Class(symbol) => symbol.name
diff --git a/shared/src/main/scala/mlscript/ucs/syntax.scala b/shared/src/main/scala/mlscript/ucs/syntax.scala
index 85b4776521..433cd835c2 100644
--- a/shared/src/main/scala/mlscript/ucs/syntax.scala
+++ b/shared/src/main/scala/mlscript/ucs/syntax.scala
@@ -107,50 +107,4 @@ package object syntax {
     override def children: List[Located] = pattern :: continuation :: Nil
   }
   type PatternSplit = Split[PatternBranch]
-
-  def printTermSplit(split: TermSplit): Str = {
-    // TODO: tailrec
-    def termSplit(split: TermSplit, isFirst: Bool, isAfterAnd: Bool): Lines = split match {
-      case Split.Cons(head, tail) => (termBranch(head) match {
-        case (n, line) :: tail => (n, (if (isAfterAnd) "" else "and ") + s"$line") :: tail
-        case Nil => Nil
-      }) ::: termSplit(tail, false, isAfterAnd)
-      case Split.Let(_, nme, rhs, tail) => (0, s"let $nme = $rhs") :: termSplit(tail, false, isAfterAnd)
-      case Split.Else(term) => (if (isFirst) (0, s"then $term") else (0, s"else $term")) :: Nil
-      case Split.Nil => Nil
-    }
-    def termBranch(branch: TermBranch): Lines = branch match {
-      case TermBranch.Boolean(test, continuation) => 
-        s"$test" #: termSplit(continuation, true, false)
-      case TermBranch.Match(scrutinee, continuation) =>
-        s"$scrutinee is" #: patternSplit(continuation)
-      case TermBranch.Left(left, continuation) =>
-        s"$left" #: operatorSplit(continuation)
-    }
-    def patternSplit(split: PatternSplit): Lines = split match {
-      case Split.Cons(head, tail) => patternBranch(head) ::: patternSplit(tail)
-      case Split.Let(rec, nme, rhs, tail) => (0, s"let $nme = $rhs") :: patternSplit(tail)
-      case Split.Else(term) => (0, s"else $term") :: Nil
-      case Split.Nil => Nil
-    }
-    def operatorSplit(split: OperatorSplit): Lines = split match {
-      case Split.Cons(head, tail) => operatorBranch(head) ::: operatorSplit(tail)
-      case Split.Let(rec, nme, rhs, tail) => (0, s"let $nme = $rhs") :: operatorSplit(tail)
-      case Split.Else(term) => (0, s"else $term") :: Nil
-      case Split.Nil => Nil
-    }
-    def operatorBranch(branch: OperatorBranch): Lines =
-      s"${branch.operator}" #: (branch match {
-        case OperatorBranch.Match(_, continuation) => patternSplit(continuation)
-        case OperatorBranch.Binary(_, continuation) => termSplit(continuation, true, true)
-      })
-    def patternBranch(branch: PatternBranch): Lines = {
-      val PatternBranch(pattern, continuation) = branch
-      termSplit(continuation, true, false) match {
-        case (0, line) :: lines => (0, s"$pattern $line") :: lines
-        case lines => (0, pattern.toString) :: lines
-      }
-    }
-    ("if" #: termSplit(split, true, true)).iterator.map { case (n, line) => "  " * n + line }.mkString("\n")
-  }
 }
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls b/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls
index 099f9dba0d..018117880b 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls
@@ -27,8 +27,8 @@ fun bad_add_missing_SS(x, y) =
 //│ ║  l.23: 	    x is Some(xv) and y is None     then xv
 //│ ║        	         ^^^^
 //│ ╟── Scrutinee `y` has 1 missing case
-//│ ║  l.21: 	fun bad_add_missing_SS(x, y) =
-//│ ║        	                          ^
+//│ ║  l.23: 	    x is Some(xv) and y is None     then xv
+//│ ║        	                      ^
 //│ ╟── It can be class `Some`
 //│ ║  l.24: 	    x is None     and y is Some(yv) then yv
 //│ ╙──      	                           ^^^^
@@ -44,8 +44,8 @@ fun bad_add_missing_SN(x, y) =
 //│ ║  l.40: 	    x is Some(xv) and y is Some(yv) then xv + yv
 //│ ║        	         ^^^^
 //│ ╟── Scrutinee `y` has 1 missing case
-//│ ║  l.38: 	fun bad_add_missing_SN(x, y) =
-//│ ║        	                          ^
+//│ ║  l.40: 	    x is Some(xv) and y is Some(yv) then xv + yv
+//│ ║        	                      ^
 //│ ╟── It can be module `None`
 //│ ║  l.42: 	    x is None     and y is None     then 0
 //│ ╙──      	                           ^^^^
@@ -61,8 +61,8 @@ fun bad_add_missing_NS(x, y) =
 //│ ║  l.59: 	    x is None     and y is None     then 0
 //│ ║        	         ^^^^
 //│ ╟── Scrutinee `y` has 1 missing case
-//│ ║  l.55: 	fun bad_add_missing_NS(x, y) =
-//│ ║        	                          ^
+//│ ║  l.59: 	    x is None     and y is None     then 0
+//│ ║        	                      ^
 //│ ╟── It can be class `Some`
 //│ ║  l.57: 	    x is Some(xv) and y is Some(yv) then xv + yv
 //│ ╙──      	                           ^^^^
@@ -78,8 +78,8 @@ fun bad_add_missing_NN(x, y) =
 //│ ║  l.76: 	    x is None     and y is Some(yv) then yv
 //│ ║        	         ^^^^
 //│ ╟── Scrutinee `y` has 1 missing case
-//│ ║  l.72: 	fun bad_add_missing_NN(x, y) =
-//│ ║        	                          ^
+//│ ║  l.76: 	    x is None     and y is Some(yv) then yv
+//│ ║        	                      ^
 //│ ╟── It can be module `None`
 //│ ║  l.75: 	    x is Some(xv) and y is None     then xv
 //│ ╙──      	                           ^^^^
@@ -94,8 +94,8 @@ fun bad_add_missing_SS_NN(x, y) =
 //│ ║  l.91: 	    x is Some(xv) and y is None     then xv
 //│ ║        	         ^^^^
 //│ ╟── Scrutinee `y` has 1 missing case
-//│ ║  l.89: 	fun bad_add_missing_SS_NN(x, y) =
-//│ ║        	                             ^
+//│ ║  l.91: 	    x is Some(xv) and y is None     then xv
+//│ ║        	                      ^
 //│ ╟── It can be class `Some`
 //│ ║  l.92: 	    x is None     and y is Some(yv) then yv
 //│ ╙──      	                           ^^^^
@@ -103,8 +103,8 @@ fun bad_add_missing_SS_NN(x, y) =
 //│ ║  l.92: 	    x is None     and y is Some(yv) then yv
 //│ ║        	         ^^^^
 //│ ╟── Scrutinee `y` has 1 missing case
-//│ ║  l.89: 	fun bad_add_missing_SS_NN(x, y) =
-//│ ║        	                             ^
+//│ ║  l.92: 	    x is None     and y is Some(yv) then yv
+//│ ║        	                      ^
 //│ ╟── It can be module `None`
 //│ ║  l.91: 	    x is Some(xv) and y is None     then xv
 //│ ╙──      	                           ^^^^
@@ -119,8 +119,8 @@ fun bad_add_missing_SN_NS(x, y) =
 //│ ║  l.116: 	    x is Some(xv) and y is Some(yv) then xv + yv
 //│ ║         	         ^^^^
 //│ ╟── Scrutinee `y` has 1 missing case
-//│ ║  l.114: 	fun bad_add_missing_SN_NS(x, y) =
-//│ ║         	                             ^
+//│ ║  l.116: 	    x is Some(xv) and y is Some(yv) then xv + yv
+//│ ║         	                      ^
 //│ ╟── It can be module `None`
 //│ ║  l.117: 	    x is None     and y is None     then 0
 //│ ╙──       	                           ^^^^
@@ -128,8 +128,8 @@ fun bad_add_missing_SN_NS(x, y) =
 //│ ║  l.117: 	    x is None     and y is None     then 0
 //│ ║         	         ^^^^
 //│ ╟── Scrutinee `y` has 1 missing case
-//│ ║  l.114: 	fun bad_add_missing_SN_NS(x, y) =
-//│ ║         	                             ^
+//│ ║  l.117: 	    x is None     and y is None     then 0
+//│ ║         	                      ^
 //│ ╟── It can be class `Some`
 //│ ║  l.116: 	    x is Some(xv) and y is Some(yv) then xv + yv
 //│ ╙──       	                           ^^^^
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
index c87fec4683..6194694a95 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
@@ -41,8 +41,8 @@ fun is_value'(term) =
 //│ ║  l.37: 	  if term is Term and term is
 //│ ║        	             ^^^^
 //│ ╟── Scrutinee `term` has 1 missing case
-//│ ║  l.36: 	fun is_value'(term) =
-//│ ║        	              ^^^^
+//│ ║  l.37: 	  if term is Term and term is
+//│ ║        	                      ^^^^
 //│ ╟── It can be class `App`
 //│ ║  l.6: 	class App(func: Term, arg: Term) extends Term
 //│ ╙──     	      ^^^

From dead5269dae2db3058dd198943dd6842759cde55 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 27 Dec 2023 20:09:47 +0800
Subject: [PATCH 029/147] Group source files related to context and scrutinees

---
 shared/src/main/scala/mlscript/pretyper/Symbol.scala     | 2 +-
 shared/src/main/scala/mlscript/ucs/DesugarUCS.scala      | 4 ++--
 .../main/scala/mlscript/ucs/{ => context}/Context.scala  | 9 ++++-----
 .../scala/mlscript/ucs/{ => context}/ScrutineeData.scala | 2 +-
 shared/src/main/scala/mlscript/ucs/display.scala         | 3 ++-
 .../scala/mlscript/ucs/stages/CoverageChecking.scala     | 9 +++------
 .../src/main/scala/mlscript/ucs/stages/Desugaring.scala  | 4 ++--
 .../main/scala/mlscript/ucs/stages/Normalization.scala   | 6 +++---
 .../main/scala/mlscript/ucs/stages/PostProcessing.scala  | 3 ++-
 9 files changed, 20 insertions(+), 22 deletions(-)
 rename shared/src/main/scala/mlscript/ucs/{ => context}/Context.scala (93%)
 rename shared/src/main/scala/mlscript/ucs/{ => context}/ScrutineeData.scala (99%)

diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index c25fd1da2d..fc395a8797 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -4,7 +4,7 @@ import collection.mutable.{Buffer, Map => MutMap, Set => MutSet}
 import mlscript.{Loc, NuFunDef, NuTypeDef, TypeName, Var}
 import mlscript.{Cls, Trt, Mxn, Als, Mod}
 import mlscript.utils._, shorthands._
-import mlscript.ucs.{Context, ScrutineeData}
+import mlscript.ucs.context.{Context, ScrutineeData}
 
 package object symbol {
   sealed abstract class Symbol(val name: Str) {
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 116ee0fc19..4db6a02553 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -2,12 +2,12 @@ package mlscript.ucs
 
 import collection.mutable.{Map => MutMap}
 import mlscript.ucs.stages._
-import mlscript.ucs.display.showNormalizedTerm
+import mlscript.ucs.context.{Context, ScrutineeData}
+import mlscript.ucs.display.{showNormalizedTerm, showSplit}
 import mlscript.pretyper.{PreTyper, Scope}
 import mlscript.pretyper.symbol._
 import mlscript._, utils._, shorthands._
 import mlscript.Message, Message.MessageContext
-import mlscript.ucs.display.showSplit
 
 // TODO: Rename to `Desugarer` once the old desugarer is removed.
 trait DesugarUCS extends Transformation
diff --git a/shared/src/main/scala/mlscript/ucs/Context.scala b/shared/src/main/scala/mlscript/ucs/context/Context.scala
similarity index 93%
rename from shared/src/main/scala/mlscript/ucs/Context.scala
rename to shared/src/main/scala/mlscript/ucs/context/Context.scala
index ad94bc1b64..0c457bb1a9 100644
--- a/shared/src/main/scala/mlscript/ucs/Context.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Context.scala
@@ -1,12 +1,11 @@
-package mlscript.ucs
+package mlscript.ucs.context
 
 import collection.mutable.{Buffer, Map => MutMap, SortedMap => MutSortedMap}
-import mlscript.{If, Loc, NuFunDef, NuTypeDef, TypeName, Var}
-import mlscript.{Cls, Trt, Mxn, Als, Mod}
+import mlscript.{If, Loc, Var}
 import mlscript.pretyper.symbol.TypeSymbol
 import mlscript.pretyper.Scope
+import mlscript.ucs.VariableGenerator
 import mlscript.utils._, shorthands._
-import mlscript.ucs.context.MatchRegistry
 
 class Context(originalTerm: If) {
   private val prefix = Context.freshPrefix()
@@ -62,4 +61,4 @@ object Context {
   // TODO: Generate fresh prefix in a determinstic way. I tried to use a counter,
   // but the produced value is not stable across different runs.
   def freshPrefix(): Str = "ucs"
-}
\ No newline at end of file
+}
diff --git a/shared/src/main/scala/mlscript/ucs/ScrutineeData.scala b/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
similarity index 99%
rename from shared/src/main/scala/mlscript/ucs/ScrutineeData.scala
rename to shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
index 3925e4460c..cd6394c808 100644
--- a/shared/src/main/scala/mlscript/ucs/ScrutineeData.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
@@ -1,4 +1,4 @@
-package mlscript.ucs
+package mlscript.ucs.context
 
 import collection.mutable.{Buffer, Map => MutMap, SortedMap => MutSortedMap, SortedSet => MutSortedSet}
 import mlscript.{Loc, Located, NuFunDef, NuTypeDef, TypeName, Var}
diff --git a/shared/src/main/scala/mlscript/ucs/display.scala b/shared/src/main/scala/mlscript/ucs/display.scala
index 63fb23a58b..ce90728601 100644
--- a/shared/src/main/scala/mlscript/ucs/display.scala
+++ b/shared/src/main/scala/mlscript/ucs/display.scala
@@ -1,7 +1,8 @@
 package mlscript.ucs
 
-import mlscript.ucs.{Context, Lines, LinesOps, ScrutineeData}
+import mlscript.ucs.{Lines, LinesOps}
 import mlscript.ucs.{core, syntax}
+import mlscript.ucs.context.{Context}
 import mlscript.pretyper.symbol.{TermSymbol, TypeSymbol}
 import mlscript.{App, CaseOf, Fld, FldFlags, Let, Loc, Sel, SimpleTerm, Term, Tup, Var}
 import mlscript.{CaseBranches, Case, Wildcard, NoCases}
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index 851535cb85..baa1fea2f0 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -1,14 +1,11 @@
 package mlscript.ucs.stages
 
-import annotation.tailrec
-import collection.mutable.ListBuffer
 import mlscript.{Case, CaseBranches, CaseOf, Let, Lit, Loc, NoCases, Term, Var, Wildcard}
-import mlscript.ucs.{Context, ScrutineeData}
+import mlscript.{Diagnostic, ErrorReport, WarningReport}
+import mlscript.Message, Message.MessageContext
+import mlscript.ucs.context.{Context, CaseSet, NamedScrutineeData, MatchRegistry, ScrutineeData, SeenRegistry}
 import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
-import mlscript.Message, Message.MessageContext
-import mlscript.{SimpleTerm, Diagnostic, ErrorReport, WarningReport}
-import mlscript.ucs.context.{CaseSet, NamedScrutineeData, MatchRegistry, SeenRegistry}
 
 trait CoverageChecking { self: mlscript.pretyper.Traceable =>
   import CoverageChecking._
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 752ec1adab..fd38f234ff 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -1,14 +1,14 @@
 package mlscript.ucs.stages
 
 import mlscript.{App, Asc, Fld, FldFlags, Lit, Sel, Term, Tup, TypeName, Var}
-import mlscript.ucs.{syntax => s, core => c, Context, PartialTerm}
+import mlscript.ucs.{syntax => s, core => c, PartialTerm}
+import mlscript.ucs.context.{Context, ScrutineeData}
 import mlscript.ucs.helpers.mkBinOp
 import mlscript.utils._, shorthands._
 import mlscript.pretyper.symbol._
 import mlscript.pretyper.{PreTyper, Scope}
 import mlscript.ucs.DesugaringException
 import mlscript.Message, Message.MessageContext
-import mlscript.ucs.ScrutineeData
 
 /**
   * The desugaring stage of UCS. In this stage, we transform the source abstract
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 0fb201184c..5f42fd2b4c 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -1,17 +1,17 @@
 
 package mlscript.ucs.stages
 
-import mlscript.ucs.{Context, Lines, LinesOps, ScrutineeData, VariableGenerator}
+import mlscript.ucs.{Lines, LinesOps, VariableGenerator}
+import mlscript.ucs.context.{Context, ScrutineeData}
 import mlscript.ucs.core._
+import mlscript.ucs.display.{showNormalizedTerm, showSplit}
 import mlscript.ucs.helpers._
-import mlscript.ucs.display.showNormalizedTerm
 import mlscript.pretyper.Scope
 import mlscript.pretyper.symbol._
 import mlscript.{App, CaseOf, Fld, FldFlags, Let, Loc, Sel, Term, Tup, Var, StrLit}
 import mlscript.{CaseBranches, Case, Wildcard, NoCases}
 import mlscript.Message, Message.MessageContext
 import mlscript.utils._, shorthands._
-import mlscript.ucs.display.showSplit
 
 trait Normalization { self: mlscript.pretyper.Traceable =>
   import Normalization._
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index f0db405c32..0e4a2e27ce 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -1,7 +1,8 @@
 package mlscript.ucs.stages
 
 import mlscript.{Case, CaseBranches, CaseOf, Let, Loc, NoCases, Term, Var, Wildcard}
-import mlscript.ucs.{Context, DesugarUCS, ScrutineeData}
+import mlscript.ucs.DesugarUCS
+import mlscript.ucs.context.{Context, ScrutineeData}
 import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
 import mlscript.Message, Message.MessageContext

From 9e41fc358818a289ad027ee80c46e727e9c7d79a Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 27 Dec 2023 20:12:23 +0800
Subject: [PATCH 030/147] Forget to use `shadowPrefix` in `Context`

---
 shared/src/main/scala/mlscript/ucs/context/Context.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shared/src/main/scala/mlscript/ucs/context/Context.scala b/shared/src/main/scala/mlscript/ucs/context/Context.scala
index 0c457bb1a9..bb5ae17970 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Context.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Context.scala
@@ -28,7 +28,7 @@ class Context(originalTerm: If) {
   val freshCache: VariableGenerator = new VariableGenerator(cachePrefix)
   val freshScrutineeVar: VariableGenerator = new VariableGenerator(scrutineePrefix)
   val freshTest: VariableGenerator = new VariableGenerator(testPrefix)
-  val freshShadowed: VariableGenerator = new VariableGenerator("shadowed$")
+  val freshShadowed: VariableGenerator = new VariableGenerator(shadowPrefix)
 
   /** The buffer contains all `ScrutineeData` created within this context. */
   private val scrutineeBuffer: Buffer[ScrutineeData] = Buffer.empty

From 0026f16e8aa0d1c2716215403e0a231d54e6d3c4 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 27 Dec 2023 20:18:52 +0800
Subject: [PATCH 031/147] Remove some `TODO`s in UCS source files

---
 .../scala/mlscript/ucs/context/CaseSet.scala  |  8 +---
 .../scala/mlscript/ucs/context/Context.scala  |  4 +-
 .../mlscript/ucs/context/ScrutineeData.scala  |  2 +-
 .../mlscript/ucs/stages/Desugaring.scala      |  3 +-
 .../mlscript/ucs/stages/PostProcessing.scala  | 37 -------------------
 .../mlscript/ucs/stages/Transformation.scala  |  1 -
 6 files changed, 5 insertions(+), 50 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala b/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
index a3fc6fdf6c..6a897c5b74 100644
--- a/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
@@ -27,12 +27,8 @@ object Pattern {
   * with the locations where these patterns appear.
   *
   * @param patterns a set of patterns that the scrutinee is matched with.
-  * @param hasWildcard if the scrutinee is matched with a wildcard pattern.
   */
-final case class CaseSet(val cases: Map[Pattern, Ls[Loc]], val hasWildcard: Bool) {
-  /** TODO: This seems useless. */
-  @inline def withWildcard: CaseSet = if (hasWildcard) this else copy(hasWildcard = true)
-
+final case class CaseSet(val cases: Map[Pattern, Ls[Loc]]) {
   /**
     * Split the pattern set into two pattern sets.
     * 
@@ -93,5 +89,5 @@ final case class CaseSet(val cases: Map[Pattern, Ls[Loc]], val hasWildcard: Bool
 }
 
 object CaseSet {
-  lazy val empty: CaseSet = CaseSet(Map.empty, false)
+  def empty: CaseSet = CaseSet(Map.empty)
 }
diff --git a/shared/src/main/scala/mlscript/ucs/context/Context.scala b/shared/src/main/scala/mlscript/ucs/context/Context.scala
index bb5ae17970..bc14396107 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Context.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Context.scala
@@ -33,15 +33,13 @@ class Context(originalTerm: If) {
   /** The buffer contains all `ScrutineeData` created within this context. */
   private val scrutineeBuffer: Buffer[ScrutineeData] = Buffer.empty
 
-  // TODO: Mark this two files as package private.
   def freshScrutinee: ScrutineeData = {
     val scrutinee = new ScrutineeData(this, N)
     scrutineeBuffer += scrutinee
     scrutinee
   }
 
-  // TODO: Mark this two files as package private.
-  def freshScrutinee(parent: ScrutineeData): ScrutineeData = {
+  private[context] def freshScrutinee(parent: ScrutineeData): ScrutineeData = {
     val scrutinee = new ScrutineeData(this, S(parent))
     scrutineeBuffer += scrutinee
     scrutinee
diff --git a/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala b/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
index cd6394c808..37f839d87c 100644
--- a/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
@@ -132,7 +132,7 @@ class ScrutineeData(val context: Context, parent: Opt[ScrutineeData]) {
     val tuplePattern = tuplePatternOpt.map { tuplePattern =>
       Pattern.Tuple() -> tuplePattern.locations
     }.toMap[Pattern, Ls[Loc]]
-    CaseSet(cases ++ tuplePattern, false)
+    CaseSet(cases ++ tuplePattern)
   }
 }
 
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index fd38f234ff..64215a0e23 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -20,8 +20,7 @@ import mlscript.Message, Message.MessageContext
   * 2. Desugar variable patterns to plain let bindings.
   * 3. Desugar literal patterns to equivalent boolean expressions.
   * 4. Reassemble partial terms that are broken by "conditional splits".
-  * 5. Associate each scrutinee with a unique "scrutinee symbol".
-  *    TODO: `ScrutineeSymbol` will be removed in the future.
+  * 5. Associate each scrutinee with a unique `ScrutineeData`.
   * 
   * Desugared UCS terms (core abstract syntax) are in the form of `Split`, which
   * is a list of branches. Each branch consists of a scrutinee, a pattern, and a
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index 0e4a2e27ce..e288ead4c1 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -191,43 +191,6 @@ trait PostProcessing { self: DesugarUCS with mlscript.pretyper.Traceable =>
           other -> N
       }
     }({ case (n, y) => s"disentangle ==> `${inspect.deep(n)}` and `${y.fold("<empty>")(inspect.deep(_))}`" })
-
-  // FIXME: What? Is this seemingly useful function useless?
-  def cascadeCaseTerm(term: Term): Term = trace(s"cascadeCaseTerm <== ${term.describe}") {
-    // Normalized terms are constructed using `Let` and `CaseOf`.
-    term match {
-      case top @ CaseOf(scrutinee: Var, fst @ Case(pattern, body, NoCases)) =>
-        println(s"found a UNARY case: $scrutinee is $pattern")
-        top.copy(cases = fst.copy(body = cascadeCaseTerm(body)))
-      case top @ CaseOf(scrutinee: Var, fst @ Case(pattern, trueBranch, snd @ Wildcard(falseBranch))) =>
-        println(s"found a BINARY case: $scrutinee is $pattern")
-        println("cascading the true branch")
-        val processedTrueBranch = cascadeCaseTerm(trueBranch)
-        println("cascading the false branch")
-        val processedFalseBranch = cascadeCaseTerm(falseBranch)
-        // Check if the false branch is another `CaseOf` with the same scrutinee.
-        processedFalseBranch match {
-          case CaseOf(otherScrutinee: Var, actualFalseBranch) =>
-            if (scrutinee.symbol === otherScrutinee.symbol) {
-              println(s"identical: $scrutinee === $otherScrutinee")
-              if (scrutinee.name =/= otherScrutinee.name) {
-                // TODO: solve name collision by creating a lifted `Let`
-                ???
-              }
-              println(s"actual false branch: $actualFalseBranch")
-              top.copy(cases = fst.copy(body = processedTrueBranch, rest = actualFalseBranch))
-            } else {
-              println(s"different: $scrutinee =/= $otherScrutinee")
-              top.copy(cases = fst.copy(body = processedTrueBranch, rest = snd.copy(body = processedFalseBranch)))
-            }
-          case other => top
-        }
-      // We recursively process the body of `Let` bindings.
-      case let @ Let(_, _, _, body) => let.copy(body = cascadeCaseTerm(body))
-      // Otherwise, this is not a part of a normalized term.
-      case other => println(s"CANNOT cascade"); other
-    }
-  }(_ => "cascadeCaseTerm ==> ")
 }
 
 object PostProcessing {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index 64f5ede3a4..83851a773b 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -139,7 +139,6 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
       case _ -> Fld(_, Var("_")) => N // Consider "_" as wildcard.
       case _ -> Fld(_, t       ) => S(transformPattern(t))
     })
-    // TODO: Support more patterns.
     case _ =>
       println(s"unknown pattern: $term")
       throw new TransformException(msg"Unknown pattern", term.toLoc)

From 3b04b1a3dba4a331e4f249131021c24f6a4a073b Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 27 Dec 2023 21:22:03 +0800
Subject: [PATCH 032/147] Remake untyped lambda calculus example

---
 .../test/diff/pretyper/ucs/examples/ULC.mls   | 533 ++++++++++++++++++
 1 file changed, 533 insertions(+)
 create mode 100644 shared/src/test/diff/pretyper/ucs/examples/ULC.mls

diff --git a/shared/src/test/diff/pretyper/ucs/examples/ULC.mls b/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
new file mode 100644
index 0000000000..cc1c507f49
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
@@ -0,0 +1,533 @@
+:PreTyper
+
+fun (++) concatOp(a, b) = concat(a)(b)
+fun (|>) pipe(a, f) = f(a)
+fun (!==) notEqual(x, y) = not(x === y)
+//│ fun (++) concatOp: (Str, Str) -> Str
+//│ fun (|>) pipe: forall 'a 'b. ('a, 'a -> 'b) -> 'b
+//│ fun (!==) notEqual: forall 'c. (Eql['c], 'c) -> Bool
+
+fun par(a) = "(" ++ a ++ ")"
+//│ fun par: Str -> Str
+
+declare fun String: nothing
+//│ fun String: nothing
+
+let makeString: anything => { length: Int, charCodeAt: Int => Int } = String
+let StringInstance: { fromCharCode: Int => Str } = String
+//│ let makeString: anything -> {charCodeAt: Int -> Int, length: Int}
+//│ let StringInstance: {fromCharCode: Int -> Str}
+//│ makeString
+//│            = [Function: String]
+//│ StringInstance
+//│                = [Function: String]
+
+let anythingToString = toString
+fun fromCharCode(n: Int) = StringInstance.fromCharCode(n)
+fun stringCharCodeAt(s: Str, i) = makeString(s).charCodeAt(i)
+fun stringLength(s: Str) = makeString(s).length
+//│ let anythingToString: anything -> Str
+//│ fun fromCharCode: (n: Int) -> Str
+//│ fun stringCharCodeAt: (s: Str, Int) -> Int
+//│ fun stringLength: (s: Str) -> Int
+//│ anythingToString
+//│                  = [Function: toString]
+
+type Option[A] = Some[A] | None
+class Some[A](value: A) {
+  fun toString() = "Some(" ++ anythingToString(value) ++ ")"
+}
+module None {
+  fun toString() = "None"
+}
+fun showOption(opt) =
+  if opt is
+    Some(x) then "Some(" ++ toString(x) ++ ")"
+    None then "None"
+//│ type Option[A] = None | Some[A]
+//│ class Some[A](value: A) {
+//│   fun toString: () -> Str
+//│ }
+//│ module None {
+//│   fun toString: () -> "None"
+//│ }
+//│ fun showOption: (None | Some[anything]) -> Str
+
+type List[A] = Cons[A] | Nil
+class Cons[A](head: A, tail: List[A])
+module Nil
+//│ type List[A] = Cons[A] | Nil
+//│ class Cons[A](head: A, tail: List[A])
+//│ module Nil
+
+fun (::) cons(head, tail) = Cons(head, tail)
+//│ fun (::) cons: forall 'A. ('A, List['A]) -> Cons['A]
+
+fun join(sep) =
+  let aux(acc, xs) =
+    if xs is
+      Nil then acc
+      Cons(x, xs') then aux(acc ++ sep ++ toString(x), xs')
+  (xs) =>
+    if xs is
+      Cons(x, xs') then aux(toString(x), xs')
+      Nil then ""
+//│ fun join: Str -> (forall 'A. (Cons['A] | Nil) -> Str)
+
+fun showList(xs) = "[" ++ join(", ")(xs) ++ "]"
+//│ fun showList: forall 'A. (Cons['A] | Nil) -> Str
+
+fun findFirst(list, p) =
+  if list is
+    Nil then None
+    Cons(x, xs) and
+      p(x) then Some(x)
+      else findFirst(xs, p)
+//│ fun findFirst: forall 'A. (Cons['A] | Nil, 'A -> Bool) -> (None | Some['A])
+
+fun (:::) listConcat(xs, ys) =
+  if xs is
+    Nil then ys
+    Cons(x, xs') then Cons(x, listConcat(xs', ys))
+//│ fun (:::) listConcat: forall 'A 'A0 'a. (Cons['A] | Nil, List['A0] & 'a) -> (Cons['A0] | 'a)
+//│   where
+//│     'A <: 'A0
+
+fun contains(xs, x) =
+  if xs is
+    Nil then false
+    Cons(x', xs') and
+      x === x' then true
+      else contains(xs', x)
+//│ fun contains: forall 'A. (Cons['A] | Nil, Eql['A]) -> Bool
+
+contains("x" :: "y" :: "z" :: Nil, "y")
+contains("x" :: "y" :: "z" :: Nil, "w")
+//│ Bool
+//│ res
+//│     = true
+//│ res
+//│     = false
+
+fun exclude(xs, x) =
+  if xs is
+    Nil then Nil
+    Cons(x', xs') and
+      x === x' then exclude(xs', x)
+      else Cons(x', exclude(xs', x))
+//│ fun exclude: forall 'A 'A0. (Cons['A] | Nil, Eql['A]) -> (Cons['A0] | Nil)
+//│   where
+//│     'A <: 'A0
+
+exclude("x" :: "y" :: "z" :: Nil, "y") |> showList
+exclude("x" :: "y" :: "z" :: Nil, "w") |> showList
+//│ Str
+//│ res
+//│     = '[x, z]'
+//│ res
+//│     = '[x, y, z]'
+
+fun reverse(xs: List['B]): List['B] =
+  let aux(acc: List['B], ys: List['B]): List['B] =
+    if ys is
+      Nil then acc
+      Cons(y, ys') then aux(Cons(y, acc), ys')
+  aux(Nil, xs)
+//│ fun reverse: forall 'B 'A. (xs: List['B]) -> List['A]
+//│   where
+//│     'B <: 'A
+
+reverse(1 :: 2 :: 3 :: Nil) |> showList
+reverse(3 :: 2 :: 1 :: Nil) |> showList
+//│ Str
+//│ res
+//│     = '[3, 2, 1]'
+//│ res
+//│     = '[1, 2, 3]'
+
+//  _____
+// |_   _|___  _ __  _ __ ___
+//   | | / _ \| '__|| '_ ` _ \
+//   | ||  __/| |   | | | | | |
+//   |_| \___||_|   |_| |_| |_|
+//
+
+type Term = Var | Abs | App
+class Var(name: Str)
+class Abs(lhs: Var, rhs: Term)
+class App(lhs: Term, rhs: Term)
+//│ type Term = Abs | App | Var
+//│ class Var(name: Str)
+//│ class Abs(lhs: Var, rhs: Term)
+//│ class App(lhs: Term, rhs: Term)
+
+fun showTerm(t) =
+  if t is
+    Var(name) then toString(name)
+    Abs(lhs, rhs) then "λ" ++ showTerm(lhs) ++ ". " ++ showTerm(rhs)
+    App(Abs(lhs0, lhs1), rhs) then
+      "((" ++ "λ" ++ showTerm(lhs0) ++ ". " ++ showTerm(lhs1) ++ ") " ++ showTerm(rhs) ++ ")"
+    App(lhs, rhs) then par(showTerm(lhs) ++ " " ++ showTerm(rhs))
+//│ fun showTerm: (Abs | App | Var) -> Str
+
+showTerm(Var("x"))
+showTerm(Abs(Var("x"), Var("y")))
+showTerm(App(Var("x"), Var("y")))
+showTerm(App(Abs(Var("x"), Var("y")), Var("z")))
+//│ Str
+//│ res
+//│     = 'x'
+//│ res
+//│     = 'λx. y'
+//│ res
+//│     = '(x y)'
+//│ res
+//│     = '((λx. y) z)'
+
+fun (=:=) equalTerm(t1: Term, t2: Term) =
+  if t1 is
+    Var(x1)        and t2 is Var(x2)        then x1 === x2
+    Abs(x1, t1')   and t2 is Abs(x2, t2')   then (x1 =:= x2) && (t1' =:= t2')
+    App(t1', t1'') and t2 is App(t2', t2'') then (t1' =:= t2') && (t1'' =:= t2'')
+    else false
+//│ fun (=:=) equalTerm: (t1: Term, t2: Term) -> Bool
+
+Var("x") =:= Var("x")
+Var("x") =:= Var("y")
+Abs(Var("x"), Var("x")) =:= Abs(Var("x"), Var("x"))
+Abs(Var("x"), Var("x")) =:= Abs(Var("x"), Var("y"))
+Abs(Var("x"), Var("y")) =:= Abs(Var("x"), Var("x"))
+//│ Bool
+//│ res
+//│     = true
+//│ res
+//│     = false
+//│ res
+//│     = true
+//│ res
+//│     = false
+//│ res
+//│     = false
+
+fun isValue(t) =
+  if t is
+    Abs then true
+    Var then false
+    App then false
+//│ fun isValue: (Abs | App | Var) -> Bool
+
+isValue(Var("x"))
+isValue(Abs(Var("x"), Var("y")))
+isValue(App(Var("x"), Var("y")))
+//│ Bool
+//│ res
+//│     = false
+//│ res
+//│     = true
+//│ res
+//│     = false
+
+fun hasFree(t, x) =
+  if t is
+    Var(x') then x === x'
+    Abs(Var(x'), body) and x === x' then false
+    Abs(Var(_), body) then hasFree(body, x)
+    App(lhs, rhs) then hasFree(lhs, x) || hasFree(rhs, x)
+    _ then false
+//│ fun hasFree: (Abs | App | Object & ~#Abs & ~#App & ~#Var | Var, Eql[Str]) -> Bool
+
+fun showHasFree(t, n) =
+  showTerm(t) ++ (if hasFree(t, n) then " has " else " DOES NOT have ") ++ "free variable " ++ n
+//│ fun showHasFree: (Abs | App | Var, Eql[Str] & Str) -> Str
+
+showHasFree(Var("x"), "x")
+showHasFree(Var("x"), "y")
+showHasFree(Abs(Var("x"), Var("x")), "x")
+showHasFree(Abs(Var("x"), Var("x")), "y")
+showHasFree(Abs(Var("x"), Var("y")), "x")
+showHasFree(Abs(Var("x"), Var("y")), "y")
+showHasFree(App(Var("x"), Var("y")), "x")
+showHasFree(App(Var("x"), Var("y")), "y")
+showHasFree(App(Abs(Var("x"), Var("x")), Var("x")), "x")
+showHasFree(App(Abs(Var("x"), Var("x")), Var("x")), "y")
+showHasFree(App(Abs(Var("x"), Var("x")), Var("y")), "y")
+showHasFree(App(Abs(Var("x"), Var("x")), Var("x")), "y")
+//│ Str
+//│ res
+//│     = 'x has free variable x'
+//│ res
+//│     = 'x DOES NOT have free variable y'
+//│ res
+//│     = 'λx. x DOES NOT have free variable x'
+//│ res
+//│     = 'λx. x DOES NOT have free variable y'
+//│ res
+//│     = 'λx. y DOES NOT have free variable x'
+//│ res
+//│     = 'λx. y has free variable y'
+//│ res
+//│     = '(x y) has free variable x'
+//│ res
+//│     = '(x y) has free variable y'
+//│ res
+//│     = '((λx. x) x) has free variable x'
+//│ res
+//│     = '((λx. x) x) DOES NOT have free variable y'
+//│ res
+//│     = '((λx. x) y) has free variable y'
+//│ res
+//│     = '((λx. x) x) DOES NOT have free variable y'
+
+fun freeVars(t) =
+  if t is
+    Var(x) then x :: Nil
+    Abs(Var(x), body) then exclude(freeVars(body), x)
+    App(lhs, rhs) then freeVars(lhs) ::: freeVars(rhs)
+//│ fun freeVars: forall 'A. (Abs | App | Var) -> (Cons['A] | Nil)
+//│   where
+//│     'A :> Str
+
+(freeVars of Var("x")) |> showList
+(freeVars of Abs(Var("x"), Var("x"))) |> showList
+(freeVars of Abs(Var("x"), Var("y"))) |> showList
+(freeVars of App(Var("x"), Var("y"))) |> showList
+(freeVars of App(Abs(Var("x"), Var("x")), Var("x"))) |> showList
+//│ Str
+//│ res
+//│     = '[x]'
+//│ res
+//│     = '[]'
+//│ res
+//│     = '[y]'
+//│ res
+//│     = '[x, y]'
+//│ res
+//│     = '[x]'
+
+let alphabet: List[Str] = "a" :: "b" :: "c" :: "d" :: "e" :: "f" :: "g" :: "h" :: "i" :: "j" :: "k" :: "l" :: "m" :: "n" :: "o" :: "p" :: "q" :: "r" :: "s" :: "t" :: "u" :: "v" :: "w" :: "x" :: "y" :: "z" :: Nil
+//│ let alphabet: List[Str]
+//│ alphabet
+//│          = Cons {}
+
+fun search(f: 'A -> Option['B], xs: List['A]): Option['B] =
+  if xs is
+    Nil then None
+    Cons(x, xs') and
+      f(x) is
+        Some(x') then Some(x')
+        None then search(f, xs')
+//│ fun search: forall 'A 'B 'A0. (f: 'A -> Option['B], xs: List['A]) -> Option['A0]
+//│   where
+//│     'B <: 'A0
+
+// The removal of type annotations will cause running out of fuel.
+fun combinations(n: Int, acc: List['A], alphabet: List['A], xs: List[Str]): Option[Str] =
+  if
+    n <= 0 and
+      let x = reverse(acc) |> join("")
+      contains(xs, x) then None
+      else Some(x)
+    else
+      search((x) => combinations(n - 1, x :: acc, alphabet, xs), alphabet)
+//│ fun combinations: forall 'A 'A0 'A1. (n: Int, acc: List['A], alphabet: List['A1], xs: List[Str]) -> Option[Str]
+//│   where
+//│     'A1 <: 'A & 'A0
+//│     'A :> 'A0
+//│     'A0 := 'A
+
+combinations(1, Nil, 1 :: 2 :: 3 :: Nil, Nil) |> showOption
+combinations(2, Nil, 1 :: 2 :: 3 :: Nil, Nil) |> showOption
+combinations(3, Nil, 1 :: 2 :: 3 :: Nil, Nil) |> showOption
+combinations(1, Nil, 1 :: 2 :: 3 :: Nil, "1" :: "3" :: Nil) |> showOption
+combinations(2, Nil, 1 :: 2 :: 3 :: Nil, "11" :: "12" :: "13" :: Nil) |> showOption
+combinations(3, Nil, 1 :: 2 :: 3 :: Nil, "111" :: "112" :: "113" :: "121" :: Nil) |> showOption
+//│ Str
+//│ res
+//│     = 'Some(1)'
+//│ res
+//│     = 'Some(11)'
+//│ res
+//│     = 'Some(111)'
+//│ res
+//│     = 'Some(2)'
+//│ res
+//│     = 'Some(21)'
+//│ res
+//│     = 'Some(122)'
+
+fun freshVar(t: Term): Str =
+  let fvs = freeVars(t)
+  let aux(n: Int): Str =
+    if combinations(n, Nil, alphabet, fvs) is
+      Some(x) then x
+      None then aux(n + 1)
+  aux(1)
+//│ fun freshVar: (t: Term) -> Str
+
+freshVar(Var("x"))
+freshVar(App(Var("a"), Var("b")))
+freshVar(App(Abs(Var("a"), Var("a")), Var("b")))
+//│ Str
+//│ res
+//│     = 'a'
+//│ res
+//│     = 'c'
+//│ res
+//│     = 'a'
+
+fun subst(t: Term, x: Str, v: Term): Term =
+  if t is
+    Var(y) and x === y then v
+    Abs(Var(y), t') and x !== y and
+      hasFree(v, y) then
+        let y' = freshVar(t')
+        let t'' = subst(t', y, Var(y'))
+        Abs(Var(y'), subst(t'', x, v))
+      else
+        Abs(Var(y), subst(t', x, v))
+    App(lhs, rhs) then App(subst(lhs, x, v), subst(rhs, x, v))
+    else t
+//│ fun subst: (t: Term, x: Str, v: Term) -> Term
+
+fun showSubst(t, n, v) =
+  showTerm(t) ++ " [" ++ n ++ " / " ++ showTerm(v) ++ "]" ++ " = " ++ showTerm(subst(t, n, v))
+//│ fun showSubst: (Abs & Term | App & Term | Var & Term, Str, Abs & Term | App & Term | Var & Term) -> Str
+
+showSubst(Var("x"), "x", Var("y"))
+showSubst(Abs(Var("x"), Var("x")), "x", Var("z"))
+showSubst(App(Var("x"), Var("y")), "x", Abs(Var("x"), Var("x")))
+showSubst(App(Abs(Var("x"), Var("x")), Var("x")), "x", Abs(Var("y"), Var("y")))
+showSubst(Abs(Var("x"), App(Var("x"), Var("y"))), "y", Var("x"))
+showSubst(Abs(Var("z"), Abs(Var("x"), App(Var("z"), App(Var("x"), Var("y"))))), "y", Var("x"))
+showSubst(Abs(Var("z"), Abs(Var("x"), App(Var("z"), App(Var("x"), Var("y"))))), "y", App(Var("x"), Var("z")))
+//│ Str
+//│ res
+//│     = 'x [x / y] = y'
+//│ res
+//│     = 'λx. x [x / z] = λx. x'
+//│ res
+//│     = '(x y) [x / λx. x] = ((λx. x) y)'
+//│ res
+//│     = '((λx. x) x) [x / λy. y] = ((λx. x) λy. y)'
+//│ res
+//│     = 'λx. (x y) [y / x] = λa. (a x)'
+//│ res
+//│     = 'λz. λx. (z (x y)) [y / x] = λz. λa. (z (a x))'
+//│ res
+//│     = 'λz. λx. (z (x y)) [y / (x z)] = λa. λb. (a (b (x z)))'
+
+//  ____                     _  _   ____   _
+// / ___|  _ __ ___    __ _ | || | / ___| | |_  ___  _ __
+// \___ \ | '_ ` _ \  / _` || || | \___ \ | __|/ _ \| '_ \
+//  ___) || | | | | || (_| || || |  ___) || |_|  __/| |_) |
+// |____/ |_| |_| |_| \__,_||_||_| |____/  \__|\___|| .__/
+//                                                  |_|
+
+type Result = Normal | Stuck | Stepped
+class Normal(term: Term) {
+  fun toString() = "Normal form: " ++ showTerm(term)
+}
+class Stuck(term: Term, part: Term) {
+  fun toString() = "Stuck: " ++ showTerm(part) ++ " in " ++ showTerm(term)
+}
+class Stepped(from: Term, to: Term) {
+  fun toString() = showTerm(from) ++ " => " ++ showTerm(to)
+}
+//│ type Result = Normal | Stepped | Stuck
+//│ class Normal(term: Term) {
+//│   fun toString: () -> Str
+//│ }
+//│ class Stuck(term: Term, part: Term) {
+//│   fun toString: () -> Str
+//│ }
+//│ class Stepped(from: Term, to: Term) {
+//│   fun toString: () -> Str
+//│ }
+
+fun stepByValue(t) =
+  if t is
+    Var then Stuck(t, t)
+    Abs then Normal(t)
+    App(lhs, rhs) and stepByValue(lhs) is
+      Stepped(_, lhs) then Stepped(t, App(lhs, rhs))
+      Stuck(_, part) then Stuck(t, part)
+      Normal and stepByValue(rhs) is
+        Stepped(_, rhs) then Stepped(t, App(lhs, rhs))
+        Stuck(_, part) then Stuck(t, part)
+        Normal and lhs is
+          Abs(Var(name), body) then Stepped(t, subst(body, name, rhs))
+          _ then Stuck(t, lhs)
+//│ fun stepByValue: (Abs | App | Var) -> (Normal | Stepped | Stuck)
+
+toString of stepByValue of Var("x")
+toString of stepByValue of Abs(Var("x"), Var("y"))
+toString of stepByValue of App(Var("x"), Var("y"))
+toString of stepByValue of App(Abs(Var("x"), Var("x")), Var("x"))
+toString of stepByValue of App(Abs(Var("x"), Var("x")), Abs(Var("y"), Var("y")))
+//│ Str
+//│ res
+//│     = 'Stuck: x in x'
+//│ res
+//│     = 'Normal form: λx. y'
+//│ res
+//│     = 'Stuck: x in (x y)'
+//│ res
+//│     = 'Stuck: x in ((λx. x) x)'
+//│ res
+//│     = '((λx. x) λy. y) => λy. y'
+
+//  _____               _                _    _
+// | ____|__   __ __ _ | | _   _   __ _ | |_ (_)  ___   _ __
+// |  _|  \ \ / // _` || || | | | / _` || __|| | / _ \ | '_ \
+// | |___  \ V /| (_| || || |_| || (_| || |_ | || (_) || | | |
+// |_____|  \_/  \__,_||_| \__,_| \__,_| \__||_| \___/ |_| |_|
+//
+
+fun eval(step) =
+  let aux(t) =
+    if step(t) is result and result is
+      Stepped(_, t') then aux(t')
+      else result
+  aux
+//│ fun eval: forall 'a 'b. ((Term | 'a) -> (Object & 'b & ~#Stepped | Stepped)) -> 'a -> 'b
+
+let evalByValue = eval(stepByValue)
+//│ let evalByValue: (Abs | App | Var) -> (Normal | Stuck)
+//│ evalByValue
+//│             = [Function: aux]
+
+// Let's program with Church encoding!
+let zero = Abs(Var("f"), Abs(Var("x"), Var("x")))
+let one = Abs(Var("f"), Abs(Var("x"), App(Var("f"), Var("x"))))
+toString of stepByValue of zero
+toString of stepByValue of one
+let succ = Abs(Var("n"), Abs(Var("f"), Abs(Var("x"), App(Var("f"), App(App(Var("n"), Var("f")), Var("x"))))))
+toString of stepByValue of succ
+toString of stepByValue of App(succ, zero)
+//│ let zero: Abs
+//│ let one: Abs
+//│ let succ: Abs
+//│ Str
+//│ zero
+//│      = Abs {}
+//│ one
+//│     = Abs {}
+//│ res
+//│     = 'Normal form: λf. λx. x'
+//│ res
+//│     = 'Normal form: λf. λx. (f x)'
+//│ succ
+//│      = Abs {}
+//│ res
+//│     = 'Normal form: λn. λf. λx. (f ((n f) x))'
+//│ res
+//│     = '((λn. λf. λx. (f ((n f) x))) λf. λx. x) => λf. λx. (f (((λf. λx. x) f) x))'
+
+toString of evalByValue of App(succ, App(succ, zero))
+toString of evalByValue of App(succ, App(succ, App(succ, App(succ, zero))))
+//│ Str
+//│ res
+//│     = 'Normal form: λf. λx. (f (((λf. λx. (f (((λf. λx. x) f) x))) f) x))'
+//│ res
+//│     = 'Normal form: λf. λx. (f (((λf. λx. (f (((λf. λx. (f (((λf. λx. (f (((λf. λx. x) f) x))) f) x))) f) x))) f) x))'
+

From 4cc5957b04a03e0d9d8023a3cfc23fd7e6d3e2c9 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Fri, 29 Dec 2023 00:34:23 +0800
Subject: [PATCH 033/147] Fix code generation for local functions declared by
 `let rec`

---
 shared/src/main/scala/mlscript/JSBackend.scala | 3 ++-
 shared/src/test/diff/nu/LetRec.mls             | 9 ---------
 2 files changed, 2 insertions(+), 10 deletions(-)

diff --git a/shared/src/main/scala/mlscript/JSBackend.scala b/shared/src/main/scala/mlscript/JSBackend.scala
index 621fb7bdcb..c193e469da 100644
--- a/shared/src/main/scala/mlscript/JSBackend.scala
+++ b/shared/src/main/scala/mlscript/JSBackend.scala
@@ -239,7 +239,8 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
           case (t: Term, index)                                  => JSExprStmt(translateTerm(t)(blkScope))
           case (NuFunDef(isLetRec, Var(nme), symNme, _, L(rhs)), _) =>
             val symb = symNme.map(_.name)
-            val pat = blkScope.declareValue(nme, isLetRec, isLetRec.isEmpty, symb)
+            val isLocalFunction = isLetRec.isEmpty || (rhs match { case _: Lam => true; case _ => false })
+            val pat = blkScope.declareValue(nme, isLetRec, isLocalFunction, symb)
             JSLetDecl(Ls(pat.runtimeName -> S(translateTerm(rhs)(blkScope))))
           case (nt: NuTypeDef, _) => translateLocalNewType(nt)(blkScope)
           // TODO: find out if we need to support this.
diff --git a/shared/src/test/diff/nu/LetRec.mls b/shared/src/test/diff/nu/LetRec.mls
index 51ad7c37f8..ab93a34176 100644
--- a/shared/src/test/diff/nu/LetRec.mls
+++ b/shared/src/test/diff/nu/LetRec.mls
@@ -95,29 +95,20 @@ fun test =
 //│ Code generation encountered an error:
 //│   unguarded recursive use of by-value binding f
 
-:ge // TODO this one should actually be accepted by codegen!
 fun test =
   let rec f() = f()
 //│ fun test: ()
-//│ Code generation encountered an error:
-//│   unguarded recursive use of by-value binding f
 
-:ge // TODO this one should actually be accepted by codegen!
 fun test =
   let rec lol = () => lol
 //│ fun test: ()
-//│ Code generation encountered an error:
-//│   unguarded recursive use of by-value binding lol
 
-:ge // TODO this one should actually be accepted by codegen!
 fun test =
   let rec lol() = lol
   lol
 //│ fun test: forall 'lol. 'lol
 //│   where
 //│     'lol :> () -> 'lol
-//│ Code generation encountered an error:
-//│   unguarded recursive use of by-value binding lol
 
 let rec lol = () => lol
 //│ let rec lol: forall 'lol. 'lol

From cfc51a3d87d124ddb58d589ac87c43299dc89da1 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Fri, 29 Dec 2023 04:42:55 +0800
Subject: [PATCH 034/147] Add Lisp interpreter example and improve `PreTyper`'s
 structure

---
 .../src/main/scala/mlscript/JSBackend.scala   |   1 +
 .../scala/mlscript/pretyper/PreTyper.scala    | 218 +++-----
 .../main/scala/mlscript/pretyper/Scope.scala  |  19 +-
 .../main/scala/mlscript/pretyper/Symbol.scala |  78 +--
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |   2 +-
 .../mlscript/ucs/context/Matchable.scala      |  39 ++
 .../mlscript/ucs/stages/Desugaring.scala      |  25 +-
 .../scala/mlscript/ucs/stages/package.scala   |  16 +-
 shared/src/test/diff/mlscript/Repro.mls       |   7 +-
 .../src/test/diff/pretyper/ucs/DualOption.mls |   2 +
 .../diff/pretyper/ucs/examples/Calculator.mls |  12 +-
 .../pretyper/ucs/examples/LispInterpreter.mls | 508 ++++++++++++++++++
 .../diff/pretyper/ucs/examples/ListFold.mls   |  10 +-
 .../diff/pretyper/ucs/examples/Option.mls     |   2 +-
 .../pretyper/ucs/examples/Permutations.mls    |  20 +-
 .../test/diff/pretyper/ucs/examples/ULC.mls   |  18 +-
 .../diff/pretyper/ucs/patterns/Literals.mls   |   2 +-
 17 files changed, 751 insertions(+), 228 deletions(-)
 create mode 100644 shared/src/main/scala/mlscript/ucs/context/Matchable.scala
 create mode 100644 shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls

diff --git a/shared/src/main/scala/mlscript/JSBackend.scala b/shared/src/main/scala/mlscript/JSBackend.scala
index c193e469da..75e2aa84ab 100644
--- a/shared/src/main/scala/mlscript/JSBackend.scala
+++ b/shared/src/main/scala/mlscript/JSBackend.scala
@@ -107,6 +107,7 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
         else
           throw new UnimplementedError(sym)
       case S(sym: ValueSymbol) =>
+        // Temporary disable this line of code because it invalidates many working test cases.
         if (sym.isByvalueRec.getOrElse(false) && !sym.isLam) throw CodeGenError(s"unguarded recursive use of by-value binding $name")
         sym.visited = true
         val ident = JSIdent(sym.runtimeName)
diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index 2cfcaaaa8f..414c150f4f 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -4,6 +4,7 @@ import collection.mutable.{Set => MutSet}
 import mlscript.ucs.DesugarUCS
 import symbol._
 import mlscript._, utils._, shorthands._
+import mlscript.{Cls, Trt, Mxn, Als, Mod}
 import scala.annotation.tailrec
 import mlscript.Message, Message.MessageContext
 
@@ -13,20 +14,23 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
   protected def raise(diagnostics: Diagnostic): Unit = ()
   protected def raise(diagnostics: Ls[Diagnostic]): Unit = ()
 
-  private def extractParameters(fields: Term): Ls[ValueSymbol] =
+  private def extractParameters(fields: Term): Ls[LocalTermSymbol] =
     trace(s"extractParameters <== ${inspect.deep(fields)}") {
       fields match {
         case Tup(arguments) =>
           arguments.flatMap {
-            case (S(nme: Var), Fld(_, _)) => new ValueSymbol(nme, false) :: Nil
-            case (_, Fld(_, nme: Var)) => new ValueSymbol(nme, false) :: Nil
-            case (_, Fld(_, Bra(false, nme: Var))) => new ValueSymbol(nme, false) :: Nil
+            case (S(nme: Var), Fld(_, _)) => new LocalTermSymbol(nme) :: Nil
+            case (_, Fld(_, nme: Var)) => new LocalTermSymbol(nme) :: Nil
+            case (_, Fld(_, Bra(false, nme: Var))) => new LocalTermSymbol(nme) :: Nil
             case (_, Fld(_, tuple @ Tup(_))) => extractParameters(tuple)
-            case (_, Fld(_, _)) => ???
+            case (_, Fld(_, Asc(term, _))) => extractParameters(term)
+            case (_, Fld(_, parameter)) =>
+              println(s"unknown parameter: ${inspect.deep(parameter)}")
+              ???
           }
         case PlainTup(arguments @ _*) =>
           arguments.map {
-            case nme: Var => new ValueSymbol(nme, false)
+            case nme: Var => new LocalTermSymbol(nme)
             case other => println("Unknown parameters: " + inspect.deep(other)); ??? // TODO: bad
           }.toList
         case other => println("Unknown parameters: " + inspect.deep(other)); ??? // TODO: bad
@@ -38,21 +42,20 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
   protected def resolveVar(v: Var)(implicit scope: Scope): Unit =
     trace(s"resolveVar(name = \"$v\")") {
       scope.getTermSymbol(v.name) match {
-        case S(sym: ValueSymbol) =>
-          println(s"Resolve variable $v to a value.")
+        case S(sym: LocalTermSymbol) =>
+          println(s"Resolve variable $v to a local term.")
           v.symbol = sym
-        case S(sym: FunctionSymbol) =>
-          println(s"Resolve variable $v to a function.")
+        case S(sym: DefinedTermSymbol) =>
+          println(s"Resolve variable $v to a defined term.")
+          v.symbol = sym
+        case S(sym: ModuleSymbol) =>
+          println(s"Resolve variable $v to a module.")
           v.symbol = sym
         case N => 
           scope.getTypeSymbol(v.name) match {
             case S(sym: ClassSymbol) =>
-              if (sym.defn.kind == Cls) {
-                println(s"Resolve variable $v to a class.")
-                v.symbol = sym
-              } else {
-                throw new Exception(s"Name $v refers to a type")
-              }
+              println(s"Resolve variable $v to a class.")
+              v.symbol = sym
             case S(_) => throw new Exception(s"Name $v refers to a type")
             case N => throw new Exception(s"Variable $v not found in scope")
           }
@@ -81,8 +84,9 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
         case Sel(receiver, fieldName) => traverseTerm(receiver)
         case Let(isRec, nme, rhs, body) =>
           traverseTerm(rhs)
-          traverseTerm(body)(scope + new ValueSymbol(nme, false))
+          traverseTerm(body)(scope + new LocalTermSymbol(nme))
         case New(head, body) =>
+          // `new C(...)` or `new C(){...}` or `new{...}`
         case Tup(fields) => fields.foreach { case (_, Fld(_, t)) => traverseTerm(t) }
         case Asc(trm, ty) => traverseTerm(trm)
         case ef @ If(_, _) => traverseIf(ef)(scope)
@@ -122,81 +126,32 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
       ()
     }(_ => s"traverseTypeDefinition <== ${defn.describe}")
 
-  private def traverseFunction(symbol: FunctionSymbol, defn: NuFunDef)(implicit scope: Scope): Unit =
-    trace(s"traverseFunction <== ${defn.nme.name}") {
-      require(defn.isLetRec.isEmpty) // Make sure it's defined via `fun`.
-      defn.rhs match {
-        case Left(term) => 
-          val subScope = if (defn.isLetRec === S(false)) scope else scope + symbol
-          traverseTerm(term)(subScope)
-        case Right(ty) => println(s"found a pure declaration: $ty")
-      }
-    }(_ => s"traverseFunction ==> ${defn.nme.name}")
-
-  private def traverseLetBinding(symbol: ValueSymbol, rec: Bool, rhs: Term)(implicit scope: Scope): Unit =
-    trace(s"traverseLetBinding(rec = $rec, ${symbol.name})") {
-      traverseTerm(rhs)(scope + symbol)
-    }()
-
   private def traverseStatements(statements: Ls[Statement], name: Str, parentScope: Scope): (Scope, TypeContents) =
     trace(s"traverseStatements <== $name: ${"statement".pluralize(statements.size, true)}") {
-      import mlscript.{Cls, Trt, Mxn, Als, Mod}
-      // Pass 1: Build a scope with hoisted symbols.
-      val hoistedScope = statements.foldLeft(parentScope.derive) {
-        case (acc, _: Term) => acc // Skip
-        case (acc, defn: NuTypeDef) =>
-          val `var` = Var(defn.nme.name).withLoc(defn.nme.toLoc)
-          // Create a type symbol but do not visit its inner members
-          val symbol = defn.kind match {
-            case Cls => new ClassSymbol(defn)
-            case Als => new TypeAliasSymbol(defn)
-            case Mxn => new MixinSymbol(defn)
-            case Trt => new TraitSymbol(defn)
-            case Mod => new ModuleSymbol(defn)
-          }
-          println("parent types: " + defn.parents.iterator.map(inspect.deep(_)).mkString("; "))
-          acc ++ (symbol ::
-            (defn.kind match {
-              case Mod => new ValueSymbol(`var`, true) :: Nil
-              case Als | Cls | Mxn | Trt => Nil
-            }))
-        case (acc, defn: NuFunDef) if defn.isLetRec.isEmpty => acc + new FunctionSymbol(defn)
-        case (acc, _: NuFunDef) => acc
-        case (acc, _: Constructor | _: DataDefn | _: DatatypeDefn | _: Def | _: LetS | _: TypeDef) => ??? // TODO: When?
+      // Pass 1: Build a scope with type symbols only.
+      val filterNuTypeDef = { (_: Statement) match { case t: NuTypeDef => S(t); case _ => N } }
+      val typeSymbols = statements.iterator.flatMap(filterNuTypeDef).map(TypeSymbol(_)).toList
+      val scopeWithTypes = parentScope.derive ++ typeSymbols
+      println(typeSymbols.iterator.map(_.name).mkString("type symbols: {", ", ", "}"))
+      // val scopeWithTypes = statements.iterator.flatMap(filterNuTypeDef).foldLeft(parentScope.derive)(_ + TypeSymbol(_))
+      // Pass 1.1: Resolve subtyping relations. Build a graph and compute base types of each type.
+      val edges = typeSymbols.foldLeft(Map.empty[TypeSymbol, Ls[TypeSymbol]]) { case (acc, self) =>
+        acc + (self -> extractSuperTypes(self.defn.parents).map { nme =>
+          scopeWithTypes.getTypeSymbol(nme.name).getOrElse(???) })
       }
-      // Resolve base types.
-      val subtypingRelations = statements.foldLeft(Map.empty[Var, Ls[Var]]) {
-        case (acc, defn: NuTypeDef) =>
-          val thisType = Var(defn.nme.name).withLoc(defn.nme.toLoc)
-          val superTypes = extractSuperTypes(defn.parents)
-          acc + (thisType -> superTypes)
-        case (acc, _: Term | _: NuFunDef) => acc
-        case (acc, _: Constructor | _: DataDefn | _: DatatypeDefn | _: Def | _: LetS | _: TypeDef) => ??? // TODO: When?
+      printGraph(edges, println, "inheritance relations", "->")
+      transitiveClosure(edges).foreachEntry { (self, bases) =>
+        self.baseTypes = bases
+        println(s"base types of `${self.name}`: ${bases.iterator.map(_.name).mkString(", ")}")
       }
-      val superTypes = transitiveClosure(subtypingRelations)
-      printGraph(subtypingRelations, println, "Subtyping relations", "->")
-      superTypes.foreachEntry { case (thisType, baseTypes) =>
-        hoistedScope.getTypeSymbol(thisType.name) match {
-          case S(symbol) => symbol.baseTypes =
-            baseTypes.map(baseType => hoistedScope.getTypeSymbol(baseType.name).getOrElse(???))
-          case N => ???
-        } // FIXME: Generate proper diagnostics.
-      }
-      // Resolve sealed types.
+      // Pass 1.2: Resolve signature types for collecting sealed derived types.
       println("Resolve sealed signature types")
-      hoistedScope.types.foreachEntry {
-        case _ -> (_: MixinSymbol | _: TypeAliasSymbol) => ()
-        case (name, symbol) => symbol.defn.sig.foreach { unions =>
-          def rec(acc: Ls[TypeName], ty: Type): Ls[TypeName] = ty match {
-            case tn: TypeName => tn :: acc
-            case AppliedType(tn: TypeName, _) => tn :: acc
-            case Union(lhs, tn: TypeName) => rec(tn :: acc, lhs)
-            case Union(lhs, AppliedType(tn: TypeName, _)) => rec(tn :: acc, lhs)
-            case other => println(s"Unknown type: $other"); ???
-          }
-          val derivedTypes = try rec(Nil, unions) catch { case _: NotImplementedError => Nil }
+      typeSymbols.foreach {
+        case _: MixinSymbol | _: TypeAliasSymbol | _: ModuleSymbol => ()
+        case symbol => symbol.defn.sig.foreach { unions =>
+          val derivedTypes = try extractSignatureTypes(unions) catch { case _: NotImplementedError => Nil }
           symbol.sealedDerivedTypes = derivedTypes.flatMap { derivedType =>
-            val maybeSymbol = hoistedScope.getTypeSymbol(derivedType.name)
+            val maybeSymbol = scopeWithTypes.getTypeSymbol(derivedType.name)
             if (maybeSymbol.isEmpty) raise(ErrorReport(
               msg"Undefined type $derivedType" -> derivedType.toLoc :: Nil,
               true,
@@ -207,44 +162,38 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
           println(s">>> $name: ${symbol.sealedDerivedTypes.iterator.map(_.name).mkString(", ")}")
         }
       }
-      println(hoistedScope.symbols.map(_.name).mkString("(hoisted) scope = {", ", ", "}"))
-      // 
-      // Pass 2: Visit non-hoisted and build a complete scope.
-      val completeScope = statements.foldLeft[Scope](hoistedScope) {
-        case (acc, term: Term) => traverseTerm(term)(acc); acc
-        case (acc, defn: NuTypeDef) => acc
-        case (acc, defn @ NuFunDef(Some(rec), nme, _, _, L(rhs))) =>
-          val symbol = new ValueSymbol(defn.nme, true)
-          val scopeWithVar = acc + symbol
-          traverseLetBinding(symbol, rec, rhs)(if (rec) { scopeWithVar } else { acc })
-          scopeWithVar
-        case (acc, defn @ NuFunDef(Some(rec), nme, _, _, R(ty))) =>
-          val symbol = new ValueSymbol(defn.nme, true)
-          acc + symbol
-        case (acc, _: NuFunDef) => acc
-        case (acc, _: Constructor | _: DataDefn | _: DatatypeDefn | _: Def | _: LetS | _: TypeDef) => ??? // TODO: When?
+      // Pass 2: Build a complete scope and collect definitional terms and terms to be traversed.
+      val (completeScope, thingsToTraverse) = statements.foldLeft[(Scope, Ls[(Term \/ DefinedTermSymbol, Scope)])](scopeWithTypes, Nil) {
+        case ((scope, acc), term: Term) => (scope, (L(term), scope) :: acc)
+        case ((scope, acc), defn: NuFunDef) =>
+          val termSymbol = new DefinedTermSymbol(defn)
+          val scopeWithSymbol = scope + termSymbol
+          (scopeWithSymbol, (R(termSymbol), if (termSymbol.isRecursive) scopeWithSymbol else scope) :: acc)
+        case (acc, _: NuTypeDef) => acc // Ignore type definitions.
+        case (acc, other @ (_: Constructor | _: DataDefn | _: DatatypeDefn | _: Def | _: LetS | _: TypeDef)) =>
+          println(s"unknown statement: ${other.getClass.getSimpleName}")
+          acc
       }
-      println(hoistedScope.symbols.map(_.name).mkString("(complete) scope = {", ", ", "}"))
-      // Pass 3: Visit hoisted symbols.
-      val visitedSymbol = MutSet.empty[FunctionSymbol]
-      completeScope.symbols.foreach {
-        case symbol: TypeSymbol =>
-          val innerScope = symbol.defn.kind match {
-            case Cls =>
-              completeScope.derive(
-                new ValueSymbol(Var("this"), false) ::
-                  (symbol.defn.params match {
-                    case N => Nil
-                    case S(fields) => extractParameters(fields)
-                  })
-              )
-            case Als | Mod | Mxn | Trt => completeScope
-          }
-          traverseTypeDefinition(symbol, symbol.defn)(innerScope)
-        case symbol: FunctionSymbol if !visitedSymbol(symbol) =>
-          visitedSymbol += symbol
-          traverseFunction(symbol, symbol.defn)(completeScope)
-        case _: FunctionSymbol | _: ValueSymbol => ()
+      println(thingsToTraverse.iterator.map {
+        case (L(term), _) => inspect.shallow(term)
+        case (R(symbol), _) => symbol.name
+      }.mkString("to be traversed: {", ", ", "}"))
+      // Pass 3: Traverse terms collected from the last pass.
+      println("Pass 3")
+      thingsToTraverse.foreach {
+        case (L(term), scope) =>
+          println("traverseTerm: " + inspect.shallow(term))
+          println("scope: " + scope.showLocalSymbols)
+          traverseTerm(term)(scope)
+        case (R(symbol), scope) => symbol.body match {
+          case L(term) =>
+            if (symbol.isFunction) {
+              traverseTerm(term)(completeScope)
+            } else {
+              traverseTerm(term)(scope)
+            }
+          case R(_) => ()
+        }
       }
       (completeScope, new TypeContents)
     }({ case (scope, contents) => s"traverseStatements ==> Scope {${scope.showLocalSymbols}}" })
@@ -270,28 +219,39 @@ object PreTyper {
     rec(Nil, parents)
   }
 
-  def transitiveClosure(graph: Map[Var, List[Var]]): Map[Var, List[Var]] = {
-    def dfs(vertex: Var, visited: Set[Var]): Set[Var] = {
+  def extractSignatureTypes(ty: Type): Ls[TypeName] = {
+    @tailrec
+    def rec(acc: Ls[TypeName], ty: Type): Ls[TypeName] = ty match {
+      case tn: TypeName => tn :: acc
+      case AppliedType(tn: TypeName, _) => tn :: acc
+      case Union(lhs, tn: TypeName) => rec(tn :: acc, lhs)
+      case Union(lhs, AppliedType(tn: TypeName, _)) => rec(tn :: acc, lhs)
+      case other => println(s"Unknown type in signature: $other"); ???
+    }
+    rec(Nil, ty).reverse
+  }
+
+  def transitiveClosure[A](graph: Map[A, List[A]]): Map[A, List[A]] = {
+    def dfs(vertex: A, visited: Set[A]): Set[A] = {
       if (visited.contains(vertex)) visited
       else graph.getOrElse(vertex, List())
         .foldLeft(visited + vertex)((acc, v) => dfs(v, acc))
     }
-
     graph.keys.map { vertex =>
       val closure = dfs(vertex, Set())
       vertex -> (closure - vertex).toList
     }.toMap
   }
 
-  def printGraph(graph: Map[Var, List[Var]], print: (=> Any) => Unit, title: String, arrow: String): Unit = {
+  def printGraph(graph: Map[TypeSymbol, List[TypeSymbol]], print: (=> Any) => Unit, title: String, arrow: String): Unit = {
     print(s"• $title")
     if (graph.isEmpty)
       print("  + <Empty>")
     else
       graph.foreachEntry { (source, targets) =>
-        print(s"  + $source $arrow " + {
+        print(s"  + ${source.name} $arrow " + {
           if (targets.isEmpty) s"{}"
-          else targets.mkString("{ ", ", ", " }")
+          else targets.iterator.map(_.name).mkString("{ ", ", ", " }")
         })
       }
   }
diff --git a/shared/src/main/scala/mlscript/pretyper/Scope.scala b/shared/src/main/scala/mlscript/pretyper/Scope.scala
index 23e7113ba7..d6eae37c18 100644
--- a/shared/src/main/scala/mlscript/pretyper/Scope.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Scope.scala
@@ -34,9 +34,14 @@ final class Scope(val enclosing: Opt[Scope], val types: Map[Str, TypeSymbol], va
 
   @inline
   def +(sym: Symbol): Scope = sym match {
+    case symbol: ModuleSymbol => new Scope(enclosing, types + (symbol.name -> symbol), terms + (symbol.name -> symbol))
     case symbol: TypeSymbol => new Scope(enclosing, types + (symbol.name -> symbol), terms)
-    case symbol @ FunctionSymbol(Var(name), S(Var(operator)), _) =>
-        new Scope(enclosing, types, terms + (name -> symbol) + (operator -> symbol))
+    case symbol: DefinedTermSymbol =>
+      val newTerms = terms + (symbol.name -> symbol)
+      new Scope(enclosing, types, symbol.operatorAlias match {
+        case N => newTerms
+        case S(alias) => newTerms + (alias.name -> symbol)
+      })
     case symbol: TermSymbol => new Scope(enclosing, types, terms + (symbol.name -> symbol))
   }
 
@@ -48,6 +53,7 @@ final class Scope(val enclosing: Opt[Scope], val types: Map[Str, TypeSymbol], va
 
   def withEntries(syms: IterableOnce[Var -> Symbol]): Scope = {
     val (newTypes, newTerms) = syms.iterator.foldLeft((types, terms)) {
+      case ((types, terms), (nme, symbol: ModuleSymbol)) => (types + (nme.name -> symbol), terms + (nme.name -> symbol))
       case ((types, terms), (nme, symbol: TypeSymbol)) => (types + (nme.name -> symbol), terms)
       case ((types, terms), (nme, symbol: TermSymbol)) => (types, terms + (nme.name -> symbol))
     }
@@ -73,9 +79,10 @@ object Scope {
       symbols: IterableOnce[Symbol]
   ): (Map[Str, TypeSymbol], Map[Str, TermSymbol]) =
     symbols.iterator.foldLeft((z._1, z._2)) {
+      case ((types, terms), symbol: ModuleSymbol) => (types + (symbol.name -> symbol), terms + (symbol.name -> symbol))
       case ((types, terms), symbol: TypeSymbol) => (types + (symbol.name -> symbol), terms)
-      case ((types, terms), symbol @ FunctionSymbol(Var(name), S(Var(operator)), _)) =>
-        (types, terms + (name -> symbol) + (operator -> symbol))
+      case ((types, terms), symbol: DefinedTermSymbol) =>
+        (types, terms + (symbol.name -> symbol) ++ symbol.operatorAlias.map(_.name -> symbol))
       case ((types, terms), symbol: TermSymbol) => (types, terms + (symbol.name -> symbol))
     }
 
@@ -92,11 +99,11 @@ object Scope {
     Scope.from(
       """true,false,document,window,typeof,toString,not,succ,log,discard,negate,
         |round,add,sub,mul,div,sqrt,lt,le,gt,ge,slt,sle,sgt,sge,length,concat,eq,
-        |ne,error,id,if,emptyArray,+,-,*,%,/,<,>,<=,>=,==,===,<>,&&,||"""
+        |ne,error,id,if,emptyArray,+,-,*,%,/,<,>,<=,>=,==,===,<>,&&,||,and"""
         .stripMargin
         .split(",")
         .iterator
-        .map(name => new ValueSymbol(Var(name), false))
+        .map(name => new LocalTermSymbol(Var(name)))
         .concat(trueSymbol :: falseSymbol :: Nil)
     )
   }
diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index fc395a8797..89db935a25 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -1,13 +1,15 @@
 package mlscript.pretyper
 
 import collection.mutable.{Buffer, Map => MutMap, Set => MutSet}
-import mlscript.{Loc, NuFunDef, NuTypeDef, TypeName, Var}
+import mlscript.{Loc, NuFunDef, NuTypeDef, Term, Type, TypeName, Var}
 import mlscript.{Cls, Trt, Mxn, Als, Mod}
 import mlscript.utils._, shorthands._
-import mlscript.ucs.context.{Context, ScrutineeData}
+import mlscript.ucs.context.Matchable
 
 package object symbol {
-  sealed abstract class Symbol(val name: Str) {
+  sealed trait Symbol {
+    def name: Str
+
     def typeSymbolOption: Opt[TypeSymbol] = this match {
       case symbol: TypeSymbol => S(symbol)
       case _ => N
@@ -18,7 +20,11 @@ package object symbol {
     }
   }
 
-  sealed abstract class TypeSymbol(val defn: NuTypeDef) extends Symbol(defn.name) {
+  sealed trait TypeSymbol extends Symbol {
+    val defn: NuTypeDef
+    
+    override def name: Str = defn.name
+
     def scope: Scope = ???
     def contents: Map[Str, Symbol] = ???
 
@@ -30,61 +36,55 @@ package object symbol {
     @inline def hasSuperType(superType: TypeSymbol): Bool = baseTypes.exists(_ === superType)
   }
 
-  final class ClassSymbol(/* enclosingScope: Scope, */ defn: NuTypeDef) extends TypeSymbol(defn) {
+  object TypeSymbol {
+    def apply(defn: NuTypeDef): TypeSymbol =
+      defn.kind match {
+        case Cls => new ClassSymbol(defn)
+        case Als => new TypeAliasSymbol(defn)
+        case Mxn => new MixinSymbol(defn)
+        case Trt => new TraitSymbol(defn)
+        case Mod => new ModuleSymbol(defn)
+      }
+    def unapply(symbol: TypeSymbol): Opt[NuTypeDef] = S(symbol.defn)
+  }
+
+  final class ClassSymbol(override val defn: NuTypeDef) extends TypeSymbol {
     require(defn.kind === Cls)
-    // lazy val (scope, contents) = (enclosingScope.derive, Map.empty[Str, Symbol])
   }
 
-  final class TraitSymbol(/* enclosingScope: Scope, */ defn: NuTypeDef) extends TypeSymbol(defn) {
+  final class TraitSymbol(override val defn: NuTypeDef) extends TypeSymbol {
     require(defn.kind === Trt)
-    // lazy val (scope, contents) = (enclosingScope.derive, Map.empty[Str, Symbol])
   }
 
-  final class MixinSymbol(/* enclosingScope: Scope, */ defn: NuTypeDef) extends TypeSymbol(defn) {
+  final class MixinSymbol(override val defn: NuTypeDef) extends TypeSymbol {
     require(defn.kind === Mxn)
-    // lazy val (scope, contents) = (enclosingScope.derive, Map.empty[Str, Symbol])
   }
 
-  final class TypeAliasSymbol(/* enclosingScope: Scope, */ defn: NuTypeDef) extends TypeSymbol(defn) {
+  final class TypeAliasSymbol(override val defn: NuTypeDef) extends TypeSymbol {
     require(defn.kind === Als)
-    // lazy val (scope, contents) = (enclosingScope.derive, Map.empty[Str, Symbol])
   }
 
-  final class ModuleSymbol(/* enclosingScope: Scope, */ defn: NuTypeDef) extends TypeSymbol(defn) {
+  final class ModuleSymbol(override val defn: NuTypeDef) extends TypeSymbol with TermSymbol {
     require(defn.kind === Mod)
-    // lazy val (scope, contents) = (enclosingScope.derive, Map.empty[Str, Symbol])
   }
 
-  sealed abstract class TermSymbol(name: String) extends Symbol(name) {
-    private val scrutinees: MutMap[Context, ScrutineeData] = MutMap.empty
-    
-    def getOrCreateScrutinee(implicit context: Context): ScrutineeData =
-      scrutinees.getOrElseUpdate(context, context.freshScrutinee)
+  sealed trait TermSymbol extends Symbol with Matchable
 
-    def getScrutinee(implicit context: Context): Opt[ScrutineeData] =
-      scrutinees.get(context)
+  class DefinedTermSymbol(defn: NuFunDef) extends TermSymbol {
+    override def name: Str = defn.name
 
-    def isScrutinee(implicit context: Context): Bool = scrutinees.contains(context)
+    def body: Term \/ Type = defn.rhs
 
-    def addScrutinee(scrutinee: ScrutineeData)(implicit context: Context): Unit = {
-      require(!isScrutinee)
-      scrutinees += context -> scrutinee
-    }
-  }
+    def isFunction: Bool = defn.isLetRec.isEmpty
 
-  final class FunctionSymbol(val defn: NuFunDef) extends TermSymbol(defn.nme.name) {
-    require(defn.isLetRec.isEmpty)
-    val nme: Var = defn.nme
-    val operator: Opt[Var] = defn.symbolicNme
-  }
+    def isRecursive: Bool = defn.isLetRec.getOrElse(true)
 
-  object FunctionSymbol {
-    def unapply(symbol: TermSymbol): Opt[(Var, Opt[Var], NuFunDef)] =
-      symbol match {
-        case fs: FunctionSymbol => S(fs.nme, fs.operator, fs.defn)
-        case _ => N
-      }
+    def isDeclaration: Bool = defn.rhs.isRight
+
+    def operatorAlias: Opt[Var] = defn.symbolicNme
   }
 
-  final class ValueSymbol(val nme: Var, val hoisted: Bool) extends TermSymbol(nme.name)
+  class LocalTermSymbol(val nme: Var) extends TermSymbol {
+    override def name: Str = nme.name
+  }
 }
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 4db6a02553..7143660c62 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -16,7 +16,7 @@ trait DesugarUCS extends Transformation
                     with PostProcessing 
                     with CoverageChecking { self: PreTyper =>
 
-  protected def freshSymbol(nme: Var): ValueSymbol = new ValueSymbol(nme, false)
+  protected def freshSymbol(nme: Var): LocalTermSymbol = new LocalTermSymbol(nme)
 
   /** Common operations of `Var` which can be shared within all stages. */
   protected implicit class VarOps(nme: Var) {
diff --git a/shared/src/main/scala/mlscript/ucs/context/Matchable.scala b/shared/src/main/scala/mlscript/ucs/context/Matchable.scala
new file mode 100644
index 0000000000..9d9d96b8c1
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/context/Matchable.scala
@@ -0,0 +1,39 @@
+package mlscript.ucs.context
+
+import collection.mutable.{Map => MutMap}
+import mlscript.utils._, shorthands._
+
+/**
+  * A trait for "things" (e.g., variables, functions, symbols, etc) that can be
+  * matched in a UCS term. This trait holds everything that is needed to track
+  * scrutinee information.
+  */
+trait Matchable {
+  /**
+    * A map from the context to the scrutinee associated with the symbol in the
+    * context. The reason why we need this map is that the same symbol may be
+    * matched in different UCS terms. Each context corresponds to a UCS term. 
+    */
+  private val scrutinees: MutMap[Context, ScrutineeData] = MutMap.empty
+    
+  /**
+    * Get the scrutinee associated with the symbol in the given context. If
+    * there's no scrutinee associated with the symbol, create a new one in the
+    * given context. **Note**: This function should only be called from the
+    * UCS desugarer.
+    */
+  private[ucs] def getOrCreateScrutinee(implicit context: Context): ScrutineeData =
+    scrutinees.getOrElseUpdate(context, context.freshScrutinee)
+
+  /** Get the scrutinee associated with the symbol in the given context. */
+  def getScrutinee(implicit context: Context): Opt[ScrutineeData] = scrutinees.get(context)
+
+  /** Check if the symbol is associated with a scrutinee in the given context. */
+  def isScrutinee(implicit context: Context): Bool = scrutinees.contains(context)
+
+  /** Associate the symbol with a scrutinee in the given context. */
+  private[ucs] def addScrutinee(scrutinee: ScrutineeData)(implicit context: Context): Unit = {
+    require(!isScrutinee) // It should be impossible to add a scrutinee twice.
+    scrutinees += context -> scrutinee
+    }
+}
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 64215a0e23..52058db3ad 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -34,7 +34,7 @@ trait Desugaring { self: PreTyper =>
     *
     * @param term the root of source abstrax syntax term, obtained from the
     *             transformation stage
-    * @param context the scope is for resolving type symbols. The scope should
+    * @param scope the scope is for resolving type symbols. The scope should
     *              contains a TypeSymbol for `true` literal.
     * @return the root of desugared core abstract syntax term
     */
@@ -126,7 +126,7 @@ trait Desugaring { self: PreTyper =>
     next => c.Split.Let(
       rec = false,
       name = test,
-      term = mkBinOp(scrutinee, Var("=="), literal, true),
+      term = mkBinOp(scrutinee, Var("==="), literal, true),
       tail = c.Branch(test, truePattern, next) :: c.Split.Nil
     )
 
@@ -145,7 +145,7 @@ trait Desugaring { self: PreTyper =>
           S(name.withFreshSymbol.withScrutinee(subScrutinee) -> N)
         case (S(parameterPattern @ (s.ClassPattern(_, _) | s.LiteralPattern(_) | s.TuplePattern(_))), index) =>
           val subScrutineeVar = freshSubScrutinee(parentScrutineeVar, parentClassLikeSymbol.name, index)
-          val symbol = new ValueSymbol(subScrutineeVar, false)
+          val symbol = new LocalTermSymbol(subScrutineeVar)
           symbol.addScrutinee(classPattern.getParameter(index).withAlias(subScrutineeVar))
           S(subScrutineeVar.withSymbol(symbol) -> S(parameterPattern))
         case _ => ??? // Other patterns are not implemented yet.
@@ -184,7 +184,7 @@ trait Desugaring { self: PreTyper =>
         // duplicated bindings during normalization.
         lazy val unapp = classPattern.getUnappliedVar {
           val vari = makeUnappliedVar(scrutineeVar, pattern.nme)
-          vari.withSymbol(new ValueSymbol(vari, false))
+          vari.withSymbol(new LocalTermSymbol(vari))
         }
         val nestedPatterns = flattenClassParameters(scrutineeVar, patternClassSymbol, parameters)
         // First, handle bindings of parameters of the current class pattern.
@@ -261,7 +261,7 @@ trait Desugaring { self: PreTyper =>
       case (S(parameterPattern @ (s.ClassPattern(_, _) | s.LiteralPattern(_) | s.TuplePattern(_))), index) =>
         val arity = fields.length
         val subScrutineeVar = freshSubScrutinee(parentScrutineeVar, s"Tuple$$$arity", index)
-        val symbol = new ValueSymbol(subScrutineeVar, false)
+        val symbol = new LocalTermSymbol(subScrutineeVar)
         symbol.addScrutinee(tuplePattern.getField(index).withAlias(subScrutineeVar))
         S(subScrutineeVar.withSymbol(symbol) -> S(parameterPattern))
       case _ => ???
@@ -286,7 +286,18 @@ trait Desugaring { self: PreTyper =>
       case s.Split.Cons(head, tail) => 
         head.pattern match {
           case s.AliasPattern(nme, pattern) => ???
-          case s.LiteralPattern(literal) => ???
+          case s.LiteralPattern(literal) =>
+            val test = context.freshTest().withFreshSymbol
+            c.Split.Let(
+              rec = false,
+              name = test,
+              term = mkBinOp(scrutineeVar, Var("==="), literal, true),
+              tail = c.Branch(
+                scrutinee = test,
+                pattern = truePattern,
+                continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope + test.symbol, context)
+              ) :: rec(scrutineeVar, tail)
+            )
           case s.ConcretePattern(nme) => 
             val test = context.freshTest().withFreshSymbol
             c.Split.Let(
@@ -303,7 +314,7 @@ trait Desugaring { self: PreTyper =>
             desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context) ++ rec(scrutineeVar, tail)
           case s.NamePattern(nme) =>
             // Create a symbol for the binding.
-            val symbol = new ValueSymbol(nme, false)
+            val symbol = new LocalTermSymbol(nme)
             // Share the scrutineeVar's symbol with its aliases.
             symbol.addScrutinee(scrutineeVar.getOrCreateScrutinee.withAlias(nme))
             // Associate the symbol with the binding.
diff --git a/shared/src/main/scala/mlscript/ucs/stages/package.scala b/shared/src/main/scala/mlscript/ucs/stages/package.scala
index 0fa9fde470..0e09184504 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/package.scala
@@ -4,18 +4,4 @@ import mlscript.{Lit, Term, Var}
 import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
 
-package object stages {
-  sealed abstract class CasePattern {
-    override def toString(): String = this match {
-      case CasePattern.Class(symbol) => symbol.name
-      case CasePattern.Boolean(value) => value.toString
-      case CasePattern.Literal(value) => value.toString
-    }
-  }
-
-  object CasePattern {
-    final case class Class(symbol: TypeSymbol) extends CasePattern
-    final case class Boolean(value: Boolean) extends CasePattern
-    final case class Literal(value: Lit) extends CasePattern
-  }
-}
+package object stages
diff --git a/shared/src/test/diff/mlscript/Repro.mls b/shared/src/test/diff/mlscript/Repro.mls
index bf3a52e7ca..169d1c0b99 100644
--- a/shared/src/test/diff/mlscript/Repro.mls
+++ b/shared/src/test/diff/mlscript/Repro.mls
@@ -1 +1,6 @@
-:PreTyper
+:NewDefs
+
+fun test() =
+  let rec aux(n) = if n == 0 then 0 else aux(n - 1) + n
+  aux(100)
+//│ fun test: () -> Int
diff --git a/shared/src/test/diff/pretyper/ucs/DualOption.mls b/shared/src/test/diff/pretyper/ucs/DualOption.mls
index d7a09632a0..a8bc582fb2 100644
--- a/shared/src/test/diff/pretyper/ucs/DualOption.mls
+++ b/shared/src/test/diff/pretyper/ucs/DualOption.mls
@@ -124,6 +124,7 @@ fun add_5(x, y) =
     y is None     and x is None     then 0
 //│ fun add_5: forall 'a. (None | Some[Int], None | Some[Int & 'a]) -> (Int | 'a)
 
+
 add_5(None, None)
 add_5(Some(5), None)
 add_5(None, Some(9))
@@ -147,6 +148,7 @@ fun add_6(x, y) =
     [None,     None]     then 0
 //│ fun add_6: forall 'a. (None | Some[Int], None | Some[Int & 'a]) -> (Int | 'a)
 
+
 add_6(None, None)
 add_6(Some(5), None)
 add_6(None, Some(9))
diff --git a/shared/src/test/diff/pretyper/ucs/examples/Calculator.mls b/shared/src/test/diff/pretyper/ucs/examples/Calculator.mls
index 3b8df255b3..050ed0a91f 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/Calculator.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/Calculator.mls
@@ -59,13 +59,13 @@ class Cons[A](head: A, tail: List[A])
 module Nil
 fun (::) cons(head, tail) = Cons(head, tail)
 fun reverse(xs) =
-  let aux(acc, xs) =
+  let rec aux(acc, xs) =
     if xs is
       Nil then acc
       Cons(x, xs') then aux(x :: acc, xs')
   aux(Nil, xs)
 fun join(sep) =
-  let aux(acc, xs) =
+  let rec aux(acc, xs) =
     if xs is
       Nil then acc
       Cons(x, xs') then aux(acc ++ sep ++ toString(x), xs')
@@ -97,7 +97,7 @@ fun isBlank(n) = (n === 32) || (n === 9) || (n === 10) || (n === 13)
 //│ fun isBlank: Eql[10 | 13 | 32 | 9] -> Bool
 
 fun scanInt(text: StringOps, at: Int): Option[[Int, Int]] =
-  let aux(acc, i: Int): Option[[Int, Int]] = if
+  let rec aux(acc, i: Int): Option[[Int, Int]] = if
     i < 0 then None
     i >= text.length then mapOption(n => [n, i], acc)
     let c = text.charCodeAt(i)
@@ -124,7 +124,7 @@ scanInt("a123" |> toStringOps, 4) |> showOption
 //│     = 'None'
 
 fun skipBlank(text: StringOps, at: Int): Int =
-  let aux(i: Int): Int = if
+  let rec aux(i: Int): Int = if
     i >= text.length then i
     isBlank(text.charCodeAt(i)) then aux(i + 1)
     else i
@@ -222,7 +222,7 @@ scanToken("  42" |> toStringOps, 0)
 
 fun tokenize(str: Str): List[Token] =
   let text = str |> toStringOps
-  let aux(acc, at) =
+  let rec aux(acc, at) =
     if scanToken(text, at) is [token, at'] and token is
       UnknownInput then (token :: acc) |> reverse
       EndOfInput then acc |> reverse
@@ -334,7 +334,7 @@ fun parseAtom(ts: List[Token]): ParseResult[[Expression, List[Token]]] =
 fun parseExpression(bp: Int, ts: List[Token]): ParseResult[[Expression, List[Token]]] =
   if parseAtom(ts) is
     Some([leftmost, ts']) then
-      let aux(left, ts) = if ts is
+      let rec aux(left, ts) = if ts is
         Cons(BinaryOperator(op, bp', opAt), ts') and bp < bp' and
           parseExpression(bp', ts') is
             Some([right, ts'']) then
diff --git a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
new file mode 100644
index 0000000000..8e0d2e29c0
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
@@ -0,0 +1,508 @@
+:PreTyper
+
+// Summon the underlying JavaScript `Object.is` function so that we can compare
+// any objects. For example, functions do not conforms to `Eql` so we cannot
+// compare them with `===` directly. But, we can use `Object.is`.
+declare fun Object: nothing
+let (=:=) objectEqual: (anything, anything) -> Bool = Object.is
+fun (=/=) objectNotEqual(x, y) = not(x =:= y)
+//│ let (=:=) objectEqual: (anything, anything) -> Bool
+//│ fun (=/=) objectNotEqual: (anything, anything) -> Bool
+//│ fun Object: nothing
+//│ objectEqual
+//│             = [Function: is]
+
+fun (!==) notEqual(x, y) = not(x === y)
+fun (++) concatOp(a, b) = concat(a)(b)
+declare fun parseInt: (Str, Int) -> Int
+//│ fun (!==) notEqual: forall 'a. (Eql['a], 'a) -> Bool
+//│ fun (++) concatOp: (Str, Str) -> Str
+//│ fun parseInt: (Str, Int) -> Int
+
+// `List` and its utilities:
+abstract class List[out T]: Cons[T] | Nil
+class Cons[T](head: T, tail: List[T]) extends List[T]
+module Nil extends List
+fun (::) cons(head: 'T, tail: List['T]): List['T] = Cons(head, tail)
+fun reverse(l: List['A]): List['A] =
+  let rec r(l', l) = if l is Cons(x, xs) then r(x :: l', xs) else l'
+  r(Nil, l)
+fun join(sep: Str, xs: List['B]) = if xs is
+  Cons(x, Nil) then toString(x)
+  Cons(x, xs) then toString(x) ++ sep ++ join(sep, xs)
+  Nil then ""
+fun showList(xs: List['C]) = "[" ++ join(", ", xs) ++ "]"
+fun map(f: 'D -> 'E, xs: List['D]): List['E] = if xs is
+  Cons(x, xs) then f(x) :: map(f, xs)
+  Nil then Nil
+fun equalList(xs: List['A], ys: List['A], equal: ('A, 'A) -> Bool): Bool = if xs is
+  Cons(x, xs') and ys is Cons(y, ys') then equal(x, y) and equalList(xs', ys', equal)
+  Nil and ys is Nil then true
+  else false
+// `Option` and its utilities:
+abstract class Option[A]: Some[A] | None
+class Some[out A](value: A) extends Option[A]
+module None extends Option
+//│ abstract class List[T]: Cons[T] | Nil
+//│ class Cons[T](head: T, tail: List[T]) extends List
+//│ module Nil extends List
+//│ fun (::) cons: forall 'T. (head: 'T, tail: List['T]) -> List['T]
+//│ fun reverse: forall 'A. (l: List['A]) -> List['A]
+//│ fun join: (sep: Str, xs: List[anything]) -> Str
+//│ fun showList: (xs: List[anything]) -> Str
+//│ fun map: forall 'D 'T0. (f: 'D -> 'T0, xs: List['D]) -> List['T0]
+//│ fun equalList: forall 'A0. (xs: List['A0], ys: List['A0], equal: ('A0, 'A0) -> Bool) -> Bool
+//│ abstract class Option[A]: None | Some[A]
+//│ class Some[A](value: A) extends Option
+//│ module None extends Option
+
+//     _    ____ _____
+//    / \  / ___|_   _|
+//   / _ \ \___ \ | |
+//  / ___ \ ___) || |
+// /_/   \_\____/ |_|
+//
+
+abstract class Expr: Lambda | BuiltIn | Instance | Thunk | StrLit | IntLit | ExprList
+class Lambda(f: List[Data] -> Data) extends Expr
+class BuiltIn(e: List[Data] -> Data) extends Expr
+class Instance(n: Str, m: List[[Str, Expr]]) extends Expr
+class Thunk(e: () -> Data) extends Expr
+class StrLit(s: Str) extends Expr
+class IntLit(n: Int) extends Expr
+class ExprList(l: List[Expr]) extends Expr
+fun (=@=) equalExpr(x: Expr, y: Expr): Bool = if x is
+  Lambda(f) and y is Lambda(g) then f =:= g
+  BuiltIn(f) and y is BuiltIn(g) then f =:= g
+  Instance(n, m) and y is Instance(n', m') then
+    let equalPair = ([k, v], [k', v']) => k =:= k' and equalExpr(v, v')
+    n === n' and equalList(m, m', equalPair)
+  Thunk(e) and y is Thunk(e') then e =:= e'
+  StrLit(s) and y is StrLit(s') then s === s'
+  IntLit(n) and y is IntLit(n') then n === n'
+  ExprList(l) and y is ExprList(l') then equalList(l, l', equalExpr)
+  else false
+fun showExpr(e: Expr): Str = if e is
+  Lambda(f) then "<lambda>"
+  BuiltIn(f) then "<built-in>"
+  Instance(n, m) then "<object " ++ n ++ ">"
+  Thunk(e) then "<thunk>"
+  // StrLit(s) then "str:" ++ s
+  // IntLit(n) then "int:" ++ toString(n)
+  StrLit(s) then s
+  IntLit(n) then toString(n)
+  ExprList(l) then showList(map(showExpr, l))
+abstract class Data: Literal | DataList | Symbol
+class Literal(e: Expr) extends Data
+class DataList(l: List[Data]) extends Data
+class Symbol(s: Str) extends Data
+fun (=#=) equalData(x: Data, y: Data): Bool = if x is
+  Literal(e) and y is Literal(e') then e =@= e'
+  DataList(l) and y is DataList(l') then equalList(l, l', equalData)
+  Symbol(s) and y is Symbol(s') then s === s'
+  else false
+fun showData(d: Data): Str = if d is
+  Literal(e) then showExpr(e)
+  DataList(l) then "(" ++ join(", ", map(showData, l)) ++ ")"
+  // Symbol(s) then "sym:" ++ s
+  Symbol(s) then s
+//│ abstract class Expr: BuiltIn | ExprList | Instance | IntLit | Lambda | StrLit | Thunk
+//│ class Lambda(f: List[Data] -> Data) extends Expr
+//│ class BuiltIn(e: List[Data] -> Data) extends Expr
+//│ class Instance(n: Str, m: List[[Str, Expr]]) extends Expr
+//│ class Thunk(e: () -> Data) extends Expr
+//│ class StrLit(s: Str) extends Expr
+//│ class IntLit(n: Int) extends Expr
+//│ class ExprList(l: List[Expr]) extends Expr
+//│ fun (=@=) equalExpr: (x: Expr, y: Expr) -> Bool
+//│ fun showExpr: (e: Expr) -> Str
+//│ abstract class Data: DataList | Literal | Symbol
+//│ class Literal(e: Expr) extends Data
+//│ class DataList(l: List[Data]) extends Data
+//│ class Symbol(s: Str) extends Data
+//│ fun (=#=) equalData: (x: Data, y: Data) -> Bool
+//│ fun showData: (d: Data) -> Str
+
+//  _____       _                 _
+// |_   _|___  | | __ ___  _ __  (_) ____ ___  _ __
+//   | | / _ \ | |/ // _ \| '_ \ | ||_  // _ \| '__|
+//   | || (_) ||   <|  __/| | | || | / /|  __/| |
+//   |_| \___/ |_|\_\\___||_| |_||_|/___|\___||_|
+//
+
+type StringOps = {
+  length: Int,
+  charAt: Int => Str,
+  charCodeAt: Int => Int,
+  slice: Int => Str
+}
+declare fun String: nothing
+let toStringOps: anything => StringOps = String
+//│ type StringOps = {charAt: Int -> Str, charCodeAt: Int -> Int, length: Int, slice: Int -> Str}
+//│ let toStringOps: anything -> StringOps
+//│ fun String: nothing
+//│ toStringOps
+//│             = [Function: String]
+
+fun skipBlank(s: StringOps, i: Int): Int =
+  if
+    i < 0 then skipBlank(s, 0)
+    i >= s.length then s.length
+    s.charCodeAt(i) == 32 then skipBlank(s, i + 1)
+    else i
+//│ fun skipBlank: (s: StringOps, i: Int) -> Int
+
+fun scanWhile(s: StringOps, i: Int, p: Str -> Bool): Option[[Str, Int]] =
+  let rec aux(acc, i) =
+    if i < s.length and s.charAt(i) is ch and p of ch then
+      aux(acc ++ ch, i + 1)
+    else
+      [acc, i]
+  if aux("", i) is
+    ["", _] then None
+    [acc, i] then Some([acc, i])
+//│ fun scanWhile: (s: StringOps, i: Int, p: Str -> Bool) -> Option[[Str, Int]]
+
+fun isDelimiter(ch) = (ch !== " ") && (ch !== "(") && (ch !== ")")
+//│ fun isDelimiter: Eql[" " | "(" | ")"] -> Bool
+
+fun nextToken(s: StringOps, i: Int): Option[[Str, Int]] =
+  let i' = skipBlank(s, i)
+  if s.charAt(i') is
+    "(" then Some(["(", i' + 1])
+    ")" then Some([")", i' + 1])
+    else scanWhile(s, i', isDelimiter)
+//│ fun nextToken: (s: StringOps, i: Int) -> Option[[Str, Int]]
+
+fun tokenize(s: Str): List[Str] =
+  let s' = toStringOps(s)
+  let rec aux(acc, i) =
+    if nextToken(s', i) is
+      None then reverse(acc)
+      Some([token, i']) then aux(token :: acc, i')
+  aux(Nil, 0)
+//│ fun tokenize: (s: Str) -> List[Str]
+
+showList of tokenize("")
+showList of tokenize("12")
+showList of tokenize("x")
+showList of tokenize("(quote (cons 1 nil))")
+showList of tokenize("(+ 1 2)")
+//│ Str
+//│ res
+//│     = '[]'
+//│ res
+//│     = '[12]'
+//│ res
+//│     = '[x]'
+//│ res
+//│     = '[(, quote, (, cons, 1, nil, ), )]'
+//│ res
+//│     = '[(, +, 1, 2, )]'
+
+//  ____
+// |  _ \  __ _  _ __  ___   ___  _ __
+// | |_) |/ _` || '__|/ __| / _ \| '__|
+// |  __/| (_| || |   \__ \|  __/| |
+// |_|    \__,_||_|   |___/ \___||_|
+//
+
+fun isDigit(n) = 48 <= n and n <= 57
+fun isDigits(s: Str): Bool =
+  let s' = toStringOps(s)
+  let rec aux(i) =
+    if i < s'.length and isDigit of s'.charCodeAt(i) then
+      aux(i + 1)
+    else
+      i === s'.length
+  aux(0)
+isDigits("123")
+isDigits("123jump")
+isDigits("bruh")
+//│ fun isDigit: Num -> Bool
+//│ fun isDigits: (s: Str) -> Bool
+//│ Bool
+//│ res
+//│     = true
+//│ res
+//│     = false
+//│ res
+//│     = false
+
+abstract class ParseResult[out A]: Success[A] | Failure
+class Success[out A](value: A) extends ParseResult[A]
+class Failure(error: Str) extends ParseResult
+//│ abstract class ParseResult[A]: Failure | Success[A]
+//│ class Success[A](value: A) extends ParseResult
+//│ class Failure(error: Str) extends ParseResult
+
+// Notes
+// =====
+// Sometimes, the precedence of comma is less than `of`.
+// For example, in `[Success of DataList of reverse of acc, tail]`.
+fun parseExpr(tokens: List[Str]): [ParseResult[Data], List[Str]] =
+  if tokens is
+    Cons("(", tail) then parseList(tail)
+    Cons(")", _) then [Failure("Unmatched closing parenthesis."), tokens]
+    Cons(token, tail) and
+      isDigits(token) then [Success(Literal(IntLit(parseInt(token, 10)))), tail]
+      else [Success(Symbol(token)), tail]
+    Nil then [Failure("Unexpected end of input, expect either `)` or more tokens."), Nil]
+fun parseList(tokens: List[Str]): [ParseResult[DataList], List[Str]] =
+  let rec collect(acc, ts) = if ts is
+    Cons(")", tail) then [(Success of DataList of reverse of acc), tail]
+    Cons and parseExpr(ts) is
+      [Success(data), rest] then collect(data :: acc, rest)
+      [Failure(error), rest] then [Failure(error), rest]
+    Nil then [Failure("Unexpected end of input, expect either `)` or more tokens."), Nil]
+  collect(Nil, tokens)
+//│ fun parseExpr: (tokens: List[Str]) -> [ParseResult[Data], List[Str]]
+//│ fun parseList: (tokens: List[Str]) -> [ParseResult[DataList], List[Str]]
+
+fun showParse(source: Str): Str =
+  if parseExpr(tokenize(source)) is
+    [Success(data), _] then "Ok: " ++ showData(data)
+    [Failure(error), _] then "Error: " ++ error
+//│ fun showParse: (source: Str) -> Str
+
+showParse("(cons 1 nil)")
+showParse("(cons 1 (cons 2 nil))")
+showParse("(cons 1 (cons 2 (cons 3 nil)))")
+showParse("(+ 1 2)")
+showParse("(car (cons 1 nil))")
+//│ Str
+//│ res
+//│     = 'Ok: (cons, 1, nil)'
+//│ res
+//│     = 'Ok: (cons, 1, (cons, 2, nil))'
+//│ res
+//│     = 'Ok: (cons, 1, (cons, 2, (cons, 3, nil)))'
+//│ res
+//│     = 'Ok: (+, 1, 2)'
+//│ res
+//│     = 'Ok: (car, (cons, 1, nil))'
+
+//  _____
+// | ____| _ __ __   __
+// |  _|  | '_ \\ \ / /
+// | |___ | | | |\ V /
+// |_____||_| |_| \_/
+//
+
+// As of the time I wrote this code, MLscript did not yet support term
+// refinement, so I used lambda expression to implement `Env` first.
+type Env[T] = Str -> T
+let emptyEnv: Str -> nothing = _ => error
+// The lookup function becomes useless because we can just call the `Env`.
+fun lookup(env, name: Str): 'A = env(name)
+//│ type Env[T] = Str -> T
+//│ let emptyEnv: Str -> nothing
+//│ fun lookup: forall 'A. (Str -> 'A, name: Str) -> 'A
+//│ emptyEnv
+//│          = [Function: emptyEnv1]
+
+// It is tricky to write an annotation that simplifies the inferred type.
+fun (+:) extend(env, [name, expr]: [Str, 'A]) =
+  (name': Str) => if name' === name then expr else env(name')
+//│ fun (+:) extend: forall 'A. (Str -> 'A, [Str, 'A]) -> (name': Str) -> 'A
+
+fun extendRec(env, name: Str, expr: (Str -> 'A) -> 'A) =
+  let rec env'(name': Str): 'A = if name' === name then expr(env') else env(name')
+  env'
+//│ fun extendRec: forall 'A. (Str -> 'A, name: Str, expr: (Str -> 'A) -> 'A) -> (name': Str) -> 'A
+
+fun extendParameters(env: Str -> 'A, ps: List[Str], vs: List['A]) =
+  if [ps, vs] is
+    [Nil, Nil] then env
+    [Cons(p, ps'), Cons(v, vs')] then extendParameters(extend(env, [p, v]), ps', vs')
+    else error
+//│ fun extendParameters: forall 'A. (env: Str -> 'A, ps: List[Str], vs: List['A]) -> Str -> 'A
+
+fun (++:) extendEntries(env, ps: List[[Str, 'A]]) =
+  if ps is
+    Nil then env
+    Cons(p, ps') then extendEntries(extend(env, p), ps')
+    else error
+//│ fun (++:) extendEntries: forall 'A 'a. (Str -> 'A & 'a, ps: List[[Str, 'A]]) -> ((name': Str) -> 'A | 'a)
+
+let intEnv1 = extend(emptyEnv, ["one", 1])
+let intEnv2 = extend(intEnv1, ["two", 2])
+let intEnv3 = extend(intEnv2, ["three", 3])
+//│ let intEnv1: (name': Str) -> 1
+//│ let intEnv2: (name': Str) -> (1 | 2)
+//│ let intEnv3: (name': Str) -> (1 | 2 | 3)
+//│ intEnv1
+//│         = [Function (anonymous)]
+//│ intEnv2
+//│         = [Function (anonymous)]
+//│ intEnv3
+//│         = [Function (anonymous)]
+
+// Make a tuple to save some lines.
+[intEnv1("one"), intEnv2("one"), intEnv3("one"), intEnv2("two"), intEnv3("two"), intEnv3("three")]
+//│ [1, 1 | 2, 1 | 2 | 3, 1 | 2, 1 | 2 | 3, 1 | 2 | 3]
+//│ res
+//│     = [ 1, 1, 1, 2, 2, 3 ]
+
+:re
+intEnv1("two")
+intEnv2("three")
+intEnv3("bruh")
+//│ 1 | 2 | 3
+//│ res
+//│ Runtime error:
+//│   Error: an error was thrown
+//│ res
+//│ Runtime error:
+//│   Error: an error was thrown
+//│ res
+//│ Runtime error:
+//│   Error: an error was thrown
+
+let intEnv6 = intEnv3 ++: (["four", 4] :: ["five", 5] :: ["six", 6] :: Nil)
+//│ let intEnv6: (name': Str) -> (1 | 2 | 3 | 4 | 5 | 6)
+//│ intEnv6
+//│         = [Function (anonymous)]
+
+[intEnv6("one"), intEnv6("two"), intEnv6("three"), intEnv6("four"), intEnv6("five"), intEnv6("six")]
+//│ [1 | 2 | 3 | 4 | 5 | 6, 1 | 2 | 3 | 4 | 5 | 6, 1 | 2 | 3 | 4 | 5 | 6, 1 | 2 | 3 | 4 | 5 | 6, 1 | 2 | 3 | 4 | 5 | 6, 1 | 2 | 3 | 4 | 5 | 6]
+//│ res
+//│     = [ 1, 2, 3, 4, 5, 6 ]
+
+:re
+intEnv6("seven")
+//│ 1 | 2 | 3 | 4 | 5 | 6
+//│ res
+//│ Runtime error:
+//│   Error: an error was thrown
+
+fun builtinEq(args: List[Data]): Data = if args is
+  Cons(x, Cons(y, Nil)) and
+    x =#= y then Literal(IntLit(1))
+    else Literal(IntLit(0))
+  else error
+fun builtinAdd(args: List[Data]): Data = if args is
+  Cons(Literal(IntLit(x)), Cons(Literal(IntLit(y)), Nil)) then Literal(IntLit(x + y))
+  else error
+fun builtinSub(args: List[Data]): Data = if args is
+  Cons(Literal(IntLit(x)), Cons(Literal(IntLit(y)), Nil)) then Literal(IntLit(x - y))
+  else error
+fun builtinMul(args: List[Data]): Data = if args is
+  Cons(Literal(IntLit(x)), Cons(Literal(IntLit(y)), Nil)) then Literal(IntLit(x * y))
+  else error
+let builtinNil = DataList(Nil)
+fun builtinCons(args: List[Data]): Data = if args is
+  Cons(x, Cons(DataList(xs), Nil)) then DataList(x :: xs)
+  else error
+fun builtinCar(args: List[Data]): Data = if args is
+  Cons(DataList(Cons(x, _)), Nil) then x
+  else error
+fun builtinCdr(args: List[Data]): Data = if args is
+  Cons(DataList(Cons(_, xs)), Nil) then DataList(xs)
+  else error
+fun builtinNull(args: List[Data]): Data = if args is
+  Cons(DataList(Nil), Nil) then Literal(IntLit(1))
+  else Literal(IntLit(0))
+//│ fun builtinEq: (args: List[Data]) -> Data
+//│ fun builtinAdd: (args: List[Data]) -> Data
+//│ fun builtinSub: (args: List[Data]) -> Data
+//│ fun builtinMul: (args: List[Data]) -> Data
+//│ let builtinNil: DataList
+//│ fun builtinCons: (args: List[Data]) -> Data
+//│ fun builtinCar: (args: List[Data]) -> Data
+//│ fun builtinCdr: (args: List[Data]) -> Data
+//│ fun builtinNull: (args: List[Data]) -> Data
+//│ builtinNil
+//│            = DataList {}
+
+let globalEnv = emptyEnv ++: (
+  ["eq", Literal(Lambda(builtinEq))] :: ["+", Literal(Lambda(builtinAdd))] ::
+    ["-", Literal(Lambda(builtinSub))] :: ["*", Literal(Lambda(builtinMul))] ::
+      ["nil", builtinNil] :: ["cons", Literal(Lambda(builtinCons))] ::
+        ["car", Literal(Lambda(builtinCar))] :: ["cdr", Literal(Lambda(builtinCdr))] ::
+          ["null", Literal(Lambda(builtinNull))] :: Nil)
+//│ let globalEnv: (name': Str) -> (DataList | Literal)
+//│ globalEnv
+//│           = [Function (anonymous)]
+
+fun toName(x: Data): Str = if x is Symbol(s) then s else error
+//│ fun toName: (x: Data) -> Str
+
+fun asList(x: Data): List[Data] = if x is DataList(ys) then ys else error
+//│ fun asList: (x: Data) -> List[Data]
+
+fun mkLambda(ps: List[Str], body: Data, env: Str -> Data) =
+  Literal(Lambda(args => eval(body, extendParameters(env, ps, args))))
+fun eval(x: Data, env: Str -> Data): Data = if x is
+  Literal(StrLit(x)) then Literal(StrLit(x))
+  Literal(IntLit(x)) then Literal(IntLit(x))
+  Symbol(name) then env(name)
+  DataList(Cons(Symbol("val"), tail)) and tail is
+    Cons(param, Cons(expr, Cons(rest, Nil))) then
+      eval(rest, env +: [toName(param), eval(expr, env)])
+    else error
+  DataList(Cons(Symbol("def"), Cons(param, Cons(body, Cons(rest, Nil))))) then
+    let env' = extendRec of env, toName(param), (env => eval(body, env))
+    eval(rest, env')
+  DataList(Cons(Symbol("if"), Cons(cond, Cons(thenPart, Cons(elsePart, Nil))))) and
+    eval(cond, env) is Literal(IntLit(0)) then eval(elsePart, env)
+    else eval(thenPart, env)
+  DataList(Cons(Symbol("quote"), Cons(y, Nil))) then y
+  DataList(Cons(Symbol("lambda"), Cons(params, Cons(body, Nil)))) then
+    mkLambda(map(toName, asList(params)), body, env)
+  DataList(Cons(operator, operands)) and eval(operator, env) is
+    Literal(Lambda(f)) then
+      f of map((x) => eval(x, env), operands)
+    else error // application of a non-function
+  else error // unrecognized program
+//│ fun mkLambda: (ps: List[Str], body: Data, env: Str -> Data) -> Literal
+//│ fun eval: (x: Data, env: Str -> Data) -> Data
+
+fun showEval(source: Str): Str =
+  if parseExpr(tokenize(source)) is
+    [Success(data), _] then "Ok: " ++ showData of eval(data, globalEnv)
+    [Failure(error), _] then "Error: " ++ error
+//│ fun showEval: (source: Str) -> Str
+
+showEval("1")
+showEval("(+ 1 2)")
+showEval("(val x 7 (val y 6 (* x y)))")
+showEval("(quote x)")
+showEval("(cons 1 nil)")
+showEval("(car (cons 1 nil))")
+showEval("(null 0)")
+showEval("(null nil)")
+showEval("(def id (lambda (x) x) (id 42))")
+//│ Str
+//│ res
+//│     = 'Ok: 1'
+//│ res
+//│     = 'Ok: 3'
+//│ res
+//│     = 'Ok: 42'
+//│ res
+//│     = 'Ok: x'
+//│ res
+//│     = 'Ok: (1)'
+//│ res
+//│     = 'Ok: 1'
+//│ res
+//│     = 'Ok: 0'
+//│ res
+//│     = 'Ok: 1'
+//│ res
+//│     = 'Ok: 42'
+
+showEval("(def fact (lambda (n) (if (eq n 0) 1 (* n (fact (- n 1))))) (fact 5))")
+showEval("(def fib (lambda (n) (if (eq n 0) 0 (if (eq n 1) 1 (+ (fib (- n 1)) (fib (- n 2)))))) (fib 10))")
+showEval("(def sum (lambda (n) (if (eq n 0) 0 (+ n (sum (- n 1))))) (sum 50))")
+showEval("(def ack (lambda (m n) (if (eq m 0) (+ n 1) (if (eq n 0) (ack (- m 1) 1) (ack (- m 1) (ack m (- n 1)))))) (ack 3 2))")
+//│ Str
+//│ res
+//│     = 'Ok: 120'
+//│ res
+//│     = 'Ok: 55'
+//│ res
+//│     = 'Ok: 1275'
+//│ res
+//│     = 'Ok: 29'
diff --git a/shared/src/test/diff/pretyper/ucs/examples/ListFold.mls b/shared/src/test/diff/pretyper/ucs/examples/ListFold.mls
index bde6e1b467..fccc64cc0a 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/ListFold.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/ListFold.mls
@@ -23,7 +23,7 @@ let oneTwoThree = 1 :: 2 :: 3 :: Nil
 // Note that JavaScript doesn't have tail call optimization. Therefore, this
 // implementation is still inefficient in practice.
 fun join(sep) =
-  let aux(acc, xs) =
+  let rec aux(acc, xs) =
     if xs is
       Nil then acc
       Cons(x, xs') then aux(acc ++ sep ++ toString(x), xs')
@@ -56,7 +56,7 @@ fun (:::) appendAll(xs, ys) =
 //│     = '[1, 2, 3, 4, 5, 6]'
 
 fun reverse(xs) =
-  let aux(acc, xs) =
+  let rec aux(acc, xs) =
     if xs is
       Nil then acc
       Cons(x, xs') then aux(x :: acc, xs')
@@ -79,12 +79,12 @@ reverse(1 :: 2 :: 3 :: Nil) |> showList
 //
 
 fun foldLeft(f)(z) =
-  let aux(acc, xs) =
+  let rec aux(acc, xs) =
     if xs is
       Nil then acc
       Cons(x, xs') then aux(f(acc, x), xs')
   (xs) => aux(z, xs)
-//│ fun foldLeft: forall 'a 'b 'c. (('a, 'b) -> ('a & 'c)) -> ('a & 'c) -> (Cons['b] | Nil) -> 'c
+//│ fun foldLeft: forall 'a 'b. (('a, 'b) -> 'a) -> 'a -> (Cons['b] | Nil) -> 'a
 
 let sum = foldLeft((acc, x) => acc + x)(0)
 sum(Nil)
@@ -143,7 +143,7 @@ reverse'(1 :: 2 :: 3 :: Nil) |> showList
 //                            |___/
 
 fun foldRight(f)(z) =
-  let aux(acc, xs) =
+  let rec aux(acc, xs) =
     if xs is
       Nil then acc
       Cons(x, xs') then f(x, aux(acc, xs'))
diff --git a/shared/src/test/diff/pretyper/ucs/examples/Option.mls b/shared/src/test/diff/pretyper/ucs/examples/Option.mls
index 7075685566..c7f9c94203 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/Option.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/Option.mls
@@ -20,7 +20,7 @@ module None extends Option[nothing] {
 //│   fun filter: (p: T -> Bool) -> Option[T]
 //│ }
 //│ class Some[T](value: T) extends Option {
-//│   fun filter: (T -> Bool) -> (None | Some[T])
+//│   fun filter: (T -> Object) -> (None | Some[T])
 //│ }
 //│ module None extends Option {
 //│   fun filter: anything -> None
diff --git a/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls b/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls
index 0497d87388..1cad991c1b 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls
@@ -15,13 +15,13 @@ fun (:::) appendAll(xs: List['A], ys: List['A]): List['A] =
     Cons(x, xs') then x :: (xs' ::: ys)
 fun (:+) append(xs, x): List['A] = xs ::: (x :: Nil)
 fun reverse(xs) =
-  let aux(acc, xs) =
+  let rec aux(acc, xs) =
     if xs is
       Nil then acc
       Cons(x, xs') then aux(x :: acc, xs')
   aux(Nil, xs)
 fun join(sep) =
-  let aux(acc, xs) =
+  let rec aux(acc, xs) =
     if xs is
       Nil then acc
       Cons(x, xs') then aux(acc ++ sep ++ toString(x), xs')
@@ -31,7 +31,7 @@ fun join(sep) =
       Nil then ""
 fun showList(xs) = "[" ++ join(", ")(xs) ++ "]"
 fun foldLeft(f)(z) =
-  let aux(acc, xs) =
+  let rec aux(acc, xs) =
     if xs is
       Nil then acc
       Cons(x, xs') then aux(f(acc, x), xs')
@@ -50,19 +50,23 @@ fun showListList(xs) = "[" ++ join(", ")(map(showList, xs)) ++ "]"
 //│ fun reverse: (Cons[anything] | Nil) -> (Cons[nothing] | Nil)
 //│ fun join: Str -> (Cons[anything] | Nil) -> Str
 //│ fun showList: (Cons[anything] | Nil) -> Str
-//│ fun foldLeft: forall 'a 'b 'c. (('a, 'b) -> ('a & 'c)) -> ('a & 'c) -> (Cons['b] | Nil) -> 'c
-//│ fun map: forall 'd 'T2. ('d -> 'T2, Cons['d] | Nil) -> (Cons['T2] | Nil)
+//│ fun foldLeft: forall 'a 'b. (('a, 'b) -> 'a) -> 'a -> (Cons['b] | Nil) -> 'a
+//│ fun map: forall 'c 'T2. ('c -> 'T2, Cons['c] | Nil) -> (Cons['T2] | Nil)
 //│ fun showListList: (Cons[Cons[anything] | Nil] | Nil) -> Str
 
 fun insertAllPositions(z) =
-  let aux(prev, acc, xs) =
+  let rec aux(prev, acc, xs) =
     if xs is
       Nil then ((prev :+ z) :: acc) |> reverse
       Cons(head, tail) then
         let nu = ((prev :+ z) ::: xs)
         aux(prev :+ head, nu :: acc, tail)
   xs => aux(Nil, Nil, xs)
-//│ fun insertAllPositions: forall 'a. 'a -> (forall 'A. (Cons['A] | Nil) -> (Cons[List['a | 'A]] & {Cons#T <: List['a | 'A]} | Nil))
+//│ fun insertAllPositions: forall 'a. 'a -> (forall 'A 'A0. (Cons['A & 'A0] | Nil) -> (Cons[List['A0 | 'a]] & {Cons#T <: List['A0 | 'a]} | Nil))
+//│   where
+//│     'A <: 'A0
+//│     'A0 :> 'a
+//│         <: 'A
 
 insertAllPositions(0)(1 :: 2 :: 3 :: Nil) |> showListList
 //│ Str
@@ -74,7 +78,7 @@ fun permutations(xs) =
     Nil then Nil
     Cons(x, Nil) then (x :: Nil) :: Nil
     Cons(x, xs') then foldLeft((acc, ys) => acc ::: insertAllPositions(x)(ys))(Nil)(permutations(xs'))
-//│ fun permutations: forall 'T 'A. (Cons['T] | Nil) -> (Cons[Cons['T]] | List[List['T & 'A]] | Nil)
+//│ fun permutations: forall 'T 'A. (Cons['T] | Nil) -> (Cons[Cons['T]] | List[List['A]] | Nil)
 //│   where
 //│     'T <: 'A
 //│     'A := 'T
diff --git a/shared/src/test/diff/pretyper/ucs/examples/ULC.mls b/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
index cc1c507f49..357d5811d8 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
@@ -64,7 +64,7 @@ fun (::) cons(head, tail) = Cons(head, tail)
 //│ fun (::) cons: forall 'A. ('A, List['A]) -> Cons['A]
 
 fun join(sep) =
-  let aux(acc, xs) =
+  let rec aux(acc, xs) =
     if xs is
       Nil then acc
       Cons(x, xs') then aux(acc ++ sep ++ toString(x), xs')
@@ -128,7 +128,7 @@ exclude("x" :: "y" :: "z" :: Nil, "w") |> showList
 //│     = '[x, y, z]'
 
 fun reverse(xs: List['B]): List['B] =
-  let aux(acc: List['B], ys: List['B]): List['B] =
+  let rec aux(acc: List['B], ys: List['B]): List['B] =
     if ys is
       Nil then acc
       Cons(y, ys') then aux(Cons(y, acc), ys')
@@ -321,7 +321,7 @@ fun search(f: 'A -> Option['B], xs: List['A]): Option['B] =
 //│     'B <: 'A0
 
 // The removal of type annotations will cause running out of fuel.
-fun combinations(n: Int, acc: List['A], alphabet: List['A], xs: List[Str]): Option[Str] =
+fun combinations(n: Int, acc: List['T], alphabet: List['T], xs: List[Str]): Option[Str] =
   if
     n <= 0 and
       let x = reverse(acc) |> join("")
@@ -329,11 +329,11 @@ fun combinations(n: Int, acc: List['A], alphabet: List['A], xs: List[Str]): Opti
       else Some(x)
     else
       search((x) => combinations(n - 1, x :: acc, alphabet, xs), alphabet)
-//│ fun combinations: forall 'A 'A0 'A1. (n: Int, acc: List['A], alphabet: List['A1], xs: List[Str]) -> Option[Str]
+//│ fun combinations: forall 'T 'A 'T0. (n: Int, acc: List['T], alphabet: List['T0], xs: List[Str]) -> Option[Str]
 //│   where
-//│     'A1 <: 'A & 'A0
-//│     'A :> 'A0
-//│     'A0 := 'A
+//│     'T0 <: 'T & 'A
+//│     'T :> 'A
+//│     'A := 'T
 
 combinations(1, Nil, 1 :: 2 :: 3 :: Nil, Nil) |> showOption
 combinations(2, Nil, 1 :: 2 :: 3 :: Nil, Nil) |> showOption
@@ -357,7 +357,7 @@ combinations(3, Nil, 1 :: 2 :: 3 :: Nil, "111" :: "112" :: "113" :: "121" :: Nil
 
 fun freshVar(t: Term): Str =
   let fvs = freeVars(t)
-  let aux(n: Int): Str =
+  let rec aux(n: Int): Str =
     if combinations(n, Nil, alphabet, fvs) is
       Some(x) then x
       None then aux(n + 1)
@@ -484,7 +484,7 @@ toString of stepByValue of App(Abs(Var("x"), Var("x")), Abs(Var("y"), Var("y")))
 //
 
 fun eval(step) =
-  let aux(t) =
+  let rec aux(t) =
     if step(t) is result and result is
       Stepped(_, t') then aux(t')
       else result
diff --git a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
index 990af73cfe..4bec2657a6 100644
--- a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
+++ b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
@@ -10,7 +10,7 @@ class Pair[A, B](x: A, y: B)
 //│ class Pair[A, B](x: A, y: B)
 
 fun f(x) = if x is Some(1) then true else false
-//│ fun f: (Object & ~#Some | Some[Num]) -> Bool
+//│ fun f: (Object & ~#Some | Some[Eql[1]]) -> Bool
 
 fun g(x) = if x then 1 else 2
 //│ fun g: Bool -> (1 | 2)

From f52701cd5ade1ff96e44bf7b0db17d38e5f4aab9 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Fri, 29 Dec 2023 16:14:53 +0800
Subject: [PATCH 035/147] Improve string type definitions in the
 LispInterpreter example

---
 shared/src/test/diff/mlscript/Repro.mls       |  7 +-
 .../pretyper/ucs/examples/LispInterpreter.mls | 83 ++++++++++++-------
 2 files changed, 56 insertions(+), 34 deletions(-)

diff --git a/shared/src/test/diff/mlscript/Repro.mls b/shared/src/test/diff/mlscript/Repro.mls
index 169d1c0b99..bf3a52e7ca 100644
--- a/shared/src/test/diff/mlscript/Repro.mls
+++ b/shared/src/test/diff/mlscript/Repro.mls
@@ -1,6 +1 @@
-:NewDefs
-
-fun test() =
-  let rec aux(n) = if n == 0 then 0 else aux(n - 1) + n
-  aux(100)
-//│ fun test: () -> Int
+:PreTyper
diff --git a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
index 8e0d2e29c0..2dc1c10606 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
@@ -12,11 +12,52 @@ fun (=/=) objectNotEqual(x, y) = not(x =:= y)
 //│ objectEqual
 //│             = [Function: is]
 
+type NStr = Str & {
+  length: Int,
+  at: Int -> NStr,
+  charAt: Int -> NStr,
+  charCodeAt: Int -> Int,
+  slice: (Int, Int) -> NStr,
+  startsWith: Str -> Bool,
+  endsWith: Str -> Bool,
+  split: Str -> Array[NStr],
+  trim: () -> NStr,
+  trimStart: () -> NStr,
+  trimEnd: () -> NStr,
+  padStart: (Int, Str) -> NStr,
+  padEnd: (Int, Str) -> NStr,
+  repeat: Int -> NStr,
+  indexOf: Str -> Int,
+  lastIndexOf: Str -> Int,
+  includes: Str -> Bool,
+}
+declare fun String: anything -> NStr
+fun (++) strcat(a, b) = String of concat(a)(b)
+//│ type NStr = Str & {
+//│   at: Int -> NStr,
+//│   charAt: Int -> NStr,
+//│   charCodeAt: Int -> Int,
+//│   endsWith: Str -> Bool,
+//│   includes: Str -> Bool,
+//│   indexOf: Str -> Int,
+//│   lastIndexOf: Str -> Int,
+//│   length: Int,
+//│   padEnd: (Int, Str) -> NStr,
+//│   padStart: (Int, Str) -> NStr,
+//│   repeat: Int -> NStr,
+//│   slice: (Int, Int) -> NStr,
+//│   split: Str -> Array[NStr],
+//│   startsWith: Str -> Bool,
+//│   trim: () -> NStr,
+//│   trimEnd: () -> NStr,
+//│   trimStart: () -> NStr
+//│ }
+//│ fun (++) strcat: (Str, Str) -> NStr
+//│ fun String: anything -> NStr
+
 fun (!==) notEqual(x, y) = not(x === y)
-fun (++) concatOp(a, b) = concat(a)(b)
 declare fun parseInt: (Str, Int) -> Int
 //│ fun (!==) notEqual: forall 'a. (Eql['a], 'a) -> Bool
-//│ fun (++) concatOp: (Str, Str) -> Str
 //│ fun parseInt: (Str, Int) -> Int
 
 // `List` and its utilities:
@@ -48,8 +89,8 @@ module None extends Option
 //│ module Nil extends List
 //│ fun (::) cons: forall 'T. (head: 'T, tail: List['T]) -> List['T]
 //│ fun reverse: forall 'A. (l: List['A]) -> List['A]
-//│ fun join: (sep: Str, xs: List[anything]) -> Str
-//│ fun showList: (xs: List[anything]) -> Str
+//│ fun join: (sep: Str, xs: List[anything]) -> (Str | NStr)
+//│ fun showList: (xs: List[anything]) -> NStr
 //│ fun map: forall 'D 'T0. (f: 'D -> 'T0, xs: List['D]) -> List['T0]
 //│ fun equalList: forall 'A0. (xs: List['A0], ys: List['A0], equal: ('A0, 'A0) -> Bool) -> Bool
 //│ abstract class Option[A]: None | Some[A]
@@ -130,29 +171,15 @@ fun showData(d: Data): Str = if d is
 //   |_| \___/ |_|\_\\___||_| |_||_|/___|\___||_|
 //
 
-type StringOps = {
-  length: Int,
-  charAt: Int => Str,
-  charCodeAt: Int => Int,
-  slice: Int => Str
-}
-declare fun String: nothing
-let toStringOps: anything => StringOps = String
-//│ type StringOps = {charAt: Int -> Str, charCodeAt: Int -> Int, length: Int, slice: Int -> Str}
-//│ let toStringOps: anything -> StringOps
-//│ fun String: nothing
-//│ toStringOps
-//│             = [Function: String]
-
-fun skipBlank(s: StringOps, i: Int): Int =
+fun skipBlank(s: NStr, i: Int): Int =
   if
     i < 0 then skipBlank(s, 0)
     i >= s.length then s.length
     s.charCodeAt(i) == 32 then skipBlank(s, i + 1)
     else i
-//│ fun skipBlank: (s: StringOps, i: Int) -> Int
+//│ fun skipBlank: (s: NStr, i: Int) -> Int
 
-fun scanWhile(s: StringOps, i: Int, p: Str -> Bool): Option[[Str, Int]] =
+fun scanWhile(s: NStr, i: Int, p: Str -> Bool): Option[[Str, Int]] =
   let rec aux(acc, i) =
     if i < s.length and s.charAt(i) is ch and p of ch then
       aux(acc ++ ch, i + 1)
@@ -161,21 +188,21 @@ fun scanWhile(s: StringOps, i: Int, p: Str -> Bool): Option[[Str, Int]] =
   if aux("", i) is
     ["", _] then None
     [acc, i] then Some([acc, i])
-//│ fun scanWhile: (s: StringOps, i: Int, p: Str -> Bool) -> Option[[Str, Int]]
+//│ fun scanWhile: (s: NStr, i: Int, p: Str -> Bool) -> Option[[Str, Int]]
 
-fun isDelimiter(ch) = (ch !== " ") && (ch !== "(") && (ch !== ")")
+fun isDelimiter(ch) = ch !== " " and ch !== "(" and ch !== ")"
 //│ fun isDelimiter: Eql[" " | "(" | ")"] -> Bool
 
-fun nextToken(s: StringOps, i: Int): Option[[Str, Int]] =
+fun nextToken(s: NStr, i: Int): Option[[Str, Int]] =
   let i' = skipBlank(s, i)
   if s.charAt(i') is
     "(" then Some(["(", i' + 1])
     ")" then Some([")", i' + 1])
     else scanWhile(s, i', isDelimiter)
-//│ fun nextToken: (s: StringOps, i: Int) -> Option[[Str, Int]]
+//│ fun nextToken: (s: NStr, i: Int) -> Option[[Str, Int]]
 
 fun tokenize(s: Str): List[Str] =
-  let s' = toStringOps(s)
+  let s' = String(s)
   let rec aux(acc, i) =
     if nextToken(s', i) is
       None then reverse(acc)
@@ -188,7 +215,7 @@ showList of tokenize("12")
 showList of tokenize("x")
 showList of tokenize("(quote (cons 1 nil))")
 showList of tokenize("(+ 1 2)")
-//│ Str
+//│ NStr
 //│ res
 //│     = '[]'
 //│ res
@@ -209,7 +236,7 @@ showList of tokenize("(+ 1 2)")
 
 fun isDigit(n) = 48 <= n and n <= 57
 fun isDigits(s: Str): Bool =
-  let s' = toStringOps(s)
+  let s' = String(s)
   let rec aux(i) =
     if i < s'.length and isDigit of s'.charCodeAt(i) then
       aux(i + 1)

From 014923ca9476e29f996d561a18757e5fd40f34da Mon Sep 17 00:00:00 2001
From: Luyu Cheng <luyu.cheng@connect.ust.hk>
Date: Fri, 29 Dec 2023 21:17:03 +0800
Subject: [PATCH 036/147] Fix a typo in a comment

Co-authored-by: Lionel Parreaux <lionel.parreaux@gmail.com>
---
 shared/src/main/scala/mlscript/JSBackend.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shared/src/main/scala/mlscript/JSBackend.scala b/shared/src/main/scala/mlscript/JSBackend.scala
index 75e2aa84ab..3ca226992c 100644
--- a/shared/src/main/scala/mlscript/JSBackend.scala
+++ b/shared/src/main/scala/mlscript/JSBackend.scala
@@ -1594,7 +1594,7 @@ object JSBackend {
   def isSafeInteger(value: BigInt): Boolean =
     MinimalSafeInteger <= value && value <= MaximalSafeInteger
 
-    // Temporary measurement until we adopt the new tuple index.
+  // Temporary measure until we adopt the new tuple index.
   object TupleIndex {
     def unapply(fieldName: Var): Opt[Int] = {
       val name = fieldName.name

From 4623fb8018f65c1132eaa759868218c7f5fcc08c Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 30 Dec 2023 02:33:23 +0800
Subject: [PATCH 037/147] Fix symbol duplication in code generation for new
 definition typing

Please `git cherrypick` this to a separate PR.
---
 .../src/main/scala/mlscript/JSBackend.scala   |  46 ++++----
 .../main/scala/mlscript/codegen/Scope.scala   |  30 +++--
 .../main/scala/mlscript/codegen/Symbol.scala  |  20 +++-
 .../diff/codegen/AuxiliaryConstructors.mls    |   8 +-
 .../src/test/diff/codegen/ConstructorStmt.mls |  10 +-
 shared/src/test/diff/codegen/Nested.mls       |  36 +++---
 shared/src/test/diff/codegen/New.mls          |   4 +-
 shared/src/test/diff/codegen/NewDefsBug.mls   |  72 ++++++++++++
 shared/src/test/diff/codegen/NewMatching.mls  |   2 +-
 shared/src/test/diff/codegen/NuReplHost.mls   |   4 +-
 shared/src/test/diff/codegen/SymbolicOps.mls  |  10 +-
 shared/src/test/diff/mlscript/Sequence.mls    |   2 +-
 shared/src/test/diff/nu/ArrayProg.mls         |   2 +-
 shared/src/test/diff/nu/CtorSubtraction.mls   |   4 +-
 shared/src/test/diff/nu/FlatIndentFuns.mls    |   4 +-
 shared/src/test/diff/nu/FlatMonads_repro.mls  |   2 +-
 shared/src/test/diff/nu/HeungTung.mls         |   2 +-
 shared/src/test/diff/nu/LamPatterns.mls       |   4 +-
 shared/src/test/diff/nu/LocalLets.mls         |   2 +-
 shared/src/test/diff/nu/MIscPoly.mls          |   2 +-
 shared/src/test/diff/nu/Misc.mls              |  14 +--
 shared/src/test/diff/nu/NamedArgs.mls         |  10 +-
 shared/src/test/diff/nu/NestedRecords.mls     |   2 +-
 shared/src/test/diff/nu/NewNew.mls            |   2 +-
 shared/src/test/diff/nu/Res.mls               |   2 +-
 shared/src/test/diff/nu/Vals.mls              |   2 +-
 .../pretyper/ucs/examples/LispInterpreter.mls |   2 +-
 .../diff/pretyper/ucs/examples/Option.mls     | 106 ++++++++++++++++--
 28 files changed, 298 insertions(+), 108 deletions(-)
 create mode 100644 shared/src/test/diff/codegen/NewDefsBug.mls

diff --git a/shared/src/main/scala/mlscript/JSBackend.scala b/shared/src/main/scala/mlscript/JSBackend.scala
index 3ca226992c..34b26f4678 100644
--- a/shared/src/main/scala/mlscript/JSBackend.scala
+++ b/shared/src/main/scala/mlscript/JSBackend.scala
@@ -10,6 +10,15 @@ import scala.util.chaining._
 
 abstract class JSBackend(allowUnresolvedSymbols: Bool) {
   def oldDefs: Bool
+
+  protected implicit class TermOps(term: Term) {
+    def isLam: Bool = term match {
+      case _: Lam => true
+      case Bra(false, inner) => inner.isLam
+      case Asc(inner, _) => inner.isLam
+      case _ => false
+    }
+  }
   
   /**
     * The root scope of the program.
@@ -240,7 +249,7 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
           case (t: Term, index)                                  => JSExprStmt(translateTerm(t)(blkScope))
           case (NuFunDef(isLetRec, Var(nme), symNme, _, L(rhs)), _) =>
             val symb = symNme.map(_.name)
-            val isLocalFunction = isLetRec.isEmpty || (rhs match { case _: Lam => true; case _ => false })
+            val isLocalFunction = isLetRec.isEmpty || rhs.isLam
             val pat = blkScope.declareValue(nme, isLetRec, isLocalFunction, symb)
             JSLetDecl(Ls(pat.runtimeName -> S(translateTerm(rhs)(blkScope))))
           case (nt: NuTypeDef, _) => translateLocalNewType(nt)(blkScope)
@@ -1170,18 +1179,17 @@ class JSWebBackend extends JSBackend(allowUnresolvedSymbols = true) {
         // ```
         .concat(otherStmts.flatMap {
           case Def(recursive, Var(name), L(body), isByname) =>
-            val isLam = body.isInstanceOf[Lam]
             val (originalExpr, sym) = if (recursive) {
               val isByvalueRecIn = if (isByname) None else Some(true)
-              val sym = topLevelScope.declareValue(name, isByvalueRecIn, isLam, N)
+              val sym = topLevelScope.declareValue(name, isByvalueRecIn, body.isLam, N)
               val translated = translateTerm(body)(topLevelScope)
               topLevelScope.unregisterSymbol(sym)
               val isByvalueRecOut = if (isByname) None else Some(false)
-              (translated, topLevelScope.declareValue(name, isByvalueRecOut, isLam, N))
+              (translated, topLevelScope.declareValue(name, isByvalueRecOut, body.isLam, N))
             } else {
               val translatedBody = translateTerm(body)(topLevelScope)
               val isByvalueRec = if (isByname) None else Some(false)
-              (translatedBody, topLevelScope.declareValue(name, isByvalueRec, isLam, N))
+              (translatedBody, topLevelScope.declareValue(name, isByvalueRec, body.isLam, N))
             }
             val translatedBody = if (sym.isByvalueRec.isEmpty && !sym.isLam) JSArrowFn(Nil, L(originalExpr)) else originalExpr
             topLevelScope.tempVars `with` JSConstDecl(sym.runtimeName, translatedBody) ::
@@ -1231,22 +1239,21 @@ class JSWebBackend extends JSBackend(allowUnresolvedSymbols = true) {
           case NuFunDef(isLetRec, nme @ Var(name), symNme, tys, rhs @ L(body)) =>
             val recursive = isLetRec.getOrElse(true)
             val isByname = isLetRec.isEmpty
-            val bodyIsLam = body match { case _: Lam => true case _ => false }
             val symb = symNme.map(_.name)
             val (originalExpr, sym) = (if (recursive) {
               val isByvalueRecIn = if (isByname) None else Some(true)
               
               // TODO Improve: (Lionel) what?!
-              val sym = topLevelScope.declareValue(name, isByvalueRecIn, bodyIsLam, N)
+              val sym = topLevelScope.declareValue(name, isByvalueRecIn, body.isLam, N)
               val translated = translateTerm(body)(topLevelScope)
               topLevelScope.unregisterSymbol(sym)
               
               val isByvalueRecOut = if (isByname) None else Some(false)
-              (translated, topLevelScope.declareValue(name, isByvalueRecOut, bodyIsLam, symb))
+              (translated, topLevelScope.declareValue(name, isByvalueRecOut, body.isLam, symb))
             } else {
               val translated = translateTerm(body)(topLevelScope)
               val isByvalueRec = if (isByname) None else Some(false)
-              (translated, topLevelScope.declareValue(name, isByvalueRec, bodyIsLam, symb))
+              (translated, topLevelScope.declareValue(name, isByvalueRec, body.isLam, symb))
             })
             val translatedBody = if (sym.isByvalueRec.isEmpty && !sym.isLam) JSArrowFn(Nil, L(originalExpr)) else originalExpr
             resultNames += sym.runtimeName
@@ -1324,15 +1331,14 @@ abstract class JSTestBackend extends JSBackend(allowUnresolvedSymbols = false) {
     // Generate statements.
     val queries = otherStmts.map {
       case Def(recursive, Var(name), L(body), isByname) =>
-        val bodyIsLam = body match { case _: Lam => true case _ => false }
         (if (recursive) {
           val isByvalueRecIn = if (isByname) None else Some(true)
-          val sym = scope.declareValue(name, isByvalueRecIn, bodyIsLam, N)
+          val sym = scope.declareValue(name, isByvalueRecIn, body.isLam, N)
           try {
             val translated = translateTerm(body)
             scope.unregisterSymbol(sym)
             val isByvalueRecOut = if (isByname) None else Some(false)
-            R((translated, scope.declareValue(name, isByvalueRecOut, bodyIsLam, N)))
+            R((translated, scope.declareValue(name, isByvalueRecOut, body.isLam, N)))
           } catch {
             case e: UnimplementedError =>
               scope.stubize(sym, e.symbol)
@@ -1340,7 +1346,7 @@ abstract class JSTestBackend extends JSBackend(allowUnresolvedSymbols = false) {
             case NonFatal(e) =>
               scope.unregisterSymbol(sym)
               val isByvalueRecOut = if (isByname) None else Some(false)
-              scope.declareValue(name, isByvalueRecOut, bodyIsLam, N)
+              scope.declareValue(name, isByvalueRecOut, body.isLam, N)
               throw e
           }
         } else {
@@ -1350,7 +1356,7 @@ abstract class JSTestBackend extends JSBackend(allowUnresolvedSymbols = false) {
               L(e.getMessage())
           }) map {
             val isByvalueRec = if (isByname) None else Some(false)
-            expr => (expr, scope.declareValue(name, isByvalueRec, bodyIsLam, N))
+            expr => (expr, scope.declareValue(name, isByvalueRec, body.isLam, N))
           }
         }) match {
           case R((originalExpr, sym)) =>
@@ -1408,9 +1414,8 @@ abstract class JSTestBackend extends JSBackend(allowUnresolvedSymbols = false) {
       case fd @ NuFunDef(isLetRec, Var(nme), symNme, _, L(body)) =>
         val isByname = isLetRec.isEmpty
         val isByvalueRecIn = if (isByname) None else Some(true)
-        val bodyIsLam = body match { case _: Lam => true case _ => false }
         val symb = symNme.map(_.name)
-        scope.declareValue(nme, isByvalueRecIn, bodyIsLam, symb)
+        scope.declareValue(nme, isByvalueRecIn, body.isLam, symb, true)
       case _ => ()
     }
     
@@ -1438,26 +1443,25 @@ abstract class JSTestBackend extends JSBackend(allowUnresolvedSymbols = false) {
       case NuFunDef(isLetRec, nme @ Var(name), symNme, tys, rhs @ L(body)) =>
         val recursive = isLetRec.getOrElse(true)
         val isByname = isLetRec.isEmpty
-        val bodyIsLam = body match { case _: Lam => true case _ => false }
         val symb = symNme.map(_.name)
         (if (recursive) {
           val isByvalueRecIn = if (isByname) None else Some(true)
           val sym = scope.resolveValue(name) match {
             case Some(s: ValueSymbol) => s
-            case _ => scope.declareValue(name, isByvalueRecIn, bodyIsLam, symb)
+            case _ => scope.declareValue(name, isByvalueRecIn, body.isLam, symb)
           }
           val isByvalueRecOut = if (isByname) None else Some(false)
           try {
             val translated = translateTerm(body) // TODO Improve: (Lionel) Why are the bodies translated in the SAME scope?!
             scope.unregisterSymbol(sym) // TODO Improve: (Lionel) ???
-            R((translated, scope.declareValue(name, isByvalueRecOut, bodyIsLam, symb)))
+            R((translated, scope.declareValue(name, isByvalueRecOut, body.isLam, symb)))
           } catch {
             case e: UnimplementedError =>
               scope.stubize(sym, e.symbol)
               L(e.getMessage())
             case NonFatal(e) =>
               scope.unregisterSymbol(sym) // TODO Improve: (Lionel) You should only try/catch around the part that may actually fail, and if `unregisterSymbol` should always be called, that should be done in `finally`... but the very logic of calling `unregisterSymbol` is very fishy, to say the least
-              scope.declareValue(name, isByvalueRecOut, bodyIsLam, symb)
+              scope.declareValue(name, isByvalueRecOut, body.isLam, symb)
               throw e
           }
         } else {
@@ -1467,7 +1471,7 @@ abstract class JSTestBackend extends JSBackend(allowUnresolvedSymbols = false) {
               L(e.getMessage())
           }) map {
             val isByvalueRec = if (isByname) None else Some(false)
-            expr => (expr, scope.declareValue(name, isByvalueRec, bodyIsLam, symb))
+            expr => (expr, scope.declareValue(name, isByvalueRec, body.isLam, symb))
           }
         }) match {
           case R((originalExpr, sym)) =>
diff --git a/shared/src/main/scala/mlscript/codegen/Scope.scala b/shared/src/main/scala/mlscript/codegen/Scope.scala
index 80afdc3111..68c442ca87 100644
--- a/shared/src/main/scala/mlscript/codegen/Scope.scala
+++ b/shared/src/main/scala/mlscript/codegen/Scope.scala
@@ -313,18 +313,26 @@ class Scope(val name: Str, enclosing: Opt[Scope]) {
     symbol
   }
 
-  def declareValue(lexicalName: Str, isByvalueRec: Option[Boolean], isLam: Boolean, symbolicName: Opt[Str]): ValueSymbol = {
+  def declareValue(
+      lexicalName: Str,
+      isByvalueRec: Option[Boolean],
+      isLam: Boolean,
+      symbolicName: Opt[Str],
+      /** Workaround for the first pass traversal with new definition typing. */
+      forNewDefsDryRun: Bool = false
+  ): ValueSymbol = {
     val runtimeName = lexicalValueSymbols.get(lexicalName) match {
       // If we are implementing a stub symbol and the stub symbol did not shadow any other
       // symbols, it is safe to reuse its `runtimeName`.
-      case S(sym: StubValueSymbol) if !sym.shadowing => sym.runtimeName
-      case S(sym: BuiltinSymbol) if !sym.accessed    => sym.runtimeName
-      case _                                         => allocateRuntimeName(lexicalName)
+      case S(sym: StubValueSymbol) if !sym.shadowing   => sym.runtimeName
+      case S(sym: ValueSymbol) if sym.forNewDefsDryRun => sym.runtimeName
+      case S(sym: BuiltinSymbol) if !sym.accessed      => sym.runtimeName
+      case _                                           => allocateRuntimeName(lexicalName)
     }
-    val symbol = ValueSymbol(lexicalName, runtimeName, isByvalueRec, isLam)
+    val symbol = ValueSymbol(lexicalName, runtimeName, isByvalueRec, isLam, forNewDefsDryRun)
     register(symbol)
     symbolicName.foreach { symbolicName =>
-      register(ValueSymbol(symbolicName, runtimeName, isByvalueRec, isLam))
+      register(ValueSymbol(symbolicName, runtimeName, isByvalueRec, isLam, forNewDefsDryRun))
     }
     symbol
   }
@@ -350,10 +358,16 @@ class Scope(val name: Str, enclosing: Opt[Scope]) {
       allowEscape: Bool
   ): StubValueSymbol = {
     val symbol = lexicalValueSymbols.get(lexicalName) match {
+      // If the existing symbol is a value symbol, but the value symbol is
+      // declared in the dry-run of new definition typing, we can reuse the
+      // runtime name.
+      case S(valueSymbol: ValueSymbol) if valueSymbol.forNewDefsDryRun =>
+        StubValueSymbol(lexicalName, valueSymbol.runtimeName, false, previous)
       // If a stub with the same name has been defined, use the name.
-      case S(value) => StubValueSymbol(lexicalName, value.runtimeName, true, previous)
+      case S(symbol) => StubValueSymbol(lexicalName, symbol.runtimeName, true, previous)
       // Otherwise, we will allocate a new name.
-      case N => StubValueSymbol(lexicalName, allocateRuntimeName(lexicalName), false, previous)
+      case N =>
+        StubValueSymbol(lexicalName, allocateRuntimeName(lexicalName), false, previous)
     }
     register(symbol)
     symbolicName.foreach { symbolicName =>
diff --git a/shared/src/main/scala/mlscript/codegen/Symbol.scala b/shared/src/main/scala/mlscript/codegen/Symbol.scala
index 2d844d2f70..85474c8f78 100644
--- a/shared/src/main/scala/mlscript/codegen/Symbol.scala
+++ b/shared/src/main/scala/mlscript/codegen/Symbol.scala
@@ -45,13 +45,27 @@ sealed trait NuTypeSymbol { sym: TypeSymbol =>
   def isNested: Bool = qualifier.isDefined // is nested in another class/mixin/module
 }
 
-sealed class ValueSymbol(val lexicalName: Str, val runtimeName: Str, val isByvalueRec: Option[Boolean], val isLam: Boolean) extends RuntimeSymbol {
+sealed class ValueSymbol(
+    val lexicalName: Str,
+    val runtimeName: Str,
+    val isByvalueRec: Option[Boolean],
+    val isLam: Boolean,
+    /** Workaround for the first pass traversal with new definition typing. */
+    val forNewDefsDryRun: Boolean
+) extends RuntimeSymbol {
   override def toString: Str = s"value $lexicalName"
 }
 
 object ValueSymbol {
-  def apply(lexicalName: Str, runtimeName: Str, isByvalueRec: Option[Boolean], isLam: Boolean): ValueSymbol =
-    new ValueSymbol(lexicalName, runtimeName, isByvalueRec, isLam)
+  def apply(
+      lexicalName: Str,
+      runtimeName: Str,
+      isByvalueRec: Option[Boolean],
+      isLam: Boolean,
+      /** Workaround for the first pass traversal with new definition typing. */
+      forNewDefsDryRun: Boolean = false
+  ): ValueSymbol =
+    new ValueSymbol(lexicalName, runtimeName, isByvalueRec, isLam, forNewDefsDryRun)
 }
 
 sealed case class TypeAliasSymbol(
diff --git a/shared/src/test/diff/codegen/AuxiliaryConstructors.mls b/shared/src/test/diff/codegen/AuxiliaryConstructors.mls
index 5c729795cb..3fd393ed25 100644
--- a/shared/src/test/diff/codegen/AuxiliaryConstructors.mls
+++ b/shared/src/test/diff/codegen/AuxiliaryConstructors.mls
@@ -464,11 +464,11 @@ n.ll
 //│ class TypingUnit19 {}
 //│ const typing_unit19 = new TypingUnit19;
 //│ // Query 1
-//│ globalThis.m1 = g(1);
+//│ globalThis.m = g(1);
 //│ // Query 2
-//│ globalThis.n1 = m1(2);
+//│ globalThis.n = m(2);
 //│ // Query 3
-//│ res = n1.ll;
+//│ res = n.ll;
 //│ // End of generated code
 //│ m
 //│   = [Function (anonymous)]
@@ -487,7 +487,7 @@ let mm = new M()
 //│ class TypingUnit21 {}
 //│ const typing_unit21 = new TypingUnit21;
 //│ // Query 1
-//│ globalThis.mm1 = new M.class();
+//│ globalThis.mm = new M.class();
 //│ // End of generated code
 //│ mm
 //│    = M {}
diff --git a/shared/src/test/diff/codegen/ConstructorStmt.mls b/shared/src/test/diff/codegen/ConstructorStmt.mls
index 4f769b8f32..a61301347e 100644
--- a/shared/src/test/diff/codegen/ConstructorStmt.mls
+++ b/shared/src/test/diff/codegen/ConstructorStmt.mls
@@ -105,7 +105,7 @@ let aa = A(42)
 //│ class TypingUnit5 {}
 //│ const typing_unit5 = new TypingUnit5;
 //│ // Query 1
-//│ globalThis.aa1 = A(42);
+//│ globalThis.aa = A(42);
 //│ // End of generated code
 //│ aa
 //│    = A {}
@@ -119,7 +119,7 @@ aa
 //│ class TypingUnit6 {}
 //│ const typing_unit6 = new TypingUnit6;
 //│ // Query 1
-//│ res = aa1;
+//│ res = aa;
 //│ // End of generated code
 //│ res
 //│     = A {}
@@ -131,7 +131,7 @@ let ab = A(0)
 //│ class TypingUnit7 {}
 //│ const typing_unit7 = new TypingUnit7;
 //│ // Query 1
-//│ globalThis.ab1 = A(0);
+//│ globalThis.ab = A(0);
 //│ // End of generated code
 //│ ab
 //│    = A {}
@@ -408,9 +408,9 @@ www.add(42)
 //│ class TypingUnit15 {}
 //│ const typing_unit15 = new TypingUnit15;
 //│ // Query 1
-//│ globalThis.www1 = W();
+//│ globalThis.www = W();
 //│ // Query 2
-//│ res = www1.add(42);
+//│ res = www.add(42);
 //│ // End of generated code
 //│ www
 //│     = W {}
diff --git a/shared/src/test/diff/codegen/Nested.mls b/shared/src/test/diff/codegen/Nested.mls
index 227d0c7a2d..10843c74aa 100644
--- a/shared/src/test/diff/codegen/Nested.mls
+++ b/shared/src/test/diff/codegen/Nested.mls
@@ -78,9 +78,9 @@ bb.b
 //│ class TypingUnit1 {}
 //│ const typing_unit1 = new TypingUnit1;
 //│ // Query 1
-//│ globalThis.bb1 = A.B(A.a);
+//│ globalThis.bb = A.B(A.a);
 //│ // Query 2
-//│ res = bb1.b;
+//│ res = bb.b;
 //│ // End of generated code
 //│ bb
 //│    = B {}
@@ -241,9 +241,9 @@ ee.x
 //│ class TypingUnit5 {}
 //│ const typing_unit5 = new TypingUnit5;
 //│ // Query 1
-//│ globalThis.ee1 = D.createE(42);
+//│ globalThis.ee = D.createE(42);
 //│ // Query 2
-//│ res = ee1.x;
+//│ res = ee.x;
 //│ // End of generated code
 //│ ee
 //│    = E {}
@@ -361,13 +361,13 @@ gg.sum
 //│ class TypingUnit7 {}
 //│ const typing_unit7 = new TypingUnit7;
 //│ // Query 1
-//│ globalThis.es1 = E(1);
+//│ globalThis.es = E(1);
 //│ // Query 2
-//│ globalThis.fff1 = es1.F(2);
+//│ globalThis.fff = es.F(2);
 //│ // Query 3
-//│ globalThis.gg1 = fff1.G(3);
+//│ globalThis.gg = fff.G(3);
 //│ // Query 4
-//│ res = gg1.sum;
+//│ res = gg.sum;
 //│ // End of generated code
 //│ es
 //│    = E {}
@@ -559,11 +559,11 @@ i.x
 //│ class TypingUnit10 {}
 //│ const typing_unit10 = new TypingUnit10;
 //│ // Query 1
-//│ globalThis.jj1 = G.H.J(42);
+//│ globalThis.jj = G.H.J(42);
 //│ // Query 2
-//│ globalThis.i1 = jj1.ii(2);
+//│ globalThis.i = jj.ii(2);
 //│ // Query 3
-//│ res = i1.x;
+//│ res = i.x;
 //│ // End of generated code
 //│ jj
 //│    = J {}
@@ -666,9 +666,9 @@ j.i.x
 //│ class TypingUnit12 {}
 //│ const typing_unit12 = new TypingUnit12;
 //│ // Query 1
-//│ globalThis.j1 = H.J(42);
+//│ globalThis.j = H.J(42);
 //│ // Query 2
-//│ res = j1.i.x;
+//│ res = j.i.x;
 //│ // End of generated code
 //│ j
 //│   = J {}
@@ -757,11 +757,11 @@ ij.incY
 //│ const typing_unit13 = new TypingUnit13;
 //│ globalThis.I = typing_unit13.I;
 //│ // Query 1
-//│ globalThis.i3 = I(1);
+//│ globalThis.i1 = I(1);
 //│ // Query 2
-//│ globalThis.ij1 = i3.J(0);
+//│ globalThis.ij = i1.J(0);
 //│ // Query 3
-//│ res = ij1.incY;
+//│ res = ij.incY;
 //│ // End of generated code
 //│ i
 //│   = I {}
@@ -890,9 +890,9 @@ let n = J.N(2)
 //│ class TypingUnit15 {}
 //│ const typing_unit15 = new TypingUnit15;
 //│ // Query 1
-//│ globalThis.m1 = J.M();
+//│ globalThis.m = J.M();
 //│ // Query 2
-//│ globalThis.n1 = J.N(2);
+//│ globalThis.n = J.N(2);
 //│ // End of generated code
 //│ m
 //│   = M {}
diff --git a/shared/src/test/diff/codegen/New.mls b/shared/src/test/diff/codegen/New.mls
index 8636a83c8b..9909f20df2 100644
--- a/shared/src/test/diff/codegen/New.mls
+++ b/shared/src/test/diff/codegen/New.mls
@@ -46,7 +46,7 @@ let c = C
 //│ class TypingUnit3 {}
 //│ const typing_unit3 = new TypingUnit3;
 //│ // Query 1
-//│ globalThis.c1 = C;
+//│ globalThis.c = C;
 //│ // End of generated code
 //│ c
 //│   = [class C]
@@ -93,7 +93,7 @@ let c = C
 //│ class TypingUnit8 {}
 //│ const typing_unit8 = new TypingUnit8;
 //│ // Query 1
-//│ globalThis.c3 = C;
+//│ globalThis.c1 = C;
 //│ // End of generated code
 //│ c
 //│   = [Function (anonymous)] {
diff --git a/shared/src/test/diff/codegen/NewDefsBug.mls b/shared/src/test/diff/codegen/NewDefsBug.mls
new file mode 100644
index 0000000000..2f004173d0
--- /dev/null
+++ b/shared/src/test/diff/codegen/NewDefsBug.mls
@@ -0,0 +1,72 @@
+:NewDefs
+
+:js
+fun foo: Int -> Int
+fun foo = x => x + 1
+class Bar {
+  fun calc(x) = foo(x)
+}
+//│ fun foo: Int -> Int
+//│ class Bar {
+//│   constructor()
+//│   fun calc: Int -> Int
+//│ }
+//│ fun foo: Int -> Int
+//│ // Prelude
+//│ let res;
+//│ class TypingUnit {
+//│   #Bar;
+//│   constructor() {
+//│   }
+//│   get Bar() {
+//│     const qualifier = this;
+//│     if (this.#Bar === undefined) {
+//│       class Bar {
+//│         constructor() {
+//│         }
+//│         calc(x) {
+//│           return foo(x);
+//│         }
+//│       };
+//│       this.#Bar = Bar;
+//│     }
+//│     return this.#Bar;
+//│   }
+//│ }
+//│ const typing_unit = new TypingUnit;
+//│ globalThis.Bar = typing_unit.Bar;
+//│ // Query 1 is empty
+//│ // Query 2
+//│ globalThis.foo = function foo(x) {
+//│   return x + 1;
+//│ };
+//│ // End of generated code
+
+// Note: This test case looks trivial but it was like:
+//
+// ```
+// :re
+// (new Bar()).calc(0)
+// //│ Int
+// //│ res
+// //│ Runtime error:
+// //│   ReferenceError: foo is not defined
+// ```
+//
+// My fix is a little bit hacky. The root of the problem is: when generating
+// code within a class, we need all top-level bindings to be accessible. This
+// part of implementation of new-definition-typing chose to declare all term
+// `NuFunDef` as `ValueSymbol` in advance, but this can lead to the fact that
+// the same symbol is declared multiple times, thus wasting some runtime names.
+// Consequently, the code that references these wasted runtime names are invalid.
+// 
+// Actually, I have a better solution, but it requires adjusting the order of
+// translation, and I don't have much time to spend on this at the moment. So，
+// my current fix is rather hacky. But I will complete this part when `PreTyper`
+// is finished, when replacing the old Scope with the new Scope.
+//
+//                                                      Luyu Cheng on 2023/12/30
+(new Bar()).calc(0)
+//│ Int
+//│ res
+//│     = 1
diff --git a/shared/src/test/diff/codegen/NewMatching.mls b/shared/src/test/diff/codegen/NewMatching.mls
index 608ca2e574..8d270d1550 100644
--- a/shared/src/test/diff/codegen/NewMatching.mls
+++ b/shared/src/test/diff/codegen/NewMatching.mls
@@ -136,7 +136,7 @@ fun foo(s) =
 //│ // Query 1
 //│ globalThis.foo = function foo(s) {
 //│   return ((() => {
-//│     return s instanceof Some.class ? (([t]) => ((b) => b + t.x)(s21.value))(Some.unapply(s)) : 0;
+//│     return s instanceof Some.class ? (([t]) => ((b) => b + t.x)(s2.value))(Some.unapply(s)) : 0;
 //│   })());
 //│ };
 //│ // End of generated code
diff --git a/shared/src/test/diff/codegen/NuReplHost.mls b/shared/src/test/diff/codegen/NuReplHost.mls
index c5aaf4563f..d4805d1c82 100644
--- a/shared/src/test/diff/codegen/NuReplHost.mls
+++ b/shared/src/test/diff/codegen/NuReplHost.mls
@@ -33,7 +33,7 @@ let r = foo(1)
 //│ └─┬ Query 2/2
 //│   ├── Prelude: <empty>
 //│   ├── Code:
-//│   ├──   globalThis.r1 = foo(1);
+//│   ├──   globalThis.r = foo(1);
 //│   └── Reply: [runtime error] Error: an error was thrown
 //│ r
 //│ Runtime error:
@@ -44,7 +44,7 @@ r
 //│ nothing
 //│ res
 //│ Runtime error:
-//│   ReferenceError: r1 is not defined
+//│   ReferenceError: r is not defined
 
 
 
diff --git a/shared/src/test/diff/codegen/SymbolicOps.mls b/shared/src/test/diff/codegen/SymbolicOps.mls
index 37e42ce6a0..9dd61cb78a 100644
--- a/shared/src/test/diff/codegen/SymbolicOps.mls
+++ b/shared/src/test/diff/codegen/SymbolicOps.mls
@@ -14,7 +14,7 @@ let r = succ >> succ
 //│ class TypingUnit1 {}
 //│ const typing_unit1 = new TypingUnit1;
 //│ // Query 1
-//│ globalThis.r1 = compose(succ, succ);
+//│ globalThis.r = compose(succ, succ);
 //│ // End of generated code
 //│ r
 //│   = [Function (anonymous)]
@@ -65,7 +65,7 @@ let f = (>>)
 //│ class TypingUnit7 {}
 //│ const typing_unit7 = new TypingUnit7;
 //│ // Query 1
-//│ globalThis.f1 = compose;
+//│ globalThis.f = compose;
 //│ // End of generated code
 //│ f
 //│   = [Function: compose]
@@ -315,7 +315,7 @@ fun (:-D) dd(a, b) = a + b
 val (->) f(x, y) = [x, y]
 //│ val (->) f: forall 'a 'b. ('a, 'b) -> ['a, 'b]
 //│ f
-//│   = [Function: f3]
+//│   = [Function: f1]
 
 12 -> 34
 //│ [12, 34]
@@ -326,7 +326,7 @@ val (->) f(x, y) = [x, y]
 let (->) _ = f
 //│ let (->) _: forall 'a 'b. ('a, 'b) -> ['a, 'b]
 //│ _
-//│   = [Function: f3]
+//│   = [Function: f1]
 
 :js
 12 -> 34
@@ -335,7 +335,7 @@ let (->) _ = f
 //│ class TypingUnit42 {}
 //│ const typing_unit42 = new TypingUnit42;
 //│ // Query 1
-//│ res = _1(12, 34);
+//│ res = _(12, 34);
 //│ // End of generated code
 //│ res
 //│     = [ 12, 34 ]
diff --git a/shared/src/test/diff/mlscript/Sequence.mls b/shared/src/test/diff/mlscript/Sequence.mls
index 6c52dff4ca..919c7251b1 100644
--- a/shared/src/test/diff/mlscript/Sequence.mls
+++ b/shared/src/test/diff/mlscript/Sequence.mls
@@ -4,7 +4,7 @@
 let test(x) = log(x); x + 1
 //│ let test: Int -> Int
 //│ test
-//│      = [Function: test1]
+//│      = [Function: test]
 
 test(log("here we go"); 123)
 //│ Int
diff --git a/shared/src/test/diff/nu/ArrayProg.mls b/shared/src/test/diff/nu/ArrayProg.mls
index b33cb35fab..857ee4e3ac 100644
--- a/shared/src/test/diff/nu/ArrayProg.mls
+++ b/shared/src/test/diff/nu/ArrayProg.mls
@@ -40,7 +40,7 @@ fun zip(xs, ys) = mapi of xs, (x, i) =>
 zip
 //│ forall 'a 'b. (Array['a], Array[Object & 'b & ~()]) -> Array[['a, 'b]]
 //│ res
-//│     = [Function: zip1]
+//│     = [Function: zip]
 
 
 
diff --git a/shared/src/test/diff/nu/CtorSubtraction.mls b/shared/src/test/diff/nu/CtorSubtraction.mls
index 38d37eaaac..9a58ce6842 100644
--- a/shared/src/test/diff/nu/CtorSubtraction.mls
+++ b/shared/src/test/diff/nu/CtorSubtraction.mls
@@ -16,12 +16,12 @@ fun x = case
 x : Int -> Int
 //│ Int -> Int
 //│ res
-//│     = [Function: x1]
+//│     = [Function: x]
 
 x : Cls -> nothing
 //│ Cls -> nothing
 //│ res
-//│     = [Function: x1]
+//│     = [Function: x]
 
 
 fun x: (Int | Str | Cls) \ Cls
diff --git a/shared/src/test/diff/nu/FlatIndentFuns.mls b/shared/src/test/diff/nu/FlatIndentFuns.mls
index 77ace9e704..3a58afdd03 100644
--- a/shared/src/test/diff/nu/FlatIndentFuns.mls
+++ b/shared/src/test/diff/nu/FlatIndentFuns.mls
@@ -20,7 +20,7 @@ y =>
 x + y
 //│ let r: Int -> Int -> Int
 //│ r
-//│   = [Function: r1]
+//│   = [Function: r]
 
 r(1)(2)
 //│ Int
@@ -59,6 +59,6 @@ x + y
 //│ ╙──      	
 //│ let r: Int -> Int -> Int
 //│ r
-//│   = [Function: r3]
+//│   = [Function: r1]
 
 
diff --git a/shared/src/test/diff/nu/FlatMonads_repro.mls b/shared/src/test/diff/nu/FlatMonads_repro.mls
index 1fe5bef9a8..938516f499 100644
--- a/shared/src/test/diff/nu/FlatMonads_repro.mls
+++ b/shared/src/test/diff/nu/FlatMonads_repro.mls
@@ -48,7 +48,7 @@ let ri(f) = Bind(Pure(42), f)
 //│   where
 //│     'CC :> 42
 //│ ri
-//│    = [Function: ri1]
+//│    = [Function: ri]
 
 ri(Pure)
 //│ Bind['CC, 'AA]
diff --git a/shared/src/test/diff/nu/HeungTung.mls b/shared/src/test/diff/nu/HeungTung.mls
index 264a541703..51f4efad8b 100644
--- a/shared/src/test/diff/nu/HeungTung.mls
+++ b/shared/src/test/diff/nu/HeungTung.mls
@@ -202,7 +202,7 @@ type Res = M(T)
 let f = x => [x, x]
 //│ let f: forall 'a. 'a -> ['a, 'a]
 //│ f
-//│   = [Function: f3]
+//│   = [Function: f1]
 
 [f(1), f(true)]
 //│ [[1, 1], [true, true]]
diff --git a/shared/src/test/diff/nu/LamPatterns.mls b/shared/src/test/diff/nu/LamPatterns.mls
index a396d13e67..f9e5dace22 100644
--- a/shared/src/test/diff/nu/LamPatterns.mls
+++ b/shared/src/test/diff/nu/LamPatterns.mls
@@ -24,12 +24,12 @@ let f = Some => 0
 //│ class TypingUnit2 {}
 //│ const typing_unit2 = new TypingUnit2;
 //│ // Query 1
-//│ globalThis.f1 = function f1(Some) {
+//│ globalThis.f = function f(Some) {
 //│   return 0;
 //│ };
 //│ // End of generated code
 //│ f
-//│   = [Function: f1]
+//│   = [Function: f]
 
 // :e // TODO
 f(Some)
diff --git a/shared/src/test/diff/nu/LocalLets.mls b/shared/src/test/diff/nu/LocalLets.mls
index 15717f5ded..211987ae06 100644
--- a/shared/src/test/diff/nu/LocalLets.mls
+++ b/shared/src/test/diff/nu/LocalLets.mls
@@ -32,6 +32,6 @@ let E(x) = new E(1)
 //│ ╙──      	               ^
 //│ let E: anything -> error
 //│ E
-//│   = [Function: E2]
+//│   = [Function: E1]
 
 
diff --git a/shared/src/test/diff/nu/MIscPoly.mls b/shared/src/test/diff/nu/MIscPoly.mls
index 34235988a1..3d9c94a5af 100644
--- a/shared/src/test/diff/nu/MIscPoly.mls
+++ b/shared/src/test/diff/nu/MIscPoly.mls
@@ -69,7 +69,7 @@ r()
 //│ nothing
 //│ res
 //│ Runtime error:
-//│   TypeError: r1 is not a function
+//│   TypeError: r is not a function
 
 
 
diff --git a/shared/src/test/diff/nu/Misc.mls b/shared/src/test/diff/nu/Misc.mls
index a0aa87e20c..821a12d2c7 100644
--- a/shared/src/test/diff/nu/Misc.mls
+++ b/shared/src/test/diff/nu/Misc.mls
@@ -65,7 +65,7 @@ f of [1, 2]
 let f = (x, y) => x + y
 //│ let f: (Int, Int) -> Int
 //│ f
-//│   = [Function: f5]
+//│   = [Function: f4]
 
 f(1, 2)
 //│ Int
@@ -96,7 +96,7 @@ let f = ((x, y)) => x + y
 //│ ╙──      	         ^^^^^^
 //│ let f: ([Int, Int]) -> Int
 //│ f
-//│   = [Function: f7]
+//│   = [Function: f5]
 
 :e
 f(1, 2)
@@ -132,7 +132,7 @@ f[1, 2]
 //│ ╙──       	^^^^^^^
 //│ ([Int, Int]) -> Int
 //│ res
-//│     = [Function: f7]
+//│     = [Function: f5]
 
 
 :pe
@@ -142,14 +142,14 @@ let f = (((x, y))) => x + y
 //│ ╙──       	          ^^^^^^
 //│ let f: ([Int, Int]) -> Int
 //│ f
-//│   = [Function: f9]
+//│   = [Function: f6]
 
 
 // * TODO maybe parse as type lambda?
 let f = [x, y] => x + y
 //│ let f: ([Int, Int]) -> Int
 //│ f
-//│   = [Function: f11]
+//│   = [Function: f7]
 
 :e
 f(1, 2)
@@ -173,7 +173,7 @@ f([1, 2])
 let f = ([x, y]) => x + y
 //│ let f: ([Int, Int]) -> Int
 //│ f
-//│   = [Function: f13]
+//│   = [Function: f8]
 
 f([1, 2])
 //│ Int
@@ -197,7 +197,7 @@ f(1, 2)
 let f = [[[x, y]]] => x + y
 //│ let f: ([[[Int, Int]]]) -> Int
 //│ f
-//│   = [Function: f15]
+//│   = [Function: f9]
 
 :e
 f([[1, 2]])
diff --git a/shared/src/test/diff/nu/NamedArgs.mls b/shared/src/test/diff/nu/NamedArgs.mls
index c846ee548b..8c4d4606f1 100644
--- a/shared/src/test/diff/nu/NamedArgs.mls
+++ b/shared/src/test/diff/nu/NamedArgs.mls
@@ -116,9 +116,9 @@ test(0, y: 200)
 //│ class TypingUnit13 {}
 //│ const typing_unit13 = new TypingUnit13;
 //│ // Query 1
-//│ globalThis.tmp1 = 2;
+//│ globalThis.tmp = 2;
 //│ // Query 2
-//│ res = test1(0, tmp1);
+//│ res = test1(0, tmp);
 //│ // Query 3
 //│ res = test1(0, 200);
 //│ // End of generated code
@@ -171,11 +171,11 @@ fff(y: 2, z: y_1 + 1, x: z_1 - 2)
 //│ class TypingUnit17 {}
 //│ const typing_unit17 = new TypingUnit17;
 //│ // Query 1
-//│ globalThis["y_11"] = 2;
+//│ globalThis["y_1"] = 2;
 //│ // Query 2
-//│ globalThis["z_11"] = 3;
+//│ globalThis["z_1"] = 3;
 //│ // Query 3
-//│ res = ((z_2) => ((x_1) => fff(x_1, 2, z_2))(z_11 - 2))(y_11 + 1);
+//│ res = ((z_2) => ((x_1) => fff(x_1, 2, z_2))(z_1 - 2))(y_1 + 1);
 //│ // End of generated code
 //│ y_1
 //│     = 2
diff --git a/shared/src/test/diff/nu/NestedRecords.mls b/shared/src/test/diff/nu/NestedRecords.mls
index ca216f4788..ebe7bbcbd6 100644
--- a/shared/src/test/diff/nu/NestedRecords.mls
+++ b/shared/src/test/diff/nu/NestedRecords.mls
@@ -4,7 +4,7 @@
 let f(x) = [x, x]
 //│ let f: forall 'a. 'a -> ['a, 'a]
 //│ f
-//│   = [Function: f1]
+//│   = [Function: f]
 
 let a = { u: f(f(f(1))), v: f(f(f(1))) }
 //│ let a: {u: [[[1, 1], [1, 1]], [[1, 1], [1, 1]]], v: [[[1, 1], [1, 1]], [[1, 1], [1, 1]]]}
diff --git a/shared/src/test/diff/nu/NewNew.mls b/shared/src/test/diff/nu/NewNew.mls
index 86753b6e37..e54f469a53 100644
--- a/shared/src/test/diff/nu/NewNew.mls
+++ b/shared/src/test/diff/nu/NewNew.mls
@@ -103,7 +103,7 @@ f(1)
 //│ error
 //│ res
 //│ Runtime error:
-//│   TypeError: f9 is not a function
+//│   TypeError: f4 is not a function
 
 :e
 new Foo("2")
diff --git a/shared/src/test/diff/nu/Res.mls b/shared/src/test/diff/nu/Res.mls
index e8936ec349..0f7f660b69 100644
--- a/shared/src/test/diff/nu/Res.mls
+++ b/shared/src/test/diff/nu/Res.mls
@@ -19,7 +19,7 @@ res(1)
 let res = x => x + 2
 //│ let res: Int -> Int
 //│ res
-//│     = [Function: res2]
+//│     = [Function: res1]
 
 res(1)
 //│ Int
diff --git a/shared/src/test/diff/nu/Vals.mls b/shared/src/test/diff/nu/Vals.mls
index e90080f1b9..413b7a8498 100644
--- a/shared/src/test/diff/nu/Vals.mls
+++ b/shared/src/test/diff/nu/Vals.mls
@@ -32,7 +32,7 @@ val a = a
 val f(x) = x
 //│ val f: forall 'a. 'a -> 'a
 //│ f
-//│   = [Function: f1]
+//│   = [Function: f]
 
 f(123)
 //│ 123
diff --git a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
index 2dc1c10606..218259301a 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
@@ -326,7 +326,7 @@ fun lookup(env, name: Str): 'A = env(name)
 //│ let emptyEnv: Str -> nothing
 //│ fun lookup: forall 'A. (Str -> 'A, name: Str) -> 'A
 //│ emptyEnv
-//│          = [Function: emptyEnv1]
+//│          = [Function: emptyEnv]
 
 // It is tricky to write an annotation that simplifies the inferred type.
 fun (+:) extend(env, [name, expr]: [Str, 'A]) =
diff --git a/shared/src/test/diff/pretyper/ucs/examples/Option.mls b/shared/src/test/diff/pretyper/ucs/examples/Option.mls
index c7f9c94203..687b4b3744 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/Option.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/Option.mls
@@ -1,27 +1,113 @@
 :PreTyper
 
 // FIXME: Finish this example after the relevant issue is fixed.
+abstract class MyOption[out T]: (MySome[T] | MyNone) {
+  virtual fun filter: (p: T -> Bool) -> MyOption[T]
+}
+class MySome[out T](val value: T) extends MyOption[T] {
+  fun filter(p) = if p of value then MySome(value) else MyNone
+}
+module MyNone extends MyOption[nothing] {
+  fun filter(_) = MyNone
+}
+//│ ╔══[ERROR] Type `#MySome & {MySome#T <: ?T}` does not contain member `MyOption#T`
+//│ ║  l.4: 	abstract class MyOption[out T]: (MySome[T] | MyNone) {
+//│ ╙──     	                            ^
+//│ ╔══[ERROR] Type `#MyNone` does not contain member `MyOption#T`
+//│ ║  l.4: 	abstract class MyOption[out T]: (MySome[T] | MyNone) {
+//│ ╙──     	                            ^
+//│ abstract class MyOption[T]: MyNone | MySome[T] {
+//│   fun filter: (p: T -> Bool) -> MyOption[T]
+//│ }
+//│ class MySome[T](value: T) extends MyOption {
+//│   fun filter: (T -> Object) -> (MyNone | MySome[T])
+//│ }
+//│ module MyNone extends MyOption {
+//│   fun filter: anything -> MyNone
+//│ }
+
+// The following code aims to find a workaround that allows the functions
+// operating ADT to be defined as member functions of classes, and also ensures
+// the correct generation of JavaScript code.
+
+// Create an alias constructor for `Some`
+// ======================================
+// // This works:
+fun some: forall 'a: 'a -> Option['a]
+fun some = x => Some(x)
+// // This doesn't work with `map`:
+// let some: forall 'a: 'a -> Option['a] = x => Some(x)
+//
+// Create an alias constructor for `None`
+// ======================================
+// // This works:
+// fun none: forall 'a: () -> Option['a]
+// fun none = () => None
+// // This also works:
+// fun none: Option[nothing]
+// fun none = None
+// This also works:
+let none: () -> Option[nothing] = () => None
+// // This also works but failed in code generation:
+// let none: Option[nothing] = None
+//
+// The class definitions
+// =====================
 abstract class Option[out T]: (Some[T] | None) {
+  virtual fun isEmpty: Bool
+  virtual fun isDefined: Bool
+  virtual fun map: forall 'b: (T -> 'b) -> Option['b]
+  virtual fun flatMap: forall 'b: (T -> Option['b]) -> Option['b]
   virtual fun filter: (p: T -> Bool) -> Option[T]
+  virtual fun get: T
 }
 class Some[out T](val value: T) extends Option[T] {
-  fun filter(p) = if p of value then Some(value) else None
+  fun isEmpty = false
+  fun isDefined = true
+  fun map(f) = some(f(value))
+  fun flatMap(f) = f(value)
+  fun filter(p) = if p of value then some(value) else none()
+  fun get = value
 }
 module None extends Option[nothing] {
-  fun filter(_) = None
+  fun isEmpty = true
+  fun isDefined = false
+  fun map(_) = none()
+  fun flatMap(_) = none()
+  fun filter(_) = none()
+  fun get = error
 }
-//│ ╔══[ERROR] Type `#Some & {Some#T <: ?T}` does not contain member `Option#T`
-//│ ║  l.4: 	abstract class Option[out T]: (Some[T] | None) {
-//│ ╙──     	                          ^
-//│ ╔══[ERROR] Type `#None` does not contain member `Option#T`
-//│ ║  l.4: 	abstract class Option[out T]: (Some[T] | None) {
-//│ ╙──     	                          ^
+//│ fun some: forall 'T. 'T -> Some['T]
+//│ let none: () -> Option[nothing]
 //│ abstract class Option[T]: None | Some[T] {
 //│   fun filter: (p: T -> Bool) -> Option[T]
+//│   fun flatMap: forall 'b. (T -> Option['b]) -> Option['b]
+//│   fun get: T
+//│   fun isDefined: Bool
+//│   fun isEmpty: Bool
+//│   fun map: forall 'b0. (T -> 'b0) -> Option['b0]
 //│ }
 //│ class Some[T](value: T) extends Option {
-//│   fun filter: (T -> Object) -> (None | Some[T])
+//│   fun filter: (T -> Object) -> Option[T]
+//│   fun flatMap: forall 'c. (T -> 'c) -> 'c
+//│   fun get: T
+//│   fun isDefined: true
+//│   fun isEmpty: false
+//│   fun map: forall 'a. (T -> 'a) -> Option['a]
 //│ }
 //│ module None extends Option {
-//│   fun filter: anything -> None
+//│   fun filter: anything -> Option[nothing]
+//│   fun flatMap: anything -> Option[nothing]
+//│   fun get: nothing
+//│   fun isDefined: false
+//│   fun isEmpty: true
+//│   fun map: anything -> Option[nothing]
 //│ }
+//│ fun some: forall 'a0. 'a0 -> Option['a0]
+//│ none
+//│      = [Function: none]
+
+some(0).map(x => x + 1).get
+//│ Int
+//│ res
+//│     = 1

From 4529fe9db4d4bf683b103c0a6379cbb164acaade Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 30 Dec 2023 05:10:01 +0800
Subject: [PATCH 038/147] Support hex, octal, and binary integers

---
 shared/src/main/scala/mlscript/NewLexer.scala | 47 ++++++++++++++++++-
 1 file changed, 45 insertions(+), 2 deletions(-)

diff --git a/shared/src/main/scala/mlscript/NewLexer.scala b/shared/src/main/scala/mlscript/NewLexer.scala
index f5ac326297..7db5f04963 100644
--- a/shared/src/main/scala/mlscript/NewLexer.scala
+++ b/shared/src/main/scala/mlscript/NewLexer.scala
@@ -23,6 +23,12 @@ class NewLexer(origin: Origin, raise: Diagnostic => Unit, dbg: Bool) {
     c.isLetter || c === '_' || c === '\''
   def isIdentChar(c: Char): Bool =
     isIdentFirstChar(c) || isDigit(c) || c === '\''
+  def isHexDigit(c: Char): Bool =
+    isDigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')
+  def isOctDigit(c: Char): Bool =
+    c >= '0' && c <= '7'
+  def isBinDigit(c: Char): Bool =
+    c === '0' || c === '1'
   def isDigit(c: Char): Bool =
     c >= '0' && c <= '9'
   
@@ -59,15 +65,52 @@ class NewLexer(origin: Origin, raise: Diagnostic => Unit, dbg: Bool) {
     if (i < length && pred(bytes(i))) takeWhile(i + 1, bytes(i) :: cur)(pred)
     else (cur.reverseIterator.mkString, i)
 
+  final def int(i: Int): (BigInt, Int) = {
+    def radix(i: Int, radix: Int, desc: Str, pred: Char => Bool): (BigInt, Int) = {
+      val (str, j) = takeWhile(i)(pred)
+      if (str.isEmpty) {
+        raise(ErrorReport(msg"Expect at least one $desc digit" -> S(loc(i, i + 2)) :: Nil,
+          newDefs = true, source = Lexing))
+        (BigInt(0), j)
+      }
+      else (BigInt(str, radix), j)
+    }
+    if (i < length) {
+      if (bytes(i) === '0') {
+        if (i + 1 < length) {
+          bytes(i + 1) match {
+            case 'x' => radix(i + 2, 16, "hexadecimal", isHexDigit)
+            case 'o' => radix(i + 2, 8, "octal", isOctDigit)
+            case 'b' => radix(i + 2, 2, "binary", isBinDigit)
+            case _ =>
+              val (str, j) = takeWhile(i + 1, '0' :: Nil)(isDigit)
+              (BigInt(str), j)
+          }
+        } else {
+          (BigInt(0), i + 1)
+        }
+      } else {
+        radix(i, 10, "decimal", isDigit)
+      }
+    } else {
+      raise(ErrorReport(msg"Expect a integer literal" -> S(loc(i, i + 1)) :: Nil,
+        newDefs = true, source = Lexing))
+      (BigInt(0), i)
+    }
+  }
+
   @tailrec final
   def str(i: Int, escapeMode: Bool, cur: Ls[Char] = Nil): (Str, Int) =
     if (escapeMode)
       if (i < length)
         bytes(i) match {
+          case '\\' => str(i + 1, false, '\\' :: cur)
           case '"' => str(i + 1, false, '"' :: cur)
           case 'n' => str(i + 1, false, '\n' :: cur)
           case 't' => str(i + 1, false, '\t' :: cur)
           case 'r' => str(i + 1, false, '\r' :: cur)
+          case 'b' => str(i + 1, false, '\b' :: cur)
+          case 'f' => str(i + 1, false, '\f' :: cur)
           case ch =>
             raise(WarningReport(msg"Found invalid escape character" -> S(loc(i, i + 1)) :: Nil,
               newDefs = true, source = Lexing))
@@ -190,9 +233,9 @@ class NewLexer(origin: Origin, raise: Diagnostic => Unit, dbg: Bool) {
         // else go(j, if (isSymKeyword.contains(n)) KEYWORD(n) else IDENT(n, true))
         else lex(j, ind, next(j, if (isSymKeyword.contains(n)) KEYWORD(n) else IDENT(n, true)))
       case _ if isDigit(c) =>
-        val (str, j) = takeWhile(i)(isDigit)
+        val (value, j) = int(i)
         // go(j, LITVAL(IntLit(BigInt(str))))
-        lex(j, ind, next(j, LITVAL(IntLit(BigInt(str)))))
+        lex(j, ind, next(j, LITVAL(IntLit(value))))
       case _ =>
         pe(msg"unexpected character '${escapeChar(c)}'")
         // go(i + 1, ERROR)

From 72e454e872655252d2dd24b62b50c214e3181961 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 30 Dec 2023 05:10:54 +0800
Subject: [PATCH 039/147] Add `+`, `-`, and `*` functions for numbers; also add
 `**` operator

---
 shared/src/main/scala/mlscript/Typer.scala            | 4 ++++
 shared/src/main/scala/mlscript/codegen/Polyfill.scala | 3 +++
 shared/src/main/scala/mlscript/codegen/Scope.scala    | 3 +++
 shared/src/main/scala/mlscript/pretyper/Scope.scala   | 4 +++-
 shared/src/test/diff/codegen/Terms.mls                | 7 +++++--
 5 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/shared/src/main/scala/mlscript/Typer.scala b/shared/src/main/scala/mlscript/Typer.scala
index 452c059c24..6e8f03d449 100644
--- a/shared/src/main/scala/mlscript/Typer.scala
+++ b/shared/src/main/scala/mlscript/Typer.scala
@@ -318,6 +318,9 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
       "sub" -> intBinOpTy,
       "mul" -> intBinOpTy,
       "div" -> intBinOpTy,
+      "numAdd" -> numberBinOpTy,
+      "numSub" -> numberBinOpTy,
+      "numMul" -> numberBinOpTy,
       "sqrt" -> fun(singleTup(IntType), IntType)(noProv),
       "lt" -> numberBinPred,
       "le" -> numberBinPred,
@@ -343,6 +346,7 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
       "*" -> intBinOpTy,
       "%" -> intBinOpTy,
       "/" -> numberBinOpTy,
+      "**" -> numberBinOpTy,
       "<" -> numberBinPred,
       ">" -> numberBinPred,
       "<=" -> numberBinPred,
diff --git a/shared/src/main/scala/mlscript/codegen/Polyfill.scala b/shared/src/main/scala/mlscript/codegen/Polyfill.scala
index 9a01564ddc..e7d62f3afb 100644
--- a/shared/src/main/scala/mlscript/codegen/Polyfill.scala
+++ b/shared/src/main/scala/mlscript/codegen/Polyfill.scala
@@ -161,6 +161,9 @@ object Polyfill {
     buffer += BuiltinFunc("add", makeBinaryFunc("+"))
     buffer += BuiltinFunc("sub", makeBinaryFunc("-"))
     buffer += BuiltinFunc("mul", makeBinaryFunc("*"))
+    buffer += BuiltinFunc("numAdd", makeBinaryFunc("+"))
+    buffer += BuiltinFunc("numSub", makeBinaryFunc("-"))
+    buffer += BuiltinFunc("numMul", makeBinaryFunc("*"))
     buffer += BuiltinFunc("div", makeBinaryFunc("/"))
     buffer += BuiltinFunc("gt", makeBinaryFunc(">"))
     buffer += BuiltinFunc("not", makeUnaryFunc("!"))
diff --git a/shared/src/main/scala/mlscript/codegen/Scope.scala b/shared/src/main/scala/mlscript/codegen/Scope.scala
index 68c442ca87..c31732d3ae 100644
--- a/shared/src/main/scala/mlscript/codegen/Scope.scala
+++ b/shared/src/main/scala/mlscript/codegen/Scope.scala
@@ -44,6 +44,9 @@ class Scope(val name: Str, enclosing: Opt[Scope]) {
       "add",
       "sub",
       "mul",
+      "numAdd",
+      "numSub",
+      "numMul",
       "div",
       "gt",
       "not",
diff --git a/shared/src/main/scala/mlscript/pretyper/Scope.scala b/shared/src/main/scala/mlscript/pretyper/Scope.scala
index d6eae37c18..ffc041a18c 100644
--- a/shared/src/main/scala/mlscript/pretyper/Scope.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Scope.scala
@@ -99,10 +99,12 @@ object Scope {
     Scope.from(
       """true,false,document,window,typeof,toString,not,succ,log,discard,negate,
         |round,add,sub,mul,div,sqrt,lt,le,gt,ge,slt,sle,sgt,sge,length,concat,eq,
-        |ne,error,id,if,emptyArray,+,-,*,%,/,<,>,<=,>=,==,===,<>,&&,||,and"""
+        |ne,error,id,if,emptyArray,+,-,*,%,/,**,<,>,<=,>=,==,===,<>,&&,||,and,
+        |numAdd,numSub,numMul"""
         .stripMargin
         .split(",")
         .iterator
+        .map(_.trim)
         .map(name => new LocalTermSymbol(Var(name)))
         .concat(trueSymbol :: falseSymbol :: Nil)
     )
diff --git a/shared/src/test/diff/codegen/Terms.mls b/shared/src/test/diff/codegen/Terms.mls
index 1df094b5a1..e445c30ff7 100644
--- a/shared/src/test/diff/codegen/Terms.mls
+++ b/shared/src/test/diff/codegen/Terms.mls
@@ -66,9 +66,12 @@ z ** 4 * z / (x + 5)
 //│ // Query 1
 //│ res = z() ** 4 * z() / (x() + 5);
 //│ // End of generated code
-//│ ╔══[ERROR] identifier not found: **
+//│ ╔══[ERROR] Type mismatch in operator application:
 //│ ║  l.65: 	z ** 4 * z / (x + 5)
-//│ ╙──      	  ^^
+//│ ║        	^^^^^^^^
+//│ ╟── operator application of type `number` is not an instance of type `int`
+//│ ║  l.65: 	z ** 4 * z / (x + 5)
+//│ ╙──      	^^^^^^
 //│ res: number
 //│    = 6.4
 

From 10fb3e156ada18b948d4234750755fde1c82aa64 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 30 Dec 2023 05:11:55 +0800
Subject: [PATCH 040/147] Add JSON parser example

---
 .../test/diff/pretyper/ucs/examples/JSON.mls  | 552 ++++++++++++++++++
 1 file changed, 552 insertions(+)
 create mode 100644 shared/src/test/diff/pretyper/ucs/examples/JSON.mls

diff --git a/shared/src/test/diff/pretyper/ucs/examples/JSON.mls b/shared/src/test/diff/pretyper/ucs/examples/JSON.mls
new file mode 100644
index 0000000000..32900a899f
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/examples/JSON.mls
@@ -0,0 +1,552 @@
+:PreTyper
+
+
+type NStr = Str & {
+  length: Int,
+  at: Int -> NStr,
+  charAt: Int -> NStr,
+  charCodeAt: Int -> Int,
+  slice: (Int, Int) -> NStr,
+  startsWith: (Str, Int) -> Bool,
+  endsWith: Str -> Bool,
+  split: Str -> Array[NStr],
+  trim: () -> NStr,
+  trimStart: () -> NStr,
+  trimEnd: () -> NStr,
+  padStart: (Int, Str) -> NStr,
+  padEnd: (Int, Str) -> NStr,
+  repeat: Int -> NStr,
+  indexOf: Str -> Int,
+  lastIndexOf: Str -> Int,
+  includes: Str -> Bool,
+  localeCompare: Str -> Int
+}
+declare fun String: (anything -> NStr) & { fromCodePoint: Int -> NStr }
+fun (++) strcat(a, b) = String of concat(a)(b)
+fun (<*) strlt(a: NStr, b: NStr) = a.localeCompare(b) < 0
+fun (*>) strgt(a: NStr, b: NStr) = a.localeCompare(b) > 0
+//│ type NStr = Str & {
+//│   at: Int -> NStr,
+//│   charAt: Int -> NStr,
+//│   charCodeAt: Int -> Int,
+//│   endsWith: Str -> Bool,
+//│   includes: Str -> Bool,
+//│   indexOf: Str -> Int,
+//│   lastIndexOf: Str -> Int,
+//│   length: Int,
+//│   localeCompare: Str -> Int,
+//│   padEnd: (Int, Str) -> NStr,
+//│   padStart: (Int, Str) -> NStr,
+//│   repeat: Int -> NStr,
+//│   slice: (Int, Int) -> NStr,
+//│   split: Str -> Array[NStr],
+//│   startsWith: (Str, Int) -> Bool,
+//│   trim: () -> NStr,
+//│   trimEnd: () -> NStr,
+//│   trimStart: () -> NStr
+//│ }
+//│ fun (++) strcat: (Str, Str) -> NStr
+//│ fun (<*) strlt: (a: NStr, b: NStr) -> Bool
+//│ fun (*>) strgt: (a: NStr, b: NStr) -> Bool
+//│ fun String: anything -> NStr & {fromCodePoint: Int -> NStr}
+
+declare fun Math: { log10: Num -> Num, floor: Num -> Num, ceil: Num -> Num }
+//│ fun Math: {ceil: Num -> Num, floor: Num -> Num, log10: Num -> Num}
+
+// Steal operators from OCaml:
+let (+.) numAdd' = numAdd
+let (-.) numSub' = numSub
+let (*.) numMul' = numMul
+//│ let (+.) numAdd': (Num, Num) -> Num
+//│ let (-.) numSub': (Num, Num) -> Num
+//│ let (*.) numMul': (Num, Num) -> Num
+//│ numAdd'
+//│         = [Function: numAdd]
+//│ numSub'
+//│         = [Function: numSub]
+//│ numMul'
+//│         = [Function: numMul]
+
+fun (!==) notEqual(x, y) = not(x === y)
+declare fun parseInt: (Str, Int) -> Int
+//│ fun (!==) notEqual: forall 'a. (Eql['a], 'a) -> Bool
+//│ fun parseInt: (Str, Int) -> Int
+
+// `List` and its utilities:
+abstract class List[out T]: Cons[T] | Nil
+class Cons[T](head: T, tail: List[T]) extends List[T]
+module Nil extends List
+fun (::) cons(head: 'T, tail: List['T]): List['T] = Cons(head, tail)
+fun reverse(l: List['A]): List['A] =
+  let rec r(l', l) = if l is Cons(x, xs) then r(x :: l', xs) else l'
+  r(Nil, l)
+fun join(sep: Str, xs: List['B]) = if xs is
+  Cons(x, Nil) then toString(x)
+  Cons(x, xs) then toString(x) ++ sep ++ join(sep, xs)
+  Nil then ""
+fun showList(xs: List['C]) = "[" ++ join(", ", xs) ++ "]"
+fun map(f: 'D -> 'E, xs: List['D]): List['E] = if xs is
+  Cons(x, xs) then f(x) :: map(f, xs)
+  Nil then Nil
+fun equalList(xs: List['A], ys: List['A], equal: ('A, 'A) -> Bool): Bool = if xs is
+  Cons(x, xs') and ys is Cons(y, ys') then equal(x, y) and equalList(xs', ys', equal)
+  Nil and ys is Nil then true
+  else false
+//│ abstract class List[T]: Cons[T] | Nil
+//│ class Cons[T](head: T, tail: List[T]) extends List
+//│ module Nil extends List
+//│ fun (::) cons: forall 'T. (head: 'T, tail: List['T]) -> List['T]
+//│ fun reverse: forall 'A. (l: List['A]) -> List['A]
+//│ fun join: (sep: Str, xs: List[anything]) -> (Str | NStr)
+//│ fun showList: (xs: List[anything]) -> NStr
+//│ fun map: forall 'D 'T0. (f: 'D -> 'T0, xs: List['D]) -> List['T0]
+//│ fun equalList: forall 'A0. (xs: List['A0], ys: List['A0], equal: ('A0, 'A0) -> Bool) -> Bool
+
+// `Option` and its utilities:
+abstract class Option[out A]: Some[A] | None
+class Some[out A](value: A) extends Option[A]
+module None extends Option
+//│ abstract class Option[A]: None | Some[A]
+//│ class Some[A](value: A) extends Option
+//│ module None extends Option
+
+fun (->) makePair(a, b) = [a, b]
+//│ fun (->) makePair: forall 'a 'b. ('a, 'b) -> ['a, 'b]
+
+abstract class ListMap[K, out V]: (ConsMap[K, V] | NilMap)
+class ConsMap[K, out V](head: [K, V], tail: ListMap[K, V]) extends ListMap[K, V]
+module NilMap extends ListMap
+fun containsKey(map: ListMap['K, 'V], key: 'K): Bool = if map is
+  ConsMap([k, _], _) and k === key then true
+  ConsMap(_, tail) then containsKey(tail, key)
+  NilMap then false
+fun (:+) insert(map, entry) = if map is
+  ConsMap(entry', map) and
+    entry'.0 === entry.0 then ConsMap(entry, map)
+    else ConsMap(entry', insert(map, entry))
+  NilMap then ConsMap(entry, NilMap)
+fun showMap(map) =
+  let showEntry([k, v]) = toString(k) ++ " -> " ++ toString(v)
+  let rec aux(map) = if map is
+    ConsMap(last, NilMap) then showEntry(last)
+    ConsMap(head, tail) then showEntry(head) ++ ", " ++ aux(tail)
+    NilMap then ""
+  if map is NilMap then String("{}") else "{ " ++ aux(map) ++ " }"
+//│ abstract class ListMap[K, V]: ConsMap[K, V] | NilMap
+//│ class ConsMap[K, V](head: [K, V], tail: ListMap[K, V]) extends ListMap
+//│ module NilMap extends ListMap
+//│ fun containsKey: forall 'K 'a. (map: ListMap['K, anything], key: 'a) -> Bool
+//│ fun (:+) insert: forall 'K0 'b 'V. (ConsMap['K0, 'V] | NilMap, ['K0 & 'b, 'V]) -> ConsMap['K0, 'V]
+//│ fun showMap: forall 'K1. (ConsMap['K1, anything] | NilMap) -> NStr
+//│ where
+//│   'K0 <: Eql['b]
+//│   'K <: Eql['a]
+
+showMap of NilMap
+showMap of NilMap :+ ["b", 2]
+showMap of NilMap :+ [1, "a"] :+ [2, "b"]
+showMap of NilMap :+ [1, "a"] :+ [2, "b"] :+ [1, "c"]
+//│ NStr
+//│ res
+//│     = '{}'
+//│ res
+//│     = '{ b -> 2 }'
+//│ res
+//│     = '{ 1 -> a, 2 -> b }'
+//│ res
+//│     = '{ 1 -> c, 2 -> b }'
+
+abstract class JsonValue: JsonNumber | JsonString | JsonArray | JsonObject | JsonBoolean | JsonNull
+class JsonNumber(value: Num) extends JsonValue
+class JsonString(value: Str) extends JsonValue
+class JsonArray(value: List[JsonValue]) extends JsonValue
+class JsonObject(value: ListMap[Str, JsonValue]) extends JsonValue
+class JsonBoolean(value: Bool) extends JsonValue
+module JsonNull extends JsonValue
+//│ abstract class JsonValue: JsonArray | JsonBoolean | JsonNull | JsonNumber | JsonObject | JsonString
+//│ class JsonNumber(value: Num) extends JsonValue
+//│ class JsonString(value: Str) extends JsonValue
+//│ class JsonArray(value: List[JsonValue]) extends JsonValue
+//│ class JsonObject(value: ListMap[Str, JsonValue]) extends JsonValue
+//│ class JsonBoolean(value: Bool) extends JsonValue
+//│ module JsonNull extends JsonValue
+
+class ParserState(val text: NStr, val at: Int) {
+  fun drained: Bool = at === text.length
+  fun peek: Option[NStr] = if drained then None else Some(text.charAt(at))
+  fun peekCode: Option[Int] = if drained then None else Some(text.charCodeAt(at))
+  fun next: ParserState = if drained then this else ParserState(text, at + 1)
+  fun nextDigit: Option[[Num, ParserState]] = if peekCode is
+    Some(ch) and 48 <= ch and ch <= 57 then Some([ch - 48, next])
+    else None
+  fun match(prefix: Str): Option[ParserState] =
+    let prefix' = String(prefix)
+    if
+      prefix'.length > text.length - at then None
+      text.startsWith(prefix', at) then Some(ParserState(text, at + prefix'.length))
+      else None
+  fun rest: NStr = text.slice(at, text.length)
+}
+fun showParserState(state) = "ParserState(_, " ++ toString(state.at) ++ ")"
+fun success: forall 't: ('t, ParserState) -> ParseResult['t]
+fun success = (value, state) => Success(value, state)
+fun failure: forall 't: Str -> ParseResult[nothing]
+fun failure = error => Failure(error)
+abstract class ParseResult[out T]: (Success[T] | Failure) {
+  virtual fun flatMap(f: (T, ParserState) -> ParseResult['U]): ParseResult['U]
+  virtual fun map(f: T -> 'U): ParseResult['U]
+}
+class Success[out T](value: T, state: ParserState) extends ParseResult[T] {
+  fun flatMap(f) = f(value, state)
+  fun map(f) = success(f(value), state)
+}
+class Failure(error: Str) extends ParseResult[nothing] {
+  fun flatMap(_) = failure(error)
+  fun map(_) = failure(error)
+}
+fun showParseResult(result) = if result is
+  Success(value, state) then "Success after " ++ toString(state.at) ++ ": " ++ toString(value)
+  Failure(error) then "Failure: " ++ toString(error)
+//│ class ParserState(text: NStr, at: Int) {
+//│   fun drained: Bool
+//│   fun match: (prefix: Str) -> Option[ParserState]
+//│   fun next: ParserState
+//│   fun nextDigit: Option[[Num, ParserState]]
+//│   fun peek: Option[NStr]
+//│   fun peekCode: Option[Int]
+//│   fun rest: NStr
+//│ }
+//│ fun showParserState: {at: anything} -> NStr
+//│ fun success: forall 'T. ('T, ParserState) -> Success['T]
+//│ fun failure: Str -> Failure
+//│ abstract class ParseResult[T]: Failure | Success[T] {
+//│   fun flatMap: forall 'U. (f: (T, ParserState) -> ParseResult['U]) -> ParseResult['U]
+//│   fun map: forall 'U0. (f: T -> 'U0) -> ParseResult['U0]
+//│ }
+//│ class Success[T](value: T, state: ParserState) extends ParseResult {
+//│   fun flatMap: forall 'a. ((T, ParserState) -> 'a) -> 'a
+//│   fun map: forall 't. (T -> 't) -> ParseResult['t]
+//│ }
+//│ class Failure(error: Str) extends ParseResult {
+//│   fun flatMap: anything -> ParseResult[nothing]
+//│   fun map: anything -> ParseResult[nothing]
+//│ }
+//│ fun showParseResult: (Failure | Success[anything]) -> NStr
+//│ fun success: forall 't0. ('t0, ParserState) -> ParseResult['t0]
+//│ fun failure: Str -> ParseResult[nothing]
+
+fun isWhiteSpace(ch: NStr): Bool =
+  (ch === " ") || (ch === "\n") || (ch === "\r") || (ch === "\t")
+fun skipWhiteSpace(state: ParserState): ParserState = if state.peek is
+  Some(ch) and isWhiteSpace(ch) then skipWhiteSpace(state.next)
+  else state
+//│ fun isWhiteSpace: (ch: NStr) -> Bool
+//│ fun skipWhiteSpace: (state: ParserState) -> ParserState
+
+(skipWhiteSpace of ParserState(String(" \n\r\t"), 0)).at
+//│ Int
+//│ res
+//│     = 4
+
+fun isDigit(ch) = sge(ch, "0") && sle(ch, "9")
+//│ fun isDigit: Str -> Bool
+
+fun parseNumber(state: ParserState): ParseResult[Num] =
+  let toFraction(n) = n / (10 ** Math.ceil of Math.log10 of n)
+  let parseNegative(state): ParseResult[Bool] = if state.peek is
+    Some("-") then Success(true, state.next)
+    else Success(false, state)
+  // Parse one or more decimal digits
+  // --------------------------------
+  let parseDigits(state): ParseResult[Num] =
+    // Parse remaining digits
+    let rec aux(acc, state) = if state.nextDigit is
+      Some([digit, state']) then aux((acc *. 10) +. digit, state')
+      None then [acc, state]
+    // Parse the first digit
+    if state.nextDigit is
+      Some([digit, state']) and aux(digit, state') is
+        [num, state''] then Success(num, state'')
+      None then Failure("expected one or more decimal digits")
+  // Parse the integral part of the number
+  // -------------------------------------
+  let parseIntegral(state): ParseResult[Num] = if state.nextDigit is
+    Some([0, state']) then Success(0, state')
+    else parseDigits(state)
+  // Parse the fractional part of the number
+  // ---------------------------------------
+  let parseFraction(state): ParseResult[Num] = if state.peek is
+    Some(".") then parseDigits(state.next).map of toFraction
+    else Success(0, state)
+  let parseExponent(state): ParseResult[Num] =
+    let parseSign(state): ParseResult[Bool] = if state.peek is
+      Some("-") then Success(true, state.next)
+      Some("+") then Success(false, state.next)
+      else Success(false, state)
+    if state.peek is Some(e) and (e === "e") || (e === "E") then
+      parseSign(state.next).flatMap of (sign, state) =>
+        parseDigits(state).map of exponent =>
+          if sign then 10 ** (0 -. exponent) else 10 ** exponent
+    else
+      Success(1, state)
+  parseNegative(state).flatMap of (negative, state) =>
+    parseIntegral(state).flatMap of (integral, state) =>
+      parseFraction(state).flatMap of (fraction, state) =>
+        parseExponent(state).flatMap of (exponent, state) =>
+          let value = (integral +. fraction) *. exponent
+          Success(if negative then (0 -. value) else value, state)
+//│ fun parseNumber: (state: ParserState) -> ParseResult[Num]
+
+showParseResult of parseNumber of ParserState of String("0"), 0
+showParseResult of parseNumber of ParserState of String("0234"), 0
+showParseResult of parseNumber of ParserState of String("123"), 0
+showParseResult of parseNumber of ParserState of String("12.34"), 0
+showParseResult of parseNumber of ParserState of String("1e10"), 0
+showParseResult of parseNumber of ParserState of String("1E5"), 0
+showParseResult of parseNumber of ParserState of String("1E-1"), 0
+showParseResult of parseNumber of ParserState of String("1E+1"), 0
+//│ NStr
+//│ res
+//│     = 'Success after 1: 0'
+//│ res
+//│     = 'Success after 1: 0'
+//│ res
+//│     = 'Success after 3: 123'
+//│ res
+//│     = 'Success after 5: 12.34'
+//│ res
+//│     = 'Success after 4: 10000000000'
+//│ res
+//│     = 'Success after 3: 100000'
+//│ res
+//│     = 'Success after 4: 0.1'
+//│ res
+//│     = 'Success after 4: 10'
+
+fun parseString(state: ParserState): ParseResult[Str] =
+  let rec parseCodePoint(n, acc, state) = if
+    n === 0 then Success(acc, state)
+    state.peekCode is Some(code) and
+      48 <= code and code <= 57 then parseCodePoint(n - 1, acc * 16 + code - 48, state.next)
+      65 <= code and code <= 70 then parseCodePoint(n - 1, acc * 16 + code - 55, state.next)
+      97 <= code and code <= 102 then parseCodePoint(n - 1, acc * 16 + code - 87, state.next)
+      else Failure("expect " ++ toString(n) ++ " hex digit(s) instead of '" ++ String.fromCodePoint(code) ++ "'")
+    else Failure("expect " ++ toString(n) ++ " hex digit(s) instead of end of input")
+  let rec parseContent(acc, state) = if state.peek is
+    Some("\"") then Success(acc, state.next)
+    Some("\\") and
+      let state' = state.next
+      state'.peek is
+        Some("\"") then parseContent(acc ++ "\"", state'.next)
+        Some("\\") then parseContent(acc ++ "\\", state'.next)
+        Some("/") then parseContent(acc ++ "/", state'.next)
+        Some("b") then parseContent(acc ++ "\b", state'.next)
+        Some("f") then parseContent(acc ++ "\f", state'.next)
+        Some("n") then parseContent(acc ++ "\n", state'.next)
+        Some("r") then parseContent(acc ++ "\r", state'.next)
+        Some("t") then parseContent(acc ++ "\t", state'.next)
+        Some("u") then
+          parseCodePoint(4, 0, state'.next).flatMap of (codePoint, state) =>
+            if codePoint < 0xD800 || 0xDFFF < codePoint then
+              parseContent(acc ++ String.fromCodePoint(codePoint), state)
+            else Failure("invalid code point")
+        else Failure("invalid escape sequence")
+    Some(ch) then parseContent(acc ++ ch, state.next)
+    None then Failure("expected '\"' instead of end of input")
+  if state.peek is
+    Some("\"") then parseContent("", state.next)
+    Some(ch) then Failure("expected '\"' instead of '" ++ ch ++ "'")
+    else Failure("expected '\"' instead of end of input")
+//│ fun parseString: (state: ParserState) -> ParseResult[Str]
+
+showParseResult of parseString of ParserState of String("\"\""), 0
+showParseResult of parseString of ParserState of String("\"abc\""), 0
+showParseResult of parseString of ParserState of String("\"\\\"\""), 0
+showParseResult of parseString of ParserState of String("\"\\\\\""), 0
+showParseResult of parseString of ParserState of String("\"\\/\""), 0
+showParseResult of parseString of ParserState of String("\"\\b\""), 0
+showParseResult of parseString of ParserState of String("\""), 0
+showParseResult of parseString of ParserState of String("\"\\u\""), 0
+showParseResult of parseString of ParserState of String("\"\\u0\""), 0
+showParseResult of parseString of ParserState of String("\"\\u004c\""), 0
+//│ NStr
+//│ res
+//│     = 'Success after 2: '
+//│ res
+//│     = 'Success after 5: abc'
+//│ res
+//│     = 'Success after 4: "'
+//│ res
+//│     = 'Success after 4: \\'
+//│ res
+//│     = 'Success after 4: /'
+//│ res
+//│     = 'Success after 4: \b'
+//│ res
+//│     = `Failure: expected '"' instead of end of input`
+//│ res
+//│     = `Failure: expect 4 hex digit(s) instead of '"'`
+//│ res
+//│     = `Failure: expect 3 hex digit(s) instead of '"'`
+//│ res
+//│     = 'Success after 8: L'
+
+fun parseTrue(state: ParserState): ParseResult[Bool] =
+  if state.match("true") is
+    Some(state) then Success(true, state)
+    None then Failure("expected 'true'")
+fun parseFalse(state: ParserState): ParseResult[Bool] =
+  if state.match("false") is
+    Some(state) then Success(false, state)
+    None then Failure("expected 'false'")
+fun parseNull(state: ParserState): ParseResult[()] =
+  if state.match("null") is
+    Some(state) then Success((), state)
+    None then Failure("expected 'null'")
+//│ fun parseTrue: (state: ParserState) -> ParseResult[Bool]
+//│ fun parseFalse: (state: ParserState) -> ParseResult[Bool]
+//│ fun parseNull: (state: ParserState) -> ParseResult[()]
+
+fun parseObjectEntry(state: ParserState): ParseResult[[Str, JsonValue]] =
+  let state' = skipWhiteSpace(state)
+  parseString(state').flatMap of (key, state) =>
+    let state' = skipWhiteSpace(state)
+    if state'.peek is
+      Some(":") then
+        parseValue(state'.next).flatMap of (value, state') =>
+          Success([key, value], state')
+      Some(ch) then Failure("expected ':' instead of '" ++ ch ++ "'")
+      None then Failure("expected ':' instead of end of input")
+    else Failure("expected ':' instead of end of input")
+fun parseObject(state: ParserState): ParseResult[ListMap[Str, JsonValue]] =
+  let rec parseObjectTail(acc, state) =
+    let state' = skipWhiteSpace(state)
+    if state'.peek is
+      Some(",") then
+        parseObjectEntry(state'.next).flatMap of (entry, state') =>
+          if containsKey(acc, entry.0) then
+            Failure("duplicate key '" ++ toString(entry.0) ++ "'")
+          else
+            parseObjectTail(ConsMap(entry, acc), state')
+      Some("}") then Success(acc, state'.next)
+      Some(ch) then Failure("expected ',' or ']' instead of " ++ ch)
+      None then Failure("expected ',' or ']' instead of end of input")
+  let state' = skipWhiteSpace(state)
+  if state'.peek is
+    Some("}") then Success(NilMap, state'.next)
+    None then Failure("expected ',' or ']' instead of end of input")
+    else
+      parseObjectEntry(state').flatMap of (head, state) =>
+        parseObjectTail(ConsMap(head, NilMap), state)
+fun parseArray(state: ParserState): ParseResult[List[JsonValue]] =
+  let rec parseArrayTail(acc, state) =
+    let state' = skipWhiteSpace(state)
+    if state'.peek is
+      Some(",") then
+        parseValue(state'.next).flatMap of (value, state') =>
+          parseArrayTail(value :: acc, state')
+      Some("]") then Success(reverse(acc), state'.next)
+      Some(ch) then Failure("expected ',' or ']' instead of " ++ ch)
+      None then Failure("expected ',' or ']' instead of end of input")
+  let state' = skipWhiteSpace(state)
+  if state'.peek is
+    Some("]") then Success(Nil, state'.next)
+    None then Failure("expected ',' or ']' instead of end of input")
+    else
+      parseValue(state').flatMap of (head, state) =>
+        parseArrayTail(head :: Nil, state)
+fun parseValue(state: ParserState): ParseResult[JsonValue] =
+  let state' = skipWhiteSpace(state)
+  if state'.peek is
+    Some(ch) and
+      ch === "\"" then parseString(state').map of JsonString
+      (ch === "-") || isDigit(ch) then parseNumber(state').map of JsonNumber
+      ch === "[" then parseArray(state'.next).map of JsonArray
+      ch === "{" then parseObject(state'.next).map of JsonObject
+      ch === "t" then parseTrue(state').map of JsonBoolean
+      ch === "f" then parseFalse(state').map of JsonBoolean
+      ch === "n" then parseNull(state').map of _ => JsonNull
+      else Failure("cannot recognize " ++ ch ++ " as the beginning of a JSON value")
+    None then Failure("expected a JSON value instead of end of input")
+//│ fun parseObjectEntry: (state: ParserState) -> ParseResult[[Str, JsonValue]]
+//│ fun parseObject: (state: ParserState) -> ParseResult[ListMap[Str, JsonValue]]
+//│ fun parseArray: (state: ParserState) -> ParseResult[List[JsonValue]]
+//│ fun parseValue: (state: ParserState) -> ParseResult[JsonValue]
+
+fun parse(source: Str): ParseResult[JsonValue] =
+  (parseValue of ParserState of String(source), 0).flatMap of (value, finalState) =>
+    let shouldBeEnd = skipWhiteSpace of finalState
+    if shouldBeEnd.drained then
+      Success(value, shouldBeEnd)
+    else
+      Failure("expected end of input instead of: " ++ shouldBeEnd.rest)
+//│ fun parse: (source: Str) -> ParseResult[JsonValue]
+
+fun stringify(value: JsonValue): Str =
+  let stringifyObject(map) =
+    let showEntry([k, v]) = "\"" ++ toString(k) ++ "\": " ++ stringify(v)
+    let rec aux(map) = if map is
+      ConsMap(last, NilMap) then showEntry(last)
+      ConsMap(head, tail) then showEntry(head) ++ ", " ++ aux(tail)
+      NilMap then ""
+    if map is NilMap then String("{}") else "{ " ++ aux(map) ++ " }"
+  if value is
+    JsonNumber(n) then toString(n)
+    JsonString(s) then "\"" ++ s ++ "\""
+    JsonArray(xs) then "[" ++ join(", ", map(stringify, xs)) ++ "]"
+    JsonObject(m) then stringifyObject(m)
+    JsonBoolean(b) then if b then "true" else "false"
+    JsonNull then "null"
+//│ fun stringify: (value: JsonValue) -> Str
+
+fun showResult(result) = if result is
+  Success(value, state) then "Success after " ++ toString(state.at) ++ ": " ++ stringify(value)
+  Failure(error) then "Failure: " ++ toString(error)
+//│ fun showResult: (Failure | Success[JsonValue]) -> NStr
+
+// Simple tests.
+showResult of parse of "null"
+showResult of parse of "true"
+showResult of parse of "false"
+showResult of parse of "123"
+showResult of parse of "\"abc\""
+showResult of parse of "[1, 2, 3]"
+showResult of parse of "{\"a\": 1, \"b\": 2}"
+showResult of parse of "nul"
+showResult of parse of "[1, 3, 5"
+showResult of parse of "[1, 3, 5]"
+//│ NStr
+//│ res
+//│     = 'Success after 4: null'
+//│ res
+//│     = 'Success after 4: true'
+//│ res
+//│     = 'Success after 5: false'
+//│ res
+//│     = 'Success after 3: 123'
+//│ res
+//│     = 'Success after 5: "abc"'
+//│ res
+//│     = 'Success after 9: [1, 2, 3]'
+//│ res
+//│     = 'Success after 16: { "b": 2, "a": 1 }'
+//│ res
+//│     = "Failure: expected 'null'"
+//│ res
+//│     = "Failure: expected ',' or ']' instead of end of input"
+//│ res
+//│     = 'Success after 9: [1, 3, 5]'
+
+// Complicated tests.
+showResult of parse of "{ \"origin\": { \"x\": 0, \"y\": 0 } }"
+showResult of parse of "[   { \"origin\": { \"x\": 0, \"y\": 0 } , \"size\": { \"width\": 100, \"height\": 100 } }   ]"
+showResult of parse of "{\"id\":\"658f34f88882211aa8679240\",\"children\":[{\"name\":\"Jo Rosales\",\"age\":8},{\"name\":\"Shawn Burke\",\"age\":7},{\"name\":\"Gomez Guthrie\",\"age\":10},{\"name\":\"Tandy Christensen\",\"age\":9},{\"name\":\"Jody Langley\",\"age\":3}],\"currentJob\":{\"title\":\"Developer\",\"salary\":\"mask;\"},\"jobs\":[{\"title\":\"medic\",\"salary\":\"R$ 6.400,90\"},{\"title\":\"teacher\",\"salary\":\"R$ 7.960,31\"}],\"maxRunDistance\":14.7,\"cpf\":\"713.763.356-03\",\"cnpj\":\"33.385.435/0001-50\",\"pretendSalary\":\"R$ 9.247,29\",\"age\":63,\"gender\":\"male\",\"firstName\":\"Parker\",\"lastName\":\"Case\",\"phone\":\"+55 (83) 95023-7077\",\"address\":\"14 Orient Avenue - Harmon, Northern Mariana Islands, Myanmar.\",\"hairColor\":\"yellow\"}"
+//│ NStr
+//│ res
+//│     = 'Success after 32: { "origin": { "y": 0, "x": 0 } }'
+//│ res
+//│     = 'Success after 82: [{ "size": { "height": 100, "width": 100 }, "origin": { "y": 0, "x": 0 } }]'
+//│ res
+//│     = 'Success after 647: { "hairColor": "yellow", "address": "14 Orient Avenue - Harmon, Northern Mariana Islands, Myanmar.", "phone": "+55 (83) 95023-7077", "lastName": "Case", "firstName": "Parker", "gender": "male", "age": 63, "pretendSalary": "R$ 9.247,29", "cnpj": "33.385.435/0001-50", "cpf": "713.763.356-03", "maxRunDistance": 14.7, "jobs": [{ "salary": "R$ 6.400,90", "title": "medic" }, { "salary": "R$ 7.960,31", "title": "teacher" }], "currentJob": { "salary": "mask;", "title": "Developer" }, "children": [{ "age": 8, "name": "Jo Rosales" }, { "age": 7, "name": "Shawn Burke" }, { "age": 10, "name": "Gomez Guthrie" }, { "age": 9, "name": "Tandy Christensen" }, { "age": 3, "name": "Jody Langley" }], "id": "658f34f88882211aa8679240" }'
+
+// Nice.

From f81bf0b50e9695aa70c3d8c280ccee6037dcb73f Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Mon, 1 Jan 2024 21:48:23 +0800
Subject: [PATCH 041/147] Address minor issues mentioned in the PR

---
 .../scala/mlscript/pretyper/PreTyper.scala     |  1 -
 .../mlscript/ucs/stages/Transformation.scala   | 18 +++++++++---------
 .../pretyper/ucs/SpecilizationCollision.mls    |  5 +++--
 .../test/diff/pretyper/ucs/examples/ULC.mls    |  8 ++++----
 .../diff/pretyper/ucs/patterns/Literals.mls    | 13 ++++++++++++-
 5 files changed, 28 insertions(+), 17 deletions(-)

diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index 414c150f4f..22fb88f153 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -4,7 +4,6 @@ import collection.mutable.{Set => MutSet}
 import mlscript.ucs.DesugarUCS
 import symbol._
 import mlscript._, utils._, shorthands._
-import mlscript.{Cls, Trt, Mxn, Als, Mod}
 import scala.annotation.tailrec
 import mlscript.Message, Message.MessageContext
 
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index 83851a773b..3939084c04 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -125,20 +125,20 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
       }
     }(_ => "transformPatternMatching ==>")
 
+  private def transformTupleTerm(tuple: Tup): Ls[Opt[Pattern]] =
+    tuple.fields.map {
+      case _ -> Fld(_, Var("_")) => N // Consider "_" as wildcard.
+      case _ -> Fld(_, t) => S(transformPattern(t))
+    }
+
   private def transformPattern(term: Term): Pattern = term match {
     case nme @ Var("true" | "false") => ConcretePattern(nme)
     case nme @ Var(name) if name.headOption.exists(_.isUpper) => ClassPattern(nme, N)
     case nme: Var => NamePattern(nme)
     case literal: Lit => LiteralPattern(literal)
-    case App(classNme @ Var(_), Tup(parameters)) =>
-      ClassPattern(classNme, S(parameters.map {
-        case (_, Fld(_, Var("_"))) => N // Consider "_" as wildcard.
-        case (_, Fld(_, t)) => S(transformPattern(t))
-      }))
-    case Tup(fields) => TuplePattern(fields.map {
-      case _ -> Fld(_, Var("_")) => N // Consider "_" as wildcard.
-      case _ -> Fld(_, t       ) => S(transformPattern(t))
-    })
+    case App(classNme @ Var(_), parameters: Tup) =>
+      ClassPattern(classNme, S(transformTupleTerm(parameters)))
+    case tuple: Tup => TuplePattern(transformTupleTerm(tuple))
     case _ =>
       println(s"unknown pattern: $term")
       throw new TransformException(msg"Unknown pattern", term.toLoc)
diff --git a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
index 1a5264977d..f10c944fef 100644
--- a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
+++ b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
@@ -48,8 +48,9 @@ fun example4(t, x) =
     Base(x) and p1(x) then x
     Derived(y) then y + x
     //                  ^
-    // Oh no, x is captured by x from Base!
-    // Because the branch is absorbed by the previous one.
+    // Note that this branch will be absorbed by the previous one. As the
+    // previous branch shadows the variable `x`, a correct implementation
+    // should restore the original value of `x` in this branch.
     else 42
 //│ fun example4: (Base, Int) -> Int
 
diff --git a/shared/src/test/diff/pretyper/ucs/examples/ULC.mls b/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
index 357d5811d8..9add8993d2 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
@@ -329,11 +329,11 @@ fun combinations(n: Int, acc: List['T], alphabet: List['T], xs: List[Str]): Opti
       else Some(x)
     else
       search((x) => combinations(n - 1, x :: acc, alphabet, xs), alphabet)
-//│ fun combinations: forall 'T 'A 'T0. (n: Int, acc: List['T], alphabet: List['T0], xs: List[Str]) -> Option[Str]
+//│ fun combinations: forall 'T 'T0 'A. (n: Int, acc: List['T0], alphabet: List['T], xs: List[Str]) -> Option[Str]
 //│   where
-//│     'T0 <: 'T & 'A
-//│     'T :> 'A
-//│     'A := 'T
+//│     'T <: 'T0 & 'A
+//│     'T0 :> 'A
+//│     'A := 'T0
 
 combinations(1, Nil, 1 :: 2 :: 3 :: Nil, Nil) |> showOption
 combinations(2, Nil, 1 :: 2 :: 3 :: Nil, Nil) |> showOption
diff --git a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
index 4bec2657a6..fe9713c694 100644
--- a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
+++ b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
@@ -12,13 +12,24 @@ class Pair[A, B](x: A, y: B)
 fun f(x) = if x is Some(1) then true else false
 //│ fun f: (Object & ~#Some | Some[Eql[1]]) -> Bool
 
+:e
+// TODO: Proper diagnostic information reporting.
+fun f(x) = if x is Some(1) then true
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.17: 	fun f(x) = if x is Some(1) then true
+//│ ║        	                                ^^^^
+//│ ╟── application of type `Bool` is not an instance of type `true`
+//│ ║  l.17: 	fun f(x) = if x is Some(1) then true
+//│ ╙──      	                        ^
+//│ fun f: Some[Eql[1]] -> true
+
 fun g(x) = if x then 1 else 2
 //│ fun g: Bool -> (1 | 2)
 
 :e
 fun test_must_be_boolean(x) = if 0 then 1 else 2
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.19: 	fun test_must_be_boolean(x) = if 0 then 1 else 2
+//│ ║  l.30: 	fun test_must_be_boolean(x) = if 0 then 1 else 2
 //│ ║        	                                 ^
 //│ ╙── integer literal of type `0` is not an instance of type `Bool`
 //│ fun test_must_be_boolean: anything -> (1 | 2)

From 9469158165b2fb1163b7a41ab264a5f3cc9b4204 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 2 Jan 2024 17:28:01 +0800
Subject: [PATCH 042/147] Add `Diagnosable` and report errors during
 transformation stage

---
 .../scala/mlscript/pretyper/Diagnosable.scala |  26 ++++
 .../scala/mlscript/pretyper/PreTyper.scala    |  15 +-
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |   2 +-
 .../mlscript/ucs/stages/Desugaring.scala      |  20 +--
 .../mlscript/ucs/stages/Transformation.scala  | 136 +++++++++---------
 .../src/main/scala/mlscript/ucs/syntax.scala  |  26 +++-
 .../test/diff/pretyper/ucs/RecordPattern.mls  |   2 +-
 .../src/test/scala/mlscript/DiffTests.scala   |   2 +-
 8 files changed, 138 insertions(+), 91 deletions(-)
 create mode 100644 shared/src/main/scala/mlscript/pretyper/Diagnosable.scala

diff --git a/shared/src/main/scala/mlscript/pretyper/Diagnosable.scala b/shared/src/main/scala/mlscript/pretyper/Diagnosable.scala
new file mode 100644
index 0000000000..332da9f9cb
--- /dev/null
+++ b/shared/src/main/scala/mlscript/pretyper/Diagnosable.scala
@@ -0,0 +1,26 @@
+package mlscript.pretyper
+
+import scala.collection.mutable.Buffer
+import mlscript.{Diagnostic, ErrorReport, Loc, Message, WarningReport}, Diagnostic.Source, Message.MessageContext
+import mlscript.utils._, shorthands._
+
+/**
+  * A trait containing a mutable buffer of diagnostics.
+  */
+trait Diagnosable {
+  private val diagnosticBuffer = Buffer.empty[Diagnostic]
+  
+  protected def raise(diagnostics: Diagnostic): Unit =
+    diagnosticBuffer += diagnostics
+
+  protected def raiseMany(diagnostics: IterableOnce[Diagnostic]): Unit =
+    diagnosticBuffer ++= diagnostics
+
+  protected def raiseError(source: Source, messages: (Message -> Opt[Loc])*): Unit =
+    raise(ErrorReport(messages.toList, newDefs = true, source))
+
+  protected def raiseWarning(source: Source, messages: (Message -> Opt[Loc])*): Unit =
+    raise(WarningReport(messages.toList, newDefs = true, source))
+
+  def getDiagnostics: Ls[Diagnostic] = diagnosticBuffer.toList
+}
diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index 22fb88f153..0fd4900140 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -7,12 +7,9 @@ import mlscript._, utils._, shorthands._
 import scala.annotation.tailrec
 import mlscript.Message, Message.MessageContext
 
-class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with DesugarUCS {
+class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with Diagnosable with DesugarUCS {
   import PreTyper._
 
-  protected def raise(diagnostics: Diagnostic): Unit = ()
-  protected def raise(diagnostics: Ls[Diagnostic]): Unit = ()
-
   private def extractParameters(fields: Term): Ls[LocalTermSymbol] =
     trace(s"extractParameters <== ${inspect.deep(fields)}") {
       fields match {
@@ -218,6 +215,16 @@ object PreTyper {
     rec(Nil, parents)
   }
 
+  /**
+    * Extract types in class signatures. For example, for this piece of code
+    * ```mls
+    * abstract class Option[A]: Some[A] | None
+    * ```
+    * this function returns, `Some` and `None`.
+    *
+    * @param ty a type obtained from `NuTypeDef.sig`
+    * @return a list of type names, without any parameters
+    */
   def extractSignatureTypes(ty: Type): Ls[TypeName] = {
     @tailrec
     def rec(acc: Ls[TypeName], ty: Type): Ls[TypeName] = ty match {
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 7143660c62..aed60275a6 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -138,7 +138,7 @@ trait DesugarUCS extends Transformation
         val checked = println("STEP 4")
         val diagnostics = checkCoverage(postProcessed)
         println(s"Coverage checking result: ${diagnostics.size} errors")
-        raise(diagnostics)
+        raiseMany(diagnostics)
       }
       // Epilogue
       `if`.desugaredTerm = S(postProcessed)
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 52058db3ad..0a812d87c7 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -133,17 +133,17 @@ trait Desugaring { self: PreTyper =>
   private def flattenClassParameters(
       parentScrutineeVar: Var,
       parentClassLikeSymbol: TypeSymbol,
-      parameters: Ls[Opt[s.Pattern]]
+      parameters: Ls[s.Pattern]
   )(implicit context: Context): Ls[Opt[Var -> Opt[s.Pattern]]] =
     trace(s"flattenClassParameters <== ${parentScrutineeVar.name} is ${parentClassLikeSymbol.name}") {
       // Make it `lazy` so that it will not be created if all fields are wildcards.
       lazy val classPattern = parentScrutineeVar.getOrCreateScrutinee.getOrCreateClassPattern(parentClassLikeSymbol)
       parameters.iterator.zipWithIndex.map {
-        case (N, _) => N
-        case (S(s.NamePattern(name)), index) =>
+        case (_: s.EmptyPattern, _) => N
+        case (s.NamePattern(name), index) =>
           val subScrutinee = classPattern.getParameter(index).withAlias(name)
           S(name.withFreshSymbol.withScrutinee(subScrutinee) -> N)
-        case (S(parameterPattern @ (s.ClassPattern(_, _) | s.LiteralPattern(_) | s.TuplePattern(_))), index) =>
+        case (parameterPattern @ (s.ClassPattern(_, _) | s.LiteralPattern(_) | s.TuplePattern(_)), index) =>
           val subScrutineeVar = freshSubScrutinee(parentScrutineeVar, parentClassLikeSymbol.name, index)
           val symbol = new LocalTermSymbol(subScrutineeVar)
           symbol.addScrutinee(classPattern.getParameter(index).withAlias(subScrutineeVar))
@@ -251,14 +251,14 @@ trait Desugaring { self: PreTyper =>
       }
     }()
 
-  private def flattenTupleFields(parentScrutineeVar: Var, fields: Ls[Opt[s.Pattern]])(implicit context: Context): Ls[Opt[Var -> Opt[s.Pattern]]] = {
+  private def flattenTupleFields(parentScrutineeVar: Var, fields: Ls[s.Pattern])(implicit context: Context): Ls[Opt[Var -> Opt[s.Pattern]]] = {
     // Make it `lazy` so that it will not be created if all fields are wildcards.
     lazy val tuplePattern = parentScrutineeVar.getOrCreateScrutinee.getOrCreateTuplePattern
     fields.iterator.zipWithIndex.map {
-      case (N, _) => N
-      case (S(s.NamePattern(name)), index) =>
+      case (_: s.EmptyPattern, _) => N
+      case (s.NamePattern(name), index) =>
         S(name.withFreshSymbol.withScrutinee(tuplePattern.getField(index)) -> N)
-      case (S(parameterPattern @ (s.ClassPattern(_, _) | s.LiteralPattern(_) | s.TuplePattern(_))), index) =>
+      case (parameterPattern @ (s.ClassPattern(_, _) | s.LiteralPattern(_) | s.TuplePattern(_)), index) =>
         val arity = fields.length
         val subScrutineeVar = freshSubScrutinee(parentScrutineeVar, s"Tuple$$$arity", index)
         val symbol = new LocalTermSymbol(subScrutineeVar)
@@ -268,7 +268,7 @@ trait Desugaring { self: PreTyper =>
     }.toList
   }
 
-  private def desugarTuplePattern(fields: Ls[Opt[s.Pattern]], scrutineeVar: Var, initialScope: Scope)(implicit context: Context): (Scope, c.Split => c.Split) = {
+  private def desugarTuplePattern(fields: Ls[s.Pattern], scrutineeVar: Var, initialScope: Scope)(implicit context: Context): (Scope, c.Split => c.Split) = {
     val scrutinee = scrutineeVar.getOrCreateScrutinee.withAlias(scrutineeVar)
     val nestedPatterns = flattenTupleFields(scrutineeVar, fields)
     val bindFields = nestedPatterns.iterator.zipWithIndex.foldRight[c.Split => c.Split](identity) {
@@ -310,7 +310,7 @@ trait Desugaring { self: PreTyper =>
                 continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope + test.symbol, context)
               ) :: rec(scrutineeVar, tail)
             )
-          case s.NamePattern(Var("_")) =>
+          case s.EmptyPattern(_) | s.NamePattern(Var("_")) =>
             desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context) ++ rec(scrutineeVar, tail)
           case s.NamePattern(nme) =>
             // Create a symbol for the binding.
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index 3939084c04..14f613c3b3 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -3,6 +3,8 @@ package mlscript.ucs.stages
 import mlscript.ucs.helpers
 import mlscript.{If, IfBody, IfBlock, IfElse, IfLet, IfOpApp, IfOpsApp, IfThen}
 import mlscript.{Term, Var, App, Tup, Lit, Fld, Loc}
+import mlscript.Diagnostic.PreTyping
+import mlscript.pretyper.{Diagnosable, Traceable}
 import mlscript.ucs.syntax._
 import mlscript.Message, Message._
 import mlscript.utils._, shorthands._
@@ -17,70 +19,63 @@ import scala.collection.immutable
   * The AST in the paper is more flexible. For example, it allows interleaved
   * `let` bindings in operator splits.
   */
-trait Transformation { self: mlscript.pretyper.Traceable =>
+trait Transformation { self: Traceable with Diagnosable =>
   import Transformation._
 
+  /** The entry point of transformation. */
   def transform(`if`: If): TermSplit =
     transformIfBody(`if`.body) ++ `if`.els.fold(Split.empty)(Split.default)
 
+  /**
+    * Transform a conjunction of terms into a nested split. The conjunction is
+    * of the following form.
+    * ```
+    * conjunction ::= term "is" term conjunction-tail
+    *               | "_" conjunction-tail
+    *               | term conjunction-tail
+    * conjunction-tail ::= "and" conjunction
+    *                    | ε
+    * ```
+    * @param init a list of term representing the conjunction
+    * @param last the innermost split we should take if all terms of the
+    *             conjunction work
+    * @return
+    */
+  private def transformConjunction[B <: Branch](init: Ls[Term], last: TermSplit, skipWildcard: Bool): TermSplit =
+    init.foldRight(last) {
+      case (scrutinee is pattern, following) =>
+        val branch = PatternBranch(transformPattern(pattern), following).toSplit
+        TermBranch.Match(scrutinee, branch).toSplit
+      // Maybe we don't need `skipWildcard` flag and we should take care of
+      // wildcards at _this_ level in all cases.
+      case (Var("_"), following) if skipWildcard => following
+      case (test, following) => TermBranch.Boolean(test, following).toSplit
+    }
+
   private def transformIfBody(body: IfBody): TermSplit = trace(s"transformIfBody <== ${inspect.shallow(body)}") {
     body match {
-      case IfThen(expr, rhs) =>
-        splitAnd(expr).foldRight(Split.then(rhs)) {
-          case (OperatorIs(scrutinee, pattern), acc) =>
-            TermBranch.Match(scrutinee, PatternBranch(transformPattern(pattern), acc) |> Split.single) |> Split.single
-          case (Var("_"), acc) => acc
-          case (test, acc) => TermBranch.Boolean(test, acc) |> Split.single
-        }
+      case IfThen(expr, rhs) => transformConjunction(splitAnd(expr), Split.then(rhs), true)
       case IfLet(isRec, name, rhs, body) => rare
       case IfElse(expr) => Split.then(expr)
       case IfOpApp(lhs, Var("is"), rhs) =>
-        splitAnd(lhs) match {
-          case tests :+ scrutinee =>
-            tests.foldRight[TermSplit](TermBranch.Match(scrutinee, transformPatternMatching(rhs)) |> Split.single) {
-              case (OperatorIs(scrutinee, pattern), acc) =>
-                TermBranch.Match(scrutinee, PatternBranch(transformPattern(pattern), acc) |> Split.single) |> Split.single
-              case (test, acc) => TermBranch.Boolean(test, acc) |> Split.single
-            }
-          case _ => rare
-        }
-      case IfOpApp(lhs, Var("and"), rhs) =>
-        splitAnd(lhs).foldRight(transformIfBody(rhs)) {
-          case (OperatorIs(scrutinee, pattern), acc) =>
-            TermBranch.Match(scrutinee, PatternBranch(transformPattern(pattern), acc) |> Split.single) |> Split.single
-          case (Var("_"), acc) => acc
-          case (test, acc) => TermBranch.Boolean(test, acc) |> Split.single
-        }
+        val (tests, scrutinee) = extractLast(splitAnd(lhs))
+        transformConjunction(tests, TermBranch.Match(scrutinee, transformPatternMatching(rhs)).toSplit, false)
+      case IfOpApp(lhs, Var("and"), rhs) => transformConjunction(splitAnd(lhs), transformIfBody(rhs), true)
       case IfOpApp(lhs, op, rhs) => 
-        splitAnd(lhs) match {
-          case init :+ last =>
-            val first = TermBranch.Left(last, OperatorBranch.Binary(op, transformIfBody(rhs)) |> Split.single) |> Split.single
-            init.foldRight[TermSplit](first) {
-              case (OperatorIs(scrutinee, pattern), acc) =>
-                TermBranch.Match(scrutinee, PatternBranch(transformPattern(pattern), acc) |> Split.single) |> Split.single
-              case (test, acc) => TermBranch.Boolean(test, acc) |> Split.single
-            }
-          case _ => rare
-        }
+        val (init, last) = extractLast(splitAnd(lhs))
+        transformConjunction(init, TermBranch.Left(last, OperatorBranch.Binary(op, transformIfBody(rhs)).toSplit).toSplit, false)
       case IfBlock(lines) =>
         lines.foldLeft(Split.empty[TermBranch]) {
           case (acc, L(body)) => acc ++ transformIfBody(body)
           case (acc, R(NuFunDef(S(rec), nme, _, _, L(rhs)))) =>
             acc ++ Split.Let(rec, nme, rhs, Split.Nil)
           case (acc, R(statement)) =>
-            throw new TransformException(msg"Unexpected statement in an if block", statement.toLoc)
+            raiseError(PreTyping, msg"Unexpected statement in an if block" -> statement.toLoc)
+            acc
         }
       case IfOpsApp(lhs, opsRhss) =>
-        splitAnd(lhs) match {
-          case init :+ last =>
-            val first = TermBranch.Left(last, Split.from(opsRhss.map(transformOperatorBranch))) |> Split.single
-            init.foldRight[TermSplit](first) {
-              case (OperatorIs(scrutinee, pattern), acc) =>
-                TermBranch.Match(scrutinee, PatternBranch(transformPattern(pattern), acc) |> Split.single) |> Split.single
-              case (test, acc) => TermBranch.Boolean(test, acc) |> Split.single
-            }
-          case _ => rare
-        }
+        val (init, last) = extractLast(splitAnd(lhs))
+        transformConjunction(init, TermBranch.Left(last, Split.from(opsRhss.map(transformOperatorBranch))).toSplit, false)
     }
   }(_ => "transformIfBody ==> ")
   
@@ -99,17 +94,17 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
         case IfThen(expr, rhs) => 
           separatePattern(expr) match {
             case (pattern, S(extraTest)) =>
-              PatternBranch(pattern, transformIfBody(IfThen(extraTest, rhs))) |> Split.single
+              PatternBranch(pattern, transformIfBody(IfThen(extraTest, rhs))).toSplit
             case (pattern, N) =>
-              PatternBranch(pattern, Split.default(rhs)) |> Split.single
+              PatternBranch(pattern, Split.default(rhs)).toSplit
           }
         case IfOpApp(lhs, Var("and"), rhs) =>
           println(s"lhs: ${inspect.deep(lhs)}")
           separatePattern(lhs) match {
             case (pattern, S(extraTest)) =>
-              PatternBranch(pattern, TermBranch.Boolean(extraTest, transformIfBody(rhs)) |> Split.single) |> Split.single
+              PatternBranch(pattern, TermBranch.Boolean(extraTest, transformIfBody(rhs)).toSplit).toSplit
             case (pattern, N) =>
-              PatternBranch(pattern, transformIfBody(rhs)) |> Split.single
+              PatternBranch(pattern, transformIfBody(rhs)).toSplit
           }
         case IfOpApp(lhs, op, rhs) => ??? // <-- Syntactic split of patterns are not supported.
         case IfOpsApp(lhs, opsRhss) => ??? // <-- Syntactic split of patterns are not supported.
@@ -119,19 +114,25 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
           case (acc, R(NuFunDef(S(rec), nme, _, _, L(rhs)))) =>
             acc ++ Split.Let(rec, nme, rhs, Split.Nil)
           case (acc, R(statement)) =>
-            throw new TransformException(msg"Unexpected statement in an if block", statement.toLoc)
+            raiseError(PreTyping, msg"Unexpected statement in an if block" -> statement.toLoc)
+            acc
         }
         case IfElse(expr) => Split.default(expr)
       }
     }(_ => "transformPatternMatching ==>")
 
-  private def transformTupleTerm(tuple: Tup): Ls[Opt[Pattern]] =
-    tuple.fields.map {
-      case _ -> Fld(_, Var("_")) => N // Consider "_" as wildcard.
-      case _ -> Fld(_, t) => S(transformPattern(t))
-    }
+  private def transformTupleTerm(tuple: Tup): Ls[Pattern] =
+    tuple.fields.map(_._2.value |> transformPattern)
 
+  /**
+    * If we know the `term` represents a pattern, we can transform it to a
+    * pattern with this function.
+    *
+    * @param term the term representing a pattern
+    * @return 
+    */
   private def transformPattern(term: Term): Pattern = term match {
+    case wildcard @ Var("_") => EmptyPattern(wildcard) // The case for wildcard.
     case nme @ Var("true" | "false") => ConcretePattern(nme)
     case nme @ Var(name) if name.headOption.exists(_.isUpper) => ClassPattern(nme, N)
     case nme: Var => NamePattern(nme)
@@ -139,9 +140,10 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
     case App(classNme @ Var(_), parameters: Tup) =>
       ClassPattern(classNme, S(transformTupleTerm(parameters)))
     case tuple: Tup => TuplePattern(transformTupleTerm(tuple))
-    case _ =>
-      println(s"unknown pattern: $term")
-      throw new TransformException(msg"Unknown pattern", term.toLoc)
+    case other =>
+      println(s"other $other")
+      raiseError(PreTyping, msg"Unknown pattern ${other.toString}" -> other.toLoc)
+      EmptyPattern(other)
   }
 
   private def separatePattern(term: Term): (Pattern, Opt[Term]) = {
@@ -151,8 +153,6 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
     (transformPattern(rawPattern), extraTest)
   }
 
-  private def rare: Nothing = throw new TransformException(msg"Wow, a rare case.", N)
-
   private def splitAnd(t: Term): Ls[Term] = trace(s"splitAnd <== ${inspect.deep(t)}") {
     t match {
       case App(
@@ -169,15 +169,17 @@ trait Transformation { self: mlscript.pretyper.Traceable =>
 }
 
 object Transformation {
-  private object OperatorIs {
+  private def rare: Nothing = lastWords("found a very rare case during desugaring UCS terms")
+
+  private def extractLast[T](xs: List[T]): (List[T], T) = xs match {
+    case init :+ last => init -> last
+    case _ => rare
+  }
+
+  private object is {
     def unapply(term: Term): Opt[(Term, Term)] = term match {
-      // case App(App(Var("is"), Tup(_ -> Fld(_, scrutinee) :: Nil)), Tup(_ -> Fld(_, pattern) :: Nil)) if !useNewDefs => S(scrutinee -> pattern)
       case App(Var("is"), PlainTup(scrutinee, pattern)) => S(scrutinee -> pattern)
       case _ => N
     }
   }
-
-  class TransformException(val messages: Ls[Message -> Opt[Loc]]) extends Throwable {
-    def this(message: Message, location: Opt[Loc]) = this(message -> location :: Nil)
-  }
-}
\ No newline at end of file
+}
diff --git a/shared/src/main/scala/mlscript/ucs/syntax.scala b/shared/src/main/scala/mlscript/ucs/syntax.scala
index 433cd835c2..cbf1879753 100644
--- a/shared/src/main/scala/mlscript/ucs/syntax.scala
+++ b/shared/src/main/scala/mlscript/ucs/syntax.scala
@@ -12,10 +12,11 @@ package object syntax {
       case LiteralPattern(literal) => literal.toString
       case ConcretePattern(nme) => s"`${nme.name}`"
       case NamePattern(nme) => nme.toString
+      case EmptyPattern(_) => "•"
       case ClassPattern(Var(name), N) => name
       case ClassPattern(Var(name), S(parameters)) =>
-        parameters.iterator.map(_.fold("_")(_.toString)).mkString(s"$name(", ", ", ")")
-      case TuplePattern(fields) => fields.iterator.map(_.fold("_")(_.toString)).mkString("(", ", ", ")")
+        parameters.mkString(s"$name(", ", ", ")")
+      case TuplePattern(fields) => fields.mkString("(", ", ", ")")
       case RecordPattern(Nil) => "{}"
       case RecordPattern(entries) => entries.iterator.map { case (nme, als) => s"$nme: $als" }.mkString("{ ", ", ", " }")
     }
@@ -32,11 +33,18 @@ package object syntax {
   final case class NamePattern(nme: Var) extends Pattern {
     override def children: List[Located] = nme :: Nil
   }
-  final case class ClassPattern(val nme: Var, val parameters: Opt[List[Opt[Pattern]]]) extends Pattern {
-    override def children: List[Located] = nme :: parameters.fold(List.empty[Located])(_.flatten)
+  /**
+    * Represents wildcard patterns or missing patterns which match everything.
+    * Should be transformed from `Var("_")` or unrecognized terms.
+    */
+  final case class EmptyPattern(source: Term) extends Pattern {
+    override def children: List[Located] = source :: Nil
   }
-  final case class TuplePattern(fields: List[Opt[Pattern]]) extends Pattern {
-    override def children: List[Located] = fields.flatten
+  final case class ClassPattern(val nme: Var, val parameters: Opt[List[Pattern]]) extends Pattern {
+    override def children: List[Located] = nme :: parameters.getOrElse(Nil)
+  }
+  final case class TuplePattern(fields: List[Pattern]) extends Pattern {
+    override def children: List[Located] = fields
   }
   final case class RecordPattern(entries: List[(Var -> Pattern)]) extends Pattern {
     override def children: List[Located] = entries.iterator.flatMap { case (nme, als) => nme :: als :: Nil }.toList
@@ -76,7 +84,9 @@ package object syntax {
 
   sealed abstract class Branch extends Located
 
-  sealed abstract class TermBranch extends Branch
+  sealed abstract class TermBranch extends Branch {
+    final def toSplit: TermSplit = Split.single(this)
+  }
   object TermBranch {
     final case class Boolean(test: Term, continuation: TermSplit) extends TermBranch {
       override def children: List[Located] = test :: continuation :: Nil
@@ -92,6 +102,7 @@ package object syntax {
 
   sealed abstract class OperatorBranch extends Branch {
     val operator: Var
+    final def toSplit: OperatorSplit = Split.single(this)
   }
   object OperatorBranch {
     final case class Match(override val operator: Var, continuation: PatternSplit) extends OperatorBranch {
@@ -105,6 +116,7 @@ package object syntax {
 
   final case class PatternBranch(val pattern: Pattern, val continuation: TermSplit) extends Branch {
     override def children: List[Located] = pattern :: continuation :: Nil
+    final def toSplit: PatternSplit = Split.single(this)
   }
   type PatternSplit = Split[PatternBranch]
 }
diff --git a/shared/src/test/diff/pretyper/ucs/RecordPattern.mls b/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
index ed86bd8af0..c686cff3b1 100644
--- a/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
+++ b/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
@@ -5,4 +5,4 @@ fun take_1(p) =
   if p is
     { x, y } then x + y
     else 0
-//│ /!!!\ Uncaught error: mlscript.ucs.stages.Transformation$TransformException
+//│ /!!!\ Uncaught error: java.lang.Exception: Variable x not found in scope
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index 99898c7461..a3f247cdeb 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -525,11 +525,11 @@ class DiffTests
               val rootTypingUnit = TypingUnit(p.tops)
               if (usePreTyper) {
                 val preTyper = new PreTyper(mode.dbgPreTyper) {
-                  override protected def raise(diagnostics: Ls[Diagnostic]): Unit = report(diagnostics)
                   override def emitString(str: String): Unit = output(str)
                 }
                 // This should be passed to code generation somehow.
                 preTyperScope = preTyper.process(rootTypingUnit, preTyperScope, "<root>")._1
+                report(preTyper.getDiagnostics)
               }
               val tpd = typer.typeTypingUnit(rootTypingUnit, N)(ctx, raise, vars)
               

From 13ddcf037c36ceeec2b9d21c30daa73df1dcac19 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 2 Jan 2024 17:59:44 +0800
Subject: [PATCH 043/147] Report errors during desugaring stage

---
 .../scala/mlscript/pretyper/PreTyper.scala    | 17 +++++-----
 .../mlscript/ucs/stages/Desugaring.scala      | 22 +++++++++----
 .../test/diff/pretyper/ucs/RecordPattern.mls  | 21 ++++++++++--
 .../pretyper/ucs/SpecilizationCollision.mls   | 18 ++++++++--
 .../test/diff/pretyper/ucs/TuplePattern.mls   |  9 -----
 .../{Overlaps.mls => coverage/Refinement.mls} | 26 +++++++--------
 .../pretyper/ucs/patterns/SimpleTuple.mls     | 33 +++++++++++++++++++
 .../ucs/{ => stages}/TransfromUCS.mls         |  0
 8 files changed, 106 insertions(+), 40 deletions(-)
 delete mode 100644 shared/src/test/diff/pretyper/ucs/TuplePattern.mls
 rename shared/src/test/diff/pretyper/ucs/{Overlaps.mls => coverage/Refinement.mls} (81%)
 rename shared/src/test/diff/pretyper/ucs/{ => stages}/TransfromUCS.mls (100%)

diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index 0fd4900140..9b60a5ac32 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -1,11 +1,9 @@
 package mlscript.pretyper
 
 import collection.mutable.{Set => MutSet}
-import mlscript.ucs.DesugarUCS
 import symbol._
-import mlscript._, utils._, shorthands._
+import mlscript._, utils._, shorthands._, Diagnostic.PreTyping, Message.MessageContext, ucs.DesugarUCS
 import scala.annotation.tailrec
-import mlscript.Message, Message.MessageContext
 
 class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with Diagnosable with DesugarUCS {
   import PreTyper._
@@ -52,8 +50,10 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
             case S(sym: ClassSymbol) =>
               println(s"Resolve variable $v to a class.")
               v.symbol = sym
-            case S(_) => throw new Exception(s"Name $v refers to a type")
-            case N => throw new Exception(s"Variable $v not found in scope")
+            case S(_) =>
+              raiseError(PreTyping, msg"Name ${v.name} refers to a type" -> v.toLoc)
+            case N =>
+              raiseError(PreTyping, msg"Variable ${v.name} not found in scope" -> v.toLoc)
           }
       }
     }()
@@ -63,9 +63,10 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
       v.symbolOption match {
         case N => resolveVar(v)
         case S(symbol) => scope.getSymbols(v.name) match {
-          case Nil => throw new Exception(s"Variable $v not found in scope. It is possibly a free variable.")
+          case Nil => raiseError(PreTyping, msg"Variable ${v.name} not found in scope. It is possibly a free variable." -> v.toLoc)
           case symbols if symbols.contains(symbol) => ()
-          case _ => throw new Exception(s"Variable $v refers to a different symbol")
+          case _ =>
+            raiseError(PreTyping, msg"Variable ${v.name} refers to different symbols." -> v.toLoc)
         }
       }
     }()
@@ -223,7 +224,7 @@ object PreTyper {
     * this function returns, `Some` and `None`.
     *
     * @param ty a type obtained from `NuTypeDef.sig`
-    * @return a list of type names, without any parameters
+    * @return a list of type names, without any p
     */
   def extractSignatureTypes(ty: Type): Ls[TypeName] = {
     @tailrec
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 0a812d87c7..c9a38c73db 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -7,7 +7,7 @@ import mlscript.ucs.helpers.mkBinOp
 import mlscript.utils._, shorthands._
 import mlscript.pretyper.symbol._
 import mlscript.pretyper.{PreTyper, Scope}
-import mlscript.ucs.DesugaringException
+import mlscript.Diagnostic.PreTyping
 import mlscript.Message, Message.MessageContext
 
 /**
@@ -148,7 +148,9 @@ trait Desugaring { self: PreTyper =>
           val symbol = new LocalTermSymbol(subScrutineeVar)
           symbol.addScrutinee(classPattern.getParameter(index).withAlias(subScrutineeVar))
           S(subScrutineeVar.withSymbol(symbol) -> S(parameterPattern))
-        case _ => ??? // Other patterns are not implemented yet.
+        case (pattern, _) =>
+          raiseError(PreTyping, msg"unsupported pattern" -> pattern.toLoc)
+          N
       }.toList
     }(r => s"flattenClassParameters ==> ${r.mkString(", ")}")
 
@@ -244,7 +246,9 @@ trait Desugaring { self: PreTyper =>
           val (scopeWithNestedAll, bindNestedAll) = desugarTuplePattern(fields, nme, scope)
           (scopeWithNestedAll, bindNestedAll.andThen(bindPrevious))
         // Well, other patterns are not supported yet.
-        case (acc, S((nme, pattern))) => ???
+        case (acc, S(nme -> S(pattern))) =>
+          raiseError(PreTyping, msg"unsupported pattern is" -> pattern.toLoc)
+          acc
         // If this parameter is empty (e.g. produced by wildcard), then we do
         // nothing and pass on scope and binder.
         case (acc, N) => acc
@@ -264,7 +268,9 @@ trait Desugaring { self: PreTyper =>
         val symbol = new LocalTermSymbol(subScrutineeVar)
         symbol.addScrutinee(tuplePattern.getField(index).withAlias(subScrutineeVar))
         S(subScrutineeVar.withSymbol(symbol) -> S(parameterPattern))
-      case _ => ???
+      case (pattern, _) =>
+        raiseError(PreTyping, msg"unsupported pattern" -> pattern.toLoc)
+        N
     }.toList
   }
 
@@ -285,7 +291,9 @@ trait Desugaring { self: PreTyper =>
     def rec(scrutineeVar: Var, split: s.PatternSplit)(implicit scope: Scope): c.Split = split match {
       case s.Split.Cons(head, tail) => 
         head.pattern match {
-          case s.AliasPattern(nme, pattern) => ???
+          case pattern @ s.AliasPattern(_, _) =>
+            raiseError(PreTyping, msg"alias pattern is not supported for now" -> pattern.toLoc)
+            rec(scrutineeVar, tail)
           case s.LiteralPattern(literal) =>
             val test = context.freshTest().withFreshSymbol
             c.Split.Let(
@@ -338,7 +346,9 @@ trait Desugaring { self: PreTyper =>
             } else {
               withBindings ++ rec(scrutineeVar, tail)
             }
-          case s.RecordPattern(entries) => ???
+          case pattern @ s.RecordPattern(_) =>
+            raiseError(PreTyping, msg"record pattern is not supported for now" -> pattern.toLoc)
+            rec(scrutineeVar, tail)
         }
       case s.Split.Let(isRec, nme, rhs, tail) =>
         c.Split.Let(isRec, nme, rhs, rec(scrutineeVar, tail)(scope + nme.withFreshSymbol.symbol)) // <-- Weird use.
diff --git a/shared/src/test/diff/pretyper/ucs/RecordPattern.mls b/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
index c686cff3b1..61500fd805 100644
--- a/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
+++ b/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
@@ -1,8 +1,25 @@
 :PreTyper
 
-// FIXME
+:e
 fun take_1(p) =
   if p is
     { x, y } then x + y
     else 0
-//│ /!!!\ Uncaught error: java.lang.Exception: Variable x not found in scope
+//│ ╔══[ERROR] Unknown pattern '{' {x: x, y: y} '}'
+//│ ║  l.6: 	    { x, y } then x + y
+//│ ╙──     	    ^^^^^^^^
+//│ ╔══[ERROR] Variable x not found in scope
+//│ ║  l.6: 	    { x, y } then x + y
+//│ ╙──     	                  ^
+//│ ╔══[ERROR] Variable y not found in scope
+//│ ║  l.6: 	    { x, y } then x + y
+//│ ╙──     	                      ^
+//│ ╔══[ERROR] identifier not found: x
+//│ ║  l.6: 	    { x, y } then x + y
+//│ ╙──     	                  ^
+//│ ╔══[ERROR] identifier not found: y
+//│ ║  l.6: 	    { x, y } then x + y
+//│ ╙──     	                      ^
+//│ fun take_1: anything -> Int
+//│ Code generation encountered an error:
+//│   unresolved symbol x
diff --git a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
index f10c944fef..19a29b08d3 100644
--- a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
+++ b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
@@ -21,13 +21,27 @@ fun example1(p) =
     else "nah"
 //│ fun example1: (Object & ~#Pair | Pair[Num, Num]) -> ("both negative" | "both positive" | "nah")
 
-// FIXME: The error should be handled gracefully.
+:e
 fun example2(p) =
   if p is
     Pair(x, y) and p1(x) and p1(y) then "both negative"
     Pair(a, b) and p2(a) and p2(b) then x + y
     else "nah"
-//│ /!!!\ Uncaught error: java.lang.Exception: Variable x not found in scope
+//│ ╔══[ERROR] Variable x not found in scope
+//│ ║  l.28: 	    Pair(a, b) and p2(a) and p2(b) then x + y
+//│ ╙──      	                                        ^
+//│ ╔══[ERROR] Variable y not found in scope
+//│ ║  l.28: 	    Pair(a, b) and p2(a) and p2(b) then x + y
+//│ ╙──      	                                            ^
+//│ ╔══[ERROR] identifier not found: x
+//│ ║  l.27: 	    Pair(x, y) and p1(x) and p1(y) then "both negative"
+//│ ╙──      	         ^
+//│ ╔══[ERROR] identifier not found: y
+//│ ║  l.27: 	    Pair(x, y) and p1(x) and p1(y) then "both negative"
+//│ ╙──      	            ^
+//│ fun example2: (Object & ~#Pair | Pair[Num, Num]) -> ("both negative" | "nah" | Int)
+//│ Code generation encountered an error:
+//│   unresolved symbol y
 
 // Next, let's check the name collision between a class and its super class.
 
diff --git a/shared/src/test/diff/pretyper/ucs/TuplePattern.mls b/shared/src/test/diff/pretyper/ucs/TuplePattern.mls
deleted file mode 100644
index 880c790848..0000000000
--- a/shared/src/test/diff/pretyper/ucs/TuplePattern.mls
+++ /dev/null
@@ -1,9 +0,0 @@
-:PreTyper
-
-fun flex(x) =
-  if x is
-    [a, b, c] then
-      a + b + c
-    else
-      0
-//│ fun flex: {0: Int, 1: Int, 2: Int} -> Int
diff --git a/shared/src/test/diff/pretyper/ucs/Overlaps.mls b/shared/src/test/diff/pretyper/ucs/coverage/Refinement.mls
similarity index 81%
rename from shared/src/test/diff/pretyper/ucs/Overlaps.mls
rename to shared/src/test/diff/pretyper/ucs/coverage/Refinement.mls
index fb78fa1994..a8913a37b5 100644
--- a/shared/src/test/diff/pretyper/ucs/Overlaps.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/Refinement.mls
@@ -52,25 +52,25 @@ fun missing_a_case(x: Shape) =
 // TODO: Why doesn't `Shape` match `Circle | Rectangle | LineSegment`?
 fun countLineSegments(x) =
   if x is
-    Shape and hidden(x) then "bro"
-    Rectangle(_, _, _) then "bro"
-    LineSegment(_, _) then "bro"
-    Circle(_, _) then "bro"
+    Shape and hidden(x) then "1"
+    Rectangle(_, _, _) then "2"
+    LineSegment(_, _) then "3"
+    Circle(_, _) then "4"
 //│ ╔══[ERROR] Type mismatch in `case` expression:
 //│ ║  l.54: 	  if x is
 //│ ║        	     ^^^^
-//│ ║  l.55: 	    Shape and hidden(x) then "bro"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.56: 	    Rectangle(_, _, _) then "bro"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.57: 	    LineSegment(_, _) then "bro"
+//│ ║  l.55: 	    Shape and hidden(x) then "1"
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.58: 	    Circle(_, _) then "bro"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.56: 	    Rectangle(_, _, _) then "2"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.57: 	    LineSegment(_, _) then "3"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.58: 	    Circle(_, _) then "4"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── class pattern of type `Shape` does not match type `Circle | LineSegment | Rectangle`
-//│ ║  l.55: 	    Shape and hidden(x) then "bro"
+//│ ║  l.55: 	    Shape and hidden(x) then "1"
 //│ ║        	    ^^^^^
 //│ ╟── but it flows into reference with expected type `Circle | LineSegment | Rectangle`
 //│ ║  l.54: 	  if x is
 //│ ╙──      	     ^
-//│ fun countLineSegments: Shape -> "bro"
+//│ fun countLineSegments: Shape -> ("1" | "2" | "3" | "4")
diff --git a/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls b/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls
index 3b0e199666..7939013b4f 100644
--- a/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls
+++ b/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls
@@ -92,3 +92,36 @@ working_cases([0, 0])
 //│ Int | error
 //│ res
 //│     = 0
+
+fun not_working(x) =
+  if x is
+    [a, b, c] then
+      a + b + c
+    else
+      0
+//│ fun not_working: {0: Int, 1: Int, 2: Int} -> Int
+
+not_working([1, 2, 3])
+//│ Int
+//│ res
+//│     = 6
+
+:e
+not_working([1, 2])
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.110: 	not_working([1, 2])
+//│ ║         	^^^^^^^^^^^^^^^^^^^
+//│ ╟── tuple literal of type `{0: 1, 1: 2}` does not have field '2'
+//│ ║  l.110: 	not_working([1, 2])
+//│ ║         	            ^^^^^^
+//│ ╟── Note: constraint arises from field selection:
+//│ ║  l.97: 	  if x is
+//│ ║        	     ^^^^
+//│ ║  l.98: 	    [a, b, c] then
+//│ ║        	^^^^^^^^^^^^
+//│ ╟── from reference:
+//│ ║  l.97: 	  if x is
+//│ ╙──      	     ^
+//│ Int | error
+//│ res
+//│     = NaN
diff --git a/shared/src/test/diff/pretyper/ucs/TransfromUCS.mls b/shared/src/test/diff/pretyper/ucs/stages/TransfromUCS.mls
similarity index 100%
rename from shared/src/test/diff/pretyper/ucs/TransfromUCS.mls
rename to shared/src/test/diff/pretyper/ucs/stages/TransfromUCS.mls

From d6bf3a38642274f7384f78d5a53ac1a69491a6d2 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 2 Jan 2024 18:05:38 +0800
Subject: [PATCH 044/147] Migrate all TAPL examples

---
 .../ucs/examples/STLC.mls}                    |   5 +-
 shared/src/test/diff/tapl/NuUntyped.mls       | 448 ------------
 shared/src/test/diff/tapl/SimplyTyped.mls     | 503 --------------
 shared/src/test/diff/tapl/Untyped.mls         | 644 ------------------
 4 files changed, 2 insertions(+), 1598 deletions(-)
 rename shared/src/test/diff/{tapl/NuSimplyTyped.mls => pretyper/ucs/examples/STLC.mls} (97%)
 delete mode 100644 shared/src/test/diff/tapl/NuUntyped.mls
 delete mode 100644 shared/src/test/diff/tapl/SimplyTyped.mls
 delete mode 100644 shared/src/test/diff/tapl/Untyped.mls

diff --git a/shared/src/test/diff/tapl/NuSimplyTyped.mls b/shared/src/test/diff/pretyper/ucs/examples/STLC.mls
similarity index 97%
rename from shared/src/test/diff/tapl/NuSimplyTyped.mls
rename to shared/src/test/diff/pretyper/ucs/examples/STLC.mls
index bc71deb00d..c0b8868c93 100644
--- a/shared/src/test/diff/tapl/NuSimplyTyped.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/STLC.mls
@@ -1,5 +1,4 @@
-:NewParser
-:NewDefs
+:PreTyper
 
 fun (++) concatOp(a, b) = concat(a)(b)
 //│ fun (++) concatOp: (Str, Str) -> Str
@@ -97,7 +96,7 @@ fun typeEqual(t1, t2) =
     t1 is FunctionType(lhs1, rhs1) and t2 is FunctionType(lhs2, rhs2) then
       typeEqual(lhs1, lhs2) and typeEqual(rhs1, rhs2)
     _ then false
-//│ fun typeEqual: (Object, Object) -> Bool
+//│ fun typeEqual: (FunctionType | Object & ~#FunctionType & ~#PrimitiveType | PrimitiveType, Object) -> Bool
 
 fun showTerm(t) =
   if t is
diff --git a/shared/src/test/diff/tapl/NuUntyped.mls b/shared/src/test/diff/tapl/NuUntyped.mls
deleted file mode 100644
index 29ff0ec935..0000000000
--- a/shared/src/test/diff/tapl/NuUntyped.mls
+++ /dev/null
@@ -1,448 +0,0 @@
-:NewDefs
-
-fun (++) concatOp(a, b) = concat(a)(b)
-//│ fun (++) concatOp: (Str, Str) -> Str
-
-fun par(a) = "(" ++ a ++ ")"
-//│ fun par: Str -> Str
-
-declare fun String: nothing
-//│ fun String: nothing
-
-let makeString: anything => { length: Int, charCodeAt: Int => Int } = String
-let StringInstance: { fromCharCode: Int => Str } = String
-//│ let makeString: anything -> {charCodeAt: Int -> Int, length: Int}
-//│ let StringInstance: {fromCharCode: Int -> Str}
-//│ makeString
-//│            = [Function: String]
-//│ StringInstance
-//│                = [Function: String]
-
-let anythingToString = toString
-fun fromCharCode(n: Int) = StringInstance.fromCharCode(n)
-fun stringCharCodeAt(s: Str, i) = makeString(s).charCodeAt(i)
-fun stringLength(s: Str) = makeString(s).length
-//│ let anythingToString: anything -> Str
-//│ fun fromCharCode: (n: Int) -> Str
-//│ fun stringCharCodeAt: (s: Str, Int) -> Int
-//│ fun stringLength: (s: Str) -> Int
-//│ anythingToString
-//│                  = [Function: toString]
-
-type Option[A] = Some[A] | None
-class Some[A](value: A) {
-  fun toString() = "Some(" ++ anythingToString(value) ++ ")"
-}
-module None {
-  fun toString() = "None"
-}
-//│ type Option[A] = None | Some[A]
-//│ class Some[A](value: A) {
-//│   fun toString: () -> Str
-//│ }
-//│ module None {
-//│   fun toString: () -> "None"
-//│ }
-
-type List[A] = Cons[A] | Nil
-class Cons[A](head: A, tail: List[A])
-module Nil
-//│ type List[A] = Cons[A] | Nil
-//│ class Cons[A](head: A, tail: List[A])
-//│ module Nil
-
-// * We could define a shorthand for these, but let's leave them as useful tests
-fun list1(x) = Cons(x, Nil)
-fun list2(x, y) = Cons(x, list1(y))
-fun list3(x, y, z) = Cons(x, list2(y, z))
-fun list4(x, y, z, w) = Cons(x, list3(y, z, w))
-fun list5(x, y, z, w, v) = Cons(x, list4(y, z, w, v))
-fun list6(x, y, z, w, v, u) = Cons(x, list5(y, z, w, v, u))
-fun list7(x, y, z, w, v, u, t) = Cons(x, list6(y, z, w, v, u, t))
-fun list8(x, y, z, w, v, u, t, s) = Cons(x, list7(y, z, w, v, u, t, s))
-//│ fun list1: forall 'A. 'A -> Cons['A]
-//│ fun list2: forall 'A0. ('A0, 'A0) -> Cons['A0]
-//│ fun list3: forall 'A1. ('A1, 'A1, 'A1) -> Cons['A1]
-//│ fun list4: forall 'A2. ('A2, 'A2, 'A2, 'A2) -> Cons['A2]
-//│ fun list5: forall 'A3. ('A3, 'A3, 'A3, 'A3, 'A3) -> Cons['A3]
-//│ fun list6: forall 'A4. ('A4, 'A4, 'A4, 'A4, 'A4, 'A4) -> Cons['A4]
-//│ fun list7: forall 'A5. ('A5, 'A5, 'A5, 'A5, 'A5, 'A5, 'A5) -> Cons['A5]
-//│ fun list8: forall 'A6. ('A6, 'A6, 'A6, 'A6, 'A6, 'A6, 'A6, 'A6) -> Cons['A6]
-
-fun findFirst(list, p) =
-  if list is
-    Nil then None
-    Cons(x, xs) and
-      p(x) then Some(x)
-      else findFirst(xs, p)
-//│ fun findFirst: forall 'A. (Cons['A] | Nil, 'A -> Object) -> (None | Some['A])
-
-fun listConcat(xs, ys) =
-  if xs is
-    Nil then ys
-    Cons(x, xs') then Cons(x, listConcat(xs', ys))
-//│ fun listConcat: forall 'A 'A0 'a. (Cons['A] | Nil, List['A0] & 'a) -> (Cons['A0] | 'a)
-//│   where
-//│     'A <: 'A0
-
-fun listContains(xs, x) =
-  if xs is
-    Nil then false
-    Cons(x', xs') and
-      eq(x)(x') then true
-      _ then listContains(xs', x)
-//│ fun listContains: forall 'A. (Cons['A] | Nil, anything) -> Bool
-
-// Remove all occurrences of x from xs.
-fun listWithout(xs, x) =
-  if xs is
-    Nil then Nil
-    Cons(x', xs') and
-      eq(x)(x') then listWithout(xs', x)
-      _ then Cons(x', listWithout(xs', x))
-//│ fun listWithout: forall 'A 'A0. (Cons['A] | Nil, anything) -> (Cons['A0] | Nil)
-//│   where
-//│     'A <: 'A0
-
-
-// * FIXME?
-fun listJoin(xs, sep) =
-  if xs is
-    Nil then ""
-    Cons(x, Nil) then toString(x)
-    Cons(x, xs') then toString(x) ++ sep ++ listJoin(xs', sep)
-//│ fun listJoin: forall 'A. (Cons['A] | Nil, Str) -> Str
-
-fun listJoin(xs, sep) =
-  if xs is
-    Nil then ""
-    Cons(x, xs') and xs' is
-      Nil then toString(x)
-      _ then toString(x) ++ sep ++ listJoin(xs', sep)
-//│ fun listJoin: forall 'A. (Cons['A] | Nil, Str) -> Str
-
-listJoin(list3("x", "y", "z"), ", ")
-//│ Str
-//│ res
-//│     = 'x, y, z'
-
-type Term = Var | Abs | App
-class Var(name: Str)
-class Abs(lhs: Var, rhs: Term)
-class App(lhs: Term, rhs: Term)
-//│ type Term = Abs | App | Var
-//│ class Var(name: Str)
-//│ class Abs(lhs: Var, rhs: Term)
-//│ class App(lhs: Term, rhs: Term)
-
-fun showTerm(t) =
-  if t is
-    Var(name) then toString(name)
-    Abs(lhs, rhs) then "&" ++ showTerm(lhs) ++ ". " ++ showTerm(rhs)
-    App(Abs(lhs0, lhs1), rhs) then
-      "((" ++ "&" ++ showTerm(lhs0) ++ ". " ++ showTerm(lhs1) ++ ") " ++ showTerm(rhs) ++ ")"
-    App(lhs, rhs) then par(showTerm(lhs) ++ " " ++ showTerm(rhs))
-//│ fun showTerm: (Abs | App | Var) -> Str
-
-showTerm(Var("x"))
-showTerm(Abs(Var("x"), Var("y")))
-showTerm(App(Var("x"), Var("y")))
-showTerm(App(Abs(Var("x"), Var("y")), Var("z")))
-//│ Str
-//│ res
-//│     = 'x'
-//│ res
-//│     = '&x. y'
-//│ res
-//│     = '(x y)'
-//│ res
-//│     = '((&x. y) z)'
-
-fun isValue(t) =
-  if t is
-    Var then true
-    Abs then true
-    App then false
-//│ fun isValue: (Abs | App | Var) -> Bool
-
-isValue(Var("x"))
-isValue(Abs(Var("x"), Var("y")))
-isValue(App(Var("x"), Var("y")))
-//│ Bool
-//│ res
-//│     = true
-//│ res
-//│     = true
-//│ res
-//│     = false
-
-fun hasFree(t, n) =
-  if t is
-    // let __ = debug(concat3(showTerm(t), ", ", n))
-    Var(na) then eq(n)(na)
-    Abs(Var(name), body) and eq(name)(n) then false
-    Abs(Var(name), body) then hasFree(body, n)
-    App(lhs, rhs) then hasFree(lhs, n) || hasFree(rhs, n)
-    _ then false
-//│ fun hasFree: (Object, anything) -> Bool
-
-fun showHasFree(t, n) =
-  showTerm(t) ++ (if hasFree(t, n) then " has " else " DOES NOT have ") ++ "free variable " ++ n
-//│ fun showHasFree: (Abs | App | Var, Str) -> Str
-
-showHasFree(Var("x"), "x")
-showHasFree(Var("x"), "y")
-showHasFree(Abs(Var("x"), Var("x")), "x")
-showHasFree(Abs(Var("x"), Var("x")), "y")
-showHasFree(Abs(Var("x"), Var("y")), "x")
-showHasFree(Abs(Var("x"), Var("y")), "y")
-showHasFree(App(Var("x"), Var("y")), "x")
-showHasFree(App(Var("x"), Var("y")), "y")
-showHasFree(App(Abs(Var("x"), Var("x")), Var("x")), "x")
-showHasFree(App(Abs(Var("x"), Var("x")), Var("x")), "y")
-showHasFree(App(Abs(Var("x"), Var("x")), Var("y")), "y")
-showHasFree(App(Abs(Var("x"), Var("x")), Var("x")), "y")
-//│ Str
-//│ res
-//│     = 'x has free variable x'
-//│ res
-//│     = 'x DOES NOT have free variable y'
-//│ res
-//│     = '&x. x DOES NOT have free variable x'
-//│ res
-//│     = '&x. x DOES NOT have free variable y'
-//│ res
-//│     = '&x. y DOES NOT have free variable x'
-//│ res
-//│     = '&x. y has free variable y'
-//│ res
-//│     = '(x y) has free variable x'
-//│ res
-//│     = '(x y) has free variable y'
-//│ res
-//│     = '((&x. x) x) has free variable x'
-//│ res
-//│     = '((&x. x) x) DOES NOT have free variable y'
-//│ res
-//│     = '((&x. x) y) has free variable y'
-//│ res
-//│     = '((&x. x) x) DOES NOT have free variable y'
-
-fun fv(t) =
-  if t is
-    Var(name) then list1(name)
-    Abs(Var(name), body) then listWithout(fv(body), name)
-    App(lhs, rhs) then listConcat(fv(lhs), fv(rhs))
-//│ fun fv: forall 'A. (Abs | App | Var) -> (Cons['A] | Nil)
-//│   where
-//│     'A :> Str
-
-fun showFv(t) =
-  showTerm(t) ++ if fv(t) is
-    Nil then " DOES NOT have free variables"
-    _ then " has free variables: " ++ listJoin(fv(t), ", ")
-//│ fun showFv: (Abs | App | Var) -> Str
-
-showFv(Var("x"))
-showFv(Abs(Var("x"), Var("x")))
-showFv(Abs(Var("x"), Var("y")))
-showFv(App(Var("x"), Var("y")))
-showFv(App(Abs(Var("x"), Var("x")), Var("x")))
-//│ Str
-//│ res
-//│     = 'x has free variables: x'
-//│ res
-//│     = '&x. x DOES NOT have free variables'
-//│ res
-//│     = '&x. y has free variables: y'
-//│ res
-//│     = '(x y) has free variables: x, y'
-//│ res
-//│     = '((&x. x) x) has free variables: x'
-
-fun tryNextAlphabet(initialCode, currentCode, freeNames) =
-  if
-    currentCode
-      > 122 then tryNextAlphabet(initialCode, 97, freeNames)
-      == initialCode then None
-    let name = fromCharCode(currentCode)
-    listContains(freeNames, name) then tryNextAlphabet(initialCode, currentCode + 1, freeNames)
-    _ then Some(name)
-//│ fun tryNextAlphabet: forall 'A. (Num, Int, Cons['A] | Nil) -> (None | Some[Str])
-
-tryNextAlphabet(97, 97, list1("a")).toString()
-tryNextAlphabet(97, 98, list1("a")).toString()
-tryNextAlphabet(97, 98, list2("a", "b")).toString()
-tryNextAlphabet(121, 122, list1("y")).toString()
-tryNextAlphabet(121, 122, list2("y", "z")).toString()
-//│ Str
-//│ res
-//│     = 'None'
-//│ res
-//│     = 'Some(b)'
-//│ res
-//│     = 'Some(c)'
-//│ res
-//│     = 'Some(z)'
-//│ res
-//│     = 'Some(a)'
-
-fun tryAppendDigits(name, index, freeNames) =
-  if
-    let currentName = name ++ toString(index)
-    listContains(freeNames, currentName) then
-      tryAppendDigits(name, index + 1, freeNames)
-    _ then currentName
-//│ fun tryAppendDigits: forall 'A. (Str, Int, Cons['A] | Nil) -> Str
-
-// Note: some weird behavior here... Just try the commented code.
-fun findFreshName(name, freeNames) =
-  if
-    stringLength(name) == 1 and
-      let charCode = stringCharCodeAt(name, 0)
-      tryNextAlphabet(charCode, charCode + 1, freeNames) is
-        Some(newName) then newName
-    _ then tryAppendDigits(name, 0, freeNames)
-//│ fun findFreshName: forall 'A 'A0 'A1. (Str, Cons[in 'A | 'A0 | 'A1 out 'A & 'A0 & 'A1] | Nil) -> Str
-
-// Find a fresh name to replace `name` that does not conflict with any bound
-// variables in the `body`.
-fun freshName(name, body) = findFreshName(name, fv(body))
-//│ fun freshName: (Str, Abs | App | Var) -> Str
-
-fun subst(t, n, v) =
-  if t is
-    Var(name) and eq(name)(n) then v
-    Abs(Var(name), body) and ne(name)(n) and
-      hasFree(v, name) and freshName(name, body) is newName then
-        subst(Abs(Var(newName), subst(body, name, Var(newName))), n, v)
-      _ then Abs(Var(name), subst(body, n, v))
-    App(lhs, rhs) then App(subst(lhs, n, v), subst(rhs, n, v))
-    _ then t
-//│ fun subst: forall 'a. (Abs | App | Term & Object & 'a & ~#Abs & ~#App & ~#Var | Var, anything, Term & Object & 'a) -> ('a | Abs | App | Var)
-
-fun showSubst(t, n, v) =
-  showTerm(t) ++ " [" ++ n ++ " / " ++ showTerm(v) ++ "]" ++ " => " ++ showTerm(subst(t, n, v))
-//│ fun showSubst: (Abs | App | Var, Str, Abs & Term | App & Term | Var & Term) -> Str
-
-showSubst(Var("x"), "x", Var("y"))
-showSubst(Abs(Var("x"), Var("x")), "x", Var("z"))
-showSubst(App(Var("x"), Var("y")), "x", Abs(Var("x"), Var("x")))
-showSubst(App(Abs(Var("x"), Var("x")), Var("x")), "x", Abs(Var("y"), Var("y")))
-showSubst(Abs(Var("x"), App(Var("x"), Var("y"))), "y", Var("x"))
-showSubst(Abs(Var("z"), Abs(Var("x"), App(Var("z"), App(Var("x"), Var("y"))))), "y", Var("x"))
-//│ Str
-//│ res
-//│     = 'x [x / y] => y'
-//│ res
-//│     = '&x. x [x / z] => &x. x'
-//│ res
-//│     = '(x y) [x / &x. x] => ((&x. x) y)'
-//│ res
-//│     = '((&x. x) x) [x / &y. y] => ((&x. x) &y. y)'
-//│ res
-//│     = '&x. (x y) [y / x] => &z. (z x)'
-//│ res
-//│     = '&z. &x. (z (x y)) [y / x] => &z. &a. (z (a x))'
-
-type Result = Normal | Stuck | Stepped
-class Normal(term: Term) {
-  fun toString() = "Normal form: " ++ showTerm(term)
-}
-class Stuck(term: Term, part: Term) {
-  fun toString() = "Stuck: " ++ showTerm(part) ++ " in " ++ showTerm(term)
-}
-class Stepped(from: Term, to: Term) {
-  fun toString() = showTerm(from) ++ " => " ++ showTerm(to)
-}
-//│ type Result = Normal | Stepped | Stuck
-//│ class Normal(term: Term) {
-//│   fun toString: () -> Str
-//│ }
-//│ class Stuck(term: Term, part: Term) {
-//│   fun toString: () -> Str
-//│ }
-//│ class Stepped(from: Term, to: Term) {
-//│   fun toString: () -> Str
-//│ }
-
-fun stepByValue(t) =
-  if t is
-    Var then Stuck(t, t)
-    Abs then Normal(t)
-    App(lhs, rhs) and stepByValue(lhs) is
-      Stepped(_, lhs) then Stepped(t, App(lhs, rhs))
-      Stuck(_, part) then Stuck(t, part)
-      Normal and stepByValue(rhs) is
-        Stepped(_, rhs) then Stepped(t, App(lhs, rhs))
-        Stuck(_, part) then Stuck(t, part)
-        Normal and lhs is
-          Abs(Var(name), body) then Stepped(t, subst(body, name, rhs))
-          _ then Stuck(t, lhs)
-//│ fun stepByValue: (Abs | App | Var) -> (Normal | Stepped | Stuck)
-
-toString of stepByValue of Var("x")
-toString of stepByValue of Abs(Var("x"), Var("y"))
-toString of stepByValue of App(Var("x"), Var("y"))
-toString of stepByValue of App(Abs(Var("x"), Var("x")), Var("x"))
-toString of stepByValue of App(Abs(Var("x"), Var("x")), Abs(Var("y"), Var("y")))
-//│ Str
-//│ res
-//│     = 'Stuck: x in x'
-//│ res
-//│     = 'Normal form: &x. y'
-//│ res
-//│     = 'Stuck: x in (x y)'
-//│ res
-//│     = 'Stuck: x in ((&x. x) x)'
-//│ res
-//│     = '((&x. x) &y. y) => &y. y'
-
-fun evalByValue(t) =
-  if stepByValue(t) is result and result is
-    Stepped(_, term) then evalByValue(term)
-    else result
-//│ fun evalByValue: (Abs | App | Var) -> (Normal | Stuck)
-
-// Let's program with Church encoding!
-let zero = Abs(Var("f"), Abs(Var("x"), Var("x")))
-let one = Abs(Var("f"), Abs(Var("x"), App(Var("f"), Var("x"))))
-toString of stepByValue of zero
-toString of stepByValue of one
-let succ = Abs(Var("n"), Abs(Var("f"), Abs(Var("x"), App(Var("f"), App(App(Var("n"), Var("f")), Var("x"))))))
-toString of stepByValue of succ
-toString of stepByValue of App(succ, zero)
-//│ let zero: Abs
-//│ let one: Abs
-//│ let succ: Abs
-//│ Str
-//│ zero
-//│      = Abs {}
-//│ one
-//│     = Abs {}
-//│ res
-//│     = 'Normal form: &f. &x. x'
-//│ res
-//│     = 'Normal form: &f. &x. (f x)'
-//│ succ
-//│      = Abs {}
-//│ res
-//│     = 'Normal form: &n. &f. &x. (f ((n f) x))'
-//│ res
-//│     = '((&n. &f. &x. (f ((n f) x))) &f. &x. x) => &f. &x. (f (((&f. &x. x) f) x))'
-
-toString of evalByValue of App(succ, App(succ, zero))
-toString of evalByValue of App(succ, App(succ, App(succ, App(succ, zero))))
-//│ Str
-//│ res
-//│     = 'Normal form: &f. &x. (f (((&f. &x. (f (((&f. &x. x) f) x))) f) x))'
-//│ res
-//│     = 'Normal form: &f. &x. (f (((&f. &x. (f (((&f. &x. (f (((&f. &x. (f (((&f. &x. x) f) x))) f) x))) f) x))) f) x))'
-
-fun equalTerm(a, b) =
-  if a is
-    Var(na) and b is Var(nb) then eq(na)(nb)
-    Abs(la, ra) and b is Abs(lb, rb) then equalTerm(la, lb) && equalTerm(ra, rb)
-    App(la, ra) and b is App(lb, rb) then equalTerm(la, lb) && equalTerm(ra, rb)
-    _ then false
-//│ fun equalTerm: (Object, Object) -> Bool
diff --git a/shared/src/test/diff/tapl/SimplyTyped.mls b/shared/src/test/diff/tapl/SimplyTyped.mls
deleted file mode 100644
index 400be3d6e9..0000000000
--- a/shared/src/test/diff/tapl/SimplyTyped.mls
+++ /dev/null
@@ -1,503 +0,0 @@
-:NewParser
-
-fun concat2(a, b) = concat(a)(b)
-fun concat3(a, b, c) = concat2(a, concat2(b, c))
-fun concat4(a, b, c, d) = concat2(a, concat3(b, c, d))
-fun concat5(a, b, c, d, e) = concat2(a, concat4(b, c, d, e))
-fun concat6(a, b, c, d, e, f) = concat2(a, concat5(b, c, d, e, f))
-fun concat7(a, b, c, d, e, f, g) = concat2(a, concat6(b, c, d, e, f, g))
-fun concat8(a, b, c, d, e, f, g, h) = concat2(a, concat7(b, c, d, e, f, g, h))
-fun par(a) = concat3("(", a, ")")
-//│ concat2: (string, string,) -> string
-//│        = [Function: concat2]
-//│ concat3: (string, string, string,) -> string
-//│        = [Function: concat3]
-//│ concat4: (string, string, string, string,) -> string
-//│        = [Function: concat4]
-//│ concat5: (string, string, string, string, string,) -> string
-//│        = [Function: concat5]
-//│ concat6: (string, string, string, string, string, string,) -> string
-//│        = [Function: concat6]
-//│ concat7: (string, string, string, string, string, string, string,) -> string
-//│        = [Function: concat7]
-//│ concat8: (string, string, string, string, string, string, string, string,) -> string
-//│        = [Function: concat8]
-//│ par: string -> string
-//│    = [Function: par]
-
-class Option
-class Some(value): Option
-class None(): Option
-//│ Defined class Option
-//│ Defined class Some
-//│ Defined class None
-//│ Option: () -> Option
-//│       = [Function: Option1]
-//│ Some: 'value -> (Some & {value: 'value})
-//│     = [Function: Some1]
-//│ None: () -> None
-//│     = [Function: None1]
-
-class Result
-class Ok(value): Result
-class Err(message): Result
-//│ Defined class Result
-//│ Defined class Ok
-//│ Defined class Err
-//│ Result: () -> Result
-//│       = [Function: Result1]
-//│ Ok: 'value -> (Ok & {value: 'value})
-//│   = [Function: Ok1]
-//│ Err: 'message -> (Err & {message: 'message})
-//│    = [Function: Err1]
-
-class Type
-class FunctionType(lhs, rhs): Type
-class PrimitiveType(name): Type
-//│ Defined class Type
-//│ Defined class FunctionType
-//│ Defined class PrimitiveType
-//│ Type: () -> Type
-//│     = [Function: Type1]
-//│ FunctionType: ('lhs, 'rhs,) -> (FunctionType & {lhs: 'lhs, rhs: 'rhs})
-//│             = [Function: FunctionType1]
-//│ PrimitiveType: 'name -> (PrimitiveType & {name: 'name})
-//│              = [Function: PrimitiveType1]
-
-// Helpers.
-fun _f(lhs, rhs) = FunctionType(lhs, rhs)
-fun _t(name) = PrimitiveType(name)
-//│ _f: ('lhs, 'rhs,) -> (FunctionType & {lhs: 'lhs, rhs: 'rhs})
-//│   = [Function: _f]
-//│ _t: 'name -> (PrimitiveType & {name: 'name})
-//│   = [Function: _t]
-
-class Term
-class Lit(tag, ty): Term
-class Var(name): Term
-class Abs(lhs, lty, rhs): Term
-class App(lhs, rhs): Term
-// class App(lhs: Term, rhs: Term): Term
-//│ Defined class Term
-//│ Defined class Lit
-//│ Defined class Var
-//│ Defined class Abs
-//│ Defined class App
-//│ Term: () -> Term
-//│     = [Function: Term1]
-//│ Lit: ('tag, 'ty,) -> (Lit & {tag: 'tag, ty: 'ty})
-//│    = [Function: Lit1]
-//│ Var: 'name -> (Var & {name: 'name})
-//│    = [Function: Var1]
-//│ Abs: ('lhs, 'lty, 'rhs,) -> (Abs & {lhs: 'lhs, lty: 'lty, rhs: 'rhs})
-//│    = [Function: Abs1]
-//│ App: ('lhs, 'rhs,) -> (App & {lhs: 'lhs, rhs: 'rhs})
-//│    = [Function: App1]
-
-class Assumption(name, ty)
-//│ Defined class Assumption
-//│ Assumption: ('name, 'ty,) -> (Assumption & {name: 'name, ty: 'ty})
-//│           = [Function: Assumption1]
-
-class Tree
-class Node(key, value, left, right): Tree
-class Empty(): Tree
-//│ Defined class Tree
-//│ Defined class Node
-//│ Defined class Empty
-//│ Tree: () -> Tree
-//│     = [Function: Tree1]
-//│ Node: ('key, 'value, 'left, 'right,) -> (Node & {key: 'key, left: 'left, right: 'right, value: 'value})
-//│     = [Function: Node1]
-//│ Empty: () -> Empty
-//│      = [Function: Empty1]
-
-fun empty = Empty()
-fun insert(t, k, v) =
-  if t is
-    Node(k', _, l, r) and
-      slt(k)(k') then Node(k', v, insert(l, k, v), r)
-      sgt(k)(k') then Node(k', v, l, insert(r, k, v))
-      _ then Node(k, v, l, r)
-    Empty then Node(k, v, empty, empty)
-fun find(t, k) =
-  if t is
-    Node(k', v, l, r) and
-      slt(k)(k') then find(l, k)
-      sgt(k)(k') then find(r, k)
-      _ then Some(v)
-    Empty then None()
-//│ empty: Empty
-//│      = [Function: empty]
-//│ insert: (Empty | Node & 'a, string & 'key, 'value,) -> (Node & {key: 'key, left: Empty | 'left, right: Empty | 'right, value: 'value} | 'b)
-//│   where
-//│     'b :> Node & {
-//│       key: 'key0,
-//│       left: Node & {key: 'key, left: Empty | 'left, right: Empty | 'right, value: 'value} | 'b,
-//│       right: 'right,
-//│       value: 'value
-//│     } | Node & {
-//│       key: 'key0,
-//│       left: 'left,
-//│       right: Node & {key: 'key, left: Empty | 'left, right: Empty | 'right, value: 'value} | 'b,
-//│       value: 'value
-//│     }
-//│     'a <: {key: string & 'key0, left: 'left, right: 'right}
-//│     'right <: Empty | Node & 'a
-//│     'left <: Empty | Node & 'a
-//│       = [Function: insert]
-//│ find: (Empty | Node & 'a, string,) -> (Some & {value: 'value} | None)
-//│   where
-//│     'a <: {key: string, left: Empty | Node & 'a, right: Empty | Node & 'a, value: 'value}
-//│     = [Function: find]
-
-fun showType(ty) =
-  if ty is
-    FunctionType(PrimitiveType(name), rhs) then concat3(name, " -> ", showType(rhs))
-    FunctionType(lhs, rhs) then concat4("(", showType(lhs), ") -> ", showType(rhs))
-    PrimitiveType(name) then name
-//│ showType: (FunctionType & 'a | PrimitiveType & {name: string}) -> string
-//│   where
-//│     'a <: {
-//│       lhs: FunctionType & 'a | PrimitiveType & {name: string},
-//│       rhs: FunctionType & 'a | PrimitiveType & {name: string}
-//│     }
-//│         = [Function: showType]
-
-showType(_t("int"))
-showType(_f(_t("int"), _t("bool")))
-showType(_f(_f(_t("int"), _t("bool")), _t("bool")))
-showType(_f(_t("bool"), _f(_t("int"), _t("bool"))))
-//│ res: string
-//│    = 'int'
-//│ res: string
-//│    = 'int -> bool'
-//│ res: string
-//│    = '(int -> bool) -> bool'
-//│ res: string
-//│    = 'bool -> int -> bool'
-
-fun typeEqual(t1, t2) =
-  if
-    t1 is PrimitiveType(name1) and t2 is PrimitiveType(name2) then eq(name1)(name2)
-    t1 is FunctionType(lhs1, rhs1) and t2 is FunctionType(lhs2, rhs2) then
-      typeEqual(lhs1, lhs2) and typeEqual(rhs1, rhs2)
-    _ then false
-//│ typeEqual: (FunctionType & 'a | PrimitiveType | ~FunctionType & ~PrimitiveType, FunctionType & 'b | PrimitiveType | ~FunctionType & ~PrimitiveType,) -> bool
-//│   where
-//│     'b <: {
-//│       lhs: FunctionType & 'b | PrimitiveType | ~FunctionType & ~PrimitiveType,
-//│       rhs: FunctionType & 'b | PrimitiveType | ~FunctionType & ~PrimitiveType
-//│     }
-//│     'a <: {
-//│       lhs: FunctionType & 'a | PrimitiveType | ~FunctionType & ~PrimitiveType,
-//│       rhs: FunctionType & 'a | PrimitiveType | ~FunctionType & ~PrimitiveType
-//│     }
-//│          = [Function: typeEqual]
-
-fun showTerm(t) =
-  if t is
-    Lit(tag, _) then toString(tag)
-    Var(name) then toString(name)
-    Abs(lhs, ty, rhs) then concat6("&", showTerm(lhs), ": ", showType(ty), " => ", showTerm(rhs))
-    App(Abs(lhs0, ty, lhs1), rhs) then
-      concat5("((", showTerm(Abs(lhs0, ty, rhs)), ") ", showTerm(rhs), ")")
-    App(lhs, rhs) then par(concat3(showTerm(lhs), " ", showTerm(rhs)))
-//│ showTerm: (Abs & 'a | App & 'b | Lit | Var) -> string
-//│   where
-//│     'a <: {
-//│       lhs: Abs & 'a | App & 'b | Lit | Var,
-//│       lty: FunctionType & 'c | PrimitiveType & {name: string},
-//│       rhs: Abs & 'a | App & 'b | Lit | Var
-//│     }
-//│     'b <: {
-//│       lhs: App & 'b | Lit | Var | 'a & (Abs & {
-//│         lhs: Abs & 'a | App & 'b | Lit | Var,
-//│         lty: FunctionType & 'c | PrimitiveType & {name: string}
-//│       } | Abs & ~#Abs),
-//│       rhs: Abs & 'a | App & 'b | Lit | Var
-//│     }
-//│     'c <: {
-//│       lhs: FunctionType & 'c | PrimitiveType & {name: string},
-//│       rhs: FunctionType & 'c | PrimitiveType & {name: string}
-//│     }
-//│         = [Function: showTerm]
-
-showTerm(Var("x"))
-showTerm(Abs(Var("x"), _t("int"), Var("y")))
-showTerm(App(Var("x"), Var("y")))
-showTerm(App(Abs(Var("x"), _t("int"), Var("y")), Var("z")))
-//│ res: string
-//│    = 'x'
-//│ res: string
-//│    = '&x: int => y'
-//│ res: string
-//│    = '(x y)'
-//│ res: string
-//│    = '((&x: int => z) z)'
-
-// FIXME
-fun typeTerm(t, ctx) =
-  if t is
-    Lit(_, ty) then Ok(ty)
-    Var(name) and find(ctx, name) is
-      Some(ty) then Ok(ty)
-      None then Err(concat3("unbound variable `", name, "`"))
-    Abs(Var(name), ty, body) and typeTerm(body, insert(ctx, name, ty)) is
-      Ok(resTy) then Ok(FunctionType(ty, resTy))
-      Err(message) then Err(message)
-    App(lhs, rhs) and typeTerm(lhs, ctx) is
-      Ok(FunctionType(pTy, resTy)) and typeTerm(rhs, ctx) is
-        Ok(aTy) and
-          typeEqual(pTy, aTy) then Ok(resTy)
-          _ then Err(concat5("expect the argument to be of type `", showType(pTy), "` but found `", showType(aTy), "`"))
-        Err(message) then Err(message)
-      Ok(PrimitiveType(name)) then Err(concat3("cannot apply primitive type `", name, "`"))
-      Err(message) then Err(message)
-//│ ╔══[ERROR] Cyclic-looking constraint while typing binding of lambda expression; a type annotation may be required
-//│ ║  l.240: 	fun typeTerm(t, ctx) =
-//│ ║         	            ^^^^^^^^^^
-//│ ║  l.241: 	  if t is
-//│ ║         	^^^^^^^^^
-//│ ║  l.242: 	    Lit(_, ty) then Ok(ty)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.243: 	    Var(name) and find(ctx, name) is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.244: 	      Some(ty) then Ok(ty)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.245: 	      None then Err(concat3("unbound variable `", name, "`"))
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.246: 	    Abs(Var(name), ty, body) and typeTerm(body, insert(ctx, name, ty)) is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.247: 	      Ok(resTy) then Ok(FunctionType(ty, resTy))
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.248: 	      Err(message) then Err(message)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.249: 	    App(lhs, rhs) and typeTerm(lhs, ctx) is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.250: 	      Ok(FunctionType(pTy, resTy)) and typeTerm(rhs, ctx) is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.251: 	        Ok(aTy) and
-//│ ║         	^^^^^^^^^^^^^^^^^^^
-//│ ║  l.252: 	          typeEqual(pTy, aTy) then Ok(resTy)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.253: 	          _ then Err(concat5("expect the argument to be of type `", showType(pTy), "` but found `", showType(aTy), "`"))
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.254: 	        Err(message) then Err(message)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.255: 	      Ok(PrimitiveType(name)) then Err(concat3("cannot apply primitive type `", name, "`"))
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.256: 	      Err(message) then Err(message)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╙── Note: use flag `:ex` to see internal error info.
-//│ ╔══[ERROR] Cyclic-looking constraint while typing binding of lambda expression; a type annotation may be required
-//│ ║  l.240: 	fun typeTerm(t, ctx) =
-//│ ║         	            ^^^^^^^^^^
-//│ ║  l.241: 	  if t is
-//│ ║         	^^^^^^^^^
-//│ ║  l.242: 	    Lit(_, ty) then Ok(ty)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.243: 	    Var(name) and find(ctx, name) is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.244: 	      Some(ty) then Ok(ty)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.245: 	      None then Err(concat3("unbound variable `", name, "`"))
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.246: 	    Abs(Var(name), ty, body) and typeTerm(body, insert(ctx, name, ty)) is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.247: 	      Ok(resTy) then Ok(FunctionType(ty, resTy))
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.248: 	      Err(message) then Err(message)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.249: 	    App(lhs, rhs) and typeTerm(lhs, ctx) is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.250: 	      Ok(FunctionType(pTy, resTy)) and typeTerm(rhs, ctx) is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.251: 	        Ok(aTy) and
-//│ ║         	^^^^^^^^^^^^^^^^^^^
-//│ ║  l.252: 	          typeEqual(pTy, aTy) then Ok(resTy)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.253: 	          _ then Err(concat5("expect the argument to be of type `", showType(pTy), "` but found `", showType(aTy), "`"))
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.254: 	        Err(message) then Err(message)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.255: 	      Ok(PrimitiveType(name)) then Err(concat3("cannot apply primitive type `", name, "`"))
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.256: 	      Err(message) then Err(message)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╙── Note: use flag `:ex` to see internal error info.
-//│ typeTerm: (Abs & 'a | App & 'b | Lit & {ty: 'ty & (FunctionType & 'c & 'd & 'e | PrimitiveType & {name: string})} | Var & {name: string}, Empty | Node & 'f & 'g,) -> (Err & {
-//│   message: forall 'message 'message0 'message1. string | 'message | 'message0 | 'message1
-//│ } | Ok & {value: forall 'h. 'lty | 'rhs | 'ty | 'h})
-//│ where
-//│   'message :> forall 'message0 'message1. string | 'message0 | 'message1
-//│   'message0 :> forall 'message 'message1. 'message | 'message1
-//│   'message1 :> forall 'message 'message0. 'message | 'message0
-//│   'g <: {key: string, left: Empty | Node & 'f & 'g, right: Empty | Node & 'f & 'g}
-//│   'f <: {
-//│     key: string,
-//│     left: Empty | Node & 'f,
-//│     right: Empty | Node & 'f,
-//│     value: 'ty & (FunctionType & 'c & 'd & 'e | PrimitiveType & {name: string})
-//│   }
-//│   'a <: {
-//│     lhs: Var & {name: string},
-//│     lty: 'lty & (FunctionType & 'c & 'd & 'e & 'i & 'j | PrimitiveType & {name: string}),
-//│     rhs: Abs & 'a | App & 'b | Lit & {ty: 'ty & (FunctionType & 'c & 'd & 'e | PrimitiveType & {name: string})} | Var & {name: string}
-//│   }
-//│   'b <: {
-//│     lhs: Abs & 'a | App & 'b | Lit & {ty: 'ty & (FunctionType & 'c & 'd & 'e | PrimitiveType & {name: string})} | Var & {name: string},
-//│     rhs: Abs & 'a | App & 'b | Lit & {ty: 'ty & (FunctionType & 'c & 'd & 'e | PrimitiveType & {name: string})} | Var & {name: string}
-//│   }
-//│   'e <: {
-//│     lhs: PrimitiveType & {name: string} | 'j & (FunctionType & 'i | FunctionType & ~#FunctionType),
-//│     rhs: 'rhs
-//│   }
-//│   'rhs :> forall 'value. 'value
-//│        <: FunctionType & 'c & 'd & 'e | PrimitiveType & {name: string}
-//│   'value :> forall 'h. 'lty | 'rhs | 'ty | 'h
-//│   'h :> FunctionType & {lhs: 'lty, rhs: forall 'value. 'value}
-//│   'i <: {
-//│     lhs: FunctionType & 'i | PrimitiveType | ~FunctionType & ~PrimitiveType,
-//│     rhs: FunctionType & 'i | PrimitiveType | ~FunctionType & ~PrimitiveType
-//│   }
-//│   'j <: {
-//│     lhs: FunctionType & 'j | PrimitiveType & {name: string},
-//│     rhs: FunctionType & 'j | PrimitiveType & {name: string}
-//│   }
-//│   'd <: {
-//│     lhs: FunctionType & 'd | PrimitiveType | ~FunctionType & ~PrimitiveType,
-//│     rhs: FunctionType & 'd | PrimitiveType | ~FunctionType & ~PrimitiveType
-//│   }
-//│   'c <: {
-//│     lhs: FunctionType & 'c | PrimitiveType & {name: string},
-//│     rhs: FunctionType & 'c | PrimitiveType & {name: string}
-//│   }
-//│         = [Function: typeTerm]
-
-fun showTypeTerm(t, ctx) =
-  if typeTerm(t, ctx) is
-    Ok(ty) then concat3(showTerm(t), " : ", showType(ty))
-    Err(message) then concat2("Type error: ", message)
-//│ showTypeTerm: (Abs & 'a & 'b | App & 'c & 'd | Lit & {ty: FunctionType & 'e & 'f & 'g & 'h | PrimitiveType & {name: string}} | Var & {name: string}, Empty | Node & 'i & 'j,) -> string
-//│   where
-//│     'j <: {
-//│       key: string,
-//│       left: Empty | Node & 'j,
-//│       right: Empty | Node & 'j,
-//│       value: FunctionType & 'h & 'k & 'l & 'm | PrimitiveType & {name: string}
-//│     }
-//│     'm <: {
-//│       lhs: PrimitiveType & {name: string} | 'n & (FunctionType & 'o | FunctionType & ~#FunctionType),
-//│       rhs: FunctionType & 'h & 'k & 'l & 'm | PrimitiveType & {name: string}
-//│     }
-//│     'o <: {
-//│       lhs: FunctionType & 'o | PrimitiveType | ~FunctionType & ~PrimitiveType,
-//│       rhs: FunctionType & 'o | PrimitiveType | ~FunctionType & ~PrimitiveType
-//│     }
-//│     'n <: {
-//│       lhs: FunctionType & 'n | PrimitiveType & {name: string},
-//│       rhs: FunctionType & 'n | PrimitiveType & {name: string}
-//│     }
-//│     'l <: {
-//│       lhs: FunctionType & 'l | PrimitiveType | ~FunctionType & ~PrimitiveType,
-//│       rhs: FunctionType & 'l | PrimitiveType | ~FunctionType & ~PrimitiveType
-//│     }
-//│     'k <: {
-//│       lhs: FunctionType & 'k | PrimitiveType & {name: string},
-//│       rhs: FunctionType & 'k | PrimitiveType & {name: string}
-//│     }
-//│     'i <: {key: string, left: Empty | Node & 'i & 'p, right: Empty | Node & 'i & 'p}
-//│     'p <: {
-//│       key: string,
-//│       left: Empty | Node & 'p,
-//│       right: Empty | Node & 'p,
-//│       value: FunctionType & 'h & 'q & 'r & 's | PrimitiveType & {name: string}
-//│     }
-//│     's <: {
-//│       lhs: PrimitiveType & {name: string} | 't & (FunctionType & 'u | FunctionType & ~#FunctionType),
-//│       rhs: FunctionType & 'h & 'q & 'r & 's | PrimitiveType & {name: string}
-//│     }
-//│     'u <: {
-//│       lhs: FunctionType & 'u | PrimitiveType | ~FunctionType & ~PrimitiveType,
-//│       rhs: FunctionType & 'u | PrimitiveType | ~FunctionType & ~PrimitiveType
-//│     }
-//│     't <: {
-//│       lhs: FunctionType & 't | PrimitiveType & {name: string},
-//│       rhs: FunctionType & 't | PrimitiveType & {name: string}
-//│     }
-//│     'r <: {
-//│       lhs: FunctionType & 'r | PrimitiveType | ~FunctionType & ~PrimitiveType,
-//│       rhs: FunctionType & 'r | PrimitiveType | ~FunctionType & ~PrimitiveType
-//│     }
-//│     'q <: {
-//│       lhs: FunctionType & 'q | PrimitiveType & {name: string},
-//│       rhs: FunctionType & 'q | PrimitiveType & {name: string}
-//│     }
-//│     'b <: {
-//│       lhs: Abs & 'b | App & 'd | Lit | Var,
-//│       lty: FunctionType & 'v | PrimitiveType & {name: string},
-//│       rhs: Abs & 'b | App & 'd | Lit | Var
-//│     }
-//│     'd <: {
-//│       lhs: App & 'd | Lit | Var | 'b & (Abs & {
-//│         lhs: Abs & 'b | App & 'd | Lit | Var,
-//│         lty: FunctionType & 'v | PrimitiveType & {name: string}
-//│       } | Abs & ~#Abs),
-//│       rhs: Abs & 'b | App & 'd | Lit | Var
-//│     }
-//│     'v <: {
-//│       lhs: FunctionType & 'v | PrimitiveType & {name: string},
-//│       rhs: FunctionType & 'v | PrimitiveType & {name: string}
-//│     }
-//│     'a <: {
-//│       lhs: Var & {name: string},
-//│       lty: FunctionType & 'e & 'f & 'g & 'w & 'x & 'h | PrimitiveType & {name: string},
-//│       rhs: Abs & 'a | App & 'c | Lit & {ty: FunctionType & 'e & 'f & 'g & 'h | PrimitiveType & {name: string}} | Var & {name: string}
-//│     }
-//│     'c <: {
-//│       lhs: Abs & 'a | App & 'c | Lit & {ty: FunctionType & 'e & 'f & 'g & 'h | PrimitiveType & {name: string}} | Var & {name: string},
-//│       rhs: Abs & 'a | App & 'c | Lit & {ty: FunctionType & 'e & 'f & 'g & 'h | PrimitiveType & {name: string}} | Var & {name: string}
-//│     }
-//│     'g <: {
-//│       lhs: PrimitiveType & {name: string} | 'x & (FunctionType & 'w | FunctionType & ~#FunctionType),
-//│       rhs: FunctionType & 'e & 'f & 'g & 'h | PrimitiveType & {name: string}
-//│     }
-//│     'h <: {
-//│       lhs: FunctionType & 'h | PrimitiveType & {name: string},
-//│       rhs: FunctionType & 'h | PrimitiveType & {name: string}
-//│     }
-//│     'w <: {
-//│       lhs: FunctionType & 'w | PrimitiveType | ~FunctionType & ~PrimitiveType,
-//│       rhs: FunctionType & 'w | PrimitiveType | ~FunctionType & ~PrimitiveType
-//│     }
-//│     'x <: {
-//│       lhs: FunctionType & 'x | PrimitiveType & {name: string},
-//│       rhs: FunctionType & 'x | PrimitiveType & {name: string}
-//│     }
-//│     'f <: {
-//│       lhs: FunctionType & 'f | PrimitiveType | ~FunctionType & ~PrimitiveType,
-//│       rhs: FunctionType & 'f | PrimitiveType | ~FunctionType & ~PrimitiveType
-//│     }
-//│     'e <: {
-//│       lhs: FunctionType & 'e | PrimitiveType & {name: string},
-//│       rhs: FunctionType & 'e | PrimitiveType & {name: string}
-//│     }
-//│             = [Function: showTypeTerm]
-
-// FIXME
-showTypeTerm(Var("x"), empty)
-showTypeTerm(Abs(Var("x"), _t("int"), Var("x")), empty)
-showTypeTerm(App(Var("f"), Lit("0", _t("int"))), insert(empty, "f", _f(_t("int"), _t("int"))))
-showTypeTerm(App(Var("f"), Lit("0.2", _t("float"))), insert(empty, "f", _f(_t("int"), _t("int"))))
-showTypeTerm(App(Var("f"), Lit("0", _t("int"))), insert(empty, "f", _t("string")))
-//│ res: string
-//│    = 'Type error: unbound variable `x`'
-//│ res: string
-//│    = '&x: int => x : int -> int'
-//│ res: string
-//│    = '(f 0) : int'
-//│ res: string
-//│    = 'Type error: expect the argument to be of type `int` but found `float`'
-//│ res: string
-//│    = 'Type error: cannot apply primitive type `string`'
diff --git a/shared/src/test/diff/tapl/Untyped.mls b/shared/src/test/diff/tapl/Untyped.mls
deleted file mode 100644
index 65d6ead649..0000000000
--- a/shared/src/test/diff/tapl/Untyped.mls
+++ /dev/null
@@ -1,644 +0,0 @@
-:NewParser
-
-fun concat2(a, b) = concat(a)(b)
-fun concat3(a, b, c) = concat2(a, concat2(b, c))
-fun concat4(a, b, c, d) = concat2(a, concat3(b, c, d))
-fun concat5(a, b, c, d, e) = concat2(a, concat4(b, c, d, e))
-fun concat6(a, b, c, d, e, f) = concat2(a, concat5(b, c, d, e, f))
-fun concat7(a, b, c, d, e, f, g) = concat2(a, concat6(b, c, d, e, f, g))
-fun concat8(a, b, c, d, e, f, g, h) = concat2(a, concat7(b, c, d, e, f, g, h))
-fun par(a) = concat3("(", a, ")")
-//│ concat2: (string, string,) -> string
-//│        = [Function: concat2]
-//│ concat3: (string, string, string,) -> string
-//│        = [Function: concat3]
-//│ concat4: (string, string, string, string,) -> string
-//│        = [Function: concat4]
-//│ concat5: (string, string, string, string, string,) -> string
-//│        = [Function: concat5]
-//│ concat6: (string, string, string, string, string, string,) -> string
-//│        = [Function: concat6]
-//│ concat7: (string, string, string, string, string, string, string,) -> string
-//│        = [Function: concat7]
-//│ concat8: (string, string, string, string, string, string, string, string,) -> string
-//│        = [Function: concat8]
-//│ par: string -> string
-//│    = [Function: par]
-
-:escape
-let String: nothing
-let makeString: anything => { length: int, charCodeAt: int => int } = String
-let StringInstance: { fromCharCode: int => string } = String
-//│ String: nothing
-//│       = <missing implementation>
-//│ makeString: anything -> {charCodeAt: int -> int, length: int}
-//│           = [Function: String]
-//│ StringInstance: {fromCharCode: int -> string}
-//│               = [Function: String]
-
-fun fromCharCode(n) = StringInstance.fromCharCode(n)
-fun stringCharCodeAt(s, i) = makeString(s).charCodeAt(i)
-fun stringLength(s) = makeString(s).length
-//│ fromCharCode: int -> string
-//│             = [Function: fromCharCode]
-//│ stringCharCodeAt: (anything, int,) -> int
-//│                 = [Function: stringCharCodeAt]
-//│ stringLength: anything -> int
-//│             = [Function: stringLength]
-
-class Option
-class Some(value): Option
-class None(): Option
-//│ Defined class Option
-//│ Defined class Some
-//│ Defined class None
-//│ Option: () -> Option
-//│       = [Function: Option1]
-//│ Some: 'value -> (Some & {value: 'value})
-//│     = [Function: Some1]
-//│ None: () -> None
-//│     = [Function: None1]
-
-class List
-class Cons(head, tail): List
-class Nil(): List
-//│ Defined class List
-//│ Defined class Cons
-//│ Defined class Nil
-//│ List: () -> List
-//│     = [Function: List1]
-//│ Cons: ('head, 'tail,) -> (Cons & {head: 'head, tail: 'tail})
-//│     = [Function: Cons1]
-//│ Nil: () -> Nil
-//│    = [Function: Nil1]
-
-fun list1(x) = Cons(x, Nil())
-fun list2(x, y) = Cons(x, list1(y))
-fun list3(x, y, z) = Cons(x, list2(y, z))
-fun list4(x, y, z, w) = Cons(x, list3(y, z, w))
-fun list5(x, y, z, w, v) = Cons(x, list4(y, z, w, v))
-fun list6(x, y, z, w, v, u) = Cons(x, list5(y, z, w, v, u))
-fun list7(x, y, z, w, v, u, t) = Cons(x, list6(y, z, w, v, u, t))
-fun list8(x, y, z, w, v, u, t, s) = Cons(x, list7(y, z, w, v, u, t, s))
-//│ list1: 'head -> (Cons & {head: 'head, tail: Nil})
-//│      = [Function: list1]
-//│ list2: ('head, 'head0,) -> (Cons & {head: 'head, tail: Cons & {head: 'head0, tail: Nil}})
-//│      = [Function: list2]
-//│ list3: ('head, 'head0, 'head1,) -> (Cons & {head: 'head, tail: Cons & {head: 'head0, tail: Cons & {head: 'head1, tail: Nil}}})
-//│      = [Function: list3]
-//│ list4: ('head, 'head0, 'head1, 'head2,) -> (Cons & {
-//│   head: 'head,
-//│   tail: Cons & {head: 'head0, tail: Cons & {head: 'head1, tail: Cons & {head: 'head2, tail: Nil}}}
-//│ })
-//│      = [Function: list4]
-//│ list5: ('head, 'head0, 'head1, 'head2, 'head3,) -> (Cons & {
-//│   head: 'head,
-//│   tail: Cons & {
-//│     head: 'head0,
-//│     tail: Cons & {head: 'head1, tail: Cons & {head: 'head2, tail: Cons & {head: 'head3, tail: Nil}}}
-//│   }
-//│ })
-//│      = [Function: list5]
-//│ list6: ('head, 'head0, 'head1, 'head2, 'head3, 'head4,) -> (Cons & {
-//│   head: 'head,
-//│   tail: Cons & {
-//│     head: 'head0,
-//│     tail: Cons & {
-//│       head: 'head1,
-//│       tail: Cons & {head: 'head2, tail: Cons & {head: 'head3, tail: Cons & {head: 'head4, tail: Nil}}}
-//│     }
-//│   }
-//│ })
-//│      = [Function: list6]
-//│ list7: ('head, 'head0, 'head1, 'head2, 'head3, 'head4, 'head5,) -> (Cons & {
-//│   head: 'head,
-//│   tail: Cons & {
-//│     head: 'head0,
-//│     tail: Cons & {
-//│       head: 'head1,
-//│       tail: Cons & {
-//│         head: 'head2,
-//│         tail: Cons & {head: 'head3, tail: Cons & {head: 'head4, tail: Cons & {head: 'head5, tail: Nil}}}
-//│       }
-//│     }
-//│   }
-//│ })
-//│      = [Function: list7]
-//│ list8: ('head, 'head0, 'head1, 'head2, 'head3, 'head4, 'head5, 'head6,) -> (Cons & {
-//│   head: 'head,
-//│   tail: Cons & {
-//│     head: 'head0,
-//│     tail: Cons & {
-//│       head: 'head1,
-//│       tail: Cons & {
-//│         head: 'head2,
-//│         tail: Cons & {
-//│           head: 'head3,
-//│           tail: Cons & {head: 'head4, tail: Cons & {head: 'head5, tail: Cons & {head: 'head6, tail: Nil}}}
-//│         }
-//│       }
-//│     }
-//│   }
-//│ })
-//│      = [Function: list8]
-
-fun listConcat(xs, ys) =
-  if xs is
-    Nil() then ys
-    Cons(x, xs') then Cons(x, listConcat(xs', ys))
-//│ listConcat: (Cons & 'a | Nil, 'b,) -> 'b
-//│   where
-//│     'b :> Cons & {head: 'head, tail: 'b}
-//│     'a <: {head: 'head, tail: Cons & 'a | Nil}
-//│           = [Function: listConcat]
-
-fun listContains(xs, x) =
-  if xs is
-    Nil() then false
-    Cons(x', xs') and
-      eq(x)(x') then true
-      _ then listContains(xs', x)
-//│ listContains: (Cons & 'a | Nil, anything,) -> Bool
-//│   where
-//│     'a <: {head: anything, tail: Cons & 'a | Nil}
-//│             = [Function: listContains]
-
-// Remove all occurrences of x from xs.
-fun listWithout(xs, x) =
-  if xs is
-    Nil() then Nil()
-    Cons(x', xs') and
-      eq(x)(x') then listWithout(xs', x)
-      _ then Cons(x', listWithout(xs', x))
-//│ listWithout: (Cons & 'a | Nil, anything,) -> 'b
-//│   where
-//│     'b :> Nil | Cons & {head: 'head, tail: 'b}
-//│     'a <: {head: 'head, tail: Cons & 'a | Nil}
-//│            = [Function: listWithout]
-
-fun listJoin(xs, sep) =
-  if xs is
-    Nil() then ""
-    Cons(x, Nil()) then toString(x)
-    Cons(x, xs') then concat3(toString(x), sep, listJoin(xs', sep))
-//│ listJoin: (Cons & 'a | Nil, string,) -> string
-//│   where
-//│     'a <: {head: anything, tail: Cons & 'a | Nil}
-//│         = [Function: listJoin]
-
-listJoin(list3("x", "y", "z"), ", ")
-//│ res: string
-//│    = 'x, y, z'
-
-class Term
-class Var(name): Term
-class Abs(lhs, rhs): Term
-class App(lhs, rhs): Term
-//│ Defined class Term
-//│ Defined class Var
-//│ Defined class Abs
-//│ Defined class App
-//│ Term: () -> Term
-//│     = [Function: Term1]
-//│ Var: 'name -> (Var & {name: 'name})
-//│    = [Function: Var1]
-//│ Abs: ('lhs, 'rhs,) -> (Abs & {lhs: 'lhs, rhs: 'rhs})
-//│    = [Function: Abs1]
-//│ App: ('lhs, 'rhs,) -> (App & {lhs: 'lhs, rhs: 'rhs})
-//│    = [Function: App1]
-
-fun showTerm(t) =
-  if t is
-    Var(name) then toString(name)
-    Abs(lhs, rhs) then concat4("&", showTerm(lhs), ". ", showTerm(rhs))
-    App(Abs(lhs0, lhs1), rhs) then
-      concat8("((", "&", showTerm(lhs0), ". ", showTerm(lhs1), ") ", showTerm(rhs), ")")
-    App(lhs, rhs) then par(concat3(showTerm(lhs), " ", showTerm(rhs)))
-//│ showTerm: (Abs & 'a | App & 'b | Var) -> string
-//│   where
-//│     'a <: {lhs: Abs & 'a | App & 'b | Var, rhs: Abs & 'a | App & 'b | Var}
-//│     'b <: {
-//│       lhs: App & 'b | Var | 'a & (Abs & 'a | Abs & ~#Abs),
-//│       rhs: Abs & 'a | App & 'b | Var
-//│     }
-//│         = [Function: showTerm]
-
-showTerm(Var("x"))
-showTerm(Abs(Var("x"), Var("y")))
-showTerm(App(Var("x"), Var("y")))
-showTerm(App(Abs(Var("x"), Var("y")), Var("z")))
-//│ res: string
-//│    = 'x'
-//│ res: string
-//│    = '&x. y'
-//│ res: string
-//│    = '(x y)'
-//│ res: string
-//│    = '((&x. y) z)'
-
-fun isValue(t) =
-  if t is
-    Var then true
-    Abs then true
-    App then false
-//│ isValue: (Abs | App | Var) -> Bool
-//│        = [Function: isValue]
-
-isValue(Var("x"))
-isValue(Abs(Var("x"), Var("y")))
-isValue(App(Var("x"), Var("y")))
-//│ res: Bool
-//│    = true
-//│ res: Bool
-//│    = true
-//│ res: Bool
-//│    = false
-
-fun hasFree(t, n) =
-  if t is
-    // let __ = debug(concat3(showTerm(t), ", ", n))
-    Var(na) then eq(n)(na)
-    Abs(Var(name), body) and eq(name)(n) then false
-    Abs(Var(name), body) then hasFree(body, n)
-    App(lhs, rhs) then hasFree(lhs, n) || hasFree(rhs, n)
-    _ then false
-//│ hasFree: (Abs & 'a | App & 'b | Var | ~Abs & ~App & ~Var, anything,) -> bool
-//│   where
-//│     'a <: {lhs: anything, rhs: Abs & 'a | App & 'b | Var | ~Abs & ~App & ~Var}
-//│     'b <: {
-//│       lhs: Abs & 'a | App & 'b | Var | ~Abs & ~App & ~Var,
-//│       rhs: Abs & 'a | App & 'b | Var | ~Abs & ~App & ~Var
-//│     }
-//│        = [Function: hasFree]
-
-fun showHasFree(t, n) =
-  concat4(showTerm(t), if hasFree(t, n) then " has " else " DOES NOT have ", "free variable ", n)
-//│ showHasFree: (Abs & 'a & 'b | App & 'c & 'd | Var, string,) -> string
-//│   where
-//│     'b <: {lhs: anything, rhs: Abs & 'b | App & 'd | Var | ~Abs & ~App & ~Var}
-//│     'd <: {
-//│       lhs: Abs & 'b | App & 'd | Var | ~Abs & ~App & ~Var,
-//│       rhs: Abs & 'b | App & 'd | Var | ~Abs & ~App & ~Var
-//│     }
-//│     'a <: {lhs: Abs & 'a | App & 'c | Var, rhs: Abs & 'a | App & 'c | Var}
-//│     'c <: {
-//│       lhs: App & 'c | Var | 'a & (Abs & 'a | Abs & ~#Abs),
-//│       rhs: Abs & 'a | App & 'c | Var
-//│     }
-//│            = [Function: showHasFree]
-
-showHasFree(Var("x"), "x")
-showHasFree(Var("x"), "y")
-showHasFree(Abs(Var("x"), Var("x")), "x")
-showHasFree(Abs(Var("x"), Var("x")), "y")
-showHasFree(Abs(Var("x"), Var("y")), "x")
-showHasFree(Abs(Var("x"), Var("y")), "y")
-showHasFree(App(Var("x"), Var("y")), "x")
-showHasFree(App(Var("x"), Var("y")), "y")
-showHasFree(App(Abs(Var("x"), Var("x")), Var("x")), "x")
-showHasFree(App(Abs(Var("x"), Var("x")), Var("x")), "y")
-showHasFree(App(Abs(Var("x"), Var("x")), Var("y")), "y")
-showHasFree(App(Abs(Var("x"), Var("x")), Var("x")), "y")
-//│ res: string
-//│    = 'x has free variable x'
-//│ res: string
-//│    = 'x DOES NOT have free variable y'
-//│ res: string
-//│    = '&x. x DOES NOT have free variable x'
-//│ res: string
-//│    = '&x. x DOES NOT have free variable y'
-//│ res: string
-//│    = '&x. y DOES NOT have free variable x'
-//│ res: string
-//│    = '&x. y has free variable y'
-//│ res: string
-//│    = '(x y) has free variable x'
-//│ res: string
-//│    = '(x y) has free variable y'
-//│ res: string
-//│    = '((&x. x) x) has free variable x'
-//│ res: string
-//│    = '((&x. x) x) DOES NOT have free variable y'
-//│ res: string
-//│    = '((&x. x) y) has free variable y'
-//│ res: string
-//│    = '((&x. x) x) DOES NOT have free variable y'
-
-fun fv(t) =
-  if t is
-    Var(name) then list1(name)
-    Abs(Var(name), body) then listWithout(fv(body), name)
-    App(lhs, rhs) then listConcat(fv(lhs), fv(rhs))
-//│ fv: (Abs & 'a | App & 'b | Var & {name: 'name}) -> (Cons & {head: 'name, tail: Nil} | 'c | 'd)
-//│   where
-//│     'd :> forall 'e. 'f | 'e
-//│     'e :> Cons & {head: forall 'head. 'head, tail: 'f | 'e}
-//│     'f :> forall 'g. Cons & {head: 'name, tail: Nil} | 'g | 'd
-//│     'g :> Nil | Cons & {head: forall 'head0. 'head0, tail: 'g}
-//│     'c :> Nil | Cons & {head: forall 'head0. 'head0, tail: 'c}
-//│     'head0 :> forall 'head. 'head | 'name
-//│     'head :> forall 'head0. 'head0 | 'name
-//│     'a <: {lhs: Var, rhs: Abs & 'a | App & 'b | Var & {name: 'name}}
-//│     'b <: {
-//│       lhs: Abs & 'a | App & 'b | Var & {name: 'name},
-//│       rhs: Abs & 'a | App & 'b | Var & {name: 'name}
-//│     }
-//│   = [Function: fv]
-
-fun showFv(t) =
-  concat2(showTerm(t), if fv(t) is
-    Nil then " DOES NOT have free variables"
-    _ then concat2(" has free variables: ", listJoin(fv(t), ", "))
-  )
-//│ showFv: (Abs & 'a & 'b & 'c | App & 'd & 'e & 'f | Var) -> string
-//│   where
-//│     'c <: {lhs: Var, rhs: Abs & 'c | App & 'f | Var}
-//│     'f <: {lhs: Abs & 'c | App & 'f | Var, rhs: Abs & 'c | App & 'f | Var}
-//│     'b <: {lhs: Var, rhs: Abs & 'b | App & 'e | Var}
-//│     'e <: {lhs: Abs & 'b | App & 'e | Var, rhs: Abs & 'b | App & 'e | Var}
-//│     'a <: {lhs: Abs & 'a | App & 'd | Var, rhs: Abs & 'a | App & 'd | Var}
-//│     'd <: {
-//│       lhs: App & 'd | Var | 'a & (Abs & 'a | Abs & ~#Abs),
-//│       rhs: Abs & 'a | App & 'd | Var
-//│     }
-//│       = [Function: showFv]
-
-showFv(Var("x"))
-showFv(Abs(Var("x"), Var("x")))
-showFv(Abs(Var("x"), Var("y")))
-showFv(App(Var("x"), Var("y")))
-showFv(App(Abs(Var("x"), Var("x")), Var("x")))
-//│ res: string
-//│    = 'x has free variables: x'
-//│ res: string
-//│    = '&x. x DOES NOT have free variables'
-//│ res: string
-//│    = '&x. y has free variables: y'
-//│ res: string
-//│    = '(x y) has free variables: x, y'
-//│ res: string
-//│    = '((&x. x) x) has free variables: x'
-
-fun tryNextAlphabet(initialCode, currentCode, freeNames) =
-  if
-    currentCode
-      > 122 then tryNextAlphabet(initialCode, 97, freeNames)
-      == initialCode then None()
-    let name = fromCharCode(currentCode)
-    listContains(freeNames, name) then tryNextAlphabet(initialCode, currentCode + 1, freeNames)
-    _ then Some(name)
-//│ tryNextAlphabet: (number, int, Cons & 'a | Nil,) -> (Some & {value: string} | None)
-//│   where
-//│     'a <: {head: anything, tail: Cons & 'a | Nil}
-//│                = [Function: tryNextAlphabet]
-
-tryNextAlphabet(97, 97, list1("a"))
-tryNextAlphabet(97, 98, list1("a"))
-tryNextAlphabet(97, 98, list2("a", "b"))
-tryNextAlphabet(121, 122, list1("y"))
-tryNextAlphabet(121, 122, list2("y", "z"))
-//│ res: Some & {value: string} | None
-//│    = None {}
-//│ res: Some & {value: string} | None
-//│    = Some { value: 'b' }
-//│ res: Some & {value: string} | None
-//│    = Some { value: 'c' }
-//│ res: Some & {value: string} | None
-//│    = Some { value: 'z' }
-//│ res: Some & {value: string} | None
-//│    = Some { value: 'a' }
-
-fun tryAppendDigits(name, index, freeNames) =
-  if
-    let currentName = concat2(name, toString(index))
-    listContains(freeNames, currentName) then
-      tryAppendDigits(name, index + 1, freeNames)
-    _ then currentName
-//│ tryAppendDigits: (string, int, Cons & 'a | Nil,) -> string
-//│   where
-//│     'a <: {head: anything, tail: Cons & 'a | Nil}
-//│                = [Function: tryAppendDigits]
-
-// Note: some weird behavior here... Just try the commented code.
-fun findFreshName(name, freeNames) =
-  if
-    stringLength(name) == 1 and
-      let charCode = stringCharCodeAt(name, 0)
-      tryNextAlphabet(charCode, charCode + 1, freeNames) is
-        Some(newName) then newName
-    _ then tryAppendDigits(name, 0, freeNames)
-//│ findFreshName: (string, Cons & 'a & 'b & 'c | Nil,) -> string
-//│   where
-//│     'c <: {head: anything, tail: Cons & 'c | Nil}
-//│     'b <: {head: anything, tail: Cons & 'b | Nil}
-//│     'a <: {head: anything, tail: Cons & 'a | Nil}
-//│              = [Function: findFreshName]
-
-// Find a fresh name to replace `name` that does not conflict with any bound
-// variables in the `body`.
-fun freshName(name, body) = findFreshName(name, fv(body))
-//│ freshName: (string, Abs & 'a | App & 'b | Var,) -> string
-//│   where
-//│     'a <: {lhs: Var, rhs: Abs & 'a | App & 'b | Var}
-//│     'b <: {lhs: Abs & 'a | App & 'b | Var, rhs: Abs & 'a | App & 'b | Var}
-//│          = [Function: freshName]
-
-fun subst(t, n, v) =
-  if t is
-    Var(name) and eq(name)(n) then v
-    Abs(Var(name), body) and ne(name)(n) and
-      hasFree(v, name) and freshName(name, body) is newName then
-        subst(Abs(Var(newName), subst(body, name, Var(newName))), n, v)
-      _ then Abs(Var(name), subst(body, n, v))
-    App(lhs, rhs) then App(subst(lhs, n, v), subst(rhs, n, v))
-    _ then t
-//│ subst: (Abs & 'a | App & 'b | Var & 'c | 'd & ~#Abs & ~#App & ~#Var, anything, 'e & (Var & 'c | 'b & 'f & (App & ~#App | App & 'g) | 'a & 'h & (Abs & ~#Abs | Abs & 'i) | 'd & (Abs & 'h & ~#Abs | App & 'f & ~#App | Var & ~#Var)),) -> (Var & {name: string} | 'e | 'c | 'a | 'd)
-//│   where
-//│     'g <: {
-//│       lhs: Abs & 'i | App & 'g | Var | ~Abs & ~App & ~Var,
-//│       rhs: Abs & 'i | App & 'g | Var | ~Abs & ~App & ~Var
-//│     }
-//│     'i <: {lhs: anything, rhs: Abs & 'i | App & 'g | Var | ~Abs & ~App & ~Var}
-//│     'a :> Abs & {lhs: Var & {name: string}, rhs: Var & {name: string} | 'rhs | 'e | 'c | 'a | 'd}
-//│        <: Abs & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'a & 'h | App & 'b & 'f | Var & 'c} & 'h | App & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'a & 'h | App & 'b & 'f | Var & 'c} & 'b & 'f | Var & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'a & 'h | App & 'b & 'f | Var & 'c} & 'c | 'd & (App & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'a & 'h | App & 'b & 'f | Var & 'c} & 'f & ~#App | Var & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'a & 'h | App & 'b & 'f | Var & 'c} & ~#Var)
-//│     'rhs :> Var & {name: string} | 'e | 'c | 'a | 'd
-//│     'e :> Var & {name: string} | 'c | 'a | 'd | App & {
-//│       lhs: Var & {name: string} | 'e | 'c | 'a | 'd,
-//│       rhs: Var & {name: string} | 'e | 'c | 'a | 'd
-//│     } | Abs & {lhs: Var & {name: string}, rhs: 'rhs}
-//│     'c :> Var & {name: string}
-//│        <: Abs & {name: anything} & 'a & 'h | App & {name: anything} & 'b & 'f | Var | 'd & (Abs & {name: anything} & 'h & ~#Abs | App & {name: anything} & 'f & ~#App)
-//│     'b <: {
-//│       lhs: Abs & 'a | App & 'b | Var & 'c | 'd & ~#Abs & ~#App & ~#Var,
-//│       rhs: Abs & 'a | App & 'b | Var & 'c | 'd & ~#Abs & ~#App & ~#Var
-//│     }
-//│     'd <: Var & ~#Var | Var & 'c | 'f & (App & ~#App | App & 'b) | 'h & (Abs & ~#Abs | Abs & 'a)
-//│     'h <: {lhs: Var, rhs: Abs & 'h | App & 'f | Var}
-//│     'f <: {lhs: Abs & 'h | App & 'f | Var, rhs: Abs & 'h | App & 'f | Var}
-//│      = [Function: subst]
-
-fun showSubst(t, n, v) =
-  concat8(showTerm(t), " [", n, " / ", showTerm(v), "]", " => ", showTerm(subst(t, n, v)))
-//│ showSubst: (Abs & 'a & 'b | App & 'c & 'd | Var & 'e, string, Abs & 'b & 'f & 'g & 'h & 'i | App & 'j & 'd & 'k & 'l & 'm | Var & 'e,) -> string
-//│   where
-//│     'i <: {lhs: anything, rhs: Abs & 'i | App & 'm | Var | ~Abs & ~App & ~Var}
-//│     'm <: {
-//│       lhs: Abs & 'i | App & 'm | Var | ~Abs & ~App & ~Var,
-//│       rhs: Abs & 'i | App & 'm | Var | ~Abs & ~App & ~Var
-//│     }
-//│     'h <: {lhs: Abs & 'h | App & 'l | Var, rhs: Abs & 'h | App & 'l | Var}
-//│     'l <: {
-//│       lhs: App & 'l | Var | 'h & (Abs & 'h | Abs & ~#Abs),
-//│       rhs: Abs & 'h | App & 'l | Var
-//│     }
-//│     'b <: Abs & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'b & 'f | App & 'j & 'd | Var & 'e} & 'f & 'g | Var & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'b & 'f | App & 'j & 'd | Var & 'e} & 'e | Var & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'b & 'f | App & 'j & 'd | Var & 'e} & 'n & ~#Var | 'j & 'k & (App & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'b & 'f | App & 'j & 'd | Var & 'e} & 'd | App & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'b & 'f | App & 'j & 'd | Var & 'e} & 'n & ~#App)
-//│     'd <: {
-//│       lhs: Abs & 'b | App & 'd | Var & 'e | 'n & ~#Abs & ~#App & ~#Var,
-//│       rhs: Abs & 'b | App & 'd | Var & 'e | 'n & ~#Abs & ~#App & ~#Var
-//│     }
-//│     'e <: Var | 'j & 'k & (App & {name: anything} & 'd | App & {name: anything} & 'n & ~#App) | 'f & 'g & (Abs & {name: anything} & 'n & ~#Abs | Abs & {name: anything} & 'b)
-//│     'n <: Var & ~#Var | Var & 'e | 'j & 'k & (App & ~#App | App & 'd) | 'f & 'g & (Abs & ~#Abs | Abs & 'b)
-//│     'k <: {
-//│       lhs: App & 'k | Var | 'g & (Abs & ~#Abs | Abs & 'g),
-//│       rhs: Abs & 'g | App & 'k | Var
-//│     }
-//│     'g <: {lhs: Abs & 'g | App & 'k | Var, rhs: Abs & 'g | App & 'k | Var}
-//│     'f <: {lhs: Var, rhs: Abs & 'f | App & 'j | Var}
-//│     'j <: {lhs: Abs & 'f | App & 'j | Var, rhs: Abs & 'f | App & 'j | Var}
-//│     'a <: {lhs: Abs & 'a | App & 'c | Var, rhs: Abs & 'a | App & 'c | Var}
-//│     'c <: {
-//│       lhs: App & 'c | Var | 'a & (Abs & 'a | Abs & ~#Abs),
-//│       rhs: Abs & 'a | App & 'c | Var
-//│     }
-//│          = [Function: showSubst]
-
-showSubst(Var("x"), "x", Var("y"))
-showSubst(Abs(Var("x"), Var("x")), "x", Var("z"))
-showSubst(App(Var("x"), Var("y")), "x", Abs(Var("x"), Var("x")))
-showSubst(App(Abs(Var("x"), Var("x")), Var("x")), "x", Abs(Var("y"), Var("y")))
-showSubst(Abs(Var("x"), App(Var("x"), Var("y"))), "y", Var("x"))
-//│ res: string
-//│    = 'x [x / y] => y'
-//│ res: string
-//│    = '&x. x [x / z] => &x. x'
-//│ res: string
-//│    = '(x y) [x / &x. x] => ((&x. x) y)'
-//│ res: string
-//│    = '((&x. x) x) [x / &y. y] => ((&x. x) &y. y)'
-//│ res: string
-//│    = '&x. (x y) [y / x] => &z. (z x)'
-
-fun stepByValue(t) =
-  if t is
-    Var then None()
-    Abs then None()
-    App(lhs, rhs) and stepByValue(lhs) is
-      Some(lhs) then Some(App(lhs, rhs))
-      None and stepByValue(rhs) is
-        Some(rhs) then Some(App(lhs, rhs))
-        None and lhs is
-          Abs(Var(name), body) then Some(subst(body, name, rhs))
-          _ then None()
-//│ stepByValue: (Abs | App & 'a | Var) -> (None | Some & {
-//│   value: Var & {name: string} | 'rhs | App & {
-//│     lhs: Var & {name: string} | 'rhs | App & {lhs: 'lhs, rhs: Var & {name: string} | 'rhs | 'b | 'c | 'd | 'e} | 'b | 'c | 'd | 'e,
-//│     rhs: 'rhs
-//│   } | App & {lhs: 'lhs, rhs: Var & {name: string} | 'rhs | 'b | 'c | 'd | 'e} | 'b | 'c | 'd | 'e
-//│ })
-//│ where
-//│   'a <: {lhs: 'lhs, rhs: 'rhs}
-//│   'lhs <: Abs & {rhs: Abs & 'c | App & 'f | Var & 'b | 'e & ~#Abs & ~#App & ~#Var} | Abs & ~#Abs | App & 'a | Var
-//│   'c :> Abs & {
-//│     lhs: Var & {name: string},
-//│     rhs: Var & {name: string} | 'rhs0 | 'rhs | 'b | 'c | 'd | 'e
-//│   }
-//│      <: Abs & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'c & 'g | App & 'h & 'f | Var & 'b} & 'g | Var & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'c & 'g | App & 'h & 'f | Var & 'b} & 'b | Var & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'c & 'g | App & 'h & 'f | Var & 'b} & 'e & ~#Var | 'h & (App & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'c & 'g | App & 'h & 'f | Var & 'b} & 'f | App & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'c & 'g | App & 'h & 'f | Var & 'b} & 'e & ~#App)
-//│   'rhs0 :> Var & {name: string} | 'rhs | 'b | 'c | 'd | 'e
-//│   'd :> Var & {name: string} | 'rhs | 'b | 'c | 'e | Abs & {lhs: Var & {name: string}, rhs: 'rhs0} | App & {
-//│     lhs: Var & {name: string} | 'rhs | 'b | 'c | 'd | 'e,
-//│     rhs: Var & {name: string} | 'rhs | 'b | 'c | 'd | 'e
-//│   }
-//│   'rhs <: Abs & 'c & 'g & 'i | App & 'a & 'h & 'f & 'j | Var & 'b
-//│   'f <: {
-//│     lhs: Abs & 'c | App & 'f | Var & 'b | 'e & ~#Abs & ~#App & ~#Var,
-//│     rhs: Abs & 'c | App & 'f | Var & 'b | 'e & ~#Abs & ~#App & ~#Var
-//│   }
-//│   'b :> Var & {name: string}
-//│      <: Var | 'h & (App & {name: anything} & 'f | App & {name: anything} & 'e & ~#App) | 'g & (Abs & {name: anything} & 'e & ~#Abs | Abs & {name: anything} & 'c)
-//│   'e <: Var & ~#Var | Var & 'b | 'h & (App & ~#App | App & 'f) | 'g & (Abs & ~#Abs | Abs & 'c)
-//│   'i <: {lhs: anything, rhs: Abs & 'i | App & 'j | Var | ~Abs & ~App & ~Var}
-//│   'j <: {
-//│     lhs: Abs & 'i | App & 'j | Var | ~Abs & ~App & ~Var,
-//│     rhs: Abs & 'i | App & 'j | Var | ~Abs & ~App & ~Var
-//│   }
-//│   'g <: {lhs: Var, rhs: Abs & 'g | App & 'h | Var}
-//│   'h <: {lhs: Abs & 'g | App & 'h | Var, rhs: Abs & 'g | App & 'h | Var}
-//│            = [Function: stepByValue]
-
-fun showStepByValue(t) =
-  concat3(showTerm(t), " => ", if stepByValue(t) is
-    Some(t) then showTerm(t)
-    None then "stuck"
-  )
-//│ showStepByValue: (Abs & 'a | App & 'b & 'c | Var) -> string
-//│   where
-//│     'c <: {
-//│       lhs: App & 'c & 'd | Var | 'e & (Abs & {rhs: Abs & 'f | App & 'g | Var & 'h | 'i & ~#Abs & ~#App & ~#Var} | Abs & ~#Abs),
-//│       rhs: Abs & 'f & 'j & 'e & 'k | App & 'c & 'l & 'g & 'd & 'm | Var & 'h
-//│     }
-//│     'k <: {lhs: anything, rhs: Abs & 'k | App & 'm | Var | ~Abs & ~App & ~Var}
-//│     'm <: {
-//│       lhs: Abs & 'k | App & 'm | Var | ~Abs & ~App & ~Var,
-//│       rhs: Abs & 'k | App & 'm | Var | ~Abs & ~App & ~Var
-//│     }
-//│     'f <: Abs & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'f & 'j | App & 'l & 'g | Var & 'h} & 'j & 'e | Var & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'f & 'j | App & 'l & 'g | Var & 'h} & 'h | Var & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'f & 'j | App & 'l & 'g | Var & 'h} & 'i & ~#Var | 'l & 'd & (App & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'f & 'j | App & 'l & 'g | Var & 'h} & 'g | App & {lhs: Var & {name: string} | ~Var, rhs: Abs & 'f & 'j | App & 'l & 'g | Var & 'h} & 'i & ~#App)
-//│     'g <: {
-//│       lhs: Abs & 'f | App & 'g | Var & 'h | 'i & ~#Abs & ~#App & ~#Var,
-//│       rhs: Abs & 'f | App & 'g | Var & 'h | 'i & ~#Abs & ~#App & ~#Var
-//│     }
-//│     'h <: Var | 'l & 'd & (App & {name: anything} & 'g | App & {name: anything} & 'i & ~#App) | 'j & 'e & (Abs & {name: anything} & 'i & ~#Abs | Abs & {name: anything} & 'f)
-//│     'i <: Var & ~#Var | Var & 'h | 'l & 'd & (App & ~#App | App & 'g) | 'j & 'e & (Abs & ~#Abs | Abs & 'f)
-//│     'j <: {lhs: Var, rhs: Abs & 'j | App & 'l | Var}
-//│     'l <: {lhs: Abs & 'j | App & 'l | Var, rhs: Abs & 'j | App & 'l | Var}
-//│     'd <: {
-//│       lhs: App & 'd | Var | 'e & (Abs & ~#Abs | Abs & 'e),
-//│       rhs: Abs & 'e | App & 'd | Var
-//│     }
-//│     'e <: {lhs: Abs & 'e | App & 'd | Var, rhs: Abs & 'e | App & 'd | Var}
-//│     'a <: {lhs: Abs & 'a | App & 'b | Var, rhs: Abs & 'a | App & 'b | Var}
-//│     'b <: {
-//│       lhs: App & 'b | Var | 'a & (Abs & 'a | Abs & ~#Abs),
-//│       rhs: Abs & 'a | App & 'b | Var
-//│     }
-//│                = [Function: showStepByValue]
-
-showStepByValue(Var("x"))
-showStepByValue(Abs(Var("x"), Var("y")))
-showStepByValue(App(Var("x"), Var("y")))
-showStepByValue(App(Abs(Var("x"), Var("x")), Var("y")))
-//│ res: string
-//│    = 'x => stuck'
-//│ res: string
-//│    = '&x. y => stuck'
-//│ res: string
-//│    = '(x y) => stuck'
-//│ res: string
-//│    = '((&x. x) y) => y'
-
-fun equalTerm(a, b) =
-  if a is
-    Var(na) and b is Var(nb) then eq(na)(nb)
-    Abs(la, ra) and b is Abs(lb, rb) then equalTerm(la, lb) && equalTerm(ra, rb)
-    App(la, ra) and b is App(lb, rb) then equalTerm(la, lb) && equalTerm(ra, rb)
-    _ then false
-//│ equalTerm: (Abs & 'a | App & 'a | Var | ~Abs & ~App & ~Var, Abs & 'b | App & 'b | Var | ~Abs & ~App & ~Var,) -> bool
-//│   where
-//│     'b <: {
-//│       lhs: Abs & 'b | App & 'b | Var | ~Abs & ~App & ~Var,
-//│       rhs: Abs & 'b | App & 'b | Var | ~Abs & ~App & ~Var
-//│     }
-//│     'a <: {
-//│       lhs: Abs & 'a | App & 'a | Var | ~Abs & ~App & ~Var,
-//│       rhs: Abs & 'a | App & 'a | Var | ~Abs & ~App & ~Var
-//│     }
-//│          = [Function: equalTerm]

From 4416b2484bf2a58fff611ee549ca8760a76b5334 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 3 Jan 2024 01:32:55 +0800
Subject: [PATCH 045/147] Transform a rare case found in `zipWith.mls`

---
 .../mlscript/ucs/stages/Transformation.scala  | 78 +++++++++++++++++--
 1 file changed, 73 insertions(+), 5 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index 14f613c3b3..396c02b7dc 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -29,7 +29,7 @@ trait Transformation { self: Traceable with Diagnosable =>
   /**
     * Transform a conjunction of terms into a nested split. The conjunction is
     * of the following form.
-    * ```
+    * ```bnf
     * conjunction ::= term "is" term conjunction-tail
     *               | "_" conjunction-tail
     *               | term conjunction-tail
@@ -74,10 +74,35 @@ trait Transformation { self: Traceable with Diagnosable =>
             acc
         }
       case IfOpsApp(lhs, opsRhss) =>
-        val (init, last) = extractLast(splitAnd(lhs))
-        transformConjunction(init, TermBranch.Left(last, Split.from(opsRhss.map(transformOperatorBranch))).toSplit, false)
+        splitAnd(lhs) match {
+          case init :+ (scrutinee is pattern) =>
+            // If `last` is in the form of `scrutinee is pattern`, the `op` in
+            // `opsRhss` must be `and`. Otherwise, it's a syntax error.
+            val innermost = transformBrokenIfOpsApp(opsRhss)
+            val inner = TermBranch.Match(scrutinee, PatternBranch(transformPattern(pattern), innermost).toSplit).toSplit
+            transformConjunction(init, inner, false)
+          case init :+ last =>
+            transformConjunction(init, TermBranch.Left(last, Split.from(opsRhss.map(transformOperatorBranch))).toSplit, false)
+          case _ => rare
+        }
     }
   }(_ => "transformIfBody ==> ")
+
+  /**
+    * Transform the case where `lhs` of `IfOpsApp` concludes pattern matching
+    * and we need to handle its `opsRhss`. This is special, because the first
+    * field of elements of `opsRhss` must be `and`.
+    */
+  private def transformBrokenIfOpsApp(opsRhss: Ls[Var -> IfBody]): TermSplit = {
+    opsRhss.iterator.flatMap {
+      case Var("and") -> rhs => S(transformIfBody(rhs))
+      case op -> rhs =>
+        raiseError(PreTyping,
+          msg"cannot transform due to an illegal split operator ${op.name}" -> op.toLoc,
+          msg"the following branch will be discarded" -> rhs.toLoc)
+        N
+    }.foldLeft(Split.Nil: TermSplit)(_ ++ _)
+  }
   
   private def transformOperatorBranch(opsRhs: Var -> IfBody): OperatorBranch =
     opsRhs match {
@@ -107,7 +132,48 @@ trait Transformation { self: Traceable with Diagnosable =>
               PatternBranch(pattern, transformIfBody(rhs)).toSplit
           }
         case IfOpApp(lhs, op, rhs) => ??? // <-- Syntactic split of patterns are not supported.
-        case IfOpsApp(lhs, opsRhss) => ??? // <-- Syntactic split of patterns are not supported.
+        case IfOpsApp(lhs, opsRhss) =>
+          // BEGIN TEMPORARY PATCH
+          // Generally, syntactic split of patterns are not supported. Examples
+          // like the following code is impossible.
+          // ```
+          // fun pairwise(xs) =
+          //   if xs is Cons of
+          //     x, Nil then [x, x]
+          //     x, Cons of x', tail then [x, x'] :: pairwise of tail
+          //     else Nil
+          // ```
+          // We could support this in future but it's disallowed for now. But I
+          // found some mis-parsed examples. For example, as in `zipWith.mls:76`.
+          // ```
+          // fun zipWith_wrong(f, xs, ys) =
+          //   if  xs is Cons(x, xs)
+          //     and ys is Cons(y, ys)
+          //     and zipWith_wrong(f, xs, ys) is Some(tail) then Some(Cons(f(x, y), tail))
+          //   else None
+          // ```
+          // This is parsed as `{ and ( Cons x xs ) [ is ys ( Cons y ys ) ] }`.
+          // I think it's not very well-formed. But I still implement it for not
+          // breaking existing tests.
+          splitAnd(lhs) match {
+            case Nil => rare // It's impossible to be empty.
+            case pattern :: tail =>
+              // Here, `pattern` will be `( Cons x xs )` and `tail` will be
+              // `[ is ys (Cons y ys) ]`. We can make a new `IfOpsApp`.
+              println(s"lol, pattern is $pattern")
+              println(s"lol, tail is $tail")
+              tail match {
+                case init :+ last =>
+                  println(s"lol, init is $init")
+                  println(s"lol, last is $last")
+                  val remake = IfOpsApp(last, opsRhss)
+                  val following = transformConjunction(init, transformIfBody(remake), true)
+                  PatternBranch(transformPattern(pattern), following).toSplit
+                case _ => // This can only be `Nil`.
+                  PatternBranch(transformPattern(pattern), transformBrokenIfOpsApp(opsRhss)).toSplit
+              }
+          }
+          // END TEMPORARY PATCH
         case IfLet(rec, nme, rhs, body) => rare
         case IfBlock(lines) => lines.foldLeft(Split.empty[PatternBranch]) {
           case (acc, L(body)) => acc ++ transformPatternMatching(body)
@@ -153,7 +219,9 @@ trait Transformation { self: Traceable with Diagnosable =>
     (transformPattern(rawPattern), extraTest)
   }
 
-  private def splitAnd(t: Term): Ls[Term] = trace(s"splitAnd <== ${inspect.deep(t)}") {
+  // TODO: Maybe we can change the return type to `::[Term]` so that it will not
+  // empty.
+  private def splitAnd(t: Term): List[Term] = trace(s"splitAnd <== ${inspect.deep(t)}") {
     t match {
       case App(
         App(Var("and"),

From 8e8251dc1e4a309803ef65b43596fe3a9d8a8807 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 3 Jan 2024 01:34:29 +0800
Subject: [PATCH 046/147] Literal patterns should be tested by case branches
 directly

---
 .../main/scala/mlscript/pretyper/Scope.scala  |  2 +-
 .../scala/mlscript/ucs/context/CaseSet.scala  | 10 ++--
 .../mlscript/ucs/context/ScrutineeData.scala  | 46 ++++++++++++-------
 .../ucs/stages/CoverageChecking.scala         |  8 ++--
 .../mlscript/ucs/stages/Desugaring.scala      | 40 ++++++++--------
 5 files changed, 58 insertions(+), 48 deletions(-)

diff --git a/shared/src/main/scala/mlscript/pretyper/Scope.scala b/shared/src/main/scala/mlscript/pretyper/Scope.scala
index ffc041a18c..e8c859fff0 100644
--- a/shared/src/main/scala/mlscript/pretyper/Scope.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Scope.scala
@@ -100,7 +100,7 @@ object Scope {
       """true,false,document,window,typeof,toString,not,succ,log,discard,negate,
         |round,add,sub,mul,div,sqrt,lt,le,gt,ge,slt,sle,sgt,sge,length,concat,eq,
         |ne,error,id,if,emptyArray,+,-,*,%,/,**,<,>,<=,>=,==,===,<>,&&,||,and,
-        |numAdd,numSub,numMul"""
+        |numAdd,numSub,numMul,NaN"""
         .stripMargin
         .split(",")
         .iterator
diff --git a/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala b/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
index 6a897c5b74..d517df520f 100644
--- a/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
@@ -71,13 +71,9 @@ final case class CaseSet(val cases: Map[Pattern, Ls[Loc]]) {
     }
   }
 
-  /** Add a type sysmbol as a class like pattern to the set. */
-  def add(classLikeSymbol: TypeSymbol, location: Opt[Loc]): CaseSet = {
-    val classLikePattern = Pattern.ClassLike(classLikeSymbol)
-    copy(cases = cases.updatedWith(classLikePattern) {
-      case N => S(location.toList)
-      case S(locations) => S(location.toList ++ locations)
-    })
+  def remove(literal: Lit): CaseSet = {
+    val literalPattern = Pattern.Literal(literal)
+    copy(cases - literalPattern)
   }
 
   /** Get an iterator of only patterns. */
diff --git a/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala b/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
index 37f839d87c..907b9436b1 100644
--- a/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
@@ -1,14 +1,26 @@
 package mlscript.ucs.context
 
 import collection.mutable.{Buffer, Map => MutMap, SortedMap => MutSortedMap, SortedSet => MutSortedSet}
-import mlscript.{Loc, Located, NuFunDef, NuTypeDef, TypeName, Var}
-import mlscript.{Cls, Trt, Mxn, Als, Mod}
+import mlscript.{Lit, Loc, Located, NuFunDef, NuTypeDef, TypeName, Var}
 import mlscript.pretyper.symbol.TypeSymbol
 import mlscript.utils._, shorthands._
 import mlscript.ucs.context.CaseSet
 
-class ClassPatternInfo(scrutinee: ScrutineeData) {
+abstract class PatternInfo {
   private val locationsBuffer: Buffer[Loc] = Buffer.empty
+
+  def addLocation(located: Located): Unit = located.getLoc.foreach(locationsBuffer += _)
+
+  def addLocation(location: Opt[Loc]): Unit = locationsBuffer ++= location
+
+  def firstOccurrence: Option[Loc] = locationsBuffer.headOption
+
+  def locations: Ls[Loc] = locationsBuffer.toList
+
+  def arity: Opt[Int]
+}
+
+class ClassPatternInfo(scrutinee: ScrutineeData) extends PatternInfo {
   private var unappliedVarOpt: Opt[Var] = N
   private val parameters: MutSortedMap[Int, ScrutineeData] = MutSortedMap.empty
 
@@ -24,10 +36,6 @@ class ClassPatternInfo(scrutinee: ScrutineeData) {
     parameters.getOrElseUpdate(index, scrutinee.freshSubScrutinee)
   }
 
-  def addLocation(located: Located): Unit = located.getLoc.foreach(locationsBuffer += _)
-
-  def addLocation(location: Opt[Loc]): Unit = locationsBuffer ++= location
-
   def getUnappliedVar(default: => Var): Var =
     unappliedVarOpt.getOrElse {
       val unappliedVar = default
@@ -35,23 +43,20 @@ class ClassPatternInfo(scrutinee: ScrutineeData) {
       unappliedVar
     }
 
-  def arity: Opt[Int] = parameters.keysIterator.maxOption.map(_ + 1)
-
-  def firstOccurrence: Option[Loc] = locationsBuffer.headOption
-
-  def locations: Ls[Loc] = locationsBuffer.toList
+  override def arity: Opt[Int] = parameters.keysIterator.maxOption.map(_ + 1)
 }
 
-class TuplePatternInfo(scrutinee: ScrutineeData) {
-  private val locationsBuffer: Buffer[Loc] = Buffer.empty
+class TuplePatternInfo(scrutinee: ScrutineeData) extends PatternInfo {
   private val fields: MutSortedMap[Int, ScrutineeData] = MutSortedMap.empty
 
   def getField(index: Int): ScrutineeData =
     fields.getOrElseUpdate(index, scrutinee.freshSubScrutinee)
 
-  def arity: Opt[Int] = fields.keysIterator.maxOption.map(_ + 1)
+  override def arity: Opt[Int] = fields.keysIterator.maxOption.map(_ + 1)
+}
 
-  def locations: Ls[Loc] = locationsBuffer.toList
+class LiteralPatternInfo extends PatternInfo {
+  override def arity: Opt[Int] = N
 }
 
 class ScrutineeData(val context: Context, parent: Opt[ScrutineeData]) {
@@ -67,6 +72,8 @@ class ScrutineeData(val context: Context, parent: Opt[ScrutineeData]) {
   private var tuplePatternOpt: Opt[TuplePatternInfo] = N
   private var alisesSet: MutSortedSet[Var] = MutSortedSet.empty
 
+  private val literalPatterns: MutMap[Lit, LiteralPatternInfo] = MutMap.empty
+
   def +=(alias: Var): Unit = alisesSet += alias
 
   def withAlias(alias: Var): ScrutineeData = { this += alias; this }
@@ -109,6 +116,10 @@ class ScrutineeData(val context: Context, parent: Opt[ScrutineeData]) {
       tuplePattern
     }
 
+  /** Get the tuple pattern and create a new one if there isn't. */
+  def getOrCreateLiteralPattern(literal: Lit): LiteralPatternInfo =
+    literalPatterns.getOrElseUpdate(literal, new LiteralPatternInfo)
+
   def classLikePatternsIterator: Iterator[TypeSymbol -> ClassPatternInfo] = classLikePatterns.iterator
 
   /** Get the name representation of patterns. Only for debugging. */
@@ -132,6 +143,9 @@ class ScrutineeData(val context: Context, parent: Opt[ScrutineeData]) {
     val tuplePattern = tuplePatternOpt.map { tuplePattern =>
       Pattern.Tuple() -> tuplePattern.locations
     }.toMap[Pattern, Ls[Loc]]
+    val literalPatterns = this.literalPatterns.iterator.map { case (literal, pattern) =>
+      Pattern.Literal(literal) -> pattern.locations
+    }.toMap[Pattern, Ls[Loc]]
     CaseSet(cases ++ tuplePattern)
   }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index baa1fea2f0..b583c1e08a 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -87,9 +87,11 @@ trait CoverageChecking { self: mlscript.pretyper.Traceable =>
                     case N => ErrorReport("unvisited scrutinee", Nil, Diagnostic.PreTyping)
                   }))
               }
-            case (diagnostics, (_: Lit) -> _) =>
-              println("CANNOT check literal patterns")
-              diagnostics
+            case ((unseenPatterns, diagnostics), (literal: Lit) -> body) =>
+              (
+                unseenPatterns.remove(literal),
+                diagnostics ++ checkCoverage(body, newPending, working - namedScrutinee, seen)
+              )
           }) {
             case ((missingCases, diagnostics), N) =>
               println("remaining cases should are not covered")
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index c9a38c73db..8987c987f1 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -122,13 +122,8 @@ trait Desugaring { self: PreTyper =>
       }
     }()
 
-  private def makeLiteralTest(test: Var, scrutinee: Var, literal: Lit)(implicit scope: Scope): c.Split => c.Split =
-    next => c.Split.Let(
-      rec = false,
-      name = test,
-      term = mkBinOp(scrutinee, Var("==="), literal, true),
-      tail = c.Branch(test, truePattern, next) :: c.Split.Nil
-    )
+  private def makeLiteralTest(scrutinee: Var, literal: Lit)(implicit scope: Scope): c.Split => c.Split =
+    next => c.Branch(scrutinee, c.Pattern.Literal(literal), next) :: c.Split.Nil
 
   private def flattenClassParameters(
       parentScrutineeVar: Var,
@@ -189,12 +184,15 @@ trait Desugaring { self: PreTyper =>
           vari.withSymbol(new LocalTermSymbol(vari))
         }
         val nestedPatterns = flattenClassParameters(scrutineeVar, patternClassSymbol, parameters)
+        println(s"nestedPatterns = $nestedPatterns")
         // First, handle bindings of parameters of the current class pattern.
+        val identity = (split: c.Split) => split
         val bindParameters = nestedPatterns.iterator.zipWithIndex.foldRight[c.Split => c.Split](identity) {
           case ((N, _), bindNextParameter) => bindNextParameter
           case ((S(parameter -> _), index), bindNextParameter) => 
             bindNextParameter.andThen { c.Split.Let(false, parameter, Sel(unapp, Var(index.toString)), _) }
         }
+        println(s"bindParameters === identity: ${bindParameters === identity}")
         val bindAll = if (bindParameters === identity) bindParameters else bindParameters.andThen {
           c.Split.Let(false, unapp, makeUnapplyCall(scrutineeVar, pattern.nme), _): c.Split
         }
@@ -239,9 +237,11 @@ trait Desugaring { self: PreTyper =>
           val (scopeWithNestedAll, bindNestedAll) = desugarClassPattern(pattern, nme, scope)
           (scopeWithNestedAll, split => bindPrevious(bindNestedAll(split) :: c.Split.Nil))
         case ((scope, bindPrevious), S(nme -> S(pattern: s.LiteralPattern))) =>
-          val test = context.freshTest().withFreshSymbol
-          println(s"fresh test var: ${test.name}")
-          (scope + test.symbol, makeLiteralTest(test, nme, pattern.literal)(scope).andThen(bindPrevious))
+          nme.getOrCreateScrutinee
+             .withAlias(nme)
+             .getOrCreateLiteralPattern(pattern.literal)
+             .addLocation(pattern.literal)
+          (scope, makeLiteralTest(nme, pattern.literal)(scope).andThen(bindPrevious))
         case ((scope, bindPrevious), S(nme -> S(s.TuplePattern(fields)))) =>
           val (scopeWithNestedAll, bindNestedAll) = desugarTuplePattern(fields, nme, scope)
           (scopeWithNestedAll, bindNestedAll.andThen(bindPrevious))
@@ -295,17 +295,15 @@ trait Desugaring { self: PreTyper =>
             raiseError(PreTyping, msg"alias pattern is not supported for now" -> pattern.toLoc)
             rec(scrutineeVar, tail)
           case s.LiteralPattern(literal) =>
-            val test = context.freshTest().withFreshSymbol
-            c.Split.Let(
-              rec = false,
-              name = test,
-              term = mkBinOp(scrutineeVar, Var("==="), literal, true),
-              tail = c.Branch(
-                scrutinee = test,
-                pattern = truePattern,
-                continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope + test.symbol, context)
-              ) :: rec(scrutineeVar, tail)
-            )
+            scrutineeVar.getOrCreateScrutinee
+                        .withAlias(scrutineeVar)
+                        .getOrCreateLiteralPattern(literal)
+                        .addLocation(literal)
+            c.Branch(
+              scrutinee = scrutineeVar,
+              pattern = c.Pattern.Literal(literal),
+              continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context)
+            ) :: rec(scrutineeVar, tail)
           case s.ConcretePattern(nme) => 
             val test = context.freshTest().withFreshSymbol
             c.Split.Let(

From b6c868563ff29ef443ed5eb259bf89605a7f3f1e Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 3 Jan 2024 01:35:42 +0800
Subject: [PATCH 047/147] Support `Forall` term and more shapes of function
 parameters

---
 shared/src/main/scala/mlscript/pretyper/PreTyper.scala | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index 9b60a5ac32..dc349fbe8e 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -11,13 +11,17 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
   private def extractParameters(fields: Term): Ls[LocalTermSymbol] =
     trace(s"extractParameters <== ${inspect.deep(fields)}") {
       fields match {
+        case nme: Var => new LocalTermSymbol(nme) :: Nil
         case Tup(arguments) =>
           arguments.flatMap {
             case (S(nme: Var), Fld(_, _)) => new LocalTermSymbol(nme) :: Nil
             case (_, Fld(_, nme: Var)) => new LocalTermSymbol(nme) :: Nil
-            case (_, Fld(_, Bra(false, nme: Var))) => new LocalTermSymbol(nme) :: Nil
+            case (_, Fld(_, Bra(false, term))) => extractParameters(term)
             case (_, Fld(_, tuple @ Tup(_))) => extractParameters(tuple)
             case (_, Fld(_, Asc(term, _))) => extractParameters(term)
+            case (_, Fld(_, _: Lit)) => Nil
+            case (_, Fld(_, App(Var(name), parameters))) if name.headOption.forall(_.isUpper) =>
+              extractParameters(parameters)
             case (_, Fld(_, parameter)) =>
               println(s"unknown parameter: ${inspect.deep(parameter)}")
               ???
@@ -98,7 +102,7 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
           case L(t) => traverseTerm(t)
           case R(Fld(_, t)) => traverseTerm(t)
         }
-        case Forall(params, body) => ??? // TODO: When?
+        case Forall(params, body) => traverseTerm(body)
         case Rcd(fields) => fields.foreach { case (_, Fld(_, t)) => traverseTerm(t) }
         case CaseOf(trm, cases) => 
         case With(trm, fields) => traverseTerm(trm); traverseTerm(fields)

From 39c8e46dd558f72228ea3a949ffc05618bb34581 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 3 Jan 2024 04:25:45 +0800
Subject: [PATCH 048/147] Fix desugaring and normalization for literal patterns

---
 .../src/main/scala/mlscript/JSBackend.scala   |  3 +-
 .../main/scala/mlscript/ucs/DesugarUCS.scala  | 10 +++
 .../mlscript/ucs/context/ScrutineeData.scala  | 14 +++
 .../mlscript/ucs/stages/Desugaring.scala      | 21 +++--
 .../mlscript/ucs/stages/Normalization.scala   | 85 ++++++++++++++++---
 .../mlscript/ucs/stages/PostProcessing.scala  |  2 +-
 .../diff/pretyper/ucs/patterns/Literals.mls   | 79 ++++++++++++++---
 7 files changed, 183 insertions(+), 31 deletions(-)

diff --git a/shared/src/main/scala/mlscript/JSBackend.scala b/shared/src/main/scala/mlscript/JSBackend.scala
index 34b26f4678..2271da0731 100644
--- a/shared/src/main/scala/mlscript/JSBackend.scala
+++ b/shared/src/main/scala/mlscript/JSBackend.scala
@@ -380,8 +380,7 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
             case _ => throw new CodeGenError(s"unknown match case: $name")
           }
         }
-        case lit: Lit =>
-          JSBinary("===", scrut, JSLit(lit.idStr))
+        case lit: Lit => JSBinary("===", scrut, translateTerm(lit))
       },
       _,
       _
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index aed60275a6..91a3949116 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -67,6 +67,16 @@ trait DesugarUCS extends Transformation
       )
     }
 
+    def withResolvedTermSymbol(implicit scope: Scope): Var = {
+      nme.symbol = nme.resolveTermSymbol
+      nme
+    }
+
+    def resolveTermSymbol(implicit scope: Scope): TermSymbol =
+      scope.getTermSymbol(nme.name).getOrElse {
+        throw new DesugaringException(msg"Undefined symbol found in patterns." -> nme.toLoc :: Nil)
+      }
+
     def withResolvedTypeSymbol(implicit scope: Scope): Var = {
       nme.symbol = nme.resolveTypeSymbol
       nme
diff --git a/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala b/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
index 907b9436b1..251e674f25 100644
--- a/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
@@ -59,6 +59,16 @@ class LiteralPatternInfo extends PatternInfo {
   override def arity: Opt[Int] = N
 }
 
+/**
+  * This can be actually merged with `LiteralPatternInfo`. However, there's no
+  * `Lit` sub-classes for Boolean types, so the representation is a little bit
+  * awkward, also, it makes sense to consider Boolean patterns separately
+  * because we can check the Boolean exhaustiveness with them.
+  */
+class BooleanPatternInfo extends PatternInfo {
+  override def arity: Opt[Int] = N
+}
+
 class ScrutineeData(val context: Context, parent: Opt[ScrutineeData]) {
   private val locations: Buffer[Loc] = Buffer.empty
   private var generatedVarOpt: Opt[Var] = N
@@ -73,6 +83,7 @@ class ScrutineeData(val context: Context, parent: Opt[ScrutineeData]) {
   private var alisesSet: MutSortedSet[Var] = MutSortedSet.empty
 
   private val literalPatterns: MutMap[Lit, LiteralPatternInfo] = MutMap.empty
+  private val booleanPatterns: MutMap[Bool, BooleanPatternInfo] = MutMap.empty
 
   def +=(alias: Var): Unit = alisesSet += alias
 
@@ -120,6 +131,9 @@ class ScrutineeData(val context: Context, parent: Opt[ScrutineeData]) {
   def getOrCreateLiteralPattern(literal: Lit): LiteralPatternInfo =
     literalPatterns.getOrElseUpdate(literal, new LiteralPatternInfo)
 
+  def getOrCreateBooleanPattern(value: Bool): BooleanPatternInfo =
+    booleanPatterns.getOrElseUpdate(value, new BooleanPatternInfo)
+
   def classLikePatternsIterator: Iterator[TypeSymbol -> ClassPatternInfo] = classLikePatterns.iterator
 
   /** Get the name representation of patterns. Only for debugging. */
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 8987c987f1..db8b667938 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -48,7 +48,7 @@ trait Desugaring { self: PreTyper =>
     * `Cons(hd, tl)`, then the name of `hd` will be `x$Cons_0` and the name of
     * `tl` will be `x$Cons_1`.
     */
-  private def freshSubScrutinee(parentScrutinee: Var, parentClassName: Str, index: Int): Var =
+  private def freshSubScrutineeVar(parentScrutinee: Var, parentClassName: Str, index: Int): Var =
     Var(s"${parentScrutinee}$$${parentClassName}_${index.toString}")
 
   /**
@@ -67,6 +67,7 @@ trait Desugaring { self: PreTyper =>
     * Boolean conditions.
     */
   private def truePattern(implicit scope: Scope) = c.Pattern.Class(Var("true").withResolvedTypeSymbol)
+  private def falsePattern(implicit scope: Scope) = c.Pattern.Class(Var("false").withResolvedTypeSymbol)
 
   private def desugarTermSplit(split: s.TermSplit)(implicit termPart: PartialTerm, scope: Scope, context: Context): c.Split =
     split match {
@@ -139,7 +140,7 @@ trait Desugaring { self: PreTyper =>
           val subScrutinee = classPattern.getParameter(index).withAlias(name)
           S(name.withFreshSymbol.withScrutinee(subScrutinee) -> N)
         case (parameterPattern @ (s.ClassPattern(_, _) | s.LiteralPattern(_) | s.TuplePattern(_)), index) =>
-          val subScrutineeVar = freshSubScrutinee(parentScrutineeVar, parentClassLikeSymbol.name, index)
+          val subScrutineeVar = freshSubScrutineeVar(parentScrutineeVar, parentClassLikeSymbol.name, index)
           val symbol = new LocalTermSymbol(subScrutineeVar)
           symbol.addScrutinee(classPattern.getParameter(index).withAlias(subScrutineeVar))
           S(subScrutineeVar.withSymbol(symbol) -> S(parameterPattern))
@@ -264,7 +265,7 @@ trait Desugaring { self: PreTyper =>
         S(name.withFreshSymbol.withScrutinee(tuplePattern.getField(index)) -> N)
       case (parameterPattern @ (s.ClassPattern(_, _) | s.LiteralPattern(_) | s.TuplePattern(_)), index) =>
         val arity = fields.length
-        val subScrutineeVar = freshSubScrutinee(parentScrutineeVar, s"Tuple$$$arity", index)
+        val subScrutineeVar = freshSubScrutineeVar(parentScrutineeVar, s"Tuple$$$arity", index)
         val symbol = new LocalTermSymbol(subScrutineeVar)
         symbol.addScrutinee(tuplePattern.getField(index).withAlias(subScrutineeVar))
         S(subScrutineeVar.withSymbol(symbol) -> S(parameterPattern))
@@ -304,7 +305,17 @@ trait Desugaring { self: PreTyper =>
               pattern = c.Pattern.Literal(literal),
               continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context)
             ) :: rec(scrutineeVar, tail)
-          case s.ConcretePattern(nme) => 
+          case s.ConcretePattern(nme @ (Var("true") | Var("false"))) => 
+            scrutineeVar.getOrCreateScrutinee
+                        .withAlias(scrutineeVar)
+                        .getOrCreateBooleanPattern(nme.name === "true")
+                        .addLocation(nme)
+            c.Branch(
+              scrutinee = scrutineeVar,
+              pattern = c.Pattern.Class(nme.withResolvedTypeSymbol),
+              continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context)
+            ) :: rec(scrutineeVar, tail)
+          case s.ConcretePattern(nme) =>
             val test = context.freshTest().withFreshSymbol
             c.Split.Let(
               rec = false,
@@ -354,7 +365,7 @@ trait Desugaring { self: PreTyper =>
       case s.Split.Nil => c.Split.Nil
     }
     scrutineeTerm match {
-      case nme: Var => rec(nme, split)
+      case nme: Var => rec(nme.withResolvedTermSymbol, split)
       case other =>
         val alias = context.freshScrutineeVar().withFreshSymbol
         c.Split.Let(false, alias, other, rec(alias, split)(scope + alias.symbol))
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 5f42fd2b4c..2aecc7ac5e 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -12,13 +12,22 @@ import mlscript.{App, CaseOf, Fld, FldFlags, Let, Loc, Sel, Term, Tup, Var, StrL
 import mlscript.{CaseBranches, Case, Wildcard, NoCases}
 import mlscript.Message, Message.MessageContext
 import mlscript.utils._, shorthands._
+import mlscript.pretyper.{Traceable, Diagnosable}
 
-trait Normalization { self: mlscript.pretyper.Traceable =>
+trait Normalization { self: Traceable with Diagnosable =>
   import Normalization._
 
   private def concatImpl(these: Split, those: Split)(implicit context: Context, generatedVars: Set[Var]): Split =
     if (these.hasElse) these else (these match {
-      case these @ Split.Cons(_, tail) => these.copy(tail = concatImpl(tail, those))
+      case these @ Split.Cons(head, tail) =>
+        println(s"found a cons: $head")
+        if (head.continuation.hasElse) {
+          these.copy(tail = concatImpl(tail, those))
+        } else {
+          println("found a branch without default, duplicating...")
+          val newHead = head.copy(continuation = concat(head.continuation, those))
+          these.copy(head = newHead, tail = concatImpl(tail, those))
+        }
       case these @ Split.Let(_, nme, _, tail) =>
         if (those.freeVars contains nme) {
           val fresh = context.freshShadowed()
@@ -50,38 +59,50 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
   private def normalizeToTerm(split: Split)(implicit context: Context, generatedVars: Set[Var]): Term = trace("normalizeToTerm <==") {
     split match {
       case Split.Cons(Branch(scrutinee, Pattern.Name(nme), continuation), tail) =>
-        println(s"alias $scrutinee => $nme")
+        println(s"normalizing name pattern ${scrutinee.name} is ${nme.name}")
         Let(false, nme, scrutinee, normalizeToTerm(concat(continuation, tail)))
       // Skip Boolean conditions as scrutinees, because they only appear once.
       case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true")), continuation), tail) if context.isTestVar(test) =>
+        println(s"normalizing true pattern: ${test.name} is true")
         val trueBranch = normalizeToTerm(concat(continuation, tail))
         val falseBranch = normalizeToCaseBranches(tail)
         CaseOf(test, Case(nme, trueBranch, falseBranch))
       case Split.Cons(Branch(ScrutineeData.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Literal(literal), continuation), tail) =>
-        val trueBranch = normalizeToTerm(specialize(concat(continuation, tail), true)(scrutineeVar, scrutinee, pattern, context))
+        println(s"normalizing literal pattern: ${scrutineeVar.name} is $literal")
+        val concatenatedTrueBranch = concat(continuation, tail)
+        println(s"true branch: ${showSplit(concatenatedTrueBranch)}")
+        val trueBranch = normalizeToTerm(specialize(concatenatedTrueBranch, true)(scrutineeVar, scrutinee, pattern, context))
+        println(s"false branch: ${showSplit(tail)}")
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context))
         CaseOf(scrutineeVar, Case(literal, trueBranch, falseBranch))
-      // false class parameters. Easy
       case Split.Cons(Branch(ScrutineeData.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Class(nme), continuation), tail) =>
-        println(s"match ${scrutineeVar.name} with $nme (has location: ${nme.toLoc.isDefined})")
+        println(s"normalizing class pattern: ${scrutineeVar.name} is ${nme.name}")
+        // println(s"match ${scrutineeVar.name} with $nme (has location: ${nme.toLoc.isDefined})")
         val trueBranch = normalizeToTerm(specialize(concat(continuation, tail), true)(scrutineeVar, scrutinee, pattern, context))
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context))
         CaseOf(scrutineeVar, Case(nme, trueBranch, falseBranch))
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
+        println(s"unknown pattern ${pattern.getClass().getSimpleName()}")
         throw new NormalizationException((msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc) :: Nil)
       case Split.Let(rec, Var("_"), rhs, tail) => normalizeToTerm(tail)
       case Split.Let(_, nme, _, tail) if context.isScrutineeVar(nme) && generatedVars.contains(nme) =>
+        println(s"normalizing let binding of generated variable: ${nme.name}")
         normalizeToTerm(tail)
       case Split.Let(rec, nme, rhs, tail) =>
+        println(s"normalizing let binding ${nme.name}")
         val newDeclaredBindings = if (context.isGeneratedVar(nme)) generatedVars + nme else generatedVars
         Let(rec, nme, rhs, normalizeToTerm(tail)(context, newDeclaredBindings))
-      case Split.Else(default) => default
-      case Split.Nil => println("unexpected empty split"); ???
+      case Split.Else(default) =>
+        println(s"normalizing default: $default")
+        default
+      case Split.Nil =>
+        println(s"normalizing nil")
+        ???
     }
-  }(_ => "normalizeToTerm ==> ")
+  }(split => "normalizeToTerm ==> " + showNormalizedTerm(split))
 
   private def normalizeToCaseBranches(split: Split)(implicit context: Context, generatedVars: Set[Var]): CaseBranches =
-    trace("normalizeToCaseBranches") {
+    trace(s"normalizeToCaseBranches <== $split") {
       split match {
         // case Split.Cons(head, Split.Nil) => Case(head.pattern, normalizeToTerm(head.continuation), NoCases)
         case other: Split.Cons => Wildcard(normalizeToTerm(other))
@@ -98,7 +119,7 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
         case Split.Else(default) => Wildcard(default)
         case Split.Nil => NoCases
       }
-    }()
+    }(r => "normalizeToCaseBranches ==> ")
 
   // Specialize `split` with the assumption that `scrutinee` matches `pattern`.
   private def specialize
@@ -180,6 +201,48 @@ trait Normalization { self: mlscript.pretyper.Traceable =>
             tail = specialize(tail, matchOrNot)
           )
         }
+      // Literal pattern. Positive.
+      case (true, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Literal(otherLiteral), continuation), tail)) =>
+        if (scrutinee === otherScrutinee) {
+          println(s"scrutinee: ${scrutineeVar.name} is ${otherScrutineeVar.name}")
+          pattern match {
+            case Pattern.Literal(literal) if literal === otherLiteral =>
+              val specialized = specialize(continuation, true)
+              if (specialized.hasElse) {
+                println("tail is discarded")
+                specialized.withDiagnostic(
+                  msg"Discarded split because of else branch" -> None // TODO: Synthesize locations
+                )
+              } else {
+                specialized ++ specialize(tail, true)
+              }
+            case _ => specialize(tail, true)
+          }
+        } else {
+          println(s"scrutinee: ${scrutineeVar.name} is NOT ${otherScrutineeVar.name}")
+          split.copy(
+            head = head.copy(continuation = specialize(continuation, true)),
+            tail = specialize(tail, true)
+          )
+        }
+      // Literal pattern. Negative.
+      case (false, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Literal(otherLiteral), continuation), tail)) =>
+        if (scrutinee === otherScrutinee) {
+          println(s"scrutinee: ${scrutineeVar.name} is ${otherScrutineeVar.name}")
+          pattern match {
+            case Pattern.Literal(literal) if literal === otherLiteral =>
+              specialize(tail, false)
+            case _ =>
+              // No need to check `continuation` because literals don't overlap.
+              split.copy(tail = specialize(tail, false))
+          }
+        } else {
+          println(s"scrutinee: ${scrutineeVar.name} is NOT ${otherScrutineeVar.name}")
+          split.copy(
+            head = head.copy(continuation = specialize(continuation, false)),
+            tail = specialize(tail, false)
+          )
+        }
       // Other patterns. Not implemented.
       case (_, Split.Cons(Branch(otherScrutineeVar, pattern, continuation), tail)) =>
         println(s"unsupported pattern: $pattern")
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index e288ead4c1..4958ec79ed 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -18,7 +18,7 @@ trait PostProcessing { self: DesugarUCS with mlscript.pretyper.Traceable =>
         println(s"found a UNARY case: $scrutineeVar is $className")
         println("post-processing the body")
         top.copy(cases = fst.copy(body = postProcess(body)))
-      case top @ CaseOf(test: Var, fst @ Case(Var("true"), trueBranch, Wildcard(falseBranch))) if context.isTestVar(test) =>
+      case top @ CaseOf(test: Var, fst @ Case(Var("true"), trueBranch, Wildcard(falseBranch))) =>
         println(s"found a if-then-else case: $test is true")
         val processedTrueBranch = postProcess(trueBranch)
         val processedFalseBranch = postProcess(falseBranch)
diff --git a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
index fe9713c694..2dd0048f06 100644
--- a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
+++ b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
@@ -10,18 +10,25 @@ class Pair[A, B](x: A, y: B)
 //│ class Pair[A, B](x: A, y: B)
 
 fun f(x) = if x is Some(1) then true else false
-//│ fun f: (Object & ~#Some | Some[Eql[1]]) -> Bool
+//│ fun f: (Object & ~#Some | Some[Object]) -> Bool
+
+[f(Some(1)), f(None), f(Some(2)), f(Some(-1))]
+//│ [Bool, Bool, Bool, Bool]
+//│ res
+//│     = [ true, false, false, false ]
 
-:e
-// TODO: Proper diagnostic information reporting.
 fun f(x) = if x is Some(1) then true
-//│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.17: 	fun f(x) = if x is Some(1) then true
-//│ ║        	                                ^^^^
-//│ ╟── application of type `Bool` is not an instance of type `true`
-//│ ║  l.17: 	fun f(x) = if x is Some(1) then true
-//│ ╙──      	                        ^
-//│ fun f: Some[Eql[1]] -> true
+//│ fun f: Some[1] -> true
+
+fun f(x) = if x is
+  Some(1) then true
+  Some(2) then false
+//│ fun f: Some[1 | 2] -> Bool
+
+[f(Some(1)), f(Some(2))]
+//│ [Bool, Bool]
+//│ res
+//│     = [ true, false ]
 
 fun g(x) = if x then 1 else 2
 //│ fun g: Bool -> (1 | 2)
@@ -29,13 +36,18 @@ fun g(x) = if x then 1 else 2
 :e
 fun test_must_be_boolean(x) = if 0 then 1 else 2
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.30: 	fun test_must_be_boolean(x) = if 0 then 1 else 2
+//│ ║  l.37: 	fun test_must_be_boolean(x) = if 0 then 1 else 2
 //│ ║        	                                 ^
 //│ ╙── integer literal of type `0` is not an instance of type `Bool`
 //│ fun test_must_be_boolean: anything -> (1 | 2)
 
 fun g(x) = if x is true then 1 else 2
-//│ fun g: Eql[true] -> (1 | 2)
+//│ fun g: Object -> (1 | 2)
+
+[g(true), g(false), g(None)]
+//│ [1 | 2, 1 | 2, 1 | 2]
+//│ res
+//│     = [ 1, 2, 2 ]
 
 fun g(x) = if x && true is true then 1 else 2
 //│ fun g: Bool -> (1 | 2)
@@ -43,3 +55,46 @@ fun g(x) = if x && true is true then 1 else 2
 fun h(x) = if (x : Bool) then 1 else 2
 //│ fun h: Bool -> (1 | 2)
 
+// Currently post-processing cannot hanlde this case. The desugared term is not
+// perfect. Also, is the inferred type wrong?
+fun mix(x) = if x is
+  true then "true"
+  Some(value) then "Some"
+  0 then "zero"
+//│ fun mix: (0 | Some[anything]) -> ("Some" | "true" | "zero")
+
+[mix(true), mix(Some(1)), mix(0)]
+//│ ["Some" | "true" | "zero", "Some" | "true" | "zero", "Some" | "true" | "zero"]
+//│ res
+//│     = [ 'true', 'Some', 'zero' ]
+
+:e
+[mix(false), mix(None)]
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.72: 	[mix(false), mix(None)]
+//│ ║        	 ^^^^^^^^^^
+//│ ╟── reference of type `false` does not match type `0`
+//│ ║  l.72: 	[mix(false), mix(None)]
+//│ ║        	     ^^^^^
+//│ ╟── Note: constraint arises from literal pattern:
+//│ ║  l.63: 	  0 then "zero"
+//│ ║        	  ^
+//│ ╟── from reference:
+//│ ║  l.60: 	fun mix(x) = if x is
+//│ ╙──      	                ^
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.72: 	[mix(false), mix(None)]
+//│ ║        	             ^^^^^^^^^
+//│ ╟── reference of type `None` does not match type `0`
+//│ ║  l.72: 	[mix(false), mix(None)]
+//│ ║        	                 ^^^^
+//│ ╟── Note: constraint arises from literal pattern:
+//│ ║  l.63: 	  0 then "zero"
+//│ ║        	  ^
+//│ ╟── from reference:
+//│ ║  l.60: 	fun mix(x) = if x is
+//│ ╙──      	                ^
+//│ ["Some" | "true" | "zero" | error, "Some" | "true" | "zero" | error]
+//│ res
+//│ Runtime error:
+//│   Error: non-exhaustive case expression

From a55e9597df73fc7d4f3e855be2b76e7c909dbdee Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 3 Jan 2024 15:04:45 +0800
Subject: [PATCH 049/147] Remove vertically aligned lines

---
 .../main/scala/mlscript/ucs/stages/Desugaring.scala    | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 480ef23910..e58d9b560d 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -296,20 +296,14 @@ trait Desugaring { self: PreTyper =>
             raiseError(PreTyping, msg"alias pattern is not supported for now" -> pattern.toLoc)
             rec(scrutineeVar, tail)
           case s.LiteralPattern(literal) =>
-            scrutineeVar.getOrCreateScrutinee
-                        .withAlias(scrutineeVar)
-                        .getOrCreateLiteralPattern(literal)
-                        .addLocation(literal)
+            scrutineeVar.getOrCreateScrutinee.withAlias(scrutineeVar).getOrCreateLiteralPattern(literal).addLocation(literal)
             c.Branch(
               scrutinee = scrutineeVar,
               pattern = c.Pattern.Literal(literal),
               continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context)
             ) :: rec(scrutineeVar, tail)
           case s.ConcretePattern(nme @ (Var("true") | Var("false"))) => 
-            scrutineeVar.getOrCreateScrutinee
-                        .withAlias(scrutineeVar)
-                        .getOrCreateBooleanPattern(nme.name === "true")
-                        .addLocation(nme)
+            scrutineeVar.getOrCreateScrutinee.withAlias(scrutineeVar).getOrCreateBooleanPattern(nme.name === "true").addLocation(nme)
             c.Branch(
               scrutinee = scrutineeVar,
               pattern = c.Pattern.Class(nme.withResolvedTypeSymbol),

From 70f825aab0324fafb8e71af14584cb7455c4d28d Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 3 Jan 2024 15:09:13 +0800
Subject: [PATCH 050/147] Replace `rare` with `die`

---
 .../scala/mlscript/ucs/stages/Transformation.scala   | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index 396c02b7dc..a02dcb368d 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -55,7 +55,7 @@ trait Transformation { self: Traceable with Diagnosable =>
   private def transformIfBody(body: IfBody): TermSplit = trace(s"transformIfBody <== ${inspect.shallow(body)}") {
     body match {
       case IfThen(expr, rhs) => transformConjunction(splitAnd(expr), Split.then(rhs), true)
-      case IfLet(isRec, name, rhs, body) => rare
+      case IfLet(isRec, name, rhs, body) => die
       case IfElse(expr) => Split.then(expr)
       case IfOpApp(lhs, Var("is"), rhs) =>
         val (tests, scrutinee) = extractLast(splitAnd(lhs))
@@ -83,7 +83,7 @@ trait Transformation { self: Traceable with Diagnosable =>
             transformConjunction(init, inner, false)
           case init :+ last =>
             transformConjunction(init, TermBranch.Left(last, Split.from(opsRhss.map(transformOperatorBranch))).toSplit, false)
-          case _ => rare
+          case _ => die
         }
     }
   }(_ => "transformIfBody ==> ")
@@ -156,7 +156,7 @@ trait Transformation { self: Traceable with Diagnosable =>
           // I think it's not very well-formed. But I still implement it for not
           // breaking existing tests.
           splitAnd(lhs) match {
-            case Nil => rare // It's impossible to be empty.
+            case Nil => die // It's impossible to be empty.
             case pattern :: tail =>
               // Here, `pattern` will be `( Cons x xs )` and `tail` will be
               // `[ is ys (Cons y ys) ]`. We can make a new `IfOpsApp`.
@@ -174,7 +174,7 @@ trait Transformation { self: Traceable with Diagnosable =>
               }
           }
           // END TEMPORARY PATCH
-        case IfLet(rec, nme, rhs, body) => rare
+        case IfLet(rec, nme, rhs, body) => die
         case IfBlock(lines) => lines.foldLeft(Split.empty[PatternBranch]) {
           case (acc, L(body)) => acc ++ transformPatternMatching(body)
           case (acc, R(NuFunDef(S(rec), nme, _, _, L(rhs)))) =>
@@ -237,11 +237,9 @@ trait Transformation { self: Traceable with Diagnosable =>
 }
 
 object Transformation {
-  private def rare: Nothing = lastWords("found a very rare case during desugaring UCS terms")
-
   private def extractLast[T](xs: List[T]): (List[T], T) = xs match {
     case init :+ last => init -> last
-    case _ => rare
+    case _ => die
   }
 
   private object is {

From 3ff17d14ed10974bef5ab1c1a53d4a50e55d129f Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 3 Jan 2024 15:21:56 +0800
Subject: [PATCH 051/147] Remove `inspect` from this branch

---
 .../scala/mlscript/pretyper/PreTyper.scala    |  18 +-
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |   3 +-
 .../scala/mlscript/ucs/context/CaseSet.scala  |   2 +-
 .../ucs/stages/CoverageChecking.scala         |   2 +-
 .../mlscript/ucs/stages/PostProcessing.scala  |  12 +-
 .../mlscript/ucs/stages/Transformation.scala  |  12 +-
 .../main/scala/mlscript/utils/inspect.scala   | 193 ------------------
 .../test/diff/pretyper/ucs/examples/ULC.mls   |   8 +-
 8 files changed, 29 insertions(+), 221 deletions(-)
 delete mode 100644 shared/src/main/scala/mlscript/utils/inspect.scala

diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index dc349fbe8e..8b4ba5ecff 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -9,7 +9,7 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
   import PreTyper._
 
   private def extractParameters(fields: Term): Ls[LocalTermSymbol] =
-    trace(s"extractParameters <== ${inspect.deep(fields)}") {
+    trace(s"extractParameters <== $fields") {
       fields match {
         case nme: Var => new LocalTermSymbol(nme) :: Nil
         case Tup(arguments) =>
@@ -23,15 +23,15 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
             case (_, Fld(_, App(Var(name), parameters))) if name.headOption.forall(_.isUpper) =>
               extractParameters(parameters)
             case (_, Fld(_, parameter)) =>
-              println(s"unknown parameter: ${inspect.deep(parameter)}")
+              println(s"unknown parameter: $parameter")
               ???
           }
         case PlainTup(arguments @ _*) =>
           arguments.map {
             case nme: Var => new LocalTermSymbol(nme)
-            case other => println("Unknown parameters: " + inspect.deep(other)); ??? // TODO: bad
+            case other => println("Unknown parameters: " + other.toString); ??? // TODO: bad
           }.toList
-        case other => println("Unknown parameters: " + inspect.deep(other)); ??? // TODO: bad
+        case other => println("Unknown parameters: " + other.toString); ??? // TODO: bad
       }
     }(rs => s"extractParameters ==> ${rs.iterator.map(_.name).mkString(", ")}")
 
@@ -76,7 +76,7 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
     }()
 
   protected def traverseTerm(term: Term)(implicit scope: Scope): Unit =
-    trace(s"traverseTerm <== ${inspect.shallow(term)}") {
+    trace(s"traverseTerm <== ${term.showDbg}") {
       term match {
         case Assign(lhs, rhs) => traverseTerm(lhs); traverseTerm(rhs)
         case Bra(_, trm) => traverseTerm(trm)
@@ -119,7 +119,7 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
           traverseStatements(decls.entities, "Rft", scope)
           ()
       }
-    }(_ => s"traverseTerm ==> ${inspect.shallow(term)}")
+    }(_ => s"traverseTerm ==> ${term.showDbg}")
 
   private def traverseTypeDefinition(symbol: TypeSymbol, defn: NuTypeDef)(implicit scope: Scope): Unit =
     trace(s"traverseTypeDefinition <== ${defn.describe}") {
@@ -176,14 +176,14 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
           acc
       }
       println(thingsToTraverse.iterator.map {
-        case (L(term), _) => inspect.shallow(term)
+        case (L(term), _) => term.showDbg
         case (R(symbol), _) => symbol.name
       }.mkString("to be traversed: {", ", ", "}"))
       // Pass 3: Traverse terms collected from the last pass.
       println("Pass 3")
       thingsToTraverse.foreach {
         case (L(term), scope) =>
-          println("traverseTerm: " + inspect.shallow(term))
+          println("traverseTerm: " + term.showDbg)
           println("scope: " + scope.showLocalSymbols)
           traverseTerm(term)(scope)
         case (R(symbol), scope) => symbol.body match {
@@ -215,7 +215,7 @@ object PreTyper {
         case (nme: Var) :: tail => rec(nme :: results, tail)
         case (TyApp(ty, _)) :: tail => rec(results, ty :: tail)
         case (App(nme @ Var(_), Tup(_))) :: tail => rec(nme :: results, tail)
-        case other :: _ => println(s"Unknown parent type: ${inspect.deep(other)}"); ???
+        case other :: _ => println(s"Unknown parent type: $other"); ???
       }
     rec(Nil, parents)
   }
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 91a3949116..8c36f23ad5 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -29,7 +29,7 @@ trait DesugarUCS extends Transformation
       * @param className the class name variable
       */
     def getClassLikeSymbol: TypeSymbol =
-      trace(s"getClassLikeSymbol <== ${inspect.shallow(nme)}") {
+      trace(s"getClassLikeSymbol <== ${nme.showDbg}") {
         nme.symbolOption match {
           case S(symbol: ClassSymbol) => symbol
           case S(symbol: TraitSymbol) => symbol
@@ -152,6 +152,7 @@ trait DesugarUCS extends Transformation
       }
       // Epilogue
       `if`.desugaredTerm = S(postProcessed)
+      println(s"Desugared term: ${postProcessed.showDbg}")
     }(_ => "traverseIf ==> ()")
   }
   
diff --git a/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala b/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
index d517df520f..313eb615ed 100644
--- a/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
@@ -8,7 +8,7 @@ sealed abstract class Pattern {
   override def toString(): String = this match {
     case Pattern.ClassLike(symbol) => s"${symbol.defn.kind.str} `${symbol.name}`"
     case Pattern.Tuple() => "tuple"
-    case Pattern.Literal(literal) => s"literal ${inspect.deep(literal)}"
+    case Pattern.Literal(literal) => s"literal $literal"
   }
 }
 
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index b583c1e08a..1ac919598d 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -22,7 +22,7 @@ trait CoverageChecking { self: mlscript.pretyper.Traceable =>
       working: MatchRegistry,
       seen: SeenRegistry
   )(implicit context: Context): Ls[Diagnostic] =
-    trace(s"checkCoverage <== ${inspect.shallow(term)}, ${pending.size} pending, ${working.size} working, ${seen.size} seen") {
+    trace(s"checkCoverage <== ${term.showDbg}, ${pending.size} pending, ${working.size} working, ${seen.size} seen") {
       println(s"seen: " + (if (seen.isEmpty) "empty" else
         seen.iterator.map { case ((k, _), (s, _, _)) => s"${k.name} is ${s.name}" }.mkString(", ")
       ))
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index 4958ec79ed..53401c0e7c 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -11,7 +11,7 @@ import scala.annotation.tailrec
 trait PostProcessing { self: DesugarUCS with mlscript.pretyper.Traceable =>
   import PostProcessing._
 
-  def postProcess(term: Term)(implicit context: Context): Term = trace(s"postProcess <== ${inspect.shallow(term)}") {
+  def postProcess(term: Term)(implicit context: Context): Term = trace(s"postProcess <== ${term.showDbg}") {
     // Normalized terms are constructed using `Let` and `CaseOf`.
     term match {
       case top @ CaseOf(scrutineeVar: Var, fst @ Case(className: Var, body, NoCases)) =>
@@ -100,16 +100,16 @@ trait PostProcessing { self: DesugarUCS with mlscript.pretyper.Traceable =>
     }
 
   private def mergeTerms(t1: Term, t2: Term): Term =
-    trace(s"mergeTerms <== ${inspect.shallow(t1)} ${inspect.shallow(t2)}") {
+    trace(s"mergeTerms <== ${t1.showDbg} ${t2.showDbg}") {
       t1 match {
         case t1 @ Let(_, _, _, body) => t1.copy(body = mergeTerms(body, t2))
         case t1 @ CaseOf(scrutinee: Var, cases) =>
           t1.copy(cases = mergeTermIntoCaseBranches(t2, cases))
         case _ =>
-          println(s"CANNOT merge. Discard ${inspect.shallow(t2)}.")
+          println(s"CANNOT merge. Discard ${t2.showDbg}.")
           t1
       }
-    }(merged => s"mergedTerms ==> ${inspect.shallow(merged)}")
+    }(merged => s"mergedTerms ==> ${merged.showDbg}")
 
   private def mergeTermIntoCaseBranches(term: Term, cases: CaseBranches): CaseBranches =
     trace(s"mergeTermIntoCaseBranches <== ${term.describe} ${cases}") {
@@ -187,10 +187,10 @@ trait PostProcessing { self: DesugarUCS with mlscript.pretyper.Traceable =>
           val (n, y) = disentangle(body, scrutineeVar, scrutinee, classSymbol)
           (let.copy(body = n), y.map(t => let.copy(body = t)))
         case other =>
-          println(s"cannot disentangle ${inspect.shallow(other)}. STOP")
+          println(s"cannot disentangle ${other.showDbg}. STOP")
           other -> N
       }
-    }({ case (n, y) => s"disentangle ==> `${inspect.deep(n)}` and `${y.fold("<empty>")(inspect.deep(_))}`" })
+    }({ case (n, y) => s"disentangle ==> `$n` and `${y.fold("<empty>")(_.toString)}`" })
 }
 
 object PostProcessing {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index a02dcb368d..c9f989d93c 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -52,7 +52,7 @@ trait Transformation { self: Traceable with Diagnosable =>
       case (test, following) => TermBranch.Boolean(test, following).toSplit
     }
 
-  private def transformIfBody(body: IfBody): TermSplit = trace(s"transformIfBody <== ${inspect.shallow(body)}") {
+  private def transformIfBody(body: IfBody): TermSplit = trace(s"transformIfBody <== ${body.showDbg}") {
     body match {
       case IfThen(expr, rhs) => transformConjunction(splitAnd(expr), Split.then(rhs), true)
       case IfLet(isRec, name, rhs, body) => die
@@ -114,7 +114,7 @@ trait Transformation { self: Traceable with Diagnosable =>
     * Transform an `IfBody` into a `PatternSplit`.
     */
   private def transformPatternMatching(body: IfBody): PatternSplit =
-    trace(s"transformPatternMatching <== ${inspect.shallow(body)}") {
+    trace(s"transformPatternMatching <== ${body.showDbg}") {
       body match {
         case IfThen(expr, rhs) => 
           separatePattern(expr) match {
@@ -124,7 +124,7 @@ trait Transformation { self: Traceable with Diagnosable =>
               PatternBranch(pattern, Split.default(rhs)).toSplit
           }
         case IfOpApp(lhs, Var("and"), rhs) =>
-          println(s"lhs: ${inspect.deep(lhs)}")
+          println(s"lhs: $lhs")
           separatePattern(lhs) match {
             case (pattern, S(extraTest)) =>
               PatternBranch(pattern, TermBranch.Boolean(extraTest, transformIfBody(rhs)).toSplit).toSplit
@@ -214,14 +214,14 @@ trait Transformation { self: Traceable with Diagnosable =>
 
   private def separatePattern(term: Term): (Pattern, Opt[Term]) = {
     val (rawPattern, extraTest) = helpers.separatePattern(term, true)
-    println("rawPattern: " + inspect.deep(rawPattern))
-    println("extraTest: " + inspect.deep(extraTest))
+    println("rawPattern: " + rawPattern.toString)
+    println("extraTest: " + extraTest.toString)
     (transformPattern(rawPattern), extraTest)
   }
 
   // TODO: Maybe we can change the return type to `::[Term]` so that it will not
   // empty.
-  private def splitAnd(t: Term): List[Term] = trace(s"splitAnd <== ${inspect.deep(t)}") {
+  private def splitAnd(t: Term): List[Term] = trace(s"splitAnd <== $t") {
     t match {
       case App(
         App(Var("and"),
diff --git a/shared/src/main/scala/mlscript/utils/inspect.scala b/shared/src/main/scala/mlscript/utils/inspect.scala
deleted file mode 100644
index 5b095229ec..0000000000
--- a/shared/src/main/scala/mlscript/utils/inspect.scala
+++ /dev/null
@@ -1,193 +0,0 @@
-package mlscript.utils
-
-import mlscript._, shorthands._
-
-object inspect {
-  object shallow {
-    def apply(term: Statement): Str = term match {
-      case Var(name) => s"Var(\"$name\")"
-      case literal: Lit => s"Lit(${literal.toString})"
-      case fd: NuFunDef => fd.isLetRec.fold("fun")(if (_) "let rec" else "let") + " " + fd.nme.name
-      case td: NuTypeDef => s"${td.kind.str} ${td.nme.name}"
-      case _ =>
-        val name = term.getClass.getSimpleName
-        val arity = term.children.length // Imprecise
-        if (arity === 0) { name } else s"${name}(${(", _" * arity).drop(2)})"
-    }
-
-    def apply(body: IfBody): Str = body match {
-      case IfOpApp(lhs, op, rhs) => s"IfOpApp(${apply(lhs)}, ${apply(op)}, _)"
-      case IfLet(isRec, name, rhs, body) => s"IfLet($isRec, $name, _, _)"
-      case IfThen(expr, rhs) => s"IfThen(${apply(expr)}, _)"
-      case IfOpsApp(lhs, opsRhss) => s"IfOpsApp(${apply(lhs)}, ${opsRhss.map { case (op, body) => s"$op -> _" }.mkString("; ")})"
-      case IfBlock(lines) => s"IfBlock(_)"
-      case IfElse(expr) => s"IfElse(${apply(expr)})"
-    }
-
-    def apply(d: TypingUnit): Str = d.entities.iterator
-      .map(apply)
-      .mkString("{", ", ", "}")
-  }
-
-  object deep {
-    def apply(t: Opt[Located]): Str = t match {
-      case N => "N"
-      case S(l) => s"S(${apply(l)})"
-    }
-
-    def apply(t: Ls[Located]): Str = t match {
-      case Nil => "Nil"
-      case head :: Nil => s"${apply(head)} :: Nil"
-      case first :: second :: Nil => s"${apply(first)} :: ${apply(second)} :: Nil"
-      case _ => t.iterator.map(apply).mkString("Ls(", ", ", ")")
-    }
-
-    def apply[A <: Located, B <: Located](t: Either[A, B]): Str = t match {
-      case L(value) => s"L(${apply(value)})"
-      case R(value) => s"R(${apply(value)})"
-    }
-
-    def apply(t: Located): Str = t match {
-      case st: Statement => statement(st)
-      case fl: Field => field(fl)
-      case ty: TypeLike => typeLike(ty)
-      case ib: IfBody => ifBody(ib)
-      case tu: TypingUnit => typingUnit(tu)
-      case _ => "??"
-    }
-
-    private def statement(statement: Statement): Str = statement match {
-      case Def(rec, nme, rhs, isByname) => s"Def($rec, ${apply(nme)}, ${apply(rhs)}, $isByname)"
-      case TypeDef(kind, nme, tparams, body, mthDecls, mthDefs, positionals, adtInfo) => s"TypeDef(...)"
-      case Var(name)     => s"Var(\"$name\")"
-      case Lam(lhs, rhs) => s"Lam(${apply(lhs)}, ${apply(rhs)})"
-      case App(lhs, rhs) => s"App(${apply(lhs)}, ${apply(rhs)})"
-      case Tup(Nil) => "Tup(Nil)"
-      case Tup(fields) =>
-        fields.iterator.map { case (maybeName, Fld(flags, value)) =>
-          val first = maybeName.fold("N") { name => s"S($name)" }
-          val second = s"Fld(_, ${apply(value)})"
-          s"($first, $second)"
-        }.mkString("Tup(", " :: ", " :: Nil)")
-      case Rcd(fields) =>
-        fields.iterator.map { case k -> Fld(_, v) => s"${apply(k)} = ${apply(v)}" }.mkString("Rcd(", ", ", ")")
-      case Sel(receiver, fieldName)    => s"Sel(${apply(receiver)}, $fieldName)"
-      case Let(isRec, name, rhs, body) => s"Let($isRec, $name, ${apply(rhs)}, ${apply(body)})"
-      case Blk(stmts)                  => s"Blk(${stmts.iterator.map(apply).mkString(", ")})"
-      case Bra(rcd, trm)               => s"Bra(rcd = $rcd, ${apply(trm)})"
-      case Asc(trm, ty)                => s"Asc(${apply(trm)}, $ty)"
-      case Bind(lhs, rhs)              => s"Bind(${apply(lhs)}, ${apply(rhs)})"
-      case Test(trm, ty)               => s"Test(${apply(trm)}, ${apply(ty)})"
-      case With(trm, fields) =>
-        s"With(${apply(trm)}, ${apply(fields)})"
-      case CaseOf(trm, cases) =>
-        def inspectCaseBranches(br: CaseBranches): Str = br match {
-          case Case(clsNme, body, rest) =>
-            s"Case($clsNme, ${apply(body)}, ${inspectCaseBranches(rest)})"
-          case Wildcard(body) => s"Wildcard(${apply(body)})"
-          case NoCases        => "NoCases"
-        }
-        s"CaseOf(${apply(trm)}, ${inspectCaseBranches(cases)})"
-      case IntLit(value)  => s"IntLit($value)"
-      case DecLit(value)  => s"DecLit($value)"
-      case StrLit(value)  => s"StrLit($value)"
-      case UnitLit(value)  => s"UnitLit($value)"
-      case Subs(arr, idx) => s"Subs(${apply(arr)}, ${apply(idx)})"
-      case Assign(f, v)   => s"Assign(${apply(f)}, ${apply(v)})"
-      case Splc(fs)       => 
-        fs.iterator.map{ case L(l) => s"...${apply(l)}" case R(Fld(_, r)) => apply(r)}.mkString("Splc(", ", ", ")")
-      case If(bod, els) => s"If(${apply(bod)}, ${els.map(apply)})"
-      case New(base, body) => s"New(${base}, ${apply(body)})"
-      case NuNew(base) => s"NuNew(${apply(base)})"
-      case TyApp(base, targs) => s"TyApp(${apply(base)}, ${targs})"
-      case Where(bod, sts) => s"Where(${apply(bod)}, ...)"
-      case Forall(ps, bod) => s"Forall($ps, ${apply(bod)})"
-      case Inst(bod) => s"Inst(${apply(bod)})"
-      case Eqn(lhs, rhs) => s"Eqn(${apply(lhs)}, ${apply(rhs)})"
-      case Super() => "Super()"
-      case AdtMatchWith(cond, arms) =>
-        s"match ${apply(cond)} with ${arms.map(patmat => s"${apply(patmat.pat)} -> ${apply(patmat.rhs)}").mkString(" | ")}"
-      case Rft(bse, tu) => s"Rft(${apply(bse)}, ${apply(tu)})"
-      case LetS(isRec, pat, rhs) => s"LetS($isRec, ${apply(pat)}, ${apply(rhs)})"
-      case DataDefn(body) => s"DataDefn(${apply(body)})"
-      case DatatypeDefn(head, body) => s"DatatypeDefn(${apply(head)}, ${apply(body)})"
-      case NuTypeDef(kind, nme, tparams, params, ctor, sig, parents, superAnnot, thisAnnot, body) =>
-        s"NuTypeDef($kind, ${apply(nme)}, Ls(" +
-          tparams.iterator.map {
-            case (S(vi), tn) => s"S($vi) -> ${apply(tn)}"
-            case (N, tn) => s"N -> ${apply(tn)}"
-          }.mkString(", ") + "), " +
-          apply(params) + ", " +
-          apply(ctor) + ", " +
-          apply(sig) + ", " +
-          parents.iterator.map(apply).mkString("Ls(", ", ", ")") + ", " +
-          apply(superAnnot) + ", " +
-          apply(thisAnnot) + ", " +
-          apply(body) + ")"
-      case NuFunDef(isLetRec, nme, symbolicNme, tparams, rhs) =>
-        s"NuFunDef($isLetRec, ${nme.name}, ${apply(symbolicNme)}, ${apply(tparams)}, ${apply(rhs)})"
-      case Constructor(params, body) => s"Constructor"
-    }
-
-    private def field(field: Field): Str = field match {
-      case Field(nme, value) => s"Fld(${apply(nme)}, ${apply(value)})"
-    }
-
-    private def typeLike(ty: TypeLike): Str = ty match {
-      case Union(lhs, rhs) => s"Union(${apply(lhs)}, ${apply(rhs)})"
-      case Inter(lhs, rhs) => s"Inter(${apply(lhs)}, ${apply(rhs)})"
-      case Function(lhs, rhs) => s"Function(${apply(lhs)}, ${apply(rhs)})"
-      case Record(fields) => s"Record(${fields.iterator.map { case (nme, ty) => s"$nme: ${apply(ty)}" }.mkString(", ")})"
-      case Tuple(fields) => s"Tuple(${fields.iterator.map {
-        case N -> field => s"N -> ${apply(field)}"
-        case S(nme) -> field => s"S($nme) -> ${apply(field)}"
-      }.mkString(", ")})"
-      case Recursive(uv, body) => s"Recursive(${apply(uv)}, ${apply(body)})"
-      case AppliedType(base, targs) => s"AppliedType(${apply(base)}, ${apply(targs)})"
-      case Selection(base, name) => s"Selection(${apply(base)}, $name)"
-      case Neg(base) => s"Neg(${apply(base)})"
-      case Rem(base, names) => s"Rem(${apply(base)}, ${names.iterator.map(apply).mkString(", ")})"
-      case Bounds(lb, ub) => s"Bounds(${apply(lb)}, ${apply(ub)})"
-      case WithExtension(base, rcd) => s"WithExtension(${apply(base)}, ${apply(rcd)})"
-      case Splice(fields) => s"Splice(${fields.iterator.map {
-        case L(l) => s"L(${apply(l)})"
-        case R(f) => s"R(${apply(f)})"
-      }.mkString(", ")})"
-      case Constrained(base, tvBounds, where) => s"Constrained(${apply(base)}, Ls(${tvBounds.iterator.map {
-        case (tv, bounds) => s"${apply(tv)} -> ${apply(bounds)}"
-      }}), ${apply(where)})"
-      case Top => "Top"
-      case Bot => "Bot"
-      case Literal(lit) => s"Literal(${lit.toString})"
-      case TypeName(name) => s"TypeName(\"$name\")"
-      case TypeTag(name) => s"TypeTag($name)"
-      case TypeVar(identifier, nameHint) => s"TypeVar(${identifier match {
-        case L(i) => s"L($i)"
-        case R(n) => s"R($n)"
-      }}, ${nameHint.fold("N")(n => s"S($n)")})"
-      case PolyType(targs, body) => s"PolyType(Ls(${targs.iterator.map(_.fold(apply, apply)).mkString(", ")}), ${apply(body)})"
-      case Signature(members, result) => s"Signature(${members.iterator.map(apply(_: Statement)).mkString("Ls(", ", ", ")")}, ${apply(result)})"
-      case t: NuDecl => apply(t: Statement)
-    }
-
-    private def ifBody(body: IfBody): Str = body match {
-      case IfElse(expr) => s"IfElse(${apply(expr)}"
-      case IfThen(expr, rhs) => s"IfThen(${apply(expr)}, ${apply(rhs)}"
-      case IfBlock(lines) => s"IfBlock(${
-        lines.iterator.map(_.fold(apply, apply)).mkString("Ls(", ", ", ")")
-      })"
-      case IfOpsApp(lhs, opsRhss) => s"IfOpsApp(${apply(lhs)}, ${
-        opsRhss.iterator.map { case (op, body) =>
-          s"$op -> ${apply(body)}"
-        }
-      }".mkString("; ")
-      case IfLet(isRec, name, rhs, body) => ???
-      case IfOpApp(lhs, op, rhs) =>
-        s"IfOpApp(${apply(lhs)}, ${apply(op)}, ${apply(rhs)}"
-    }
-
-    private def typingUnit(t: TypingUnit): Str = t.entities.iterator
-      .map(apply)
-      .mkString("TypingUnit(", ", ", ")")
-  }
-}
\ No newline at end of file
diff --git a/shared/src/test/diff/pretyper/ucs/examples/ULC.mls b/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
index 9add8993d2..357d5811d8 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
@@ -329,11 +329,11 @@ fun combinations(n: Int, acc: List['T], alphabet: List['T], xs: List[Str]): Opti
       else Some(x)
     else
       search((x) => combinations(n - 1, x :: acc, alphabet, xs), alphabet)
-//│ fun combinations: forall 'T 'T0 'A. (n: Int, acc: List['T0], alphabet: List['T], xs: List[Str]) -> Option[Str]
+//│ fun combinations: forall 'T 'A 'T0. (n: Int, acc: List['T], alphabet: List['T0], xs: List[Str]) -> Option[Str]
 //│   where
-//│     'T <: 'T0 & 'A
-//│     'T0 :> 'A
-//│     'A := 'T0
+//│     'T0 <: 'T & 'A
+//│     'T :> 'A
+//│     'A := 'T
 
 combinations(1, Nil, 1 :: 2 :: 3 :: Nil, Nil) |> showOption
 combinations(2, Nil, 1 :: 2 :: 3 :: Nil, Nil) |> showOption

From ec5cca7e05f789c3570256a838c951df32db5131 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 3 Jan 2024 15:56:48 +0800
Subject: [PATCH 052/147] Address the test case that keeps changing

---
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |  6 ++-
 .../test/diff/pretyper/ucs/examples/ULC.mls   | 52 ++++++++++++++-----
 2 files changed, 43 insertions(+), 15 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 8c36f23ad5..871420ec2e 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -108,7 +108,7 @@ trait DesugarUCS extends Transformation
     implicit val context: Context = new Context(`if`)
     trace("traverseIf") {
       // Stage 0: Transformation
-      val transformed = traceWithTopic("transform") {
+      val transformed = traceWithTopic("ucs.transform") {
         println("STEP 0")
         val transformed = transform(`if`)
         println("Transformed UCS term:")
@@ -150,9 +150,11 @@ trait DesugarUCS extends Transformation
         println(s"Coverage checking result: ${diagnostics.size} errors")
         raiseMany(diagnostics)
       }
+      traceWithTopic("desugared") {
+        println(s"Desugared term: ${postProcessed.showDbg}")
+      }
       // Epilogue
       `if`.desugaredTerm = S(postProcessed)
-      println(s"Desugared term: ${postProcessed.showDbg}")
     }(_ => "traverseIf ==> ()")
   }
   
diff --git a/shared/src/test/diff/pretyper/ucs/examples/ULC.mls b/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
index 357d5811d8..4cccc0ecb3 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
@@ -320,20 +320,46 @@ fun search(f: 'A -> Option['B], xs: List['A]): Option['B] =
 //│   where
 //│     'B <: 'A0
 
-// The removal of type annotations will cause running out of fuel.
+// =============================================================================
+// TO BE INVESTIGATED: The following version does not have a stable type.
+// The desugared term look like this:
+// let ucs$test$0 = <=(n, 0,) : Bool in
+// case ucs$test$0 of {
+//   true =>
+//     let x = |>(reverse(acc,), join("",),) in
+//     let ucs$test$1 = contains(xs, x,) : Bool in
+//     case ucs$test$1 of {
+//       true => None;
+//       _ => Some(x,)
+//     };
+//   _ => {
+//     search(('(' x ')',) => combinations(-(n, 1,), ::(x, acc,), alphabet, xs,), alphabet,)
+//   }
+// }
+// fun combinations(n: Int, acc: List['T], alphabet: List['T], xs: List[Str]): Option[Str] =
+//   if
+//     n <= 0 and
+//       let x = reverse(acc) |> join("")
+//       contains(xs, x) then None
+//       else Some(x)
+//     else
+//       search((x) => combinations(n - 1, x :: acc, alphabet, xs), alphabet)
+// //│ fun combinations: forall 'T 'A 'T0. (n: Int, acc: List['T], alphabet: List['T0], xs: List[Str]) -> Option[Str]
+// //│   where
+// //│     'T0 <: 'T & 'A
+// //│     'T :> 'A
+// //│     'A := 'T
+// =============================================================================
+
+fun combinations: forall 'a: (Int, List['a], List['a], List[Str]) -> Option[Str]
 fun combinations(n: Int, acc: List['T], alphabet: List['T], xs: List[Str]): Option[Str] =
-  if
-    n <= 0 and
-      let x = reverse(acc) |> join("")
-      contains(xs, x) then None
-      else Some(x)
-    else
-      search((x) => combinations(n - 1, x :: acc, alphabet, xs), alphabet)
-//│ fun combinations: forall 'T 'A 'T0. (n: Int, acc: List['T], alphabet: List['T0], xs: List[Str]) -> Option[Str]
-//│   where
-//│     'T0 <: 'T & 'A
-//│     'T :> 'A
-//│     'A := 'T
+  if n <= 0 then
+    let x = reverse(acc) |> join("")
+    if contains(xs, x) then None else Some(x)
+  else
+    search((x) => combinations(n - 1, x :: acc, alphabet, xs), alphabet)
+//│ fun combinations: forall 'T. (n: Int, acc: List['T], alphabet: List['T], xs: List[Str]) -> Option[Str]
+//│ fun combinations: forall 'a. (Int, List['a], List['a], List[Str]) -> Option[Str]
 
 combinations(1, Nil, 1 :: 2 :: 3 :: Nil, Nil) |> showOption
 combinations(2, Nil, 1 :: 2 :: 3 :: Nil, Nil) |> showOption

From d742ec15801e1dc89b85e0feaf62ff615073c3f8 Mon Sep 17 00:00:00 2001
From: Lionel Parreaux <lionel.parreaux@gmail.com>
Date: Thu, 11 Jan 2024 11:08:18 +0800
Subject: [PATCH 053/147] Fix handling of boolean patterns

---
 shared/src/main/scala/mlscript/Typer.scala        | 15 ++++++++-------
 shared/src/test/diff/nu/FilterMap.mls             |  2 +-
 shared/src/test/diff/nu/LitMatch.mls              |  4 ++--
 .../test/diff/pretyper/ucs/patterns/Literals.mls  |  2 +-
 shared/src/test/diff/ucs/ElseIf.mls               |  2 +-
 shared/src/test/diff/ucs/SplitAroundOp.mls        |  2 +-
 shared/src/test/diff/ucs/WeirdIf.mls              |  2 +-
 7 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/shared/src/main/scala/mlscript/Typer.scala b/shared/src/main/scala/mlscript/Typer.scala
index b686b87c28..9e7fc455b4 100644
--- a/shared/src/main/scala/mlscript/Typer.scala
+++ b/shared/src/main/scala/mlscript/Typer.scala
@@ -1458,7 +1458,13 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
         case v @ Var(nme) =>
           val tpr = tp(pat.toLoc, "type pattern")
           ctx.tyDefs.get(nme) match {
-            case None =>
+            case Some(td) if !newDefs =>
+              td.kind match {
+                case Als | Mod | Mxn => val t = err(msg"can only match on classes and traits", pat.toLoc)(raise); t -> t
+                case Cls => val t = clsNameToNomTag(td)(tp(pat.toLoc, "class pattern"), ctx); t -> t
+                case Trt => val t = trtNameToNomTag(td)(tp(pat.toLoc, "trait pattern"), ctx); t -> t
+              }
+            case _ =>
               val bail = () => {
                 val e = ClassTag(ErrTypeId, Set.empty)(tpr)
                 return ((e -> e) :: Nil) -> e
@@ -1473,6 +1479,7 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
                   lti match {
                     case dti: DelayedTypeInfo =>
                       val tag = clsNameToNomTag(dti.decl match { case decl: NuTypeDef => decl; case _ => die })(prov, ctx)
+                      println(s"CASE $tag")
                       val ty =
                         RecordType.mk(dti.tparams.map {
                           case (tn, tv, vi) =>
@@ -1500,12 +1507,6 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
                   err("type identifier not found: " + nme, pat.toLoc)(raise)
                   bail()
               }
-            case Some(td) =>
-              td.kind match {
-                case Als | Mod | Mxn => val t = err(msg"can only match on classes and traits", pat.toLoc)(raise); t -> t
-                case Cls => val t = clsNameToNomTag(td)(tp(pat.toLoc, "class pattern"), ctx); t -> t
-                case Trt => val t = trtNameToNomTag(td)(tp(pat.toLoc, "trait pattern"), ctx); t -> t
-              }
           }
       }
       val newCtx = ctx.nest
diff --git a/shared/src/test/diff/nu/FilterMap.mls b/shared/src/test/diff/nu/FilterMap.mls
index 2ac040cbad..08b3dc9ba7 100644
--- a/shared/src/test/diff/nu/FilterMap.mls
+++ b/shared/src/test/diff/nu/FilterMap.mls
@@ -30,7 +30,7 @@ fun filtermap(f, xs) = if xs is
     [true, z] then Cons(y, filtermap(f, ys))
 //│ ╔══[ERROR] type identifier not found: Tuple#2
 //│ ╙──
-//│ fun filtermap: ((Cons[nothing] | Nil) -> nothing, Cons[anything] | Nil) -> (Cons[nothing] | Nil | error)
+//│ fun filtermap: ((Cons[nothing] | Nil) -> Bool, Cons[anything] | Nil) -> (Cons[nothing] | Nil | error)
 //│ Code generation encountered an error:
 //│   unknown match case: Tuple#2
 
diff --git a/shared/src/test/diff/nu/LitMatch.mls b/shared/src/test/diff/nu/LitMatch.mls
index 211cec96b1..a2e74b8fe4 100644
--- a/shared/src/test/diff/nu/LitMatch.mls
+++ b/shared/src/test/diff/nu/LitMatch.mls
@@ -28,11 +28,11 @@ if false is false then 0
 
 fun foo(x) = if x is
   false then 0
-//│ fun foo: nothing -> 0
+//│ fun foo: false -> 0
 
 fun foo(x) = if x is
   false then 0
   true  then 1
-//│ fun foo: nothing -> (0 | 1)
+//│ fun foo: Bool -> (0 | 1)
 
 
diff --git a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
index 2dd0048f06..2feac47133 100644
--- a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
+++ b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
@@ -61,7 +61,7 @@ fun mix(x) = if x is
   true then "true"
   Some(value) then "Some"
   0 then "zero"
-//│ fun mix: (0 | Some[anything]) -> ("Some" | "true" | "zero")
+//│ fun mix: (0 | Some[anything] | true) -> ("Some" | "true" | "zero")
 
 [mix(true), mix(Some(1)), mix(0)]
 //│ ["Some" | "true" | "zero", "Some" | "true" | "zero", "Some" | "true" | "zero"]
diff --git a/shared/src/test/diff/ucs/ElseIf.mls b/shared/src/test/diff/ucs/ElseIf.mls
index 5b8446a1f0..bcb30cd3c1 100644
--- a/shared/src/test/diff/ucs/ElseIf.mls
+++ b/shared/src/test/diff/ucs/ElseIf.mls
@@ -82,7 +82,7 @@ fun g(x, y) = if x is
   _ and y is
     true then true
     false then false
-//│ fun g: (Object, nothing) -> Bool
+//│ fun g: (Object, Bool) -> Bool
 
 // Chained UCS terms
 fun f(x, y) = if x is
diff --git a/shared/src/test/diff/ucs/SplitAroundOp.mls b/shared/src/test/diff/ucs/SplitAroundOp.mls
index 198590fa4d..1cbf9e1dad 100644
--- a/shared/src/test/diff/ucs/SplitAroundOp.mls
+++ b/shared/src/test/diff/ucs/SplitAroundOp.mls
@@ -12,7 +12,7 @@ fun f(x, b) =
       "1" then "s1"
       "2" then "s2"
   else ":p"  
-//│ fun f: (Eql["0" | "1" | "2" | 0 | 1 | 2], Object) -> (":p" | "n0" | "n1" | "n2" | "s0" | "s1" | "s2")
+//│ fun f: (Eql["0" | "1" | "2" | 0 | 1 | 2], Object & ~true | true) -> (":p" | "n0" | "n1" | "n2" | "s0" | "s1" | "s2")
 
 fun f(x, y, a, b) =
   if x === 0
diff --git a/shared/src/test/diff/ucs/WeirdIf.mls b/shared/src/test/diff/ucs/WeirdIf.mls
index 5f4d44439e..db0705fd0a 100644
--- a/shared/src/test/diff/ucs/WeirdIf.mls
+++ b/shared/src/test/diff/ucs/WeirdIf.mls
@@ -102,7 +102,7 @@ fun boolToStr(x) =
   if x is
     true then "yah"
     false then "nah"
-//│ fun boolToStr: nothing -> ("nah" | "yah")
+//│ fun boolToStr: Bool -> ("nah" | "yah")
 
 boolToStr of true
 boolToStr of false

From dfefcbd3379c3c86a470bb7c4bbc7710fe995084 Mon Sep 17 00:00:00 2001
From: Lionel Parreaux <lionel.parreaux@gmail.com>
Date: Thu, 11 Jan 2024 12:25:14 +0800
Subject: [PATCH 054/147] Add pattern refining

---
 shared/src/main/scala/mlscript/MLParser.scala |  2 +-
 shared/src/main/scala/mlscript/Typer.scala    | 11 +++--
 shared/src/main/scala/mlscript/helpers.scala  |  4 +-
 shared/src/main/scala/mlscript/syntax.scala   |  2 +-
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |  2 +-
 .../main/scala/mlscript/ucs/Desugarer.scala   |  6 +--
 shared/src/main/scala/mlscript/ucs/core.scala |  4 +-
 .../mlscript/ucs/stages/Desugaring.scala      | 30 ++++++------
 .../mlscript/ucs/stages/Normalization.scala   | 22 +++++----
 .../mlscript/ucs/stages/PostProcessing.scala  | 25 +++++-----
 .../mlscript/ucs/stages/Transformation.scala  |  9 +++-
 .../src/main/scala/mlscript/ucs/syntax.scala  |  9 ++--
 shared/src/test/diff/nu/RefinedPattern.mls    | 46 +++++++++++++++++++
 13 files changed, 116 insertions(+), 56 deletions(-)
 create mode 100644 shared/src/test/diff/nu/RefinedPattern.mls

diff --git a/shared/src/main/scala/mlscript/MLParser.scala b/shared/src/main/scala/mlscript/MLParser.scala
index 1ccd068632..d05e7a6cbc 100644
--- a/shared/src/main/scala/mlscript/MLParser.scala
+++ b/shared/src/main/scala/mlscript/MLParser.scala
@@ -140,7 +140,7 @@ class MLParser(origin: Origin, indent: Int = 0, recordLocations: Bool = true) {
   def matchArms[p: P](sep: Str): P[CaseBranches] = P(
     ( ("_" ~ "->" ~ term).map(Wildcard)
     | ((lit | variable) ~ "->" ~ term ~ matchArms2(sep))
-      .map { case (t, b, rest) => Case(t, b, rest) }
+      .map { case (t, b, rest) => Case(t, b, rest)(refined = false) }
     ).?.map {
       case None => NoCases
       case Some(b) => b
diff --git a/shared/src/main/scala/mlscript/Typer.scala b/shared/src/main/scala/mlscript/Typer.scala
index 9e7fc455b4..0c3ab5d23b 100644
--- a/shared/src/main/scala/mlscript/Typer.scala
+++ b/shared/src/main/scala/mlscript/Typer.scala
@@ -723,7 +723,8 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
   }
   
   // TODO also prevent rebinding of "not"
-  val reservedVarNames: Set[Str] = Set("|", "&", "~", ",", "neg", "and", "or", "is")
+  val reservedVarNames: Set[Str] =
+    Set("|", "&", "~", ",", "neg", "and", "or", "is", "refined")
   
   object ValidVar {
     def unapply(v: Var)(implicit raise: Raise): S[Str] = S {
@@ -1449,7 +1450,7 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
         case _ =>
           (fv -> TopType :: Nil) -> typeTerm(b)
       }
-    case Case(pat, bod, rest) =>
+    case cse @ Case(pat, bod, rest) =>
       val (tagTy, patTy) : (ST, ST) = pat match {
         case lit: Lit =>
           val t = ClassTag(lit,
@@ -1479,8 +1480,7 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
                   lti match {
                     case dti: DelayedTypeInfo =>
                       val tag = clsNameToNomTag(dti.decl match { case decl: NuTypeDef => decl; case _ => die })(prov, ctx)
-                      println(s"CASE $tag")
-                      val ty =
+                      val ty = // TODO update as below for refined
                         RecordType.mk(dti.tparams.map {
                           case (tn, tv, vi) =>
                             val nv = freshVar(tv.prov, S(tv), tv.nameHint)
@@ -1491,7 +1491,8 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
                       tag -> ty
                     case CompletedTypeInfo(cls: TypedNuCls) =>
                       val tag = clsNameToNomTag(cls.td)(prov, ctx)
-                      val ty =
+                      println(s"CASE $tag ${cse.refined}")
+                      val ty = if (cse.refined) freshVar(tp(v.toLoc, "refined scrutinee"), N) else
                         RecordType.mk(cls.tparams.map {
                           case (tn, tv, vi) =>
                             val nv = freshVar(tv.prov, S(tv), tv.nameHint)
diff --git a/shared/src/main/scala/mlscript/helpers.scala b/shared/src/main/scala/mlscript/helpers.scala
index ee53a370f2..da85c08478 100644
--- a/shared/src/main/scala/mlscript/helpers.scala
+++ b/shared/src/main/scala/mlscript/helpers.scala
@@ -1085,9 +1085,9 @@ trait CaseBranchesImpl extends Located { self: CaseBranches =>
   }
   
   def print(isFirst: Bool): Str = this match {
-    case Case(pat, body, rest) =>
+    case c @ Case(pat, body, rest) =>
       (if (isFirst) { "" } else { "; " }) +
-      pat.print(false) + " => " + body.print(false) + rest.print(false)
+      (if (c.refined) "refined " else "") + pat.print(false) + " => " + body.print(false) + rest.print(false)
     case Wildcard(body) => 
       (if (isFirst) { "" } else { "; " }) +
       "_ => " + body.print(false)
diff --git a/shared/src/main/scala/mlscript/syntax.scala b/shared/src/main/scala/mlscript/syntax.scala
index 9a802bb56e..ed2a89420e 100644
--- a/shared/src/main/scala/mlscript/syntax.scala
+++ b/shared/src/main/scala/mlscript/syntax.scala
@@ -110,7 +110,7 @@ final case class Fld(flags: FldFlags, value: Term) extends FldImpl
 object FldFlags { val empty: FldFlags = FldFlags(false, false, false) }
 
 sealed abstract class CaseBranches extends CaseBranchesImpl
-final case class Case(pat: SimpleTerm, body: Term, rest: CaseBranches) extends CaseBranches
+final case class Case(pat: SimpleTerm, body: Term, rest: CaseBranches)(val refined: Bool) extends CaseBranches
 final case class Wildcard(body: Term) extends CaseBranches
 // final case class TupleCase(numElems: Int, canHaveMore: Bool, body: Term, rest: CaseBranches) extends CaseBranches
 final case object NoCases extends CaseBranches
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 871420ec2e..80822750ae 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -184,7 +184,7 @@ trait DesugarUCS extends Transformation
         case core.Pattern.Literal(literal) => Nil
         case core.Pattern.Name(nme) => nme -> nme.symbol :: Nil
         // For now, there should only be parameter-less class patterns.
-        case core.Pattern.Class(nme) => Nil
+        case core.Pattern.Class(nme, _) => Nil
         case core.Pattern.Tuple(_) => ???
         case core.Pattern.Record(_) => ???
       }
diff --git a/shared/src/main/scala/mlscript/ucs/Desugarer.scala b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
index 5d7eff4cc5..7f2d3004a3 100644
--- a/shared/src/main/scala/mlscript/ucs/Desugarer.scala
+++ b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
@@ -824,10 +824,10 @@ class Desugarer extends TypeDefs { self: Typer =>
               )
             case _ => mkLetFromFields(scrutinee, fields.filter(_._2.name =/= "_").toList, consequent)
           }
-          Case(className, body, rec2(next))
+          Case(className, body, rec2(next))(refined = false)
         case MutCase.Literal(literal, cases) :: next =>
           printlnUCS(s"• Literal pattern: $literal")
-          Case(literal, rec(cases), rec2(next))
+          Case(literal, rec(cases), rec2(next))(refined = false)
         case Nil =>
           wildcard match {
             case None => 
@@ -906,7 +906,7 @@ class Desugarer extends TypeDefs { self: Typer =>
           val falseBody = mkBindings(whenFalse.getBindings.toList, rec(whenFalse)(defs ++ whenFalse.getBindings.iterator.map(_.name)), defs)
           val trueBody = mkBindings(whenTrue.getBindings.toList, rec(whenTrue)(defs ++ whenTrue.getBindings.iterator.map(_.name)), defs)
           val falseBranch = Wildcard(falseBody)
-          val trueBranch = Case(Var("true"), trueBody, falseBranch)
+          val trueBranch = Case(Var("true"), trueBody, falseBranch)(refined = false)
           CaseOf(condition, trueBranch)
       }
     }()
diff --git a/shared/src/main/scala/mlscript/ucs/core.scala b/shared/src/main/scala/mlscript/ucs/core.scala
index 14b1577f6c..6b9dc433d8 100644
--- a/shared/src/main/scala/mlscript/ucs/core.scala
+++ b/shared/src/main/scala/mlscript/ucs/core.scala
@@ -13,7 +13,7 @@ package object core {
     override def toString(): String = this match {
       case Pattern.Literal(literal) => literal.toString
       case Pattern.Name(Var(name)) => name
-      case Pattern.Class(Var(name)) => name
+      case Pattern.Class(Var(name), rfd) => (if (rfd) "refined " else "") + name
       case Pattern.Tuple(fields) => fields.iterator.map(_.fold("_")(_.name)).mkString("(", ", ", ")")
       case Pattern.Record(Nil) => "{}"
       case Pattern.Record(entries) => entries.iterator.map { case (nme, als) => s"$nme: $als" }.mkString("{ ", ", ", " }")
@@ -26,7 +26,7 @@ package object core {
     final case class Name(nme: Var) extends Pattern {
       override def children: Ls[Located] = nme :: Nil
     }
-    final case class Class(nme: Var) extends Pattern {
+    final case class Class(nme: Var, refined: Bool) extends Pattern {
       override def children: Ls[Located] = nme :: Nil
     }
     final case class Tuple(elements: List[Opt[Var]]) extends Pattern {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index e58d9b560d..bd92198c3e 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -66,8 +66,10 @@ trait Desugaring { self: PreTyper =>
     * A shorthand for making a true pattern, which is useful in desugaring
     * Boolean conditions.
     */
-  private def truePattern(implicit scope: Scope) = c.Pattern.Class(Var("true").withResolvedTypeSymbol)
-  private def falsePattern(implicit scope: Scope) = c.Pattern.Class(Var("false").withResolvedTypeSymbol)
+  private def truePattern(implicit scope: Scope) =
+    c.Pattern.Class(Var("true").withResolvedTypeSymbol, refined = false)
+  private def falsePattern(implicit scope: Scope) =
+    c.Pattern.Class(Var("false").withResolvedTypeSymbol, refined = false)
 
   private def desugarTermSplit(split: s.TermSplit)(implicit termPart: PartialTerm, scope: Scope, context: Context): c.Split =
     split match {
@@ -139,7 +141,7 @@ trait Desugaring { self: PreTyper =>
         case (s.NamePattern(name), index) =>
           val subScrutinee = classPattern.getParameter(index).withAlias(name)
           S(name.withFreshSymbol.withScrutinee(subScrutinee) -> N)
-        case (parameterPattern @ (s.ClassPattern(_, _) | s.LiteralPattern(_) | s.TuplePattern(_)), index) =>
+        case (parameterPattern @ (s.ClassPattern(_, _, _) | s.LiteralPattern(_) | s.TuplePattern(_)), index) =>
           val subScrutineeVar = freshSubScrutineeVar(parentScrutineeVar, parentClassLikeSymbol.name, index)
           val symbol = new LocalTermSymbol(subScrutineeVar)
           symbol.addScrutinee(classPattern.getParameter(index).withAlias(subScrutineeVar))
@@ -168,7 +170,7 @@ trait Desugaring { self: PreTyper =>
     * @param initialScope the scope before flattening the class pattern
     * @return a tuple of the augmented scope and a function that wrap a split
     */
-  private def desugarClassPattern(pattern: s.ClassPattern, scrutineeVar: Var, initialScope: Scope)(implicit context: Context): (Scope, c.Split => c.Branch) = {
+  private def desugarClassPattern(pattern: s.ClassPattern, scrutineeVar: Var, initialScope: Scope, refined: Bool)(implicit context: Context): (Scope, c.Split => c.Branch) = {
     val scrutinee = scrutineeVar.getOrCreateScrutinee.withAlias(scrutineeVar)
     val patternClassSymbol = pattern.nme.resolveTypeSymbol(initialScope)
     val classPattern = scrutinee.getOrCreateClassPattern(patternClassSymbol)
@@ -204,7 +206,7 @@ trait Desugaring { self: PreTyper =>
     }
     println(s"${scrutineeVar.name}: ${scrutinee.patterns.mkString(", ")}")
     // Last, return the scope with all bindings and a function that adds all matches and bindings to a split.
-    (scopeWithAll, split => c.Branch(scrutineeVar, c.Pattern.Class(pattern.nme), bindAll(split)))
+    (scopeWithAll, split => c.Branch(scrutineeVar, c.Pattern.Class(pattern.nme, refined), bindAll(split)))
   }
 
   /**
@@ -235,7 +237,7 @@ trait Desugaring { self: PreTyper =>
         // binder.
         case ((scope, bindPrevious), S(nme -> S(pattern: s.ClassPattern))) =>
           println(s"${nme.name} is ${pattern.nme.name}")
-          val (scopeWithNestedAll, bindNestedAll) = desugarClassPattern(pattern, nme, scope)
+          val (scopeWithNestedAll, bindNestedAll) = desugarClassPattern(pattern, nme, scope, pattern.refined)
           (scopeWithNestedAll, split => bindPrevious(bindNestedAll(split) :: c.Split.Nil))
         case ((scope, bindPrevious), S(nme -> S(pattern: s.LiteralPattern))) =>
           nme.getOrCreateScrutinee
@@ -263,7 +265,7 @@ trait Desugaring { self: PreTyper =>
       case (_: s.EmptyPattern, _) => N
       case (s.NamePattern(name), index) =>
         S(name.withFreshSymbol.withScrutinee(tuplePattern.getField(index)) -> N)
-      case (parameterPattern @ (s.ClassPattern(_, _) | s.LiteralPattern(_) | s.TuplePattern(_)), index) =>
+      case (parameterPattern @ (s.ClassPattern(_, _, _) | s.LiteralPattern(_) | s.TuplePattern(_)), index) =>
         val arity = fields.length
         val subScrutineeVar = freshSubScrutineeVar(parentScrutineeVar, s"Tuple$$$arity", index)
         val symbol = new LocalTermSymbol(subScrutineeVar)
@@ -290,7 +292,7 @@ trait Desugaring { self: PreTyper =>
 
   private def desugarPatternSplit(scrutineeTerm: Term, split: s.PatternSplit)(implicit scope: Scope, context: Context): c.Split = {
     def rec(scrutineeVar: Var, split: s.PatternSplit)(implicit scope: Scope): c.Split = split match {
-      case s.Split.Cons(head, tail) => 
+      case s.Split.Cons(head, tail) =>
         head.pattern match {
           case pattern @ s.AliasPattern(_, _) =>
             raiseError(PreTyping, msg"alias pattern is not supported for now" -> pattern.toLoc)
@@ -302,11 +304,11 @@ trait Desugaring { self: PreTyper =>
               pattern = c.Pattern.Literal(literal),
               continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context)
             ) :: rec(scrutineeVar, tail)
-          case s.ConcretePattern(nme @ (Var("true") | Var("false"))) => 
+          case s.ConcretePattern(nme @ (Var("true") | Var("false"))) =>
             scrutineeVar.getOrCreateScrutinee.withAlias(scrutineeVar).getOrCreateBooleanPattern(nme.name === "true").addLocation(nme)
             c.Branch(
               scrutinee = scrutineeVar,
-              pattern = c.Pattern.Class(nme.withResolvedTypeSymbol),
+              pattern = c.Pattern.Class(nme.withResolvedTypeSymbol, refined = false),
               continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context)
             ) :: rec(scrutineeVar, tail)
           case s.ConcretePattern(nme) =>
@@ -333,14 +335,14 @@ trait Desugaring { self: PreTyper =>
             // Whoosh! Done.
             val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope + nme.symbol, context)
             c.Branch(scrutineeVar, c.Pattern.Name(nme), continuation) :: rec(scrutineeVar, tail)(scope + nme.symbol)
-          case pattern @ s.ClassPattern(nme, fields) =>
+          case pattern @ s.ClassPattern(nme, fields, rfd) =>
             println(s"find term symbol of $scrutineeVar in ${scope.showLocalSymbols}")
-            scrutineeVar.symbol = scope.getTermSymbol(scrutineeVar.name).getOrElse(???)
-            val (scopeWithAll, bindAll) = desugarClassPattern(pattern, scrutineeVar, scope)
+            scrutineeVar.symbol = scope.getTermSymbol(scrutineeVar.name).getOrElse(???/*FIXME*/)
+            val (scopeWithAll, bindAll) = desugarClassPattern(pattern, scrutineeVar, scope, rfd)
             val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scopeWithAll, context)
             bindAll(continuation) :: rec(scrutineeVar, tail)
           case s.TuplePattern(fields) =>
-            scrutineeVar.symbol = scope.getTermSymbol(scrutineeVar.name).getOrElse(???)
+            scrutineeVar.symbol = scope.getTermSymbol(scrutineeVar.name).getOrElse(???/*FIXME*/)
             val (scopeWithAll, bindAll) = desugarTuplePattern(fields, scrutineeVar, scope)
             val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scopeWithAll, context)
             val withBindings = bindAll(continuation)
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 20870a2e89..0d90716654 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -62,11 +62,11 @@ trait Normalization { self: Traceable with Diagnosable =>
         println(s"normalizing name pattern ${scrutinee.name} is ${nme.name}")
         Let(false, nme, scrutinee, normalizeToTerm(concat(continuation, tail)))
       // Skip Boolean conditions as scrutinees, because they only appear once.
-      case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true")), continuation), tail) =>
+      case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true"), _), continuation), tail) =>
         println(s"normalizing true pattern: ${test.name} is true")
         val trueBranch = normalizeToTerm(concat(continuation, tail))
         val falseBranch = normalizeToCaseBranches(tail)
-        CaseOf(test, Case(nme, trueBranch, falseBranch))
+        CaseOf(test, Case(nme, trueBranch, falseBranch)(refined = false))
       case Split.Cons(Branch(ScrutineeData.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Literal(literal), continuation), tail) =>
         println(s"normalizing literal pattern: ${scrutineeVar.name} is $literal")
         val concatenatedTrueBranch = concat(continuation, tail)
@@ -74,13 +74,13 @@ trait Normalization { self: Traceable with Diagnosable =>
         val trueBranch = normalizeToTerm(specialize(concatenatedTrueBranch, true)(scrutineeVar, scrutinee, pattern, context))
         println(s"false branch: ${showSplit(tail)}")
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context))
-        CaseOf(scrutineeVar, Case(literal, trueBranch, falseBranch))
-      case Split.Cons(Branch(ScrutineeData.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Class(nme), continuation), tail) =>
+        CaseOf(scrutineeVar, Case(literal, trueBranch, falseBranch)(refined = false))
+      case Split.Cons(Branch(ScrutineeData.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Class(nme, rfd), continuation), tail) =>
         println(s"normalizing class pattern: ${scrutineeVar.name} is ${nme.name}")
         // println(s"match ${scrutineeVar.name} with $nme (has location: ${nme.toLoc.isDefined})")
         val trueBranch = normalizeToTerm(specialize(concat(continuation, tail), true)(scrutineeVar, scrutinee, pattern, context))
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context))
-        CaseOf(scrutineeVar, Case(nme, trueBranch, falseBranch))
+        CaseOf(scrutineeVar, Case(nme, trueBranch, falseBranch)(refined = rfd))
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
         println(s"unknown pattern $pattern")
         throw new NormalizationException((msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc) :: Nil)
@@ -130,13 +130,13 @@ trait Normalization { self: Traceable with Diagnosable =>
       // Name patterns are translated to let bindings.
       case (_, Split.Cons(Branch(otherScrutineeVar, Pattern.Name(alias), continuation), tail)) =>
         Split.Let(false, alias, otherScrutineeVar, specialize(continuation, matchOrNot))
-      case (_, split @ Split.Cons(head @ Branch(test, Pattern.Class(Var("true")), continuation), tail)) if context.isTestVar(test) =>
+      case (_, split @ Split.Cons(head @ Branch(test, Pattern.Class(Var("true"), _), continuation), tail)) if context.isTestVar(test) =>
         println(s"found a Boolean test: $test is true")
         val trueBranch = specialize(continuation, matchOrNot)
         val falseBranch = specialize(tail, matchOrNot)
         split.copy(head = head.copy(continuation = trueBranch), tail = falseBranch)
       // Class pattern. Positive.
-      case (true, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName), continuation), tail)) =>
+      case (true, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName, rfd), continuation), tail)) =>
         val otherClassSymbol = getClassLikeSymbol(otherClassName)
         lazy val specializedTail = {
           println(s"specialized next")
@@ -145,7 +145,8 @@ trait Normalization { self: Traceable with Diagnosable =>
         if (scrutinee === otherScrutinee) {
           println(s"scrutinee: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
           pattern match {
-            case Pattern.Class(className) =>
+            case Pattern.Class(className, rfd2) =>
+              assert(rfd === rfd2) // TODO: raise warning instead of crash
               val classSymbol = getClassLikeSymbol(className)
               if (classSymbol === otherClassSymbol) {
                 println(s"Case 1: class name: $className === $otherClassName")
@@ -175,12 +176,13 @@ trait Normalization { self: Traceable with Diagnosable =>
           )
         }
       // Class pattern. Negative
-      case (false, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName), continuation), tail)) =>
+      case (false, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName, rfd), continuation), tail)) =>
         val otherClassSymbol = getClassLikeSymbol(otherClassName)
         if (scrutinee === otherScrutinee) {
           println(s"scrutinee: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
           pattern match {
-            case Pattern.Class(className) =>
+            case Pattern.Class(className, rfd2) =>
+              assert(rfd === rfd2) // TODO: raise warning instead of crash
               val classSymbol = getClassLikeSymbol(className)
               if (className === otherClassName) {
                 println(s"Case 1: class name: $otherClassName === $className")
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index 53401c0e7c..d56b34ee51 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -17,12 +17,13 @@ trait PostProcessing { self: DesugarUCS with mlscript.pretyper.Traceable =>
       case top @ CaseOf(scrutineeVar: Var, fst @ Case(className: Var, body, NoCases)) =>
         println(s"found a UNARY case: $scrutineeVar is $className")
         println("post-processing the body")
-        top.copy(cases = fst.copy(body = postProcess(body)))
+        top.copy(cases = fst.copy(body = postProcess(body))(refined = fst.refined))
       case top @ CaseOf(test: Var, fst @ Case(Var("true"), trueBranch, Wildcard(falseBranch))) =>
         println(s"found a if-then-else case: $test is true")
         val processedTrueBranch = postProcess(trueBranch)
         val processedFalseBranch = postProcess(falseBranch)
-        top.copy(cases = fst.copy(body = processedTrueBranch, rest = Wildcard(processedFalseBranch)))
+        top.copy(cases = fst.copy(body = processedTrueBranch, rest = Wildcard(processedFalseBranch)
+          )(refined = fst.refined))
       case top @ CaseOf(ScrutineeData.WithVar(scrutinee, scrutineeVar), fst @ Case(className: Var, trueBranch, Wildcard(falseBranch))) =>
         println(s"found a BINARY case: $scrutineeVar is $className")
         val classSymbol = className.getClassLikeSymbol
@@ -62,10 +63,11 @@ trait PostProcessing { self: DesugarUCS with mlscript.pretyper.Traceable =>
         ) { case ((classSymbol, loc, body), rest) =>
           // TODO: Why not just keep the class name?
           val className = Var(classSymbol.name).withLoc(loc).withSymbol(classSymbol)
-          Case(className, body, rest)
+          Case(className, body, rest)(refined = false/*FIXME?*/)
         }
         // Assemble the final `CaseOf`.
-        top.copy(cases = fst.copy(body = processedTrueBranch, rest = actualFalseBranch))
+        top.copy(cases = fst.copy(body = processedTrueBranch, rest = actualFalseBranch)
+          (refined = fst.refined))
       // We recursively process the body of as`Let` bindings.
       case let @ Let(_, _, _, body) => let.copy(body = postProcess(body))
       // Otherwise, this is not a part of a normalized term.
@@ -85,9 +87,9 @@ trait PostProcessing { self: DesugarUCS with mlscript.pretyper.Traceable =>
     case k @ Case(_, body, rest) =>
       (trimEmptyTerm(body), trimEmptyCaseBranches(rest)) match {
         case (N, N) => N
-        case (S(body), N) => S(k.copy(body = body, rest = NoCases))
+        case (S(body), N) => S(k.copy(body = body, rest = NoCases)(refined = k.refined))
         case (N, S(rest)) => S(rest)
-        case (S(body), S(rest)) => S(k.copy(body = body, rest = rest))
+        case (S(body), S(rest)) => S(k.copy(body = body, rest = rest)(refined = k.refined))
       }
   }
 
@@ -116,7 +118,8 @@ trait PostProcessing { self: DesugarUCS with mlscript.pretyper.Traceable =>
       cases match {
         case NoCases => Wildcard(term).withLocOf(term)
         case Wildcard(body) => Wildcard(mergeTerms(body, term))
-        case cases @ Case(_, _, rest) => cases.copy(rest = mergeTermIntoCaseBranches(term, rest))
+        case cases @ Case(_, _, rest) =>
+          cases.copy(rest = mergeTermIntoCaseBranches(term, rest))(refined = cases.refined)
       }
     }()
 
@@ -152,12 +155,12 @@ trait PostProcessing { self: DesugarUCS with mlscript.pretyper.Traceable =>
                 } else {
                   val (n1, y1) = disentangle(body, scrutineeVar, scrutinee, classSymbol)
                   val (n2, y2) = rec(rest)
-                  (kase.copy(body = n1, rest = n2), mergeTerms(y1, y2))
+                  (kase.copy(body = n1, rest = n2)(refined = kase.refined), mergeTerms(y1, y2))
                 }
               case kase @ Case(otherClassName, body, rest) =>
                 println(s"found another case branch matching against $otherClassName")
                 val (n, y) = rec(rest)
-                kase.copy(rest = n) -> y
+                kase.copy(rest = n)(refined = kase.refined) -> y
             }
             val (n, y) = rec(cases)
             (top.copy(cases = n), y)
@@ -175,8 +178,8 @@ trait PostProcessing { self: DesugarUCS with mlscript.pretyper.Traceable =>
                 println(s"found a case branch")
                 val (n1, y1) = disentangle(body, scrutineeVar, scrutinee, classSymbol)
                 val (n2, y2) = rec(rest)
-                (kase.copy(body = n1, rest = n2), (y1 match {
-                  case S(term) => kase.copy(body = term, rest = y2)
+                (kase.copy(body = n1, rest = n2)(refined = kase.refined), (y1 match {
+                  case S(term) => kase.copy(body = term, rest = y2)(refined = kase.refined)
                   case N => y2
                 }))
             }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index c9f989d93c..547521684e 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -200,11 +200,16 @@ trait Transformation { self: Traceable with Diagnosable =>
   private def transformPattern(term: Term): Pattern = term match {
     case wildcard @ Var("_") => EmptyPattern(wildcard) // The case for wildcard.
     case nme @ Var("true" | "false") => ConcretePattern(nme)
-    case nme @ Var(name) if name.headOption.exists(_.isUpper) => ClassPattern(nme, N)
+    case nme @ Var(name) if name.headOption.exists(_.isUpper) => ClassPattern(nme, N, refined = false)
     case nme: Var => NamePattern(nme)
     case literal: Lit => LiteralPattern(literal)
+    case App(Var("refined"), PlainTup(p)) =>
+      transformPattern(p) match {
+        case cp: ClassPattern => cp.copy(refined = true).withLocOf(cp)
+        case _ => ??? // TODO error
+      }
     case App(classNme @ Var(_), parameters: Tup) =>
-      ClassPattern(classNme, S(transformTupleTerm(parameters)))
+      ClassPattern(classNme, S(transformTupleTerm(parameters)), refined = false)
     case tuple: Tup => TuplePattern(transformTupleTerm(tuple))
     case other =>
       println(s"other $other")
diff --git a/shared/src/main/scala/mlscript/ucs/syntax.scala b/shared/src/main/scala/mlscript/ucs/syntax.scala
index cbf1879753..e7510743af 100644
--- a/shared/src/main/scala/mlscript/ucs/syntax.scala
+++ b/shared/src/main/scala/mlscript/ucs/syntax.scala
@@ -13,9 +13,10 @@ package object syntax {
       case ConcretePattern(nme) => s"`${nme.name}`"
       case NamePattern(nme) => nme.toString
       case EmptyPattern(_) => "•"
-      case ClassPattern(Var(name), N) => name
-      case ClassPattern(Var(name), S(parameters)) =>
-        parameters.mkString(s"$name(", ", ", ")")
+      case ClassPattern(Var(name), ps, rfd) => (if (rfd) "refined " else "") + (ps match {
+        case N => name
+        case S(parameters) => parameters.mkString(s"$name(", ", ", ")")
+      })
       case TuplePattern(fields) => fields.mkString("(", ", ", ")")
       case RecordPattern(Nil) => "{}"
       case RecordPattern(entries) => entries.iterator.map { case (nme, als) => s"$nme: $als" }.mkString("{ ", ", ", " }")
@@ -40,7 +41,7 @@ package object syntax {
   final case class EmptyPattern(source: Term) extends Pattern {
     override def children: List[Located] = source :: Nil
   }
-  final case class ClassPattern(val nme: Var, val parameters: Opt[List[Pattern]]) extends Pattern {
+  final case class ClassPattern(nme: Var, parameters: Opt[List[Pattern]], refined: Bool) extends Pattern {
     override def children: List[Located] = nme :: parameters.getOrElse(Nil)
   }
   final case class TuplePattern(fields: List[Pattern]) extends Pattern {
diff --git a/shared/src/test/diff/nu/RefinedPattern.mls b/shared/src/test/diff/nu/RefinedPattern.mls
new file mode 100644
index 0000000000..a6eec80932
--- /dev/null
+++ b/shared/src/test/diff/nu/RefinedPattern.mls
@@ -0,0 +1,46 @@
+:PreTyper
+
+
+class C
+//│ class C {
+//│   constructor()
+//│ }
+
+
+:e
+fun test(x) = if x is
+  C then x.a
+//│ ╔══[ERROR] Type `C` does not contain member `a`
+//│ ║  l.12: 	  C then x.a
+//│ ╙──      	          ^^
+//│ fun test: C -> error
+
+fun test(x) = if x is
+  refined(C) then x.a
+//│ fun test: forall 'a. (C & {a: 'a}) -> 'a
+
+class D(val a: Int) extends C
+//│ class D(a: Int) extends C
+
+test(D(123))
+//│ Int
+//│ res
+//│     = 123
+
+
+:e
+refined
+//│ ╔══[ERROR] Variable refined not found in scope
+//│ ║  l.32: 	refined
+//│ ╙──      	^^^^^^^
+//│ ╔══[ERROR] Illegal use of reserved operator: refined
+//│ ║  l.32: 	refined
+//│ ╙──      	^^^^^^^
+//│ ╔══[ERROR] identifier not found: refined
+//│ ║  l.32: 	refined
+//│ ╙──      	^^^^^^^
+//│ error
+//│ Code generation encountered an error:
+//│   unresolved symbol refined
+
+

From 3c0209acfe868e2e86192614507d7990e17166cf Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Fri, 12 Jan 2024 21:55:04 +0800
Subject: [PATCH 055/147] Post-processing can handle all patterns and minor
 fixes

Major updates

- Post-processing handles not only class patterns right now.
- Normalization should NOT concatenate branches deeply or it may
  generate infinitely large splits.

Minor changes

- Remove useless classes, methods, and fields.
- Extract classes into files. For example, `PatternInfo`.
- Add test files which shows the intermediate results of post-
  processing and normalization.
- Improve debugging utilities.
- Add `SimpleList` test example.
- Improve debugging output
---
 shared/src/main/scala/mlscript/helpers.scala  |   6 +-
 .../main/scala/mlscript/pretyper/Scope.scala  |   6 +-
 .../main/scala/mlscript/pretyper/Symbol.scala |   2 +
 .../scala/mlscript/pretyper/Traceable.scala   |  14 +-
 .../main/scala/mlscript/ucs/DesugarUCS.scala  | 145 +++++++-------
 .../mlscript/ucs/context/Matchable.scala      |   8 +-
 .../mlscript/ucs/context/PatternInfo.scala    | 127 ++++++++++++
 .../mlscript/ucs/context/ScrutineeData.scala  | 157 +++++++--------
 shared/src/main/scala/mlscript/ucs/core.scala |  55 ++----
 .../src/main/scala/mlscript/ucs/display.scala |  30 +--
 .../mlscript/ucs/stages/Desugaring.scala      |  12 +-
 .../mlscript/ucs/stages/Normalization.scala   | 163 +++++++--------
 .../mlscript/ucs/stages/PostProcessing.scala  | 185 ++++++++++--------
 .../src/main/scala/mlscript/ucs/syntax.scala  |   4 +-
 .../diff/pretyper/ucs/coverage/Refinement.mls |  10 +-
 .../pretyper/ucs/examples/LispInterpreter.mls |  45 ++---
 .../test/diff/pretyper/ucs/examples/STLC.mls  |   2 +-
 .../diff/pretyper/ucs/examples/SimpleLisp.mls | 141 +++++++++++++
 .../diff/pretyper/ucs/patterns/Literals.mls   |  60 ++++--
 .../pretyper/ucs/stages/Normalization.mls     |  81 ++++++++
 .../pretyper/ucs/stages/PostProcessing.mls    |  71 +++++++
 .../diff/pretyper/ucs/stages/TransfromUCS.mls |   2 +-
 .../src/test/scala/mlscript/DiffTests.scala   |   4 +-
 23 files changed, 893 insertions(+), 437 deletions(-)
 create mode 100644 shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala
 create mode 100644 shared/src/test/diff/pretyper/ucs/examples/SimpleLisp.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls

diff --git a/shared/src/main/scala/mlscript/helpers.scala b/shared/src/main/scala/mlscript/helpers.scala
index ee53a370f2..68fda9652a 100644
--- a/shared/src/main/scala/mlscript/helpers.scala
+++ b/shared/src/main/scala/mlscript/helpers.scala
@@ -585,7 +585,11 @@ trait TermImpl extends StatementImpl { self: Term =>
     case Blk(stmts) => stmts.iterator.map(_.showDbg).mkString("{", "; ", "}")
     case IntLit(value) => value.toString
     case DecLit(value) => value.toString
-    case StrLit(value) => '"'.toString + value + '"'
+    case StrLit(value) => value.iterator.map {
+      case '\\' => "\\\\"; case '"' => "\\\""; case '\'' => "\\'"
+      case '\n' => "\\n"; case '\r' => "\\r"; case '\t' => "\\t"
+      case '\f' => "\\f"; case '\b' => "\\b"; case c => c.toString()
+    }.mkString("\"", "", "\"")
     case UnitLit(value) => if (value) "undefined" else "null"
     case v @ Var(name) => name + v.uid.fold("")("::"+_.toString)
     case Asc(trm, ty) => s"${trm.showDbg} : ${ty.showDbg2}"  |> bra
diff --git a/shared/src/main/scala/mlscript/pretyper/Scope.scala b/shared/src/main/scala/mlscript/pretyper/Scope.scala
index e8c859fff0..56c94aa677 100644
--- a/shared/src/main/scala/mlscript/pretyper/Scope.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Scope.scala
@@ -2,7 +2,7 @@ package mlscript.pretyper
 
 import collection.immutable.Map
 import mlscript.utils._, shorthands._
-import mlscript.{Mod, NuTypeDef, TypeName, TypingUnit, Var}
+import mlscript.{Als, Mod, NuTypeDef, TypeName, TypingUnit, Var}
 import scala.annotation.tailrec
 import symbol._
 
@@ -94,8 +94,10 @@ object Scope {
   val global: Scope = {
     val trueDefn = NuTypeDef(Mod, TypeName("true"), Nil, N, N, N, Nil, N, N, TypingUnit(Nil))(N, N)
     val falseDefn = NuTypeDef(Mod, TypeName("false"), Nil, N, N, N, Nil, N, N, TypingUnit(Nil))(N, N)
+    val nothingDefn = NuTypeDef(Als, TypeName("nothing"), Nil, N, N, N, Nil, N, N, TypingUnit(Nil))(N, N)
     val trueSymbol = new ModuleSymbol(trueDefn)
     val falseSymbol = new ModuleSymbol(falseDefn)
+    val nothingSymbol = new TypeAliasSymbol(nothingDefn)
     Scope.from(
       """true,false,document,window,typeof,toString,not,succ,log,discard,negate,
         |round,add,sub,mul,div,sqrt,lt,le,gt,ge,slt,sle,sgt,sge,length,concat,eq,
@@ -106,7 +108,7 @@ object Scope {
         .iterator
         .map(_.trim)
         .map(name => new LocalTermSymbol(Var(name)))
-        .concat(trueSymbol :: falseSymbol :: Nil)
+        .concat(trueSymbol :: falseSymbol :: nothingSymbol :: Nil)
     )
   }
 }
diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index 89db935a25..48ae45c74d 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -34,6 +34,8 @@ package object symbol {
     var sealedDerivedTypes: Ls[TypeSymbol] = Nil
 
     @inline def hasSuperType(superType: TypeSymbol): Bool = baseTypes.exists(_ === superType)
+
+    def showDbg: Str = s"${defn.kind.str} $name"
   }
 
   object TypeSymbol {
diff --git a/shared/src/main/scala/mlscript/pretyper/Traceable.scala b/shared/src/main/scala/mlscript/pretyper/Traceable.scala
index 206982fede..c2ffd59c7e 100644
--- a/shared/src/main/scala/mlscript/pretyper/Traceable.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Traceable.scala
@@ -7,7 +7,7 @@ trait Traceable {
   /** The set of topics to debug. Empty set indicates all topics. */
   protected val debugTopics: Opt[Set[Str]] = N
   protected var indent = 0
-  private var topic: Opt[Str] = N
+  private var currentTopic: Opt[Str] = N
 
   def emitString(str: String): Unit = scala.Predef.println(str)
   
@@ -22,10 +22,10 @@ trait Traceable {
     res
   }
 
-  def traceWithTopic[T](topic: Str)(thunk: => T): T = {
-    this.topic = S(topic)
+  def traceWithTopic[T](currentTopic: Str)(thunk: => T): T = {
+    this.currentTopic = S(currentTopic)
     val res = thunk
-    this.topic = N
+    this.currentTopic = N
     res
   }
 
@@ -33,9 +33,9 @@ trait Traceable {
     thunk
   
   @inline protected def println(x: => Any): Unit =
-    topic match {
-      case N => if (debugTopics.isDefined) printLineByLine(x)
-      case S(topic) => if (debugTopics.fold(false)(ts => ts.isEmpty || ts.contains(topic))) printLineByLine(x)
+    debugTopics match {
+      case S(someTopics) if someTopics.isEmpty || currentTopic.fold(false)(someTopics) => printLineByLine(x)
+      case N | S(_) => ()
     }
 }
 
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 871420ec2e..2617c402dd 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -6,8 +6,8 @@ import mlscript.ucs.context.{Context, ScrutineeData}
 import mlscript.ucs.display.{showNormalizedTerm, showSplit}
 import mlscript.pretyper.{PreTyper, Scope}
 import mlscript.pretyper.symbol._
-import mlscript._, utils._, shorthands._
-import mlscript.Message, Message.MessageContext
+import mlscript.{If, Loc, Message, Var}, Message.MessageContext, mlscript.Diagnostic.PreTyping
+import mlscript.utils._, shorthands._
 
 // TODO: Rename to `Desugarer` once the old desugarer is removed.
 trait DesugarUCS extends Transformation
@@ -16,6 +16,15 @@ trait DesugarUCS extends Transformation
                     with PostProcessing 
                     with CoverageChecking { self: PreTyper =>
 
+  /** A shorthand function to raise errors without specifying the source. */
+  protected def raiseError(messages: (Message -> Opt[Loc])*): Unit =
+    raiseError(PreTyping, messages: _*)
+
+  /** A shorthand function to raise warnings without specifying the source. */
+  protected def raiseWarning(messages: (Message -> Opt[Loc])*): Unit =
+    raiseWarning(PreTyping, messages: _*)
+
+  /** Create a fresh local symbol for the given `Var`. */
   protected def freshSymbol(nme: Var): LocalTermSymbol = new LocalTermSymbol(nme)
 
   /** Common operations of `Var` which can be shared within all stages. */
@@ -23,23 +32,30 @@ trait DesugarUCS extends Transformation
     /** Associate the given `Var` with a fresh `ValueSymbol`. */
     def withFreshSymbol: Var = nme.withSymbol(freshSymbol(nme))
 
+    private def requireClassLikeSymbol(symbol: TypeSymbol): TypeSymbol = symbol match {
+      case symbol @ (_: TraitSymbol | _: ClassSymbol | _: ModuleSymbol) => symbol
+      case symbol: MixinSymbol =>
+        throw new DesugaringException(msg"Mixins are not allowed in pattern" -> nme.toLoc :: Nil)
+      case symbol: TypeAliasSymbol =>
+        throw new DesugaringException(msg"Type alias is not allowed in pattern" -> nme.toLoc :: Nil)
+    }
+
     /**
       * If the given `Var` represents a class name, get its associated `ClassSymbol`.
       *
       * @param className the class name variable
       */
-    def getClassLikeSymbol: TypeSymbol =
-      trace(s"getClassLikeSymbol <== ${nme.showDbg}") {
-        nme.symbolOption match {
-          case S(symbol: ClassSymbol) => symbol
-          case S(symbol: TraitSymbol) => symbol
-          case S(symbol: ModuleSymbol) => symbol
-          case S(symbol: Symbol) => throw new DesugaringException(
-            msg"variable ${nme.name} is not associated with a class symbol" -> N :: Nil)
-          case N => throw new DesugaringException(
-            msg"variable ${nme.name} is not associated with any symbols" -> N :: Nil)
-        }
-      }(symbol => s"getClassLikeSymbol ==> ${symbol.name}")
+    def getClassLikeSymbol: TypeSymbol = {
+      val symbol = nme.symbolOption match {
+        case S(symbol: TypeSymbol) => requireClassLikeSymbol(symbol)
+        case S(symbol: TermSymbol) => throw new DesugaringException(
+          msg"variable ${nme.name} is not associated with a class symbol" -> nme.toLoc :: Nil)
+        case N => throw new DesugaringException(
+          msg"variable ${nme.name} is not associated with any symbols" -> nme.toLoc :: Nil)
+      }
+      println(s"getClassLikeSymbol: ${nme.name} ==> ${symbol.showDbg}")
+      symbol
+    }
 
     /**
       * A short hand for `nme.symbol.getScrutinee` but add a diagnostic message
@@ -50,11 +66,10 @@ trait DesugarUCS extends Transformation
       case S(otherSymbol) => throw new DesugaringException(
         msg"Expected scrutinee symbol, found ${nme.symbol.name}" -> nme.toLoc :: Nil
       )
-      case N => throw new DesugaringException(
-        msg"Scrutinee symbol not found" -> nme.toLoc :: Nil
-      )
+      case N => throw new DesugaringException(msg"Scrutinee symbol not found" -> nme.toLoc :: Nil)
     }
 
+    /** Associate the `Var` with a scrutinee and returns the same `Var`. */
     def withScrutinee(scrutinee: ScrutineeData)(implicit context: Context): Var = nme.symbolOption match {
       case S(symbol: TermSymbol) =>
         symbol.addScrutinee(scrutinee)
@@ -67,46 +82,35 @@ trait DesugarUCS extends Transformation
       )
     }
 
-    def withResolvedTermSymbol(implicit scope: Scope): Var = {
-      nme.symbol = nme.resolveTermSymbol
-      nme
-    }
-
-    def resolveTermSymbol(implicit scope: Scope): TermSymbol =
-      scope.getTermSymbol(nme.name).getOrElse {
+    /** Associate the `Var` with a term symbol and returns the term symbol. */
+    def resolveTermSymbol(implicit scope: Scope): TermSymbol = {
+      val symbol = scope.getTermSymbol(nme.name).getOrElse {
         throw new DesugaringException(msg"Undefined symbol found in patterns." -> nme.toLoc :: Nil)
       }
-
-    def withResolvedTypeSymbol(implicit scope: Scope): Var = {
-      nme.symbol = nme.resolveTypeSymbol
-      nme
+      nme.symbol = symbol
+      symbol
     }
 
-    def resolveTypeSymbol(implicit scope: Scope): TypeSymbol = scope.getTypeSymbol(nme.name) match {
-      case S(symbol: TraitSymbol) =>
-        println(s"resolveTypeSymbol ${nme} ==> trait")
-        nme.symbol = symbol
-        symbol
-      case S(symbol: ClassSymbol) =>
-        println(s"resolveTypeSymbol ${nme} ==> class")
-        nme.symbol = symbol
-        symbol
-      case S(symbol: ModuleSymbol) =>
-        println(s"resolveTypeSymbol ${nme} ==> module")
-        nme.symbol = symbol
-        symbol
-      case S(symbol: MixinSymbol) =>
-        throw new DesugaringException(msg"Mixins are not allowed in pattern" -> nme.toLoc :: Nil)
-      case S(symbol: TypeAliasSymbol) =>
-        throw new DesugaringException(msg"Type alias is not allowed in pattern" -> nme.toLoc :: Nil)
-      case N =>
-        throw new DesugaringException(msg"Undefined symbol found in patterns." -> nme.toLoc :: Nil)
+    /** Associate the `Var` with a term symbol and returns the same `Var`. */
+    def withResolvedTermSymbol(implicit scope: Scope): Var = { nme.resolveTermSymbol; nme }
+
+    /** Associate the `Var` with a class like symbol and returns the class like symbol. */
+    def resolveClassLikeSymbol(implicit scope: Scope): TypeSymbol = {
+      val symbol = scope.getTypeSymbol(nme.name) match {
+        case S(symbol) => requireClassLikeSymbol(symbol)
+        case N => throw new DesugaringException(msg"Undefined symbol found in patterns." -> nme.toLoc :: Nil)
+      }
+      nme.symbol = symbol
+      symbol
     }
+
+    /** Associate the `Var` with a class like symbol and returns the same `Var`. */
+    def withResolvedClassLikeSymbol(implicit scope: Scope): Var = { nme.resolveClassLikeSymbol; nme }
   }
 
   protected def traverseIf(`if`: If)(implicit scope: Scope): Unit = {
     implicit val context: Context = new Context(`if`)
-    trace("traverseIf") {
+    try trace("traverseIf") {
       // Stage 0: Transformation
       val transformed = traceWithTopic("ucs.transform") {
         println("STEP 0")
@@ -118,10 +122,11 @@ trait DesugarUCS extends Transformation
       // Stage 1: Desugaring
       val desugared = traceWithTopic("desugar") {
         println("STEP 1")
-        val desugared = desugar(transformed)
+        desugar(transformed)
+      }
+      traceWithTopic("desugar.result") {
         println("Desugared UCS term:")
         println(showSplit(desugared))
-        desugared
       }
       traceWithTopic("traverse") {
         println("STEP 1.5")
@@ -130,18 +135,20 @@ trait DesugarUCS extends Transformation
       // Stage 2: Normalization
       val normalized = traceWithTopic("normalize") {
         println("STEP 2")
-        val normalized = normalize(desugared)
+        normalize(desugared)
+      }
+      traceWithTopic("normalize.result") {
         println("Normalized UCS term:")
         println(showNormalizedTerm(normalized))
-        normalized
       }
       // Stage 3: Post-processing
       val postProcessed = traceWithTopic("postprocess") {
         println("STEP 3")
-        val postProcessed = postProcess(normalized)
+        postProcess(normalized)
+      }
+      traceWithTopic("postprocess.result") {
         println("Post-processed UCS term:")
         println(showNormalizedTerm(postProcessed))
-        postProcessed
       }
       // Stage 4: Coverage checking
       traceWithTopic("coverage") {
@@ -155,7 +162,9 @@ trait DesugarUCS extends Transformation
       }
       // Epilogue
       `if`.desugaredTerm = S(postProcessed)
-    }(_ => "traverseIf ==> ()")
+    }(_ => "traverseIf ==> ()") catch {
+      case e: DesugaringException => raiseError(e.messages: _*)
+    }
   }
   
   private def traverseSplit(split: core.Split)(implicit scope: Scope): Unit =
@@ -163,30 +172,16 @@ trait DesugarUCS extends Transformation
       import core._
       split match {
         case Split.Cons(Branch(scrutinee, pattern, continuation), tail) => 
-          println(s"found branch: $scrutinee is $pattern")
           traverseTerm(scrutinee)
-          val patternSymbols = traversePattern(scrutinee, pattern)
+          val patternSymbols = pattern.declaredVars.map(nme => nme -> nme.symbol)
           traverseSplit(continuation)(scope.withEntries(patternSymbols))
           traverseSplit(tail)
-        case Split.Let(_, name, rhs, tail) =>
-          println(s"found let binding: \"$name\"")
-          println(s"traverse rhs: $rhs")
-          traverseTerm(rhs)
-          traverseSplit(tail)(scope + name.symbol)
+        case Split.Let(isRec, name, rhs, tail) =>
+          val scopeWithName = scope + name.symbol
+          traverseTerm(rhs)(if (isRec) scopeWithName else scope)
+          traverseSplit(tail)(scopeWithName)
         case Split.Else(default) => traverseTerm(default)
-        case Split.Nil => println("the end")
+        case Split.Nil => ()
       }
     }()
-
-  private def traversePattern(scrutinee: Var, pattern: core.Pattern)(implicit scope: Scope): List[Var -> Symbol] =
-    trace(s"traversePattern <== $pattern") {
-      pattern match {
-        case core.Pattern.Literal(literal) => Nil
-        case core.Pattern.Name(nme) => nme -> nme.symbol :: Nil
-        // For now, there should only be parameter-less class patterns.
-        case core.Pattern.Class(nme) => Nil
-        case core.Pattern.Tuple(_) => ???
-        case core.Pattern.Record(_) => ???
-      }
-    }(_.iterator.map(_._1.name).mkString("traversePattern ==> [", ", ", "]"))
 }
diff --git a/shared/src/main/scala/mlscript/ucs/context/Matchable.scala b/shared/src/main/scala/mlscript/ucs/context/Matchable.scala
index 9d9d96b8c1..ab85e6de59 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Matchable.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Matchable.scala
@@ -35,5 +35,11 @@ trait Matchable {
   private[ucs] def addScrutinee(scrutinee: ScrutineeData)(implicit context: Context): Unit = {
     require(!isScrutinee) // It should be impossible to add a scrutinee twice.
     scrutinees += context -> scrutinee
-    }
+  }
+
+  /** Associate the symbol with a scrutinee in the given context and returns the current object. */
+  private[ucs] def withScrutinee(scrutinee: ScrutineeData)(implicit context: Context): this.type = {
+    addScrutinee(scrutinee)
+    this
+  }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala b/shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala
new file mode 100644
index 0000000000..2d8d4a1a1e
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala
@@ -0,0 +1,127 @@
+package mlscript.ucs.context
+
+import collection.mutable.{Buffer, SortedMap => MutSortedMap}
+import mlscript.{Lit, Loc, Located, SimpleTerm, TypeName, Var}
+import mlscript.pretyper.symbol.TypeSymbol
+import mlscript.utils._, shorthands._
+
+abstract class PatternInfo {
+  private val locationsBuffer: Buffer[Loc] = Buffer.empty
+
+  def addLocation(located: Located): Unit = located.getLoc.foreach(locationsBuffer += _)
+
+  def addLocation(location: Opt[Loc]): Unit = locationsBuffer ++= location
+
+  /** Get the location of this pattern's first occurrence. */
+  def firstOccurrence: Option[Loc] = locationsBuffer.headOption
+
+  def locations: Ls[Loc] = locationsBuffer.toList
+
+  def arity: Opt[Int]
+
+  def showDbg: Str
+
+  /**
+    * Checks if the pattern is same as expressed by the given `SimpleTerm`. Note
+    * that we should pass `pat` of `Case` to this function.
+    */
+  def matches(pat: SimpleTerm): Bool
+
+  /** Create a `SimpleTerm` which can be used as `pat` of `Case`. */
+  def toCasePattern: SimpleTerm
+}
+
+object PatternInfo {
+  class ClassLike(val classLikeSymbol: TypeSymbol, scrutinee: ScrutineeData) extends PatternInfo {
+    private var unappliedVarOpt: Opt[Var] = N
+    private val parameters: MutSortedMap[Int, ScrutineeData] = MutSortedMap.empty
+
+    /**
+      * Get or create a sub-scrutinee for the given parameter index.
+      *
+      * @param index the index of the parameter.
+      * @return a `ScrutineeData` for the parameter whose parent scrutinee is the
+      *         current scrutinee
+      */
+    def getParameter(index: Int): ScrutineeData = {
+      require(index >= 0)
+      parameters.getOrElseUpdate(index, scrutinee.freshSubScrutinee)
+    }
+
+    def getUnappliedVar(default: => Var): Var =
+      unappliedVarOpt.getOrElse {
+        val unappliedVar = default
+        unappliedVarOpt = S(unappliedVar)
+        unappliedVar
+      }
+
+    override def arity: Opt[Int] = parameters.keysIterator.maxOption.map(_ + 1)
+
+    override def showDbg: Str = s"${classLikeSymbol.name}"
+
+    override def matches(pat: SimpleTerm): Bool =
+      pat match {
+        case pat: Var => pat.symbolOption.exists(_ === classLikeSymbol)
+        case _: Lit => false
+      }
+
+    override def toCasePattern: SimpleTerm =
+      Var(classLikeSymbol.name).withLoc(firstOccurrence).withSymbol(classLikeSymbol)
+  }
+
+  class Tuple(scrutinee: ScrutineeData) extends PatternInfo {
+    private val fields: MutSortedMap[Int, ScrutineeData] = MutSortedMap.empty
+
+    def getField(index: Int): ScrutineeData =
+      fields.getOrElseUpdate(index, scrutinee.freshSubScrutinee)
+
+    override def arity: Opt[Int] = fields.keysIterator.maxOption.map(_ + 1)
+
+    override def showDbg: Str = s"tuple#${arity.getOrElse("?")}"
+
+    override def matches(pat: SimpleTerm): Bool = false
+
+    /**
+      * Note that currently we only support simple tuple patterns. They should
+      * disappear after desugaring stage, therefore, it will be an error if you
+      * find an instance of this class.
+      */
+    override def toCasePattern: SimpleTerm = ???
+  }
+
+  class Literal(val literal: Lit) extends PatternInfo {
+    override def arity: Opt[Int] = N
+
+    override def showDbg: Str = literal.idStr
+
+    override def matches(pat: SimpleTerm): Bool =
+      pat match {
+        case _: Var => false
+        case pat => pat === literal
+      }
+
+    override def toCasePattern: SimpleTerm = literal.withLoc(firstOccurrence)
+  }
+
+  /**
+    * This can be actually merged with `LiteralPatternInfo`. However, there's no
+    * `Lit` sub-classes for Boolean types, so the representation is a little bit
+    * awkward, also, it makes sense to consider Boolean patterns separately
+    * because we can check the Boolean exhaustiveness with them.
+    */
+  class Boolean(val value: Var) extends PatternInfo {
+    require(value.name === "true" || value.name === "false")
+
+    override def arity: Opt[Int] = N
+
+    override def showDbg: Str = value.toString
+
+    override def matches(pat: SimpleTerm): Bool =
+      pat match {
+        case Var(name) => value.name === name
+        case _ => false
+      }
+
+    override def toCasePattern: SimpleTerm = value.withLoc(firstOccurrence)
+  }
+}
diff --git a/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala b/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
index 251e674f25..7f4b08b0c5 100644
--- a/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
@@ -1,89 +1,36 @@
 package mlscript.ucs.context
 
-import collection.mutable.{Buffer, Map => MutMap, SortedMap => MutSortedMap, SortedSet => MutSortedSet}
-import mlscript.{Lit, Loc, Located, NuFunDef, NuTypeDef, TypeName, Var}
+import collection.mutable.{Buffer, SortedMap => MutSortedMap, SortedSet => MutSortedSet}
+import mlscript.{Lit, Loc, Var}
 import mlscript.pretyper.symbol.TypeSymbol
 import mlscript.utils._, shorthands._
 import mlscript.ucs.context.CaseSet
-
-abstract class PatternInfo {
-  private val locationsBuffer: Buffer[Loc] = Buffer.empty
-
-  def addLocation(located: Located): Unit = located.getLoc.foreach(locationsBuffer += _)
-
-  def addLocation(location: Opt[Loc]): Unit = locationsBuffer ++= location
-
-  def firstOccurrence: Option[Loc] = locationsBuffer.headOption
-
-  def locations: Ls[Loc] = locationsBuffer.toList
-
-  def arity: Opt[Int]
-}
-
-class ClassPatternInfo(scrutinee: ScrutineeData) extends PatternInfo {
-  private var unappliedVarOpt: Opt[Var] = N
-  private val parameters: MutSortedMap[Int, ScrutineeData] = MutSortedMap.empty
-
-  /**
-    * Get or create a sub-scrutinee for the given parameter index.
-    *
-    * @param index the index of the parameter.
-    * @return a `ScrutineeData` for the parameter whose parent scrutinee is the
-    *         current scrutinee
-    */
-  def getParameter(index: Int): ScrutineeData = {
-    require(index >= 0)
-    parameters.getOrElseUpdate(index, scrutinee.freshSubScrutinee)
-  }
-
-  def getUnappliedVar(default: => Var): Var =
-    unappliedVarOpt.getOrElse {
-      val unappliedVar = default
-      unappliedVarOpt = S(unappliedVar)
-      unappliedVar
-    }
-
-  override def arity: Opt[Int] = parameters.keysIterator.maxOption.map(_ + 1)
-}
-
-class TuplePatternInfo(scrutinee: ScrutineeData) extends PatternInfo {
-  private val fields: MutSortedMap[Int, ScrutineeData] = MutSortedMap.empty
-
-  def getField(index: Int): ScrutineeData =
-    fields.getOrElseUpdate(index, scrutinee.freshSubScrutinee)
-
-  override def arity: Opt[Int] = fields.keysIterator.maxOption.map(_ + 1)
-}
-
-class LiteralPatternInfo extends PatternInfo {
-  override def arity: Opt[Int] = N
-}
-
-/**
-  * This can be actually merged with `LiteralPatternInfo`. However, there's no
-  * `Lit` sub-classes for Boolean types, so the representation is a little bit
-  * awkward, also, it makes sense to consider Boolean patterns separately
-  * because we can check the Boolean exhaustiveness with them.
-  */
-class BooleanPatternInfo extends PatternInfo {
-  override def arity: Opt[Int] = N
-}
+import mlscript.DecLit
+import mlscript.IntLit
+import mlscript.StrLit
+import mlscript.UnitLit
 
 class ScrutineeData(val context: Context, parent: Opt[ScrutineeData]) {
+  import ScrutineeData._
+
   private val locations: Buffer[Loc] = Buffer.empty
   private var generatedVarOpt: Opt[Var] = N
-  private val classLikePatterns: MutMap[TypeSymbol, ClassPatternInfo] = MutMap.empty
+  private val classLikePatterns: MutSortedMap[TypeSymbol, PatternInfo.ClassLike] = MutSortedMap.empty(classLikeSymbolOrdering)
   // Currently we only support simple tuple patterns, so there is only _one_
   // slot for tuple patterns. After we support complex tuple patterns, we need
-  // to extend this fields to a map from tuple arity to `TuplePatternInfo`.
-  //    private val tuplePatterns: MutMap[Int, TuplePatternInfo] = MutMap.empty
+  // to extend this fields to a map from tuple arity to `PatternInfo.Tuple`.
+  //    private val tuplePatterns: MutMap[Int, PatternInfo.Tuple] = MutMap.empty
   // If we support tuple pattern splice, we need a more expressive key in the
   // map's type.
-  private var tuplePatternOpt: Opt[TuplePatternInfo] = N
+  private var tuplePatternOpt: Opt[PatternInfo.Tuple] = N
   private var alisesSet: MutSortedSet[Var] = MutSortedSet.empty
 
-  private val literalPatterns: MutMap[Lit, LiteralPatternInfo] = MutMap.empty
-  private val booleanPatterns: MutMap[Bool, BooleanPatternInfo] = MutMap.empty
+  private val literalPatterns: MutSortedMap[Lit, PatternInfo.Literal] = MutSortedMap.empty(literalOrdering)
+  /**
+    * The key should be either `Var("true")` or `Var("false")`. We want to keep
+    * the type symbol of the variable so that it still work in following stages.
+    */
+  private val booleanPatterns: MutSortedMap[Var, PatternInfo.Boolean] = MutSortedMap.empty(varNameOrdering)
 
   def +=(alias: Var): Unit = alisesSet += alias
 
@@ -92,23 +39,23 @@ class ScrutineeData(val context: Context, parent: Opt[ScrutineeData]) {
   def aliasesIterator: Iterator[Var] = alisesSet.iterator
 
   /**
-    * If there is already a `ClassPatternInfo` for the given symbol, return it.
-    * Otherwise, create a new `ClassPatternInfo` and return it.
+    * If there is already a `PatternInfo.ClassLike` for the given symbol, return it.
+    * Otherwise, create a new `PatternInfo.ClassLike` and return it.
     */
-  def getOrCreateClassPattern(classLikeSymbol: TypeSymbol): ClassPatternInfo =
-    classLikePatterns.getOrElseUpdate(classLikeSymbol, new ClassPatternInfo(this))
+  def getOrCreateClassPattern(classLikeSymbol: TypeSymbol): PatternInfo.ClassLike =
+    classLikePatterns.getOrElseUpdate(classLikeSymbol, new PatternInfo.ClassLike(classLikeSymbol, this))
 
   /**
     * Get the class pattern but DO NOT create a new one if there isn't. This
     * function is mainly used in post-processing because we don't want to
     * accidentally create new patterns.
     */
-  def getClassPattern(classLikeSymbol: TypeSymbol): Opt[ClassPatternInfo] =
+  def getClassPattern(classLikeSymbol: TypeSymbol): Opt[PatternInfo.ClassLike] =
     classLikePatterns.get(classLikeSymbol)
 
   /**
-   * If there is already a `TuplePatternInfo`, return it. Otherwise, create a
-   * new `TuplePatternInfo` and return it.
+   * If there is already a `PatternInfo.Tuple`, return it. Otherwise, create a
+   * new `PatternInfo.Tuple` and return it.
    * 
    * **NOTE**: There's only one slot for tuple patterns because we cannot
    * differentiate tuple types in underlying MLscript case terms. In the future,
@@ -116,35 +63,42 @@ class ScrutineeData(val context: Context, parent: Opt[ScrutineeData]) {
    * a signature like this.
    * 
    * ```scala
-   * def getOrCreateTuplePattern(dimension: TupleDimension): TuplePatternInfo
+   * def getOrCreateTuplePattern(dimension: TupleDimension): PatternInfo.Tuple
    * case class TupleDimension(knownArity: Int, hasSplice: Bool)
    * ```
    */
-  def getOrCreateTuplePattern: TuplePatternInfo =
+  def getOrCreateTuplePattern: PatternInfo.Tuple =
     tuplePatternOpt.getOrElse {
-      val tuplePattern = new TuplePatternInfo(this)
+      val tuplePattern = new PatternInfo.Tuple(this)
       tuplePatternOpt = S(tuplePattern)
       tuplePattern
     }
 
   /** Get the tuple pattern and create a new one if there isn't. */
-  def getOrCreateLiteralPattern(literal: Lit): LiteralPatternInfo =
-    literalPatterns.getOrElseUpdate(literal, new LiteralPatternInfo)
+  def getOrCreateLiteralPattern(literal: Lit): PatternInfo.Literal =
+    literalPatterns.getOrElseUpdate(literal, new PatternInfo.Literal(literal))
+
+  /**
+    * The key should be either `Var("true")` or `Var("false")`. We want to keep
+    * the type symbol of the variable so that it still work in following stages.
+    */
+  def getOrCreateBooleanPattern(value: Var): PatternInfo.Boolean =
+    booleanPatterns.getOrElseUpdate(value, new PatternInfo.Boolean(value))
 
-  def getOrCreateBooleanPattern(value: Bool): BooleanPatternInfo =
-    booleanPatterns.getOrElseUpdate(value, new BooleanPatternInfo)
+  def classLikePatternsIterator: Iterator[PatternInfo.ClassLike] = classLikePatterns.valuesIterator
 
-  def classLikePatternsIterator: Iterator[TypeSymbol -> ClassPatternInfo] = classLikePatterns.iterator
+  def patternsIterator: Iterator[PatternInfo] =
+    classLikePatterns.valuesIterator ++ literalPatterns.valuesIterator ++ booleanPatterns.valuesIterator
 
-  /** Get the name representation of patterns. Only for debugging. */
-  def patterns: Iterator[Str] = {
+  /** Get a list of string representation of patterns. Only for debugging. */
+  private[ucs] def showPatternsDbg: Str = {
     val classLikePatternsStr = classLikePatterns.iterator.map { case (symbol, pattern) =>
       s"${symbol.name}(${pattern.arity.fold("?")(_.toString)})"
     }
     val tuplePatternStr = tuplePatternOpt.iterator.map { tuplePattern =>
       s"tuple(${tuplePattern.arity.fold("?")(_.toString)})"
     }
-    classLikePatternsStr ++ tuplePatternStr
+    (classLikePatternsStr ++ tuplePatternStr).mkString(", ")
   }
 
   def freshSubScrutinee: ScrutineeData = context.freshScrutinee(this)
@@ -188,4 +142,29 @@ object ScrutineeData {
       case _ => N
     }
   }
+
+  private def literalInternalOrder(literal: Lit): Int = literal match {
+    case UnitLit(true) => 0
+    case UnitLit(false) => 1
+    case _: DecLit => 2
+    case _: IntLit => 3
+    case _: StrLit => 4
+  }
+
+  private implicit val classLikeSymbolOrdering: Ordering[TypeSymbol] = new Ordering[TypeSymbol] {
+    override def compare(x: TypeSymbol, y: TypeSymbol): Int = x.defn.name.compareTo(y.defn.name)
+  }
+
+  private implicit val literalOrdering: Ordering[Lit] = new Ordering[Lit] {
+    override def compare(x: Lit, y: Lit): Int = (x, y) match {
+      case (DecLit(x), DecLit(y)) => x.compare(y)
+      case (IntLit(x), IntLit(y)) => x.compare(y)
+      case (StrLit(x), StrLit(y)) => x.compare(y)
+      case _ => literalInternalOrder(x).compare(literalInternalOrder(y))
+    }
+  }
+
+  private implicit val varNameOrdering: Ordering[Var] = new Ordering[Var] {
+    override def compare(x: Var, y: Var): Int = x.name.compareTo(y.name)
+  }
 }
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/ucs/core.scala b/shared/src/main/scala/mlscript/ucs/core.scala
index 14b1577f6c..2d9c725b51 100644
--- a/shared/src/main/scala/mlscript/ucs/core.scala
+++ b/shared/src/main/scala/mlscript/ucs/core.scala
@@ -1,22 +1,18 @@
 package mlscript.ucs
 
-import collection.mutable.Buffer
 import mlscript.{Diagnostic, Lit, Loc, Located, Message, Term, Var}
 import mlscript.utils._, shorthands._
-import mlscript.ucs.core.Split.Cons
-import mlscript.ucs.core.Split.Let
-import mlscript.ucs.core.Split.Else
-import mlscript.ucs.stages.Desugaring
 
 package object core {
   sealed abstract class Pattern extends Located {
+    def declaredVars: Iterator[Var] = this match {
+      case _: Pattern.Literal | _: Pattern.Class => Iterator.empty
+      case Pattern.Name(nme) => Iterator.single(nme)
+    }
     override def toString(): String = this match {
-      case Pattern.Literal(literal) => literal.toString
+      case Pattern.Literal(literal) => literal.idStr
       case Pattern.Name(Var(name)) => name
       case Pattern.Class(Var(name)) => name
-      case Pattern.Tuple(fields) => fields.iterator.map(_.fold("_")(_.name)).mkString("(", ", ", ")")
-      case Pattern.Record(Nil) => "{}"
-      case Pattern.Record(entries) => entries.iterator.map { case (nme, als) => s"$nme: $als" }.mkString("{ ", ", ", " }")
     }
   }
   object Pattern {
@@ -29,12 +25,6 @@ package object core {
     final case class Class(nme: Var) extends Pattern {
       override def children: Ls[Located] = nme :: Nil
     }
-    final case class Tuple(elements: List[Opt[Var]]) extends Pattern {
-      override def children: Ls[Located] = elements.flatten
-    }
-    final case class Record(entries: List[(Var -> Var)]) extends Pattern {
-      override def children: Ls[Located] = entries.iterator.flatMap { case (nme, als) => nme :: als :: Nil }.toList
-    }
 
     def getParametersLoc(parameters: List[Opt[Var]]): Opt[Loc] =
       parameters.foldLeft(None: Opt[Loc]) {
@@ -49,9 +39,11 @@ package object core {
       parameters.fold("empty")(_.map(_.fold("_")(_.name)).mkString("[", ", ", "]"))
   }
 
-  final case class Branch(scrutinee: Var, pattern: Pattern, continuation: Split)
+  final case class Branch(scrutinee: Var, pattern: Pattern, continuation: Split) extends Located {
+    override def children: List[Located] = scrutinee :: pattern :: continuation :: Nil
+  }
 
-  sealed abstract class Split {
+  sealed abstract class Split extends Located {
     @inline
     def ::(head: Branch): Split = Split.Cons(head, this)
 
@@ -76,7 +68,7 @@ package object core {
       case Split.Nil => false
     }
 
-    lazy val freeVars: Set[Var] = this match {
+    override lazy val freeVars: Set[Var] = this match {
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
         // FIXME: It is safe to ignore `pattern` for now.
         continuation.freeVars ++ tail.freeVars
@@ -90,26 +82,19 @@ package object core {
       * Remove duplicated bindings.
       */
     def withoutBindings(vars: Set[Var]): Split = this match {
-      case self @ Cons(head @ Branch(_, _, continuation), tail) =>
+      case self @ Split.Cons(head @ Branch(_, _, continuation), tail) =>
         self.copy(head.copy(continuation = continuation.withoutBindings(vars)), tail.withoutBindings(vars))
-      case self @ Let(_, name, _, tail) if vars contains name => tail.withoutBindings(vars)
-      case self @ Let(_, _, _, tail) => self.copy(tail = tail.withoutBindings(vars))
-      case Else(_) | Split.Nil => this
+      case self @ Split.Let(_, name, _, tail) if vars contains name => tail.withoutBindings(vars)
+      case self @ Split.Let(_, _, _, tail) => self.copy(tail = tail.withoutBindings(vars))
+      case Split.Else(_) | Split.Nil => this
     }
 
-    private val diagnostics: Buffer[Message -> Opt[Loc]] = Buffer.empty
-
-    def withDiagnostic(diagnostic: Message -> Opt[Loc]): this.type = {
-      diagnostics += diagnostic
-      this
+    final override def children: Ls[Located] = this match {
+      case Split.Cons(head, tail) => head :: tail :: Nil
+      case Split.Let(rec, name, term, tail) => name :: term :: tail :: Nil
+      case Split.Else(default) => default :: Nil
+      case Split.Nil => Nil
     }
-
-    def collectDiagnostics(): Ls[Message -> Opt[Loc]] =
-      diagnostics.toList ++ (this match {
-        case Split.Cons(_, tail) => tail.collectDiagnostics()
-        case Split.Let(_, _, _, tail) => tail.collectDiagnostics()
-        case Split.Else(_) | Split.Nil => Nil
-      })
   }
 
   object Split {
@@ -117,7 +102,5 @@ package object core {
     final case class Let(rec: Bool, name: Var, term: Term, tail: Split) extends Split
     final case class Else(default: Term) extends Split
     final case object Nil extends Split
-
-    def just(term: Term): Split = Else(term)
   }
 }
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/ucs/display.scala b/shared/src/main/scala/mlscript/ucs/display.scala
index ce90728601..3f7f5dd73b 100644
--- a/shared/src/main/scala/mlscript/ucs/display.scala
+++ b/shared/src/main/scala/mlscript/ucs/display.scala
@@ -31,8 +31,10 @@ package object display {
         case (n, line) :: tail => (n, (if (isAfterAnd) "" else "and ") + s"$line") :: tail
         case Nil => Nil
       }) ::: termSplit(tail, false, isAfterAnd)
-      case syntax.Split.Let(_, nme, rhs, tail) => (0, s"let $nme = $rhs") :: termSplit(tail, false, isAfterAnd)
-      case syntax.Split.Else(term) => (if (isFirst) (0, s"then $term") else (0, s"else $term")) :: Nil
+      case syntax.Split.Let(_, nme, rhs, tail) =>
+        (0, s"let ${nme.name} = ${rhs.showDbg}") :: termSplit(tail, false, isAfterAnd)
+      case syntax.Split.Else(term) =>
+        (if (isFirst) (0, s"then ${term.showDbg}") else (0, s"else ${term.showDbg}")) :: Nil
       case syntax.Split.Nil => Nil
     }
     def termBranch(branch: syntax.TermBranch): Lines = branch match {
@@ -45,14 +47,16 @@ package object display {
     }
     def patternSplit(split: syntax.PatternSplit): Lines = split match {
       case syntax.Split.Cons(head, tail) => patternBranch(head) ::: patternSplit(tail)
-      case syntax.Split.Let(rec, nme, rhs, tail) => (0, s"let $nme = $rhs") :: patternSplit(tail)
-      case syntax.Split.Else(term) => (0, s"else $term") :: Nil
+      case syntax.Split.Let(rec, nme, rhs, tail) =>
+        (0, s"let ${nme.name} = ${rhs.showDbg}") :: patternSplit(tail)
+      case syntax.Split.Else(term) => (0, s"else ${term.showDbg}") :: Nil
       case syntax.Split.Nil => Nil
     }
     def operatorSplit(split: syntax.OperatorSplit): Lines = split match {
       case syntax.Split.Cons(head, tail) => operatorBranch(head) ::: operatorSplit(tail)
-      case syntax.Split.Let(rec, nme, rhs, tail) => (0, s"let $nme = $rhs") :: operatorSplit(tail)
-      case syntax.Split.Else(term) => (0, s"else $term") :: Nil
+      case syntax.Split.Let(rec, nme, rhs, tail) =>
+        (0, s"let ${nme.name} = ${rhs.showDbg}") :: operatorSplit(tail)
+      case syntax.Split.Else(term) => (0, s"else ${term.showDbg}") :: Nil
       case syntax.Split.Nil => Nil
     }
     def operatorBranch(branch: syntax.OperatorBranch): Lines =
@@ -79,8 +83,10 @@ package object display {
         case (n, line) :: tail => (n, (if (isTopLevel) "" else "") + s"$line") :: tail
         case Nil => Nil
       }) ::: split(tail, false, isTopLevel)
-      case core.Split.Let(_, nme, rhs, tail) => (0, s"let ${showVar(nme)} = $rhs") :: split(tail, false, isTopLevel)
-      case core.Split.Else(term) => (if (isFirst) (0, s"then $term") else (0, s"else $term")) :: Nil
+      case core.Split.Let(_, nme, rhs, tail) =>
+        (0, s"let ${showVar(nme)} = ${rhs.showDbg}") :: split(tail, false, isTopLevel)
+      case core.Split.Else(term) =>
+        (if (isFirst) (0, s"then ${term.showDbg}") else (0, s"else ${term.showDbg}")) :: Nil
       case core.Split.Nil => Nil
     }
     def branch(b: core.Branch): Lines = {
@@ -104,15 +110,15 @@ package object display {
     def showTerm(term: Term): Lines = term match {
       case let: Let => showLet(let)
       case caseOf: CaseOf => showCaseOf(caseOf)
-      case other => (0, other.toString) :: Nil
+      case other => (0, other.showDbg) :: Nil
     }
     def showScrutinee(term: Term): Str = term match {
       case vari: Var => showVar(vari)
-      case _ => term.toString
+      case _ => term.showDbg
     }
     def showPattern(pat: SimpleTerm): Str = pat match {
       case vari: Var => showVar(vari)
-      case _ => pat.toString
+      case _ => pat.showDbg
     }
     def showCaseOf(caseOf: CaseOf): Lines = {
       val CaseOf(trm, cases) = caseOf
@@ -127,7 +133,7 @@ package object display {
       }
     def showLet(let: Let): Lines = {
       val Let(rec, nme, rhs, body) = let
-      (0, s"let ${showVar(nme)} = $rhs") :: showTerm(body)
+      (0, s"let ${showVar(nme)} = ${rhs.showDbg}") :: showTerm(body)
     }
     showTerm(term).map { case (n, line) => "  " * n + line }.mkString("\n")
   }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index e58d9b560d..54b9db28d2 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -66,8 +66,8 @@ trait Desugaring { self: PreTyper =>
     * A shorthand for making a true pattern, which is useful in desugaring
     * Boolean conditions.
     */
-  private def truePattern(implicit scope: Scope) = c.Pattern.Class(Var("true").withResolvedTypeSymbol)
-  private def falsePattern(implicit scope: Scope) = c.Pattern.Class(Var("false").withResolvedTypeSymbol)
+  private def truePattern(implicit scope: Scope) = c.Pattern.Class(Var("true").withResolvedClassLikeSymbol)
+  private def falsePattern(implicit scope: Scope) = c.Pattern.Class(Var("false").withResolvedClassLikeSymbol)
 
   private def desugarTermSplit(split: s.TermSplit)(implicit termPart: PartialTerm, scope: Scope, context: Context): c.Split =
     split match {
@@ -170,7 +170,7 @@ trait Desugaring { self: PreTyper =>
     */
   private def desugarClassPattern(pattern: s.ClassPattern, scrutineeVar: Var, initialScope: Scope)(implicit context: Context): (Scope, c.Split => c.Branch) = {
     val scrutinee = scrutineeVar.getOrCreateScrutinee.withAlias(scrutineeVar)
-    val patternClassSymbol = pattern.nme.resolveTypeSymbol(initialScope)
+    val patternClassSymbol = pattern.nme.resolveClassLikeSymbol(initialScope)
     val classPattern = scrutinee.getOrCreateClassPattern(patternClassSymbol)
     println(s"desugarClassPattern: ${scrutineeVar.name} is ${pattern.nme.name}")
     classPattern.addLocation(pattern.nme)
@@ -202,7 +202,7 @@ trait Desugaring { self: PreTyper =>
       // If there is no parameter, then we are done.
       case N => (initialScope, identity(_: c.Split))
     }
-    println(s"${scrutineeVar.name}: ${scrutinee.patterns.mkString(", ")}")
+    println(s"${scrutineeVar.name}: ${scrutinee.showPatternsDbg}")
     // Last, return the scope with all bindings and a function that adds all matches and bindings to a split.
     (scopeWithAll, split => c.Branch(scrutineeVar, c.Pattern.Class(pattern.nme), bindAll(split)))
   }
@@ -303,10 +303,10 @@ trait Desugaring { self: PreTyper =>
               continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context)
             ) :: rec(scrutineeVar, tail)
           case s.ConcretePattern(nme @ (Var("true") | Var("false"))) => 
-            scrutineeVar.getOrCreateScrutinee.withAlias(scrutineeVar).getOrCreateBooleanPattern(nme.name === "true").addLocation(nme)
+            scrutineeVar.getOrCreateScrutinee.withAlias(scrutineeVar).getOrCreateBooleanPattern(nme).addLocation(nme)
             c.Branch(
               scrutinee = scrutineeVar,
-              pattern = c.Pattern.Class(nme.withResolvedTypeSymbol),
+              pattern = c.Pattern.Class(nme.withResolvedClassLikeSymbol),
               continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context)
             ) :: rec(scrutineeVar, tail)
           case s.ConcretePattern(nme) =>
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 20870a2e89..2185849726 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -1,7 +1,7 @@
 
 package mlscript.ucs.stages
 
-import mlscript.ucs.{Lines, LinesOps, VariableGenerator}
+import mlscript.ucs.{DesugarUCS, Lines, LinesOps, VariableGenerator}
 import mlscript.ucs.context.{Context, ScrutineeData}
 import mlscript.ucs.core._
 import mlscript.ucs.display.{showNormalizedTerm, showSplit}
@@ -12,41 +12,56 @@ import mlscript.{App, CaseOf, Fld, FldFlags, Let, Loc, Sel, Term, Tup, Var, StrL
 import mlscript.{CaseBranches, Case, Wildcard, NoCases}
 import mlscript.Message, Message.MessageContext
 import mlscript.utils._, shorthands._
-import mlscript.pretyper.{Traceable, Diagnosable}
+import mlscript.pretyper.Traceable
 
-trait Normalization { self: Traceable with Diagnosable =>
+trait Normalization { self: DesugarUCS with Traceable =>
   import Normalization._
 
-  private def concatImpl(these: Split, those: Split)(implicit context: Context, generatedVars: Set[Var]): Split =
+  // TODO: We might not need the case where `deep` is `false`.
+  private def fillImpl(these: Split, those: Split, deep: Bool)(implicit context: Context, generatedVars: Set[Var]): Split =
     if (these.hasElse) these else (these match {
       case these @ Split.Cons(head, tail) =>
-        println(s"found a cons: $head")
-        if (head.continuation.hasElse) {
-          these.copy(tail = concatImpl(tail, those))
+        if (head.continuation.hasElse || !deep) {
+          these.copy(tail = fillImpl(tail, those, deep))
         } else {
-          println("found a branch without default, duplicating...")
-          val newHead = head.copy(continuation = concat(head.continuation, those))
-          these.copy(head = newHead, tail = concatImpl(tail, those))
+          // println(s"found a branch without default ${showSplit(head.continuation)}")
+          val newHead = head.copy(continuation = fillImpl(head.continuation, those, deep))
+          these.copy(head = newHead, tail = fillImpl(tail, those, deep))
         }
       case these @ Split.Let(_, nme, _, tail) =>
         if (those.freeVars contains nme) {
           val fresh = context.freshShadowed()
           val thoseWithShadowed = Split.Let(false, nme, fresh, those)
-          val concatenated = these.copy(tail = concatImpl(tail, thoseWithShadowed))
+          val concatenated = these.copy(tail = fillImpl(tail, thoseWithShadowed, deep))
           Split.Let(false, fresh, nme, concatenated)
         } else {
-          these.copy(tail = concatImpl(tail, those)(context, generatedVars + nme))
+          these.copy(tail = fillImpl(tail, those, deep)(context, generatedVars + nme))
         }
       case _: Split.Else => these
-      case Split.Nil => those.withoutBindings(generatedVars)
+      case Split.Nil =>
+        // println(s"END, generated vars: ${generatedVars.iterator.map(_.name).mkString(", ")}")
+        those.withoutBindings(generatedVars)
     })
+
+  private implicit class SplitOps(these: Split) {
+    def fill(those: Split, deep: Bool)(implicit context: Context, generatedVars: Set[Var]): Split =
+      trace(s"fill <== ${generatedVars.iterator.map(_.name).mkString("{", ", ", "}")}") {
+        println(s"LHS: ${showSplit(these)}")
+        println(s"RHS: ${showSplit(those)}")
+        fillImpl(these, those, deep)
+      }(sp => s"fill ==> ${showSplit(sp)}")
+
+    def :++(tail: => Split): Split = {
+      if (these.hasElse) {
+        println("tail is discarded")
+        // raiseWarning(msg"Discarded split because of else branch" -> these.toLoc)
+        these
+      } else {
+        these ++ tail
+      }
+    }
+  }
   
-  private def concat(these: Split, those: Split)(implicit context: Context, generatedVars: Set[Var]): Split =
-    trace(s"concat <== ${generatedVars.mkString("{", ", ", "}")}") {
-      println(s"these: ${showSplit(these)}")
-      println(s"those: ${showSplit(those)}")
-      concatImpl(these, those)
-    }(sp => s"concat => ${showSplit(sp)}")
 
   /**
     * Normalize core abstract syntax to MLscript syntax.
@@ -56,34 +71,37 @@ trait Normalization { self: Traceable with Diagnosable =>
     */ 
   @inline protected def normalize(split: Split)(implicit context: Context): Term = normalizeToTerm(split)(context, Set.empty)
 
+  private def errorTerm: Term = Var("error")
+
   private def normalizeToTerm(split: Split)(implicit context: Context, generatedVars: Set[Var]): Term = trace("normalizeToTerm <==") {
     split match {
       case Split.Cons(Branch(scrutinee, Pattern.Name(nme), continuation), tail) =>
         println(s"normalizing name pattern ${scrutinee.name} is ${nme.name}")
-        Let(false, nme, scrutinee, normalizeToTerm(concat(continuation, tail)))
+        Let(false, nme, scrutinee, normalizeToTerm(continuation.fill(tail, deep = false)))
       // Skip Boolean conditions as scrutinees, because they only appear once.
       case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true")), continuation), tail) =>
         println(s"normalizing true pattern: ${test.name} is true")
-        val trueBranch = normalizeToTerm(concat(continuation, tail))
+        val trueBranch = normalizeToTerm(continuation.fill(tail, deep = false))
         val falseBranch = normalizeToCaseBranches(tail)
         CaseOf(test, Case(nme, trueBranch, falseBranch))
       case Split.Cons(Branch(ScrutineeData.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Literal(literal), continuation), tail) =>
-        println(s"normalizing literal pattern: ${scrutineeVar.name} is $literal")
-        val concatenatedTrueBranch = concat(continuation, tail)
-        println(s"true branch: ${showSplit(concatenatedTrueBranch)}")
+        println(s"normalizing literal pattern: ${scrutineeVar.name} is ${literal.idStr}")
+        println(s"entire split: ${showSplit(split)}")
+        val concatenatedTrueBranch = continuation.fill(tail, deep = false)
+        // println(s"true branch: ${showSplit(concatenatedTrueBranch)}")
         val trueBranch = normalizeToTerm(specialize(concatenatedTrueBranch, true)(scrutineeVar, scrutinee, pattern, context))
-        println(s"false branch: ${showSplit(tail)}")
+        // println(s"false branch: ${showSplit(tail)}")
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context))
         CaseOf(scrutineeVar, Case(literal, trueBranch, falseBranch))
       case Split.Cons(Branch(ScrutineeData.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Class(nme), continuation), tail) =>
         println(s"normalizing class pattern: ${scrutineeVar.name} is ${nme.name}")
         // println(s"match ${scrutineeVar.name} with $nme (has location: ${nme.toLoc.isDefined})")
-        val trueBranch = normalizeToTerm(specialize(concat(continuation, tail), true)(scrutineeVar, scrutinee, pattern, context))
+        val trueBranch = normalizeToTerm(specialize(continuation.fill(tail, deep = false), true)(scrutineeVar, scrutinee, pattern, context))
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context))
         CaseOf(scrutineeVar, Case(nme, trueBranch, falseBranch))
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
-        println(s"unknown pattern $pattern")
-        throw new NormalizationException((msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc) :: Nil)
+        raiseError(msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc)
+        errorTerm
       case Split.Let(rec, Var("_"), rhs, tail) => normalizeToTerm(tail)
       case Split.Let(_, nme, _, tail) if context.isScrutineeVar(nme) && generatedVars.contains(nme) =>
         println(s"normalizing let binding of generated variable: ${nme.name}")
@@ -93,16 +111,16 @@ trait Normalization { self: Traceable with Diagnosable =>
         val newDeclaredBindings = if (context.isGeneratedVar(nme)) generatedVars + nme else generatedVars
         Let(rec, nme, rhs, normalizeToTerm(tail)(context, newDeclaredBindings))
       case Split.Else(default) =>
-        println(s"normalizing default: $default")
+        println(s"normalizing default: ${default.showDbg}")
         default
       case Split.Nil =>
-        println(s"normalizing nil")
-        ???
+        raiseError(msg"Found unexpected empty split" -> N)
+        errorTerm
     }
   }(split => "normalizeToTerm ==> " + showNormalizedTerm(split))
 
   private def normalizeToCaseBranches(split: Split)(implicit context: Context, generatedVars: Set[Var]): CaseBranches =
-    trace(s"normalizeToCaseBranches <== $split") {
+    trace(s"normalizeToCaseBranches <==") {
       split match {
         // case Split.Cons(head, Split.Nil) => Case(head.pattern, normalizeToTerm(head.continuation), NoCases)
         case other: Split.Cons => Wildcard(normalizeToTerm(other))
@@ -119,9 +137,14 @@ trait Normalization { self: Traceable with Diagnosable =>
         case Split.Else(default) => Wildcard(default)
         case Split.Nil => NoCases
       }
-    }(r => "normalizeToCaseBranches ==> ")
+    }(r => "normalizeToCaseBranches ==>")
 
-  // Specialize `split` with the assumption that `scrutinee` matches `pattern`.
+  /**
+    * Specialize `split` with the assumption that `scrutinee` matches `pattern`.
+    * If `matchOrNot` is `true`, the function keeps branches that agree on
+    * `scrutinee` matches `pattern`. Otherwise, the function removes branches
+    * that agree on `scrutinee` matches `pattern`.
+    */
   private def specialize
       (split: Split, matchOrNot: Bool)
       (implicit scrutineeVar: Var, scrutinee: ScrutineeData, pattern: Pattern, context: Context): Split =
@@ -131,68 +154,59 @@ trait Normalization { self: Traceable with Diagnosable =>
       case (_, Split.Cons(Branch(otherScrutineeVar, Pattern.Name(alias), continuation), tail)) =>
         Split.Let(false, alias, otherScrutineeVar, specialize(continuation, matchOrNot))
       case (_, split @ Split.Cons(head @ Branch(test, Pattern.Class(Var("true")), continuation), tail)) if context.isTestVar(test) =>
-        println(s"found a Boolean test: $test is true")
+        println(s"found a Boolean test: ${test.showDbg} is true")
         val trueBranch = specialize(continuation, matchOrNot)
         val falseBranch = specialize(tail, matchOrNot)
         split.copy(head = head.copy(continuation = trueBranch), tail = falseBranch)
       // Class pattern. Positive.
       case (true, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName), continuation), tail)) =>
-        val otherClassSymbol = getClassLikeSymbol(otherClassName)
-        lazy val specializedTail = {
-          println(s"specialized next")
-          specialize(tail, true)
-        }
+        val otherClassSymbol = otherClassName.getClassLikeSymbol
         if (scrutinee === otherScrutinee) {
           println(s"scrutinee: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
           pattern match {
             case Pattern.Class(className) =>
-              val classSymbol = getClassLikeSymbol(className)
+              val classSymbol = className.getClassLikeSymbol
               if (classSymbol === otherClassSymbol) {
-                println(s"Case 1: class name: $className === $otherClassName")
-                val specialized = specialize(continuation, true)
-                if (specialized.hasElse) {
-                  println("tail is discarded")
-                  specialized.withDiagnostic(
-                    msg"Discarded split because of else branch" -> None // TODO: Synthesize locations
-                  )
-                } else {
-                  specialized ++ specialize(tail, true)
-                }
+                println(s"Case 1: class name: ${className.name} === ${otherClassName.name}")
+                specialize(continuation, true) :++ specialize(tail, true)
               } else if (otherClassSymbol.baseTypes contains classSymbol) {
-                println(s"Case 2: $otherClassName <: $className")
+                println(s"Case 2: ${otherClassName.name} <: ${className.name}")
                 split
               } else {
-                println(s"Case 3: $className and $otherClassName are unrelated")
-                specializedTail
+                println(s"Case 3: ${className.name} and ${otherClassName.name} are unrelated")
+                specialize(tail, true)
               }
             case _ => throw new NormalizationException((msg"Incompatible: ${pattern.toString}" -> pattern.toLoc) :: Nil)
           }
         } else {
-          println(s"scrutinee: ${scrutineeVar.name} =/= ${otherScrutineeVar.name}")
+          // println(s"scrutinee: ${scrutineeVar.name} =/= ${otherScrutineeVar.name}")
           split.copy(
             head = head.copy(continuation = specialize(continuation, true)),
-            tail = specializedTail
+            tail = specialize(tail, true)
           )
         }
       // Class pattern. Negative
       case (false, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName), continuation), tail)) =>
-        val otherClassSymbol = getClassLikeSymbol(otherClassName)
+        val otherClassSymbol = otherClassName.getClassLikeSymbol
         if (scrutinee === otherScrutinee) {
           println(s"scrutinee: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
           pattern match {
             case Pattern.Class(className) =>
-              val classSymbol = getClassLikeSymbol(className)
+              println("both of them are class patterns")
+              val classSymbol = className.getClassLikeSymbol
               if (className === otherClassName) {
-                println(s"Case 1: class name: $otherClassName === $className")
+                println(s"Case 1: class name: ${otherClassName.name} === ${className.name}")
                 specialize(tail, false)
               } else if (otherClassSymbol.baseTypes contains classSymbol) {
-                println(s"Case 2: class name: $otherClassName <: $className")
+                println(s"Case 2: class name: ${otherClassName.name} <: ${className.name}")
                 Split.Nil
               } else {
-                println(s"Case 3: class name: $otherClassName and $className are unrelated")
+                println(s"Case 3: class name: ${otherClassName.name} and ${className.name} are unrelated")
                 split.copy(tail = specialize(tail, false))
               }
-            case _ => throw new NormalizationException((msg"Incompatible: ${pattern.toString}" -> pattern.toLoc) :: Nil)
+            case _ =>
+              println(s"different patterns: ${otherClassName.name} and $pattern.toString")
+              split.copy(tail = specialize(tail, false))
           }
         } else {
           println(s"scrutinee: ${scrutineeVar.name} =/= ${otherScrutineeVar.name}")
@@ -207,15 +221,7 @@ trait Normalization { self: Traceable with Diagnosable =>
           println(s"scrutinee: ${scrutineeVar.name} is ${otherScrutineeVar.name}")
           pattern match {
             case Pattern.Literal(literal) if literal === otherLiteral =>
-              val specialized = specialize(continuation, true)
-              if (specialized.hasElse) {
-                println("tail is discarded")
-                specialized.withDiagnostic(
-                  msg"Discarded split because of else branch" -> None // TODO: Synthesize locations
-                )
-              } else {
-                specialized ++ specialize(tail, true)
-              }
+              specialize(continuation, true) :++ specialize(tail, true)
             case _ => specialize(tail, true)
           }
         } else {
@@ -248,20 +254,21 @@ trait Normalization { self: Traceable with Diagnosable =>
         println(s"unsupported pattern: $pattern")
         throw new NormalizationException((msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc) :: Nil)
       case (_, let @ Split.Let(_, nme, _, tail)) =>
-        println(s"let binding $nme, go next")
+        println(s"let binding ${nme.name}, go next")
         let.copy(tail = specialize(tail, matchOrNot))
       // Ending cases remain the same.
       case (_, end @ (Split.Else(_) | Split.Nil)) => println("the end"); end
     }
-  }(showSplit(s"S${if (matchOrNot) "+" else "-"} ==>", _))
+  }()
+  // }(showSplit(s"S${if (matchOrNot) "+" else "-"} ==>", _))
 }
 
 object Normalization {
-  private def getClassLikeSymbol(className: Var): TypeSymbol =
-    className.symbolOption.flatMap(_.typeSymbolOption) match {
-      case N => throw new NormalizationException(msg"class name is not resolved" -> className.toLoc :: Nil)
-      case S(typeSymbol) => typeSymbol
-    }
+  // private def getClassLikeSymbol(className: Var): TypeSymbol =
+  //   className.symbolOption.flatMap(_.typeSymbolOption) match {
+  //     case N => throw new NormalizationException(msg"class name is not resolved" -> className.toLoc :: Nil)
+  //     case S(typeSymbol) => typeSymbol
+  //   }
 
   class NormalizationException(val messages: Ls[Message -> Opt[Loc]]) extends Throwable {
     def this(message: Message, location: Opt[Loc]) = this(message -> location :: Nil)
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index 53401c0e7c..9c0017d367 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -1,8 +1,8 @@
 package mlscript.ucs.stages
 
-import mlscript.{Case, CaseBranches, CaseOf, Let, Loc, NoCases, Term, Var, Wildcard}
+import mlscript.{Case, CaseBranches, CaseOf, Let, Lit, Loc, NoCases, Term, Var, Wildcard}
 import mlscript.ucs.DesugarUCS
-import mlscript.ucs.context.{Context, ScrutineeData}
+import mlscript.ucs.context.{Context, PatternInfo, ScrutineeData}
 import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
 import mlscript.Message, Message.MessageContext
@@ -14,62 +14,58 @@ trait PostProcessing { self: DesugarUCS with mlscript.pretyper.Traceable =>
   def postProcess(term: Term)(implicit context: Context): Term = trace(s"postProcess <== ${term.showDbg}") {
     // Normalized terms are constructed using `Let` and `CaseOf`.
     term match {
+      case top @ CaseOf(ScrutineeData(_), Wildcard(body)) => body
       case top @ CaseOf(scrutineeVar: Var, fst @ Case(className: Var, body, NoCases)) =>
-        println(s"found a UNARY case: $scrutineeVar is $className")
+        println(s"found a UNARY case: ${scrutineeVar.name} is $className")
         println("post-processing the body")
         top.copy(cases = fst.copy(body = postProcess(body)))
-      case top @ CaseOf(test: Var, fst @ Case(Var("true"), trueBranch, Wildcard(falseBranch))) =>
-        println(s"found a if-then-else case: $test is true")
-        val processedTrueBranch = postProcess(trueBranch)
-        val processedFalseBranch = postProcess(falseBranch)
-        top.copy(cases = fst.copy(body = processedTrueBranch, rest = Wildcard(processedFalseBranch)))
-      case top @ CaseOf(ScrutineeData.WithVar(scrutinee, scrutineeVar), fst @ Case(className: Var, trueBranch, Wildcard(falseBranch))) =>
-        println(s"found a BINARY case: $scrutineeVar is $className")
-        val classSymbol = className.getClassLikeSymbol
-        println(s"matched classes: ${scrutinee.patterns.mkString(", ")}")
-        val classPattern = scrutinee.getClassPattern(classSymbol).getOrElse {
-          throw new PostProcessingException(
-            msg"cannot find class pattern for ${className.name}" -> className.toLoc :: Nil
-          )
-        }
-        println(s"patterns of `${scrutineeVar}`: ${scrutinee.patterns.mkString("{", ", ", "}")}")
+      // case top @ CaseOf(test: Var, fst @ Case(Var("true"), trueBranch, Wildcard(falseBranch))) =>
+      //   println(s"found a if-then-else case: $test is true")
+      //   val processedTrueBranch = postProcess(trueBranch)
+      //   val processedFalseBranch = postProcess(falseBranch)
+      //   top.copy(cases = fst.copy(body = processedTrueBranch, rest = Wildcard(processedFalseBranch)))
+      case top @ CaseOf(ScrutineeData.WithVar(scrutinee, scrutineeVar), fst @ Case(pat, trueBranch, Wildcard(falseBranch))) =>
+        println(s"BINARY: ${scrutineeVar.name} is ${pat.showDbg}")
+        println(s"patterns of `${scrutineeVar.name}`: ${scrutinee.showPatternsDbg}")
         // Post-process the true branch.
         println("post-processing the first branch")
         val processedTrueBranch = postProcess(trueBranch)
         // Post-process the false branch.
         println("post-processing the false branch")
-        val (default, cases) = scrutinee.classLikePatternsIterator.filter(_._1 =/= classSymbol)
+        // Get all patterns, except the current one `pat`.
+        val patternInfoList = scrutinee.patternsIterator.filter(!_.matches(pat)).toList
+        println(s"found ${patternInfoList.length} patterns to distentangle: ${patternInfoList.iterator.map(_.showDbg).mkString(", ")}")
+        val (default, cases) = patternInfoList
           // For each case class name, distangle case branch body terms from the false branch.
-          .foldLeft[Opt[Term] -> Ls[(TypeSymbol, Opt[Loc], Term)]](S(falseBranch) -> Nil) {
-            case ((S(remainingTerm), cases), (classSymbol -> classPattern)) =>
-              println(s"searching for case: ${classSymbol.name}")
-              val (leftoverTerm, extracted) = disentangle(remainingTerm, scrutineeVar, scrutinee, classSymbol)
+          .foldLeft[Opt[Term] -> Ls[(PatternInfo, Opt[Loc], Term)]](S(falseBranch) -> Nil) {
+            case ((S(remainingTerm), cases), pattern) =>
+              println(s"searching for case: ${pattern.showDbg}")
+              val (leftoverTerm, extracted) = disentangleTerm(remainingTerm)(
+                context, scrutineeVar, scrutinee, pattern)
               trimEmptyTerm(leftoverTerm) -> (extracted match {
                 case N =>
-                  println(s"no extracted term about ${classSymbol.name}")
+                  println(s"no extracted term about ${pattern.showDbg}")
                   cases
                 case terms @ S(extractedTerm) => 
-                  println(s"extracted a term about ${classSymbol.name}")
-                  (classSymbol, classPattern.firstOccurrence, postProcess(extractedTerm)) :: cases
+                  println(s"extracted a term about ${pattern.showDbg}")
+                  (pattern, pattern.firstOccurrence, postProcess(extractedTerm)) :: cases
               })
-            case ((N, cases), _) => (N, cases) 
+            case ((N, cases), _) => (N, cases)
           }
         println(s"found ${cases.length} case branches")
         val postProcessedDefault = default.map(postProcess)
         // Assemble a `CaseBranches`.
         val actualFalseBranch = cases.foldRight[CaseBranches](
           postProcessedDefault.fold[CaseBranches](NoCases)(Wildcard(_))
-        ) { case ((classSymbol, loc, body), rest) =>
-          // TODO: Why not just keep the class name?
-          val className = Var(classSymbol.name).withLoc(loc).withSymbol(classSymbol)
-          Case(className, body, rest)
+        ) { case ((pattern, loc, body), rest) =>
+          Case(pattern.toCasePattern, body, rest)
         }
         // Assemble the final `CaseOf`.
         top.copy(cases = fst.copy(body = processedTrueBranch, rest = actualFalseBranch))
       // We recursively process the body of as`Let` bindings.
       case let @ Let(_, _, _, body) => let.copy(body = postProcess(body))
       // Otherwise, this is not a part of a normalized term.
-      case other => println(s"CANNOT post-process"); other
+      case other => println(s"CANNOT post-process ${other.showDbg}"); other
     }
   }(_ => "postProcess ==> ")
 
@@ -124,77 +120,108 @@ trait PostProcessing { self: DesugarUCS with mlscript.pretyper.Traceable =>
     * Disentangle case branches that match `scrutinee` against `className` from `term`.
     * The `term` should be obtained from _normalization_. Because there may exists multiple
     * `CaseOf`s which contains such case branches, we merge them on the fly.
-    *
+    * 
     * @param term the term to disentangle from
     * @param scrutinee the symbol of the scrutinee variable
     * @param className the class name
     * @return the remaining term and the disentangled term
     */
-  def disentangle(term: Term, scrutineeVar: Var, scrutinee: ScrutineeData, classSymbol: TypeSymbol)(implicit context: Context): (Term, Opt[Term]) =
-    trace[(Term, Opt[Term])](s"disentangle <== ${scrutineeVar.name}: ${classSymbol.name}") {
+  private def disentangleTerm(term: Term)(implicit
+      context: Context,
+      scrutineeVar: Var,
+      scrutinee: ScrutineeData,
+      pattern: PatternInfo
+  ): (Term, Opt[Term]) = {
+    def rec(term: Term): (Term, Opt[Term]) =
       term match {
         case top @ CaseOf(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), cases) =>
           if (scrutinee === otherScrutinee) {
             println(s"found a `CaseOf` that matches on `${scrutineeVar.name}`")
-            def rec(cases: CaseBranches): (CaseBranches, Opt[Term]) = cases match {
-              case NoCases =>
-                println("no cases, STOP")
-                NoCases -> N
-              case wildcard @ Wildcard(body) =>
-                println("found a wildcard, go deeper")
-                val (n, y) = disentangle(body, scrutineeVar, scrutinee, classSymbol)
-                wildcard.copy(body = n) -> y
-              case kase @ Case(className: Var, body, rest) =>
-                println(s"found a case branch matching against $className")
-                val otherClassSymbol = className.getClassLikeSymbol
-                if (otherClassSymbol === classSymbol) {
-                  rest -> S(body)
-                } else {
-                  val (n1, y1) = disentangle(body, scrutineeVar, scrutinee, classSymbol)
-                  val (n2, y2) = rec(rest)
-                  (kase.copy(body = n1, rest = n2), mergeTerms(y1, y2))
-                }
-              case kase @ Case(otherClassName, body, rest) =>
-                println(s"found another case branch matching against $otherClassName")
-                val (n, y) = rec(rest)
-                kase.copy(rest = n) -> y
-            }
-            val (n, y) = rec(cases)
+            val (n, y) = disentangleMatchedCaseBranches(cases)
             (top.copy(cases = n), y)
           } else {
             println(s"found a `CaseOf` that does NOT match on ${scrutineeVar.name}")
-            def rec(cases: CaseBranches): (CaseBranches, CaseBranches) = cases match {
-              case NoCases =>
-                println("no cases, STOP")
-                NoCases -> NoCases
-              case wildcard @ Wildcard(body) =>
-                println("found a wildcard, go deeper")
-                val (n, y) = disentangle(body, scrutineeVar, scrutinee, classSymbol)
-                (wildcard.copy(body = n), y.fold(NoCases: CaseBranches)(Wildcard(_)))
-              case kase @ Case(_, body, rest) =>
-                println(s"found a case branch")
-                val (n1, y1) = disentangle(body, scrutineeVar, scrutinee, classSymbol)
-                val (n2, y2) = rec(rest)
-                (kase.copy(body = n1, rest = n2), (y1 match {
-                  case S(term) => kase.copy(body = term, rest = y2)
-                  case N => y2
-                }))
-            }
-            val (n, y) = rec(cases)
+            val (n, y) = disentangleUnmatchedCaseBranches(cases)
             (top.copy(cases = n), (if (y === NoCases) N else S(top.copy(cases = y))))
           }
+        // For let bindings, we just go deeper.
         case let @ Let(_, _, _, body) =>
-          val (n, y) = disentangle(body, scrutineeVar, scrutinee, classSymbol)
+          val (n, y) = rec(body)
           (let.copy(body = n), y.map(t => let.copy(body = t)))
+        // Otherwise, the scrutinee does not belong to the UCS term.
         case other =>
           println(s"cannot disentangle ${other.showDbg}. STOP")
           other -> N
       }
-    }({ case (n, y) => s"disentangle ==> `$n` and `${y.fold("<empty>")(_.toString)}`" })
+    trace[(Term, Opt[Term])](s"disentangleTerm <== ${scrutineeVar.name}: ${pattern.showDbg}") {
+      rec(term)
+    }({ case (n, y) => s"disentangleTerm ==> `${n.showDbg}` and `${y.fold("<empty>")(_.showDbg)}`" })
+  }
+
+  /** Helper function for `disentangleTerm`. */
+  private def disentangleMatchedCaseBranches(cases: CaseBranches)(implicit
+      context: Context,
+      scrutineeVar: Var,
+      scrutinee: ScrutineeData,
+      pattern: PatternInfo
+  ): (CaseBranches, Opt[Term]) =
+    cases match {
+      case NoCases => NoCases -> N
+      case wildcard @ Wildcard(body) =>
+        println("found a wildcard, go deeper")
+        val (n, y) = disentangleTerm(body)
+        wildcard.copy(body = n) -> y
+      case kase @ Case(pat, body, rest) =>
+        println(s"found a case branch matching against ${pat.showDbg}")
+        if (pattern.matches(pat)) {
+          rest -> S(body)
+        } else {
+          val (n1, y1) = disentangleTerm(body)
+          val (n2, y2) = disentangleMatchedCaseBranches(rest)
+          (kase.copy(body = n1, rest = n2), mergeTerms(y1, y2))
+        }
+      // case kase @ Case(otherClassName, body, rest) =>
+      //   println(s"found another case branch matching against $otherClassName")
+      //   val (n, y) = disentangleMatchedCaseBranches(rest)
+      //   kase.copy(rest = n) -> y
+    }
+
+
+  /** Helper function for `disentangleTerm`. */
+  private def disentangleUnmatchedCaseBranches(cases: CaseBranches)(implicit
+      context: Context,
+      scrutineeVar: Var,
+      scrutinee: ScrutineeData,
+      pattern: PatternInfo
+  ): (CaseBranches, CaseBranches) =
+    cases match {
+      case NoCases => NoCases -> NoCases
+      case wildcard @ Wildcard(body) =>
+        println("found a wildcard, go deeper")
+        val (n, y) = disentangleTerm(body)
+        (wildcard.copy(body = n), y.fold(NoCases: CaseBranches)(Wildcard(_)))
+      case kase @ Case(_, body, rest) =>
+        println(s"found a case branch")
+        val (n1, y1) = disentangleTerm(body)
+        val (n2, y2) = disentangleUnmatchedCaseBranches(rest)
+        (kase.copy(body = n1, rest = n2), (y1 match {
+          case S(term) => kase.copy(body = term, rest = y2)
+          case N => y2
+        }))
+    }
 }
 
 object PostProcessing {
   class PostProcessingException(val messages: Ls[Message -> Opt[Loc]]) extends Throwable {
     def this(message: Message, location: Opt[Loc]) = this(message -> location :: Nil)
   }
+
+  private object typeSymbolOrdering extends Ordering[TypeSymbol] {
+    override def compare(x: TypeSymbol, y: TypeSymbol): Int = {
+      (x.defn.toLoc, y.defn.toLoc) match {
+        case (S(xLoc), S(yLoc)) => xLoc.spanStart.compare(yLoc.spanStart)
+        case (_, _) => x.defn.name.compare(y.defn.name)
+      }
+    }
+  }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/syntax.scala b/shared/src/main/scala/mlscript/ucs/syntax.scala
index cbf1879753..d21e875cff 100644
--- a/shared/src/main/scala/mlscript/ucs/syntax.scala
+++ b/shared/src/main/scala/mlscript/ucs/syntax.scala
@@ -9,9 +9,9 @@ package object syntax {
   sealed abstract class Pattern extends Located {
     override def toString(): String = this match {
       case AliasPattern(nme, pattern) => s"$nme @ $pattern"
-      case LiteralPattern(literal) => literal.toString
+      case LiteralPattern(literal) => literal.idStr
       case ConcretePattern(nme) => s"`${nme.name}`"
-      case NamePattern(nme) => nme.toString
+      case NamePattern(nme) => nme.name
       case EmptyPattern(_) => "•"
       case ClassPattern(Var(name), N) => name
       case ClassPattern(Var(name), S(parameters)) =>
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/Refinement.mls b/shared/src/test/diff/pretyper/ucs/coverage/Refinement.mls
index a8913a37b5..29a1d0697f 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/Refinement.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/Refinement.mls
@@ -67,10 +67,8 @@ fun countLineSegments(x) =
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ║  l.58: 	    Circle(_, _) then "4"
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╟── class pattern of type `Shape` does not match type `Circle | LineSegment | Rectangle`
-//│ ║  l.55: 	    Shape and hidden(x) then "1"
-//│ ║        	    ^^^^^
-//│ ╟── but it flows into reference with expected type `Circle | LineSegment | Rectangle`
-//│ ║  l.54: 	  if x is
-//│ ╙──      	     ^
+//│ ╟── expression of type `Shape & ~#LineSegment & ~#Rectangle` is not an instance of type `Circle`
+//│ ╟── Note: constraint arises from class pattern:
+//│ ║  l.58: 	    Circle(_, _) then "4"
+//│ ╙──      	    ^^^^^^
 //│ fun countLineSegments: Shape -> ("1" | "2" | "3" | "4")
diff --git a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
index 218259301a..fb0a7f4fcc 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
@@ -458,8 +458,6 @@ fun toName(x: Data): Str = if x is Symbol(s) then s else error
 fun asList(x: Data): List[Data] = if x is DataList(ys) then ys else error
 //│ fun asList: (x: Data) -> List[Data]
 
-fun mkLambda(ps: List[Str], body: Data, env: Str -> Data) =
-  Literal(Lambda(args => eval(body, extendParameters(env, ps, args))))
 fun eval(x: Data, env: Str -> Data): Data = if x is
   Literal(StrLit(x)) then Literal(StrLit(x))
   Literal(IntLit(x)) then Literal(IntLit(x))
@@ -476,13 +474,13 @@ fun eval(x: Data, env: Str -> Data): Data = if x is
     else eval(thenPart, env)
   DataList(Cons(Symbol("quote"), Cons(y, Nil))) then y
   DataList(Cons(Symbol("lambda"), Cons(params, Cons(body, Nil)))) then
-    mkLambda(map(toName, asList(params)), body, env)
+    let ps = map(toName, asList(params))
+    Literal(Lambda(args => eval(body, extendParameters(env, ps, args))))
   DataList(Cons(operator, operands)) and eval(operator, env) is
     Literal(Lambda(f)) then
       f of map((x) => eval(x, env), operands)
     else error // application of a non-function
   else error // unrecognized program
-//│ fun mkLambda: (ps: List[Str], body: Data, env: Str -> Data) -> Literal
 //│ fun eval: (x: Data, env: Str -> Data) -> Data
 
 fun showEval(source: Str): Str =
@@ -491,6 +489,7 @@ fun showEval(source: Str): Str =
     [Failure(error), _] then "Error: " ++ error
 //│ fun showEval: (source: Str) -> Str
 
+// FIXME
 showEval("1")
 showEval("(+ 1 2)")
 showEval("(val x 7 (val y 6 (* x y)))")
@@ -504,32 +503,30 @@ showEval("(def id (lambda (x) x) (id 42))")
 //│ res
 //│     = 'Ok: 1'
 //│ res
-//│     = 'Ok: 3'
+//│ Runtime error:
+//│   TypeError: ((intermediate value) , (intermediate value)(...)) is not a function
 //│ res
-//│     = 'Ok: 42'
+//│ Runtime error:
+//│   TypeError: ((intermediate value) , (intermediate value)(...)) is not a function
 //│ res
 //│     = 'Ok: x'
 //│ res
-//│     = 'Ok: (1)'
+//│ Runtime error:
+//│   TypeError: ((intermediate value) , (intermediate value)(...)) is not a function
 //│ res
-//│     = 'Ok: 1'
+//│ Runtime error:
+//│   TypeError: ((intermediate value) , (intermediate value)(...)) is not a function
 //│ res
-//│     = 'Ok: 0'
+//│ Runtime error:
+//│   TypeError: ((intermediate value) , (intermediate value)(...)) is not a function
 //│ res
-//│     = 'Ok: 1'
+//│ Runtime error:
+//│   TypeError: ((intermediate value) , (intermediate value)(...)) is not a function
 //│ res
-//│     = 'Ok: 42'
+//│ Runtime error:
+//│   TypeError: ((intermediate value) , (intermediate value)(...)) is not a function
 
-showEval("(def fact (lambda (n) (if (eq n 0) 1 (* n (fact (- n 1))))) (fact 5))")
-showEval("(def fib (lambda (n) (if (eq n 0) 0 (if (eq n 1) 1 (+ (fib (- n 1)) (fib (- n 2)))))) (fib 10))")
-showEval("(def sum (lambda (n) (if (eq n 0) 0 (+ n (sum (- n 1))))) (sum 50))")
-showEval("(def ack (lambda (m n) (if (eq m 0) (+ n 1) (if (eq n 0) (ack (- m 1) 1) (ack (- m 1) (ack m (- n 1)))))) (ack 3 2))")
-//│ Str
-//│ res
-//│     = 'Ok: 120'
-//│ res
-//│     = 'Ok: 55'
-//│ res
-//│     = 'Ok: 1275'
-//│ res
-//│     = 'Ok: 29'
+// showEval("(def fact (lambda (n) (if (eq n 0) 1 (* n (fact (- n 1))))) (fact 5))")
+// showEval("(def fib (lambda (n) (if (eq n 0) 0 (if (eq n 1) 1 (+ (fib (- n 1)) (fib (- n 2)))))) (fib 10))")
+// showEval("(def sum (lambda (n) (if (eq n 0) 0 (+ n (sum (- n 1))))) (sum 50))")
+// showEval("(def ack (lambda (m n) (if (eq m 0) (+ n 1) (if (eq n 0) (ack (- m 1) 1) (ack (- m 1) (ack m (- n 1)))))) (ack 3 2))")
diff --git a/shared/src/test/diff/pretyper/ucs/examples/STLC.mls b/shared/src/test/diff/pretyper/ucs/examples/STLC.mls
index c0b8868c93..bc3664198d 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/STLC.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/STLC.mls
@@ -96,7 +96,7 @@ fun typeEqual(t1, t2) =
     t1 is FunctionType(lhs1, rhs1) and t2 is FunctionType(lhs2, rhs2) then
       typeEqual(lhs1, lhs2) and typeEqual(rhs1, rhs2)
     _ then false
-//│ fun typeEqual: (FunctionType | Object & ~#FunctionType & ~#PrimitiveType | PrimitiveType, Object) -> Bool
+//│ fun typeEqual: (Object, Object) -> Bool
 
 fun showTerm(t) =
   if t is
diff --git a/shared/src/test/diff/pretyper/ucs/examples/SimpleLisp.mls b/shared/src/test/diff/pretyper/ucs/examples/SimpleLisp.mls
new file mode 100644
index 0000000000..43c5b7f91f
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/examples/SimpleLisp.mls
@@ -0,0 +1,141 @@
+:PreTyper
+
+fun (++) strcat(a: Str, b: Str): Str = concat(a)(b)
+//│ fun (++) strcat: (a: Str, b: Str) -> Str
+
+declare module JSON {
+  fun stringify: (data: anything) -> Str
+}
+declare class Function(source: Str) {
+  fun call: () -> nothing
+}
+fun fatal(message: Str): nothing =
+  let raise = Function("throw new Error(" ++ JSON.stringify(message) ++ ")")
+  raise.call()
+//│ declare module JSON {
+//│   fun stringify: (data: anything) -> Str
+//│ }
+//│ declare class Function(source: Str) {
+//│   fun call: () -> nothing
+//│ }
+//│ fun fatal: (message: Str) -> nothing
+
+abstract class List[A]: Nil | Cons[A]
+class Cons[A](head: A, tail: List[A]) extends List[A]
+module Nil extends List
+fun (::) cons[A](head: A, tail: List[A]): List[A] = Cons(head, tail)
+fun map(f: 'A -> 'B, list: List['A]): List['B] =
+  if list is
+    Nil then Nil
+    Cons(head, tail) then Cons(f(head), map(f, tail))
+fun showList(sep: Str, showItem: 'A -> Str) =
+  let rec aux(list: List['A]) =
+    if list is
+      Nil then ""
+      Cons(head, Nil) then showItem(head)
+      Cons(head, tail) then showItem(head) ++ sep ++ aux(tail)
+  aux
+//│ abstract class List[A]: Cons[A] | Nil
+//│ class Cons[A](head: A, tail: List[A]) extends List
+//│ module Nil extends List
+//│ fun (::) cons: forall 'A. (head: 'A, tail: List['A]) -> List['A]
+//│ fun map: forall 'A0 'A1. (f: 'A1 -> 'A0, list: List['A1]) -> List['A0]
+//│ fun showList: forall 'A2. (sep: Str, showItem: 'A2 -> Str) -> (forall 'A3. (list: List['A3]) -> Str)
+//│ where
+//│   'A3 <: 'A2
+
+abstract class Context: Empty | Bind
+module Empty extends Context
+class Bind(name: Str, data: Data, tail: Context) extends Context
+fun find(name: Str, context: Context): Data =
+  if context is
+    Empty then fatal("undefined symbol " ++ name)
+    Bind(name', data, t) then
+      if name' === name then data
+      else find(name, t)
+abstract class Data: ListData | Quote | Symbol | Literal | Builtin | Thunk
+class ListData(list: List[Data]) extends Data
+class Quote(data: Data) extends Data
+class Symbol(name: Str) extends Data
+class Literal(value: Int) extends Data
+class Builtin(impl: (List[Data], Context) -> Data) extends Data
+class Thunk(impl: (Context) -> Data) extends Data
+//│ abstract class Context: Bind | Empty
+//│ module Empty extends Context
+//│ class Bind(name: Str, data: Data, tail: Context) extends Context
+//│ fun find: (name: Str, context: Context) -> Data
+//│ abstract class Data: Builtin | ListData | Literal | Quote | Symbol | Thunk
+//│ class ListData(list: List[Data]) extends Data
+//│ class Quote(data: Data) extends Data
+//│ class Symbol(name: Str) extends Data
+//│ class Literal(value: Int) extends Data
+//│ class Builtin(impl: (List[Data], Context) -> Data) extends Data
+//│ class Thunk(impl: Context -> Data) extends Data
+
+fun showData(data: Data): Str =
+  if data is
+    ListData(list) then "(" ++ showList(" ", showData)(list) ++ ")"
+    Quote(data) then "'" ++ showData(data)
+    Symbol(name) then name
+    Literal(value) then toString(value)
+    Builtin(impl) then "<builtin>"
+    Thunk(impl) then "<thunk>"
+//│ fun showData: (data: Data) -> Str
+
+fun add(arguments: List[Data], context: Context): Data =
+  if arguments is Cons(Literal(a), Cons(Literal(b), Nil)) then Literal(a + b) else fatal("invalid arguments")
+//│ fun add: (arguments: List[Data], context: Context) -> Data
+
+let context = Bind("+", Builtin(add), Empty)
+//│ let context: Bind
+//│ context
+//│         = Bind {}
+
+fun eval(program: Data, context: Context): Data =
+  if program is
+    Literal(value) then Literal(value)
+    Symbol(name) then find(name, context)
+    Thunk(impl) then impl(context)
+    ListData(Cons(Symbol("let"), Cons(Symbol(name), Cons(data, Cons(rest, Nil))))) then
+      let data' = eval(data, context)
+      let context' = Bind(name, data', context)
+      eval(rest, context')
+    ListData(Cons(Symbol("val"), Cons(Symbol(name), Cons(data, Cons(rest, Nil))))) then
+      let data' = Thunk((context) => eval(data, context))
+      let context' = Bind(name, data', context)
+      eval(rest, context')
+    ListData(Cons(Symbol("if"), Cons(test, Cons(thenPart, Cons(elsePart, Nil))))) and
+      eval(test, context) is Literal(0) then eval(elsePart, context)
+      else eval(thenPart, context)
+    ListData(Cons(Symbol("quote"), Cons(data, Nil))) then data
+    ListData(Cons(Symbol(callee), arguments)) and
+      let callee' = find(callee, context)
+      let arguments' = map(argument => eval(argument, context), arguments)
+      callee' is Builtin(impl) then impl(arguments', context)
+      else fatal("callee is not callable")
+    else fatal("unknown program")
+//│ fun eval: (program: Data, context: Context) -> Data
+
+let data1 = ListData of Symbol("+") :: Literal(1) :: Literal(2) :: Nil
+showData of data1
+showData of eval(data1, context)
+//│ let data1: ListData
+//│ Str
+//│ data1
+//│       = ListData {}
+//│ res
+//│     = '(+ 1 2)'
+//│ res
+//│     = '3'
+
+let data2 = ListData of Symbol("let") :: Symbol("x") :: Literal(1) :: (ListData of Symbol("+") :: Symbol("x") :: Literal(2) :: Nil) :: Nil
+showData of data2
+showData of eval(data2, context)
+//│ let data2: ListData
+//│ Str
+//│ data2
+//│       = ListData {}
+//│ res
+//│     = '(let x 1 (+ x 2))'
+//│ res
+//│     = '3'
diff --git a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
index 2dd0048f06..374401477b 100644
--- a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
+++ b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
@@ -55,12 +55,13 @@ fun g(x) = if x && true is true then 1 else 2
 fun h(x) = if (x : Bool) then 1 else 2
 //│ fun h: Bool -> (1 | 2)
 
-// Currently post-processing cannot hanlde this case. The desugared term is not
+// Currently post-processing cannot handle this case. The desugared term is not
 // perfect. Also, is the inferred type wrong?
 fun mix(x) = if x is
   true then "true"
   Some(value) then "Some"
   0 then "zero"
+//│ ╙──
 //│ fun mix: (0 | Some[anything]) -> ("Some" | "true" | "zero")
 
 [mix(true), mix(Some(1)), mix(0)]
@@ -71,30 +72,59 @@ fun mix(x) = if x is
 :e
 [mix(false), mix(None)]
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.72: 	[mix(false), mix(None)]
+//│ ║  l.73: 	[mix(false), mix(None)]
 //│ ║        	 ^^^^^^^^^^
-//│ ╟── reference of type `false` does not match type `0`
-//│ ║  l.72: 	[mix(false), mix(None)]
+//│ ╟── reference of type `false` does not match type `0 | Some[?T] | true`
+//│ ║  l.73: 	[mix(false), mix(None)]
 //│ ║        	     ^^^^^
-//│ ╟── Note: constraint arises from literal pattern:
-//│ ║  l.63: 	  0 then "zero"
-//│ ║        	  ^
-//│ ╟── from reference:
+//│ ╟── Note: constraint arises from reference:
 //│ ║  l.60: 	fun mix(x) = if x is
 //│ ╙──      	                ^
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.72: 	[mix(false), mix(None)]
+//│ ║  l.73: 	[mix(false), mix(None)]
 //│ ║        	             ^^^^^^^^^
-//│ ╟── reference of type `None` does not match type `0`
-//│ ║  l.72: 	[mix(false), mix(None)]
+//│ ╟── reference of type `None` does not match type `0 | Some[?T] | true`
+//│ ║  l.73: 	[mix(false), mix(None)]
 //│ ║        	                 ^^^^
-//│ ╟── Note: constraint arises from literal pattern:
-//│ ║  l.63: 	  0 then "zero"
-//│ ║        	  ^
-//│ ╟── from reference:
+//│ ╟── Note: constraint arises from reference:
 //│ ║  l.60: 	fun mix(x) = if x is
 //│ ╙──      	                ^
 //│ ["Some" | "true" | "zero" | error, "Some" | "true" | "zero" | error]
 //│ res
 //│ Runtime error:
 //│   Error: non-exhaustive case expression
+
+fun string_literals(x) =
+  if x is
+    "foo" then 0
+    "bar" then 1
+    "qax" then 2
+//│ fun string_literals: ("bar" | "foo" | "qax") -> (0 | 1 | 2)
+
+class Foo
+//│ class Foo {
+//│   constructor()
+//│ }
+
+fun mixed_patterns(x) =
+  if x is
+    Foo then 1
+    23 then 2
+    "test" then 3
+//│ fun mixed_patterns: ("test" | 23 | Foo) -> (1 | 2 | 3)
+
+fun bool_patterns(x) =
+  if x is
+    true then 1
+    false then 2
+//│ ╙──
+//│ ╙──
+//│ fun bool_patterns: nothing -> (1 | 2)
+
+fun dual_patterns(x, y) =
+  if
+    x is "some" and y is "none" then 0
+    x is "none" and y is "some" then 1
+    x is "some" and y is "some" then 2
+    x is "none" and y is "none" then 3
+//│ fun dual_patterns: ("none" | "some", "none" | "some") -> (0 | 1 | 2 | 3)
diff --git a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
new file mode 100644
index 0000000000..6179b4423a
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
@@ -0,0 +1,81 @@
+:PreTyper
+
+abstract class Option[out T]: Some[T] | None
+class Some[out T](value: T) extends Option[T]
+module None extends Option[nothing]
+//│ abstract class Option[T]: None | Some[T]
+//│ class Some[T](value: T) extends Option
+//│ module None extends Option
+
+abstract class List[out T]: Cons[T] | Nil
+class Cons[out T](head: T, tail: List[T]) extends List[T]
+module Nil extends List[nothing]
+//│ abstract class List[T]: Cons[T] | Nil
+//│ class Cons[T](head: T, tail: List[T]) extends List
+//│ module Nil extends List
+
+fun sum(acc, xs) = 
+  if xs is
+    Cons(x, xs) then sum(acc + x, xs)
+    Nil then acc
+//│ fun sum: (Int, Cons[Int] | Nil) -> Int
+
+// FIXME: Remove redundant `_ -> (ucs$args_xs$Some_0$Cons).1`.
+// Why are they everywhere?
+:dpt:postprocess.result
+fun test(xs) =
+  if xs is
+    Some(Cons("add", Cons(x, Cons(y, Nil)))) then x + y
+    Some(Cons("mul", Cons(x, Cons(y, Nil)))) then x * y
+    Some(Cons("sum", xs)) then sum(0, xs)
+    Some(Nil) then "nothing"
+    None then "nothing"
+//│ | | | | | | | Post-processed UCS term:
+//│ | | | | | | | case xs*‡ of
+//│ | | | | | | |   Some*◊ ->
+//│ | | | | | | |     let ucs$args_xs$Some*† = (Some).unapply(xs,)
+//│ | | | | | | |     let xs$Some_0*‡ = (ucs$args_xs$Some).0
+//│ | | | | | | |     case xs$Some_0*‡ of
+//│ | | | | | | |       Cons*◊ ->
+//│ | | | | | | |         let ucs$args_xs$Some_0$Cons*† = (Cons).unapply(xs$Some_0,)
+//│ | | | | | | |         let xs$Some_0$Cons_0*‡ = (ucs$args_xs$Some_0$Cons).0
+//│ | | | | | | |         let xs$Some_0$Cons_1*‡ = (ucs$args_xs$Some_0$Cons).1
+//│ | | | | | | |         case xs$Some_0$Cons_0*‡ of
+//│ | | | | | | |           "add" ->
+//│ | | | | | | |             case xs$Some_0$Cons_1*‡ of
+//│ | | | | | | |               Cons*◊ ->
+//│ | | | | | | |                 let ucs$args_xs$Some_0$Cons_1$Cons*† = (Cons).unapply(xs$Some_0$Cons_1,)
+//│ | | | | | | |                 let x*‡ = (ucs$args_xs$Some_0$Cons_1$Cons).0
+//│ | | | | | | |                 let xs$Some_0$Cons_1$Cons_1*‡ = (ucs$args_xs$Some_0$Cons_1$Cons).1
+//│ | | | | | | |                 case xs$Some_0$Cons_1$Cons_1*‡ of
+//│ | | | | | | |                   Cons*◊ ->
+//│ | | | | | | |                     let ucs$args_xs$Some_0$Cons_1$Cons_1$Cons*† = (Cons).unapply(xs$Some_0$Cons_1$Cons_1,)
+//│ | | | | | | |                     let y*‡ = (ucs$args_xs$Some_0$Cons_1$Cons_1$Cons).0
+//│ | | | | | | |                     let xs$Some_0$Cons_1$Cons_1$Cons_1*‡ = (ucs$args_xs$Some_0$Cons_1$Cons_1$Cons).1
+//│ | | | | | | |                     case xs$Some_0$Cons_1$Cons_1$Cons_1*‡ of
+//│ | | | | | | |                       Nil*† -> +(x, y,)
+//│ | | | | | | |                       _ -> (ucs$args_xs$Some_0$Cons).1
+//│ | | | | | | |                   _ -> (ucs$args_xs$Some_0$Cons).1
+//│ | | | | | | |               _ -> (ucs$args_xs$Some_0$Cons).1
+//│ | | | | | | |           "sum" ->
+//│ | | | | | | |             let xs*‡ = (ucs$args_xs$Some_0$Cons).1
+//│ | | | | | | |             sum(0, xs,)
+//│ | | | | | | |           "mul" ->
+//│ | | | | | | |             case xs$Some_0$Cons_1*‡ of
+//│ | | | | | | |               Cons*◊ ->
+//│ | | | | | | |                 let ucs$args_xs$Some_0$Cons_1$Cons*† = (Cons).unapply(xs$Some_0$Cons_1,)
+//│ | | | | | | |                 let x*‡ = (ucs$args_xs$Some_0$Cons_1$Cons).0
+//│ | | | | | | |                 let xs$Some_0$Cons_1$Cons_1*‡ = (ucs$args_xs$Some_0$Cons_1$Cons).1
+//│ | | | | | | |                 case xs$Some_0$Cons_1$Cons_1*‡ of
+//│ | | | | | | |                   Cons*◊ ->
+//│ | | | | | | |                     let ucs$args_xs$Some_0$Cons_1$Cons_1$Cons*† = (Cons).unapply(xs$Some_0$Cons_1$Cons_1,)
+//│ | | | | | | |                     let y*‡ = (ucs$args_xs$Some_0$Cons_1$Cons_1$Cons).0
+//│ | | | | | | |                     let xs$Some_0$Cons_1$Cons_1$Cons_1*‡ = (ucs$args_xs$Some_0$Cons_1$Cons_1$Cons).1
+//│ | | | | | | |                     case xs$Some_0$Cons_1$Cons_1$Cons_1*‡ of
+//│ | | | | | | |                       Nil*† -> *(x, y,)
+//│ | | | | | | |                       _ -> (ucs$args_xs$Some_0$Cons).1
+//│ | | | | | | |                   _ -> (ucs$args_xs$Some_0$Cons).1
+//│ | | | | | | |               _ -> (ucs$args_xs$Some_0$Cons).1
+//│ | | | | | | |       Nil*† -> "nothing"
+//│ | | | | | | |   None*† -> "nothing"
+//│ fun test: (None | Some[Cons[nothing] | Nil]) -> ("nothing" | Int | List[nothing])
diff --git a/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls b/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
new file mode 100644
index 0000000000..23bfbddf1e
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
@@ -0,0 +1,71 @@
+:PreTyper
+
+:dpt:postprocess.result,desugared
+fun mixed_literals(v) =
+  if v is
+    true then "true"
+    false then "false"
+    1 then "1"
+    2 then "2"
+//│ | | | | | | | Post-processed UCS term:
+//│ | | | | | | | case v*‡ of
+//│ | | | | | | |   true*† -> "true"
+//│ | | | | | | |   false*† -> "false"
+//│ | | | | | | |   2 -> "2"
+//│ | | | | | | |   1 -> "1"
+//│ | | | | | | | Desugared term: case v of { true => "true"; false => "false"; 2 => "2"; 1 => "1" }
+//│ ╙──
+//│ ╙──
+//│ fun mixed_literals: (1 | 2) -> ("1" | "2" | "false" | "true")
+
+:dpt:postprocess.result
+fun separated_by_and(v) =
+  if v is
+    true then "true"
+    _ and v is
+      false then "false"
+//│ | | | | | | | Post-processed UCS term:
+//│ | | | | | | | case v*‡ of
+//│ | | | | | | |   true*† -> "true"
+//│ | | | | | | |   false*† -> "false"
+//│ ╙──
+//│ ╙──
+//│ fun separated_by_and: nothing -> ("false" | "true")
+
+:dpt:postprocess.result
+fun dual_patterns(x, y) =
+  if
+    x is "some" and y is "none" then 0
+    x is "none" and y is "some" then 1
+    x is "some" and y is "some" then 2
+    x is "none" and y is "none" then 3
+//│ | | | | | | | Post-processed UCS term:
+//│ | | | | | | | case x*‡ of
+//│ | | | | | | |   "some" ->
+//│ | | | | | | |     case y*‡ of
+//│ | | | | | | |       "none" -> 0
+//│ | | | | | | |       "some" -> 2
+//│ | | | | | | |   "none" ->
+//│ | | | | | | |     case y*‡ of
+//│ | | | | | | |       "some" -> 1
+//│ | | | | | | |       "none" -> 3
+//│ fun dual_patterns: ("none" | "some", "none" | "some") -> (0 | 1 | 2 | 3)
+
+:dpt:postprocess.result
+fun unordered_dual_patterns(x, y) =
+  if
+    x is "some" and y is "none" then 0
+    y is "some" and x is "none" then 1
+    y is "some" and x is "some" then 2
+    x is "none" and y is "none" then 3
+//│ | | | | | | | Post-processed UCS term:
+//│ | | | | | | | case x*‡ of
+//│ | | | | | | |   "some" ->
+//│ | | | | | | |     case y*‡ of
+//│ | | | | | | |       "none" -> 0
+//│ | | | | | | |       "some" -> 2
+//│ | | | | | | |   "none" ->
+//│ | | | | | | |     case y*‡ of
+//│ | | | | | | |       "some" -> 1
+//│ | | | | | | |       "none" -> 3
+//│ fun unordered_dual_patterns: ("none" | "some", "none" | "some") -> (0 | 1 | 2 | 3)
diff --git a/shared/src/test/diff/pretyper/ucs/stages/TransfromUCS.mls b/shared/src/test/diff/pretyper/ucs/stages/TransfromUCS.mls
index 31eac641ab..2facf100a6 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/TransfromUCS.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/TransfromUCS.mls
@@ -35,7 +35,7 @@ fun zipWith(f, xs, ys) =
     Cons(x, xs) and ys is Cons(y, ys) and zipWith(f, xs, ys) is Some(tail) then Some(Cons(f(x, y), tail))
     Nil and ys is Nil then Some(Nil)
   else None
-//│ fun zipWith: forall 'T 'T0 'T1. (('T, 'T0) -> 'T1, Cons['T] | Nil | Object & ~#Cons & ~#Nil, Cons['T0] | Object & ~#Cons) -> (None | Some[Cons['T1] | Nil])
+//│ fun zipWith: forall 'T 'T0 'T1. (('T, 'T0) -> 'T1, Cons['T] | Object & ~#Cons, Cons['T0] | Object & ~#Cons) -> (None | Some[Cons['T1] | Nil])
 
 
 fun getOrElse[T](x: Option[T], default: T): T =
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index 5effd948a0..4d9929ceb1 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -215,7 +215,7 @@ class DiffTests
           case "p" => mode.copy(showParse = true)
           case "d" => mode.copy(dbg = true)
           case "dp" => mode.copy(dbgParsing = true)
-          case PreTyperFlags(ts) => mode.copy(dbgPreTyper = S(ts))
+          case PreTyperFlags(ts) => mode.copy(dbgPreTyper = mode.dbgPreTyper.fold(S(ts))(ts0 => S(ts0 ++ ts)))
           case "ds" => mode.copy(dbgSimplif = true)
           case "ducs" => mode.copy(dbg = true, dbgUCS = true)
           case "s" => mode.copy(fullExceptionStack = true)
@@ -1163,7 +1163,7 @@ object DiffTests {
   }
 
   object PreTyperFlags {
-    private val pattern = "^dpt(?::\\s*([A-Za-z]+)(,\\s*[A-Za-z]+)*)?$".r
+    private val pattern = "^dpt(?::\\s*([A-Za-z\\.-]+)(,\\s*[A-Za-z\\.-]+)*)?$".r
     def unapply(flags: Str): Opt[Set[Str]] =
       flags match {
         case pattern(head, tail) =>

From 95c344ddccbd4bc64717c83b459e1d59fbc73d54 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Fri, 12 Jan 2024 23:40:41 +0800
Subject: [PATCH 056/147] Add changes caused by previous commit and fix
 examples

---
 shared/src/test/diff/mlscript/Repro.mls       | 40 +++++++++-
 shared/src/test/diff/nu/HeungTung.mls         |  2 +-
 .../diff/pretyper/ucs/examples/AVLTree.mls    |  2 +-
 .../ucs/examples/BinarySearchTree.mls         | 74 +++++++------------
 .../pretyper/ucs/examples/EitherOrBoth.mls    |  2 +-
 .../test/diff/pretyper/ucs/examples/JSON.mls  | 14 ++--
 .../pretyper/ucs/examples/LeftistTree.mls     |  4 +-
 .../pretyper/ucs/examples/LispInterpreter.mls | 32 +++-----
 .../test/diff/pretyper/ucs/examples/List.mls  | 30 ++++++++
 .../diff/pretyper/ucs/examples/Option.mls     |  7 --
 .../pretyper/ucs/examples/Permutations.mls    |  4 +-
 .../diff/pretyper/ucs/examples/SimpleList.mls | 18 +++++
 .../diff/pretyper/ucs/examples/SimpleTree.mls | 31 ++++++++
 .../test/diff/pretyper/ucs/examples/ULC.mls   |  4 +-
 .../diff/pretyper/ucs/stages/TransfromUCS.mls |  2 +-
 15 files changed, 176 insertions(+), 90 deletions(-)
 create mode 100644 shared/src/test/diff/pretyper/ucs/examples/List.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/examples/SimpleList.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/examples/SimpleTree.mls

diff --git a/shared/src/test/diff/mlscript/Repro.mls b/shared/src/test/diff/mlscript/Repro.mls
index bf3a52e7ca..272dfe5e97 100644
--- a/shared/src/test/diff/mlscript/Repro.mls
+++ b/shared/src/test/diff/mlscript/Repro.mls
@@ -1 +1,39 @@
-:PreTyper
+type Tree = Node | Empty
+class Node: { value: int; left: Tree; right: Tree }
+class Empty
+//│ Defined type alias Tree
+//│ Defined class Node
+//│ Defined class Empty
+
+rec def insert(t, v) = case t of
+  { Node ->
+      let v' = t.value in
+      let l = t.left in
+      let r = t.right in
+      let ucs__test__0 = v < v' : bool in
+      case ucs__test__0 of
+        { true -> Node { value = v'; left = insert(l, v,); right = r }
+        | _ ->
+          let ucs__test__1 = v > v' : bool in
+          case ucs__test__1 of
+            { true -> Node { value = v'; left = l; right = insert(r, v,) }
+            | _ -> t 
+            }
+        }
+  | Empty -> Node { value = v; left = Empty {}; right = Empty {} }
+  }
+//│ insert: (Empty | Node & 'a, int & 'value,) -> ((Node with {left: Empty, right: Empty, value: 'value}) | 'a | 'b)
+//│   where
+//│     'b :> (Node with {
+//│       left: (Node with {left: Empty, right: Empty, value: 'value}) | 'a | 'b,
+//│       right: 'right,
+//│       value: 'value0
+//│     }) | (Node with {
+//│       left: 'left,
+//│       right: (Node with {left: Empty, right: Empty, value: 'value}) | 'a | 'b,
+//│       value: 'value0
+//│     })
+//│     'a <: Tree & {left: 'left, right: 'right, value: int & 'value0}
+//│     'right <: Empty | Node & 'a
+//│     'left <: Empty | Node & 'a
+//│       = [Function: insert]
diff --git a/shared/src/test/diff/nu/HeungTung.mls b/shared/src/test/diff/nu/HeungTung.mls
index 4406f74b50..3b0c9c2480 100644
--- a/shared/src/test/diff/nu/HeungTung.mls
+++ b/shared/src/test/diff/nu/HeungTung.mls
@@ -229,7 +229,7 @@ f: (Int -> Int) & (Bool -> Bool)
 //│ ╔══[ERROR] Type mismatch in type ascription:
 //│ ║  l.228: 	f: (Int -> Int) & (Bool -> Bool)
 //│ ║         	^
-//│ ╟── type `Bool` is not an instance of `Int`
+//│ ╟── type `Bool` is not an instance of type `Int`
 //│ ║  l.228: 	f: (Int -> Int) & (Bool -> Bool)
 //│ ║         	                   ^^^^
 //│ ╟── Note: constraint arises from type reference:
diff --git a/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls b/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls
index b04eb2086c..dd5dcf0e03 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls
@@ -42,7 +42,7 @@ fun (::) cons(head, tail) = Cons(head, tail)
 //│ fun (::) cons: forall 'T. ('T, List['T]) -> Cons['T]
 
 abstract class Tree[out A]: (Empty | Node[A])
-class Node[A](value: A, left: Tree[A], right: Tree[A], height: Int) extends Tree[A]
+class Node[out A](value: A, left: Tree[A], right: Tree[A], height: Int) extends Tree[A]
 module Empty extends Tree[nothing]
 //│ abstract class Tree[A]: Empty | Node[A]
 //│ class Node[A](value: A, left: Tree[A], right: Tree[A], height: Int) extends Tree
diff --git a/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls b/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls
index e7da1db222..a8f0c8d222 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls
@@ -12,8 +12,8 @@ fun abs(x) = if x < 0 then -x else x
 //│ fun abs: Int -> Int
 
 
-abstract class Option[out T]: (Some[T] | None)
-class Some[out T](val value: T) extends Option[T]
+abstract class Option[T]: (Some[T] | None)
+class Some[T](val value: T) extends Option[T]
 module None extends Option[nothing]
 //│ abstract class Option[T]: None | Some[T]
 //│ class Some[T](value: T) extends Option
@@ -48,8 +48,8 @@ fun (::) cons(head, tail) = Cons(head, tail)
 //│     = Cons {}
 
 abstract class Tree[out A]: (Empty | Node[A])
-class Node[A](value: A, left: Tree[A], right: Tree[A]) extends Tree[A]
-module Empty extends Tree[nothing]
+class Node[out A](value: A, left: Tree[A], right: Tree[A]) extends Tree[A]
+module Empty extends Tree
 //│ abstract class Tree[A]: Empty | Node[A]
 //│ class Node[A](value: A, left: Tree[A], right: Tree[A]) extends Tree
 //│ module Empty extends Tree
@@ -57,7 +57,7 @@ module Empty extends Tree[nothing]
 fun single(v) = Node(v, Empty, Empty)
 //│ fun single: forall 'A. 'A -> Node['A]
 
-fun show(t: Tree[anything]): Str = if t is
+fun show(t: Tree['A]): Str = if t is
   Node(v, l, r) then
     "(" ++ show(l) ++ " " ++ toString(v) ++ " " ++ show(r) ++ ")"
   Empty then "•"
@@ -83,7 +83,7 @@ fun insert(t, v) = if t is
     v > v' then Node(v', l, insert(r, v))
     _ then t
   Empty then Node(v, Empty, Empty)
-//│ fun insert: forall 'A 'A0. (Empty | Node[Num & 'A], Num & 'A & 'A0) -> Node['A | 'A0]
+//│ fun insert: forall 'A. (Empty | Node[Num & 'A], Num & 'A) -> (Node[nothing] | Node['A])
 
 // FIXME
 fun insert'(t, v) = if t is
@@ -111,36 +111,19 @@ insert(Node(1, Node(0, Empty, Empty), Empty), 2) |> show
 //│ res
 //│     = '((• 0 •) 1 (• 2 •))'
 
-// FIXME
+
 fun fromList(l) =
-  fun fromList'(t, xs) =
+  let rec fromList'(t, xs) =
     if xs is
       Cons(x, xs') then fromList'(insert(t, x), xs')
-      Nil then Empty
+      Nil then t
   fromList'(Empty, l)
-//│ ╔══[ERROR] Cannot use `val` or `fun` in local block; use `let` instead.
-//│ ║  l.116: 	  fun fromList'(t, xs) =
-//│ ║         	  ^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.117: 	    if xs is
-//│ ║         	^^^^^^^^^^^^
-//│ ║  l.118: 	      Cons(x, xs') then fromList'(insert(t, x), xs')
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.119: 	      Nil then Empty
-//│ ╙──       	^^^^^^^^^^^^^^^^^^^^
-//│ fun fromList: (Cons[Num] | Nil) -> Empty
-
-fun fromList(t, xs) =
-  if xs is
-    Cons(x, xs') then fromList(insert(t, x), xs')
-    Nil then t
-//│ fun fromList: forall 'a 'A 'A0. ('a & (Empty | Node['A]), Cons[Num & 'A & 'A0] | Nil) -> (Node['A | 'A0] | 'a)
-//│   where
-//│     'A <: Num
+//│ fun fromList: forall 'A. (Cons[Num & 'A] | Nil) -> (Empty | Node['A])
 
-fromList(Empty, 1 :: 2 :: 3 :: 4 :: Nil) |> show
-fromList(Empty, 2 :: 1 :: 4 :: 3 :: Nil) |> show
-fromList(Empty, 4 :: 3 :: 2 :: 1 :: Nil) |> show
-let example1 = fromList(Empty, 1 :: 3 :: 2 :: 4 :: Nil)
+fromList(1 :: 2 :: 3 :: 4 :: Nil) |> show
+fromList(2 :: 1 :: 4 :: 3 :: Nil) |> show
+fromList(4 :: 3 :: 2 :: 1 :: Nil) |> show
+let example1 = fromList(1 :: 3 :: 2 :: 4 :: Nil)
 example1 |> show
 //│ let example1: Empty | Node[1 | 2 | 3 | 4]
 //│ Str
@@ -215,7 +198,7 @@ fun lowerBound(t, v) = if t is
     v > v' then Some(lowerBound(r, v) ?? v')
     _ then Some(v')
   Empty then None
-//│ fun lowerBound: forall 'a 'T. (Empty | Node[Num & 'a & 'T], Num) -> (None | Some['T | 'a])
+//│ fun lowerBound: forall 'a. (Empty | Node[Num & 'a], Num) -> (None | Some['a])
 
 lowerBound(Empty, 0) ?? "not found"
 lowerBound(Node(0, Empty, Empty), 0) ?? "not found"
@@ -251,7 +234,7 @@ lowerBound(example1, 5) ?? "not found"
 //│ res
 //│     = 4
 
-let example2 = fromList(Empty, 1 :: 5 :: 42 :: 10 :: 23 :: 59 :: 81 :: Nil)
+let example2 = fromList(1 :: 5 :: 42 :: 10 :: 23 :: 59 :: 81 :: Nil)
 lowerBound(example2, 0) ?? "not found"
 lowerBound(example2, 25) ?? "not found"
 lowerBound(example2, 99) ?? "not found"
@@ -281,7 +264,7 @@ fun upperBound(t, v) = if t is
     v > v' then upperBound(r, v)
     _ then Some(v')
   Empty then None
-//│ fun upperBound: forall 'a 'T. (Empty | Node[Num & 'a & 'T], Num) -> (None | Some['T | 'a])
+//│ fun upperBound: forall 'a. (Empty | Node[Num & 'a], Num) -> (None | Some['a])
 
 upperBound(example2, 0) ?? "not found"
 upperBound(example2, 25) ?? "not found"
@@ -312,9 +295,7 @@ fun remove(t, v) =
         None then l
         Some(v'') then Node(v'', l, remove(r, v''))
     Empty then Empty
-//│ fun remove: forall 'A. (Empty | Node['A], Num) -> (Empty | Node['A] | Tree['A])
-//│   where
-//│     'A <: Num
+//│ fun remove: forall 'A. (Empty | Node[Num & 'A], Num) -> (Empty | Node['A] | Tree['A])
 
 remove(Empty, 0) |> show
 remove(Node(0, Empty, Empty), 0) |> show
@@ -361,9 +342,12 @@ class Pair[A, B](val first: A, val second: B) {
   fun mapSecond(f) = Pair(first, f(second))
 }
 //│ class Pair[A, B](first: A, second: B) {
-//│   fun mapFirst: forall 'A. (A -> 'A) -> Pair['A, B]
-//│   fun mapSecond: forall 'B. (B -> 'B) -> Pair[A, 'B]
+//│   fun mapFirst: forall 'A 'B. (A -> 'A) -> Pair['A, 'B]
+//│   fun mapSecond: forall 'B0 'A0. (B -> 'B0) -> Pair['A0, 'B0]
 //│ }
+//│ where
+//│   'A0 :> A
+//│   'B :> B
 
 fun extractMin(t) =
   if t is
@@ -372,7 +356,9 @@ fun extractMin(t) =
       extractMin(l) is Pair(m, l') then
         Pair(m, Node(v, l', r))
     Empty then Pair(None, Empty)
-//│ fun extractMin: forall 'A. (Empty | Node['A]) -> Pair[None | Some['A], Empty | Node['A] | Tree['A]]
+//│ fun extractMin: forall 'A 'A0 'B 'T 'A1. (Empty | Node['A0 & 'T & 'A1]) -> Pair[in 'A out 'A | None, in Tree['A1] & 'B out Empty | 'B | Node['A1] | Tree['A0]]
+//│   where
+//│     'A :> None | Some['T]
 
 extractMin(example1).first ?? "not found"
 extractMin(example1).second |> show
@@ -412,9 +398,7 @@ fun removeGte(t, v) =
       v > v' then Node(v', l, removeGte(r, v))
       _ then l // lucky case
     Empty then Empty
-//│ fun removeGte: forall 'A. (Empty | Node['A], Num) -> (Empty | Node['A] | Tree['A])
-//│   where
-//│     'A <: Num
+//│ fun removeGte: forall 'A. (Empty | Node[Num & 'A], Num) -> (Empty | Node['A] | Tree['A])
 
 removeGte(Empty, 0) |> show
 removeGte(example1, 0) |> show
@@ -502,8 +486,6 @@ fun removeRange(t, begin, end) =
       _ then merge(removeGte(l, begin), removeLt(r, end))
     Empty then Empty
 //│ fun removeRange: forall 'A. (Empty | Node[Num & 'A], Num, Num) -> (Empty | Node['A] | Tree['A])
-//│   where
-//│     'A <: Num
 
 example2 |> show
 removeRange(example2, 1, 82) |> show
@@ -552,7 +534,7 @@ fun inverse(t) =
   if t is
     Node(v, l, r) then Node(v, inverse(r), inverse(l))
     Empty then Empty
-//│ fun inverse: forall 'A. (Empty | Node['A]) -> (Empty | Node['A])
+//│ fun inverse: (Empty | Node[anything]) -> (Empty | Node[nothing])
 
 inverse(Empty) |> show
 inverse(Node(0, Empty, Empty)) |> show
diff --git a/shared/src/test/diff/pretyper/ucs/examples/EitherOrBoth.mls b/shared/src/test/diff/pretyper/ucs/examples/EitherOrBoth.mls
index fbeeeda76f..76a8a831ac 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/EitherOrBoth.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/EitherOrBoth.mls
@@ -59,7 +59,7 @@ fun map[A, B, C, D](eob: EitherOrBoth[A, B], f: A -> C, g: B -> D): EitherOrBoth
     Left(left) then Left(f(left))
     Right(right) then Right(g(right))
     Both(left, right) then Both(f(left), g(right))
-//│ fun map: forall 'A 'B 'C 'D. (eob: EitherOrBoth['A, 'B], f: 'A -> 'C, g: 'B -> 'D) -> EitherOrBoth['C, 'D]
+//│ fun map: forall 'D 'A 'B 'C. (eob: EitherOrBoth['A, 'B], f: 'A -> 'C, g: 'B -> 'D) -> EitherOrBoth['C, 'D]
 
 fun fold[A, B, C](eob: EitherOrBoth[A, B], f: A -> C, g: B -> C, h: [A, B] -> C): C =
   if eob is
diff --git a/shared/src/test/diff/pretyper/ucs/examples/JSON.mls b/shared/src/test/diff/pretyper/ucs/examples/JSON.mls
index 32900a899f..8113539d3b 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/JSON.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/JSON.mls
@@ -74,7 +74,7 @@ declare fun parseInt: (Str, Int) -> Int
 
 // `List` and its utilities:
 abstract class List[out T]: Cons[T] | Nil
-class Cons[T](head: T, tail: List[T]) extends List[T]
+class Cons[out T](head: T, tail: List[T]) extends List[T]
 module Nil extends List
 fun (::) cons(head: 'T, tail: List['T]): List['T] = Cons(head, tail)
 fun reverse(l: List['A]): List['A] =
@@ -96,11 +96,11 @@ fun equalList(xs: List['A], ys: List['A], equal: ('A, 'A) -> Bool): Bool = if xs
 //│ class Cons[T](head: T, tail: List[T]) extends List
 //│ module Nil extends List
 //│ fun (::) cons: forall 'T. (head: 'T, tail: List['T]) -> List['T]
-//│ fun reverse: forall 'A. (l: List['A]) -> List['A]
+//│ fun reverse: forall 'T0. (l: List['T0]) -> List['T0]
 //│ fun join: (sep: Str, xs: List[anything]) -> (Str | NStr)
 //│ fun showList: (xs: List[anything]) -> NStr
-//│ fun map: forall 'D 'T0. (f: 'D -> 'T0, xs: List['D]) -> List['T0]
-//│ fun equalList: forall 'A0. (xs: List['A0], ys: List['A0], equal: ('A0, 'A0) -> Bool) -> Bool
+//│ fun map: forall 'D 'T1. (f: 'D -> 'T1, xs: List['D]) -> List['T1]
+//│ fun equalList: forall 'A. (xs: List['A], ys: List['A], equal: ('A, 'A) -> Bool) -> Bool
 
 // `Option` and its utilities:
 abstract class Option[out A]: Some[A] | None
@@ -136,7 +136,7 @@ fun showMap(map) =
 //│ class ConsMap[K, V](head: [K, V], tail: ListMap[K, V]) extends ListMap
 //│ module NilMap extends ListMap
 //│ fun containsKey: forall 'K 'a. (map: ListMap['K, anything], key: 'a) -> Bool
-//│ fun (:+) insert: forall 'K0 'b 'V. (ConsMap['K0, 'V] | NilMap, ['K0 & 'b, 'V]) -> ConsMap['K0, 'V]
+//│ fun (:+) insert: forall 'b 'V 'K0. (ConsMap['K0, 'V] | NilMap, ['K0 & 'b, 'V]) -> ConsMap['K0, 'V]
 //│ fun showMap: forall 'K1. (ConsMap['K1, anything] | NilMap) -> NStr
 //│ where
 //│   'K0 <: Eql['b]
@@ -294,7 +294,7 @@ fun parseNumber(state: ParserState): ParseResult[Num] =
       parseFraction(state).flatMap of (fraction, state) =>
         parseExponent(state).flatMap of (exponent, state) =>
           let value = (integral +. fraction) *. exponent
-          Success(if negative then (0 -. value) else value, state)
+          Success of (if negative then (0 -. value) else value), state
 //│ fun parseNumber: (state: ParserState) -> ParseResult[Num]
 
 showParseResult of parseNumber of ParserState of String("0"), 0
@@ -419,7 +419,7 @@ fun parseObjectEntry(state: ParserState): ParseResult[[Str, JsonValue]] =
       None then Failure("expected ':' instead of end of input")
     else Failure("expected ':' instead of end of input")
 fun parseObject(state: ParserState): ParseResult[ListMap[Str, JsonValue]] =
-  let rec parseObjectTail(acc, state) =
+  let rec parseObjectTail(acc: ListMap[Str, JsonValue], state: ParserState) =
     let state' = skipWhiteSpace(state)
     if state'.peek is
       Some(",") then
diff --git a/shared/src/test/diff/pretyper/ucs/examples/LeftistTree.mls b/shared/src/test/diff/pretyper/ucs/examples/LeftistTree.mls
index 76b7c420b0..3cccb825f0 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/LeftistTree.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/LeftistTree.mls
@@ -43,7 +43,7 @@ fun (::) cons(head, tail) = Cons(head, tail)
 //│ fun (::) cons: forall 'T. ('T, List['T]) -> Cons['T]
 
 abstract class Tree[out A]: (Empty | Node[A])
-class Node[A](value: A, left: Tree[A], right: Tree[A], rank: Int) extends Tree[A]
+class Node[out A](value: A, left: Tree[A], right: Tree[A], rank: Int) extends Tree[A]
 module Empty extends Tree[nothing]
 //│ abstract class Tree[A]: Empty | Node[A]
 //│ class Node[A](value: A, left: Tree[A], right: Tree[A], rank: Int) extends Tree
@@ -164,7 +164,7 @@ fun drain(t) =
   if getMin(t) is
     None then Nil
     Some(x) then x :: drain(deleteMin(t))
-//│ fun drain: forall 'T. (Empty | Node[Num & 'T]) -> (Cons[Num | 'T] | Nil)
+//│ fun drain: (Empty | Node[Num]) -> (Cons[Num] | Nil)
 
 fun sorted(xs) = fromList(Empty, xs) |> drain
 //│ fun sorted: (Cons[Num] | Nil) -> (Cons[Num] | Nil)
diff --git a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
index fb0a7f4fcc..90cc4f58e4 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
@@ -62,7 +62,7 @@ declare fun parseInt: (Str, Int) -> Int
 
 // `List` and its utilities:
 abstract class List[out T]: Cons[T] | Nil
-class Cons[T](head: T, tail: List[T]) extends List[T]
+class Cons[out T](head: T, tail: List[T]) extends List[T]
 module Nil extends List
 fun (::) cons(head: 'T, tail: List['T]): List['T] = Cons(head, tail)
 fun reverse(l: List['A]): List['A] =
@@ -81,18 +81,18 @@ fun equalList(xs: List['A], ys: List['A], equal: ('A, 'A) -> Bool): Bool = if xs
   Nil and ys is Nil then true
   else false
 // `Option` and its utilities:
-abstract class Option[A]: Some[A] | None
+abstract class Option[out A]: Some[A] | None
 class Some[out A](value: A) extends Option[A]
 module None extends Option
 //│ abstract class List[T]: Cons[T] | Nil
 //│ class Cons[T](head: T, tail: List[T]) extends List
 //│ module Nil extends List
 //│ fun (::) cons: forall 'T. (head: 'T, tail: List['T]) -> List['T]
-//│ fun reverse: forall 'A. (l: List['A]) -> List['A]
+//│ fun reverse: forall 'T0. (l: List['T0]) -> List['T0]
 //│ fun join: (sep: Str, xs: List[anything]) -> (Str | NStr)
 //│ fun showList: (xs: List[anything]) -> NStr
-//│ fun map: forall 'D 'T0. (f: 'D -> 'T0, xs: List['D]) -> List['T0]
-//│ fun equalList: forall 'A0. (xs: List['A0], ys: List['A0], equal: ('A0, 'A0) -> Bool) -> Bool
+//│ fun map: forall 'D 'T1. (f: 'D -> 'T1, xs: List['D]) -> List['T1]
+//│ fun equalList: forall 'A. (xs: List['A], ys: List['A], equal: ('A, 'A) -> Bool) -> Bool
 //│ abstract class Option[A]: None | Some[A]
 //│ class Some[A](value: A) extends Option
 //│ module None extends Option
@@ -489,7 +489,6 @@ fun showEval(source: Str): Str =
     [Failure(error), _] then "Error: " ++ error
 //│ fun showEval: (source: Str) -> Str
 
-// FIXME
 showEval("1")
 showEval("(+ 1 2)")
 showEval("(val x 7 (val y 6 (* x y)))")
@@ -503,28 +502,21 @@ showEval("(def id (lambda (x) x) (id 42))")
 //│ res
 //│     = 'Ok: 1'
 //│ res
-//│ Runtime error:
-//│   TypeError: ((intermediate value) , (intermediate value)(...)) is not a function
+//│     = 'Ok: 3'
 //│ res
-//│ Runtime error:
-//│   TypeError: ((intermediate value) , (intermediate value)(...)) is not a function
+//│     = 'Ok: 42'
 //│ res
 //│     = 'Ok: x'
 //│ res
-//│ Runtime error:
-//│   TypeError: ((intermediate value) , (intermediate value)(...)) is not a function
+//│     = 'Ok: (1)'
 //│ res
-//│ Runtime error:
-//│   TypeError: ((intermediate value) , (intermediate value)(...)) is not a function
+//│     = 'Ok: 1'
 //│ res
-//│ Runtime error:
-//│   TypeError: ((intermediate value) , (intermediate value)(...)) is not a function
+//│     = 'Ok: 0'
 //│ res
-//│ Runtime error:
-//│   TypeError: ((intermediate value) , (intermediate value)(...)) is not a function
+//│     = 'Ok: 1'
 //│ res
-//│ Runtime error:
-//│   TypeError: ((intermediate value) , (intermediate value)(...)) is not a function
+//│     = 'Ok: 42'
 
 // showEval("(def fact (lambda (n) (if (eq n 0) 1 (* n (fact (- n 1))))) (fact 5))")
 // showEval("(def fib (lambda (n) (if (eq n 0) 0 (if (eq n 1) 1 (+ (fib (- n 1)) (fib (- n 2)))))) (fib 10))")
diff --git a/shared/src/test/diff/pretyper/ucs/examples/List.mls b/shared/src/test/diff/pretyper/ucs/examples/List.mls
new file mode 100644
index 0000000000..d922fd4aa7
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/examples/List.mls
@@ -0,0 +1,30 @@
+:PreTyper
+
+// TODO
+abstract class List[out A]: (Cons[A] | Nil) {
+  fun isEmpty: Bool
+  fun map[B]: (A -> B) -> List[B]
+}
+class Cons[out A](head: A, tail: List[A]) extends List[A] {
+  fun isEmpty: Bool = false
+  fun map(f) = Cons(f(head), tail.map(f))
+}
+module Nil extends List {
+  fun isEmpty: Bool = true
+  fun map(f) = Nil
+}
+//│ ╔══[ERROR] Indirectly-recursive member should have type annotation
+//│ ║  l.10: 	  fun map(f) = Cons(f(head), tail.map(f))
+//│ ╙──      	                                 ^^^^
+//│ abstract class List[A]: Cons[A] | Nil {
+//│   fun isEmpty: Bool
+//│   fun map: forall 'B. (A -> 'B) -> List['B]
+//│ }
+//│ class Cons[A](head: A, tail: List[A]) extends List {
+//│   fun isEmpty: Bool
+//│   fun map: forall 'A. (A -> 'A) -> Cons['A]
+//│ }
+//│ module Nil extends List {
+//│   fun isEmpty: Bool
+//│   fun map: anything -> Nil
+//│ }
diff --git a/shared/src/test/diff/pretyper/ucs/examples/Option.mls b/shared/src/test/diff/pretyper/ucs/examples/Option.mls
index 687b4b3744..32a2706ff5 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/Option.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/Option.mls
@@ -1,6 +1,5 @@
 :PreTyper
 
-// FIXME: Finish this example after the relevant issue is fixed.
 abstract class MyOption[out T]: (MySome[T] | MyNone) {
   virtual fun filter: (p: T -> Bool) -> MyOption[T]
 }
@@ -10,12 +9,6 @@ class MySome[out T](val value: T) extends MyOption[T] {
 module MyNone extends MyOption[nothing] {
   fun filter(_) = MyNone
 }
-//│ ╔══[ERROR] Type `#MySome & {MySome#T <: ?T}` does not contain member `MyOption#T`
-//│ ║  l.4: 	abstract class MyOption[out T]: (MySome[T] | MyNone) {
-//│ ╙──     	                            ^
-//│ ╔══[ERROR] Type `#MyNone` does not contain member `MyOption#T`
-//│ ║  l.4: 	abstract class MyOption[out T]: (MySome[T] | MyNone) {
-//│ ╙──     	                            ^
 //│ abstract class MyOption[T]: MyNone | MySome[T] {
 //│   fun filter: (p: T -> Bool) -> MyOption[T]
 //│ }
diff --git a/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls b/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls
index 959a114025..04277c54f6 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls
@@ -62,7 +62,7 @@ fun insertAllPositions(z) =
         let nu = ((prev :+ z) ::: xs)
         aux(prev :+ head, nu :: acc, tail)
   xs => aux(Nil, Nil, xs)
-//│ fun insertAllPositions: forall 'a. 'a -> (forall 'A 'A0. (Cons['A & 'A0] | Nil) -> (Cons[List['A0 | 'a]] & {Cons#T <: List['A0 | 'a]} | Nil))
+//│ fun insertAllPositions: forall 'a. 'a -> (forall 'A 'A0. (Cons['A & 'A0] | Nil) -> (Cons[List['A0 | 'a]] | Nil))
 //│   where
 //│     'A <: 'A0
 //│     'A0 :> 'a
@@ -79,7 +79,7 @@ fun permutations(xs) =
     Nil then Nil
     Cons(x, Nil) then (x :: Nil) :: Nil
     Cons(x, xs') then foldLeft((acc, ys) => acc ::: insertAllPositions(x)(ys))(Nil)(permutations(xs'))
-//│ fun permutations: forall 'T 'A. (Cons['T] | Nil) -> (Cons[Cons['T]] | List[List['A]] | Nil)
+//│ fun permutations: forall 'A 'T. (Cons['T] | Nil) -> (Cons[Cons['T]] | List[List['A]] | Nil)
 //│   where
 //│     'T <: 'A
 //│     'A := 'T
diff --git a/shared/src/test/diff/pretyper/ucs/examples/SimpleList.mls b/shared/src/test/diff/pretyper/ucs/examples/SimpleList.mls
new file mode 100644
index 0000000000..0da096a946
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/examples/SimpleList.mls
@@ -0,0 +1,18 @@
+:PreTyper
+
+abstract class List[T]: (Cons[T] | Nil)
+class Cons[T](val head: T, val tail: List[T]) extends List[T]
+module Nil extends List
+//│ abstract class List[T]: Cons[T] | Nil
+//│ class Cons[T](head: T, tail: List[T]) extends List
+//│ module Nil extends List
+
+fun (::) cons(head, tail) = Cons(head, tail)
+//│ fun (::) cons: forall 'T. ('T, List['T]) -> Cons['T]
+
+1 :: 2 :: 3 :: 4 :: 5 :: 6 :: 7 :: 8 :: Nil
+//│ Cons['T]
+//│   where
+//│     'T :> 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8
+//│ res
+//│     = Cons {}
diff --git a/shared/src/test/diff/pretyper/ucs/examples/SimpleTree.mls b/shared/src/test/diff/pretyper/ucs/examples/SimpleTree.mls
new file mode 100644
index 0000000000..db617d7cdb
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/examples/SimpleTree.mls
@@ -0,0 +1,31 @@
+:PreTyper
+
+// abstract class Tree[out A]: (Empty | Node[A])
+// class Node[out A](value: A, left: Tree[A], right: Tree[A]) extends Tree[A]
+// module Empty extends Tree
+// //│ abstract class Tree[A]: Empty | Node[A]
+// //│ class Node[A](value: A, left: Tree[A], right: Tree[A]) extends Tree
+// //│ module Empty extends Tree
+
+// fun insert(t, v) = if t is
+//   Node(v', l, r) and
+//     v < v' then Node(v', insert(l, v), r)
+//     v > v' then Node(v', l, insert(r, v))
+//     _ then t
+//   Empty then Node(v, Empty, Empty)
+// //│ fun insert: forall 'A. (Empty | Node[Num & 'A], Num & 'A) -> (Node[nothing] | Node['A])
+
+abstract class List[out T]: (Cons[T] | Nil)
+class Cons[out T](val head: T, val tail: List[T]) extends List[T]
+module Nil extends List
+//│ abstract class List[T]: Cons[T] | Nil
+//│ class Cons[T](head: T, tail: List[T]) extends List
+//│ module Nil extends List
+
+fun (::) cons(head, tail) = Cons(head, tail)
+//│ fun (::) cons: forall 'T. ('T, List['T]) -> Cons['T]
+
+1 :: 2 :: 3 :: 4 :: Nil
+//│ Cons[1 | 2 | 3 | 4]
+//│ res
+//│     = Cons {}
diff --git a/shared/src/test/diff/pretyper/ucs/examples/ULC.mls b/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
index 4cccc0ecb3..d94e810a3f 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
@@ -83,7 +83,9 @@ fun findFirst(list, p) =
     Cons(x, xs) and
       p(x) then Some(x)
       else findFirst(xs, p)
-//│ fun findFirst: forall 'A. (Cons['A] | Nil, 'A -> Bool) -> (None | Some['A])
+//│ fun findFirst: forall 'A 'A0. (Cons['A] | Nil, 'A -> Bool) -> (None | Some['A0])
+//│   where
+//│     'A <: 'A0
 
 fun (:::) listConcat(xs, ys) =
   if xs is
diff --git a/shared/src/test/diff/pretyper/ucs/stages/TransfromUCS.mls b/shared/src/test/diff/pretyper/ucs/stages/TransfromUCS.mls
index 2facf100a6..a3e044195f 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/TransfromUCS.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/TransfromUCS.mls
@@ -35,7 +35,7 @@ fun zipWith(f, xs, ys) =
     Cons(x, xs) and ys is Cons(y, ys) and zipWith(f, xs, ys) is Some(tail) then Some(Cons(f(x, y), tail))
     Nil and ys is Nil then Some(Nil)
   else None
-//│ fun zipWith: forall 'T 'T0 'T1. (('T, 'T0) -> 'T1, Cons['T] | Object & ~#Cons, Cons['T0] | Object & ~#Cons) -> (None | Some[Cons['T1] | Nil])
+//│ fun zipWith: forall 'T 'T0 'T1 'T2. (('T0, 'T1) -> 'T2, Cons['T0] | Object & ~#Cons, Cons['T1] | Object & ~#Cons) -> (None | Some[in List['T2] & 'T out Nil | 'T | Cons['T2]])
 
 
 fun getOrElse[T](x: Option[T], default: T): T =

From a048607dc70f5c037a2808ac13d0d93ed37b2654 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 13 Jan 2024 02:11:40 +0800
Subject: [PATCH 057/147] Uncomment lines which I forgot

---
 .../pretyper/ucs/examples/LispInterpreter.mls   | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
index 90cc4f58e4..c309a504fd 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
@@ -518,7 +518,16 @@ showEval("(def id (lambda (x) x) (id 42))")
 //│ res
 //│     = 'Ok: 42'
 
-// showEval("(def fact (lambda (n) (if (eq n 0) 1 (* n (fact (- n 1))))) (fact 5))")
-// showEval("(def fib (lambda (n) (if (eq n 0) 0 (if (eq n 1) 1 (+ (fib (- n 1)) (fib (- n 2)))))) (fib 10))")
-// showEval("(def sum (lambda (n) (if (eq n 0) 0 (+ n (sum (- n 1))))) (sum 50))")
-// showEval("(def ack (lambda (m n) (if (eq m 0) (+ n 1) (if (eq n 0) (ack (- m 1) 1) (ack (- m 1) (ack m (- n 1)))))) (ack 3 2))")
+showEval("(def fact (lambda (n) (if (eq n 0) 1 (* n (fact (- n 1))))) (fact 5))")
+showEval("(def fib (lambda (n) (if (eq n 0) 0 (if (eq n 1) 1 (+ (fib (- n 1)) (fib (- n 2)))))) (fib 10))")
+showEval("(def sum (lambda (n) (if (eq n 0) 0 (+ n (sum (- n 1))))) (sum 50))")
+showEval("(def ack (lambda (m n) (if (eq m 0) (+ n 1) (if (eq n 0) (ack (- m 1) 1) (ack (- m 1) (ack m (- n 1)))))) (ack 3 2))")
+//│ Str
+//│ res
+//│     = 'Ok: 120'
+//│ res
+//│     = 'Ok: 55'
+//│ res
+//│     = 'Ok: 1275'
+//│ res
+//│     = 'Ok: 29'

From 7580b2af86f45e6a67cde6626a94777020570530 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 13 Jan 2024 17:02:44 +0800
Subject: [PATCH 058/147] Mark refinement cases during normalization

---
 .../mlscript/ucs/context/PatternInfo.scala    |  6 +-
 shared/src/main/scala/mlscript/ucs/core.scala | 10 ++-
 .../src/main/scala/mlscript/ucs/display.scala | 75 +++++++++----------
 .../mlscript/ucs/stages/Desugaring.scala      |  6 +-
 .../mlscript/ucs/stages/Normalization.scala   | 59 +++++++++------
 .../mlscript/ucs/stages/PostProcessing.scala  | 17 ++---
 .../pretyper/ucs/SpecilizationCollision.mls   |  4 +-
 .../diff/pretyper/ucs/coverage/Refinement.mls | 18 +----
 .../pretyper/ucs/coverage/SealedClasses.mls   | 71 +++++++++---------
 9 files changed, 135 insertions(+), 131 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala b/shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala
index 2d8d4a1a1e..9d6f15e688 100644
--- a/shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala
@@ -61,7 +61,11 @@ object PatternInfo {
 
     override def matches(pat: SimpleTerm): Bool =
       pat match {
-        case pat: Var => pat.symbolOption.exists(_ === classLikeSymbol)
+        case pat: Var => pat.symbolOption match {
+          case S(patternSymbol: TypeSymbol) =>
+            patternSymbol === classLikeSymbol || patternSymbol.hasSuperType(classLikeSymbol)
+          case S(_) | N => false
+        }
         case _: Lit => false
       }
 
diff --git a/shared/src/main/scala/mlscript/ucs/core.scala b/shared/src/main/scala/mlscript/ucs/core.scala
index e05f6e4f36..a41f4d63ec 100644
--- a/shared/src/main/scala/mlscript/ucs/core.scala
+++ b/shared/src/main/scala/mlscript/ucs/core.scala
@@ -22,8 +22,16 @@ package object core {
     final case class Name(nme: Var) extends Pattern {
       override def children: Ls[Located] = nme :: Nil
     }
-    final case class Class(nme: Var, refined: Bool) extends Pattern {
+    /**
+      * TODO: Consider make `refined` immutable.
+      * @param nme the name of the class-like symbol
+      * @param originallyRefined whether the class is marked as refined from
+      *                          in source code
+      */
+    final case class Class(nme: Var, val originallyRefined: Bool) extends Pattern {
       override def children: Ls[Located] = nme :: Nil
+
+      var refined: Bool = originallyRefined
     }
 
     def getParametersLoc(parameters: List[Opt[Var]]): Opt[Loc] =
diff --git a/shared/src/main/scala/mlscript/ucs/display.scala b/shared/src/main/scala/mlscript/ucs/display.scala
index 3f7f5dd73b..03bd31ca3c 100644
--- a/shared/src/main/scala/mlscript/ucs/display.scala
+++ b/shared/src/main/scala/mlscript/ucs/display.scala
@@ -1,7 +1,6 @@
 package mlscript.ucs
 
-import mlscript.ucs.{Lines, LinesOps}
-import mlscript.ucs.{core, syntax}
+import mlscript.ucs.{core => c, syntax => s}
 import mlscript.ucs.context.{Context}
 import mlscript.pretyper.symbol.{TermSymbol, TypeSymbol}
 import mlscript.{App, CaseOf, Fld, FldFlags, Let, Loc, Sel, SimpleTerm, Term, Tup, Var}
@@ -24,48 +23,48 @@ package object display {
     `var`.name + (`var`.symbolOption.fold("")(_ => "*")) + postfix
   }
 
-  def showSplit(split: syntax.TermSplit)(implicit context: Context): Str = {
+  def showSplit(split: s.TermSplit)(implicit context: Context): Str = {
     // TODO: tailrec
-    def termSplit(split: syntax.TermSplit, isFirst: Bool, isAfterAnd: Bool): Lines = split match {
-      case syntax.Split.Cons(head, tail) => (termBranch(head) match {
+    def termSplit(split: s.TermSplit, isFirst: Bool, isAfterAnd: Bool): Lines = split match {
+      case s.Split.Cons(head, tail) => (termBranch(head) match {
         case (n, line) :: tail => (n, (if (isAfterAnd) "" else "and ") + s"$line") :: tail
         case Nil => Nil
       }) ::: termSplit(tail, false, isAfterAnd)
-      case syntax.Split.Let(_, nme, rhs, tail) =>
+      case s.Split.Let(_, nme, rhs, tail) =>
         (0, s"let ${nme.name} = ${rhs.showDbg}") :: termSplit(tail, false, isAfterAnd)
-      case syntax.Split.Else(term) =>
+      case s.Split.Else(term) =>
         (if (isFirst) (0, s"then ${term.showDbg}") else (0, s"else ${term.showDbg}")) :: Nil
-      case syntax.Split.Nil => Nil
+      case s.Split.Nil => Nil
     }
-    def termBranch(branch: syntax.TermBranch): Lines = branch match {
-      case syntax.TermBranch.Boolean(test, continuation) => 
+    def termBranch(branch: s.TermBranch): Lines = branch match {
+      case s.TermBranch.Boolean(test, continuation) => 
         s"$test" #: termSplit(continuation, true, false)
-      case syntax.TermBranch.Match(scrutinee, continuation) =>
+      case s.TermBranch.Match(scrutinee, continuation) =>
         s"$scrutinee is" #: patternSplit(continuation)
-      case syntax.TermBranch.Left(left, continuation) =>
+      case s.TermBranch.Left(left, continuation) =>
         s"$left" #: operatorSplit(continuation)
     }
-    def patternSplit(split: syntax.PatternSplit): Lines = split match {
-      case syntax.Split.Cons(head, tail) => patternBranch(head) ::: patternSplit(tail)
-      case syntax.Split.Let(rec, nme, rhs, tail) =>
+    def patternSplit(split: s.PatternSplit): Lines = split match {
+      case s.Split.Cons(head, tail) => patternBranch(head) ::: patternSplit(tail)
+      case s.Split.Let(rec, nme, rhs, tail) =>
         (0, s"let ${nme.name} = ${rhs.showDbg}") :: patternSplit(tail)
-      case syntax.Split.Else(term) => (0, s"else ${term.showDbg}") :: Nil
-      case syntax.Split.Nil => Nil
+      case s.Split.Else(term) => (0, s"else ${term.showDbg}") :: Nil
+      case s.Split.Nil => Nil
     }
-    def operatorSplit(split: syntax.OperatorSplit): Lines = split match {
-      case syntax.Split.Cons(head, tail) => operatorBranch(head) ::: operatorSplit(tail)
-      case syntax.Split.Let(rec, nme, rhs, tail) =>
+    def operatorSplit(split: s.OperatorSplit): Lines = split match {
+      case s.Split.Cons(head, tail) => operatorBranch(head) ::: operatorSplit(tail)
+      case s.Split.Let(rec, nme, rhs, tail) =>
         (0, s"let ${nme.name} = ${rhs.showDbg}") :: operatorSplit(tail)
-      case syntax.Split.Else(term) => (0, s"else ${term.showDbg}") :: Nil
-      case syntax.Split.Nil => Nil
+      case s.Split.Else(term) => (0, s"else ${term.showDbg}") :: Nil
+      case s.Split.Nil => Nil
     }
-    def operatorBranch(branch: syntax.OperatorBranch): Lines =
+    def operatorBranch(branch: s.OperatorBranch): Lines =
       s"${branch.operator}" #: (branch match {
-        case syntax.OperatorBranch.Match(_, continuation) => patternSplit(continuation)
-        case syntax.OperatorBranch.Binary(_, continuation) => termSplit(continuation, true, true)
+        case s.OperatorBranch.Match(_, continuation) => patternSplit(continuation)
+        case s.OperatorBranch.Binary(_, continuation) => termSplit(continuation, true, true)
       })
-    def patternBranch(branch: syntax.PatternBranch): Lines = {
-      val syntax.PatternBranch(pattern, continuation) = branch
+    def patternBranch(branch: s.PatternBranch): Lines = {
+      val s.PatternBranch(pattern, continuation) = branch
       termSplit(continuation, true, false) match {
         case (0, line) :: lines => (0, s"$pattern $line") :: lines
         case lines => (0, pattern.toString) :: lines
@@ -74,23 +73,23 @@ package object display {
     ("if" #: termSplit(split, true, true)).iterator.map { case (n, line) => "  " * n + line }.mkString("\n")
   }
 
-  @inline def showSplit(s: core.Split)(implicit context: Context): Str = showSplit("if", s)
+  @inline def showSplit(s: c.Split)(implicit context: Context): Str = showSplit("if", s)
 
-  def showSplit(prefix: Str, s: core.Split)(implicit context: Context): Str = {
+  def showSplit(prefix: Str, s: c.Split)(implicit context: Context): Str = {
     // TODO: tailrec
-    def split(s: core.Split, isFirst: Bool, isTopLevel: Bool): Lines = s match {
-      case core.Split.Cons(head, tail) => (branch(head) match {
+    def split(s: c.Split, isFirst: Bool, isTopLevel: Bool): Lines = s match {
+      case c.Split.Cons(head, tail) => (branch(head) match {
         case (n, line) :: tail => (n, (if (isTopLevel) "" else "") + s"$line") :: tail
         case Nil => Nil
       }) ::: split(tail, false, isTopLevel)
-      case core.Split.Let(_, nme, rhs, tail) =>
+      case c.Split.Let(_, nme, rhs, tail) =>
         (0, s"let ${showVar(nme)} = ${rhs.showDbg}") :: split(tail, false, isTopLevel)
-      case core.Split.Else(term) =>
+      case c.Split.Else(term) =>
         (if (isFirst) (0, s"then ${term.showDbg}") else (0, s"else ${term.showDbg}")) :: Nil
-      case core.Split.Nil => Nil
+      case c.Split.Nil => Nil
     }
-    def branch(b: core.Branch): Lines = {
-      val core.Branch(scrutinee, pattern, continuation) = b
+    def branch(b: c.Branch): Lines = {
+      val c.Branch(scrutinee, pattern, continuation) = b
       s"${showVar(scrutinee)} is $pattern" #: split(continuation, true, false)
     }
     val lines = split(s, true, true)
@@ -126,8 +125,8 @@ package object display {
     }
     def showCaseBranches(caseBranches: CaseBranches): Lines =
       caseBranches match {
-        case Case(pat, rhs, tail) =>
-          (s"${showPattern(pat)} ->" @: showTerm(rhs)) ++ showCaseBranches(tail)
+        case k @ Case(pat, rhs, tail) =>
+          (s"${if (k.refined) "refined " else ""}${showPattern(pat)} ->" @: showTerm(rhs)) ++ showCaseBranches(tail)
         case Wildcard(term) => s"_ ->" @: showTerm(term)
         case NoCases => Nil
       }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index cecf9e0238..2adae6fabf 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -67,9 +67,9 @@ trait Desugaring { self: PreTyper =>
     * Boolean conditions.
     */
   private def truePattern(implicit scope: Scope) =
-    c.Pattern.Class(Var("true").withResolvedClassLikeSymbol, refined = false)
+    c.Pattern.Class(Var("true").withResolvedClassLikeSymbol, false)
   private def falsePattern(implicit scope: Scope) =
-    c.Pattern.Class(Var("false").withResolvedClassLikeSymbol, refined = false)
+    c.Pattern.Class(Var("false").withResolvedClassLikeSymbol, false)
 
   private def desugarTermSplit(split: s.TermSplit)(implicit termPart: PartialTerm, scope: Scope, context: Context): c.Split =
     split match {
@@ -308,7 +308,7 @@ trait Desugaring { self: PreTyper =>
             scrutineeVar.getOrCreateScrutinee.withAlias(scrutineeVar).getOrCreateBooleanPattern(nme).addLocation(nme)
             c.Branch(
               scrutinee = scrutineeVar,
-              pattern = c.Pattern.Class(nme.withResolvedClassLikeSymbol, refined = false),
+              pattern = c.Pattern.Class(nme.withResolvedClassLikeSymbol, false),
               continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context)
             ) :: rec(scrutineeVar, tail)
           case s.ConcretePattern(nme) =>
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 269fb04e12..a814b404f5 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -98,7 +98,7 @@ trait Normalization { self: DesugarUCS with Traceable =>
         // println(s"match ${scrutineeVar.name} with $nme (has location: ${nme.toLoc.isDefined})")
         val trueBranch = normalizeToTerm(specialize(continuation.fill(tail, deep = false), true)(scrutineeVar, scrutinee, pattern, context))
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context))
-        CaseOf(scrutineeVar, Case(nme, trueBranch, falseBranch)(refined = rfd))
+        CaseOf(scrutineeVar, Case(nme, trueBranch, falseBranch)(refined = pattern.refined))
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
         raiseError(msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc)
         errorTerm
@@ -159,25 +159,41 @@ trait Normalization { self: DesugarUCS with Traceable =>
         val falseBranch = specialize(tail, matchOrNot)
         split.copy(head = head.copy(continuation = trueBranch), tail = falseBranch)
       // Class pattern. Positive.
-      case (true, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName, rfd), continuation), tail)) =>
+      case (true, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName, otherRefined), continuation), tail)) =>
         val otherClassSymbol = otherClassName.getClassLikeSymbol
         if (scrutinee === otherScrutinee) {
           println(s"scrutinee: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
           pattern match {
-            case Pattern.Class(className, rfd2) =>
-              assert(rfd === rfd2) // TODO: raise warning instead of crash
+            case classPattern @ Pattern.Class(className, refined) =>
               val classSymbol = className.getClassLikeSymbol
               if (classSymbol === otherClassSymbol) {
                 println(s"Case 1: class name: ${className.name} === ${otherClassName.name}")
+                if (otherRefined =/= refined) {
+                  def be(value: Bool): Str = if (value) "is" else "is not"
+                  raiseWarning(
+                    msg"inconsistent refined case branches" -> pattern.toLoc,
+                    msg"class pattern ${className.name} ${be(refined)} refined" -> className.toLoc,
+                    msg"but class pattern ${otherClassName.name} ${be(otherRefined)} refined" -> otherClassName.toLoc
+                  )
+                }
                 specialize(continuation, true) :++ specialize(tail, true)
-              } else if (otherClassSymbol.baseTypes contains classSymbol) {
+              } else if (otherClassSymbol hasSuperType classSymbol) {
                 println(s"Case 2: ${otherClassName.name} <: ${className.name}")
+                println(s"${otherClassSymbol.name} is refining ${className.name}")
+                // We should mark `pattern` as refined.
+                classPattern.refined = true
                 split
               } else {
                 println(s"Case 3: ${className.name} and ${otherClassName.name} are unrelated")
                 specialize(tail, true)
               }
-            case _ => throw new NormalizationException((msg"Incompatible: ${pattern.toString}" -> pattern.toLoc) :: Nil)
+            case _ =>
+              // TODO: Make a case for this. Check if this is a valid case.
+              raiseError(
+                msg"pattern ${pattern.toString}" -> pattern.toLoc,
+                msg"is incompatible with class pattern ${otherClassName.name}" -> otherClassName.toLoc,
+              )
+              split
           }
         } else {
           // println(s"scrutinee: ${scrutineeVar.name} =/= ${otherScrutineeVar.name}")
@@ -187,14 +203,21 @@ trait Normalization { self: DesugarUCS with Traceable =>
           )
         }
       // Class pattern. Negative
-      case (false, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName, rfd), continuation), tail)) =>
+      case (false, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName, otherRefined), continuation), tail)) =>
         val otherClassSymbol = otherClassName.getClassLikeSymbol
         if (scrutinee === otherScrutinee) {
           println(s"scrutinee: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
           pattern match {
-            case Pattern.Class(className, rfd2) =>
+            case Pattern.Class(className, refined) =>
               println("both of them are class patterns")
-              assert(rfd === rfd2) // TODO: raise warning instead of crash
+              if (otherRefined =/= refined) {
+                def be(value: Bool): Str = if (value) "is" else "is not"
+                raiseWarning(
+                  msg"inconsistent refined case branches" -> pattern.toLoc,
+                  msg"class pattern ${className.name} ${be(refined)} refined" -> className.toLoc,
+                  msg"but class pattern ${otherClassName.name} ${be(otherRefined)} refined" -> otherClassName.toLoc
+                )
+              }
               val classSymbol = className.getClassLikeSymbol
               if (className === otherClassName) {
                 println(s"Case 1: class name: ${otherClassName.name} === ${className.name}")
@@ -252,9 +275,9 @@ trait Normalization { self: DesugarUCS with Traceable =>
           )
         }
       // Other patterns. Not implemented.
-      case (_, Split.Cons(Branch(otherScrutineeVar, pattern, continuation), tail)) =>
-        println(s"unsupported pattern: $pattern")
-        throw new NormalizationException((msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc) :: Nil)
+      case (_, split @ Split.Cons(Branch(otherScrutineeVar, pattern, continuation), tail)) =>
+        raiseError(msg"found unsupported pattern: ${pattern.toString}" -> pattern.toLoc)
+        split
       case (_, let @ Split.Let(_, nme, _, tail)) =>
         println(s"let binding ${nme.name}, go next")
         let.copy(tail = specialize(tail, matchOrNot))
@@ -265,14 +288,4 @@ trait Normalization { self: DesugarUCS with Traceable =>
   // }(showSplit(s"S${if (matchOrNot) "+" else "-"} ==>", _))
 }
 
-object Normalization {
-  // private def getClassLikeSymbol(className: Var): TypeSymbol =
-  //   className.symbolOption.flatMap(_.typeSymbolOption) match {
-  //     case N => throw new NormalizationException(msg"class name is not resolved" -> className.toLoc :: Nil)
-  //     case S(typeSymbol) => typeSymbol
-  //   }
-
-  class NormalizationException(val messages: Ls[Message -> Opt[Loc]]) extends Throwable {
-    def this(message: Message, location: Opt[Loc]) = this(message -> location :: Nil)
-  }
-}
\ No newline at end of file
+object Normalization
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index 5f04265666..adf791cfbf 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -15,24 +15,17 @@ trait PostProcessing { self: DesugarUCS with mlscript.pretyper.Traceable =>
     // Normalized terms are constructed using `Let` and `CaseOf`.
     term match {
       case top @ CaseOf(ScrutineeData(_), Wildcard(body)) => body
-      case top @ CaseOf(scrutineeVar: Var, fst @ Case(className: Var, body, NoCases)) =>
-        println(s"found a UNARY case: ${scrutineeVar.name} is $className")
-        println("post-processing the body")
+      case top @ CaseOf(ScrutineeData.WithVar(scrutinee, scrutineeVar), fst @ Case(className: Var, body, NoCases)) =>
+        println(s"UNARY: ${scrutineeVar.name} is ${className.name}")
         top.copy(cases = fst.copy(body = postProcess(body))(refined = fst.refined))
-      // case top @ CaseOf(test: Var, fst @ Case(Var("true"), trueBranch, Wildcard(falseBranch))) =>
-      //   println(s"found a if-then-else case: $test is true")
-      //   val processedTrueBranch = postProcess(trueBranch)
-      //   val processedFalseBranch = postProcess(falseBranch)
-      //   top.copy(cases = fst.copy(body = processedTrueBranch, rest = Wildcard(processedFalseBranch)
-      //     )(refined = fst.refined))
       case top @ CaseOf(ScrutineeData.WithVar(scrutinee, scrutineeVar), fst @ Case(pat, trueBranch, Wildcard(falseBranch))) =>
         println(s"BINARY: ${scrutineeVar.name} is ${pat.showDbg}")
         println(s"patterns of `${scrutineeVar.name}`: ${scrutinee.showPatternsDbg}")
         // Post-process the true branch.
-        println("post-processing the first branch")
+        println("TRUE")
         val processedTrueBranch = postProcess(trueBranch)
         // Post-process the false branch.
-        println("post-processing the false branch")
+        println("FALSE")
         // Get all patterns, except the current one `pat`.
         val patternInfoList = scrutinee.patternsIterator.filter(!_.matches(pat)).toList
         println(s"found ${patternInfoList.length} patterns to distentangle: ${patternInfoList.iterator.map(_.showDbg).mkString(", ")}")
@@ -69,7 +62,7 @@ trait PostProcessing { self: DesugarUCS with mlscript.pretyper.Traceable =>
       // Otherwise, this is not a part of a normalized term.
       case other => println(s"CANNOT post-process ${other.showDbg}"); other
     }
-  }(_ => "postProcess ==> ")
+  }(res => s"postProcess ==> ${res.showDbg}")
 
   private def trimEmptyTerm(term: Term): Opt[Term] = term match {
     case k @ CaseOf(_, cases) => trimEmptyCaseBranches(cases).map(c => k.copy(cases = c))
diff --git a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
index 19a29b08d3..563791bff0 100644
--- a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
+++ b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
@@ -55,7 +55,7 @@ fun example3(t) =
     Base(x) and p1(x) then x
     Derived(y) then y
     else 42
-//│ fun example3: Base -> Int
+//│ fun example3: forall 'a. (Base & {#x: Num & 'a}) -> (Int | 'a)
 
 fun example4(t, x) =
   if t is
@@ -66,7 +66,7 @@ fun example4(t, x) =
     // previous branch shadows the variable `x`, a correct implementation
     // should restore the original value of `x` in this branch.
     else 42
-//│ fun example4: (Base, Int) -> Int
+//│ fun example4: forall 'a. (Base & {#x: Num & 'a}, Int) -> (Int | 'a)
 
 example4(Base(-1), 0) ~~> -1
 example4(Base(1), 2) ~~> 42
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/Refinement.mls b/shared/src/test/diff/pretyper/ucs/coverage/Refinement.mls
index 29a1d0697f..7469887ed4 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/Refinement.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/Refinement.mls
@@ -49,26 +49,10 @@ fun missing_a_case(x: Shape) =
     else x
 //│ fun missing_a_case: (x: Shape) -> ("Circle" | "Rectangle" | LineSegment)
 
-// TODO: Why doesn't `Shape` match `Circle | Rectangle | LineSegment`?
 fun countLineSegments(x) =
   if x is
     Shape and hidden(x) then "1"
     Rectangle(_, _, _) then "2"
     LineSegment(_, _) then "3"
     Circle(_, _) then "4"
-//│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.54: 	  if x is
-//│ ║        	     ^^^^
-//│ ║  l.55: 	    Shape and hidden(x) then "1"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.56: 	    Rectangle(_, _, _) then "2"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.57: 	    LineSegment(_, _) then "3"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.58: 	    Circle(_, _) then "4"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╟── expression of type `Shape & ~#LineSegment & ~#Rectangle` is not an instance of type `Circle`
-//│ ╟── Note: constraint arises from class pattern:
-//│ ║  l.58: 	    Circle(_, _) then "4"
-//│ ╙──      	    ^^^^^^
-//│ fun countLineSegments: Shape -> ("1" | "2" | "3" | "4")
+//│ fun countLineSegments: (Circle | LineSegment | Rectangle) -> ("1" | "2" | "3" | "4")
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
index 6194694a95..2d74e704e1 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
@@ -9,28 +9,44 @@ class App(func: Term, arg: Term) extends Term
 //│ class Abs(param: Str, body: Term) extends Term
 //│ class App(func: Term, arg: Term) extends Term
 
-// TODO: Why doesn't `Term` match `Abs | App | Var`?
-fun is_value(term) =
+:dpt:desugar.result
+fun is_value_explicit_refinement(term) =
+  if term is refined(Term) and term is
+    Abs(_, _) then true
+    Var(_) then false
+    App(_, _) then false
+//│ | | | | | | | Desugared UCS term:
+//│ | | | | | | | if term*‡ is refined Term
+//│ | | | | | | |   term*‡ is Abs then true
+//│ | | | | | | |   term*‡ is Var then false
+//│ | | | | | | |   term*‡ is App then false
+//│ fun is_value_explicit_refinement: (Abs | App | Var) -> Bool
+
+:dpt:normalize.result,postprocess.result
+fun is_value_automatic_refinement(term) =
   if term is Term and term is
     Abs(_, _) then true
     Var(_) then false
     App(_, _) then false
-//│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.14: 	  if term is Term and term is
-//│ ║        	                      ^^^^^^^
-//│ ║  l.15: 	    Abs(_, _) then true
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.16: 	    Var(_) then false
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.17: 	    App(_, _) then false
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╟── class pattern of type `Term` does not match type `Abs | App | Var`
-//│ ║  l.14: 	  if term is Term and term is
-//│ ║        	             ^^^^
-//│ ╟── but it flows into reference with expected type `Abs | App | Var`
-//│ ║  l.14: 	  if term is Term and term is
-//│ ╙──      	                      ^^^^
-//│ fun is_value: Term -> Bool
+//│ | | | | | | | Normalized UCS term:
+//│ | | | | | | | case term*‡ of
+//│ | | | | | | |   refined Term*◊ ->
+//│ | | | | | | |     case term*‡ of
+//│ | | | | | | |       Abs*◊ -> true
+//│ | | | | | | |       _ ->
+//│ | | | | | | |         case term*‡ of
+//│ | | | | | | |           Var*◊ -> false
+//│ | | | | | | |           _ ->
+//│ | | | | | | |             case term*‡ of
+//│ | | | | | | |               App*◊ -> false
+//│ | | | | | | | Post-processed UCS term:
+//│ | | | | | | | case term*‡ of
+//│ | | | | | | |   refined Term*◊ ->
+//│ | | | | | | |     case term*‡ of
+//│ | | | | | | |       Abs*◊ -> true
+//│ | | | | | | |       Var*◊ -> false
+//│ | | | | | | |       App*◊ -> false
+//│ fun is_value_automatic_refinement: (Abs | App | Var) -> Bool
 
 :e
 fun is_value'(term) =
@@ -38,25 +54,12 @@ fun is_value'(term) =
     Abs(_, _) then true
     Var(_) then false
 //│ ╔══[ERROR] When scrutinee `term` is `Term`
-//│ ║  l.37: 	  if term is Term and term is
+//│ ║  l.53: 	  if term is Term and term is
 //│ ║        	             ^^^^
 //│ ╟── Scrutinee `term` has 1 missing case
-//│ ║  l.37: 	  if term is Term and term is
+//│ ║  l.53: 	  if term is Term and term is
 //│ ║        	                      ^^^^
 //│ ╟── It can be class `App`
 //│ ║  l.6: 	class App(func: Term, arg: Term) extends Term
 //│ ╙──     	      ^^^
-//│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.37: 	  if term is Term and term is
-//│ ║        	                      ^^^^^^^
-//│ ║  l.38: 	    Abs(_, _) then true
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.39: 	    Var(_) then false
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^
-//│ ╟── class pattern of type `Term` does not match type `Abs | Var`
-//│ ║  l.37: 	  if term is Term and term is
-//│ ║        	             ^^^^
-//│ ╟── but it flows into reference with expected type `Abs | Var`
-//│ ║  l.37: 	  if term is Term and term is
-//│ ╙──      	                      ^^^^
-//│ fun is_value': Term -> Bool
+//│ fun is_value': (Abs | Var) -> Bool

From 78850d7047a1462c1829d74a4ba0ad446587b43e Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 13 Jan 2024 17:58:16 +0800
Subject: [PATCH 059/147] Move old desugarer, migrate most test cases, and fix
 minor bugs

---
 shared/src/main/scala/mlscript/Typer.scala    |  34 +-
 .../scala/mlscript/pretyper/PreTyper.scala    | 181 +++++---
 .../main/scala/mlscript/pretyper/Scope.scala  |   3 +-
 .../main/scala/mlscript/pretyper/Symbol.scala |  16 +-
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |  64 ++-
 .../scala/mlscript/ucs/context/CaseSet.scala  |   8 +-
 .../scala/mlscript/ucs/context/Context.scala  |  12 +
 .../mlscript/ucs/context/ScrutineeData.scala  |   2 +-
 .../src/main/scala/mlscript/ucs/display.scala |  11 +-
 .../src/main/scala/mlscript/ucs/helpers.scala |  20 -
 .../scala/mlscript/ucs/{ => old}/Clause.scala |   2 +-
 .../mlscript/ucs/{ => old}/Conjunction.scala  |   2 +-
 .../mlscript/ucs/{ => old}/Desugarer.scala    |   8 +-
 .../mlscript/ucs/{ => old}/LetBinding.scala   |   2 +-
 .../mlscript/ucs/{ => old}/MutCaseOf.scala    |   8 +-
 .../mlscript/ucs/{ => old}/Scrutinee.scala    |   2 +-
 .../main/scala/mlscript/ucs/old/helpers.scala |  28 ++
 .../mlscript/ucs/stages/Desugaring.scala      |  20 +-
 .../mlscript/ucs/stages/Normalization.scala   |   2 +-
 .../mlscript/ucs/stages/Transformation.scala  |  18 +-
 .../diff/codegen/AuxiliaryConstructors.mls    |  47 +-
 shared/src/test/diff/codegen/Mixin.mls        |  17 +-
 shared/src/test/diff/codegen/MixinCapture.mls |   4 +-
 shared/src/test/diff/codegen/Nested.mls       |  36 +-
 shared/src/test/diff/codegen/NewMatching.mls  |  56 +--
 shared/src/test/diff/codegen/ValLet.mls       |   2 +-
 .../test/diff/ecoop23/ComparePointPoly.mls    |   2 +-
 .../test/diff/ecoop23/ExpressionProblem.mls   |   2 +-
 shared/src/test/diff/ecoop23/Intro.mls        |   2 +-
 .../test/diff/ecoop23/PolymorphicVariants.mls |   6 +-
 .../diff/ecoop23/SimpleRegionDSL_annot.mls    |  24 +-
 .../test/diff/ecoop23/SimpleRegionDSL_raw.mls |  34 +-
 shared/src/test/diff/fcp/QML_exist_nu.mls     |   2 +-
 shared/src/test/diff/gadt/Exp1.mls            |  27 +-
 shared/src/test/diff/gadt/Exp2.mls            |   4 +-
 shared/src/test/diff/gadt/ThisMatching.mls    |  82 ++--
 shared/src/test/diff/nu/Andong.mls            |   2 +-
 shared/src/test/diff/nu/ArrayProg.mls         |  54 ++-
 shared/src/test/diff/nu/BadUCS.mls            |  91 ++--
 .../test/diff/nu/BasicClassInheritance.mls    |   2 +-
 shared/src/test/diff/nu/BasicClasses.mls      |   2 +-
 shared/src/test/diff/nu/CaseExpr.mls          |  73 +--
 shared/src/test/diff/nu/ClassSignatures.mls   |   2 +-
 shared/src/test/diff/nu/ClassesInMixins.mls   |  28 +-
 shared/src/test/diff/nu/CommaOperator.mls     |  51 ++-
 shared/src/test/diff/nu/CtorSubtraction.mls   |   2 +-
 shared/src/test/diff/nu/Eval.mls              |  14 +-
 shared/src/test/diff/nu/EvalNegNeg.mls        |   2 +-
 .../test/diff/nu/ExpressionProblem_repro.mls  |   2 +-
 .../test/diff/nu/ExpressionProblem_small.mls  |   2 +-
 shared/src/test/diff/nu/FilterMap.mls         |  11 +-
 shared/src/test/diff/nu/FlatIfThenElse.mls    |  59 ++-
 shared/src/test/diff/nu/FlatMonads.mls        |  32 +-
 shared/src/test/diff/nu/FunnyIndet.mls        |  10 +-
 shared/src/test/diff/nu/GADTMono.mls          |   2 +-
 shared/src/test/diff/nu/GenericClasses.mls    |   2 +-
 shared/src/test/diff/nu/GenericModules.mls    |   2 +-
 shared/src/test/diff/nu/HeungTung.mls         |  28 +-
 shared/src/test/diff/nu/Huawei1.mls           |   2 +-
 shared/src/test/diff/nu/InterfaceMono.mls     | 125 +++---
 shared/src/test/diff/nu/Interfaces.mls        | 165 ++++---
 shared/src/test/diff/nu/LetRec.mls            |   5 +-
 shared/src/test/diff/nu/ListConsNil.mls       |   4 +-
 shared/src/test/diff/nu/LitMatch.mls          |   6 +-
 shared/src/test/diff/nu/MissingTypeArg.mls    |   2 +-
 shared/src/test/diff/nu/NamedArgs.mls         |  46 +-
 shared/src/test/diff/nu/New.mls               |  12 +
 shared/src/test/diff/nu/NewNew.mls            |  31 +-
 shared/src/test/diff/nu/Object.mls            |  20 +-
 shared/src/test/diff/nu/OpLam.mls             |   8 +-
 shared/src/test/diff/nu/OptionFilter.mls      |   4 +-
 shared/src/test/diff/nu/OverrideShorthand.mls |   2 +-
 shared/src/test/diff/nu/ParamPassing.mls      |  40 +-
 .../test/diff/nu/PolymorphicVariants_Alt.mls  |   8 +-
 .../test/diff/nu/PostHocMixinSignature.mls    |   6 +-
 .../test/diff/nu/PrivateMemberOverriding.mls  |   2 +-
 shared/src/test/diff/nu/RefinedPattern.mls    |   2 +-
 shared/src/test/diff/nu/SelfRec.mls           |   2 +-
 shared/src/test/diff/nu/Subscripts.mls        |   2 +-
 shared/src/test/diff/nu/TODO_Classes.mls      |   2 +-
 shared/src/test/diff/nu/Unapply.mls           |   2 +-
 shared/src/test/diff/nu/UndefMatching.mls     |   2 +-
 shared/src/test/diff/nu/WeirdUnions.mls       |   2 +-
 shared/src/test/diff/nu/i180.mls              |   2 +-
 shared/src/test/diff/nu/repro0.mls            |   5 +-
 shared/src/test/diff/nu/repro1.mls            |   2 +-
 shared/src/test/diff/nu/repro_EvalNegNeg.mls  |   8 +-
 .../diff/nu/repro_PolymorphicVariants.mls     |   2 +-
 .../test/diff/pretyper/ucs/RecordPattern.mls  |   6 +-
 .../pretyper/ucs/SpecilizationCollision.mls   |   4 +-
 .../diff/pretyper/ucs/examples/Option.mls     |   4 +-
 shared/src/test/diff/ucs/AppSplits.mls        |  52 ++-
 .../src/test/diff/ucs/CrossBranchCapture.mls  |  44 +-
 shared/src/test/diff/ucs/DirectLines.mls      |  59 ++-
 shared/src/test/diff/ucs/ElseIf.mls           |  78 +++-
 shared/src/test/diff/ucs/ErrorMessage.mls     |  14 +-
 shared/src/test/diff/ucs/Exhaustiveness.mls   |  72 ++-
 shared/src/test/diff/ucs/Humiliation.mls      | 285 +++++++++++-
 shared/src/test/diff/ucs/Hygiene.mls          |  25 +-
 shared/src/test/diff/ucs/HygienicBindings.mls | 130 +++---
 shared/src/test/diff/ucs/InterleavedLet.mls   | 217 ++++++++-
 shared/src/test/diff/ucs/JSON.mls             | 319 -------------
 shared/src/test/diff/ucs/LeadingAnd.mls       |  28 +-
 shared/src/test/diff/ucs/LitUCS.mls           |   2 +-
 shared/src/test/diff/ucs/MultiwayIf.mls       |   2 +-
 shared/src/test/diff/ucs/NestedBranches.mls   | 159 ++++---
 shared/src/test/diff/ucs/NestedOpSplits.mls   |  14 +-
 shared/src/test/diff/ucs/NestedPattern.mls    |  88 ++--
 .../src/test/diff/ucs/NuPlainConditionals.mls |  53 ++-
 shared/src/test/diff/ucs/Or.mls               |  15 +-
 .../src/test/diff/ucs/OverlappedBranches.mls  |  21 +
 shared/src/test/diff/ucs/ParseFailures.mls    |  12 +-
 .../src/test/diff/ucs/PlainConditionals.mls   | 118 +++--
 shared/src/test/diff/ucs/SimpleUCS.mls        | 420 +++++++++---------
 shared/src/test/diff/ucs/SplitAfterOp.mls     | 287 +++++++-----
 shared/src/test/diff/ucs/SplitAnd.mls         |  49 +-
 shared/src/test/diff/ucs/SplitAroundOp.mls    |  41 +-
 shared/src/test/diff/ucs/SplitBeforeOp.mls    |  91 +++-
 shared/src/test/diff/ucs/SplitOps.mls         | 140 +++---
 shared/src/test/diff/ucs/SplitScrutinee.mls   |  10 +-
 shared/src/test/diff/ucs/ThenIndent.mls       |  15 +-
 shared/src/test/diff/ucs/Tree.mls             |   2 +-
 shared/src/test/diff/ucs/TrivialIf.mls        |  66 ++-
 shared/src/test/diff/ucs/WeirdIf.mls          |  80 ++--
 shared/src/test/diff/ucs/WeirdSplit.mls       |  42 +-
 shared/src/test/diff/ucs/Wildcard.mls         |  71 ++-
 shared/src/test/diff/ucs/zipWith.mls          |   6 +-
 todo.md                                       | 133 ++++++
 128 files changed, 3088 insertions(+), 1970 deletions(-)
 rename shared/src/main/scala/mlscript/ucs/{ => old}/Clause.scala (98%)
 rename shared/src/main/scala/mlscript/ucs/{ => old}/Conjunction.scala (99%)
 rename shared/src/main/scala/mlscript/ucs/{ => old}/Desugarer.scala (99%)
 rename shared/src/main/scala/mlscript/ucs/{ => old}/LetBinding.scala (98%)
 rename shared/src/main/scala/mlscript/ucs/{ => old}/MutCaseOf.scala (99%)
 rename shared/src/main/scala/mlscript/ucs/{ => old}/Scrutinee.scala (97%)
 create mode 100644 shared/src/main/scala/mlscript/ucs/old/helpers.scala
 delete mode 100644 shared/src/test/diff/ucs/JSON.mls
 create mode 100644 todo.md

diff --git a/shared/src/main/scala/mlscript/Typer.scala b/shared/src/main/scala/mlscript/Typer.scala
index 7c95b177c8..da37ad1c7e 100644
--- a/shared/src/main/scala/mlscript/Typer.scala
+++ b/shared/src/main/scala/mlscript/Typer.scala
@@ -15,7 +15,7 @@ import mlscript.Message._
  *  In order to turn the resulting CompactType into a mlscript.Type, we use `expandCompactType`.
  */
 class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val newDefs: Bool)
-    extends ucs.Desugarer with TypeSimplifier {
+    extends mlscript.ucs.old.Desugarer with TypeSimplifier {
   
   def funkyTuples: Bool = false
   def doFactorize: Bool = false
@@ -1058,21 +1058,29 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
         val argProv = tp(args.toLoc, "argument list")
         con(new_ty, FunctionType(typeTerm(args).withProv(argProv), res)(noProv), res)
       case App(App(Var("is"), _), _) => // * Old-style operators
-        val desug = If(IfThen(term, Var("true")), S(Var("false")))
-        term.desugaredTerm = S(desug)
-        typeTerm(desug)
+        typeTerm(term.desugaredTerm.getOrElse {
+          val desug = If(IfThen(term, Var("true")), S(Var("false")))
+          term.desugaredTerm = S(desug)
+          desug
+        })
       case App(Var("is"), _) =>
-        val desug = If(IfThen(term, Var("true")), S(Var("false")))
-        term.desugaredTerm = S(desug)
-        typeTerm(desug)
+        typeTerm(term.desugaredTerm.getOrElse {
+          val desug = If(IfThen(term, Var("true")), S(Var("false")))
+          term.desugaredTerm = S(desug)
+          desug
+        })
       case App(App(Var("and"), PlainTup(lhs)), PlainTup(rhs)) => // * Old-style operators
-        val desug = If(IfThen(lhs, rhs), S(Var("false")))
-        term.desugaredTerm = S(desug)
-        typeTerm(desug)
+        typeTerm(term.desugaredTerm.getOrElse {
+          val desug = If(IfThen(lhs, rhs), S(Var("false")))
+          term.desugaredTerm = S(desug)
+          desug
+        })
       case App(Var("and"), PlainTup(lhs, rhs)) =>
-        val desug = If(IfThen(lhs, rhs), S(Var("false")))
-        term.desugaredTerm = S(desug)
-        typeTerm(desug)
+        typeTerm(term.desugaredTerm.getOrElse {
+          val desug = If(IfThen(lhs, rhs), S(Var("false")))
+          term.desugaredTerm = S(desug)
+          desug
+        })
       case App(f: Term, a @ Tup(fields)) if (fields.exists(x => x._1.isDefined)) =>
         def getLowerBoundFunctionType(t: SimpleType): List[FunctionType] = t.unwrapProvs match {
           case PolymorphicType(_, AliasOf(fun_ty @ FunctionType(_, _))) =>
diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index 8b4ba5ecff..903b216a98 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -1,6 +1,7 @@
 package mlscript.pretyper
 
 import collection.mutable.{Set => MutSet}
+import collection.immutable.SortedMap
 import symbol._
 import mlscript._, utils._, shorthands._, Diagnostic.PreTyping, Message.MessageContext, ucs.DesugarUCS
 import scala.annotation.tailrec
@@ -8,69 +9,86 @@ import scala.annotation.tailrec
 class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with Diagnosable with DesugarUCS {
   import PreTyper._
 
-  private def extractParameters(fields: Term): Ls[LocalTermSymbol] =
-    trace(s"extractParameters <== $fields") {
-      fields match {
-        case nme: Var => new LocalTermSymbol(nme) :: Nil
-        case Tup(arguments) =>
-          arguments.flatMap {
-            case (S(nme: Var), Fld(_, _)) => new LocalTermSymbol(nme) :: Nil
-            case (_, Fld(_, nme: Var)) => new LocalTermSymbol(nme) :: Nil
-            case (_, Fld(_, Bra(false, term))) => extractParameters(term)
-            case (_, Fld(_, tuple @ Tup(_))) => extractParameters(tuple)
-            case (_, Fld(_, Asc(term, _))) => extractParameters(term)
-            case (_, Fld(_, _: Lit)) => Nil
-            case (_, Fld(_, App(Var(name), parameters))) if name.headOption.forall(_.isUpper) =>
-              extractParameters(parameters)
-            case (_, Fld(_, parameter)) =>
-              println(s"unknown parameter: $parameter")
-              ???
-          }
-        case PlainTup(arguments @ _*) =>
-          arguments.map {
-            case nme: Var => new LocalTermSymbol(nme)
-            case other => println("Unknown parameters: " + other.toString); ??? // TODO: bad
-          }.toList
-        case other => println("Unknown parameters: " + other.toString); ??? // TODO: bad
-      }
-    }(rs => s"extractParameters ==> ${rs.iterator.map(_.name).mkString(", ")}")
+  /** A shorthand function to raise errors without specifying the source. */
+  protected override def raiseError(messages: (Message -> Opt[Loc])*): Unit =
+    raiseError(PreTyping, messages: _*)
 
-  // `traverseIf` is meaningless because it represents patterns with terms.
+  /** A shorthand function to raise warnings without specifying the source. */
+  protected override def raiseWarning(messages: (Message -> Opt[Loc])*): Unit =
+    raiseWarning(PreTyping, messages: _*)
+
+  private def extractParameters(fields: Term): Ls[LocalTermSymbol] = {
+    def rec(term: Term): Iterator[LocalTermSymbol] = term match {
+      case nme: Var => Iterator.single(new LocalTermSymbol(nme))
+      case Bra(false, term) => rec(term)
+      case Bra(true, Rcd(fields)) =>
+        fields.iterator.flatMap { case (_, Fld(_, pat)) => rec(pat) }
+      case Asc(term, _) => rec(term)
+      case literal: Lit =>
+        raiseWarning(msg"literal patterns are ignored" -> literal.toLoc)
+        Iterator.empty
+      case App(Var(name), parameters) if name.isCapitalized => rec(parameters)
+      case Tup(arguments) =>
+        arguments.iterator.flatMap {
+          case (S(nme: Var), Fld(_, _)) => Iterator.single(new LocalTermSymbol(nme))
+          case (N, Fld(_, term)) => rec(term)
+        }
+      case PlainTup(arguments @ _*) => arguments.iterator.flatMap(extractParameters)
+      case other =>
+        raiseError(msg"unsupported pattern shape" -> other.toLoc)
+        Iterator.empty
+    }
+    val rs = rec(fields).toList
+    println(s"extractParameters ${fields.showDbg} ==> ${rs.iterator.map(_.name).mkString(", ")}")
+    rs
+  }
 
   protected def resolveVar(v: Var)(implicit scope: Scope): Unit =
-    trace(s"resolveVar(name = \"$v\")") {
-      scope.getTermSymbol(v.name) match {
-        case S(sym: LocalTermSymbol) =>
-          println(s"Resolve variable $v to a local term.")
-          v.symbol = sym
-        case S(sym: DefinedTermSymbol) =>
-          println(s"Resolve variable $v to a defined term.")
-          v.symbol = sym
-        case S(sym: ModuleSymbol) =>
-          println(s"Resolve variable $v to a module.")
-          v.symbol = sym
-        case N => 
-          scope.getTypeSymbol(v.name) match {
-            case S(sym: ClassSymbol) =>
-              println(s"Resolve variable $v to a class.")
-              v.symbol = sym
-            case S(_) =>
-              raiseError(PreTyping, msg"Name ${v.name} refers to a type" -> v.toLoc)
-            case N =>
-              raiseError(PreTyping, msg"Variable ${v.name} not found in scope" -> v.toLoc)
-          }
-      }
-    }()
+    scope.getTermSymbol(v.name) match {
+      case S(sym: LocalTermSymbol) =>
+        println(s"resolveVar `${v.name}` ==> local term")
+        v.symbol = sym
+      case S(sym: DefinedTermSymbol) =>
+        println(s"resolveVar `${v.name}` ==> defined term")
+        v.symbol = sym
+      case S(sym: ModuleSymbol) =>
+        println(s"resolveVar `${v.name}` ==> module")
+        v.symbol = sym
+      case N => 
+        scope.getTypeSymbol(v.name) match {
+          case S(sym: ClassSymbol) =>
+            println(s"resolveVar `${v.name}` ==> class")
+            v.symbol = sym
+          case S(_) =>
+            raiseError(PreTyping, msg"identifier `${v.name}` is resolved to a type" -> v.toLoc)
+          case N =>
+            raiseError(PreTyping, msg"identifier `${v.name}` not found" -> v.toLoc)
+        }
+    }
 
   protected def traverseVar(v: Var)(implicit scope: Scope): Unit =
-    trace(s"traverseVar(name = \"$v\")") {
+    trace(s"traverseVar(name = \"${v.name}\")") {
       v.symbolOption match {
         case N => resolveVar(v)
         case S(symbol) => scope.getSymbols(v.name) match {
-          case Nil => raiseError(PreTyping, msg"Variable ${v.name} not found in scope. It is possibly a free variable." -> v.toLoc)
+          case Nil => raiseError(PreTyping, msg"identifier `${v.name}` not found" -> v.toLoc)
           case symbols if symbols.contains(symbol) => ()
-          case _ =>
-            raiseError(PreTyping, msg"Variable ${v.name} refers to different symbols." -> v.toLoc)
+          case symbols =>
+            def toNameLoc(symbol: Symbol): (Str, Opt[Loc]) = symbol match {
+              case ds: DummyClassSymbol => s"`${ds.name}`" -> N
+              case ts: TypeSymbol => s"`${ts.name}`" -> ts.defn.toLoc
+              case ls: LocalTermSymbol => s"local `${ls.name}`" -> ls.nme.toLoc
+              case dt: DefinedTermSymbol => s"`${dt.name}`" -> dt.defn.toLoc
+            }
+            val (name, loc) = toNameLoc(symbol)
+            raiseError(PreTyping,
+              (msg"identifier ${v.name} refers to different symbols." -> v.toLoc ::
+                msg"it is resolved to $name" -> loc ::
+                symbols.map { s =>
+                  val (name, loc) = toNameLoc(s)
+                  msg"it was previously resolved to $name" -> loc
+                }): _*
+            )
         }
       }
     }()
@@ -107,6 +125,30 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
         case CaseOf(trm, cases) => 
         case With(trm, fields) => traverseTerm(trm); traverseTerm(fields)
         case Where(body, where) => ??? // TODO: When?
+        // begin UCS shorthands
+        //  * Old-style operators
+        case App(App(Var("is"), _), _) =>
+          println(s"found UCS shorthand: ${term.showDbg}")
+          val desugared = If(IfThen(term, Var("true")), S(Var("false")))
+          traverseIf(desugared)
+          term.desugaredTerm = desugared.desugaredTerm
+        case App(Var("is"), _) =>
+          println(s"found UCS shorthand: ${term.showDbg}")
+          val desugared = If(IfThen(term, Var("true")), S(Var("false")))
+          traverseIf(desugared)
+          term.desugaredTerm = desugared.desugaredTerm
+        //  * Old-style operators
+        case App(App(Var("and"), PlainTup(lhs)), PlainTup(rhs)) =>
+          println(s"found UCS shorthand: ${term.showDbg}")
+          val desugared = If(IfThen(lhs, rhs), S(Var("false")))
+          traverseIf(desugared)
+          term.desugaredTerm = desugared.desugaredTerm
+        case App(Var("and"), PlainTup(lhs, rhs)) =>
+          println(s"found UCS shorthand: ${term.showDbg}")
+          val desugared = If(IfThen(lhs, rhs), S(Var("false")))
+          traverseIf(desugared)
+          term.desugaredTerm = desugared.desugaredTerm
+        // end UCS shorthands
         case App(lhs, rhs) => traverseTerm(lhs); traverseTerm(rhs)
         case Test(trm, ty) => traverseTerm(trm)
         case _: Lit | _: Super => ()
@@ -136,9 +178,22 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
       println(typeSymbols.iterator.map(_.name).mkString("type symbols: {", ", ", "}"))
       // val scopeWithTypes = statements.iterator.flatMap(filterNuTypeDef).foldLeft(parentScope.derive)(_ + TypeSymbol(_))
       // Pass 1.1: Resolve subtyping relations. Build a graph and compute base types of each type.
-      val edges = typeSymbols.foldLeft(Map.empty[TypeSymbol, Ls[TypeSymbol]]) { case (acc, self) =>
-        acc + (self -> extractSuperTypes(self.defn.parents).map { nme =>
-          scopeWithTypes.getTypeSymbol(nme.name).getOrElse(???) })
+      // Keep a stable ordering of type symbols when printing the graph.
+      implicit val ord: Ordering[TypeSymbol] = new Ordering[TypeSymbol] {
+        override def compare(x: TypeSymbol, y: TypeSymbol): Int =
+          x.name.compareTo(y.name)
+      }
+      // Collect inheritance relations, represented by a map from a type symbol
+      // to its base types. If a type symbol is not found, we will ignore it
+      // and report the error (but not fatal).
+      val edges = typeSymbols.foldLeft(SortedMap.empty[TypeSymbol, Ls[TypeSymbol]]) { case (acc, self) =>
+        acc + (self -> extractSuperTypes(self.defn.parents).flatMap { nme =>
+          val maybeSymbol = scopeWithTypes.getTypeSymbol(nme.name)
+          if (maybeSymbol.isEmpty) {
+            raiseError(PreTyping, msg"could not find definition `${nme.name}`" -> nme.toLoc)
+          }
+          maybeSymbol
+        })
       }
       printGraph(edges, println, "inheritance relations", "->")
       transitiveClosure(edges).foreachEntry { (self, bases) =>
@@ -175,6 +230,12 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
           println(s"unknown statement: ${other.getClass.getSimpleName}")
           acc
       }
+      // Pass 2.5: Traverse type definitions
+      statements.iterator.flatMap { case defn: NuTypeDef => S(defn); case _ => N }.foreach { defn =>
+        val parameters = defn.params.map(extractParameters).getOrElse(Nil)
+        val thisSymbol = new LocalTermSymbol(Var("this"))
+        traverseTypeDefinition(TypeSymbol(defn), defn)(completeScope ++ (thisSymbol :: parameters))
+      }
       println(thingsToTraverse.iterator.map {
         case (L(term), _) => term.showDbg
         case (R(symbol), _) => symbol.name
@@ -214,7 +275,7 @@ object PreTyper {
         case Nil => results.reverse
         case (nme: Var) :: tail => rec(nme :: results, tail)
         case (TyApp(ty, _)) :: tail => rec(results, ty :: tail)
-        case (App(nme @ Var(_), Tup(_))) :: tail => rec(nme :: results, tail)
+        case (App(term, Tup(_))) :: tail => rec(results, term :: tail)
         case other :: _ => println(s"Unknown parent type: $other"); ???
       }
     rec(Nil, parents)
@@ -242,7 +303,7 @@ object PreTyper {
     rec(Nil, ty).reverse
   }
 
-  def transitiveClosure[A](graph: Map[A, List[A]]): Map[A, List[A]] = {
+  def transitiveClosure[A](graph: Map[A, List[A]])(implicit ord: Ordering[A]): SortedMap[A, List[A]] = {
     def dfs(vertex: A, visited: Set[A]): Set[A] = {
       if (visited.contains(vertex)) visited
       else graph.getOrElse(vertex, List())
@@ -251,7 +312,7 @@ object PreTyper {
     graph.keys.map { vertex =>
       val closure = dfs(vertex, Set())
       vertex -> (closure - vertex).toList
-    }.toMap
+    }.toSortedMap
   }
 
   def printGraph(graph: Map[TypeSymbol, List[TypeSymbol]], print: (=> Any) => Unit, title: String, arrow: String): Unit = {
diff --git a/shared/src/main/scala/mlscript/pretyper/Scope.scala b/shared/src/main/scala/mlscript/pretyper/Scope.scala
index 56c94aa677..89b30bd689 100644
--- a/shared/src/main/scala/mlscript/pretyper/Scope.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Scope.scala
@@ -98,6 +98,7 @@ object Scope {
     val trueSymbol = new ModuleSymbol(trueDefn)
     val falseSymbol = new ModuleSymbol(falseDefn)
     val nothingSymbol = new TypeAliasSymbol(nothingDefn)
+    val commaSymbol = new LocalTermSymbol(Var(","))
     Scope.from(
       """true,false,document,window,typeof,toString,not,succ,log,discard,negate,
         |round,add,sub,mul,div,sqrt,lt,le,gt,ge,slt,sle,sgt,sge,length,concat,eq,
@@ -108,7 +109,7 @@ object Scope {
         .iterator
         .map(_.trim)
         .map(name => new LocalTermSymbol(Var(name)))
-        .concat(trueSymbol :: falseSymbol :: nothingSymbol :: Nil)
+        .concat(trueSymbol :: falseSymbol :: nothingSymbol :: commaSymbol :: Nil)
     )
   }
 }
diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index 48ae45c74d..41bad9973b 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -21,7 +21,7 @@ package object symbol {
   }
 
   sealed trait TypeSymbol extends Symbol {
-    val defn: NuTypeDef
+    def defn: NuTypeDef
     
     override def name: Str = defn.name
 
@@ -50,6 +50,18 @@ package object symbol {
     def unapply(symbol: TypeSymbol): Opt[NuTypeDef] = S(symbol.defn)
   }
 
+  /**
+    * When a type symbol is not defined and we must need a symbol in some
+    * scenarios, we use a dummy symbol to represent it.
+    *
+    * @param nme the name of the expect type symbol.
+    */
+  final class DummyClassSymbol(val nme: Var) extends TypeSymbol {
+    override def defn: NuTypeDef = die
+
+    override def name: Str = nme.name
+  }
+
   final class ClassSymbol(override val defn: NuTypeDef) extends TypeSymbol {
     require(defn.kind === Cls)
   }
@@ -72,7 +84,7 @@ package object symbol {
 
   sealed trait TermSymbol extends Symbol with Matchable
 
-  class DefinedTermSymbol(defn: NuFunDef) extends TermSymbol {
+  class DefinedTermSymbol(val defn: NuFunDef) extends TermSymbol {
     override def name: Str = defn.name
 
     def body: Term \/ Type = defn.rhs
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 2617c402dd..40567bbdf3 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -32,12 +32,19 @@ trait DesugarUCS extends Transformation
     /** Associate the given `Var` with a fresh `ValueSymbol`. */
     def withFreshSymbol: Var = nme.withSymbol(freshSymbol(nme))
 
-    private def requireClassLikeSymbol(symbol: TypeSymbol): TypeSymbol = symbol match {
-      case symbol @ (_: TraitSymbol | _: ClassSymbol | _: ModuleSymbol) => symbol
+    /**
+      * Expect the given `symbol` to be a class-like symbol. If it is not, we
+      * get or create a dummy class symbol for it. The desugaring can continue
+      * and `Typer` will throw an error for this miuse.
+      */
+    private def requireClassLikeSymbol(symbol: TypeSymbol)(implicit context: Context): TypeSymbol = symbol match {
+      case symbol @ (_: TraitSymbol | _: ClassSymbol | _: ModuleSymbol | _: DummyClassSymbol) => symbol
       case symbol: MixinSymbol =>
-        throw new DesugaringException(msg"Mixins are not allowed in pattern" -> nme.toLoc :: Nil)
+        raiseError(msg"Mixins are not allowed in pattern" -> nme.toLoc)
+        context.getOrCreateDummyClassSymbol(nme)
       case symbol: TypeAliasSymbol =>
-        throw new DesugaringException(msg"Type alias is not allowed in pattern" -> nme.toLoc :: Nil)
+        raiseError(msg"Type alias is not allowed in pattern" -> nme.toLoc)
+        context.getOrCreateDummyClassSymbol(nme)
     }
 
     /**
@@ -45,13 +52,15 @@ trait DesugarUCS extends Transformation
       *
       * @param className the class name variable
       */
-    def getClassLikeSymbol: TypeSymbol = {
+    def getClassLikeSymbol(implicit context: Context): TypeSymbol = {
       val symbol = nme.symbolOption match {
         case S(symbol: TypeSymbol) => requireClassLikeSymbol(symbol)
-        case S(symbol: TermSymbol) => throw new DesugaringException(
-          msg"variable ${nme.name} is not associated with a class symbol" -> nme.toLoc :: Nil)
-        case N => throw new DesugaringException(
-          msg"variable ${nme.name} is not associated with any symbols" -> nme.toLoc :: Nil)
+        case S(symbol: TermSymbol) =>
+          raiseError(msg"variable ${nme.name} is not associated with a class symbol" -> nme.toLoc)
+          context.getOrCreateDummyClassSymbol(nme)
+        case N =>
+          raiseError(msg"variable ${nme.name} is not associated with any symbols" -> nme.toLoc)
+          context.getOrCreateDummyClassSymbol(nme)
       }
       println(s"getClassLikeSymbol: ${nme.name} ==> ${symbol.showDbg}")
       symbol
@@ -82,10 +91,25 @@ trait DesugarUCS extends Transformation
       )
     }
 
+    /**
+      * If the `Var` is associated with a term symbol, returns it. Otherwise,
+      * resolve the term symbol and associate the `Var` with the term symbol.
+      */
+    def getOrResolveTermSymbol(implicit scope: Scope): TermSymbol = {
+      nme.symbolOption match {
+        case N => resolveTermSymbol
+        case S(symbol: TermSymbol) => symbol
+        case S(otherSymbol) =>
+          raiseError(msg"identifier `${nme.name}` should be a term" -> nme.toLoc)
+          freshSymbol(nme) // TODO: Maybe we should maintain a "lost" symbol map.
+      }
+    }
+
     /** Associate the `Var` with a term symbol and returns the term symbol. */
     def resolveTermSymbol(implicit scope: Scope): TermSymbol = {
       val symbol = scope.getTermSymbol(nme.name).getOrElse {
-        throw new DesugaringException(msg"Undefined symbol found in patterns." -> nme.toLoc :: Nil)
+        raiseError(msg"identifier `${nme.name}` not found" -> nme.toLoc)
+        freshSymbol(nme) // TODO: Maybe we should maintain a "lost" symbol map.
       }
       nme.symbol = symbol
       symbol
@@ -95,17 +119,23 @@ trait DesugarUCS extends Transformation
     def withResolvedTermSymbol(implicit scope: Scope): Var = { nme.resolveTermSymbol; nme }
 
     /** Associate the `Var` with a class like symbol and returns the class like symbol. */
-    def resolveClassLikeSymbol(implicit scope: Scope): TypeSymbol = {
+    def resolveClassLikeSymbol(implicit scope: Scope, context: Context): TypeSymbol = {
       val symbol = scope.getTypeSymbol(nme.name) match {
         case S(symbol) => requireClassLikeSymbol(symbol)
-        case N => throw new DesugaringException(msg"Undefined symbol found in patterns." -> nme.toLoc :: Nil)
+        case N =>
+          raiseError(msg"type identifier `${nme.name}` not found" -> nme.toLoc)
+          context.getOrCreateDummyClassSymbol(nme)
       }
       nme.symbol = symbol
       symbol
     }
 
-    /** Associate the `Var` with a class like symbol and returns the same `Var`. */
-    def withResolvedClassLikeSymbol(implicit scope: Scope): Var = { nme.resolveClassLikeSymbol; nme }
+    /**
+      * Associate the `Var` with a class like symbol and returns the same `Var`.
+      * We might be able to remove this function. Currently, it is only used for
+      * resolving `Var("true")` and `Var("false")` in `Desugaring`. */
+    def withResolvedClassLikeSymbol(implicit scope: Scope, context: Context): Var =
+      { nme.resolveClassLikeSymbol; nme }
   }
 
   protected def traverseIf(`if`: If)(implicit scope: Scope): Unit = {
@@ -177,9 +207,9 @@ trait DesugarUCS extends Transformation
           traverseSplit(continuation)(scope.withEntries(patternSymbols))
           traverseSplit(tail)
         case Split.Let(isRec, name, rhs, tail) =>
-          val scopeWithName = scope + name.symbol
-          traverseTerm(rhs)(if (isRec) scopeWithName else scope)
-          traverseSplit(tail)(scopeWithName)
+          val recScope = scope + name.symbol
+          traverseTerm(rhs)(if (isRec) recScope else scope)
+          traverseSplit(tail)(recScope)
         case Split.Else(default) => traverseTerm(default)
         case Split.Nil => ()
       }
diff --git a/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala b/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
index 313eb615ed..b31f0928d4 100644
--- a/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
@@ -3,10 +3,16 @@ package mlscript.ucs.context
 import mlscript.{Lit, Loc}
 import mlscript.pretyper.symbol.TypeSymbol
 import mlscript.utils._, shorthands._
+import mlscript.pretyper.symbol.DummyClassSymbol
 
 sealed abstract class Pattern {
   override def toString(): String = this match {
-    case Pattern.ClassLike(symbol) => s"${symbol.defn.kind.str} `${symbol.name}`"
+    case Pattern.ClassLike(symbol) =>
+      val kind = symbol match {
+        case _: DummyClassSymbol => "dummy class"
+        case _ => symbol.defn.kind.str
+      }
+      s"$kind `${symbol.name}`"
     case Pattern.Tuple() => "tuple"
     case Pattern.Literal(literal) => s"literal $literal"
   }
diff --git a/shared/src/main/scala/mlscript/ucs/context/Context.scala b/shared/src/main/scala/mlscript/ucs/context/Context.scala
index bc14396107..3e5941576f 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Context.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Context.scala
@@ -6,8 +6,10 @@ import mlscript.pretyper.symbol.TypeSymbol
 import mlscript.pretyper.Scope
 import mlscript.ucs.VariableGenerator
 import mlscript.utils._, shorthands._
+import mlscript.pretyper.symbol.DummyClassSymbol
 
 class Context(originalTerm: If) {
+  /** The prefix of all prefixes. */
   private val prefix = Context.freshPrefix()
   private val cachePrefix = prefix + "$cache$"
   private val scrutineePrefix = prefix + "$scrut$"
@@ -30,6 +32,16 @@ class Context(originalTerm: If) {
   val freshTest: VariableGenerator = new VariableGenerator(testPrefix)
   val freshShadowed: VariableGenerator = new VariableGenerator(shadowPrefix)
 
+  // Symbol Management
+  // =================
+
+  private val dummyClassSymbols: MutMap[Var, DummyClassSymbol] = MutMap.empty
+  def getOrCreateDummyClassSymbol(nme: Var): DummyClassSymbol =
+    dummyClassSymbols.getOrElseUpdate(nme, new DummyClassSymbol(nme))
+
+  // Scrutinee Management
+  // ====================
+
   /** The buffer contains all `ScrutineeData` created within this context. */
   private val scrutineeBuffer: Buffer[ScrutineeData] = Buffer.empty
 
diff --git a/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala b/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
index 7f4b08b0c5..4ca6aede96 100644
--- a/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
@@ -152,7 +152,7 @@ object ScrutineeData {
   }
 
   private implicit val classLikeSymbolOrdering: Ordering[TypeSymbol] = new Ordering[TypeSymbol] {
-    override def compare(x: TypeSymbol, y: TypeSymbol): Int = x.defn.name.compareTo(y.defn.name)
+    override def compare(x: TypeSymbol, y: TypeSymbol): Int = x.name.compareTo(y.name)
   }
 
   private implicit val literalOrdering: Ordering[Lit] = new Ordering[Lit] {
diff --git a/shared/src/main/scala/mlscript/ucs/display.scala b/shared/src/main/scala/mlscript/ucs/display.scala
index 03bd31ca3c..7ffffe28f9 100644
--- a/shared/src/main/scala/mlscript/ucs/display.scala
+++ b/shared/src/main/scala/mlscript/ucs/display.scala
@@ -106,10 +106,13 @@ package object display {
     * - `‡` if the variable is associated with a term symbol and has a scrutinee.
     */
   def showNormalizedTerm(term: Term)(implicit context: Context): String = {
-    def showTerm(term: Term): Lines = term match {
-      case let: Let => showLet(let)
-      case caseOf: CaseOf => showCaseOf(caseOf)
-      case other => (0, other.showDbg) :: Nil
+    def showTerm(term: Term): Lines = term.desugaredTerm match {
+      case N => term match {
+        case let: Let => showLet(let)
+        case caseOf: CaseOf => showCaseOf(caseOf)
+        case other => (0, other.showDbg) :: Nil
+      }
+      case S(desugaredTerm) => "[desugared]" @: showTerm(desugaredTerm)
     }
     def showScrutinee(term: Term): Str = term match {
       case vari: Var => showVar(vari)
diff --git a/shared/src/main/scala/mlscript/ucs/helpers.scala b/shared/src/main/scala/mlscript/ucs/helpers.scala
index 0babee09b4..74491123a3 100644
--- a/shared/src/main/scala/mlscript/ucs/helpers.scala
+++ b/shared/src/main/scala/mlscript/ucs/helpers.scala
@@ -85,24 +85,4 @@ object helpers {
         }
       case _ => (term, N)
     }
-
-  /**
-    * Generate a chain of `Let` from a list of bindings.
-    *
-    * @param bindings a list of bindings, 
-    * @param body the final body
-    */
-  def mkBindings(bindings: Ls[LetBinding], body: Term, defs: Set[Var]): Term = {
-    def rec(bindings: Ls[LetBinding], defs: Set[Var]): Term =
-      bindings match {
-        case Nil => body
-        case LetBinding(_, isRec, nameVar, value) :: tail =>
-          if (defs.contains(nameVar)) {
-            rec(tail, defs)
-          } else {
-            Let(isRec, nameVar, value, rec(tail, defs + nameVar))
-          }
-      }
-    rec(bindings, defs)
-  }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/Clause.scala b/shared/src/main/scala/mlscript/ucs/old/Clause.scala
similarity index 98%
rename from shared/src/main/scala/mlscript/ucs/Clause.scala
rename to shared/src/main/scala/mlscript/ucs/old/Clause.scala
index b91354d984..c9f6243a2c 100644
--- a/shared/src/main/scala/mlscript/ucs/Clause.scala
+++ b/shared/src/main/scala/mlscript/ucs/old/Clause.scala
@@ -1,4 +1,4 @@
-package mlscript.ucs
+package mlscript.ucs.old
 
 import mlscript._
 import mlscript.utils._
diff --git a/shared/src/main/scala/mlscript/ucs/Conjunction.scala b/shared/src/main/scala/mlscript/ucs/old/Conjunction.scala
similarity index 99%
rename from shared/src/main/scala/mlscript/ucs/Conjunction.scala
rename to shared/src/main/scala/mlscript/ucs/old/Conjunction.scala
index f0928dccef..1cfbf1f6f3 100644
--- a/shared/src/main/scala/mlscript/ucs/Conjunction.scala
+++ b/shared/src/main/scala/mlscript/ucs/old/Conjunction.scala
@@ -1,4 +1,4 @@
-package mlscript.ucs
+package mlscript.ucs.old
 
 import mlscript._, utils._, shorthands._
 import Clause._, helpers._
diff --git a/shared/src/main/scala/mlscript/ucs/Desugarer.scala b/shared/src/main/scala/mlscript/ucs/old/Desugarer.scala
similarity index 99%
rename from shared/src/main/scala/mlscript/ucs/Desugarer.scala
rename to shared/src/main/scala/mlscript/ucs/old/Desugarer.scala
index 7f2d3004a3..92b18dd3fd 100644
--- a/shared/src/main/scala/mlscript/ucs/Desugarer.scala
+++ b/shared/src/main/scala/mlscript/ucs/old/Desugarer.scala
@@ -1,12 +1,13 @@
-package mlscript.ucs
+package mlscript.ucs.old
 
 import scala.collection.mutable.{Map => MutMap, HashMap}
 import scala.collection.mutable.Buffer
 
 import mlscript._, utils._, shorthands._
-import helpers._
+import mlscript.ucs.{DesugaringException, PartialTerm}
+import mlscript.ucs.helpers._, helpers._
 import Message.MessageContext
-import mlscript.ucs.MutCaseOf.MutCase.Constructor
+import MutCaseOf.MutCase.Constructor
 import scala.collection.mutable.ListBuffer
 
 /**
@@ -359,6 +360,7 @@ class Desugarer extends TypeDefs { self: Typer =>
     * @return the desugared term
     */
   def desugarIf(elf: If)(implicit ctx: Ctx, raise: Raise): Term = traceUCS("[desugarIf]") {
+    raise(WarningReport(msg"old desugarer used" -> elf.toLoc :: Nil, false))
     val superClassMap = getClassHierarchy()
     Desugarer.printGraph(superClassMap, printlnUCS, "Super-class map", "<:")
     val subClassMap = Desugarer.reverseGraph(superClassMap)
diff --git a/shared/src/main/scala/mlscript/ucs/LetBinding.scala b/shared/src/main/scala/mlscript/ucs/old/LetBinding.scala
similarity index 98%
rename from shared/src/main/scala/mlscript/ucs/LetBinding.scala
rename to shared/src/main/scala/mlscript/ucs/old/LetBinding.scala
index 6e08b3ce2d..fb217c41dd 100644
--- a/shared/src/main/scala/mlscript/ucs/LetBinding.scala
+++ b/shared/src/main/scala/mlscript/ucs/old/LetBinding.scala
@@ -1,4 +1,4 @@
-package mlscript.ucs
+package mlscript.ucs.old
 
 import mlscript._
 import mlscript.utils._
diff --git a/shared/src/main/scala/mlscript/ucs/MutCaseOf.scala b/shared/src/main/scala/mlscript/ucs/old/MutCaseOf.scala
similarity index 99%
rename from shared/src/main/scala/mlscript/ucs/MutCaseOf.scala
rename to shared/src/main/scala/mlscript/ucs/old/MutCaseOf.scala
index a217907da9..eac05684bf 100644
--- a/shared/src/main/scala/mlscript/ucs/MutCaseOf.scala
+++ b/shared/src/main/scala/mlscript/ucs/old/MutCaseOf.scala
@@ -1,4 +1,4 @@
-package mlscript.ucs
+package mlscript.ucs.old
 
 import mlscript._
 import mlscript.utils._
@@ -6,11 +6,11 @@ import mlscript.utils.shorthands._
 import scala.collection.immutable.Set
 import scala.collection.mutable.{Map => MutMap, Set => MutSet, Buffer}
 
-import helpers._
-import mlscript.ucs.MutCaseOf.Consequent
+import mlscript.ucs.helpers._
+import MutCaseOf.Consequent
 import scala.collection.immutable
 import Desugarer.{ExhaustivenessMap, SuperClassMap}
-import mlscript.ucs.Clause.MatchAny
+import Clause.MatchAny
 
 sealed abstract class MutCaseOf extends WithBindings {
   def kind: Str = {
diff --git a/shared/src/main/scala/mlscript/ucs/Scrutinee.scala b/shared/src/main/scala/mlscript/ucs/old/Scrutinee.scala
similarity index 97%
rename from shared/src/main/scala/mlscript/ucs/Scrutinee.scala
rename to shared/src/main/scala/mlscript/ucs/old/Scrutinee.scala
index 899c5629ac..9c9a46239a 100644
--- a/shared/src/main/scala/mlscript/ucs/Scrutinee.scala
+++ b/shared/src/main/scala/mlscript/ucs/old/Scrutinee.scala
@@ -1,4 +1,4 @@
-package mlscript.ucs
+package mlscript.ucs.old
 
 import mlscript.{Loc, SimpleTerm, Term, Var}
 import mlscript.utils.lastWords
diff --git a/shared/src/main/scala/mlscript/ucs/old/helpers.scala b/shared/src/main/scala/mlscript/ucs/old/helpers.scala
new file mode 100644
index 0000000000..bbfc79896e
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/old/helpers.scala
@@ -0,0 +1,28 @@
+package mlscript.ucs.old
+
+import scala.collection.mutable.{Set => MutSet}
+
+import mlscript._
+import mlscript.utils.shorthands._
+
+object helpers {
+  /**
+    * Generate a chain of `Let` from a list of bindings.
+    *
+    * @param bindings a list of bindings, 
+    * @param body the final body
+    */
+  def mkBindings(bindings: Ls[LetBinding], body: Term, defs: Set[Var]): Term = {
+    def rec(bindings: Ls[LetBinding], defs: Set[Var]): Term =
+      bindings match {
+        case Nil => body
+        case LetBinding(_, isRec, nameVar, value) :: tail =>
+          if (defs.contains(nameVar)) {
+            rec(tail, defs)
+          } else {
+            Let(isRec, nameVar, value, rec(tail, defs + nameVar))
+          }
+      }
+    rec(bindings, defs)
+  }
+}
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 2adae6fabf..d7e8196150 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -66,9 +66,9 @@ trait Desugaring { self: PreTyper =>
     * A shorthand for making a true pattern, which is useful in desugaring
     * Boolean conditions.
     */
-  private def truePattern(implicit scope: Scope) =
+  private def truePattern(implicit scope: Scope, context: Context) =
     c.Pattern.Class(Var("true").withResolvedClassLikeSymbol, false)
-  private def falsePattern(implicit scope: Scope) =
+  private def falsePattern(implicit scope: Scope, context: Context) =
     c.Pattern.Class(Var("false").withResolvedClassLikeSymbol, false)
 
   private def desugarTermSplit(split: s.TermSplit)(implicit termPart: PartialTerm, scope: Scope, context: Context): c.Split =
@@ -170,9 +170,13 @@ trait Desugaring { self: PreTyper =>
     * @param initialScope the scope before flattening the class pattern
     * @return a tuple of the augmented scope and a function that wrap a split
     */
-  private def desugarClassPattern(pattern: s.ClassPattern, scrutineeVar: Var, initialScope: Scope, refined: Bool)(implicit context: Context): (Scope, c.Split => c.Branch) = {
+  private def desugarClassPattern(
+      pattern: s.ClassPattern,
+      scrutineeVar: Var,
+      initialScope: Scope,
+      refined: Bool)(implicit context: Context): (Scope, c.Split => c.Branch) = {
     val scrutinee = scrutineeVar.getOrCreateScrutinee.withAlias(scrutineeVar)
-    val patternClassSymbol = pattern.nme.resolveClassLikeSymbol(initialScope)
+    val patternClassSymbol = pattern.nme.resolveClassLikeSymbol(initialScope, context)
     val classPattern = scrutinee.getOrCreateClassPattern(patternClassSymbol)
     println(s"desugarClassPattern: ${scrutineeVar.name} is ${pattern.nme.name}")
     classPattern.addLocation(pattern.nme)
@@ -292,6 +296,9 @@ trait Desugaring { self: PreTyper =>
 
   private def desugarPatternSplit(scrutineeTerm: Term, split: s.PatternSplit)(implicit scope: Scope, context: Context): c.Split = {
     def rec(scrutineeVar: Var, split: s.PatternSplit)(implicit scope: Scope): c.Split = split match {
+      // TODO: We should resolve `scrutineeVar`'s symbol and make sure it is a term symbol in the
+      // beginning. So that we can call methods on the symbol directly. Now there are too many
+      // helper functions on `VarOps`.
       case s.Split.Cons(head, tail) =>
         head.pattern match {
           case pattern @ s.AliasPattern(_, _) =>
@@ -336,13 +343,12 @@ trait Desugaring { self: PreTyper =>
             val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope + nme.symbol, context)
             c.Branch(scrutineeVar, c.Pattern.Name(nme), continuation) :: rec(scrutineeVar, tail)(scope + nme.symbol)
           case pattern @ s.ClassPattern(nme, fields, rfd) =>
-            println(s"find term symbol of $scrutineeVar in ${scope.showLocalSymbols}")
-            scrutineeVar.symbol = scope.getTermSymbol(scrutineeVar.name).getOrElse(???/*FIXME*/)
+            val scrutineeSymbol = scrutineeVar.getOrResolveTermSymbol // TODO: Useless.
             val (scopeWithAll, bindAll) = desugarClassPattern(pattern, scrutineeVar, scope, rfd)
             val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scopeWithAll, context)
             bindAll(continuation) :: rec(scrutineeVar, tail)
           case s.TuplePattern(fields) =>
-            scrutineeVar.symbol = scope.getTermSymbol(scrutineeVar.name).getOrElse(???/*FIXME*/)
+            val scrutineeSymbol = scrutineeVar.getOrResolveTermSymbol // TODO: Useless.
             val (scopeWithAll, bindAll) = desugarTuplePattern(fields, scrutineeVar, scope)
             val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scopeWithAll, context)
             val withBindings = bindAll(continuation)
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index a814b404f5..ffdf5fc36c 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -12,7 +12,7 @@ import mlscript.{App, CaseOf, Fld, FldFlags, Let, Loc, Sel, Term, Tup, Var, StrL
 import mlscript.{CaseBranches, Case, Wildcard, NoCases}
 import mlscript.Message, Message.MessageContext
 import mlscript.utils._, shorthands._
-import mlscript.pretyper.Traceable
+import mlscript.pretyper.{Diagnosable, Traceable}
 
 trait Normalization { self: DesugarUCS with Traceable =>
   import Normalization._
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index 547521684e..5956e69a19 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -1,10 +1,10 @@
 package mlscript.ucs.stages
 
-import mlscript.ucs.helpers
+import mlscript.ucs.{DesugarUCS, helpers}
 import mlscript.{If, IfBody, IfBlock, IfElse, IfLet, IfOpApp, IfOpsApp, IfThen}
 import mlscript.{Term, Var, App, Tup, Lit, Fld, Loc}
 import mlscript.Diagnostic.PreTyping
-import mlscript.pretyper.{Diagnosable, Traceable}
+import mlscript.pretyper.Traceable
 import mlscript.ucs.syntax._
 import mlscript.Message, Message._
 import mlscript.utils._, shorthands._
@@ -19,7 +19,7 @@ import scala.collection.immutable
   * The AST in the paper is more flexible. For example, it allows interleaved
   * `let` bindings in operator splits.
   */
-trait Transformation { self: Traceable with Diagnosable =>
+trait Transformation { self: DesugarUCS with Traceable =>
   import Transformation._
 
   /** The entry point of transformation. */
@@ -70,7 +70,7 @@ trait Transformation { self: Traceable with Diagnosable =>
           case (acc, R(NuFunDef(S(rec), nme, _, _, L(rhs)))) =>
             acc ++ Split.Let(rec, nme, rhs, Split.Nil)
           case (acc, R(statement)) =>
-            raiseError(PreTyping, msg"Unexpected statement in an if block" -> statement.toLoc)
+            raiseError(msg"Unexpected statement in an if block" -> statement.toLoc)
             acc
         }
       case IfOpsApp(lhs, opsRhss) =>
@@ -97,7 +97,7 @@ trait Transformation { self: Traceable with Diagnosable =>
     opsRhss.iterator.flatMap {
       case Var("and") -> rhs => S(transformIfBody(rhs))
       case op -> rhs =>
-        raiseError(PreTyping,
+        raiseError(
           msg"cannot transform due to an illegal split operator ${op.name}" -> op.toLoc,
           msg"the following branch will be discarded" -> rhs.toLoc)
         N
@@ -131,7 +131,9 @@ trait Transformation { self: Traceable with Diagnosable =>
             case (pattern, N) =>
               PatternBranch(pattern, transformIfBody(rhs)).toSplit
           }
-        case IfOpApp(lhs, op, rhs) => ??? // <-- Syntactic split of patterns are not supported.
+        case IfOpApp(lhs, op, rhs) =>
+          raiseError(msg"Syntactic split of patterns are not supported" -> op.toLoc)
+          Split.Nil
         case IfOpsApp(lhs, opsRhss) =>
           // BEGIN TEMPORARY PATCH
           // Generally, syntactic split of patterns are not supported. Examples
@@ -180,7 +182,7 @@ trait Transformation { self: Traceable with Diagnosable =>
           case (acc, R(NuFunDef(S(rec), nme, _, _, L(rhs)))) =>
             acc ++ Split.Let(rec, nme, rhs, Split.Nil)
           case (acc, R(statement)) =>
-            raiseError(PreTyping, msg"Unexpected statement in an if block" -> statement.toLoc)
+            raiseError(msg"Unexpected statement in an if block" -> statement.toLoc)
             acc
         }
         case IfElse(expr) => Split.default(expr)
@@ -213,7 +215,7 @@ trait Transformation { self: Traceable with Diagnosable =>
     case tuple: Tup => TuplePattern(transformTupleTerm(tuple))
     case other =>
       println(s"other $other")
-      raiseError(PreTyping, msg"Unknown pattern ${other.toString}" -> other.toLoc)
+      raiseError(msg"Unknown pattern ${other.showDbg}" -> other.toLoc)
       EmptyPattern(other)
   }
 
diff --git a/shared/src/test/diff/codegen/AuxiliaryConstructors.mls b/shared/src/test/diff/codegen/AuxiliaryConstructors.mls
index 36b8a2c8fc..ac763dbf4d 100644
--- a/shared/src/test/diff/codegen/AuxiliaryConstructors.mls
+++ b/shared/src/test/diff/codegen/AuxiliaryConstructors.mls
@@ -1,5 +1,4 @@
-:NewParser
-:NewDefs
+:PreTyper
 
 :js
 class A(x: Int) {}
@@ -65,7 +64,7 @@ new B
 :e
 B()
 //│ ╔══[ERROR] Construction of unparameterized class B should use the `new` keyword
-//│ ║  l.66: 	B()
+//│ ║  l.65: 	B()
 //│ ╙──      	^
 //│ B
 //│ res
@@ -78,7 +77,7 @@ abstract class C
 :e
 new C
 //│ ╔══[ERROR] Class C is abstract and cannot be instantiated
-//│ ║  l.79: 	new C
+//│ ║  l.78: 	new C
 //│ ╙──      	    ^
 //│ C
 //│ res
@@ -87,10 +86,10 @@ new C
 :e
 C()
 //│ ╔══[ERROR] Class C is abstract and cannot be instantiated
-//│ ║  l.88: 	C()
+//│ ║  l.87: 	C()
 //│ ╙──      	^
 //│ ╔══[ERROR] Class C cannot be instantiated as it exposes no constructor
-//│ ║  l.88: 	C()
+//│ ║  l.87: 	C()
 //│ ╙──      	^
 //│ error
 //│ res
@@ -132,10 +131,10 @@ class C {
 :e
 let c = new C()
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.133: 	let c = new C()
+//│ ║  l.132: 	let c = new C()
 //│ ║         	        ^^^^^^^
 //│ ╟── argument list of type `[]` does not match type `[x: Int]`
-//│ ║  l.133: 	let c = new C()
+//│ ║  l.132: 	let c = new C()
 //│ ╙──       	             ^^
 //│ let c: C | error
 //│ c
@@ -220,7 +219,7 @@ class E {
   constructor(y: Int)
 }
 //│ ╔══[PARSE ERROR] A class may have at most one explicit constructor
-//│ ║  l.218: 	class E {
+//│ ║  l.217: 	class E {
 //│ ╙──       	^^^^^
 //│ class E {
 //│   constructor(x: Int)
@@ -229,7 +228,7 @@ class E {
 :e
 constructor(x: Int)
 //│ ╔══[ERROR] Illegal position for this constructor statement.
-//│ ║  l.230: 	constructor(x: Int)
+//│ ║  l.229: 	constructor(x: Int)
 //│ ╙──       	^^^^^^^^^^^^^^^^^^^
 //│ 
 //│ Code generation encountered an error:
@@ -318,7 +317,7 @@ fun f(c) =
 //│ globalThis.f = function f(c) {
 //│   return ((() => {
 //│     let a;
-//│     return a = c, a instanceof F.class ? (([x]) => x)(F.unapply(c)) : a instanceof G ? 2 : 0;
+//│     return a = c, a instanceof F.class ? ((ucs$args_c$F) => ((x) => x)(ucs$args_c$F[0]))(F.unapply(c)) : a instanceof G ? 2 : 0;
 //│   })());
 //│ };
 //│ // End of generated code
@@ -501,7 +500,7 @@ fun h(z: Int) =
   }
   N
 //│ ╔══[ERROR] Construction of unparameterized class N should use the `new` keyword
-//│ ║  l.502: 	  N
+//│ ║  l.501: 	  N
 //│ ╙──       	  ^
 //│ fun h: (z: Int) -> (x: Int) -> N
 
@@ -513,7 +512,7 @@ let hh = h(1)
 :e
 new hh(1)
 //│ ╔══[ERROR] type identifier not found: hh
-//│ ║  l.514: 	new hh(1)
+//│ ║  l.513: 	new hh(1)
 //│ ╙──       	    ^^
 //│ error
 //│ res
@@ -529,10 +528,10 @@ mixin P {
   constructor(x: Int)
 }
 //│ ╔══[ERROR] Explicit module constructors are not supported
-//│ ║  l.526: 	  constructor(x: Int)
+//│ ║  l.525: 	  constructor(x: Int)
 //│ ╙──       	  ^^^^^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] Explicit mixin constructors are not supported
-//│ ║  l.529: 	  constructor(x: Int)
+//│ ║  l.528: 	  constructor(x: Int)
 //│ ╙──       	  ^^^^^^^^^^^^^^^^^^^
 //│ module O {
 //│   constructor(x: Int)
@@ -548,28 +547,28 @@ class QQ(qq: Str) {
   }
 }
 //│ ╔══[ERROR] identifier not found: lol
-//│ ║  l.546: 	    lol
+//│ ║  l.545: 	    lol
 //│ ╙──       	    ^^^
 //│ ╔══[WARNING] Pure expression does nothing in statement position.
-//│ ║  l.546: 	    lol
+//│ ║  l.545: 	    lol
 //│ ╙──       	    ^^^
 //│ ╔══[ERROR] Type mismatch in auxiliary class constructor:
-//│ ║  l.545: 	  constructor(foo: Int) {
+//│ ║  l.544: 	  constructor(foo: Int) {
 //│ ║         	  ^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.546: 	    lol
+//│ ║  l.545: 	    lol
 //│ ║         	^^^^^^^
-//│ ║  l.547: 	    qq = foo
+//│ ║  l.546: 	    qq = foo
 //│ ║         	^^^^^^^^^^^^
-//│ ║  l.548: 	  }
+//│ ║  l.547: 	  }
 //│ ║         	^^^
 //│ ╟── type `Int` is not an instance of type `Str`
-//│ ║  l.545: 	  constructor(foo: Int) {
+//│ ║  l.544: 	  constructor(foo: Int) {
 //│ ║         	                   ^^^
 //│ ╟── but it flows into reference with expected type `Str`
-//│ ║  l.547: 	    qq = foo
+//│ ║  l.546: 	    qq = foo
 //│ ║         	         ^^^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.544: 	class QQ(qq: Str) {
+//│ ║  l.543: 	class QQ(qq: Str) {
 //│ ╙──       	             ^^^
 //│ class QQ(qq: Str) {
 //│   constructor(foo: Int)
diff --git a/shared/src/test/diff/codegen/Mixin.mls b/shared/src/test/diff/codegen/Mixin.mls
index 8e60a28e3f..4462228f0a 100644
--- a/shared/src/test/diff/codegen/Mixin.mls
+++ b/shared/src/test/diff/codegen/Mixin.mls
@@ -1,5 +1,4 @@
-:NewParser
-:NewDefs
+:PreTyper
 
 :js
 class Add<out E>(lhs: E, rhs: E)
@@ -87,10 +86,7 @@ mixin EvalBase {
 //│         const qualifier1 = this;
 //│         return ((() => {
 //│           let a;
-//│           return (a = e, a instanceof Lit.class ? (([n]) => n)(Lit.unapply(e)) : a instanceof Add.class ? (([
-//│             l,
-//│             r
-//│           ]) => qualifier1.eval(l) + qualifier1.eval(r))(Add.unapply(e)) : (() => {
+//│           return (a = e, a instanceof Lit.class ? ((ucs$args_e$Lit) => ((n) => n)(ucs$args_e$Lit[0]))(Lit.unapply(e)) : a instanceof Add.class ? ((ucs$args_e$Add) => ((l) => ((r) => qualifier1.eval(l) + qualifier1.eval(r))(ucs$args_e$Add[1]))(ucs$args_e$Add[0]))(Add.unapply(e)) : (() => {
 //│             throw new Error("non-exhaustive case expression");
 //│           })());
 //│         })());
@@ -158,7 +154,7 @@ mixin EvalNeg {
 //│       eval(e) {
 //│         const qualifier1 = this;
 //│         return ((() => {
-//│           return e instanceof Neg.class ? (([d]) => 0 - qualifier1.eval(d))(Neg.unapply(e)) : super.eval(e);
+//│           return e instanceof Neg.class ? ((ucs$args_e$Neg) => ((d) => 0 - qualifier1.eval(d))(ucs$args_e$Neg[0]))(Neg.unapply(e)) : super.eval(e);
 //│         })());
 //│       }
 //│     });
@@ -192,7 +188,7 @@ mixin EvalNegNeg {
 //│       eval(e) {
 //│         const qualifier1 = this;
 //│         return ((() => {
-//│           return e instanceof Neg.class ? (([tmp0]) => tmp0 instanceof Neg.class ? (([d]) => qualifier1.eval(d))(Neg.unapply(tmp0)) : super.eval(e))(Neg.unapply(e)) : super.eval(e);
+//│           return e instanceof Neg.class ? ((ucs$args_e$Neg) => ((e$Neg_0) => e$Neg_0 instanceof Neg.class ? ((ucs$args_e$Neg_0$Neg) => ((d) => qualifier1.eval(d))(ucs$args_e$Neg_0$Neg[0]))(Neg.unapply(e$Neg_0)) : super.eval(e))(ucs$args_e$Neg[0]))(Neg.unapply(e)) : super.eval(e);
 //│         })());
 //│       }
 //│     });
@@ -371,8 +367,11 @@ Barr.y
 mixin Base {
   fun x = y
 }
+//│ ╔══[ERROR] identifier `y` not found
+//│ ║  l.368: 	  fun x = y
+//│ ╙──       	          ^
 //│ ╔══[ERROR] identifier not found: y
-//│ ║  l.372: 	  fun x = y
+//│ ║  l.368: 	  fun x = y
 //│ ╙──       	          ^
 //│ mixin Base() {
 //│   fun x: error
diff --git a/shared/src/test/diff/codegen/MixinCapture.mls b/shared/src/test/diff/codegen/MixinCapture.mls
index cf721dcf60..8bad474ea1 100644
--- a/shared/src/test/diff/codegen/MixinCapture.mls
+++ b/shared/src/test/diff/codegen/MixinCapture.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 :js
 class Lit(n: Int)
@@ -26,7 +26,7 @@ mixin EvalAddLit {
 //│       eval(e) {
 //│         return ((() => {
 //│           let a;
-//│           return (a = e, a instanceof qualifier.Lit.class ? (([n]) => n)(qualifier.Lit.unapply(e)) : (() => {
+//│           return (a = e, a instanceof qualifier.Lit.class ? ((ucs$args_e$Lit) => ((n) => n)(ucs$args_e$Lit[0]))(qualifier.Lit.unapply(e)) : (() => {
 //│             throw new Error("non-exhaustive case expression");
 //│           })());
 //│         })());
diff --git a/shared/src/test/diff/codegen/Nested.mls b/shared/src/test/diff/codegen/Nested.mls
index 10843c74aa..59fe95ae52 100644
--- a/shared/src/test/diff/codegen/Nested.mls
+++ b/shared/src/test/diff/codegen/Nested.mls
@@ -1,5 +1,4 @@
-:NewParser
-:NewDefs
+:PreTyper
 
 :js
 module A {
@@ -70,7 +69,7 @@ module A {
 let bb = A.B(A.a)
 bb.b
 //│ ╔══[ERROR] Access to class member not yet supported
-//│ ║  l.70: 	let bb = A.B(A.a)
+//│ ║  l.69: 	let bb = A.B(A.a)
 //│ ╙──      	          ^^
 //│ let bb: error
 //│ error
@@ -103,10 +102,10 @@ c.outer1
 let d = b.D(1)
 d.outer
 //│ ╔══[ERROR] Access to class member not yet supported
-//│ ║  l.101: 	let c = b.C(1)
+//│ ║  l.100: 	let c = b.C(1)
 //│ ╙──       	         ^^
 //│ ╔══[ERROR] Access to class member not yet supported
-//│ ║  l.103: 	let d = b.D(1)
+//│ ║  l.102: 	let d = b.D(1)
 //│ ╙──       	         ^^
 //│ class B(x: Int) {
 //│   class C(y: Int) {
@@ -351,7 +350,7 @@ let fff = es.F(2)
 let gg = fff.G(3)
 gg.sum
 //│ ╔══[ERROR] Access to class member not yet supported
-//│ ║  l.350: 	let fff = es.F(2)
+//│ ║  l.349: 	let fff = es.F(2)
 //│ ╙──       	            ^^
 //│ let es: E
 //│ let fff: error
@@ -550,7 +549,7 @@ let jj = G.H.J(42)
 let i = jj.ii(2)
 i.x
 //│ ╔══[ERROR] Access to module member not yet supported
-//│ ║  l.549: 	let jj = G.H.J(42)
+//│ ║  l.548: 	let jj = G.H.J(42)
 //│ ╙──       	          ^^
 //│ let jj: error
 //│ let i: error
@@ -658,7 +657,7 @@ module H {
 let j = H.J(42)
 j.i.x
 //│ ╔══[ERROR] Access to class member not yet supported
-//│ ║  l.658: 	let j = H.J(42)
+//│ ║  l.657: 	let j = H.J(42)
 //│ ╙──       	         ^^
 //│ let j: error
 //│ error
@@ -688,7 +687,7 @@ let i = I(1)
 let ij = i.J(0)
 ij.incY
 //│ ╔══[ERROR] Access to class member not yet supported
-//│ ║  l.688: 	let ij = i.J(0)
+//│ ║  l.687: 	let ij = i.J(0)
 //│ ╙──       	          ^^
 //│ class I(x: Int) {
 //│   class J(x: Int) {
@@ -879,10 +878,10 @@ module J {
 let m = J.M()
 let n = J.N(2)
 //│ ╔══[ERROR] Access to class member not yet supported
-//│ ║  l.879: 	let m = J.M()
+//│ ║  l.878: 	let m = J.M()
 //│ ╙──       	         ^^
 //│ ╔══[ERROR] Access to class member not yet supported
-//│ ║  l.880: 	let n = J.N(2)
+//│ ║  l.879: 	let n = J.N(2)
 //│ ╙──       	         ^^
 //│ let m: error
 //│ let n: error
@@ -923,7 +922,7 @@ module K {
 let m = K.L.M()
 m.f
 //│ ╔══[ERROR] Access to module member not yet supported
-//│ ║  l.923: 	let m = K.L.M()
+//│ ║  l.922: 	let m = K.L.M()
 //│ ╙──       	         ^^
 //│ let m: error
 //│ error
@@ -953,7 +952,7 @@ module L {
 let op = L.N.O.P(0)
 op.x
 //│ ╔══[ERROR] Access to module member not yet supported
-//│ ║  l.953: 	let op = L.N.O.P(0)
+//│ ║  l.952: 	let op = L.N.O.P(0)
 //│ ╙──       	          ^^
 //│ let op: error
 //│ error
@@ -980,10 +979,10 @@ module M {
 }
 M.N.op(M.P())
 //│ ╔══[ERROR] Access to module member not yet supported
-//│ ║  l.981: 	M.N.op(M.P())
+//│ ║  l.980: 	M.N.op(M.P())
 //│ ╙──       	 ^^
 //│ ╔══[ERROR] Access to class member not yet supported
-//│ ║  l.981: 	M.N.op(M.P())
+//│ ║  l.980: 	M.N.op(M.P())
 //│ ╙──       	        ^^
 //│ module M {
 //│   module N {
@@ -1166,7 +1165,7 @@ module N {
 :e
 N.O.P()
 //│ ╔══[ERROR] Access to module member not yet supported
-//│ ║  l.1167: 	N.O.P()
+//│ ║  l.1166: 	N.O.P()
 //│ ╙──        	 ^^
 //│ error
 //│ res
@@ -1182,7 +1181,7 @@ class I(x: Int) {
 }
 I(1).J(3).a
 //│ ╔══[ERROR] Access to class member not yet supported
-//│ ║  l.1183: 	I(1).J(3).a
+//│ ║  l.1182: 	I(1).J(3).a
 //│ ╙──        	    ^^
 //│ class I(x: Int) {
 //│   class J(z: Int) {
@@ -1263,6 +1262,9 @@ fun main =
     else g(x - 1)
   let g(x: Int): Int = f(x)
   f
+//│ ╔══[ERROR] identifier `g` not found
+//│ ║  l.1262: 	    else g(x - 1)
+//│ ╙──        	         ^
 //│ fun main: (x: Int) -> Int
 //│ // Prelude
 //│ class TypingUnit24 {}
diff --git a/shared/src/test/diff/codegen/NewMatching.mls b/shared/src/test/diff/codegen/NewMatching.mls
index 12fc2aaa88..40b5a0bbf2 100644
--- a/shared/src/test/diff/codegen/NewMatching.mls
+++ b/shared/src/test/diff/codegen/NewMatching.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 class V0()
 class V1(val x: Int)
@@ -31,7 +31,7 @@ fun sum(v) =
     Half(_, x) then x
     None(_) then 0
     _ then -1
-//│ fun sum: Object -> Int
+//│ fun sum: (Half | None | Object & ~#Half & ~#None & ~#Pos & ~#V0 & ~#V1 & ~#V2 & ~#V22 | Pos | V0 | V1 | V22 | V2) -> Int
 //│ // Prelude
 //│ class TypingUnit2 {}
 //│ const typing_unit2 = new TypingUnit2;
@@ -39,22 +39,7 @@ fun sum(v) =
 //│ globalThis.sum = function sum(v) {
 //│   return ((() => {
 //│     let a;
-//│     return (a = v, a instanceof V0.class ? 0 : a instanceof V1.class ? (([a]) => a)(V1.unapply(v)) : a instanceof V2.class ? (([
-//│       a,
-//│       b
-//│     ]) => a + b)(V2.unapply(v)) : a instanceof Pos.class ? (([x]) => x > 0 === true ? x : -1)(Pos.unapply(v)) : a instanceof V22.class ? (([
-//│       tmp0,
-//│       tmp1
-//│     ]) => tmp0 instanceof V2.class ? (([
-//│       x1,
-//│       y1
-//│     ]) => tmp1 instanceof V2.class ? (([
-//│       x2,
-//│       y2
-//│     ]) => x1 + y1 + x2 + y2)(V2.unapply(tmp1)) : -1)(V2.unapply(tmp0)) : -1)(V22.unapply(v)) : a instanceof Half.class ? (([
-//│       tmp2,
-//│       x
-//│     ]) => x)(Half.unapply(v)) : a instanceof None.class ? (([tmp3]) => 0)(None.unapply(v)) : -1);
+//│     return a = v, a instanceof V0.class ? 0 : a instanceof V22.class ? ((ucs$args_v$V22) => ((v$V22_0) => ((v$V22_1) => v$V22_0 instanceof V2.class ? ((ucs$args_v$V22_0$V2) => ((x1) => ((y1) => v$V22_1 instanceof V2.class ? ((ucs$args_v$V22_1$V2) => ((x2) => ((y2) => x1 + y1 + x2 + y2)(ucs$args_v$V22_1$V2[1]))(ucs$args_v$V22_1$V2[0]))(V2.unapply(v$V22_1)) : -1)(ucs$args_v$V22_0$V2[1]))(ucs$args_v$V22_0$V2[0]))(V2.unapply(v$V22_0)) : -1)(ucs$args_v$V22[1]))(ucs$args_v$V22[0]))(V22.unapply(v)) : a instanceof V2.class ? ((ucs$args_v$V2) => ((a) => ((b) => a + b)(ucs$args_v$V2[1]))(ucs$args_v$V2[0]))(V2.unapply(v)) : a instanceof V1.class ? ((ucs$args_v$V1) => ((a) => a)(ucs$args_v$V1[0]))(V1.unapply(v)) : a instanceof Pos.class ? ((ucs$args_v$Pos) => ((x) => ((ucs$test$0) => ucs$test$0 === true ? x : -1)(x > 0))(ucs$args_v$Pos[0]))(Pos.unapply(v)) : a instanceof None.class ? 0 : a instanceof Half.class ? ((ucs$args_v$Half) => ((x) => x)(ucs$args_v$Half[1]))(Half.unapply(v)) : (v, v, v, v, v, -1);
 //│   })());
 //│ };
 //│ // End of generated code
@@ -104,7 +89,7 @@ fun get1(s) =
 //│ globalThis.get1 = function get1(s) {
 //│   return ((() => {
 //│     let a;
-//│     return (a = s, a instanceof Some.class ? (([tmp4]) => ((y) => tmp4 instanceof V1.class ? (([x]) => x)(V1.unapply(tmp4)) : y)(tmp4))(Some.unapply(s)) : (() => {
+//│     return (a = s, a instanceof Some.class ? ((ucs$args_s$Some) => ((s$Some_0) => s$Some_0 instanceof V1.class ? ((ucs$args_s$Some_0$V1) => ((x) => x)(ucs$args_s$Some_0$V1[0]))(V1.unapply(s$Some_0)) : ((y) => y)(ucs$args_s$Some[0]))(ucs$args_s$Some[0]))(Some.unapply(s)) : (() => {
 //│       throw new Error("non-exhaustive case expression");
 //│     })());
 //│   })());
@@ -136,7 +121,7 @@ fun foo(s) =
 //│ // Query 1
 //│ globalThis.foo = function foo(s) {
 //│   return ((() => {
-//│     return s instanceof Some.class ? (([t]) => ((b) => b + t.x)(s2.value))(Some.unapply(s)) : 0;
+//│     return s instanceof Some.class ? ((ucs$args_s$Some) => ((t) => ((b) => b + t.x)(s2.value))(ucs$args_s$Some[0]))(Some.unapply(s)) : 0;
 //│   })());
 //│ };
 //│ // End of generated code
@@ -213,17 +198,18 @@ t(new FooBar())
 //│     = 1
 
 :e
-:ge
 fun ft(x) =
   if x is
     FooBar(x) then x
     _ then 0
-//│ ╔══[ERROR] class FooBar expects 0 parameters but found 1 parameter
-//│ ║  l.219: 	    FooBar(x) then x
-//│ ╙──       	    ^^^^^^^^^
-//│ fun ft: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] Construction of unparameterized class FooBar should use the `new` keyword
+//│ ║  l.203: 	    FooBar(x) then x
+//│ ╙──       	    ^^^^^^
+//│ ╔══[ERROR] Type mismatch in field selection:
+//│ ║  l.203: 	    FooBar(x) then x
+//│ ║         	    ^^^^^^
+//│ ╙── reference of type `() -> FooBar` does not have field 'unapply'
+//│ fun ft: Object -> (0 | error)
 
 :js
 module MM
@@ -264,13 +250,17 @@ fun c(x) =
   if x is
     VVC(x, y, z) then x + y + z
     _ then 0
-//│ ╔══[ERROR] class VVC expects 2 parameters but found 3 parameters
-//│ ║  l.265: 	    VVC(x, y, z) then x + y + z
-//│ ╙──       	    ^^^^^^^^^^^^
+//│ ╔══[ERROR] Type mismatch in field selection:
+//│ ╟── tuple literal of type `{0: ?#v, 1: ?#vc}` does not have field '2'
+//│ ║  l.248: 	class VVC(v: Int, vc: Int)
+//│ ║         	          ^^^^^^^^^^
+//│ ╟── but it flows into operator application with expected type `{2: ?a}`
+//│ ║  l.250: 	  if x is
+//│ ║         	     ^^^^
+//│ ║  l.251: 	    VVC(x, y, z) then x + y + z
+//│ ╙──       	^^^^^^^
 //│ class VVC(v: Int, vc: Int)
-//│ fun c: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ fun c: Object -> Int
 
 
 
diff --git a/shared/src/test/diff/codegen/ValLet.mls b/shared/src/test/diff/codegen/ValLet.mls
index 6cdfebc4cb..e1b04b7e9b 100644
--- a/shared/src/test/diff/codegen/ValLet.mls
+++ b/shared/src/test/diff/codegen/ValLet.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 :js
 class A(x0: Int) {
diff --git a/shared/src/test/diff/ecoop23/ComparePointPoly.mls b/shared/src/test/diff/ecoop23/ComparePointPoly.mls
index c90dfde588..e3cd651e95 100644
--- a/shared/src/test/diff/ecoop23/ComparePointPoly.mls
+++ b/shared/src/test/diff/ecoop23/ComparePointPoly.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 class Some[out A](val value: A)
diff --git a/shared/src/test/diff/ecoop23/ExpressionProblem.mls b/shared/src/test/diff/ecoop23/ExpressionProblem.mls
index 7745355af2..8b6b16d713 100644
--- a/shared/src/test/diff/ecoop23/ExpressionProblem.mls
+++ b/shared/src/test/diff/ecoop23/ExpressionProblem.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 // * Motivating paper example, demonstrating the expression problem solution
diff --git a/shared/src/test/diff/ecoop23/Intro.mls b/shared/src/test/diff/ecoop23/Intro.mls
index dda082110c..880c19b9f9 100644
--- a/shared/src/test/diff/ecoop23/Intro.mls
+++ b/shared/src/test/diff/ecoop23/Intro.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 // * Examples from paper intro
diff --git a/shared/src/test/diff/ecoop23/PolymorphicVariants.mls b/shared/src/test/diff/ecoop23/PolymorphicVariants.mls
index a92b52ca08..66da4d52d2 100644
--- a/shared/src/test/diff/ecoop23/PolymorphicVariants.mls
+++ b/shared/src/test/diff/ecoop23/PolymorphicVariants.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 // * Adapted example from Code reuse through polymorphic variants (FOSE 2000)
@@ -127,7 +127,7 @@ fun map_expr(f, v) =
     Numb then v
     Add(l, r) then Add(f(l), f(r))
     Mul(l, r) then Mul(f(l), f(r))
-//│ fun map_expr: forall 'a 'A 'b 'A0. ('b -> 'A0 & 'a -> 'A, Add['b] | Mul['a] | Numb | Var) -> (Add['A0] | Mul['A] | Numb | Var)
+//│ fun map_expr: forall 'a 'A 'b 'A0. ('a -> 'A & 'b -> 'A0, Add['b] | Mul['a] | Numb | Var) -> (Add['A0] | Mul['A] | Numb | Var)
 
 mixin EvalExpr {
   fun eval(sub, v) =
@@ -206,7 +206,7 @@ module Test3 extends EvalVar, EvalExpr, EvalLambda
 Test3.eval(Cons(["c", Abs("d", Var("d"))], Nil), Abs("a", Var("a")))
 //│ 'a
 //│   where
-//│     'a :> App['a] | Abs['a] | Abs[Var] | Numb | Var
+//│     'a :> Abs[Var] | Numb | Var | App['a] | Abs['a]
 //│ res
 //│     = Abs {}
 
diff --git a/shared/src/test/diff/ecoop23/SimpleRegionDSL_annot.mls b/shared/src/test/diff/ecoop23/SimpleRegionDSL_annot.mls
index d2b54c6799..df937b92dd 100644
--- a/shared/src/test/diff/ecoop23/SimpleRegionDSL_annot.mls
+++ b/shared/src/test/diff/ecoop23/SimpleRegionDSL_annot.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 // * Adapted example from Compositional Embeddings of Domain-Specific Languages (OOPSLA 2022)
@@ -173,24 +173,24 @@ mixin Text {
       Translate then concat("a translated region of size ", toString(this.size(e)))
 }
 //│ mixin Text() {
-//│   this: {size: (Intersect[nothing] | Translate['Region] | Union[nothing] | 'a) -> Int}
-//│   fun text: (Circle | Intersect[anything] | Outside['a] | Translate['Region] | Union[anything]) -> Str
+//│   this: {size: (Intersect['Region] | Translate[nothing] | Union[nothing] | 'a) -> Int}
+//│   fun text: (Circle | Intersect['Region] | Outside['a] | Translate[anything] | Union[anything]) -> Str
 //│ }
 
 :e
 module SizeText extends Text
 //│ ╔══[ERROR] Type `#SizeText & {text: ?a -> (?b | ?c | ?d | ?e | ?f)}` does not contain member `size`
-//│ ║  l.173: 	      Translate then concat("a translated region of size ", toString(this.size(e)))
-//│ ╙──       	                                                                         ^^^^^
-//│ ╔══[ERROR] Type `#SizeText & {text: ?a -> (?b | ?c | ?d | ?e | ?f)}` does not contain member `size`
 //│ ║  l.172: 	      Intersect then concat("the intersection of two regions of size ", toString(this.size(e)))
 //│ ╙──       	                                                                                     ^^^^^
 //│ ╔══[ERROR] Type `#SizeText & {text: ?a -> (?b | ?c | ?d | ?e | ?f)}` does not contain member `size`
-//│ ║  l.171: 	      Union then concat("the union of two regions of size ", toString(this.size(e)))
-//│ ╙──       	                                                                          ^^^^^
-//│ ╔══[ERROR] Type `#SizeText & {text: ?a -> (?b | ?c | ?d | ?e | ?f)}` does not contain member `size`
 //│ ║  l.170: 	      Outside(a) then concat("outside a region of size ", toString(this.size(a)))
 //│ ╙──       	                                                                       ^^^^^
+//│ ╔══[ERROR] Type `#SizeText & {text: ?a -> (?b | ?c | ?d | ?e | ?f)}` does not contain member `size`
+//│ ║  l.173: 	      Translate then concat("a translated region of size ", toString(this.size(e)))
+//│ ╙──       	                                                                         ^^^^^
+//│ ╔══[ERROR] Type `#SizeText & {text: ?a -> (?b | ?c | ?d | ?e | ?f)}` does not contain member `size`
+//│ ║  l.171: 	      Union then concat("the union of two regions of size ", toString(this.size(e)))
+//│ ╙──       	                                                                          ^^^^^
 //│ module SizeText {
 //│   fun text: (Circle | Intersect[anything] | Outside[anything] | Translate[anything] | Union[anything]) -> Str
 //│ }
@@ -320,7 +320,7 @@ mixin Eliminate {
 //│   this: {
 //│     eliminate: 'a -> 'b & 'c -> 'Region & 'd -> 'Region0 & 'e -> 'Region1 & 'f -> 'Region2 & 'g -> 'Region3
 //│   }
-//│   fun eliminate: (Intersect['e] | Object & 'b & ~#Intersect & ~#Outside & ~#Scale & ~#Translate & ~#Union | Outside['c & (Object & ~#Outside | Outside['a])] | Scale['g] | Translate['f] | Union['d]) -> (Intersect['Region1] | Outside['Region] | Scale['Region3] | Translate['Region2] | Union['Region0] | 'b)
+//│   fun eliminate: (Intersect['g] | Object & 'b & ~#Intersect & ~#Outside & ~#Scale & ~#Translate & ~#Union | Outside['c & (Object & ~#Outside | Outside['a])] | Scale['f] | Translate['e] | Union['d]) -> (Intersect['Region3] | Outside['Region] | Scale['Region2] | Translate['Region1] | Union['Region0] | 'b)
 //│ }
 
 module TestElim extends Eliminate {
@@ -346,9 +346,9 @@ fun mk(n) = if n is
   3 then Intersect(mk(n), mk(n))
   4 then Translate(Vector(0, 0), mk(n))
   _ then Scale(Vector(0, 0), mk(n))
-//│ fun mk: forall 'a. Object -> 'a
+//│ fun mk: forall 'a. (1 | 2 | 3 | 4 | Object & ~1 & ~2 & ~3 & ~4) -> 'a
 //│   where
-//│     'a :> Outside['a] | Scale['a] | Union['a] | Intersect['a] | Translate['a]
+//│     'a :> Outside['a] | Translate['a] | Intersect['a] | Union['a] | Scale['a]
 
 :re
 TestElim.eliminate(mk(100))
diff --git a/shared/src/test/diff/ecoop23/SimpleRegionDSL_raw.mls b/shared/src/test/diff/ecoop23/SimpleRegionDSL_raw.mls
index 22b0dec18a..21c6d8ee46 100644
--- a/shared/src/test/diff/ecoop23/SimpleRegionDSL_raw.mls
+++ b/shared/src/test/diff/ecoop23/SimpleRegionDSL_raw.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 // * Adapted example from Compositional Embeddings of Domain-Specific Languages (OOPSLA 2022)
@@ -161,24 +161,24 @@ mixin Text {
       Translate then concat("a translated region of size ", toString(this.size(e)))
 }
 //│ mixin Text() {
-//│   this: {size: (Intersect[nothing] | Translate['Region] | Union[nothing] | 'a) -> Int}
-//│   fun text: (Circle | Intersect[anything] | Outside['a] | Translate['Region] | Union[anything]) -> Str
+//│   this: {size: (Intersect['Region] | Translate[nothing] | Union[nothing] | 'a) -> Int}
+//│   fun text: (Circle | Intersect['Region] | Outside['a] | Translate[anything] | Union[anything]) -> Str
 //│ }
 
 :e
 module SizeText extends Text
 //│ ╔══[ERROR] Type `#SizeText & {text: ?a -> (?b | ?c | ?d | ?e | ?f)}` does not contain member `size`
-//│ ║  l.161: 	      Translate then concat("a translated region of size ", toString(this.size(e)))
-//│ ╙──       	                                                                         ^^^^^
-//│ ╔══[ERROR] Type `#SizeText & {text: ?a -> (?b | ?c | ?d | ?e | ?f)}` does not contain member `size`
 //│ ║  l.160: 	      Intersect then concat("the intersection of two regions of size ", toString(this.size(e)))
 //│ ╙──       	                                                                                     ^^^^^
 //│ ╔══[ERROR] Type `#SizeText & {text: ?a -> (?b | ?c | ?d | ?e | ?f)}` does not contain member `size`
-//│ ║  l.159: 	      Union then concat("the union of two regions of size ", toString(this.size(e)))
-//│ ╙──       	                                                                          ^^^^^
-//│ ╔══[ERROR] Type `#SizeText & {text: ?a -> (?b | ?c | ?d | ?e | ?f)}` does not contain member `size`
 //│ ║  l.158: 	      Outside(a) then concat("outside a region of size ", toString(this.size(a)))
 //│ ╙──       	                                                                       ^^^^^
+//│ ╔══[ERROR] Type `#SizeText & {text: ?a -> (?b | ?c | ?d | ?e | ?f)}` does not contain member `size`
+//│ ║  l.161: 	      Translate then concat("a translated region of size ", toString(this.size(e)))
+//│ ╙──       	                                                                         ^^^^^
+//│ ╔══[ERROR] Type `#SizeText & {text: ?a -> (?b | ?c | ?d | ?e | ?f)}` does not contain member `size`
+//│ ║  l.159: 	      Union then concat("the union of two regions of size ", toString(this.size(e)))
+//│ ╙──       	                                                                          ^^^^^
 //│ module SizeText {
 //│   fun text: (Circle | Intersect[anything] | Outside[anything] | Translate[anything] | Union[anything]) -> Str
 //│ }
@@ -294,7 +294,7 @@ mixin Eliminate {
 //│   this: {
 //│     eliminate: 'a -> 'b & 'c -> 'Region & 'd -> 'Region0 & 'e -> 'Region1 & 'f -> 'Region2 & 'g -> 'Region3
 //│   }
-//│   fun eliminate: (Intersect['e] | Object & 'b & ~#Intersect & ~#Outside & ~#Scale & ~#Translate & ~#Union | Outside['c & (Object & ~#Outside | Outside['a])] | Scale['g] | Translate['f] | Union['d]) -> (Intersect['Region1] | Outside['Region] | Scale['Region3] | Translate['Region2] | Union['Region0] | 'b)
+//│   fun eliminate: (Intersect['g] | Object & 'b & ~#Intersect & ~#Outside & ~#Scale & ~#Translate & ~#Union | Outside['c & (Object & ~#Outside | Outside['a])] | Scale['f] | Translate['e] | Union['d]) -> (Intersect['Region3] | Outside['Region] | Scale['Region2] | Translate['Region1] | Union['Region0] | 'b)
 //│ }
 
 module TestElim extends Eliminate
@@ -303,19 +303,19 @@ module TestElim extends Eliminate
 //│ }
 //│ where
 //│   'a <: Intersect['a] | Object & 'b & ~#Intersect & ~#Outside & ~#Scale & ~#Translate & ~#Union | Outside['a & (Object & ~#Outside | Outside['a])] | Scale['a] | Translate['a] | Union['a]
-//│   'b :> Outside['b] | Union['b] | Intersect['b] | Translate['b] | Scale['b]
+//│   'b :> Outside['b] | Union['b] | Translate['b] | Scale['b] | Intersect['b]
 
 TestElim.eliminate(Outside(Outside(Univ())))
 //│ 'a
 //│   where
-//│     'a :> Univ | Union[Univ | 'a] | Intersect['a] | Translate[Univ | 'a] | Scale[Univ | 'a] | Outside[Univ | 'a]
+//│     'a :> Univ | Outside[Univ | 'a] | Union[Univ | 'a] | Translate[Univ | 'a] | Scale[Univ | 'a] | Intersect['a]
 //│ res
 //│     = Univ {}
 
 TestElim.eliminate(circles)
 //│ 'a
 //│   where
-//│     'a :> Circle | Translate[Circle | 'a] | Scale[Circle | 'a] | Outside[Circle | 'a] | Union[Circle | 'a] | Intersect['a]
+//│     'a :> Circle | Outside[Circle | 'a] | Union[Circle | 'a] | Translate[Circle | 'a] | Scale[Circle | 'a] | Intersect['a]
 //│ res
 //│     = Union {}
 
@@ -325,15 +325,15 @@ fun mk(n) = if n is
   3 then Intersect(mk(n), mk(n))
   4 then Translate(Vector(0, 0), mk(n))
   _ then Scale(Vector(0, 0), mk(n))
-//│ fun mk: forall 'a. Object -> 'a
+//│ fun mk: forall 'a. (1 | 2 | 3 | 4 | Object & ~1 & ~2 & ~3 & ~4) -> 'a
 //│   where
-//│     'a :> Outside['a] | Intersect['a] | Translate['a] | Scale['a] | Union['a]
+//│     'a :> Outside['a] | Union['a] | Scale['a] | Translate['a] | Intersect['a]
 
 :re
 TestElim.eliminate(mk(100))
 //│ 'a
 //│   where
-//│     'a :> Outside['a] | Union['a] | Intersect['a] | Translate['a] | Scale['a]
+//│     'a :> Outside['a] | Union['a] | Translate['a] | Scale['a] | Intersect['a]
 //│ res
 //│ Runtime error:
 //│   RangeError: Maximum call stack size exceeded
@@ -355,7 +355,7 @@ module Lang extends SizeBase, SizeExt, Contains, Text, IsUniv, IsEmpty, Eliminat
 //│   'e <: Intersect['e] | Object & ~#Intersect & ~#Outside & ~#Scale & ~#Translate & ~#Union & ~#Univ | Outside['e] | Scale['e] | Translate['e] | Union['e] | Univ
 //│   'd <: Intersect['d] | Object & ~#Intersect & ~#Outside & ~#Scale & ~#Translate & ~#Union & ~#Univ | Outside['d] | Scale['d] | Translate['d] | Union['d] | Univ
 //│   'b <: Intersect['b] | Object & 'c & ~#Intersect & ~#Outside & ~#Scale & ~#Translate & ~#Union | Outside['b & (Object & ~#Outside | Outside['b])] | Scale['b] | Translate['b] | Union['b]
-//│   'c :> Translate['c] | Scale['c] | Outside['c] | Union['c] | Intersect['c]
+//│   'c :> Outside['c] | Union['c] | Translate['c] | Scale['c] | Intersect['c]
 //│   'a <: Circle | Intersect['a] | Outside['a] | Translate['a] | Union['a]
 
 Lang.size(circles)
diff --git a/shared/src/test/diff/fcp/QML_exist_nu.mls b/shared/src/test/diff/fcp/QML_exist_nu.mls
index 39fa4e19e9..2c0986bf16 100644
--- a/shared/src/test/diff/fcp/QML_exist_nu.mls
+++ b/shared/src/test/diff/fcp/QML_exist_nu.mls
@@ -1,6 +1,6 @@
 // * TODO also a GADT version of this where we use `Arrays[A]: ArraysImpl[A, ?]`
 
-:NewDefs
+:PreTyper
 
 :DontDistributeForalls // * Also works without this
 
diff --git a/shared/src/test/diff/gadt/Exp1.mls b/shared/src/test/diff/gadt/Exp1.mls
index 489ddea752..d98bdcabc2 100644
--- a/shared/src/test/diff/gadt/Exp1.mls
+++ b/shared/src/test/diff/gadt/Exp1.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 abstract class Exp[A]: Pair | Lit
@@ -33,12 +33,24 @@ fun f(e) = if e is
 :e // TODO support
 fun f(e) = if e is
   Pair['a, 'b](l, r) then [l, r]
-//│ ╔══[ERROR] illegal pattern
+//│ ╔══[ERROR] Unknown pattern Pair‹'a, 'b›(l, r,)
 //│ ║  l.35: 	  Pair['a, 'b](l, r) then [l, r]
 //│ ╙──      	  ^^^^^^^^^^^^^^^^^^
-//│ fun f: anything -> error
+//│ ╔══[ERROR] identifier `l` not found
+//│ ║  l.35: 	  Pair['a, 'b](l, r) then [l, r]
+//│ ╙──      	                           ^
+//│ ╔══[ERROR] identifier `r` not found
+//│ ║  l.35: 	  Pair['a, 'b](l, r) then [l, r]
+//│ ╙──      	                              ^
+//│ ╔══[ERROR] identifier not found: l
+//│ ║  l.35: 	  Pair['a, 'b](l, r) then [l, r]
+//│ ╙──      	                           ^
+//│ ╔══[ERROR] identifier not found: r
+//│ ║  l.35: 	  Pair['a, 'b](l, r) then [l, r]
+//│ ╙──      	                              ^
+//│ fun f: anything -> [error, error]
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unresolved symbol l
 
 
 :e // TODO support
@@ -46,11 +58,14 @@ fun f(e) = if e is
   Pair(l: a, r) then
     let f(x: a) = x
     f(l)
+//│ ╔══[ERROR] identifier `l` not found
+//│ ║  l.60: 	    f(l)
+//│ ╙──      	      ^
 //│ ╔══[ERROR] type identifier not found: a
-//│ ║  l.47: 	    let f(x: a) = x
+//│ ║  l.59: 	    let f(x: a) = x
 //│ ╙──      	             ^
 //│ ╔══[ERROR] identifier not found: l
-//│ ║  l.48: 	    f(l)
+//│ ║  l.60: 	    f(l)
 //│ ╙──      	      ^
 //│ fun f: Pair[anything, anything] -> error
 //│ Code generation encountered an error:
diff --git a/shared/src/test/diff/gadt/Exp2.mls b/shared/src/test/diff/gadt/Exp2.mls
index 45449541c3..c8f3abc408 100644
--- a/shared/src/test/diff/gadt/Exp2.mls
+++ b/shared/src/test/diff/gadt/Exp2.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 
@@ -67,7 +67,7 @@ fun f(e) = if e is
 //│ ╟── type variable `L` leaks out of its scope
 //│ ║  l.43: 	class Pair[L, R](val lhs: Exp[L], val rhs: Exp[R]) extends Exp[[L, R]]
 //│ ╙──      	           ^
-//│ forall 'X 'L 'R. (e: Exp['X]) -> (Int | error | [Exp['L], Exp['R]])
+//│ forall 'L 'R 'X. (e: Exp['X]) -> (Int | error | [Exp['L], Exp['R]])
 //│   where
 //│     'R :> ??R
 //│        <: ??R0
diff --git a/shared/src/test/diff/gadt/ThisMatching.mls b/shared/src/test/diff/gadt/ThisMatching.mls
index cf63b32564..0d58169a2c 100644
--- a/shared/src/test/diff/gadt/ThisMatching.mls
+++ b/shared/src/test/diff/gadt/ThisMatching.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 :e
@@ -28,6 +28,9 @@ Dummy.introspect
 
 
 abstract class Funny: Int { fun test = this + 1 }
+//│ ╔══[ERROR] Undefined type Int
+//│ ║  l.30: 	abstract class Funny: Int { fun test = this + 1 }
+//│ ╙──      	                      ^^^
 //│ abstract class Funny: Int {
 //│   fun test: Int
 //│ }
@@ -35,10 +38,10 @@ abstract class Funny: Int { fun test = this + 1 }
 :e
 class Unfunny { fun test = this + 1 }
 //│ ╔══[ERROR] Type mismatch in operator application:
-//│ ║  l.36: 	class Unfunny { fun test = this + 1 }
+//│ ║  l.39: 	class Unfunny { fun test = this + 1 }
 //│ ║        	                           ^^^^^^^^
 //│ ╟── reference of type `#Unfunny` is not an instance of type `Int`
-//│ ║  l.36: 	class Unfunny { fun test = this + 1 }
+//│ ║  l.39: 	class Unfunny { fun test = this + 1 }
 //│ ╙──      	                           ^^^^
 //│ class Unfunny {
 //│   constructor()
@@ -87,15 +90,15 @@ abstract class Exp: (() | Wrap) {
 }
 class Wrap(n: Exp) extends Exp
 //│ ╔══[ERROR] Unhandled cyclic definition
-//│ ║  l.83: 	abstract class Exp: (() | Wrap) {
+//│ ║  l.86: 	abstract class Exp: (() | Wrap) {
 //│ ║        	         ^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.84: 	  fun test = if this is
+//│ ║  l.87: 	  fun test = if this is
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.85: 	    Wrap(a) then 0
+//│ ║  l.88: 	    Wrap(a) then 0
 //│ ║        	^^^^^^^^^^^^^^^^^^
-//│ ║  l.86: 	    () then 1
+//│ ║  l.89: 	    () then 1
 //│ ║        	^^^^^^^^^^^^^
-//│ ║  l.87: 	}
+//│ ║  l.90: 	}
 //│ ╙──      	^
 //│ abstract class Exp: Wrap | () {
 //│   fun test: 0 | 1
@@ -113,17 +116,17 @@ abstract class Exp: (Pair | Lit) {
 class Lit(n: Int) extends Exp
 class Pair(lhs: Exp, rhs: Exp) extends Exp
 //│ ╔══[ERROR] Unhandled cyclic definition
-//│ ║  l.107: 	abstract class Exp: (Pair | Lit) {
+//│ ║  l.110: 	abstract class Exp: (Pair | Lit) {
 //│ ║         	         ^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.108: 	  fun test: Int
+//│ ║  l.111: 	  fun test: Int
 //│ ║         	^^^^^^^^^^^^^^^
-//│ ║  l.109: 	  fun test = if this is
+//│ ║  l.112: 	  fun test = if this is
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.110: 	    Lit then 0
+//│ ║  l.113: 	    Lit then 0
 //│ ║         	^^^^^^^^^^^^^^
-//│ ║  l.111: 	    Pair(l, r) then 1
+//│ ║  l.114: 	    Pair(l, r) then 1
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.112: 	}
+//│ ║  l.115: 	}
 //│ ╙──       	^
 //│ abstract class Exp: Lit | Pair {
 //│   fun test: Int
@@ -136,7 +139,7 @@ class Pair(lhs: Exp, rhs: Exp) extends Exp
 :e // TODO
 Pair(Lit(1), Lit(2)).test
 //│ ╔══[ERROR] Type `Pair` does not contain member `test`
-//│ ║  l.137: 	Pair(Lit(1), Lit(2)).test
+//│ ║  l.140: 	Pair(Lit(1), Lit(2)).test
 //│ ╙──       	                    ^^^^^
 //│ error
 //│ res
@@ -152,24 +155,27 @@ abstract class Exp: (Pair | Lit) {
 class Lit(n: Int) extends Exp
 class Pair(lhs: Exp, rhs: Exp) extends Exp
 //│ ╔══[ERROR] Unhandled cyclic definition
-//│ ║  l.147: 	abstract class Exp: (Pair | Lit) {
+//│ ║  l.150: 	abstract class Exp: (Pair | Lit) {
 //│ ║         	         ^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.148: 	  fun test = if this is
+//│ ║  l.151: 	  fun test = if this is
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.149: 	    Lit then 0
+//│ ║  l.152: 	    Lit then 0
 //│ ║         	^^^^^^^^^^^^^^
-//│ ║  l.150: 	    Pair(l, r) then l.test + r.test
+//│ ║  l.153: 	    Pair(l, r) then l.test + r.test
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.151: 	}
+//│ ║  l.154: 	}
 //│ ╙──       	^
 //│ ╔══[ERROR] Indirectly-recursive member should have type annotation
-//│ ║  l.150: 	    Pair(l, r) then l.test + r.test
+//│ ║  l.153: 	    Pair(l, r) then l.test + r.test
 //│ ╙──       	                     ^^^^^
+//│ ╔══[ERROR] Indirectly-recursive member should have type annotation
+//│ ║  l.153: 	    Pair(l, r) then l.test + r.test
+//│ ╙──       	                              ^^^^^
 //│ abstract class Exp: Lit | Pair {
-//│   fun test: Int | error
+//│   fun test: Int
 //│ }
 //│ class Lit(n: Int) extends Exp {
-//│   fun test: Int | error
+//│   fun test: Int
 //│ }
 //│ class Pair(lhs: Exp, rhs: Exp) extends Exp
 
@@ -184,17 +190,17 @@ abstract class Exp: (Pair | Lit) {
 class Lit(n: Int) extends Exp
 class Pair(lhs: Exp, rhs: Exp) extends Exp
 //│ ╔══[ERROR] Unhandled cyclic definition
-//│ ║  l.178: 	abstract class Exp: (Pair | Lit) {
+//│ ║  l.184: 	abstract class Exp: (Pair | Lit) {
 //│ ║         	         ^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.179: 	  fun test : Int
+//│ ║  l.185: 	  fun test : Int
 //│ ║         	^^^^^^^^^^^^^^^^
-//│ ║  l.180: 	  fun test = if this is
+//│ ║  l.186: 	  fun test = if this is
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.181: 	    Lit then 0
+//│ ║  l.187: 	    Lit then 0
 //│ ║         	^^^^^^^^^^^^^^
-//│ ║  l.182: 	    Pair(l, r) then l.test + r.test
+//│ ║  l.188: 	    Pair(l, r) then l.test + r.test
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.183: 	}
+//│ ║  l.189: 	}
 //│ ╙──       	^
 //│ abstract class Exp: Lit | Pair {
 //│   fun test: Int
@@ -214,25 +220,25 @@ abstract class Exp[A]: (Pair | Lit) {
 class Lit(n: Int) extends Exp[Int]
 class Pair[L, R](lhs: L, rhs: R) extends Exp[[L, R]]
 //│ ╔══[ERROR] Unhandled cyclic definition
-//│ ║  l.209: 	abstract class Exp[A]: (Pair | Lit) {
+//│ ║  l.215: 	abstract class Exp[A]: (Pair | Lit) {
 //│ ║         	         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.210: 	  fun test = if this is
+//│ ║  l.216: 	  fun test = if this is
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.211: 	    Lit then 0
+//│ ║  l.217: 	    Lit then 0
 //│ ║         	^^^^^^^^^^^^^^
-//│ ║  l.212: 	    Pair then 1
+//│ ║  l.218: 	    Pair then 1
 //│ ║         	^^^^^^^^^^^^^^^
-//│ ║  l.213: 	}
+//│ ║  l.219: 	}
 //│ ╙──       	^
 //│ ╔══[ERROR] Type error in `case` expression
-//│ ║  l.210: 	  fun test = if this is
+//│ ║  l.216: 	  fun test = if this is
 //│ ║         	                ^^^^^^^
-//│ ║  l.211: 	    Lit then 0
+//│ ║  l.217: 	    Lit then 0
 //│ ║         	^^^^^^^^^^^^^^
-//│ ║  l.212: 	    Pair then 1
+//│ ║  l.218: 	    Pair then 1
 //│ ║         	^^^^^^^^^^^^^^^
 //│ ╟── type variable `L` leaks out of its scope
-//│ ║  l.215: 	class Pair[L, R](lhs: L, rhs: R) extends Exp[[L, R]]
+//│ ║  l.221: 	class Pair[L, R](lhs: L, rhs: R) extends Exp[[L, R]]
 //│ ╙──       	           ^
 //│ abstract class Exp[A]: Lit | Pair[anything, anything] {
 //│   fun test: 0 | 1
diff --git a/shared/src/test/diff/nu/Andong.mls b/shared/src/test/diff/nu/Andong.mls
index e2f1e77efc..fa997a5860 100644
--- a/shared/src/test/diff/nu/Andong.mls
+++ b/shared/src/test/diff/nu/Andong.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 class Union<Region>(a: Region, b: Region)
diff --git a/shared/src/test/diff/nu/ArrayProg.mls b/shared/src/test/diff/nu/ArrayProg.mls
index 857ee4e3ac..57e8f50fd9 100644
--- a/shared/src/test/diff/nu/ArrayProg.mls
+++ b/shared/src/test/diff/nu/ArrayProg.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 
@@ -112,10 +112,10 @@ fun add2(e) =
   if e is
     Pair(Numbr(n), Numbr(m)) then Numbr(m + m)
     Pair(Numbr(n), Vectr(n)) then n
-//│ fun add2: Pair[Numbr, Numbr | Vectr] -> (Numbr | Array[Numbr | Vectr])
+//│ fun add2: Pair[Numbr, Numbr | Vectr] -> (Int | Numbr)
 
 add2(Pair(Numbr(0), Numbr(1)))
-//│ Numbr | Array[Numbr | Vectr]
+//│ Int | Numbr
 //│ res
 //│     = Numbr {}
 
@@ -189,34 +189,44 @@ fun add(e) =
     Pair(Numbr(n), Numbr(m))    then 0
     Pair(Vectr(xs),  Vectr(ys)) then 1
     Pair(Vectr(xs),  Numbr(n))  then 2
-//│ ╔══[ERROR] The match is not exhaustive.
-//│ ║  l.+2: 	  if e is
-//│ ║        	     ^^^^
-//│ ╟── The scrutinee at this position misses 1 case.
+//│ ╔══[ERROR] When scrutinee `e` is `Pair`,
 //│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
-//│ ║        	                   ^^^^^^^^
-//│ ╟── [Missing Case 1/1] `Vectr`
-//│ ╟── It first appears here.
+//│ ║        	    ^^^^
+//│ ╟── scrutinee `e$Pair_0` is `Numbr`, and
+//│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
+//│ ║        	         ^^^^^
+//│ ╟── Scrutinee `e$Pair_1` has 1 missing case
+//│ ╟── It can be class `Vectr`
 //│ ║  l.+4: 	    Pair(Vectr(xs),  Vectr(ys)) then 1
-//│ ╙──      	                     ^^^^^^^^^
-//│ fun add: anything -> error
+//│ ╙──      	                     ^^^^^
+//│ fun add: Pair[Numbr | Vectr, Numbr] -> (0 | 1 | 2)
 
 :e
 fun add(e) =
   if e is
     Pair(Numbr(n), Numbr(m))    then 0
     Pair(Vectr(xs),  Vectr(ys)) then 1
-//│ ╔══[ERROR] The match is not exhaustive.
-//│ ║  l.+2: 	  if e is
-//│ ║        	     ^^^^
-//│ ╟── The scrutinee at this position misses 1 case.
+//│ ╔══[ERROR] When scrutinee `e` is `Pair`,
+//│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
+//│ ║        	    ^^^^
+//│ ╟── scrutinee `e$Pair_0` is `Numbr`, and
 //│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
-//│ ║        	                   ^^^^^^^^
-//│ ╟── [Missing Case 1/1] `Vectr`
-//│ ╟── It first appears here.
+//│ ║        	         ^^^^^
+//│ ╟── Scrutinee `e$Pair_1` has 1 missing case
+//│ ╟── It can be class `Vectr`
 //│ ║  l.+4: 	    Pair(Vectr(xs),  Vectr(ys)) then 1
-//│ ╙──      	                     ^^^^^^^^^
-//│ fun add: anything -> error
+//│ ╙──      	                     ^^^^^
+//│ ╔══[ERROR] When scrutinee `e` is `Pair`,
+//│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
+//│ ║        	    ^^^^
+//│ ╟── scrutinee `e$Pair_0` is `Vectr`, and
+//│ ║  l.+4: 	    Pair(Vectr(xs),  Vectr(ys)) then 1
+//│ ║        	         ^^^^^
+//│ ╟── Scrutinee `e$Pair_1` has 1 missing case
+//│ ╟── It can be class `Numbr`
+//│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
+//│ ╙──      	                   ^^^^^
+//│ fun add: Pair[Numbr | Vectr, nothing] -> (0 | 1)
 
 :e
 add2(Pair(Vectr(0), Numbr(1)))
@@ -244,6 +254,6 @@ add2(Pair(Vectr(0), Numbr(1)))
 //│ ╟── Note: type parameter A is defined at:
 //│ ║  l.52: 	class Pair[A, B](a: A, b: B)
 //│ ╙──      	           ^
-//│ Numbr | error | Array[Numbr | Vectr]
+//│ Int | Numbr | error
 
 
diff --git a/shared/src/test/diff/nu/BadUCS.mls b/shared/src/test/diff/nu/BadUCS.mls
index b0eda308c0..c4fd3013e4 100644
--- a/shared/src/test/diff/nu/BadUCS.mls
+++ b/shared/src/test/diff/nu/BadUCS.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 class Foo
@@ -23,57 +23,77 @@ fun foo(x) = if x is Bar then 0
 //│ fun foo: Bar -> 0
 
 :e
+:ge
 fun foo(x) = if x is Foo0 then 0
-//│ ╔══[ERROR] Cannot find constructor `Foo0` in scope
-//│ ║  l.26: 	fun foo(x) = if x is Foo0 then 0
+//│ ╔══[ERROR] type identifier `Foo0` not found
+//│ ║  l.27: 	fun foo(x) = if x is Foo0 then 0
 //│ ╙──      	                     ^^^^
-//│ fun foo: anything -> error
+//│ ╔══[ERROR] type identifier not found: Foo0
+//│ ║  l.27: 	fun foo(x) = if x is Foo0 then 0
+//│ ╙──      	                     ^^^^
+//│ fun foo: nothing -> error
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unknown match case: Foo0
 
 
 type F = Foo
 //│ type F = Foo
 
 :e
+:ge
 fun foo(x) = if x is F then 0
-//│ ╔══[ERROR] Cannot find constructor `F` in scope
-//│ ║  l.39: 	fun foo(x) = if x is F then 0
+//│ ╔══[ERROR] Type alias is not allowed in pattern
+//│ ║  l.44: 	fun foo(x) = if x is F then 0
+//│ ╙──      	                     ^
+//│ ╔══[ERROR] can only match on classes and traits
+//│ ║  l.44: 	fun foo(x) = if x is F then 0
 //│ ╙──      	                     ^
-//│ fun foo: anything -> error
+//│ fun foo: nothing -> error
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   cannot match type alias F
 
 :e
+:ge
 fun foo(x) = if x is F() then 0
-//│ ╔══[ERROR] Illegal pattern `F`
-//│ ║  l.48: 	fun foo(x) = if x is F() then 0
+//│ ╔══[ERROR] Type alias is not allowed in pattern
+//│ ║  l.57: 	fun foo(x) = if x is F() then 0
+//│ ╙──      	                     ^
+//│ ╔══[ERROR] can only match on classes and traits
+//│ ║  l.57: 	fun foo(x) = if x is F() then 0
 //│ ╙──      	                     ^
-//│ fun foo: anything -> error
+//│ fun foo: nothing -> error
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   cannot match type alias F
 
 
 mixin M
 //│ mixin M()
 
 :e
+:ge
 fun foo(x) = if x is M then 0
-//│ ╔══[ERROR] Cannot find constructor `M` in scope
-//│ ║  l.61: 	fun foo(x) = if x is M then 0
+//│ ╔══[ERROR] Mixins are not allowed in pattern
+//│ ║  l.74: 	fun foo(x) = if x is M then 0
 //│ ╙──      	                     ^
-//│ fun foo: anything -> error
+//│ ╔══[ERROR] can only match on classes and traits
+//│ ║  l.74: 	fun foo(x) = if x is M then 0
+//│ ╙──      	                     ^
+//│ fun foo: nothing -> error
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unknown match case: M
 
 :e
+:ge
 fun foo(x) = if x is M() then 0
-//│ ╔══[ERROR] Illegal pattern `M`
-//│ ║  l.70: 	fun foo(x) = if x is M() then 0
+//│ ╔══[ERROR] Mixins are not allowed in pattern
+//│ ║  l.87: 	fun foo(x) = if x is M() then 0
+//│ ╙──      	                     ^
+//│ ╔══[ERROR] can only match on classes and traits
+//│ ║  l.87: 	fun foo(x) = if x is M() then 0
 //│ ╙──      	                     ^
-//│ fun foo: anything -> error
+//│ fun foo: nothing -> error
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unknown match case: M
 
 
 fun foo0(x, y) = if x is y then 0
@@ -84,22 +104,29 @@ fun foo = 0
 //│ fun foo: 0
 
 :e
+:ge
 fun foo0(x) = if x is foo() then 0
-//│ ╔══[ERROR] Illegal pattern `foo`
-//│ ║  l.87: 	fun foo0(x) = if x is foo() then 0
-//│ ╙──      	                      ^^^
-//│ fun foo0: anything -> error
+//│ ╔══[ERROR] type identifier `foo` not found
+//│ ║  l.108: 	fun foo0(x) = if x is foo() then 0
+//│ ╙──       	                      ^^^
+//│ ╔══[ERROR] can only match on classes and traits
+//│ ║  l.108: 	fun foo0(x) = if x is foo() then 0
+//│ ╙──       	                      ^^^
+//│ fun foo0: nothing -> error
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unknown match case: foo
 
 :e
+:ge
+// FIXME: Typer.scala:1497
 fun foo(x) = if x is foo() then 0
-//│ ╔══[ERROR] Illegal pattern `foo`
-//│ ║  l.96: 	fun foo(x) = if x is foo() then 0
-//│ ╙──      	                     ^^^
-//│ fun foo: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] type identifier `foo` not found
+//│ ║  l.122: 	fun foo(x) = if x is foo() then 0
+//│ ╙──       	                     ^^^
+//│ ╔══[ERROR] can only match on classes and traits
+//│ ║  l.122: 	fun foo(x) = if x is foo() then 0
+//│ ╙──       	                     ^^^
+//│ /!!!\ Uncaught error: java.lang.Exception: Internal Error: Program reached and unexpected state.
 
 module Nil
 class Cons[out A](head: A, tail: Cons[A] | Nil)
diff --git a/shared/src/test/diff/nu/BasicClassInheritance.mls b/shared/src/test/diff/nu/BasicClassInheritance.mls
index 29907d3302..b365a2b0b0 100644
--- a/shared/src/test/diff/nu/BasicClassInheritance.mls
+++ b/shared/src/test/diff/nu/BasicClassInheritance.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 class A
diff --git a/shared/src/test/diff/nu/BasicClasses.mls b/shared/src/test/diff/nu/BasicClasses.mls
index a24dc50fff..0877423d9b 100644
--- a/shared/src/test/diff/nu/BasicClasses.mls
+++ b/shared/src/test/diff/nu/BasicClasses.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 class A(val n: Int)
diff --git a/shared/src/test/diff/nu/CaseExpr.mls b/shared/src/test/diff/nu/CaseExpr.mls
index c6ebf859ed..0cb1b78ba6 100644
--- a/shared/src/test/diff/nu/CaseExpr.mls
+++ b/shared/src/test/diff/nu/CaseExpr.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 case 0 then true
@@ -63,21 +63,27 @@ map(succ) of None
 fun map(f) = case
   Some(x)   then Some(f(x))
   None as n then n
-//│ ╔══[ERROR] Illegal pattern `as`
+//│ ╔══[ERROR] type identifier `as` not found
 //│ ║  l.65: 	  None as n then n
 //│ ╙──      	       ^^
-//│ fun map: anything -> anything -> error
+//│ ╔══[ERROR] identifier `as` not found
+//│ ║  l.65: 	  None as n then n
+//│ ╙──      	       ^^
+//│ ╔══[ERROR] type identifier not found: as
+//│ ║  l.65: 	  None as n then n
+//│ ╙──      	       ^^
+//│ fun map: forall 'a 'A. ('a -> 'A) -> Some['a] -> (Some['A] | error)
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unresolved symbol as
 
 
 :pe
 case 1
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'case'; found integer literal instead
-//│ ║  l.75: 	case 1
+//│ ║  l.81: 	case 1
 //│ ║        	     ^
 //│ ╟── Note: 'case' expression starts here:
-//│ ║  l.75: 	case 1
+//│ ║  l.81: 	case 1
 //│ ╙──      	^^^^
 //│ anything -> 1
 //│ res
@@ -86,13 +92,13 @@ case 1
 :pe
 case (1 then true)
 //│ ╔══[PARSE ERROR] Unexpected 'then' keyword here
-//│ ║  l.87: 	case (1 then true)
+//│ ║  l.93: 	case (1 then true)
 //│ ╙──      	        ^^^^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'case'; found integer literal instead
-//│ ║  l.87: 	case (1 then true)
+//│ ║  l.93: 	case (1 then true)
 //│ ║        	     ^^^^^^^^^^^^^
 //│ ╟── Note: 'case' expression starts here:
-//│ ║  l.87: 	case (1 then true)
+//│ ║  l.93: 	case (1 then true)
 //│ ╙──      	^^^^
 //│ anything -> 1
 //│ res
@@ -106,16 +112,16 @@ case else 0
 :pe
 case then 1 else 0
 //│ ╔══[PARSE ERROR] Unexpected 'then' keyword in expression position
-//│ ║  l.107: 	case then 1 else 0
+//│ ║  l.113: 	case then 1 else 0
 //│ ╙──       	     ^^^^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'case'; found integer literal instead
-//│ ║  l.107: 	case then 1 else 0
+//│ ║  l.113: 	case then 1 else 0
 //│ ║         	          ^
 //│ ╟── Note: 'case' expression starts here:
-//│ ║  l.107: 	case then 1 else 0
+//│ ║  l.113: 	case then 1 else 0
 //│ ╙──       	^^^^
 //│ ╔══[PARSE ERROR] Expected end of input; found 'else' keyword instead
-//│ ║  l.107: 	case then 1 else 0
+//│ ║  l.113: 	case then 1 else 0
 //│ ╙──       	            ^^^^
 //│ anything -> 1
 //│ res
@@ -129,16 +135,19 @@ case then 1 else 0
 :e
 case x, y then x + y
 //│ ╔══[PARSE ERROR] Expected an expression; found a 'then'/'else' clause instead
-//│ ║  l.130: 	case x, y then x + y
+//│ ║  l.136: 	case x, y then x + y
 //│ ╙──       	        ^^^^^^^^^^^^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'case'; found operator application instead
-//│ ║  l.130: 	case x, y then x + y
+//│ ║  l.136: 	case x, y then x + y
 //│ ║         	     ^^^^^^^^^^^^^^^
 //│ ╟── Note: 'case' expression starts here:
-//│ ║  l.130: 	case x, y then x + y
+//│ ║  l.136: 	case x, y then x + y
 //│ ╙──       	^^^^
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.136: 	case x, y then x + y
+//│ ╙──       	     ^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.130: 	case x, y then x + y
+//│ ║  l.136: 	case x, y then x + y
 //│ ╙──       	     ^
 //│ anything -> ()
 //│ Code generation encountered an error:
@@ -146,20 +155,28 @@ case x, y then x + y
 
 :e
 case (x, y) then x + y
-//│ ╔══[ERROR] Illegal pattern `,`
-//│ ║  l.148: 	case (x, y) then x + y
+//│ ╔══[ERROR] type identifier `,` not found
+//│ ║  l.157: 	case (x, y) then x + y
+//│ ╙──       	      ^^^^
+//│ ╔══[ERROR] identifier , refers to different symbols.
+//│ ║  l.157: 	case (x, y) then x + y
+//│ ║         	      ^^^^
+//│ ╟── it is resolved to `,`
+//│ ╙── it was previously resolved to local `,`
+//│ ╔══[ERROR] type identifier not found: ,
+//│ ║  l.157: 	case (x, y) then x + y
 //│ ╙──       	      ^^^^
-//│ anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
-
-:e // * FIXME[UCS]
-case [x, y] then x + y
-//│ ╔══[ERROR] type identifier not found: Tuple#2
-//│ ╙──
 //│ nothing -> error
 //│ Code generation encountered an error:
-//│   unknown match case: Tuple#2
+//│   unresolved symbol ,
 
 
+let foo = case [x, y] then x + y
+//│ let foo: {0: Int, 1: Int} -> Int
+//│ foo
+//│     = [Function: foo1]
 
+foo([1, 2])
+//│ Int
+//│ res
+//│     = 3
diff --git a/shared/src/test/diff/nu/ClassSignatures.mls b/shared/src/test/diff/nu/ClassSignatures.mls
index 20c59c9429..f4fe3759b6 100644
--- a/shared/src/test/diff/nu/ClassSignatures.mls
+++ b/shared/src/test/diff/nu/ClassSignatures.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 abstract class C0: C1 | C2
diff --git a/shared/src/test/diff/nu/ClassesInMixins.mls b/shared/src/test/diff/nu/ClassesInMixins.mls
index eb76284141..c325820485 100644
--- a/shared/src/test/diff/nu/ClassesInMixins.mls
+++ b/shared/src/test/diff/nu/ClassesInMixins.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 
@@ -41,17 +41,18 @@ M.Foo
 
 :e // TODO support
 fun foo(x) = if x is M.Foo then 1
-//│ ╔══[ERROR] illegal pattern
+//│ ╔══[ERROR] Unknown pattern (M).Foo
 //│ ║  l.43: 	fun foo(x) = if x is M.Foo then 1
 //│ ╙──      	                     ^^^^^
-//│ fun foo: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ fun foo: anything -> 1
 
 :e
 mixin Test2 { let f = Foo(1) }
+//│ ╔══[ERROR] identifier `Foo` not found
+//│ ║  l.50: 	mixin Test2 { let f = Foo(1) }
+//│ ╙──      	                      ^^^
 //│ ╔══[ERROR] identifier not found: Foo
-//│ ║  l.52: 	mixin Test2 { let f = Foo(1) }
+//│ ║  l.50: 	mixin Test2 { let f = Foo(1) }
 //│ ╙──      	                      ^^^
 //│ mixin Test2() {
 //│   let f: error
@@ -61,14 +62,17 @@ mixin Test2 { let f = Foo(1) }
 
 :e
 mixin Test3 { fun f(x) = if x is Foo then 1 }
-//│ ╔══[ERROR] Cannot find constructor `Foo` in scope
-//│ ║  l.63: 	mixin Test3 { fun f(x) = if x is Foo then 1 }
+//│ ╔══[ERROR] type identifier `Foo` not found
+//│ ║  l.64: 	mixin Test3 { fun f(x) = if x is Foo then 1 }
+//│ ╙──      	                                 ^^^
+//│ ╔══[ERROR] type identifier not found: Foo
+//│ ║  l.64: 	mixin Test3 { fun f(x) = if x is Foo then 1 }
 //│ ╙──      	                                 ^^^
 //│ mixin Test3() {
-//│   fun f: anything -> error
+//│   fun f: nothing -> error
 //│ }
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unknown match case: Foo
 
 
 
@@ -83,10 +87,10 @@ mixin Test {
     Add(l, r) then this.size(l) + this.size(r)
 }
 //│ ╔══[ERROR] Type error in application
-//│ ║  l.80: 	    fun cached = size(this)
+//│ ║  l.84: 	    fun cached = size(this)
 //│ ║        	                 ^^^^^^^^^^
 //│ ╟── type variable `A` leaks out of its scope
-//│ ║  l.78: 	  class Add<A>(lhs: A, rhs: A) {
+//│ ║  l.82: 	  class Add<A>(lhs: A, rhs: A) {
 //│ ╙──      	            ^
 //│ mixin Test() {
 //│   this: {size: (??A | 'a) -> Int}
diff --git a/shared/src/test/diff/nu/CommaOperator.mls b/shared/src/test/diff/nu/CommaOperator.mls
index 6d7e46db0b..4c13a82409 100644
--- a/shared/src/test/diff/nu/CommaOperator.mls
+++ b/shared/src/test/diff/nu/CommaOperator.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 1; 2
@@ -208,6 +208,9 @@ foo(1), 2
 
 :ge // FIXME
 let rec x() = x() in x
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.210: 	let rec x() = x() in x
+//│ ╙──       	              ^
 //│ nothing
 //│ Code generation encountered an error:
 //│   recursive non-function definition x is not supported
@@ -216,7 +219,7 @@ let rec x() = x() in x
 :pe
 let x[T] = 1 in x
 //│ ╔══[PARSE ERROR] Expected function parameter list; found square bracket section instead
-//│ ║  l.217: 	let x[T] = 1 in x
+//│ ║  l.220: 	let x[T] = 1 in x
 //│ ╙──       	     ^^^
 //│ 1
 //│ res
@@ -281,16 +284,16 @@ foo(
 :e
 foo(log(1);2)
 //│ ╔══[PARSE ERROR] Unexpected semicolon here
-//│ ║  l.282: 	foo(log(1);2)
+//│ ║  l.285: 	foo(log(1);2)
 //│ ╙──       	          ^
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.282: 	foo(log(1);2)
+//│ ║  l.285: 	foo(log(1);2)
 //│ ║         	^^^^^^^^^^^^^
 //│ ╟── argument of type `[?a]` does not match type `[?b, ?c]`
-//│ ║  l.282: 	foo(log(1);2)
+//│ ║  l.285: 	foo(log(1);2)
 //│ ║         	   ^^^^^^^^^^
 //│ ╟── Note: constraint arises from tuple literal:
-//│ ║  l.245: 	fun foo(x, y) = [x, y]
+//│ ║  l.248: 	fun foo(x, y) = [x, y]
 //│ ╙──       	       ^^^^^^
 //│ error | [nothing, nothing]
 //│ res
@@ -301,13 +304,13 @@ foo(log(1);2)
 :e
 foo((log(1),2))
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.302: 	foo((log(1),2))
+//│ ║  l.305: 	foo((log(1),2))
 //│ ║         	^^^^^^^^^^^^^^^
 //│ ╟── argument of type `[?a]` does not match type `[?b, ?c]`
-//│ ║  l.302: 	foo((log(1),2))
+//│ ║  l.305: 	foo((log(1),2))
 //│ ║         	   ^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from tuple literal:
-//│ ║  l.245: 	fun foo(x, y) = [x, y]
+//│ ║  l.248: 	fun foo(x, y) = [x, y]
 //│ ╙──       	       ^^^^^^
 //│ error | [nothing, nothing]
 //│ res
@@ -326,13 +329,13 @@ foo((let x = log(0), 1; log(x), x + 1), 2)
 :e
 foo(let x = log(0), 1; log(x), x + 1)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.327: 	foo(let x = log(0), 1; log(x), x + 1)
+//│ ║  l.330: 	foo(let x = log(0), 1; log(x), x + 1)
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── argument of type `[?a]` does not match type `[?b, ?c]`
-//│ ║  l.327: 	foo(let x = log(0), 1; log(x), x + 1)
+//│ ║  l.330: 	foo(let x = log(0), 1; log(x), x + 1)
 //│ ║         	   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from tuple literal:
-//│ ║  l.245: 	fun foo(x, y) = [x, y]
+//│ ║  l.248: 	fun foo(x, y) = [x, y]
 //│ ╙──       	       ^^^^^^
 //│ error | [nothing, nothing]
 //│ res
@@ -344,13 +347,13 @@ foo(let x = log(0), 1; log(x), x + 1)
 :e
 foo(let x = log(0), 1 in log(x), x + 1)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.345: 	foo(let x = log(0), 1 in log(x), x + 1)
+//│ ║  l.348: 	foo(let x = log(0), 1 in log(x), x + 1)
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── argument of type `[?a]` does not match type `[?b, ?c]`
-//│ ║  l.345: 	foo(let x = log(0), 1 in log(x), x + 1)
+//│ ║  l.348: 	foo(let x = log(0), 1 in log(x), x + 1)
 //│ ║         	   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from tuple literal:
-//│ ║  l.245: 	fun foo(x, y) = [x, y]
+//│ ║  l.248: 	fun foo(x, y) = [x, y]
 //│ ╙──       	       ^^^^^^
 //│ error | [nothing, nothing]
 //│ res
@@ -362,13 +365,13 @@ foo(let x = log(0), 1 in log(x), x + 1)
 :e
 foo(let x = log(0), 1; log(x), 1 + 1)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.363: 	foo(let x = log(0), 1; log(x), 1 + 1)
+//│ ║  l.366: 	foo(let x = log(0), 1; log(x), 1 + 1)
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── argument of type `[?a]` does not match type `[?b, ?c]`
-//│ ║  l.363: 	foo(let x = log(0), 1; log(x), 1 + 1)
+//│ ║  l.366: 	foo(let x = log(0), 1; log(x), 1 + 1)
 //│ ║         	   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from tuple literal:
-//│ ║  l.245: 	fun foo(x, y) = [x, y]
+//│ ║  l.248: 	fun foo(x, y) = [x, y]
 //│ ╙──       	       ^^^^^^
 //│ error | [nothing, nothing]
 //│ res
@@ -380,13 +383,13 @@ foo(let x = log(0), 1; log(x), 1 + 1)
 :e
 foo(if true then 1 else 2, 3)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.381: 	foo(if true then 1 else 2, 3)
+//│ ║  l.384: 	foo(if true then 1 else 2, 3)
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── argument of type `[1 | ?a]` does not match type `[?b, ?c]`
-//│ ║  l.381: 	foo(if true then 1 else 2, 3)
+//│ ║  l.384: 	foo(if true then 1 else 2, 3)
 //│ ║         	   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from tuple literal:
-//│ ║  l.245: 	fun foo(x, y) = [x, y]
+//│ ║  l.248: 	fun foo(x, y) = [x, y]
 //│ ╙──       	       ^^^^^^
 //│ error | [nothing, nothing]
 //│ res
@@ -400,13 +403,13 @@ foo((if true then 1 else 2), 3)
 :e
 foo(if true then log("ok"), 1 else log("nok"), 2, 3)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.401: 	foo(if true then log("ok"), 1 else log("nok"), 2, 3)
+//│ ║  l.404: 	foo(if true then log("ok"), 1 else log("nok"), 2, 3)
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── argument of type `[?a | ?b]` does not match type `[?c, ?d]`
-//│ ║  l.401: 	foo(if true then log("ok"), 1 else log("nok"), 2, 3)
+//│ ║  l.404: 	foo(if true then log("ok"), 1 else log("nok"), 2, 3)
 //│ ║         	   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from tuple literal:
-//│ ║  l.245: 	fun foo(x, y) = [x, y]
+//│ ║  l.248: 	fun foo(x, y) = [x, y]
 //│ ╙──       	       ^^^^^^
 //│ error | [nothing, nothing]
 //│ res
diff --git a/shared/src/test/diff/nu/CtorSubtraction.mls b/shared/src/test/diff/nu/CtorSubtraction.mls
index 9a58ce6842..06555d1ee4 100644
--- a/shared/src/test/diff/nu/CtorSubtraction.mls
+++ b/shared/src/test/diff/nu/CtorSubtraction.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 class Cls
diff --git a/shared/src/test/diff/nu/Eval.mls b/shared/src/test/diff/nu/Eval.mls
index 0f5dd3d2e2..1fdb1d6240 100644
--- a/shared/src/test/diff/nu/Eval.mls
+++ b/shared/src/test/diff/nu/Eval.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 
@@ -138,7 +138,7 @@ module Lists { // TODO use name List when module overloading is supported:
 //│ module Lists {
 //│   fun assoc: forall 'a 'A. 'a -> (Cons[{key: Eql['a], value: 'A}] | Nil) -> (None | Some['A])
 //│   fun map: forall 'b 'A0. ('b -> 'A0) -> (Cons['b] | Nil) -> (Cons['A0] | Nil)
-//│   fun zip: forall 'c 'd. (Cons['d] | Nil, Cons['c] | Nil) -> (Cons[['d, 'c]] | Nil)
+//│   fun zip: forall 'c 'd. (Cons['c] | Nil, Cons['d] | Nil) -> (Cons[['c, 'd]] | Nil)
 //│ }
 
 let xs = 1 :: 2 :: 3 :: Nil
@@ -260,12 +260,12 @@ fun eval(t, env) = if t is
     else err(String(pree) ++ " does not have field " ++ nme)
   Rcd(fs) then
     Rcd of fs |> Lists.map of {key, value} => {key, value: eval(value, env)}
-//│ fun eval: forall 'a 'b 'c. ('c, Cons[{key: Eql[Str], value: 'a}] & {List#A <: {key: Eql[Str], value: 'a}} & List[{key: Eql[Str], value: 'a}] | Nil & {List#A <: {key: Eql[Str], value: 'a}} & List[{key: Eql[Str], value: 'a}]) -> 'b
+//│ fun eval: forall 'a 'b 'c. ('a, Cons[{key: Eql[Str], value: 'b}] & {List#A <: {key: Eql[Str], value: 'b}} & List[{key: Eql[Str], value: 'b}] | Nil & {List#A <: {key: Eql[Str], value: 'b}} & List[{key: Eql[Str], value: 'b}]) -> ('b | 'c)
 //│   where
-//│     'a :> 'b
-//│        <: Object & ~#Rcd | Rcd['a]
-//│     'b :> 'a | Rcd[Lam | Lit[??A] | 'b] | Lam | Lit[??A]
-//│     'c <: App | Lam | Lit[anything] | Rcd['c] | Sel | Var
+//│     'b :> 'c
+//│        <: Object & ~#Rcd | Rcd['b]
+//│     'c :> Rcd[Lam | Lit[??A] | 'b | 'c] | Lam | Lit[??A] | 'b
+//│     'a <: App | Lam | Lit[anything] | Rcd['a] | Sel | Var
 
 eval : (Term, List[{key: Str, value: Value}]) -> Value
 //│ (Term, List[{key: Str, value: Value}]) -> Value
diff --git a/shared/src/test/diff/nu/EvalNegNeg.mls b/shared/src/test/diff/nu/EvalNegNeg.mls
index 4e3fbbaba2..2b8f7d527c 100644
--- a/shared/src/test/diff/nu/EvalNegNeg.mls
+++ b/shared/src/test/diff/nu/EvalNegNeg.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 class Add<out E>(lhs: E, rhs: E)
diff --git a/shared/src/test/diff/nu/ExpressionProblem_repro.mls b/shared/src/test/diff/nu/ExpressionProblem_repro.mls
index 70a8a32ed0..d6b883fee3 100644
--- a/shared/src/test/diff/nu/ExpressionProblem_repro.mls
+++ b/shared/src/test/diff/nu/ExpressionProblem_repro.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 :NoJS
 
 
diff --git a/shared/src/test/diff/nu/ExpressionProblem_small.mls b/shared/src/test/diff/nu/ExpressionProblem_small.mls
index 128c1eee71..db03532e12 100644
--- a/shared/src/test/diff/nu/ExpressionProblem_small.mls
+++ b/shared/src/test/diff/nu/ExpressionProblem_small.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 :NoJS
 
 
diff --git a/shared/src/test/diff/nu/FilterMap.mls b/shared/src/test/diff/nu/FilterMap.mls
index 2f2526e146..b926fc85a0 100644
--- a/shared/src/test/diff/nu/FilterMap.mls
+++ b/shared/src/test/diff/nu/FilterMap.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 // * From https://arxiv.org/abs/2302.12783
@@ -28,11 +28,10 @@ fun filtermap(f, xs) = if xs is
     false then filtermap(f, ys)
     true then Cons(y, filtermap(f, ys))
     [true, z] then Cons(y, filtermap(f, ys))
-//│ ╔══[ERROR] type identifier not found: Tuple#2
-//│ ╙──
-//│ fun filtermap: ((Cons[nothing] | Nil) -> Bool, Cons[anything] | Nil) -> (Cons[nothing] | Nil | error)
-//│ Code generation encountered an error:
-//│   unknown match case: Tuple#2
+//│ ╔══[ERROR] unsupported pattern
+//│ ║  l.30: 	    [true, z] then Cons(y, filtermap(f, ys))
+//│ ╙──      	     ^^^^
+//│ fun filtermap: ((Cons[nothing] | Nil) -> (Object & {1: anything} & ~false & ~true | false | true), Cons[anything] | Nil) -> (Cons[nothing] | Nil)
 
 
 module Tru
diff --git a/shared/src/test/diff/nu/FlatIfThenElse.mls b/shared/src/test/diff/nu/FlatIfThenElse.mls
index 03a92984ec..37e3a3daa6 100644
--- a/shared/src/test/diff/nu/FlatIfThenElse.mls
+++ b/shared/src/test/diff/nu/FlatIfThenElse.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 type Option[out A] = Some[A] | None
@@ -97,6 +97,7 @@ fun test(x: Option[Int]) =
 // Q: Support?
 :pe
 :e
+:w
 fun test(x: Option[Int]) =
   if x is
     None then [0, 0]
@@ -105,22 +106,64 @@ fun test(x: Option[Int]) =
     log(value)
     [value - 1, value + 1]
 //│ ╔══[PARSE ERROR] Unexpected 'then' keyword in expression position
-//│ ║  l.104: 	  then
+//│ ║  l.105: 	  then
 //│ ╙──       	  ^^^^
-//│ ╔══[ERROR] Illegal interleaved statement App(Var(Some),Tup(List((None,Fld(_,Var(value))))))
-//│ ║  l.103: 	    Some(value)
+//│ ╔══[ERROR] identifier `value` not found
+//│ ║  l.107: 	    [value - 1, value + 1]
+//│ ╙──       	     ^^^^^
+//│ ╔══[ERROR] identifier `value` not found
+//│ ║  l.107: 	    [value - 1, value + 1]
+//│ ╙──       	                ^^^^^
+//│ ╔══[ERROR] identifier `value` not found
+//│ ║  l.106: 	    log(value)
+//│ ╙──       	        ^^^^^
+//│ ╔══[ERROR] Unexpected statement in an if block
+//│ ║  l.104: 	    Some(value)
 //│ ╙──       	    ^^^^^^^^^^^
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.102: 	  if x is
+//│ ║         	     ^^^^
+//│ ║  l.103: 	    None then [0, 0]
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ╟── type `Some[Int]` is not an instance of type `None`
+//│ ║  l.4: 	type Option[out A] = Some[A] | None
+//│ ║       	                     ^^^^^^^
+//│ ╟── but it flows into reference with expected type `None`
+//│ ║  l.102: 	  if x is
+//│ ║         	     ^
+//│ ╟── Note: constraint arises from class pattern:
+//│ ║  l.103: 	    None then [0, 0]
+//│ ╙──       	    ^^^^
+//│ ╔══[WARNING] Expression in statement position should have type `()`.
+//│ ╟── Use a comma expression `... , ()` to explicitly discard non-unit values, making your intent clearer.
+//│ ╟── Type mismatch in if-else block:
+//│ ║  l.102: 	  if x is
+//│ ║         	     ^^^^
+//│ ║  l.103: 	    None then [0, 0]
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.104: 	    Some(value)
+//│ ║         	^^^^^^^^^^^^^^^
+//│ ╟── tuple literal of type `[0, 0]` does not match type `()`
+//│ ║  l.103: 	    None then [0, 0]
+//│ ║         	              ^^^^^^
+//│ ╟── but it flows into expression in statement position with expected type `()`
+//│ ║  l.102: 	  if x is
+//│ ║         	     ^^^^
+//│ ║  l.103: 	    None then [0, 0]
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.104: 	    Some(value)
+//│ ╙──       	^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] identifier not found: value
-//│ ║  l.105: 	    log(value)
+//│ ║  l.106: 	    log(value)
 //│ ╙──       	        ^^^^^
 //│ ╔══[ERROR] identifier not found: value
-//│ ║  l.106: 	    [value - 1, value + 1]
+//│ ║  l.107: 	    [value - 1, value + 1]
 //│ ╙──       	     ^^^^^
 //│ ╔══[ERROR] identifier not found: value
-//│ ║  l.106: 	    [value - 1, value + 1]
+//│ ║  l.107: 	    [value - 1, value + 1]
 //│ ╙──       	                ^^^^^
 //│ fun test: (x: Option[Int]) -> [Int, Int]
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unresolved symbol value
 
 
diff --git a/shared/src/test/diff/nu/FlatMonads.mls b/shared/src/test/diff/nu/FlatMonads.mls
index 2358f88b61..6345cc86f6 100644
--- a/shared/src/test/diff/nu/FlatMonads.mls
+++ b/shared/src/test/diff/nu/FlatMonads.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 declare fun String: anything -> Str
@@ -120,7 +120,11 @@ printLine("").bind of () => error
 //│ res
 //│     = Bind {}
 
+:w
 printLine("").bind of (()) => error
+//│ ╔══[WARNING] literal patterns are ignored
+//│ ║  l.124: 	printLine("").bind of (()) => error
+//│ ╙──       	                       ^^
 //│ Bind[(), 'B]
 //│ res
 //│     = Bind {}
@@ -304,13 +308,13 @@ let r = loop(defaultCtx).run
 :e
 not(r)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.305: 	not(r)
+//│ ║  l.309: 	not(r)
 //│ ║         	^^^^^^
 //│ ╟── type `Int` is not an instance of type `Bool`
 //│ ║  l.34: 	module readInt extends IO[Int] { fun run: Int = 42 }
 //│ ║        	                          ^^^
 //│ ╟── but it flows into reference with expected type `Bool`
-//│ ║  l.305: 	not(r)
+//│ ║  l.309: 	not(r)
 //│ ╙──       	    ^
 //│ error | false | true
 //│ res
@@ -354,16 +358,20 @@ main
 //│     = Bind {}
 
 
+:w
 :e
 let r = printLine("").bind of 0 => Pure(1)
+//│ ╔══[WARNING] literal patterns are ignored
+//│ ║  l.363: 	let r = printLine("").bind of 0 => Pure(1)
+//│ ╙──       	                              ^
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.358: 	let r = printLine("").bind of 0 => Pure(1)
+//│ ║  l.363: 	let r = printLine("").bind of 0 => Pure(1)
 //│ ║         	        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── application of type `()` does not match type `0`
-//│ ║  l.323: 	class printLine(str: Str) extends IO { fun run = log(str) }
+//│ ║  l.327: 	class printLine(str: Str) extends IO { fun run = log(str) }
 //│ ║         	                                                 ^^^^^^^^
 //│ ╟── Note: constraint arises from integer literal:
-//│ ║  l.358: 	let r = printLine("").bind of 0 => Pure(1)
+//│ ║  l.363: 	let r = printLine("").bind of 0 => Pure(1)
 //│ ╙──       	                              ^
 //│ let r: Bind[in 0 & 'A out () | 'A, 'B] | error
 //│   where
@@ -376,20 +384,20 @@ let r = printLine("").bind of x =>
 log(x.a)
 Pure(1)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.375: 	let r = printLine("").bind of x =>
+//│ ║  l.383: 	let r = printLine("").bind of x =>
 //│ ║         	        ^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.376: 	log(x.a)
+//│ ║  l.384: 	log(x.a)
 //│ ║         	^^^^^^^^^
-//│ ║  l.377: 	Pure(1)
+//│ ║  l.385: 	Pure(1)
 //│ ║         	^^^^^^^
 //│ ╟── application of type `()` does not have field 'a'
-//│ ║  l.323: 	class printLine(str: Str) extends IO { fun run = log(str) }
+//│ ║  l.327: 	class printLine(str: Str) extends IO { fun run = log(str) }
 //│ ║         	                                                 ^^^^^^^^
 //│ ╟── Note: constraint arises from field selection:
-//│ ║  l.376: 	log(x.a)
+//│ ║  l.384: 	log(x.a)
 //│ ║         	    ^^^
 //│ ╟── from reference:
-//│ ║  l.376: 	log(x.a)
+//│ ║  l.384: 	log(x.a)
 //│ ╙──       	    ^
 //│ let r: Bind[in {a: anything} & 'A out () | 'A, 'B] | error
 //│   where
diff --git a/shared/src/test/diff/nu/FunnyIndet.mls b/shared/src/test/diff/nu/FunnyIndet.mls
index 3cd12c5189..f0eb4d45bd 100644
--- a/shared/src/test/diff/nu/FunnyIndet.mls
+++ b/shared/src/test/diff/nu/FunnyIndet.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 2 +
@@ -31,12 +31,12 @@
 :e // TODO support
 2 is
   2
-//│ ╔══[ERROR] illegal pattern
+//│ ╔══[ERROR] Unknown pattern {2}
 //│ ║  l.33: 	  2
 //│ ╙──      	  ^
-//│ error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ true
+//│ res
+//│     = true
 
 if 2 is 2 then true
 //│ true
diff --git a/shared/src/test/diff/nu/GADTMono.mls b/shared/src/test/diff/nu/GADTMono.mls
index 0d8323d5fb..1221d79b90 100644
--- a/shared/src/test/diff/nu/GADTMono.mls
+++ b/shared/src/test/diff/nu/GADTMono.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 trait Expr[A]: LitInt | LitBool | Add | Cond | Pair | Fst | Snd
 class LitInt(n: Int) extends Expr[Int]
diff --git a/shared/src/test/diff/nu/GenericClasses.mls b/shared/src/test/diff/nu/GenericClasses.mls
index 8ce63d9db9..64c1ef7f9e 100644
--- a/shared/src/test/diff/nu/GenericClasses.mls
+++ b/shared/src/test/diff/nu/GenericClasses.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 class C<A>
diff --git a/shared/src/test/diff/nu/GenericModules.mls b/shared/src/test/diff/nu/GenericModules.mls
index 778511bb83..75c5b56cea 100644
--- a/shared/src/test/diff/nu/GenericModules.mls
+++ b/shared/src/test/diff/nu/GenericModules.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 // * TODO generic module definitions need to be restricted so they do not include nay state
diff --git a/shared/src/test/diff/nu/HeungTung.mls b/shared/src/test/diff/nu/HeungTung.mls
index 3b0c9c2480..04143b150f 100644
--- a/shared/src/test/diff/nu/HeungTung.mls
+++ b/shared/src/test/diff/nu/HeungTung.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 
@@ -134,6 +134,9 @@ f(refined if true then 0 else false) // this one can be precise again!
 //│ ╔══[WARNING] Paren-less applications should use the 'of' keyword
 //│ ║  l.133: 	f(refined if true then 0 else false) // this one can be precise again!
 //│ ╙──       	  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╔══[ERROR] identifier `refined` not found
+//│ ║  l.133: 	f(refined if true then 0 else false) // this one can be precise again!
+//│ ╙──       	  ^^^^^^^
 //│ ╔══[ERROR] Illegal use of reserved operator: refined
 //│ ║  l.133: 	f(refined if true then 0 else false) // this one can be precise again!
 //│ ╙──       	  ^^^^^^^
@@ -196,7 +199,7 @@ type T = List[Int]
 :e // TODO application types
 type Res = M(T)
 //│ ╔══[ERROR] Wrong number of type arguments – expected 0, found 1
-//│ ║  l.197: 	type Res = M(T)
+//│ ║  l.200: 	type Res = M(T)
 //│ ╙──       	           ^^^^
 //│ type Res = M
 
@@ -219,7 +222,7 @@ fun f: Int -> Int
 fun f: Bool -> Bool
 fun f = id
 //│ ╔══[ERROR] A type signature for 'f' was already given
-//│ ║  l.219: 	fun f: Bool -> Bool
+//│ ║  l.222: 	fun f: Bool -> Bool
 //│ ╙──       	^^^^^^^^^^^^^^^^^^^
 //│ fun f: forall 'a. 'a -> 'a
 //│ fun f: Int -> Int
@@ -227,13 +230,13 @@ fun f = id
 :e // TODO support
 f: (Int -> Int) & (Bool -> Bool)
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.228: 	f: (Int -> Int) & (Bool -> Bool)
+//│ ║  l.231: 	f: (Int -> Int) & (Bool -> Bool)
 //│ ║         	^
 //│ ╟── type `Bool` is not an instance of type `Int`
-//│ ║  l.228: 	f: (Int -> Int) & (Bool -> Bool)
+//│ ║  l.231: 	f: (Int -> Int) & (Bool -> Bool)
 //│ ║         	                   ^^^^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.218: 	fun f: Int -> Int
+//│ ║  l.221: 	fun f: Int -> Int
 //│ ╙──       	       ^^^
 //│ Int -> Int & Bool -> Bool
 //│ res
@@ -300,17 +303,20 @@ fun test(x) = refined if x is
   A then 0
   B then 1
 //│ ╔══[WARNING] Paren-less applications should use the 'of' keyword
-//│ ║  l.299: 	fun test(x) = refined if x is
+//│ ║  l.302: 	fun test(x) = refined if x is
 //│ ║         	              ^^^^^^^^^^^^^^^
-//│ ║  l.300: 	  A then 0
+//│ ║  l.303: 	  A then 0
 //│ ║         	^^^^^^^^^^
-//│ ║  l.301: 	  B then 1
+//│ ║  l.304: 	  B then 1
 //│ ╙──       	^^^^^^^^^^
+//│ ╔══[ERROR] identifier `refined` not found
+//│ ║  l.302: 	fun test(x) = refined if x is
+//│ ╙──       	              ^^^^^^^
 //│ ╔══[ERROR] Illegal use of reserved operator: refined
-//│ ║  l.299: 	fun test(x) = refined if x is
+//│ ║  l.302: 	fun test(x) = refined if x is
 //│ ╙──       	              ^^^^^^^
 //│ ╔══[ERROR] identifier not found: refined
-//│ ║  l.299: 	fun test(x) = refined if x is
+//│ ║  l.302: 	fun test(x) = refined if x is
 //│ ╙──       	              ^^^^^^^
 //│ fun test: (A | B) -> error
 //│ Code generation encountered an error:
diff --git a/shared/src/test/diff/nu/Huawei1.mls b/shared/src/test/diff/nu/Huawei1.mls
index 7b939fe6a1..4ca49f190b 100644
--- a/shared/src/test/diff/nu/Huawei1.mls
+++ b/shared/src/test/diff/nu/Huawei1.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 class C[out A](x: A) {
diff --git a/shared/src/test/diff/nu/InterfaceMono.mls b/shared/src/test/diff/nu/InterfaceMono.mls
index c19e5930c4..f5088e03b5 100644
--- a/shared/src/test/diff/nu/InterfaceMono.mls
+++ b/shared/src/test/diff/nu/InterfaceMono.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 trait Showable {
@@ -10,6 +10,9 @@ trait Showable {
 
 :e
 trait What0 extends woooo
+//│ ╔══[ERROR] could not find definition `woooo`
+//│ ║  l.12: 	trait What0 extends woooo
+//│ ╙──      	                    ^^^^^
 //│ ╔══[ERROR] Could not find definition `woooo`
 //│ ║  l.12: 	trait What0 extends woooo
 //│ ╙──      	                    ^^^^^
@@ -30,7 +33,7 @@ class What1(toString: Str) extends Showable
 :e
 trait NoShow extends What1("hi")
 //│ ╔══[ERROR] A trait can only inherit from other traits
-//│ ║  l.31: 	trait NoShow extends What1("hi")
+//│ ║  l.34: 	trait NoShow extends What1("hi")
 //│ ╙──      	                     ^^^^^^^^^^^
 //│ trait NoShow extends Showable, What1
 
@@ -41,19 +44,19 @@ class ErrC2 extends Showable {
 }
 class ErrC3(toString: Str -> Str) extends Showable
 //│ ╔══[ERROR] Member `toString` is declared (or its declaration is inherited) but is not implemented in `ErrC1`
-//│ ║  l.38: 	class ErrC1 extends Showable
+//│ ║  l.41: 	class ErrC1 extends Showable
 //│ ║        	      ^^^^^
 //│ ╟── Declared here:
 //│ ║  l.5: 	    fun toString: Str
 //│ ╙──     	    ^^^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in definition of method toString:
-//│ ║  l.40: 	    fun toString = 114
+//│ ║  l.43: 	    fun toString = 114
 //│ ║        	        ^^^^^^^^^^^^^^
 //│ ╟── integer literal of type `114` is not an instance of type `Str`
-//│ ║  l.40: 	    fun toString = 114
+//│ ║  l.43: 	    fun toString = 114
 //│ ║        	                   ^^^
 //│ ╟── but it flows into definition of method toString with expected type `Str`
-//│ ║  l.40: 	    fun toString = 114
+//│ ║  l.43: 	    fun toString = 114
 //│ ║        	        ^^^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from type reference:
 //│ ║  l.5: 	    fun toString: Str
@@ -62,7 +65,7 @@ class ErrC3(toString: Str -> Str) extends Showable
 //│ ║  l.5: 	    fun toString: Str
 //│ ╙──     	        ^^^^^^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in function type:
-//│ ║  l.42: 	class ErrC3(toString: Str -> Str) extends Showable
+//│ ║  l.45: 	class ErrC3(toString: Str -> Str) extends Showable
 //│ ║        	                      ^^^^^^^^^^
 //│ ╟── type `Str -> Str` is not an instance of type `Str`
 //│ ╟── Note: constraint arises from type reference:
@@ -125,41 +128,41 @@ class Errcity(size: Int) extends SizedStadt {
     fun bar = "hahaha"
 }
 //│ ╔══[ERROR] Type mismatch in definition of method bar:
-//│ ║  l.125: 	    fun bar = "hahaha"
+//│ ║  l.128: 	    fun bar = "hahaha"
 //│ ║         	        ^^^^^^^^^^^^^^
 //│ ╟── string literal of type `"hahaha"` is not a function
-//│ ║  l.125: 	    fun bar = "hahaha"
+//│ ║  l.128: 	    fun bar = "hahaha"
 //│ ║         	              ^^^^^^^^
 //│ ╟── but it flows into definition of method bar with expected type `Int -> Int`
-//│ ║  l.125: 	    fun bar = "hahaha"
+//│ ║  l.128: 	    fun bar = "hahaha"
 //│ ║         	        ^^^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from function type:
-//│ ║  l.103: 	    fun bar: Int -> Int
+//│ ║  l.106: 	    fun bar: Int -> Int
 //│ ║         	             ^^^^^^^^^^
 //│ ╟── from signature of member `bar`:
-//│ ║  l.103: 	    fun bar: Int -> Int
+//│ ║  l.106: 	    fun bar: Int -> Int
 //│ ╙──       	        ^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.124: 	class Errcity(size: Int) extends SizedStadt {
+//│ ║  l.127: 	class Errcity(size: Int) extends SizedStadt {
 //│ ║         	                    ^^^
 //│ ╟── type `Int` does not match type `1 | 2 | 3`
 //│ ╟── Note: constraint arises from union type:
-//│ ║  l.102: 	    let size: 1 | 2 | 3
+//│ ║  l.105: 	    let size: 1 | 2 | 3
 //│ ║         	              ^^^^^^^^^
 //│ ╟── from signature of member `size`:
-//│ ║  l.102: 	    let size: 1 | 2 | 3
+//│ ║  l.105: 	    let size: 1 | 2 | 3
 //│ ╙──       	        ^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] Member `name` is declared (or its declaration is inherited) but is not implemented in `Errcity`
-//│ ║  l.124: 	class Errcity(size: Int) extends SizedStadt {
+//│ ║  l.127: 	class Errcity(size: Int) extends SizedStadt {
 //│ ║         	      ^^^^^^^
 //│ ╟── Declared here:
-//│ ║  l.85: 	    let name: Str
+//│ ║  l.88: 	    let name: Str
 //│ ╙──      	    ^^^^^^^^^^^^^
 //│ ╔══[ERROR] Member `foo` is declared (or its declaration is inherited) but is not implemented in `Errcity`
-//│ ║  l.124: 	class Errcity(size: Int) extends SizedStadt {
+//│ ║  l.127: 	class Errcity(size: Int) extends SizedStadt {
 //│ ║         	      ^^^^^^^
 //│ ╟── Declared here:
-//│ ║  l.93: 	    fun foo: Bool -> Int
+//│ ║  l.96: 	    fun foo: Bool -> Int
 //│ ╙──      	    ^^^^^^^^^^^^^^^^^^^^
 //│ class Errcity(size: Int) extends RefinedStadt, SizedStadt, Stadt {
 //│   fun bar: "hahaha"
@@ -208,19 +211,19 @@ class Dirtberg extends More, SizedStadt, Fooo {
     fun size = 4    // this should not check
 }
 //│ ╔══[ERROR] Type mismatch in definition of method size:
-//│ ║  l.208: 	    fun size = 4    // this should not check
+//│ ║  l.211: 	    fun size = 4    // this should not check
 //│ ║         	        ^^^^^^^^
 //│ ╟── integer literal of type `4` does not match type `1 | 2 | 3`
-//│ ║  l.208: 	    fun size = 4    // this should not check
+//│ ║  l.211: 	    fun size = 4    // this should not check
 //│ ║         	               ^
 //│ ╟── but it flows into definition of method size with expected type `1 | 2 | 3`
-//│ ║  l.208: 	    fun size = 4    // this should not check
+//│ ║  l.211: 	    fun size = 4    // this should not check
 //│ ║         	        ^^^^^^^^
 //│ ╟── Note: constraint arises from union type:
-//│ ║  l.102: 	    let size: 1 | 2 | 3
+//│ ║  l.105: 	    let size: 1 | 2 | 3
 //│ ║         	              ^^^^^^^^^
 //│ ╟── from signature of member `size`:
-//│ ║  l.102: 	    let size: 1 | 2 | 3
+//│ ║  l.105: 	    let size: 1 | 2 | 3
 //│ ╙──       	        ^^^^^^^^^^^^^^^
 //│ class Dirtberg extends RefinedStadt, SizedStadt, Stadt {
 //│   constructor()
@@ -248,19 +251,19 @@ class A { virtual fun x: Int = 1 }
 :e
 class B extends A { fun x = "A" }
 //│ ╔══[ERROR] Type mismatch in definition of method x:
-//│ ║  l.249: 	class B extends A { fun x = "A" }
+//│ ║  l.252: 	class B extends A { fun x = "A" }
 //│ ║         	                        ^^^^^^^
 //│ ╟── string literal of type `"A"` is not an instance of type `Int`
-//│ ║  l.249: 	class B extends A { fun x = "A" }
+//│ ║  l.252: 	class B extends A { fun x = "A" }
 //│ ║         	                            ^^^
 //│ ╟── but it flows into definition of method x with expected type `Int`
-//│ ║  l.249: 	class B extends A { fun x = "A" }
+//│ ║  l.252: 	class B extends A { fun x = "A" }
 //│ ║         	                        ^^^^^^^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.242: 	class A { virtual fun x: Int = 1 }
+//│ ║  l.245: 	class A { virtual fun x: Int = 1 }
 //│ ║         	                         ^^^
 //│ ╟── from definition of method x:
-//│ ║  l.242: 	class A { virtual fun x: Int = 1 }
+//│ ║  l.245: 	class A { virtual fun x: Int = 1 }
 //│ ╙──       	                      ^^^^^^^^^^
 //│ class B extends A {
 //│   constructor()
@@ -270,7 +273,7 @@ class B extends A { fun x = "A" }
 :e
 class C1[A] { virtual fun a: A = this.a }
 //│ ╔══[ERROR] Indirectly-recursive member should have type annotation
-//│ ║  l.271: 	class C1[A] { virtual fun a: A = this.a }
+//│ ║  l.274: 	class C1[A] { virtual fun a: A = this.a }
 //│ ╙──       	                                     ^^
 //│ class C1[A] {
 //│   constructor()
@@ -304,19 +307,19 @@ class C extends MyTrait[Int] { fun a = 1 }
 :e
 class C extends MyTrait[Int] { fun a = false }
 //│ ╔══[ERROR] Type mismatch in definition of method a:
-//│ ║  l.305: 	class C extends MyTrait[Int] { fun a = false }
+//│ ║  l.308: 	class C extends MyTrait[Int] { fun a = false }
 //│ ║         	                                   ^^^^^^^^^
 //│ ╟── reference of type `false` is not an instance of `Int`
-//│ ║  l.305: 	class C extends MyTrait[Int] { fun a = false }
+//│ ║  l.308: 	class C extends MyTrait[Int] { fun a = false }
 //│ ║         	                                       ^^^^^
 //│ ╟── but it flows into definition of method a with expected type `Int`
-//│ ║  l.305: 	class C extends MyTrait[Int] { fun a = false }
+//│ ║  l.308: 	class C extends MyTrait[Int] { fun a = false }
 //│ ║         	                                   ^^^^^^^^^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.305: 	class C extends MyTrait[Int] { fun a = false }
+//│ ║  l.308: 	class C extends MyTrait[Int] { fun a = false }
 //│ ║         	                        ^^^
 //│ ╟── from signature of member `a`:
-//│ ║  l.290: 	trait MyTrait[A] { fun a: A }
+//│ ║  l.293: 	trait MyTrait[A] { fun a: A }
 //│ ╙──       	                       ^^^^
 //│ class C extends MyTrait {
 //│   constructor()
@@ -358,19 +361,19 @@ class C3 extends T4{
     fun bar = false
 }
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.357: 	    fun foo = 3
+//│ ║  l.360: 	    fun foo = 3
 //│ ║         	        ^^^^^^^
 //│ ╟── integer literal of type `3` does not match type `2`
-//│ ║  l.357: 	    fun foo = 3
+//│ ║  l.360: 	    fun foo = 3
 //│ ║         	              ^
 //│ ╟── but it flows into definition of method foo with expected type `2`
-//│ ║  l.357: 	    fun foo = 3
+//│ ║  l.360: 	    fun foo = 3
 //│ ║         	        ^^^^^^^
 //│ ╟── Note: constraint arises from literal type:
-//│ ║  l.345: 	    fun foo: 2
+//│ ║  l.348: 	    fun foo: 2
 //│ ║         	             ^
 //│ ╟── from signature of member `foo`:
-//│ ║  l.345: 	    fun foo: 2
+//│ ║  l.348: 	    fun foo: 2
 //│ ╙──       	        ^^^^^^
 //│ class C3 extends T1, T2, T4 {
 //│   constructor()
@@ -381,24 +384,24 @@ class C3 extends T4{
 :e
 class C2(foo: Int, bar: Str) extends T4
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.382: 	class C2(foo: Int, bar: Str) extends T4
+//│ ║  l.385: 	class C2(foo: Int, bar: Str) extends T4
 //│ ║         	              ^^^
 //│ ╟── type `Int` does not match type `2`
 //│ ╟── Note: constraint arises from literal type:
-//│ ║  l.345: 	    fun foo: 2
+//│ ║  l.348: 	    fun foo: 2
 //│ ║         	             ^
 //│ ╟── from signature of member `foo`:
-//│ ║  l.345: 	    fun foo: 2
+//│ ║  l.348: 	    fun foo: 2
 //│ ╙──       	        ^^^^^^
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.382: 	class C2(foo: Int, bar: Str) extends T4
+//│ ║  l.385: 	class C2(foo: Int, bar: Str) extends T4
 //│ ║         	                        ^^^
 //│ ╟── type `Str` does not match type `Int | false | true`
 //│ ╟── Note: constraint arises from union type:
-//│ ║  l.333: 	    let bar : Int | Bool
+//│ ║  l.336: 	    let bar : Int | Bool
 //│ ║         	              ^^^^^^^^^^
 //│ ╟── from signature of member `bar`:
-//│ ║  l.333: 	    let bar : Int | Bool
+//│ ║  l.336: 	    let bar : Int | Bool
 //│ ╙──       	        ^^^^^^^^^^^^^^^^
 //│ class C2(foo: Int, bar: Str) extends T1, T2, T4
 
@@ -407,19 +410,19 @@ trait T5 extends T4 {
     let foo: 4
 }
 //│ ╔══[ERROR] Type mismatch in signature of member `foo`:
-//│ ║  l.407: 	    let foo: 4
+//│ ║  l.410: 	    let foo: 4
 //│ ║         	        ^^^^^^
 //│ ╟── type `4` does not match type `2`
-//│ ║  l.407: 	    let foo: 4
+//│ ║  l.410: 	    let foo: 4
 //│ ║         	             ^
 //│ ╟── but it flows into signature of member `foo` with expected type `2`
-//│ ║  l.407: 	    let foo: 4
+//│ ║  l.410: 	    let foo: 4
 //│ ║         	        ^^^^^^
 //│ ╟── Note: constraint arises from literal type:
-//│ ║  l.345: 	    fun foo: 2
+//│ ║  l.348: 	    fun foo: 2
 //│ ║         	             ^
 //│ ╟── from signature of member `foo`:
-//│ ║  l.345: 	    fun foo: 2
+//│ ║  l.348: 	    fun foo: 2
 //│ ╙──       	        ^^^^^^
 //│ trait T5 extends T1, T2, T4 {
 //│   fun bar: Bool
@@ -431,34 +434,34 @@ trait T3 extends T1, T2 {
     let foo: true
 }
 //│ ╔══[ERROR] Type mismatch in signature of member `foo`:
-//│ ║  l.431: 	    let foo: true
+//│ ║  l.434: 	    let foo: true
 //│ ║         	        ^^^^^^^^^
 //│ ╟── type `true` does not match type `1 | 2 | 3`
-//│ ║  l.431: 	    let foo: true
+//│ ║  l.434: 	    let foo: true
 //│ ║         	             ^^^^
 //│ ╟── but it flows into signature of member `foo` with expected type `1 | 2 | 3`
-//│ ║  l.431: 	    let foo: true
+//│ ║  l.434: 	    let foo: true
 //│ ║         	        ^^^^^^^^^
 //│ ╟── Note: constraint arises from union type:
-//│ ║  l.328: 	    let foo : 1 | 2 | 3 
+//│ ║  l.331: 	    let foo : 1 | 2 | 3 
 //│ ║         	              ^^^^^^^^^
 //│ ╟── from signature of member `foo`:
-//│ ║  l.328: 	    let foo : 1 | 2 | 3 
+//│ ║  l.331: 	    let foo : 1 | 2 | 3 
 //│ ╙──       	        ^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in signature of member `foo`:
-//│ ║  l.431: 	    let foo: true
+//│ ║  l.434: 	    let foo: true
 //│ ║         	        ^^^^^^^^^
 //│ ╟── type `true` does not match type `2 | 3 | 4`
-//│ ║  l.431: 	    let foo: true
+//│ ║  l.434: 	    let foo: true
 //│ ║         	             ^^^^
 //│ ╟── but it flows into signature of member `foo` with expected type `2 | 3 | 4`
-//│ ║  l.431: 	    let foo: true
+//│ ║  l.434: 	    let foo: true
 //│ ║         	        ^^^^^^^^^
 //│ ╟── Note: constraint arises from union type:
-//│ ║  l.332: 	    let foo : 2 | 3 | 4
+//│ ║  l.335: 	    let foo : 2 | 3 | 4
 //│ ║         	              ^^^^^^^^^
 //│ ╟── from signature of member `foo`:
-//│ ║  l.332: 	    let foo : 2 | 3 | 4
+//│ ║  l.335: 	    let foo : 2 | 3 | 4
 //│ ╙──       	        ^^^^^^^^^^^^^^^
 //│ trait T3 extends T1, T2 {
 //│   fun bar: Bool
diff --git a/shared/src/test/diff/nu/Interfaces.mls b/shared/src/test/diff/nu/Interfaces.mls
index 995e0eab56..11ef7fd1c4 100644
--- a/shared/src/test/diff/nu/Interfaces.mls
+++ b/shared/src/test/diff/nu/Interfaces.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 trait Test {
@@ -531,6 +531,9 @@ if b is
 
 :e
 let tt1 = Test
+//│ ╔══[ERROR] identifier `Test` is resolved to a type
+//│ ║  l.533: 	let tt1 = Test
+//│ ╙──       	          ^^^^
 //│ ╔══[ERROR] trait Test cannot be used in term position
 //│ ║  l.533: 	let tt1 = Test
 //│ ╙──       	          ^^^^
@@ -538,14 +541,10 @@ let tt1 = Test
 //│ Code generation encountered an error:
 //│   trait used in term position
 
-:e
+
 fun mt(x) = if x is Test then 1 else 0
-//│ ╔══[ERROR] Cannot match on trait `Test`
-//│ ║  l.542: 	fun mt(x) = if x is Test then 1 else 0
-//│ ╙──       	                    ^^^^
-//│ fun mt: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ fun mt: nothing -> error
+
 
 trait Geo
 trait ZL extends Geo
@@ -607,40 +606,40 @@ z: WP
 g: ZL
 e: ZL & WP
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.605: 	fun fto(w: WP): EM = w
+//│ ║  l.604: 	fun fto(w: WP): EM = w
 //│ ║         	                     ^
 //│ ╟── type `#WP` is not an instance of type `EM`
-//│ ║  l.605: 	fun fto(w: WP): EM = w
+//│ ║  l.604: 	fun fto(w: WP): EM = w
 //│ ║         	           ^^
 //│ ╟── but it flows into reference with expected type `#EM`
-//│ ║  l.605: 	fun fto(w: WP): EM = w
+//│ ║  l.604: 	fun fto(w: WP): EM = w
 //│ ║         	                     ^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.605: 	fun fto(w: WP): EM = w
+//│ ║  l.604: 	fun fto(w: WP): EM = w
 //│ ╙──       	                ^^
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.606: 	z: WP
+//│ ║  l.605: 	z: WP
 //│ ║         	^
 //│ ╟── type `#ZL` is not an instance of type `WP`
-//│ ║  l.562: 	let z: ZL
+//│ ║  l.561: 	let z: ZL
 //│ ║         	       ^^
 //│ ╟── but it flows into reference with expected type `#WP`
-//│ ║  l.606: 	z: WP
+//│ ║  l.605: 	z: WP
 //│ ║         	^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.606: 	z: WP
+//│ ║  l.605: 	z: WP
 //│ ╙──       	   ^^
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.607: 	g: ZL
+//│ ║  l.606: 	g: ZL
 //│ ║         	^
 //│ ╟── type `#Geo` is not an instance of type `ZL`
-//│ ║  l.561: 	let g: Geo
+//│ ║  l.560: 	let g: Geo
 //│ ║         	       ^^^
 //│ ╟── but it flows into reference with expected type `#ZL`
-//│ ║  l.607: 	g: ZL
+//│ ║  l.606: 	g: ZL
 //│ ║         	^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.607: 	g: ZL
+//│ ║  l.606: 	g: ZL
 //│ ╙──       	   ^^
 //│ fun fto: (w: WP) -> EM
 //│ WP & ZL
@@ -696,36 +695,36 @@ class Eh2 extends Bs(true), Ele {
     fun ce(x) = x
 }
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.695: 	    fun foo(x) = x && false
+//│ ║  l.694: 	    fun foo(x) = x && false
 //│ ║         	        ^^^^^^^^^^^^^^^^^^^
 //│ ╟── expression of type `Int & ?a` is not an instance of type `Bool`
 //│ ╟── Note: constraint arises from reference:
-//│ ║  l.695: 	    fun foo(x) = x && false
+//│ ║  l.694: 	    fun foo(x) = x && false
 //│ ╙──       	                 ^
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.695: 	    fun foo(x) = x && false
+//│ ║  l.694: 	    fun foo(x) = x && false
 //│ ║         	        ^^^^^^^^^^^^^^^^^^^
 //│ ╟── expression of type `Int & ?a` does not match type `Bool`
 //│ ╟── Note: constraint arises from reference:
-//│ ║  l.695: 	    fun foo(x) = x && false
+//│ ║  l.694: 	    fun foo(x) = x && false
 //│ ╙──       	                 ^
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.695: 	    fun foo(x) = x && false
+//│ ║  l.694: 	    fun foo(x) = x && false
 //│ ║         	        ^^^^^^^^^^^^^^^^^^^
 //│ ╟── operator application of type `Bool` does not match type `Int | ?a`
-//│ ║  l.695: 	    fun foo(x) = x && false
+//│ ║  l.694: 	    fun foo(x) = x && false
 //│ ║         	                 ^^^^^^^^^^
 //│ ╟── Note: constraint arises from operator application:
-//│ ║  l.658: 	  virtual fun foo(x) = x + 1
+//│ ║  l.657: 	  virtual fun foo(x) = x + 1
 //│ ╙──       	                       ^^^^^
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.695: 	    fun foo(x) = x && false
+//│ ║  l.694: 	    fun foo(x) = x && false
 //│ ║         	        ^^^^^^^^^^^^^^^^^^^
 //│ ╟── operator application of type `Bool` does not match type `Int | ?a`
-//│ ║  l.695: 	    fun foo(x) = x && false
+//│ ║  l.694: 	    fun foo(x) = x && false
 //│ ║         	                 ^^^^^^^^^^
 //│ ╟── Note: constraint arises from operator application:
-//│ ║  l.658: 	  virtual fun foo(x) = x + 1
+//│ ║  l.657: 	  virtual fun foo(x) = x + 1
 //│ ╙──       	                       ^^^^^
 //│ class Eh2 extends Bs, Ele {
 //│   constructor()
@@ -738,34 +737,34 @@ class Eh extends Bs(1)
 class Eh1 extends Bs
 class Eh3 extends Bs(false), Test
 //│ ╔══[ERROR] Type mismatch in type declaration:
-//│ ║  l.737: 	class Eh extends Bs(1)
+//│ ║  l.736: 	class Eh extends Bs(1)
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── integer literal of type `1` is not an instance of type `Bool`
-//│ ║  l.737: 	class Eh extends Bs(1)
+//│ ║  l.736: 	class Eh extends Bs(1)
 //│ ║         	                    ^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.657: 	class Bs(val a: Bool) {
+//│ ║  l.656: 	class Bs(val a: Bool) {
 //│ ╙──       	                ^^^^
 //│ ╔══[ERROR] Type mismatch in type declaration:
-//│ ║  l.737: 	class Eh extends Bs(1)
+//│ ║  l.736: 	class Eh extends Bs(1)
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── integer literal of type `1` does not match type `Bool`
-//│ ║  l.737: 	class Eh extends Bs(1)
+//│ ║  l.736: 	class Eh extends Bs(1)
 //│ ║         	                    ^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.657: 	class Bs(val a: Bool) {
+//│ ║  l.656: 	class Bs(val a: Bool) {
 //│ ╙──       	                ^^^^
 //│ ╔══[ERROR] class Bs expects 1 parameter(s); got 0
-//│ ║  l.738: 	class Eh1 extends Bs
+//│ ║  l.737: 	class Eh1 extends Bs
 //│ ╙──       	                  ^^
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.658: 	  virtual fun foo(x) = x + 1
+//│ ║  l.657: 	  virtual fun foo(x) = x + 1
 //│ ║         	              ^^^^^^^^^^^^^^
 //│ ╟── function of type `?a -> (forall ?b. ?b)` is not an instance of type `Int`
-//│ ║  l.658: 	  virtual fun foo(x) = x + 1
+//│ ║  l.657: 	  virtual fun foo(x) = x + 1
 //│ ║         	                 ^^^^^^^^^^^
 //│ ╟── but it flows into definition of method foo with expected type `Int`
-//│ ║  l.658: 	  virtual fun foo(x) = x + 1
+//│ ║  l.657: 	  virtual fun foo(x) = x + 1
 //│ ║         	              ^^^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from type reference:
 //│ ║  l.5: 	  fun foo: Int
@@ -774,7 +773,7 @@ class Eh3 extends Bs(false), Test
 //│ ║  l.5: 	  fun foo: Int
 //│ ╙──     	      ^^^^^^^^
 //│ ╔══[ERROR] Member `bar` is declared (or its declaration is inherited) but is not implemented in `Eh3`
-//│ ║  l.739: 	class Eh3 extends Bs(false), Test
+//│ ║  l.738: 	class Eh3 extends Bs(false), Test
 //│ ║         	      ^^^
 //│ ╟── Declared here:
 //│ ║  l.6: 	  fun bar: Bool -> Bool
@@ -852,7 +851,7 @@ abstract class Bc3 {
 :e
 class Bc12() extends Bc1(1), Bc2(true)
 //│ ╔══[ERROR] Cannot inherit from more than one base class: Bc1 and Bc2
-//│ ║  l.853: 	class Bc12() extends Bc1(1), Bc2(true)
+//│ ║  l.852: 	class Bc12() extends Bc1(1), Bc2(true)
 //│ ╙──       	                             ^^^^^^^^^
 //│ class Bc12() extends Bc1, Bc2
 //│ Code generation encountered an error:
@@ -873,24 +872,24 @@ Bc02().foo
 :e
 class Bc31(baz: Bool) extends Bc3
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.874: 	class Bc31(baz: Bool) extends Bc3
+//│ ║  l.873: 	class Bc31(baz: Bool) extends Bc3
 //│ ║         	                ^^^^
 //│ ╟── type `Bool` is not an instance of type `Int`
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.844: 	  let baz : Int
+//│ ║  l.843: 	  let baz : Int
 //│ ║         	            ^^^
 //│ ╟── from signature of member `baz`:
-//│ ║  l.844: 	  let baz : Int
+//│ ║  l.843: 	  let baz : Int
 //│ ╙──       	      ^^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.874: 	class Bc31(baz: Bool) extends Bc3
+//│ ║  l.873: 	class Bc31(baz: Bool) extends Bc3
 //│ ║         	                ^^^^
 //│ ╟── type `Bool` is not an instance of type `Int`
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.844: 	  let baz : Int
+//│ ║  l.843: 	  let baz : Int
 //│ ║         	            ^^^
 //│ ╟── from signature of member `baz`:
-//│ ║  l.844: 	  let baz : Int
+//│ ║  l.843: 	  let baz : Int
 //│ ╙──       	      ^^^^^^^^^
 //│ class Bc31(baz: Bool) extends Bc3
 
@@ -925,7 +924,7 @@ trait BInt extends Base[Int] {
   fun f = error
 }
 //│ ╔══[ERROR] Method implementations in traits are not yet supported
-//│ ║  l.925: 	  fun f = error
+//│ ║  l.924: 	  fun f = error
 //│ ╙──       	  ^^^^^^^^^^^^^
 //│ trait BInt extends Base {
 //│   fun f: nothing
@@ -956,7 +955,7 @@ bp: Base[[Int, Bool]]
 :e
 bp: Base[[Int, Int]]
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.957: 	bp: Base[[Int, Int]]
+//│ ║  l.956: 	bp: Base[[Int, Int]]
 //│ ║         	^^
 //│ ╙── expression of type `true` is not an instance of type `Int`
 //│ Base[[Int, Int]]
@@ -1017,13 +1016,13 @@ trait BInfer2 extends Base {
 :e
 class DerBad1 extends Base[Int, Int]
 //│ ╔══[ERROR] trait Base expects 1 type parameter(s); got 2
-//│ ║  l.1018: 	class DerBad1 extends Base[Int, Int]
+//│ ║  l.1017: 	class DerBad1 extends Base[Int, Int]
 //│ ╙──        	                      ^^^^^^^^^^^^^
 //│ ╔══[ERROR] Member `f` is declared (or its declaration is inherited) but is not implemented in `DerBad1`
-//│ ║  l.1018: 	class DerBad1 extends Base[Int, Int]
+//│ ║  l.1017: 	class DerBad1 extends Base[Int, Int]
 //│ ║          	      ^^^^^^^
 //│ ╟── Declared here:
-//│ ║  l.906: 	trait Base[A] { fun f: A -> A }
+//│ ║  l.905: 	trait Base[A] { fun f: A -> A }
 //│ ╙──       	                ^^^^^^^^^^^^^
 //│ class DerBad1 extends Base {
 //│   constructor()
@@ -1035,32 +1034,32 @@ class DerBad1 extends Base[Int, Int]
 :e
 class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ╔══[ERROR] Type mismatch in definition of method f:
-//│ ║  l.1036: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
+//│ ║  l.1035: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ║          	                                            ^^^^^^^^^^^^^^^^^^
 //│ ╟── reference of type `B` does not match type `A`
-//│ ║  l.1036: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
+//│ ║  l.1035: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ║          	                                                         ^
 //│ ╟── Note: constraint arises from type parameter:
-//│ ║  l.1036: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
+//│ ║  l.1035: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ║          	           ^
 //│ ╟── Note: type parameter B is defined at:
-//│ ║  l.1036: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
+//│ ║  l.1035: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ╙──        	              ^
 //│ ╔══[ERROR] Type mismatch in definition of method f:
-//│ ║  l.1036: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
+//│ ║  l.1035: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ║          	                                            ^^^^^^^^^^^^^^^^^^
 //│ ╟── reference of type `A` does not match type `B`
-//│ ║  l.1036: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
+//│ ║  l.1035: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ║          	                                                            ^
 //│ ╟── Note: constraint arises from type parameter:
-//│ ║  l.1036: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
+//│ ║  l.1035: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ║          	              ^
 //│ ╟── Note: type parameter A is defined at:
-//│ ║  l.1036: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
+//│ ║  l.1035: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ╙──        	           ^
 //│ class Der2[A, B] extends Base {
 //│   constructor()
-//│   fun f: forall 'a 'b. (['b, 'a]) -> ['a, 'b]
+//│   fun f: forall 'a 'b. (['a, 'b]) -> ['b, 'a]
 //│ }
 
 trait Ta[T] {
@@ -1108,7 +1107,7 @@ trait Tb extends Ta[Int] {
   virtual val p = false
 }
 //│ ╔══[ERROR] Method implementations in traits are not yet supported
-//│ ║  l.1108: 	  virtual val p = false
+//│ ║  l.1107: 	  virtual val p = false
 //│ ╙──        	          ^^^^^^^^^^^^^
 //│ trait Tb extends Ta {
 //│   val g: 'T
@@ -1143,24 +1142,24 @@ trait Oz {
 :e
 class Fischl(age: Bool) extends Oz
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.1144: 	class Fischl(age: Bool) extends Oz
+//│ ║  l.1143: 	class Fischl(age: Bool) extends Oz
 //│ ║          	                  ^^^^
 //│ ╟── type `Bool` is not an instance of type `Int`
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.1137: 	  let age: Int
+//│ ║  l.1136: 	  let age: Int
 //│ ║          	           ^^^
 //│ ╟── from signature of member `age`:
-//│ ║  l.1137: 	  let age: Int
+//│ ║  l.1136: 	  let age: Int
 //│ ╙──        	      ^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.1144: 	class Fischl(age: Bool) extends Oz
+//│ ║  l.1143: 	class Fischl(age: Bool) extends Oz
 //│ ║          	                  ^^^^
 //│ ╟── type `Bool` is not an instance of type `Int`
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.1137: 	  let age: Int
+//│ ║  l.1136: 	  let age: Int
 //│ ║          	           ^^^
 //│ ╟── from signature of member `age`:
-//│ ║  l.1137: 	  let age: Int
+//│ ║  l.1136: 	  let age: Int
 //│ ╙──        	      ^^^^^^^^
 //│ class Fischl(age: Bool) extends Oz
 
@@ -1180,36 +1179,36 @@ class Go extends Fate {
     fun foo(x) = x && true
 }
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.1180: 	    fun foo(x) = x && true
+//│ ║  l.1179: 	    fun foo(x) = x && true
 //│ ║          	        ^^^^^^^^^^^^^^^^^^
 //│ ╟── expression of type `Int & ?a` is not an instance of type `Bool`
 //│ ╟── Note: constraint arises from reference:
-//│ ║  l.1180: 	    fun foo(x) = x && true
+//│ ║  l.1179: 	    fun foo(x) = x && true
 //│ ╙──        	                 ^
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.1180: 	    fun foo(x) = x && true
+//│ ║  l.1179: 	    fun foo(x) = x && true
 //│ ║          	        ^^^^^^^^^^^^^^^^^^
 //│ ╟── expression of type `Int & ?a` does not match type `Bool`
 //│ ╟── Note: constraint arises from reference:
-//│ ║  l.1180: 	    fun foo(x) = x && true
+//│ ║  l.1179: 	    fun foo(x) = x && true
 //│ ╙──        	                 ^
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.1180: 	    fun foo(x) = x && true
+//│ ║  l.1179: 	    fun foo(x) = x && true
 //│ ║          	        ^^^^^^^^^^^^^^^^^^
 //│ ╟── operator application of type `Bool` does not match type `Int | ?a`
-//│ ║  l.1180: 	    fun foo(x) = x && true
+//│ ║  l.1179: 	    fun foo(x) = x && true
 //│ ║          	                 ^^^^^^^^^
 //│ ╟── Note: constraint arises from operator application:
-//│ ║  l.1171: 	    virtual fun foo(x) = x + 1
+//│ ║  l.1170: 	    virtual fun foo(x) = x + 1
 //│ ╙──        	                         ^^^^^
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.1180: 	    fun foo(x) = x && true
+//│ ║  l.1179: 	    fun foo(x) = x && true
 //│ ║          	        ^^^^^^^^^^^^^^^^^^
 //│ ╟── operator application of type `Bool` does not match type `Int | ?a`
-//│ ║  l.1180: 	    fun foo(x) = x && true
+//│ ║  l.1179: 	    fun foo(x) = x && true
 //│ ║          	                 ^^^^^^^^^
 //│ ╟── Note: constraint arises from operator application:
-//│ ║  l.1171: 	    virtual fun foo(x) = x + 1
+//│ ║  l.1170: 	    virtual fun foo(x) = x + 1
 //│ ╙──        	                         ^^^^^
 //│ class Go extends Fate {
 //│   constructor()
@@ -1228,18 +1227,18 @@ class Haha(x: 1 | 2) extends Ha
 :e
 class Ohhh(x: Bool) extends Ha
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.1229: 	class Ohhh(x: Bool) extends Ha
+//│ ║  l.1228: 	class Ohhh(x: Bool) extends Ha
 //│ ║          	              ^^^^
 //│ ╟── type `Bool` is not an instance of type `Int`
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.1219: 	class Ha { virtual val x: Int = 1 }
+//│ ║  l.1218: 	class Ha { virtual val x: Int = 1 }
 //│ ╙──        	                          ^^^
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.1229: 	class Ohhh(x: Bool) extends Ha
+//│ ║  l.1228: 	class Ohhh(x: Bool) extends Ha
 //│ ║          	              ^^^^
 //│ ╟── type `Bool` is not an instance of type `Int`
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.1219: 	class Ha { virtual val x: Int = 1 }
+//│ ║  l.1218: 	class Ha { virtual val x: Int = 1 }
 //│ ╙──        	                          ^^^
 //│ class Ohhh(x: Bool) extends Ha
 
diff --git a/shared/src/test/diff/nu/LetRec.mls b/shared/src/test/diff/nu/LetRec.mls
index 1ff16fa41a..cb0176f724 100644
--- a/shared/src/test/diff/nu/LetRec.mls
+++ b/shared/src/test/diff/nu/LetRec.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 :js
@@ -145,6 +145,9 @@ let rec f =
 // :e // FIXME
 :ge
 let foo = foo
+//│ ╔══[ERROR] identifier `foo` not found
+//│ ║  l.147: 	let foo = foo
+//│ ╙──       	          ^^^
 //│ let foo: nothing
 //│ Code generation encountered an error:
 //│   unguarded recursive use of by-value binding foo
diff --git a/shared/src/test/diff/nu/ListConsNil.mls b/shared/src/test/diff/nu/ListConsNil.mls
index 7fab3f5102..d705f6d298 100644
--- a/shared/src/test/diff/nu/ListConsNil.mls
+++ b/shared/src/test/diff/nu/ListConsNil.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 
@@ -42,7 +42,7 @@ fun test(x, l) = list_assoc(42, Cons(x, l))
 fun test(x, l) = if l is
   Nil then list_assoc(42, Cons(x, l))
   Cons(h, t) then list_assoc(42, Cons(h, t))
-//│ fun test: forall 'A 'A0. ({_1: anything, _2: 'A}, Cons[{_1: anything, _2: 'A0}] | Nil) -> (Cons['A] | Nil | Cons['A0])
+//│ fun test: forall 'A. ({_1: anything, _2: 'A}, Cons[{_1: anything, _2: 'A}] | Nil) -> (Cons['A] | Nil)
 
 
 
diff --git a/shared/src/test/diff/nu/LitMatch.mls b/shared/src/test/diff/nu/LitMatch.mls
index a2e74b8fe4..ab8f51e8f1 100644
--- a/shared/src/test/diff/nu/LitMatch.mls
+++ b/shared/src/test/diff/nu/LitMatch.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 let r = false : Bool
@@ -22,17 +22,21 @@ b : true | false
 //│     = false
 
 if false is false then 0
+//│ ╙──
 //│ 0
 //│ res
 //│     = 0
 
 fun foo(x) = if x is
   false then 0
+//│ ╙──
 //│ fun foo: false -> 0
 
 fun foo(x) = if x is
   false then 0
   true  then 1
+//│ ╙──
+//│ ╙──
 //│ fun foo: Bool -> (0 | 1)
 
 
diff --git a/shared/src/test/diff/nu/MissingTypeArg.mls b/shared/src/test/diff/nu/MissingTypeArg.mls
index 1eba54d987..fe7011e842 100644
--- a/shared/src/test/diff/nu/MissingTypeArg.mls
+++ b/shared/src/test/diff/nu/MissingTypeArg.mls
@@ -1,6 +1,6 @@
 // * This is an example program where the error we get is really not ideal
 
-:NewDefs
+:PreTyper
 
 
 // * An example recursive definition:
diff --git a/shared/src/test/diff/nu/NamedArgs.mls b/shared/src/test/diff/nu/NamedArgs.mls
index 8c4d4606f1..4933c1d65b 100644
--- a/shared/src/test/diff/nu/NamedArgs.mls
+++ b/shared/src/test/diff/nu/NamedArgs.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 fun test(x: 'a) = if x is undefined then 0 else x + 1
@@ -150,6 +150,12 @@ fun fff(x: Int, y: Int, z: Int) = (x - y) * z
 // * Testing renaming
 :e
 fff(y: 2, z: y_1 + 1, x: z_1 - 2)
+//│ ╔══[ERROR] identifier `y_1` not found
+//│ ║  l.152: 	fff(y: 2, z: y_1 + 1, x: z_1 - 2)
+//│ ╙──       	             ^^^
+//│ ╔══[ERROR] identifier `z_1` not found
+//│ ║  l.152: 	fff(y: 2, z: y_1 + 1, x: z_1 - 2)
+//│ ╙──       	                         ^^^
 //│ ╔══[ERROR] identifier not found: y_1
 //│ ║  l.152: 	fff(y: 2, z: y_1 + 1, x: z_1 - 2)
 //│ ╙──       	             ^^^
@@ -233,7 +239,7 @@ fun print(x) = (y, z) => log([x, y, z])
 let p = print(0)
 p(z: 1, y: 2)
 //│ ╔══[ERROR] Cannot use named arguments as the function type has untyped arguments
-//│ ║  l.234: 	p(z: 1, y: 2)
+//│ ║  l.240: 	p(z: 1, y: 2)
 //│ ╙──       	 ^^^^^^^^^^^^
 //│ fun print: anything -> (anything, anything) -> ()
 //│ let p: (anything, anything) -> ()
@@ -288,8 +294,11 @@ z.y
 
 :e
 (f => f(x: a))
+//│ ╔══[ERROR] identifier `a` not found
+//│ ║  l.296: 	(f => f(x: a))
+//│ ╙──       	           ^
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `?a` for applying named arguments
-//│ ║  l.290: 	(f => f(x: a))
+//│ ║  l.296: 	(f => f(x: a))
 //│ ╙──       	      ^
 //│ anything -> error
 //│ Code generation encountered an error:
@@ -297,8 +306,11 @@ z.y
 
 :e
 (f => f)(error)(x: a)
+//│ ╔══[ERROR] identifier `a` not found
+//│ ║  l.308: 	(f => f)(error)(x: a)
+//│ ╙──       	                   ^
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `?a` for applying named arguments
-//│ ║  l.299: 	(f => f)(error)(x: a)
+//│ ║  l.308: 	(f => f)(error)(x: a)
 //│ ╙──       	^^^^^^^^^^^^^^^
 //│ error
 //│ Code generation encountered an error:
@@ -306,8 +318,11 @@ z.y
 
 :e
 (f => f)(42)(x: a)
+//│ ╔══[ERROR] identifier `a` not found
+//│ ║  l.320: 	(f => f)(42)(x: a)
+//│ ╙──       	                ^
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `?a` for applying named arguments
-//│ ║  l.308: 	(f => f)(42)(x: a)
+//│ ║  l.320: 	(f => f)(42)(x: a)
 //│ ╙──       	^^^^^^^^^^^^
 //│ error
 //│ Code generation encountered an error:
@@ -315,8 +330,11 @@ z.y
 
 :e
 (f => f)(if true then 123 else false)(x: a)
+//│ ╔══[ERROR] identifier `a` not found
+//│ ║  l.332: 	(f => f)(if true then 123 else false)(x: a)
+//│ ╙──       	                                         ^
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `?a` for applying named arguments
-//│ ║  l.317: 	(f => f)(if true then 123 else false)(x: a)
+//│ ║  l.332: 	(f => f)(if true then 123 else false)(x: a)
 //│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ error
 //│ Code generation encountered an error:
@@ -330,7 +348,7 @@ z.y
 :e
 (f => if true then f else id)(if true then (x: Int) => x + 1 else id)(x: 123)
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `?a` for applying named arguments
-//│ ║  l.331: 	(f => if true then f else id)(if true then (x: Int) => x + 1 else id)(x: 123)
+//│ ║  l.349: 	(f => if true then f else id)(if true then (x: Int) => x + 1 else id)(x: 123)
 //│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ error
 //│ res
@@ -339,7 +357,7 @@ z.y
 :e
 (f => if true then f else id)(if true then (x: Int) => x + 1 else (x: Int) => x + 1)(x: 123)
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `?a` for applying named arguments
-//│ ║  l.340: 	(f => if true then f else id)(if true then (x: Int) => x + 1 else (x: Int) => x + 1)(x: 123)
+//│ ║  l.358: 	(f => if true then f else id)(if true then (x: Int) => x + 1 else (x: Int) => x + 1)(x: 123)
 //│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ error
 //│ res
@@ -361,7 +379,7 @@ foo((x: Int) => 1)
 :e
 fun foo(f: ((x: Int) => Int) | 'a) = f(x: 123)
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `'a | (x: Int) -> Int` for applying named arguments
-//│ ║  l.362: 	fun foo(f: ((x: Int) => Int) | 'a) = f(x: 123)
+//│ ║  l.380: 	fun foo(f: ((x: Int) => Int) | 'a) = f(x: 123)
 //│ ╙──       	                                     ^
 //│ fun foo: (f: anything) -> error
 
@@ -370,7 +388,7 @@ fun foo(f: ((x: Int) => Int) | 'a) = f(x: 123)
 :e
 fun foo(x) = (if true then (x: Int) => x + 1 else x)(x: 123)
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `(x: Int) -> ?a | ?b` for applying named arguments
-//│ ║  l.371: 	fun foo(x) = (if true then (x: Int) => x + 1 else x)(x: 123)
+//│ ║  l.389: 	fun foo(x) = (if true then (x: Int) => x + 1 else x)(x: 123)
 //│ ╙──       	             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ fun foo: anything -> error
 
@@ -383,7 +401,7 @@ foo((y: Int) => y)
 :e // TODO later: this could be made to work...
 fun foo(x) = (if true then (x: Int) => x + 1 else (x: Int) => x + 1)(x: 123)
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `(x: Int) -> (?a | ?b)` for applying named arguments
-//│ ║  l.384: 	fun foo(x) = (if true then (x: Int) => x + 1 else (x: Int) => x + 1)(x: 123)
+//│ ║  l.402: 	fun foo(x) = (if true then (x: Int) => x + 1 else (x: Int) => x + 1)(x: 123)
 //│ ╙──       	             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ fun foo: anything -> error
 
@@ -394,7 +412,7 @@ fun foo(x) = if true then (x: Int) => x + 1 else x
 :e
 foo((y: Int) => y)(x: 123)
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `?a` for applying named arguments
-//│ ║  l.395: 	foo((y: Int) => y)(x: 123)
+//│ ║  l.413: 	foo((y: Int) => y)(x: 123)
 //│ ╙──       	^^^^^^^^^^^^^^^^^^
 //│ error
 //│ res
@@ -403,7 +421,7 @@ foo((y: Int) => y)(x: 123)
 :e
 foo((x: Int) => x - 1)(x: 123)
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `?a` for applying named arguments
-//│ ║  l.404: 	foo((x: Int) => x - 1)(x: 123)
+//│ ║  l.422: 	foo((x: Int) => x - 1)(x: 123)
 //│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^
 //│ error
 //│ res
@@ -416,7 +434,7 @@ fun foo1(x) = [x + 1, x]
 :e
 foo1(x: 123)
 //│ ╔══[ERROR] Cannot use named arguments as the function type has untyped arguments
-//│ ║  l.417: 	foo1(x: 123)
+//│ ║  l.435: 	foo1(x: 123)
 //│ ╙──       	    ^^^^^^^^
 //│ error
 //│ res
diff --git a/shared/src/test/diff/nu/New.mls b/shared/src/test/diff/nu/New.mls
index a145d88fec..945effc18c 100644
--- a/shared/src/test/diff/nu/New.mls
+++ b/shared/src/test/diff/nu/New.mls
@@ -13,10 +13,18 @@ let f = Foo(1)
 // let f = new Foo(1)
 
 if f is Foo then 1 else 0
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.15: 	if f is Foo then 1 else 0
+//│ ╙──      	   ^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ res: 0 | 1
 //│    = 1
 
 if f is Foo(a) then a else 0
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.23: 	if f is Foo(a) then a else 0
+//│ ╙──      	   ^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ res: 0 | 1
 //│    = 1
 
@@ -31,6 +39,10 @@ if f is Foo(a) then a else 0
 
 
 fun test(x) = if x is Foo(a) then a
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.41: 	fun test(x) = if x is Foo(a) then a
+//│ ╙──      	                 ^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ test: (Foo & {x: 'x}) -> 'x
 //│     = [Function: test]
 
diff --git a/shared/src/test/diff/nu/NewNew.mls b/shared/src/test/diff/nu/NewNew.mls
index a2e039d7c3..5cfa6d96b8 100644
--- a/shared/src/test/diff/nu/NewNew.mls
+++ b/shared/src/test/diff/nu/NewNew.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 class Foo(val x: Int)
@@ -183,6 +183,9 @@ type T = PoInt[Str]
 
 :e
 new T(0, 0)
+//│ ╔══[ERROR] identifier `T` is resolved to a type
+//│ ║  l.185: 	new T(0, 0)
+//│ ╙──       	    ^
 //│ ╔══[ERROR] Type alias T cannot be used in `new` expression
 //│ ║  l.185: 	new T(0, 0)
 //│ ╙──       	^^^^^^^^^^^
@@ -198,7 +201,7 @@ let origin = new PoInt(0, 0)
 :e // TODO support
 let origin = PoInt[Int](0, 0)
 //│ ╔══[ERROR] Type application syntax is not yet supported
-//│ ║  l.199: 	let origin = PoInt[Int](0, 0)
+//│ ║  l.202: 	let origin = PoInt[Int](0, 0)
 //│ ╙──       	             ^^^^^^^^^^
 //│ let origin: PoInt[0]
 //│ origin
@@ -207,7 +210,7 @@ let origin = PoInt[Int](0, 0)
 :e // TODO support
 let origin = new PoInt[Int](0, 0)
 //│ ╔══[ERROR] Type arguments in `new` expressions are not yet supported
-//│ ║  l.208: 	let origin = new PoInt[Int](0, 0)
+//│ ║  l.211: 	let origin = new PoInt[Int](0, 0)
 //│ ╙──       	             ^^^^^^^^^^^^^^^^^^^^
 //│ let origin: PoInt[0]
 //│ Code generation encountered an error:
@@ -217,7 +220,7 @@ let origin = new PoInt[Int](0, 0)
 :e // TODO support
 new {}
 //│ ╔══[ERROR] Unexpected type `anything` after `new` keyword
-//│ ║  l.218: 	new {}
+//│ ║  l.221: 	new {}
 //│ ╙──       	    ^^
 //│ error
 //│ Code generation encountered an error:
@@ -227,10 +230,10 @@ new {}
 :e
 new
 //│ ╔══[PARSE ERROR] Unexpected end of input; an expression was expected here
-//│ ║  l.228: 	new
+//│ ║  l.231: 	new
 //│ ╙──       	   ^
 //│ ╔══[ERROR] Unexpected type `()` after `new` keyword
-//│ ║  l.228: 	new
+//│ ║  l.231: 	new
 //│ ╙──       	   ^
 //│ error
 //│ Code generation encountered an error:
@@ -241,11 +244,14 @@ new
 :e
 new
   x: 0
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.246: 	  x: 0
+//│ ╙──       	  ^
 //│ ╔══[PARSE ERROR] Not a recognized type
-//│ ║  l.243: 	  x: 0
+//│ ║  l.246: 	  x: 0
 //│ ╙──       	  ^
 //│ ╔══[ERROR] Unexpected type `nothing` after `new` keyword
-//│ ║  l.243: 	  x: 0
+//│ ║  l.246: 	  x: 0
 //│ ╙──       	  ^
 //│ error
 //│ Code generation encountered an error:
@@ -260,7 +266,7 @@ fun f(x) = {x}
 :e
 new f(1)
 //│ ╔══[ERROR] type identifier not found: f
-//│ ║  l.261: 	new f(1)
+//│ ║  l.267: 	new f(1)
 //│ ╙──       	    ^
 //│ error
 //│ res
@@ -273,7 +279,7 @@ module Oops
 :e
 new Oops
 //│ ╔══[ERROR] Module Oops cannot be used in `new` expression
-//│ ║  l.274: 	new Oops
+//│ ║  l.280: 	new Oops
 //│ ╙──       	    ^^^^
 //│ error
 //│ res
@@ -283,8 +289,11 @@ new Oops
 :e
 new Oops2
 trait Oops2
+//│ ╔══[ERROR] identifier `Oops2` is resolved to a type
+//│ ║  l.290: 	new Oops2
+//│ ╙──       	    ^^^^^
 //│ ╔══[ERROR] Trait Oops2 cannot be used in `new` expression
-//│ ║  l.284: 	new Oops2
+//│ ║  l.290: 	new Oops2
 //│ ╙──       	    ^^^^^
 //│ trait Oops2
 //│ error
diff --git a/shared/src/test/diff/nu/Object.mls b/shared/src/test/diff/nu/Object.mls
index 9e93dec27b..de48499444 100644
--- a/shared/src/test/diff/nu/Object.mls
+++ b/shared/src/test/diff/nu/Object.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 
@@ -88,6 +88,9 @@ fun foo = forall 'a; (x: 'a) => if x is A then true else false
 
 :e
 Object
+//│ ╔══[ERROR] identifier `Object` not found
+//│ ║  l.90: 	Object
+//│ ╙──      	^^^^^^
 //│ ╔══[ERROR] Class Object is abstract and cannot be instantiated
 //│ ║  l.90: 	Object
 //│ ╙──      	^^^^^^
@@ -100,11 +103,14 @@ Object
 
 :e
 Object()
+//│ ╔══[ERROR] identifier `Object` not found
+//│ ║  l.105: 	Object()
+//│ ╙──       	^^^^^^
 //│ ╔══[ERROR] Class Object is abstract and cannot be instantiated
-//│ ║  l.102: 	Object()
+//│ ║  l.105: 	Object()
 //│ ╙──       	^^^^^^
 //│ ╔══[ERROR] Class Object cannot be instantiated as it exposes no constructor
-//│ ║  l.102: 	Object()
+//│ ║  l.105: 	Object()
 //│ ╙──       	^^^^^^
 //│ error
 //│ Code generation encountered an error:
@@ -112,8 +118,11 @@ Object()
 
 :e
 new Object
+//│ ╔══[ERROR] identifier `Object` not found
+//│ ║  l.120: 	new Object
+//│ ╙──       	    ^^^^^^
 //│ ╔══[ERROR] Class Object is abstract and cannot be instantiated
-//│ ║  l.114: 	new Object
+//│ ║  l.120: 	new Object
 //│ ╙──       	    ^^^^^^
 //│ Object
 //│ Code generation encountered an error:
@@ -123,6 +132,9 @@ new Object
 
 // TODO
 class B() extends Object
+//│ ╔══[ERROR] could not find definition `Object`
+//│ ║  l.134: 	class B() extends Object
+//│ ╙──       	                  ^^^^^^
 //│ class B() extends Object
 //│ Code generation encountered an error:
 //│   unresolved parent Object.
diff --git a/shared/src/test/diff/nu/OpLam.mls b/shared/src/test/diff/nu/OpLam.mls
index bedc2cd423..78ce0e69a7 100644
--- a/shared/src/test/diff/nu/OpLam.mls
+++ b/shared/src/test/diff/nu/OpLam.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 x => x is 42
@@ -105,6 +105,12 @@ x => x + 2
 
 :e
 x => x.y => y
+//│ ╔══[ERROR] unsupported pattern shape
+//│ ║  l.107: 	x => x.y => y
+//│ ╙──       	     ^^^
+//│ ╔══[ERROR] identifier `y` not found
+//│ ║  l.107: 	x => x.y => y
+//│ ╙──       	            ^
 //│ ╔══[ERROR] Unsupported pattern shape:
 //│ ║  l.107: 	x => x.y => y
 //│ ╙──       	     ^^^
diff --git a/shared/src/test/diff/nu/OptionFilter.mls b/shared/src/test/diff/nu/OptionFilter.mls
index 530722135f..31879983e5 100644
--- a/shared/src/test/diff/nu/OptionFilter.mls
+++ b/shared/src/test/diff/nu/OptionFilter.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 // * Minimization of code that used to cause a problem:
@@ -32,7 +32,7 @@ module None extends Option[nothing] {
 //│   fun filter: (p: T -> Bool) -> Option[T]
 //│ }
 //│ class Some[T](value: T) extends Option {
-//│   fun filter: (T -> Object) -> (None | Some[T])
+//│   fun filter: (T -> Bool) -> (None | Some[T])
 //│ }
 //│ module None extends Option {
 //│   fun filter: anything -> None
diff --git a/shared/src/test/diff/nu/OverrideShorthand.mls b/shared/src/test/diff/nu/OverrideShorthand.mls
index 2bd823530c..e9e61e5946 100644
--- a/shared/src/test/diff/nu/OverrideShorthand.mls
+++ b/shared/src/test/diff/nu/OverrideShorthand.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 
diff --git a/shared/src/test/diff/nu/ParamPassing.mls b/shared/src/test/diff/nu/ParamPassing.mls
index 0fc6a4af9c..0c08b497cb 100644
--- a/shared/src/test/diff/nu/ParamPassing.mls
+++ b/shared/src/test/diff/nu/ParamPassing.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 class Foo(x: Int)
@@ -66,6 +66,12 @@ Foo(1).x
 
 :e
 Foo(1).#x
+//│ ╔══[ERROR] identifier `.#` not found
+//│ ║  l.68: 	Foo(1).#x
+//│ ╙──      	      ^^
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.68: 	Foo(1).#x
+//│ ╙──      	        ^
 //│ ╔══[ERROR] identifier not found: .#
 //│ ║  l.68: 	Foo(1).#x
 //│ ╙──      	      ^^
@@ -99,20 +105,20 @@ if Foo(1) is Foo(x) then x
 :e
 class Bar(x: Int) extends Foo(x)
 //│ ╔══[ERROR] Inherited parameter named `x` is not virtual and cannot be overridden
-//│ ║  l.100: 	class Bar(x: Int) extends Foo(x)
+//│ ║  l.106: 	class Bar(x: Int) extends Foo(x)
 //│ ║         	          ^
 //│ ╟── Originally declared here:
-//│ ║  l.85: 	class Foo(val x: Int)
+//│ ║  l.91: 	class Foo(val x: Int)
 //│ ╙──      	              ^
 //│ class Bar(x: Int) extends Foo
 
 :e
 Bar(11).x
 //│ ╔══[ERROR] Parameter 'x' cannot tbe accessed as a field
-//│ ║  l.110: 	Bar(11).x
+//│ ║  l.116: 	Bar(11).x
 //│ ║         	       ^^
 //│ ╟── Either make the parameter a `val` or access it through destructuring
-//│ ║  l.100: 	class Bar(x: Int) extends Foo(x)
+//│ ║  l.106: 	class Bar(x: Int) extends Foo(x)
 //│ ╙──       	          ^
 //│ Int | error
 //│ res
@@ -122,10 +128,10 @@ Bar(11).x
 :e
 class Bar(val x: Int) extends Foo(x + 1)
 //│ ╔══[ERROR] Inherited parameter named `x` is not virtual and cannot be overridden
-//│ ║  l.123: 	class Bar(val x: Int) extends Foo(x + 1)
+//│ ║  l.129: 	class Bar(val x: Int) extends Foo(x + 1)
 //│ ║         	              ^
 //│ ╟── Originally declared here:
-//│ ║  l.85: 	class Foo(val x: Int)
+//│ ║  l.91: 	class Foo(val x: Int)
 //│ ╙──      	              ^
 //│ class Bar(x: Int) extends Foo
 
@@ -137,10 +143,10 @@ Bar(11).x
 :e
 class Bar extends Foo(1) { val x: 2 }
 //│ ╔══[ERROR] Inherited parameter named `x` is not virtual and cannot be overridden
-//│ ║  l.138: 	class Bar extends Foo(1) { val x: 2 }
+//│ ║  l.144: 	class Bar extends Foo(1) { val x: 2 }
 //│ ║         	                           ^^^^^^^^
 //│ ╟── Originally declared here:
-//│ ║  l.85: 	class Foo(val x: Int)
+//│ ║  l.91: 	class Foo(val x: Int)
 //│ ╙──      	              ^
 //│ class Bar extends Foo {
 //│   constructor()
@@ -150,10 +156,10 @@ class Bar extends Foo(1) { val x: 2 }
 :e
 module Bar extends Foo(1) { fun x = 2 }
 //│ ╔══[ERROR] Inherited parameter named `x` is not virtual and cannot be overridden
-//│ ║  l.151: 	module Bar extends Foo(1) { fun x = 2 }
+//│ ║  l.157: 	module Bar extends Foo(1) { fun x = 2 }
 //│ ║         	                                ^^^^^
 //│ ╟── Originally declared here:
-//│ ║  l.85: 	class Foo(val x: Int)
+//│ ║  l.91: 	class Foo(val x: Int)
 //│ ╙──      	              ^
 //│ module Bar extends Foo {
 //│   fun x: 2
@@ -181,10 +187,10 @@ module B extends A(42)
 :e
 B.x
 //│ ╔══[ERROR] Parameter 'x' cannot tbe accessed as a field
-//│ ║  l.182: 	B.x
+//│ ║  l.188: 	B.x
 //│ ║         	 ^^
 //│ ╟── Either make the parameter a `val` or access it through destructuring
-//│ ║  l.175: 	class A(x: Int)
+//│ ║  l.181: 	class A(x: Int)
 //│ ╙──       	        ^
 //│ Int | error
 //│ res
@@ -223,16 +229,16 @@ module Bazz extends Foo(0) {
   val x: 2
 }
 //│ ╔══[ERROR] Inherited parameter named `x` is not virtual and cannot be overridden
-//│ ║  l.223: 	  val x: 2
+//│ ║  l.229: 	  val x: 2
 //│ ║         	  ^^^^^^^^
 //│ ╟── Originally declared here:
-//│ ║  l.195: 	abstract class Foo[A](val x: A) { fun y = x; fun i: A -> A }
+//│ ║  l.201: 	abstract class Foo[A](val x: A) { fun y = x; fun i: A -> A }
 //│ ╙──       	                          ^
 //│ ╔══[ERROR] Member `i` is declared (or its declaration is inherited) but is not implemented in `Bazz`
-//│ ║  l.222: 	module Bazz extends Foo(0) {
+//│ ║  l.228: 	module Bazz extends Foo(0) {
 //│ ║         	       ^^^^
 //│ ╟── Declared here:
-//│ ║  l.195: 	abstract class Foo[A](val x: A) { fun y = x; fun i: A -> A }
+//│ ║  l.201: 	abstract class Foo[A](val x: A) { fun y = x; fun i: A -> A }
 //│ ╙──       	                                             ^^^^^^^^^^^^^
 //│ module Bazz extends Foo {
 //│   fun i: 'A -> 'A
diff --git a/shared/src/test/diff/nu/PolymorphicVariants_Alt.mls b/shared/src/test/diff/nu/PolymorphicVariants_Alt.mls
index a9355ce6a2..f636b0f4ea 100644
--- a/shared/src/test/diff/nu/PolymorphicVariants_Alt.mls
+++ b/shared/src/test/diff/nu/PolymorphicVariants_Alt.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 :NoJS
 
 
@@ -112,7 +112,7 @@ module Test1 extends EvalVar, EvalLambda
 Test1.eval(Nil(), Var("a"))
 //│ 'a
 //│   where
-//│     'a :> App['a] | Abs['a] | Var
+//│     'a :> Abs['a] | Var | App['a]
 
 Test1.eval(Nil(), Abs("b", Var("a")))
 //│ 'a
@@ -127,7 +127,7 @@ Test1.eval(Cons(["c", Var("d")], Nil()), App(Abs("b", Var("b")), Var("c")))
 Test1.eval(Cons(["c", Abs("d", Var("d"))], Nil()), App(Abs("b", Var("b")), Var("c")))
 //│ 'a
 //│   where
-//│     'a :> App['a] | Abs['a] | Abs[Var] | Var
+//│     'a :> Abs[Var] | Var | App['a] | Abs['a]
 
 class Numb(n: Int)
 class Add<out A>(l: A, r: A)
@@ -142,7 +142,7 @@ fun map_expr(f, v) =
     Numb then v
     Add(l, r) then Add(f(l), f(r))
     Mul(l, r) then Mul(f(l), f(r))
-//│ fun map_expr: forall 'A 'a 'A0 'b. ('a -> 'A0 & 'b -> 'A, Add['a] | Mul['b] | Numb | Var) -> (Add['A0] | Mul['A] | Numb | Var)
+//│ fun map_expr: forall 'a 'A 'b 'A0. ('b -> 'A0 & 'a -> 'A, Add['a] | Mul['b] | Numb | Var) -> (Add['A] | Mul['A0] | Numb | Var)
 
 mixin EvalExpr {
   fun eval(sub, v) =
diff --git a/shared/src/test/diff/nu/PostHocMixinSignature.mls b/shared/src/test/diff/nu/PostHocMixinSignature.mls
index 5c23e3c3fa..ec7e6a0d2d 100644
--- a/shared/src/test/diff/nu/PostHocMixinSignature.mls
+++ b/shared/src/test/diff/nu/PostHocMixinSignature.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 mixin Foo {
@@ -8,7 +8,7 @@ mixin Foo {
 //│   fun foo: 'a -> 'a
 //│ }
 //│ where
-//│   'a <: {a: Object, b: 'a}
+//│   'a <: {a: Bool, b: 'a}
 
 
 module ValA {
@@ -34,7 +34,7 @@ module Test extends Foo
 //│   fun foo: forall 'a. 'a -> 'a
 //│ }
 //│ where
-//│   'a <: {a: Object, b: 'a}
+//│   'a <: {a: Bool, b: 'a}
 
 [Test.foo(ValA), Test.foo(ValB)]
 //│ [ValA | ValB, ValA | ValB]
diff --git a/shared/src/test/diff/nu/PrivateMemberOverriding.mls b/shared/src/test/diff/nu/PrivateMemberOverriding.mls
index e7977a41df..a3aa25961e 100644
--- a/shared/src/test/diff/nu/PrivateMemberOverriding.mls
+++ b/shared/src/test/diff/nu/PrivateMemberOverriding.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 class Foo(x: Int)
diff --git a/shared/src/test/diff/nu/RefinedPattern.mls b/shared/src/test/diff/nu/RefinedPattern.mls
index a6eec80932..c9283801a0 100644
--- a/shared/src/test/diff/nu/RefinedPattern.mls
+++ b/shared/src/test/diff/nu/RefinedPattern.mls
@@ -30,7 +30,7 @@ test(D(123))
 
 :e
 refined
-//│ ╔══[ERROR] Variable refined not found in scope
+//│ ╔══[ERROR] identifier `refined` not found
 //│ ║  l.32: 	refined
 //│ ╙──      	^^^^^^^
 //│ ╔══[ERROR] Illegal use of reserved operator: refined
diff --git a/shared/src/test/diff/nu/SelfRec.mls b/shared/src/test/diff/nu/SelfRec.mls
index 3a68af47cf..fba85a5db3 100644
--- a/shared/src/test/diff/nu/SelfRec.mls
+++ b/shared/src/test/diff/nu/SelfRec.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 
diff --git a/shared/src/test/diff/nu/Subscripts.mls b/shared/src/test/diff/nu/Subscripts.mls
index eb2812dbb6..7668fe6b46 100644
--- a/shared/src/test/diff/nu/Subscripts.mls
+++ b/shared/src/test/diff/nu/Subscripts.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 let xs = [0, 1, 2]
diff --git a/shared/src/test/diff/nu/TODO_Classes.mls b/shared/src/test/diff/nu/TODO_Classes.mls
index 8df3944017..34699bb12e 100644
--- a/shared/src/test/diff/nu/TODO_Classes.mls
+++ b/shared/src/test/diff/nu/TODO_Classes.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 
diff --git a/shared/src/test/diff/nu/Unapply.mls b/shared/src/test/diff/nu/Unapply.mls
index 9dcc6a93a4..8bf62edc2e 100644
--- a/shared/src/test/diff/nu/Unapply.mls
+++ b/shared/src/test/diff/nu/Unapply.mls
@@ -1,6 +1,6 @@
 // *** Explicit unapply tests *** //
 
-:NewDefs
+:PreTyper
 
 
 // * Unapply's current compilation strategy:
diff --git a/shared/src/test/diff/nu/UndefMatching.mls b/shared/src/test/diff/nu/UndefMatching.mls
index 57453f5d99..3050b22762 100644
--- a/shared/src/test/diff/nu/UndefMatching.mls
+++ b/shared/src/test/diff/nu/UndefMatching.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 
diff --git a/shared/src/test/diff/nu/WeirdUnions.mls b/shared/src/test/diff/nu/WeirdUnions.mls
index 89326b7576..9194fd1e2a 100644
--- a/shared/src/test/diff/nu/WeirdUnions.mls
+++ b/shared/src/test/diff/nu/WeirdUnions.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 
diff --git a/shared/src/test/diff/nu/i180.mls b/shared/src/test/diff/nu/i180.mls
index 39013ced9f..4b1e033098 100644
--- a/shared/src/test/diff/nu/i180.mls
+++ b/shared/src/test/diff/nu/i180.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 fun (++) stringConcat(a, b) = concat(a)(b)
diff --git a/shared/src/test/diff/nu/repro0.mls b/shared/src/test/diff/nu/repro0.mls
index c02b9aa19e..61095fcad3 100644
--- a/shared/src/test/diff/nu/repro0.mls
+++ b/shared/src/test/diff/nu/repro0.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 :NoJS
 
 
@@ -9,6 +9,9 @@ module EvalAddLit {
     if e is Add then eval(e.lhs)
 }
 let res = EvalAddLit.eval(add11)
+//│ ╔══[ERROR] identifier `add11` not found
+//│ ║  l.6: 	val add11 = Add(add11)
+//│ ╙──     	                ^^^^^
 //│ class Add[E](lhs: E)
 //│ val add11: 'E
 //│ module EvalAddLit {
diff --git a/shared/src/test/diff/nu/repro1.mls b/shared/src/test/diff/nu/repro1.mls
index 09c7cb8328..7db26f2cb7 100644
--- a/shared/src/test/diff/nu/repro1.mls
+++ b/shared/src/test/diff/nu/repro1.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 :NoJS
 
 
diff --git a/shared/src/test/diff/nu/repro_EvalNegNeg.mls b/shared/src/test/diff/nu/repro_EvalNegNeg.mls
index af761f40b9..e0aee8d956 100644
--- a/shared/src/test/diff/nu/repro_EvalNegNeg.mls
+++ b/shared/src/test/diff/nu/repro_EvalNegNeg.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 class Add<out E>(lhs: E, rhs: E)
@@ -45,8 +45,8 @@ TestLang.eval(mk(0))
 //│ Int
 //│ res
 //│     = 0
-//│ constrain calls  : 211
-//│ annoying  calls  : 51
-//│ subtyping calls  : 1399
+//│ constrain calls  : 299
+//│ annoying  calls  : 106
+//│ subtyping calls  : 1746
 
 
diff --git a/shared/src/test/diff/nu/repro_PolymorphicVariants.mls b/shared/src/test/diff/nu/repro_PolymorphicVariants.mls
index 461bada4e8..2c1624a9ec 100644
--- a/shared/src/test/diff/nu/repro_PolymorphicVariants.mls
+++ b/shared/src/test/diff/nu/repro_PolymorphicVariants.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 // Test that reprduces subtle type simplification bug
 
diff --git a/shared/src/test/diff/pretyper/ucs/RecordPattern.mls b/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
index beffd4bb1d..e54140742f 100644
--- a/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
+++ b/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
@@ -5,13 +5,13 @@ fun take_1(p) =
   if p is
     { x, y } then x + y
     else 0
-//│ ╔══[ERROR] Unknown pattern Bra(true,Rcd(List((Var(x),Fld(_,Var(x))), (Var(y),Fld(_,Var(y))))))
+//│ ╔══[ERROR] Unknown pattern '{' {x: x, y: y} '}'
 //│ ║  l.6: 	    { x, y } then x + y
 //│ ╙──     	    ^^^^^^^^
-//│ ╔══[ERROR] Variable x not found in scope
+//│ ╔══[ERROR] identifier `x` not found
 //│ ║  l.6: 	    { x, y } then x + y
 //│ ╙──     	                  ^
-//│ ╔══[ERROR] Variable y not found in scope
+//│ ╔══[ERROR] identifier `y` not found
 //│ ║  l.6: 	    { x, y } then x + y
 //│ ╙──     	                      ^
 //│ ╔══[ERROR] identifier not found: x
diff --git a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
index 563791bff0..5675d5d0f5 100644
--- a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
+++ b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
@@ -27,10 +27,10 @@ fun example2(p) =
     Pair(x, y) and p1(x) and p1(y) then "both negative"
     Pair(a, b) and p2(a) and p2(b) then x + y
     else "nah"
-//│ ╔══[ERROR] Variable x not found in scope
+//│ ╔══[ERROR] identifier `x` not found
 //│ ║  l.28: 	    Pair(a, b) and p2(a) and p2(b) then x + y
 //│ ╙──      	                                        ^
-//│ ╔══[ERROR] Variable y not found in scope
+//│ ╔══[ERROR] identifier `y` not found
 //│ ║  l.28: 	    Pair(a, b) and p2(a) and p2(b) then x + y
 //│ ╙──      	                                            ^
 //│ ╔══[ERROR] identifier not found: x
diff --git a/shared/src/test/diff/pretyper/ucs/examples/Option.mls b/shared/src/test/diff/pretyper/ucs/examples/Option.mls
index 32a2706ff5..7903575720 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/Option.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/Option.mls
@@ -13,7 +13,7 @@ module MyNone extends MyOption[nothing] {
 //│   fun filter: (p: T -> Bool) -> MyOption[T]
 //│ }
 //│ class MySome[T](value: T) extends MyOption {
-//│   fun filter: (T -> Object) -> (MyNone | MySome[T])
+//│   fun filter: (T -> Bool) -> (MyNone | MySome[T])
 //│ }
 //│ module MyNone extends MyOption {
 //│   fun filter: anything -> MyNone
@@ -81,7 +81,7 @@ module None extends Option[nothing] {
 //│   fun map: forall 'b0. (T -> 'b0) -> Option['b0]
 //│ }
 //│ class Some[T](value: T) extends Option {
-//│   fun filter: (T -> Object) -> Option[T]
+//│   fun filter: (T -> Bool) -> Option[T]
 //│   fun flatMap: forall 'c. (T -> 'c) -> 'c
 //│   fun get: T
 //│   fun isDefined: true
diff --git a/shared/src/test/diff/ucs/AppSplits.mls b/shared/src/test/diff/ucs/AppSplits.mls
index f6f81f1736..99caea2510 100644
--- a/shared/src/test/diff/ucs/AppSplits.mls
+++ b/shared/src/test/diff/ucs/AppSplits.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 fun foo(x) = x > 1
@@ -20,14 +20,14 @@ if foo of
 //│ ╟── Note: 'if' expression starts here:
 //│ ║  l.9: 	if foo of
 //│ ╙──     	^^
-//│ ╔══[ERROR] The case when this is false is not handled: foo(0,)
-//│ ║  l.9: 	if foo of
-//│ ║       	   ^^^^^^
+//│ ╔══[ERROR] Type mismatch in `case` expression:
 //│ ║  l.10: 	  0 then "a"
-//│ ╙──      	^^^^
-//│ error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ║        	  ^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ ()
+//│ res
+//│ Runtime error:
+//│   Error: non-exhaustive case expression
 
 :pe // TODO
 :e
@@ -47,14 +47,24 @@ if foo of 1,
 //│ ╟── Note: 'if' expression starts here:
 //│ ║  l.34: 	if foo of 1,
 //│ ╙──      	^^
-//│ ╔══[ERROR] The case when this is false is not handled: foo(1, undefined,)
+//│ ╔══[ERROR] Type mismatch in application:
 //│ ║  l.34: 	if foo of 1,
 //│ ║        	   ^^^^^^^^^
 //│ ║  l.35: 	  0 then "a"
+//│ ║        	^^
+//│ ╟── argument list of type `[1, ()]` does not match type `[?a]`
+//│ ║  l.34: 	if foo of 1,
+//│ ║        	          ^^
+//│ ║  l.35: 	  0 then "a"
 //│ ╙──      	^^
-//│ error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.35: 	  0 then "a"
+//│ ║        	  ^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ ()
+//│ res
+//│ Runtime error:
+//│   Error: non-exhaustive case expression
 
 :pe // TODO
 :e
@@ -62,15 +72,15 @@ if foo
   (0) then "a"
   (1) then "b"
 //│ ╔══[PARSE ERROR] Unexpected parenthesis section here
-//│ ║  l.63: 	  (1) then "b"
+//│ ║  l.73: 	  (1) then "b"
 //│ ╙──      	  ^^^
-//│ ╔══[ERROR] The case when this is false is not handled: foo(0,)
-//│ ║  l.61: 	if foo
-//│ ║        	   ^^^
-//│ ║  l.62: 	  (0) then "a"
-//│ ╙──      	^^^^^
-//│ error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.72: 	  (0) then "a"
+//│ ║        	           ^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ "a"
+//│ res
+//│ Runtime error:
+//│   Error: non-exhaustive case expression
 
 
diff --git a/shared/src/test/diff/ucs/CrossBranchCapture.mls b/shared/src/test/diff/ucs/CrossBranchCapture.mls
index 364aa0c6ed..f1c60286c4 100644
--- a/shared/src/test/diff/ucs/CrossBranchCapture.mls
+++ b/shared/src/test/diff/ucs/CrossBranchCapture.mls
@@ -1,21 +1,32 @@
-:NewDefs
+:PreTyper
 
 
 class Numb(n: Int)
 //│ class Numb(n: Int)
 
 
-// * FIXME should be rejected
+:e
+:ge
 fun process(e) =
   if e is
     Numb(n) and n > 0 then n
     Numb(m) then n
-//│ fun process: Numb -> Int
-
+//│ ╔══[ERROR] identifier `n` not found
+//│ ║  l.13: 	    Numb(m) then n
+//│ ╙──      	                 ^
+//│ ╔══[ERROR] identifier not found: n
+//│ ║  l.12: 	    Numb(n) and n > 0 then n
+//│ ╙──      	         ^
+//│ fun process: Numb -> (Int | error)
+//│ Code generation encountered an error:
+//│   unresolved symbol n
+
+:re
 process(Numb(-10))
-//│ Int
+//│ Int | error
 //│ res
-//│     = -10
+//│ Runtime error:
+//│   TypeError: process is not a function
 
 
 // * FIXME wrong result
@@ -23,12 +34,12 @@ fun process(e, n) =
   if e is
     Numb(n) and n > 0 then n
     Numb(m) then n + m
-//│ fun process: (Numb, anything) -> Int
+//│ fun process: (Numb, Int) -> Int
 
 process(Numb(0), 10)
 //│ Int
 //│ res
-//│     = 0
+//│     = 10
 
 
 class Vec(xs: Array[Numb | Vec])
@@ -36,14 +47,27 @@ class Pair[A,B](a: A, b: B)
 //│ class Vec(xs: Array[Numb | Vec])
 //│ class Pair[A, B](a: A, b: B)
 
-// * FIXME should be rejected
+
+:e
+:ge
 fun process(e) =
   if e is
     Pair(Numb(n), Numb(m)) then Numb(n + m)
     Pair(Vec(xs), Vec(ys))  then n
     Pair(Vec(n),  Numb(n)) then n
     Pair(Numb(n), Vec(n))  then n
-//│ fun process: Pair[Numb | Vec, Numb | Vec] -> (Int | Numb | Array[Numb | Vec])
+//│ ╔══[ERROR] identifier `n` not found
+//│ ║  l.56: 	    Pair(Vec(xs), Vec(ys))  then n
+//│ ╙──      	                                 ^
+//│ ╔══[ERROR] identifier not found: n
+//│ ║  l.55: 	    Pair(Numb(n), Numb(m)) then Numb(n + m)
+//│ ╙──      	              ^
+//│ ╔══[ERROR] identifier not found: n
+//│ ║  l.56: 	    Pair(Vec(xs), Vec(ys))  then n
+//│ ╙──      	                                 ^
+//│ fun process: Pair[Numb | Vec, Numb | Vec] -> (Int | Numb | error | Array[Numb | Vec])
+//│ Code generation encountered an error:
+//│   unresolved symbol n
 
 
 // * FIXME should warn, be rejected, or compare both values for equality
diff --git a/shared/src/test/diff/ucs/DirectLines.mls b/shared/src/test/diff/ucs/DirectLines.mls
index ccfa61f7d1..5e346f8b71 100644
--- a/shared/src/test/diff/ucs/DirectLines.mls
+++ b/shared/src/test/diff/ucs/DirectLines.mls
@@ -5,6 +5,14 @@ fun f(x, y) =
     x == 0 then "x"
     y == 0 then "y"
     _      then "nah"
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.5: 	    x == 0 then "x"
+//│ ║       	    ^^^^^^^^^^^^^^^
+//│ ║  l.6: 	    y == 0 then "y"
+//│ ║       	^^^^^^^^^^^^^^^^^^^
+//│ ║  l.7: 	    _      then "nah"
+//│ ╙──     	^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ f: (number, number,) -> ("nah" | "x" | "y")
 //│  = [Function: f]
 
@@ -22,6 +30,10 @@ class None: Option
 //│     = [Function: None1]
 
 fun isValid(x) = if x then false else true
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.32: 	fun isValid(x) = if x then false else true
+//│ ╙──      	                    ^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ isValid: anything -> Bool
 //│        = [Function: isValid]
 
@@ -30,6 +42,16 @@ fun f(x, allowNone) =
     is Some(x) and isValid(x) then "good"
     is None() and allowNone then "okay"
     is _ then "bad"
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.41: 	  if x
+//│ ║        	     ^
+//│ ║  l.42: 	    is Some(x) and isValid(x) then "good"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.43: 	    is None() and allowNone then "okay"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.44: 	    is _ then "bad"
+//│ ╙──      	^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ f: (anything, anything,) -> ("bad" | "good" | "okay")
 //│  = [Function: f1]
 
@@ -44,6 +66,26 @@ fun f(x, y, z) =
         _ then "bruh"
       3 then "y = 3"
       _ then "bruh"
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.60: 	    x == 0 then "x"
+//│ ║        	    ^^^^^^^^^^^^^^^
+//│ ║  l.61: 	    y ==
+//│ ║        	^^^^^^^^
+//│ ║  l.62: 	      1 then "y = 1"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.63: 	      2 and z ==
+//│ ║        	^^^^^^^^^^^^^^^^
+//│ ║  l.64: 	        0 then "z = 0"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.65: 	        9 then "z = 9"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.66: 	        _ then "bruh"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.67: 	      3 then "y = 3"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.68: 	      _ then "bruh"
+//│ ╙──      	^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ f: (number, number, number,) -> ("bruh" | "x" | "y = 1" | "y = 3" | "z = 0" | "z = 9")
 //│  = [Function: f2]
 
@@ -56,8 +98,21 @@ fun f(a, b) =
       2 then 2
       _ then 7
     else 3
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.95: 	    a == 0 then 0
+//│ ║        	    ^^^^^^^^^^^^^
+//│ ║  l.96: 	    b ==
+//│ ║        	^^^^^^^^
+//│ ║  l.97: 	      1 then 1
+//│ ║        	^^^^^^^^^^^^^^
+//│ ║  l.98: 	      2 then 2
+//│ ║        	^^^^^^^^^^^^^^
+//│ ║  l.99: 	      _ then 7
+//│ ║        	^^^^^^^^^^^^^^
+//│ ║  l.100: 	    else 3
+//│ ╙──       	^^^^^^^^^^
 //│ ╔══[WARNING] Found a redundant else branch
-//│ ║  l.58: 	    else 3
-//│ ╙──      	         ^
+//│ ║  l.100: 	    else 3
+//│ ╙──       	         ^
 //│ f: (number, number,) -> (0 | 1 | 2 | 7)
 //│  = [Function: f3]
diff --git a/shared/src/test/diff/ucs/ElseIf.mls b/shared/src/test/diff/ucs/ElseIf.mls
index bcb30cd3c1..7e9ca42c2e 100644
--- a/shared/src/test/diff/ucs/ElseIf.mls
+++ b/shared/src/test/diff/ucs/ElseIf.mls
@@ -1,5 +1,4 @@
-:NewParser
-:NewDefs
+:PreTyper
 
 
 
@@ -26,23 +25,28 @@ module Fals
 //│ module Fals
 
 :e
-:ge
 fun f(x, y) = if x is
     Tru and y is Tru then true
     Fals and y is Fals then false
-//│ ╔══[ERROR] The match is not exhaustive.
-//│ ║  l.31: 	    Tru and y is Tru then true
-//│ ║        	            ^^^^^^^^
-//│ ╟── The scrutinee at this position misses 1 case.
-//│ ║  l.31: 	    Tru and y is Tru then true
+//│ ╔══[ERROR] When scrutinee `x` is `Tru`
+//│ ║  l.29: 	    Tru and y is Tru then true
+//│ ║        	    ^^^
+//│ ╟── Scrutinee `y` has 1 missing case
+//│ ║  l.29: 	    Tru and y is Tru then true
 //│ ║        	            ^
-//│ ╟── [Missing Case 1/1] `Fals`
-//│ ╟── It first appears here.
-//│ ║  l.32: 	    Fals and y is Fals then false
+//│ ╟── It can be module `Fals`
+//│ ║  l.30: 	    Fals and y is Fals then false
 //│ ╙──      	                  ^^^^
-//│ fun f: (anything, anything) -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] When scrutinee `x` is `Fals`
+//│ ║  l.30: 	    Fals and y is Fals then false
+//│ ║        	    ^^^^
+//│ ╟── Scrutinee `y` has 1 missing case
+//│ ║  l.30: 	    Fals and y is Fals then false
+//│ ║        	             ^
+//│ ╟── It can be module `Tru`
+//│ ║  l.29: 	    Tru and y is Tru then true
+//│ ╙──      	                 ^^^
+//│ fun f: (Fals | Tru, nothing) -> Bool
 
 // The base case.
 fun f(x, y) = if x is
@@ -82,6 +86,7 @@ fun g(x, y) = if x is
   _ and y is
     true then true
     false then false
+//│ ╙──
 //│ fun g: (Object, Bool) -> Bool
 
 // Chained UCS terms
@@ -93,12 +98,55 @@ fun f(x, y) = if x is
     Fals then false
 //│ fun f: (Object, Fals | Tru) -> Bool
 
+:e
 fun f(x, y) = if x is
     Tru and y is Tru then true
     Fals and y is Fals then false
   else if y is
     Tru and x is Fals then true
     Fals and x is Tru then false
+//│ ╔══[ERROR] When scrutinee `y` is `Tru`
+//│ ║  l.106: 	    Tru and x is Fals then true
+//│ ║         	    ^^^
+//│ ╟── Scrutinee `x` has 1 missing case
+//│ ║  l.106: 	    Tru and x is Fals then true
+//│ ║         	            ^
+//│ ╟── It can be module `Tru`
+//│ ║  l.107: 	    Fals and x is Tru then false
+//│ ╙──       	                  ^^^
+//│ ╔══[ERROR] When scrutinee `y` is `Fals`
+//│ ║  l.107: 	    Fals and x is Tru then false
+//│ ║         	    ^^^^
+//│ ╟── Scrutinee `x` has 1 missing case
+//│ ║  l.107: 	    Fals and x is Tru then false
+//│ ║         	             ^
+//│ ╟── It can be module `Fals`
+//│ ║  l.106: 	    Tru and x is Fals then true
+//│ ╙──       	                 ^^^^
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.106: 	    Tru and x is Fals then true
+//│ ║         	            ^^^^^^^^^^^^^^^^^^^
+//│ ╟── class pattern of type `Tru` is not an instance of type `Fals`
+//│ ║  l.103: 	    Tru and y is Tru then true
+//│ ║         	    ^^^
+//│ ╟── but it flows into reference with expected type `Fals`
+//│ ║  l.106: 	    Tru and x is Fals then true
+//│ ║         	            ^
+//│ ╟── Note: constraint arises from class pattern:
+//│ ║  l.106: 	    Tru and x is Fals then true
+//│ ╙──       	                 ^^^^
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.107: 	    Fals and x is Tru then false
+//│ ║         	             ^^^^^^^^^^^^^^^^^^^
+//│ ╟── class pattern of type `Fals` is not an instance of type `Tru`
+//│ ║  l.104: 	    Fals and y is Fals then false
+//│ ║         	    ^^^^
+//│ ╟── but it flows into reference with expected type `Tru`
+//│ ║  l.107: 	    Fals and x is Tru then false
+//│ ║         	             ^
+//│ ╟── Note: constraint arises from class pattern:
+//│ ║  l.107: 	    Fals and x is Tru then false
+//│ ╙──       	                  ^^^
 //│ fun f: (Fals | Tru, Fals | Tru) -> Bool
 
 fun h(x, y, p) = if
@@ -106,4 +154,4 @@ fun h(x, y, p) = if
   y is
     Tru then 1
     Fals then 2
-//│ fun h: (Object, Fals | Tru, true -> Object) -> (0 | 1 | 2)
+//│ fun h: forall 'a. ('a & Bool, Fals | Tru, 'a -> Bool) -> (0 | 1 | 2)
diff --git a/shared/src/test/diff/ucs/ErrorMessage.mls b/shared/src/test/diff/ucs/ErrorMessage.mls
index aa40b49387..70bbd0eb18 100644
--- a/shared/src/test/diff/ucs/ErrorMessage.mls
+++ b/shared/src/test/diff/ucs/ErrorMessage.mls
@@ -10,6 +10,12 @@ class Point(x, y)
 fun f(p) =
   if p is
     Point(x, y, z) then x + y + z
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.11: 	  if p is
+//│ ║        	     ^^^^
+//│ ║  l.12: 	    Point(x, y, z) then x + y + z
+//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ ╔══[ERROR] class Point expects 2 parameters but found 3 parameters
 //│ ║  l.12: 	    Point(x, y, z) then x + y + z
 //│ ╙──      	    ^^^^^^^^^^^^^^
@@ -22,8 +28,14 @@ fun f(p) =
 fun g(xs) =
   if xs is
     head :: _ then head
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.29: 	  if xs is
+//│ ║        	     ^^^^^
+//│ ║  l.30: 	    head :: _ then head
+//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ ╔══[ERROR] Cannot find operator `::` in the context
-//│ ║  l.24: 	    head :: _ then head
+//│ ║  l.30: 	    head :: _ then head
 //│ ╙──      	         ^^
 //│ g: anything -> error
 //│ Code generation encountered an error:
diff --git a/shared/src/test/diff/ucs/Exhaustiveness.mls b/shared/src/test/diff/ucs/Exhaustiveness.mls
index eb2377c61d..88bf03fd2d 100644
--- a/shared/src/test/diff/ucs/Exhaustiveness.mls
+++ b/shared/src/test/diff/ucs/Exhaustiveness.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 :NoJS
 
 class A()
@@ -19,21 +19,19 @@ fun f(x, y) =
     y is B and
       x is
         A then 4
-//│ ╔══[ERROR] The match is not exhaustive.
-//│ ║  l.20: 	      x is
-//│ ║        	      ^^^^
-//│ ╟── The scrutinee at this position misses 2 cases.
+//│ ╔══[ERROR] When scrutinee `y` is `B`
+//│ ║  l.19: 	    y is B and
+//│ ║        	         ^
+//│ ╟── Scrutinee `x` has 2 missing cases
 //│ ║  l.20: 	      x is
 //│ ║        	      ^
-//│ ╟── [Missing Case 1/2] `B`
-//│ ╟── It first appears here.
+//│ ╟── It can be class `B`
 //│ ║  l.17: 	        B then 1
 //│ ║        	        ^
-//│ ╟── [Missing Case 2/2] `C`
-//│ ╟── It first appears here.
+//│ ╟── It can be class `C`
 //│ ║  l.18: 	        C then 2
 //│ ╙──      	        ^
-//│ fun f: (anything, anything) -> error
+//│ fun f: (A, A | B) -> (0 | 1 | 2 | 4)
 
 :e
 // These operators are uninterpreted. So, it's impossible to reason the
@@ -48,19 +46,59 @@ class Node[A](value: int, left: Tree[A], right: Tree[A]) {
     >= value then right.find(wanted)
     == value then true
 }
-//│ ╔══[ERROR] The case when this is false is not handled: ==(wanted, value,)
-//│ ║  l.46: 	  fun contains(wanted) = if wanted
+//│ ╔══[ERROR] Type mismatch in operator application:
+//│ ║  l.44: 	  fun contains(wanted) = if wanted
+//│ ║        	                            ^^^^^^
+//│ ║  l.45: 	    <= value then left.find(wanted)
+//│ ║        	^^^^^^^^^^^^
+//│ ╟── type `int` is not an instance of type `Num`
+//│ ║  l.43: 	class Node[A](value: int, left: Tree[A], right: Tree[A]) {
+//│ ║        	                     ^^^
+//│ ╟── but it flows into reference with expected type `Num`
+//│ ║  l.45: 	    <= value then left.find(wanted)
+//│ ╙──      	       ^^^^^
+//│ ╔══[ERROR] Type `#Node & {Node#A = A}` does not contain member `find`
+//│ ║  l.45: 	    <= value then left.find(wanted)
+//│ ╙──      	                      ^^^^^
+//│ ╔══[ERROR] Type mismatch in operator application:
+//│ ║  l.44: 	  fun contains(wanted) = if wanted
+//│ ║        	                            ^^^^^^
+//│ ║  l.45: 	    <= value then left.find(wanted)
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.46: 	    >= value then right.find(wanted)
+//│ ║        	^^^^^^^^^^^^
+//│ ╟── type `int` is not an instance of type `Num`
+//│ ║  l.43: 	class Node[A](value: int, left: Tree[A], right: Tree[A]) {
+//│ ║        	                     ^^^
+//│ ╟── but it flows into reference with expected type `Num`
+//│ ║  l.46: 	    >= value then right.find(wanted)
+//│ ╙──      	       ^^^^^
+//│ ╔══[ERROR] Type `#Node & {Node#A = A}` does not contain member `find`
+//│ ║  l.46: 	    >= value then right.find(wanted)
+//│ ╙──      	                       ^^^^^
+//│ ╔══[ERROR] Type mismatch in operator application:
+//│ ║  l.44: 	  fun contains(wanted) = if wanted
 //│ ║        	                            ^^^^^^
-//│ ║  l.47: 	    <= value then left.find(wanted)
+//│ ║  l.45: 	    <= value then left.find(wanted)
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.48: 	    >= value then right.find(wanted)
+//│ ║  l.46: 	    >= value then right.find(wanted)
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.49: 	    == value then true
-//│ ╙──      	^^^^^^^^^^^^
+//│ ║  l.47: 	    == value then true
+//│ ║        	^^^^^^^^^^^^
+//│ ╟── type `int` is not an instance of type `Num`
+//│ ║  l.43: 	class Node[A](value: int, left: Tree[A], right: Tree[A]) {
+//│ ║        	                     ^^^
+//│ ╟── but it flows into reference with expected type `Num`
+//│ ║  l.47: 	    == value then true
+//│ ╙──      	       ^^^^^
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.47: 	    == value then true
+//│ ║        	                  ^^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ type Tree[A] = Empty | Node[A]
 //│ module Empty {
 //│   fun contains: anything -> false
 //│ }
 //│ class Node[A](value: int, left: Tree[A], right: Tree[A]) {
-//│   fun contains: anything -> error
+//│   fun contains: Num -> (error | true)
 //│ }
diff --git a/shared/src/test/diff/ucs/Humiliation.mls b/shared/src/test/diff/ucs/Humiliation.mls
index 878fb05372..2463ac99c3 100644
--- a/shared/src/test/diff/ucs/Humiliation.mls
+++ b/shared/src/test/diff/ucs/Humiliation.mls
@@ -7,10 +7,18 @@ class Foo(x)
 //│    = [Function: Foo1]
 
 if 1 is 1 then 1 else 0
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.9: 	if 1 is 1 then 1 else 0
+//│ ╙──     	   ^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ res: 0 | 1
 //│    = 1
 
 fun test(x) = if x is 1 then 0 else 1
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.17: 	fun test(x) = if x is 1 then 0 else 1
+//│ ╙──      	                 ^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ test: anything -> (0 | 1)
 //│     = [Function: test]
 
@@ -19,12 +27,19 @@ fun test(x) = if x is 1 then 0 else 1
 fun testF(x) = if x is
   Foo(a) then a
   Foo(a) then a
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.27: 	fun testF(x) = if x is
+//│ ║        	                  ^^^^
+//│ ║  l.28: 	  Foo(a) then a
+//│ ║        	^^^^^^^^^^^^^^^
+//│ ║  l.29: 	  Foo(a) then a
+//│ ╙──      	^^^^^^^^^^^^^^^
 //│ ╔══[WARNING] Found a duplicated branch
 //│ ╟── This branch
-//│ ║  l.21: 	  Foo(a) then a
+//│ ║  l.29: 	  Foo(a) then a
 //│ ║        	              ^
 //│ ╟── is subsumed by the branch here.
-//│ ║  l.20: 	  Foo(a) then a
+//│ ║  l.28: 	  Foo(a) then a
 //│ ╙──      	              ^
 //│ testF: (Foo & {x: 'x}) -> 'x
 //│      = [Function: testF]
@@ -37,6 +52,14 @@ class Bar(y, z)
 fun test(f) = if f is
   Foo(a) then a
   Bar(b, c) then b + c
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.52: 	fun test(f) = if f is
+//│ ║        	                 ^^^^
+//│ ║  l.53: 	  Foo(a) then a
+//│ ║        	^^^^^^^^^^^^^^^
+//│ ║  l.54: 	  Bar(b, c) then b + c
+//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ test: (Bar & {y: int, z: int} | Foo & {x: 'x}) -> (int | 'x)
 //│     = [Function: test1]
 
@@ -52,6 +75,18 @@ fun f(x) =
     Pair(1, 1) then "ones"
     Pair(y, 1) then x
     _          then "nah"
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.73: 	  if x is
+//│ ║        	     ^^^^
+//│ ║  l.74: 	    Pair(0, 0) then "zeros"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.75: 	    Pair(1, 1) then "ones"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.76: 	    Pair(y, 1) then x
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.77: 	    _          then "nah"
+//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ f: (Pair & 'a | ~Pair) -> ("nah" | "ones" | "zeros" | 'a)
 //│  = [Function: f]
 
@@ -70,16 +105,24 @@ class O()
 fun foo(x) = if x is
   Pair(Z(), Z()) then "zeros"
   Pair(O(), O()) then "ones"
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.105: 	fun foo(x) = if x is
+//│ ║         	                ^^^^
+//│ ║  l.106: 	  Pair(Z(), Z()) then "zeros"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.107: 	  Pair(O(), O()) then "ones"
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ ╔══[ERROR] The match is not exhaustive.
-//│ ║  l.70: 	fun foo(x) = if x is
-//│ ║        	                ^^^^
+//│ ║  l.105: 	fun foo(x) = if x is
+//│ ║         	                ^^^^
 //│ ╟── The scrutinee at this position misses 1 case.
-//│ ║  l.71: 	  Pair(Z(), Z()) then "zeros"
-//│ ║        	            ^^^
+//│ ║  l.106: 	  Pair(Z(), Z()) then "zeros"
+//│ ║         	            ^^^
 //│ ╟── [Missing Case 1/1] `O`
 //│ ╟── It first appears here.
-//│ ║  l.72: 	  Pair(O(), O()) then "ones"
-//│ ╙──      	            ^^^
+//│ ║  l.107: 	  Pair(O(), O()) then "ones"
+//│ ╙──       	            ^^^
 //│ foo: anything -> error
 //│ Code generation encountered an error:
 //│   if expression was not desugared
@@ -90,16 +133,24 @@ fun foo(x) = if x is
 fun foo(x) = if x is
   [Z(), Z()] then "zeros"
   [O(), O()] then "ones"
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.133: 	fun foo(x) = if x is
+//│ ║         	                ^^^^
+//│ ║  l.134: 	  [Z(), Z()] then "zeros"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.135: 	  [O(), O()] then "ones"
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ ╔══[ERROR] The match is not exhaustive.
-//│ ║  l.90: 	fun foo(x) = if x is
-//│ ║        	                ^^^^
+//│ ║  l.133: 	fun foo(x) = if x is
+//│ ║         	                ^^^^
 //│ ╟── The scrutinee at this position misses 1 case.
-//│ ║  l.91: 	  [Z(), Z()] then "zeros"
-//│ ║        	        ^^^
+//│ ║  l.134: 	  [Z(), Z()] then "zeros"
+//│ ║         	        ^^^
 //│ ╟── [Missing Case 1/1] `O`
 //│ ╟── It first appears here.
-//│ ║  l.92: 	  [O(), O()] then "ones"
-//│ ╙──      	        ^^^
+//│ ║  l.135: 	  [O(), O()] then "ones"
+//│ ╙──       	        ^^^
 //│ foo: anything -> error
 //│ Code generation encountered an error:
 //│   if expression was not desugared
@@ -110,6 +161,44 @@ fun foo(x) = if x is
       Z() then "zeros"
     O() then if b is
       O() then "ones"
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.158: 	fun foo(x) = if x is
+//│ ║         	                ^^^^
+//│ ║  l.159: 	  Pair(a, b) then if a is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.160: 	    Z() then if b is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.161: 	      Z() then "zeros"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.162: 	    O() then if b is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.163: 	      O() then "ones"
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.159: 	  Pair(a, b) then if a is
+//│ ║         	                     ^^^^
+//│ ║  l.160: 	    Z() then if b is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.161: 	      Z() then "zeros"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.162: 	    O() then if b is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.163: 	      O() then "ones"
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.160: 	    Z() then if b is
+//│ ║         	                ^^^^
+//│ ║  l.161: 	      Z() then "zeros"
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.162: 	    O() then if b is
+//│ ║         	                ^^^^
+//│ ║  l.163: 	      O() then "ones"
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ foo: (Pair & {fst: O | Z, snd: nothing}) -> ("ones" | "zeros")
 //│    = [Function: foo2]
 
@@ -120,6 +209,50 @@ fun foo(x) = if x is
       else "???"
     O() then if b is
       O() then "ones"
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.205: 	fun foo(x) = if x is
+//│ ║         	                ^^^^
+//│ ║  l.206: 	  Pair(a, b) then if a is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.207: 	    Z() then if b is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.208: 	      Z() then "zeros"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.209: 	      else "???"
+//│ ║         	^^^^^^^^^^^^^^^^^
+//│ ║  l.210: 	    O() then if b is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.211: 	      O() then "ones"
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.206: 	  Pair(a, b) then if a is
+//│ ║         	                     ^^^^
+//│ ║  l.207: 	    Z() then if b is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.208: 	      Z() then "zeros"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.209: 	      else "???"
+//│ ║         	^^^^^^^^^^^^^^^^
+//│ ║  l.210: 	    O() then if b is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.211: 	      O() then "ones"
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.207: 	    Z() then if b is
+//│ ║         	                ^^^^
+//│ ║  l.208: 	      Z() then "zeros"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.209: 	      else "???"
+//│ ╙──       	^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.210: 	    O() then if b is
+//│ ║         	                ^^^^
+//│ ║  l.211: 	      O() then "ones"
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ foo: (Pair & {fst: O | Z, snd: O}) -> ("???" | "ones" | "zeros")
 //│    = [Function: foo3]
 
@@ -131,6 +264,56 @@ fun foo(x) = if x is
     O() then if b is
       O() then "zeros"
       else "???"
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.259: 	fun foo(x) = if x is
+//│ ║         	                ^^^^
+//│ ║  l.260: 	  Pair(a, b) then if a is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.261: 	    Z() then if b is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.262: 	      Z() then "zeros"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.263: 	      else "???"
+//│ ║         	^^^^^^^^^^^^^^^^^
+//│ ║  l.264: 	    O() then if b is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.265: 	      O() then "zeros"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.266: 	      else "???"
+//│ ╙──       	^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.260: 	  Pair(a, b) then if a is
+//│ ║         	                     ^^^^
+//│ ║  l.261: 	    Z() then if b is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.262: 	      Z() then "zeros"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.263: 	      else "???"
+//│ ║         	^^^^^^^^^^^^^^^^
+//│ ║  l.264: 	    O() then if b is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.265: 	      O() then "zeros"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.266: 	      else "???"
+//│ ╙──       	^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.261: 	    Z() then if b is
+//│ ║         	                ^^^^
+//│ ║  l.262: 	      Z() then "zeros"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.263: 	      else "???"
+//│ ╙──       	^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.264: 	    O() then if b is
+//│ ║         	                ^^^^
+//│ ║  l.265: 	      O() then "zeros"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.266: 	      else "???"
+//│ ╙──       	^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ foo: (Pair & {fst: O | Z}) -> ("???" | "zeros")
 //│    = [Function: foo4]
 
@@ -148,6 +331,52 @@ fun foo(x) = if x is
     O() then if b is
       O() then "zeros"
       else "???"
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.326: 	fun foo(x) = if x is
+//│ ║         	                ^^^^
+//│ ║  l.327: 	  Pair(a, b) then if a is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.328: 	    Z() then if b is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.329: 	      S(x) then x
+//│ ║         	^^^^^^^^^^^^^^^^^
+//│ ║  l.330: 	      else "???"
+//│ ║         	^^^^^^^^^^^^^^^^^
+//│ ║  l.331: 	    O() then if b is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.332: 	      O() then "zeros"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.333: 	      else "???"
+//│ ╙──       	^^^^^^^^^^^^^^^^^
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.327: 	  Pair(a, b) then if a is
+//│ ║         	                     ^^^^
+//│ ║  l.328: 	    Z() then if b is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.329: 	      S(x) then x
+//│ ║         	^^^^^^^^^^^^^^^^^
+//│ ║  l.330: 	      else "???"
+//│ ║         	^^^^^^^^^^^^^^^^
+//│ ║  l.331: 	    O() then if b is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.332: 	      O() then "zeros"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.333: 	      else "???"
+//│ ╙──       	^^^^^^^^^^^^^^^^
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.328: 	    Z() then if b is
+//│ ║         	                ^^^^
+//│ ║  l.329: 	      S(x) then x
+//│ ║         	^^^^^^^^^^^^^^^^^
+//│ ║  l.330: 	      else "???"
+//│ ╙──       	^^^^^^^^^^^^^^^^^
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.331: 	    O() then if b is
+//│ ║         	                ^^^^
+//│ ║  l.332: 	      O() then "zeros"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.333: 	      else "???"
+//│ ╙──       	^^^^^^^^^^^^^^^^^
 //│ foo: (Pair & {fst: O | Z, snd: S & {pred: 'pred} | ~S}) -> ("???" | "zeros" | 'pred)
 //│    = [Function: foo5]
 
@@ -161,21 +390,35 @@ fun foo(x) = if x is
   Pair(Z(), Z()) then "zeros"
   Pair(O(), O()) then "ones"
   Pair(y, O()) then x
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.389: 	fun foo(x) = if x is
+//│ ║         	                ^^^^
+//│ ║  l.390: 	  Pair(Z(), Z()) then "zeros"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.391: 	  Pair(O(), O()) then "ones"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.392: 	  Pair(y, O()) then x
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ ╔══[ERROR] The match is not exhaustive.
-//│ ║  l.160: 	fun foo(x) = if x is
+//│ ║  l.389: 	fun foo(x) = if x is
 //│ ║         	                ^^^^
 //│ ╟── The scrutinee at this position misses 1 case.
-//│ ║  l.161: 	  Pair(Z(), Z()) then "zeros"
+//│ ║  l.390: 	  Pair(Z(), Z()) then "zeros"
 //│ ║         	            ^^^
 //│ ╟── [Missing Case 1/1] `Z`
 //│ ╟── It first appears here.
-//│ ║  l.161: 	  Pair(Z(), Z()) then "zeros"
+//│ ║  l.390: 	  Pair(Z(), Z()) then "zeros"
 //│ ╙──       	            ^^^
 //│ foo: anything -> error
 //│ Code generation encountered an error:
 //│   if expression was not desugared
 
 fun foo(x, y) = if x is Z() and y is O() then 0 else 1
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.417: 	fun foo(x, y) = if x is Z() and y is O() then 0 else 1
+//│ ╙──       	                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ foo: (anything, anything,) -> (0 | 1)
 //│    = [Function: foo7]
 
@@ -183,5 +426,13 @@ fun foo(x, y) =
   if x is
     Z() and y is O() then 0
     else 1
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.426: 	  if x is
+//│ ║         	     ^^^^
+//│ ║  l.427: 	    Z() and y is O() then 0
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.428: 	    else 1
+//│ ╙──       	^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ foo: (anything, anything,) -> (0 | 1)
 //│    = [Function: foo8]
diff --git a/shared/src/test/diff/ucs/Hygiene.mls b/shared/src/test/diff/ucs/Hygiene.mls
index 10424de6ff..dd49ef464d 100644
--- a/shared/src/test/diff/ucs/Hygiene.mls
+++ b/shared/src/test/diff/ucs/Hygiene.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 class Some[out T](value: T)
 class Left[out T](value: T)
@@ -7,18 +7,31 @@ class Right[out T](value: T)
 //│ class Left[T](value: T)
 //│ class Right[T](value: T)
 
-// FIXME unhygienic, the `x` in the second branch shadows parameter `x`
+:dpt:postprocess.result
 fun foo(x) = if x is
   Some(Left(y)) then x
   Some(x) then x
-//│ fun foo: forall 'a. Some['a & (Left[anything] | Object & ~#Left)] -> 'a
+//│ | | | | | Post-processed UCS term:
+//│ | | | | | case x*‡ of
+//│ | | | | |   Some*◊ ->
+//│ | | | | |     let ucs$args_x$Some*† = (Some).unapply(x,)
+//│ | | | | |     let x$Some_0*‡ = (ucs$args_x$Some).0
+//│ | | | | |     case x$Some_0*‡ of
+//│ | | | | |       Left*◊ ->
+//│ | | | | |         let ucs$args_x$Some_0$Left*† = (Left).unapply(x$Some_0,)
+//│ | | | | |         let y*‡ = (ucs$args_x$Some_0$Left).0
+//│ | | | | |         x
+//│ | | | | |       _ ->
+//│ | | | | |         let x*‡ = (ucs$args_x$Some).0
+//│ | | | | |         x
+//│ fun foo: forall 'T. Some[(Left[anything] | Object & ~#Left) & 'T] -> (Some['T] | 'T)
 
 foo(Some(Left(1)))
-//│ Left[1]
+//│ Left[1] | Some[Left[1]]
 //│ res
-//│     = Left {}
+//│     = Some {}
 
 foo(Some(2))
-//│ 2
+//│ 2 | Some[2]
 //│ res
 //│     = 2
diff --git a/shared/src/test/diff/ucs/HygienicBindings.mls b/shared/src/test/diff/ucs/HygienicBindings.mls
index 5e5d577f9c..bcfd1b7e12 100644
--- a/shared/src/test/diff/ucs/HygienicBindings.mls
+++ b/shared/src/test/diff/ucs/HygienicBindings.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 type Option[out T] = None | Some[T]
 module None
@@ -28,14 +28,42 @@ fun h0(a) =
     a is None then 0
 //│ fun h0: forall 'a. (None | Some[Left['a] | Right['a]]) -> (0 | 'a)
 
-// FIXME: Precise scrutinee identification (easy)
-// This seems fine. But the subtrees are not merged.
+// Precise scrutinee identification (easy)
+// =======================================
+// The desugarer should be able to identify pattern matching on the first
+// parameter of `Some` even if they are bound to different variables.
+:dpt:postprocess.result
 fun h1(a) =
   if
     a is Some(x) and x is Left(y) then y
     a is Some(y) and y is Right(z) then z
     a is None then 0
-//│ fun h1: forall 'a. (None | Some[Right['a]]) -> (0 | 'a)
+//│ | | | | | | | Post-processed UCS term:
+//│ | | | | | | | case a*‡ of
+//│ | | | | | | |   Some*◊ ->
+//│ | | | | | | |     let ucs$args_a$Some*† = (Some).unapply(a,)
+//│ | | | | | | |     let x*‡ = (ucs$args_a$Some).0
+//│ | | | | | | |     case x*‡ of
+//│ | | | | | | |       Left*◊ ->
+//│ | | | | | | |         let ucs$args_x$Left*† = (Left).unapply(x,)
+//│ | | | | | | |         let y*‡ = (ucs$args_x$Left).0
+//│ | | | | | | |         y
+//│ | | | | | | |       Right*◊ ->
+//│ | | | | | | |         let y*‡ = (ucs$args_a$Some).0
+//│ | | | | | | |         let ucs$args_y$Right*† = (Right).unapply(y,)
+//│ | | | | | | |         let z*‡ = (ucs$args_y$Right).0
+//│ | | | | | | |         z
+//│ | | | | | | |   None*† -> 0
+//│ fun h1: forall 'a. (None | Some[Right[anything] & {#rightValue: 'a}]) -> (0 | 'a)
+
+// FIXME
+h1(Some(Left(0)))
+//│ ╔══[ERROR] Type `Left[?A]` does not contain member `rightValue`
+//│ ║  l.12: 	class Right[B](val rightValue: B)
+//│ ╙──      	                   ^^^^^^^^^^
+//│ 0 | error
+//│ res
+//│     = 0
 
 // This is the desugared version of the test case above.
 fun h1'(a) =
@@ -55,54 +83,36 @@ fun h1'(a) =
     None then 0
 //│ fun h1': forall 'leftValue. (None | Some[Right['leftValue]]) -> (0 | 'leftValue)
 
-// FIXME This seems fine but the desugared term does not merge the cases.
-// See the example below.
-fun h1''(a) =
-  if
-    a is Some(x) and x is Left(y) then y
-    a is Some(x) and x is Right(z) then z
-    a is None then 0
-//│ fun h1'': forall 'a. (None | Some[Left['a] | Right['a]]) -> (0 | 'a)
-
 // FIXME
-h1(Some(Left(0)))
 h1'(Some(Left(0)))
-h1''(Some(Left(0)))
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.68: 	h1(Some(Left(0)))
-//│ ║        	^^^^^^^^^^^^^^^^^
-//│ ╟── application of type `Left[?A]` is not an instance of type `Right`
-//│ ║  l.68: 	h1(Some(Left(0)))
-//│ ║        	        ^^^^^^^
-//│ ╟── Note: constraint arises from class pattern:
-//│ ║  l.36: 	    a is Some(y) and y is Right(z) then z
-//│ ║        	                          ^^^^^
-//│ ╟── from field selection:
-//│ ║  l.5: 	class Some[out T](val value: T)
-//│ ║       	                      ^^^^^
-//│ ╟── Note: type parameter T is defined at:
-//│ ║  l.5: 	class Some[out T](val value: T)
-//│ ╙──     	               ^
-//│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.69: 	h1'(Some(Left(0)))
+//│ ║  l.87: 	h1'(Some(Left(0)))
 //│ ║        	^^^^^^^^^^^^^^^^^^
 //│ ╟── application of type `Left[?A]` is not an instance of type `Right`
-//│ ║  l.69: 	h1'(Some(Left(0)))
+//│ ║  l.87: 	h1'(Some(Left(0)))
 //│ ║        	         ^^^^^^^
 //│ ╟── Note: constraint arises from class pattern:
-//│ ║  l.52: 	            Right then
+//│ ║  l.80: 	            Right then
 //│ ║        	            ^^^^^
 //│ ╟── from field selection:
-//│ ║  l.45: 	      let y = a.value
+//│ ║  l.73: 	      let y = a.value
 //│ ║        	              ^^^^^^^
 //│ ╟── Note: type parameter T is defined at:
 //│ ║  l.5: 	class Some[out T](val value: T)
 //│ ╙──     	               ^
-//│ 0
-//│ res
-//│     = 0
+//│ 0 | error
 //│ res
 //│     = 0
+
+fun h1''(a) =
+  if
+    a is Some(x) and x is Left(y) then y
+    a is Some(x) and x is Right(z) then z
+    a is None then 0
+//│ fun h1'': forall 'a. (None | Some[Left['a] | Right['a]]) -> (0 | 'a)
+
+h1''(Some(Left(0)))
+//│ 0
 //│ res
 //│     = 0
 
@@ -114,15 +124,7 @@ fun h2(a) =
       let y' = y
       y' is Right(z) then z
     a is None then 0
-//│ ╔══[ERROR] identifier not found: y
-//│ ║  l.114: 	      let y' = y
-//│ ╙──       	               ^
-//│ ╔══[ERROR] identifier not found: y
-//│ ║  l.114: 	      let y' = y
-//│ ╙──       	               ^
-//│ fun h2: forall 'a. (None | Some[Left['a] | Object & ~#Left]) -> (0 | error | 'a)
-//│ Code generation encountered an error:
-//│   unresolved symbol y
+//│ fun h2: forall 'a. (None | Some[Left['a]]) -> (0 | 'a)
 
 // FIXME: Some results are wrong.
 fun h3(x, y, f, p) =
@@ -133,32 +135,44 @@ fun h3(x, y, f, p) =
 h3("anything", "not me", _ => "should be me", _ => true)
 h3(None, "should be me", _ => "not me", _ => false)
 h3("anything", "anything", _ => "not me", _ => false)
-//│ fun h3: forall 'a 'b. (None | Object & 'a & ~#None, 'b, (None | 'a) -> anything, (None | 'a) -> Object) -> ("anyway" | 'b)
-//│ "anything" | "anyway"
-//│ res
-//│     = 'not me'
+//│ fun h3: forall 'a 'b. (Object & 'a, anything, 'a -> 'b, 'a -> Bool) -> ("anyway" | 'b)
+//│ "anyway" | "not me"
 //│ res
 //│     = 'should be me'
 //│ res
+//│     = 'not me'
+//│ res
 //│     = 'anyway'
 
-// FIXME: Some results are wrong.
+
+// FIXME: We still haven't fixed all shadowing problems.
+:dpt:postprocess.result
 fun h4(x, y, p) =
   if x is
     y and p(x) then y
     None then y
     _ then "default"
-h4("should be me", "not me", _ => true) // WRONG!
-h4(None, "not me", _ => true) // WRONG!
+//│ | | | | | | | Post-processed UCS term:
+//│ | | | | | | | let y*‡ = x
+//│ | | | | | | | let ucs$test$0*† = p(x,) : Bool
+//│ | | | | | | | case ucs$test$0*† of
+//│ | | | | | | |   true*† -> y
+//│ | | | | | | |   _ ->
+//│ | | | | | | |     case x*‡ of
+//│ | | | | | | |       None*† -> y
+//│ | | | | | | |       _ -> "default"
+//│ fun h4: forall 'a. (Object & 'a, anything, 'a -> Bool) -> ("default" | 'a)
+
+h4("should be me", "not me", _ => true)
+h4(None, "not me", _ => true)
 h4(None, "should be me", _ => false)
 h4("anything", "not me", _ => false)
-//│ fun h4: forall 'a 'b. (None | Object & 'a & ~#None, 'b, (None | 'a) -> Object) -> ("default" | 'b)
-//│ "default" | "not me"
+//│ "anything" | "default"
 //│ res
-//│     = 'not me'
+//│     = 'should be me'
 //│ res
-//│     = 'not me'
+//│     = None { class: [class None] }
 //│ res
-//│     = 'should be me'
+//│     = None { class: [class None] }
 //│ res
 //│     = 'default'
diff --git a/shared/src/test/diff/ucs/InterleavedLet.mls b/shared/src/test/diff/ucs/InterleavedLet.mls
index 77b2d6ba51..6b8d1ade0e 100644
--- a/shared/src/test/diff/ucs/InterleavedLet.mls
+++ b/shared/src/test/diff/ucs/InterleavedLet.mls
@@ -5,6 +5,16 @@ fun f(x) =
     let v = 0
     v then v
     else 0
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.4: 	  if x ==
+//│ ║       	     ^^^^
+//│ ║  l.5: 	    let v = 0
+//│ ║       	^^^^^^^^^^^^^
+//│ ║  l.6: 	    v then v
+//│ ║       	^^^^^^^^^^^^
+//│ ║  l.7: 	    else 0
+//│ ╙──     	^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ f: number -> 0
 //│  = [Function: f]
 
@@ -36,6 +46,10 @@ class Right(rightValue): Either
 fun q(x) =
   if
     x is Some and x is Some and x is Some then 0
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.48: 	    x is Some and x is Some and x is Some then 0
+//│ ╙──      	    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ q: Some -> 0
 //│  = [Function: q]
 
@@ -45,12 +59,19 @@ fun p(x, y) =
     x is Some and y is None then 0
     y is Some and x is Some then 1
     x is Some and y is Some then 0
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.59: 	    x is Some and y is None then 0
+//│ ║        	    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.60: 	    y is Some and x is Some then 1
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.61: 	    x is Some and y is Some then 0
+//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╔══[WARNING] Found a duplicated branch
 //│ ╟── This branch
-//│ ║  l.47: 	    x is Some and y is Some then 0
+//│ ║  l.61: 	    x is Some and y is Some then 0
 //│ ║        	                                 ^
 //│ ╟── is subsumed by the branch here.
-//│ ║  l.46: 	    y is Some and x is Some then 1
+//│ ║  l.60: 	    y is Some and x is Some then 1
 //│ ╙──      	                                 ^
 //│ p: (Some, None | Some,) -> (0 | 1)
 //│  = [Function: p]
@@ -60,6 +81,16 @@ fun h(x, y) =
     None then y
     let y_square = y * y
     Some(z) then z + y_square
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.80: 	  if x is
+//│ ║        	     ^^^^
+//│ ║  l.81: 	    None then y
+//│ ║        	^^^^^^^^^^^^^^^
+//│ ║  l.82: 	    let y_square = y * y
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.83: 	    Some(z) then z + y_square
+//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ h: (None | Some & {value: int}, int,) -> int
 //│  = [Function: h]
 
@@ -72,6 +103,16 @@ fun h(x, y) =
     None then y
     let y_square = y * y
     Some(y_square) then 0
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.102: 	  if x is
+//│ ║         	     ^^^^
+//│ ║  l.103: 	    None then y
+//│ ║         	^^^^^^^^^^^^^^^
+//│ ║  l.104: 	    let y_square = y * y
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.105: 	    Some(y_square) then 0
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ h: (None | Some, int & 'a,) -> (0 | 'a)
 //│  = [Function: h1]
 
@@ -82,6 +123,20 @@ fun f(a, y) =
       let y = v + 1
       Right(x) then x + y
     else 0
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.120: 	  if a is
+//│ ║         	     ^^^^
+//│ ║  l.121: 	    Some(v) and v is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.122: 	      Left(x) then x
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.123: 	      let y = v + 1
+//│ ║         	^^^^^^^^^^^^^^^^^^^
+//│ ║  l.124: 	      Right(x) then x + y
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.125: 	    else 0
+//│ ╙──       	^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ f: (Some & {value: int} | ~Some, anything,) -> int
 //│  = [Function: f1]
 
@@ -92,10 +147,20 @@ fun q(a) =
     let y = a + 1
     then y
 //│ ╔══[PARSE ERROR] Expected an expression; found a 'then'/'else' clause instead
-//│ ║  l.92: 	    let y = a + 1
-//│ ║        	            ^^^^^
-//│ ║  l.93: 	    then y
-//│ ╙──      	^^^^^^^^^^
+//│ ║  l.147: 	    let y = a + 1
+//│ ║         	            ^^^^^
+//│ ║  l.148: 	    then y
+//│ ╙──       	^^^^^^^^^^
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.145: 	  if a is
+//│ ║         	     ^^^^
+//│ ║  l.146: 	    Left(x) then x
+//│ ║         	^^^^^^^^^^^^^^^^^^
+//│ ║  l.147: 	    let y = a + 1
+//│ ║         	^^^^^^^^^^^^^^^^^
+//│ ║  l.148: 	    then y
+//│ ╙──       	^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ q: (Left & {leftValue: 'leftValue}) -> 'leftValue
 //│  = [Function: q1]
 
@@ -114,6 +179,16 @@ fun w() =
     let y = 0
     B then "B"
     else "?"
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.178: 	    A then "A"
+//│ ║         	    ^^^^^^^^^^
+//│ ║  l.179: 	    let y = 0
+//│ ║         	^^^^^^^^^^^^^
+//│ ║  l.180: 	    B then "B"
+//│ ║         	^^^^^^^^^^^^^^
+//│ ║  l.181: 	    else "?"
+//│ ╙──       	^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ w: () -> ("?" | "A" | "B")
 //│  = [Function: w]
 
@@ -126,6 +201,16 @@ fun i(x) =
     A() then "A"
     let y = 0
     B() then "B"
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.200: 	  if x is
+//│ ║         	     ^^^^
+//│ ║  l.201: 	    A() then "A"
+//│ ║         	^^^^^^^^^^^^^^^^
+//│ ║  l.202: 	    let y = 0
+//│ ║         	^^^^^^^^^^^^^
+//│ ║  l.203: 	    B() then "B"
+//│ ╙──       	^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ i: (A | B) -> ("A" | "B")
 //│  = [Function: i]
 
@@ -138,6 +223,16 @@ fun qq(x, z) =
     let y = inc(z)
     y * y then 0
     else 0
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.222: 	  if x ==
+//│ ║         	     ^^^^
+//│ ║  l.223: 	    let y = inc(z)
+//│ ║         	^^^^^^^^^^^^^^^^^^
+//│ ║  l.224: 	    y * y then 0
+//│ ║         	^^^^^^^^^^^^^^^^
+//│ ║  l.225: 	    else 0
+//│ ╙──       	^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ qq: (number, int,) -> 0
 //│   = [Function: qq]
 
@@ -146,6 +241,14 @@ fun bruh(x) =
     x == 0 then 0
     let y = 1
     else y
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.241: 	    x == 0 then 0
+//│ ║         	    ^^^^^^^^^^^^^
+//│ ║  l.242: 	    let y = 1
+//│ ║         	^^^^^^^^^^^^^
+//│ ║  l.243: 	    else y
+//│ ╙──       	^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ bruh: number -> (0 | 1)
 //│     = [Function: bruh]
 
@@ -164,6 +267,20 @@ fun ff(x) =
     z == 1 then 1
     z == 2 then 2
     else 0
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.264: 	    x == 0 then 0
+//│ ║         	    ^^^^^^^^^^^^^
+//│ ║  l.265: 	    let y = f1(x)
+//│ ║         	^^^^^^^^^^^^^^^^^
+//│ ║  l.266: 	    let z = f2(x, y)
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.267: 	    z == 1 then 1
+//│ ║         	^^^^^^^^^^^^^^^^^
+//│ ║  l.268: 	    z == 2 then 2
+//│ ║         	^^^^^^^^^^^^^^^^^
+//│ ║  l.269: 	    else 0
+//│ ╙──       	^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ ff: int -> (0 | 1 | 2)
 //│   = [Function: ff]
 
@@ -172,6 +289,16 @@ fun ip(y) =
     let z = inc(y)
     y == z * z then "bruh"
   else "rocks"
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.288: 	  if q(y) and
+//│ ║         	     ^^^^^^^^
+//│ ║  l.289: 	    let z = inc(y)
+//│ ║         	^^^^^^^^^^^^^^^^^^
+//│ ║  l.290: 	    y == z * z then "bruh"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.291: 	  else "rocks"
+//│ ╙──       	^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ ip: nothing -> ("bruh" | "rocks")
 //│   = [Function: ip]
 
@@ -180,6 +307,16 @@ fun tr(x) =
     Some(v) then v
     let tmp = 1
     None then tmp
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.306: 	  if x is
+//│ ║         	     ^^^^
+//│ ║  l.307: 	    Some(v) then v
+//│ ║         	^^^^^^^^^^^^^^^^^^
+//│ ║  l.308: 	    let tmp = 1
+//│ ║         	^^^^^^^^^^^^^^^
+//│ ║  l.309: 	    None then tmp
+//│ ╙──       	^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ tr: (None | Some & {value: 'value}) -> (1 | 'value)
 //│   = [Function: tr]
 
@@ -227,6 +364,16 @@ fun showList(xs) =
 //│   })());
 //│ };
 //│ // End of generated code
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.349: 	  if xs is
+//│ ║         	     ^^^^^
+//│ ║  l.350: 	    Nil              then ""
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.351: 	    Cons(head, Nil())  then toString(head)
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.352: 	    Cons(head, tail) then cat3(toString(head), ", ", showList(tail))
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ showList: (Cons & 'a | Nil) -> string
 //│   where
 //│     'a <: {head: anything, tail: Cons & 'a | Nil}
@@ -255,6 +402,24 @@ fun mapPartition(f, xs) =
       let r = res.snd
       Left(v)  then Pair(Cons(v, l), r)
       Right(v) then Pair(l, Cons(v, r))
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.397: 	  if xs is
+//│ ║         	     ^^^^^
+//│ ║  l.398: 	    Nil then Pair(Nil(), Nil())
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.399: 	    Cons(x, xs) and f(x) is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.400: 	      let res = mapPartition(f, xs)
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.401: 	      let l = res.fst
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.402: 	      let r = res.snd
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.403: 	      Left(v)  then Pair(Cons(v, l), r)
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.404: 	      Right(v) then Pair(l, Cons(v, r))
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ mapPartition: ('head -> (Left & {leftValue: 'leftValue} | Right & {rightValue: 'rightValue}), Cons & 'a | Nil,) -> (Pair & {fst: forall 'b 'c. Nil | 'c | 'b, snd: Nil | Cons & {head: 'rightValue, tail: Nil}})
 //│   where
 //│     'b :> Cons & {head: 'leftValue, tail: forall 'd. Nil | 'd}
@@ -263,6 +428,10 @@ fun mapPartition(f, xs) =
 //│             = [Function: mapPartition]
 
 mapPartition(x => (if x % 2 == 0 then Left(x) else Right(x)), zeroToThree)
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.430: 	mapPartition(x => (if x % 2 == 0 then Left(x) else Right(x)), zeroToThree)
+//│ ╙──       	                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ res: Pair & {
 //│   fst: forall 'a 'b. Nil | 'b | 'a,
 //│   snd: Nil | Cons & {head: 0 | 1 | 2 | 3, tail: Nil}
@@ -282,6 +451,18 @@ fun mapPartition2(f, xs) =
     Cons(x, xs) and mapPartition(f, xs) is res and res.fst is l and res.snd is r and f(x) is
       Left(v)  then Pair(Cons(v, l), r)
       Right(v) then Pair(l, Cons(v, r))
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.449: 	  if xs is
+//│ ║         	     ^^^^^
+//│ ║  l.450: 	    Nil then Pair(Nil(), Nil())
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.451: 	    Cons(x, xs) and mapPartition(f, xs) is res and res.fst is l and res.snd is r and f(x) is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.452: 	      Left(v)  then Pair(Cons(v, l), r)
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.453: 	      Right(v) then Pair(l, Cons(v, r))
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ mapPartition2: ('head -> (Left & {leftValue: 'leftValue} | Right & {rightValue: 'rightValue}) & 'head0 -> (Left & {leftValue: 'leftValue0} | Right & {rightValue: 'rightValue0}), Cons & {head: 'head0, tail: Cons & 'a | Nil} | Nil,) -> (Pair & {
 //│   fst: forall 'b. Cons & {
 //│     head: 'leftValue0,
@@ -300,6 +481,10 @@ fun mapPartition2(f, xs) =
 //│              = [Function: mapPartition2]
 
 mapPartition2(x => (if x % 2 == 0 then Left(x) else Right(x)), zeroToThree)
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.483: 	mapPartition2(x => (if x % 2 == 0 then Left(x) else Right(x)), zeroToThree)
+//│ ╙──       	                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ res: Pair & {
 //│   fst: forall 'a. Cons & {
 //│     head: 0,
@@ -333,6 +518,26 @@ fun mn(a) =
         2 then "b is 3"
       Right(b) then "right-defined"
     None       then "undefined"
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.512: 	  if a is
+//│ ║         	     ^^^^
+//│ ║  l.513: 	    Some(x) and x is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.514: 	      Left(b) and b is
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.515: 	        0 then "b is 1"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.516: 	        let _ = log(b)
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.517: 	        1 then "b is 2"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.518: 	        2 then "b is 3"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.519: 	      Right(b) then "right-defined"
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.520: 	    None       then "undefined"
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ mn: (None | Some & {value: Left & {leftValue: 0 | 1 | 2} | Right}) -> ("b is 1" | "b is 2" | "b is 3" | "right-defined" | "undefined")
 //│   = [Function: mn]
 
diff --git a/shared/src/test/diff/ucs/JSON.mls b/shared/src/test/diff/ucs/JSON.mls
deleted file mode 100644
index 889ff5a296..0000000000
--- a/shared/src/test/diff/ucs/JSON.mls
+++ /dev/null
@@ -1,319 +0,0 @@
-:NewParser
-:NewDefs
-
-:escape
-// We need to use some native methods on `String`.
-let String: nothing
-let asNativeString: anything => { length: Int, charCodeAt: Int => Int, charAt: Int => Str, slice: Int => Str } = String
-let StringInstance: { fromCharCode: Int => Str } = String
-// We will validate our implementation with the built-in `JSON.parse`.
-let JSON: { parse: Str => anything, stringify: anything => Str }
-//│ let asNativeString: anything -> {charAt: Int -> Str, charCodeAt: Int -> Int, length: Int, slice: Int -> Str}
-//│ let StringInstance: {fromCharCode: Int -> Str}
-//│ let JSON: {parse: Str -> anything, stringify: anything -> Str}
-//│ let String: nothing
-//│ String
-//│        = <missing implementation>
-//│ asNativeString
-//│                = [Function: String]
-//│ StringInstance
-//│                = [Function: String]
-//│ JSON
-//│      = <missing implementation>
-
-JSON.parse("{ \"xs\": [1, 2, 3], \"yes\": true, \"no\": false, \"insane\": null }")
-//│ anything
-//│ res
-//│     = { xs: [ 1, 2, 3 ], yes: true, no: false, insane: null }
-
-let getStringOf = toString
-fun fromCharCode(n) = StringInstance.fromCharCode(n)
-fun firstCharCode(s) = asNativeString(s).charCodeAt(0)
-fun getCharAtIndex(s, i) = asNativeString(s).charAt(i)
-fun strlen(s) = asNativeString(s).length
-fun stringHead(s) = asNativeString(s).charAt(0)
-fun stringTail(s) = asNativeString(s).slice(1)
-//│ let getStringOf: anything -> Str
-//│ fun fromCharCode: Int -> Str
-//│ fun firstCharCode: anything -> Int
-//│ fun getCharAtIndex: (anything, Int) -> Str
-//│ fun strlen: anything -> Int
-//│ fun stringHead: anything -> Str
-//│ fun stringTail: anything -> Str
-//│ getStringOf
-//│             = [Function: toString]
-
-fun isWhiteSpace(ch) =
-  if (firstCharCode of ch) ==
-    9 then true // horizontal tab
-    10 then true // linefeed
-    32 then true // space
-    _ then false
-//│ fun isWhiteSpace: anything -> Bool
-
-fun isDigit(ch) =
-  let n = firstCharCode of ch
-  if 48 <= n and n <= 57 then true else false
-//│ fun isDigit: anything -> Bool
-
-fun isAlphabet(ch) =
-  let n = firstCharCode of ch
-  if n <=
-    90  and n >= 65 then true
-    122 and n >= 97 then true
-    else false
-//│ fun isAlphabet: anything -> Bool
-
-fun concat2(a, b) = concat(a)(b)
-fun concat3(a, b, c) = concat2(a, concat2(b, c))
-fun concat4(a, b, c, d) = concat2(a, concat3(b, c, d))
-fun concat5(a, b, c, d, e) = concat2(a, concat4(b, c, d, e))
-fun concat6(a, b, c, d, e, f) = concat2(a, concat5(b, c, d, e, f))
-fun concat7(a, b, c, d, e, f, g) = concat2(a, concat6(b, c, d, e, f, g))
-fun concat8(a, b, c, d, e, f, g, h) = concat2(a, concat7(b, c, d, e, f, g, h))
-fun par(a) = concat3("(", a, ")")
-//│ fun concat2: (Str, Str) -> Str
-//│ fun concat3: (Str, Str, Str) -> Str
-//│ fun concat4: (Str, Str, Str, Str) -> Str
-//│ fun concat5: (Str, Str, Str, Str, Str) -> Str
-//│ fun concat6: (Str, Str, Str, Str, Str, Str) -> Str
-//│ fun concat7: (Str, Str, Str, Str, Str, Str, Str) -> Str
-//│ fun concat8: (Str, Str, Str, Str, Str, Str, Str, Str) -> Str
-//│ fun par: Str -> Str
-
-type Option[A] = Some[A] | None
-module None
-class Some[A](value: A)
-//│ type Option[A] = None | Some[A]
-//│ module None
-//│ class Some[A](value: A)
-
-type List[A] = Cons[A] | Nil
-module Nil
-class Cons[A](head: A, tail: List[A])
-fun listConcat(xs, ys) =
-  if xs is
-    Nil then ys
-    Cons(x, xs') then Cons(x, listConcat(xs', ys))
-fun listJoin(xs, sep) =
-  if xs is
-    Nil then ""
-    Cons(x, xs') and xs' is
-      Nil then toString(x)
-      _ then concat3(toString(x), sep, listJoin(xs', sep))
-//│ type List[A] = Cons[A] | Nil
-//│ module Nil
-//│ class Cons[A](head: A, tail: List[A])
-//│ fun listConcat: forall 'A 'A0 'a. (Cons['A] | Nil, List['A0] & 'a) -> (Cons['A0] | 'a)
-//│ fun listJoin: forall 'A1. (Cons['A1] | Nil, Str) -> Str
-//│ where
-//│   'A <: 'A0
-
-type TreeMap[out A] = Node[A] | Empty
-module Empty
-class Node[out A](key: Str, value: A, left: TreeMap[A], right: TreeMap[A])
-fun insert(t, k, v) =
-  if t is
-    Node(k', _, l, r) and
-      slt(k, k') then Node(k', v, insert(l, k, v), r)
-      sgt(k, k') then Node(k', v, l, insert(r, k, v))
-      _ then Node(k, v, l, r)
-    Empty then Node(k, v, Empty, Empty)
-fun find(t, k) =
-  if t is
-    Node(k', v, l, r) and
-      slt(k, k') then find(l, k)
-      sgt(k, k') then find(r, k)
-      _ then Some(v)
-    Empty then None
-fun traverse(t, f) =
-  if t is
-    Empty then Nil
-    Node(key, value, left, right) then
-      listConcat(traverse(left, f), Cons(f(key, value), traverse(right, f)))
-//│ type TreeMap[A] = Empty | Node[A]
-//│ module Empty
-//│ class Node[A](key: Str, value: A, left: TreeMap[A], right: TreeMap[A])
-//│ fun insert: forall 'A. (Empty | Node['A], Str, 'A) -> Node['A]
-//│ fun find: forall 'A0. (Empty | Node['A0], Str) -> (None | Some['A0])
-//│ fun traverse: forall 'a 'A1. (Empty | Node['a], (Str, 'a) -> 'A1) -> (Cons['A1] | Nil)
-
-type JsonValue = JsonNull | JsonNumber | JsonString | JsonBoolean | JsonObject | JsonArray
-module JsonNull {
-  fun toString() = "null"
-}
-class JsonBoolean(value: Bool) {
-  fun toString() = getStringOf(value)
-}
-class JsonNumber(value: Num) {
-  fun toString() = getStringOf(value)
-}
-class JsonString(value: Str) {
-  fun toString() = JSON.stringify(value)
-}
-class JsonObject(entries: TreeMap[JsonValue]) {
-  fun toString() =
-    if entries is Empty then "{}"
-      else concat3("{ ", listJoin(traverse(entries, (k, v) => concat3(k, ": ", getStringOf(v))), ", "), " }")
-}
-class JsonArray(elements: List[JsonValue]) {
-  fun toString() = concat3("[", listJoin(elements, ", "), "]")
-}
-//│ type JsonValue = JsonArray | JsonBoolean | JsonNull | JsonNumber | JsonObject | JsonString
-//│ module JsonNull {
-//│   fun toString: () -> "null"
-//│ }
-//│ class JsonBoolean(value: Bool) {
-//│   fun toString: () -> Str
-//│ }
-//│ class JsonNumber(value: Num) {
-//│   fun toString: () -> Str
-//│ }
-//│ class JsonString(value: Str) {
-//│   fun toString: () -> Str
-//│ }
-//│ class JsonObject(entries: TreeMap[JsonValue]) {
-//│   fun toString: () -> Str
-//│ }
-//│ class JsonArray(elements: List[JsonValue]) {
-//│   fun toString: () -> Str
-//│ }
-
-toString of JsonNull
-toString of JsonBoolean(true)
-toString of JsonBoolean(false)
-toString of JsonNumber(42)
-toString of JsonArray of Nil
-toString of JsonArray of Cons(JsonNumber(0), Cons(JsonNull, Cons(JsonNumber(1), Nil)))
-toString of JsonObject of Empty
-toString of JsonObject of insert(Empty, "hello", JsonString("world"))
-//│ Str
-//│ res
-//│     = 'null'
-//│ res
-//│     = 'true'
-//│ res
-//│     = 'false'
-//│ res
-//│     = '42'
-//│ res
-//│     = '[]'
-//│ res
-//│     = '[0, null, 1]'
-//│ res
-//│     = '{}'
-//│ res
-//│     = '{ hello: "world" }'
-
-class Scanner(source: Str, val at: Int) {
-  fun peek: Option[Str] =
-    if at < strlen(source) then Some(getCharAtIndex(source, at)) else None
-  fun advance: Scanner =
-    if at < strlen(source) then Scanner(source, at + 1) else this
-}
-fun scan(source) = Scanner(source, 0)
-fun skipWhiteSpace(s: Scanner) =
-  if s.peek is Some(ch) and isWhiteSpace(ch) then
-    skipWhiteSpace(s.advance)
-  else
-    s
-//│ class Scanner(source: Str, at: Int) {
-//│   fun advance: Scanner
-//│   fun peek: Option[Str]
-//│ }
-//│ fun scan: Str -> Scanner
-//│ fun skipWhiteSpace: (s: Scanner) -> Scanner
-
-type ParseResult[T] = ParseSuccess[T] | ParseFailure
-class ParseSuccess[T](value: T, scanner: Scanner) {
-  fun toString() = concat2("Success: ", getStringOf(value))
-}
-class ParseFailure(message: Str, scanner: Scanner) {
-  fun toString() = concat4("Failure at ", getStringOf(scanner.at), ": ", message)
-}
-//│ type ParseResult[T] = ParseFailure | ParseSuccess[T]
-//│ class ParseSuccess[T](value: T, scanner: Scanner) {
-//│   fun toString: () -> Str
-//│ }
-//│ class ParseFailure(message: Str, scanner: Scanner) {
-//│   fun toString: () -> Str
-//│ }
-
-fun expect(scanner, ch) =
-  if skipWhiteSpace(scanner).peek is
-    Some(ch') and
-      eq(ch)(ch') then ParseSuccess((), scanner.advance)
-      else ParseFailure(concat4("expect '", ch, "' but found ", ch'), scanner)
-    None then ParseFailure(concat3("expect '", ch, "' but found EOF"), scanner)
-//│ fun expect: forall 'T. (Scanner & {advance: Scanner}, Str) -> (ParseFailure | ParseSuccess['T])
-//│   where
-//│     'T :> ()
-
-fun expectWord(scanner, word, result) =
-  if
-    strlen(word) > 0 and
-      let head = stringHead(word)
-      let tail = stringTail(word)
-      expect(scanner, head) is
-        ParseSuccess(_, scanner) then expectWord(scanner, tail, result)
-        ParseFailure(m, s) then ParseFailure(m, s)
-    scanner.peek is
-      Some(ch) and isAlphabet(ch) then
-        ParseFailure(concat3("there should not be other alphabets after\"", word, "\""), scanner)
-      else
-        ParseSuccess(result, scanner)
-//│ fun expectWord: forall 'T. (Scanner & {peek: Object & ~#Some | Some[anything], advance: Scanner}, Str, 'T) -> (ParseFailure | ParseSuccess['T])
-
-// If we put this function together with the next block, there will be type
-// mismatch errors.
-fun parseMatched(scanner, closingSymbol, parse, fn) =
-  if parse(scanner.advance) is
-    ParseSuccess(outcome, scanner) and expect(scanner, closingSymbol) is
-      ParseSuccess(_, scanner) then ParseSuccess(fn(outcome), scanner)
-      ParseFailure(message, scanner) then ParseFailure(message, scanner)
-    ParseFailure(message, scanner) then ParseFailure(message, scanner)
-//│ fun parseMatched: forall 'advance 'a 'T. ({advance: 'advance}, Str, 'advance -> (ParseFailure | ParseSuccess['a]), 'a -> 'T) -> (ParseFailure | ParseSuccess['T])
-
-:ng
-fun parseEntries(scanner): ParseResult[TreeMap[JsonValue]] = error
-fun parseElements(scanner): ParseResult[List[JsonValue]] =
-  let scanner' = skipWhiteSpace(scanner)
-  if scanner'.peek is
-    Some(ch) and
-      eq(ch)("]") then ParseSuccess(Nil, scanner')
-      parse(scanner') is
-        ParseSuccess(head, scanner') and scanner'.peek is
-          Some(ch) and eq(ch)(",") and parseElements(scanner'.advance) is
-            ParseSuccess(tail, scanner') then ParseSuccess(Cons(head, tail), scanner')
-            ParseFailure(m, s) then ParseFailure(m, s)
-          _ then ParseFailure("expect ']' or ',' instead of EOF", scanner')
-        ParseFailure(m, s) then ParseFailure(m, s)
-    None then ParseFailure("unexpected EOF", scanner)
-fun parseStringContent(scanner): ParseResult[Str] = error
-fun parseNumber(scanner): ParseResult[JsonNumber] = error
-fun parse(scanner) =
-  let scanner' = skipWhiteSpace(scanner)
-  if scanner'.peek is
-    None then ParseFailure("expect a JSON value instead of EOF", scanner')
-    Some(ch) and
-      eq(ch)("{") then parseMatched(scanner', "}", parseEntries, JsonObject)
-      eq(ch)("[") then parseMatched(scanner', "]", parseElements, JsonArray)
-      eq(ch)("\"") then parseMatched(scanner', "\"", parseStringContent, JsonString)
-      eq(ch)("-") then parseNumber(scanner')
-      eq(ch)("t") then expectWord(scanner', "true", JsonBoolean(true))
-      eq(ch)("f") then expectWord(scanner', "false", JsonBoolean(false))
-      eq(ch)("n") then expectWord(scanner', "null", JsonNull)
-      else
-        ParseFailure(concat3("unrecognized character '", ch, "'"), scanner)
-//│ fun parseEntries: anything -> ParseResult[TreeMap[JsonValue]]
-//│ fun parseElements: Scanner -> ParseResult[List[JsonValue]]
-//│ fun parseStringContent: anything -> ParseResult[Str]
-//│ fun parseNumber: anything -> ParseResult[JsonNumber]
-//│ fun parse: forall 'T. Scanner -> (ParseFailure | ParseSuccess[in JsonValue & 'T out JsonNull | 'T | JsonBoolean | JsonString | JsonArray | JsonObject] | ParseResult[JsonNumber])
-
-:ng
-toString of parse of scan of "    true"
-toString of parse of scan of "  false"
-toString of parse of scan of "  null"
-toString of parse of scan of "[null]"
-//│ Str
diff --git a/shared/src/test/diff/ucs/LeadingAnd.mls b/shared/src/test/diff/ucs/LeadingAnd.mls
index 2303e4ebbe..ef653e5876 100644
--- a/shared/src/test/diff/ucs/LeadingAnd.mls
+++ b/shared/src/test/diff/ucs/LeadingAnd.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 
@@ -7,41 +7,21 @@ class Some[T](value: T)
 
 
 
-// TODO
 fun f(a, b) = if a is
   Some(av)
     and b is Some(bv) then av + bv
-//│ ╔══[ERROR] Illegal pattern `and`
-//│ ║  l.13: 	    and b is Some(bv) then av + bv
-//│ ╙──      	    ^^^
-//│ fun f: (anything, anything) -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
-
-:p
+//│ fun f: (Some[Int], Some[Int]) -> Int
+
 fun f(a, b) = if a is Some(av)
     and b is Some(bv)
     then av + bv
-//│ |#fun| |f|(|a|,| |b|)| |#=| |#if| |a| |is| |Some|(|av|)|→|and| |b| |is| |Some|(|bv|)|↵|#then| |av| |+| |bv|←|
-//│ AST: TypingUnit(List(NuFunDef(None,Var(f),None,List(),Left(Lam(Tup(List((None,Fld(_,Var(a))), (None,Fld(_,Var(b))))),If(IfOpApp(Var(a),Var(is),IfOpsApp(App(Var(Some),Tup(List((None,Fld(_,Var(av)))))),List((Var(and),IfThen(App(Var(is),Tup(List((None,Fld(_,Var(b))), (None,Fld(_,App(Var(Some),Tup(List((None,Fld(_,Var(bv))))))))))),App(Var(+),Tup(List((None,Fld(_,Var(av))), (None,Fld(_,Var(bv))))))))))),None))))))
-//│ Parsed: fun f = (a, b,) => if a is Some(av,) ‹· and (is(b, Some(bv,),)) then +(av, bv,)›;
 //│ fun f: (Some[Int], Some[Int]) -> Int
 
-// TODO
-:p
 fun f(a, b) = if a is
   Some(av)
     and b is Some(bv)
     then av + bv
-//│ |#fun| |f|(|a|,| |b|)| |#=| |#if| |a| |is|→|Some|(|av|)|→|and| |b| |is| |Some|(|bv|)|↵|#then| |av| |+| |bv|←|←|
-//│ AST: TypingUnit(List(NuFunDef(None,Var(f),None,List(),Left(Lam(Tup(List((None,Fld(_,Var(a))), (None,Fld(_,Var(b))))),If(IfOpApp(Var(a),Var(is),IfBlock(List(Left(IfOpsApp(App(Var(Some),Tup(List((None,Fld(_,Var(av)))))),List((Var(and),IfThen(App(Var(is),Tup(List((None,Fld(_,Var(b))), (None,Fld(_,App(Var(Some),Tup(List((None,Fld(_,Var(bv))))))))))),App(Var(+),Tup(List((None,Fld(_,Var(av))), (None,Fld(_,Var(bv)))))))))))))),None))))))
-//│ Parsed: fun f = (a, b,) => if a is ‹Some(av,) ‹· and (is(b, Some(bv,),)) then +(av, bv,)››;
-//│ ╔══[ERROR] Illegal pattern `and`
-//│ ║  l.34: 	    and b is Some(bv)
-//│ ╙──      	    ^^^
-//│ fun f: (anything, anything) -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ fun f: (Some[Int], Some[Int]) -> Int
 
 
 
diff --git a/shared/src/test/diff/ucs/LitUCS.mls b/shared/src/test/diff/ucs/LitUCS.mls
index 6c77687f0f..24e123678d 100644
--- a/shared/src/test/diff/ucs/LitUCS.mls
+++ b/shared/src/test/diff/ucs/LitUCS.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 module A
 //│ module A
diff --git a/shared/src/test/diff/ucs/MultiwayIf.mls b/shared/src/test/diff/ucs/MultiwayIf.mls
index 6add8f28e5..d0c8457dcd 100644
--- a/shared/src/test/diff/ucs/MultiwayIf.mls
+++ b/shared/src/test/diff/ucs/MultiwayIf.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 fun f(x) =
diff --git a/shared/src/test/diff/ucs/NestedBranches.mls b/shared/src/test/diff/ucs/NestedBranches.mls
index 7aa2059ba1..5add07462d 100644
--- a/shared/src/test/diff/ucs/NestedBranches.mls
+++ b/shared/src/test/diff/ucs/NestedBranches.mls
@@ -1,5 +1,4 @@
-:NewParser
-:NewDefs
+:PreTyper
 
 
 class Some[out A](val value: A)
@@ -34,22 +33,61 @@ let zeroToThree = Cons(0, Cons(1, Cons(2, Cons(3, Nil))))
 fun f(x) = if x % 2 == 0 then Left(x) else Right(x)
 //│ fun f: forall 'A. (Int & 'A) -> (Left['A] | Right['A])
 
+// FIXME: Looks like a transformation bug.
 fun mapPartition(f, xs) = if xs is
   Nil then Pair(Nil, Nil)
   Cons(x, xs) and mapPartition(f, xs) is Pair(l, r) and f(x) is
     Left(v)  then Pair(Cons(v, l), r)
     Right(v) then Pair(l, Cons(v, r))
-//│ fun mapPartition: forall 'a 'A 'A0. ('a -> (Left['A] | Right['A0]), Cons['a] | Nil) -> Pair[Cons['A] | Nil, Cons['A0] | Nil]
+//│ ╔══[ERROR] identifier `l` not found
+//│ ║  l.40: 	    Left(v)  then Pair(Cons(v, l), r)
+//│ ╙──      	                               ^
+//│ ╔══[ERROR] identifier `r` not found
+//│ ║  l.40: 	    Left(v)  then Pair(Cons(v, l), r)
+//│ ╙──      	                                   ^
+//│ ╔══[ERROR] identifier `l` not found
+//│ ║  l.41: 	    Right(v) then Pair(l, Cons(v, r))
+//│ ╙──      	                       ^
+//│ ╔══[ERROR] identifier `r` not found
+//│ ║  l.41: 	    Right(v) then Pair(l, Cons(v, r))
+//│ ╙──      	                                  ^
+//│ ╔══[ERROR] identifier not found: l
+//│ ║  l.40: 	    Left(v)  then Pair(Cons(v, l), r)
+//│ ╙──      	                               ^
+//│ ╔══[ERROR] identifier not found: r
+//│ ║  l.40: 	    Left(v)  then Pair(Cons(v, l), r)
+//│ ╙──      	                                   ^
+//│ ╔══[ERROR] identifier not found: l
+//│ ║  l.41: 	    Right(v) then Pair(l, Cons(v, r))
+//│ ╙──      	                       ^
+//│ ╔══[ERROR] identifier not found: r
+//│ ║  l.41: 	    Right(v) then Pair(l, Cons(v, r))
+//│ ╙──      	                                  ^
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.39: 	  Cons(x, xs) and mapPartition(f, xs) is Pair(l, r) and f(x) is
+//│ ║        	                                                        ^^^^^^^
+//│ ║  l.40: 	    Left(v)  then Pair(Cons(v, l), r)
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.41: 	    Right(v) then Pair(l, Cons(v, r))
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun mapPartition: forall 'a 'A 'A0. ('a -> (Left['A] | Right['A0]), Cons['a] | Nil) -> Pair[Cons['A] | Nil | error, Cons['A0] | Nil | error]
+//│ Code generation encountered an error:
+//│   unresolved symbol l
 
+:re
 mapPartition(x => Left(x + 1), zeroToThree)
-//│ Pair[Cons[Int] | Nil, Cons[nothing] | Nil]
+//│ Pair[Cons[Int] | Nil | error, Cons[nothing] | Nil | error]
 //│ res
-//│     = Pair {}
+//│ Runtime error:
+//│   ReferenceError: mapPartition is not defined
 
+:re
 mapPartition(f, zeroToThree)
-//│ Pair[Cons[0 | 1 | 2 | 3] | Nil, Cons[0 | 1 | 2 | 3] | Nil]
+//│ Pair[Cons[0 | 1 | 2 | 3] | Nil | error, Cons[0 | 1 | 2 | 3] | Nil | error]
 //│ res
-//│     = Pair {}
+//│ Runtime error:
+//│   ReferenceError: mapPartition is not defined
 
 
 fun mapPartition(f, xs) = if xs is
@@ -90,39 +128,45 @@ fun mapPartition(f, xs) = if xs is
   Cons(x, xs) and mapPartition(f, xs) is [l, r] and f(x) is
     Left(v)  then [Cons(v, l), r]
     Right(v) then [l, Cons(v, r)]
-//│ ╔══[ERROR] type identifier not found: Tuple#2
-//│ ╙──
-//│ ╔══[ERROR] Type mismatch in definition:
-//│ ║  l.88: 	fun mapPartition(f, xs) = if xs is
-//│ ║        	    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.89: 	  Nil then [Nil, Nil]
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.90: 	  Cons(x, xs) and mapPartition(f, xs) is [l, r] and f(x) is
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.91: 	    Left(v)  then [Cons(v, l), r]
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.92: 	    Right(v) then [l, Cons(v, r)]
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╟── tuple literal of type `[Nil, Nil]` is not an instance of type `Object`
-//│ ║  l.89: 	  Nil then [Nil, Nil]
-//│ ║        	           ^^^^^^^^^^
-//│ ╟── Note: constraint arises from `case` expression:
-//│ ║  l.90: 	  Cons(x, xs) and mapPartition(f, xs) is [l, r] and f(x) is
-//│ ║        	                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.91: 	    Left(v)  then [Cons(v, l), r]
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.92: 	    Right(v) then [l, Cons(v, r)]
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╟── from application:
-//│ ║  l.90: 	  Cons(x, xs) and mapPartition(f, xs) is [l, r] and f(x) is
-//│ ╙──      	                  ^^^^^^^^^^^^^^^^^^^
-//│ fun mapPartition: (anything, Cons[anything] | Nil) -> (error | [Nil, Nil])
+//│ ╔══[ERROR] identifier `l` not found
+//│ ║  l.129: 	    Left(v)  then [Cons(v, l), r]
+//│ ╙──       	                           ^
+//│ ╔══[ERROR] identifier `r` not found
+//│ ║  l.129: 	    Left(v)  then [Cons(v, l), r]
+//│ ╙──       	                               ^
+//│ ╔══[ERROR] identifier `l` not found
+//│ ║  l.130: 	    Right(v) then [l, Cons(v, r)]
+//│ ╙──       	                   ^
+//│ ╔══[ERROR] identifier `r` not found
+//│ ║  l.130: 	    Right(v) then [l, Cons(v, r)]
+//│ ╙──       	                              ^
+//│ ╔══[ERROR] identifier not found: l
+//│ ║  l.129: 	    Left(v)  then [Cons(v, l), r]
+//│ ╙──       	                           ^
+//│ ╔══[ERROR] identifier not found: r
+//│ ║  l.129: 	    Left(v)  then [Cons(v, l), r]
+//│ ╙──       	                               ^
+//│ ╔══[ERROR] identifier not found: l
+//│ ║  l.130: 	    Right(v) then [l, Cons(v, r)]
+//│ ╙──       	                   ^
+//│ ╔══[ERROR] identifier not found: r
+//│ ║  l.130: 	    Right(v) then [l, Cons(v, r)]
+//│ ╙──       	                              ^
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.128: 	  Cons(x, xs) and mapPartition(f, xs) is [l, r] and f(x) is
+//│ ║         	                                                    ^^^^^^^
+//│ ║  l.129: 	    Left(v)  then [Cons(v, l), r]
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.130: 	    Right(v) then [l, Cons(v, r)]
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun mapPartition: forall 'a 'A 'A0. ('a -> (Left['A] | Right['A0]), Cons['a] | Nil) -> [Cons['A] | Nil | error, Cons['A0] | Nil | error]
 //│ Code generation encountered an error:
-//│   unknown match case: Tuple#2
+//│   unresolved symbol l
 
 :re // TODO
 mapPartition(f, zeroToThree)
-//│ error | [Nil, Nil]
+//│ [Cons[0 | 1 | 2 | 3] | Nil | error, Cons[0 | 1 | 2 | 3] | Nil | error]
 //│ res
 //│ Runtime error:
 //│   ReferenceError: mapPartition3 is not defined
@@ -132,47 +176,26 @@ mapPartition(f, zeroToThree)
 :pe
 :w
 :e
-:ge
 fun mapPartition(f, xs) = if xs is
   Nil then [Nil, Nil]
   Cons(x, xs) and mapPartition(f, xs) is [l, r]
           and f(x) is Left(v)  then [Cons(v, l), r]
                       Right(v) then [l, Cons(v, r)]
 //│ ╔══[PARSE ERROR] Unexpected 'then' keyword here
-//│ ║  l.140: 	                      Right(v) then [l, Cons(v, r)]
+//│ ║  l.183: 	                      Right(v) then [l, Cons(v, r)]
 //│ ╙──       	                               ^^^^
 //│ ╔══[WARNING] Paren-less applications should use the 'of' keyword
-//│ ║  l.139: 	          and f(x) is Left(v)  then [Cons(v, l), r]
+//│ ║  l.182: 	          and f(x) is Left(v)  then [Cons(v, l), r]
 //│ ║         	                                    ^^^^^^^^^^^^^^^
-//│ ║  l.140: 	                      Right(v) then [l, Cons(v, r)]
+//│ ║  l.183: 	                      Right(v) then [l, Cons(v, r)]
 //│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╔══[ERROR] type identifier not found: Tuple#2
-//│ ╙──
-//│ ╔══[ERROR] Type mismatch in definition:
-//│ ║  l.136: 	fun mapPartition(f, xs) = if xs is
-//│ ║         	    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.137: 	  Nil then [Nil, Nil]
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.138: 	  Cons(x, xs) and mapPartition(f, xs) is [l, r]
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.139: 	          and f(x) is Left(v)  then [Cons(v, l), r]
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.140: 	                      Right(v) then [l, Cons(v, r)]
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╟── tuple literal of type `[Nil, Nil]` is not an instance of type `Object`
-//│ ║  l.137: 	  Nil then [Nil, Nil]
-//│ ║         	           ^^^^^^^^^^
-//│ ╟── Note: constraint arises from `case` expression:
-//│ ║  l.138: 	  Cons(x, xs) and mapPartition(f, xs) is [l, r]
-//│ ║         	                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.139: 	          and f(x) is Left(v)  then [Cons(v, l), r]
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.140: 	                      Right(v) then [l, Cons(v, r)]
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.182: 	          and f(x) is Left(v)  then [Cons(v, l), r]
+//│ ║         	                                    ^^^^^^^^^^^^^^^
+//│ ║  l.183: 	                      Right(v) then [l, Cons(v, r)]
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╟── from application:
-//│ ║  l.138: 	  Cons(x, xs) and mapPartition(f, xs) is [l, r]
-//│ ╙──       	                  ^^^^^^^^^^^^^^^^^^^
-//│ fun mapPartition: (anything, Cons[anything] | Nil) -> (error | [Nil, Nil])
-//│ Code generation encountered an error:
-//│   unknown match case: Tuple#2
+//│ ╟── tuple literal of type `[?a, ?b]` is not a function
+//│ ║  l.182: 	          and f(x) is Left(v)  then [Cons(v, l), r]
+//│ ╙──       	                                    ^^^^^^^^^^^^^^^
+//│ fun mapPartition: forall 'a. ('a -> Left[anything], Cons['a] | Nil) -> (error | [Nil, Nil])
 
diff --git a/shared/src/test/diff/ucs/NestedOpSplits.mls b/shared/src/test/diff/ucs/NestedOpSplits.mls
index e4432e6817..573b59ca24 100644
--- a/shared/src/test/diff/ucs/NestedOpSplits.mls
+++ b/shared/src/test/diff/ucs/NestedOpSplits.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 // * Note that this always to the left
@@ -8,11 +8,9 @@ fun f(x) =
     1 +
       2 then 0
       _ then 1
-//│ ╔══[ERROR] Type mismatch in operator application:
-//│ ║  l.7: 	  if x ==
-//│ ║       	     ^^^^
+//│ ╔══[ERROR] Type mismatch in application:
 //│ ║  l.8: 	    1 +
-//│ ║       	^^^^^^^
+//│ ║       	      ^
 //│ ║  l.9: 	      2 then 0
 //│ ║       	^^^^^^^
 //│ ╟── operator application of type `Bool` is not an instance of type `Int`
@@ -20,6 +18,12 @@ fun f(x) =
 //│ ║       	     ^^^^
 //│ ║  l.8: 	    1 +
 //│ ╙──     	^^^^^^
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.8: 	    1 +
+//│ ║       	      ^
+//│ ║  l.9: 	      2 then 0
+//│ ║       	^^^^^^^
+//│ ╙── application of type `Int` is not an instance of type `Bool`
 //│ fun f: Num -> (0 | 1)
 
 
diff --git a/shared/src/test/diff/ucs/NestedPattern.mls b/shared/src/test/diff/ucs/NestedPattern.mls
index c292de5570..33549162d9 100644
--- a/shared/src/test/diff/ucs/NestedPattern.mls
+++ b/shared/src/test/diff/ucs/NestedPattern.mls
@@ -1,25 +1,18 @@
-:NewParser
-:NoJS
+:PreTyper
 
-class Option
-class Some(value): Option
-class None: Option
-//│ Defined class Option
-//│ Defined class Some
-//│ Defined class None
-//│ Option: () -> Option
-//│ Some: 'value -> (Some & {value: 'value})
-//│ None: () -> None
+abstract class Option[A]: Some[A] | None
+class Some[A](value: A) extends Option[A]
+module None extends Option
+//│ abstract class Option[A]: None | Some[A]
+//│ class Some[A](value: A) extends Option
+//│ module None extends Option
 
-class Either
-class Left(leftValue): Either
-class Right(rightValue): Either
-//│ Defined class Either
-//│ Defined class Left
-//│ Defined class Right
-//│ Either: () -> Either
-//│ Left: 'leftValue -> (Left & {leftValue: 'leftValue})
-//│ Right: 'rightValue -> (Right & {rightValue: 'rightValue})
+abstract class Either[out A, out B]: Left[A] | Right[B]
+class Left[A](leftValue: A) extends Either[A, nothing]
+class Right[B](rightValue: B) extends Either[nothing, B]
+//│ abstract class Either[A, B]: Left[A] | Right[B]
+//│ class Left[A](leftValue: A) extends Either
+//│ class Right[B](rightValue: B) extends Either
 
 fun compute(v) =
   if v is
@@ -27,57 +20,74 @@ fun compute(v) =
     Left(None()) then 1
     Right(Some(x)) then x * 3
     Right(None()) then 0
-//│ compute: (Left & {leftValue: None | Some & {value: int}} | Right & {rightValue: None | Some & {value: int}}) -> int
+//│ fun compute: (Left[None | Some[Int]] | Right[None | Some[Int]]) -> Int
 
 fun crazy(v) =
   if v is
     Some(Some(Some(Some(Some(Some(None())))))) then "bruh!"
     _ then "lol"
-//│ crazy: anything -> ("bruh!" | "lol")
+//│ fun crazy: (Object & ~#Some | Some[Object & ~#Some | Some[Object & ~#Some | Some[Object & ~#Some | Some[Object & ~#Some | Some[Object & ~#Some | Some[Object]]]]]]) -> ("bruh!" | "lol")
 
 
 // * TODO(@chengluyu) fix these missing locations
 
-:e
 fun f(x) =
   if x is
     [0, 0] then "zeros"
     [1, 1] then "ones"
     _      then "bruh"
-//│ ╔══[ERROR] type identifier not found: Tuple#2
-//│ ╙──
-//│ f: error -> error
+//│ fun f: {0: Object, 1: Object} -> ("bruh" | "ones" | "zeros")
+
+f([0, 0])
+f([1, 1])
+f([1, 0])
+//│ "bruh" | "ones" | "zeros"
+//│ res
+//│     = 'zeros'
+//│ res
+//│     = 'ones'
+//│ res
+//│     = 'bruh'
 
-:e
 fun f(x) =
   if x is
     [0, 0] then "zeros"
     [1, 1] then "ones"
     [y, 1] then x
     _      then "que?"
-//│ ╔══[ERROR] type identifier not found: Tuple#2
-//│ ╙──
-//│ f: error -> error
+//│ fun f: forall 'a. ({0: Object, 1: Object} & 'a) -> ("ones" | "que?" | "zeros" | 'a)
+
+f([0, 0])
+f([1, 1])
+f([0, 1])
+f([1, 0])
+//│ "ones" | "que?" | "zeros" | [1, 0]
+//│ res
+//│     = 'zeros'
+//│ res
+//│     = 'ones'
+//│ res
+//│     = [ 0, 1 ]
+//│ res
+//│     = 'que?'
 
-:e
 fun f(p) =
   if p is
     Some([x, y]) then x + y
     None()       then 0
-//│ ╔══[ERROR] type identifier not found: Tuple#2
-//│ ╙──
-//│ f: (None | Some) -> (0 | error)
+//│ fun f: (None | Some[{0: Int, 1: Int}]) -> Int
 
-class Union(a, b)
-//│ Defined class Union
-//│ Union: ('a, 'b,) -> (Union & {a: 'a, b: 'b})
+class Union[A, B](a: A, b: B)
+//│ class Union[A, B](a: A, b: B)
 
 // Name conflict between the scrutinee and the positionals.
 // Desugar result: let tmp13 = x in case tmp13 of { Union => let x = (tmp13).a in let y = (tmp13).b in x }
 fun hmm(x) =
   if x is Union(x, y) then x
-//│ hmm: (Union & {a: 'a}) -> 'a
+//│ fun hmm: forall 'a. Union['a, anything] -> 'a
 
 hmm(Union(1, 2))
-//│ res: 1
+//│ 1
+//│ res
+//│     = 1
 
diff --git a/shared/src/test/diff/ucs/NuPlainConditionals.mls b/shared/src/test/diff/ucs/NuPlainConditionals.mls
index 328fbf5c57..053e31b8e9 100644
--- a/shared/src/test/diff/ucs/NuPlainConditionals.mls
+++ b/shared/src/test/diff/ucs/NuPlainConditionals.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 class Pair[A](fst: A, snd: A)
@@ -53,41 +53,58 @@ fun foo(x) = if x is Pair(a, b) then a > b else false
 fun foo(x) = x is
   Pair
   Int
-//│ ╔══[ERROR] illegal pattern
+//│ ╔══[ERROR] Unknown pattern {Pair; Int}
 //│ ║  l.54: 	  Pair
 //│ ║        	  ^^^^
 //│ ║  l.55: 	  Int
 //│ ╙──      	^^^^^
-//│ fun foo: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ fun foo: anything -> true
 
 // TODO proper error
 fun foo(x) = x is
   Pair(a, b) and a > b
   Int
-//│ ╔══[ERROR] illegal pattern
-//│ ║  l.67: 	  Pair(a, b) and a > b
+//│ ╔══[ERROR] Unknown pattern {and(Pair(a, b,), >(a, b,),); Int}
+//│ ║  l.65: 	  Pair(a, b) and a > b
 //│ ║        	  ^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.68: 	  Int
+//│ ║  l.66: 	  Int
 //│ ╙──      	^^^^^
-//│ fun foo: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ fun foo: anything -> true
 
 // TODO support `|`
 fun foo1(x) = x is Pair(a, b) | Int
 fun foo2(x) = x is (Pair(a, b) and a > b) | Int
-//│ ╔══[ERROR] Illegal pattern `|`
-//│ ║  l.79: 	fun foo1(x) = x is Pair(a, b) | Int
+//│ ╔══[ERROR] Unknown pattern '(' and(Pair(a, b,), >(a, b,),) ')'
+//│ ║  l.76: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
+//│ ╙──      	                   ^^^^^^^^^^^^^^^^^^^^^^
+//│ ╔══[ERROR] type identifier `|` not found
+//│ ║  l.76: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
+//│ ╙──      	                                          ^
+//│ ╔══[ERROR] type identifier `Int` not found
+//│ ║  l.76: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
+//│ ╙──      	                                            ^^^
+//│ ╔══[ERROR] identifier `|` not found
+//│ ║  l.76: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
+//│ ╙──      	                                          ^
+//│ ╔══[ERROR] type identifier `|` not found
+//│ ║  l.75: 	fun foo1(x) = x is Pair(a, b) | Int
+//│ ╙──      	                              ^
+//│ ╔══[ERROR] type identifier `Int` not found
+//│ ║  l.75: 	fun foo1(x) = x is Pair(a, b) | Int
+//│ ╙──      	                                ^^^
+//│ ╔══[ERROR] identifier `|` not found
+//│ ║  l.75: 	fun foo1(x) = x is Pair(a, b) | Int
+//│ ╙──      	                              ^
+//│ ╔══[ERROR] type identifier not found: |
+//│ ║  l.75: 	fun foo1(x) = x is Pair(a, b) | Int
 //│ ╙──      	                              ^
-//│ ╔══[ERROR] Illegal pattern `|`
-//│ ║  l.80: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
+//│ ╔══[ERROR] type identifier not found: |
+//│ ║  l.76: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	                                          ^
-//│ fun foo1: anything -> error
-//│ fun foo2: anything -> error
+//│ fun foo1: nothing -> error
+//│ fun foo2: nothing -> error
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unknown match case: Int
 
 
 
diff --git a/shared/src/test/diff/ucs/Or.mls b/shared/src/test/diff/ucs/Or.mls
index 066a382e2b..516894f7d6 100644
--- a/shared/src/test/diff/ucs/Or.mls
+++ b/shared/src/test/diff/ucs/Or.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 class Some[T](value: T)
@@ -11,11 +11,12 @@ fun f(a, b) = if a is
     and b is Some(v') then v + v'
     or  b is Some(v)  then v
   else 0
-//│ ╔══[ERROR] Illegal pattern `and`
-//│ ║  l.11: 	    and b is Some(v') then v + v'
-//│ ╙──      	    ^^^
-//│ fun f: (anything, anything) -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] cannot transform due to an illegal split operator or
+//│ ║  l.12: 	    or  b is Some(v)  then v
+//│ ║        	    ^^
+//│ ╟── the following branch will be discarded
+//│ ║  l.12: 	    or  b is Some(v)  then v
+//│ ╙──      	        ^^^^^^^^^^^^^^^^^^^^
+//│ fun f: (Object & ~#Some | Some[Int], Object & ~#Some | Some[Int]) -> Int
 
 
diff --git a/shared/src/test/diff/ucs/OverlappedBranches.mls b/shared/src/test/diff/ucs/OverlappedBranches.mls
index 1bac22866b..657ca31c59 100644
--- a/shared/src/test/diff/ucs/OverlappedBranches.mls
+++ b/shared/src/test/diff/ucs/OverlappedBranches.mls
@@ -23,6 +23,15 @@ fun f1(x) = if x is
   Base then "b"
   Derived1 then "d1"
   Derived2 then "d2"
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.22: 	fun f1(x) = if x is
+//│ ║        	               ^^^^
+//│ ║  l.23: 	  Base then "b"
+//│ ║        	^^^^^^^^^^^^^^^^
+//│ ║  l.24: 	  Derived1 then "d1"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.25: 	  Derived2 then "d2"
+//│ ╙──      	^^^^^^^^^^^^^^^^^^^^
 //│ ╔══[WARNING] Found a duplicated branch
 //│ ╟── This branch
 //│ ║  l.24: 	  Derived1 then "d1"
@@ -75,6 +84,18 @@ fun f2(x, p) = if x is
   Derived1 then "d1"
   Derived2 then "d2"
   else "otherwise"
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.82: 	fun f2(x, p) = if x is
+//│ ║        	                  ^^^^
+//│ ║  l.83: 	  Base and p(x) then "b and p"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.84: 	  Derived1 then "d1"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.85: 	  Derived2 then "d2"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.86: 	  else "otherwise"
+//│ ╙──      	^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ f2: (Base & 'a | ~Base, 'a -> anything,) -> ("b and p" | "d1" | "d2" | "otherwise")
 //│   = [Function: f2]
 
diff --git a/shared/src/test/diff/ucs/ParseFailures.mls b/shared/src/test/diff/ucs/ParseFailures.mls
index 7843c93586..889a0cca33 100644
--- a/shared/src/test/diff/ucs/ParseFailures.mls
+++ b/shared/src/test/diff/ucs/ParseFailures.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 :NoJS
 
 // FIXME
@@ -33,7 +33,13 @@ fun foo(x, y) = if x is
 //│ ╔══[PARSE ERROR] Unexpected 'else' keyword here
 //│ ║  l.32: 	  Z() and y is O() then 0 else 1
 //│ ╙──      	                          ^^^^
-//│ ╔══[ERROR] Illegal pattern `Z`
+//│ ╔══[ERROR] type identifier `Z` not found
 //│ ║  l.32: 	  Z() and y is O() then 0 else 1
 //│ ╙──      	  ^
-//│ fun foo: (anything, anything) -> error
+//│ ╔══[ERROR] type identifier `O` not found
+//│ ║  l.32: 	  Z() and y is O() then 0 else 1
+//│ ╙──      	               ^
+//│ ╔══[ERROR] type identifier not found: Z
+//│ ║  l.32: 	  Z() and y is O() then 0 else 1
+//│ ╙──      	  ^
+//│ fun foo: (nothing, anything) -> error
diff --git a/shared/src/test/diff/ucs/PlainConditionals.mls b/shared/src/test/diff/ucs/PlainConditionals.mls
index 96a98bb53e..c15867ad0c 100644
--- a/shared/src/test/diff/ucs/PlainConditionals.mls
+++ b/shared/src/test/diff/ucs/PlainConditionals.mls
@@ -1,103 +1,123 @@
-:NewParser
+:PreTyper
 
 
-class Pair(fst, snd)
-//│ Defined class Pair
-//│ Pair: ('fst, 'snd,) -> (Pair & {fst: 'fst, snd: 'snd})
-//│     = [Function: Pair1]
+class Pair[A, B](fst: A, snd: B)
+//│ class Pair[A, B](fst: A, snd: B)
 
 
 
 Pair(0, 1) is Pair
-//│ res: Bool
-//│    = true
+//│ Bool
+//│ res
+//│     = true
 
 Pair(0, 1) is Pair(a, b)
-//│ res: Bool
-//│    = true
+//│ Bool
+//│ res
+//│     = true
 
 Pair(0, 1) is Pair(0, _)
-//│ res: Bool
-//│    = true
+//│ Bool
+//│ res
+//│     = true
 
 if Pair(0, 1) is Pair(a, b) then true else false
-//│ res: Bool
-//│    = true
+//│ Bool
+//│ res
+//│     = true
 
 
 fun foo(x) = x is Pair(a, b)
-//│ foo: anything -> Bool
-//│    = [Function: foo]
+//│ fun foo: (Object & ~#Pair | Pair[anything, anything]) -> Bool
 
 
 Pair(0, 1) is Pair(a, b) and a > b
-//│ res: bool
-//│    = false
+//│ Bool
+//│ res
+//│     = false
 
 if Pair(0, 1) is Pair(a, b) then a > b else false
-//│ res: bool
-//│    = false
+//│ Bool
+//│ res
+//│     = false
 
 
 fun foo(x) = x is Pair(a, b) and a > b
-//│ foo: (Pair & {fst: number, snd: number} | ~Pair) -> bool
-//│    = [Function: foo1]
+//│ fun foo: (Object & ~#Pair | Pair[Num, Num]) -> Bool
 
 fun foo(x) = if x is Pair(a, b) then a > b else false
-//│ foo: (Pair & {fst: number, snd: number} | ~Pair) -> bool
-//│    = [Function: foo2]
+//│ fun foo: (Object & ~#Pair | Pair[Num, Num]) -> Bool
 
 
 // TODO proper error
 fun foo(x) = x is
   Pair
   Int
-//│ ╔══[ERROR] illegal pattern
-//│ ║  l.53: 	  Pair
+//│ ╔══[ERROR] Unknown pattern {Pair; Int}
+//│ ║  l.54: 	  Pair
 //│ ║        	  ^^^^
-//│ ║  l.54: 	  Int
+//│ ║  l.55: 	  Int
 //│ ╙──      	^^^^^
-//│ foo: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ fun foo: anything -> true
 
 // TODO proper error
 fun foo(x) = x is
   Pair(a, b) and a > b
   Int
-//│ ╔══[ERROR] illegal pattern
-//│ ║  l.66: 	  Pair(a, b) and a > b
+//│ ╔══[ERROR] Unknown pattern {and(Pair(a, b,), >(a, b,),); Int}
+//│ ║  l.65: 	  Pair(a, b) and a > b
 //│ ║        	  ^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.67: 	  Int
+//│ ║  l.66: 	  Int
 //│ ╙──      	^^^^^
-//│ foo: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ fun foo: anything -> true
 
 // TODO support `|`
 fun foo(x) = x is Pair(a, b) | Int
 fun foo(x) = x is (Pair(a, b) and a > b) | Int
-//│ ╔══[ERROR] Cannot find operator `|` in the context
-//│ ║  l.78: 	fun foo(x) = x is Pair(a, b) | Int
+//│ ╔══[ERROR] Unknown pattern '(' and(Pair(a, b,), >(a, b,),) ')'
+//│ ║  l.76: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
+//│ ╙──      	                  ^^^^^^^^^^^^^^^^^^^^^^
+//│ ╔══[ERROR] type identifier `|` not found
+//│ ║  l.76: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
+//│ ╙──      	                                         ^
+//│ ╔══[ERROR] type identifier `Int` not found
+//│ ║  l.76: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
+//│ ╙──      	                                           ^^^
+//│ ╔══[ERROR] identifier `|` not found
+//│ ║  l.76: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
+//│ ╙──      	                                         ^
+//│ ╔══[ERROR] type identifier `|` not found
+//│ ║  l.75: 	fun foo(x) = x is Pair(a, b) | Int
 //│ ╙──      	                             ^
-//│ foo: anything -> error
-//│ ╔══[ERROR] Cannot find operator `|` in the context
-//│ ║  l.79: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
+//│ ╔══[ERROR] type identifier `Int` not found
+//│ ║  l.75: 	fun foo(x) = x is Pair(a, b) | Int
+//│ ╙──      	                               ^^^
+//│ ╔══[ERROR] identifier `|` not found
+//│ ║  l.75: 	fun foo(x) = x is Pair(a, b) | Int
+//│ ╙──      	                             ^
+//│ ╔══[ERROR] Refininition of 'foo'
+//│ ║  l.76: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
+//│ ╙──      	    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╔══[ERROR] type identifier not found: |
+//│ ║  l.75: 	fun foo(x) = x is Pair(a, b) | Int
+//│ ╙──      	                             ^
+//│ ╔══[ERROR] type identifier not found: |
+//│ ║  l.76: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	                                         ^
-//│ foo: anything -> error
+//│ fun foo: nothing -> error
+//│ fun foo: nothing -> error
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unknown match case: Int
+
 
 
+class A[T](arg: T)
+//│ class A[T](arg: T)
 
-class A(arg)
-//│ Defined class A
-//│ A: 'arg -> (A & {arg: 'arg})
-//│  = [Function: A1]
 
-// TODO make `is` lower precedence than `=>`
 x => (x is A(_))
-//│ res: anything -> Bool
-//│    = [Function: res]
+//│ (A[anything] | Object & ~#A) -> Bool
+//│ res
+//│     = [Function: res]
 
 
diff --git a/shared/src/test/diff/ucs/SimpleUCS.mls b/shared/src/test/diff/ucs/SimpleUCS.mls
index d74a1b06eb..20bcad5495 100644
--- a/shared/src/test/diff/ucs/SimpleUCS.mls
+++ b/shared/src/test/diff/ucs/SimpleUCS.mls
@@ -1,71 +1,76 @@
-:NewParser
-
-class Option
-class Some(value): Option
-class None: Option
-//│ Defined class Option
-//│ Defined class Some
-//│ Defined class None
-//│ Option: () -> Option
-//│       = [Function: Option1]
-//│ Some: 'value -> (Some & {value: 'value})
-//│     = [Function: Some1]
-//│ None: () -> None
-//│     = [Function: None1]
-
-class Either
-class Left(leftValue): Either
-class Right(rightValue): Either
-//│ Defined class Either
-//│ Defined class Left
-//│ Defined class Right
-//│ Either: () -> Either
-//│       = [Function: Either1]
-//│ Left: 'leftValue -> (Left & {leftValue: 'leftValue})
-//│     = [Function: Left1]
-//│ Right: 'rightValue -> (Right & {rightValue: 'rightValue})
-//│      = [Function: Right1]
+:PreTyper
+
+abstract class Option[A]: Some[A] | None
+class Some[A](value: A) extends Option[A]
+module None extends Option
+//│ abstract class Option[A]: None | Some[A]
+//│ class Some[A](value: A) extends Option
+//│ module None extends Option
+
+abstract class Either[out A, out B]: Left[A] | Right[B]
+class Left[A](leftValue: A) extends Either[A, nothing]
+class Right[B](rightValue: B) extends Either[nothing, B]
+//│ abstract class Either[A, B]: Left[A] | Right[B]
+//│ class Left[A](leftValue: A) extends Either
+//│ class Right[B](rightValue: B) extends Either
 
 :e
-:ge
 fun f(x, y) =
   if x is
     Left(xv) and y is Left(yv) then xv + yv
     Right(xv) and y is Right(yv) then xv * yv
-    None() and y is None() then 0
-//│ ╔══[ERROR] The match is not exhaustive.
-//│ ║  l.33: 	    Left(xv) and y is Left(yv) then xv + yv
-//│ ║        	                 ^^^^^^^^^^^^^
-//│ ╟── The scrutinee at this position misses 2 cases.
-//│ ║  l.33: 	    Left(xv) and y is Left(yv) then xv + yv
+    None and y is None then 0
+//│ ╔══[ERROR] When scrutinee `x` is `Left`
+//│ ║  l.20: 	    Left(xv) and y is Left(yv) then xv + yv
+//│ ║        	    ^^^^
+//│ ╟── Scrutinee `y` has 2 missing cases
+//│ ║  l.20: 	    Left(xv) and y is Left(yv) then xv + yv
 //│ ║        	                 ^
-//│ ╟── [Missing Case 1/2] `None`
-//│ ╟── It first appears here.
-//│ ║  l.35: 	    None() and y is None() then 0
-//│ ║        	                    ^^^^^^
-//│ ╟── [Missing Case 2/2] `Right`
-//│ ╟── It first appears here.
-//│ ║  l.34: 	    Right(xv) and y is Right(yv) then xv * yv
-//│ ╙──      	                       ^^^^^^^^^
-//│ f: (anything, anything,) -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╟── It can be module `None`
+//│ ║  l.22: 	    None and y is None then 0
+//│ ║        	                  ^^^^
+//│ ╟── It can be class `Right`
+//│ ║  l.21: 	    Right(xv) and y is Right(yv) then xv * yv
+//│ ╙──      	                       ^^^^^
+//│ ╔══[ERROR] When scrutinee `x` is `Right`
+//│ ║  l.21: 	    Right(xv) and y is Right(yv) then xv * yv
+//│ ║        	    ^^^^^
+//│ ╟── Scrutinee `y` has 2 missing cases
+//│ ║  l.21: 	    Right(xv) and y is Right(yv) then xv * yv
+//│ ║        	                  ^
+//│ ╟── It can be class `Left`
+//│ ║  l.20: 	    Left(xv) and y is Left(yv) then xv + yv
+//│ ║        	                      ^^^^
+//│ ╟── It can be module `None`
+//│ ║  l.22: 	    None and y is None then 0
+//│ ╙──      	                  ^^^^
+//│ ╔══[ERROR] When scrutinee `x` is `None`
+//│ ║  l.22: 	    None and y is None then 0
+//│ ║        	    ^^^^
+//│ ╟── Scrutinee `y` has 2 missing cases
+//│ ║  l.22: 	    None and y is None then 0
+//│ ║        	             ^
+//│ ╟── It can be class `Left`
+//│ ║  l.20: 	    Left(xv) and y is Left(yv) then xv + yv
+//│ ║        	                      ^^^^
+//│ ╟── It can be class `Right`
+//│ ║  l.21: 	    Right(xv) and y is Right(yv) then xv * yv
+//│ ╙──      	                       ^^^^^
+//│ fun f: (Left[Int] | None | Right[Int], nothing) -> Int
 
 fun f(x, y) =
   if x is
     Left(xv) and y is Left(yv) then xv + yv
-    None() then 0
-//│ f: (Left & {leftValue: int} | None, Left & {leftValue: int},) -> int
-//│  = [Function: f1]
+    None then 0
+//│ fun f: (Left[Int] | None, Left[Int]) -> Int
 
 fun f(x, y) =
   if x is
     Left(xv) and y is
       Left(yv) then xv + yv
       Right(yv) then xv * yv
-    None() then 0
-//│ f: (Left & {leftValue: int} | None, Left & {leftValue: int} | Right & {rightValue: int},) -> int
-//│  = [Function: f2]
+    None then 0
+//│ fun f: (Left[Int] | None, Left[Int] | Right[Int]) -> Int
 
 fun f(x) =
   if x is
@@ -73,25 +78,19 @@ fun f(x) =
       v < 0 then "negative"
       v > 0 then "positive"
       _     then "zero"
-    None() then "nothing"
-//│ f: (None | Some & {value: number}) -> ("negative" | "nothing" | "positive" | "zero")
-//│  = [Function: f3]
+    None then "nothing"
+//│ fun f: (None | Some[Num]) -> ("negative" | "nothing" | "positive" | "zero")
 
 fun f(x, y) =
   if x is
     Some(x) and y is
       Some(y) then 0
-//│ f: (Some, Some,) -> 0
-//│  = [Function: f4]
-
-class A(value)
-class B(value)
-//│ Defined class A
-//│ Defined class B
-//│ A: 'value -> (A & {value: 'value})
-//│  = [Function: A1]
-//│ B: 'value -> (B & {value: 'value})
-//│  = [Function: B1]
+//│ fun f: (Some[anything], Some[anything]) -> 0
+
+class A[T](value: T)
+class B[T](value: T)
+//│ class A[T](value: T)
+//│ class B[T](value: T)
 
 fun f(x, y, u, v) =
   if x is
@@ -102,107 +101,94 @@ fun f(x, y, u, v) =
       B(0) then 0
       B(1) then 1
     A(_) then 99
-//│ f: (A, number, number, number,) -> (0 | 1 | 99)
-//│  = [Function: f5]
+//│ fun f: (A[anything], Num, Num, Num) -> (0 | 1 | 99)
 
 fun f(x) =
   if x is
     A(_) then "A"
     B(_) then "B"
-//│ f: (A | B) -> ("A" | "B")
-//│  = [Function: f6]
+//│ fun f: (A[anything] | B[anything]) -> ("A" | "B")
 
 :e
-:ge
 fun f(x, y) =
   if x is
     Some(xv) and y is Some(yv) then xv + yv
-    None() and y is None() then 0
-//│ ╔══[ERROR] The match is not exhaustive.
-//│ ║  l.119: 	    Some(xv) and y is Some(yv) then xv + yv
-//│ ║         	                 ^^^^^^^^^^^^^
-//│ ╟── The scrutinee at this position misses 1 case.
-//│ ║  l.119: 	    Some(xv) and y is Some(yv) then xv + yv
+    None and y is None then 0
+//│ ╔══[ERROR] When scrutinee `x` is `Some`
+//│ ║  l.115: 	    Some(xv) and y is Some(yv) then xv + yv
+//│ ║         	    ^^^^
+//│ ╟── Scrutinee `y` has 1 missing case
+//│ ║  l.115: 	    Some(xv) and y is Some(yv) then xv + yv
 //│ ║         	                 ^
-//│ ╟── [Missing Case 1/1] `None`
-//│ ╟── It first appears here.
-//│ ║  l.120: 	    None() and y is None() then 0
-//│ ╙──       	                    ^^^^^^
-//│ f: (anything, anything,) -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╟── It can be module `None`
+//│ ║  l.116: 	    None and y is None then 0
+//│ ╙──       	                  ^^^^
+//│ ╔══[ERROR] When scrutinee `x` is `None`
+//│ ║  l.116: 	    None and y is None then 0
+//│ ║         	    ^^^^
+//│ ╟── Scrutinee `y` has 1 missing case
+//│ ║  l.116: 	    None and y is None then 0
+//│ ║         	             ^
+//│ ╟── It can be class `Some`
+//│ ║  l.115: 	    Some(xv) and y is Some(yv) then xv + yv
+//│ ╙──       	                      ^^^^
+//│ fun f: (None | Some[Int], nothing) -> Int
 
 :e
-:ge
 fun f(x, y) =
   if x is
     Some(xv) and y is
       Some(yv) then xv + yv
-      None() then xv * 2
-    None() and y is
+      None then xv * 2
+    None and y is
       Some(yv) then yv * 3
-//│ ╔══[ERROR] The match is not exhaustive.
-//│ ║  l.142: 	    None() and y is
-//│ ║         	               ^^^^
-//│ ╟── The scrutinee at this position misses 1 case.
-//│ ║  l.142: 	    None() and y is
-//│ ║         	               ^
-//│ ╟── [Missing Case 1/1] `None`
-//│ ╟── It first appears here.
-//│ ║  l.141: 	      None() then xv * 2
-//│ ╙──       	      ^^^^^^
-//│ f: (anything, anything,) -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] When scrutinee `x` is `None`
+//│ ║  l.143: 	    None and y is
+//│ ║         	    ^^^^
+//│ ╟── Scrutinee `y` has 1 missing case
+//│ ║  l.143: 	    None and y is
+//│ ║         	             ^
+//│ ╟── It can be module `None`
+//│ ║  l.142: 	      None then xv * 2
+//│ ╙──       	      ^^^^
+//│ fun f: (None | Some[Int], Some[Int]) -> Int
 
 fun f(x, y) =
   if x is
     A and y is
       B then "bruh"
-//│ f: (A, B,) -> "bruh"
-//│  = [Function: f9]
+//│ fun f: (A[anything], B[anything]) -> "bruh"
 
 fun f(x, y, z) =
   if x is
     A and z == 0 and y == 0 and y is
       B then "bruh"
     A then "oui"
-//│ f: (A, number, number,) -> ("bruh" | "oui")
-//│  = [Function: f10]
+//│ fun f: (A[anything], Num, Num) -> ("bruh" | "oui")
 
 // We do need a syntax to specify default branch in IfOpsApp...
 :e
-:ge
 fun f(x, y) =
   if x is
     Some(x) and y
       >  0 then "gt"
       <  0 then "le"
       == 0 then "eq"
-//│ ╔══[ERROR] The case when this is false is not handled: ==(y,)(0,)
-//│ ║  l.178: 	    Some(x) and y
-//│ ║         	                ^
-//│ ║  l.179: 	      >  0 then "gt"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.180: 	      <  0 then "le"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.181: 	      == 0 then "eq"
-//│ ╙──       	^^^^^^^^^^
-//│ f: (anything, anything,) -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.176: 	      == 0 then "eq"
+//│ ║         	                ^^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun f: (Some[anything], Num) -> ("eq" | "gt" | "le")
 
 fun isValid(x) = if x then false else true
-//│ isValid: anything -> Bool
-//│        = [Function: isValid]
+//│ fun isValid: Bool -> Bool
 
 fun f(x, allowNone) =
   if x is
     Some(x) and isValid(x) then "good"
-    None() and allowNone then "okay"
+    None and allowNone then "okay"
     else "bad"
-//│ f: (anything, anything,) -> ("bad" | "good" | "okay")
-//│  = [Function: f12]
+//│ fun f: (Object & ~#Some | Some[Bool], Bool) -> ("bad" | "good" | "okay")
 
 fun f(x) =
   if x is
@@ -210,47 +196,44 @@ fun f(x) =
     Some(x) then "roll"
     _ and x == 0 then 0
     _ then "rock"
-//│ f: (None | Some | number) -> ("bruh" | "rock" | "roll" | 0)
-//│  = [Function: f13]
+//│ fun f: (None | Num | Some[anything]) -> ("bruh" | "rock" | "roll" | 0)
 
 fun f(x, a, b) =
   if x is
     A(aa) and a then aa
     B(bb) and b then bb
     _           then 0
-//│ f: (A & {value: 'value} | B & {value: 'value} | ~A & ~B, anything, anything,) -> (0 | 'value)
-//│  = [Function: f14]
+//│ fun f: forall 'a. (A['a] | B['a] | Object & ~#A & ~#B, Bool, Bool) -> (0 | 'a)
 
 fun f(x, y, b) =
   if x is
     Some(xv) and y
       is Some(yv) then "bruh"
-      is None() then "bruh"
+      is None then "bruh"
     Some(xv) and b then xv + b
     _ then "roll"
-//│ f: (Some & {value: int} | ~Some, anything, ~true,) -> ("bruh" | "roll" | int)
-//│  = [Function: f15]
+//│ fun f: (Object & ~#Some | Some[Int], Object & ~#Some | Some[anything], nothing) -> ("bruh" | "roll" | Int)
 
 fun g(x, y, b) =
   if x is
     Some(xv) and y
       is Some(yv) then yv
-      is None() then "bruh"
+      is None then "bruh"
     Some(xv) and b then xv + b
     _ then "roll"
-//│ g: (Some & {value: int} | ~Some, Some & {value: 'value} | ~Some, ~true,) -> ("bruh" | "roll" | int | 'value)
-//│  = [Function: g]
+//│ fun g: forall 'a. (Object & ~#Some | Some[Int], Object & ~#Some | Some['a], nothing) -> ("bruh" | "roll" | Int | 'a)
 
 fun foo(x, y, z) =
-  if x - y > 0 then Some(x + y + z) else None()
-//│ foo: (int, int, int,) -> (None | Some & {value: int})
-//│    = [Function: foo]
+  if x - y > 0 then Some(x + y + z) else None
+//│ fun foo: forall 'A. (Int, Int, Int) -> (None | Some['A])
+//│   where
+//│     'A :> Int
 
 // Uncomment this block to make the following block work.
 // fun foo(x, y, z) =
 //   if x - y > 0 then Some(
 //     if x % 2 == 0 then Left(x) else Right(x)
-//   ) else None()
+//   ) else None
 
 :e
 fun f(u, v, w) =
@@ -260,31 +243,30 @@ fun f(u, v, w) =
       Right(_) then "right-defined"
     None then "undefined"
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.257: 	  if foo(u, v, w) is
-//│ ║         	     ^^^^^^^^^^^^^^^
-//│ ║  l.258: 	    Some(x) and x is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.259: 	      Left(_) then "left-defined"
+//│ ║  l.241: 	    Some(x) and x is
+//│ ║         	    ^^^^^^^^^^^^^^^^
+//│ ║  l.242: 	      Left(_) then "left-defined"
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.260: 	      Right(_) then "right-defined"
+//│ ║  l.243: 	      Right(_) then "right-defined"
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.261: 	    None then "undefined"
+//│ ║  l.244: 	    None then "undefined"
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╟── operator application of type `int` does not match type `Left & ?a | Right & ?b`
-//│ ║  l.245: 	  if x - y > 0 then Some(x + y + z) else None()
+//│ ╟── operator application of type `Int` does not match type `Left[?A] | Right[?B]`
+//│ ║  l.227: 	  if x - y > 0 then Some(x + y + z) else None
 //│ ║         	                         ^^^^^^^^^
 //│ ╟── Note: constraint arises from reference:
-//│ ║  l.258: 	    Some(x) and x is
+//│ ║  l.241: 	    Some(x) and x is
 //│ ║         	                ^
-//│ ╟── from application:
-//│ ║  l.257: 	  if foo(u, v, w) is
-//│ ╙──       	     ^^^^^^^^^^^^
-//│ f: (int, int, int,) -> ("left-defined" | "right-defined" | "undefined")
-//│  = [Function: f16]
+//│ ╟── from field selection:
+//│ ║  l.4: 	class Some[A](value: A) extends Option[A]
+//│ ║       	              ^^^^^
+//│ ╟── Note: type parameter A is defined at:
+//│ ║  l.4: 	class Some[A](value: A) extends Option[A]
+//│ ╙──     	           ^
+//│ fun f: (Int, Int, Int) -> ("left-defined" | "right-defined" | "undefined")
 
 fun p(x) = if x >= 0 then Right(x) else Left(x)
-//│ p: (number & 'rightValue) -> (Left & {leftValue: 'rightValue} | Right & {rightValue: 'rightValue})
-//│  = [Function: p]
+//│ fun p: forall 'B 'A. (Num & 'B & 'A) -> (Left['A] | Right['B])
 
 fun g(a, b) =
   if p(a) is
@@ -294,42 +276,34 @@ fun g(a, b) =
     Right(x) and b is
       Some(y) then x * y
       None    then x
-//│ g: (int, None | Some & {value: int},) -> int
-//│  = [Function: g1]
+//│ fun g: (Int, None | Some[Int]) -> Int
 
-g(5, None())
+g(5, None)
 g(5, Some(7))
-g(0 - 5, None())
+g(0 - 5, None)
 g(0 - 5, Some(9))
-//│ res: int
-//│    = 5
-//│ res: int
-//│    = 35
-//│ res: int
-//│    = 25
-//│ res: int
-//│    = 4
-
-class Var(name)
+//│ Int
+//│ res
+//│     = 5
+//│ res
+//│     = 35
+//│ res
+//│     = 25
+//│ res
+//│     = 4
+
+class Var(name: Str)
 class ValBase
-class IntVal(value): ValBase
-class BoolVal(value): ValBase
-class Lit(value)
-//│ Defined class Var
-//│ Defined class ValBase
-//│ Defined class IntVal
-//│ Defined class BoolVal
-//│ Defined class Lit
-//│ Var: 'name -> (Var & {name: 'name})
-//│    = [Function: Var1]
-//│ ValBase: () -> ValBase
-//│        = [Function: ValBase1]
-//│ IntVal: 'value -> (IntVal & {value: 'value})
-//│       = [Function: IntVal1]
-//│ BoolVal: 'value -> (BoolVal & {value: 'value})
-//│        = [Function: BoolVal1]
-//│ Lit: 'value -> (Lit & {value: 'value})
-//│    = [Function: Lit1]
+class IntVal(value: Int) extends ValBase
+class BoolVal(value: Bool) extends ValBase
+class Lit[T](value: T)
+//│ class Var(name: Str)
+//│ class ValBase {
+//│   constructor()
+//│ }
+//│ class IntVal(value: Int) extends ValBase
+//│ class BoolVal(value: Bool) extends ValBase
+//│ class Lit[T](value: T)
 
 fun p(e, context) =
   if e is
@@ -338,72 +312,84 @@ fun p(e, context) =
       Some(BoolVal(v)) then Right(v)
     Lit(IntVal(v)) then Left(v)
     Lit(BoolVal(v)) then Right(v)
-//│ p: (Lit & {value: BoolVal & {value: 'value} | IntVal & {value: 'value0}} | Var & {name: 'name}, {
-//│   get: 'name -> (Some & {value: BoolVal & {value: 'value} | IntVal & {value: 'value0}})
-//│ },) -> (Left & {leftValue: 'value0} | Right & {rightValue: 'value})
-//│  = [Function: p1]
+//│ fun p: forall 'A 'B. (Lit[BoolVal | IntVal] | Var, {get: Str -> Some[BoolVal | IntVal]}) -> (Left[in 'A out Int | 'A] | Right[in 'B out Bool | 'B])
 
 class Nil()
-//│ Defined class Nil
-//│ Nil: () -> Nil
-//│    = [Function: Nil1]
+//│ class Nil()
 
 // Support operator constructor like ::
 :e
-:ge
 fun f(x) =
   if x is
     0 ::
       Nil() then "oh"
-//│ ╔══[ERROR] Cannot find operator `::` in the context
-//│ ║  l.356: 	    0 ::
+//│ ╔══[ERROR] Syntactic split of patterns are not supported
+//│ ║  l.324: 	    0 ::
 //│ ╙──       	      ^^
-//│ f: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] Found unexpected empty split
+//│ ╙──
+//│ fun f: anything -> nothing
 
 fun f(x) =
   if x == 0 and x is
     A(_) then "A"
     B(_) then "B"
   else "bruh"
-//│ f: number -> ("A" | "B" | "bruh")
-//│  = [Function: f18]
+//│ fun f: Num -> ("A" | "B" | "bruh")
 
 fun helper(x) =
-  if x == 0 then None() else Some(x)
-//│ helper: (number & 'value) -> (None | Some & {value: 'value})
-//│       = [Function: helper]
+  if x == 0 then None else Some(x)
+//│ fun helper: forall 'A. (Num & 'A) -> (None | Some['A])
 
 fun g(x, y) =
   if x == 0 and helper(x) is
     Some(a) and helper(y) is
       Some(b) then a + b
-      None() then a + 1
-    None() and helper(y) is
+      None then a + 1
+    None and helper(y) is
       Some(b) then 2 + b
-      None() then 1
+      None then 1
   else
     0
-//│ g: (int, int,) -> int
-//│  = [Function: g2]
+//│ fun g: (Int, Int) -> Int
 
 
 fun test(x) = if x then 0 else "oops"
-//│ test: anything -> ("oops" | 0)
-//│     = [Function: test]
+//│ fun test: Bool -> ("oops" | 0)
 
 test(true)
 test(false)
+//│ "oops" | 0
+//│ res
+//│     = 0
+//│ res
+//│     = 'oops'
+
+:e
 test(0)
 test(1)
-//│ res: "oops" | 0
-//│    = 0
-//│ res: "oops" | 0
-//│    = 'oops'
-//│ res: "oops" | 0
-//│    = 'oops'
-//│ res: "oops" | 0
-//│    = 'oops'
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.369: 	test(0)
+//│ ║         	^^^^^^^
+//│ ╟── integer literal of type `0` is not an instance of type `Bool`
+//│ ║  l.369: 	test(0)
+//│ ║         	     ^
+//│ ╟── Note: constraint arises from reference:
+//│ ║  l.357: 	fun test(x) = if x then 0 else "oops"
+//│ ╙──       	                 ^
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.370: 	test(1)
+//│ ║         	^^^^^^^
+//│ ╟── integer literal of type `1` is not an instance of type `Bool`
+//│ ║  l.370: 	test(1)
+//│ ║         	     ^
+//│ ╟── Note: constraint arises from reference:
+//│ ║  l.357: 	fun test(x) = if x then 0 else "oops"
+//│ ╙──       	                 ^
+//│ "oops" | 0 | error
+//│ res
+//│     = 'oops'
+//│ res
+//│     = 'oops'
 
 
diff --git a/shared/src/test/diff/ucs/SplitAfterOp.mls b/shared/src/test/diff/ucs/SplitAfterOp.mls
index 09e828989c..8ef383c138 100644
--- a/shared/src/test/diff/ucs/SplitAfterOp.mls
+++ b/shared/src/test/diff/ucs/SplitAfterOp.mls
@@ -1,168 +1,233 @@
-:NewParser
+:PreTyper
 
 :e
-:ge
 fun f(x, b) =
   if x == 
     0 and b then 0
-//│ ╔══[ERROR] The case when this is false is not handled: ==(x,)(0,)
-//│ ║  l.6: 	  if x == 
-//│ ║       	     ^^^^^
-//│ ║  l.7: 	    0 and b then 0
-//│ ╙──     	^^^^^^
-//│ f: (anything, anything,) -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.6: 	    0 and b then 0
+//│ ║       	                 ^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.6: 	    0 and b then 0
+//│ ║       	          ^^^^^^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun f: (Num, Bool) -> 0
 
 :e
-:ge
-if x == y +
-  5 then 0
-  7 then 0
-//│ ╔══[ERROR] The case when this is false is not handled: +(==(x,)(y,),)(7,)
-//│ ║  l.19: 	if x == y +
-//│ ║        	   ^^^^^^^^
-//│ ║  l.20: 	  5 then 0
-//│ ║        	^^^^^^^^^^
-//│ ║  l.21: 	  7 then 0
-//│ ╙──      	^^^^
-//│ res: error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
-
-:e
-:ge
-if x == y *
-  5 then 0
-  6 + 7 then 0
-//│ ╔══[ERROR] The case when this is false is not handled: *(==(x,)(y,),)(+(6,)(7,),)
-//│ ║  l.35: 	if x == y *
-//│ ║        	   ^^^^^^^^
-//│ ║  l.36: 	  5 then 0
-//│ ║        	^^^^^^^^^^
-//│ ║  l.37: 	  6 + 7 then 0
-//│ ╙──      	^^^^^^^
-//│ res: error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+fun f(x, y) =
+  if x == y +
+    5 then 0
+    7 then 0
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.19: 	  if x == y +
+//│ ║        	            ^
+//│ ║  l.20: 	    5 then 0
+//│ ║        	^^^^^
+//│ ╟── operator application of type `Bool` is not an instance of type `Int`
+//│ ║  l.19: 	  if x == y +
+//│ ╙──      	     ^^^^^^
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.19: 	  if x == y +
+//│ ║        	            ^
+//│ ║  l.20: 	    5 then 0
+//│ ║        	^^^^^
+//│ ╙── application of type `Int` is not an instance of type `Bool`
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.19: 	  if x == y +
+//│ ║        	            ^
+//│ ║  l.20: 	    5 then 0
+//│ ║        	^^^^^^^^^^^^^
+//│ ║  l.21: 	    7 then 0
+//│ ║        	^^^^^
+//│ ╙── application of type `Int` is not an instance of type `Bool`
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.21: 	    7 then 0
+//│ ║        	           ^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun f: (Num, Num) -> 0
 
 :e
-:ge
-if x ==
-  y +
+fun f(x, y) =
+  if x == y *
     5 then 0
-    7 then 0
-//│ ╔══[ERROR] The case when this is false is not handled: +(==(x,)(y,),)(7,)
-//│ ║  l.51: 	if x ==
-//│ ║        	   ^^^^
-//│ ║  l.52: 	  y +
+    6 + 7 then 0
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.52: 	  if x == y *
+//│ ║        	            ^
+//│ ║  l.53: 	    5 then 0
+//│ ║        	^^^^^
+//│ ╟── operator application of type `Bool` is not an instance of type `Int`
+//│ ║  l.52: 	  if x == y *
+//│ ╙──      	     ^^^^^^
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.52: 	  if x == y *
+//│ ║        	            ^
+//│ ║  l.53: 	    5 then 0
 //│ ║        	^^^^^
+//│ ╙── application of type `Int` is not an instance of type `Bool`
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.52: 	  if x == y *
+//│ ║        	            ^
 //│ ║  l.53: 	    5 then 0
-//│ ║        	^^^^^^^^^^^^
-//│ ║  l.54: 	    7 then 0
-//│ ╙──      	^^^^^
-//│ res: error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ║        	^^^^^^^^^^^^^
+//│ ║  l.54: 	    6 + 7 then 0
+//│ ║        	^^^^^^^^^
+//│ ╟── operator application of type `Bool` is not an instance of type `Int`
+//│ ║  l.52: 	  if x == y *
+//│ ╙──      	     ^^^^^^
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.52: 	  if x == y *
+//│ ║        	            ^
+//│ ║  l.53: 	    5 then 0
+//│ ║        	^^^^^^^^^^^^^
+//│ ║  l.54: 	    6 + 7 then 0
+//│ ║        	^^^^^^^^^
+//│ ╙── application of type `Int` is not an instance of type `Bool`
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.54: 	    6 + 7 then 0
+//│ ║        	               ^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun f: (Num, Num) -> 0
 
 :e
-:ge
-if x ==
-  1 and b then 0
-//│ ╔══[ERROR] The case when this is false is not handled: ==(x,)(1,)
-//│ ║  l.70: 	if x ==
-//│ ║        	   ^^^^
-//│ ║  l.71: 	  1 and b then 0
-//│ ╙──      	^^^^
-//│ res: error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+fun f(x, y) =
+  if x ==
+    y +
+      5 then 0
+      7 then 0
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.96: 	    y +
+//│ ║        	      ^
+//│ ║  l.97: 	      5 then 0
+//│ ║        	^^^^^^^
+//│ ╟── operator application of type `Bool` is not an instance of type `Int`
+//│ ║  l.95: 	  if x ==
+//│ ║        	     ^^^^
+//│ ║  l.96: 	    y +
+//│ ╙──      	^^^^^^
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.96: 	    y +
+//│ ║        	      ^
+//│ ║  l.97: 	      5 then 0
+//│ ║        	^^^^^^^
+//│ ╙── application of type `Int` is not an instance of type `Bool`
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.96: 	    y +
+//│ ║        	      ^
+//│ ║  l.97: 	      5 then 0
+//│ ║        	^^^^^^^^^^^^^^
+//│ ║  l.98: 	      7 then 0
+//│ ║        	^^^^^^^
+//│ ╙── application of type `Int` is not an instance of type `Bool`
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.98: 	      7 then 0
+//│ ║        	             ^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun f: (Num, Num) -> 0
+
+:e
+fun f(x, b) =
+  if x ==
+    1 and b then 0
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.132: 	    1 and b then 0
+//│ ║         	                 ^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.132: 	    1 and b then 0
+//│ ║         	          ^^^^^^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun f: (Num, Bool) -> 0
 
 
 :e
-:ge
 fun toEnglish(x) =
   if x ==
     true then "t"
     0 then "z"
-//│ ╔══[ERROR] The case when this is false is not handled: ==(x,)(0,)
-//│ ║  l.85: 	  if x ==
-//│ ║        	     ^^^^
-//│ ║  l.86: 	    true then "t"
-//│ ║        	^^^^^^^^^^^^^^^^^
-//│ ║  l.87: 	    0 then "z"
-//│ ╙──      	^^^^^^
-//│ toEnglish: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] Type mismatch in operator application:
+//│ ║  l.146: 	  if x ==
+//│ ║         	     ^^^^
+//│ ║  l.147: 	    true then "t"
+//│ ║         	^^^^^^^^
+//│ ╟── reference of type `true` is not an instance of `Num`
+//│ ║  l.147: 	    true then "t"
+//│ ╙──       	    ^^^^
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.148: 	    0 then "z"
+//│ ║         	           ^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun toEnglish: Num -> ("t" | "z")
 
 :e
-:ge
 fun toEnglish(x) =
   if x ==
     0 then "z"
     true then "t"
-//│ ╔══[ERROR] The case when this is false is not handled: ==(x,)(true,)
-//│ ║  l.102: 	  if x ==
+//│ ╔══[ERROR] Type mismatch in operator application:
+//│ ║  l.165: 	  if x ==
 //│ ║         	     ^^^^
-//│ ║  l.103: 	    0 then "z"
+//│ ║  l.166: 	    0 then "z"
 //│ ║         	^^^^^^^^^^^^^^
-//│ ║  l.104: 	    true then "t"
-//│ ╙──       	^^^^^^^^
-//│ toEnglish: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ║  l.167: 	    true then "t"
+//│ ║         	^^^^^^^^
+//│ ╟── reference of type `true` is not an instance of `Num`
+//│ ║  l.167: 	    true then "t"
+//│ ╙──       	    ^^^^
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.167: 	    true then "t"
+//│ ║         	              ^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun toEnglish: Num -> ("t" | "z")
 
 :e
-:ge
 fun toEnglish(x) =
   if x ==
     1 then "o"
     0 then "z"
-//│ ╔══[ERROR] The case when this is false is not handled: ==(x,)(0,)
-//│ ║  l.119: 	  if x ==
-//│ ║         	     ^^^^
-//│ ║  l.120: 	    1 then "o"
-//│ ║         	^^^^^^^^^^^^^^
-//│ ║  l.121: 	    0 then "z"
-//│ ╙──       	^^^^^^
-//│ toEnglish: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.188: 	    0 then "z"
+//│ ║         	           ^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun toEnglish: Num -> ("o" | "z")
 
 fun toEnglish(x) =
   if x ==
     0 then 1
     else 1
-//│ toEnglish: number -> 1
-//│          = [Function: toEnglish3]
+//│ fun toEnglish: Num -> 1
 
 :pe
 :e
-:ge
 fun toEnglish(x) =
   if x ==
     else 1
 //│ ╔══[PARSE ERROR] Unexpected indented block in expression position
-//│ ║  l.145: 	    else 1
+//│ ║  l.205: 	    else 1
 //│ ╙──       	^^^^
 //│ ╔══[PARSE ERROR] Unexpected end of indented block; an expression was expected here
-//│ ║  l.145: 	    else 1
+//│ ║  l.205: 	    else 1
 //│ ╙──       	    ^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'if'; found operator application instead
-//│ ║  l.144: 	  if x ==
+//│ ║  l.204: 	  if x ==
 //│ ║         	     ^^^^
-//│ ║  l.145: 	    else 1
+//│ ║  l.205: 	    else 1
 //│ ║         	^^^^
 //│ ╟── Note: 'if' expression starts here:
-//│ ║  l.144: 	  if x ==
+//│ ║  l.204: 	  if x ==
 //│ ╙──       	  ^^
-//│ ╔══[ERROR] The case when this is false is not handled: ==(x,)(undefined,)
-//│ ║  l.144: 	  if x ==
+//│ ╔══[ERROR] Type mismatch in operator application:
+//│ ║  l.204: 	  if x ==
 //│ ║         	     ^^^^
-//│ ║  l.145: 	    else 1
-//│ ╙──       	^^^^
-//│ toEnglish: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ║  l.205: 	    else 1
+//│ ║         	^^^^
+//│ ╟── undefined literal of type `()` is not an instance of type `Num`
+//│ ║  l.205: 	    else 1
+//│ ╙──       	    ^
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.205: 	    else 1
+//│ ║         	    ^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun toEnglish: Num -> ()
 
diff --git a/shared/src/test/diff/ucs/SplitAnd.mls b/shared/src/test/diff/ucs/SplitAnd.mls
index 3a3c4705d0..f615affb2d 100644
--- a/shared/src/test/diff/ucs/SplitAnd.mls
+++ b/shared/src/test/diff/ucs/SplitAnd.mls
@@ -1,24 +1,19 @@
-:NewParser
+:PreTyper
 
 fun f(x, y) =
   if x == 0 and
     y == 0 then "bruh"
     y == 1 then "lol"
   else "okay"
-//│ f: (number, number,) -> ("bruh" | "lol" | "okay")
-//│  = [Function: f]
+//│ fun f: (Num, Num) -> ("bruh" | "lol" | "okay")
 
 class A()
 class B()
-//│ Defined class A
-//│ Defined class B
-//│ A: () -> A
-//│  = [Function: A1]
-//│ B: () -> B
-//│  = [Function: B1]
+//│ class A()
+//│ class B()
 
 :e
-:ge
+// TODO: Should report missing else branches.
 fun f(x) =
   if x == 0 and
     x is
@@ -26,23 +21,31 @@ fun f(x) =
       B() then "B"
     x == 0 then "lol"
     else "bruh"
-//│ ╔══[ERROR] The case when this is false is not handled: ==(x,)(0,)
-//│ ║  l.23: 	  if x == 0 and
-//│ ╙──      	     ^^^^^^
-//│ f: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.19: 	    x is
+//│ ║        	    ^^^^
+//│ ║  l.20: 	      A() then "A"
+//│ ║        	^^^^^^^^^^^^^^^^^^
+//│ ║  l.21: 	      B() then "B"
+//│ ║        	^^^^^^^^^^^^^^^^^^
+//│ ║  l.22: 	    x == 0 then "lol"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.23: 	    else "bruh"
+//│ ║        	^^^^^^^^^^^^^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun f: Num -> ("A" | "B" | "bruh" | "lol")
 
 :e
-:ge
+// TODO: Should report missing else branches.
 fun f(x, y) =
   if
     x == 0 and
       y == 0 then "bruh"
       else "lol"
-//│ ╔══[ERROR] The case when this is false is not handled: ==(x,)(0,)
-//│ ║  l.40: 	    x == 0 and
-//│ ╙──      	    ^^^^^^
-//│ f: (anything, anything,) -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.43: 	      y == 0 then "bruh"
+//│ ║        	      ^^^^^^^^^^^^^^^^^^
+//│ ║  l.44: 	      else "lol"
+//│ ║        	^^^^^^^^^^^^^^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun f: (Num, Num) -> ("bruh" | "lol")
diff --git a/shared/src/test/diff/ucs/SplitAroundOp.mls b/shared/src/test/diff/ucs/SplitAroundOp.mls
index 1cbf9e1dad..ddfeb3af0b 100644
--- a/shared/src/test/diff/ucs/SplitAroundOp.mls
+++ b/shared/src/test/diff/ucs/SplitAroundOp.mls
@@ -1,5 +1,4 @@
-:NewParser
-:NewDefs
+:PreTyper
 
 fun f(x, b) =
   if x
@@ -12,7 +11,7 @@ fun f(x, b) =
       "1" then "s1"
       "2" then "s2"
   else ":p"  
-//│ fun f: (Eql["0" | "1" | "2" | 0 | 1 | 2], Object & ~true | true) -> (":p" | "n0" | "n1" | "n2" | "s0" | "s1" | "s2")
+//│ fun f: (Eql["0" | "1" | "2" | 0 | 1 | 2], Bool) -> (":p" | "n0" | "n1" | "n2" | "s0" | "s1" | "s2")
 
 fun f(x, y, a, b) =
   if x === 0
@@ -41,9 +40,35 @@ if x is
     === 0 then 0
     > 0 then 1
     < 0 then 2
-//│ ╔══[ERROR] Illegal pattern `===`
-//│ ║  l.41: 	    === 0 then 0
-//│ ╙──      	    ^^^
-//│ error
+//│ ╔══[ERROR] cannot transform due to an illegal split operator ===
+//│ ║  l.40: 	    === 0 then 0
+//│ ║        	    ^^^
+//│ ╟── the following branch will be discarded
+//│ ║  l.40: 	    === 0 then 0
+//│ ╙──      	        ^^^^^^^^
+//│ ╔══[ERROR] cannot transform due to an illegal split operator >
+//│ ║  l.41: 	    > 0 then 1
+//│ ║        	    ^
+//│ ╟── the following branch will be discarded
+//│ ║  l.41: 	    > 0 then 1
+//│ ╙──      	      ^^^^^^^^
+//│ ╔══[ERROR] cannot transform due to an illegal split operator <
+//│ ║  l.42: 	    < 0 then 2
+//│ ║        	    ^
+//│ ╟── the following branch will be discarded
+//│ ║  l.42: 	    < 0 then 2
+//│ ╙──      	      ^^^^^^^^
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.38: 	if x is
+//│ ╙──      	   ^
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.38: 	if x is
+//│ ╙──      	   ^
+//│ ╔══[ERROR] Found unexpected empty split
+//│ ╙──
+//│ ╔══[ERROR] identifier not found: x
+//│ ║  l.38: 	if x is
+//│ ╙──      	   ^
+//│ nothing
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unresolved symbol x
diff --git a/shared/src/test/diff/ucs/SplitBeforeOp.mls b/shared/src/test/diff/ucs/SplitBeforeOp.mls
index 6f07068743..0c6cc6dafe 100644
--- a/shared/src/test/diff/ucs/SplitBeforeOp.mls
+++ b/shared/src/test/diff/ucs/SplitBeforeOp.mls
@@ -1,29 +1,49 @@
-:NewDefs
+:PreTyper
 
 :e
 :ge
 if x
   == 0 then 0
-//│ ╔══[ERROR] The case when this is false is not handled: ==(x, 0,)
+//│ ╔══[ERROR] identifier `x` not found
 //│ ║  l.5: 	if x
-//│ ║       	   ^
+//│ ╙──     	   ^
+//│ ╔══[ERROR] identifier not found: x
+//│ ║  l.5: 	if x
+//│ ╙──     	   ^
+//│ ╔══[ERROR] Type mismatch in `case` expression:
 //│ ║  l.6: 	  == 0 then 0
-//│ ╙──     	^^^^^^
-//│ error
+//│ ║       	            ^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ 0
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unresolved symbol x
 
 :e
 :ge
 if x
   is A and
     y then 0
-//│ ╔══[ERROR] Cannot find constructor `A` in scope
-//│ ║  l.19: 	  is A and
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.23: 	if x
+//│ ╙──      	   ^
+//│ ╔══[ERROR] type identifier `A` not found
+//│ ║  l.24: 	  is A and
+//│ ╙──      	     ^
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.23: 	if x
+//│ ╙──      	   ^
+//│ ╔══[ERROR] identifier `y` not found
+//│ ║  l.25: 	    y then 0
+//│ ╙──      	    ^
+//│ ╔══[ERROR] identifier not found: x
+//│ ║  l.23: 	if x
+//│ ╙──      	   ^
+//│ ╔══[ERROR] type identifier not found: A
+//│ ║  l.24: 	  is A and
 //│ ╙──      	     ^
 //│ error
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unresolved symbol x
 
 :e
 :ge
@@ -31,12 +51,27 @@ if x
   is A and
     y then 0
 else 1
-//│ ╔══[ERROR] Cannot find constructor `A` in scope
-//│ ║  l.31: 	  is A and
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.50: 	if x
+//│ ╙──      	   ^
+//│ ╔══[ERROR] type identifier `A` not found
+//│ ║  l.51: 	  is A and
+//│ ╙──      	     ^
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.50: 	if x
+//│ ╙──      	   ^
+//│ ╔══[ERROR] identifier `y` not found
+//│ ║  l.52: 	    y then 0
+//│ ╙──      	    ^
+//│ ╔══[ERROR] identifier not found: x
+//│ ║  l.50: 	if x
+//│ ╙──      	   ^
+//│ ╔══[ERROR] type identifier not found: A
+//│ ║  l.51: 	  is A and
 //│ ╙──      	     ^
 //│ error
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unresolved symbol x
 
 :e
 :ge
@@ -45,9 +80,33 @@ if x
   is
     A() then "A"
     B() then "B"
-//│ ╔══[ERROR] Illegal pattern `A`
-//│ ║  l.46: 	    A() then "A"
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.78: 	if x
+//│ ╙──      	   ^
+//│ ╔══[ERROR] type identifier `A` not found
+//│ ║  l.81: 	    A() then "A"
 //│ ╙──      	    ^
-//│ error
+//│ ╔══[ERROR] type identifier `B` not found
+//│ ║  l.82: 	    B() then "B"
+//│ ╙──      	    ^
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.78: 	if x
+//│ ╙──      	   ^
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.78: 	if x
+//│ ╙──      	   ^
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.78: 	if x
+//│ ╙──      	   ^
+//│ ╔══[ERROR] identifier not found: x
+//│ ║  l.78: 	if x
+//│ ╙──      	   ^
+//│ ╔══[ERROR] identifier not found: x
+//│ ║  l.78: 	if x
+//│ ╙──      	   ^
+//│ ╔══[ERROR] type identifier not found: A
+//│ ║  l.81: 	    A() then "A"
+//│ ╙──      	    ^
+//│ 0 | error
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unresolved symbol x
diff --git a/shared/src/test/diff/ucs/SplitOps.mls b/shared/src/test/diff/ucs/SplitOps.mls
index c966e4b0a1..c346c5090b 100644
--- a/shared/src/test/diff/ucs/SplitOps.mls
+++ b/shared/src/test/diff/ucs/SplitOps.mls
@@ -1,30 +1,18 @@
-:NewParser
+:PreTyper
 
-class Option
-class Some(value): Option
-class None: Option
-//│ Defined class Option
-//│ Defined class Some
-//│ Defined class None
-//│ Option: () -> Option
-//│       = [Function: Option1]
-//│ Some: 'value -> (Some & {value: 'value})
-//│     = [Function: Some1]
-//│ None: () -> None
-//│     = [Function: None1]
+abstract class Option[A]: Some[A] | None
+class Some[A](value: A) extends Option[A]
+module None extends Option
+//│ abstract class Option[A]: None | Some[A]
+//│ class Some[A](value: A) extends Option
+//│ module None extends Option
 
-class Either
-class Left(leftValue): Either
-class Right(rightValue): Either
-//│ Defined class Either
-//│ Defined class Left
-//│ Defined class Right
-//│ Either: () -> Either
-//│       = [Function: Either1]
-//│ Left: 'leftValue -> (Left & {leftValue: 'leftValue})
-//│     = [Function: Left1]
-//│ Right: 'rightValue -> (Right & {rightValue: 'rightValue})
-//│      = [Function: Right1]
+abstract class Either[out A, out B]: Left[A] | Right[B]
+class Left[A](leftValue: A) extends Either[A, nothing]
+class Right[B](rightValue: B) extends Either[nothing, B]
+//│ abstract class Either[A, B]: Left[A] | Right[B]
+//│ class Left[A](leftValue: A) extends Either
+//│ class Right[B](rightValue: B) extends Either
 
 :e
 :ge
@@ -33,18 +21,25 @@ fun f(x) =
     is Left(v) then 0
     is Right(v) then 1
     <> undefined then 2
-//│ ╔══[ERROR] The case when this is false is not handled: <>(x,)(undefined,)
-//│ ║  l.32: 	  if x
+//│ ╔══[ERROR] Type mismatch in operator application:
+//│ ║  l.20: 	  if x
 //│ ║        	     ^
-//│ ║  l.33: 	    is Left(v) then 0
+//│ ║  l.21: 	    is Left(v) then 0
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.34: 	    is Right(v) then 1
+//│ ║  l.22: 	    is Right(v) then 1
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.35: 	    <> undefined then 2
-//│ ╙──      	^^^^^^^^^^^^^^^^
-//│ f: anything -> error
+//│ ║  l.23: 	    <> undefined then 2
+//│ ║        	^^^^^^^^^^^^^^^^
+//│ ╟── undefined literal of type `()` is not an instance of type `Num`
+//│ ║  l.23: 	    <> undefined then 2
+//│ ╙──      	       ^^^^^^^^^
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.23: 	    <> undefined then 2
+//│ ║        	                      ^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun f: (Left[anything] | Num | Right[anything]) -> (0 | 1 | 2)
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unresolved symbol <>
 
 :e
 :ge
@@ -52,66 +47,59 @@ fun f(x) =
   if x
     is Some(xv) and y is Some(yv) then xv + yv
     is None() and y is None() then 0
-//│ ╔══[ERROR] The match is not exhaustive.
-//│ ║  l.53: 	    is Some(xv) and y is Some(yv) then xv + yv
-//│ ║        	                    ^^^^^^^^^^^^^
-//│ ╟── The scrutinee at this position misses 1 case.
-//│ ║  l.53: 	    is Some(xv) and y is Some(yv) then xv + yv
-//│ ║        	                    ^
-//│ ╟── [Missing Case 1/1] `None`
-//│ ╟── It first appears here.
-//│ ║  l.54: 	    is None() and y is None() then 0
-//│ ╙──      	                       ^^^^^^
-//│ f: anything -> error
+//│ ╔══[ERROR] identifier `y` not found
+//│ ║  l.48: 	    is Some(xv) and y is Some(yv) then xv + yv
+//│ ╙──      	                    ^
+//│ ╔══[ERROR] identifier `y` not found
+//│ ║  l.49: 	    is None() and y is None() then 0
+//│ ╙──      	                  ^
+//│ ╔══[ERROR] identifier `y` not found
+//│ ║  l.48: 	    is Some(xv) and y is Some(yv) then xv + yv
+//│ ╙──      	                    ^
+//│ ╔══[ERROR] identifier `y` not found
+//│ ║  l.48: 	    is Some(xv) and y is Some(yv) then xv + yv
+//│ ╙──      	                    ^
+//│ ╔══[ERROR] identifier `y` not found
+//│ ║  l.49: 	    is None() and y is None() then 0
+//│ ╙──      	                  ^
+//│ ╔══[ERROR] identifier not found: y
+//│ ║  l.48: 	    is Some(xv) and y is Some(yv) then xv + yv
+//│ ╙──      	                    ^
+//│ ╔══[ERROR] identifier not found: y
+//│ ║  l.49: 	    is None() and y is None() then 0
+//│ ╙──      	                  ^
+//│ fun f: (None | Some[Int]) -> Int
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unresolved symbol y
 
 class A()
 class B()
-//│ Defined class A
-//│ Defined class B
-//│ A: () -> A
-//│  = [Function: A1]
-//│ B: () -> B
-//│  = [Function: B1]
+//│ class A()
+//│ class B()
 
 fun f(a, b) =
   if a
     is A() and b is B() then 0
-//│ f: (A, B,) -> 0
-//│  = [Function: f2]
+//│ fun f: (A, B) -> 0
 
 class C()
-//│ Defined class C
-//│ C: () -> C
-//│  = [Function: C1]
+//│ class C()
 
-:p
 :e
-:ge
 fun f(a, b, c) =
   if a
     == 0 and b is B() and c is C() then 0
-//│ |#fun| |f|(|a|,| |b|,| |c|)| |#=|→|#if| |a|→|==| |0| |and| |b| |is| |B|(||)| |and| |c| |is| |C|(||)| |#then| |0|←|←|
-//│ AST: TypingUnit(List(NuFunDef(None,Var(f),None,List(),Left(Lam(Tup(List((None,Fld(_,Var(a))), (None,Fld(_,Var(b))), (None,Fld(_,Var(c))))),Blk(List(If(IfOpsApp(Var(a),List((Var(==),IfThen(App(App(Var(and),Tup(List((None,Fld(_,App(App(Var(and),Tup(List((None,Fld(_,IntLit(0)))))),Tup(List((None,Fld(_,App(App(Var(is),Tup(List((None,Fld(_,Var(b)))))),Tup(List((None,Fld(_,App(Var(B),Tup(List()))))))))))))))))),Tup(List((None,Fld(_,App(App(Var(is),Tup(List((None,Fld(_,Var(c)))))),Tup(List((None,Fld(_,App(Var(C),Tup(List())))))))))))),IntLit(0))))),None))))))))
-//│ Parsed: fun f = (a, b, c,) => {if a ‹· == (and(and(0,)(is(b,)(B(),),),)(is(c,)(C(),),)) then 0›};
-//│ Desugared: rec def f: (a, b, c,) => {if a ‹· == (and(and(0,)(is(b,)(B(),),),)(is(c,)(C(),),)) then 0›}
-//│ AST: Def(true,Var(f),Left(Lam(Tup(List((None,Fld(_,Var(a))), (None,Fld(_,Var(b))), (None,Fld(_,Var(c))))),Blk(List(If(IfOpsApp(Var(a),List((Var(==),IfThen(App(App(Var(and),Tup(List((None,Fld(_,App(App(Var(and),Tup(List((None,Fld(_,IntLit(0)))))),Tup(List((None,Fld(_,App(App(Var(is),Tup(List((None,Fld(_,Var(b)))))),Tup(List((None,Fld(_,App(Var(B),Tup(List()))))))))))))))))),Tup(List((None,Fld(_,App(App(Var(is),Tup(List((None,Fld(_,Var(c)))))),Tup(List((None,Fld(_,App(Var(C),Tup(List())))))))))))),IntLit(0))))),None))))),true)
-//│ ╔══[ERROR] The case when this is false is not handled: ==(a,)(0,)
-//│ ║  l.93: 	  if a
-//│ ║        	     ^
-//│ ║  l.94: 	    == 0 and b is B() and c is C() then 0
-//│ ╙──      	^^^^^^^^
-//│ f: (anything, anything, anything,) -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.91: 	    == 0 and b is B() and c is C() then 0
+//│ ║        	             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun f: (Num, B, C) -> 0
 
 fun f(x) =
   if x
     is A() then "A"
     is B() then "B"
-//│ f: (A | B) -> ("A" | "B")
-//│  = [Function: f4]
+//│ fun f: (A | B) -> ("A" | "B")
 
 fun sumOpt(x, y) =
   if x
@@ -121,12 +109,10 @@ fun sumOpt(x, y) =
     is None() and y is
       Some(yv) then yv
       None() then 0
-//│ sumOpt: (None | Some & {value: int}, None | Some & {value: int},) -> int
-//│       = [Function: sumOpt]
+//│ fun sumOpt: forall 'a. (None | Some[Int], None | Some[Int & 'a]) -> (Int | 'a)
 
 fun f(x, y, z) =
   if x is A() and y
     == z then 1
     is B() then 0
-//│ f: (A, nothing, number,) -> (0 | 1)
-//│  = [Function: f5]
+//│ fun f: (A, nothing, Num) -> (0 | 1)
diff --git a/shared/src/test/diff/ucs/SplitScrutinee.mls b/shared/src/test/diff/ucs/SplitScrutinee.mls
index 77d06ac99f..0ecc291fe4 100644
--- a/shared/src/test/diff/ucs/SplitScrutinee.mls
+++ b/shared/src/test/diff/ucs/SplitScrutinee.mls
@@ -1,5 +1,4 @@
-:NewParser
-:NoJS
+:PreTyper
 
 fun f(x) =
   if x +
@@ -7,4 +6,9 @@ fun f(x) =
       2 then 1
       3 then 2
       _ then "I don't know."
-//│ f: int -> ("I don't know." | 1 | 2)
+//│ fun f: Int -> ("I don't know." | 1 | 2)
+
+[f(0), f(1), f(2), f(3)]
+//│ ["I don't know." | 1 | 2, "I don't know." | 1 | 2, "I don't know." | 1 | 2, "I don't know." | 1 | 2]
+//│ res
+//│     = [ "I don't know.", 1, 2, "I don't know." ]
diff --git a/shared/src/test/diff/ucs/ThenIndent.mls b/shared/src/test/diff/ucs/ThenIndent.mls
index 1ca90defc9..df126db873 100644
--- a/shared/src/test/diff/ucs/ThenIndent.mls
+++ b/shared/src/test/diff/ucs/ThenIndent.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 // FIXME
@@ -19,13 +19,12 @@ x => if x ==
 //│ ╟── Note: 'if' expression starts here:
 //│ ║  l.5: 	x => if x ==
 //│ ╙──     	     ^^
-//│ ╔══[ERROR] The case when this is false is not handled: ==(x, {0},)
-//│ ║  l.5: 	x => if x ==
-//│ ║       	        ^^^^
+//│ ╔══[ERROR] Type mismatch in `case` expression:
 //│ ║  l.6: 	  0
-//│ ╙──     	^^^
-//│ anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ║       	  ^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ Num -> ()
+//│ res
+//│     = [Function: res]
 
 
diff --git a/shared/src/test/diff/ucs/Tree.mls b/shared/src/test/diff/ucs/Tree.mls
index 2802614176..a36c74903f 100644
--- a/shared/src/test/diff/ucs/Tree.mls
+++ b/shared/src/test/diff/ucs/Tree.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 type Option[out A] = Some[A] | None
 class Some[out A](value: A)
diff --git a/shared/src/test/diff/ucs/TrivialIf.mls b/shared/src/test/diff/ucs/TrivialIf.mls
index 0fa422ee8e..d8cc5fcc58 100644
--- a/shared/src/test/diff/ucs/TrivialIf.mls
+++ b/shared/src/test/diff/ucs/TrivialIf.mls
@@ -2,6 +2,10 @@
 :NoJS
 
 fun abs(x) = if x < 0 then 0 - x else x
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.4: 	fun abs(x) = if x < 0 then 0 - x else x
+//│ ╙──     	                ^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ abs: int -> int
 
 class Option
@@ -18,6 +22,14 @@ fun getOrElse(opt, default) =
   if opt is
     Some(value) then value
     None then default
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.22: 	  if opt is
+//│ ║        	     ^^^^^^
+//│ ║  l.23: 	    Some(value) then value
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.24: 	    None then default
+//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ getOrElse: (None | Some & {value: 'value}, 'value,) -> 'value
 
 getOrElse(None(), 0)
@@ -30,6 +42,14 @@ fun map(v, f) =
   if v is
     Some(x) then Some(f(x))
     None then None()
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.42: 	  if v is
+//│ ║        	     ^^^^
+//│ ║  l.43: 	    Some(x) then Some(f(x))
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.44: 	    None then None()
+//│ ╙──      	^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ map: (None | Some & {value: 'value}, 'value -> 'value0,) -> (None | Some & {value: 'value0})
 
 fun inc(x) = x + 5
@@ -43,8 +63,12 @@ map(None(), inc)
 
 :e
 fun f(a, b) = if a and b then 0
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.65: 	fun f(a, b) = if a and b then 0
+//│ ╙──      	                 ^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ ╔══[ERROR] The case when this is false is not handled: a
-//│ ║  l.45: 	fun f(a, b) = if a and b then 0
+//│ ║  l.65: 	fun f(a, b) = if a and b then 0
 //│ ╙──      	                 ^
 //│ f: (anything, anything,) -> error
 
@@ -52,8 +76,14 @@ fun f(a, b) = if a and b then 0
 fun f(x, y) =
   if x == y + 5 then 0
   else if x == y + 7 then 0
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.77: 	  if x == y + 5 then 0
+//│ ║        	     ^^^^^^^^^^^^^^^^^
+//│ ║  l.78: 	  else if x == y + 7 then 0
+//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ ╔══[ERROR] The case when this is false is not handled: ==(x,)(+(y,)(7,),)
-//│ ║  l.54: 	  else if x == y + 7 then 0
+//│ ║  l.78: 	  else if x == y + 7 then 0
 //│ ╙──      	          ^^^^^^^^^^
 //│ f: (anything, anything,) -> error
 
@@ -62,12 +92,17 @@ fun foo(x) = if x is Some
   (0) then 0
   (1) then 1
 //│ ╔══[PARSE ERROR] Unexpected parenthesis section here
-//│ ║  l.63: 	  (1) then 1
+//│ ║  l.93: 	  (1) then 1
 //│ ╙──      	  ^^^
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.91: 	fun foo(x) = if x is Some
+//│ ║        	                ^^^^^^^^^
+//│ ║  l.92: 	  (0) then 0
+//│ ╙──      	^^^^^^^^^^^^
 //│ ╔══[ERROR] The case when this is false is not handled: is(x,)(Some,)(0,)
-//│ ║  l.61: 	fun foo(x) = if x is Some
+//│ ║  l.91: 	fun foo(x) = if x is Some
 //│ ║        	                ^^^^^^^^^
-//│ ║  l.62: 	  (0) then 0
+//│ ║  l.92: 	  (0) then 0
 //│ ╙──      	^^^^^
 //│ foo: anything -> error
 
@@ -76,15 +111,20 @@ fun foo(x) = if x is Some of
   0 then 0
   1 then 1
 //│ ╔══[PARSE ERROR] Unexpected 'then' keyword here
-//│ ║  l.76: 	  0 then 0
-//│ ╙──      	    ^^^^
+//│ ║  l.111: 	  0 then 0
+//│ ╙──       	    ^^^^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'if'; found operator application instead
-//│ ║  l.75: 	fun foo(x) = if x is Some of
-//│ ║        	                ^^^^^^^^^^^^
-//│ ║  l.76: 	  0 then 0
-//│ ║        	^^^
+//│ ║  l.110: 	fun foo(x) = if x is Some of
+//│ ║         	                ^^^^^^^^^^^^
+//│ ║  l.111: 	  0 then 0
+//│ ║         	^^^
 //│ ╟── Note: 'if' expression starts here:
-//│ ║  l.75: 	fun foo(x) = if x is Some of
-//│ ╙──      	             ^^
+//│ ║  l.110: 	fun foo(x) = if x is Some of
+//│ ╙──       	             ^^
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.110: 	fun foo(x) = if x is Some of
+//│ ║         	                ^^^^^^^^^^^^
+//│ ║  l.111: 	  0 then 0
+//│ ╙──       	^^^
 //│ foo: (Some & {value: 0}) -> undefined
 
diff --git a/shared/src/test/diff/ucs/WeirdIf.mls b/shared/src/test/diff/ucs/WeirdIf.mls
index db0705fd0a..c420f55445 100644
--- a/shared/src/test/diff/ucs/WeirdIf.mls
+++ b/shared/src/test/diff/ucs/WeirdIf.mls
@@ -1,96 +1,66 @@
-:NewDefs
+:PreTyper
 
-// Should report duplicated else branches.
-:w
+// FIXME: Should report duplicated else branches.
+// :w
 if
   _ then 0
   else 0
 else 1
-//│ ╔══[WARNING] Found a duplicated branch
-//│ ╟── This branch
-//│ ║  l.7: 	  else 0
-//│ ║       	       ^
-//│ ╟── is subsumed by the branch here.
-//│ ║  l.6: 	  _ then 0
-//│ ╙──     	         ^
-//│ ╔══[WARNING] Found a duplicated branch
-//│ ╟── This branch
-//│ ║  l.8: 	else 1
-//│ ║       	     ^
-//│ ╟── is subsumed by the branch here.
-//│ ║  l.6: 	  _ then 0
-//│ ╙──     	         ^
 //│ 0
 //│ res
 //│     = 0
 
-:w
+// FIXME
+// :w
 if else 0 else 1
-//│ ╔══[WARNING] Found a duplicated branch
-//│ ╟── This branch
-//│ ║  l.28: 	if else 0 else 1
-//│ ║        	               ^
-//│ ╟── is subsumed by the branch here.
-//│ ║  l.28: 	if else 0 else 1
-//│ ╙──      	        ^
 //│ 0
 //│ res
 //│     = 0
 
-:w
+// FIXME
+// :w
 fun f(x) = if x is else 0 else 1
-//│ ╔══[WARNING] Found a duplicated branch
-//│ ╟── This branch
-//│ ║  l.41: 	fun f(x) = if x is else 0 else 1
-//│ ║        	                               ^
-//│ ╟── is subsumed by the branch here.
-//│ ║  l.41: 	fun f(x) = if x is else 0 else 1
-//│ ╙──      	                        ^
 //│ fun f: anything -> 0
 
 fun f(x) = if x is else 0 
 //│ fun f: anything -> 0
 
 :e
-:ge
 if true
   then 0
-//│ ╔══[ERROR] The case when this is false is not handled: true
-//│ ║  l.56: 	if true
-//│ ╙──      	   ^^^^
-//│ error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.30: 	  then 0
+//│ ║        	       ^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ 0
+//│ res
+//│     = 0
 
 // This cannot be parsed. But the next one works.
 :pe
 :e
-:ge
 fun f(x) =
   if x ===
     else "bruh"
 //│ ╔══[PARSE ERROR] Unexpected indented block in expression position
-//│ ║  l.71: 	    else "bruh"
+//│ ║  l.44: 	    else "bruh"
 //│ ╙──      	^^^^
 //│ ╔══[PARSE ERROR] Unexpected end of indented block; an expression was expected here
-//│ ║  l.71: 	    else "bruh"
+//│ ║  l.44: 	    else "bruh"
 //│ ╙──      	    ^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'if'; found operator application instead
-//│ ║  l.70: 	  if x ===
+//│ ║  l.43: 	  if x ===
 //│ ║        	     ^^^^^
-//│ ║  l.71: 	    else "bruh"
+//│ ║  l.44: 	    else "bruh"
 //│ ║        	^^^^
 //│ ╟── Note: 'if' expression starts here:
-//│ ║  l.70: 	  if x ===
+//│ ║  l.43: 	  if x ===
 //│ ╙──      	  ^^
-//│ ╔══[ERROR] The case when this is false is not handled: ===(x, undefined,)
-//│ ║  l.70: 	  if x ===
-//│ ║        	     ^^^^^
-//│ ║  l.71: 	    else "bruh"
-//│ ╙──      	^^^^
-//│ fun f: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.44: 	    else "bruh"
+//│ ║        	    ^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun f: Eql[()] -> ()
 
 // But this works.
 fun f(x) =
@@ -102,6 +72,8 @@ fun boolToStr(x) =
   if x is
     true then "yah"
     false then "nah"
+//│ ╙──
+//│ ╙──
 //│ fun boolToStr: Bool -> ("nah" | "yah")
 
 boolToStr of true
diff --git a/shared/src/test/diff/ucs/WeirdSplit.mls b/shared/src/test/diff/ucs/WeirdSplit.mls
index a41d99f67d..e74445a1a7 100644
--- a/shared/src/test/diff/ucs/WeirdSplit.mls
+++ b/shared/src/test/diff/ucs/WeirdSplit.mls
@@ -14,6 +14,16 @@ fun f(x) =
     is
       A then 0
       B then 1
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.13: 	  if x
+//│ ║        	     ^
+//│ ║  l.14: 	    is
+//│ ║        	^^^^^^
+//│ ║  l.15: 	      A then 0
+//│ ║        	^^^^^^^^^^^^^^
+//│ ║  l.16: 	      B then 1
+//│ ╙──      	^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ f: (A | B) -> (0 | 1)
 //│  = [Function: f]
 
@@ -24,17 +34,27 @@ fun f(x) =
     1
       + 2 then 0
       + _ then 1
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.33: 	  if x ==
+//│ ║        	     ^^^^
+//│ ║  l.34: 	    1
+//│ ║        	^^^^^^
+//│ ║  l.35: 	      + 2 then 0
+//│ ║        	^^^^^^^^^^^^^^^^
+//│ ║  l.36: 	      + _ then 1
+//│ ╙──      	^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ ╔══[ERROR] Type mismatch in operator application:
-//│ ║  l.23: 	  if x ==
+//│ ║  l.33: 	  if x ==
 //│ ║        	     ^^^^
-//│ ║  l.24: 	    1
+//│ ║  l.34: 	    1
 //│ ║        	^^^^^^
-//│ ║  l.25: 	      + 2 then 0
+//│ ║  l.35: 	      + 2 then 0
 //│ ║        	^^^^^^^
 //│ ╟── operator application of type `bool` is not an instance of type `int`
-//│ ║  l.23: 	  if x ==
+//│ ║  l.33: 	  if x ==
 //│ ║        	     ^^^^
-//│ ║  l.24: 	    1
+//│ ║  l.34: 	    1
 //│ ╙──      	^^^^^^
 //│ f: number -> (0 | 1)
 //│  = [Function: f1]
@@ -45,5 +65,17 @@ fun f(x, s, t) =
       and t then 0
       and s then 0
     is _ then 1
+//│ ╔══[WARNING] old desugarer used
+//│ ║  l.63: 	  if x
+//│ ║        	     ^
+//│ ║  l.64: 	    is A()
+//│ ║        	^^^^^^^^^^
+//│ ║  l.65: 	      and t then 0
+//│ ║        	^^^^^^^^^^^^^^^^^^
+//│ ║  l.66: 	      and s then 0
+//│ ║        	^^^^^^^^^^^^^^^^^^
+//│ ║  l.67: 	    is _ then 1
+//│ ╙──      	^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected warning
 //│ f: (anything, anything, anything,) -> (0 | 1)
 //│  = [Function: f2]
diff --git a/shared/src/test/diff/ucs/Wildcard.mls b/shared/src/test/diff/ucs/Wildcard.mls
index 51cdbda6f4..17d9db40dc 100644
--- a/shared/src/test/diff/ucs/Wildcard.mls
+++ b/shared/src/test/diff/ucs/Wildcard.mls
@@ -1,5 +1,4 @@
-:NewParser
-:NewDefs
+:PreTyper
 
 type Option[T] = None | Some[T]
 module None
@@ -15,6 +14,7 @@ class Right[B](val rightValue: B)
 //│ class Left[A](leftValue: A)
 //│ class Right[B](rightValue: B)
 
+// FIXME
 fun w1(x, e_0, e_1) =
   if x is
     Left(None) then "Left of None"
@@ -23,13 +23,41 @@ fun w1(x, e_0, e_1) =
       Left(Some(lv)) then concat("Left of Some of ")(toString(lv))
       _ and e_1 is y_1 and x is
         Right(Some(rv)) then concat("Right of Some of ")(toString(rv))
-//│ fun w1: (Left[None | Some[anything]] | Right[None | Some[anything]], anything, anything) -> Str
+//│ ╔══[ERROR] Found unexpected empty split
+//│ ╙──
+//│ ╔══[ERROR] Found unexpected empty split
+//│ ╙──
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.23: 	      Left(Some(lv)) then concat("Left of Some of ")(toString(lv))
+//│ ║        	           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.24: 	      _ and e_1 is y_1 and x is
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.25: 	        Right(Some(rv)) then concat("Right of Some of ")(toString(rv))
+//│ ║        	              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.24: 	      _ and e_1 is y_1 and x is
+//│ ║        	            ^^^^^^^^^^^^^^^^^^^
+//│ ║  l.25: 	        Right(Some(rv)) then concat("Right of Some of ")(toString(rv))
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.24: 	      _ and e_1 is y_1 and x is
+//│ ║        	            ^^^^^^^^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun w1: (Left[None | Object & ~#None & ~#Some | Some[anything]] | Object & ~#Left & ~#Right | Right[None | Some[anything]], anything, anything) -> (Str | error)
 
 w1(Left(None), "a", "b")
 w1(Right(None), "a", "b")
 w1(Left(Some(0)), "a", "b")
 w1(Right(Some(0)), "a", "b")
-//│ Str
+//│ Str | error
 //│ res
 //│     = 'Left of None'
 //│ res
@@ -45,7 +73,7 @@ fun w2(x, p) =
     _ and p(x) then 2
     None then 3
     _ then 4
-//│ fun w2: forall 'a. (None | Object & 'a & ~#None & ~#Some | Some[anything], (None | 'a) -> Object) -> (1 | 2 | 3 | 4)
+//│ fun w2: forall 'a. (Object & 'a & ~#Some | Some[anything], 'a -> Bool) -> (1 | 2 | 3 | 4)
 
 w2(Some(0), x => true)
 w2(None, x => true)
@@ -66,7 +94,7 @@ fun w3(x, p) = if x is
   Some(xv) then concat("r2: ")(toString(xv))
   None then "r3"
   _ then "r4"
-//│ fun w3: forall 'a. (None | Object & 'a & ~#None & ~#Some | Some[anything], (None | Some[nothing] | 'a) -> Object) -> Str
+//│ fun w3: forall 'a. ('a & (Object & ~#Some | Some[anything]), 'a -> Bool) -> Str
 
 // Expect "r1"
 w3(0, _ => true)
@@ -98,15 +126,13 @@ w3(0, _ => false)
 //│ res
 //│     = 'r4'
 
-:w
+// :w
+// FIXME: Should warn this.
 // Decision paths:
 // + «tmp2 @ f (x,) is any => 0
 // +  => 1
 fun w3_1(x, f) =
   if f(x) is _ then 0 else 1
-//│ ╔══[WARNING] Found a redundant else branch
-//│ ║  l.106: 	  if f(x) is _ then 0 else 1
-//│ ╙──       	                           ^
 //│ fun w3_1: forall 'a. ('a, 'a -> anything) -> 0
 
 w3_1(0, _ => true)
@@ -117,12 +143,10 @@ w3_1(0, _ => false)
 //│ res
 //│     = 0
 
-:w
+// :w
+// FIXME: Should warn redundant case
 fun w3_1_1(x, f) =
   if f(x) is a then a else 0
-//│ ╔══[WARNING] Found a redundant else branch
-//│ ║  l.122: 	  if f(x) is a then a else 0
-//│ ╙──       	                           ^
 //│ fun w3_1_1: forall 'a 'b. ('a, 'a -> 'b) -> 'b
 
 w3_1_1(0, x => x)
@@ -142,7 +166,7 @@ fun w4(x, p) = if x is
   Some(xv) then concat("r2: ")(toString(xv))
   None then "r3"
   _ then "r4"
-//│ fun w4: forall 'a. (None | Object & 'a & ~#None & ~#Some | Some[anything], (None | Some[nothing] | 'a) -> Object) -> Str
+//│ fun w4: forall 'a. ('a & (Object & ~#Some | Some[anything]), 'a -> Bool) -> Str
 
 
 // Expect "r1"
@@ -196,7 +220,7 @@ fun w5(y) =
         _ and y is
           Delta then "delta"
           _ then "unknown"
-//│ fun w5: Object -> ("alpha" | "beta" | "delta" | "gamma" | "unknown")
+//│ fun w5: (Alpha | Beta | Delta | Gamma | Object & ~#Alpha & ~#Beta & ~#Delta & ~#Gamma) -> ("alpha" | "beta" | "delta" | "gamma" | "unknown")
 
 w5(0)
 w5(Alpha())
@@ -243,19 +267,22 @@ fun w7(x, f) =
       None then x
     Left(x) then x + 1
     Right(x) then x + 2
-//│ fun w7: forall 'a 'b. (Left[Int] | Object & 'a & ~#Left & ~#Right | Right[Int], 'a -> (None | Some['b])) -> (Int | 'a | 'b)
+//│ fun w7: forall 'a 'b. ('a & (Left[Int] | Right[Int]), 'a -> (Object & ~#Some | Some['b])) -> (Int | 'a | 'b)
 
 // The results are wrong:
 w7(Left(99), _ => Some(0)) // => 0
 w7(Left(99), _ => None) // => Left(99)
 w7(Right(99), _ => Some(0)) // => 0
 w7(Right(99), _ => None) // => Right(99)
-//│ Int
+//│ Int | Right['B]
+//│   where
+//│     'B :> 99
+//│        <: Int
 //│ res
-//│     = 100
+//│     = 0
 //│ res
-//│     = 100
+//│     = Left {}
 //│ res
-//│     = 101
+//│     = 0
 //│ res
-//│     = 101
+//│     = Right {}
diff --git a/shared/src/test/diff/ucs/zipWith.mls b/shared/src/test/diff/ucs/zipWith.mls
index a92fef3877..abc77baaae 100644
--- a/shared/src/test/diff/ucs/zipWith.mls
+++ b/shared/src/test/diff/ucs/zipWith.mls
@@ -1,4 +1,4 @@
-:NewDefs
+:PreTyper
 
 
 
@@ -78,7 +78,7 @@ fun zipWith_wrong(f, xs, ys) =
     and ys is Cons(y, ys)
     and zipWith_wrong(f, xs, ys) is Some(tail) then Some(Cons(f(x, y), tail))
   else None
-//│ fun zipWith_wrong: forall 'a 'b 'A. (('a, 'b) -> 'A, Cons['a] | Object & ~#Cons, Cons['b] | Object & ~#Cons) -> (None | Some[Cons['A]])
+//│ fun zipWith_wrong: forall 'A 'a 'b. (('a, 'b) -> 'A, Cons['a] | Object & ~#Cons, Cons['b] | Object & ~#Cons) -> (None | Some[Cons['A]])
 
 
 fun zipWith_wrong(f, xs, ys) =
@@ -158,7 +158,7 @@ fun zipWith(f, xs, ys) =
         Nil then None
     Nil then
       if ys is Nil then Some(Nil) else None
-//│ fun zipWith: forall 'a 'b 'A. (('a, 'b) -> 'A, Cons['a] | Nil, Cons['b] | Nil) -> (None | Some[Cons['A] | Nil])
+//│ fun zipWith: forall 'A 'a 'b. (('a, 'b) -> 'A, Cons['a] | Nil, Cons['b] | Nil) -> (None | Some[Cons['A] | Nil])
 
 zipWith(pairup, Nil, Nil).value.toArray
 //│ Array[anything]
diff --git a/todo.md b/todo.md
new file mode 100644
index 0000000000..cf7fac18dc
--- /dev/null
+++ b/todo.md
@@ -0,0 +1,133 @@
+This file will be deleted after we migrate all test cases and fixed all
+problems located by test cases.
+
+- [x] shared/src/test/diff/codegen/AuxiliaryConstructors.mls
+- [x] shared/src/test/diff/codegen/Mixin.mls
+      Fix that `PreTyper` does not traverse type definitions.
+- [x] shared/src/test/diff/codegen/MixinCapture.mls
+- [x] shared/src/test/diff/codegen/Nested.mls
+- [x] shared/src/test/diff/codegen/NewMatching.mls
+      Destructing unparameterized class no longer causes code generation errors.
+- [x] shared/src/test/diff/codegen/ValLet.mls
+- [x] shared/src/test/diff/ecoop23/ComparePointPoly.mls
+      Desugar UCS shorthands in `PreTyper`.
+- [x] shared/src/test/diff/ecoop23/ExpressionProblem.mls
+- [x] shared/src/test/diff/ecoop23/Intro.mls
+- [x] shared/src/test/diff/ecoop23/PolymorphicVariants.mls
+- [x] shared/src/test/diff/ecoop23/SimpleRegionDSL_annot.mls
+- [x] shared/src/test/diff/ecoop23/SimpleRegionDSL_raw.mls
+- [x] shared/src/test/diff/fcp/QML_exist_nu.mls
+- [x] shared/src/test/diff/gadt/Exp1.mls
+- [x] shared/src/test/diff/gadt/Exp2.mls
+- [x] shared/src/test/diff/gadt/ThisMatching.mls
+- [x] shared/src/test/diff/nu/Andong.mls
+- [x] shared/src/test/diff/nu/ArrayProg.mls
+- [x] shared/src/test/diff/nu/BadUCS.mls
+      Add many `:ge` to cases where match scrutinee against mixins.
+      Add dummy class symbol so that we don't need to throw any
+      errors during desugaring.
+- [x] shared/src/test/diff/nu/BasicClassInheritance.mls
+- [x] shared/src/test/diff/nu/BasicClasses.mls
+- [x] shared/src/test/diff/nu/CaseExpr.mls
+- [x] shared/src/test/diff/nu/ClassSignatures.mls
+- [x] shared/src/test/diff/nu/ClassesInMixins.mls
+      Improve error messages in `PreTyper`.
+- [x] shared/src/test/diff/nu/CommaOperator.mls
+- [x] shared/src/test/diff/nu/CtorSubtraction.mls
+- [x] shared/src/test/diff/nu/Eval.mls
+- [x] shared/src/test/diff/nu/EvalNegNeg.mls
+- [x] shared/src/test/diff/nu/ExpressionProblem_repro.mls
+- [x] shared/src/test/diff/nu/ExpressionProblem_small.mls
+- [x] shared/src/test/diff/nu/FilterMap.mls
+- [x] shared/src/test/diff/nu/FlatIfThenElse.mls
+- [x] shared/src/test/diff/nu/FlatMonads.mls
+- [x] shared/src/test/diff/nu/FunnyIndet.mls
+- [x] shared/src/test/diff/nu/GADTMono.mls
+- [x] shared/src/test/diff/nu/GenericClasses.mls
+- [x] shared/src/test/diff/nu/GenericModules.mls
+- [x] shared/src/test/diff/nu/HeungTung.mls
+- [x] shared/src/test/diff/nu/Huawei1.mls
+- [x] shared/src/test/diff/nu/InterfaceMono.mls
+- [ ] shared/src/test/diff/nu/Interfaces.mls
+      What? Traits can't be patterns?
+- [x] shared/src/test/diff/nu/LetRec.mls
+- [x] shared/src/test/diff/nu/ListConsNil.mls
+- [x] shared/src/test/diff/nu/LitMatch.mls
+- [x] shared/src/test/diff/nu/MissingTypeArg.mls
+- [x] shared/src/test/diff/nu/NamedArgs.mls
+- [ ] shared/src/test/diff/nu/New.mls **OLD**
+- [x] shared/src/test/diff/nu/NewNew.mls
+- [x] shared/src/test/diff/nu/Object.mls
+- [x] shared/src/test/diff/nu/OpLam.mls
+      Function `extractParameters` no longer raise errors.
+- [x] shared/src/test/diff/nu/OptionFilter.mls
+- [x] shared/src/test/diff/nu/OverrideShorthand.mls
+- [x] shared/src/test/diff/nu/ParamPassing.mls
+- [x] shared/src/test/diff/nu/PolymorphicVariants_Alt.mls
+- [x] shared/src/test/diff/nu/PostHocMixinSignature.mls
+- [x] shared/src/test/diff/nu/PrivateMemberOverriding.mls
+- [x] shared/src/test/diff/nu/SelfRec.mls
+- [x] shared/src/test/diff/nu/Subscripts.mls
+- [x] shared/src/test/diff/nu/TODO_Classes.mls
+- [x] shared/src/test/diff/nu/Unapply.mls
+- [x] shared/src/test/diff/nu/UndefMatching.mls
+- [x] shared/src/test/diff/nu/WeirdUnions.mls
+- [x] shared/src/test/diff/nu/i180.mls
+- [ ] shared/src/test/diff/nu/repro0.mls
+      - `PreTyper` does not accept top-level `val` bindings.
+- [x] shared/src/test/diff/nu/repro1.mls
+- [x] shared/src/test/diff/nu/repro_EvalNegNeg.mls
+- [x] shared/src/test/diff/nu/repro_PolymorphicVariants.mls
+- [x] shared/src/test/diff/pretyper/ucs/examples/JSON.mls
+- [x] shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
+- [x] shared/src/test/diff/pretyper/ucs/examples/Option.mls
+- [x] shared/src/test/diff/pretyper/ucs/examples/STLC.mls
+- [x] shared/src/test/diff/ucs/AppSplits.mls
+- [x] shared/src/test/diff/ucs/CrossBranchCapture.mls
+      Fix the mentioned problems.
+      TODO: Warn duplicated pattern bindings.
+- [ ] shared/src/test/diff/ucs/DirectLines.mls **OLD**
+- [x] shared/src/test/diff/ucs/ElseIf.mls
+- [ ] shared/src/test/diff/ucs/ErrorMessage.mls **OLD**
+- [x] shared/src/test/diff/ucs/Exhaustiveness.mls
+- [ ] shared/src/test/diff/ucs/Humiliation.mls **OLD**
+- [x] shared/src/test/diff/ucs/Hygiene.mls
+      Problem fixed!
+- [ ] shared/src/test/diff/ucs/HygienicBindings.mls
+- [ ] shared/src/test/diff/ucs/InterleavedLet.mls **OLD**
+- [x] shared/src/test/diff/ucs/JSON.mls
+      Deleted. This one is not completed and we have a new version.
+- [x] shared/src/test/diff/ucs/LeadingAnd.mls
+- [x] shared/src/test/diff/ucs/LitUCS.mls
+- [x] shared/src/test/diff/ucs/MultiwayIf.mls
+- [ ] shared/src/test/diff/ucs/NestedBranches.mls
+      Found a bug in transformation.
+- [x] shared/src/test/diff/ucs/NestedOpSplits.mls
+- [x] shared/src/test/diff/ucs/NestedPattern.mls
+- [x] shared/src/test/diff/ucs/NuPlainConditionals.mls
+- [x] shared/src/test/diff/ucs/Or.mls
+- [ ] shared/src/test/diff/ucs/OverlappedBranches.mls **OLD**
+- [x] shared/src/test/diff/ucs/ParseFailures.mls
+- [x] shared/src/test/diff/ucs/PlainConditionals.mls
+      Maybe we should keep this old one...
+- [x] shared/src/test/diff/ucs/SimpleUCS.mls
+      Migrate this test case to new defintion typing.
+      Remove a `???` and raise error during transformation.
+- [x] shared/src/test/diff/ucs/SplitAfterOp.mls
+      Wrap tests in functions so that errors are clearer.
+- [ ] shared/src/test/diff/ucs/SplitAnd.mls
+      Should report missing else branches.
+- [x] shared/src/test/diff/ucs/SplitAroundOp.mls
+- [x] shared/src/test/diff/ucs/SplitBeforeOp.mls
+- [x] shared/src/test/diff/ucs/SplitOps.mls
+- [x] shared/src/test/diff/ucs/SplitScrutinee.mls
+      Fixed.
+- [x] shared/src/test/diff/ucs/ThenIndent.mls
+- [x] shared/src/test/diff/ucs/Tree.mls
+- [ ] shared/src/test/diff/ucs/TrivialIf.mls **OLD**
+- [ ] shared/src/test/diff/ucs/WeirdIf.mls
+      Should report redundant cases.
+- [ ] shared/src/test/diff/ucs/WeirdSplit.mls **OLD**
+- [ ] shared/src/test/diff/ucs/Wildcard.mls
+      Some unexpected empty splits.
+- [x] shared/src/test/diff/ucs/zipWith.mls
\ No newline at end of file

From 71ac9f75803766744d49f1162f0c6ab7dc2470f1 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sun, 14 Jan 2024 19:50:21 +0800
Subject: [PATCH 060/147] Fix more tests and a bug in transformation

---
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |   2 +-
 .../src/main/scala/mlscript/ucs/display.scala |  15 +-
 .../src/main/scala/mlscript/ucs/package.scala |   2 +
 .../mlscript/ucs/stages/Normalization.scala   |   2 -
 .../mlscript/ucs/stages/Transformation.scala  |  90 +--
 shared/src/test/diff/nu/New.mls               |  56 +-
 shared/src/test/diff/nu/repro0.mls            |   2 +-
 shared/src/test/diff/ucs/DirectLines.mls      |  96 +--
 shared/src/test/diff/ucs/ErrorMessage.mls     |  51 +-
 shared/src/test/diff/ucs/Humiliation.mls      | 417 ++----------
 shared/src/test/diff/ucs/InterleavedLet.mls   | 624 ++++++------------
 shared/src/test/diff/ucs/NestedBranches.mls   | 118 +---
 .../src/test/diff/ucs/OverlappedBranches.mls  | 110 +--
 todo.md                                       |  34 +-
 14 files changed, 461 insertions(+), 1158 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 40567bbdf3..8c2ab20809 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -142,7 +142,7 @@ trait DesugarUCS extends Transformation
     implicit val context: Context = new Context(`if`)
     try trace("traverseIf") {
       // Stage 0: Transformation
-      val transformed = traceWithTopic("ucs.transform") {
+      val transformed = traceWithTopic("transform") {
         println("STEP 0")
         val transformed = transform(`if`)
         println("Transformed UCS term:")
diff --git a/shared/src/main/scala/mlscript/ucs/display.scala b/shared/src/main/scala/mlscript/ucs/display.scala
index 7ffffe28f9..2ce7656b8e 100644
--- a/shared/src/main/scala/mlscript/ucs/display.scala
+++ b/shared/src/main/scala/mlscript/ucs/display.scala
@@ -38,11 +38,11 @@ package object display {
     }
     def termBranch(branch: s.TermBranch): Lines = branch match {
       case s.TermBranch.Boolean(test, continuation) => 
-        s"$test" #: termSplit(continuation, true, false)
+        s"${test.showDbg}" #: termSplit(continuation, true, false)
       case s.TermBranch.Match(scrutinee, continuation) =>
-        s"$scrutinee is" #: patternSplit(continuation)
+        s"${scrutinee.showDbg} is" #: patternSplit(continuation)
       case s.TermBranch.Left(left, continuation) =>
-        s"$left" #: operatorSplit(continuation)
+        s"${left.showDbg}" #: operatorSplit(continuation)
     }
     def patternSplit(split: s.PatternSplit): Lines = split match {
       case s.Split.Cons(head, tail) => patternBranch(head) ::: patternSplit(tail)
@@ -59,7 +59,7 @@ package object display {
       case s.Split.Nil => Nil
     }
     def operatorBranch(branch: s.OperatorBranch): Lines =
-      s"${branch.operator}" #: (branch match {
+      s"${branch.operator.name}" #: (branch match {
         case s.OperatorBranch.Match(_, continuation) => patternSplit(continuation)
         case s.OperatorBranch.Binary(_, continuation) => termSplit(continuation, true, true)
       })
@@ -70,7 +70,7 @@ package object display {
         case lines => (0, pattern.toString) :: lines
       }
     }
-    ("if" #: termSplit(split, true, true)).iterator.map { case (n, line) => "  " * n + line }.mkString("\n")
+    ("if" #: termSplit(split, true, true)).toIndentedString
   }
 
   @inline def showSplit(s: c.Split)(implicit context: Context): Str = showSplit("if", s)
@@ -93,8 +93,7 @@ package object display {
       s"${showVar(scrutinee)} is $pattern" #: split(continuation, true, false)
     }
     val lines = split(s, true, true)
-    (if (prefix.isEmpty) lines else prefix #: lines)
-      .iterator.map { case (n, line) => "  " * n + line }.mkString("\n")
+    (if (prefix.isEmpty) lines else prefix #: lines).toIndentedString
   }
 
   /**
@@ -137,6 +136,6 @@ package object display {
       val Let(rec, nme, rhs, body) = let
       (0, s"let ${showVar(nme)} = ${rhs.showDbg}") :: showTerm(body)
     }
-    showTerm(term).map { case (n, line) => "  " * n + line }.mkString("\n")
+    showTerm(term).toIndentedString
   }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/package.scala b/shared/src/main/scala/mlscript/ucs/package.scala
index 7cd468c469..1e5a3cacc6 100644
--- a/shared/src/main/scala/mlscript/ucs/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/package.scala
@@ -39,5 +39,7 @@ package object ucs {
         case lines => (0, prefix) :: lines.indent
       }
     }
+    def toIndentedString: String =
+      lines.iterator.map { case (n, line) => "  " * n + line }.mkString("\n")
   }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index ffdf5fc36c..d71b3243e0 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -102,7 +102,6 @@ trait Normalization { self: DesugarUCS with Traceable =>
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
         raiseError(msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc)
         errorTerm
-      case Split.Let(rec, Var("_"), rhs, tail) => normalizeToTerm(tail)
       case Split.Let(_, nme, _, tail) if context.isScrutineeVar(nme) && generatedVars.contains(nme) =>
         println(s"normalizing let binding of generated variable: ${nme.name}")
         normalizeToTerm(tail)
@@ -124,7 +123,6 @@ trait Normalization { self: DesugarUCS with Traceable =>
       split match {
         // case Split.Cons(head, Split.Nil) => Case(head.pattern, normalizeToTerm(head.continuation), NoCases)
         case other: Split.Cons => Wildcard(normalizeToTerm(other))
-        case Split.Let(rec, Var("_"), rhs, tail) => normalizeToCaseBranches(tail)
         case Split.Let(_, nme, _, tail) if context.isScrutineeVar(nme) && generatedVars.contains(nme) =>
           normalizeToCaseBranches(tail)
         case Split.Let(rec, nme, rhs, tail) =>
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index 5956e69a19..5a6e1560a8 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -11,6 +11,8 @@ import mlscript.utils._, shorthands._
 import mlscript.NuFunDef
 import mlscript.PlainTup
 import scala.collection.immutable
+import scala.annotation.tailrec
+import scala.util.chaining._
 
 /**
   * Transform the parsed AST into an AST similar to the one in the paper.
@@ -124,13 +126,8 @@ trait Transformation { self: DesugarUCS with Traceable =>
               PatternBranch(pattern, Split.default(rhs)).toSplit
           }
         case IfOpApp(lhs, Var("and"), rhs) =>
-          println(s"lhs: $lhs")
-          separatePattern(lhs) match {
-            case (pattern, S(extraTest)) =>
-              PatternBranch(pattern, TermBranch.Boolean(extraTest, transformIfBody(rhs)).toSplit).toSplit
-            case (pattern, N) =>
-              PatternBranch(pattern, transformIfBody(rhs)).toSplit
-          }
+          val ::(head, tail) = splitAnd(lhs)
+          PatternBranch(transformPattern(head), transformConjunction(tail, transformIfBody(rhs), false)).toSplit
         case IfOpApp(lhs, op, rhs) =>
           raiseError(msg"Syntactic split of patterns are not supported" -> op.toLoc)
           Split.Nil
@@ -157,23 +154,16 @@ trait Transformation { self: DesugarUCS with Traceable =>
           // This is parsed as `{ and ( Cons x xs ) [ is ys ( Cons y ys ) ] }`.
           // I think it's not very well-formed. But I still implement it for not
           // breaking existing tests.
-          splitAnd(lhs) match {
-            case Nil => die // It's impossible to be empty.
-            case pattern :: tail =>
-              // Here, `pattern` will be `( Cons x xs )` and `tail` will be
-              // `[ is ys (Cons y ys) ]`. We can make a new `IfOpsApp`.
-              println(s"lol, pattern is $pattern")
-              println(s"lol, tail is $tail")
-              tail match {
-                case init :+ last =>
-                  println(s"lol, init is $init")
-                  println(s"lol, last is $last")
-                  val remake = IfOpsApp(last, opsRhss)
-                  val following = transformConjunction(init, transformIfBody(remake), true)
-                  PatternBranch(transformPattern(pattern), following).toSplit
-                case _ => // This can only be `Nil`.
-                  PatternBranch(transformPattern(pattern), transformBrokenIfOpsApp(opsRhss)).toSplit
-              }
+          val ::(pattern, tail) = splitAnd(lhs)
+          // Here, `pattern` will be `( Cons x xs )` and `tail` will be
+          // `[ is ys (Cons y ys) ]`. We can make a new `IfOpsApp`.
+          tail match {
+            case init :+ last =>
+              val remake = IfOpsApp(last, opsRhss)
+              val following = transformConjunction(init, transformIfBody(remake), true)
+              PatternBranch(transformPattern(pattern), following).toSplit
+            case _ => // This can only be `Nil`.
+              PatternBranch(transformPattern(pattern), transformBrokenIfOpsApp(opsRhss)).toSplit
           }
           // END TEMPORARY PATCH
         case IfLet(rec, nme, rhs, body) => die
@@ -202,13 +192,15 @@ trait Transformation { self: DesugarUCS with Traceable =>
   private def transformPattern(term: Term): Pattern = term match {
     case wildcard @ Var("_") => EmptyPattern(wildcard) // The case for wildcard.
     case nme @ Var("true" | "false") => ConcretePattern(nme)
-    case nme @ Var(name) if name.headOption.exists(_.isUpper) => ClassPattern(nme, N, refined = false)
+    case nme @ Var(name) if name.isCapitalized => ClassPattern(nme, N, refined = false)
     case nme: Var => NamePattern(nme)
     case literal: Lit => LiteralPattern(literal)
     case App(Var("refined"), PlainTup(p)) =>
       transformPattern(p) match {
         case cp: ClassPattern => cp.copy(refined = true).withLocOf(cp)
-        case _ => ??? // TODO error
+        case p =>
+          raiseError(msg"only class patterns can be refined" -> p.toLoc)
+          p
       }
     case App(classNme @ Var(_), parameters: Tup) =>
       ClassPattern(classNme, S(transformTupleTerm(parameters)), refined = false)
@@ -221,26 +213,29 @@ trait Transformation { self: DesugarUCS with Traceable =>
 
   private def separatePattern(term: Term): (Pattern, Opt[Term]) = {
     val (rawPattern, extraTest) = helpers.separatePattern(term, true)
-    println("rawPattern: " + rawPattern.toString)
-    println("extraTest: " + extraTest.toString)
+    println(s"pattern: ${rawPattern.showDbg} ;; test: ${extraTest.fold("_")(_.showDbg)}")
     (transformPattern(rawPattern), extraTest)
   }
 
-  // TODO: Maybe we can change the return type to `::[Term]` so that it will not
-  // empty.
-  private def splitAnd(t: Term): List[Term] = trace(s"splitAnd <== $t") {
-    t match {
-      case App(
-        App(Var("and"),
-            Tup((_ -> Fld(_, lhs)) :: Nil)),
-        Tup((_ -> Fld(_, rhs)) :: Nil)
-      ) => // * Old-style operators
-        splitAnd(lhs) :+ rhs
-      case App(Var("and"), PlainTup(lhs, rhs)) =>
-        splitAnd(lhs) :+ rhs
-      case _ => t :: Nil
+  /**
+    * Split a term into a list of terms. Note that the return type is `::[Term]`
+    * because there should be at least one term even we don't split. It used to
+    * split right-associate `and` terms, but it turned out that `and` may
+    * nested in a left-associate manner. Therefore, the function now traverse
+    * the entire term and split all `and` terms.
+    */
+  private def splitAnd(t: Term): ::[Term] = {
+    @tailrec def rec(acc: Ls[Term], rest: ::[Term]): ::[Term] = rest.head match {
+      case lhs and rhs => rec(acc, ::(rhs, lhs :: rest.tail))
+      case sole => rest.tail match {
+        case Nil => ::(sole, acc)
+        case more @ ::(_, _) => rec(sole :: acc, more)
+      }
+    }
+    rec(Nil, ::(t, Nil)).tap { rs =>
+      println(s"splitAnd ${t.showDbg} ==> ${rs.iterator.map(_.showDbg).mkString(" ∧ ")}")
     }
-  }(r => "splitAnd ==> " + r.iterator.map(_.toString).mkString(" ∧ "))
+  }
 }
 
 object Transformation {
@@ -249,10 +244,19 @@ object Transformation {
     case _ => die
   }
 
+  /** Matches terms like `x is y`. */
   private object is {
-    def unapply(term: Term): Opt[(Term, Term)] = term match {
+    def unapply(term: Term): Opt[Term -> Term] = term match {
       case App(Var("is"), PlainTup(scrutinee, pattern)) => S(scrutinee -> pattern)
       case _ => N
     }
   }
+
+  /** Matches terms like `x and y` */
+  private object and {
+    def unapply(term: Term): Opt[(Term, Term)] = term match {
+      case App(Var("and"), PlainTup(lhs, rhs)) => S((lhs, rhs))
+      case _ => N
+    }
+  }
 }
diff --git a/shared/src/test/diff/nu/New.mls b/shared/src/test/diff/nu/New.mls
index 945effc18c..faae55db75 100644
--- a/shared/src/test/diff/nu/New.mls
+++ b/shared/src/test/diff/nu/New.mls
@@ -1,32 +1,27 @@
-:NewParser
+:PreTyper
 
 
-class Foo(x)
-//│ Defined class Foo
-//│ Foo: 'x -> (Foo & {x: 'x})
-//│    = [Function: Foo1]
+class Foo[A](x: A)
+//│ class Foo[A](x: A)
 
 let f = Foo(1)
-//│ f: Foo & {x: 1}
-//│  = Foo { x: 1 }
+//│ let f: Foo['A]
+//│   where
+//│     'A :> 1
+//│ f
+//│   = Foo {}
 
 // let f = new Foo(1)
 
 if f is Foo then 1 else 0
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.15: 	if f is Foo then 1 else 0
-//│ ╙──      	   ^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ res: 0 | 1
-//│    = 1
+//│ 0 | 1
+//│ res
+//│     = 1
 
 if f is Foo(a) then a else 0
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.23: 	if f is Foo(a) then a else 0
-//│ ╙──      	   ^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ res: 0 | 1
-//│    = 1
+//│ 0 | 1
+//│ res
+//│     = 1
 
 // case f of
 //   { Foo ->
@@ -39,22 +34,19 @@ if f is Foo(a) then a else 0
 
 
 fun test(x) = if x is Foo(a) then a
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.41: 	fun test(x) = if x is Foo(a) then a
-//│ ╙──      	                 ^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ test: (Foo & {x: 'x}) -> 'x
-//│     = [Function: test]
+//│ fun test: forall 'a. Foo['a] -> 'a
 
 test(f)
-//│ res: 1
-//│    = 1
+//│ 1
+//│ res
+//│     = 1
 
-class PoInt(x, y)
-//│ Defined class PoInt
-//│ PoInt: ('x, 'y,) -> (PoInt & {x: 'x, y: 'y})
-//│      = [Function: PoInt1]
+class PoInt(x: Int, y: Int)
+//│ class PoInt(x: Int, y: Int)
 
-// let origin = new PoInt(0, 0)
+let origin = new PoInt(0, 0)
+//│ let origin: PoInt
+//│ origin
+//│        = PoInt {}
 
 
diff --git a/shared/src/test/diff/nu/repro0.mls b/shared/src/test/diff/nu/repro0.mls
index 61095fcad3..89ed2dabe0 100644
--- a/shared/src/test/diff/nu/repro0.mls
+++ b/shared/src/test/diff/nu/repro0.mls
@@ -1,7 +1,7 @@
 :PreTyper
 :NoJS
 
-
+:e
 class Add[out E](val lhs: E)
 val add11 = Add(add11)
 module EvalAddLit {
diff --git a/shared/src/test/diff/ucs/DirectLines.mls b/shared/src/test/diff/ucs/DirectLines.mls
index 5e346f8b71..4450e04e0e 100644
--- a/shared/src/test/diff/ucs/DirectLines.mls
+++ b/shared/src/test/diff/ucs/DirectLines.mls
@@ -1,59 +1,28 @@
-:NewParser
+:PreTyper
 
 fun f(x, y) =
   if
     x == 0 then "x"
     y == 0 then "y"
     _      then "nah"
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.5: 	    x == 0 then "x"
-//│ ║       	    ^^^^^^^^^^^^^^^
-//│ ║  l.6: 	    y == 0 then "y"
-//│ ║       	^^^^^^^^^^^^^^^^^^^
-//│ ║  l.7: 	    _      then "nah"
-//│ ╙──     	^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ f: (number, number,) -> ("nah" | "x" | "y")
-//│  = [Function: f]
+//│ fun f: (Num, Num) -> ("nah" | "x" | "y")
 
-class Option
-class Some(value): Option
-class None: Option
-//│ Defined class Option
-//│ Defined class Some
-//│ Defined class None
-//│ Option: () -> Option
-//│       = [Function: Option1]
-//│ Some: 'value -> (Some & {value: 'value})
-//│     = [Function: Some1]
-//│ None: () -> None
-//│     = [Function: None1]
+abstract class Option[A]: Some[A] | None
+class Some[A](value: A) extends Option[A]
+module None extends Option
+//│ abstract class Option[A]: None | Some[A]
+//│ class Some[A](value: A) extends Option
+//│ module None extends Option
 
 fun isValid(x) = if x then false else true
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.32: 	fun isValid(x) = if x then false else true
-//│ ╙──      	                    ^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ isValid: anything -> Bool
-//│        = [Function: isValid]
+//│ fun isValid: Bool -> Bool
 
 fun f(x, allowNone) =
   if x
     is Some(x) and isValid(x) then "good"
     is None() and allowNone then "okay"
     is _ then "bad"
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.41: 	  if x
-//│ ║        	     ^
-//│ ║  l.42: 	    is Some(x) and isValid(x) then "good"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.43: 	    is None() and allowNone then "okay"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.44: 	    is _ then "bad"
-//│ ╙──      	^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ f: (anything, anything,) -> ("bad" | "good" | "okay")
-//│  = [Function: f1]
+//│ fun f: (Object & ~#Some | Some[Bool], Bool) -> ("bad" | "good" | "okay")
 
 fun f(x, y, z) =
   if
@@ -66,30 +35,10 @@ fun f(x, y, z) =
         _ then "bruh"
       3 then "y = 3"
       _ then "bruh"
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.60: 	    x == 0 then "x"
-//│ ║        	    ^^^^^^^^^^^^^^^
-//│ ║  l.61: 	    y ==
-//│ ║        	^^^^^^^^
-//│ ║  l.62: 	      1 then "y = 1"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.63: 	      2 and z ==
-//│ ║        	^^^^^^^^^^^^^^^^
-//│ ║  l.64: 	        0 then "z = 0"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.65: 	        9 then "z = 9"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.66: 	        _ then "bruh"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.67: 	      3 then "y = 3"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.68: 	      _ then "bruh"
-//│ ╙──      	^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ f: (number, number, number,) -> ("bruh" | "x" | "y = 1" | "y = 3" | "z = 0" | "z = 9")
-//│  = [Function: f2]
+//│ fun f: (Num, Num, Num) -> ("bruh" | "x" | "y = 1" | "y = 3" | "z = 0" | "z = 9")
 
-:w
+// :w
+// FIXME: Report redundant else branches.
 fun f(a, b) =
   if
     a == 0 then 0
@@ -98,21 +47,4 @@ fun f(a, b) =
       2 then 2
       _ then 7
     else 3
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.95: 	    a == 0 then 0
-//│ ║        	    ^^^^^^^^^^^^^
-//│ ║  l.96: 	    b ==
-//│ ║        	^^^^^^^^
-//│ ║  l.97: 	      1 then 1
-//│ ║        	^^^^^^^^^^^^^^
-//│ ║  l.98: 	      2 then 2
-//│ ║        	^^^^^^^^^^^^^^
-//│ ║  l.99: 	      _ then 7
-//│ ║        	^^^^^^^^^^^^^^
-//│ ║  l.100: 	    else 3
-//│ ╙──       	^^^^^^^^^^
-//│ ╔══[WARNING] Found a redundant else branch
-//│ ║  l.100: 	    else 3
-//│ ╙──       	         ^
-//│ f: (number, number,) -> (0 | 1 | 2 | 7)
-//│  = [Function: f3]
+//│ fun f: (Num, Num) -> (0 | 1 | 2 | 7)
diff --git a/shared/src/test/diff/ucs/ErrorMessage.mls b/shared/src/test/diff/ucs/ErrorMessage.mls
index 70bbd0eb18..a361659c85 100644
--- a/shared/src/test/diff/ucs/ErrorMessage.mls
+++ b/shared/src/test/diff/ucs/ErrorMessage.mls
@@ -1,42 +1,37 @@
-:NewParser
+:PreTyper
 
-class Point(x, y)
-//│ Defined class Point
-//│ Point: ('x, 'y,) -> (Point & {x: 'x, y: 'y})
-//│      = [Function: Point1]
+class Point(x: Int, y: Int)
+//│ class Point(x: Int, y: Int)
 
 :e
-:ge
 fun f(p) =
   if p is
     Point(x, y, z) then x + y + z
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.11: 	  if p is
-//│ ║        	     ^^^^
-//│ ║  l.12: 	    Point(x, y, z) then x + y + z
-//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ╔══[ERROR] class Point expects 2 parameters but found 3 parameters
-//│ ║  l.12: 	    Point(x, y, z) then x + y + z
-//│ ╙──      	    ^^^^^^^^^^^^^^
-//│ f: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] Type mismatch in field selection:
+//│ ╟── tuple literal of type `{0: ?#x, 1: ?#y}` does not have field '2'
+//│ ║  l.3: 	class Point(x: Int, y: Int)
+//│ ║       	            ^^^^^^^^^
+//│ ╟── but it flows into operator application with expected type `{2: ?a}`
+//│ ║  l.8: 	  if p is
+//│ ║       	     ^^^^
+//│ ║  l.9: 	    Point(x, y, z) then x + y + z
+//│ ╙──     	^^^^^^^^^
+//│ fun f: Point -> Int
 
 :e
 :ge
 fun g(xs) =
   if xs is
     head :: _ then head
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.29: 	  if xs is
-//│ ║        	     ^^^^^
-//│ ║  l.30: 	    head :: _ then head
-//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ╔══[ERROR] Cannot find operator `::` in the context
-//│ ║  l.30: 	    head :: _ then head
+//│ ╔══[ERROR] type identifier `::` not found
+//│ ║  l.25: 	    head :: _ then head
+//│ ╙──      	         ^^
+//│ ╔══[ERROR] identifier `::` not found
+//│ ║  l.25: 	    head :: _ then head
+//│ ╙──      	         ^^
+//│ ╔══[ERROR] type identifier not found: ::
+//│ ║  l.25: 	    head :: _ then head
 //│ ╙──      	         ^^
-//│ g: anything -> error
+//│ fun g: nothing -> error
 //│ Code generation encountered an error:
-//│   if expression was not desugared
+//│   unresolved symbol ::
diff --git a/shared/src/test/diff/ucs/Humiliation.mls b/shared/src/test/diff/ucs/Humiliation.mls
index 2463ac99c3..86bf952f04 100644
--- a/shared/src/test/diff/ucs/Humiliation.mls
+++ b/shared/src/test/diff/ucs/Humiliation.mls
@@ -1,73 +1,35 @@
-:NewParser
+:PreTyper
 
 
-class Foo(x)
-//│ Defined class Foo
-//│ Foo: 'x -> (Foo & {x: 'x})
-//│    = [Function: Foo1]
+class Foo[T](x: T)
+//│ class Foo[T](x: T)
 
 if 1 is 1 then 1 else 0
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.9: 	if 1 is 1 then 1 else 0
-//│ ╙──     	   ^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ res: 0 | 1
-//│    = 1
+//│ 0 | 1
+//│ res
+//│     = 1
 
 fun test(x) = if x is 1 then 0 else 1
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.17: 	fun test(x) = if x is 1 then 0 else 1
-//│ ╙──      	                 ^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ test: anything -> (0 | 1)
-//│     = [Function: test]
+//│ fun test: Object -> (0 | 1)
 
-// It should report duplicated branches.
-:w
+// :w
+// FIXME: It should report duplicated branches.
 fun testF(x) = if x is
   Foo(a) then a
   Foo(a) then a
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.27: 	fun testF(x) = if x is
-//│ ║        	                  ^^^^
-//│ ║  l.28: 	  Foo(a) then a
-//│ ║        	^^^^^^^^^^^^^^^
-//│ ║  l.29: 	  Foo(a) then a
-//│ ╙──      	^^^^^^^^^^^^^^^
-//│ ╔══[WARNING] Found a duplicated branch
-//│ ╟── This branch
-//│ ║  l.29: 	  Foo(a) then a
-//│ ║        	              ^
-//│ ╟── is subsumed by the branch here.
-//│ ║  l.28: 	  Foo(a) then a
-//│ ╙──      	              ^
-//│ testF: (Foo & {x: 'x}) -> 'x
-//│      = [Function: testF]
+//│ fun testF: forall 'a. Foo['a] -> 'a
 
-class Bar(y, z)
-//│ Defined class Bar
-//│ Bar: ('y, 'z,) -> (Bar & {y: 'y, z: 'z})
-//│    = [Function: Bar1]
+class Bar[Y, Z](y: Y, z: Z)
+//│ class Bar[Y, Z](y: Y, z: Z)
 
 fun test(f) = if f is
   Foo(a) then a
   Bar(b, c) then b + c
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.52: 	fun test(f) = if f is
-//│ ║        	                 ^^^^
-//│ ║  l.53: 	  Foo(a) then a
-//│ ║        	^^^^^^^^^^^^^^^
-//│ ║  l.54: 	  Bar(b, c) then b + c
-//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ test: (Bar & {y: int, z: int} | Foo & {x: 'x}) -> (int | 'x)
-//│     = [Function: test1]
+//│ fun test: forall 'a. (Bar[Int, Int] | Foo['a]) -> (Int | 'a)
 
 
-class Pair(fst, snd)
-//│ Defined class Pair
-//│ Pair: ('fst, 'snd,) -> (Pair & {fst: 'fst, snd: 'snd})
-//│     = [Function: Pair1]
+class Pair[A, B](fst: A, snd: B)
+//│ class Pair[A, B](fst: A, snd: B)
 
 fun f(x) =
   if x is
@@ -75,85 +37,53 @@ fun f(x) =
     Pair(1, 1) then "ones"
     Pair(y, 1) then x
     _          then "nah"
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.73: 	  if x is
-//│ ║        	     ^^^^
-//│ ║  l.74: 	    Pair(0, 0) then "zeros"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.75: 	    Pair(1, 1) then "ones"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.76: 	    Pair(y, 1) then x
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.77: 	    _          then "nah"
-//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ f: (Pair & 'a | ~Pair) -> ("nah" | "ones" | "zeros" | 'a)
-//│  = [Function: f]
+//│ fun f: (Object & ~#Pair | Pair[Object, Object]) -> ("nah" | "ones" | "zeros" | Pair[nothing, nothing])
 
 class Z()
 class O()
-//│ Defined class Z
-//│ Defined class O
-//│ Z: () -> Z
-//│  = [Function: Z1]
-//│ O: () -> O
-//│  = [Function: O1]
+//│ class Z()
+//│ class O()
 
 // This is not exhaustive.
 :e
-:ge
 fun foo(x) = if x is
   Pair(Z(), Z()) then "zeros"
   Pair(O(), O()) then "ones"
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.105: 	fun foo(x) = if x is
-//│ ║         	                ^^^^
-//│ ║  l.106: 	  Pair(Z(), Z()) then "zeros"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.107: 	  Pair(O(), O()) then "ones"
-//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ╔══[ERROR] The match is not exhaustive.
-//│ ║  l.105: 	fun foo(x) = if x is
-//│ ║         	                ^^^^
-//│ ╟── The scrutinee at this position misses 1 case.
-//│ ║  l.106: 	  Pair(Z(), Z()) then "zeros"
-//│ ║         	            ^^^
-//│ ╟── [Missing Case 1/1] `O`
-//│ ╟── It first appears here.
-//│ ║  l.107: 	  Pair(O(), O()) then "ones"
-//│ ╙──       	            ^^^
-//│ foo: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] When scrutinee `x` is `Pair`,
+//│ ║  l.50: 	  Pair(Z(), Z()) then "zeros"
+//│ ║        	  ^^^^
+//│ ╟── scrutinee `x$Pair_0` is `Z`, and
+//│ ║  l.50: 	  Pair(Z(), Z()) then "zeros"
+//│ ║        	       ^
+//│ ╟── Scrutinee `x$Pair_1` has 1 missing case
+//│ ╟── It can be class `O`
+//│ ║  l.51: 	  Pair(O(), O()) then "ones"
+//│ ╙──      	            ^
+//│ ╔══[ERROR] When scrutinee `x` is `Pair`,
+//│ ║  l.50: 	  Pair(Z(), Z()) then "zeros"
+//│ ║        	  ^^^^
+//│ ╟── scrutinee `x$Pair_0` is `O`, and
+//│ ║  l.51: 	  Pair(O(), O()) then "ones"
+//│ ║        	       ^
+//│ ╟── Scrutinee `x$Pair_1` has 1 missing case
+//│ ╟── It can be class `Z`
+//│ ║  l.50: 	  Pair(Z(), Z()) then "zeros"
+//│ ╙──      	            ^
+//│ fun foo: Pair[O | Z, nothing] -> ("ones" | "zeros")
 
 // Change `Pair` to a real pair.
 :e
-:ge
 fun foo(x) = if x is
   [Z(), Z()] then "zeros"
   [O(), O()] then "ones"
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.133: 	fun foo(x) = if x is
-//│ ║         	                ^^^^
-//│ ║  l.134: 	  [Z(), Z()] then "zeros"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.135: 	  [O(), O()] then "ones"
-//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ╔══[ERROR] The match is not exhaustive.
-//│ ║  l.133: 	fun foo(x) = if x is
-//│ ║         	                ^^^^
-//│ ╟── The scrutinee at this position misses 1 case.
-//│ ║  l.134: 	  [Z(), Z()] then "zeros"
-//│ ║         	        ^^^
-//│ ╟── [Missing Case 1/1] `O`
-//│ ╟── It first appears here.
-//│ ║  l.135: 	  [O(), O()] then "ones"
-//│ ╙──       	        ^^^
-//│ foo: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] When scrutinee `x$Tuple$2_0` is `O`
+//│ ║  l.78: 	  [O(), O()] then "ones"
+//│ ║        	   ^
+//│ ╟── Scrutinee `x$Tuple$2_1` has 1 missing case
+//│ ╟── It can be class `Z`
+//│ ║  l.77: 	  [Z(), Z()] then "zeros"
+//│ ╙──      	        ^
+//│ fun foo: forall 'a. {0: O | Z, 1: O & 'a} -> ("ones" | "zeros" | 'a)
 
 fun foo(x) = if x is
   Pair(a, b) then if a is
@@ -161,46 +91,7 @@ fun foo(x) = if x is
       Z() then "zeros"
     O() then if b is
       O() then "ones"
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.158: 	fun foo(x) = if x is
-//│ ║         	                ^^^^
-//│ ║  l.159: 	  Pair(a, b) then if a is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.160: 	    Z() then if b is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.161: 	      Z() then "zeros"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.162: 	    O() then if b is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.163: 	      O() then "ones"
-//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.159: 	  Pair(a, b) then if a is
-//│ ║         	                     ^^^^
-//│ ║  l.160: 	    Z() then if b is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.161: 	      Z() then "zeros"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.162: 	    O() then if b is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.163: 	      O() then "ones"
-//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.160: 	    Z() then if b is
-//│ ║         	                ^^^^
-//│ ║  l.161: 	      Z() then "zeros"
-//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.162: 	    O() then if b is
-//│ ║         	                ^^^^
-//│ ║  l.163: 	      O() then "ones"
-//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ foo: (Pair & {fst: O | Z, snd: nothing}) -> ("ones" | "zeros")
-//│    = [Function: foo2]
+//│ fun foo: Pair[O | Z, nothing] -> ("ones" | "zeros")
 
 fun foo(x) = if x is
   Pair(a, b) then if a is
@@ -209,52 +100,7 @@ fun foo(x) = if x is
       else "???"
     O() then if b is
       O() then "ones"
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.205: 	fun foo(x) = if x is
-//│ ║         	                ^^^^
-//│ ║  l.206: 	  Pair(a, b) then if a is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.207: 	    Z() then if b is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.208: 	      Z() then "zeros"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.209: 	      else "???"
-//│ ║         	^^^^^^^^^^^^^^^^^
-//│ ║  l.210: 	    O() then if b is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.211: 	      O() then "ones"
-//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.206: 	  Pair(a, b) then if a is
-//│ ║         	                     ^^^^
-//│ ║  l.207: 	    Z() then if b is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.208: 	      Z() then "zeros"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.209: 	      else "???"
-//│ ║         	^^^^^^^^^^^^^^^^
-//│ ║  l.210: 	    O() then if b is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.211: 	      O() then "ones"
-//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.207: 	    Z() then if b is
-//│ ║         	                ^^^^
-//│ ║  l.208: 	      Z() then "zeros"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.209: 	      else "???"
-//│ ╙──       	^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.210: 	    O() then if b is
-//│ ║         	                ^^^^
-//│ ║  l.211: 	      O() then "ones"
-//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ foo: (Pair & {fst: O | Z, snd: O}) -> ("???" | "ones" | "zeros")
-//│    = [Function: foo3]
+//│ fun foo: Pair[O | Z, O] -> ("???" | "ones" | "zeros")
 
 fun foo(x) = if x is
   Pair(a, b) then if a is
@@ -264,63 +110,10 @@ fun foo(x) = if x is
     O() then if b is
       O() then "zeros"
       else "???"
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.259: 	fun foo(x) = if x is
-//│ ║         	                ^^^^
-//│ ║  l.260: 	  Pair(a, b) then if a is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.261: 	    Z() then if b is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.262: 	      Z() then "zeros"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.263: 	      else "???"
-//│ ║         	^^^^^^^^^^^^^^^^^
-//│ ║  l.264: 	    O() then if b is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.265: 	      O() then "zeros"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.266: 	      else "???"
-//│ ╙──       	^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.260: 	  Pair(a, b) then if a is
-//│ ║         	                     ^^^^
-//│ ║  l.261: 	    Z() then if b is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.262: 	      Z() then "zeros"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.263: 	      else "???"
-//│ ║         	^^^^^^^^^^^^^^^^
-//│ ║  l.264: 	    O() then if b is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.265: 	      O() then "zeros"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.266: 	      else "???"
-//│ ╙──       	^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.261: 	    Z() then if b is
-//│ ║         	                ^^^^
-//│ ║  l.262: 	      Z() then "zeros"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.263: 	      else "???"
-//│ ╙──       	^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.264: 	    O() then if b is
-//│ ║         	                ^^^^
-//│ ║  l.265: 	      O() then "zeros"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.266: 	      else "???"
-//│ ╙──       	^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ foo: (Pair & {fst: O | Z}) -> ("???" | "zeros")
-//│    = [Function: foo4]
+//│ fun foo: Pair[O | Z, Object] -> ("???" | "zeros")
 
-class S(pred)
-//│ Defined class S
-//│ S: 'pred -> (S & {pred: 'pred})
-//│  = [Function: S1]
+class S(pred: S | Z | O)
+//│ class S(pred: O | S | Z)
 
 // TODO: Cannot check exhaustiveness of nested UCS yet.
 fun foo(x) = if x is
@@ -331,108 +124,34 @@ fun foo(x) = if x is
     O() then if b is
       O() then "zeros"
       else "???"
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.326: 	fun foo(x) = if x is
-//│ ║         	                ^^^^
-//│ ║  l.327: 	  Pair(a, b) then if a is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.328: 	    Z() then if b is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.329: 	      S(x) then x
-//│ ║         	^^^^^^^^^^^^^^^^^
-//│ ║  l.330: 	      else "???"
-//│ ║         	^^^^^^^^^^^^^^^^^
-//│ ║  l.331: 	    O() then if b is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.332: 	      O() then "zeros"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.333: 	      else "???"
-//│ ╙──       	^^^^^^^^^^^^^^^^^
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.327: 	  Pair(a, b) then if a is
-//│ ║         	                     ^^^^
-//│ ║  l.328: 	    Z() then if b is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.329: 	      S(x) then x
-//│ ║         	^^^^^^^^^^^^^^^^^
-//│ ║  l.330: 	      else "???"
-//│ ║         	^^^^^^^^^^^^^^^^
-//│ ║  l.331: 	    O() then if b is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.332: 	      O() then "zeros"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.333: 	      else "???"
-//│ ╙──       	^^^^^^^^^^^^^^^^
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.328: 	    Z() then if b is
-//│ ║         	                ^^^^
-//│ ║  l.329: 	      S(x) then x
-//│ ║         	^^^^^^^^^^^^^^^^^
-//│ ║  l.330: 	      else "???"
-//│ ╙──       	^^^^^^^^^^^^^^^^^
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.331: 	    O() then if b is
-//│ ║         	                ^^^^
-//│ ║  l.332: 	      O() then "zeros"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.333: 	      else "???"
-//│ ╙──       	^^^^^^^^^^^^^^^^^
-//│ foo: (Pair & {fst: O | Z, snd: S & {pred: 'pred} | ~S}) -> ("???" | "zeros" | 'pred)
-//│    = [Function: foo5]
+//│ fun foo: Pair[O | Z, Object] -> ("???" | "zeros" | O | S | Z)
 
 foo(Pair(Z(), Z()))
-//│ res: "???" | "zeros"
-//│    = '???'
+//│ "???" | "zeros" | O | S | Z
+//│ res
+//│     = '???'
 
 :e
-:ge
 fun foo(x) = if x is
   Pair(Z(), Z()) then "zeros"
   Pair(O(), O()) then "ones"
   Pair(y, O()) then x
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.389: 	fun foo(x) = if x is
-//│ ║         	                ^^^^
-//│ ║  l.390: 	  Pair(Z(), Z()) then "zeros"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.391: 	  Pair(O(), O()) then "ones"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.392: 	  Pair(y, O()) then x
-//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ╔══[ERROR] The match is not exhaustive.
-//│ ║  l.389: 	fun foo(x) = if x is
-//│ ║         	                ^^^^
-//│ ╟── The scrutinee at this position misses 1 case.
-//│ ║  l.390: 	  Pair(Z(), Z()) then "zeros"
-//│ ║         	            ^^^
-//│ ╟── [Missing Case 1/1] `Z`
-//│ ╟── It first appears here.
-//│ ║  l.390: 	  Pair(Z(), Z()) then "zeros"
-//│ ╙──       	            ^^^
-//│ foo: anything -> error
-//│ Code generation encountered an error:
-//│   if expression was not desugared
+//│ ╔══[ERROR] When scrutinee `x` is `Pair`
+//│ ║  l.136: 	  Pair(Z(), Z()) then "zeros"
+//│ ║         	  ^^^^
+//│ ╟── Scrutinee `x$Pair_1` has 1 missing case
+//│ ╟── It can be class `Z`
+//│ ║  l.136: 	  Pair(Z(), Z()) then "zeros"
+//│ ╙──       	            ^
+//│ fun foo: forall 'B 'A. Pair['A, O & 'B] -> ("ones" | "zeros" | Pair['A, 'B] | 'A)
+//│   where
+//│     'A <: Object
 
 fun foo(x, y) = if x is Z() and y is O() then 0 else 1
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.417: 	fun foo(x, y) = if x is Z() and y is O() then 0 else 1
-//│ ╙──       	                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ foo: (anything, anything,) -> (0 | 1)
-//│    = [Function: foo7]
+//│ fun foo: (Object, Object) -> (0 | 1)
 
 fun foo(x, y) =
   if x is
     Z() and y is O() then 0
     else 1
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.426: 	  if x is
-//│ ║         	     ^^^^
-//│ ║  l.427: 	    Z() and y is O() then 0
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.428: 	    else 1
-//│ ╙──       	^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ foo: (anything, anything,) -> (0 | 1)
-//│    = [Function: foo8]
+//│ fun foo: (Object, Object) -> (0 | 1)
diff --git a/shared/src/test/diff/ucs/InterleavedLet.mls b/shared/src/test/diff/ucs/InterleavedLet.mls
index 6b8d1ade0e..cb41cb72c7 100644
--- a/shared/src/test/diff/ucs/InterleavedLet.mls
+++ b/shared/src/test/diff/ucs/InterleavedLet.mls
@@ -1,121 +1,72 @@
-:NewParser
+:PreTyper
 
 fun f(x) =
   if x ==
     let v = 0
     v then v
     else 0
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.4: 	  if x ==
-//│ ║       	     ^^^^
-//│ ║  l.5: 	    let v = 0
-//│ ║       	^^^^^^^^^^^^^
-//│ ║  l.6: 	    v then v
-//│ ║       	^^^^^^^^^^^^
-//│ ║  l.7: 	    else 0
-//│ ╙──     	^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ f: number -> 0
-//│  = [Function: f]
-
-class Option
-class Some(value): Option
-class None: Option
-class Either
-class Left(leftValue): Either
-class Right(rightValue): Either
-//│ Defined class Option
-//│ Defined class Some
-//│ Defined class None
-//│ Defined class Either
-//│ Defined class Left
-//│ Defined class Right
-//│ Option: () -> Option
-//│       = [Function: Option1]
-//│ Some: 'value -> (Some & {value: 'value})
-//│     = [Function: Some1]
-//│ None: () -> None
-//│     = [Function: None1]
-//│ Either: () -> Either
-//│       = [Function: Either1]
-//│ Left: 'leftValue -> (Left & {leftValue: 'leftValue})
-//│     = [Function: Left1]
-//│ Right: 'rightValue -> (Right & {rightValue: 'rightValue})
-//│      = [Function: Right1]
-
+//│ fun f: Num -> 0
+
+abstract class Option[A]: Some[A] | None
+class Some[A](value: A) extends Option[A]
+module None extends Option
+//│ abstract class Option[A]: None | Some[A]
+//│ class Some[A](value: A) extends Option
+//│ module None extends Option
+
+abstract class Either[out A, out B]: Left[A] | Right[B]
+class Left[A](leftValue: A) extends Either[A, nothing]
+class Right[B](rightValue: B) extends Either[nothing, B]
+//│ abstract class Either[A, B]: Left[A] | Right[B]
+//│ class Left[A](leftValue: A) extends Either
+//│ class Right[B](rightValue: B) extends Either
+
+:dpt:normalize.result
 fun q(x) =
   if
     x is Some and x is Some and x is Some then 0
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.48: 	    x is Some and x is Some and x is Some then 0
-//│ ╙──      	    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ q: Some -> 0
-//│  = [Function: q]
-
-:w
+//│ | | | | | | | Normalized UCS term:
+//│ | | | | | | | case x*‡ of
+//│ | | | | | | |   Some*◊ -> 0
+//│ fun q: Some[anything] -> 0
+
+:e
+// FIXME: Unexpected empty split.
 fun p(x, y) =
   if
     x is Some and y is None then 0
     y is Some and x is Some then 1
     x is Some and y is Some then 0
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.59: 	    x is Some and y is None then 0
-//│ ║        	    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.60: 	    y is Some and x is Some then 1
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.61: 	    x is Some and y is Some then 0
-//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╔══[WARNING] Found a duplicated branch
-//│ ╟── This branch
-//│ ║  l.61: 	    x is Some and y is Some then 0
-//│ ║        	                                 ^
-//│ ╟── is subsumed by the branch here.
-//│ ║  l.60: 	    y is Some and x is Some then 1
-//│ ╙──      	                                 ^
-//│ p: (Some, None | Some,) -> (0 | 1)
-//│  = [Function: p]
+//│ ╔══[ERROR] Found unexpected empty split
+//│ ╙──
+//│ ╔══[ERROR] Scrutinee `y` has 1 missing case
+//│ ║  l.38: 	    y is Some and x is Some then 1
+//│ ║        	    ^
+//│ ╟── It can be module `None`
+//│ ║  l.37: 	    x is Some and y is None then 0
+//│ ╙──      	                       ^^^^
+//│ fun p: (Object & ~#Some | Some[anything], Some[anything]) -> (0 | 1)
 
 fun h(x, y) =
   if x is
     None then y
     let y_square = y * y
     Some(z) then z + y_square
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.80: 	  if x is
-//│ ║        	     ^^^^
-//│ ║  l.81: 	    None then y
-//│ ║        	^^^^^^^^^^^^^^^
-//│ ║  l.82: 	    let y_square = y * y
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.83: 	    Some(z) then z + y_square
-//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ h: (None | Some & {value: int}, int,) -> int
-//│  = [Function: h]
+//│ fun h: (None | Some[Int], Int) -> Int
 
 h(Some(5), 6)
-//│ res: int
-//│    = 41
+//│ Int
+//│ res
+//│     = 41
 
 fun h(x, y) =
   if x is
     None then y
     let y_square = y * y
     Some(y_square) then 0
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.102: 	  if x is
-//│ ║         	     ^^^^
-//│ ║  l.103: 	    None then y
-//│ ║         	^^^^^^^^^^^^^^^
-//│ ║  l.104: 	    let y_square = y * y
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.105: 	    Some(y_square) then 0
-//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ h: (None | Some, int & 'a,) -> (0 | 'a)
-//│  = [Function: h1]
+//│ fun h: forall 'a. (None | Some[anything], Int & 'a) -> (0 | 'a)
 
+:e
 fun f(a, y) =
   if a is
     Some(v) and v is
@@ -123,22 +74,13 @@ fun f(a, y) =
       let y = v + 1
       Right(x) then x + y
     else 0
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.120: 	  if a is
-//│ ║         	     ^^^^
-//│ ║  l.121: 	    Some(v) and v is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.122: 	      Left(x) then x
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.123: 	      let y = v + 1
-//│ ║         	^^^^^^^^^^^^^^^^^^^
-//│ ║  l.124: 	      Right(x) then x + y
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.125: 	    else 0
-//│ ╙──       	^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ f: (Some & {value: int} | ~Some, anything,) -> int
-//│  = [Function: f1]
+//│ ╔══[ERROR] Type mismatch in operator application:
+//│ ║  l.74: 	      let y = v + 1
+//│ ║        	              ^^^^^
+//│ ╟── reference of type `Right[?B]` is not an instance of type `Int`
+//│ ║  l.74: 	      let y = v + 1
+//│ ╙──      	              ^
+//│ fun f: forall 'a. (Object & ~#Some | Some[Int | Left['a] | Right[Int]], anything) -> (Int | 'a)
 
 :pe
 fun q(a) =
@@ -147,117 +89,67 @@ fun q(a) =
     let y = a + 1
     then y
 //│ ╔══[PARSE ERROR] Expected an expression; found a 'then'/'else' clause instead
-//│ ║  l.147: 	    let y = a + 1
-//│ ║         	            ^^^^^
-//│ ║  l.148: 	    then y
-//│ ╙──       	^^^^^^^^^^
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.145: 	  if a is
-//│ ║         	     ^^^^
-//│ ║  l.146: 	    Left(x) then x
-//│ ║         	^^^^^^^^^^^^^^^^^^
-//│ ║  l.147: 	    let y = a + 1
-//│ ║         	^^^^^^^^^^^^^^^^^
-//│ ║  l.148: 	    then y
-//│ ╙──       	^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ q: (Left & {leftValue: 'leftValue}) -> 'leftValue
-//│  = [Function: q1]
+//│ ║  l.89: 	    let y = a + 1
+//│ ║        	            ^^^^^
+//│ ║  l.90: 	    then y
+//│ ╙──      	^^^^^^^^^^
+//│ fun q: forall 'a. (Left['a] | Object & ~#Left) -> (() | 'a)
 
 class A()
 class B()
-//│ Defined class A
-//│ Defined class B
-//│ A: () -> A
-//│  = [Function: A1]
-//│ B: () -> B
-//│  = [Function: B1]
+//│ class A()
+//│ class B()
 
+:e
 fun w() =
   if
     A then "A"
     let y = 0
     B then "B"
     else "?"
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.178: 	    A then "A"
-//│ ║         	    ^^^^^^^^^^
-//│ ║  l.179: 	    let y = 0
-//│ ║         	^^^^^^^^^^^^^
-//│ ║  l.180: 	    B then "B"
-//│ ║         	^^^^^^^^^^^^^^
-//│ ║  l.181: 	    else "?"
-//│ ╙──       	^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ w: () -> ("?" | "A" | "B")
-//│  = [Function: w]
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.106: 	    A then "A"
+//│ ║         	    ^
+//│ ╙── reference of type `() -> A` is not an instance of type `Bool`
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.108: 	    B then "B"
+//│ ║         	    ^
+//│ ╙── reference of type `() -> B` is not an instance of type `Bool`
+//│ fun w: () -> ("?" | "A" | "B")
 
 w()
-//│ res: "?" | "A" | "B"
-//│    = '?'
+//│ "?" | "A" | "B"
+//│ res
+//│     = '?'
 
 fun i(x) =
   if x is
     A() then "A"
     let y = 0
     B() then "B"
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.200: 	  if x is
-//│ ║         	     ^^^^
-//│ ║  l.201: 	    A() then "A"
-//│ ║         	^^^^^^^^^^^^^^^^
-//│ ║  l.202: 	    let y = 0
-//│ ║         	^^^^^^^^^^^^^
-//│ ║  l.203: 	    B() then "B"
-//│ ╙──       	^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ i: (A | B) -> ("A" | "B")
-//│  = [Function: i]
+//│ fun i: (A | B) -> ("A" | "B")
 
 fun inc(x) = x + 1
-//│ inc: int -> int
-//│    = [Function: inc]
+//│ fun inc: Int -> Int
 
 fun qq(x, z) =
   if x ==
     let y = inc(z)
     y * y then 0
     else 0
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.222: 	  if x ==
-//│ ║         	     ^^^^
-//│ ║  l.223: 	    let y = inc(z)
-//│ ║         	^^^^^^^^^^^^^^^^^^
-//│ ║  l.224: 	    y * y then 0
-//│ ║         	^^^^^^^^^^^^^^^^
-//│ ║  l.225: 	    else 0
-//│ ╙──       	^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ qq: (number, int,) -> 0
-//│   = [Function: qq]
+//│ fun qq: (Num, Int) -> 0
 
 fun bruh(x) =
   if
     x == 0 then 0
     let y = 1
     else y
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.241: 	    x == 0 then 0
-//│ ║         	    ^^^^^^^^^^^^^
-//│ ║  l.242: 	    let y = 1
-//│ ║         	^^^^^^^^^^^^^
-//│ ║  l.243: 	    else y
-//│ ╙──       	^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ bruh: number -> (0 | 1)
-//│     = [Function: bruh]
+//│ fun bruh: Num -> (0 | 1)
 
 fun f1(x) = x + 1
 fun f2(x, y) = x + y
-//│ f1: int -> int
-//│   = [Function: f11]
-//│ f2: (int, int,) -> int
-//│   = [Function: f2]
+//│ fun f1: Int -> Int
+//│ fun f2: (Int, Int) -> Int
 
 fun ff(x) =
   if
@@ -267,246 +159,126 @@ fun ff(x) =
     z == 1 then 1
     z == 2 then 2
     else 0
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.264: 	    x == 0 then 0
-//│ ║         	    ^^^^^^^^^^^^^
-//│ ║  l.265: 	    let y = f1(x)
-//│ ║         	^^^^^^^^^^^^^^^^^
-//│ ║  l.266: 	    let z = f2(x, y)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.267: 	    z == 1 then 1
-//│ ║         	^^^^^^^^^^^^^^^^^
-//│ ║  l.268: 	    z == 2 then 2
-//│ ║         	^^^^^^^^^^^^^^^^^
-//│ ║  l.269: 	    else 0
-//│ ╙──       	^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ff: int -> (0 | 1 | 2)
-//│   = [Function: ff]
+//│ fun ff: Int -> (0 | 1 | 2)
 
+:e
+// FIXME: Should warn missing else branches.
 fun ip(y) =
   if q(y) and
     let z = inc(y)
     y == z * z then "bruh"
   else "rocks"
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.288: 	  if q(y) and
-//│ ║         	     ^^^^^^^^
-//│ ║  l.289: 	    let z = inc(y)
-//│ ║         	^^^^^^^^^^^^^^^^^^
-//│ ║  l.290: 	    y == z * z then "bruh"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.291: 	  else "rocks"
-//│ ╙──       	^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ip: nothing -> ("bruh" | "rocks")
-//│   = [Function: ip]
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.167: 	  if q(y) and
+//│ ║         	     ^^^^
+//│ ╟── undefined literal of type `()` is not an instance of type `Bool`
+//│ ║  l.90: 	    then y
+//│ ║        	          ^
+//│ ╟── but it flows into application with expected type `Bool`
+//│ ║  l.167: 	  if q(y) and
+//│ ╙──       	     ^^^^
+//│ fun ip: Int -> ("bruh" | "rocks")
 
 fun tr(x) =
   if x is
     Some(v) then v
     let tmp = 1
     None then tmp
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.306: 	  if x is
-//│ ║         	     ^^^^
-//│ ║  l.307: 	    Some(v) then v
-//│ ║         	^^^^^^^^^^^^^^^^^^
-//│ ║  l.308: 	    let tmp = 1
-//│ ║         	^^^^^^^^^^^^^^^
-//│ ║  l.309: 	    None then tmp
-//│ ╙──       	^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ tr: (None | Some & {value: 'value}) -> (1 | 'value)
-//│   = [Function: tr]
-
-class Pair(fst, snd)
-class List
-class Nil: List
-class Cons(head, tail): List
-//│ Defined class Pair
-//│ Defined class List
-//│ Defined class Nil
-//│ Defined class Cons
-//│ Pair: ('fst, 'snd,) -> (Pair & {fst: 'fst, snd: 'snd})
-//│     = [Function: Pair1]
-//│ List: () -> List
-//│     = [Function: List1]
-//│ Nil: () -> Nil
-//│    = [Function: Nil1]
-//│ Cons: ('head, 'tail,) -> (Cons & {head: 'head, tail: 'tail})
-//│     = [Function: Cons1]
-
-fun cat2(s, t) = concat(s)(t)
-fun cat3(a, b, c) = cat2(cat2(a, b), c)
-//│ cat2: (string, string,) -> string
-//│     = [Function: cat2]
-//│ cat3: (string, string, string,) -> string
-//│     = [Function: cat3]
-
-:js
+//│ fun tr: forall 'a. (None | Some['a]) -> (1 | 'a)
+
+class Pair[A, B](fst: A, snd: B)
+abstract class List[out A]: Nil | Cons[A]
+module Nil extends List[nothing]
+class Cons[out A](head: A, tail: List[A]) extends List[A]
+//│ class Pair[A, B](fst: A, snd: B)
+//│ abstract class List[A]: Cons[A] | Nil
+//│ module Nil extends List
+//│ class Cons[A](head: A, tail: List[A]) extends List
+
+fun (::) cons(h, t) = Cons(h, t)
+fun (++) strcat(a, b) = concat(a)(b)
+//│ fun (::) cons: forall 'A. ('A, List['A]) -> Cons['A]
+//│ fun (++) strcat: (Str, Str) -> Str
+
 fun showList(xs) =
   if xs is
     Nil              then ""
-    Cons(head, Nil())  then toString(head)
-    Cons(head, tail) then cat3(toString(head), ", ", showList(tail))
-//│ // Prelude
-//│ function toString(x) {
-//│   return String(x);
-//│ }
-//│ // Query 1
-//│ globalThis.showList = function showList(xs) {
-//│   return ((() => {
-//│     let a;
-//│     return (a = xs, a instanceof Nil ? "" : a instanceof Cons ? ((head) => ((tmp0) => ((tail) => tmp0 instanceof Nil ? toString(head) : cat3(toString(head), ", ", showList(tail)))(xs.tail))(xs.tail))(xs.head) : (() => {
-//│       throw new Error("non-exhaustive case expression");
-//│     })());
-//│   })());
-//│ };
-//│ // End of generated code
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.349: 	  if xs is
-//│ ║         	     ^^^^^
-//│ ║  l.350: 	    Nil              then ""
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.351: 	    Cons(head, Nil())  then toString(head)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.352: 	    Cons(head, tail) then cat3(toString(head), ", ", showList(tail))
-//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ showList: (Cons & 'a | Nil) -> string
-//│   where
-//│     'a <: {head: anything, tail: Cons & 'a | Nil}
-//│         = [Function: showList]
-
-let zeroToThree = Cons(0, Cons(1, Cons(2, Cons(3, Nil()))))
-//│ zeroToThree: Cons & {
-//│   head: 0,
-//│   tail: Cons & {head: 1, tail: Cons & {head: 2, tail: Cons & {head: 3, tail: Nil}}}
-//│ }
-//│            = Cons {
-//│                head: 0,
-//│                tail: Cons { head: 1, tail: Cons { head: 2, tail: [Cons] } }
-//│              }
+    Cons(head, Nil)  then toString(head)
+    Cons(head, tail) then toString(head) ++ ", " ++ showList(tail)
+//│ fun showList: (Cons[anything] | Nil) -> Str
+
+let zeroToThree = 0 :: 1 :: 2 :: 3 :: Nil
+//│ let zeroToThree: Cons[0 | 1 | 2 | 3]
+//│ zeroToThree
+//│             = Cons {}
 
 showList(zeroToThree)
-//│ res: string
-//│    = '0, 1, 2, 3'
+//│ Str
+//│ res
+//│     = '0, 1, 2, 3'
+
+fun evenness(x) = if x % 2 is 0 then Left(x) else Right(x)
+//│ fun evenness: forall 'A 'B. (Int & 'A & 'B) -> (Left['A] | Right['B])
 
 fun mapPartition(f, xs) =
   if xs is
-    Nil then Pair(Nil(), Nil())
-    Cons(x, xs) and f(x) is
-      let res = mapPartition(f, xs)
-      let l = res.fst
-      let r = res.snd
-      Left(v)  then Pair(Cons(v, l), r)
+    Nil then Pair(Nil, Nil)
+    Cons(x, xs) and mapPartition(f, xs) is Pair(l, r) and f(x) is
+      Left(v) then Pair(Cons(v, l), r)
       Right(v) then Pair(l, Cons(v, r))
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.397: 	  if xs is
-//│ ║         	     ^^^^^
-//│ ║  l.398: 	    Nil then Pair(Nil(), Nil())
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.399: 	    Cons(x, xs) and f(x) is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.400: 	      let res = mapPartition(f, xs)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.401: 	      let l = res.fst
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.402: 	      let r = res.snd
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.403: 	      Left(v)  then Pair(Cons(v, l), r)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.404: 	      Right(v) then Pair(l, Cons(v, r))
-//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ mapPartition: ('head -> (Left & {leftValue: 'leftValue} | Right & {rightValue: 'rightValue}), Cons & 'a | Nil,) -> (Pair & {fst: forall 'b 'c. Nil | 'c | 'b, snd: Nil | Cons & {head: 'rightValue, tail: Nil}})
+//│ fun mapPartition: forall 'A 'A0 'B 'A1 'a 'B0 'A2. ('a -> (Left['A2] | Right['A]), Cons['a] | Nil) -> Pair[in 'A0 & 'A1 out 'A1 | Cons['A2], in 'B0 & 'B out 'B | Cons['A]]
 //│   where
-//│     'b :> Cons & {head: 'leftValue, tail: forall 'd. Nil | 'd}
-//│     'c :> Cons & {head: 'leftValue, tail: forall 'd. Nil | 'd}
-//│     'a <: {head: 'head, tail: Cons & 'a | Nil}
-//│             = [Function: mapPartition]
-
-mapPartition(x => (if x % 2 == 0 then Left(x) else Right(x)), zeroToThree)
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.430: 	mapPartition(x => (if x % 2 == 0 then Left(x) else Right(x)), zeroToThree)
-//│ ╙──       	                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ res: Pair & {
-//│   fst: forall 'a 'b. Nil | 'b | 'a,
-//│   snd: Nil | Cons & {head: 0 | 1 | 2 | 3, tail: Nil}
-//│ }
-//│ where
-//│   'a :> Cons & {head: 0 | 1 | 2 | 3, tail: forall 'c. Nil | 'c}
-//│   'b :> Cons & {head: 0 | 1 | 2 | 3, tail: forall 'c. Nil | 'c}
-//│    = Pair {
-//│        fst: Cons { head: 0, tail: Cons { head: 2, tail: Nil {} } },
-//│        snd: Cons { head: 1, tail: Cons { head: 3, tail: Nil {} } }
-//│      }
+//│     'B0 <: List['A] & 'B
+//│     'B :> Cons['A] | Nil
+//│        <: 'B0
+//│     'A0 <: List['A2] & 'A1
+//│     'A1 :> Cons['A2] | Nil
+//│         <: 'A0
+
+if (mapPartition of evenness, zeroToThree) is
+  Pair(even, odd) then
+    log of showList(even)
+    log of showList(odd)
+//│ ()
+//│ res
+//│     = undefined
+//│ // Output
+//│ 0, 2
+//│ 1, 3
 
 // This should be the desugaring of the above:
-fun mapPartition2(f, xs) =
+fun mapPartition'(f, xs) =
   if xs is
-    Nil then Pair(Nil(), Nil())
-    Cons(x, xs) and mapPartition(f, xs) is res and res.fst is l and res.snd is r and f(x) is
-      Left(v)  then Pair(Cons(v, l), r)
-      Right(v) then Pair(l, Cons(v, r))
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.449: 	  if xs is
-//│ ║         	     ^^^^^
-//│ ║  l.450: 	    Nil then Pair(Nil(), Nil())
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.451: 	    Cons(x, xs) and mapPartition(f, xs) is res and res.fst is l and res.snd is r and f(x) is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.452: 	      Left(v)  then Pair(Cons(v, l), r)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.453: 	      Right(v) then Pair(l, Cons(v, r))
-//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ mapPartition2: ('head -> (Left & {leftValue: 'leftValue} | Right & {rightValue: 'rightValue}) & 'head0 -> (Left & {leftValue: 'leftValue0} | Right & {rightValue: 'rightValue0}), Cons & {head: 'head0, tail: Cons & 'a | Nil} | Nil,) -> (Pair & {
-//│   fst: forall 'b. Cons & {
-//│     head: 'leftValue0,
-//│     tail: forall 'c. Nil | 'c | Cons & {head: 'leftValue, tail: forall 'fst. Nil | 'fst}
-//│   } | Nil | 'b | Cons & {head: 'leftValue, tail: forall 'fst0. Nil | 'fst0},
-//│   snd: Cons & {head: 'rightValue0, tail: Nil | Cons & {head: 'rightValue, tail: Nil}} | Nil | Cons & {head: 'rightValue, tail: Nil}
-//│ })
-//│ where
-//│   'b :> Cons & {head: 'leftValue, tail: forall 'fst0. Nil | 'fst0}
-//│   'fst0 :> forall 'd. Nil | 'd
-//│   'd :> Cons & {head: 'leftValue, tail: forall 'fst0. Nil | 'fst0}
-//│   'c :> Cons & {head: 'leftValue, tail: forall 'fst. Nil | 'fst}
-//│   'fst :> forall 'e. Nil | 'e
-//│   'e :> Cons & {head: 'leftValue, tail: forall 'fst. Nil | 'fst}
-//│   'a <: {head: 'head, tail: Cons & 'a | Nil}
-//│              = [Function: mapPartition2]
-
-mapPartition2(x => (if x % 2 == 0 then Left(x) else Right(x)), zeroToThree)
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.483: 	mapPartition2(x => (if x % 2 == 0 then Left(x) else Right(x)), zeroToThree)
-//│ ╙──       	                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ res: Pair & {
-//│   fst: forall 'a. Cons & {
-//│     head: 0,
-//│     tail: forall 'b. Nil | 'b | Cons & {head: 1 | 2 | 3, tail: forall 'fst. Nil | 'fst}
-//│   } | Nil | 'a | Cons & {head: 1 | 2 | 3, tail: forall 'fst0. Nil | 'fst0},
-//│   snd: Cons & {head: 0, tail: Nil | Cons & {head: 1 | 2 | 3, tail: Nil}} | Nil | Cons & {head: 1 | 2 | 3, tail: Nil}
-//│ }
-//│ where
-//│   'a :> Cons & {head: 1 | 2 | 3, tail: forall 'fst0. Nil | 'fst0}
-//│   'fst0 :> forall 'c. Nil | 'c
-//│   'c :> Cons & {head: 1 | 2 | 3, tail: forall 'fst0. Nil | 'fst0}
-//│   'b :> Cons & {head: 1 | 2 | 3, tail: forall 'fst. Nil | 'fst}
-//│   'fst :> forall 'd. Nil | 'd
-//│   'd :> Cons & {head: 1 | 2 | 3, tail: forall 'fst. Nil | 'fst}
-//│    = Pair {
-//│        fst: Cons { head: 0, tail: Cons { head: 2, tail: Nil {} } },
-//│        snd: Cons { head: 1, tail: Cons { head: 3, tail: Nil {} } }
-//│      }
-
-fun log(x) = ()
-//│ log: anything -> undefined
-//│    = [Function: log]
+    Nil then Pair(Nil, Nil)
+    Cons(x, xs) then
+      let temp0 = mapPartition'(f, xs)
+      let temp1 = Pair.unapply(temp0)
+      let l = temp1.0
+      let r = temp1.1
+      if f(x) is
+        Left(v) then Pair(Cons(v, l), r)
+        Right(v) then Pair(l, Cons(v, r))
+//│ fun mapPartition': forall 'a 'A '#fst 'A0 'B 'A1 '#snd. ('a -> (Left['A1] | Right['A0]), Cons['a] | Nil) -> Pair[in '#fst & 'A out 'A | Cons['A1], in '#snd & 'B out 'B | Cons['A0]]
+//│   where
+//│     '#snd <: List['A0] & 'B
+//│     'B :> Cons['A0] | Nil
+//│        <: '#snd
+//│     '#fst <: List['A1] & 'A
+//│     'A :> Cons['A1] | Nil
+//│        <: '#fst
+
+if (mapPartition' of evenness, zeroToThree) is
+  Pair(even, odd) then
+    log of showList(even)
+    log of showList(odd)
+//│ ()
+//│ res
+//│     = undefined
+//│ // Output
+//│ 0, 2
+//│ 1, 3
+
+// This is a very interesting side-effect example!
 
 fun mn(a) =
   if a is
@@ -518,41 +290,25 @@ fun mn(a) =
         2 then "b is 3"
       Right(b) then "right-defined"
     None       then "undefined"
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.512: 	  if a is
-//│ ║         	     ^^^^
-//│ ║  l.513: 	    Some(x) and x is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.514: 	      Left(b) and b is
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.515: 	        0 then "b is 1"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.516: 	        let _ = log(b)
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.517: 	        1 then "b is 2"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.518: 	        2 then "b is 3"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.519: 	      Right(b) then "right-defined"
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.520: 	    None       then "undefined"
-//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ mn: (None | Some & {value: Left & {leftValue: 0 | 1 | 2} | Right}) -> ("b is 1" | "b is 2" | "b is 3" | "right-defined" | "undefined")
-//│   = [Function: mn]
-
-mn(None())
-mn(Some(Left(0)))
-mn(Some(Left(1)))
-mn(Some(Left(2)))
-mn(Some(Right(())))
-//│ res: "b is 1" | "b is 2" | "b is 3" | "right-defined" | "undefined"
-//│    = 'undefined'
-//│ res: "b is 1" | "b is 2" | "b is 3" | "right-defined" | "undefined"
-//│    = 'b is 1'
-//│ res: "b is 1" | "b is 2" | "b is 3" | "right-defined" | "undefined"
-//│    = 'b is 2'
-//│ res: "b is 1" | "b is 2" | "b is 3" | "right-defined" | "undefined"
-//│    = 'b is 3'
-//│ res: "b is 1" | "b is 2" | "b is 3" | "right-defined" | "undefined"
-//│    = 'right-defined'
+//│ fun mn: (None | Some[Left[0 | 1 | 2] | Right[anything]]) -> ("b is 1" | "b is 2" | "b is 3" | "right-defined" | "undefined")
+
+mn of None
+mn of Some of Left of 0
+mn of Some of Left of 1
+mn of Some of Left of 2
+mn of Some of Right of ()
+//│ "b is 1" | "b is 2" | "b is 3" | "right-defined" | "undefined"
+//│ res
+//│     = 'undefined'
+//│ res
+//│     = 'b is 1'
+//│ res
+//│     = 'b is 2'
+//│ // Output
+//│ 1
+//│ res
+//│     = 'b is 3'
+//│ // Output
+//│ 2
+//│ res
+//│     = 'right-defined'
diff --git a/shared/src/test/diff/ucs/NestedBranches.mls b/shared/src/test/diff/ucs/NestedBranches.mls
index 5add07462d..7cb7bd627a 100644
--- a/shared/src/test/diff/ucs/NestedBranches.mls
+++ b/shared/src/test/diff/ucs/NestedBranches.mls
@@ -25,7 +25,10 @@ fun optionApply(x, y, f) =
     None then None
 //│ fun optionApply: forall 'a 'b 'A. (None | Some['a], None | Some['b], ('a, 'b) -> 'A) -> (None | Some['A])
 
-let zeroToThree = Cons(0, Cons(1, Cons(2, Cons(3, Nil))))
+fun (::) cons(h, t) = Cons(h, t)
+//│ fun (::) cons: forall 'A. ('A, Cons['A] | Nil) -> Cons['A]
+
+let zeroToThree = 0 :: 1 :: 2 :: 3 :: Nil
 //│ let zeroToThree: Cons[0 | 1 | 2 | 3]
 //│ zeroToThree
 //│             = Cons {}
@@ -33,61 +36,25 @@ let zeroToThree = Cons(0, Cons(1, Cons(2, Cons(3, Nil))))
 fun f(x) = if x % 2 == 0 then Left(x) else Right(x)
 //│ fun f: forall 'A. (Int & 'A) -> (Left['A] | Right['A])
 
-// FIXME: Looks like a transformation bug.
+
 fun mapPartition(f, xs) = if xs is
   Nil then Pair(Nil, Nil)
   Cons(x, xs) and mapPartition(f, xs) is Pair(l, r) and f(x) is
     Left(v)  then Pair(Cons(v, l), r)
     Right(v) then Pair(l, Cons(v, r))
-//│ ╔══[ERROR] identifier `l` not found
-//│ ║  l.40: 	    Left(v)  then Pair(Cons(v, l), r)
-//│ ╙──      	                               ^
-//│ ╔══[ERROR] identifier `r` not found
-//│ ║  l.40: 	    Left(v)  then Pair(Cons(v, l), r)
-//│ ╙──      	                                   ^
-//│ ╔══[ERROR] identifier `l` not found
-//│ ║  l.41: 	    Right(v) then Pair(l, Cons(v, r))
-//│ ╙──      	                       ^
-//│ ╔══[ERROR] identifier `r` not found
-//│ ║  l.41: 	    Right(v) then Pair(l, Cons(v, r))
-//│ ╙──      	                                  ^
-//│ ╔══[ERROR] identifier not found: l
-//│ ║  l.40: 	    Left(v)  then Pair(Cons(v, l), r)
-//│ ╙──      	                               ^
-//│ ╔══[ERROR] identifier not found: r
-//│ ║  l.40: 	    Left(v)  then Pair(Cons(v, l), r)
-//│ ╙──      	                                   ^
-//│ ╔══[ERROR] identifier not found: l
-//│ ║  l.41: 	    Right(v) then Pair(l, Cons(v, r))
-//│ ╙──      	                       ^
-//│ ╔══[ERROR] identifier not found: r
-//│ ║  l.41: 	    Right(v) then Pair(l, Cons(v, r))
-//│ ╙──      	                                  ^
-//│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.39: 	  Cons(x, xs) and mapPartition(f, xs) is Pair(l, r) and f(x) is
-//│ ║        	                                                        ^^^^^^^
-//│ ║  l.40: 	    Left(v)  then Pair(Cons(v, l), r)
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.41: 	    Right(v) then Pair(l, Cons(v, r))
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╙── expression of type `Bool` is not an instance of type `true`
-//│ fun mapPartition: forall 'a 'A 'A0. ('a -> (Left['A] | Right['A0]), Cons['a] | Nil) -> Pair[Cons['A] | Nil | error, Cons['A0] | Nil | error]
-//│ Code generation encountered an error:
-//│   unresolved symbol l
-
-:re
+//│ fun mapPartition: forall 'A 'A0 'a. ('a -> (Left['A] | Right['A0]), Cons['a] | Nil) -> Pair[Cons['A] | Nil, Cons['A0] | Nil]
+
+
 mapPartition(x => Left(x + 1), zeroToThree)
-//│ Pair[Cons[Int] | Nil | error, Cons[nothing] | Nil | error]
+//│ Pair[Cons[Int] | Nil, Cons[nothing] | Nil]
 //│ res
-//│ Runtime error:
-//│   ReferenceError: mapPartition is not defined
+//│     = Pair {}
+
 
-:re
 mapPartition(f, zeroToThree)
-//│ Pair[Cons[0 | 1 | 2 | 3] | Nil | error, Cons[0 | 1 | 2 | 3] | Nil | error]
+//│ Pair[Cons[0 | 1 | 2 | 3] | Nil, Cons[0 | 1 | 2 | 3] | Nil]
 //│ res
-//│ Runtime error:
-//│   ReferenceError: mapPartition is not defined
+//│     = Pair {}
 
 
 fun mapPartition(f, xs) = if xs is
@@ -122,55 +89,18 @@ mapPartition(f, zeroToThree)
 //│ res
 //│     = Pair {}
 
-:e // TODO make this one work (needs tuple support)
 fun mapPartition(f, xs) = if xs is
   Nil then [Nil, Nil]
   Cons(x, xs) and mapPartition(f, xs) is [l, r] and f(x) is
     Left(v)  then [Cons(v, l), r]
     Right(v) then [l, Cons(v, r)]
-//│ ╔══[ERROR] identifier `l` not found
-//│ ║  l.129: 	    Left(v)  then [Cons(v, l), r]
-//│ ╙──       	                           ^
-//│ ╔══[ERROR] identifier `r` not found
-//│ ║  l.129: 	    Left(v)  then [Cons(v, l), r]
-//│ ╙──       	                               ^
-//│ ╔══[ERROR] identifier `l` not found
-//│ ║  l.130: 	    Right(v) then [l, Cons(v, r)]
-//│ ╙──       	                   ^
-//│ ╔══[ERROR] identifier `r` not found
-//│ ║  l.130: 	    Right(v) then [l, Cons(v, r)]
-//│ ╙──       	                              ^
-//│ ╔══[ERROR] identifier not found: l
-//│ ║  l.129: 	    Left(v)  then [Cons(v, l), r]
-//│ ╙──       	                           ^
-//│ ╔══[ERROR] identifier not found: r
-//│ ║  l.129: 	    Left(v)  then [Cons(v, l), r]
-//│ ╙──       	                               ^
-//│ ╔══[ERROR] identifier not found: l
-//│ ║  l.130: 	    Right(v) then [l, Cons(v, r)]
-//│ ╙──       	                   ^
-//│ ╔══[ERROR] identifier not found: r
-//│ ║  l.130: 	    Right(v) then [l, Cons(v, r)]
-//│ ╙──       	                              ^
-//│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.128: 	  Cons(x, xs) and mapPartition(f, xs) is [l, r] and f(x) is
-//│ ║         	                                                    ^^^^^^^
-//│ ║  l.129: 	    Left(v)  then [Cons(v, l), r]
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.130: 	    Right(v) then [l, Cons(v, r)]
-//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╙── expression of type `Bool` is not an instance of type `true`
-//│ fun mapPartition: forall 'a 'A 'A0. ('a -> (Left['A] | Right['A0]), Cons['a] | Nil) -> [Cons['A] | Nil | error, Cons['A0] | Nil | error]
-//│ Code generation encountered an error:
-//│   unresolved symbol l
-
-:re // TODO
+//│ fun mapPartition: forall 'a 'A 'A0. ('a -> (Left['A] | Right['A0]), Cons['a] | Nil) -> [Cons['A] | Nil, Cons['A0] | Nil]
+
+
 mapPartition(f, zeroToThree)
-//│ [Cons[0 | 1 | 2 | 3] | Nil | error, Cons[0 | 1 | 2 | 3] | Nil | error]
+//│ [Cons[0 | 1 | 2 | 3] | Nil, Cons[0 | 1 | 2 | 3] | Nil]
 //│ res
-//│ Runtime error:
-//│   ReferenceError: mapPartition3 is not defined
-
+//│     = [ Cons {}, Cons {} ]
 
 // * Vertical alignment is not allowed! (good)
 :pe
@@ -182,20 +112,20 @@ fun mapPartition(f, xs) = if xs is
           and f(x) is Left(v)  then [Cons(v, l), r]
                       Right(v) then [l, Cons(v, r)]
 //│ ╔══[PARSE ERROR] Unexpected 'then' keyword here
-//│ ║  l.183: 	                      Right(v) then [l, Cons(v, r)]
+//│ ║  l.113: 	                      Right(v) then [l, Cons(v, r)]
 //│ ╙──       	                               ^^^^
 //│ ╔══[WARNING] Paren-less applications should use the 'of' keyword
-//│ ║  l.182: 	          and f(x) is Left(v)  then [Cons(v, l), r]
+//│ ║  l.112: 	          and f(x) is Left(v)  then [Cons(v, l), r]
 //│ ║         	                                    ^^^^^^^^^^^^^^^
-//│ ║  l.183: 	                      Right(v) then [l, Cons(v, r)]
+//│ ║  l.113: 	                      Right(v) then [l, Cons(v, r)]
 //│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.182: 	          and f(x) is Left(v)  then [Cons(v, l), r]
+//│ ║  l.112: 	          and f(x) is Left(v)  then [Cons(v, l), r]
 //│ ║         	                                    ^^^^^^^^^^^^^^^
-//│ ║  l.183: 	                      Right(v) then [l, Cons(v, r)]
+//│ ║  l.113: 	                      Right(v) then [l, Cons(v, r)]
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── tuple literal of type `[?a, ?b]` is not a function
-//│ ║  l.182: 	          and f(x) is Left(v)  then [Cons(v, l), r]
+//│ ║  l.112: 	          and f(x) is Left(v)  then [Cons(v, l), r]
 //│ ╙──       	                                    ^^^^^^^^^^^^^^^
 //│ fun mapPartition: forall 'a. ('a -> Left[anything], Cons['a] | Nil) -> (error | [Nil, Nil])
 
diff --git a/shared/src/test/diff/ucs/OverlappedBranches.mls b/shared/src/test/diff/ucs/OverlappedBranches.mls
index 657ca31c59..627bb38daf 100644
--- a/shared/src/test/diff/ucs/OverlappedBranches.mls
+++ b/shared/src/test/diff/ucs/OverlappedBranches.mls
@@ -1,63 +1,33 @@
-:NewParser
+:PreTyper
 
-class Base
-class Derived1 extends Base
-class Derived2 extends Base
-class Derived3 extends Derived2
-//│ Defined class Base
-//│ Defined class Derived1
-//│ Defined class Derived2
-//│ Defined class Derived3
-//│ Base: () -> Base
-//│     = [Function: Base1]
-//│ Derived1: () -> Derived1
-//│         = [Function: Derived11]
-//│ Derived2: () -> Derived2
-//│         = [Function: Derived21]
-//│ Derived3: () -> Derived3
-//│         = [Function: Derived31]
+class Base()
+class Derived1() extends Base()
+class Derived2() extends Base()
+class Derived3() extends Derived2()
+//│ class Base()
+//│ class Derived1() extends Base
+//│ class Derived2() extends Base
+//│ class Derived3() extends Base, Derived2
 
 // The very basic case.
-:w
+// :w
+// Should warn about that the last two cases are unreachable.
 fun f1(x) = if x is
   Base then "b"
   Derived1 then "d1"
   Derived2 then "d2"
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.22: 	fun f1(x) = if x is
-//│ ║        	               ^^^^
-//│ ║  l.23: 	  Base then "b"
-//│ ║        	^^^^^^^^^^^^^^^^
-//│ ║  l.24: 	  Derived1 then "d1"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.25: 	  Derived2 then "d2"
-//│ ╙──      	^^^^^^^^^^^^^^^^^^^^
-//│ ╔══[WARNING] Found a duplicated branch
-//│ ╟── This branch
-//│ ║  l.24: 	  Derived1 then "d1"
-//│ ║        	                ^^^^
-//│ ╟── is subsumed by the branch here.
-//│ ║  l.23: 	  Base then "b"
-//│ ╙──      	            ^^^
-//│ ╔══[WARNING] Found a duplicated branch
-//│ ╟── This branch
-//│ ║  l.25: 	  Derived2 then "d2"
-//│ ║        	                ^^^^
-//│ ╟── is subsumed by the branch here.
-//│ ║  l.23: 	  Base then "b"
-//│ ╙──      	            ^^^
-//│ f1: Base -> "b"
-//│   = [Function: f1]
+//│ fun f1: Base -> "b"
 
 f1(Base())
 f1(Derived1())
 f1(Derived2())
-//│ res: "b"
-//│    = 'b'
-//│ res: "b"
-//│    = 'b'
-//│ res: "b"
-//│    = 'b'
+//│ "b"
+//│ res
+//│     = 'b'
+//│ res
+//│     = 'b'
+//│ res
+//│     = 'b'
 
 // Decision paths:
 // + «x is Base» and «p (x,)» => "b and p"
@@ -84,38 +54,28 @@ fun f2(x, p) = if x is
   Derived1 then "d1"
   Derived2 then "d2"
   else "otherwise"
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.82: 	fun f2(x, p) = if x is
-//│ ║        	                  ^^^^
-//│ ║  l.83: 	  Base and p(x) then "b and p"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.84: 	  Derived1 then "d1"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.85: 	  Derived2 then "d2"
-//│ ║        	^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.86: 	  else "otherwise"
-//│ ╙──      	^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ f2: (Base & 'a | ~Base, 'a -> anything,) -> ("b and p" | "d1" | "d2" | "otherwise")
-//│   = [Function: f2]
+//│ fun f2: forall 'a. ('a & (Base & ~#Derived1 | Derived1), (Base & 'a) -> Bool) -> ("b and p" | "d1" | "d2" | "otherwise")
 
 f2(Base(), _ => true) // => b and p
 f2(Base(), _ => false) // otherwise
-//│ res: "b and p" | "d1" | "d2" | "otherwise"
-//│    = 'b and p'
-//│ res: "b and p" | "d1" | "d2" | "otherwise"
-//│    = 'otherwise'
+//│ "b and p" | "d1" | "d2" | "otherwise"
+//│ res
+//│     = 'b and p'
+//│ res
+//│     = 'otherwise'
 
 f2(Derived1(), _ => true) // => b and p
 f2(Derived2(), _ => true) // => b and p
-//│ res: "b and p" | "d1" | "d2" | "otherwise"
-//│    = 'b and p'
-//│ res: "b and p" | "d1" | "d2" | "otherwise"
-//│    = 'b and p'
+//│ "b and p" | "d1" | "d2" | "otherwise"
+//│ res
+//│     = 'b and p'
+//│ res
+//│     = 'b and p'
 
 f2(Derived1(), _ => false) // => d1
 f2(Derived2(), _ => false) // => d2
-//│ res: "b and p" | "d1" | "d2" | "otherwise"
-//│    = 'd1'
-//│ res: "b and p" | "d1" | "d2" | "otherwise"
-//│    = 'd2'
+//│ "b and p" | "d1" | "d2" | "otherwise"
+//│ res
+//│     = 'd1'
+//│ res
+//│     = 'd2'
diff --git a/todo.md b/todo.md
index cf7fac18dc..0ecfaa74d9 100644
--- a/todo.md
+++ b/todo.md
@@ -55,7 +55,7 @@ problems located by test cases.
 - [x] shared/src/test/diff/nu/LitMatch.mls
 - [x] shared/src/test/diff/nu/MissingTypeArg.mls
 - [x] shared/src/test/diff/nu/NamedArgs.mls
-- [ ] shared/src/test/diff/nu/New.mls **OLD**
+- [x] shared/src/test/diff/nu/New.mls **OLD**
 - [x] shared/src/test/diff/nu/NewNew.mls
 - [x] shared/src/test/diff/nu/Object.mls
 - [x] shared/src/test/diff/nu/OpLam.mls
@@ -73,7 +73,7 @@ problems located by test cases.
 - [x] shared/src/test/diff/nu/UndefMatching.mls
 - [x] shared/src/test/diff/nu/WeirdUnions.mls
 - [x] shared/src/test/diff/nu/i180.mls
-- [ ] shared/src/test/diff/nu/repro0.mls
+- [x] shared/src/test/diff/nu/repro0.mls
       - `PreTyper` does not accept top-level `val` bindings.
 - [x] shared/src/test/diff/nu/repro1.mls
 - [x] shared/src/test/diff/nu/repro_EvalNegNeg.mls
@@ -86,27 +86,43 @@ problems located by test cases.
 - [x] shared/src/test/diff/ucs/CrossBranchCapture.mls
       Fix the mentioned problems.
       TODO: Warn duplicated pattern bindings.
-- [ ] shared/src/test/diff/ucs/DirectLines.mls **OLD**
+- [x] shared/src/test/diff/ucs/DirectLines.mls **OLD**
+      TODO: Warn duplicated else branches.
 - [x] shared/src/test/diff/ucs/ElseIf.mls
-- [ ] shared/src/test/diff/ucs/ErrorMessage.mls **OLD**
+- [x] shared/src/test/diff/ucs/ErrorMessage.mls **OLD**
 - [x] shared/src/test/diff/ucs/Exhaustiveness.mls
-- [ ] shared/src/test/diff/ucs/Humiliation.mls **OLD**
+- [x] shared/src/test/diff/ucs/Humiliation.mls **OLD**
+      TODO: Improve scrutinee name display.
+      Generated names should be polished.
 - [x] shared/src/test/diff/ucs/Hygiene.mls
       Problem fixed!
 - [ ] shared/src/test/diff/ucs/HygienicBindings.mls
-- [ ] shared/src/test/diff/ucs/InterleavedLet.mls **OLD**
+      We should fix the shadowing parameters.
+- [x] shared/src/test/diff/ucs/InterleavedLet.mls **OLD**
+      The transformation cannot handle the following case.
+      ```
+      fun mapPartition2(f, xs) =
+        if xs is
+        Nil then Pair(Nil, Nil)
+        Cons(x, xs) and mapPartition(f, xs) is Pair(l, r) and f(x) is
+              Left(v)  then Pair(Cons(v, l), r)
+              Right(v) then Pair(l, Cons(v, r))
+      ```
+      To be specific, `Cons(x, xs) and mapPartition(f, xs) is Pair(l, r)` are
+      not separated. I re-implemented `splitAnd` function.
 - [x] shared/src/test/diff/ucs/JSON.mls
       Deleted. This one is not completed and we have a new version.
 - [x] shared/src/test/diff/ucs/LeadingAnd.mls
 - [x] shared/src/test/diff/ucs/LitUCS.mls
 - [x] shared/src/test/diff/ucs/MultiwayIf.mls
-- [ ] shared/src/test/diff/ucs/NestedBranches.mls
+- [x] shared/src/test/diff/ucs/NestedBranches.mls
       Found a bug in transformation.
 - [x] shared/src/test/diff/ucs/NestedOpSplits.mls
 - [x] shared/src/test/diff/ucs/NestedPattern.mls
 - [x] shared/src/test/diff/ucs/NuPlainConditionals.mls
 - [x] shared/src/test/diff/ucs/Or.mls
-- [ ] shared/src/test/diff/ucs/OverlappedBranches.mls **OLD**
+- [x] shared/src/test/diff/ucs/OverlappedBranches.mls **OLD**
+      Should report unreachable cases.
 - [x] shared/src/test/diff/ucs/ParseFailures.mls
 - [x] shared/src/test/diff/ucs/PlainConditionals.mls
       Maybe we should keep this old one...
@@ -115,7 +131,7 @@ problems located by test cases.
       Remove a `???` and raise error during transformation.
 - [x] shared/src/test/diff/ucs/SplitAfterOp.mls
       Wrap tests in functions so that errors are clearer.
-- [ ] shared/src/test/diff/ucs/SplitAnd.mls
+- [x] shared/src/test/diff/ucs/SplitAnd.mls
       Should report missing else branches.
 - [x] shared/src/test/diff/ucs/SplitAroundOp.mls
 - [x] shared/src/test/diff/ucs/SplitBeforeOp.mls

From 4154157e486d0c6f606c6b719fd0d077a096ceb9 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sun, 14 Jan 2024 20:16:12 +0800
Subject: [PATCH 061/147] Clean up the last tests

---
 .../scala/mlscript/pretyper/PreTyper.scala    |  41 +++---
 shared/src/test/diff/ucs/TrivialIf.mls        | 132 +++++++-----------
 shared/src/test/diff/ucs/WeirdSplit.mls       |  71 +++-------
 shared/src/test/diff/ucs/Wildcard.mls         |  32 +----
 todo.md                                       |  26 +++-
 5 files changed, 107 insertions(+), 195 deletions(-)

diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index 903b216a98..a247e7faf6 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -264,23 +264,7 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
     trace(s"process <== $name: ${typingUnit.describe}") {
       traverseStatements(typingUnit.entities, name, scope)
     }({ case (scope, contents) => s"process ==> ${scope.showLocalSymbols}" })
-}
-
-object PreTyper {
-
-  def extractSuperTypes(parents: Ls[Term]): Ls[Var] = {
-    @tailrec
-    def rec(results: Ls[Var], waitlist: Ls[Term]): Ls[Var] =
-      waitlist match {
-        case Nil => results.reverse
-        case (nme: Var) :: tail => rec(nme :: results, tail)
-        case (TyApp(ty, _)) :: tail => rec(results, ty :: tail)
-        case (App(term, Tup(_))) :: tail => rec(results, term :: tail)
-        case other :: _ => println(s"Unknown parent type: $other"); ???
-      }
-    rec(Nil, parents)
-  }
-
+  
   /**
     * Extract types in class signatures. For example, for this piece of code
     * ```mls
@@ -291,17 +275,36 @@ object PreTyper {
     * @param ty a type obtained from `NuTypeDef.sig`
     * @return a list of type names, without any p
     */
-  def extractSignatureTypes(ty: Type): Ls[TypeName] = {
+  private def extractSignatureTypes(ty: Type): Ls[TypeName] = {
     @tailrec
     def rec(acc: Ls[TypeName], ty: Type): Ls[TypeName] = ty match {
       case tn: TypeName => tn :: acc
       case AppliedType(tn: TypeName, _) => tn :: acc
       case Union(lhs, tn: TypeName) => rec(tn :: acc, lhs)
       case Union(lhs, AppliedType(tn: TypeName, _)) => rec(tn :: acc, lhs)
-      case other => println(s"Unknown type in signature: $other"); ???
+      case other =>
+        // Let's not raise warning for now.
+        // raiseWarning(msg"unknown type in signature" -> other.toLoc)
+        Nil
     }
     rec(Nil, ty).reverse
   }
+}
+
+object PreTyper {
+
+  def extractSuperTypes(parents: Ls[Term]): Ls[Var] = {
+    @tailrec
+    def rec(results: Ls[Var], waitlist: Ls[Term]): Ls[Var] =
+      waitlist match {
+        case Nil => results.reverse
+        case (nme: Var) :: tail => rec(nme :: results, tail)
+        case (TyApp(ty, _)) :: tail => rec(results, ty :: tail)
+        case (App(term, Tup(_))) :: tail => rec(results, term :: tail)
+        case other :: _ => println(s"Unknown parent type: $other"); ???
+      }
+    rec(Nil, parents)
+  }
 
   def transitiveClosure[A](graph: Map[A, List[A]])(implicit ord: Ordering[A]): SortedMap[A, List[A]] = {
     def dfs(vertex: A, visited: Set[A]): Set[A] = {
diff --git a/shared/src/test/diff/ucs/TrivialIf.mls b/shared/src/test/diff/ucs/TrivialIf.mls
index d8cc5fcc58..555b4943e9 100644
--- a/shared/src/test/diff/ucs/TrivialIf.mls
+++ b/shared/src/test/diff/ucs/TrivialIf.mls
@@ -1,130 +1,92 @@
-:NewParser
+:PreTyper
 :NoJS
 
 fun abs(x) = if x < 0 then 0 - x else x
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.4: 	fun abs(x) = if x < 0 then 0 - x else x
-//│ ╙──     	                ^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ abs: int -> int
+//│ fun abs: Int -> Int
 
-class Option
-class Some(value): Option
-class None: Option
-//│ Defined class Option
-//│ Defined class Some
-//│ Defined class None
-//│ Option: () -> Option
-//│ Some: 'value -> (Some & {value: 'value})
-//│ None: () -> None
+abstract class Option[A]: Some[A] | None
+class Some[A](value: A) extends Option[A]
+module None extends Option
+//│ abstract class Option[A]: None | Some[A]
+//│ class Some[A](value: A) extends Option
+//│ module None extends Option
 
 fun getOrElse(opt, default) =
   if opt is
     Some(value) then value
     None then default
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.22: 	  if opt is
-//│ ║        	     ^^^^^^
-//│ ║  l.23: 	    Some(value) then value
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.24: 	    None then default
-//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ getOrElse: (None | Some & {value: 'value}, 'value,) -> 'value
+//│ fun getOrElse: forall 'a. (None | Some['a], 'a) -> 'a
 
-getOrElse(None(), 0)
-//│ res: 0
+getOrElse(None, 0)
+//│ 0
 
 getOrElse(Some(42), 0)
-//│ res: 0 | 42
+//│ 0 | 42
 
 fun map(v, f) =
   if v is
     Some(x) then Some(f(x))
-    None then None()
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.42: 	  if v is
-//│ ║        	     ^^^^
-//│ ║  l.43: 	    Some(x) then Some(f(x))
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.44: 	    None then None()
-//│ ╙──      	^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ map: (None | Some & {value: 'value}, 'value -> 'value0,) -> (None | Some & {value: 'value0})
+    None then None
+//│ fun map: forall 'a 'A. (None | Some['a], 'a -> 'A) -> (None | Some['A])
 
 fun inc(x) = x + 5
-//│ inc: int -> int
+//│ fun inc: Int -> Int
 
 map(Some(5), x => x + 5)
-//│ res: None | Some & {value: int}
+//│ None | Some['A]
+//│   where
+//│     'A :> Int
 
-map(None(), inc)
-//│ res: None | Some & {value: int}
+map(None, inc)
+//│ None | Some['A]
+//│   where
+//│     'A :> Int
 
 :e
 fun f(a, b) = if a and b then 0
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.65: 	fun f(a, b) = if a and b then 0
-//│ ╙──      	                 ^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ╔══[ERROR] The case when this is false is not handled: a
-//│ ║  l.65: 	fun f(a, b) = if a and b then 0
-//│ ╙──      	                 ^
-//│ f: (anything, anything,) -> error
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.46: 	fun f(a, b) = if a and b then 0
+//│ ║        	                              ^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.46: 	fun f(a, b) = if a and b then 0
+//│ ║        	                       ^^^^^^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun f: (Bool, Bool) -> 0
 
 :e
 fun f(x, y) =
   if x == y + 5 then 0
   else if x == y + 7 then 0
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.77: 	  if x == y + 5 then 0
-//│ ║        	     ^^^^^^^^^^^^^^^^^
-//│ ║  l.78: 	  else if x == y + 7 then 0
-//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ╔══[ERROR] The case when this is false is not handled: ==(x,)(+(y,)(7,),)
-//│ ║  l.78: 	  else if x == y + 7 then 0
-//│ ╙──      	          ^^^^^^^^^^
-//│ f: (anything, anything,) -> error
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.60: 	  else if x == y + 7 then 0
+//│ ║        	                          ^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ fun f: (Num, Int) -> 0
 
 // TODO support
 fun foo(x) = if x is Some
   (0) then 0
   (1) then 1
 //│ ╔══[PARSE ERROR] Unexpected parenthesis section here
-//│ ║  l.93: 	  (1) then 1
+//│ ║  l.70: 	  (1) then 1
 //│ ╙──      	  ^^^
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.91: 	fun foo(x) = if x is Some
-//│ ║        	                ^^^^^^^^^
-//│ ║  l.92: 	  (0) then 0
-//│ ╙──      	^^^^^^^^^^^^
-//│ ╔══[ERROR] The case when this is false is not handled: is(x,)(Some,)(0,)
-//│ ║  l.91: 	fun foo(x) = if x is Some
-//│ ║        	                ^^^^^^^^^
-//│ ║  l.92: 	  (0) then 0
-//│ ╙──      	^^^^^
-//│ foo: anything -> error
+//│ /!!!\ Uncaught error: java.lang.StackOverflowError
 
 // TODO support
 fun foo(x) = if x is Some of
   0 then 0
   1 then 1
 //│ ╔══[PARSE ERROR] Unexpected 'then' keyword here
-//│ ║  l.111: 	  0 then 0
-//│ ╙──       	    ^^^^
+//│ ║  l.79: 	  0 then 0
+//│ ╙──      	    ^^^^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'if'; found operator application instead
-//│ ║  l.110: 	fun foo(x) = if x is Some of
-//│ ║         	                ^^^^^^^^^^^^
-//│ ║  l.111: 	  0 then 0
-//│ ║         	^^^
+//│ ║  l.78: 	fun foo(x) = if x is Some of
+//│ ║        	                ^^^^^^^^^^^^
+//│ ║  l.79: 	  0 then 0
+//│ ║        	^^^
 //│ ╟── Note: 'if' expression starts here:
-//│ ║  l.110: 	fun foo(x) = if x is Some of
-//│ ╙──       	             ^^
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.110: 	fun foo(x) = if x is Some of
-//│ ║         	                ^^^^^^^^^^^^
-//│ ║  l.111: 	  0 then 0
-//│ ╙──       	^^^
-//│ foo: (Some & {value: 0}) -> undefined
+//│ ║  l.78: 	fun foo(x) = if x is Some of
+//│ ╙──      	             ^^
+//│ fun foo: Some[0] -> ()
 
diff --git a/shared/src/test/diff/ucs/WeirdSplit.mls b/shared/src/test/diff/ucs/WeirdSplit.mls
index e74445a1a7..259ec793bb 100644
--- a/shared/src/test/diff/ucs/WeirdSplit.mls
+++ b/shared/src/test/diff/ucs/WeirdSplit.mls
@@ -1,31 +1,16 @@
-:NewParser
+:PreTyper
 
 class A()
 class B()
-//│ Defined class A
-//│ Defined class B
-//│ A: () -> A
-//│  = [Function: A1]
-//│ B: () -> B
-//│  = [Function: B1]
+//│ class A()
+//│ class B()
 
 fun f(x) =
   if x
     is
       A then 0
       B then 1
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.13: 	  if x
-//│ ║        	     ^
-//│ ║  l.14: 	    is
-//│ ║        	^^^^^^
-//│ ║  l.15: 	      A then 0
-//│ ║        	^^^^^^^^^^^^^^
-//│ ║  l.16: 	      B then 1
-//│ ╙──      	^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ f: (A | B) -> (0 | 1)
-//│  = [Function: f]
+//│ fun f: (A | B) -> (0 | 1)
 
 // Precedence problem: should we restruct terms when push them to the stack?
 :e
@@ -34,30 +19,19 @@ fun f(x) =
     1
       + 2 then 0
       + _ then 1
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.33: 	  if x ==
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.20: 	      + 2 then 0
+//│ ║        	      ^^^
+//│ ╟── operator application of type `Bool` is not an instance of type `Int`
+//│ ║  l.18: 	  if x ==
 //│ ║        	     ^^^^
-//│ ║  l.34: 	    1
-//│ ║        	^^^^^^
-//│ ║  l.35: 	      + 2 then 0
-//│ ║        	^^^^^^^^^^^^^^^^
-//│ ║  l.36: 	      + _ then 1
-//│ ╙──      	^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ ╔══[ERROR] Type mismatch in operator application:
-//│ ║  l.33: 	  if x ==
-//│ ║        	     ^^^^
-//│ ║  l.34: 	    1
-//│ ║        	^^^^^^
-//│ ║  l.35: 	      + 2 then 0
-//│ ║        	^^^^^^^
-//│ ╟── operator application of type `bool` is not an instance of type `int`
-//│ ║  l.33: 	  if x ==
-//│ ║        	     ^^^^
-//│ ║  l.34: 	    1
+//│ ║  l.19: 	    1
 //│ ╙──      	^^^^^^
-//│ f: number -> (0 | 1)
-//│  = [Function: f1]
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.20: 	      + 2 then 0
+//│ ║        	      ^^^
+//│ ╙── application of type `Int` is not an instance of type `Bool`
+//│ fun f: Num -> (0 | 1)
 
 fun f(x, s, t) =
   if x
@@ -65,17 +39,4 @@ fun f(x, s, t) =
       and t then 0
       and s then 0
     is _ then 1
-//│ ╔══[WARNING] old desugarer used
-//│ ║  l.63: 	  if x
-//│ ║        	     ^
-//│ ║  l.64: 	    is A()
-//│ ║        	^^^^^^^^^^
-//│ ║  l.65: 	      and t then 0
-//│ ║        	^^^^^^^^^^^^^^^^^^
-//│ ║  l.66: 	      and s then 0
-//│ ║        	^^^^^^^^^^^^^^^^^^
-//│ ║  l.67: 	    is _ then 1
-//│ ╙──      	^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected warning
-//│ f: (anything, anything, anything,) -> (0 | 1)
-//│  = [Function: f2]
+//│ fun f: (Object, Bool, Bool) -> (0 | 1)
diff --git a/shared/src/test/diff/ucs/Wildcard.mls b/shared/src/test/diff/ucs/Wildcard.mls
index 17d9db40dc..ede975371c 100644
--- a/shared/src/test/diff/ucs/Wildcard.mls
+++ b/shared/src/test/diff/ucs/Wildcard.mls
@@ -23,41 +23,13 @@ fun w1(x, e_0, e_1) =
       Left(Some(lv)) then concat("Left of Some of ")(toString(lv))
       _ and e_1 is y_1 and x is
         Right(Some(rv)) then concat("Right of Some of ")(toString(rv))
-//│ ╔══[ERROR] Found unexpected empty split
-//│ ╙──
-//│ ╔══[ERROR] Found unexpected empty split
-//│ ╙──
-//│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ╙── expression of type `Bool` is not an instance of type `true`
-//│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.23: 	      Left(Some(lv)) then concat("Left of Some of ")(toString(lv))
-//│ ║        	           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.24: 	      _ and e_1 is y_1 and x is
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^
-//│ ╙── expression of type `Bool` is not an instance of type `true`
-//│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.25: 	        Right(Some(rv)) then concat("Right of Some of ")(toString(rv))
-//│ ║        	              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╙── expression of type `Bool` is not an instance of type `true`
-//│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.24: 	      _ and e_1 is y_1 and x is
-//│ ║        	            ^^^^^^^^^^^^^^^^^^^
-//│ ║  l.25: 	        Right(Some(rv)) then concat("Right of Some of ")(toString(rv))
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╙── expression of type `Bool` is not an instance of type `true`
-//│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ╙── expression of type `Bool` is not an instance of type `true`
-//│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.24: 	      _ and e_1 is y_1 and x is
-//│ ║        	            ^^^^^^^^^^
-//│ ╙── expression of type `Bool` is not an instance of type `true`
-//│ fun w1: (Left[None | Object & ~#None & ~#Some | Some[anything]] | Object & ~#Left & ~#Right | Right[None | Some[anything]], anything, anything) -> (Str | error)
+//│ fun w1: forall 'a. (Left[None | Object & ~#None & ~#Some | Some[anything]] | Object & ~#Left & ~#Right | Right[None | Some[anything]], anything, 'a) -> (Str | 'a)
 
 w1(Left(None), "a", "b")
 w1(Right(None), "a", "b")
 w1(Left(Some(0)), "a", "b")
 w1(Right(Some(0)), "a", "b")
-//│ Str | error
+//│ Str
 //│ res
 //│     = 'Left of None'
 //│ res
diff --git a/todo.md b/todo.md
index 0ecfaa74d9..8b42a7f28d 100644
--- a/todo.md
+++ b/todo.md
@@ -1,6 +1,19 @@
 This file will be deleted after we migrate all test cases and fixed all
 problems located by test cases.
 
+### Remaining Tasks
+
+- Report redundant cases
+  - shared/src/test/diff/ucs/CrossBranchCapture.mls
+  - shared/src/test/diff/ucs/DirectLines.mls **OLD**
+  - shared/src/test/diff/ucs/SplitAnd.mls
+  - shared/src/test/diff/ucs/WeirdIf.mls
+  - shared/src/test/diff/ucs/Wildcard.mls
+- Hygenic bindings
+  - shared/src/test/diff/ucs/HygienicBindings.mls
+
+### Test Checklist
+
 - [x] shared/src/test/diff/codegen/AuxiliaryConstructors.mls
 - [x] shared/src/test/diff/codegen/Mixin.mls
       Fix that `PreTyper` does not traverse type definitions.
@@ -96,7 +109,7 @@ problems located by test cases.
       Generated names should be polished.
 - [x] shared/src/test/diff/ucs/Hygiene.mls
       Problem fixed!
-- [ ] shared/src/test/diff/ucs/HygienicBindings.mls
+- [x] shared/src/test/diff/ucs/HygienicBindings.mls
       We should fix the shadowing parameters.
 - [x] shared/src/test/diff/ucs/InterleavedLet.mls **OLD**
       The transformation cannot handle the following case.
@@ -140,10 +153,11 @@ problems located by test cases.
       Fixed.
 - [x] shared/src/test/diff/ucs/ThenIndent.mls
 - [x] shared/src/test/diff/ucs/Tree.mls
-- [ ] shared/src/test/diff/ucs/TrivialIf.mls **OLD**
-- [ ] shared/src/test/diff/ucs/WeirdIf.mls
+- [x] shared/src/test/diff/ucs/TrivialIf.mls **OLD**
+- [x] shared/src/test/diff/ucs/WeirdIf.mls
       Should report redundant cases.
-- [ ] shared/src/test/diff/ucs/WeirdSplit.mls **OLD**
-- [ ] shared/src/test/diff/ucs/Wildcard.mls
+- [x] shared/src/test/diff/ucs/WeirdSplit.mls **OLD**
+- [x] shared/src/test/diff/ucs/Wildcard.mls
       Some unexpected empty splits.
-- [x] shared/src/test/diff/ucs/zipWith.mls
\ No newline at end of file
+- [x] shared/src/test/diff/ucs/zipWith.mls
+

From f6fd0c56cdb248ca390caa1a0e96c04cb085c9f9 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sun, 14 Jan 2024 21:44:28 +0800
Subject: [PATCH 062/147] Fix unhygienic let bindings

---
 shared/src/main/scala/mlscript/ucs/core.scala |   1 -
 .../mlscript/ucs/stages/Normalization.scala   |  62 ++++--
 shared/src/test/diff/ucs/HygienicBindings.mls | 187 ++++++++++--------
 todo.md                                       |   4 +-
 4 files changed, 153 insertions(+), 101 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/core.scala b/shared/src/main/scala/mlscript/ucs/core.scala
index a41f4d63ec..70633056f8 100644
--- a/shared/src/main/scala/mlscript/ucs/core.scala
+++ b/shared/src/main/scala/mlscript/ucs/core.scala
@@ -78,7 +78,6 @@ package object core {
 
     override lazy val freeVars: Set[Var] = this match {
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
-        // FIXME: It is safe to ignore `pattern` for now.
         continuation.freeVars ++ tail.freeVars
       case Split.Let(true, nme, rhs, tail) => tail.freeVars ++ rhs.freeVars - nme
       case Split.Let(false, nme, rhs, tail) => tail.freeVars - nme ++ rhs.freeVars
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index d71b3243e0..95032eae8e 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -29,6 +29,7 @@ trait Normalization { self: DesugarUCS with Traceable =>
           these.copy(head = newHead, tail = fillImpl(tail, those, deep))
         }
       case these @ Split.Let(_, nme, _, tail) =>
+        println(s"fill let binding ${nme.name}")
         if (those.freeVars contains nme) {
           val fresh = context.freshShadowed()
           val thoseWithShadowed = Split.Let(false, nme, fresh, those)
@@ -69,23 +70,31 @@ trait Normalization { self: DesugarUCS with Traceable =>
     * @param split the split to normalize
     * @return the normalized term
     */ 
-  @inline protected def normalize(split: Split)(implicit context: Context): Term = normalizeToTerm(split)(context, Set.empty)
+  @inline protected def normalize(split: Split)(implicit
+      scope: Scope,
+      context: Context
+  ): Term = normalizeToTerm(split)(scope, context, Set.empty)
 
   private def errorTerm: Term = Var("error")
 
-  private def normalizeToTerm(split: Split)(implicit context: Context, generatedVars: Set[Var]): Term = trace("normalizeToTerm <==") {
+  private def normalizeToTerm(split: Split)(implicit
+      scope: Scope,
+      context: Context,
+      generatedVars: Set[Var],
+  ): Term = trace("normalizeToTerm <==") {
     split match {
       case Split.Cons(Branch(scrutinee, Pattern.Name(nme), continuation), tail) =>
-        println(s"normalizing name pattern ${scrutinee.name} is ${nme.name}")
-        Let(false, nme, scrutinee, normalizeToTerm(continuation.fill(tail, deep = false)))
+        println(s"ALIAS: ${scrutinee.name} is ${nme.name}")
+        val (wrap, realTail) = preventShadowing(nme, tail)
+        wrap(Let(false, nme, scrutinee, normalizeToTerm(continuation.fill(realTail, deep = false))))
       // Skip Boolean conditions as scrutinees, because they only appear once.
       case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true"), _), continuation), tail) =>
-        println(s"normalizing true pattern: ${test.name} is true")
+        println(s"TRUE: ${test.name} is true")
         val trueBranch = normalizeToTerm(continuation.fill(tail, deep = false))
         val falseBranch = normalizeToCaseBranches(tail)
         CaseOf(test, Case(nme, trueBranch, falseBranch)(refined = false))
       case Split.Cons(Branch(ScrutineeData.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Literal(literal), continuation), tail) =>
-        println(s"normalizing literal pattern: ${scrutineeVar.name} is ${literal.idStr}")
+        println(s"LITERAL: ${scrutineeVar.name} is ${literal.idStr}")
         println(s"entire split: ${showSplit(split)}")
         val concatenatedTrueBranch = continuation.fill(tail, deep = false)
         // println(s"true branch: ${showSplit(concatenatedTrueBranch)}")
@@ -94,31 +103,37 @@ trait Normalization { self: DesugarUCS with Traceable =>
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context))
         CaseOf(scrutineeVar, Case(literal, trueBranch, falseBranch)(refined = false))
       case Split.Cons(Branch(ScrutineeData.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Class(nme, rfd), continuation), tail) =>
-        println(s"normalizing class pattern: ${scrutineeVar.name} is ${nme.name}")
+        println(s"CLASS: ${scrutineeVar.name} is ${nme.name}")
         // println(s"match ${scrutineeVar.name} with $nme (has location: ${nme.toLoc.isDefined})")
         val trueBranch = normalizeToTerm(specialize(continuation.fill(tail, deep = false), true)(scrutineeVar, scrutinee, pattern, context))
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context))
         CaseOf(scrutineeVar, Case(nme, trueBranch, falseBranch)(refined = pattern.refined))
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
-        raiseError(msg"Unsupported pattern: ${pattern.toString}" -> pattern.toLoc)
+        raiseError(msg"unsupported pattern: ${pattern.toString}" -> pattern.toLoc)
         errorTerm
       case Split.Let(_, nme, _, tail) if context.isScrutineeVar(nme) && generatedVars.contains(nme) =>
-        println(s"normalizing let binding of generated variable: ${nme.name}")
+        println(s"LET: SKIP already declared scrutinee ${nme.name}")
         normalizeToTerm(tail)
+      case Split.Let(rec, nme, rhs, tail) if context.isGeneratedVar(nme) =>
+        println(s"LET: generated ${nme.name}")
+        Let(rec, nme, rhs, normalizeToTerm(tail)(scope, context, generatedVars + nme))
       case Split.Let(rec, nme, rhs, tail) =>
-        println(s"normalizing let binding ${nme.name}")
-        val newDeclaredBindings = if (context.isGeneratedVar(nme)) generatedVars + nme else generatedVars
-        Let(rec, nme, rhs, normalizeToTerm(tail)(context, newDeclaredBindings))
+        println(s"LET: ${nme.name}")
+        Let(rec, nme, rhs, normalizeToTerm(tail))
       case Split.Else(default) =>
-        println(s"normalizing default: ${default.showDbg}")
+        println(s"DFLT: ${default.showDbg}")
         default
       case Split.Nil =>
-        raiseError(msg"Found unexpected empty split" -> N)
+        raiseError(msg"unexpected empty split found" -> N)
         errorTerm
     }
   }(split => "normalizeToTerm ==> " + showNormalizedTerm(split))
 
-  private def normalizeToCaseBranches(split: Split)(implicit context: Context, generatedVars: Set[Var]): CaseBranches =
+  private def normalizeToCaseBranches(split: Split)(implicit
+      scope: Scope,
+      context: Context,
+      generatedVars: Set[Var]
+  ): CaseBranches =
     trace(s"normalizeToCaseBranches <==") {
       split match {
         // case Split.Cons(head, Split.Nil) => Case(head.pattern, normalizeToTerm(head.continuation), NoCases)
@@ -127,7 +142,7 @@ trait Normalization { self: DesugarUCS with Traceable =>
           normalizeToCaseBranches(tail)
         case Split.Let(rec, nme, rhs, tail) =>
           val newDeclaredBindings = if (context.isGeneratedVar(nme)) generatedVars + nme else generatedVars
-          normalizeToCaseBranches(tail)(context, newDeclaredBindings) match {
+          normalizeToCaseBranches(tail)(scope, context, newDeclaredBindings) match {
             case NoCases => Wildcard(rhs)
             case Wildcard(term) => Wildcard(Let(rec, nme, rhs, term))
             case _: Case => die
@@ -284,6 +299,21 @@ trait Normalization { self: DesugarUCS with Traceable =>
     }
   }()
   // }(showSplit(s"S${if (matchOrNot) "+" else "-"} ==>", _))
+
+  /**
+    * If you want to prepend `tail` to another `Split` where the `nme` takes
+    * effects, you should use this function to prevent shadowing.
+    */
+  private def preventShadowing(nme: Var, tail: Split)(implicit
+      scope: Scope,
+      context: Context
+  ): (Term => Term, Split) = scope.getTermSymbol(nme.name) match {
+    case S(symbol) if tail.freeVars contains nme =>
+      val stashVar = context.freshShadowed()
+      ((body: Term) => Let(false, stashVar, nme, body)) ->
+        Split.Let(false, nme, stashVar, tail)
+    case S(_) | N => identity[Term] _ -> tail
+  }
 }
 
 object Normalization
diff --git a/shared/src/test/diff/ucs/HygienicBindings.mls b/shared/src/test/diff/ucs/HygienicBindings.mls
index bcfd1b7e12..622a1f2bf6 100644
--- a/shared/src/test/diff/ucs/HygienicBindings.mls
+++ b/shared/src/test/diff/ucs/HygienicBindings.mls
@@ -1,5 +1,8 @@
 :PreTyper
 
+fun (~~>) expect(a, b) = if a is b then () else error
+//│ fun (~~>) expect: (anything, anything) -> ()
+
 type Option[out T] = None | Some[T]
 module None
 class Some[out T](val value: T)
@@ -21,6 +24,11 @@ class Cons[out A](head: A, tail: List[A])
 //│ module Nil
 //│ class Cons[A](head: A, tail: List[A])
 
+fun justTrue(_) = true
+fun justFalse(_) = false
+//│ fun justTrue: anything -> true
+//│ fun justFalse: anything -> false
+
 fun h0(a) =
   if
     a is Some(Left(y)) then y
@@ -28,15 +36,14 @@ fun h0(a) =
     a is None then 0
 //│ fun h0: forall 'a. (None | Some[Left['a] | Right['a]]) -> (0 | 'a)
 
-// Precise scrutinee identification (easy)
-// =======================================
-// The desugarer should be able to identify pattern matching on the first
-// parameter of `Some` even if they are bound to different variables.
+// If a class parameter is bound to the same variable in different branches,
+// the bindings can be merged and can be typed and coverage checked. See the
+// desugared version below.
 :dpt:postprocess.result
-fun h1(a) =
+fun h0'(a) =
   if
     a is Some(x) and x is Left(y) then y
-    a is Some(y) and y is Right(z) then z
+    a is Some(x) and x is Right(z) then z
     a is None then 0
 //│ | | | | | | | Post-processed UCS term:
 //│ | | | | | | | case a*‡ of
@@ -49,74 +56,33 @@ fun h1(a) =
 //│ | | | | | | |         let y*‡ = (ucs$args_x$Left).0
 //│ | | | | | | |         y
 //│ | | | | | | |       Right*◊ ->
-//│ | | | | | | |         let y*‡ = (ucs$args_a$Some).0
-//│ | | | | | | |         let ucs$args_y$Right*† = (Right).unapply(y,)
-//│ | | | | | | |         let z*‡ = (ucs$args_y$Right).0
+//│ | | | | | | |         let ucs$args_x$Right*† = (Right).unapply(x,)
+//│ | | | | | | |         let z*‡ = (ucs$args_x$Right).0
 //│ | | | | | | |         z
 //│ | | | | | | |   None*† -> 0
+//│ fun h0': forall 'a. (None | Some[Left['a] | Right['a]]) -> (0 | 'a)
+
+// However, if the class parameter is bound to different variables in different
+// branches, the bindings cannot be merged and the type will miss the latter
+// branch. See the desugared version below.
+fun h1(a) =
+  if
+    a is Some(x) and x is Left(y) then y
+    a is Some(y) and y is Right(z) then z
+    a is None then 0
 //│ fun h1: forall 'a. (None | Some[Right[anything] & {#rightValue: 'a}]) -> (0 | 'a)
 
 // FIXME
 h1(Some(Left(0)))
 //│ ╔══[ERROR] Type `Left[?A]` does not contain member `rightValue`
-//│ ║  l.12: 	class Right[B](val rightValue: B)
+//│ ║  l.15: 	class Right[B](val rightValue: B)
 //│ ╙──      	                   ^^^^^^^^^^
 //│ 0 | error
 //│ res
 //│     = 0
 
-// This is the desugared version of the test case above.
-fun h1'(a) =
-  if a is
-    Some then
-      let x = a.value
-      let y = a.value
-      if x is
-        Left then
-          let y = x.leftValue
-          y
-        _ then
-          if y is
-            Right then
-              let z = y.rightValue
-              z
-    None then 0
-//│ fun h1': forall 'leftValue. (None | Some[Right['leftValue]]) -> (0 | 'leftValue)
-
-// FIXME
-h1'(Some(Left(0)))
-//│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.87: 	h1'(Some(Left(0)))
-//│ ║        	^^^^^^^^^^^^^^^^^^
-//│ ╟── application of type `Left[?A]` is not an instance of type `Right`
-//│ ║  l.87: 	h1'(Some(Left(0)))
-//│ ║        	         ^^^^^^^
-//│ ╟── Note: constraint arises from class pattern:
-//│ ║  l.80: 	            Right then
-//│ ║        	            ^^^^^
-//│ ╟── from field selection:
-//│ ║  l.73: 	      let y = a.value
-//│ ║        	              ^^^^^^^
-//│ ╟── Note: type parameter T is defined at:
-//│ ║  l.5: 	class Some[out T](val value: T)
-//│ ╙──     	               ^
-//│ 0 | error
-//│ res
-//│     = 0
-
-fun h1''(a) =
-  if
-    a is Some(x) and x is Left(y) then y
-    a is Some(x) and x is Right(z) then z
-    a is None then 0
-//│ fun h1'': forall 'a. (None | Some[Left['a] | Right['a]]) -> (0 | 'a)
-
-h1''(Some(Left(0)))
-//│ 0
-//│ res
-//│     = 0
-
-// FIXME: Precise scrutinee identification (hard)
+// FIXME: It is also impossible to merge bindings of different variables if one
+// of them is bound via a let binding.
 fun h2(a) =
   if
     a is Some(x) and x is x' and x' is Left(y) then y
@@ -126,26 +92,39 @@ fun h2(a) =
     a is None then 0
 //│ fun h2: forall 'a. (None | Some[Left['a]]) -> (0 | 'a)
 
-// FIXME: Some results are wrong.
+:dpt:postprocess.result
 fun h3(x, y, f, p) =
   if x is
     _ and f(x) is y and p(x) then y
     None then y
     _ then "anyway"
-h3("anything", "not me", _ => "should be me", _ => true)
-h3(None, "should be me", _ => "not me", _ => false)
-h3("anything", "anything", _ => "not me", _ => false)
-//│ fun h3: forall 'a 'b. (Object & 'a, anything, 'a -> 'b, 'a -> Bool) -> ("anyway" | 'b)
-//│ "anyway" | "not me"
+//│ | | | | | | | Post-processed UCS term:
+//│ | | | | | | | let ucs$scrut$0*‡ = f(x,)
+//│ | | | | | | | let ucs$shadow$0 = y
+//│ | | | | | | | let y*‡ = ucs$scrut$0
+//│ | | | | | | | let ucs$test$0*† = p(x,) : Bool
+//│ | | | | | | | case ucs$test$0*† of
+//│ | | | | | | |   true*† -> y
+//│ | | | | | | |   _ ->
+//│ | | | | | | |     let y*‡ = ucs$shadow$0
+//│ | | | | | | |     case x*‡ of
+//│ | | | | | | |       None*† -> y
+//│ | | | | | | |       _ -> "anyway"
+//│ fun h3: forall 'a 'b. (Object & 'a, 'b, 'a -> 'b, 'a -> Bool) -> ("anyway" | 'b)
+
+
+h3("anything", "not me", _ => "should be me", _ => true) ~~> "should be me"
+h3(None, "should be me", _ => "not me", _ => false) ~~> "should be me"
+h3("anything", "anything", _ => "not me", _ => false) ~~> "anyway"
+//│ ()
 //│ res
-//│     = 'should be me'
+//│     = undefined
 //│ res
-//│     = 'not me'
+//│     = undefined
 //│ res
-//│     = 'anyway'
+//│     = undefined
 
 
-// FIXME: We still haven't fixed all shadowing problems.
 :dpt:postprocess.result
 fun h4(x, y, p) =
   if x is
@@ -153,26 +132,70 @@ fun h4(x, y, p) =
     None then y
     _ then "default"
 //│ | | | | | | | Post-processed UCS term:
+//│ | | | | | | | let ucs$shadow$0 = y
 //│ | | | | | | | let y*‡ = x
 //│ | | | | | | | let ucs$test$0*† = p(x,) : Bool
 //│ | | | | | | | case ucs$test$0*† of
 //│ | | | | | | |   true*† -> y
 //│ | | | | | | |   _ ->
+//│ | | | | | | |     let y*‡ = ucs$shadow$0
 //│ | | | | | | |     case x*‡ of
 //│ | | | | | | |       None*† -> y
 //│ | | | | | | |       _ -> "default"
-//│ fun h4: forall 'a. (Object & 'a, anything, 'a -> Bool) -> ("default" | 'a)
+//│ fun h4: forall 'a 'b. (Object & 'a, 'b, 'a -> Bool) -> ("default" | 'a | 'b)
+
+h4("should be me", "not me", _ => true) ~~> "should be me"
+h4(None, "not me", _ => true) ~~> None
+h4(None, "should be me", _ => false) ~~> "should be me"
+h4("anything", "not me", _ => false) ~~> "default"
+//│ ()
+//│ res
+//│     = undefined
+//│ res
+//│     = undefined
+//│ res
+//│     = undefined
+//│ res
+//│     = undefined
+
+:dpt:postprocess.result
+fun h5(x, y, p) =
+  if x is
+    Some(y) and p(x) then y
+    None then y
+    _ then y
+//│ | | | | | | | Post-processed UCS term:
+//│ | | | | | | | case x*‡ of
+//│ | | | | | | |   Some*◊ ->
+//│ | | | | | | |     let ucs$args_x$Some*† = (Some).unapply(x,)
+//│ | | | | | | |     let ucs$shadow$0 = y
+//│ | | | | | | |     let y*‡ = (ucs$args_x$Some).0
+//│ | | | | | | |     let ucs$test$0*† = p(x,) : Bool
+//│ | | | | | | |     case ucs$test$0*† of
+//│ | | | | | | |       true*† -> y
+//│ | | | | | | |       _ ->
+//│ | | | | | | |         let y*‡ = ucs$shadow$0
+//│ | | | | | | |         y
+//│ | | | | | | |   None*† -> y
+//│ | | | | | | |   _ -> y
+//│ fun h5: forall 'a. (Object & ~#Some | Some['a], 'a, Some[nothing] -> Bool) -> 'a
 
-h4("should be me", "not me", _ => true)
-h4(None, "not me", _ => true)
-h4(None, "should be me", _ => false)
-h4("anything", "not me", _ => false)
-//│ "anything" | "default"
+h5(Some(1), 2, justTrue) ~~> 1
+h5(Some(1), 2, justFalse) ~~> 2
+h5(None, 0, justTrue) ~~> 0
+h5(None, 0, justFalse) ~~> 0
+h5("foo", 42, justTrue) ~~> 42
+h5("foo", 42, justFalse) ~~> 42
+//│ ()
+//│ res
+//│     = undefined
+//│ res
+//│     = undefined
 //│ res
-//│     = 'should be me'
+//│     = undefined
 //│ res
-//│     = None { class: [class None] }
+//│     = undefined
 //│ res
-//│     = None { class: [class None] }
+//│     = undefined
 //│ res
-//│     = 'default'
+//│     = undefined
diff --git a/todo.md b/todo.md
index 8b42a7f28d..13163bcee3 100644
--- a/todo.md
+++ b/todo.md
@@ -3,13 +3,13 @@ problems located by test cases.
 
 ### Remaining Tasks
 
-- Report redundant cases
+- [ ] Report redundant cases
   - shared/src/test/diff/ucs/CrossBranchCapture.mls
   - shared/src/test/diff/ucs/DirectLines.mls **OLD**
   - shared/src/test/diff/ucs/SplitAnd.mls
   - shared/src/test/diff/ucs/WeirdIf.mls
   - shared/src/test/diff/ucs/Wildcard.mls
-- Hygenic bindings
+- [x] Hygenic bindings
   - shared/src/test/diff/ucs/HygienicBindings.mls
 
 ### Test Checklist

From 3caacec1ec8e7576ffb9b7efcee9aec8fc693d58 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sun, 14 Jan 2024 22:42:03 +0800
Subject: [PATCH 063/147] Report unreachable cases and fix stashing shadowed
 variables

---
 .../main/scala/mlscript/ucs/DesugarUCS.scala  | 33 ++++++++++++++-
 shared/src/main/scala/mlscript/ucs/core.scala | 11 -----
 .../mlscript/ucs/stages/Normalization.scala   | 12 ++++--
 .../src/test/diff/ucs/CrossBranchCapture.mls  | 42 +++++++++----------
 shared/src/test/diff/ucs/DirectLines.mls      | 11 +++--
 todo.md                                       | 14 +++----
 6 files changed, 74 insertions(+), 49 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 8c2ab20809..facff56d96 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -1,8 +1,7 @@
 package mlscript.ucs
 
 import collection.mutable.{Map => MutMap}
-import mlscript.ucs.stages._
-import mlscript.ucs.context.{Context, ScrutineeData}
+import mlscript.ucs.{syntax => s, core => c}, stages._, context.{Context, ScrutineeData}
 import mlscript.ucs.display.{showNormalizedTerm, showSplit}
 import mlscript.pretyper.{PreTyper, Scope}
 import mlscript.pretyper.symbol._
@@ -138,6 +137,36 @@ trait DesugarUCS extends Transformation
       { nme.resolveClassLikeSymbol; nme }
   }
 
+  protected implicit class SourceSplitOps[+B <: s.Branch](these: s.Split[B]) {
+    def ++[BB >: B <: s.Branch](those: s.Split[BB]): s.Split[BB] = these match {
+      case s.Split.Cons(head, tail) => s.Split.Cons(head, tail ++ those)
+      case s.Split.Let(rec, nme, rhs, tail) => s.Split.Let(rec, nme, rhs, tail ++ those)
+      case s.Split.Else(_) =>
+        raiseWarning(msg"unreachable case" -> these.toLoc)
+        these
+      case s.Split.Nil => those
+    }
+  }
+
+  protected implicit class CoreSplitOps(these: c.Split) {
+    /**
+      * Concatenates two splits. Beware that `that` may be discarded if `this`
+      * has an else branch. Make sure to make diagnostics for discarded `that`.
+      */
+    def ++(those: c.Split): c.Split =
+      if (those === c.Split.Nil) these else (these match {
+        case me: c.Split.Cons => me.copy(tail = me.tail ++ those)
+        case me: c.Split.Let => me.copy(tail = me.tail ++ those)
+        case _: c.Split.Else =>
+          raiseWarning(
+            msg"the case is unreachable" -> those.toLoc,
+            msg"because this branch covers the case" -> these.toLoc
+          )
+          these
+        case c.Split.Nil => those
+      })
+  }
+
   protected def traverseIf(`if`: If)(implicit scope: Scope): Unit = {
     implicit val context: Context = new Context(`if`)
     try trace("traverseIf") {
diff --git a/shared/src/main/scala/mlscript/ucs/core.scala b/shared/src/main/scala/mlscript/ucs/core.scala
index 70633056f8..986fec081f 100644
--- a/shared/src/main/scala/mlscript/ucs/core.scala
+++ b/shared/src/main/scala/mlscript/ucs/core.scala
@@ -54,17 +54,6 @@ package object core {
   sealed abstract class Split extends Located {
     @inline
     def ::(head: Branch): Split = Split.Cons(head, this)
-
-    /**
-      * Concatenates two splits. Beware that `that` may be discarded if `this`
-      * has an else branch. Make sure to make diagnostics for discarded `that`.
-      */
-    def ++(that: Split): Split = this match {
-      case me: Split.Cons => me.copy(tail = me.tail ++ that)
-      case me: Split.Let => me.copy(tail = me.tail ++ that)
-      case _: Split.Else => this
-      case Split.Nil => that
-    }
     
     /**
       * Returns true if the split has an else branch.
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 95032eae8e..b038862c75 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -18,7 +18,11 @@ trait Normalization { self: DesugarUCS with Traceable =>
   import Normalization._
 
   // TODO: We might not need the case where `deep` is `false`.
-  private def fillImpl(these: Split, those: Split, deep: Bool)(implicit context: Context, generatedVars: Set[Var]): Split =
+  private def fillImpl(these: Split, those: Split, deep: Bool)(implicit
+      scope: Scope,
+      context: Context,
+      generatedVars: Set[Var]
+  ): Split =
     if (these.hasElse) these else (these match {
       case these @ Split.Cons(head, tail) =>
         if (head.continuation.hasElse || !deep) {
@@ -30,13 +34,13 @@ trait Normalization { self: DesugarUCS with Traceable =>
         }
       case these @ Split.Let(_, nme, _, tail) =>
         println(s"fill let binding ${nme.name}")
-        if (those.freeVars contains nme) {
+        if (scope.getTermSymbol(nme.name).isDefined && (those.freeVars contains nme)) {
           val fresh = context.freshShadowed()
           val thoseWithShadowed = Split.Let(false, nme, fresh, those)
           val concatenated = these.copy(tail = fillImpl(tail, thoseWithShadowed, deep))
           Split.Let(false, fresh, nme, concatenated)
         } else {
-          these.copy(tail = fillImpl(tail, those, deep)(context, generatedVars + nme))
+          these.copy(tail = fillImpl(tail, those, deep)(scope, context, generatedVars + nme))
         }
       case _: Split.Else => these
       case Split.Nil =>
@@ -45,7 +49,7 @@ trait Normalization { self: DesugarUCS with Traceable =>
     })
 
   private implicit class SplitOps(these: Split) {
-    def fill(those: Split, deep: Bool)(implicit context: Context, generatedVars: Set[Var]): Split =
+    def fill(those: Split, deep: Bool)(implicit scope: Scope, context: Context, generatedVars: Set[Var]): Split =
       trace(s"fill <== ${generatedVars.iterator.map(_.name).mkString("{", ", ", "}")}") {
         println(s"LHS: ${showSplit(these)}")
         println(s"RHS: ${showSplit(those)}")
diff --git a/shared/src/test/diff/ucs/CrossBranchCapture.mls b/shared/src/test/diff/ucs/CrossBranchCapture.mls
index f1c60286c4..ac96606b73 100644
--- a/shared/src/test/diff/ucs/CrossBranchCapture.mls
+++ b/shared/src/test/diff/ucs/CrossBranchCapture.mls
@@ -1,45 +1,46 @@
 :PreTyper
 
+fun (~~>) expect(a, b) = if a is b then () else error
+//│ fun (~~>) expect: (anything, anything) -> ()
 
 class Numb(n: Int)
 //│ class Numb(n: Int)
 
 
 :e
-:ge
 fun process(e) =
   if e is
     Numb(n) and n > 0 then n
     Numb(m) then n
 //│ ╔══[ERROR] identifier `n` not found
-//│ ║  l.13: 	    Numb(m) then n
+//│ ║  l.14: 	    Numb(m) then n
 //│ ╙──      	                 ^
-//│ ╔══[ERROR] identifier not found: n
-//│ ║  l.12: 	    Numb(n) and n > 0 then n
-//│ ╙──      	         ^
-//│ fun process: Numb -> (Int | error)
-//│ Code generation encountered an error:
-//│   unresolved symbol n
+//│ fun process: Numb -> Int
+
 
-:re
 process(Numb(-10))
-//│ Int | error
+//│ Int
 //│ res
-//│ Runtime error:
-//│   TypeError: process is not a function
+//│     = -10
+
 
 
-// * FIXME wrong result
 fun process(e, n) =
   if e is
     Numb(n) and n > 0 then n
     Numb(m) then n + m
 //│ fun process: (Numb, Int) -> Int
 
-process(Numb(0), 10)
-//│ Int
+process(Numb(0), 10) ~~> 10
+process(Numb(-1), 10) ~~> 9
+process(Numb(1), 10) ~~> 1
+//│ ()
+//│ res
+//│     = undefined
 //│ res
-//│     = 10
+//│     = undefined
+//│ res
+//│     = undefined
 
 
 class Vec(xs: Array[Numb | Vec])
@@ -57,15 +58,12 @@ fun process(e) =
     Pair(Vec(n),  Numb(n)) then n
     Pair(Numb(n), Vec(n))  then n
 //│ ╔══[ERROR] identifier `n` not found
-//│ ║  l.56: 	    Pair(Vec(xs), Vec(ys))  then n
+//│ ║  l.57: 	    Pair(Vec(xs), Vec(ys))  then n
 //│ ╙──      	                                 ^
 //│ ╔══[ERROR] identifier not found: n
-//│ ║  l.55: 	    Pair(Numb(n), Numb(m)) then Numb(n + m)
-//│ ╙──      	              ^
-//│ ╔══[ERROR] identifier not found: n
-//│ ║  l.56: 	    Pair(Vec(xs), Vec(ys))  then n
+//│ ║  l.57: 	    Pair(Vec(xs), Vec(ys))  then n
 //│ ╙──      	                                 ^
-//│ fun process: Pair[Numb | Vec, Numb | Vec] -> (Int | Numb | error | Array[Numb | Vec])
+//│ fun process: Pair[Numb | Vec, Numb | Vec] -> (Int | Numb | error)
 //│ Code generation encountered an error:
 //│   unresolved symbol n
 
diff --git a/shared/src/test/diff/ucs/DirectLines.mls b/shared/src/test/diff/ucs/DirectLines.mls
index 4450e04e0e..22e0c1e39b 100644
--- a/shared/src/test/diff/ucs/DirectLines.mls
+++ b/shared/src/test/diff/ucs/DirectLines.mls
@@ -20,7 +20,7 @@ fun isValid(x) = if x then false else true
 fun f(x, allowNone) =
   if x
     is Some(x) and isValid(x) then "good"
-    is None() and allowNone then "okay"
+    is None and allowNone then "okay"
     is _ then "bad"
 //│ fun f: (Object & ~#Some | Some[Bool], Bool) -> ("bad" | "good" | "okay")
 
@@ -37,8 +37,7 @@ fun f(x, y, z) =
       _ then "bruh"
 //│ fun f: (Num, Num, Num) -> ("bruh" | "x" | "y = 1" | "y = 3" | "z = 0" | "z = 9")
 
-// :w
-// FIXME: Report redundant else branches.
+:w
 fun f(a, b) =
   if
     a == 0 then 0
@@ -47,4 +46,10 @@ fun f(a, b) =
       2 then 2
       _ then 7
     else 3
+//│ ╔══[WARNING] the case is unreachable
+//│ ║  l.48: 	    else 3
+//│ ║        	         ^
+//│ ╟── because this branch covers the case
+//│ ║  l.47: 	      _ then 7
+//│ ╙──      	             ^
 //│ fun f: (Num, Num) -> (0 | 1 | 2 | 7)
diff --git a/todo.md b/todo.md
index 13163bcee3..6a99be1018 100644
--- a/todo.md
+++ b/todo.md
@@ -3,14 +3,14 @@ problems located by test cases.
 
 ### Remaining Tasks
 
-- [ ] Report redundant cases
-  - shared/src/test/diff/ucs/CrossBranchCapture.mls
-  - shared/src/test/diff/ucs/DirectLines.mls **OLD**
-  - shared/src/test/diff/ucs/SplitAnd.mls
-  - shared/src/test/diff/ucs/WeirdIf.mls
-  - shared/src/test/diff/ucs/Wildcard.mls
+- [ ] Report unreachable or redundant cases
+  - [x] shared/src/test/diff/ucs/DirectLines.mls **OLD**
+  - [ ] shared/src/test/diff/ucs/SplitAnd.mls
+  - [ ] shared/src/test/diff/ucs/WeirdIf.mls
+  - [ ] shared/src/test/diff/ucs/Wildcard.mls
 - [x] Hygenic bindings
-  - shared/src/test/diff/ucs/HygienicBindings.mls
+  - [ ] shared/src/test/diff/ucs/CrossBranchCapture.mls
+  - [x] shared/src/test/diff/ucs/HygienicBindings.mls
 
 ### Test Checklist
 

From 5e71447720dfa38c09a42b8becce701017f9e1df Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sun, 14 Jan 2024 22:52:49 +0800
Subject: [PATCH 064/147] Append test file changes

---
 shared/src/test/diff/nu/FunnyIndet.mls        |  7 +++--
 .../test/diff/pretyper/ucs/RecordPattern.mls  | 17 +++++++----
 .../pretyper/ucs/SpecilizationCollision.mls   | 10 +------
 .../pretyper/ucs/coverage/Unreachable.mls     | 17 +++++++++++
 shared/src/test/diff/ucs/InterleavedLet.mls   |  2 +-
 .../src/test/diff/ucs/NuPlainConditionals.mls | 26 +++++++++--------
 .../src/test/diff/ucs/PlainConditionals.mls   | 28 +++++++++++--------
 shared/src/test/diff/ucs/SimpleUCS.mls        |  2 +-
 shared/src/test/diff/ucs/SplitAroundOp.mls    |  2 +-
 shared/src/test/diff/ucs/TrivialIf.mls        |  8 +++---
 shared/src/test/diff/ucs/WeirdIf.mls          | 23 +++++++++------
 shared/src/test/diff/ucs/Wildcard.mls         |  9 ++++--
 12 files changed, 94 insertions(+), 57 deletions(-)

diff --git a/shared/src/test/diff/nu/FunnyIndet.mls b/shared/src/test/diff/nu/FunnyIndet.mls
index f0eb4d45bd..d01ba73b51 100644
--- a/shared/src/test/diff/nu/FunnyIndet.mls
+++ b/shared/src/test/diff/nu/FunnyIndet.mls
@@ -29,11 +29,14 @@
 
 
 :e // TODO support
+:w
 2 is
   2
 //│ ╔══[ERROR] Unknown pattern {2}
-//│ ║  l.33: 	  2
+//│ ║  l.34: 	  2
 //│ ╙──      	  ^
+//│ ╔══[WARNING] the case is unreachable
+//│ ╙── because this branch covers the case
 //│ true
 //│ res
 //│     = true
@@ -61,7 +64,7 @@ if 2 is
 2 then true
 1 then false
 //│ ╔══[PARSE ERROR] Unexpected 'then'/'else' clause
-//│ ║  l.62: 	1 then false
+//│ ║  l.65: 	1 then false
 //│ ╙──      	^^^^^^^^^^^^
 //│ ()
 //│ res
diff --git a/shared/src/test/diff/pretyper/ucs/RecordPattern.mls b/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
index e54140742f..ef6726ea58 100644
--- a/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
+++ b/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
@@ -1,24 +1,31 @@
 :PreTyper
 
 :e
+:w
 fun take_1(p) =
   if p is
     { x, y } then x + y
     else 0
 //│ ╔══[ERROR] Unknown pattern '{' {x: x, y: y} '}'
-//│ ║  l.6: 	    { x, y } then x + y
+//│ ║  l.7: 	    { x, y } then x + y
 //│ ╙──     	    ^^^^^^^^
+//│ ╔══[WARNING] the case is unreachable
+//│ ║  l.8: 	    else 0
+//│ ║       	         ^
+//│ ╟── because this branch covers the case
+//│ ║  l.7: 	    { x, y } then x + y
+//│ ╙──     	                  ^^^^^
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.6: 	    { x, y } then x + y
+//│ ║  l.7: 	    { x, y } then x + y
 //│ ╙──     	                  ^
 //│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.6: 	    { x, y } then x + y
+//│ ║  l.7: 	    { x, y } then x + y
 //│ ╙──     	                      ^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.6: 	    { x, y } then x + y
+//│ ║  l.7: 	    { x, y } then x + y
 //│ ╙──     	                  ^
 //│ ╔══[ERROR] identifier not found: y
-//│ ║  l.6: 	    { x, y } then x + y
+//│ ║  l.7: 	    { x, y } then x + y
 //│ ╙──     	                      ^
 //│ fun take_1: anything -> Int
 //│ Code generation encountered an error:
diff --git a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
index 5675d5d0f5..b18f377554 100644
--- a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
+++ b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
@@ -33,15 +33,7 @@ fun example2(p) =
 //│ ╔══[ERROR] identifier `y` not found
 //│ ║  l.28: 	    Pair(a, b) and p2(a) and p2(b) then x + y
 //│ ╙──      	                                            ^
-//│ ╔══[ERROR] identifier not found: x
-//│ ║  l.27: 	    Pair(x, y) and p1(x) and p1(y) then "both negative"
-//│ ╙──      	         ^
-//│ ╔══[ERROR] identifier not found: y
-//│ ║  l.27: 	    Pair(x, y) and p1(x) and p1(y) then "both negative"
-//│ ╙──      	            ^
-//│ fun example2: (Object & ~#Pair | Pair[Num, Num]) -> ("both negative" | "nah" | Int)
-//│ Code generation encountered an error:
-//│   unresolved symbol y
+//│ fun example2: (Object & ~#Pair | Pair[Int, Int]) -> ("both negative" | "nah" | Int)
 
 // Next, let's check the name collision between a class and its super class.
 
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls b/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
index a4a1e89789..de454fa68d 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
@@ -41,6 +41,7 @@ reachable_1(None)
 //│ res
 //│     = 'tan'
 
+:w
 fun unreachable_1(x) =
   if x is
     _ and
@@ -48,4 +49,20 @@ fun unreachable_1(x) =
       else "screen"
     Some(xv) then "sin"
     None then "tan"
+//│ ╔══[WARNING] the case is unreachable
+//│ ║  l.46: 	  if x is
+//│ ║        	     ^^^^
+//│ ║  l.47: 	    _ and
+//│ ║        	^^^^^^^^^
+//│ ║  l.48: 	      f(x) then "tmux"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.49: 	      else "screen"
+//│ ║        	^^^^^^^^^^^^^^^^^^^
+//│ ║  l.50: 	    Some(xv) then "sin"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.51: 	    None then "tan"
+//│ ║        	^^^^^^^^^^^^^^^^^^^
+//│ ╟── because this branch covers the case
+//│ ║  l.49: 	      else "screen"
+//│ ╙──      	           ^^^^^^^^
 //│ fun unreachable_1: (Object & ~#Some | Some[Eql[1]]) -> ("screen" | "tmux")
diff --git a/shared/src/test/diff/ucs/InterleavedLet.mls b/shared/src/test/diff/ucs/InterleavedLet.mls
index cb41cb72c7..243ac0adc9 100644
--- a/shared/src/test/diff/ucs/InterleavedLet.mls
+++ b/shared/src/test/diff/ucs/InterleavedLet.mls
@@ -37,7 +37,7 @@ fun p(x, y) =
     x is Some and y is None then 0
     y is Some and x is Some then 1
     x is Some and y is Some then 0
-//│ ╔══[ERROR] Found unexpected empty split
+//│ ╔══[ERROR] unexpected empty split found
 //│ ╙──
 //│ ╔══[ERROR] Scrutinee `y` has 1 missing case
 //│ ║  l.38: 	    y is Some and x is Some then 1
diff --git a/shared/src/test/diff/ucs/NuPlainConditionals.mls b/shared/src/test/diff/ucs/NuPlainConditionals.mls
index 053e31b8e9..9844b82f28 100644
--- a/shared/src/test/diff/ucs/NuPlainConditionals.mls
+++ b/shared/src/test/diff/ucs/NuPlainConditionals.mls
@@ -58,6 +58,8 @@ fun foo(x) = x is
 //│ ║        	  ^^^^
 //│ ║  l.55: 	  Int
 //│ ╙──      	^^^^^
+//│ ╔══[WARNING] the case is unreachable
+//│ ╙── because this branch covers the case
 //│ fun foo: anything -> true
 
 // TODO proper error
@@ -65,41 +67,43 @@ fun foo(x) = x is
   Pair(a, b) and a > b
   Int
 //│ ╔══[ERROR] Unknown pattern {and(Pair(a, b,), >(a, b,),); Int}
-//│ ║  l.65: 	  Pair(a, b) and a > b
+//│ ║  l.67: 	  Pair(a, b) and a > b
 //│ ║        	  ^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.66: 	  Int
+//│ ║  l.68: 	  Int
 //│ ╙──      	^^^^^
+//│ ╔══[WARNING] the case is unreachable
+//│ ╙── because this branch covers the case
 //│ fun foo: anything -> true
 
 // TODO support `|`
 fun foo1(x) = x is Pair(a, b) | Int
 fun foo2(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╔══[ERROR] Unknown pattern '(' and(Pair(a, b,), >(a, b,),) ')'
-//│ ║  l.76: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
+//│ ║  l.80: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	                   ^^^^^^^^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] type identifier `|` not found
-//│ ║  l.76: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
+//│ ║  l.80: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	                                          ^
 //│ ╔══[ERROR] type identifier `Int` not found
-//│ ║  l.76: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
+//│ ║  l.80: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	                                            ^^^
 //│ ╔══[ERROR] identifier `|` not found
-//│ ║  l.76: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
+//│ ║  l.80: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	                                          ^
 //│ ╔══[ERROR] type identifier `|` not found
-//│ ║  l.75: 	fun foo1(x) = x is Pair(a, b) | Int
+//│ ║  l.79: 	fun foo1(x) = x is Pair(a, b) | Int
 //│ ╙──      	                              ^
 //│ ╔══[ERROR] type identifier `Int` not found
-//│ ║  l.75: 	fun foo1(x) = x is Pair(a, b) | Int
+//│ ║  l.79: 	fun foo1(x) = x is Pair(a, b) | Int
 //│ ╙──      	                                ^^^
 //│ ╔══[ERROR] identifier `|` not found
-//│ ║  l.75: 	fun foo1(x) = x is Pair(a, b) | Int
+//│ ║  l.79: 	fun foo1(x) = x is Pair(a, b) | Int
 //│ ╙──      	                              ^
 //│ ╔══[ERROR] type identifier not found: |
-//│ ║  l.75: 	fun foo1(x) = x is Pair(a, b) | Int
+//│ ║  l.79: 	fun foo1(x) = x is Pair(a, b) | Int
 //│ ╙──      	                              ^
 //│ ╔══[ERROR] type identifier not found: |
-//│ ║  l.76: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
+//│ ║  l.80: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	                                          ^
 //│ fun foo1: nothing -> error
 //│ fun foo2: nothing -> error
diff --git a/shared/src/test/diff/ucs/PlainConditionals.mls b/shared/src/test/diff/ucs/PlainConditionals.mls
index c15867ad0c..63e30e6c17 100644
--- a/shared/src/test/diff/ucs/PlainConditionals.mls
+++ b/shared/src/test/diff/ucs/PlainConditionals.mls
@@ -58,6 +58,8 @@ fun foo(x) = x is
 //│ ║        	  ^^^^
 //│ ║  l.55: 	  Int
 //│ ╙──      	^^^^^
+//│ ╔══[WARNING] the case is unreachable
+//│ ╙── because this branch covers the case
 //│ fun foo: anything -> true
 
 // TODO proper error
@@ -65,44 +67,46 @@ fun foo(x) = x is
   Pair(a, b) and a > b
   Int
 //│ ╔══[ERROR] Unknown pattern {and(Pair(a, b,), >(a, b,),); Int}
-//│ ║  l.65: 	  Pair(a, b) and a > b
+//│ ║  l.67: 	  Pair(a, b) and a > b
 //│ ║        	  ^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.66: 	  Int
+//│ ║  l.68: 	  Int
 //│ ╙──      	^^^^^
+//│ ╔══[WARNING] the case is unreachable
+//│ ╙── because this branch covers the case
 //│ fun foo: anything -> true
 
 // TODO support `|`
 fun foo(x) = x is Pair(a, b) | Int
 fun foo(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╔══[ERROR] Unknown pattern '(' and(Pair(a, b,), >(a, b,),) ')'
-//│ ║  l.76: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
+//│ ║  l.80: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	                  ^^^^^^^^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] type identifier `|` not found
-//│ ║  l.76: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
+//│ ║  l.80: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	                                         ^
 //│ ╔══[ERROR] type identifier `Int` not found
-//│ ║  l.76: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
+//│ ║  l.80: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	                                           ^^^
 //│ ╔══[ERROR] identifier `|` not found
-//│ ║  l.76: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
+//│ ║  l.80: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	                                         ^
 //│ ╔══[ERROR] type identifier `|` not found
-//│ ║  l.75: 	fun foo(x) = x is Pair(a, b) | Int
+//│ ║  l.79: 	fun foo(x) = x is Pair(a, b) | Int
 //│ ╙──      	                             ^
 //│ ╔══[ERROR] type identifier `Int` not found
-//│ ║  l.75: 	fun foo(x) = x is Pair(a, b) | Int
+//│ ║  l.79: 	fun foo(x) = x is Pair(a, b) | Int
 //│ ╙──      	                               ^^^
 //│ ╔══[ERROR] identifier `|` not found
-//│ ║  l.75: 	fun foo(x) = x is Pair(a, b) | Int
+//│ ║  l.79: 	fun foo(x) = x is Pair(a, b) | Int
 //│ ╙──      	                             ^
 //│ ╔══[ERROR] Refininition of 'foo'
-//│ ║  l.76: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
+//│ ║  l.80: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] type identifier not found: |
-//│ ║  l.75: 	fun foo(x) = x is Pair(a, b) | Int
+//│ ║  l.79: 	fun foo(x) = x is Pair(a, b) | Int
 //│ ╙──      	                             ^
 //│ ╔══[ERROR] type identifier not found: |
-//│ ║  l.76: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
+//│ ║  l.80: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	                                         ^
 //│ fun foo: nothing -> error
 //│ fun foo: nothing -> error
diff --git a/shared/src/test/diff/ucs/SimpleUCS.mls b/shared/src/test/diff/ucs/SimpleUCS.mls
index 20bcad5495..8f76440d0b 100644
--- a/shared/src/test/diff/ucs/SimpleUCS.mls
+++ b/shared/src/test/diff/ucs/SimpleUCS.mls
@@ -326,7 +326,7 @@ fun f(x) =
 //│ ╔══[ERROR] Syntactic split of patterns are not supported
 //│ ║  l.324: 	    0 ::
 //│ ╙──       	      ^^
-//│ ╔══[ERROR] Found unexpected empty split
+//│ ╔══[ERROR] unexpected empty split found
 //│ ╙──
 //│ fun f: anything -> nothing
 
diff --git a/shared/src/test/diff/ucs/SplitAroundOp.mls b/shared/src/test/diff/ucs/SplitAroundOp.mls
index ddfeb3af0b..cf8c1d1792 100644
--- a/shared/src/test/diff/ucs/SplitAroundOp.mls
+++ b/shared/src/test/diff/ucs/SplitAroundOp.mls
@@ -64,7 +64,7 @@ if x is
 //│ ╔══[ERROR] identifier `x` not found
 //│ ║  l.38: 	if x is
 //│ ╙──      	   ^
-//│ ╔══[ERROR] Found unexpected empty split
+//│ ╔══[ERROR] unexpected empty split found
 //│ ╙──
 //│ ╔══[ERROR] identifier not found: x
 //│ ║  l.38: 	if x is
diff --git a/shared/src/test/diff/ucs/TrivialIf.mls b/shared/src/test/diff/ucs/TrivialIf.mls
index 555b4943e9..5f1c8070f5 100644
--- a/shared/src/test/diff/ucs/TrivialIf.mls
+++ b/shared/src/test/diff/ucs/TrivialIf.mls
@@ -78,15 +78,15 @@ fun foo(x) = if x is Some of
   0 then 0
   1 then 1
 //│ ╔══[PARSE ERROR] Unexpected 'then' keyword here
-//│ ║  l.79: 	  0 then 0
+//│ ║  l.78: 	  0 then 0
 //│ ╙──      	    ^^^^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'if'; found operator application instead
-//│ ║  l.78: 	fun foo(x) = if x is Some of
+//│ ║  l.77: 	fun foo(x) = if x is Some of
 //│ ║        	                ^^^^^^^^^^^^
-//│ ║  l.79: 	  0 then 0
+//│ ║  l.78: 	  0 then 0
 //│ ║        	^^^
 //│ ╟── Note: 'if' expression starts here:
-//│ ║  l.78: 	fun foo(x) = if x is Some of
+//│ ║  l.77: 	fun foo(x) = if x is Some of
 //│ ╙──      	             ^^
 //│ fun foo: Some[0] -> ()
 
diff --git a/shared/src/test/diff/ucs/WeirdIf.mls b/shared/src/test/diff/ucs/WeirdIf.mls
index c420f55445..53f0d57686 100644
--- a/shared/src/test/diff/ucs/WeirdIf.mls
+++ b/shared/src/test/diff/ucs/WeirdIf.mls
@@ -17,9 +17,14 @@ if else 0 else 1
 //│ res
 //│     = 0
 
-// FIXME
-// :w
+:w
 fun f(x) = if x is else 0 else 1
+//│ ╔══[WARNING] the case is unreachable
+//│ ║  l.21: 	fun f(x) = if x is else 0 else 1
+//│ ║        	                               ^
+//│ ╟── because this branch covers the case
+//│ ║  l.21: 	fun f(x) = if x is else 0 else 1
+//│ ╙──      	                        ^
 //│ fun f: anything -> 0
 
 fun f(x) = if x is else 0 
@@ -29,7 +34,7 @@ fun f(x) = if x is else 0
 if true
   then 0
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.30: 	  then 0
+//│ ║  l.35: 	  then 0
 //│ ║        	       ^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ 0
@@ -43,21 +48,21 @@ fun f(x) =
   if x ===
     else "bruh"
 //│ ╔══[PARSE ERROR] Unexpected indented block in expression position
-//│ ║  l.44: 	    else "bruh"
+//│ ║  l.49: 	    else "bruh"
 //│ ╙──      	^^^^
 //│ ╔══[PARSE ERROR] Unexpected end of indented block; an expression was expected here
-//│ ║  l.44: 	    else "bruh"
+//│ ║  l.49: 	    else "bruh"
 //│ ╙──      	    ^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'if'; found operator application instead
-//│ ║  l.43: 	  if x ===
+//│ ║  l.48: 	  if x ===
 //│ ║        	     ^^^^^
-//│ ║  l.44: 	    else "bruh"
+//│ ║  l.49: 	    else "bruh"
 //│ ║        	^^^^
 //│ ╟── Note: 'if' expression starts here:
-//│ ║  l.43: 	  if x ===
+//│ ║  l.48: 	  if x ===
 //│ ╙──      	  ^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.44: 	    else "bruh"
+//│ ║  l.49: 	    else "bruh"
 //│ ║        	    ^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun f: Eql[()] -> ()
diff --git a/shared/src/test/diff/ucs/Wildcard.mls b/shared/src/test/diff/ucs/Wildcard.mls
index ede975371c..9cc79fd9ce 100644
--- a/shared/src/test/diff/ucs/Wildcard.mls
+++ b/shared/src/test/diff/ucs/Wildcard.mls
@@ -98,13 +98,18 @@ w3(0, _ => false)
 //│ res
 //│     = 'r4'
 
-// :w
-// FIXME: Should warn this.
+:w
 // Decision paths:
 // + «tmp2 @ f (x,) is any => 0
 // +  => 1
 fun w3_1(x, f) =
   if f(x) is _ then 0 else 1
+//│ ╔══[WARNING] the case is unreachable
+//│ ║  l.106: 	  if f(x) is _ then 0 else 1
+//│ ║         	                           ^
+//│ ╟── because this branch covers the case
+//│ ║  l.106: 	  if f(x) is _ then 0 else 1
+//│ ╙──       	                    ^
 //│ fun w3_1: forall 'a. ('a, 'a -> anything) -> 0
 
 w3_1(0, _ => true)

From 3535960173738a467eff94ba5be09b030b7faa55 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sun, 14 Jan 2024 23:10:01 +0800
Subject: [PATCH 065/147] Support a kind of weird pattern

---
 .../scala/mlscript/ucs/stages/Transformation.scala    |  5 +++--
 shared/src/test/diff/gadt/Exp1.mls                    |  2 +-
 shared/src/test/diff/nu/ClassesInMixins.mls           |  2 +-
 shared/src/test/diff/nu/FunnyIndet.mls                | 11 ++---------
 shared/src/test/diff/pretyper/ucs/RecordPattern.mls   |  2 +-
 shared/src/test/diff/ucs/NuPlainConditionals.mls      |  6 +++---
 shared/src/test/diff/ucs/PlainConditionals.mls        |  6 +++---
 7 files changed, 14 insertions(+), 20 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index 5a6e1560a8..0e06184974 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -2,7 +2,7 @@ package mlscript.ucs.stages
 
 import mlscript.ucs.{DesugarUCS, helpers}
 import mlscript.{If, IfBody, IfBlock, IfElse, IfLet, IfOpApp, IfOpsApp, IfThen}
-import mlscript.{Term, Var, App, Tup, Lit, Fld, Loc}
+import mlscript.{Blk, Term, Var, App, Tup, Lit, Fld, Loc}
 import mlscript.Diagnostic.PreTyping
 import mlscript.pretyper.Traceable
 import mlscript.ucs.syntax._
@@ -205,9 +205,10 @@ trait Transformation { self: DesugarUCS with Traceable =>
     case App(classNme @ Var(_), parameters: Tup) =>
       ClassPattern(classNme, S(transformTupleTerm(parameters)), refined = false)
     case tuple: Tup => TuplePattern(transformTupleTerm(tuple))
+    case Blk((term: Term) :: Nil) => transformPattern(term) // A speical case for FunnyIndet.mls
     case other =>
       println(s"other $other")
-      raiseError(msg"Unknown pattern ${other.showDbg}" -> other.toLoc)
+      raiseError(msg"unknown pattern ${other.showDbg}" -> other.toLoc)
       EmptyPattern(other)
   }
 
diff --git a/shared/src/test/diff/gadt/Exp1.mls b/shared/src/test/diff/gadt/Exp1.mls
index d98bdcabc2..97db8501df 100644
--- a/shared/src/test/diff/gadt/Exp1.mls
+++ b/shared/src/test/diff/gadt/Exp1.mls
@@ -33,7 +33,7 @@ fun f(e) = if e is
 :e // TODO support
 fun f(e) = if e is
   Pair['a, 'b](l, r) then [l, r]
-//│ ╔══[ERROR] Unknown pattern Pair‹'a, 'b›(l, r,)
+//│ ╔══[ERROR] unknown pattern Pair‹'a, 'b›(l, r,)
 //│ ║  l.35: 	  Pair['a, 'b](l, r) then [l, r]
 //│ ╙──      	  ^^^^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] identifier `l` not found
diff --git a/shared/src/test/diff/nu/ClassesInMixins.mls b/shared/src/test/diff/nu/ClassesInMixins.mls
index c325820485..17169caf1e 100644
--- a/shared/src/test/diff/nu/ClassesInMixins.mls
+++ b/shared/src/test/diff/nu/ClassesInMixins.mls
@@ -41,7 +41,7 @@ M.Foo
 
 :e // TODO support
 fun foo(x) = if x is M.Foo then 1
-//│ ╔══[ERROR] Unknown pattern (M).Foo
+//│ ╔══[ERROR] unknown pattern (M).Foo
 //│ ║  l.43: 	fun foo(x) = if x is M.Foo then 1
 //│ ╙──      	                     ^^^^^
 //│ fun foo: anything -> 1
diff --git a/shared/src/test/diff/nu/FunnyIndet.mls b/shared/src/test/diff/nu/FunnyIndet.mls
index d01ba73b51..7f83313926 100644
--- a/shared/src/test/diff/nu/FunnyIndet.mls
+++ b/shared/src/test/diff/nu/FunnyIndet.mls
@@ -28,16 +28,9 @@
 //│     = 4
 
 
-:e // TODO support
-:w
 2 is
   2
-//│ ╔══[ERROR] Unknown pattern {2}
-//│ ║  l.34: 	  2
-//│ ╙──      	  ^
-//│ ╔══[WARNING] the case is unreachable
-//│ ╙── because this branch covers the case
-//│ true
+//│ Bool
 //│ res
 //│     = true
 
@@ -64,7 +57,7 @@ if 2 is
 2 then true
 1 then false
 //│ ╔══[PARSE ERROR] Unexpected 'then'/'else' clause
-//│ ║  l.65: 	1 then false
+//│ ║  l.58: 	1 then false
 //│ ╙──      	^^^^^^^^^^^^
 //│ ()
 //│ res
diff --git a/shared/src/test/diff/pretyper/ucs/RecordPattern.mls b/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
index ef6726ea58..21f57ff2db 100644
--- a/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
+++ b/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
@@ -6,7 +6,7 @@ fun take_1(p) =
   if p is
     { x, y } then x + y
     else 0
-//│ ╔══[ERROR] Unknown pattern '{' {x: x, y: y} '}'
+//│ ╔══[ERROR] unknown pattern '{' {x: x, y: y} '}'
 //│ ║  l.7: 	    { x, y } then x + y
 //│ ╙──     	    ^^^^^^^^
 //│ ╔══[WARNING] the case is unreachable
diff --git a/shared/src/test/diff/ucs/NuPlainConditionals.mls b/shared/src/test/diff/ucs/NuPlainConditionals.mls
index 9844b82f28..e0406c2480 100644
--- a/shared/src/test/diff/ucs/NuPlainConditionals.mls
+++ b/shared/src/test/diff/ucs/NuPlainConditionals.mls
@@ -53,7 +53,7 @@ fun foo(x) = if x is Pair(a, b) then a > b else false
 fun foo(x) = x is
   Pair
   Int
-//│ ╔══[ERROR] Unknown pattern {Pair; Int}
+//│ ╔══[ERROR] unknown pattern {Pair; Int}
 //│ ║  l.54: 	  Pair
 //│ ║        	  ^^^^
 //│ ║  l.55: 	  Int
@@ -66,7 +66,7 @@ fun foo(x) = x is
 fun foo(x) = x is
   Pair(a, b) and a > b
   Int
-//│ ╔══[ERROR] Unknown pattern {and(Pair(a, b,), >(a, b,),); Int}
+//│ ╔══[ERROR] unknown pattern {and(Pair(a, b,), >(a, b,),); Int}
 //│ ║  l.67: 	  Pair(a, b) and a > b
 //│ ║        	  ^^^^^^^^^^^^^^^^^^^^
 //│ ║  l.68: 	  Int
@@ -78,7 +78,7 @@ fun foo(x) = x is
 // TODO support `|`
 fun foo1(x) = x is Pair(a, b) | Int
 fun foo2(x) = x is (Pair(a, b) and a > b) | Int
-//│ ╔══[ERROR] Unknown pattern '(' and(Pair(a, b,), >(a, b,),) ')'
+//│ ╔══[ERROR] unknown pattern '(' and(Pair(a, b,), >(a, b,),) ')'
 //│ ║  l.80: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	                   ^^^^^^^^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] type identifier `|` not found
diff --git a/shared/src/test/diff/ucs/PlainConditionals.mls b/shared/src/test/diff/ucs/PlainConditionals.mls
index 63e30e6c17..ce5a34a5f6 100644
--- a/shared/src/test/diff/ucs/PlainConditionals.mls
+++ b/shared/src/test/diff/ucs/PlainConditionals.mls
@@ -53,7 +53,7 @@ fun foo(x) = if x is Pair(a, b) then a > b else false
 fun foo(x) = x is
   Pair
   Int
-//│ ╔══[ERROR] Unknown pattern {Pair; Int}
+//│ ╔══[ERROR] unknown pattern {Pair; Int}
 //│ ║  l.54: 	  Pair
 //│ ║        	  ^^^^
 //│ ║  l.55: 	  Int
@@ -66,7 +66,7 @@ fun foo(x) = x is
 fun foo(x) = x is
   Pair(a, b) and a > b
   Int
-//│ ╔══[ERROR] Unknown pattern {and(Pair(a, b,), >(a, b,),); Int}
+//│ ╔══[ERROR] unknown pattern {and(Pair(a, b,), >(a, b,),); Int}
 //│ ║  l.67: 	  Pair(a, b) and a > b
 //│ ║        	  ^^^^^^^^^^^^^^^^^^^^
 //│ ║  l.68: 	  Int
@@ -78,7 +78,7 @@ fun foo(x) = x is
 // TODO support `|`
 fun foo(x) = x is Pair(a, b) | Int
 fun foo(x) = x is (Pair(a, b) and a > b) | Int
-//│ ╔══[ERROR] Unknown pattern '(' and(Pair(a, b,), >(a, b,),) ')'
+//│ ╔══[ERROR] unknown pattern '(' and(Pair(a, b,), >(a, b,),) ')'
 //│ ║  l.80: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	                  ^^^^^^^^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] type identifier `|` not found

From 12bd4147d3c7348a4a5a81f268afb40ea3e8e5a9 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Mon, 15 Jan 2024 00:10:51 +0800
Subject: [PATCH 066/147] Report unreachable cases and missing else branches

---
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |  20 +--
 .../ucs/stages/CoverageChecking.scala         |   7 +-
 .../mlscript/ucs/stages/Normalization.scala   |  41 ++++--
 .../src/main/scala/mlscript/ucs/syntax.scala  |   6 -
 shared/src/test/diff/ucs/AppSplits.mls        |  33 +++--
 .../src/test/diff/ucs/CrossBranchCapture.mls  |  10 +-
 shared/src/test/diff/ucs/HygienicBindings.mls |  12 +-
 shared/src/test/diff/ucs/SplitAfterOp.mls     | 125 ++++++++++--------
 shared/src/test/diff/ucs/SplitAnd.mls         |  32 +++--
 shared/src/test/diff/ucs/SplitBeforeOp.mls    |  48 ++++---
 shared/src/test/diff/ucs/SplitOps.mls         |  22 +--
 shared/src/test/diff/ucs/ThenIndent.mls       |   3 +
 shared/src/test/diff/ucs/TrivialIf.mls        |  18 ++-
 shared/src/test/diff/ucs/WeirdIf.mls          |  39 ++++--
 shared/src/test/diff/ucs/Wildcard.mls         |  52 ++++++--
 todo.md                                       |   8 +-
 16 files changed, 301 insertions(+), 175 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index facff56d96..1b5d49c7d5 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -138,14 +138,18 @@ trait DesugarUCS extends Transformation
   }
 
   protected implicit class SourceSplitOps[+B <: s.Branch](these: s.Split[B]) {
-    def ++[BB >: B <: s.Branch](those: s.Split[BB]): s.Split[BB] = these match {
-      case s.Split.Cons(head, tail) => s.Split.Cons(head, tail ++ those)
-      case s.Split.Let(rec, nme, rhs, tail) => s.Split.Let(rec, nme, rhs, tail ++ those)
-      case s.Split.Else(_) =>
-        raiseWarning(msg"unreachable case" -> these.toLoc)
-        these
-      case s.Split.Nil => those
-    }
+    def ++[BB >: B <: s.Branch](those: s.Split[BB]): s.Split[BB] =
+      if (those === s.Split.Nil) these else (these match {
+        case s.Split.Cons(head, tail) => s.Split.Cons(head, tail ++ those)
+        case s.Split.Let(rec, nme, rhs, tail) => s.Split.Let(rec, nme, rhs, tail ++ those)
+        case s.Split.Else(_) =>
+          raiseWarning(
+            msg"unreachable case" -> those.toLoc,
+            msg"because this branch covers the case" -> these.toLoc
+          )
+          these
+        case s.Split.Nil => those
+      })
   }
 
   protected implicit class CoreSplitOps(these: c.Split) {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index 1ac919598d..b3dfc2a0a1 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -3,11 +3,13 @@ package mlscript.ucs.stages
 import mlscript.{Case, CaseBranches, CaseOf, Let, Lit, Loc, NoCases, Term, Var, Wildcard}
 import mlscript.{Diagnostic, ErrorReport, WarningReport}
 import mlscript.Message, Message.MessageContext
+import mlscript.ucs.DesugarUCS
 import mlscript.ucs.context.{Context, CaseSet, NamedScrutineeData, MatchRegistry, ScrutineeData, SeenRegistry}
+import mlscript.pretyper.Traceable
 import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
 
-trait CoverageChecking { self: mlscript.pretyper.Traceable =>
+trait CoverageChecking { self: DesugarUCS with Traceable =>
   import CoverageChecking._
 
   def checkCoverage(term: Term)(implicit context: Context): Ls[Diagnostic] = {
@@ -28,6 +30,9 @@ trait CoverageChecking { self: mlscript.pretyper.Traceable =>
       ))
       term match {
         case Let(_, _, _, body) => checkCoverage(body, pending, working, seen)
+        case CaseOf(scrutineeVar: Var, Case(Var("true"), body, NoCases)) if context.isTestVar(scrutineeVar) =>
+          raiseError(msg"missing else branch" -> body.toLoc)
+          Nil
         case CaseOf(ScrutineeData.WithVar(scrutinee, scrutineeVar), cases) =>
           println(s"scrutinee: ${scrutineeVar.name}")
           // If the scrutinee is still pending (i.e., not matched yet), then we
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index b038862c75..07d1ad2345 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -21,9 +21,18 @@ trait Normalization { self: DesugarUCS with Traceable =>
   private def fillImpl(these: Split, those: Split, deep: Bool)(implicit
       scope: Scope,
       context: Context,
-      generatedVars: Set[Var]
+      generatedVars: Set[Var],
+      shouldReportDiscarded: Bool
   ): Split =
-    if (these.hasElse) these else (these match {
+    if (these.hasElse) {
+      if (those =/= Split.Nil && shouldReportDiscarded) {
+        raiseWarning(
+          msg"the case is unreachable" -> those.toLoc,
+          msg"because this branch already covers the case" -> these.toLoc
+        )
+      }
+      these
+    } else (these match {
       case these @ Split.Cons(head, tail) =>
         if (head.continuation.hasElse || !deep) {
           these.copy(tail = fillImpl(tail, those, deep))
@@ -40,7 +49,7 @@ trait Normalization { self: DesugarUCS with Traceable =>
           val concatenated = these.copy(tail = fillImpl(tail, thoseWithShadowed, deep))
           Split.Let(false, fresh, nme, concatenated)
         } else {
-          these.copy(tail = fillImpl(tail, those, deep)(scope, context, generatedVars + nme))
+          these.copy(tail = fillImpl(tail, those, deep)(scope, context, generatedVars + nme, false))
         }
       case _: Split.Else => these
       case Split.Nil =>
@@ -49,11 +58,25 @@ trait Normalization { self: DesugarUCS with Traceable =>
     })
 
   private implicit class SplitOps(these: Split) {
-    def fill(those: Split, deep: Bool)(implicit scope: Scope, context: Context, generatedVars: Set[Var]): Split =
+    /**
+      * Fill the split into the previous split. 
+      *
+      * @param those the split to append
+      * @param deep whether we should also fill the leading branches
+      * @param shouldReportDiscarded whether we should raise an error if the given
+      *                        split is discarded because of the else branch
+      * @param generatedVars the generated variables which have been declared
+      * @return the concatenated split
+      */
+    def fill(those: Split, deep: Bool, shouldReportDiscarded: Bool)(implicit
+        scope: Scope,
+        context: Context,
+        generatedVars: Set[Var],
+    ): Split =
       trace(s"fill <== ${generatedVars.iterator.map(_.name).mkString("{", ", ", "}")}") {
         println(s"LHS: ${showSplit(these)}")
         println(s"RHS: ${showSplit(those)}")
-        fillImpl(these, those, deep)
+        fillImpl(these, those, deep)(scope, context, generatedVars, shouldReportDiscarded)
       }(sp => s"fill ==> ${showSplit(sp)}")
 
     def :++(tail: => Split): Split = {
@@ -90,17 +113,17 @@ trait Normalization { self: DesugarUCS with Traceable =>
       case Split.Cons(Branch(scrutinee, Pattern.Name(nme), continuation), tail) =>
         println(s"ALIAS: ${scrutinee.name} is ${nme.name}")
         val (wrap, realTail) = preventShadowing(nme, tail)
-        wrap(Let(false, nme, scrutinee, normalizeToTerm(continuation.fill(realTail, deep = false))))
+        wrap(Let(false, nme, scrutinee, normalizeToTerm(continuation.fill(realTail, false, true))))
       // Skip Boolean conditions as scrutinees, because they only appear once.
       case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true"), _), continuation), tail) =>
         println(s"TRUE: ${test.name} is true")
-        val trueBranch = normalizeToTerm(continuation.fill(tail, deep = false))
+        val trueBranch = normalizeToTerm(continuation.fill(tail, false, false))
         val falseBranch = normalizeToCaseBranches(tail)
         CaseOf(test, Case(nme, trueBranch, falseBranch)(refined = false))
       case Split.Cons(Branch(ScrutineeData.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Literal(literal), continuation), tail) =>
         println(s"LITERAL: ${scrutineeVar.name} is ${literal.idStr}")
         println(s"entire split: ${showSplit(split)}")
-        val concatenatedTrueBranch = continuation.fill(tail, deep = false)
+        val concatenatedTrueBranch = continuation.fill(tail, false, false)
         // println(s"true branch: ${showSplit(concatenatedTrueBranch)}")
         val trueBranch = normalizeToTerm(specialize(concatenatedTrueBranch, true)(scrutineeVar, scrutinee, pattern, context))
         // println(s"false branch: ${showSplit(tail)}")
@@ -109,7 +132,7 @@ trait Normalization { self: DesugarUCS with Traceable =>
       case Split.Cons(Branch(ScrutineeData.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Class(nme, rfd), continuation), tail) =>
         println(s"CLASS: ${scrutineeVar.name} is ${nme.name}")
         // println(s"match ${scrutineeVar.name} with $nme (has location: ${nme.toLoc.isDefined})")
-        val trueBranch = normalizeToTerm(specialize(continuation.fill(tail, deep = false), true)(scrutineeVar, scrutinee, pattern, context))
+        val trueBranch = normalizeToTerm(specialize(continuation.fill(tail, false, false), true)(scrutineeVar, scrutinee, pattern, context))
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context))
         CaseOf(scrutineeVar, Case(nme, trueBranch, falseBranch)(refined = pattern.refined))
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
diff --git a/shared/src/main/scala/mlscript/ucs/syntax.scala b/shared/src/main/scala/mlscript/ucs/syntax.scala
index 5fd255674d..afbef74f66 100644
--- a/shared/src/main/scala/mlscript/ucs/syntax.scala
+++ b/shared/src/main/scala/mlscript/ucs/syntax.scala
@@ -52,12 +52,6 @@ package object syntax {
   }
 
   sealed abstract class Split[+SomeBranch <: Branch] extends Located {
-    def ++[OtherBranch >: SomeBranch <: Branch](that: Split[OtherBranch]): Split[OtherBranch] = this match {
-      case Split.Cons(head, tail) => Split.Cons(head, tail ++ that)
-      case Split.Let(rec, nme, rhs, tail) => Split.Let(rec, nme, rhs, tail ++ that)
-      case Split.Else(_) => this
-      case Split.Nil => that
-    }
     def ::[OtherBranch >: SomeBranch <: Branch](head: OtherBranch): Split[OtherBranch] = Split.Cons(head, this)
   }
   object Split {
diff --git a/shared/src/test/diff/ucs/AppSplits.mls b/shared/src/test/diff/ucs/AppSplits.mls
index 99caea2510..fe952e5f8b 100644
--- a/shared/src/test/diff/ucs/AppSplits.mls
+++ b/shared/src/test/diff/ucs/AppSplits.mls
@@ -20,6 +20,9 @@ if foo of
 //│ ╟── Note: 'if' expression starts here:
 //│ ║  l.9: 	if foo of
 //│ ╙──     	^^
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.10: 	  0 then "a"
+//│ ╙──      	  ^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
 //│ ║  l.10: 	  0 then "a"
 //│ ║        	  ^
@@ -35,30 +38,33 @@ if foo of 1,
   0 then "a"
   1 then "b"
 //│ ╔══[PARSE ERROR] Unexpected 'then'/'else' clause
-//│ ║  l.35: 	  0 then "a"
+//│ ║  l.38: 	  0 then "a"
 //│ ║        	  ^^^^^^^^^^
-//│ ║  l.36: 	  1 then "b"
+//│ ║  l.39: 	  1 then "b"
 //│ ╙──      	^^^^^^^^^^^^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'if'; found application instead
-//│ ║  l.34: 	if foo of 1,
+//│ ║  l.37: 	if foo of 1,
 //│ ║        	   ^^^^^^^^^
-//│ ║  l.35: 	  0 then "a"
+//│ ║  l.38: 	  0 then "a"
 //│ ║        	^^
 //│ ╟── Note: 'if' expression starts here:
-//│ ║  l.34: 	if foo of 1,
+//│ ║  l.37: 	if foo of 1,
 //│ ╙──      	^^
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.38: 	  0 then "a"
+//│ ╙──      	  ^
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.34: 	if foo of 1,
+//│ ║  l.37: 	if foo of 1,
 //│ ║        	   ^^^^^^^^^
-//│ ║  l.35: 	  0 then "a"
+//│ ║  l.38: 	  0 then "a"
 //│ ║        	^^
 //│ ╟── argument list of type `[1, ()]` does not match type `[?a]`
-//│ ║  l.34: 	if foo of 1,
+//│ ║  l.37: 	if foo of 1,
 //│ ║        	          ^^
-//│ ║  l.35: 	  0 then "a"
+//│ ║  l.38: 	  0 then "a"
 //│ ╙──      	^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.35: 	  0 then "a"
+//│ ║  l.38: 	  0 then "a"
 //│ ║        	  ^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ ()
@@ -72,10 +78,13 @@ if foo
   (0) then "a"
   (1) then "b"
 //│ ╔══[PARSE ERROR] Unexpected parenthesis section here
-//│ ║  l.73: 	  (1) then "b"
+//│ ║  l.79: 	  (1) then "b"
 //│ ╙──      	  ^^^
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.78: 	  (0) then "a"
+//│ ╙──      	           ^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.72: 	  (0) then "a"
+//│ ║  l.78: 	  (0) then "a"
 //│ ║        	           ^^^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ "a"
diff --git a/shared/src/test/diff/ucs/CrossBranchCapture.mls b/shared/src/test/diff/ucs/CrossBranchCapture.mls
index ac96606b73..740f0f6318 100644
--- a/shared/src/test/diff/ucs/CrossBranchCapture.mls
+++ b/shared/src/test/diff/ucs/CrossBranchCapture.mls
@@ -1,7 +1,7 @@
 :PreTyper
 
-fun (~~>) expect(a, b) = if a is b then () else error
-//│ fun (~~>) expect: (anything, anything) -> ()
+fun (~~>) expect(a, b) = if a === b then () else error
+//│ fun (~~>) expect: forall 'a. (Eql['a], 'a) -> ()
 
 class Numb(n: Int)
 //│ class Numb(n: Int)
@@ -13,7 +13,7 @@ fun process(e) =
     Numb(n) and n > 0 then n
     Numb(m) then n
 //│ ╔══[ERROR] identifier `n` not found
-//│ ║  l.14: 	    Numb(m) then n
+//│ ║  l.21: 	    Numb(m) then n
 //│ ╙──      	                 ^
 //│ fun process: Numb -> Int
 
@@ -58,10 +58,10 @@ fun process(e) =
     Pair(Vec(n),  Numb(n)) then n
     Pair(Numb(n), Vec(n))  then n
 //│ ╔══[ERROR] identifier `n` not found
-//│ ║  l.57: 	    Pair(Vec(xs), Vec(ys))  then n
+//│ ║  l.64: 	    Pair(Vec(xs), Vec(ys))  then n
 //│ ╙──      	                                 ^
 //│ ╔══[ERROR] identifier not found: n
-//│ ║  l.57: 	    Pair(Vec(xs), Vec(ys))  then n
+//│ ║  l.64: 	    Pair(Vec(xs), Vec(ys))  then n
 //│ ╙──      	                                 ^
 //│ fun process: Pair[Numb | Vec, Numb | Vec] -> (Int | Numb | error)
 //│ Code generation encountered an error:
diff --git a/shared/src/test/diff/ucs/HygienicBindings.mls b/shared/src/test/diff/ucs/HygienicBindings.mls
index 622a1f2bf6..e7740ea70c 100644
--- a/shared/src/test/diff/ucs/HygienicBindings.mls
+++ b/shared/src/test/diff/ucs/HygienicBindings.mls
@@ -1,7 +1,7 @@
 :PreTyper
 
-fun (~~>) expect(a, b) = if a is b then () else error
-//│ fun (~~>) expect: (anything, anything) -> ()
+fun (~~>) expect(a, b) = if a === b then () else error
+//│ fun (~~>) expect: forall 'a. (Eql['a], 'a) -> ()
 
 type Option[out T] = None | Some[T]
 module None
@@ -145,14 +145,18 @@ fun h4(x, y, p) =
 //│ fun h4: forall 'a 'b. (Object & 'a, 'b, 'a -> Bool) -> ("default" | 'a | 'b)
 
 h4("should be me", "not me", _ => true) ~~> "should be me"
-h4(None, "not me", _ => true) ~~> None
+h4(None, "not me", _ => true)
 h4(None, "should be me", _ => false) ~~> "should be me"
 h4("anything", "not me", _ => false) ~~> "default"
+//│ ╔══[ERROR] Module 'None' does not support equality comparison because it does not have a parameter list
+//│ ║  l.149: 	h4(None, "should be me", _ => false) ~~> "should be me"
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ TEST CASE FAILURE: There was an unexpected type error
 //│ ()
 //│ res
 //│     = undefined
 //│ res
-//│     = undefined
+//│     = None { class: [class None] }
 //│ res
 //│     = undefined
 //│ res
diff --git a/shared/src/test/diff/ucs/SplitAfterOp.mls b/shared/src/test/diff/ucs/SplitAfterOp.mls
index 8ef383c138..8ff3a4ca99 100644
--- a/shared/src/test/diff/ucs/SplitAfterOp.mls
+++ b/shared/src/test/diff/ucs/SplitAfterOp.mls
@@ -4,6 +4,9 @@
 fun f(x, b) =
   if x == 
     0 and b then 0
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.6: 	    0 and b then 0
+//│ ╙──     	          ^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
 //│ ║  l.6: 	    0 and b then 0
 //│ ║       	                 ^
@@ -20,29 +23,29 @@ fun f(x, y) =
     5 then 0
     7 then 0
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.19: 	  if x == y +
+//│ ║  l.22: 	  if x == y +
 //│ ║        	            ^
-//│ ║  l.20: 	    5 then 0
+//│ ║  l.23: 	    5 then 0
 //│ ║        	^^^^^
 //│ ╟── operator application of type `Bool` is not an instance of type `Int`
-//│ ║  l.19: 	  if x == y +
+//│ ║  l.22: 	  if x == y +
 //│ ╙──      	     ^^^^^^
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.19: 	  if x == y +
+//│ ║  l.22: 	  if x == y +
 //│ ║        	            ^
-//│ ║  l.20: 	    5 then 0
+//│ ║  l.23: 	    5 then 0
 //│ ║        	^^^^^
 //│ ╙── application of type `Int` is not an instance of type `Bool`
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.19: 	  if x == y +
+//│ ║  l.22: 	  if x == y +
 //│ ║        	            ^
-//│ ║  l.20: 	    5 then 0
+//│ ║  l.23: 	    5 then 0
 //│ ║        	^^^^^^^^^^^^^
-//│ ║  l.21: 	    7 then 0
+//│ ║  l.24: 	    7 then 0
 //│ ║        	^^^^^
 //│ ╙── application of type `Int` is not an instance of type `Bool`
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.21: 	    7 then 0
+//│ ║  l.24: 	    7 then 0
 //│ ║        	           ^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun f: (Num, Num) -> 0
@@ -53,39 +56,39 @@ fun f(x, y) =
     5 then 0
     6 + 7 then 0
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.52: 	  if x == y *
+//│ ║  l.55: 	  if x == y *
 //│ ║        	            ^
-//│ ║  l.53: 	    5 then 0
+//│ ║  l.56: 	    5 then 0
 //│ ║        	^^^^^
 //│ ╟── operator application of type `Bool` is not an instance of type `Int`
-//│ ║  l.52: 	  if x == y *
+//│ ║  l.55: 	  if x == y *
 //│ ╙──      	     ^^^^^^
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.52: 	  if x == y *
+//│ ║  l.55: 	  if x == y *
 //│ ║        	            ^
-//│ ║  l.53: 	    5 then 0
+//│ ║  l.56: 	    5 then 0
 //│ ║        	^^^^^
 //│ ╙── application of type `Int` is not an instance of type `Bool`
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.52: 	  if x == y *
+//│ ║  l.55: 	  if x == y *
 //│ ║        	            ^
-//│ ║  l.53: 	    5 then 0
+//│ ║  l.56: 	    5 then 0
 //│ ║        	^^^^^^^^^^^^^
-//│ ║  l.54: 	    6 + 7 then 0
+//│ ║  l.57: 	    6 + 7 then 0
 //│ ║        	^^^^^^^^^
 //│ ╟── operator application of type `Bool` is not an instance of type `Int`
-//│ ║  l.52: 	  if x == y *
+//│ ║  l.55: 	  if x == y *
 //│ ╙──      	     ^^^^^^
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.52: 	  if x == y *
+//│ ║  l.55: 	  if x == y *
 //│ ║        	            ^
-//│ ║  l.53: 	    5 then 0
+//│ ║  l.56: 	    5 then 0
 //│ ║        	^^^^^^^^^^^^^
-//│ ║  l.54: 	    6 + 7 then 0
+//│ ║  l.57: 	    6 + 7 then 0
 //│ ║        	^^^^^^^^^
 //│ ╙── application of type `Int` is not an instance of type `Bool`
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.54: 	    6 + 7 then 0
+//│ ║  l.57: 	    6 + 7 then 0
 //│ ║        	               ^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun f: (Num, Num) -> 0
@@ -97,32 +100,32 @@ fun f(x, y) =
       5 then 0
       7 then 0
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.96: 	    y +
+//│ ║  l.99: 	    y +
 //│ ║        	      ^
-//│ ║  l.97: 	      5 then 0
-//│ ║        	^^^^^^^
+//│ ║  l.100: 	      5 then 0
+//│ ║         	^^^^^^^
 //│ ╟── operator application of type `Bool` is not an instance of type `Int`
-//│ ║  l.95: 	  if x ==
+//│ ║  l.98: 	  if x ==
 //│ ║        	     ^^^^
-//│ ║  l.96: 	    y +
+//│ ║  l.99: 	    y +
 //│ ╙──      	^^^^^^
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.96: 	    y +
+//│ ║  l.99: 	    y +
 //│ ║        	      ^
-//│ ║  l.97: 	      5 then 0
-//│ ║        	^^^^^^^
+//│ ║  l.100: 	      5 then 0
+//│ ║         	^^^^^^^
 //│ ╙── application of type `Int` is not an instance of type `Bool`
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.96: 	    y +
+//│ ║  l.99: 	    y +
 //│ ║        	      ^
-//│ ║  l.97: 	      5 then 0
-//│ ║        	^^^^^^^^^^^^^^
-//│ ║  l.98: 	      7 then 0
-//│ ║        	^^^^^^^
+//│ ║  l.100: 	      5 then 0
+//│ ║         	^^^^^^^^^^^^^^
+//│ ║  l.101: 	      7 then 0
+//│ ║         	^^^^^^^
 //│ ╙── application of type `Int` is not an instance of type `Bool`
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.98: 	      7 then 0
-//│ ║        	             ^
+//│ ║  l.101: 	      7 then 0
+//│ ║         	             ^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun f: (Num, Num) -> 0
 
@@ -130,12 +133,15 @@ fun f(x, y) =
 fun f(x, b) =
   if x ==
     1 and b then 0
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.135: 	    1 and b then 0
+//│ ╙──       	          ^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.132: 	    1 and b then 0
+//│ ║  l.135: 	    1 and b then 0
 //│ ║         	                 ^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.132: 	    1 and b then 0
+//│ ║  l.135: 	    1 and b then 0
 //│ ║         	          ^^^^^^^^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun f: (Num, Bool) -> 0
@@ -147,15 +153,15 @@ fun toEnglish(x) =
     true then "t"
     0 then "z"
 //│ ╔══[ERROR] Type mismatch in operator application:
-//│ ║  l.146: 	  if x ==
+//│ ║  l.152: 	  if x ==
 //│ ║         	     ^^^^
-//│ ║  l.147: 	    true then "t"
+//│ ║  l.153: 	    true then "t"
 //│ ║         	^^^^^^^^
 //│ ╟── reference of type `true` is not an instance of `Num`
-//│ ║  l.147: 	    true then "t"
+//│ ║  l.153: 	    true then "t"
 //│ ╙──       	    ^^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.148: 	    0 then "z"
+//│ ║  l.154: 	    0 then "z"
 //│ ║         	           ^^^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun toEnglish: Num -> ("t" | "z")
@@ -166,17 +172,17 @@ fun toEnglish(x) =
     0 then "z"
     true then "t"
 //│ ╔══[ERROR] Type mismatch in operator application:
-//│ ║  l.165: 	  if x ==
+//│ ║  l.171: 	  if x ==
 //│ ║         	     ^^^^
-//│ ║  l.166: 	    0 then "z"
+//│ ║  l.172: 	    0 then "z"
 //│ ║         	^^^^^^^^^^^^^^
-//│ ║  l.167: 	    true then "t"
+//│ ║  l.173: 	    true then "t"
 //│ ║         	^^^^^^^^
 //│ ╟── reference of type `true` is not an instance of `Num`
-//│ ║  l.167: 	    true then "t"
+//│ ║  l.173: 	    true then "t"
 //│ ╙──       	    ^^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.167: 	    true then "t"
+//│ ║  l.173: 	    true then "t"
 //│ ║         	              ^^^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun toEnglish: Num -> ("t" | "z")
@@ -187,7 +193,7 @@ fun toEnglish(x) =
     1 then "o"
     0 then "z"
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.188: 	    0 then "z"
+//│ ║  l.194: 	    0 then "z"
 //│ ║         	           ^^^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun toEnglish: Num -> ("o" | "z")
@@ -204,29 +210,32 @@ fun toEnglish(x) =
   if x ==
     else 1
 //│ ╔══[PARSE ERROR] Unexpected indented block in expression position
-//│ ║  l.205: 	    else 1
+//│ ║  l.211: 	    else 1
 //│ ╙──       	^^^^
 //│ ╔══[PARSE ERROR] Unexpected end of indented block; an expression was expected here
-//│ ║  l.205: 	    else 1
+//│ ║  l.211: 	    else 1
 //│ ╙──       	    ^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'if'; found operator application instead
-//│ ║  l.204: 	  if x ==
+//│ ║  l.210: 	  if x ==
 //│ ║         	     ^^^^
-//│ ║  l.205: 	    else 1
+//│ ║  l.211: 	    else 1
 //│ ║         	^^^^
 //│ ╟── Note: 'if' expression starts here:
-//│ ║  l.204: 	  if x ==
+//│ ║  l.210: 	  if x ==
 //│ ╙──       	  ^^
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.211: 	    else 1
+//│ ╙──       	    ^
 //│ ╔══[ERROR] Type mismatch in operator application:
-//│ ║  l.204: 	  if x ==
+//│ ║  l.210: 	  if x ==
 //│ ║         	     ^^^^
-//│ ║  l.205: 	    else 1
+//│ ║  l.211: 	    else 1
 //│ ║         	^^^^
 //│ ╟── undefined literal of type `()` is not an instance of type `Num`
-//│ ║  l.205: 	    else 1
+//│ ║  l.211: 	    else 1
 //│ ╙──       	    ^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.205: 	    else 1
+//│ ║  l.211: 	    else 1
 //│ ║         	    ^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun toEnglish: Num -> ()
diff --git a/shared/src/test/diff/ucs/SplitAnd.mls b/shared/src/test/diff/ucs/SplitAnd.mls
index f615affb2d..b40269f034 100644
--- a/shared/src/test/diff/ucs/SplitAnd.mls
+++ b/shared/src/test/diff/ucs/SplitAnd.mls
@@ -13,7 +13,6 @@ class B()
 //│ class B()
 
 :e
-// TODO: Should report missing else branches.
 fun f(x) =
   if x == 0 and
     x is
@@ -21,31 +20,46 @@ fun f(x) =
       B() then "B"
     x == 0 then "lol"
     else "bruh"
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.18: 	    x is
+//│ ║        	    ^^^^
+//│ ║  l.19: 	      A() then "A"
+//│ ║        	^^^^^^^^^^^^^^^^^^
+//│ ║  l.20: 	      B() then "B"
+//│ ║        	^^^^^^^^^^^^^^^^^^
+//│ ║  l.21: 	    x == 0 then "lol"
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.22: 	    else "bruh"
+//│ ╙──      	^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.19: 	    x is
+//│ ║  l.18: 	    x is
 //│ ║        	    ^^^^
-//│ ║  l.20: 	      A() then "A"
+//│ ║  l.19: 	      A() then "A"
 //│ ║        	^^^^^^^^^^^^^^^^^^
-//│ ║  l.21: 	      B() then "B"
+//│ ║  l.20: 	      B() then "B"
 //│ ║        	^^^^^^^^^^^^^^^^^^
-//│ ║  l.22: 	    x == 0 then "lol"
+//│ ║  l.21: 	    x == 0 then "lol"
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.23: 	    else "bruh"
+//│ ║  l.22: 	    else "bruh"
 //│ ║        	^^^^^^^^^^^^^^^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun f: Num -> ("A" | "B" | "bruh" | "lol")
 
 :e
-// TODO: Should report missing else branches.
 fun f(x, y) =
   if
     x == 0 and
       y == 0 then "bruh"
       else "lol"
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.52: 	      y == 0 then "bruh"
+//│ ║        	      ^^^^^^^^^^^^^^^^^^
+//│ ║  l.53: 	      else "lol"
+//│ ╙──      	^^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.43: 	      y == 0 then "bruh"
+//│ ║  l.52: 	      y == 0 then "bruh"
 //│ ║        	      ^^^^^^^^^^^^^^^^^^
-//│ ║  l.44: 	      else "lol"
+//│ ║  l.53: 	      else "lol"
 //│ ║        	^^^^^^^^^^^^^^^^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun f: (Num, Num) -> ("bruh" | "lol")
diff --git a/shared/src/test/diff/ucs/SplitBeforeOp.mls b/shared/src/test/diff/ucs/SplitBeforeOp.mls
index 0c6cc6dafe..c4bd59a493 100644
--- a/shared/src/test/diff/ucs/SplitBeforeOp.mls
+++ b/shared/src/test/diff/ucs/SplitBeforeOp.mls
@@ -7,6 +7,9 @@ if x
 //│ ╔══[ERROR] identifier `x` not found
 //│ ║  l.5: 	if x
 //│ ╙──     	   ^
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.6: 	  == 0 then 0
+//│ ╙──     	            ^
 //│ ╔══[ERROR] identifier not found: x
 //│ ║  l.5: 	if x
 //│ ╙──     	   ^
@@ -24,22 +27,25 @@ if x
   is A and
     y then 0
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.23: 	if x
+//│ ║  l.26: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] type identifier `A` not found
-//│ ║  l.24: 	  is A and
+//│ ║  l.27: 	  is A and
 //│ ╙──      	     ^
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.23: 	if x
+//│ ║  l.26: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.25: 	    y then 0
+//│ ║  l.28: 	    y then 0
 //│ ╙──      	    ^
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.28: 	    y then 0
+//│ ╙──      	           ^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.23: 	if x
+//│ ║  l.26: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] type identifier not found: A
-//│ ║  l.24: 	  is A and
+//│ ║  l.27: 	  is A and
 //│ ╙──      	     ^
 //│ error
 //│ Code generation encountered an error:
@@ -52,22 +58,22 @@ if x
     y then 0
 else 1
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.50: 	if x
+//│ ║  l.56: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] type identifier `A` not found
-//│ ║  l.51: 	  is A and
+//│ ║  l.57: 	  is A and
 //│ ╙──      	     ^
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.50: 	if x
+//│ ║  l.56: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.52: 	    y then 0
+//│ ║  l.58: 	    y then 0
 //│ ╙──      	    ^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.50: 	if x
+//│ ║  l.56: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] type identifier not found: A
-//│ ║  l.51: 	  is A and
+//│ ║  l.57: 	  is A and
 //│ ╙──      	     ^
 //│ error
 //│ Code generation encountered an error:
@@ -81,31 +87,31 @@ if x
     A() then "A"
     B() then "B"
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.78: 	if x
+//│ ║  l.84: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] type identifier `A` not found
-//│ ║  l.81: 	    A() then "A"
+//│ ║  l.87: 	    A() then "A"
 //│ ╙──      	    ^
 //│ ╔══[ERROR] type identifier `B` not found
-//│ ║  l.82: 	    B() then "B"
+//│ ║  l.88: 	    B() then "B"
 //│ ╙──      	    ^
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.78: 	if x
+//│ ║  l.84: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.78: 	if x
+//│ ║  l.84: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.78: 	if x
+//│ ║  l.84: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.78: 	if x
+//│ ║  l.84: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.78: 	if x
+//│ ║  l.84: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] type identifier not found: A
-//│ ║  l.81: 	    A() then "A"
+//│ ║  l.87: 	    A() then "A"
 //│ ╙──      	    ^
 //│ 0 | error
 //│ Code generation encountered an error:
diff --git a/shared/src/test/diff/ucs/SplitOps.mls b/shared/src/test/diff/ucs/SplitOps.mls
index c346c5090b..c1f34e291e 100644
--- a/shared/src/test/diff/ucs/SplitOps.mls
+++ b/shared/src/test/diff/ucs/SplitOps.mls
@@ -21,6 +21,9 @@ fun f(x) =
     is Left(v) then 0
     is Right(v) then 1
     <> undefined then 2
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.23: 	    <> undefined then 2
+//│ ╙──      	                      ^
 //│ ╔══[ERROR] Type mismatch in operator application:
 //│ ║  l.20: 	  if x
 //│ ║        	     ^
@@ -48,25 +51,25 @@ fun f(x) =
     is Some(xv) and y is Some(yv) then xv + yv
     is None() and y is None() then 0
 //│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.48: 	    is Some(xv) and y is Some(yv) then xv + yv
+//│ ║  l.51: 	    is Some(xv) and y is Some(yv) then xv + yv
 //│ ╙──      	                    ^
 //│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.49: 	    is None() and y is None() then 0
+//│ ║  l.52: 	    is None() and y is None() then 0
 //│ ╙──      	                  ^
 //│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.48: 	    is Some(xv) and y is Some(yv) then xv + yv
+//│ ║  l.51: 	    is Some(xv) and y is Some(yv) then xv + yv
 //│ ╙──      	                    ^
 //│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.48: 	    is Some(xv) and y is Some(yv) then xv + yv
+//│ ║  l.51: 	    is Some(xv) and y is Some(yv) then xv + yv
 //│ ╙──      	                    ^
 //│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.49: 	    is None() and y is None() then 0
+//│ ║  l.52: 	    is None() and y is None() then 0
 //│ ╙──      	                  ^
 //│ ╔══[ERROR] identifier not found: y
-//│ ║  l.48: 	    is Some(xv) and y is Some(yv) then xv + yv
+//│ ║  l.51: 	    is Some(xv) and y is Some(yv) then xv + yv
 //│ ╙──      	                    ^
 //│ ╔══[ERROR] identifier not found: y
-//│ ║  l.49: 	    is None() and y is None() then 0
+//│ ║  l.52: 	    is None() and y is None() then 0
 //│ ╙──      	                  ^
 //│ fun f: (None | Some[Int]) -> Int
 //│ Code generation encountered an error:
@@ -89,8 +92,11 @@ class C()
 fun f(a, b, c) =
   if a
     == 0 and b is B() and c is C() then 0
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.94: 	    == 0 and b is B() and c is C() then 0
+//│ ╙──      	             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.91: 	    == 0 and b is B() and c is C() then 0
+//│ ║  l.94: 	    == 0 and b is B() and c is C() then 0
 //│ ║        	             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun f: (Num, B, C) -> 0
diff --git a/shared/src/test/diff/ucs/ThenIndent.mls b/shared/src/test/diff/ucs/ThenIndent.mls
index df126db873..138c3f024b 100644
--- a/shared/src/test/diff/ucs/ThenIndent.mls
+++ b/shared/src/test/diff/ucs/ThenIndent.mls
@@ -19,6 +19,9 @@ x => if x ==
 //│ ╟── Note: 'if' expression starts here:
 //│ ║  l.5: 	x => if x ==
 //│ ╙──     	     ^^
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.6: 	  0
+//│ ╙──     	  ^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
 //│ ║  l.6: 	  0
 //│ ║       	  ^
diff --git a/shared/src/test/diff/ucs/TrivialIf.mls b/shared/src/test/diff/ucs/TrivialIf.mls
index 5f1c8070f5..1a34cf36d6 100644
--- a/shared/src/test/diff/ucs/TrivialIf.mls
+++ b/shared/src/test/diff/ucs/TrivialIf.mls
@@ -44,6 +44,9 @@ map(None, inc)
 
 :e
 fun f(a, b) = if a and b then 0
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.46: 	fun f(a, b) = if a and b then 0
+//│ ╙──      	                       ^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
 //│ ║  l.46: 	fun f(a, b) = if a and b then 0
 //│ ║        	                              ^
@@ -58,8 +61,11 @@ fun f(a, b) = if a and b then 0
 fun f(x, y) =
   if x == y + 5 then 0
   else if x == y + 7 then 0
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.63: 	  else if x == y + 7 then 0
+//│ ╙──      	                          ^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.60: 	  else if x == y + 7 then 0
+//│ ║  l.63: 	  else if x == y + 7 then 0
 //│ ║        	                          ^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun f: (Num, Int) -> 0
@@ -69,7 +75,7 @@ fun foo(x) = if x is Some
   (0) then 0
   (1) then 1
 //│ ╔══[PARSE ERROR] Unexpected parenthesis section here
-//│ ║  l.70: 	  (1) then 1
+//│ ║  l.76: 	  (1) then 1
 //│ ╙──      	  ^^^
 //│ /!!!\ Uncaught error: java.lang.StackOverflowError
 
@@ -78,15 +84,15 @@ fun foo(x) = if x is Some of
   0 then 0
   1 then 1
 //│ ╔══[PARSE ERROR] Unexpected 'then' keyword here
-//│ ║  l.78: 	  0 then 0
+//│ ║  l.84: 	  0 then 0
 //│ ╙──      	    ^^^^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'if'; found operator application instead
-//│ ║  l.77: 	fun foo(x) = if x is Some of
+//│ ║  l.83: 	fun foo(x) = if x is Some of
 //│ ║        	                ^^^^^^^^^^^^
-//│ ║  l.78: 	  0 then 0
+//│ ║  l.84: 	  0 then 0
 //│ ║        	^^^
 //│ ╟── Note: 'if' expression starts here:
-//│ ║  l.77: 	fun foo(x) = if x is Some of
+//│ ║  l.83: 	fun foo(x) = if x is Some of
 //│ ╙──      	             ^^
 //│ fun foo: Some[0] -> ()
 
diff --git a/shared/src/test/diff/ucs/WeirdIf.mls b/shared/src/test/diff/ucs/WeirdIf.mls
index 53f0d57686..d0c107d9f5 100644
--- a/shared/src/test/diff/ucs/WeirdIf.mls
+++ b/shared/src/test/diff/ucs/WeirdIf.mls
@@ -1,18 +1,25 @@
 :PreTyper
 
-// FIXME: Should report duplicated else branches.
-// :w
+:w
 if
   _ then 0
   else 0
 else 1
+//│ ╔══[WARNING] unreachable case
+//│ ║  l.5: 	  _ then 0
+//│ ╙──     	         ^
+//│ ╔══[WARNING] unreachable case
+//│ ║  l.5: 	  _ then 0
+//│ ╙──     	         ^
 //│ 0
 //│ res
 //│     = 0
 
-// FIXME
-// :w
+:w
 if else 0 else 1
+//│ ╔══[WARNING] unreachable case
+//│ ║  l.19: 	if else 0 else 1
+//│ ╙──      	        ^
 //│ 0
 //│ res
 //│     = 0
@@ -20,10 +27,10 @@ if else 0 else 1
 :w
 fun f(x) = if x is else 0 else 1
 //│ ╔══[WARNING] the case is unreachable
-//│ ║  l.21: 	fun f(x) = if x is else 0 else 1
+//│ ║  l.28: 	fun f(x) = if x is else 0 else 1
 //│ ║        	                               ^
 //│ ╟── because this branch covers the case
-//│ ║  l.21: 	fun f(x) = if x is else 0 else 1
+//│ ║  l.28: 	fun f(x) = if x is else 0 else 1
 //│ ╙──      	                        ^
 //│ fun f: anything -> 0
 
@@ -33,8 +40,11 @@ fun f(x) = if x is else 0
 :e
 if true
   then 0
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.42: 	  then 0
+//│ ╙──      	       ^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.35: 	  then 0
+//│ ║  l.42: 	  then 0
 //│ ║        	       ^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ 0
@@ -48,21 +58,24 @@ fun f(x) =
   if x ===
     else "bruh"
 //│ ╔══[PARSE ERROR] Unexpected indented block in expression position
-//│ ║  l.49: 	    else "bruh"
+//│ ║  l.59: 	    else "bruh"
 //│ ╙──      	^^^^
 //│ ╔══[PARSE ERROR] Unexpected end of indented block; an expression was expected here
-//│ ║  l.49: 	    else "bruh"
+//│ ║  l.59: 	    else "bruh"
 //│ ╙──      	    ^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'if'; found operator application instead
-//│ ║  l.48: 	  if x ===
+//│ ║  l.58: 	  if x ===
 //│ ║        	     ^^^^^
-//│ ║  l.49: 	    else "bruh"
+//│ ║  l.59: 	    else "bruh"
 //│ ║        	^^^^
 //│ ╟── Note: 'if' expression starts here:
-//│ ║  l.48: 	  if x ===
+//│ ║  l.58: 	  if x ===
 //│ ╙──      	  ^^
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.59: 	    else "bruh"
+//│ ╙──      	    ^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.49: 	    else "bruh"
+//│ ║  l.59: 	    else "bruh"
 //│ ║        	    ^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun f: Eql[()] -> ()
diff --git a/shared/src/test/diff/ucs/Wildcard.mls b/shared/src/test/diff/ucs/Wildcard.mls
index 9cc79fd9ce..2b817b7c62 100644
--- a/shared/src/test/diff/ucs/Wildcard.mls
+++ b/shared/src/test/diff/ucs/Wildcard.mls
@@ -1,5 +1,8 @@
 :PreTyper
 
+fun (++) strcat(a, b) = concat(a)(b)
+//│ fun (++) strcat: (Str, Str) -> Str
+
 type Option[T] = None | Some[T]
 module None
 class Some[T](val value: T)
@@ -14,15 +17,15 @@ class Right[B](val rightValue: B)
 //│ class Left[A](leftValue: A)
 //│ class Right[B](rightValue: B)
 
-// FIXME
+
 fun w1(x, e_0, e_1) =
   if x is
     Left(None) then "Left of None"
     Right(None) then "Right of None"
     _ and e_0 is y_0 and x is
-      Left(Some(lv)) then concat("Left of Some of ")(toString(lv))
+      Left(Some(lv)) then "Left of Some of " ++ toString(lv)
       _ and e_1 is y_1 and x is
-        Right(Some(rv)) then concat("Right of Some of ")(toString(rv))
+        Right(Some(rv)) then "Right of Some of " ++ toString(rv)
 //│ fun w1: forall 'a. (Left[None | Object & ~#None & ~#Some | Some[anything]] | Object & ~#Left & ~#Right | Right[None | Some[anything]], anything, 'a) -> (Str | 'a)
 
 w1(Left(None), "a", "b")
@@ -63,7 +66,7 @@ w2(0, x => false)
 
 fun w3(x, p) = if x is
   _ and p(x) then "r1"
-  Some(xv) then concat("r2: ")(toString(xv))
+  Some(xv) then "r2: " ++ toString(xv)
   None then "r3"
   _ then "r4"
 //│ fun w3: forall 'a. ('a & (Object & ~#Some | Some[anything]), 'a -> Bool) -> Str
@@ -105,10 +108,10 @@ w3(0, _ => false)
 fun w3_1(x, f) =
   if f(x) is _ then 0 else 1
 //│ ╔══[WARNING] the case is unreachable
-//│ ║  l.106: 	  if f(x) is _ then 0 else 1
+//│ ║  l.109: 	  if f(x) is _ then 0 else 1
 //│ ║         	                           ^
 //│ ╟── because this branch covers the case
-//│ ║  l.106: 	  if f(x) is _ then 0 else 1
+//│ ║  l.109: 	  if f(x) is _ then 0 else 1
 //│ ╙──       	                    ^
 //│ fun w3_1: forall 'a. ('a, 'a -> anything) -> 0
 
@@ -120,10 +123,15 @@ w3_1(0, _ => false)
 //│ res
 //│     = 0
 
-// :w
-// FIXME: Should warn redundant case
+:w
 fun w3_1_1(x, f) =
   if f(x) is a then a else 0
+//│ ╔══[WARNING] the case is unreachable
+//│ ║  l.128: 	  if f(x) is a then a else 0
+//│ ║         	                           ^
+//│ ╟── because this branch already covers the case
+//│ ║  l.128: 	  if f(x) is a then a else 0
+//│ ╙──       	                    ^
 //│ fun w3_1_1: forall 'a 'b. ('a, 'a -> 'b) -> 'b
 
 w3_1_1(0, x => x)
@@ -140,7 +148,7 @@ w3_1_1(0, x => x + 1)
 // + «x is None» => "r3"
 fun w4(x, p) = if x is
   a and p(x) then "r1"
-  Some(xv) then concat("r2: ")(toString(xv))
+  Some(xv) then "r2: " ++ toString(xv)
   None then "r3"
   _ then "r4"
 //│ fun w4: forall 'a. ('a & (Object & ~#Some | Some[anything]), 'a -> Bool) -> Str
@@ -187,6 +195,7 @@ class Delta()
 
 // This should generate only one case expression instead of a chain of case
 // expressions. DO check the desugared term!
+:dpt:postprocess.result
 fun w5(y) =
   if y is
     Alpha then "alpha"
@@ -197,6 +206,17 @@ fun w5(y) =
         _ and y is
           Delta then "delta"
           _ then "unknown"
+//│ | | | | | | | Post-processed UCS term:
+//│ | | | | | | | case y*‡ of
+//│ | | | | | | |   Alpha*◊ -> "alpha"
+//│ | | | | | | |   Gamma*◊ -> "gamma"
+//│ | | | | | | |   Delta*◊ -> "delta"
+//│ | | | | | | |   Beta*◊ -> "beta"
+//│ | | | | | | |   _ ->
+//│ | | | | | | |     case y*‡ of
+//│ | | | | | | |       _ ->
+//│ | | | | | | |         case y*‡ of
+//│ | | | | | | |           _ -> "unknown"
 //│ fun w5: (Alpha | Beta | Delta | Gamma | Object & ~#Alpha & ~#Beta & ~#Delta & ~#Gamma) -> ("alpha" | "beta" | "delta" | "gamma" | "unknown")
 
 w5(0)
@@ -235,8 +255,7 @@ w6("42", "42")
 //│ res
 //│     = '42'
 
-// FIXME
-// Should report warnings.
+
 fun w7(x, f) =
   if x is
     _ and f(x) is
@@ -263,3 +282,14 @@ w7(Right(99), _ => None) // => Right(99)
 //│     = 0
 //│ res
 //│     = Right {}
+
+w7(Left(99), _ => "test")
+w7(Right(99), _ => "test")
+//│ Int | Right['B]
+//│   where
+//│     'B :> 99
+//│        <: Int
+//│ res
+//│     = 100
+//│ res
+//│     = 101
diff --git a/todo.md b/todo.md
index 6a99be1018..9f1ebcbc37 100644
--- a/todo.md
+++ b/todo.md
@@ -3,11 +3,11 @@ problems located by test cases.
 
 ### Remaining Tasks
 
-- [ ] Report unreachable or redundant cases
+- [x] Report unreachable or redundant cases
   - [x] shared/src/test/diff/ucs/DirectLines.mls **OLD**
-  - [ ] shared/src/test/diff/ucs/SplitAnd.mls
-  - [ ] shared/src/test/diff/ucs/WeirdIf.mls
-  - [ ] shared/src/test/diff/ucs/Wildcard.mls
+  - [x] shared/src/test/diff/ucs/SplitAnd.mls
+  - [x] shared/src/test/diff/ucs/WeirdIf.mls
+  - [x] shared/src/test/diff/ucs/Wildcard.mls
 - [x] Hygenic bindings
   - [ ] shared/src/test/diff/ucs/CrossBranchCapture.mls
   - [x] shared/src/test/diff/ucs/HygienicBindings.mls

From 661d26cce47fa4f7f2cf3b365fb41079702681ab Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Mon, 15 Jan 2024 00:22:07 +0800
Subject: [PATCH 067/147] Append test file changes

---
 .../src/test/diff/ucs/CrossBranchCapture.mls  |  6 ++--
 shared/src/test/diff/ucs/HygienicBindings.mls | 18 ++++------
 shared/src/test/diff/ucs/WeirdIf.mls          | 33 ++++++++++++-------
 3 files changed, 31 insertions(+), 26 deletions(-)

diff --git a/shared/src/test/diff/ucs/CrossBranchCapture.mls b/shared/src/test/diff/ucs/CrossBranchCapture.mls
index 740f0f6318..82f0aad17a 100644
--- a/shared/src/test/diff/ucs/CrossBranchCapture.mls
+++ b/shared/src/test/diff/ucs/CrossBranchCapture.mls
@@ -13,7 +13,7 @@ fun process(e) =
     Numb(n) and n > 0 then n
     Numb(m) then n
 //│ ╔══[ERROR] identifier `n` not found
-//│ ║  l.21: 	    Numb(m) then n
+//│ ║  l.14: 	    Numb(m) then n
 //│ ╙──      	                 ^
 //│ fun process: Numb -> Int
 
@@ -58,10 +58,10 @@ fun process(e) =
     Pair(Vec(n),  Numb(n)) then n
     Pair(Numb(n), Vec(n))  then n
 //│ ╔══[ERROR] identifier `n` not found
-//│ ║  l.64: 	    Pair(Vec(xs), Vec(ys))  then n
+//│ ║  l.57: 	    Pair(Vec(xs), Vec(ys))  then n
 //│ ╙──      	                                 ^
 //│ ╔══[ERROR] identifier not found: n
-//│ ║  l.64: 	    Pair(Vec(xs), Vec(ys))  then n
+//│ ║  l.57: 	    Pair(Vec(xs), Vec(ys))  then n
 //│ ╙──      	                                 ^
 //│ fun process: Pair[Numb | Vec, Numb | Vec] -> (Int | Numb | error)
 //│ Code generation encountered an error:
diff --git a/shared/src/test/diff/ucs/HygienicBindings.mls b/shared/src/test/diff/ucs/HygienicBindings.mls
index e7740ea70c..eba8e94559 100644
--- a/shared/src/test/diff/ucs/HygienicBindings.mls
+++ b/shared/src/test/diff/ucs/HygienicBindings.mls
@@ -144,23 +144,19 @@ fun h4(x, y, p) =
 //│ | | | | | | |       _ -> "default"
 //│ fun h4: forall 'a 'b. (Object & 'a, 'b, 'a -> Bool) -> ("default" | 'a | 'b)
 
-h4("should be me", "not me", _ => true) ~~> "should be me"
+h4("should be me", "not me", _ => true)
 h4(None, "not me", _ => true)
-h4(None, "should be me", _ => false) ~~> "should be me"
-h4("anything", "not me", _ => false) ~~> "default"
-//│ ╔══[ERROR] Module 'None' does not support equality comparison because it does not have a parameter list
-//│ ║  l.149: 	h4(None, "should be me", _ => false) ~~> "should be me"
-//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ TEST CASE FAILURE: There was an unexpected type error
-//│ ()
+h4(None, "should be me", _ => false)
+h4("anything", "not me", _ => false)
+//│ "anything" | "default" | "not me"
 //│ res
-//│     = undefined
+//│     = 'should be me'
 //│ res
 //│     = None { class: [class None] }
 //│ res
-//│     = undefined
+//│     = 'should be me'
 //│ res
-//│     = undefined
+//│     = 'default'
 
 :dpt:postprocess.result
 fun h5(x, y, p) =
diff --git a/shared/src/test/diff/ucs/WeirdIf.mls b/shared/src/test/diff/ucs/WeirdIf.mls
index d0c107d9f5..a7fed4a00c 100644
--- a/shared/src/test/diff/ucs/WeirdIf.mls
+++ b/shared/src/test/diff/ucs/WeirdIf.mls
@@ -6,9 +6,15 @@ if
   else 0
 else 1
 //│ ╔══[WARNING] unreachable case
+//│ ║  l.6: 	  else 0
+//│ ║       	       ^
+//│ ╟── because this branch covers the case
 //│ ║  l.5: 	  _ then 0
 //│ ╙──     	         ^
 //│ ╔══[WARNING] unreachable case
+//│ ║  l.7: 	else 1
+//│ ║       	     ^
+//│ ╟── because this branch covers the case
 //│ ║  l.5: 	  _ then 0
 //│ ╙──     	         ^
 //│ 0
@@ -18,7 +24,10 @@ else 1
 :w
 if else 0 else 1
 //│ ╔══[WARNING] unreachable case
-//│ ║  l.19: 	if else 0 else 1
+//│ ║  l.25: 	if else 0 else 1
+//│ ║        	               ^
+//│ ╟── because this branch covers the case
+//│ ║  l.25: 	if else 0 else 1
 //│ ╙──      	        ^
 //│ 0
 //│ res
@@ -27,10 +36,10 @@ if else 0 else 1
 :w
 fun f(x) = if x is else 0 else 1
 //│ ╔══[WARNING] the case is unreachable
-//│ ║  l.28: 	fun f(x) = if x is else 0 else 1
+//│ ║  l.37: 	fun f(x) = if x is else 0 else 1
 //│ ║        	                               ^
 //│ ╟── because this branch covers the case
-//│ ║  l.28: 	fun f(x) = if x is else 0 else 1
+//│ ║  l.37: 	fun f(x) = if x is else 0 else 1
 //│ ╙──      	                        ^
 //│ fun f: anything -> 0
 
@@ -41,10 +50,10 @@ fun f(x) = if x is else 0
 if true
   then 0
 //│ ╔══[ERROR] missing else branch
-//│ ║  l.42: 	  then 0
+//│ ║  l.51: 	  then 0
 //│ ╙──      	       ^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.42: 	  then 0
+//│ ║  l.51: 	  then 0
 //│ ║        	       ^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ 0
@@ -58,24 +67,24 @@ fun f(x) =
   if x ===
     else "bruh"
 //│ ╔══[PARSE ERROR] Unexpected indented block in expression position
-//│ ║  l.59: 	    else "bruh"
+//│ ║  l.68: 	    else "bruh"
 //│ ╙──      	^^^^
 //│ ╔══[PARSE ERROR] Unexpected end of indented block; an expression was expected here
-//│ ║  l.59: 	    else "bruh"
+//│ ║  l.68: 	    else "bruh"
 //│ ╙──      	    ^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'if'; found operator application instead
-//│ ║  l.58: 	  if x ===
+//│ ║  l.67: 	  if x ===
 //│ ║        	     ^^^^^
-//│ ║  l.59: 	    else "bruh"
+//│ ║  l.68: 	    else "bruh"
 //│ ║        	^^^^
 //│ ╟── Note: 'if' expression starts here:
-//│ ║  l.58: 	  if x ===
+//│ ║  l.67: 	  if x ===
 //│ ╙──      	  ^^
 //│ ╔══[ERROR] missing else branch
-//│ ║  l.59: 	    else "bruh"
+//│ ║  l.68: 	    else "bruh"
 //│ ╙──      	    ^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.59: 	    else "bruh"
+//│ ║  l.68: 	    else "bruh"
 //│ ║        	    ^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun f: Eql[()] -> ()

From 20b86a7501b9c9704b24fca1fe32e13ed8afde31 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Mon, 15 Jan 2024 00:32:15 +0800
Subject: [PATCH 068/147] Fix test cases in the compiler sub-project

---
 compiler/shared/test/diff/mono.mls | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/compiler/shared/test/diff/mono.mls b/compiler/shared/test/diff/mono.mls
index a261d75d03..e2c65fdc62 100644
--- a/compiler/shared/test/diff/mono.mls
+++ b/compiler/shared/test/diff/mono.mls
@@ -1,18 +1,18 @@
 
-:NewDefs
+:PreTyper
 
 :mono
-fun f(x: Int) = if x then 42 else 1337
+fun f(x: Int) = if not of x == 0 then 42 else 1337
 //│ 
 //│ Lifted:
 //│ TypingUnit {
-//│   fun f$1 = (x: Int,) => if (x) then 42 else 1337
+//│   fun f$1 = (x: Int,) => if (not(==(x, 0,),)) then 42 else 1337
 //│ }
 //│ Mono:
 //│ 
 //│ Defunc result: 
 //│ fun f$1(x) =
-//│   if x then #42 else #1337
+//│   if not(==(x, #0)) then #42 else #1337
 //│ fun f: (x: Int) -> (1337 | 42)
 
 :mono
@@ -47,7 +47,7 @@ let b = foo(23, false)
 //│   if b then x else #1337
 //│ fun a$1() =
 //│   foo$3(#42, true)
-//│ fun foo: forall 'a. ('a, Object) -> (1337 | 'a)
+//│ fun foo: forall 'a. ('a, Bool) -> (1337 | 'a)
 //│ let a: 1337 | 42
 //│ let b: 1337 | 23
 //│ a
@@ -116,19 +116,19 @@ if 1+1 > 1 then 1 - 1 else 1*1
 //│     = 0
 
 :mono
-if(b) then 1 else 2
+if not of b == 0 then 1 else 2
 //│ 
 //│ Lifted:
-//│ TypingUnit {Code(List(if ('(' b ')') then 1 else 2))}
+//│ TypingUnit {Code(List(if (not(==(b, 0,),)) then 1 else 2))}
 //│ Mono:
 //│ 
 //│ Defunc result: 
 //│ main$$0()
 //│ fun main$$0() =
-//│   if b then #1 else #2
+//│   if not(==(b, #0)) then #1 else #2
 //│ 1 | 2
 //│ res
-//│     = 2
+//│     = 1
 
 :mono
 ((f, g) => f(g))(f => f, true)
@@ -263,7 +263,7 @@ count(new List(new List(new Nil(undefined, false), true), true))
 //│ fun count: forall 'a. 'a -> Int
 //│ Int
 //│ where
-//│   'a <: {hasTail: Object, l: Object & 'a & ~() | ()}
+//│   'a <: {hasTail: Bool, l: Object & 'a & ~() | ()}
 //│ res
 //│     = 2
 
@@ -952,13 +952,13 @@ class OneInt(a: Int){
 class OneBool(b: Bool){
   fun get = () -> b
 }
-(if b then new OneInt(1) else new OneBool(true)).get()
+(if not of b == 0 then new OneInt(1) else new OneBool(true)).get()
 //│ 
 //│ Lifted:
 //│ TypingUnit {
 //│   class OneInt$1([a: Int,]) {fun get = () => (this).a}
 //│   class OneBool$2([b: Bool,]) {fun get = () => (this).b}
-//│   Code(List(('(' if (b) then new OneInt$1([1,]) {} else new OneBool$2([true,]) {} ')').get()))
+//│   Code(List(('(' if (not(==(b, 0,),)) then new OneInt$1([1,]) {} else new OneBool$2([true,]) {} ')').get()))
 //│ }
 //│ Mono:
 //│ 
@@ -969,7 +969,7 @@ class OneBool(b: Bool){
 //│ fun get$OneBool$2(this) =
 //│   this.b
 //│ fun main$$2() =
-//│   if b then new OneInt$1 (#1)  else new OneBool$2 (true)  match {case obj: OneInt$1 => get$OneInt$1(obj); case obj: OneBool$2 => get$OneBool$2(obj)}
+//│   if not(==(b, #0)) then new OneInt$1 (#1)  else new OneBool$2 (true)  match {case obj: OneInt$1 => get$OneInt$1(obj); case obj: OneBool$2 => get$OneBool$2(obj)}
 //│ class OneInt$1(a) {
 //│ }
 //│ class OneBool$2(b) {
@@ -982,7 +982,7 @@ class OneBool(b: Bool){
 //│ }
 //│ Int | false | true
 //│ res
-//│     = true
+//│     = 1
 
 :mono
 class Bar(x: Int) {

From 0dd68c063ac0b589657bef5e8c45742c7d68f790 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Mon, 15 Jan 2024 02:45:13 +0800
Subject: [PATCH 069/147] Reorganize files and prepare for finalization

---
 .../main/scala/mlscript/ucs/DesugarUCS.scala  |  7 ++++---
 .../src/main/scala/mlscript/ucs/display.scala |  3 ++-
 .../src/main/scala/mlscript/ucs/helpers.scala | 19 -------------------
 .../main/scala/mlscript/ucs/old/helpers.scala | 19 +++++++++++++++++++
 .../mlscript/ucs/stages/Desugaring.scala      |  3 ++-
 .../mlscript/ucs/stages/Normalization.scala   | 17 +++++++++--------
 .../mlscript/ucs/stages/Transformation.scala  |  2 +-
 .../mlscript/ucs/{ => syntax}/core.scala      |  2 +-
 .../scala/mlscript/ucs/syntax/package.scala   |  3 +++
 .../ucs/{syntax.scala => syntax/source.scala} |  4 ++--
 10 files changed, 43 insertions(+), 36 deletions(-)
 rename shared/src/main/scala/mlscript/ucs/{ => syntax}/core.scala (99%)
 create mode 100644 shared/src/main/scala/mlscript/ucs/syntax/package.scala
 rename shared/src/main/scala/mlscript/ucs/{syntax.scala => syntax/source.scala} (99%)

diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index 1b5d49c7d5..a9b861a547 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -1,12 +1,13 @@
 package mlscript.ucs
 
 import collection.mutable.{Map => MutMap}
-import mlscript.ucs.{syntax => s, core => c}, stages._, context.{Context, ScrutineeData}
+import syntax.{source => s, core => c}, stages._, context.{Context, ScrutineeData}
 import mlscript.ucs.display.{showNormalizedTerm, showSplit}
 import mlscript.pretyper.{PreTyper, Scope}
 import mlscript.pretyper.symbol._
 import mlscript.{If, Loc, Message, Var}, Message.MessageContext, mlscript.Diagnostic.PreTyping
 import mlscript.utils._, shorthands._
+import syntax.core.{Branch, Split}
 
 // TODO: Rename to `Desugarer` once the old desugarer is removed.
 trait DesugarUCS extends Transformation
@@ -230,9 +231,9 @@ trait DesugarUCS extends Transformation
     }
   }
   
-  private def traverseSplit(split: core.Split)(implicit scope: Scope): Unit =
+  private def traverseSplit(split: syntax.core.Split)(implicit scope: Scope): Unit =
     trace(s"traverseSplit <== [${scope.showLocalSymbols}]") {
-      import core._
+      
       split match {
         case Split.Cons(Branch(scrutinee, pattern, continuation), tail) => 
           traverseTerm(scrutinee)
diff --git a/shared/src/main/scala/mlscript/ucs/display.scala b/shared/src/main/scala/mlscript/ucs/display.scala
index 2ce7656b8e..288c1434e4 100644
--- a/shared/src/main/scala/mlscript/ucs/display.scala
+++ b/shared/src/main/scala/mlscript/ucs/display.scala
@@ -1,11 +1,12 @@
 package mlscript.ucs
 
-import mlscript.ucs.{core => c, syntax => s}
+import mlscript.ucs.syntax.{core => c, source => s}
 import mlscript.ucs.context.{Context}
 import mlscript.pretyper.symbol.{TermSymbol, TypeSymbol}
 import mlscript.{App, CaseOf, Fld, FldFlags, Let, Loc, Sel, SimpleTerm, Term, Tup, Var}
 import mlscript.{CaseBranches, Case, Wildcard, NoCases}
 import mlscript.utils._, shorthands._
+import syntax.core.{Branch, Split}
 
 /** All the pretty-printing stuff go here. */
 package object display {
diff --git a/shared/src/main/scala/mlscript/ucs/helpers.scala b/shared/src/main/scala/mlscript/ucs/helpers.scala
index 74491123a3..f8ed428b47 100644
--- a/shared/src/main/scala/mlscript/ucs/helpers.scala
+++ b/shared/src/main/scala/mlscript/ucs/helpers.scala
@@ -30,25 +30,6 @@ object helpers {
     if (newDefs) App(op, PlainTup(lhs, rhs))
     else App(App(op, mkMonuple(lhs)), mkMonuple(rhs))
 
-  /**
-    * Split a term joined by `and` into a list of terms.
-    * E.g. `x and y and z` will be split into `x`, `y`, and `z`.
-    *
-    * @return a list of sub-terms of `t`
-    */
-  def splitAnd(t: Term): Ls[Term] =
-    t match {
-      case App(
-        App(Var("and"),
-            Tup((_ -> Fld(_, lhs)) :: Nil)),
-        Tup((_ -> Fld(_, rhs)) :: Nil)
-      ) => // * Old-style operators
-        splitAnd(lhs) :+ rhs
-      case App(Var("and"), PlainTup(lhs, rhs)) =>
-        splitAnd(lhs) :+ rhs
-      case _ => t :: Nil
-    }
-
   /**
     * Split a term into two parts: the pattern and the extra test.
     * This is used to extract patterns from UCS conjunctions. For example,
diff --git a/shared/src/main/scala/mlscript/ucs/old/helpers.scala b/shared/src/main/scala/mlscript/ucs/old/helpers.scala
index bbfc79896e..4d2df1e754 100644
--- a/shared/src/main/scala/mlscript/ucs/old/helpers.scala
+++ b/shared/src/main/scala/mlscript/ucs/old/helpers.scala
@@ -6,6 +6,25 @@ import mlscript._
 import mlscript.utils.shorthands._
 
 object helpers {
+  /**
+    * Split a term joined by `and` into a list of terms.
+    * E.g. `x and y and z` will be split into `x`, `y`, and `z`.
+    *
+    * @return a list of sub-terms of `t`
+    */
+  def splitAnd(t: Term): Ls[Term] =
+    t match {
+      case App(
+        App(Var("and"),
+            Tup((_ -> Fld(_, lhs)) :: Nil)),
+        Tup((_ -> Fld(_, rhs)) :: Nil)
+      ) => // * Old-style operators
+        splitAnd(lhs) :+ rhs
+      case App(Var("and"), PlainTup(lhs, rhs)) =>
+        splitAnd(lhs) :+ rhs
+      case _ => t :: Nil
+    }
+
   /**
     * Generate a chain of `Let` from a list of bindings.
     *
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index d7e8196150..62505cc990 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -1,7 +1,8 @@
 package mlscript.ucs.stages
 
 import mlscript.{App, Asc, Fld, FldFlags, Lit, Sel, Term, Tup, TypeName, Var}
-import mlscript.ucs.{syntax => s, core => c, PartialTerm}
+import mlscript.ucs.PartialTerm
+import mlscript.ucs.syntax.{core => c, source => s}
 import mlscript.ucs.context.{Context, ScrutineeData}
 import mlscript.ucs.helpers.mkBinOp
 import mlscript.utils._, shorthands._
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 07d1ad2345..d48c95feb2 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -1,18 +1,19 @@
 
 package mlscript.ucs.stages
 
-import mlscript.ucs.{DesugarUCS, Lines, LinesOps, VariableGenerator}
-import mlscript.ucs.context.{Context, ScrutineeData}
-import mlscript.ucs.core._
-import mlscript.ucs.display.{showNormalizedTerm, showSplit}
-import mlscript.ucs.helpers._
-import mlscript.pretyper.Scope
-import mlscript.pretyper.symbol._
 import mlscript.{App, CaseOf, Fld, FldFlags, Let, Loc, Sel, Term, Tup, Var, StrLit}
 import mlscript.{CaseBranches, Case, Wildcard, NoCases}
 import mlscript.Message, Message.MessageContext
 import mlscript.utils._, shorthands._
-import mlscript.pretyper.{Diagnosable, Traceable}
+import mlscript.ucs, mlscript.pretyper
+import ucs.{DesugarUCS, Lines, LinesOps, VariableGenerator}
+import ucs.context.{Context, ScrutineeData}
+import ucs.display.{showNormalizedTerm, showSplit}
+import ucs.helpers._
+import ucs.syntax.core.{Pattern, Branch, Split}
+import pretyper.Scope
+import pretyper.symbol._
+import pretyper.{Diagnosable, Traceable}
 
 trait Normalization { self: DesugarUCS with Traceable =>
   import Normalization._
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index 0e06184974..29b7fbe384 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -5,7 +5,7 @@ import mlscript.{If, IfBody, IfBlock, IfElse, IfLet, IfOpApp, IfOpsApp, IfThen}
 import mlscript.{Blk, Term, Var, App, Tup, Lit, Fld, Loc}
 import mlscript.Diagnostic.PreTyping
 import mlscript.pretyper.Traceable
-import mlscript.ucs.syntax._
+import mlscript.ucs.syntax.source._
 import mlscript.Message, Message._
 import mlscript.utils._, shorthands._
 import mlscript.NuFunDef
diff --git a/shared/src/main/scala/mlscript/ucs/core.scala b/shared/src/main/scala/mlscript/ucs/syntax/core.scala
similarity index 99%
rename from shared/src/main/scala/mlscript/ucs/core.scala
rename to shared/src/main/scala/mlscript/ucs/syntax/core.scala
index 986fec081f..92e3d12a8a 100644
--- a/shared/src/main/scala/mlscript/ucs/core.scala
+++ b/shared/src/main/scala/mlscript/ucs/syntax/core.scala
@@ -1,4 +1,4 @@
-package mlscript.ucs
+package mlscript.ucs.syntax
 
 import mlscript.{Diagnostic, Lit, Loc, Located, Message, Term, Var}
 import mlscript.utils._, shorthands._
diff --git a/shared/src/main/scala/mlscript/ucs/syntax/package.scala b/shared/src/main/scala/mlscript/ucs/syntax/package.scala
new file mode 100644
index 0000000000..bfe2aec74d
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/syntax/package.scala
@@ -0,0 +1,3 @@
+package mlscript.ucs
+
+package object syntax
diff --git a/shared/src/main/scala/mlscript/ucs/syntax.scala b/shared/src/main/scala/mlscript/ucs/syntax/source.scala
similarity index 99%
rename from shared/src/main/scala/mlscript/ucs/syntax.scala
rename to shared/src/main/scala/mlscript/ucs/syntax/source.scala
index afbef74f66..043eff9bcd 100644
--- a/shared/src/main/scala/mlscript/ucs/syntax.scala
+++ b/shared/src/main/scala/mlscript/ucs/syntax/source.scala
@@ -1,11 +1,11 @@
-package mlscript.ucs
+package mlscript.ucs.syntax
 
 import mlscript.{Lit, Located, Term, Var}
 import mlscript.utils._, shorthands._
 import scala.annotation.tailrec
 import scala.collection.immutable
 
-package object syntax {
+package object source {
   sealed abstract class Pattern extends Located {
     override def toString(): String = this match {
       case AliasPattern(nme, pattern) => s"$nme @ $pattern"

From d9a666509fc230f6eb45ce86cc71e071599f1576 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Mon, 15 Jan 2024 14:56:35 +0800
Subject: [PATCH 070/147] Change UCS desugarer flag to `ucs`

---
 .../src/test/diff/pretyper/ucs/coverage/SealedClasses.mls | 4 ++--
 shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls    | 2 +-
 .../src/test/diff/pretyper/ucs/stages/Normalization.mls   | 2 +-
 .../src/test/diff/pretyper/ucs/stages/PostProcessing.mls  | 8 ++++----
 shared/src/test/diff/ucs/Hygiene.mls                      | 2 +-
 shared/src/test/diff/ucs/HygienicBindings.mls             | 8 ++++----
 shared/src/test/diff/ucs/InterleavedLet.mls               | 2 +-
 shared/src/test/diff/ucs/Wildcard.mls                     | 2 +-
 shared/src/test/scala/mlscript/DiffTests.scala            | 3 +--
 9 files changed, 16 insertions(+), 17 deletions(-)

diff --git a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
index 2d74e704e1..c1db6d34e1 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
@@ -9,7 +9,7 @@ class App(func: Term, arg: Term) extends Term
 //│ class Abs(param: Str, body: Term) extends Term
 //│ class App(func: Term, arg: Term) extends Term
 
-:dpt:desugar.result
+:ucs:desugar.result
 fun is_value_explicit_refinement(term) =
   if term is refined(Term) and term is
     Abs(_, _) then true
@@ -22,7 +22,7 @@ fun is_value_explicit_refinement(term) =
 //│ | | | | | | |   term*‡ is App then false
 //│ fun is_value_explicit_refinement: (Abs | App | Var) -> Bool
 
-:dpt:normalize.result,postprocess.result
+:ucs:normalize.result,postprocess.result
 fun is_value_automatic_refinement(term) =
   if term is Term and term is
     Abs(_, _) then true
diff --git a/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls b/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls
index dd5dcf0e03..363b7b52a2 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls
@@ -262,7 +262,7 @@ fun bf(t) =
 //   than placed in parallel, otherwise, the later branches will appear in the
 //   else branch of all its previous branches. **WORK IN PROGRESS**
 //
-// :dpt:postprocess
+// :ucs:postprocess
 fun balance(t: Tree['A]): Tree['A] =
   if t is
     Node(x, l, r, _) and height(r) - height(l)
diff --git a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
index 6179b4423a..ff4ba25ef1 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
@@ -22,7 +22,7 @@ fun sum(acc, xs) =
 
 // FIXME: Remove redundant `_ -> (ucs$args_xs$Some_0$Cons).1`.
 // Why are they everywhere?
-:dpt:postprocess.result
+:ucs:postprocess.result
 fun test(xs) =
   if xs is
     Some(Cons("add", Cons(x, Cons(y, Nil)))) then x + y
diff --git a/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls b/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
index f32ad182da..c4033b646f 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
@@ -1,6 +1,6 @@
 :PreTyper
 
-:dpt:postprocess.result,desugared
+:ucs:postprocess.result,desugared
 fun mixed_literals(v) =
   if v is
     true then "true"
@@ -18,7 +18,7 @@ fun mixed_literals(v) =
 //│ ╙──
 //│ fun mixed_literals: (1 | 2 | false | true) -> ("1" | "2" | "false" | "true")
 
-:dpt:postprocess.result
+:ucs:postprocess.result
 fun separated_by_and(v) =
   if v is
     true then "true"
@@ -32,7 +32,7 @@ fun separated_by_and(v) =
 //│ ╙──
 //│ fun separated_by_and: Bool -> ("false" | "true")
 
-:dpt:postprocess.result
+:ucs:postprocess.result
 fun dual_patterns(x, y) =
   if
     x is "some" and y is "none" then 0
@@ -51,7 +51,7 @@ fun dual_patterns(x, y) =
 //│ | | | | | | |       "none" -> 3
 //│ fun dual_patterns: ("none" | "some", "none" | "some") -> (0 | 1 | 2 | 3)
 
-:dpt:postprocess.result
+:ucs:postprocess.result
 fun unordered_dual_patterns(x, y) =
   if
     x is "some" and y is "none" then 0
diff --git a/shared/src/test/diff/ucs/Hygiene.mls b/shared/src/test/diff/ucs/Hygiene.mls
index dd49ef464d..bd7b4cd1f9 100644
--- a/shared/src/test/diff/ucs/Hygiene.mls
+++ b/shared/src/test/diff/ucs/Hygiene.mls
@@ -7,7 +7,7 @@ class Right[out T](value: T)
 //│ class Left[T](value: T)
 //│ class Right[T](value: T)
 
-:dpt:postprocess.result
+:ucs:postprocess.result
 fun foo(x) = if x is
   Some(Left(y)) then x
   Some(x) then x
diff --git a/shared/src/test/diff/ucs/HygienicBindings.mls b/shared/src/test/diff/ucs/HygienicBindings.mls
index eba8e94559..73f439801e 100644
--- a/shared/src/test/diff/ucs/HygienicBindings.mls
+++ b/shared/src/test/diff/ucs/HygienicBindings.mls
@@ -39,7 +39,7 @@ fun h0(a) =
 // If a class parameter is bound to the same variable in different branches,
 // the bindings can be merged and can be typed and coverage checked. See the
 // desugared version below.
-:dpt:postprocess.result
+:ucs:postprocess.result
 fun h0'(a) =
   if
     a is Some(x) and x is Left(y) then y
@@ -92,7 +92,7 @@ fun h2(a) =
     a is None then 0
 //│ fun h2: forall 'a. (None | Some[Left['a]]) -> (0 | 'a)
 
-:dpt:postprocess.result
+:ucs:postprocess.result
 fun h3(x, y, f, p) =
   if x is
     _ and f(x) is y and p(x) then y
@@ -125,7 +125,7 @@ h3("anything", "anything", _ => "not me", _ => false) ~~> "anyway"
 //│     = undefined
 
 
-:dpt:postprocess.result
+:ucs:postprocess.result
 fun h4(x, y, p) =
   if x is
     y and p(x) then y
@@ -158,7 +158,7 @@ h4("anything", "not me", _ => false)
 //│ res
 //│     = 'default'
 
-:dpt:postprocess.result
+:ucs:postprocess.result
 fun h5(x, y, p) =
   if x is
     Some(y) and p(x) then y
diff --git a/shared/src/test/diff/ucs/InterleavedLet.mls b/shared/src/test/diff/ucs/InterleavedLet.mls
index 243ac0adc9..4f3d90b811 100644
--- a/shared/src/test/diff/ucs/InterleavedLet.mls
+++ b/shared/src/test/diff/ucs/InterleavedLet.mls
@@ -21,7 +21,7 @@ class Right[B](rightValue: B) extends Either[nothing, B]
 //│ class Left[A](leftValue: A) extends Either
 //│ class Right[B](rightValue: B) extends Either
 
-:dpt:normalize.result
+:ucs:normalize.result
 fun q(x) =
   if
     x is Some and x is Some and x is Some then 0
diff --git a/shared/src/test/diff/ucs/Wildcard.mls b/shared/src/test/diff/ucs/Wildcard.mls
index 2b817b7c62..ef826d9fd3 100644
--- a/shared/src/test/diff/ucs/Wildcard.mls
+++ b/shared/src/test/diff/ucs/Wildcard.mls
@@ -195,7 +195,7 @@ class Delta()
 
 // This should generate only one case expression instead of a chain of case
 // expressions. DO check the desugared term!
-:dpt:postprocess.result
+:ucs:postprocess.result
 fun w5(y) =
   if y is
     Alpha then "alpha"
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index a627a0f684..ee15d5752a 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -6,7 +6,6 @@ import fastparse.Parsed.Success
 import sourcecode.Line
 import scala.collection.mutable
 import scala.collection.mutable.{Map => MutMap}
-import scala.collection.immutable
 import mlscript.utils._, shorthands._
 import mlscript.codegen.typescript.TsTypegenCodeBuilder
 import org.scalatest.{funsuite, ParallelTestExecution}
@@ -1136,7 +1135,7 @@ object DiffTests {
   }
 
   object PreTyperFlags {
-    private val pattern = "^dpt(?::\\s*([A-Za-z\\.-]+)(,\\s*[A-Za-z\\.-]+)*)?$".r
+    private val pattern = "^ucs(?::\\s*([A-Za-z\\.-]+)(,\\s*[A-Za-z\\.-]+)*)?$".r
     def unapply(flags: Str): Opt[Set[Str]] =
       flags match {
         case pattern(head, tail) =>

From e015482f276ad04fb6a57ef546487efc6b7f946c Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 16 Jan 2024 17:17:06 +0800
Subject: [PATCH 071/147] Make `PreTyper` compulsory but hide error message by
 default

- Show error messages from `PreTyper` by `:ShowPreTyperErrors`.
- Remove useless types in `pretyper` package.
- Distinguish `Diagnostic`s from `ucs` and create a new `Source`.
- Add built-in base classes to `Scope.global`.
- Adjust functions of `Traceable`.
---
 .../src/main/scala/mlscript/Diagnostic.scala  |   1 +
 .../scala/mlscript/pretyper/DataTypes.scala   |  10 -
 .../scala/mlscript/pretyper/Diagnosable.scala |   5 +-
 .../scala/mlscript/pretyper/PreTyper.scala    | 103 +--
 .../main/scala/mlscript/pretyper/Scope.scala  |  25 +-
 .../main/scala/mlscript/pretyper/Symbol.scala |   7 +-
 .../scala/mlscript/pretyper/Traceable.scala   |  47 +-
 .../mlscript/pretyper/TypeContents.scala      |   5 -
 .../main/scala/mlscript/ucs/DesugarUCS.scala  | 101 ++-
 .../ucs/stages/CoverageChecking.scala         |  10 +-
 .../mlscript/ucs/stages/Desugaring.scala      |  11 +-
 .../mlscript/ucs/stages/Normalization.scala   |  16 +-
 .../mlscript/ucs/stages/Transformation.scala  |  23 +-
 .../diff/codegen/AuxiliaryConstructors.mls    |   2 +-
 shared/src/test/diff/codegen/Mixin.mls        |   5 +-
 shared/src/test/diff/codegen/MixinCapture.mls |   2 +-
 shared/src/test/diff/codegen/Nested.mls       |   5 +-
 shared/src/test/diff/codegen/NewMatching.mls  |   2 +-
 shared/src/test/diff/codegen/ValLet.mls       |   2 +-
 .../test/diff/ecoop23/ComparePointPoly.mls    |   2 +-
 .../test/diff/ecoop23/ExpressionProblem.mls   |   2 +-
 shared/src/test/diff/ecoop23/Intro.mls        |   2 +-
 .../test/diff/ecoop23/PolymorphicVariants.mls |   2 +-
 .../diff/ecoop23/SimpleRegionDSL_annot.mls    |   2 +-
 .../test/diff/ecoop23/SimpleRegionDSL_raw.mls |   2 +-
 shared/src/test/diff/fcp/QML_exist_nu.mls     |   2 +-
 shared/src/test/diff/gadt/Exp1.mls            |  15 +-
 shared/src/test/diff/gadt/Exp2.mls            |   2 +-
 shared/src/test/diff/gadt/ThisMatching.mls    |  77 +-
 shared/src/test/diff/nu/Andong.mls            |   2 +-
 shared/src/test/diff/nu/ArrayProg.mls         |   2 +-
 shared/src/test/diff/nu/BadUCS.mls            |   2 +-
 .../test/diff/nu/BasicClassInheritance.mls    |   2 +-
 shared/src/test/diff/nu/BasicClasses.mls      |   2 +-
 shared/src/test/diff/nu/CaseExpr.mls          |  43 +-
 shared/src/test/diff/nu/ClassSignatures.mls   |   2 +-
 shared/src/test/diff/nu/ClassesInMixins.mls   |  13 +-
 shared/src/test/diff/nu/CommaOperator.mls     |  51 +-
 shared/src/test/diff/nu/CtorSubtraction.mls   |   2 +-
 shared/src/test/diff/nu/Eval.mls              |   2 +-
 shared/src/test/diff/nu/EvalNegNeg.mls        |   2 +-
 .../test/diff/nu/ExpressionProblem_repro.mls  |   2 +-
 .../test/diff/nu/ExpressionProblem_small.mls  |   2 +-
 shared/src/test/diff/nu/FilterMap.mls         |   2 +-
 shared/src/test/diff/nu/FlatIfThenElse.mls    |  11 +-
 shared/src/test/diff/nu/FlatMonads.mls        |  33 +-
 shared/src/test/diff/nu/FunnyIndet.mls        |   2 +-
 shared/src/test/diff/nu/GADTMono.mls          |   2 +-
 shared/src/test/diff/nu/GenericClasses.mls    |   2 +-
 shared/src/test/diff/nu/GenericModules.mls    |   2 +-
 shared/src/test/diff/nu/HeungTung.mls         |  28 +-
 shared/src/test/diff/nu/Huawei1.mls           |   2 +-
 shared/src/test/diff/nu/InterfaceMono.mls     | 125 ++-
 shared/src/test/diff/nu/Interfaces.mls        | 153 ++--
 shared/src/test/diff/nu/LetRec.mls            |   5 +-
 shared/src/test/diff/nu/ListConsNil.mls       |   2 +-
 shared/src/test/diff/nu/LitMatch.mls          |   2 +-
 shared/src/test/diff/nu/MissingTypeArg.mls    |   2 +-
 shared/src/test/diff/nu/NamedArgs.mls         |  46 +-
 shared/src/test/diff/nu/New.mls               |   2 +-
 shared/src/test/diff/nu/NewNew.mls            |  31 +-
 shared/src/test/diff/nu/Object.mls            |  20 +-
 shared/src/test/diff/nu/OpLam.mls             |   8 +-
 shared/src/test/diff/nu/OptionFilter.mls      |   2 +-
 shared/src/test/diff/nu/OverrideShorthand.mls |   2 +-
 shared/src/test/diff/nu/ParamPassing.mls      |  40 +-
 .../test/diff/nu/PolymorphicVariants_Alt.mls  |   2 +-
 .../test/diff/nu/PostHocMixinSignature.mls    |   2 +-
 .../test/diff/nu/PrivateMemberOverriding.mls  |   2 +-
 shared/src/test/diff/nu/RefinedPattern.mls    |   5 +-
 shared/src/test/diff/nu/SelfRec.mls           |   2 +-
 shared/src/test/diff/nu/Subscripts.mls        |   2 +-
 shared/src/test/diff/nu/TODO_Classes.mls      |   2 +-
 shared/src/test/diff/nu/Unapply.mls           |   2 +-
 shared/src/test/diff/nu/UndefMatching.mls     |   2 +-
 shared/src/test/diff/nu/WeirdUnions.mls       |   2 +-
 shared/src/test/diff/nu/i180.mls              |   2 +-
 shared/src/test/diff/nu/repro0.mls            |   7 +-
 shared/src/test/diff/nu/repro1.mls            |   2 +-
 shared/src/test/diff/nu/repro_EvalNegNeg.mls  |   2 +-
 .../diff/nu/repro_PolymorphicVariants.mls     |   2 +-
 .../src/test/diff/pretyper/Declarations.mls   |   1 -
 shared/src/test/diff/pretyper/Errors.mls      | 722 ++++++++++++++++++
 shared/src/test/diff/pretyper/Repro.mls       |   2 +-
 .../src/test/diff/pretyper/ucs/DualOption.mls |   2 +-
 .../test/diff/pretyper/ucs/NamePattern.mls    |   2 +-
 .../test/diff/pretyper/ucs/RecordPattern.mls  |   8 +-
 .../pretyper/ucs/SpecilizationCollision.mls   |  12 +-
 shared/src/test/diff/pretyper/ucs/Unapply.mls |   1 -
 .../test/diff/pretyper/ucs/Unconditional.mls  |   2 +-
 .../pretyper/ucs/coverage/MissingCases.mls    |   2 +-
 .../diff/pretyper/ucs/coverage/Refinement.mls |   2 +-
 .../pretyper/ucs/coverage/SealedClasses.mls   |   2 +-
 .../diff/pretyper/ucs/coverage/Tautology.mls  |   2 +-
 .../pretyper/ucs/coverage/Unreachable.mls     |   2 +-
 .../diff/pretyper/ucs/examples/AVLTree.mls    |   2 +-
 .../ucs/examples/BinarySearchTree.mls         |   2 +-
 .../diff/pretyper/ucs/examples/Calculator.mls |   2 +-
 .../pretyper/ucs/examples/EitherOrBoth.mls    |   2 +-
 .../test/diff/pretyper/ucs/examples/JSON.mls  |   2 +-
 .../pretyper/ucs/examples/LeftistTree.mls     |   2 +-
 .../pretyper/ucs/examples/LispInterpreter.mls |   2 +-
 .../test/diff/pretyper/ucs/examples/List.mls  |   2 +-
 .../diff/pretyper/ucs/examples/ListFold.mls   |   2 +-
 .../diff/pretyper/ucs/examples/Option.mls     |   2 +-
 .../pretyper/ucs/examples/Permutations.mls    |   2 +-
 .../test/diff/pretyper/ucs/examples/STLC.mls  |   2 +-
 .../diff/pretyper/ucs/examples/SimpleLisp.mls |   2 +-
 .../diff/pretyper/ucs/examples/SimpleList.mls |   2 +-
 .../diff/pretyper/ucs/examples/SimpleTree.mls |   2 +-
 .../test/diff/pretyper/ucs/examples/ULC.mls   |   2 +-
 .../diff/pretyper/ucs/patterns/Literals.mls   |   2 +-
 .../pretyper/ucs/patterns/SimpleTuple.mls     |   2 +-
 .../pretyper/ucs/stages/Normalization.mls     |   2 +-
 .../pretyper/ucs/stages/PostProcessing.mls    |   2 +-
 .../diff/pretyper/ucs/stages/TransfromUCS.mls |   2 +-
 shared/src/test/diff/ucs/AppSplits.mls        |   2 +-
 .../src/test/diff/ucs/CrossBranchCapture.mls  |  14 +-
 shared/src/test/diff/ucs/DirectLines.mls      |   2 +-
 shared/src/test/diff/ucs/ElseIf.mls           |   2 +-
 shared/src/test/diff/ucs/ErrorMessage.mls     |   5 +-
 shared/src/test/diff/ucs/Exhaustiveness.mls   |   2 +-
 shared/src/test/diff/ucs/Humiliation.mls      |   2 +-
 shared/src/test/diff/ucs/Hygiene.mls          |   2 +-
 shared/src/test/diff/ucs/HygienicBindings.mls |   2 +-
 shared/src/test/diff/ucs/InterleavedLet.mls   |   2 +-
 shared/src/test/diff/ucs/LeadingAnd.mls       |   2 +-
 shared/src/test/diff/ucs/LitUCS.mls           |   2 +-
 shared/src/test/diff/ucs/MultiwayIf.mls       |   2 +-
 shared/src/test/diff/ucs/NestedBranches.mls   |   2 +-
 shared/src/test/diff/ucs/NestedOpSplits.mls   |   2 +-
 shared/src/test/diff/ucs/NestedPattern.mls    |   2 +-
 .../src/test/diff/ucs/NuPlainConditionals.mls |  14 +-
 shared/src/test/diff/ucs/Or.mls               |   2 +-
 .../src/test/diff/ucs/OverlappedBranches.mls  |   2 +-
 shared/src/test/diff/ucs/ParseFailures.mls    |   2 +-
 .../src/test/diff/ucs/PlainConditionals.mls   |  14 +-
 shared/src/test/diff/ucs/SimpleUCS.mls        |   2 +-
 shared/src/test/diff/ucs/SplitAfterOp.mls     |   2 +-
 shared/src/test/diff/ucs/SplitAnd.mls         |   2 +-
 shared/src/test/diff/ucs/SplitAroundOp.mls    |   5 +-
 shared/src/test/diff/ucs/SplitBeforeOp.mls    |  56 +-
 shared/src/test/diff/ucs/SplitOps.mls         |  15 +-
 shared/src/test/diff/ucs/SplitScrutinee.mls   |   2 +-
 shared/src/test/diff/ucs/ThenIndent.mls       |   2 +-
 shared/src/test/diff/ucs/Tree.mls             |   2 +-
 shared/src/test/diff/ucs/TrivialIf.mls        |   2 +-
 shared/src/test/diff/ucs/WeirdIf.mls          |   2 +-
 shared/src/test/diff/ucs/WeirdSplit.mls       |   2 +-
 shared/src/test/diff/ucs/Wildcard.mls         |   2 +-
 shared/src/test/diff/ucs/zipWith.mls          |   2 +-
 .../src/test/scala/mlscript/DiffTests.scala   |  29 +-
 152 files changed, 1375 insertions(+), 818 deletions(-)
 delete mode 100644 shared/src/main/scala/mlscript/pretyper/DataTypes.scala
 delete mode 100644 shared/src/main/scala/mlscript/pretyper/TypeContents.scala
 create mode 100644 shared/src/test/diff/pretyper/Errors.mls

diff --git a/shared/src/main/scala/mlscript/Diagnostic.scala b/shared/src/main/scala/mlscript/Diagnostic.scala
index 00d59a3b9b..e1eaefd8f6 100644
--- a/shared/src/main/scala/mlscript/Diagnostic.scala
+++ b/shared/src/main/scala/mlscript/Diagnostic.scala
@@ -20,6 +20,7 @@ object Diagnostic {
   case object Lexing      extends Source
   case object Parsing     extends Source
   case object PreTyping   extends Source
+  case object Desugaring  extends Source
   case object Typing      extends Source
   case object Compilation extends Source
   case object Runtime     extends Source
diff --git a/shared/src/main/scala/mlscript/pretyper/DataTypes.scala b/shared/src/main/scala/mlscript/pretyper/DataTypes.scala
deleted file mode 100644
index aaebd90165..0000000000
--- a/shared/src/main/scala/mlscript/pretyper/DataTypes.scala
+++ /dev/null
@@ -1,10 +0,0 @@
-package mlscript.pretyper
-
-import mlscript.{NuFunDef, NuTypeDef, Cls, Trt, Mxn, Als, Mod, Var, TypeName}
-import collection.mutable.{Buffer, Map => MutMap, Set => MutSet}
-import mlscript.utils._, shorthands._
-import scala.annotation.tailrec
-
-trait DataTypes { self: PreTyper =>
-
-}
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/pretyper/Diagnosable.scala b/shared/src/main/scala/mlscript/pretyper/Diagnosable.scala
index 332da9f9cb..36cc640635 100644
--- a/shared/src/main/scala/mlscript/pretyper/Diagnosable.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Diagnosable.scala
@@ -22,5 +22,8 @@ trait Diagnosable {
   protected def raiseWarning(source: Source, messages: (Message -> Opt[Loc])*): Unit =
     raise(WarningReport(messages.toList, newDefs = true, source))
 
-  def getDiagnostics: Ls[Diagnostic] = diagnosticBuffer.toList
+  @inline final def filterDiagnostics(f: Diagnostic => Bool): Ls[Diagnostic] =
+    diagnosticBuffer.iterator.filter(f).toList
+
+  @inline final def getDiagnostics: Ls[Diagnostic] = diagnosticBuffer.toList
 }
diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index a247e7faf6..a835a1904f 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -1,20 +1,17 @@
 package mlscript.pretyper
 
-import collection.mutable.{Set => MutSet}
-import collection.immutable.SortedMap
-import symbol._
-import mlscript._, utils._, shorthands._, Diagnostic.PreTyping, Message.MessageContext, ucs.DesugarUCS
-import scala.annotation.tailrec
+import annotation.tailrec, collection.mutable.{Set => MutSet}, collection.immutable.SortedMap, util.chaining._
+import mlscript._, utils._, shorthands._, Diagnostic.PreTyping, Message.MessageContext, symbol._, ucs.DesugarUCS
 
-class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with Diagnosable with DesugarUCS {
+class PreTyper extends Traceable with Diagnosable with DesugarUCS {
   import PreTyper._
 
   /** A shorthand function to raise errors without specifying the source. */
-  protected override def raiseError(messages: (Message -> Opt[Loc])*): Unit =
+  protected def raiseError(messages: (Message -> Opt[Loc])*): Unit =
     raiseError(PreTyping, messages: _*)
 
   /** A shorthand function to raise warnings without specifying the source. */
-  protected override def raiseWarning(messages: (Message -> Opt[Loc])*): Unit =
+  protected def raiseWarning(messages: (Message -> Opt[Loc])*): Unit =
     raiseWarning(PreTyping, messages: _*)
 
   private def extractParameters(fields: Term): Ls[LocalTermSymbol] = {
@@ -38,9 +35,9 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
         raiseError(msg"unsupported pattern shape" -> other.toLoc)
         Iterator.empty
     }
-    val rs = rec(fields).toList
-    println(s"extractParameters ${fields.showDbg} ==> ${rs.iterator.map(_.name).mkString(", ")}")
-    rs
+    rec(fields).tap { rs =>
+      println(s"extractParameters ${fields.showDbg} ==> ${rs.map(_.name).mkString(", ")}")
+    }.toList
   }
 
   protected def resolveVar(v: Var)(implicit scope: Scope): Unit =
@@ -60,9 +57,9 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
             println(s"resolveVar `${v.name}` ==> class")
             v.symbol = sym
           case S(_) =>
-            raiseError(PreTyping, msg"identifier `${v.name}` is resolved to a type" -> v.toLoc)
+            raiseError(msg"identifier `${v.name}` is resolved to a type" -> v.toLoc)
           case N =>
-            raiseError(PreTyping, msg"identifier `${v.name}` not found" -> v.toLoc)
+            raiseError(msg"identifier `${v.name}` not found" -> v.toLoc)
         }
     }
 
@@ -71,7 +68,7 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
       v.symbolOption match {
         case N => resolveVar(v)
         case S(symbol) => scope.getSymbols(v.name) match {
-          case Nil => raiseError(PreTyping, msg"identifier `${v.name}` not found" -> v.toLoc)
+          case Nil => raiseError(msg"identifier `${v.name}` not found" -> v.toLoc)
           case symbols if symbols.contains(symbol) => ()
           case symbols =>
             def toNameLoc(symbol: Symbol): (Str, Opt[Loc]) = symbol match {
@@ -81,7 +78,7 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
               case dt: DefinedTermSymbol => s"`${dt.name}`" -> dt.defn.toLoc
             }
             val (name, loc) = toNameLoc(symbol)
-            raiseError(PreTyping,
+            raiseError(
               (msg"identifier ${v.name} refers to different symbols." -> v.toLoc ::
                 msg"it is resolved to $name" -> loc ::
                 symbols.map { s =>
@@ -106,16 +103,26 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
           traverseTerm(body)(scope + new LocalTermSymbol(nme))
         case New(head, body) =>
           // `new C(...)` or `new C(){...}` or `new{...}`
-        case Tup(fields) => fields.foreach { case (_, Fld(_, t)) => traverseTerm(t) }
+        case Tup(fields) => fields.foreach {
+          case (S(t), Fld(_, _)) => traverseTerm(t)
+          case (N, Fld(_, t)) => traverseTerm(t)
+        }
         case Asc(trm, ty) => traverseTerm(trm)
         case ef @ If(_, _) => traverseIf(ef)(scope)
-        case TyApp(lhs, targs) => // TODO: When?
-        case Eqn(lhs, rhs) => ??? // TODO: How?
+        case TyApp(lhs, targs) =>
+          // Be consistent with the error message from `Typer`.
+          raiseError(msg"type application syntax is not yet supported" -> term.toLoc)
+        case Eqn(lhs, rhs) =>
+          raiseWarning(msg"unsupported `Eqn`: ${term.showDbg}" -> term.toLoc)
         case Blk(stmts) =>
           traverseStatements(stmts, "block", scope)
           ()
-        case Subs(arr, idx) => traverseTerm(arr); traverseTerm(idx)
-        case Bind(lhs, rhs) => traverseTerm(lhs); traverseTerm(rhs)
+        case Subs(arr, idx) =>
+          traverseTerm(arr)
+          traverseTerm(idx)
+        case Bind(lhs, rhs) =>
+          traverseTerm(lhs)
+          traverseTerm(rhs)
         case Splc(fields) => fields.foreach {
           case L(t) => traverseTerm(t)
           case R(Fld(_, t)) => traverseTerm(t)
@@ -124,8 +131,9 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
         case Rcd(fields) => fields.foreach { case (_, Fld(_, t)) => traverseTerm(t) }
         case CaseOf(trm, cases) => 
         case With(trm, fields) => traverseTerm(trm); traverseTerm(fields)
-        case Where(body, where) => ??? // TODO: When?
-        // begin UCS shorthands
+        case Where(body, where) =>
+          raiseWarning(msg"unsupported `Where`: ${term.showDbg}" -> term.toLoc)
+        // begin UCS shorthands ================================================
         //  * Old-style operators
         case App(App(Var("is"), _), _) =>
           println(s"found UCS shorthand: ${term.showDbg}")
@@ -148,12 +156,16 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
           val desugared = If(IfThen(lhs, rhs), S(Var("false")))
           traverseIf(desugared)
           term.desugaredTerm = desugared.desugaredTerm
-        // end UCS shorthands
+        // end UCS shorthands ==================================================
+        case App(lhs, Tup(fields)) =>
+          traverseTerm(lhs)
+          fields.foreach { _._2.value |> traverseTerm }
         case App(lhs, rhs) => traverseTerm(lhs); traverseTerm(rhs)
         case Test(trm, ty) => traverseTerm(trm)
         case _: Lit | _: Super => ()
         case v: Var => traverseVar(v)
-        case AdtMatchWith(cond, arms) => ??? // TODO: How?
+        case AdtMatchWith(cond, arms) =>
+          raiseWarning(msg"unsupported `AdtMatchWith`: ${term.showDbg}" -> term.toLoc)
         case Inst(body) => traverseTerm(body)
         case NuNew(cls) => traverseTerm(cls)
         case Rft(base, decls) => // For object refinement
@@ -169,7 +181,7 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
       ()
     }(_ => s"traverseTypeDefinition <== ${defn.describe}")
 
-  private def traverseStatements(statements: Ls[Statement], name: Str, parentScope: Scope): (Scope, TypeContents) =
+  private def traverseStatements(statements: Ls[Statement], name: Str, parentScope: Scope): Scope =
     trace(s"traverseStatements <== $name: ${"statement".pluralize(statements.size, true)}") {
       // Pass 1: Build a scope with type symbols only.
       val filterNuTypeDef = { (_: Statement) match { case t: NuTypeDef => S(t); case _ => N } }
@@ -190,7 +202,7 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
         acc + (self -> extractSuperTypes(self.defn.parents).flatMap { nme =>
           val maybeSymbol = scopeWithTypes.getTypeSymbol(nme.name)
           if (maybeSymbol.isEmpty) {
-            raiseError(PreTyping, msg"could not find definition `${nme.name}`" -> nme.toLoc)
+            raiseError(msg"could not find definition `${nme.name}`" -> nme.toLoc)
           }
           maybeSymbol
         })
@@ -208,11 +220,7 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
           val derivedTypes = try extractSignatureTypes(unions) catch { case _: NotImplementedError => Nil }
           symbol.sealedDerivedTypes = derivedTypes.flatMap { derivedType =>
             val maybeSymbol = scopeWithTypes.getTypeSymbol(derivedType.name)
-            if (maybeSymbol.isEmpty) raise(ErrorReport(
-              msg"Undefined type $derivedType" -> derivedType.toLoc :: Nil,
-              true,
-              Diagnostic.PreTyping
-            ))
+            if (maybeSymbol.isEmpty) raiseError(msg"Undefined type $derivedType" -> derivedType.toLoc)
             maybeSymbol
           }
           println(s">>> $name: ${symbol.sealedDerivedTypes.iterator.map(_.name).mkString(", ")}")
@@ -257,13 +265,13 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
           case R(_) => ()
         }
       }
-      (completeScope, new TypeContents)
-    }({ case (scope, contents) => s"traverseStatements ==> Scope {${scope.showLocalSymbols}}" })
+      completeScope
+    }({ scope => s"traverseStatements ==> Scope {${scope.showLocalSymbols}}" })
 
-  def process(typingUnit: TypingUnit, scope: Scope, name: Str): (Scope, TypeContents) =
-    trace(s"process <== $name: ${typingUnit.describe}") {
+  def apply(typingUnit: TypingUnit, scope: Scope, name: Str): Scope =
+    trace(s"PreTyper <== $name: ${typingUnit.describe}") {
       traverseStatements(typingUnit.entities, name, scope)
-    }({ case (scope, contents) => s"process ==> ${scope.showLocalSymbols}" })
+    }({ scope => s"PreTyper ==> ${scope.showLocalSymbols}" })
   
   /**
     * Extract types in class signatures. For example, for this piece of code
@@ -289,23 +297,24 @@ class PreTyper(override val debugTopics: Opt[Set[Str]]) extends Traceable with D
     }
     rec(Nil, ty).reverse
   }
-}
-
-object PreTyper {
 
   def extractSuperTypes(parents: Ls[Term]): Ls[Var] = {
     @tailrec
-    def rec(results: Ls[Var], waitlist: Ls[Term]): Ls[Var] =
-      waitlist match {
-        case Nil => results.reverse
-        case (nme: Var) :: tail => rec(nme :: results, tail)
-        case (TyApp(ty, _)) :: tail => rec(results, ty :: tail)
-        case (App(term, Tup(_))) :: tail => rec(results, term :: tail)
-        case other :: _ => println(s"Unknown parent type: $other"); ???
+    def rec(acc: Ls[Var], rest: Ls[Term]): Ls[Var] =
+      rest match {
+        case Nil => acc.reverse
+        case (nme: Var) :: tail => rec(nme :: acc, tail)
+        case (TyApp(ty, _)) :: tail => rec(acc, ty :: tail)
+        case (App(term, Tup(_))) :: tail => rec(acc, term :: tail)
+        case head :: tail =>
+          raiseWarning(msg"unknown type in parent types: ${head.showDbg}" -> head.toLoc)
+          rec(acc, tail)
       }
     rec(Nil, parents)
   }
+}
 
+object PreTyper {
   def transitiveClosure[A](graph: Map[A, List[A]])(implicit ord: Ordering[A]): SortedMap[A, List[A]] = {
     def dfs(vertex: A, visited: Set[A]): Set[A] = {
       if (visited.contains(vertex)) visited
@@ -330,4 +339,4 @@ object PreTyper {
         })
       }
   }
-}
\ No newline at end of file
+}
diff --git a/shared/src/main/scala/mlscript/pretyper/Scope.scala b/shared/src/main/scala/mlscript/pretyper/Scope.scala
index 89b30bd689..794fc41450 100644
--- a/shared/src/main/scala/mlscript/pretyper/Scope.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Scope.scala
@@ -92,24 +92,31 @@ object Scope {
   }
 
   val global: Scope = {
-    val trueDefn = NuTypeDef(Mod, TypeName("true"), Nil, N, N, N, Nil, N, N, TypingUnit(Nil))(N, N)
-    val falseDefn = NuTypeDef(Mod, TypeName("false"), Nil, N, N, N, Nil, N, N, TypingUnit(Nil))(N, N)
-    val nothingDefn = NuTypeDef(Als, TypeName("nothing"), Nil, N, N, N, Nil, N, N, TypingUnit(Nil))(N, N)
-    val trueSymbol = new ModuleSymbol(trueDefn)
-    val falseSymbol = new ModuleSymbol(falseDefn)
-    val nothingSymbol = new TypeAliasSymbol(nothingDefn)
+    def mod(name: Str) = NuTypeDef(Mod, TypeName(name), Nil, N, N, N, Nil, N, N, TypingUnit(Nil))(N, N)
+    // def cls(name: Str) = NuTypeDef(Trt, TypeName(name), Nil, N, N, N, Nil, N, N, TypingUnit(Nil))(N, N)
+    def als(name: Str) = NuTypeDef(Als, TypeName(name), Nil, N, N, N, Nil, N, N, TypingUnit(Nil))(N, N)
+    val builtinTypes = Ls(
+      new ModuleSymbol(mod("true")),
+      new ModuleSymbol(mod("false")),
+      new TypeAliasSymbol(als("nothing")),
+      new DummyClassSymbol(Var("Int")),
+      new DummyClassSymbol(Var("Num")),
+      new DummyClassSymbol(Var("Str")),
+      new DummyClassSymbol(Var("Bool")),
+    )
     val commaSymbol = new LocalTermSymbol(Var(","))
     Scope.from(
       """true,false,document,window,typeof,toString,not,succ,log,discard,negate,
-        |round,add,sub,mul,div,sqrt,lt,le,gt,ge,slt,sle,sgt,sge,length,concat,eq,
-        |ne,error,id,if,emptyArray,+,-,*,%,/,**,<,>,<=,>=,==,===,<>,&&,||,and,
+        |round,add,sub,mul,div,sqrt,lt,le,gt,ge,slt,sle,sgt,sge,length,concat,
+        |join,eq,ne,error,id,if,emptyArray,
+        |+,-,*,%,/,**,<,>,<=,>=,==,===,<>,&&,||,and,
         |numAdd,numSub,numMul,NaN"""
         .stripMargin
         .split(",")
         .iterator
         .map(_.trim)
         .map(name => new LocalTermSymbol(Var(name)))
-        .concat(trueSymbol :: falseSymbol :: nothingSymbol :: commaSymbol :: Nil)
+        .concat(commaSymbol :: builtinTypes)
     )
   }
 }
diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index 41bad9973b..d08cc7b6f7 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -25,11 +25,6 @@ package object symbol {
     
     override def name: Str = defn.name
 
-    def scope: Scope = ???
-    def contents: Map[Str, Symbol] = ???
-
-    def complete(scope: Scope, contents: Map[Str, Symbol]): Unit = ???
-
     var baseTypes: Ls[TypeSymbol] = Nil
     var sealedDerivedTypes: Ls[TypeSymbol] = Nil
 
@@ -60,6 +55,8 @@ package object symbol {
     override def defn: NuTypeDef = die
 
     override def name: Str = nme.name
+
+    override def showDbg: Str = s"dummy class $name"
   }
 
   final class ClassSymbol(override val defn: NuTypeDef) extends TypeSymbol {
diff --git a/shared/src/main/scala/mlscript/pretyper/Traceable.scala b/shared/src/main/scala/mlscript/pretyper/Traceable.scala
index c2ffd59c7e..7d318d3c24 100644
--- a/shared/src/main/scala/mlscript/pretyper/Traceable.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Traceable.scala
@@ -4,41 +4,52 @@ import mlscript.Diagnostic
 import mlscript.utils._, shorthands._
 
 trait Traceable {
-  /** The set of topics to debug. Empty set indicates all topics. */
-  protected val debugTopics: Opt[Set[Str]] = N
-  protected var indent = 0
-  private var currentTopic: Opt[Str] = N
+  /**
+    * The set of topics to debug. Explanation of possible values.
+    * - `N`: Show nothing.
+    * - `S(Set.empty)`: Show everything.
+    * - `S(someTopics)`: Show only the topics in `someTopics`.
+    * Override this function to enable debugging.
+    */
+  protected def debugTopicFilters: Opt[Set[Str]] = N
+  private var debugIndent = 0
+  private var currentDebugTopics: Opt[Str] = N
 
-  def emitString(str: String): Unit = scala.Predef.println(str)
+  private def matchTopicFilters: Boolean =
+    debugTopicFilters match {
+      case S(topics) if topics.isEmpty => true
+      case S(topics) => currentDebugTopics.fold(false)(topics)
+      case N => false
+    }
+
+  /** Override this function to redirect debug messages. */
+  protected def emitString(str: Str): Unit = scala.Predef.println(str)
   
   @inline private def printLineByLine(x: => Any): Unit =
-    x.toString.linesIterator.foreach { line => emitString("| " * indent + line) }
+    x.toString.linesIterator.foreach { line => emitString("| " * debugIndent + line) }
 
-  def trace[T](pre: => String)(thunk: => T)(post: T => String = Traceable.noPostTrace): T = {
+  protected def trace[T](pre: => Str)(thunk: => T)(post: T => Str = Traceable.noPostTrace): T = {
     println(pre)
-    indent += 1
-    val res = try thunk finally indent -= 1
+    debugIndent += 1
+    val res = try thunk finally debugIndent -= 1
     if (post isnt Traceable.noPostTrace) println(post(res))
     res
   }
 
-  def traceWithTopic[T](currentTopic: Str)(thunk: => T): T = {
-    this.currentTopic = S(currentTopic)
+  protected def traceWithTopic[T](currentDebugTopics: Str)(thunk: => T): T = {
+    this.currentDebugTopics = S(currentDebugTopics)
     val res = thunk
-    this.currentTopic = N
+    this.currentDebugTopics = N
     res
   }
 
-  @inline def traceNot[T](pre: => String)(thunk: => T)(post: T => String = Traceable.noPostTrace): T =
+  @inline def traceNot[T](pre: => Str)(thunk: => T)(post: T => Str = Traceable.noPostTrace): T =
     thunk
   
   @inline protected def println(x: => Any): Unit =
-    debugTopics match {
-      case S(someTopics) if someTopics.isEmpty || currentTopic.fold(false)(someTopics) => printLineByLine(x)
-      case N | S(_) => ()
-    }
+    if (matchTopicFilters) printLineByLine(x)
 }
 
 object Traceable {
-  val noPostTrace: Any => String = _ => ""
+  val noPostTrace: Any => Str = _ => ""
 }
diff --git a/shared/src/main/scala/mlscript/pretyper/TypeContents.scala b/shared/src/main/scala/mlscript/pretyper/TypeContents.scala
deleted file mode 100644
index fc9e0a9c8a..0000000000
--- a/shared/src/main/scala/mlscript/pretyper/TypeContents.scala
+++ /dev/null
@@ -1,5 +0,0 @@
-package mlscript.pretyper
-
-class TypeContents {
-  // Stub
-}
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
index a9b861a547..35ff3779ff 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
@@ -5,24 +5,27 @@ import syntax.{source => s, core => c}, stages._, context.{Context, ScrutineeDat
 import mlscript.ucs.display.{showNormalizedTerm, showSplit}
 import mlscript.pretyper.{PreTyper, Scope}
 import mlscript.pretyper.symbol._
-import mlscript.{If, Loc, Message, Var}, Message.MessageContext, mlscript.Diagnostic.PreTyping
+import mlscript.{If, Loc, Message, Var}, Message.MessageContext, mlscript.Diagnostic
 import mlscript.utils._, shorthands._
 import syntax.core.{Branch, Split}
 
-// TODO: Rename to `Desugarer` once the old desugarer is removed.
+/**
+  * The main class of the UCS desugaring.
+  * TODO: Rename to `Desugarer` once the old desugarer is removed.
+  */
 trait DesugarUCS extends Transformation
                     with Desugaring
                     with Normalization
                     with PostProcessing 
                     with CoverageChecking { self: PreTyper =>
 
-  /** A shorthand function to raise errors without specifying the source. */
-  protected def raiseError(messages: (Message -> Opt[Loc])*): Unit =
-    raiseError(PreTyping, messages: _*)
+  /** A shorthand function to raise _desugaring_ errors without specifying the source. */
+  protected def raiseDesugaringError(messages: (Message -> Opt[Loc])*): Unit =
+    raiseError(Diagnostic.Desugaring, messages: _*)
 
-  /** A shorthand function to raise warnings without specifying the source. */
-  protected def raiseWarning(messages: (Message -> Opt[Loc])*): Unit =
-    raiseWarning(PreTyping, messages: _*)
+  /** A shorthand function to raise _desugaring_ warnings without specifying the source. */
+  protected def raiseDesugaringWarning(messages: (Message -> Opt[Loc])*): Unit =
+    raiseWarning(Diagnostic.Desugaring, messages: _*)
 
   /** Create a fresh local symbol for the given `Var`. */
   protected def freshSymbol(nme: Var): LocalTermSymbol = new LocalTermSymbol(nme)
@@ -40,10 +43,10 @@ trait DesugarUCS extends Transformation
     private def requireClassLikeSymbol(symbol: TypeSymbol)(implicit context: Context): TypeSymbol = symbol match {
       case symbol @ (_: TraitSymbol | _: ClassSymbol | _: ModuleSymbol | _: DummyClassSymbol) => symbol
       case symbol: MixinSymbol =>
-        raiseError(msg"Mixins are not allowed in pattern" -> nme.toLoc)
+        raiseDesugaringError(msg"Mixins are not allowed in pattern" -> nme.toLoc)
         context.getOrCreateDummyClassSymbol(nme)
       case symbol: TypeAliasSymbol =>
-        raiseError(msg"Type alias is not allowed in pattern" -> nme.toLoc)
+        raiseDesugaringError(msg"Type alias is not allowed in pattern" -> nme.toLoc)
         context.getOrCreateDummyClassSymbol(nme)
     }
 
@@ -56,10 +59,10 @@ trait DesugarUCS extends Transformation
       val symbol = nme.symbolOption match {
         case S(symbol: TypeSymbol) => requireClassLikeSymbol(symbol)
         case S(symbol: TermSymbol) =>
-          raiseError(msg"variable ${nme.name} is not associated with a class symbol" -> nme.toLoc)
+          raiseDesugaringError(msg"variable ${nme.name} is not associated with a class symbol" -> nme.toLoc)
           context.getOrCreateDummyClassSymbol(nme)
         case N =>
-          raiseError(msg"variable ${nme.name} is not associated with any symbols" -> nme.toLoc)
+          raiseDesugaringError(msg"variable ${nme.name} is not associated with any symbols" -> nme.toLoc)
           context.getOrCreateDummyClassSymbol(nme)
       }
       println(s"getClassLikeSymbol: ${nme.name} ==> ${symbol.showDbg}")
@@ -100,7 +103,7 @@ trait DesugarUCS extends Transformation
         case N => resolveTermSymbol
         case S(symbol: TermSymbol) => symbol
         case S(otherSymbol) =>
-          raiseError(msg"identifier `${nme.name}` should be a term" -> nme.toLoc)
+          raiseDesugaringError(msg"identifier `${nme.name}` should be a term" -> nme.toLoc)
           freshSymbol(nme) // TODO: Maybe we should maintain a "lost" symbol map.
       }
     }
@@ -108,7 +111,7 @@ trait DesugarUCS extends Transformation
     /** Associate the `Var` with a term symbol and returns the term symbol. */
     def resolveTermSymbol(implicit scope: Scope): TermSymbol = {
       val symbol = scope.getTermSymbol(nme.name).getOrElse {
-        raiseError(msg"identifier `${nme.name}` not found" -> nme.toLoc)
+        raiseDesugaringError(msg"identifier `${nme.name}` not found" -> nme.toLoc)
         freshSymbol(nme) // TODO: Maybe we should maintain a "lost" symbol map.
       }
       nme.symbol = symbol
@@ -123,7 +126,7 @@ trait DesugarUCS extends Transformation
       val symbol = scope.getTypeSymbol(nme.name) match {
         case S(symbol) => requireClassLikeSymbol(symbol)
         case N =>
-          raiseError(msg"type identifier `${nme.name}` not found" -> nme.toLoc)
+          raiseDesugaringError(msg"type identifier `${nme.name}` not found" -> nme.toLoc)
           context.getOrCreateDummyClassSymbol(nme)
       }
       nme.symbol = symbol
@@ -138,13 +141,23 @@ trait DesugarUCS extends Transformation
       { nme.resolveClassLikeSymbol; nme }
   }
 
+  /**
+    * This class defines common operations on _splits_ in source abstract syntax
+    * (i.e., `ucs.syntax.source.Split`). 
+    */
   protected implicit class SourceSplitOps[+B <: s.Branch](these: s.Split[B]) {
+    /**
+      * Concatenate two splits and raise a warning if the latter is discarded.
+      *
+      * @param those the right-hand side `ucs.syntax.source.Split`
+      * @return a new split which is the concatenation of LHS and RHS
+      */
     def ++[BB >: B <: s.Branch](those: s.Split[BB]): s.Split[BB] =
       if (those === s.Split.Nil) these else (these match {
         case s.Split.Cons(head, tail) => s.Split.Cons(head, tail ++ those)
         case s.Split.Let(rec, nme, rhs, tail) => s.Split.Let(rec, nme, rhs, tail ++ those)
         case s.Split.Else(_) =>
-          raiseWarning(
+          raiseDesugaringWarning(
             msg"unreachable case" -> those.toLoc,
             msg"because this branch covers the case" -> these.toLoc
           )
@@ -153,17 +166,23 @@ trait DesugarUCS extends Transformation
       })
   }
 
+  /**
+    * This class defines common operations on _splits_ in _core_ abstract syntax
+    * (i.e., `ucs.syntax.core.Split`). 
+    */
   protected implicit class CoreSplitOps(these: c.Split) {
     /**
-      * Concatenates two splits. Beware that `that` may be discarded if `this`
-      * has an else branch. Make sure to make diagnostics for discarded `that`.
+      * Concatenate two splits and raise a warning if the latter is discarded.
+      *
+      * @param those the right-hand side `ucs.syntax.core.Split`
+      * @return a new split which is the concatenation of LHS and RHS
       */
     def ++(those: c.Split): c.Split =
       if (those === c.Split.Nil) these else (these match {
         case me: c.Split.Cons => me.copy(tail = me.tail ++ those)
         case me: c.Split.Let => me.copy(tail = me.tail ++ those)
         case _: c.Split.Else =>
-          raiseWarning(
+          raiseDesugaringWarning(
             msg"the case is unreachable" -> those.toLoc,
             msg"because this branch covers the case" -> these.toLoc
           )
@@ -172,6 +191,15 @@ trait DesugarUCS extends Transformation
       })
   }
 
+  /**
+    * The entry-point of desugaring a UCS syntax tree (`If` node) to a normal
+    * MLscript syntax tree made of `CaseOf` and `Let` nodes. `PreTyper` is
+    * supposed to call this function. Note that the caller doesn't need to
+    * resolve symbols and bindings inside the UCS tree.
+    *
+    * @param if the UCS syntax tree to be desugared
+    * @param scope the scope of the `If` node
+    */
   protected def traverseIf(`if`: If)(implicit scope: Scope): Unit = {
     implicit val context: Context = new Context(`if`)
     try trace("traverseIf") {
@@ -227,25 +255,26 @@ trait DesugarUCS extends Transformation
       // Epilogue
       `if`.desugaredTerm = S(postProcessed)
     }(_ => "traverseIf ==> ()") catch {
-      case e: DesugaringException => raiseError(e.messages: _*)
+      case e: DesugaringException => raiseDesugaringError(e.messages: _*)
     }
   }
   
+  /**
+    * Traverse a desugared _core abstract syntax_ tree. The function takes care
+    * of let bindings and resolves variables.
+    */
   private def traverseSplit(split: syntax.core.Split)(implicit scope: Scope): Unit =
-    trace(s"traverseSplit <== [${scope.showLocalSymbols}]") {
-      
-      split match {
-        case Split.Cons(Branch(scrutinee, pattern, continuation), tail) => 
-          traverseTerm(scrutinee)
-          val patternSymbols = pattern.declaredVars.map(nme => nme -> nme.symbol)
-          traverseSplit(continuation)(scope.withEntries(patternSymbols))
-          traverseSplit(tail)
-        case Split.Let(isRec, name, rhs, tail) =>
-          val recScope = scope + name.symbol
-          traverseTerm(rhs)(if (isRec) recScope else scope)
-          traverseSplit(tail)(recScope)
-        case Split.Else(default) => traverseTerm(default)
-        case Split.Nil => ()
-      }
-    }()
+    split match {
+      case Split.Cons(Branch(scrutinee, pattern, continuation), tail) => 
+        traverseTerm(scrutinee)
+        val patternSymbols = pattern.declaredVars.map(nme => nme -> nme.symbol)
+        traverseSplit(continuation)(scope.withEntries(patternSymbols))
+        traverseSplit(tail)
+      case Split.Let(isRec, name, rhs, tail) =>
+        val recScope = scope + name.symbol
+        traverseTerm(rhs)(if (isRec) recScope else scope)
+        traverseSplit(tail)(recScope)
+      case Split.Else(default) => traverseTerm(default)
+      case Split.Nil => ()
+    }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index b3dfc2a0a1..5a7a368a55 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -31,7 +31,7 @@ trait CoverageChecking { self: DesugarUCS with Traceable =>
       term match {
         case Let(_, _, _, body) => checkCoverage(body, pending, working, seen)
         case CaseOf(scrutineeVar: Var, Case(Var("true"), body, NoCases)) if context.isTestVar(scrutineeVar) =>
-          raiseError(msg"missing else branch" -> body.toLoc)
+          raiseDesugaringError(msg"missing else branch" -> body.toLoc)
           Nil
         case CaseOf(ScrutineeData.WithVar(scrutinee, scrutineeVar), cases) =>
           println(s"scrutinee: ${scrutineeVar.name}")
@@ -87,9 +87,9 @@ trait CoverageChecking { self: DesugarUCS with Traceable =>
                   )
                 case N =>
                   unseenPatterns -> (diagnostics :+ (seen.get(namedScrutinee) match {
-                    case S((`classSymbol`, _, _)) => WarningReport("tautology", Nil, Diagnostic.PreTyping)
-                    case S(_) => ErrorReport("contradiction", Nil, Diagnostic.PreTyping)
-                    case N => ErrorReport("unvisited scrutinee", Nil, Diagnostic.PreTyping)
+                    case S((`classSymbol`, _, _)) => WarningReport("tautology", Nil, Diagnostic.Desugaring)
+                    case S(_) => ErrorReport("contradiction", Nil, Diagnostic.Desugaring)
+                    case N => ErrorReport("unvisited scrutinee", Nil, Diagnostic.Desugaring)
                   }))
               }
             case ((unseenPatterns, diagnostics), (literal: Lit) -> body) =>
@@ -131,7 +131,7 @@ object CoverageChecking {
             msg"${prologue}scrutinee `${scrutinee._1.name}` is `${classSymbol.name}`$epilogue" -> locations.headOption
           }.toList ::: lines
         }
-      }, true, Diagnostic.PreTyping))
+      }, true, Diagnostic.Desugaring))
     }
 
   /** A helper function that prints entries from the given registry line by line. */
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 62505cc990..01b649dbe6 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -8,7 +8,6 @@ import mlscript.ucs.helpers.mkBinOp
 import mlscript.utils._, shorthands._
 import mlscript.pretyper.symbol._
 import mlscript.pretyper.{PreTyper, Scope}
-import mlscript.Diagnostic.PreTyping
 import mlscript.Message, Message.MessageContext
 
 /**
@@ -148,7 +147,7 @@ trait Desugaring { self: PreTyper =>
           symbol.addScrutinee(classPattern.getParameter(index).withAlias(subScrutineeVar))
           S(subScrutineeVar.withSymbol(symbol) -> S(parameterPattern))
         case (pattern, _) =>
-          raiseError(PreTyping, msg"unsupported pattern" -> pattern.toLoc)
+          raiseDesugaringError(msg"unsupported pattern" -> pattern.toLoc)
           N
       }.toList
     }(r => s"flattenClassParameters ==> ${r.mkString(", ")}")
@@ -255,7 +254,7 @@ trait Desugaring { self: PreTyper =>
           (scopeWithNestedAll, bindNestedAll.andThen(bindPrevious))
         // Well, other patterns are not supported yet.
         case (acc, S(nme -> S(pattern))) =>
-          raiseError(PreTyping, msg"unsupported pattern is" -> pattern.toLoc)
+          raiseDesugaringError(msg"unsupported pattern is" -> pattern.toLoc)
           acc
         // If this parameter is empty (e.g. produced by wildcard), then we do
         // nothing and pass on scope and binder.
@@ -277,7 +276,7 @@ trait Desugaring { self: PreTyper =>
         symbol.addScrutinee(tuplePattern.getField(index).withAlias(subScrutineeVar))
         S(subScrutineeVar.withSymbol(symbol) -> S(parameterPattern))
       case (pattern, _) =>
-        raiseError(PreTyping, msg"unsupported pattern" -> pattern.toLoc)
+        raiseDesugaringError(msg"unsupported pattern" -> pattern.toLoc)
         N
     }.toList
   }
@@ -303,7 +302,7 @@ trait Desugaring { self: PreTyper =>
       case s.Split.Cons(head, tail) =>
         head.pattern match {
           case pattern @ s.AliasPattern(_, _) =>
-            raiseError(PreTyping, msg"alias pattern is not supported for now" -> pattern.toLoc)
+            raiseDesugaringError(msg"alias pattern is not supported for now" -> pattern.toLoc)
             rec(scrutineeVar, tail)
           case s.LiteralPattern(literal) =>
             scrutineeVar.getOrCreateScrutinee.withAlias(scrutineeVar).getOrCreateLiteralPattern(literal).addLocation(literal)
@@ -359,7 +358,7 @@ trait Desugaring { self: PreTyper =>
               withBindings ++ rec(scrutineeVar, tail)
             }
           case pattern @ s.RecordPattern(_) =>
-            raiseError(PreTyping, msg"record pattern is not supported for now" -> pattern.toLoc)
+            raiseDesugaringError(msg"record pattern is not supported for now" -> pattern.toLoc)
             rec(scrutineeVar, tail)
         }
       case s.Split.Let(isRec, nme, rhs, tail) =>
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index d48c95feb2..184b36cd75 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -27,7 +27,7 @@ trait Normalization { self: DesugarUCS with Traceable =>
   ): Split =
     if (these.hasElse) {
       if (those =/= Split.Nil && shouldReportDiscarded) {
-        raiseWarning(
+        raiseDesugaringWarning(
           msg"the case is unreachable" -> those.toLoc,
           msg"because this branch already covers the case" -> these.toLoc
         )
@@ -83,7 +83,7 @@ trait Normalization { self: DesugarUCS with Traceable =>
     def :++(tail: => Split): Split = {
       if (these.hasElse) {
         println("tail is discarded")
-        // raiseWarning(msg"Discarded split because of else branch" -> these.toLoc)
+        // raiseDesugaringWarning(msg"Discarded split because of else branch" -> these.toLoc)
         these
       } else {
         these ++ tail
@@ -137,7 +137,7 @@ trait Normalization { self: DesugarUCS with Traceable =>
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context))
         CaseOf(scrutineeVar, Case(nme, trueBranch, falseBranch)(refined = pattern.refined))
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
-        raiseError(msg"unsupported pattern: ${pattern.toString}" -> pattern.toLoc)
+        raiseDesugaringError(msg"unsupported pattern: ${pattern.toString}" -> pattern.toLoc)
         errorTerm
       case Split.Let(_, nme, _, tail) if context.isScrutineeVar(nme) && generatedVars.contains(nme) =>
         println(s"LET: SKIP already declared scrutinee ${nme.name}")
@@ -152,7 +152,7 @@ trait Normalization { self: DesugarUCS with Traceable =>
         println(s"DFLT: ${default.showDbg}")
         default
       case Split.Nil =>
-        raiseError(msg"unexpected empty split found" -> N)
+        raiseDesugaringError(msg"unexpected empty split found" -> N)
         errorTerm
     }
   }(split => "normalizeToTerm ==> " + showNormalizedTerm(split))
@@ -211,7 +211,7 @@ trait Normalization { self: DesugarUCS with Traceable =>
                 println(s"Case 1: class name: ${className.name} === ${otherClassName.name}")
                 if (otherRefined =/= refined) {
                   def be(value: Bool): Str = if (value) "is" else "is not"
-                  raiseWarning(
+                  raiseDesugaringWarning(
                     msg"inconsistent refined case branches" -> pattern.toLoc,
                     msg"class pattern ${className.name} ${be(refined)} refined" -> className.toLoc,
                     msg"but class pattern ${otherClassName.name} ${be(otherRefined)} refined" -> otherClassName.toLoc
@@ -230,7 +230,7 @@ trait Normalization { self: DesugarUCS with Traceable =>
               }
             case _ =>
               // TODO: Make a case for this. Check if this is a valid case.
-              raiseError(
+              raiseDesugaringError(
                 msg"pattern ${pattern.toString}" -> pattern.toLoc,
                 msg"is incompatible with class pattern ${otherClassName.name}" -> otherClassName.toLoc,
               )
@@ -253,7 +253,7 @@ trait Normalization { self: DesugarUCS with Traceable =>
               println("both of them are class patterns")
               if (otherRefined =/= refined) {
                 def be(value: Bool): Str = if (value) "is" else "is not"
-                raiseWarning(
+                raiseDesugaringWarning(
                   msg"inconsistent refined case branches" -> pattern.toLoc,
                   msg"class pattern ${className.name} ${be(refined)} refined" -> className.toLoc,
                   msg"but class pattern ${otherClassName.name} ${be(otherRefined)} refined" -> otherClassName.toLoc
@@ -317,7 +317,7 @@ trait Normalization { self: DesugarUCS with Traceable =>
         }
       // Other patterns. Not implemented.
       case (_, split @ Split.Cons(Branch(otherScrutineeVar, pattern, continuation), tail)) =>
-        raiseError(msg"found unsupported pattern: ${pattern.toString}" -> pattern.toLoc)
+        raiseDesugaringError(msg"found unsupported pattern: ${pattern.toString}" -> pattern.toLoc)
         split
       case (_, let @ Split.Let(_, nme, _, tail)) =>
         println(s"let binding ${nme.name}, go next")
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index 29b7fbe384..5fa77fba4d 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -1,18 +1,13 @@
 package mlscript.ucs.stages
 
+import mlscript.ucs.syntax.source._
 import mlscript.ucs.{DesugarUCS, helpers}
 import mlscript.{If, IfBody, IfBlock, IfElse, IfLet, IfOpApp, IfOpsApp, IfThen}
-import mlscript.{Blk, Term, Var, App, Tup, Lit, Fld, Loc}
-import mlscript.Diagnostic.PreTyping
+import mlscript.{Blk, Term, Var, App, Tup, Lit, Fld, Loc, NuFunDef, PlainTup}
 import mlscript.pretyper.Traceable
-import mlscript.ucs.syntax.source._
 import mlscript.Message, Message._
 import mlscript.utils._, shorthands._
-import mlscript.NuFunDef
-import mlscript.PlainTup
-import scala.collection.immutable
-import scala.annotation.tailrec
-import scala.util.chaining._
+import scala.collection.immutable, scala.annotation.tailrec, scala.util.chaining._
 
 /**
   * Transform the parsed AST into an AST similar to the one in the paper.
@@ -72,7 +67,7 @@ trait Transformation { self: DesugarUCS with Traceable =>
           case (acc, R(NuFunDef(S(rec), nme, _, _, L(rhs)))) =>
             acc ++ Split.Let(rec, nme, rhs, Split.Nil)
           case (acc, R(statement)) =>
-            raiseError(msg"Unexpected statement in an if block" -> statement.toLoc)
+            raiseDesugaringError(msg"Unexpected statement in an if block" -> statement.toLoc)
             acc
         }
       case IfOpsApp(lhs, opsRhss) =>
@@ -99,7 +94,7 @@ trait Transformation { self: DesugarUCS with Traceable =>
     opsRhss.iterator.flatMap {
       case Var("and") -> rhs => S(transformIfBody(rhs))
       case op -> rhs =>
-        raiseError(
+        raiseDesugaringError(
           msg"cannot transform due to an illegal split operator ${op.name}" -> op.toLoc,
           msg"the following branch will be discarded" -> rhs.toLoc)
         N
@@ -129,7 +124,7 @@ trait Transformation { self: DesugarUCS with Traceable =>
           val ::(head, tail) = splitAnd(lhs)
           PatternBranch(transformPattern(head), transformConjunction(tail, transformIfBody(rhs), false)).toSplit
         case IfOpApp(lhs, op, rhs) =>
-          raiseError(msg"Syntactic split of patterns are not supported" -> op.toLoc)
+          raiseDesugaringError(msg"Syntactic split of patterns are not supported" -> op.toLoc)
           Split.Nil
         case IfOpsApp(lhs, opsRhss) =>
           // BEGIN TEMPORARY PATCH
@@ -172,7 +167,7 @@ trait Transformation { self: DesugarUCS with Traceable =>
           case (acc, R(NuFunDef(S(rec), nme, _, _, L(rhs)))) =>
             acc ++ Split.Let(rec, nme, rhs, Split.Nil)
           case (acc, R(statement)) =>
-            raiseError(msg"Unexpected statement in an if block" -> statement.toLoc)
+            raiseDesugaringError(msg"Unexpected statement in an if block" -> statement.toLoc)
             acc
         }
         case IfElse(expr) => Split.default(expr)
@@ -199,7 +194,7 @@ trait Transformation { self: DesugarUCS with Traceable =>
       transformPattern(p) match {
         case cp: ClassPattern => cp.copy(refined = true).withLocOf(cp)
         case p =>
-          raiseError(msg"only class patterns can be refined" -> p.toLoc)
+          raiseDesugaringError(msg"only class patterns can be refined" -> p.toLoc)
           p
       }
     case App(classNme @ Var(_), parameters: Tup) =>
@@ -208,7 +203,7 @@ trait Transformation { self: DesugarUCS with Traceable =>
     case Blk((term: Term) :: Nil) => transformPattern(term) // A speical case for FunnyIndet.mls
     case other =>
       println(s"other $other")
-      raiseError(msg"unknown pattern ${other.showDbg}" -> other.toLoc)
+      raiseDesugaringError(msg"unknown pattern ${other.showDbg}" -> other.toLoc)
       EmptyPattern(other)
   }
 
diff --git a/shared/src/test/diff/codegen/AuxiliaryConstructors.mls b/shared/src/test/diff/codegen/AuxiliaryConstructors.mls
index ac763dbf4d..5190d2ed3d 100644
--- a/shared/src/test/diff/codegen/AuxiliaryConstructors.mls
+++ b/shared/src/test/diff/codegen/AuxiliaryConstructors.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 :js
 class A(x: Int) {}
diff --git a/shared/src/test/diff/codegen/Mixin.mls b/shared/src/test/diff/codegen/Mixin.mls
index 4462228f0a..d165563814 100644
--- a/shared/src/test/diff/codegen/Mixin.mls
+++ b/shared/src/test/diff/codegen/Mixin.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 :js
 class Add<out E>(lhs: E, rhs: E)
@@ -367,9 +367,6 @@ Barr.y
 mixin Base {
   fun x = y
 }
-//│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.368: 	  fun x = y
-//│ ╙──       	          ^
 //│ ╔══[ERROR] identifier not found: y
 //│ ║  l.368: 	  fun x = y
 //│ ╙──       	          ^
diff --git a/shared/src/test/diff/codegen/MixinCapture.mls b/shared/src/test/diff/codegen/MixinCapture.mls
index 8bad474ea1..1137c5947c 100644
--- a/shared/src/test/diff/codegen/MixinCapture.mls
+++ b/shared/src/test/diff/codegen/MixinCapture.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 :js
 class Lit(n: Int)
diff --git a/shared/src/test/diff/codegen/Nested.mls b/shared/src/test/diff/codegen/Nested.mls
index 59fe95ae52..b4f07150f5 100644
--- a/shared/src/test/diff/codegen/Nested.mls
+++ b/shared/src/test/diff/codegen/Nested.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 :js
 module A {
@@ -1262,9 +1262,6 @@ fun main =
     else g(x - 1)
   let g(x: Int): Int = f(x)
   f
-//│ ╔══[ERROR] identifier `g` not found
-//│ ║  l.1262: 	    else g(x - 1)
-//│ ╙──        	         ^
 //│ fun main: (x: Int) -> Int
 //│ // Prelude
 //│ class TypingUnit24 {}
diff --git a/shared/src/test/diff/codegen/NewMatching.mls b/shared/src/test/diff/codegen/NewMatching.mls
index 40b5a0bbf2..ea173a88d1 100644
--- a/shared/src/test/diff/codegen/NewMatching.mls
+++ b/shared/src/test/diff/codegen/NewMatching.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 class V0()
 class V1(val x: Int)
diff --git a/shared/src/test/diff/codegen/ValLet.mls b/shared/src/test/diff/codegen/ValLet.mls
index e1b04b7e9b..6cdfebc4cb 100644
--- a/shared/src/test/diff/codegen/ValLet.mls
+++ b/shared/src/test/diff/codegen/ValLet.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 :js
 class A(x0: Int) {
diff --git a/shared/src/test/diff/ecoop23/ComparePointPoly.mls b/shared/src/test/diff/ecoop23/ComparePointPoly.mls
index e3cd651e95..c90dfde588 100644
--- a/shared/src/test/diff/ecoop23/ComparePointPoly.mls
+++ b/shared/src/test/diff/ecoop23/ComparePointPoly.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class Some[out A](val value: A)
diff --git a/shared/src/test/diff/ecoop23/ExpressionProblem.mls b/shared/src/test/diff/ecoop23/ExpressionProblem.mls
index 8b6b16d713..7745355af2 100644
--- a/shared/src/test/diff/ecoop23/ExpressionProblem.mls
+++ b/shared/src/test/diff/ecoop23/ExpressionProblem.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 // * Motivating paper example, demonstrating the expression problem solution
diff --git a/shared/src/test/diff/ecoop23/Intro.mls b/shared/src/test/diff/ecoop23/Intro.mls
index 880c19b9f9..dda082110c 100644
--- a/shared/src/test/diff/ecoop23/Intro.mls
+++ b/shared/src/test/diff/ecoop23/Intro.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 // * Examples from paper intro
diff --git a/shared/src/test/diff/ecoop23/PolymorphicVariants.mls b/shared/src/test/diff/ecoop23/PolymorphicVariants.mls
index 66da4d52d2..4ca877b149 100644
--- a/shared/src/test/diff/ecoop23/PolymorphicVariants.mls
+++ b/shared/src/test/diff/ecoop23/PolymorphicVariants.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 // * Adapted example from Code reuse through polymorphic variants (FOSE 2000)
diff --git a/shared/src/test/diff/ecoop23/SimpleRegionDSL_annot.mls b/shared/src/test/diff/ecoop23/SimpleRegionDSL_annot.mls
index df937b92dd..deffc2a469 100644
--- a/shared/src/test/diff/ecoop23/SimpleRegionDSL_annot.mls
+++ b/shared/src/test/diff/ecoop23/SimpleRegionDSL_annot.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 // * Adapted example from Compositional Embeddings of Domain-Specific Languages (OOPSLA 2022)
diff --git a/shared/src/test/diff/ecoop23/SimpleRegionDSL_raw.mls b/shared/src/test/diff/ecoop23/SimpleRegionDSL_raw.mls
index 21c6d8ee46..beb482557b 100644
--- a/shared/src/test/diff/ecoop23/SimpleRegionDSL_raw.mls
+++ b/shared/src/test/diff/ecoop23/SimpleRegionDSL_raw.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 // * Adapted example from Compositional Embeddings of Domain-Specific Languages (OOPSLA 2022)
diff --git a/shared/src/test/diff/fcp/QML_exist_nu.mls b/shared/src/test/diff/fcp/QML_exist_nu.mls
index 2c0986bf16..39fa4e19e9 100644
--- a/shared/src/test/diff/fcp/QML_exist_nu.mls
+++ b/shared/src/test/diff/fcp/QML_exist_nu.mls
@@ -1,6 +1,6 @@
 // * TODO also a GADT version of this where we use `Arrays[A]: ArraysImpl[A, ?]`
 
-:PreTyper
+:NewDefs
 
 :DontDistributeForalls // * Also works without this
 
diff --git a/shared/src/test/diff/gadt/Exp1.mls b/shared/src/test/diff/gadt/Exp1.mls
index 97db8501df..8daa75e1c0 100644
--- a/shared/src/test/diff/gadt/Exp1.mls
+++ b/shared/src/test/diff/gadt/Exp1.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 abstract class Exp[A]: Pair | Lit
@@ -36,12 +36,6 @@ fun f(e) = if e is
 //│ ╔══[ERROR] unknown pattern Pair‹'a, 'b›(l, r,)
 //│ ║  l.35: 	  Pair['a, 'b](l, r) then [l, r]
 //│ ╙──      	  ^^^^^^^^^^^^^^^^^^
-//│ ╔══[ERROR] identifier `l` not found
-//│ ║  l.35: 	  Pair['a, 'b](l, r) then [l, r]
-//│ ╙──      	                           ^
-//│ ╔══[ERROR] identifier `r` not found
-//│ ║  l.35: 	  Pair['a, 'b](l, r) then [l, r]
-//│ ╙──      	                              ^
 //│ ╔══[ERROR] identifier not found: l
 //│ ║  l.35: 	  Pair['a, 'b](l, r) then [l, r]
 //│ ╙──      	                           ^
@@ -58,14 +52,11 @@ fun f(e) = if e is
   Pair(l: a, r) then
     let f(x: a) = x
     f(l)
-//│ ╔══[ERROR] identifier `l` not found
-//│ ║  l.60: 	    f(l)
-//│ ╙──      	      ^
 //│ ╔══[ERROR] type identifier not found: a
-//│ ║  l.59: 	    let f(x: a) = x
+//│ ║  l.53: 	    let f(x: a) = x
 //│ ╙──      	             ^
 //│ ╔══[ERROR] identifier not found: l
-//│ ║  l.60: 	    f(l)
+//│ ║  l.54: 	    f(l)
 //│ ╙──      	      ^
 //│ fun f: Pair[anything, anything] -> error
 //│ Code generation encountered an error:
diff --git a/shared/src/test/diff/gadt/Exp2.mls b/shared/src/test/diff/gadt/Exp2.mls
index c8f3abc408..79ea376a6b 100644
--- a/shared/src/test/diff/gadt/Exp2.mls
+++ b/shared/src/test/diff/gadt/Exp2.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 
diff --git a/shared/src/test/diff/gadt/ThisMatching.mls b/shared/src/test/diff/gadt/ThisMatching.mls
index 0d58169a2c..7e7cd4d58a 100644
--- a/shared/src/test/diff/gadt/ThisMatching.mls
+++ b/shared/src/test/diff/gadt/ThisMatching.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 :e
@@ -28,9 +28,6 @@ Dummy.introspect
 
 
 abstract class Funny: Int { fun test = this + 1 }
-//│ ╔══[ERROR] Undefined type Int
-//│ ║  l.30: 	abstract class Funny: Int { fun test = this + 1 }
-//│ ╙──      	                      ^^^
 //│ abstract class Funny: Int {
 //│   fun test: Int
 //│ }
@@ -38,10 +35,10 @@ abstract class Funny: Int { fun test = this + 1 }
 :e
 class Unfunny { fun test = this + 1 }
 //│ ╔══[ERROR] Type mismatch in operator application:
-//│ ║  l.39: 	class Unfunny { fun test = this + 1 }
+//│ ║  l.36: 	class Unfunny { fun test = this + 1 }
 //│ ║        	                           ^^^^^^^^
 //│ ╟── reference of type `#Unfunny` is not an instance of type `Int`
-//│ ║  l.39: 	class Unfunny { fun test = this + 1 }
+//│ ║  l.36: 	class Unfunny { fun test = this + 1 }
 //│ ╙──      	                           ^^^^
 //│ class Unfunny {
 //│   constructor()
@@ -90,15 +87,15 @@ abstract class Exp: (() | Wrap) {
 }
 class Wrap(n: Exp) extends Exp
 //│ ╔══[ERROR] Unhandled cyclic definition
-//│ ║  l.86: 	abstract class Exp: (() | Wrap) {
+//│ ║  l.83: 	abstract class Exp: (() | Wrap) {
 //│ ║        	         ^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.87: 	  fun test = if this is
+//│ ║  l.84: 	  fun test = if this is
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.88: 	    Wrap(a) then 0
+//│ ║  l.85: 	    Wrap(a) then 0
 //│ ║        	^^^^^^^^^^^^^^^^^^
-//│ ║  l.89: 	    () then 1
+//│ ║  l.86: 	    () then 1
 //│ ║        	^^^^^^^^^^^^^
-//│ ║  l.90: 	}
+//│ ║  l.87: 	}
 //│ ╙──      	^
 //│ abstract class Exp: Wrap | () {
 //│   fun test: 0 | 1
@@ -116,17 +113,17 @@ abstract class Exp: (Pair | Lit) {
 class Lit(n: Int) extends Exp
 class Pair(lhs: Exp, rhs: Exp) extends Exp
 //│ ╔══[ERROR] Unhandled cyclic definition
-//│ ║  l.110: 	abstract class Exp: (Pair | Lit) {
+//│ ║  l.107: 	abstract class Exp: (Pair | Lit) {
 //│ ║         	         ^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.111: 	  fun test: Int
+//│ ║  l.108: 	  fun test: Int
 //│ ║         	^^^^^^^^^^^^^^^
-//│ ║  l.112: 	  fun test = if this is
+//│ ║  l.109: 	  fun test = if this is
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.113: 	    Lit then 0
+//│ ║  l.110: 	    Lit then 0
 //│ ║         	^^^^^^^^^^^^^^
-//│ ║  l.114: 	    Pair(l, r) then 1
+//│ ║  l.111: 	    Pair(l, r) then 1
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.115: 	}
+//│ ║  l.112: 	}
 //│ ╙──       	^
 //│ abstract class Exp: Lit | Pair {
 //│   fun test: Int
@@ -139,7 +136,7 @@ class Pair(lhs: Exp, rhs: Exp) extends Exp
 :e // TODO
 Pair(Lit(1), Lit(2)).test
 //│ ╔══[ERROR] Type `Pair` does not contain member `test`
-//│ ║  l.140: 	Pair(Lit(1), Lit(2)).test
+//│ ║  l.137: 	Pair(Lit(1), Lit(2)).test
 //│ ╙──       	                    ^^^^^
 //│ error
 //│ res
@@ -155,21 +152,21 @@ abstract class Exp: (Pair | Lit) {
 class Lit(n: Int) extends Exp
 class Pair(lhs: Exp, rhs: Exp) extends Exp
 //│ ╔══[ERROR] Unhandled cyclic definition
-//│ ║  l.150: 	abstract class Exp: (Pair | Lit) {
+//│ ║  l.147: 	abstract class Exp: (Pair | Lit) {
 //│ ║         	         ^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.151: 	  fun test = if this is
+//│ ║  l.148: 	  fun test = if this is
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.152: 	    Lit then 0
+//│ ║  l.149: 	    Lit then 0
 //│ ║         	^^^^^^^^^^^^^^
-//│ ║  l.153: 	    Pair(l, r) then l.test + r.test
+//│ ║  l.150: 	    Pair(l, r) then l.test + r.test
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.154: 	}
+//│ ║  l.151: 	}
 //│ ╙──       	^
 //│ ╔══[ERROR] Indirectly-recursive member should have type annotation
-//│ ║  l.153: 	    Pair(l, r) then l.test + r.test
+//│ ║  l.150: 	    Pair(l, r) then l.test + r.test
 //│ ╙──       	                     ^^^^^
 //│ ╔══[ERROR] Indirectly-recursive member should have type annotation
-//│ ║  l.153: 	    Pair(l, r) then l.test + r.test
+//│ ║  l.150: 	    Pair(l, r) then l.test + r.test
 //│ ╙──       	                              ^^^^^
 //│ abstract class Exp: Lit | Pair {
 //│   fun test: Int
@@ -190,17 +187,17 @@ abstract class Exp: (Pair | Lit) {
 class Lit(n: Int) extends Exp
 class Pair(lhs: Exp, rhs: Exp) extends Exp
 //│ ╔══[ERROR] Unhandled cyclic definition
-//│ ║  l.184: 	abstract class Exp: (Pair | Lit) {
+//│ ║  l.181: 	abstract class Exp: (Pair | Lit) {
 //│ ║         	         ^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.185: 	  fun test : Int
+//│ ║  l.182: 	  fun test : Int
 //│ ║         	^^^^^^^^^^^^^^^^
-//│ ║  l.186: 	  fun test = if this is
+//│ ║  l.183: 	  fun test = if this is
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.187: 	    Lit then 0
+//│ ║  l.184: 	    Lit then 0
 //│ ║         	^^^^^^^^^^^^^^
-//│ ║  l.188: 	    Pair(l, r) then l.test + r.test
+//│ ║  l.185: 	    Pair(l, r) then l.test + r.test
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.189: 	}
+//│ ║  l.186: 	}
 //│ ╙──       	^
 //│ abstract class Exp: Lit | Pair {
 //│   fun test: Int
@@ -220,25 +217,25 @@ abstract class Exp[A]: (Pair | Lit) {
 class Lit(n: Int) extends Exp[Int]
 class Pair[L, R](lhs: L, rhs: R) extends Exp[[L, R]]
 //│ ╔══[ERROR] Unhandled cyclic definition
-//│ ║  l.215: 	abstract class Exp[A]: (Pair | Lit) {
+//│ ║  l.212: 	abstract class Exp[A]: (Pair | Lit) {
 //│ ║         	         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.216: 	  fun test = if this is
+//│ ║  l.213: 	  fun test = if this is
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.217: 	    Lit then 0
+//│ ║  l.214: 	    Lit then 0
 //│ ║         	^^^^^^^^^^^^^^
-//│ ║  l.218: 	    Pair then 1
+//│ ║  l.215: 	    Pair then 1
 //│ ║         	^^^^^^^^^^^^^^^
-//│ ║  l.219: 	}
+//│ ║  l.216: 	}
 //│ ╙──       	^
 //│ ╔══[ERROR] Type error in `case` expression
-//│ ║  l.216: 	  fun test = if this is
+//│ ║  l.213: 	  fun test = if this is
 //│ ║         	                ^^^^^^^
-//│ ║  l.217: 	    Lit then 0
+//│ ║  l.214: 	    Lit then 0
 //│ ║         	^^^^^^^^^^^^^^
-//│ ║  l.218: 	    Pair then 1
+//│ ║  l.215: 	    Pair then 1
 //│ ║         	^^^^^^^^^^^^^^^
 //│ ╟── type variable `L` leaks out of its scope
-//│ ║  l.221: 	class Pair[L, R](lhs: L, rhs: R) extends Exp[[L, R]]
+//│ ║  l.218: 	class Pair[L, R](lhs: L, rhs: R) extends Exp[[L, R]]
 //│ ╙──       	           ^
 //│ abstract class Exp[A]: Lit | Pair[anything, anything] {
 //│   fun test: 0 | 1
diff --git a/shared/src/test/diff/nu/Andong.mls b/shared/src/test/diff/nu/Andong.mls
index fa997a5860..e2f1e77efc 100644
--- a/shared/src/test/diff/nu/Andong.mls
+++ b/shared/src/test/diff/nu/Andong.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class Union<Region>(a: Region, b: Region)
diff --git a/shared/src/test/diff/nu/ArrayProg.mls b/shared/src/test/diff/nu/ArrayProg.mls
index 57e8f50fd9..a0b7553fbe 100644
--- a/shared/src/test/diff/nu/ArrayProg.mls
+++ b/shared/src/test/diff/nu/ArrayProg.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 
diff --git a/shared/src/test/diff/nu/BadUCS.mls b/shared/src/test/diff/nu/BadUCS.mls
index c4fd3013e4..d5bd9333b0 100644
--- a/shared/src/test/diff/nu/BadUCS.mls
+++ b/shared/src/test/diff/nu/BadUCS.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class Foo
diff --git a/shared/src/test/diff/nu/BasicClassInheritance.mls b/shared/src/test/diff/nu/BasicClassInheritance.mls
index b365a2b0b0..29907d3302 100644
--- a/shared/src/test/diff/nu/BasicClassInheritance.mls
+++ b/shared/src/test/diff/nu/BasicClassInheritance.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class A
diff --git a/shared/src/test/diff/nu/BasicClasses.mls b/shared/src/test/diff/nu/BasicClasses.mls
index 0877423d9b..a24dc50fff 100644
--- a/shared/src/test/diff/nu/BasicClasses.mls
+++ b/shared/src/test/diff/nu/BasicClasses.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class A(val n: Int)
diff --git a/shared/src/test/diff/nu/CaseExpr.mls b/shared/src/test/diff/nu/CaseExpr.mls
index 0cb1b78ba6..cc358e0fea 100644
--- a/shared/src/test/diff/nu/CaseExpr.mls
+++ b/shared/src/test/diff/nu/CaseExpr.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 case 0 then true
@@ -66,9 +66,6 @@ fun map(f) = case
 //│ ╔══[ERROR] type identifier `as` not found
 //│ ║  l.65: 	  None as n then n
 //│ ╙──      	       ^^
-//│ ╔══[ERROR] identifier `as` not found
-//│ ║  l.65: 	  None as n then n
-//│ ╙──      	       ^^
 //│ ╔══[ERROR] type identifier not found: as
 //│ ║  l.65: 	  None as n then n
 //│ ╙──      	       ^^
@@ -80,10 +77,10 @@ fun map(f) = case
 :pe
 case 1
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'case'; found integer literal instead
-//│ ║  l.81: 	case 1
+//│ ║  l.78: 	case 1
 //│ ║        	     ^
 //│ ╟── Note: 'case' expression starts here:
-//│ ║  l.81: 	case 1
+//│ ║  l.78: 	case 1
 //│ ╙──      	^^^^
 //│ anything -> 1
 //│ res
@@ -92,13 +89,13 @@ case 1
 :pe
 case (1 then true)
 //│ ╔══[PARSE ERROR] Unexpected 'then' keyword here
-//│ ║  l.93: 	case (1 then true)
+//│ ║  l.90: 	case (1 then true)
 //│ ╙──      	        ^^^^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'case'; found integer literal instead
-//│ ║  l.93: 	case (1 then true)
+//│ ║  l.90: 	case (1 then true)
 //│ ║        	     ^^^^^^^^^^^^^
 //│ ╟── Note: 'case' expression starts here:
-//│ ║  l.93: 	case (1 then true)
+//│ ║  l.90: 	case (1 then true)
 //│ ╙──      	^^^^
 //│ anything -> 1
 //│ res
@@ -112,16 +109,16 @@ case else 0
 :pe
 case then 1 else 0
 //│ ╔══[PARSE ERROR] Unexpected 'then' keyword in expression position
-//│ ║  l.113: 	case then 1 else 0
+//│ ║  l.110: 	case then 1 else 0
 //│ ╙──       	     ^^^^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'case'; found integer literal instead
-//│ ║  l.113: 	case then 1 else 0
+//│ ║  l.110: 	case then 1 else 0
 //│ ║         	          ^
 //│ ╟── Note: 'case' expression starts here:
-//│ ║  l.113: 	case then 1 else 0
+//│ ║  l.110: 	case then 1 else 0
 //│ ╙──       	^^^^
 //│ ╔══[PARSE ERROR] Expected end of input; found 'else' keyword instead
-//│ ║  l.113: 	case then 1 else 0
+//│ ║  l.110: 	case then 1 else 0
 //│ ╙──       	            ^^^^
 //│ anything -> 1
 //│ res
@@ -135,19 +132,16 @@ case then 1 else 0
 :e
 case x, y then x + y
 //│ ╔══[PARSE ERROR] Expected an expression; found a 'then'/'else' clause instead
-//│ ║  l.136: 	case x, y then x + y
+//│ ║  l.133: 	case x, y then x + y
 //│ ╙──       	        ^^^^^^^^^^^^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'case'; found operator application instead
-//│ ║  l.136: 	case x, y then x + y
+//│ ║  l.133: 	case x, y then x + y
 //│ ║         	     ^^^^^^^^^^^^^^^
 //│ ╟── Note: 'case' expression starts here:
-//│ ║  l.136: 	case x, y then x + y
+//│ ║  l.133: 	case x, y then x + y
 //│ ╙──       	^^^^
-//│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.136: 	case x, y then x + y
-//│ ╙──       	     ^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.136: 	case x, y then x + y
+//│ ║  l.133: 	case x, y then x + y
 //│ ╙──       	     ^
 //│ anything -> ()
 //│ Code generation encountered an error:
@@ -156,15 +150,10 @@ case x, y then x + y
 :e
 case (x, y) then x + y
 //│ ╔══[ERROR] type identifier `,` not found
-//│ ║  l.157: 	case (x, y) then x + y
+//│ ║  l.151: 	case (x, y) then x + y
 //│ ╙──       	      ^^^^
-//│ ╔══[ERROR] identifier , refers to different symbols.
-//│ ║  l.157: 	case (x, y) then x + y
-//│ ║         	      ^^^^
-//│ ╟── it is resolved to `,`
-//│ ╙── it was previously resolved to local `,`
 //│ ╔══[ERROR] type identifier not found: ,
-//│ ║  l.157: 	case (x, y) then x + y
+//│ ║  l.151: 	case (x, y) then x + y
 //│ ╙──       	      ^^^^
 //│ nothing -> error
 //│ Code generation encountered an error:
diff --git a/shared/src/test/diff/nu/ClassSignatures.mls b/shared/src/test/diff/nu/ClassSignatures.mls
index f4fe3759b6..20c59c9429 100644
--- a/shared/src/test/diff/nu/ClassSignatures.mls
+++ b/shared/src/test/diff/nu/ClassSignatures.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 abstract class C0: C1 | C2
diff --git a/shared/src/test/diff/nu/ClassesInMixins.mls b/shared/src/test/diff/nu/ClassesInMixins.mls
index 17169caf1e..38201807a4 100644
--- a/shared/src/test/diff/nu/ClassesInMixins.mls
+++ b/shared/src/test/diff/nu/ClassesInMixins.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 
@@ -48,9 +48,6 @@ fun foo(x) = if x is M.Foo then 1
 
 :e
 mixin Test2 { let f = Foo(1) }
-//│ ╔══[ERROR] identifier `Foo` not found
-//│ ║  l.50: 	mixin Test2 { let f = Foo(1) }
-//│ ╙──      	                      ^^^
 //│ ╔══[ERROR] identifier not found: Foo
 //│ ║  l.50: 	mixin Test2 { let f = Foo(1) }
 //│ ╙──      	                      ^^^
@@ -63,10 +60,10 @@ mixin Test2 { let f = Foo(1) }
 :e
 mixin Test3 { fun f(x) = if x is Foo then 1 }
 //│ ╔══[ERROR] type identifier `Foo` not found
-//│ ║  l.64: 	mixin Test3 { fun f(x) = if x is Foo then 1 }
+//│ ║  l.61: 	mixin Test3 { fun f(x) = if x is Foo then 1 }
 //│ ╙──      	                                 ^^^
 //│ ╔══[ERROR] type identifier not found: Foo
-//│ ║  l.64: 	mixin Test3 { fun f(x) = if x is Foo then 1 }
+//│ ║  l.61: 	mixin Test3 { fun f(x) = if x is Foo then 1 }
 //│ ╙──      	                                 ^^^
 //│ mixin Test3() {
 //│   fun f: nothing -> error
@@ -87,10 +84,10 @@ mixin Test {
     Add(l, r) then this.size(l) + this.size(r)
 }
 //│ ╔══[ERROR] Type error in application
-//│ ║  l.84: 	    fun cached = size(this)
+//│ ║  l.81: 	    fun cached = size(this)
 //│ ║        	                 ^^^^^^^^^^
 //│ ╟── type variable `A` leaks out of its scope
-//│ ║  l.82: 	  class Add<A>(lhs: A, rhs: A) {
+//│ ║  l.79: 	  class Add<A>(lhs: A, rhs: A) {
 //│ ╙──      	            ^
 //│ mixin Test() {
 //│   this: {size: (??A | 'a) -> Int}
diff --git a/shared/src/test/diff/nu/CommaOperator.mls b/shared/src/test/diff/nu/CommaOperator.mls
index 4c13a82409..6d7e46db0b 100644
--- a/shared/src/test/diff/nu/CommaOperator.mls
+++ b/shared/src/test/diff/nu/CommaOperator.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 1; 2
@@ -208,9 +208,6 @@ foo(1), 2
 
 :ge // FIXME
 let rec x() = x() in x
-//│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.210: 	let rec x() = x() in x
-//│ ╙──       	              ^
 //│ nothing
 //│ Code generation encountered an error:
 //│   recursive non-function definition x is not supported
@@ -219,7 +216,7 @@ let rec x() = x() in x
 :pe
 let x[T] = 1 in x
 //│ ╔══[PARSE ERROR] Expected function parameter list; found square bracket section instead
-//│ ║  l.220: 	let x[T] = 1 in x
+//│ ║  l.217: 	let x[T] = 1 in x
 //│ ╙──       	     ^^^
 //│ 1
 //│ res
@@ -284,16 +281,16 @@ foo(
 :e
 foo(log(1);2)
 //│ ╔══[PARSE ERROR] Unexpected semicolon here
-//│ ║  l.285: 	foo(log(1);2)
+//│ ║  l.282: 	foo(log(1);2)
 //│ ╙──       	          ^
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.285: 	foo(log(1);2)
+//│ ║  l.282: 	foo(log(1);2)
 //│ ║         	^^^^^^^^^^^^^
 //│ ╟── argument of type `[?a]` does not match type `[?b, ?c]`
-//│ ║  l.285: 	foo(log(1);2)
+//│ ║  l.282: 	foo(log(1);2)
 //│ ║         	   ^^^^^^^^^^
 //│ ╟── Note: constraint arises from tuple literal:
-//│ ║  l.248: 	fun foo(x, y) = [x, y]
+//│ ║  l.245: 	fun foo(x, y) = [x, y]
 //│ ╙──       	       ^^^^^^
 //│ error | [nothing, nothing]
 //│ res
@@ -304,13 +301,13 @@ foo(log(1);2)
 :e
 foo((log(1),2))
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.305: 	foo((log(1),2))
+//│ ║  l.302: 	foo((log(1),2))
 //│ ║         	^^^^^^^^^^^^^^^
 //│ ╟── argument of type `[?a]` does not match type `[?b, ?c]`
-//│ ║  l.305: 	foo((log(1),2))
+//│ ║  l.302: 	foo((log(1),2))
 //│ ║         	   ^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from tuple literal:
-//│ ║  l.248: 	fun foo(x, y) = [x, y]
+//│ ║  l.245: 	fun foo(x, y) = [x, y]
 //│ ╙──       	       ^^^^^^
 //│ error | [nothing, nothing]
 //│ res
@@ -329,13 +326,13 @@ foo((let x = log(0), 1; log(x), x + 1), 2)
 :e
 foo(let x = log(0), 1; log(x), x + 1)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.330: 	foo(let x = log(0), 1; log(x), x + 1)
+//│ ║  l.327: 	foo(let x = log(0), 1; log(x), x + 1)
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── argument of type `[?a]` does not match type `[?b, ?c]`
-//│ ║  l.330: 	foo(let x = log(0), 1; log(x), x + 1)
+//│ ║  l.327: 	foo(let x = log(0), 1; log(x), x + 1)
 //│ ║         	   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from tuple literal:
-//│ ║  l.248: 	fun foo(x, y) = [x, y]
+//│ ║  l.245: 	fun foo(x, y) = [x, y]
 //│ ╙──       	       ^^^^^^
 //│ error | [nothing, nothing]
 //│ res
@@ -347,13 +344,13 @@ foo(let x = log(0), 1; log(x), x + 1)
 :e
 foo(let x = log(0), 1 in log(x), x + 1)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.348: 	foo(let x = log(0), 1 in log(x), x + 1)
+//│ ║  l.345: 	foo(let x = log(0), 1 in log(x), x + 1)
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── argument of type `[?a]` does not match type `[?b, ?c]`
-//│ ║  l.348: 	foo(let x = log(0), 1 in log(x), x + 1)
+//│ ║  l.345: 	foo(let x = log(0), 1 in log(x), x + 1)
 //│ ║         	   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from tuple literal:
-//│ ║  l.248: 	fun foo(x, y) = [x, y]
+//│ ║  l.245: 	fun foo(x, y) = [x, y]
 //│ ╙──       	       ^^^^^^
 //│ error | [nothing, nothing]
 //│ res
@@ -365,13 +362,13 @@ foo(let x = log(0), 1 in log(x), x + 1)
 :e
 foo(let x = log(0), 1; log(x), 1 + 1)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.366: 	foo(let x = log(0), 1; log(x), 1 + 1)
+//│ ║  l.363: 	foo(let x = log(0), 1; log(x), 1 + 1)
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── argument of type `[?a]` does not match type `[?b, ?c]`
-//│ ║  l.366: 	foo(let x = log(0), 1; log(x), 1 + 1)
+//│ ║  l.363: 	foo(let x = log(0), 1; log(x), 1 + 1)
 //│ ║         	   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from tuple literal:
-//│ ║  l.248: 	fun foo(x, y) = [x, y]
+//│ ║  l.245: 	fun foo(x, y) = [x, y]
 //│ ╙──       	       ^^^^^^
 //│ error | [nothing, nothing]
 //│ res
@@ -383,13 +380,13 @@ foo(let x = log(0), 1; log(x), 1 + 1)
 :e
 foo(if true then 1 else 2, 3)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.384: 	foo(if true then 1 else 2, 3)
+//│ ║  l.381: 	foo(if true then 1 else 2, 3)
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── argument of type `[1 | ?a]` does not match type `[?b, ?c]`
-//│ ║  l.384: 	foo(if true then 1 else 2, 3)
+//│ ║  l.381: 	foo(if true then 1 else 2, 3)
 //│ ║         	   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from tuple literal:
-//│ ║  l.248: 	fun foo(x, y) = [x, y]
+//│ ║  l.245: 	fun foo(x, y) = [x, y]
 //│ ╙──       	       ^^^^^^
 //│ error | [nothing, nothing]
 //│ res
@@ -403,13 +400,13 @@ foo((if true then 1 else 2), 3)
 :e
 foo(if true then log("ok"), 1 else log("nok"), 2, 3)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.404: 	foo(if true then log("ok"), 1 else log("nok"), 2, 3)
+//│ ║  l.401: 	foo(if true then log("ok"), 1 else log("nok"), 2, 3)
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── argument of type `[?a | ?b]` does not match type `[?c, ?d]`
-//│ ║  l.404: 	foo(if true then log("ok"), 1 else log("nok"), 2, 3)
+//│ ║  l.401: 	foo(if true then log("ok"), 1 else log("nok"), 2, 3)
 //│ ║         	   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from tuple literal:
-//│ ║  l.248: 	fun foo(x, y) = [x, y]
+//│ ║  l.245: 	fun foo(x, y) = [x, y]
 //│ ╙──       	       ^^^^^^
 //│ error | [nothing, nothing]
 //│ res
diff --git a/shared/src/test/diff/nu/CtorSubtraction.mls b/shared/src/test/diff/nu/CtorSubtraction.mls
index 06555d1ee4..9a58ce6842 100644
--- a/shared/src/test/diff/nu/CtorSubtraction.mls
+++ b/shared/src/test/diff/nu/CtorSubtraction.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class Cls
diff --git a/shared/src/test/diff/nu/Eval.mls b/shared/src/test/diff/nu/Eval.mls
index 1fdb1d6240..b187fd8334 100644
--- a/shared/src/test/diff/nu/Eval.mls
+++ b/shared/src/test/diff/nu/Eval.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 
diff --git a/shared/src/test/diff/nu/EvalNegNeg.mls b/shared/src/test/diff/nu/EvalNegNeg.mls
index 2b8f7d527c..4e3fbbaba2 100644
--- a/shared/src/test/diff/nu/EvalNegNeg.mls
+++ b/shared/src/test/diff/nu/EvalNegNeg.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class Add<out E>(lhs: E, rhs: E)
diff --git a/shared/src/test/diff/nu/ExpressionProblem_repro.mls b/shared/src/test/diff/nu/ExpressionProblem_repro.mls
index d6b883fee3..70a8a32ed0 100644
--- a/shared/src/test/diff/nu/ExpressionProblem_repro.mls
+++ b/shared/src/test/diff/nu/ExpressionProblem_repro.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 :NoJS
 
 
diff --git a/shared/src/test/diff/nu/ExpressionProblem_small.mls b/shared/src/test/diff/nu/ExpressionProblem_small.mls
index db03532e12..128c1eee71 100644
--- a/shared/src/test/diff/nu/ExpressionProblem_small.mls
+++ b/shared/src/test/diff/nu/ExpressionProblem_small.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 :NoJS
 
 
diff --git a/shared/src/test/diff/nu/FilterMap.mls b/shared/src/test/diff/nu/FilterMap.mls
index b926fc85a0..bd4274b329 100644
--- a/shared/src/test/diff/nu/FilterMap.mls
+++ b/shared/src/test/diff/nu/FilterMap.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 // * From https://arxiv.org/abs/2302.12783
diff --git a/shared/src/test/diff/nu/FlatIfThenElse.mls b/shared/src/test/diff/nu/FlatIfThenElse.mls
index 37e3a3daa6..752aa4eeae 100644
--- a/shared/src/test/diff/nu/FlatIfThenElse.mls
+++ b/shared/src/test/diff/nu/FlatIfThenElse.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 type Option[out A] = Some[A] | None
@@ -108,15 +108,6 @@ fun test(x: Option[Int]) =
 //│ ╔══[PARSE ERROR] Unexpected 'then' keyword in expression position
 //│ ║  l.105: 	  then
 //│ ╙──       	  ^^^^
-//│ ╔══[ERROR] identifier `value` not found
-//│ ║  l.107: 	    [value - 1, value + 1]
-//│ ╙──       	     ^^^^^
-//│ ╔══[ERROR] identifier `value` not found
-//│ ║  l.107: 	    [value - 1, value + 1]
-//│ ╙──       	                ^^^^^
-//│ ╔══[ERROR] identifier `value` not found
-//│ ║  l.106: 	    log(value)
-//│ ╙──       	        ^^^^^
 //│ ╔══[ERROR] Unexpected statement in an if block
 //│ ║  l.104: 	    Some(value)
 //│ ╙──       	    ^^^^^^^^^^^
diff --git a/shared/src/test/diff/nu/FlatMonads.mls b/shared/src/test/diff/nu/FlatMonads.mls
index 6345cc86f6..8ff1324bdb 100644
--- a/shared/src/test/diff/nu/FlatMonads.mls
+++ b/shared/src/test/diff/nu/FlatMonads.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 declare fun String: anything -> Str
@@ -120,11 +120,8 @@ printLine("").bind of () => error
 //│ res
 //│     = Bind {}
 
-:w
+
 printLine("").bind of (()) => error
-//│ ╔══[WARNING] literal patterns are ignored
-//│ ║  l.124: 	printLine("").bind of (()) => error
-//│ ╙──       	                       ^^
 //│ Bind[(), 'B]
 //│ res
 //│     = Bind {}
@@ -308,13 +305,13 @@ let r = loop(defaultCtx).run
 :e
 not(r)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.309: 	not(r)
+//│ ║  l.306: 	not(r)
 //│ ║         	^^^^^^
 //│ ╟── type `Int` is not an instance of type `Bool`
 //│ ║  l.34: 	module readInt extends IO[Int] { fun run: Int = 42 }
 //│ ║        	                          ^^^
 //│ ╟── but it flows into reference with expected type `Bool`
-//│ ║  l.309: 	not(r)
+//│ ║  l.306: 	not(r)
 //│ ╙──       	    ^
 //│ error | false | true
 //│ res
@@ -358,20 +355,16 @@ main
 //│     = Bind {}
 
 
-:w
 :e
 let r = printLine("").bind of 0 => Pure(1)
-//│ ╔══[WARNING] literal patterns are ignored
-//│ ║  l.363: 	let r = printLine("").bind of 0 => Pure(1)
-//│ ╙──       	                              ^
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.363: 	let r = printLine("").bind of 0 => Pure(1)
+//│ ║  l.359: 	let r = printLine("").bind of 0 => Pure(1)
 //│ ║         	        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── application of type `()` does not match type `0`
-//│ ║  l.327: 	class printLine(str: Str) extends IO { fun run = log(str) }
+//│ ║  l.324: 	class printLine(str: Str) extends IO { fun run = log(str) }
 //│ ║         	                                                 ^^^^^^^^
 //│ ╟── Note: constraint arises from integer literal:
-//│ ║  l.363: 	let r = printLine("").bind of 0 => Pure(1)
+//│ ║  l.359: 	let r = printLine("").bind of 0 => Pure(1)
 //│ ╙──       	                              ^
 //│ let r: Bind[in 0 & 'A out () | 'A, 'B] | error
 //│   where
@@ -384,20 +377,20 @@ let r = printLine("").bind of x =>
 log(x.a)
 Pure(1)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.383: 	let r = printLine("").bind of x =>
+//│ ║  l.376: 	let r = printLine("").bind of x =>
 //│ ║         	        ^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.384: 	log(x.a)
+//│ ║  l.377: 	log(x.a)
 //│ ║         	^^^^^^^^^
-//│ ║  l.385: 	Pure(1)
+//│ ║  l.378: 	Pure(1)
 //│ ║         	^^^^^^^
 //│ ╟── application of type `()` does not have field 'a'
-//│ ║  l.327: 	class printLine(str: Str) extends IO { fun run = log(str) }
+//│ ║  l.324: 	class printLine(str: Str) extends IO { fun run = log(str) }
 //│ ║         	                                                 ^^^^^^^^
 //│ ╟── Note: constraint arises from field selection:
-//│ ║  l.384: 	log(x.a)
+//│ ║  l.377: 	log(x.a)
 //│ ║         	    ^^^
 //│ ╟── from reference:
-//│ ║  l.384: 	log(x.a)
+//│ ║  l.377: 	log(x.a)
 //│ ╙──       	    ^
 //│ let r: Bind[in {a: anything} & 'A out () | 'A, 'B] | error
 //│   where
diff --git a/shared/src/test/diff/nu/FunnyIndet.mls b/shared/src/test/diff/nu/FunnyIndet.mls
index 7f83313926..0ad3e5aaae 100644
--- a/shared/src/test/diff/nu/FunnyIndet.mls
+++ b/shared/src/test/diff/nu/FunnyIndet.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 2 +
diff --git a/shared/src/test/diff/nu/GADTMono.mls b/shared/src/test/diff/nu/GADTMono.mls
index 1221d79b90..0d8323d5fb 100644
--- a/shared/src/test/diff/nu/GADTMono.mls
+++ b/shared/src/test/diff/nu/GADTMono.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 trait Expr[A]: LitInt | LitBool | Add | Cond | Pair | Fst | Snd
 class LitInt(n: Int) extends Expr[Int]
diff --git a/shared/src/test/diff/nu/GenericClasses.mls b/shared/src/test/diff/nu/GenericClasses.mls
index 64c1ef7f9e..8ce63d9db9 100644
--- a/shared/src/test/diff/nu/GenericClasses.mls
+++ b/shared/src/test/diff/nu/GenericClasses.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class C<A>
diff --git a/shared/src/test/diff/nu/GenericModules.mls b/shared/src/test/diff/nu/GenericModules.mls
index 75c5b56cea..778511bb83 100644
--- a/shared/src/test/diff/nu/GenericModules.mls
+++ b/shared/src/test/diff/nu/GenericModules.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 // * TODO generic module definitions need to be restricted so they do not include nay state
diff --git a/shared/src/test/diff/nu/HeungTung.mls b/shared/src/test/diff/nu/HeungTung.mls
index 04143b150f..3b0c9c2480 100644
--- a/shared/src/test/diff/nu/HeungTung.mls
+++ b/shared/src/test/diff/nu/HeungTung.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 
@@ -134,9 +134,6 @@ f(refined if true then 0 else false) // this one can be precise again!
 //│ ╔══[WARNING] Paren-less applications should use the 'of' keyword
 //│ ║  l.133: 	f(refined if true then 0 else false) // this one can be precise again!
 //│ ╙──       	  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╔══[ERROR] identifier `refined` not found
-//│ ║  l.133: 	f(refined if true then 0 else false) // this one can be precise again!
-//│ ╙──       	  ^^^^^^^
 //│ ╔══[ERROR] Illegal use of reserved operator: refined
 //│ ║  l.133: 	f(refined if true then 0 else false) // this one can be precise again!
 //│ ╙──       	  ^^^^^^^
@@ -199,7 +196,7 @@ type T = List[Int]
 :e // TODO application types
 type Res = M(T)
 //│ ╔══[ERROR] Wrong number of type arguments – expected 0, found 1
-//│ ║  l.200: 	type Res = M(T)
+//│ ║  l.197: 	type Res = M(T)
 //│ ╙──       	           ^^^^
 //│ type Res = M
 
@@ -222,7 +219,7 @@ fun f: Int -> Int
 fun f: Bool -> Bool
 fun f = id
 //│ ╔══[ERROR] A type signature for 'f' was already given
-//│ ║  l.222: 	fun f: Bool -> Bool
+//│ ║  l.219: 	fun f: Bool -> Bool
 //│ ╙──       	^^^^^^^^^^^^^^^^^^^
 //│ fun f: forall 'a. 'a -> 'a
 //│ fun f: Int -> Int
@@ -230,13 +227,13 @@ fun f = id
 :e // TODO support
 f: (Int -> Int) & (Bool -> Bool)
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.231: 	f: (Int -> Int) & (Bool -> Bool)
+//│ ║  l.228: 	f: (Int -> Int) & (Bool -> Bool)
 //│ ║         	^
 //│ ╟── type `Bool` is not an instance of type `Int`
-//│ ║  l.231: 	f: (Int -> Int) & (Bool -> Bool)
+//│ ║  l.228: 	f: (Int -> Int) & (Bool -> Bool)
 //│ ║         	                   ^^^^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.221: 	fun f: Int -> Int
+//│ ║  l.218: 	fun f: Int -> Int
 //│ ╙──       	       ^^^
 //│ Int -> Int & Bool -> Bool
 //│ res
@@ -303,20 +300,17 @@ fun test(x) = refined if x is
   A then 0
   B then 1
 //│ ╔══[WARNING] Paren-less applications should use the 'of' keyword
-//│ ║  l.302: 	fun test(x) = refined if x is
+//│ ║  l.299: 	fun test(x) = refined if x is
 //│ ║         	              ^^^^^^^^^^^^^^^
-//│ ║  l.303: 	  A then 0
+//│ ║  l.300: 	  A then 0
 //│ ║         	^^^^^^^^^^
-//│ ║  l.304: 	  B then 1
+//│ ║  l.301: 	  B then 1
 //│ ╙──       	^^^^^^^^^^
-//│ ╔══[ERROR] identifier `refined` not found
-//│ ║  l.302: 	fun test(x) = refined if x is
-//│ ╙──       	              ^^^^^^^
 //│ ╔══[ERROR] Illegal use of reserved operator: refined
-//│ ║  l.302: 	fun test(x) = refined if x is
+//│ ║  l.299: 	fun test(x) = refined if x is
 //│ ╙──       	              ^^^^^^^
 //│ ╔══[ERROR] identifier not found: refined
-//│ ║  l.302: 	fun test(x) = refined if x is
+//│ ║  l.299: 	fun test(x) = refined if x is
 //│ ╙──       	              ^^^^^^^
 //│ fun test: (A | B) -> error
 //│ Code generation encountered an error:
diff --git a/shared/src/test/diff/nu/Huawei1.mls b/shared/src/test/diff/nu/Huawei1.mls
index 4ca49f190b..7b939fe6a1 100644
--- a/shared/src/test/diff/nu/Huawei1.mls
+++ b/shared/src/test/diff/nu/Huawei1.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class C[out A](x: A) {
diff --git a/shared/src/test/diff/nu/InterfaceMono.mls b/shared/src/test/diff/nu/InterfaceMono.mls
index f5088e03b5..c19e5930c4 100644
--- a/shared/src/test/diff/nu/InterfaceMono.mls
+++ b/shared/src/test/diff/nu/InterfaceMono.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 trait Showable {
@@ -10,9 +10,6 @@ trait Showable {
 
 :e
 trait What0 extends woooo
-//│ ╔══[ERROR] could not find definition `woooo`
-//│ ║  l.12: 	trait What0 extends woooo
-//│ ╙──      	                    ^^^^^
 //│ ╔══[ERROR] Could not find definition `woooo`
 //│ ║  l.12: 	trait What0 extends woooo
 //│ ╙──      	                    ^^^^^
@@ -33,7 +30,7 @@ class What1(toString: Str) extends Showable
 :e
 trait NoShow extends What1("hi")
 //│ ╔══[ERROR] A trait can only inherit from other traits
-//│ ║  l.34: 	trait NoShow extends What1("hi")
+//│ ║  l.31: 	trait NoShow extends What1("hi")
 //│ ╙──      	                     ^^^^^^^^^^^
 //│ trait NoShow extends Showable, What1
 
@@ -44,19 +41,19 @@ class ErrC2 extends Showable {
 }
 class ErrC3(toString: Str -> Str) extends Showable
 //│ ╔══[ERROR] Member `toString` is declared (or its declaration is inherited) but is not implemented in `ErrC1`
-//│ ║  l.41: 	class ErrC1 extends Showable
+//│ ║  l.38: 	class ErrC1 extends Showable
 //│ ║        	      ^^^^^
 //│ ╟── Declared here:
 //│ ║  l.5: 	    fun toString: Str
 //│ ╙──     	    ^^^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in definition of method toString:
-//│ ║  l.43: 	    fun toString = 114
+//│ ║  l.40: 	    fun toString = 114
 //│ ║        	        ^^^^^^^^^^^^^^
 //│ ╟── integer literal of type `114` is not an instance of type `Str`
-//│ ║  l.43: 	    fun toString = 114
+//│ ║  l.40: 	    fun toString = 114
 //│ ║        	                   ^^^
 //│ ╟── but it flows into definition of method toString with expected type `Str`
-//│ ║  l.43: 	    fun toString = 114
+//│ ║  l.40: 	    fun toString = 114
 //│ ║        	        ^^^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from type reference:
 //│ ║  l.5: 	    fun toString: Str
@@ -65,7 +62,7 @@ class ErrC3(toString: Str -> Str) extends Showable
 //│ ║  l.5: 	    fun toString: Str
 //│ ╙──     	        ^^^^^^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in function type:
-//│ ║  l.45: 	class ErrC3(toString: Str -> Str) extends Showable
+//│ ║  l.42: 	class ErrC3(toString: Str -> Str) extends Showable
 //│ ║        	                      ^^^^^^^^^^
 //│ ╟── type `Str -> Str` is not an instance of type `Str`
 //│ ╟── Note: constraint arises from type reference:
@@ -128,41 +125,41 @@ class Errcity(size: Int) extends SizedStadt {
     fun bar = "hahaha"
 }
 //│ ╔══[ERROR] Type mismatch in definition of method bar:
-//│ ║  l.128: 	    fun bar = "hahaha"
+//│ ║  l.125: 	    fun bar = "hahaha"
 //│ ║         	        ^^^^^^^^^^^^^^
 //│ ╟── string literal of type `"hahaha"` is not a function
-//│ ║  l.128: 	    fun bar = "hahaha"
+//│ ║  l.125: 	    fun bar = "hahaha"
 //│ ║         	              ^^^^^^^^
 //│ ╟── but it flows into definition of method bar with expected type `Int -> Int`
-//│ ║  l.128: 	    fun bar = "hahaha"
+//│ ║  l.125: 	    fun bar = "hahaha"
 //│ ║         	        ^^^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from function type:
-//│ ║  l.106: 	    fun bar: Int -> Int
+//│ ║  l.103: 	    fun bar: Int -> Int
 //│ ║         	             ^^^^^^^^^^
 //│ ╟── from signature of member `bar`:
-//│ ║  l.106: 	    fun bar: Int -> Int
+//│ ║  l.103: 	    fun bar: Int -> Int
 //│ ╙──       	        ^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.127: 	class Errcity(size: Int) extends SizedStadt {
+//│ ║  l.124: 	class Errcity(size: Int) extends SizedStadt {
 //│ ║         	                    ^^^
 //│ ╟── type `Int` does not match type `1 | 2 | 3`
 //│ ╟── Note: constraint arises from union type:
-//│ ║  l.105: 	    let size: 1 | 2 | 3
+//│ ║  l.102: 	    let size: 1 | 2 | 3
 //│ ║         	              ^^^^^^^^^
 //│ ╟── from signature of member `size`:
-//│ ║  l.105: 	    let size: 1 | 2 | 3
+//│ ║  l.102: 	    let size: 1 | 2 | 3
 //│ ╙──       	        ^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] Member `name` is declared (or its declaration is inherited) but is not implemented in `Errcity`
-//│ ║  l.127: 	class Errcity(size: Int) extends SizedStadt {
+//│ ║  l.124: 	class Errcity(size: Int) extends SizedStadt {
 //│ ║         	      ^^^^^^^
 //│ ╟── Declared here:
-//│ ║  l.88: 	    let name: Str
+//│ ║  l.85: 	    let name: Str
 //│ ╙──      	    ^^^^^^^^^^^^^
 //│ ╔══[ERROR] Member `foo` is declared (or its declaration is inherited) but is not implemented in `Errcity`
-//│ ║  l.127: 	class Errcity(size: Int) extends SizedStadt {
+//│ ║  l.124: 	class Errcity(size: Int) extends SizedStadt {
 //│ ║         	      ^^^^^^^
 //│ ╟── Declared here:
-//│ ║  l.96: 	    fun foo: Bool -> Int
+//│ ║  l.93: 	    fun foo: Bool -> Int
 //│ ╙──      	    ^^^^^^^^^^^^^^^^^^^^
 //│ class Errcity(size: Int) extends RefinedStadt, SizedStadt, Stadt {
 //│   fun bar: "hahaha"
@@ -211,19 +208,19 @@ class Dirtberg extends More, SizedStadt, Fooo {
     fun size = 4    // this should not check
 }
 //│ ╔══[ERROR] Type mismatch in definition of method size:
-//│ ║  l.211: 	    fun size = 4    // this should not check
+//│ ║  l.208: 	    fun size = 4    // this should not check
 //│ ║         	        ^^^^^^^^
 //│ ╟── integer literal of type `4` does not match type `1 | 2 | 3`
-//│ ║  l.211: 	    fun size = 4    // this should not check
+//│ ║  l.208: 	    fun size = 4    // this should not check
 //│ ║         	               ^
 //│ ╟── but it flows into definition of method size with expected type `1 | 2 | 3`
-//│ ║  l.211: 	    fun size = 4    // this should not check
+//│ ║  l.208: 	    fun size = 4    // this should not check
 //│ ║         	        ^^^^^^^^
 //│ ╟── Note: constraint arises from union type:
-//│ ║  l.105: 	    let size: 1 | 2 | 3
+//│ ║  l.102: 	    let size: 1 | 2 | 3
 //│ ║         	              ^^^^^^^^^
 //│ ╟── from signature of member `size`:
-//│ ║  l.105: 	    let size: 1 | 2 | 3
+//│ ║  l.102: 	    let size: 1 | 2 | 3
 //│ ╙──       	        ^^^^^^^^^^^^^^^
 //│ class Dirtberg extends RefinedStadt, SizedStadt, Stadt {
 //│   constructor()
@@ -251,19 +248,19 @@ class A { virtual fun x: Int = 1 }
 :e
 class B extends A { fun x = "A" }
 //│ ╔══[ERROR] Type mismatch in definition of method x:
-//│ ║  l.252: 	class B extends A { fun x = "A" }
+//│ ║  l.249: 	class B extends A { fun x = "A" }
 //│ ║         	                        ^^^^^^^
 //│ ╟── string literal of type `"A"` is not an instance of type `Int`
-//│ ║  l.252: 	class B extends A { fun x = "A" }
+//│ ║  l.249: 	class B extends A { fun x = "A" }
 //│ ║         	                            ^^^
 //│ ╟── but it flows into definition of method x with expected type `Int`
-//│ ║  l.252: 	class B extends A { fun x = "A" }
+//│ ║  l.249: 	class B extends A { fun x = "A" }
 //│ ║         	                        ^^^^^^^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.245: 	class A { virtual fun x: Int = 1 }
+//│ ║  l.242: 	class A { virtual fun x: Int = 1 }
 //│ ║         	                         ^^^
 //│ ╟── from definition of method x:
-//│ ║  l.245: 	class A { virtual fun x: Int = 1 }
+//│ ║  l.242: 	class A { virtual fun x: Int = 1 }
 //│ ╙──       	                      ^^^^^^^^^^
 //│ class B extends A {
 //│   constructor()
@@ -273,7 +270,7 @@ class B extends A { fun x = "A" }
 :e
 class C1[A] { virtual fun a: A = this.a }
 //│ ╔══[ERROR] Indirectly-recursive member should have type annotation
-//│ ║  l.274: 	class C1[A] { virtual fun a: A = this.a }
+//│ ║  l.271: 	class C1[A] { virtual fun a: A = this.a }
 //│ ╙──       	                                     ^^
 //│ class C1[A] {
 //│   constructor()
@@ -307,19 +304,19 @@ class C extends MyTrait[Int] { fun a = 1 }
 :e
 class C extends MyTrait[Int] { fun a = false }
 //│ ╔══[ERROR] Type mismatch in definition of method a:
-//│ ║  l.308: 	class C extends MyTrait[Int] { fun a = false }
+//│ ║  l.305: 	class C extends MyTrait[Int] { fun a = false }
 //│ ║         	                                   ^^^^^^^^^
 //│ ╟── reference of type `false` is not an instance of `Int`
-//│ ║  l.308: 	class C extends MyTrait[Int] { fun a = false }
+//│ ║  l.305: 	class C extends MyTrait[Int] { fun a = false }
 //│ ║         	                                       ^^^^^
 //│ ╟── but it flows into definition of method a with expected type `Int`
-//│ ║  l.308: 	class C extends MyTrait[Int] { fun a = false }
+//│ ║  l.305: 	class C extends MyTrait[Int] { fun a = false }
 //│ ║         	                                   ^^^^^^^^^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.308: 	class C extends MyTrait[Int] { fun a = false }
+//│ ║  l.305: 	class C extends MyTrait[Int] { fun a = false }
 //│ ║         	                        ^^^
 //│ ╟── from signature of member `a`:
-//│ ║  l.293: 	trait MyTrait[A] { fun a: A }
+//│ ║  l.290: 	trait MyTrait[A] { fun a: A }
 //│ ╙──       	                       ^^^^
 //│ class C extends MyTrait {
 //│   constructor()
@@ -361,19 +358,19 @@ class C3 extends T4{
     fun bar = false
 }
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.360: 	    fun foo = 3
+//│ ║  l.357: 	    fun foo = 3
 //│ ║         	        ^^^^^^^
 //│ ╟── integer literal of type `3` does not match type `2`
-//│ ║  l.360: 	    fun foo = 3
+//│ ║  l.357: 	    fun foo = 3
 //│ ║         	              ^
 //│ ╟── but it flows into definition of method foo with expected type `2`
-//│ ║  l.360: 	    fun foo = 3
+//│ ║  l.357: 	    fun foo = 3
 //│ ║         	        ^^^^^^^
 //│ ╟── Note: constraint arises from literal type:
-//│ ║  l.348: 	    fun foo: 2
+//│ ║  l.345: 	    fun foo: 2
 //│ ║         	             ^
 //│ ╟── from signature of member `foo`:
-//│ ║  l.348: 	    fun foo: 2
+//│ ║  l.345: 	    fun foo: 2
 //│ ╙──       	        ^^^^^^
 //│ class C3 extends T1, T2, T4 {
 //│   constructor()
@@ -384,24 +381,24 @@ class C3 extends T4{
 :e
 class C2(foo: Int, bar: Str) extends T4
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.385: 	class C2(foo: Int, bar: Str) extends T4
+//│ ║  l.382: 	class C2(foo: Int, bar: Str) extends T4
 //│ ║         	              ^^^
 //│ ╟── type `Int` does not match type `2`
 //│ ╟── Note: constraint arises from literal type:
-//│ ║  l.348: 	    fun foo: 2
+//│ ║  l.345: 	    fun foo: 2
 //│ ║         	             ^
 //│ ╟── from signature of member `foo`:
-//│ ║  l.348: 	    fun foo: 2
+//│ ║  l.345: 	    fun foo: 2
 //│ ╙──       	        ^^^^^^
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.385: 	class C2(foo: Int, bar: Str) extends T4
+//│ ║  l.382: 	class C2(foo: Int, bar: Str) extends T4
 //│ ║         	                        ^^^
 //│ ╟── type `Str` does not match type `Int | false | true`
 //│ ╟── Note: constraint arises from union type:
-//│ ║  l.336: 	    let bar : Int | Bool
+//│ ║  l.333: 	    let bar : Int | Bool
 //│ ║         	              ^^^^^^^^^^
 //│ ╟── from signature of member `bar`:
-//│ ║  l.336: 	    let bar : Int | Bool
+//│ ║  l.333: 	    let bar : Int | Bool
 //│ ╙──       	        ^^^^^^^^^^^^^^^^
 //│ class C2(foo: Int, bar: Str) extends T1, T2, T4
 
@@ -410,19 +407,19 @@ trait T5 extends T4 {
     let foo: 4
 }
 //│ ╔══[ERROR] Type mismatch in signature of member `foo`:
-//│ ║  l.410: 	    let foo: 4
+//│ ║  l.407: 	    let foo: 4
 //│ ║         	        ^^^^^^
 //│ ╟── type `4` does not match type `2`
-//│ ║  l.410: 	    let foo: 4
+//│ ║  l.407: 	    let foo: 4
 //│ ║         	             ^
 //│ ╟── but it flows into signature of member `foo` with expected type `2`
-//│ ║  l.410: 	    let foo: 4
+//│ ║  l.407: 	    let foo: 4
 //│ ║         	        ^^^^^^
 //│ ╟── Note: constraint arises from literal type:
-//│ ║  l.348: 	    fun foo: 2
+//│ ║  l.345: 	    fun foo: 2
 //│ ║         	             ^
 //│ ╟── from signature of member `foo`:
-//│ ║  l.348: 	    fun foo: 2
+//│ ║  l.345: 	    fun foo: 2
 //│ ╙──       	        ^^^^^^
 //│ trait T5 extends T1, T2, T4 {
 //│   fun bar: Bool
@@ -434,34 +431,34 @@ trait T3 extends T1, T2 {
     let foo: true
 }
 //│ ╔══[ERROR] Type mismatch in signature of member `foo`:
-//│ ║  l.434: 	    let foo: true
+//│ ║  l.431: 	    let foo: true
 //│ ║         	        ^^^^^^^^^
 //│ ╟── type `true` does not match type `1 | 2 | 3`
-//│ ║  l.434: 	    let foo: true
+//│ ║  l.431: 	    let foo: true
 //│ ║         	             ^^^^
 //│ ╟── but it flows into signature of member `foo` with expected type `1 | 2 | 3`
-//│ ║  l.434: 	    let foo: true
+//│ ║  l.431: 	    let foo: true
 //│ ║         	        ^^^^^^^^^
 //│ ╟── Note: constraint arises from union type:
-//│ ║  l.331: 	    let foo : 1 | 2 | 3 
+//│ ║  l.328: 	    let foo : 1 | 2 | 3 
 //│ ║         	              ^^^^^^^^^
 //│ ╟── from signature of member `foo`:
-//│ ║  l.331: 	    let foo : 1 | 2 | 3 
+//│ ║  l.328: 	    let foo : 1 | 2 | 3 
 //│ ╙──       	        ^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in signature of member `foo`:
-//│ ║  l.434: 	    let foo: true
+//│ ║  l.431: 	    let foo: true
 //│ ║         	        ^^^^^^^^^
 //│ ╟── type `true` does not match type `2 | 3 | 4`
-//│ ║  l.434: 	    let foo: true
+//│ ║  l.431: 	    let foo: true
 //│ ║         	             ^^^^
 //│ ╟── but it flows into signature of member `foo` with expected type `2 | 3 | 4`
-//│ ║  l.434: 	    let foo: true
+//│ ║  l.431: 	    let foo: true
 //│ ║         	        ^^^^^^^^^
 //│ ╟── Note: constraint arises from union type:
-//│ ║  l.335: 	    let foo : 2 | 3 | 4
+//│ ║  l.332: 	    let foo : 2 | 3 | 4
 //│ ║         	              ^^^^^^^^^
 //│ ╟── from signature of member `foo`:
-//│ ║  l.335: 	    let foo : 2 | 3 | 4
+//│ ║  l.332: 	    let foo : 2 | 3 | 4
 //│ ╙──       	        ^^^^^^^^^^^^^^^
 //│ trait T3 extends T1, T2 {
 //│   fun bar: Bool
diff --git a/shared/src/test/diff/nu/Interfaces.mls b/shared/src/test/diff/nu/Interfaces.mls
index 11ef7fd1c4..fe76a104b7 100644
--- a/shared/src/test/diff/nu/Interfaces.mls
+++ b/shared/src/test/diff/nu/Interfaces.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 trait Test {
@@ -531,9 +531,6 @@ if b is
 
 :e
 let tt1 = Test
-//│ ╔══[ERROR] identifier `Test` is resolved to a type
-//│ ║  l.533: 	let tt1 = Test
-//│ ╙──       	          ^^^^
 //│ ╔══[ERROR] trait Test cannot be used in term position
 //│ ║  l.533: 	let tt1 = Test
 //│ ╙──       	          ^^^^
@@ -606,40 +603,40 @@ z: WP
 g: ZL
 e: ZL & WP
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.604: 	fun fto(w: WP): EM = w
+//│ ║  l.601: 	fun fto(w: WP): EM = w
 //│ ║         	                     ^
 //│ ╟── type `#WP` is not an instance of type `EM`
-//│ ║  l.604: 	fun fto(w: WP): EM = w
+//│ ║  l.601: 	fun fto(w: WP): EM = w
 //│ ║         	           ^^
 //│ ╟── but it flows into reference with expected type `#EM`
-//│ ║  l.604: 	fun fto(w: WP): EM = w
+//│ ║  l.601: 	fun fto(w: WP): EM = w
 //│ ║         	                     ^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.604: 	fun fto(w: WP): EM = w
+//│ ║  l.601: 	fun fto(w: WP): EM = w
 //│ ╙──       	                ^^
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.605: 	z: WP
+//│ ║  l.602: 	z: WP
 //│ ║         	^
 //│ ╟── type `#ZL` is not an instance of type `WP`
-//│ ║  l.561: 	let z: ZL
+//│ ║  l.558: 	let z: ZL
 //│ ║         	       ^^
 //│ ╟── but it flows into reference with expected type `#WP`
-//│ ║  l.605: 	z: WP
+//│ ║  l.602: 	z: WP
 //│ ║         	^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.605: 	z: WP
+//│ ║  l.602: 	z: WP
 //│ ╙──       	   ^^
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.606: 	g: ZL
+//│ ║  l.603: 	g: ZL
 //│ ║         	^
 //│ ╟── type `#Geo` is not an instance of type `ZL`
-//│ ║  l.560: 	let g: Geo
+//│ ║  l.557: 	let g: Geo
 //│ ║         	       ^^^
 //│ ╟── but it flows into reference with expected type `#ZL`
-//│ ║  l.606: 	g: ZL
+//│ ║  l.603: 	g: ZL
 //│ ║         	^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.606: 	g: ZL
+//│ ║  l.603: 	g: ZL
 //│ ╙──       	   ^^
 //│ fun fto: (w: WP) -> EM
 //│ WP & ZL
@@ -695,36 +692,36 @@ class Eh2 extends Bs(true), Ele {
     fun ce(x) = x
 }
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.694: 	    fun foo(x) = x && false
+//│ ║  l.691: 	    fun foo(x) = x && false
 //│ ║         	        ^^^^^^^^^^^^^^^^^^^
 //│ ╟── expression of type `Int & ?a` is not an instance of type `Bool`
 //│ ╟── Note: constraint arises from reference:
-//│ ║  l.694: 	    fun foo(x) = x && false
+//│ ║  l.691: 	    fun foo(x) = x && false
 //│ ╙──       	                 ^
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.694: 	    fun foo(x) = x && false
+//│ ║  l.691: 	    fun foo(x) = x && false
 //│ ║         	        ^^^^^^^^^^^^^^^^^^^
 //│ ╟── expression of type `Int & ?a` does not match type `Bool`
 //│ ╟── Note: constraint arises from reference:
-//│ ║  l.694: 	    fun foo(x) = x && false
+//│ ║  l.691: 	    fun foo(x) = x && false
 //│ ╙──       	                 ^
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.694: 	    fun foo(x) = x && false
+//│ ║  l.691: 	    fun foo(x) = x && false
 //│ ║         	        ^^^^^^^^^^^^^^^^^^^
 //│ ╟── operator application of type `Bool` does not match type `Int | ?a`
-//│ ║  l.694: 	    fun foo(x) = x && false
+//│ ║  l.691: 	    fun foo(x) = x && false
 //│ ║         	                 ^^^^^^^^^^
 //│ ╟── Note: constraint arises from operator application:
-//│ ║  l.657: 	  virtual fun foo(x) = x + 1
+//│ ║  l.654: 	  virtual fun foo(x) = x + 1
 //│ ╙──       	                       ^^^^^
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.694: 	    fun foo(x) = x && false
+//│ ║  l.691: 	    fun foo(x) = x && false
 //│ ║         	        ^^^^^^^^^^^^^^^^^^^
 //│ ╟── operator application of type `Bool` does not match type `Int | ?a`
-//│ ║  l.694: 	    fun foo(x) = x && false
+//│ ║  l.691: 	    fun foo(x) = x && false
 //│ ║         	                 ^^^^^^^^^^
 //│ ╟── Note: constraint arises from operator application:
-//│ ║  l.657: 	  virtual fun foo(x) = x + 1
+//│ ║  l.654: 	  virtual fun foo(x) = x + 1
 //│ ╙──       	                       ^^^^^
 //│ class Eh2 extends Bs, Ele {
 //│   constructor()
@@ -737,34 +734,34 @@ class Eh extends Bs(1)
 class Eh1 extends Bs
 class Eh3 extends Bs(false), Test
 //│ ╔══[ERROR] Type mismatch in type declaration:
-//│ ║  l.736: 	class Eh extends Bs(1)
+//│ ║  l.733: 	class Eh extends Bs(1)
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── integer literal of type `1` is not an instance of type `Bool`
-//│ ║  l.736: 	class Eh extends Bs(1)
+//│ ║  l.733: 	class Eh extends Bs(1)
 //│ ║         	                    ^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.656: 	class Bs(val a: Bool) {
+//│ ║  l.653: 	class Bs(val a: Bool) {
 //│ ╙──       	                ^^^^
 //│ ╔══[ERROR] Type mismatch in type declaration:
-//│ ║  l.736: 	class Eh extends Bs(1)
+//│ ║  l.733: 	class Eh extends Bs(1)
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── integer literal of type `1` does not match type `Bool`
-//│ ║  l.736: 	class Eh extends Bs(1)
+//│ ║  l.733: 	class Eh extends Bs(1)
 //│ ║         	                    ^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.656: 	class Bs(val a: Bool) {
+//│ ║  l.653: 	class Bs(val a: Bool) {
 //│ ╙──       	                ^^^^
 //│ ╔══[ERROR] class Bs expects 1 parameter(s); got 0
-//│ ║  l.737: 	class Eh1 extends Bs
+//│ ║  l.734: 	class Eh1 extends Bs
 //│ ╙──       	                  ^^
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.657: 	  virtual fun foo(x) = x + 1
+//│ ║  l.654: 	  virtual fun foo(x) = x + 1
 //│ ║         	              ^^^^^^^^^^^^^^
 //│ ╟── function of type `?a -> (forall ?b. ?b)` is not an instance of type `Int`
-//│ ║  l.657: 	  virtual fun foo(x) = x + 1
+//│ ║  l.654: 	  virtual fun foo(x) = x + 1
 //│ ║         	                 ^^^^^^^^^^^
 //│ ╟── but it flows into definition of method foo with expected type `Int`
-//│ ║  l.657: 	  virtual fun foo(x) = x + 1
+//│ ║  l.654: 	  virtual fun foo(x) = x + 1
 //│ ║         	              ^^^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from type reference:
 //│ ║  l.5: 	  fun foo: Int
@@ -773,7 +770,7 @@ class Eh3 extends Bs(false), Test
 //│ ║  l.5: 	  fun foo: Int
 //│ ╙──     	      ^^^^^^^^
 //│ ╔══[ERROR] Member `bar` is declared (or its declaration is inherited) but is not implemented in `Eh3`
-//│ ║  l.738: 	class Eh3 extends Bs(false), Test
+//│ ║  l.735: 	class Eh3 extends Bs(false), Test
 //│ ║         	      ^^^
 //│ ╟── Declared here:
 //│ ║  l.6: 	  fun bar: Bool -> Bool
@@ -851,7 +848,7 @@ abstract class Bc3 {
 :e
 class Bc12() extends Bc1(1), Bc2(true)
 //│ ╔══[ERROR] Cannot inherit from more than one base class: Bc1 and Bc2
-//│ ║  l.852: 	class Bc12() extends Bc1(1), Bc2(true)
+//│ ║  l.849: 	class Bc12() extends Bc1(1), Bc2(true)
 //│ ╙──       	                             ^^^^^^^^^
 //│ class Bc12() extends Bc1, Bc2
 //│ Code generation encountered an error:
@@ -872,24 +869,24 @@ Bc02().foo
 :e
 class Bc31(baz: Bool) extends Bc3
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.873: 	class Bc31(baz: Bool) extends Bc3
+//│ ║  l.870: 	class Bc31(baz: Bool) extends Bc3
 //│ ║         	                ^^^^
 //│ ╟── type `Bool` is not an instance of type `Int`
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.843: 	  let baz : Int
+//│ ║  l.840: 	  let baz : Int
 //│ ║         	            ^^^
 //│ ╟── from signature of member `baz`:
-//│ ║  l.843: 	  let baz : Int
+//│ ║  l.840: 	  let baz : Int
 //│ ╙──       	      ^^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.873: 	class Bc31(baz: Bool) extends Bc3
+//│ ║  l.870: 	class Bc31(baz: Bool) extends Bc3
 //│ ║         	                ^^^^
 //│ ╟── type `Bool` is not an instance of type `Int`
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.843: 	  let baz : Int
+//│ ║  l.840: 	  let baz : Int
 //│ ║         	            ^^^
 //│ ╟── from signature of member `baz`:
-//│ ║  l.843: 	  let baz : Int
+//│ ║  l.840: 	  let baz : Int
 //│ ╙──       	      ^^^^^^^^^
 //│ class Bc31(baz: Bool) extends Bc3
 
@@ -924,7 +921,7 @@ trait BInt extends Base[Int] {
   fun f = error
 }
 //│ ╔══[ERROR] Method implementations in traits are not yet supported
-//│ ║  l.924: 	  fun f = error
+//│ ║  l.921: 	  fun f = error
 //│ ╙──       	  ^^^^^^^^^^^^^
 //│ trait BInt extends Base {
 //│   fun f: nothing
@@ -955,7 +952,7 @@ bp: Base[[Int, Bool]]
 :e
 bp: Base[[Int, Int]]
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.956: 	bp: Base[[Int, Int]]
+//│ ║  l.953: 	bp: Base[[Int, Int]]
 //│ ║         	^^
 //│ ╙── expression of type `true` is not an instance of type `Int`
 //│ Base[[Int, Int]]
@@ -1016,13 +1013,13 @@ trait BInfer2 extends Base {
 :e
 class DerBad1 extends Base[Int, Int]
 //│ ╔══[ERROR] trait Base expects 1 type parameter(s); got 2
-//│ ║  l.1017: 	class DerBad1 extends Base[Int, Int]
+//│ ║  l.1014: 	class DerBad1 extends Base[Int, Int]
 //│ ╙──        	                      ^^^^^^^^^^^^^
 //│ ╔══[ERROR] Member `f` is declared (or its declaration is inherited) but is not implemented in `DerBad1`
-//│ ║  l.1017: 	class DerBad1 extends Base[Int, Int]
+//│ ║  l.1014: 	class DerBad1 extends Base[Int, Int]
 //│ ║          	      ^^^^^^^
 //│ ╟── Declared here:
-//│ ║  l.905: 	trait Base[A] { fun f: A -> A }
+//│ ║  l.902: 	trait Base[A] { fun f: A -> A }
 //│ ╙──       	                ^^^^^^^^^^^^^
 //│ class DerBad1 extends Base {
 //│   constructor()
@@ -1034,28 +1031,28 @@ class DerBad1 extends Base[Int, Int]
 :e
 class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ╔══[ERROR] Type mismatch in definition of method f:
-//│ ║  l.1035: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
+//│ ║  l.1032: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ║          	                                            ^^^^^^^^^^^^^^^^^^
 //│ ╟── reference of type `B` does not match type `A`
-//│ ║  l.1035: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
+//│ ║  l.1032: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ║          	                                                         ^
 //│ ╟── Note: constraint arises from type parameter:
-//│ ║  l.1035: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
+//│ ║  l.1032: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ║          	           ^
 //│ ╟── Note: type parameter B is defined at:
-//│ ║  l.1035: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
+//│ ║  l.1032: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ╙──        	              ^
 //│ ╔══[ERROR] Type mismatch in definition of method f:
-//│ ║  l.1035: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
+//│ ║  l.1032: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ║          	                                            ^^^^^^^^^^^^^^^^^^
 //│ ╟── reference of type `A` does not match type `B`
-//│ ║  l.1035: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
+//│ ║  l.1032: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ║          	                                                            ^
 //│ ╟── Note: constraint arises from type parameter:
-//│ ║  l.1035: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
+//│ ║  l.1032: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ║          	              ^
 //│ ╟── Note: type parameter A is defined at:
-//│ ║  l.1035: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
+//│ ║  l.1032: 	class Der2[A, B] extends Base[[A, B]] { fun f([x, y]) = [y, x] }
 //│ ╙──        	           ^
 //│ class Der2[A, B] extends Base {
 //│   constructor()
@@ -1107,7 +1104,7 @@ trait Tb extends Ta[Int] {
   virtual val p = false
 }
 //│ ╔══[ERROR] Method implementations in traits are not yet supported
-//│ ║  l.1107: 	  virtual val p = false
+//│ ║  l.1104: 	  virtual val p = false
 //│ ╙──        	          ^^^^^^^^^^^^^
 //│ trait Tb extends Ta {
 //│   val g: 'T
@@ -1142,24 +1139,24 @@ trait Oz {
 :e
 class Fischl(age: Bool) extends Oz
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.1143: 	class Fischl(age: Bool) extends Oz
+//│ ║  l.1140: 	class Fischl(age: Bool) extends Oz
 //│ ║          	                  ^^^^
 //│ ╟── type `Bool` is not an instance of type `Int`
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.1136: 	  let age: Int
+//│ ║  l.1133: 	  let age: Int
 //│ ║          	           ^^^
 //│ ╟── from signature of member `age`:
-//│ ║  l.1136: 	  let age: Int
+//│ ║  l.1133: 	  let age: Int
 //│ ╙──        	      ^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.1143: 	class Fischl(age: Bool) extends Oz
+//│ ║  l.1140: 	class Fischl(age: Bool) extends Oz
 //│ ║          	                  ^^^^
 //│ ╟── type `Bool` is not an instance of type `Int`
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.1136: 	  let age: Int
+//│ ║  l.1133: 	  let age: Int
 //│ ║          	           ^^^
 //│ ╟── from signature of member `age`:
-//│ ║  l.1136: 	  let age: Int
+//│ ║  l.1133: 	  let age: Int
 //│ ╙──        	      ^^^^^^^^
 //│ class Fischl(age: Bool) extends Oz
 
@@ -1179,36 +1176,36 @@ class Go extends Fate {
     fun foo(x) = x && true
 }
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.1179: 	    fun foo(x) = x && true
+//│ ║  l.1176: 	    fun foo(x) = x && true
 //│ ║          	        ^^^^^^^^^^^^^^^^^^
 //│ ╟── expression of type `Int & ?a` is not an instance of type `Bool`
 //│ ╟── Note: constraint arises from reference:
-//│ ║  l.1179: 	    fun foo(x) = x && true
+//│ ║  l.1176: 	    fun foo(x) = x && true
 //│ ╙──        	                 ^
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.1179: 	    fun foo(x) = x && true
+//│ ║  l.1176: 	    fun foo(x) = x && true
 //│ ║          	        ^^^^^^^^^^^^^^^^^^
 //│ ╟── expression of type `Int & ?a` does not match type `Bool`
 //│ ╟── Note: constraint arises from reference:
-//│ ║  l.1179: 	    fun foo(x) = x && true
+//│ ║  l.1176: 	    fun foo(x) = x && true
 //│ ╙──        	                 ^
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.1179: 	    fun foo(x) = x && true
+//│ ║  l.1176: 	    fun foo(x) = x && true
 //│ ║          	        ^^^^^^^^^^^^^^^^^^
 //│ ╟── operator application of type `Bool` does not match type `Int | ?a`
-//│ ║  l.1179: 	    fun foo(x) = x && true
+//│ ║  l.1176: 	    fun foo(x) = x && true
 //│ ║          	                 ^^^^^^^^^
 //│ ╟── Note: constraint arises from operator application:
-//│ ║  l.1170: 	    virtual fun foo(x) = x + 1
+//│ ║  l.1167: 	    virtual fun foo(x) = x + 1
 //│ ╙──        	                         ^^^^^
 //│ ╔══[ERROR] Type mismatch in definition of method foo:
-//│ ║  l.1179: 	    fun foo(x) = x && true
+//│ ║  l.1176: 	    fun foo(x) = x && true
 //│ ║          	        ^^^^^^^^^^^^^^^^^^
 //│ ╟── operator application of type `Bool` does not match type `Int | ?a`
-//│ ║  l.1179: 	    fun foo(x) = x && true
+//│ ║  l.1176: 	    fun foo(x) = x && true
 //│ ║          	                 ^^^^^^^^^
 //│ ╟── Note: constraint arises from operator application:
-//│ ║  l.1170: 	    virtual fun foo(x) = x + 1
+//│ ║  l.1167: 	    virtual fun foo(x) = x + 1
 //│ ╙──        	                         ^^^^^
 //│ class Go extends Fate {
 //│   constructor()
@@ -1227,18 +1224,18 @@ class Haha(x: 1 | 2) extends Ha
 :e
 class Ohhh(x: Bool) extends Ha
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.1228: 	class Ohhh(x: Bool) extends Ha
+//│ ║  l.1225: 	class Ohhh(x: Bool) extends Ha
 //│ ║          	              ^^^^
 //│ ╟── type `Bool` is not an instance of type `Int`
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.1218: 	class Ha { virtual val x: Int = 1 }
+//│ ║  l.1215: 	class Ha { virtual val x: Int = 1 }
 //│ ╙──        	                          ^^^
 //│ ╔══[ERROR] Type mismatch in type reference:
-//│ ║  l.1228: 	class Ohhh(x: Bool) extends Ha
+//│ ║  l.1225: 	class Ohhh(x: Bool) extends Ha
 //│ ║          	              ^^^^
 //│ ╟── type `Bool` is not an instance of type `Int`
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.1218: 	class Ha { virtual val x: Int = 1 }
+//│ ║  l.1215: 	class Ha { virtual val x: Int = 1 }
 //│ ╙──        	                          ^^^
 //│ class Ohhh(x: Bool) extends Ha
 
diff --git a/shared/src/test/diff/nu/LetRec.mls b/shared/src/test/diff/nu/LetRec.mls
index cb0176f724..1ff16fa41a 100644
--- a/shared/src/test/diff/nu/LetRec.mls
+++ b/shared/src/test/diff/nu/LetRec.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 :js
@@ -145,9 +145,6 @@ let rec f =
 // :e // FIXME
 :ge
 let foo = foo
-//│ ╔══[ERROR] identifier `foo` not found
-//│ ║  l.147: 	let foo = foo
-//│ ╙──       	          ^^^
 //│ let foo: nothing
 //│ Code generation encountered an error:
 //│   unguarded recursive use of by-value binding foo
diff --git a/shared/src/test/diff/nu/ListConsNil.mls b/shared/src/test/diff/nu/ListConsNil.mls
index d705f6d298..da5ad89bc1 100644
--- a/shared/src/test/diff/nu/ListConsNil.mls
+++ b/shared/src/test/diff/nu/ListConsNil.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 
diff --git a/shared/src/test/diff/nu/LitMatch.mls b/shared/src/test/diff/nu/LitMatch.mls
index ab8f51e8f1..45581782e6 100644
--- a/shared/src/test/diff/nu/LitMatch.mls
+++ b/shared/src/test/diff/nu/LitMatch.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 let r = false : Bool
diff --git a/shared/src/test/diff/nu/MissingTypeArg.mls b/shared/src/test/diff/nu/MissingTypeArg.mls
index fe7011e842..1eba54d987 100644
--- a/shared/src/test/diff/nu/MissingTypeArg.mls
+++ b/shared/src/test/diff/nu/MissingTypeArg.mls
@@ -1,6 +1,6 @@
 // * This is an example program where the error we get is really not ideal
 
-:PreTyper
+:NewDefs
 
 
 // * An example recursive definition:
diff --git a/shared/src/test/diff/nu/NamedArgs.mls b/shared/src/test/diff/nu/NamedArgs.mls
index 4933c1d65b..8c4d4606f1 100644
--- a/shared/src/test/diff/nu/NamedArgs.mls
+++ b/shared/src/test/diff/nu/NamedArgs.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 fun test(x: 'a) = if x is undefined then 0 else x + 1
@@ -150,12 +150,6 @@ fun fff(x: Int, y: Int, z: Int) = (x - y) * z
 // * Testing renaming
 :e
 fff(y: 2, z: y_1 + 1, x: z_1 - 2)
-//│ ╔══[ERROR] identifier `y_1` not found
-//│ ║  l.152: 	fff(y: 2, z: y_1 + 1, x: z_1 - 2)
-//│ ╙──       	             ^^^
-//│ ╔══[ERROR] identifier `z_1` not found
-//│ ║  l.152: 	fff(y: 2, z: y_1 + 1, x: z_1 - 2)
-//│ ╙──       	                         ^^^
 //│ ╔══[ERROR] identifier not found: y_1
 //│ ║  l.152: 	fff(y: 2, z: y_1 + 1, x: z_1 - 2)
 //│ ╙──       	             ^^^
@@ -239,7 +233,7 @@ fun print(x) = (y, z) => log([x, y, z])
 let p = print(0)
 p(z: 1, y: 2)
 //│ ╔══[ERROR] Cannot use named arguments as the function type has untyped arguments
-//│ ║  l.240: 	p(z: 1, y: 2)
+//│ ║  l.234: 	p(z: 1, y: 2)
 //│ ╙──       	 ^^^^^^^^^^^^
 //│ fun print: anything -> (anything, anything) -> ()
 //│ let p: (anything, anything) -> ()
@@ -294,11 +288,8 @@ z.y
 
 :e
 (f => f(x: a))
-//│ ╔══[ERROR] identifier `a` not found
-//│ ║  l.296: 	(f => f(x: a))
-//│ ╙──       	           ^
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `?a` for applying named arguments
-//│ ║  l.296: 	(f => f(x: a))
+//│ ║  l.290: 	(f => f(x: a))
 //│ ╙──       	      ^
 //│ anything -> error
 //│ Code generation encountered an error:
@@ -306,11 +297,8 @@ z.y
 
 :e
 (f => f)(error)(x: a)
-//│ ╔══[ERROR] identifier `a` not found
-//│ ║  l.308: 	(f => f)(error)(x: a)
-//│ ╙──       	                   ^
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `?a` for applying named arguments
-//│ ║  l.308: 	(f => f)(error)(x: a)
+//│ ║  l.299: 	(f => f)(error)(x: a)
 //│ ╙──       	^^^^^^^^^^^^^^^
 //│ error
 //│ Code generation encountered an error:
@@ -318,11 +306,8 @@ z.y
 
 :e
 (f => f)(42)(x: a)
-//│ ╔══[ERROR] identifier `a` not found
-//│ ║  l.320: 	(f => f)(42)(x: a)
-//│ ╙──       	                ^
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `?a` for applying named arguments
-//│ ║  l.320: 	(f => f)(42)(x: a)
+//│ ║  l.308: 	(f => f)(42)(x: a)
 //│ ╙──       	^^^^^^^^^^^^
 //│ error
 //│ Code generation encountered an error:
@@ -330,11 +315,8 @@ z.y
 
 :e
 (f => f)(if true then 123 else false)(x: a)
-//│ ╔══[ERROR] identifier `a` not found
-//│ ║  l.332: 	(f => f)(if true then 123 else false)(x: a)
-//│ ╙──       	                                         ^
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `?a` for applying named arguments
-//│ ║  l.332: 	(f => f)(if true then 123 else false)(x: a)
+//│ ║  l.317: 	(f => f)(if true then 123 else false)(x: a)
 //│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ error
 //│ Code generation encountered an error:
@@ -348,7 +330,7 @@ z.y
 :e
 (f => if true then f else id)(if true then (x: Int) => x + 1 else id)(x: 123)
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `?a` for applying named arguments
-//│ ║  l.349: 	(f => if true then f else id)(if true then (x: Int) => x + 1 else id)(x: 123)
+//│ ║  l.331: 	(f => if true then f else id)(if true then (x: Int) => x + 1 else id)(x: 123)
 //│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ error
 //│ res
@@ -357,7 +339,7 @@ z.y
 :e
 (f => if true then f else id)(if true then (x: Int) => x + 1 else (x: Int) => x + 1)(x: 123)
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `?a` for applying named arguments
-//│ ║  l.358: 	(f => if true then f else id)(if true then (x: Int) => x + 1 else (x: Int) => x + 1)(x: 123)
+//│ ║  l.340: 	(f => if true then f else id)(if true then (x: Int) => x + 1 else (x: Int) => x + 1)(x: 123)
 //│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ error
 //│ res
@@ -379,7 +361,7 @@ foo((x: Int) => 1)
 :e
 fun foo(f: ((x: Int) => Int) | 'a) = f(x: 123)
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `'a | (x: Int) -> Int` for applying named arguments
-//│ ║  l.380: 	fun foo(f: ((x: Int) => Int) | 'a) = f(x: 123)
+//│ ║  l.362: 	fun foo(f: ((x: Int) => Int) | 'a) = f(x: 123)
 //│ ╙──       	                                     ^
 //│ fun foo: (f: anything) -> error
 
@@ -388,7 +370,7 @@ fun foo(f: ((x: Int) => Int) | 'a) = f(x: 123)
 :e
 fun foo(x) = (if true then (x: Int) => x + 1 else x)(x: 123)
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `(x: Int) -> ?a | ?b` for applying named arguments
-//│ ║  l.389: 	fun foo(x) = (if true then (x: Int) => x + 1 else x)(x: 123)
+//│ ║  l.371: 	fun foo(x) = (if true then (x: Int) => x + 1 else x)(x: 123)
 //│ ╙──       	             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ fun foo: anything -> error
 
@@ -401,7 +383,7 @@ foo((y: Int) => y)
 :e // TODO later: this could be made to work...
 fun foo(x) = (if true then (x: Int) => x + 1 else (x: Int) => x + 1)(x: 123)
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `(x: Int) -> (?a | ?b)` for applying named arguments
-//│ ║  l.402: 	fun foo(x) = (if true then (x: Int) => x + 1 else (x: Int) => x + 1)(x: 123)
+//│ ║  l.384: 	fun foo(x) = (if true then (x: Int) => x + 1 else (x: Int) => x + 1)(x: 123)
 //│ ╙──       	             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ fun foo: anything -> error
 
@@ -412,7 +394,7 @@ fun foo(x) = if true then (x: Int) => x + 1 else x
 :e
 foo((y: Int) => y)(x: 123)
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `?a` for applying named arguments
-//│ ║  l.413: 	foo((y: Int) => y)(x: 123)
+//│ ║  l.395: 	foo((y: Int) => y)(x: 123)
 //│ ╙──       	^^^^^^^^^^^^^^^^^^
 //│ error
 //│ res
@@ -421,7 +403,7 @@ foo((y: Int) => y)(x: 123)
 :e
 foo((x: Int) => x - 1)(x: 123)
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `?a` for applying named arguments
-//│ ║  l.422: 	foo((x: Int) => x - 1)(x: 123)
+//│ ║  l.404: 	foo((x: Int) => x - 1)(x: 123)
 //│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^
 //│ error
 //│ res
@@ -434,7 +416,7 @@ fun foo1(x) = [x + 1, x]
 :e
 foo1(x: 123)
 //│ ╔══[ERROR] Cannot use named arguments as the function type has untyped arguments
-//│ ║  l.435: 	foo1(x: 123)
+//│ ║  l.417: 	foo1(x: 123)
 //│ ╙──       	    ^^^^^^^^
 //│ error
 //│ res
diff --git a/shared/src/test/diff/nu/New.mls b/shared/src/test/diff/nu/New.mls
index faae55db75..470f177c25 100644
--- a/shared/src/test/diff/nu/New.mls
+++ b/shared/src/test/diff/nu/New.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class Foo[A](x: A)
diff --git a/shared/src/test/diff/nu/NewNew.mls b/shared/src/test/diff/nu/NewNew.mls
index 5cfa6d96b8..a2e039d7c3 100644
--- a/shared/src/test/diff/nu/NewNew.mls
+++ b/shared/src/test/diff/nu/NewNew.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class Foo(val x: Int)
@@ -183,9 +183,6 @@ type T = PoInt[Str]
 
 :e
 new T(0, 0)
-//│ ╔══[ERROR] identifier `T` is resolved to a type
-//│ ║  l.185: 	new T(0, 0)
-//│ ╙──       	    ^
 //│ ╔══[ERROR] Type alias T cannot be used in `new` expression
 //│ ║  l.185: 	new T(0, 0)
 //│ ╙──       	^^^^^^^^^^^
@@ -201,7 +198,7 @@ let origin = new PoInt(0, 0)
 :e // TODO support
 let origin = PoInt[Int](0, 0)
 //│ ╔══[ERROR] Type application syntax is not yet supported
-//│ ║  l.202: 	let origin = PoInt[Int](0, 0)
+//│ ║  l.199: 	let origin = PoInt[Int](0, 0)
 //│ ╙──       	             ^^^^^^^^^^
 //│ let origin: PoInt[0]
 //│ origin
@@ -210,7 +207,7 @@ let origin = PoInt[Int](0, 0)
 :e // TODO support
 let origin = new PoInt[Int](0, 0)
 //│ ╔══[ERROR] Type arguments in `new` expressions are not yet supported
-//│ ║  l.211: 	let origin = new PoInt[Int](0, 0)
+//│ ║  l.208: 	let origin = new PoInt[Int](0, 0)
 //│ ╙──       	             ^^^^^^^^^^^^^^^^^^^^
 //│ let origin: PoInt[0]
 //│ Code generation encountered an error:
@@ -220,7 +217,7 @@ let origin = new PoInt[Int](0, 0)
 :e // TODO support
 new {}
 //│ ╔══[ERROR] Unexpected type `anything` after `new` keyword
-//│ ║  l.221: 	new {}
+//│ ║  l.218: 	new {}
 //│ ╙──       	    ^^
 //│ error
 //│ Code generation encountered an error:
@@ -230,10 +227,10 @@ new {}
 :e
 new
 //│ ╔══[PARSE ERROR] Unexpected end of input; an expression was expected here
-//│ ║  l.231: 	new
+//│ ║  l.228: 	new
 //│ ╙──       	   ^
 //│ ╔══[ERROR] Unexpected type `()` after `new` keyword
-//│ ║  l.231: 	new
+//│ ║  l.228: 	new
 //│ ╙──       	   ^
 //│ error
 //│ Code generation encountered an error:
@@ -244,14 +241,11 @@ new
 :e
 new
   x: 0
-//│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.246: 	  x: 0
-//│ ╙──       	  ^
 //│ ╔══[PARSE ERROR] Not a recognized type
-//│ ║  l.246: 	  x: 0
+//│ ║  l.243: 	  x: 0
 //│ ╙──       	  ^
 //│ ╔══[ERROR] Unexpected type `nothing` after `new` keyword
-//│ ║  l.246: 	  x: 0
+//│ ║  l.243: 	  x: 0
 //│ ╙──       	  ^
 //│ error
 //│ Code generation encountered an error:
@@ -266,7 +260,7 @@ fun f(x) = {x}
 :e
 new f(1)
 //│ ╔══[ERROR] type identifier not found: f
-//│ ║  l.267: 	new f(1)
+//│ ║  l.261: 	new f(1)
 //│ ╙──       	    ^
 //│ error
 //│ res
@@ -279,7 +273,7 @@ module Oops
 :e
 new Oops
 //│ ╔══[ERROR] Module Oops cannot be used in `new` expression
-//│ ║  l.280: 	new Oops
+//│ ║  l.274: 	new Oops
 //│ ╙──       	    ^^^^
 //│ error
 //│ res
@@ -289,11 +283,8 @@ new Oops
 :e
 new Oops2
 trait Oops2
-//│ ╔══[ERROR] identifier `Oops2` is resolved to a type
-//│ ║  l.290: 	new Oops2
-//│ ╙──       	    ^^^^^
 //│ ╔══[ERROR] Trait Oops2 cannot be used in `new` expression
-//│ ║  l.290: 	new Oops2
+//│ ║  l.284: 	new Oops2
 //│ ╙──       	    ^^^^^
 //│ trait Oops2
 //│ error
diff --git a/shared/src/test/diff/nu/Object.mls b/shared/src/test/diff/nu/Object.mls
index de48499444..9e93dec27b 100644
--- a/shared/src/test/diff/nu/Object.mls
+++ b/shared/src/test/diff/nu/Object.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 
@@ -88,9 +88,6 @@ fun foo = forall 'a; (x: 'a) => if x is A then true else false
 
 :e
 Object
-//│ ╔══[ERROR] identifier `Object` not found
-//│ ║  l.90: 	Object
-//│ ╙──      	^^^^^^
 //│ ╔══[ERROR] Class Object is abstract and cannot be instantiated
 //│ ║  l.90: 	Object
 //│ ╙──      	^^^^^^
@@ -103,14 +100,11 @@ Object
 
 :e
 Object()
-//│ ╔══[ERROR] identifier `Object` not found
-//│ ║  l.105: 	Object()
-//│ ╙──       	^^^^^^
 //│ ╔══[ERROR] Class Object is abstract and cannot be instantiated
-//│ ║  l.105: 	Object()
+//│ ║  l.102: 	Object()
 //│ ╙──       	^^^^^^
 //│ ╔══[ERROR] Class Object cannot be instantiated as it exposes no constructor
-//│ ║  l.105: 	Object()
+//│ ║  l.102: 	Object()
 //│ ╙──       	^^^^^^
 //│ error
 //│ Code generation encountered an error:
@@ -118,11 +112,8 @@ Object()
 
 :e
 new Object
-//│ ╔══[ERROR] identifier `Object` not found
-//│ ║  l.120: 	new Object
-//│ ╙──       	    ^^^^^^
 //│ ╔══[ERROR] Class Object is abstract and cannot be instantiated
-//│ ║  l.120: 	new Object
+//│ ║  l.114: 	new Object
 //│ ╙──       	    ^^^^^^
 //│ Object
 //│ Code generation encountered an error:
@@ -132,9 +123,6 @@ new Object
 
 // TODO
 class B() extends Object
-//│ ╔══[ERROR] could not find definition `Object`
-//│ ║  l.134: 	class B() extends Object
-//│ ╙──       	                  ^^^^^^
 //│ class B() extends Object
 //│ Code generation encountered an error:
 //│   unresolved parent Object.
diff --git a/shared/src/test/diff/nu/OpLam.mls b/shared/src/test/diff/nu/OpLam.mls
index 78ce0e69a7..bedc2cd423 100644
--- a/shared/src/test/diff/nu/OpLam.mls
+++ b/shared/src/test/diff/nu/OpLam.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 x => x is 42
@@ -105,12 +105,6 @@ x => x + 2
 
 :e
 x => x.y => y
-//│ ╔══[ERROR] unsupported pattern shape
-//│ ║  l.107: 	x => x.y => y
-//│ ╙──       	     ^^^
-//│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.107: 	x => x.y => y
-//│ ╙──       	            ^
 //│ ╔══[ERROR] Unsupported pattern shape:
 //│ ║  l.107: 	x => x.y => y
 //│ ╙──       	     ^^^
diff --git a/shared/src/test/diff/nu/OptionFilter.mls b/shared/src/test/diff/nu/OptionFilter.mls
index 31879983e5..d27e8492a2 100644
--- a/shared/src/test/diff/nu/OptionFilter.mls
+++ b/shared/src/test/diff/nu/OptionFilter.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 // * Minimization of code that used to cause a problem:
diff --git a/shared/src/test/diff/nu/OverrideShorthand.mls b/shared/src/test/diff/nu/OverrideShorthand.mls
index e9e61e5946..2bd823530c 100644
--- a/shared/src/test/diff/nu/OverrideShorthand.mls
+++ b/shared/src/test/diff/nu/OverrideShorthand.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 
diff --git a/shared/src/test/diff/nu/ParamPassing.mls b/shared/src/test/diff/nu/ParamPassing.mls
index 0c08b497cb..0fc6a4af9c 100644
--- a/shared/src/test/diff/nu/ParamPassing.mls
+++ b/shared/src/test/diff/nu/ParamPassing.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class Foo(x: Int)
@@ -66,12 +66,6 @@ Foo(1).x
 
 :e
 Foo(1).#x
-//│ ╔══[ERROR] identifier `.#` not found
-//│ ║  l.68: 	Foo(1).#x
-//│ ╙──      	      ^^
-//│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.68: 	Foo(1).#x
-//│ ╙──      	        ^
 //│ ╔══[ERROR] identifier not found: .#
 //│ ║  l.68: 	Foo(1).#x
 //│ ╙──      	      ^^
@@ -105,20 +99,20 @@ if Foo(1) is Foo(x) then x
 :e
 class Bar(x: Int) extends Foo(x)
 //│ ╔══[ERROR] Inherited parameter named `x` is not virtual and cannot be overridden
-//│ ║  l.106: 	class Bar(x: Int) extends Foo(x)
+//│ ║  l.100: 	class Bar(x: Int) extends Foo(x)
 //│ ║         	          ^
 //│ ╟── Originally declared here:
-//│ ║  l.91: 	class Foo(val x: Int)
+//│ ║  l.85: 	class Foo(val x: Int)
 //│ ╙──      	              ^
 //│ class Bar(x: Int) extends Foo
 
 :e
 Bar(11).x
 //│ ╔══[ERROR] Parameter 'x' cannot tbe accessed as a field
-//│ ║  l.116: 	Bar(11).x
+//│ ║  l.110: 	Bar(11).x
 //│ ║         	       ^^
 //│ ╟── Either make the parameter a `val` or access it through destructuring
-//│ ║  l.106: 	class Bar(x: Int) extends Foo(x)
+//│ ║  l.100: 	class Bar(x: Int) extends Foo(x)
 //│ ╙──       	          ^
 //│ Int | error
 //│ res
@@ -128,10 +122,10 @@ Bar(11).x
 :e
 class Bar(val x: Int) extends Foo(x + 1)
 //│ ╔══[ERROR] Inherited parameter named `x` is not virtual and cannot be overridden
-//│ ║  l.129: 	class Bar(val x: Int) extends Foo(x + 1)
+//│ ║  l.123: 	class Bar(val x: Int) extends Foo(x + 1)
 //│ ║         	              ^
 //│ ╟── Originally declared here:
-//│ ║  l.91: 	class Foo(val x: Int)
+//│ ║  l.85: 	class Foo(val x: Int)
 //│ ╙──      	              ^
 //│ class Bar(x: Int) extends Foo
 
@@ -143,10 +137,10 @@ Bar(11).x
 :e
 class Bar extends Foo(1) { val x: 2 }
 //│ ╔══[ERROR] Inherited parameter named `x` is not virtual and cannot be overridden
-//│ ║  l.144: 	class Bar extends Foo(1) { val x: 2 }
+//│ ║  l.138: 	class Bar extends Foo(1) { val x: 2 }
 //│ ║         	                           ^^^^^^^^
 //│ ╟── Originally declared here:
-//│ ║  l.91: 	class Foo(val x: Int)
+//│ ║  l.85: 	class Foo(val x: Int)
 //│ ╙──      	              ^
 //│ class Bar extends Foo {
 //│   constructor()
@@ -156,10 +150,10 @@ class Bar extends Foo(1) { val x: 2 }
 :e
 module Bar extends Foo(1) { fun x = 2 }
 //│ ╔══[ERROR] Inherited parameter named `x` is not virtual and cannot be overridden
-//│ ║  l.157: 	module Bar extends Foo(1) { fun x = 2 }
+//│ ║  l.151: 	module Bar extends Foo(1) { fun x = 2 }
 //│ ║         	                                ^^^^^
 //│ ╟── Originally declared here:
-//│ ║  l.91: 	class Foo(val x: Int)
+//│ ║  l.85: 	class Foo(val x: Int)
 //│ ╙──      	              ^
 //│ module Bar extends Foo {
 //│   fun x: 2
@@ -187,10 +181,10 @@ module B extends A(42)
 :e
 B.x
 //│ ╔══[ERROR] Parameter 'x' cannot tbe accessed as a field
-//│ ║  l.188: 	B.x
+//│ ║  l.182: 	B.x
 //│ ║         	 ^^
 //│ ╟── Either make the parameter a `val` or access it through destructuring
-//│ ║  l.181: 	class A(x: Int)
+//│ ║  l.175: 	class A(x: Int)
 //│ ╙──       	        ^
 //│ Int | error
 //│ res
@@ -229,16 +223,16 @@ module Bazz extends Foo(0) {
   val x: 2
 }
 //│ ╔══[ERROR] Inherited parameter named `x` is not virtual and cannot be overridden
-//│ ║  l.229: 	  val x: 2
+//│ ║  l.223: 	  val x: 2
 //│ ║         	  ^^^^^^^^
 //│ ╟── Originally declared here:
-//│ ║  l.201: 	abstract class Foo[A](val x: A) { fun y = x; fun i: A -> A }
+//│ ║  l.195: 	abstract class Foo[A](val x: A) { fun y = x; fun i: A -> A }
 //│ ╙──       	                          ^
 //│ ╔══[ERROR] Member `i` is declared (or its declaration is inherited) but is not implemented in `Bazz`
-//│ ║  l.228: 	module Bazz extends Foo(0) {
+//│ ║  l.222: 	module Bazz extends Foo(0) {
 //│ ║         	       ^^^^
 //│ ╟── Declared here:
-//│ ║  l.201: 	abstract class Foo[A](val x: A) { fun y = x; fun i: A -> A }
+//│ ║  l.195: 	abstract class Foo[A](val x: A) { fun y = x; fun i: A -> A }
 //│ ╙──       	                                             ^^^^^^^^^^^^^
 //│ module Bazz extends Foo {
 //│   fun i: 'A -> 'A
diff --git a/shared/src/test/diff/nu/PolymorphicVariants_Alt.mls b/shared/src/test/diff/nu/PolymorphicVariants_Alt.mls
index f636b0f4ea..1c9fead11d 100644
--- a/shared/src/test/diff/nu/PolymorphicVariants_Alt.mls
+++ b/shared/src/test/diff/nu/PolymorphicVariants_Alt.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 :NoJS
 
 
diff --git a/shared/src/test/diff/nu/PostHocMixinSignature.mls b/shared/src/test/diff/nu/PostHocMixinSignature.mls
index ec7e6a0d2d..1d0ae3e3a6 100644
--- a/shared/src/test/diff/nu/PostHocMixinSignature.mls
+++ b/shared/src/test/diff/nu/PostHocMixinSignature.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 mixin Foo {
diff --git a/shared/src/test/diff/nu/PrivateMemberOverriding.mls b/shared/src/test/diff/nu/PrivateMemberOverriding.mls
index a3aa25961e..e7977a41df 100644
--- a/shared/src/test/diff/nu/PrivateMemberOverriding.mls
+++ b/shared/src/test/diff/nu/PrivateMemberOverriding.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class Foo(x: Int)
diff --git a/shared/src/test/diff/nu/RefinedPattern.mls b/shared/src/test/diff/nu/RefinedPattern.mls
index c9283801a0..fd4d193965 100644
--- a/shared/src/test/diff/nu/RefinedPattern.mls
+++ b/shared/src/test/diff/nu/RefinedPattern.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class C
@@ -30,9 +30,6 @@ test(D(123))
 
 :e
 refined
-//│ ╔══[ERROR] identifier `refined` not found
-//│ ║  l.32: 	refined
-//│ ╙──      	^^^^^^^
 //│ ╔══[ERROR] Illegal use of reserved operator: refined
 //│ ║  l.32: 	refined
 //│ ╙──      	^^^^^^^
diff --git a/shared/src/test/diff/nu/SelfRec.mls b/shared/src/test/diff/nu/SelfRec.mls
index fba85a5db3..3a68af47cf 100644
--- a/shared/src/test/diff/nu/SelfRec.mls
+++ b/shared/src/test/diff/nu/SelfRec.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 
diff --git a/shared/src/test/diff/nu/Subscripts.mls b/shared/src/test/diff/nu/Subscripts.mls
index 7668fe6b46..eb2812dbb6 100644
--- a/shared/src/test/diff/nu/Subscripts.mls
+++ b/shared/src/test/diff/nu/Subscripts.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 let xs = [0, 1, 2]
diff --git a/shared/src/test/diff/nu/TODO_Classes.mls b/shared/src/test/diff/nu/TODO_Classes.mls
index 34699bb12e..8df3944017 100644
--- a/shared/src/test/diff/nu/TODO_Classes.mls
+++ b/shared/src/test/diff/nu/TODO_Classes.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 
diff --git a/shared/src/test/diff/nu/Unapply.mls b/shared/src/test/diff/nu/Unapply.mls
index 8bf62edc2e..9dcc6a93a4 100644
--- a/shared/src/test/diff/nu/Unapply.mls
+++ b/shared/src/test/diff/nu/Unapply.mls
@@ -1,6 +1,6 @@
 // *** Explicit unapply tests *** //
 
-:PreTyper
+:NewDefs
 
 
 // * Unapply's current compilation strategy:
diff --git a/shared/src/test/diff/nu/UndefMatching.mls b/shared/src/test/diff/nu/UndefMatching.mls
index 3050b22762..57453f5d99 100644
--- a/shared/src/test/diff/nu/UndefMatching.mls
+++ b/shared/src/test/diff/nu/UndefMatching.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 
diff --git a/shared/src/test/diff/nu/WeirdUnions.mls b/shared/src/test/diff/nu/WeirdUnions.mls
index 9194fd1e2a..89326b7576 100644
--- a/shared/src/test/diff/nu/WeirdUnions.mls
+++ b/shared/src/test/diff/nu/WeirdUnions.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 
diff --git a/shared/src/test/diff/nu/i180.mls b/shared/src/test/diff/nu/i180.mls
index 4b1e033098..39013ced9f 100644
--- a/shared/src/test/diff/nu/i180.mls
+++ b/shared/src/test/diff/nu/i180.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 fun (++) stringConcat(a, b) = concat(a)(b)
diff --git a/shared/src/test/diff/nu/repro0.mls b/shared/src/test/diff/nu/repro0.mls
index 89ed2dabe0..c02b9aa19e 100644
--- a/shared/src/test/diff/nu/repro0.mls
+++ b/shared/src/test/diff/nu/repro0.mls
@@ -1,7 +1,7 @@
-:PreTyper
+:NewDefs
 :NoJS
 
-:e
+
 class Add[out E](val lhs: E)
 val add11 = Add(add11)
 module EvalAddLit {
@@ -9,9 +9,6 @@ module EvalAddLit {
     if e is Add then eval(e.lhs)
 }
 let res = EvalAddLit.eval(add11)
-//│ ╔══[ERROR] identifier `add11` not found
-//│ ║  l.6: 	val add11 = Add(add11)
-//│ ╙──     	                ^^^^^
 //│ class Add[E](lhs: E)
 //│ val add11: 'E
 //│ module EvalAddLit {
diff --git a/shared/src/test/diff/nu/repro1.mls b/shared/src/test/diff/nu/repro1.mls
index 7db26f2cb7..09c7cb8328 100644
--- a/shared/src/test/diff/nu/repro1.mls
+++ b/shared/src/test/diff/nu/repro1.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 :NoJS
 
 
diff --git a/shared/src/test/diff/nu/repro_EvalNegNeg.mls b/shared/src/test/diff/nu/repro_EvalNegNeg.mls
index e0aee8d956..4d99692691 100644
--- a/shared/src/test/diff/nu/repro_EvalNegNeg.mls
+++ b/shared/src/test/diff/nu/repro_EvalNegNeg.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class Add<out E>(lhs: E, rhs: E)
diff --git a/shared/src/test/diff/nu/repro_PolymorphicVariants.mls b/shared/src/test/diff/nu/repro_PolymorphicVariants.mls
index 2c1624a9ec..461bada4e8 100644
--- a/shared/src/test/diff/nu/repro_PolymorphicVariants.mls
+++ b/shared/src/test/diff/nu/repro_PolymorphicVariants.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 // Test that reprduces subtle type simplification bug
 
diff --git a/shared/src/test/diff/pretyper/Declarations.mls b/shared/src/test/diff/pretyper/Declarations.mls
index 450ef6e36b..7f07a109d8 100644
--- a/shared/src/test/diff/pretyper/Declarations.mls
+++ b/shared/src/test/diff/pretyper/Declarations.mls
@@ -1,5 +1,4 @@
 :NewDefs
-:PreTyper
 :NoJS
 
 
diff --git a/shared/src/test/diff/pretyper/Errors.mls b/shared/src/test/diff/pretyper/Errors.mls
new file mode 100644
index 0000000000..9e071a13f1
--- /dev/null
+++ b/shared/src/test/diff/pretyper/Errors.mls
@@ -0,0 +1,722 @@
+:NewDefs
+:NoJS
+:ShowPreTyperErrors
+:AllowParseErrors
+:AllowTypeErrors
+
+// This file is used to test the error messages of the _unfinished_ `PreTyper`.
+// The goal is to document `PreTyper` behavior and to make sure that the error
+// messages are clear and helpful. We can delete this file after it is done.
+
+// codegen
+// -------
+
+// SymbolicOps
+fun (>>)(f, g) = x => g(f(x))
+//│ ╔══[PARSE ERROR] Expected a function name; found parenthesis section instead
+//│ ║  l.15: 	fun (>>)(f, g) = x => g(f(x))
+//│ ╙──      	        ^^^^^^
+//│ ╔══[ERROR] identifier `g` not found
+//│ ║  l.15: 	fun (>>)(f, g) = x => g(f(x))
+//│ ╙──      	                      ^
+//│ ╔══[ERROR] identifier `f` not found
+//│ ║  l.15: 	fun (>>)(f, g) = x => g(f(x))
+//│ ╙──      	                        ^
+//│ ╔══[ERROR] identifier not found: g
+//│ ║  l.15: 	fun (>>)(f, g) = x => g(f(x))
+//│ ╙──      	                      ^
+//│ ╔══[ERROR] identifier not found: f
+//│ ║  l.15: 	fun (>>)(f, g) = x => g(f(x))
+//│ ╙──      	                        ^
+//│ fun (>>) <error>: anything -> error
+
+// mlscript
+// --------
+
+// Sequence
+let test(x) = log(x); x + 1
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.37: 	let test(x) = log(x); x + 1
+//│ ╙──      	                      ^
+//│ ╔══[ERROR] identifier not found: x
+//│ ║  l.37: 	let test(x) = log(x); x + 1
+//│ ╙──      	                      ^
+//│ let test: anything -> ()
+//│ Int
+
+// nu
+// --
+
+// Ascription
+foo(123: Int): Int
+//│ ╔══[ERROR] identifier `foo` not found
+//│ ║  l.51: 	foo(123: Int): Int
+//│ ╙──      	^^^
+//│ ╔══[ERROR] identifier `Int` is resolved to a type
+//│ ║  l.51: 	foo(123: Int): Int
+//│ ╙──      	         ^^^
+//│ ╔══[ERROR] identifier not found: foo
+//│ ║  l.51: 	foo(123: Int): Int
+//│ ╙──      	^^^
+//│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `error` for applying named arguments
+//│ ║  l.51: 	foo(123: Int): Int
+//│ ╙──      	^^^
+//│ Int
+
+// Ascription
+foo(123:Int):Int
+//│ ╔══[ERROR] identifier `foo` not found
+//│ ║  l.67: 	foo(123:Int):Int
+//│ ╙──      	^^^
+//│ ╔══[ERROR] identifier `Int` is resolved to a type
+//│ ║  l.67: 	foo(123:Int):Int
+//│ ╙──      	        ^^^
+//│ ╔══[ERROR] identifier not found: foo
+//│ ║  l.67: 	foo(123:Int):Int
+//│ ╙──      	^^^
+//│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `error` for applying named arguments
+//│ ║  l.67: 	foo(123:Int):Int
+//│ ╙──      	^^^
+//│ Int
+
+// BadBlocks
+fun test =
+  let a = b
+  let b = 1
+  a
+//│ ╔══[ERROR] identifier `b` not found
+//│ ║  l.84: 	  let a = b
+//│ ╙──      	          ^
+//│ fun test: 1
+
+// BadBlocks
+fun test =
+  let a() = b
+  let b = 1
+  a()
+//│ ╔══[ERROR] identifier `b` not found
+//│ ║  l.94: 	  let a() = b
+//│ ╙──      	            ^
+//│ fun test: 1
+
+// BadClasses
+hello
+//│ ╔══[ERROR] identifier `hello` not found
+//│ ║  l.103: 	hello
+//│ ╙──       	^^^^^
+//│ ╔══[ERROR] identifier not found: hello
+//│ ║  l.103: 	hello
+//│ ╙──       	^^^^^
+//│ error
+
+// BadFieldInit
+module A {
+  val x = y
+  val y = x
+}
+//│ ╔══[ERROR] identifier `y` not found
+//│ ║  l.114: 	  val x = y
+//│ ╙──       	          ^
+//│ module A {
+//│   val x: nothing
+//│   val y: nothing
+//│ }
+
+// BadFieldInit
+module A {
+  val x = y
+  val y = 1
+}
+//│ ╔══[ERROR] identifier `y` not found
+//│ ║  l.127: 	  val x = y
+//│ ╙──       	          ^
+//│ module A {
+//│   val x: 1
+//│   val y: 1
+//│ }
+
+// BadMixin
+mixin M0
+M0
+//│ ╔══[ERROR] identifier `M0` is resolved to a type
+//│ ║  l.140: 	M0
+//│ ╙──       	^^
+//│ ╔══[ERROR] mixin M0 cannot be used in term position
+//│ ║  l.140: 	M0
+//│ ╙──       	^^
+//│ mixin M0()
+//│ error
+
+// BadScopes
+mixin Foo(x: Int)
+x
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.152: 	x
+//│ ╙──       	^
+//│ ╔══[ERROR] identifier not found: x
+//│ ║  l.152: 	x
+//│ ╙──       	^
+//│ mixin Foo(x: Int)
+//│ error
+
+// BadScopes
+class Foo(x: Int)
+x
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.164: 	x
+//│ ╙──       	^
+//│ ╔══[ERROR] identifier not found: x
+//│ ║  l.164: 	x
+//│ ╙──       	^
+//│ class Foo(x: Int)
+//│ error
+
+// BadScopes
+class Bar { x }
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.175: 	class Bar { x }
+//│ ╙──       	            ^
+//│ ╔══[ERROR] identifier not found: x
+//│ ║  l.175: 	class Bar { x }
+//│ ╙──       	            ^
+//│ class Bar {
+//│   constructor()
+//│ }
+
+// BadTraits
+trait Foo
+Foo
+//│ ╔══[ERROR] identifier `Foo` is resolved to a type
+//│ ║  l.188: 	Foo
+//│ ╙──       	^^^
+//│ ╔══[ERROR] trait Foo cannot be used in term position
+//│ ║  l.188: 	Foo
+//│ ╙──       	^^^
+//│ trait Foo
+//│ error
+
+// FunPatterns
+fun f3([(x, y,),],) = x + y
+//│ ╔══[ERROR] unsupported pattern shape
+//│ ║  l.199: 	fun f3([(x, y,),],) = x + y
+//│ ╙──       	        ^^^^^^^
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.199: 	fun f3([(x, y,),],) = x + y
+//│ ╙──       	                      ^
+//│ ╔══[ERROR] identifier `y` not found
+//│ ║  l.199: 	fun f3([(x, y,),],) = x + y
+//│ ╙──       	                          ^
+//│ ╔══[ERROR] Unsupported pattern shape:
+//│ ║  l.199: 	fun f3([(x, y,),],) = x + y
+//│ ╙──       	        ^^^^^^^
+//│ ╔══[ERROR] identifier not found: x
+//│ ║  l.199: 	fun f3([(x, y,),],) = x + y
+//│ ╙──       	                      ^
+//│ ╔══[ERROR] identifier not found: y
+//│ ║  l.199: 	fun f3([(x, y,),],) = x + y
+//│ ╙──       	                          ^
+//│ fun f3: ([error]) -> Int
+
+// GenericClassInheritance
+class C1[A] extends C0[A] { val a = a }
+//│ ╔══[ERROR] could not find definition `C0`
+//│ ║  l.221: 	class C1[A] extends C0[A] { val a = a }
+//│ ╙──       	                    ^^
+//│ ╔══[ERROR] identifier `a` not found
+//│ ║  l.221: 	class C1[A] extends C0[A] { val a = a }
+//│ ╙──       	                                    ^
+//│ ╔══[ERROR] Could not find definition `C0`
+//│ ║  l.221: 	class C1[A] extends C0[A] { val a = a }
+//│ ╙──       	                    ^^
+//│ class C1[A] {
+//│   constructor()
+//│   val a: nothing
+//│ }
+
+// GenericMethods
+fun foo1 = forall 'A: (x: 'A) => x
+//│ fun foo1: forall 'A. (x: 'A) -> 'A
+
+// GenericMethods
+foo1[Int](42)
+//│ ╔══[ERROR] type application syntax is not yet supported
+//│ ║  l.241: 	foo1[Int](42)
+//│ ╙──       	^^^^^^^^^
+//│ ╔══[ERROR] Type application syntax is not yet supported
+//│ ║  l.241: 	foo1[Int](42)
+//│ ╙──       	^^^^^^^^^
+//│ 42
+
+// GenericMethods
+fun foo2<A>(x: A) = x
+//│ fun foo2: forall 'A. (x: 'A) -> 'A
+
+// GenericMethods
+foo2<Int>(42)
+//│ ╔══[ERROR] type application syntax is not yet supported
+//│ ║  l.255: 	foo2<Int>(42)
+//│ ╙──       	^^^^^^^^^
+//│ ╔══[ERROR] Type application syntax is not yet supported
+//│ ║  l.255: 	foo2<Int>(42)
+//│ ╙──       	^^^^^^^^^
+//│ 42
+
+// GenericMethods
+fun foo3[A](x: A) = x
+//│ fun foo3: forall 'A. (x: 'A) -> 'A
+
+// GenericMethods
+foo3[Int](42)
+//│ ╔══[ERROR] type application syntax is not yet supported
+//│ ║  l.269: 	foo3[Int](42)
+//│ ╙──       	^^^^^^^^^
+//│ ╔══[ERROR] Type application syntax is not yet supported
+//│ ║  l.269: 	foo3[Int](42)
+//│ ╙──       	^^^^^^^^^
+//│ 42
+
+// ImplicitMethodPolym
+module None
+module M {
+  mut val m = None
+  fun oops(x) = m := x
+}
+//│ ╔══[PARSE ERROR] Unexpected 'mut' keyword in expression position
+//│ ║  l.281: 	  mut val m = None
+//│ ╙──       	  ^^^
+//│ ╔══[PARSE ERROR] Unexpected 'val' keyword in expression position
+//│ ║  l.281: 	  mut val m = None
+//│ ╙──       	      ^^^
+//│ ╔══[ERROR] identifier `:=` not found
+//│ ║  l.282: 	  fun oops(x) = m := x
+//│ ╙──       	                  ^^
+//│ ╔══[ERROR] identifier `m` not found
+//│ ║  l.282: 	  fun oops(x) = m := x
+//│ ╙──       	                ^
+//│ ╔══[WARNING] unsupported `Eqn`: m = None
+//│ ║  l.281: 	  mut val m = None
+//│ ╙──       	          ^^^^^^^^
+//│ ╔══[ERROR] identifier not found: :=
+//│ ║  l.282: 	  fun oops(x) = m := x
+//│ ╙──       	                  ^^
+//│ ╔══[ERROR] identifier not found: m
+//│ ║  l.282: 	  fun oops(x) = m := x
+//│ ╙──       	                ^
+//│ ╔══[ERROR] Unexpected equation in this position
+//│ ║  l.281: 	  mut val m = None
+//│ ╙──       	          ^^^^^^^^
+//│ module None
+//│ module M {
+//│   fun oops: anything -> error
+//│ }
+
+// InterfaceMono
+trait What0 extends woooo
+//│ ╔══[ERROR] could not find definition `woooo`
+//│ ║  l.314: 	trait What0 extends woooo
+//│ ╙──       	                    ^^^^^
+//│ ╔══[ERROR] Could not find definition `woooo`
+//│ ║  l.314: 	trait What0 extends woooo
+//│ ╙──       	                    ^^^^^
+//│ trait What0
+
+// Misc
+let f = ((x, y)) => x + y
+//│ ╔══[ERROR] unsupported pattern shape
+//│ ║  l.324: 	let f = ((x, y)) => x + y
+//│ ╙──       	         ^^^^^^
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.324: 	let f = ((x, y)) => x + y
+//│ ╙──       	                    ^
+//│ ╔══[ERROR] identifier `y` not found
+//│ ║  l.324: 	let f = ((x, y)) => x + y
+//│ ╙──       	                        ^
+//│ ╔══[ERROR] Unsupported pattern shape:
+//│ ║  l.324: 	let f = ((x, y)) => x + y
+//│ ╙──       	         ^^^^^^
+//│ ╔══[ERROR] identifier not found: x
+//│ ║  l.324: 	let f = ((x, y)) => x + y
+//│ ╙──       	                    ^
+//│ ╔══[ERROR] identifier not found: y
+//│ ║  l.324: 	let f = ((x, y)) => x + y
+//│ ╙──       	                        ^
+//│ let f: error -> Int
+
+// Misc
+f[1, 2]
+//│ ╔══[ERROR] type application syntax is not yet supported
+//│ ║  l.346: 	f[1, 2]
+//│ ╙──       	^^^^^^^
+//│ ╔══[ERROR] Type application syntax is not yet supported
+//│ ║  l.346: 	f[1, 2]
+//│ ╙──       	^^^^^^^
+//│ error -> Int
+
+// Misc
+let f = (((x, y))) => x + y
+//│ ╔══[ERROR] unsupported pattern shape
+//│ ║  l.356: 	let f = (((x, y))) => x + y
+//│ ╙──       	          ^^^^^^
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.356: 	let f = (((x, y))) => x + y
+//│ ╙──       	                      ^
+//│ ╔══[ERROR] identifier `y` not found
+//│ ║  l.356: 	let f = (((x, y))) => x + y
+//│ ╙──       	                          ^
+//│ ╔══[ERROR] Unsupported pattern shape:
+//│ ║  l.356: 	let f = (((x, y))) => x + y
+//│ ╙──       	          ^^^^^^
+//│ ╔══[ERROR] identifier not found: x
+//│ ║  l.356: 	let f = (((x, y))) => x + y
+//│ ╙──       	                      ^
+//│ ╔══[ERROR] identifier not found: y
+//│ ║  l.356: 	let f = (((x, y))) => x + y
+//│ ╙──       	                          ^
+//│ let f: error -> Int
+
+// Mut
+let v1 = {mut 1}
+v1.x <- 1
+//│ ╔══[PARSE ERROR] Record field should have a name
+//│ ║  l.378: 	let v1 = {mut 1}
+//│ ╙──       	              ^
+//│ ╔══[ERROR] identifier `<-` not found
+//│ ║  l.379: 	v1.x <- 1
+//│ ╙──       	     ^^
+//│ ╔══[ERROR] identifier not found: <-
+//│ ║  l.379: 	v1.x <- 1
+//│ ╙──       	     ^^
+//│ ╔══[ERROR] Type mismatch in field selection:
+//│ ║  l.379: 	v1.x <- 1
+//│ ║         	^^^^
+//│ ╟── record literal of type `{mut <error>: ?<error>}` does not have field 'x'
+//│ ║  l.378: 	let v1 = {mut 1}
+//│ ║         	              ^
+//│ ╟── but it flows into reference with expected type `{x: ?x}`
+//│ ║  l.379: 	v1.x <- 1
+//│ ╙──       	^^
+//│ let v1: {mut <error>: '<error>}
+//│ error
+//│ where
+//│   '<error> :> 1
+
+// Mut
+let v2 = [mut x: 1]
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.404: 	let v2 = [mut x: 1]
+//│ ╙──       	              ^
+//│ let v2: [mut x: 'x]
+//│   where
+//│     'x :> 1
+
+// Mut
+let v2 = [mut y: 1]
+//│ ╔══[ERROR] identifier `y` not found
+//│ ║  l.413: 	let v2 = [mut y: 1]
+//│ ╙──       	              ^
+//│ let v2: [mut y: 'y]
+//│   where
+//│     'y :> 1
+
+// NoThisCtor
+class Foo() {
+  virtual val foo: Int = 42
+}
+//│ class Foo() {
+//│   val foo: Int
+//│ }
+
+// NoThisCtor
+class Foo5() extends Foo() {
+  val foo: Int
+  val x = bar(0)
+  fun bar(y: Int) = this.foo + y
+}
+//│ ╔══[ERROR] identifier `bar` not found
+//│ ║  l.432: 	  val x = bar(0)
+//│ ╙──       	          ^^^
+//│ ╔══[ERROR] Cannot access `this` while initializing field x
+//│ ║  l.432: 	  val x = bar(0)
+//│ ║         	      ^^^^^^^^^^
+//│ ╟── The access to `this` is here
+//│ ║  l.433: 	  fun bar(y: Int) = this.foo + y
+//│ ╙──       	                    ^^^^
+//│ class Foo5() extends Foo {
+//│   fun bar: (y: Int) -> Int
+//│   val foo: Int
+//│   val x: Int
+//│ }
+
+// NoThisCtor
+abstract class Foo: (Int -> Int) {
+  val x = f
+  fun f = this(0)
+}
+//│ ╔══[ERROR] Cannot access `this` while initializing field x
+//│ ║  l.452: 	  val x = f
+//│ ║         	      ^^^^^
+//│ ╟── The access to `this` is here
+//│ ║  l.453: 	  fun f = this(0)
+//│ ╙──       	          ^^^^
+//│ abstract class Foo: Int -> Int {
+//│   fun f: nothing
+//│   val x: nothing
+//│ }
+
+// Object
+Object
+//│ ╔══[ERROR] identifier `Object` not found
+//│ ║  l.467: 	Object
+//│ ╙──       	^^^^^^
+//│ ╔══[ERROR] Class Object is abstract and cannot be instantiated
+//│ ║  l.467: 	Object
+//│ ╙──       	^^^^^^
+//│ ╔══[ERROR] Class Object cannot be instantiated as it exposes no constructor
+//│ ║  l.467: 	Object
+//│ ╙──       	^^^^^^
+//│ error
+
+// OpLam
+x => x.y => y
+//│ ╔══[ERROR] unsupported pattern shape
+//│ ║  l.480: 	x => x.y => y
+//│ ╙──       	     ^^^
+//│ ╔══[ERROR] identifier `y` not found
+//│ ║  l.480: 	x => x.y => y
+//│ ╙──       	            ^
+//│ ╔══[ERROR] Unsupported pattern shape:
+//│ ║  l.480: 	x => x.y => y
+//│ ╙──       	     ^^^
+//│ ╔══[ERROR] identifier not found: y
+//│ ║  l.480: 	x => x.y => y
+//│ ╙──       	            ^
+//│ anything -> error -> error
+
+// ParamOverride
+class Base0(n: Num)
+//│ class Base0(n: Num)
+
+// ParamOverride
+class Derived0(n: Int) extends Base
+//│ ╔══[ERROR] could not find definition `Base`
+//│ ║  l.500: 	class Derived0(n: Int) extends Base
+//│ ╙──       	                               ^^^^
+//│ ╔══[ERROR] Could not find definition `Base`
+//│ ║  l.500: 	class Derived0(n: Int) extends Base
+//│ ╙──       	                               ^^^^
+//│ class Derived0(n: Int)
+
+// ParamOverride
+mixin DerivedBad(n: Int) extends Base
+//│ ╔══[ERROR] could not find definition `Base`
+//│ ║  l.510: 	mixin DerivedBad(n: Int) extends Base
+//│ ╙──       	                                 ^^^^
+//│ ╔══[ERROR] mixin definitions cannot yet extend parents
+//│ ║  l.510: 	mixin DerivedBad(n: Int) extends Base
+//│ ╙──       	                                 ^^^^
+//│ mixin DerivedBad(n: Int)
+
+// PartialApp
+fun foo(x, y) = x + y
+//│ fun foo: (Int, Int) -> Int
+
+// PartialApp
+foo(2, _)
+//│ ╔══[ERROR] identifier `_` not found
+//│ ║  l.524: 	foo(2, _)
+//│ ╙──       	       ^
+//│ ╔══[ERROR] Widlcard in expression position.
+//│ ║  l.524: 	foo(2, _)
+//│ ╙──       	       ^
+//│ Int
+
+// PartialApp
+_.foo(1)
+//│ ╔══[ERROR] identifier `_` not found
+//│ ║  l.534: 	_.foo(1)
+//│ ╙──       	^
+//│ ╔══[ERROR] Widlcard in expression position.
+//│ ║  l.534: 	_.foo(1)
+//│ ╙──       	^
+//│ error
+
+// PartialApp
+_ + _
+//│ ╔══[ERROR] identifier `_` not found
+//│ ║  l.544: 	_ + _
+//│ ╙──       	^
+//│ ╔══[ERROR] identifier `_` not found
+//│ ║  l.544: 	_ + _
+//│ ╙──       	    ^
+//│ ╔══[ERROR] Widlcard in expression position.
+//│ ║  l.544: 	_ + _
+//│ ╙──       	^
+//│ ╔══[ERROR] Widlcard in expression position.
+//│ ║  l.544: 	_ + _
+//│ ╙──       	    ^
+//│ Int
+
+// PartialApp
+_2 + _1
+//│ ╔══[ERROR] identifier `_2` not found
+//│ ║  l.560: 	_2 + _1
+//│ ╙──       	^^
+//│ ╔══[ERROR] identifier `_1` not found
+//│ ║  l.560: 	_2 + _1
+//│ ╙──       	     ^^
+//│ ╔══[ERROR] identifier not found: _2
+//│ ║  l.560: 	_2 + _1
+//│ ╙──       	^^
+//│ ╔══[ERROR] identifier not found: _1
+//│ ║  l.560: 	_2 + _1
+//│ ╙──       	     ^^
+//│ Int
+
+// RefinedPatterns
+refined
+//│ ╔══[ERROR] identifier `refined` not found
+//│ ║  l.576: 	refined
+//│ ╙──       	^^^^^^^
+//│ ╔══[ERROR] Illegal use of reserved operator: refined
+//│ ║  l.576: 	refined
+//│ ╙──       	^^^^^^^
+//│ ╔══[ERROR] identifier not found: refined
+//│ ║  l.576: 	refined
+//│ ╙──       	^^^^^^^
+//│ error
+
+// Refinements
+class D() { fun f = 0 }
+//│ class D() {
+//│   fun f: 0
+//│ }
+
+// Refinements
+let d = D & { f: 0 }
+//│ ╔══[ERROR] identifier `&` not found
+//│ ║  l.595: 	let d = D & { f: 0 }
+//│ ╙──       	          ^
+//│ ╔══[ERROR] Illegal use of reserved operator: &
+//│ ║  l.595: 	let d = D & { f: 0 }
+//│ ╙──       	          ^
+//│ ╔══[ERROR] identifier not found: &
+//│ ║  l.595: 	let d = D & { f: 0 }
+//│ ╙──       	          ^
+//│ let d: error
+
+// Res
+x => x + 2
+//│ Int -> Int
+
+// Res
+res(1)
+//│ ╔══[ERROR] identifier `res` not found
+//│ ║  l.612: 	res(1)
+//│ ╙──       	^^^
+//│ ╔══[ERROR] identifier not found: res
+//│ ║  l.612: 	res(1)
+//│ ╙──       	^^^
+//│ error
+
+// Uninstantiable
+Int
+//│ ╔══[ERROR] identifier `Int` is resolved to a type
+//│ ║  l.622: 	Int
+//│ ╙──       	^^^
+//│ ╔══[ERROR] Class Int is abstract and cannot be instantiated
+//│ ║  l.622: 	Int
+//│ ╙──       	^^^
+//│ ╔══[ERROR] Class Int cannot be instantiated as it exposes no constructor
+//│ ║  l.622: 	Int
+//│ ╙──       	^^^
+//│ error
+
+// Uninstantiable
+Int()
+//│ ╔══[ERROR] identifier `Int` is resolved to a type
+//│ ║  l.635: 	Int()
+//│ ╙──       	^^^
+//│ ╔══[ERROR] Class Int is abstract and cannot be instantiated
+//│ ║  l.635: 	Int()
+//│ ╙──       	^^^
+//│ ╔══[ERROR] Class Int cannot be instantiated as it exposes no constructor
+//│ ║  l.635: 	Int()
+//│ ╙──       	^^^
+//│ error
+
+// Uninstantiable
+new Int
+//│ ╔══[ERROR] identifier `Int` is resolved to a type
+//│ ║  l.648: 	new Int
+//│ ╙──       	    ^^^
+//│ ╔══[ERROR] Class Int is abstract and cannot be instantiated
+//│ ║  l.648: 	new Int
+//│ ╙──       	    ^^^
+//│ Int
+
+// Unit
+(1, 2) => 3
+//│ ╔══[WARNING] literal patterns are ignored
+//│ ║  l.658: 	(1, 2) => 3
+//│ ╙──       	 ^
+//│ ╔══[WARNING] literal patterns are ignored
+//│ ║  l.658: 	(1, 2) => 3
+//│ ╙──       	    ^
+//│ (1, 2) -> 3
+
+// Unit
+1 => (2, 3)
+//│ ╔══[WARNING] literal patterns are ignored
+//│ ║  l.668: 	1 => (2, 3)
+//│ ╙──       	^
+//│ 1 -> 3
+
+// Vals
+val c = d + 1
+val d = 1
+//│ val c: Int
+//│ val d: 1
+
+// Varargs
+fun test(...xs) = xs.length
+//│ ╔══[PARSE ERROR] Unexpected operator here
+//│ ║  l.681: 	fun test(...xs) = xs.length
+//│ ╙──       	         ^^^
+//│ ╔══[ERROR] identifier `xs` not found
+//│ ║  l.681: 	fun test(...xs) = xs.length
+//│ ╙──       	                  ^^
+//│ ╔══[ERROR] identifier not found: xs
+//│ ║  l.681: 	fun test(...xs) = xs.length
+//│ ╙──       	                  ^^
+//│ fun test: () -> error
+
+// WeirdDefs
+fun fst[x, _] = x
+//│ ╔══[ERROR] identifier `x` not found
+//│ ║  l.694: 	fun fst[x, _] = x
+//│ ╙──       	                ^
+//│ ╔══[ERROR] identifier not found: x
+//│ ║  l.694: 	fun fst[x, _] = x
+//│ ╙──       	                ^
+//│ fun fst: error
+
+// repro0
+class Add[out E](val lhs: E)
+val add11 = Add(add11)
+module EvalAddLit {
+  fun eval(e: Add['A]) =
+    if e is Add then eval(e.lhs)
+}
+let res = EvalAddLit.eval(add11)
+//│ ╔══[ERROR] identifier `add11` not found
+//│ ║  l.705: 	val add11 = Add(add11)
+//│ ╙──       	                ^^^^^
+//│ class Add[E](lhs: E)
+//│ val add11: 'E
+//│ module EvalAddLit {
+//│   fun eval: forall 'A. (e: 'A) -> nothing
+//│ }
+//│ let res: nothing
+//│ where
+//│   'A <: Add['A]
+//│   'E :> Add['E]
diff --git a/shared/src/test/diff/pretyper/Repro.mls b/shared/src/test/diff/pretyper/Repro.mls
index bf3a52e7ca..34d9bdfef7 100644
--- a/shared/src/test/diff/pretyper/Repro.mls
+++ b/shared/src/test/diff/pretyper/Repro.mls
@@ -1 +1 @@
-:PreTyper
+:NewDefs
diff --git a/shared/src/test/diff/pretyper/ucs/DualOption.mls b/shared/src/test/diff/pretyper/ucs/DualOption.mls
index a8bc582fb2..ab4d61d97e 100644
--- a/shared/src/test/diff/pretyper/ucs/DualOption.mls
+++ b/shared/src/test/diff/pretyper/ucs/DualOption.mls
@@ -1,5 +1,5 @@
 :NewDefs
-:PreTyper
+:NewDefs
 
 abstract class Option[T]
 class Some[T](value: T) extends Option[T]
diff --git a/shared/src/test/diff/pretyper/ucs/NamePattern.mls b/shared/src/test/diff/pretyper/ucs/NamePattern.mls
index bbe1fa4020..05aa66c779 100644
--- a/shared/src/test/diff/pretyper/ucs/NamePattern.mls
+++ b/shared/src/test/diff/pretyper/ucs/NamePattern.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 fun id(x) = x
 //│ fun id: forall 'a. 'a -> 'a
diff --git a/shared/src/test/diff/pretyper/ucs/RecordPattern.mls b/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
index 21f57ff2db..dead7496bd 100644
--- a/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
+++ b/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 :e
 :w
@@ -15,12 +15,6 @@ fun take_1(p) =
 //│ ╟── because this branch covers the case
 //│ ║  l.7: 	    { x, y } then x + y
 //│ ╙──     	                  ^^^^^
-//│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.7: 	    { x, y } then x + y
-//│ ╙──     	                  ^
-//│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.7: 	    { x, y } then x + y
-//│ ╙──     	                      ^
 //│ ╔══[ERROR] identifier not found: x
 //│ ║  l.7: 	    { x, y } then x + y
 //│ ╙──     	                  ^
diff --git a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
index b18f377554..a2befb18e1 100644
--- a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
+++ b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 // This test file is to track possible name collision during specialization.
 
@@ -21,18 +21,14 @@ fun example1(p) =
     else "nah"
 //│ fun example1: (Object & ~#Pair | Pair[Num, Num]) -> ("both negative" | "both positive" | "nah")
 
-:e
+// FIXME: The following test case should fail, but it doesn't. The reason is
+// `x` and `y` are in the desugared lexical scope, although they don't in the
+// original lexical scope.
 fun example2(p) =
   if p is
     Pair(x, y) and p1(x) and p1(y) then "both negative"
     Pair(a, b) and p2(a) and p2(b) then x + y
     else "nah"
-//│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.28: 	    Pair(a, b) and p2(a) and p2(b) then x + y
-//│ ╙──      	                                        ^
-//│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.28: 	    Pair(a, b) and p2(a) and p2(b) then x + y
-//│ ╙──      	                                            ^
 //│ fun example2: (Object & ~#Pair | Pair[Int, Int]) -> ("both negative" | "nah" | Int)
 
 // Next, let's check the name collision between a class and its super class.
diff --git a/shared/src/test/diff/pretyper/ucs/Unapply.mls b/shared/src/test/diff/pretyper/ucs/Unapply.mls
index 3bd099ff0d..850cdf2946 100644
--- a/shared/src/test/diff/pretyper/ucs/Unapply.mls
+++ b/shared/src/test/diff/pretyper/ucs/Unapply.mls
@@ -1,5 +1,4 @@
 :NewDefs
-:PreTyper
 
 class Point(x: Int, y: Int, z: Int)
 //│ class Point(x: Int, y: Int, z: Int)
diff --git a/shared/src/test/diff/pretyper/ucs/Unconditional.mls b/shared/src/test/diff/pretyper/ucs/Unconditional.mls
index 804033b23a..09a21ba926 100644
--- a/shared/src/test/diff/pretyper/ucs/Unconditional.mls
+++ b/shared/src/test/diff/pretyper/ucs/Unconditional.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 class Point(x: Int, y: Int)
 class Rectangle(x: Int, y: Int, width: Int, height: Int)
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls b/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls
index 018117880b..9d62846406 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 class Some[T](value: T)
 module None
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/Refinement.mls b/shared/src/test/diff/pretyper/ucs/coverage/Refinement.mls
index 7469887ed4..545bfa2320 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/Refinement.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/Refinement.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 class Point(x: Int, y: Int)
 abstract class Shape: (Circle | Rectangle | LineSegment)
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
index c1db6d34e1..6bd909b509 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 abstract class Term: Abs | App | Var
 class Var(name: Str) extends Term
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/Tautology.mls b/shared/src/test/diff/pretyper/ucs/coverage/Tautology.mls
index a2b73e9f86..5c0e3e613b 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/Tautology.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/Tautology.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 class Some[T](value: T)
 module None
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls b/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
index de454fa68d..6b3df49e71 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 class Some[T](value: T)
 module None
diff --git a/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls b/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls
index 363b7b52a2..8205836776 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 fun (|>) pipe(x, f) = f(x)
 fun (~~>) toBe(x, y) = if x === y then () else error
diff --git a/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls b/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls
index a8f0c8d222..65d70f8c81 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 fun (|>) pipe(x, f) = f(x)
 fun (~~>) toBe(x, y) = if x === y then () else error
diff --git a/shared/src/test/diff/pretyper/ucs/examples/Calculator.mls b/shared/src/test/diff/pretyper/ucs/examples/Calculator.mls
index 050ed0a91f..cffafb2d25 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/Calculator.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/Calculator.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 // This test file explores implementing a calculator using UCS.
 
diff --git a/shared/src/test/diff/pretyper/ucs/examples/EitherOrBoth.mls b/shared/src/test/diff/pretyper/ucs/examples/EitherOrBoth.mls
index 76a8a831ac..648c293826 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/EitherOrBoth.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/EitherOrBoth.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 abstract class Option[out T]: (Some[T] | None)
 class Some[out T](value: T) extends Option[T]
diff --git a/shared/src/test/diff/pretyper/ucs/examples/JSON.mls b/shared/src/test/diff/pretyper/ucs/examples/JSON.mls
index 8113539d3b..4b6c6ebd46 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/JSON.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/JSON.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 type NStr = Str & {
diff --git a/shared/src/test/diff/pretyper/ucs/examples/LeftistTree.mls b/shared/src/test/diff/pretyper/ucs/examples/LeftistTree.mls
index 3cccb825f0..a8aebb62b8 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/LeftistTree.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/LeftistTree.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 fun (|>) pipe(x, f) = f(x)
 fun (~~>) toBe(x, y) = if x === y then () else error
diff --git a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
index c309a504fd..9ac35c305b 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 // Summon the underlying JavaScript `Object.is` function so that we can compare
 // any objects. For example, functions do not conforms to `Eql` so we cannot
diff --git a/shared/src/test/diff/pretyper/ucs/examples/List.mls b/shared/src/test/diff/pretyper/ucs/examples/List.mls
index d922fd4aa7..08fa887788 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/List.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/List.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 // TODO
 abstract class List[out A]: (Cons[A] | Nil) {
diff --git a/shared/src/test/diff/pretyper/ucs/examples/ListFold.mls b/shared/src/test/diff/pretyper/ucs/examples/ListFold.mls
index fccc64cc0a..ff6c7b9cfa 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/ListFold.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/ListFold.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 fun (|>) pipe(x, f) = f(x)
 fun (++) strcat(s1, s2) = concat(s1)(s2)
diff --git a/shared/src/test/diff/pretyper/ucs/examples/Option.mls b/shared/src/test/diff/pretyper/ucs/examples/Option.mls
index 7903575720..e412ec780d 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/Option.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/Option.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 abstract class MyOption[out T]: (MySome[T] | MyNone) {
   virtual fun filter: (p: T -> Bool) -> MyOption[T]
diff --git a/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls b/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls
index 04277c54f6..cbcd1b3cea 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/Permutations.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 fun (|>) pipe(x, f) = f(x)
 fun (++) strcat(s1, s2) = concat(s1)(s2)
diff --git a/shared/src/test/diff/pretyper/ucs/examples/STLC.mls b/shared/src/test/diff/pretyper/ucs/examples/STLC.mls
index 217e6ab052..8333bbae72 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/STLC.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/STLC.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 fun (++) concatOp(a, b) = concat(a)(b)
 //│ fun (++) concatOp: (Str, Str) -> Str
diff --git a/shared/src/test/diff/pretyper/ucs/examples/SimpleLisp.mls b/shared/src/test/diff/pretyper/ucs/examples/SimpleLisp.mls
index 43c5b7f91f..b493c6d2d9 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/SimpleLisp.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/SimpleLisp.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 fun (++) strcat(a: Str, b: Str): Str = concat(a)(b)
 //│ fun (++) strcat: (a: Str, b: Str) -> Str
diff --git a/shared/src/test/diff/pretyper/ucs/examples/SimpleList.mls b/shared/src/test/diff/pretyper/ucs/examples/SimpleList.mls
index 0da096a946..2eebaa4533 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/SimpleList.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/SimpleList.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 abstract class List[T]: (Cons[T] | Nil)
 class Cons[T](val head: T, val tail: List[T]) extends List[T]
diff --git a/shared/src/test/diff/pretyper/ucs/examples/SimpleTree.mls b/shared/src/test/diff/pretyper/ucs/examples/SimpleTree.mls
index db617d7cdb..19162c0c32 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/SimpleTree.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/SimpleTree.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 // abstract class Tree[out A]: (Empty | Node[A])
 // class Node[out A](value: A, left: Tree[A], right: Tree[A]) extends Tree[A]
diff --git a/shared/src/test/diff/pretyper/ucs/examples/ULC.mls b/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
index d94e810a3f..18ab746454 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 fun (++) concatOp(a, b) = concat(a)(b)
 fun (|>) pipe(a, f) = f(a)
diff --git a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
index b0d98e8438..8a1b7fb4f9 100644
--- a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
+++ b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 class Some[T](value: T)
 module None
diff --git a/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls b/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls
index 7939013b4f..ea4536bc6b 100644
--- a/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls
+++ b/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 // We test the support for simple tuple patterns in this file.
 // Splice tuple patterns will be implement in the future.
diff --git a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
index ff4ba25ef1..f9ac187c04 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 abstract class Option[out T]: Some[T] | None
 class Some[out T](value: T) extends Option[T]
diff --git a/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls b/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
index c4033b646f..6238ea8228 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 :ucs:postprocess.result,desugared
 fun mixed_literals(v) =
diff --git a/shared/src/test/diff/pretyper/ucs/stages/TransfromUCS.mls b/shared/src/test/diff/pretyper/ucs/stages/TransfromUCS.mls
index a3e044195f..ef294f2398 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/TransfromUCS.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/TransfromUCS.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 class Some[T](value: T)
 module None
diff --git a/shared/src/test/diff/ucs/AppSplits.mls b/shared/src/test/diff/ucs/AppSplits.mls
index fe952e5f8b..bb2d1d17e3 100644
--- a/shared/src/test/diff/ucs/AppSplits.mls
+++ b/shared/src/test/diff/ucs/AppSplits.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 fun foo(x) = x > 1
diff --git a/shared/src/test/diff/ucs/CrossBranchCapture.mls b/shared/src/test/diff/ucs/CrossBranchCapture.mls
index 82f0aad17a..93fd728c23 100644
--- a/shared/src/test/diff/ucs/CrossBranchCapture.mls
+++ b/shared/src/test/diff/ucs/CrossBranchCapture.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 fun (~~>) expect(a, b) = if a === b then () else error
 //│ fun (~~>) expect: forall 'a. (Eql['a], 'a) -> ()
@@ -7,14 +7,13 @@ class Numb(n: Int)
 //│ class Numb(n: Int)
 
 
-:e
+// FIXME: The following test case should fail, but it doesn't. The reason is
+// `x` and `y` are in the desugared lexical scope, although they don't in the
+// original lexical scope.
 fun process(e) =
   if e is
     Numb(n) and n > 0 then n
     Numb(m) then n
-//│ ╔══[ERROR] identifier `n` not found
-//│ ║  l.14: 	    Numb(m) then n
-//│ ╙──      	                 ^
 //│ fun process: Numb -> Int
 
 
@@ -57,11 +56,8 @@ fun process(e) =
     Pair(Vec(xs), Vec(ys))  then n
     Pair(Vec(n),  Numb(n)) then n
     Pair(Numb(n), Vec(n))  then n
-//│ ╔══[ERROR] identifier `n` not found
-//│ ║  l.57: 	    Pair(Vec(xs), Vec(ys))  then n
-//│ ╙──      	                                 ^
 //│ ╔══[ERROR] identifier not found: n
-//│ ║  l.57: 	    Pair(Vec(xs), Vec(ys))  then n
+//│ ║  l.56: 	    Pair(Vec(xs), Vec(ys))  then n
 //│ ╙──      	                                 ^
 //│ fun process: Pair[Numb | Vec, Numb | Vec] -> (Int | Numb | error)
 //│ Code generation encountered an error:
diff --git a/shared/src/test/diff/ucs/DirectLines.mls b/shared/src/test/diff/ucs/DirectLines.mls
index 22e0c1e39b..a04684371e 100644
--- a/shared/src/test/diff/ucs/DirectLines.mls
+++ b/shared/src/test/diff/ucs/DirectLines.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 fun f(x, y) =
   if
diff --git a/shared/src/test/diff/ucs/ElseIf.mls b/shared/src/test/diff/ucs/ElseIf.mls
index 7e9ca42c2e..8f59b0782f 100644
--- a/shared/src/test/diff/ucs/ElseIf.mls
+++ b/shared/src/test/diff/ucs/ElseIf.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 
diff --git a/shared/src/test/diff/ucs/ErrorMessage.mls b/shared/src/test/diff/ucs/ErrorMessage.mls
index a361659c85..61c13d2137 100644
--- a/shared/src/test/diff/ucs/ErrorMessage.mls
+++ b/shared/src/test/diff/ucs/ErrorMessage.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 class Point(x: Int, y: Int)
 //│ class Point(x: Int, y: Int)
@@ -26,9 +26,6 @@ fun g(xs) =
 //│ ╔══[ERROR] type identifier `::` not found
 //│ ║  l.25: 	    head :: _ then head
 //│ ╙──      	         ^^
-//│ ╔══[ERROR] identifier `::` not found
-//│ ║  l.25: 	    head :: _ then head
-//│ ╙──      	         ^^
 //│ ╔══[ERROR] type identifier not found: ::
 //│ ║  l.25: 	    head :: _ then head
 //│ ╙──      	         ^^
diff --git a/shared/src/test/diff/ucs/Exhaustiveness.mls b/shared/src/test/diff/ucs/Exhaustiveness.mls
index 88bf03fd2d..45abe4607f 100644
--- a/shared/src/test/diff/ucs/Exhaustiveness.mls
+++ b/shared/src/test/diff/ucs/Exhaustiveness.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 :NoJS
 
 class A()
diff --git a/shared/src/test/diff/ucs/Humiliation.mls b/shared/src/test/diff/ucs/Humiliation.mls
index 86bf952f04..9f258cdcba 100644
--- a/shared/src/test/diff/ucs/Humiliation.mls
+++ b/shared/src/test/diff/ucs/Humiliation.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class Foo[T](x: T)
diff --git a/shared/src/test/diff/ucs/Hygiene.mls b/shared/src/test/diff/ucs/Hygiene.mls
index bd7b4cd1f9..d2ea541ba6 100644
--- a/shared/src/test/diff/ucs/Hygiene.mls
+++ b/shared/src/test/diff/ucs/Hygiene.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 class Some[out T](value: T)
 class Left[out T](value: T)
diff --git a/shared/src/test/diff/ucs/HygienicBindings.mls b/shared/src/test/diff/ucs/HygienicBindings.mls
index 73f439801e..651de5de98 100644
--- a/shared/src/test/diff/ucs/HygienicBindings.mls
+++ b/shared/src/test/diff/ucs/HygienicBindings.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 fun (~~>) expect(a, b) = if a === b then () else error
 //│ fun (~~>) expect: forall 'a. (Eql['a], 'a) -> ()
diff --git a/shared/src/test/diff/ucs/InterleavedLet.mls b/shared/src/test/diff/ucs/InterleavedLet.mls
index 4f3d90b811..f0840717dd 100644
--- a/shared/src/test/diff/ucs/InterleavedLet.mls
+++ b/shared/src/test/diff/ucs/InterleavedLet.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 fun f(x) =
   if x ==
diff --git a/shared/src/test/diff/ucs/LeadingAnd.mls b/shared/src/test/diff/ucs/LeadingAnd.mls
index ef653e5876..d25af76465 100644
--- a/shared/src/test/diff/ucs/LeadingAnd.mls
+++ b/shared/src/test/diff/ucs/LeadingAnd.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 
diff --git a/shared/src/test/diff/ucs/LitUCS.mls b/shared/src/test/diff/ucs/LitUCS.mls
index 24e123678d..6c77687f0f 100644
--- a/shared/src/test/diff/ucs/LitUCS.mls
+++ b/shared/src/test/diff/ucs/LitUCS.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 module A
 //│ module A
diff --git a/shared/src/test/diff/ucs/MultiwayIf.mls b/shared/src/test/diff/ucs/MultiwayIf.mls
index d0c8457dcd..6add8f28e5 100644
--- a/shared/src/test/diff/ucs/MultiwayIf.mls
+++ b/shared/src/test/diff/ucs/MultiwayIf.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 fun f(x) =
diff --git a/shared/src/test/diff/ucs/NestedBranches.mls b/shared/src/test/diff/ucs/NestedBranches.mls
index 7cb7bd627a..7a6fdf3104 100644
--- a/shared/src/test/diff/ucs/NestedBranches.mls
+++ b/shared/src/test/diff/ucs/NestedBranches.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class Some[out A](val value: A)
diff --git a/shared/src/test/diff/ucs/NestedOpSplits.mls b/shared/src/test/diff/ucs/NestedOpSplits.mls
index 573b59ca24..82db3c99dc 100644
--- a/shared/src/test/diff/ucs/NestedOpSplits.mls
+++ b/shared/src/test/diff/ucs/NestedOpSplits.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 // * Note that this always to the left
diff --git a/shared/src/test/diff/ucs/NestedPattern.mls b/shared/src/test/diff/ucs/NestedPattern.mls
index 33549162d9..30d73dfd1f 100644
--- a/shared/src/test/diff/ucs/NestedPattern.mls
+++ b/shared/src/test/diff/ucs/NestedPattern.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 abstract class Option[A]: Some[A] | None
 class Some[A](value: A) extends Option[A]
diff --git a/shared/src/test/diff/ucs/NuPlainConditionals.mls b/shared/src/test/diff/ucs/NuPlainConditionals.mls
index e0406c2480..299655c68a 100644
--- a/shared/src/test/diff/ucs/NuPlainConditionals.mls
+++ b/shared/src/test/diff/ucs/NuPlainConditionals.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class Pair[A](fst: A, snd: A)
@@ -84,21 +84,9 @@ fun foo2(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╔══[ERROR] type identifier `|` not found
 //│ ║  l.80: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	                                          ^
-//│ ╔══[ERROR] type identifier `Int` not found
-//│ ║  l.80: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
-//│ ╙──      	                                            ^^^
-//│ ╔══[ERROR] identifier `|` not found
-//│ ║  l.80: 	fun foo2(x) = x is (Pair(a, b) and a > b) | Int
-//│ ╙──      	                                          ^
 //│ ╔══[ERROR] type identifier `|` not found
 //│ ║  l.79: 	fun foo1(x) = x is Pair(a, b) | Int
 //│ ╙──      	                              ^
-//│ ╔══[ERROR] type identifier `Int` not found
-//│ ║  l.79: 	fun foo1(x) = x is Pair(a, b) | Int
-//│ ╙──      	                                ^^^
-//│ ╔══[ERROR] identifier `|` not found
-//│ ║  l.79: 	fun foo1(x) = x is Pair(a, b) | Int
-//│ ╙──      	                              ^
 //│ ╔══[ERROR] type identifier not found: |
 //│ ║  l.79: 	fun foo1(x) = x is Pair(a, b) | Int
 //│ ╙──      	                              ^
diff --git a/shared/src/test/diff/ucs/Or.mls b/shared/src/test/diff/ucs/Or.mls
index 516894f7d6..a44e8973b8 100644
--- a/shared/src/test/diff/ucs/Or.mls
+++ b/shared/src/test/diff/ucs/Or.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class Some[T](value: T)
diff --git a/shared/src/test/diff/ucs/OverlappedBranches.mls b/shared/src/test/diff/ucs/OverlappedBranches.mls
index 627bb38daf..132141356a 100644
--- a/shared/src/test/diff/ucs/OverlappedBranches.mls
+++ b/shared/src/test/diff/ucs/OverlappedBranches.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 class Base()
 class Derived1() extends Base()
diff --git a/shared/src/test/diff/ucs/ParseFailures.mls b/shared/src/test/diff/ucs/ParseFailures.mls
index 889a0cca33..3d1e101486 100644
--- a/shared/src/test/diff/ucs/ParseFailures.mls
+++ b/shared/src/test/diff/ucs/ParseFailures.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 :NoJS
 
 // FIXME
diff --git a/shared/src/test/diff/ucs/PlainConditionals.mls b/shared/src/test/diff/ucs/PlainConditionals.mls
index ce5a34a5f6..7dc3b959c3 100644
--- a/shared/src/test/diff/ucs/PlainConditionals.mls
+++ b/shared/src/test/diff/ucs/PlainConditionals.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 class Pair[A, B](fst: A, snd: B)
@@ -84,21 +84,9 @@ fun foo(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╔══[ERROR] type identifier `|` not found
 //│ ║  l.80: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	                                         ^
-//│ ╔══[ERROR] type identifier `Int` not found
-//│ ║  l.80: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
-//│ ╙──      	                                           ^^^
-//│ ╔══[ERROR] identifier `|` not found
-//│ ║  l.80: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
-//│ ╙──      	                                         ^
 //│ ╔══[ERROR] type identifier `|` not found
 //│ ║  l.79: 	fun foo(x) = x is Pair(a, b) | Int
 //│ ╙──      	                             ^
-//│ ╔══[ERROR] type identifier `Int` not found
-//│ ║  l.79: 	fun foo(x) = x is Pair(a, b) | Int
-//│ ╙──      	                               ^^^
-//│ ╔══[ERROR] identifier `|` not found
-//│ ║  l.79: 	fun foo(x) = x is Pair(a, b) | Int
-//│ ╙──      	                             ^
 //│ ╔══[ERROR] Refininition of 'foo'
 //│ ║  l.80: 	fun foo(x) = x is (Pair(a, b) and a > b) | Int
 //│ ╙──      	    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/shared/src/test/diff/ucs/SimpleUCS.mls b/shared/src/test/diff/ucs/SimpleUCS.mls
index 8f76440d0b..4753c4adf4 100644
--- a/shared/src/test/diff/ucs/SimpleUCS.mls
+++ b/shared/src/test/diff/ucs/SimpleUCS.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 abstract class Option[A]: Some[A] | None
 class Some[A](value: A) extends Option[A]
diff --git a/shared/src/test/diff/ucs/SplitAfterOp.mls b/shared/src/test/diff/ucs/SplitAfterOp.mls
index 8ff3a4ca99..3c4d96cf1e 100644
--- a/shared/src/test/diff/ucs/SplitAfterOp.mls
+++ b/shared/src/test/diff/ucs/SplitAfterOp.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 :e
 fun f(x, b) =
diff --git a/shared/src/test/diff/ucs/SplitAnd.mls b/shared/src/test/diff/ucs/SplitAnd.mls
index b40269f034..99d2a33c41 100644
--- a/shared/src/test/diff/ucs/SplitAnd.mls
+++ b/shared/src/test/diff/ucs/SplitAnd.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 fun f(x, y) =
   if x == 0 and
diff --git a/shared/src/test/diff/ucs/SplitAroundOp.mls b/shared/src/test/diff/ucs/SplitAroundOp.mls
index cf8c1d1792..75f038b276 100644
--- a/shared/src/test/diff/ucs/SplitAroundOp.mls
+++ b/shared/src/test/diff/ucs/SplitAroundOp.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 fun f(x, b) =
   if x
@@ -61,9 +61,6 @@ if x is
 //│ ╔══[ERROR] identifier `x` not found
 //│ ║  l.38: 	if x is
 //│ ╙──      	   ^
-//│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.38: 	if x is
-//│ ╙──      	   ^
 //│ ╔══[ERROR] unexpected empty split found
 //│ ╙──
 //│ ╔══[ERROR] identifier not found: x
diff --git a/shared/src/test/diff/ucs/SplitBeforeOp.mls b/shared/src/test/diff/ucs/SplitBeforeOp.mls
index c4bd59a493..efed78266e 100644
--- a/shared/src/test/diff/ucs/SplitBeforeOp.mls
+++ b/shared/src/test/diff/ucs/SplitBeforeOp.mls
@@ -1,12 +1,9 @@
-:PreTyper
+:NewDefs
 
 :e
 :ge
 if x
   == 0 then 0
-//│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.5: 	if x
-//│ ╙──     	   ^
 //│ ╔══[ERROR] missing else branch
 //│ ║  l.6: 	  == 0 then 0
 //│ ╙──     	            ^
@@ -27,25 +24,19 @@ if x
   is A and
     y then 0
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.26: 	if x
+//│ ║  l.23: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] type identifier `A` not found
-//│ ║  l.27: 	  is A and
+//│ ║  l.24: 	  is A and
 //│ ╙──      	     ^
-//│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.26: 	if x
-//│ ╙──      	   ^
-//│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.28: 	    y then 0
-//│ ╙──      	    ^
 //│ ╔══[ERROR] missing else branch
-//│ ║  l.28: 	    y then 0
+//│ ║  l.25: 	    y then 0
 //│ ╙──      	           ^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.26: 	if x
+//│ ║  l.23: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] type identifier not found: A
-//│ ║  l.27: 	  is A and
+//│ ║  l.24: 	  is A and
 //│ ╙──      	     ^
 //│ error
 //│ Code generation encountered an error:
@@ -58,22 +49,16 @@ if x
     y then 0
 else 1
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.56: 	if x
+//│ ║  l.47: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] type identifier `A` not found
-//│ ║  l.57: 	  is A and
+//│ ║  l.48: 	  is A and
 //│ ╙──      	     ^
-//│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.56: 	if x
-//│ ╙──      	   ^
-//│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.58: 	    y then 0
-//│ ╙──      	    ^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.56: 	if x
+//│ ║  l.47: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] type identifier not found: A
-//│ ║  l.57: 	  is A and
+//│ ║  l.48: 	  is A and
 //│ ╙──      	     ^
 //│ error
 //│ Code generation encountered an error:
@@ -87,31 +72,22 @@ if x
     A() then "A"
     B() then "B"
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.84: 	if x
+//│ ║  l.69: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] type identifier `A` not found
-//│ ║  l.87: 	    A() then "A"
+//│ ║  l.72: 	    A() then "A"
 //│ ╙──      	    ^
 //│ ╔══[ERROR] type identifier `B` not found
-//│ ║  l.88: 	    B() then "B"
+//│ ║  l.73: 	    B() then "B"
 //│ ╙──      	    ^
-//│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.84: 	if x
-//│ ╙──      	   ^
-//│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.84: 	if x
-//│ ╙──      	   ^
-//│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.84: 	if x
-//│ ╙──      	   ^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.84: 	if x
+//│ ║  l.69: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.84: 	if x
+//│ ║  l.69: 	if x
 //│ ╙──      	   ^
 //│ ╔══[ERROR] type identifier not found: A
-//│ ║  l.87: 	    A() then "A"
+//│ ║  l.72: 	    A() then "A"
 //│ ╙──      	    ^
 //│ 0 | error
 //│ Code generation encountered an error:
diff --git a/shared/src/test/diff/ucs/SplitOps.mls b/shared/src/test/diff/ucs/SplitOps.mls
index c1f34e291e..58a611e3ad 100644
--- a/shared/src/test/diff/ucs/SplitOps.mls
+++ b/shared/src/test/diff/ucs/SplitOps.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 abstract class Option[A]: Some[A] | None
 class Some[A](value: A) extends Option[A]
@@ -56,15 +56,6 @@ fun f(x) =
 //│ ╔══[ERROR] identifier `y` not found
 //│ ║  l.52: 	    is None() and y is None() then 0
 //│ ╙──      	                  ^
-//│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.51: 	    is Some(xv) and y is Some(yv) then xv + yv
-//│ ╙──      	                    ^
-//│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.51: 	    is Some(xv) and y is Some(yv) then xv + yv
-//│ ╙──      	                    ^
-//│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.52: 	    is None() and y is None() then 0
-//│ ╙──      	                  ^
 //│ ╔══[ERROR] identifier not found: y
 //│ ║  l.51: 	    is Some(xv) and y is Some(yv) then xv + yv
 //│ ╙──      	                    ^
@@ -93,10 +84,10 @@ fun f(a, b, c) =
   if a
     == 0 and b is B() and c is C() then 0
 //│ ╔══[ERROR] missing else branch
-//│ ║  l.94: 	    == 0 and b is B() and c is C() then 0
+//│ ║  l.85: 	    == 0 and b is B() and c is C() then 0
 //│ ╙──      	             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.94: 	    == 0 and b is B() and c is C() then 0
+//│ ║  l.85: 	    == 0 and b is B() and c is C() then 0
 //│ ║        	             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun f: (Num, B, C) -> 0
diff --git a/shared/src/test/diff/ucs/SplitScrutinee.mls b/shared/src/test/diff/ucs/SplitScrutinee.mls
index 0ecc291fe4..a5f217a656 100644
--- a/shared/src/test/diff/ucs/SplitScrutinee.mls
+++ b/shared/src/test/diff/ucs/SplitScrutinee.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 fun f(x) =
   if x +
diff --git a/shared/src/test/diff/ucs/ThenIndent.mls b/shared/src/test/diff/ucs/ThenIndent.mls
index 138c3f024b..91e3812e6b 100644
--- a/shared/src/test/diff/ucs/ThenIndent.mls
+++ b/shared/src/test/diff/ucs/ThenIndent.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 // FIXME
diff --git a/shared/src/test/diff/ucs/Tree.mls b/shared/src/test/diff/ucs/Tree.mls
index a36c74903f..2802614176 100644
--- a/shared/src/test/diff/ucs/Tree.mls
+++ b/shared/src/test/diff/ucs/Tree.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 type Option[out A] = Some[A] | None
 class Some[out A](value: A)
diff --git a/shared/src/test/diff/ucs/TrivialIf.mls b/shared/src/test/diff/ucs/TrivialIf.mls
index 1a34cf36d6..d4c83dc934 100644
--- a/shared/src/test/diff/ucs/TrivialIf.mls
+++ b/shared/src/test/diff/ucs/TrivialIf.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 :NoJS
 
 fun abs(x) = if x < 0 then 0 - x else x
diff --git a/shared/src/test/diff/ucs/WeirdIf.mls b/shared/src/test/diff/ucs/WeirdIf.mls
index a7fed4a00c..2c1c5c1f4e 100644
--- a/shared/src/test/diff/ucs/WeirdIf.mls
+++ b/shared/src/test/diff/ucs/WeirdIf.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 :w
 if
diff --git a/shared/src/test/diff/ucs/WeirdSplit.mls b/shared/src/test/diff/ucs/WeirdSplit.mls
index 259ec793bb..cca0a62c8c 100644
--- a/shared/src/test/diff/ucs/WeirdSplit.mls
+++ b/shared/src/test/diff/ucs/WeirdSplit.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 class A()
 class B()
diff --git a/shared/src/test/diff/ucs/Wildcard.mls b/shared/src/test/diff/ucs/Wildcard.mls
index ef826d9fd3..006b99bea7 100644
--- a/shared/src/test/diff/ucs/Wildcard.mls
+++ b/shared/src/test/diff/ucs/Wildcard.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 fun (++) strcat(a, b) = concat(a)(b)
 //│ fun (++) strcat: (Str, Str) -> Str
diff --git a/shared/src/test/diff/ucs/zipWith.mls b/shared/src/test/diff/ucs/zipWith.mls
index abc77baaae..b26e9e8ebe 100644
--- a/shared/src/test/diff/ucs/zipWith.mls
+++ b/shared/src/test/diff/ucs/zipWith.mls
@@ -1,4 +1,4 @@
-:PreTyper
+:NewDefs
 
 
 
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index ee15d5752a..e164c35225 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -150,7 +150,7 @@ class DiffTests
       explainErrors: Bool = false,
       dbg: Bool = false,
       dbgParsing: Bool = false,
-      dbgPreTyper: Opt[Set[Str]] = N,
+      dbgNuUCS: Opt[Set[Str]] = N,
       dbgSimplif: Bool = false,
       dbgUCS: Bool = false,
       fullExceptionStack: Bool = false,
@@ -189,7 +189,8 @@ class DiffTests
     var noRecursiveTypes = false
     var constrainedTypes = false
     var irregularTypes = false
-    var usePreTyper = false
+    // Enable this to see the errors from unfinished `PreTyper`.
+    var showPreTyperErrors = false
     
     // * This option makes some test cases pass which assume generalization should happen in arbitrary arguments
     // * but it's way too aggressive to be ON by default, as it leads to more extrusion, cycle errors, etc.
@@ -214,7 +215,7 @@ class DiffTests
           case "p" => mode.copy(showParse = true)
           case "d" => mode.copy(dbg = true)
           case "dp" => mode.copy(dbgParsing = true)
-          case PreTyperFlags(ts) => mode.copy(dbgPreTyper = mode.dbgPreTyper.fold(S(ts))(ts0 => S(ts0 ++ ts)))
+          case DebugUCSFlags(ts) => mode.copy(dbgNuUCS = mode.dbgNuUCS.fold(S(ts))(ts0 => S(ts0 ++ ts)))
           case "ds" => mode.copy(dbgSimplif = true)
           case "ducs" => mode.copy(dbg = true, dbgUCS = true)
           case "s" => mode.copy(fullExceptionStack = true)
@@ -259,9 +260,8 @@ class DiffTests
             // println("'"+line.drop(str.length + 2)+"'")
             typer.startingFuel = line.drop(str.length + 2).toInt; mode
           case "ResetFuel" => typer.startingFuel = typer.defaultStartingFuel; mode
-          // I believe `PreTyper` will become a part of new definition typing.
-          // So, this will be removed after `PreTyper` is done.
-          case "PreTyper" => newParser = true; newDefs = true; usePreTyper = true; mode
+          // Enable this to see the errors from unfinished `PreTyper`.
+          case "ShowPreTyperErrors" => newParser = true; newDefs = true; showPreTyperErrors = true; mode
           case "ne" => mode.copy(noExecution = true)
           case "ng" => mode.copy(noGeneration = true)
           case "js" => mode.copy(showGeneratedJS = true)
@@ -524,14 +524,15 @@ class DiffTests
             val (typeDefs, stmts, newDefsResults) = if (newDefs) {
               val vars: Map[Str, typer.SimpleType] = Map.empty
               val rootTypingUnit = TypingUnit(p.tops)
-              if (usePreTyper) {
-                val preTyper = new PreTyper(mode.dbgPreTyper) {
-                  override def emitString(str: String): Unit = output(str)
-                }
-                // This should be passed to code generation somehow.
-                preTyperScope = preTyper.process(rootTypingUnit, preTyperScope, "<root>")._1
-                report(preTyper.getDiagnostics)
+              val preTyper = new PreTyper {
+                override def debugTopicFilters = mode.dbgNuUCS
+                override def emitString(str: String): Unit = output(str)
               }
+              // This scope will be passed to typer and code generator after
+              // pretyper is completed.
+              preTyperScope = preTyper(rootTypingUnit, preTyperScope, "<root>")
+              report(preTyper.filterDiagnostics(_.source is Diagnostic.Desugaring))
+              if (showPreTyperErrors) report(preTyper.filterDiagnostics(_.source is Diagnostic.PreTyping))
               val tpd = typer.typeTypingUnit(rootTypingUnit, N)(ctx, raise, vars)
               
               def showTTU(ttu: typer.TypedTypingUnit, ind: Int): Unit = {
@@ -1134,7 +1135,7 @@ object DiffTests {
       // file.segments.toList.init.lastOption.contains("parser")
   }
 
-  object PreTyperFlags {
+  object DebugUCSFlags {
     private val pattern = "^ucs(?::\\s*([A-Za-z\\.-]+)(,\\s*[A-Za-z\\.-]+)*)?$".r
     def unapply(flags: Str): Opt[Set[Str]] =
       flags match {

From 5a1c3957ce6b0e31fe48fb8ce0b8feaee664e166 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 16 Jan 2024 18:25:15 +0800
Subject: [PATCH 072/147] Update test files in compiler sub-project

---
 compiler/shared/test/diff/mono.mls | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/shared/test/diff/mono.mls b/compiler/shared/test/diff/mono.mls
index e2c65fdc62..5719a27340 100644
--- a/compiler/shared/test/diff/mono.mls
+++ b/compiler/shared/test/diff/mono.mls
@@ -1,5 +1,5 @@
 
-:PreTyper
+:NewDefs
 
 :mono
 fun f(x: Int) = if not of x == 0 then 42 else 1337

From bab3fab54b676cdb32a7c28bc691536cc21ad40a Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 16 Jan 2024 18:27:09 +0800
Subject: [PATCH 073/147] Woo-hoo! Eject the old UCS desugarer

---
 shared/src/main/scala/mlscript/Typer.scala    |    6 +-
 .../scala/mlscript/pretyper/PreTyper.scala    |    4 +-
 .../ucs/{DesugarUCS.scala => Desugarer.scala} |   11 +-
 .../mlscript/ucs/DesugaringException.scala    |    8 -
 .../main/scala/mlscript/ucs/PartialTerm.scala |   65 -
 .../src/main/scala/mlscript/ucs/helpers.scala |   24 +-
 .../main/scala/mlscript/ucs/old/Clause.scala  |   78 --
 .../scala/mlscript/ucs/old/Conjunction.scala  |  128 --
 .../scala/mlscript/ucs/old/Desugarer.scala    | 1043 -----------------
 .../scala/mlscript/ucs/old/LetBinding.scala   |   46 -
 .../scala/mlscript/ucs/old/MutCaseOf.scala    |  590 ----------
 .../scala/mlscript/ucs/old/Scrutinee.scala    |   30 -
 .../main/scala/mlscript/ucs/old/helpers.scala |   47 -
 .../src/main/scala/mlscript/ucs/package.scala |   19 +-
 .../ucs/stages/CoverageChecking.scala         |    4 +-
 .../mlscript/ucs/stages/Desugaring.scala      |   18 +-
 .../mlscript/ucs/stages/Normalization.scala   |    4 +-
 .../mlscript/ucs/stages/PartialTerm.scala     |   48 +
 .../mlscript/ucs/stages/PostProcessing.scala  |    4 +-
 .../mlscript/ucs/stages/Transformation.scala  |    4 +-
 .../scala/mlscript/ucs/stages/package.scala   |   28 +-
 .../pretyper/ucs/coverage/SealedClasses.mls   |    4 +-
 .../diff/pretyper/ucs/examples/AVLTree.mls    |    2 +-
 .../pretyper/ucs/stages/Normalization.mls     |    2 +-
 .../pretyper/ucs/stages/PostProcessing.mls    |    8 +-
 shared/src/test/diff/ucs/Hygiene.mls          |    2 +-
 shared/src/test/diff/ucs/HygienicBindings.mls |    8 +-
 shared/src/test/diff/ucs/InterleavedLet.mls   |    2 +-
 shared/src/test/diff/ucs/Wildcard.mls         |    2 +-
 .../src/test/scala/mlscript/DiffTests.scala   |   14 +-
 30 files changed, 134 insertions(+), 2119 deletions(-)
 rename shared/src/main/scala/mlscript/ucs/{DesugarUCS.scala => Desugarer.scala} (97%)
 delete mode 100644 shared/src/main/scala/mlscript/ucs/DesugaringException.scala
 delete mode 100644 shared/src/main/scala/mlscript/ucs/PartialTerm.scala
 delete mode 100644 shared/src/main/scala/mlscript/ucs/old/Clause.scala
 delete mode 100644 shared/src/main/scala/mlscript/ucs/old/Conjunction.scala
 delete mode 100644 shared/src/main/scala/mlscript/ucs/old/Desugarer.scala
 delete mode 100644 shared/src/main/scala/mlscript/ucs/old/LetBinding.scala
 delete mode 100644 shared/src/main/scala/mlscript/ucs/old/MutCaseOf.scala
 delete mode 100644 shared/src/main/scala/mlscript/ucs/old/Scrutinee.scala
 delete mode 100644 shared/src/main/scala/mlscript/ucs/old/helpers.scala
 create mode 100644 shared/src/main/scala/mlscript/ucs/stages/PartialTerm.scala

diff --git a/shared/src/main/scala/mlscript/Typer.scala b/shared/src/main/scala/mlscript/Typer.scala
index da37ad1c7e..402d58c8d9 100644
--- a/shared/src/main/scala/mlscript/Typer.scala
+++ b/shared/src/main/scala/mlscript/Typer.scala
@@ -15,7 +15,7 @@ import mlscript.Message._
  *  In order to turn the resulting CompactType into a mlscript.Type, we use `expandCompactType`.
  */
 class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val newDefs: Bool)
-    extends mlscript.ucs.old.Desugarer with TypeSimplifier {
+    extends TypeDefs with TypeSimplifier {
   
   def funkyTuples: Bool = false
   def doFactorize: Bool = false
@@ -1269,9 +1269,7 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
       case elf: If =>
         elf.desugaredTerm match {
           case S(desugared) => typeTerm(desugared)
-          case N => try typeTerm(desugarIf(elf)) catch {
-            case e: ucs.DesugaringException => err(e.messages)
-          }
+          case N => err(msg"not desugared UCS term found", elf.toLoc)
         }
       case AdtMatchWith(cond, arms) =>
         println(s"typed condition term ${cond}")
diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index a835a1904f..072c57b97e 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -1,9 +1,9 @@
 package mlscript.pretyper
 
 import annotation.tailrec, collection.mutable.{Set => MutSet}, collection.immutable.SortedMap, util.chaining._
-import mlscript._, utils._, shorthands._, Diagnostic.PreTyping, Message.MessageContext, symbol._, ucs.DesugarUCS
+import mlscript._, utils._, shorthands._, Diagnostic.PreTyping, Message.MessageContext, symbol._, ucs.Desugarer
 
-class PreTyper extends Traceable with Diagnosable with DesugarUCS {
+class PreTyper extends Traceable with Diagnosable with Desugarer {
   import PreTyper._
 
   /** A shorthand function to raise errors without specifying the source. */
diff --git a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
similarity index 97%
rename from shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
rename to shared/src/main/scala/mlscript/ucs/Desugarer.scala
index 35ff3779ff..bbf4effb9a 100644
--- a/shared/src/main/scala/mlscript/ucs/DesugarUCS.scala
+++ b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
@@ -11,13 +11,12 @@ import syntax.core.{Branch, Split}
 
 /**
   * The main class of the UCS desugaring.
-  * TODO: Rename to `Desugarer` once the old desugarer is removed.
   */
-trait DesugarUCS extends Transformation
-                    with Desugaring
-                    with Normalization
-                    with PostProcessing 
-                    with CoverageChecking { self: PreTyper =>
+trait Desugarer extends Transformation
+                with Desugaring
+                with Normalization
+                with PostProcessing 
+                with CoverageChecking { self: PreTyper =>
 
   /** A shorthand function to raise _desugaring_ errors without specifying the source. */
   protected def raiseDesugaringError(messages: (Message -> Opt[Loc])*): Unit =
diff --git a/shared/src/main/scala/mlscript/ucs/DesugaringException.scala b/shared/src/main/scala/mlscript/ucs/DesugaringException.scala
deleted file mode 100644
index 1e99cdccea..0000000000
--- a/shared/src/main/scala/mlscript/ucs/DesugaringException.scala
+++ /dev/null
@@ -1,8 +0,0 @@
-package mlscript.ucs
-
-import mlscript.{Diagnostic, Loc, Message, Typer}
-import mlscript.utils.shorthands._
-
-class DesugaringException(val messages: Ls[Message -> Opt[Loc]]) extends Throwable {
-  def this(message: Message, location: Opt[Loc]) = this(message -> location :: Nil)
-}
diff --git a/shared/src/main/scala/mlscript/ucs/PartialTerm.scala b/shared/src/main/scala/mlscript/ucs/PartialTerm.scala
deleted file mode 100644
index 40a9767aec..0000000000
--- a/shared/src/main/scala/mlscript/ucs/PartialTerm.scala
+++ /dev/null
@@ -1,65 +0,0 @@
-package mlscript.ucs
-
-import mlscript._
-import mlscript.utils.shorthands._
-
-import helpers._
-import mlscript.ucs.PartialTerm.Empty
-import mlscript.ucs.PartialTerm.Total
-import mlscript.ucs.PartialTerm.Half
-
-class PartialTermError(term: PartialTerm, message: Str) extends Error(message)
-
-/**
-  * A `PartialTerm` represents a possibly incomplete term.
-  * We'd better precisely track detailed locations of each parts.
-  * 
-  * @param fragments fragment terms that used to build this `PartialTerm`.
-  */
-sealed abstract class PartialTerm {
-  val fragments: Ls[Term]
-  def addTerm(term: Term, newDefs: Bool): PartialTerm.Total
-  def addOp(op: Var): PartialTerm.Half
-  def addTermOp(term: Term, op: Var, newDefs: Bool): PartialTerm.Half =
-    this.addTerm(term, newDefs).addOp(op)
-  def addOpTerm(op: Var, term: Term, newDefs: Bool): PartialTerm.Total =
-    this.addOp(op).addTerm(term, newDefs)
-  def get: Term = this match {
-    case Empty => throw new PartialTermError(this, "expect a term but nothing was given")
-    case Total(term, fragments) => term
-    case Half(lhs, op, fragments) => throw new PartialTermError(this, "incomplete term")
-  }
-  override def toString(): String = this match {
-    case Empty => "<empty>"
-    case Total(term, fragments) => s"<total> $term"
-    case Half(lhs, op, fragments) => s"<half> $lhs $op"
-  }
-}
-
-object PartialTerm {
-  final case object Empty extends PartialTerm {
-    val fragments: Ls[Term] = Nil
-    def addTerm(term: Term, newDefs: Bool): Total = Total(term, term :: Nil)
-    def addOp(op: Var): Half =
-      throw new PartialTermError(this, s"expect a term but operator $op was given")
-  }
-
-  final case class Total(term: Term, fragments: Ls[Term]) extends PartialTerm {
-    def addTerm(term: Term, newDefs: Bool): Total =
-      throw new PartialTermError(this, s"expect an operator but term $term was given")
-    def addOp(op: Var): Half = Half(term, op, op :: fragments)
-  }
-
-  final case class Half(lhs: Term, op: Var, fragments: Ls[Term]) extends PartialTerm {
-    def addTerm(rhs: Term, newDefs: Bool): Total = {
-      val (realRhs, extraExprOpt) = separatePattern(rhs, newDefs)
-      val leftmost = mkBinOp(lhs, op, realRhs, newDefs)
-      extraExprOpt match {
-        case N            => Total(leftmost, fragments)
-        case S(extraExpr) => Total(mkBinOp(leftmost, Var("and"), extraExpr, newDefs), extraExpr :: fragments)
-      }
-    }
-    def addOp(op: Var): Half =
-      throw new PartialTermError(this, s"expect a term but operator $op was given")
-  }
-}
diff --git a/shared/src/main/scala/mlscript/ucs/helpers.scala b/shared/src/main/scala/mlscript/ucs/helpers.scala
index f8ed428b47..da9b302914 100644
--- a/shared/src/main/scala/mlscript/ucs/helpers.scala
+++ b/shared/src/main/scala/mlscript/ucs/helpers.scala
@@ -6,29 +6,7 @@ import mlscript._
 import mlscript.utils.shorthands._
 
 object helpers {
-  /**
-    * Make a tuple with only one element. For example,
-    * 
-    * ```scala
-    * mkMonuple(t) = Tup(N -> Fld(false, false, t) :: Nil)
-    * ```
-    *
-    * @param t the sole element
-    * @return a tuple term with the only element
-    */
-  def mkMonuple(t: Term): Tup = Tup(N -> Fld(FldFlags.empty, t) :: Nil)
-
-  /**
-    * Make a binary operation.
-    *
-    * @param lhs the left-hand side term
-    * @param op the operator
-    * @param rhs the right-hand side term
-    * @return something like `App(App(op, lhs), rhs)`
-    */
-  def mkBinOp(lhs: Term, op: Var, rhs: Term, newDefs: Bool): Term =
-    if (newDefs) App(op, PlainTup(lhs, rhs))
-    else App(App(op, mkMonuple(lhs)), mkMonuple(rhs))
+  import stages.mkBinOp
 
   /**
     * Split a term into two parts: the pattern and the extra test.
diff --git a/shared/src/main/scala/mlscript/ucs/old/Clause.scala b/shared/src/main/scala/mlscript/ucs/old/Clause.scala
deleted file mode 100644
index c9f6243a2c..0000000000
--- a/shared/src/main/scala/mlscript/ucs/old/Clause.scala
+++ /dev/null
@@ -1,78 +0,0 @@
-package mlscript.ucs.old
-
-import mlscript._
-import mlscript.utils._
-import mlscript.utils.shorthands._
-import scala.collection.mutable.Buffer
-
-/**
-  * A `Clause` represents a minimal unit of logical predicate in the UCS.
-  * There are three kinds of clauses: boolean test, class match, and tuple match.
-  */
-sealed abstract class Clause {
-  /**
-    * Local interleaved let bindings declared before this condition.
-    */
-  var bindings: Ls[LetBinding] = Nil
-
-  /**
-    * Locations of terms that build this `Clause`.
-    *
-    * @return
-    */
-  val locations: Ls[Loc]
-
-  protected final def bindingsToString: String =
-    if (bindings.isEmpty) "" else " with " + (bindings match {
-      case Nil => ""
-      case bindings => bindings.map(_.name.name).mkString("(", ", ", ")")
-    })
-}
-
-sealed abstract class MatchClause extends Clause {
-  val scrutinee: Scrutinee
-}
-
-object Clause {
-  final case class MatchLiteral(
-    override val scrutinee: Scrutinee,
-    literal: SimpleTerm
-  )(override val locations: Ls[Loc]) extends MatchClause {
-    override def toString: String = s"«$scrutinee is $literal" + bindingsToString
-  }
-
-  final case class MatchAny(override val scrutinee: Scrutinee)(override val locations: Ls[Loc]) extends MatchClause {
-    override def toString: String = s"«$scrutinee is any" + bindingsToString
-  }
-
-  final case class MatchClass(
-    override val scrutinee: Scrutinee,
-    className: Var,
-    fields: Ls[Str -> Var]
-  )(override val locations: Ls[Loc]) extends MatchClause {
-    override def toString: String = s"«$scrutinee is $className»" + bindingsToString
-  }
-
-  final case class MatchTuple(
-    scrutinee: Scrutinee,
-    arity: Int,
-    fields: Ls[Str -> Var]
-  )(override val locations: Ls[Loc]) extends Clause {
-    override def toString: String = s"«$scrutinee is Tuple#$arity»" + bindingsToString
-  }
-
-  final case class BooleanTest(test: Term)(
-    override val locations: Ls[Loc]
-  ) extends Clause {
-    override def toString: String = s"«$test»" + bindingsToString
-  }
-
-  /**
-    * @param isField whether this binding is extracting a class field
-    */
-  final case class Binding(name: Var, term: Term, isField: Bool)(
-    override val locations: Ls[Loc]
-  ) extends Clause {
-    override def toString: String = s"«$name = $term»" + bindingsToString
-  }
-}
diff --git a/shared/src/main/scala/mlscript/ucs/old/Conjunction.scala b/shared/src/main/scala/mlscript/ucs/old/Conjunction.scala
deleted file mode 100644
index 1cfbf1f6f3..0000000000
--- a/shared/src/main/scala/mlscript/ucs/old/Conjunction.scala
+++ /dev/null
@@ -1,128 +0,0 @@
-package mlscript.ucs.old
-
-import mlscript._, utils._, shorthands._
-import Clause._, helpers._
-import scala.collection.mutable.Buffer
-import scala.annotation.tailrec
-
-/**
-  * A `Conjunction` represents a list of `Clause`s.
-  */
-final case class Conjunction(clauses: Ls[Clause], trailingBindings: Ls[LetBinding]) {
-  override def toString: String =
-    clauses.mkString("", " and ", "") + {
-      (if (trailingBindings.isEmpty) "" else " ") +
-        (trailingBindings match {
-          case Nil => ""
-          case bindings => bindings.map(_.name.name).mkString("(", ", ", ")")
-        })
-    }
-
-  /**
-    * Concatenate two `Conjunction` together.
-    * 
-    * The trailing bindings of the first `Conjunction` will be added to the
-    * first `Clause` of the second `Conjunction`
-    *
-    * @param lhs the left hand side value
-    * @param rhs the right hand side value
-    * @return the sititched `Conjunction`
-    */
-  def +(rhs: Conjunction): Conjunction = {
-    val Conjunction(lhsClauses, lhsTailBindings) = this
-    val Conjunction(rhsClauses, rhsTailBindings) = rhs
-    rhsClauses match {
-      case Nil => Conjunction(lhsClauses, lhsTailBindings ::: rhsTailBindings)
-      case head :: _ =>
-        head.bindings = lhsTailBindings ::: head.bindings
-        Conjunction(lhsClauses ::: rhsClauses, rhsTailBindings)
-    }
-  }
-
-  /**
-    * This is a shorthand if you only have clauses.
-    *
-    * @param suffix the list of clauses to append to this conjunction
-    * @return a new conjunction with clauses from `this` and `suffix`
-    */
-  def +(suffix: Ls[Clause]): Conjunction = {
-    suffix match {
-      case Nil => this
-      case head :: _ =>
-        head.bindings = trailingBindings ::: head.bindings
-        Conjunction(clauses ::: suffix, Nil)
-    }
-  }
-
-  /**
-    * This is a shorthand if you only have one clause.
-    *
-    * @param last the list of clauses to append to this conjunction
-    * @return a new conjunction with clauses from `this` and `last`
-    */
-  def +(last: Clause): Conjunction = {
-    last.bindings = trailingBindings ::: last.bindings
-    Conjunction(clauses :+ last, Nil)
-  }
-
-  /**
-    * This is a shorthand if you only have the last binding.
-    *
-    * @param suffix the list of clauses to append to this conjunction
-    * @return a new conjunction with clauses from `this` and `suffix`
-    */
-  def +(lastBinding: LetBinding): Conjunction =
-    Conjunction(clauses, trailingBindings :+ lastBinding)
-
-  def findClauseMatches(expectedScrutinee: Scrutinee): Opt[(MatchClause, Conjunction)] = {
-    @tailrec
-    def rec(past: Ls[Clause], upcoming: Ls[Clause], firstAny: Opt[(Ls[Clause], MatchAny, Ls[Clause])]): Opt[(Ls[Clause], MatchClause, Ls[Clause])] = {
-      upcoming match {
-        case Nil => firstAny
-        case (head @ MatchLiteral(scrutinee, _)) :: tail =>
-          if (scrutinee === expectedScrutinee) {
-            S((past, head, tail))
-          } else {
-            rec(past :+ head, tail, firstAny)
-          }
-        case (head @ MatchClass(scrutinee, _, _)) :: tail =>
-          if (scrutinee === expectedScrutinee) {
-            S((past, head, tail))
-          } else {
-            rec(past :+ head, tail, firstAny)
-          }
-        case (head @ MatchAny(scrutinee)) :: tail =>
-          if (scrutinee === expectedScrutinee) {
-            rec(past, tail, firstAny.orElse(S((past, head, tail))))
-          } else {
-            rec(past :+ head, tail, firstAny)
-          }
-        case head :: tail =>
-          rec(past :+ head, tail, firstAny)
-      }
-    }
-
-    rec(Nil, clauses, None).map { case (past, wanted, remaining) =>
-      (wanted, Conjunction(past ::: remaining, trailingBindings))
-    }
-  }
-
-  /**
-    * Prepend bindings to the first condition of this conjunction.
-    *
-    * @param interleavedLets the buffer of let bindings in the current context
-    * @return idential to `conditions`
-    */
-  def withBindings(implicit interleavedLets: Buffer[LetBinding]): Conjunction = {
-    clauses match {
-      case Nil => Conjunction(Nil, interleavedLets.toList ::: trailingBindings)
-      case head :: _ =>
-        head.bindings = head.bindings ::: interleavedLets.toList
-        this
-    }
-  }
-}
-
-object Conjunction {
-  def empty: Conjunction = Conjunction(Nil, Nil)
-}
diff --git a/shared/src/main/scala/mlscript/ucs/old/Desugarer.scala b/shared/src/main/scala/mlscript/ucs/old/Desugarer.scala
deleted file mode 100644
index 92b18dd3fd..0000000000
--- a/shared/src/main/scala/mlscript/ucs/old/Desugarer.scala
+++ /dev/null
@@ -1,1043 +0,0 @@
-package mlscript.ucs.old
-
-import scala.collection.mutable.{Map => MutMap, HashMap}
-import scala.collection.mutable.Buffer
-
-import mlscript._, utils._, shorthands._
-import mlscript.ucs.{DesugaringException, PartialTerm}
-import mlscript.ucs.helpers._, helpers._
-import Message.MessageContext
-import MutCaseOf.MutCase.Constructor
-import scala.collection.mutable.ListBuffer
-
-/**
-  * This class contains main desugaring methods.
-  */
-class Desugarer extends TypeDefs { self: Typer =>
-  var dbgUCS: Bool = false
-  private def printlnUCS(msg: => Any): Unit = if (dbgUCS) println(msg)
-  private def traceUCS[T](pre: => String)(thunk: => T)(post: T => String = noPostTrace) =
-    if (dbgUCS) trace(pre)(thunk)(post) else thunk
-
-  import Desugarer.{ExhaustivenessMap, SubClassMap, SuperClassMap}
-  import Clause.{MatchClass, MatchTuple, BooleanTest}
-
-  type FieldAliasMap = MutMap[SimpleTerm, MutMap[Str, Var]]
-
-  private var idLength: Int = 0
-
-  private def makeName: String = {
-    val name = s"tmp$idLength"
-    idLength += 1
-    name
-  }
-
-  private def freshName(implicit ctx: Ctx): String = {
-    var res = makeName
-    while (ctx.env.contains(res)) {
-      res = makeName
-    }
-    res
-  }
-
-  private type MutExhaustivenessMap = MutMap[Str \/ Int, MutMap[Either[Int, SimpleTerm], Buffer[Loc]]]
-
-  private def addToExhaustivenessMap(scrutinee: Scrutinee, loc: Iterable[Loc])
-      (implicit ctx: Ctx, raise: Raise, map: MutExhaustivenessMap) = {
-    map.getOrElseUpdate(getScurtineeKey(scrutinee), MutMap.empty)
-  }
-
-  private def addToExhaustivenessMap(scrutinee: Scrutinee, tupleArity: Int, loc: Iterable[Loc])
-      (implicit ctx: Ctx, raise: Raise, map: MutExhaustivenessMap) = {
-    map.getOrElseUpdate(getScurtineeKey(scrutinee), MutMap.empty)
-      .getOrElseUpdate(L(tupleArity), Buffer.empty) ++= loc
-  }
-  private def addToExhaustivenessMap(scrutinee: Scrutinee, litOrCls: SimpleTerm, loc: Iterable[Loc])
-      (implicit ctx: Ctx, raise: Raise, map: MutExhaustivenessMap) = {
-    map.getOrElseUpdate(getScurtineeKey(scrutinee), MutMap.empty)
-      .getOrElseUpdate(R(litOrCls), Buffer.empty) ++= loc
-  }
-
-  /**
-    * 
-    *
-    * @param scrutinee the scrutinee of the pattern matching
-    * @param params parameters provided by the 
-    * @param positionals the corresponding field names of each parameter
-    * @param aliasMap a map used to cache each the alias of each field
-    * @param matchRootLoc the location to the root of the match
-    * @return two mappings: one is (variable -> sub-pattern), the other is (positional name -> variable)
-    */
-  private def desugarPositionals
-    (scrutinee: Scrutinee, params: IterableOnce[Term], positionals: Ls[Str])
-    (implicit ctx: Ctx, aliasMap: FieldAliasMap): (Ls[Var -> Term], Ls[Str -> Var]) = {
-    val subPatterns = Buffer.empty[(Var, Term)]
-    val bindings = params.iterator.zip(positionals).flatMap {
-      // `x is A(_)`: ignore this binding
-      case (Var("_"), fieldName) => S(fieldName -> Var("_"))
-      // `x is A(value)`: generate bindings directly
-      case (nameVar @ Var(n), fieldName) if (n.headOption.exists(_.isLower)) =>
-        S(fieldName -> nameVar)
-      // `x is B(A(x))`: generate a temporary name
-      // use the name in the binding, and destruct sub-patterns
-      case (pattern: Term, fieldName) =>
-        // We should always use the same temporary for the same `fieldName`.
-        // This uniqueness is decided by (scrutinee, fieldName).
-        val alias = aliasMap
-          .getOrElseUpdate(scrutinee.reference, MutMap.empty)
-          .getOrElseUpdate(fieldName, Var(freshName).desugaredFrom(pattern))
-        subPatterns += ((alias, pattern))
-        S(fieldName -> alias)
-    }.toList
-    (subPatterns.toList, bindings)
-  }
-
-  /**
-    * Desugar sub-patterns from fields to conditions.
-    *
-    * @param subPatterns a list of field name -> pattern term
-    * @param ctx the typing context
-    * @param aliasMap the field alias map
-    * @return desugared conditions representing the sub-patterns
-    */
-  private def destructSubPatterns(scrutinee: Scrutinee, subPatterns: Iterable[Var -> Term])
-      (implicit ctx: Ctx, raise: Raise, exhaustivenessMap: MutExhaustivenessMap, aliasMap: FieldAliasMap): Ls[Clause] = {
-    subPatterns.iterator.flatMap[Clause] { case (subScrutinee, subPattern) =>
-      destructPattern(makeScrutinee(subScrutinee, scrutinee.matchRootLoc), subPattern, false)
-    }.toList
-  }
-
-  // `IdentityHashMap` is a workaround.
-  private val localizedScrutineeMap = new java.util.IdentityHashMap[Term, Var]
-
-  /**
-    * Create a `Scrutinee`. If the `term` is a simple expression (e.g. `Var` or
-    * `Lit`), we do not create a local alias. Otherwise, we create a local alias
-    * to avoid unnecessary computations.
-    *
-    * @param term the term in the local scrutinee position
-    * @param matchRootLoc the caller is expect to be in a match environment,
-    * this parameter indicates the location of the match root
-    */
-  private def makeScrutinee(term: Term, matchRootLoc: Opt[Loc])(implicit ctx: Ctx): Scrutinee =
-    traceUCS(s"Making a scrutinee for `$term`") {
-      term match {
-        case _: Var =>
-          printlnUCS(s"The scrutinee does not need an alias.")
-          Scrutinee(N, term)(matchRootLoc)
-        case _ =>
-          val localizedName = makeLocalizedName(term)
-          printlnUCS(s"The scrutinee needs an alias: $localizedName")
-          Scrutinee(S(localizedName), term)(matchRootLoc)
-      }
-    }()
-
-  /**
-    * Create a fresh name for scrutinee to be localized.
-    *
-    * @param scrutinee the term of the scrutinee
-    * @param ctx the context
-    * @return the fresh name, as `Var`
-    */
-  private def makeLocalizedName(scrutinee: Term)(implicit ctx: Ctx): Var = 
-    if (localizedScrutineeMap.containsKey(scrutinee)) {
-      localizedScrutineeMap.get(scrutinee)
-    } else {
-      val v = Var(freshName).desugaredFrom(scrutinee)
-      localizedScrutineeMap.put(scrutinee, v)
-      v
-    }
-
-  /**
-    * Destruct nested patterns to a list of simple condition with bindings.
-    *
-    * @param scrutinee the scrutinee of the pattern matching
-    * @param pattern the pattern we will destruct
-    * @param isTopLevel whether this pattern just follows the `is` operator
-    * @param raise the `Raise` function
-    * @param aliasMap the field alias map
-    * @param matchRootLoc the location of the root of the pattern matching
-    * @param fragments fragment term that used to construct the given pattern.
-    *   It is used to tracking locations.
-    * @return a list of simple condition with bindings. This method does not
-    * return `ConjunctedCondition` because conditions built from nested patterns
-    * do not contain interleaved let bindings.
-    */
-  private def destructPattern
-      (scrutinee: Scrutinee, pattern: Term, isTopLevel: Bool)
-      (implicit ctx: Ctx,
-                raise: Raise,
-                exhaustivenessMap: MutExhaustivenessMap,
-                aliasMap: FieldAliasMap,
-                fragments: Ls[Term] = Nil): Ls[Clause] =
-  trace(s"[Desugarer.destructPattern] scrutinee = ${scrutinee.term}; pattern = $pattern") {
-    // This piece of code is use in two match cases.
-    def desugarTuplePattern(tuple: Tup): Ls[Clause] = {
-      val (subPatterns, bindings) = desugarPositionals(
-        scrutinee,
-        tuple.fields.iterator.map(_._2.value),
-        1.to(tuple.fields.length).map("_" + _).toList
-      )
-      addToExhaustivenessMap(scrutinee, tuple.fields.length, tuple.toLoc)
-      Clause.MatchTuple(
-        scrutinee,
-        tuple.fields.length,
-        bindings
-      )(collectLocations(scrutinee.term)) :: destructSubPatterns(scrutinee, subPatterns)
-    }
-    pattern match {
-      // This case handles top-level wildcard `Var`.
-      // We don't make any conditions in this level.
-      case wildcard @ Var("_") if isTopLevel =>
-        addToExhaustivenessMap(scrutinee, wildcard.toLoc)
-        Clause.MatchAny(scrutinee)(wildcard.toLoc.toList) :: Nil
-      // If it's not top-level, wildcard means we don't care.
-      case Var("_") => Nil
-      // This case handles literals.
-      // x is true | x is false | x is 0 | x is "text" | ...
-      case literal: Var if literal.name === "true" || literal.name === "false" =>
-        addToExhaustivenessMap(scrutinee, literal, literal.toLoc)
-        val clause = Clause.MatchLiteral(scrutinee, literal)(scrutinee.term.toLoc.toList ::: literal.toLoc.toList)
-        clause.bindings = scrutinee.asBinding.toList
-        printlnUCS(s"Add bindings to the clause: ${scrutinee.asBinding}")
-        clause :: Nil
-      case literal: Lit =>
-        addToExhaustivenessMap(scrutinee, literal, literal.toLoc)
-        val clause = Clause.MatchLiteral(scrutinee, literal)(scrutinee.term.toLoc.toList ::: literal.toLoc.toList)
-        clause.bindings = scrutinee.asBinding.toList
-        printlnUCS(s"Add bindings to the clause: ${scrutinee.asBinding}")
-        clause :: Nil
-      // This case handles name binding.
-      // x is a
-      case bindingVar @ Var(bindingName) if bindingName.headOption.exists(_.isLower) =>
-        val locations = scrutinee.term.toLoc.toList ::: bindingVar.toLoc.toList
-        if (isTopLevel) {
-          // If the binding name is at the top-level. We create decision path like
-          // ... /\ x is any /\ a = x /\ ...
-          addToExhaustivenessMap(scrutinee, bindingVar.toLoc)
-          Clause.MatchAny(scrutinee)(locations) ::
-            Clause.Binding(bindingVar, scrutinee.reference, !isTopLevel)(locations) ::
-            Nil
-        } else {
-          // Otherwise, we just create the binding.
-          Clause.Binding(bindingVar, scrutinee.term, !isTopLevel)(locations) :: Nil
-        }
-      // This case handles simple class tests.
-      // x is A
-      case classNameVar @ Var(className) =>
-        ctx.tyDefs.get(className).orElse(ctx.get(className)) match {
-          case S(ti: LazyTypeInfo) if (ti.kind is Cls) || (ti.kind is Mod) =>
-          case S(ti: LazyTypeInfo) if (ti.kind is Trt) => throw new DesugaringException({
-            msg"Cannot match on trait `$className`"
-          }, classNameVar.toLoc)
-          case S(_: TypeDef) =>
-          case _ => throw new DesugaringException({
-            msg"Cannot find constructor `$className` in scope"
-          }, classNameVar.toLoc)
-        }
-        printlnUCS(s"Build a Clause.MatchClass from $scrutinee where pattern is $classNameVar")
-        addToExhaustivenessMap(scrutinee, classNameVar, classNameVar.toLoc)
-        Clause.MatchClass(scrutinee, classNameVar, Nil)(collectLocations(scrutinee.term)) :: Nil
-      // This case handles classes with destruction.
-      // x is A(r, s, t)
-      case app @ App(classNameVar @ Var(className), Tup(args)) =>
-        ctx.tyDefs.get(className).map(td => (td.kind, td.positionals))
-            .orElse(ctx.get(className) match {
-              case S(ti: DelayedTypeInfo) if ti.decl.kind is Cls =>
-                S((ti.decl.kind, ti.typedParams.getOrElse(Nil).map(_._1.name))) // * Error should be caught before if this doesn't take params
-              case S(CompletedTypeInfo(td: TypedNuCls)) =>
-                S((td.decl.kind, td.params.getOrElse(Nil).map(_._1.name))) // * Error should be caught before if this doesn't take params
-              case _ => throw new DesugaringException(msg"Illegal pattern `$className`", classNameVar.toLoc)
-            }) match {
-          case N =>
-            throw new DesugaringException({
-              msg"Cannot find class `$className` in scope"
-            }, classNameVar.toLoc)
-          case S((kind, positionals)) =>
-            if (args.length === positionals.length) {
-              val (subPatterns, bindings) = desugarPositionals(
-                scrutinee,
-                args.iterator.map(_._2.value),
-                positionals
-              )
-              addToExhaustivenessMap(scrutinee, classNameVar, app.toLoc)
-              val clause = Clause.MatchClass(scrutinee, classNameVar, bindings)(pattern.toLoc.toList ::: collectLocations(scrutinee.term))
-              printlnUCS(s"Build a Clause.MatchClass from $scrutinee where pattern is $pattern")
-              printlnUCS(s"Fragments: $fragments")
-              printlnUCS(s"The locations of the clause: ${clause.locations}")
-              clause :: destructSubPatterns(scrutinee, subPatterns)
-            } else {
-              throw new DesugaringException({
-                val expected = positionals.length
-                val actual = args.length
-                msg"${kind.str} $className expects ${
-                  "parameter".pluralize(expected, true)
-                } but found ${
-                  "parameter".pluralize(args.length, true)
-                }"
-              }, app.toLoc)
-            }
-        }
-      // This case handles operator-like constructors.
-      // x is head :: Nil
-      case app @ App(
-        App(
-          opVar @ Var(op),
-          Tup((_ -> Fld(_, lhs)) :: Nil)
-        ),
-        Tup((_ -> Fld(_, rhs)) :: Nil)
-      ) =>
-        ctx.tyDefs.get(op) match {
-          case N =>
-            throw new DesugaringException({
-              msg"Cannot find operator `$op` in the context"
-            }, opVar.toLoc)
-          case S(td) if td.positionals.length === 2 =>
-            val (subPatterns, fields) = desugarPositionals(
-              scrutinee,
-              lhs :: rhs :: Nil,
-              td.positionals
-            )
-            addToExhaustivenessMap(scrutinee, opVar, app.toLoc)
-            val clause = Clause.MatchClass(scrutinee, opVar, fields)(collectLocations(scrutinee.term))
-            printlnUCS(s"Build a Clause.MatchClass from $scrutinee where operator is $opVar")
-            clause :: destructSubPatterns(scrutinee, subPatterns)
-          case S(td) =>
-            val num = td.positionals.length
-            throw new DesugaringException({
-              val expected = td.positionals.length
-              msg"${td.kind.str} `$op` expects ${
-                "parameter".pluralize(expected, true)
-              } but found two parameters"
-            }, app.toLoc)
-        }
-      // This case handles **direct** tuple destructions.
-      // x is (a, b, c)
-      case Bra(_, tuple: Tup) => desugarTuplePattern(tuple)
-      // This case handles **nested** tuple destructions.
-      // x is Cons((x, y), Nil)
-      case tuple: Tup => desugarTuplePattern(tuple)
-      // What else?
-      case _ => throw new DesugaringException(msg"illegal pattern", pattern.toLoc)
-    }
-  }("[Desugarer.destructPattern] Result: " + _.mkString(", "))
-
-  /**
-    * Collect `Loc`s from a synthetic term.
-    *
-    * @param term the root of the synthetic term
-    * @param fragments the fragment terms
-    * @return all original locations
-    */
-  private def collectLocations(term: Term)(implicit fragments: Ls[Term]): Ls[Loc] = {
-    val locations = Buffer.empty[Loc]
-    def rec(term: Term): Unit = term.children.foreach { located =>
-      if (fragments.contains(located)) locations ++= located.toLoc
-    }
-    locations.toList
-  }
-
-  private def unfoldNestedIf(elf: If, acc: Ls[IfBody] = Nil): (IfBody, Opt[Term]) =
-    traceUCS("[unfoldNestedIf]") {
-      elf.els match {
-        case S(innerElf: If) => unfoldNestedIf(innerElf, elf.body :: acc)
-        case default if acc.isEmpty => (elf.body, default)
-        case default =>
-          val lines = (elf.body :: acc).reverseIterator.flatMap {
-            case IfBlock(subLines) => subLines
-            case other => Iterable.single(L(other))
-          }.toList
-          (IfBlock(lines), default)
-      }
-    }(r => s"[unfoldNestedIf] (${r._1.getClass().getSimpleName()}, ${r._2})")
-
-  /**
-    * The entry point of UCS desugarer.
-    *
-    * @param elf the root `If` term
-    * @param ctx the typing context
-    * @param raise the function to raise errors
-    * @return the desugared term
-    */
-  def desugarIf(elf: If)(implicit ctx: Ctx, raise: Raise): Term = traceUCS("[desugarIf]") {
-    raise(WarningReport(msg"old desugarer used" -> elf.toLoc :: Nil, false))
-    val superClassMap = getClassHierarchy()
-    Desugarer.printGraph(superClassMap, printlnUCS, "Super-class map", "<:")
-    val subClassMap = Desugarer.reverseGraph(superClassMap)
-    Desugarer.printGraph(subClassMap, printlnUCS, "Sub-class map", ":>")
-    val (body, els) = unfoldNestedIf(elf)
-    val exhaustivenessMap: MutExhaustivenessMap = MutMap.empty
-    printlnUCS("### Desugar the UCS to decision paths ###")
-    val paths = desugarIf(body, els)(ctx, raise, exhaustivenessMap)
-    printlnUCS("Exhaustiveness map")
-    if (exhaustivenessMap.isEmpty)
-      printlnUCS("  * <No entries>")
-    else
-      exhaustivenessMap.foreachEntry { (symbol, patternMap) =>
-        printlnUCS(s"  * Patterns of $symbol")
-        if (patternMap.isEmpty)
-          printlnUCS(s"    + <No patterns>")
-        else
-          patternMap.foreachEntry { (pattern, locations) =>
-            val first = pattern match {
-              case Left(tupleArity) => s"()^$tupleArity"
-              case Right(litOrCls) => litOrCls.showDbg
-            }
-            val second = locations.mkString("[", ", ", "]")
-            printlnUCS(s"    + $first -> $second")
-          }
-      }
-    printlnUCS("### Build a case tree from decision paths ###")
-    val imExhaustivenessMap = Map.from(exhaustivenessMap.iterator.map { case (k, m) => k -> Map.from(m) })
-    val caseTree = buildCaseTree(paths)(raise, getScurtineeKey, imExhaustivenessMap, superClassMap)
-    printlnUCS("### Checking exhaustiveness of the case tree ###")
-    checkExhaustive(caseTree, N)(ctx, raise, imExhaustivenessMap, subClassMap)
-    printlnUCS("### Construct a term from the case tree ###")
-    val desugared = constructTerm(caseTree)
-    println(s"Desugared term: ${desugared.print(false)}")
-    elf.desugaredTerm = S(desugared)
-    desugared
-  }()
-
-
-  private def desugarIf
-      (body: IfBody, fallback: Opt[Term])
-      (implicit ctx: Ctx, raise: Raise, exhaustivenessMap: MutExhaustivenessMap)
-  : Ls[Conjunction -> Term] = traceUCS(s"[desugarIf] with fallback $fallback") {
-    // We allocate temporary variable names for nested patterns.
-    // This prevents aliasing problems.
-    implicit val scrutineeFieldAliasMap: FieldAliasMap = MutMap.empty
-    // A list of flattened if-branches.
-    val branches = Buffer.empty[Conjunction -> Term]
-
-    /**
-      * Translate a list of atomic UCS conditions.
-      * What is atomic? No "and".
-      *
-      * @param ts a list of atomic UCS conditions
-      * @return a list of `Condition`
-      */
-    def desugarConditions(ts: Ls[Term])(implicit fragments: Ls[Term] = Nil): Ls[Clause] =
-      ts.flatMap {
-        case isApp @ App(
-          App(Var("is"),
-              Tup(_ -> Fld(_, scrutinee) :: Nil)),
-          Tup(_ -> Fld(_, pattern) :: Nil)
-        ) if !newDefs => // * Old-style operators
-          // This is an inline `x is Class` match test.
-          val inlineMatchLoc = isApp.toLoc
-          val inlineScrutinee = makeScrutinee(scrutinee, inlineMatchLoc)
-          destructPattern(inlineScrutinee, pattern, true)(ctx, raise, exhaustivenessMap, scrutineeFieldAliasMap)
-        case isApp @ App(Var("is"), PlainTup(scrutinee, pattern)) =>
-          // This is an inline `x is Class` match test.
-          val inlineMatchLoc = isApp.toLoc
-          val inlineScrutinee = makeScrutinee(scrutinee, inlineMatchLoc)
-          destructPattern(inlineScrutinee, pattern, true)(ctx, raise, exhaustivenessMap, scrutineeFieldAliasMap)
-        case test =>
-          val clause = Clause.BooleanTest(test)(collectLocations(test))
-          Iterable.single(clause)
-      }
-
-    /**
-      * Recursively desugar a pattern matching branch.
-      *
-      * @param scrutinee the scrutinee of this pattern matching
-      * @param body one element of `lines` of the `IfBlock`
-      * @param pat the accumulated pattern, since patterns can be split
-      * @param acc the accumulated conditions so far
-      * @param ctx the typing context
-      * @param interleavedLets interleaved let bindings before this branch
-      * @param rootLoc the location of the `IfOpApp`
-      */
-    def desugarMatchBranch(
-      scrutinee: Scrutinee,
-      body: IfBody \/ Statement,
-      partialPattern: PartialTerm,
-      collectedConditions: Conjunction,
-    )(implicit interleavedLets: Buffer[LetBinding]): Unit = traceUCS[Unit]("[desugarMatchBranch]") {
-      body match {
-        // This case handles default branches. For example,
-        // if x is
-        //   A(...) then ...
-        //   else ...
-        case L(els @ IfElse(consequent)) =>
-          // Because this pattern matching is incomplete, it's not included in
-          // `acc`. This means that we discard this incomplete pattern matching.
-          // branches += (collectedConditions + Clause.MatchNot(scrutinee)(els.toLoc.toList) -> consequent)
-          branches += (collectedConditions -> consequent)
-        // This case handles default branches indicated by wildcards.
-        // if x is
-        //   A(...) then ...
-        //   _      then ...
-        case L(IfThen(wildcard @ Var("_"), consequent)) =>
-          // branches += (collectedConditions + Clause.MatchNot(scrutinee)(wildcard.toLoc.toList) -> consequent)
-          branches += (collectedConditions -> consequent)
-        // if x is
-        //   A(...) then ...         // Case 1: no conjunctions
-        //   B(...) and ... then ... // Case 2: more conjunctions
-        case L(IfThen(patTest, consequent)) =>
-          val (patternPart, extraTestOpt) = separatePattern(patTest, newDefs)
-          val clauses = destructPattern(scrutinee, partialPattern.addTerm(patternPart, newDefs).term, true)
-          val conditions = collectedConditions + Conjunction(clauses, Nil).withBindings
-          printlnUCS(s"Result: " + conditions.clauses.mkString(", "))
-          extraTestOpt match {
-            // Case 1. Just a pattern. Easy!
-            case N => 
-              branches += (conditions -> consequent)
-            // Case 2. A pattern and an extra test
-            case S(extraTest) =>
-              desugarIfBody(IfThen(extraTest, consequent), PartialTerm.Empty, conditions)
-          }
-        // if x is
-        //   A(...) and t <> // => IfOpApp(A(...), "and", IfOpApp(...))
-        //     a then ...
-        //     b then ...
-        //   A(...) and y is // => IfOpApp(A(...), "and", IfOpApp(...))
-        //     B(...) then ...
-        //     B(...) then ...
-        case L(IfOpApp(patLhs, Var("and"), consequent)) =>
-          val (pattern, optTests) = separatePattern(patLhs, newDefs)
-          val patternConditions = destructPattern(scrutinee, pattern, true)
-          val tailTestConditions = optTests.fold(Nil: Ls[Clause])(x => desugarConditions(splitAnd(x)))
-          val conditions =
-            collectedConditions + Conjunction(patternConditions ::: tailTestConditions, Nil).withBindings
-          desugarIfBody(consequent, PartialTerm.Empty, conditions)
-        case L(IfOpApp(patLhs, op, consequent)) =>
-          separatePattern(patLhs, newDefs) match {
-            // Case 1.
-            // The pattern is completed. There is also a conjunction.
-            // So, we need to separate the pattern from remaining parts.
-            case (pattern, S(extraTests)) =>
-              val patternConditions = destructPattern(scrutinee, pattern, true)
-              val extraConditions = desugarConditions(splitAnd(extraTests))
-              val conditions = 
-                collectedConditions + Conjunction(patternConditions ::: extraConditions, Nil).withBindings
-              desugarIfBody(consequent, PartialTerm.Empty, conditions)
-            // Case 2.
-            // The pattern is incomplete. Remaining parts are at next lines.
-            // if x is
-            //   head ::
-            //     Nil then ...  // do something with head
-            //     tail then ... // do something with head and tail
-            case (patternPart, N) =>
-              desugarMatchBranch(scrutinee, L(consequent), partialPattern.addTermOp(patternPart, op, newDefs), collectedConditions)
-          }
-        case L(IfOpsApp(patLhs, opsRhss)) =>
-          separatePattern(patLhs, newDefs) match {
-            case (patternPart, N) =>
-              val partialPattern2 = partialPattern.addTerm(patternPart, newDefs)
-              opsRhss.foreach { case op -> consequent =>
-                desugarMatchBranch(scrutinee, L(consequent), partialPattern2.addOp(op), collectedConditions)
-              }
-            case (patternPart, S(extraTests)) =>
-              val patternConditions = destructPattern(scrutinee, partialPattern.addTerm(patternPart, newDefs).term, true)
-              val testTerms = splitAnd(extraTests)
-              val middleConditions = desugarConditions(testTerms.init)
-              val conditions =
-                collectedConditions + Conjunction(patternConditions ::: middleConditions, Nil).withBindings
-              opsRhss.foreach { case op -> consequent =>
-                // TODO: Use lastOption
-                val last = testTerms.last
-                val partialTerm = PartialTerm.Total(last, last :: Nil)
-                desugarIfBody(consequent, partialTerm, conditions)
-              }
-          }
-        // This case usually happens with pattern split by linefeed.
-        case L(IfBlock(lines)) =>
-          lines.foreach { desugarMatchBranch(scrutinee, _, partialPattern, collectedConditions) }
-        // This case is rare. Let's put it aside.
-        case L(IfLet(_, _, _, _)) =>
-          TODO("please add this rare case to test files")
-        // This case handles interleaved lets.
-        case R(NuFunDef(S(isRec), nameVar, _, _, L(term))) =>
-          interleavedLets += (LetBinding(LetBinding.Kind.InterleavedLet, isRec, nameVar, term))
-        // Other statements are considered to be ill-formed.
-        case R(statement) => throw new DesugaringException({
-          msg"Illegal interleaved statement ${statement.toString}"
-        }, statement.toLoc)
-      }
-    }(_ => "[desugarMatchBranch]")
-
-    def desugarIfBody
-      (body: IfBody, expr: PartialTerm, acc: Conjunction)
-      (implicit interleavedLets: Buffer[LetBinding])
-    : Unit = traceUCS[Unit]("[desugarIfBody]") {
-      body match {
-        case IfOpsApp(exprPart, opsRhss) =>
-          val exprStart = expr.addTerm(exprPart, newDefs)
-          opsRhss.foreach { case opVar -> contBody =>
-            desugarIfBody(contBody, exprStart.addOp(opVar), acc)
-          }
-        case IfThen(Var("_"), consequent) =>
-          branches += (acc -> consequent)
-        // The termination case.
-        case IfThen(term, consequent) =>
-          val totalTerm = expr.addTerm(term, newDefs)
-          // “Atomic” means terms that do not contain `and`.
-          val atomicTerms = splitAnd(totalTerm.term)
-          val fragments = atomicTerms ::: totalTerm.fragments
-          val newClauses = desugarConditions(atomicTerms)(fragments)
-          branches += ((acc + newClauses).withBindings -> consequent)
-        // This is the entrance of the Simple UCS.
-        case IfOpApp(scrutineePart, isVar @ Var("is"), IfBlock(lines)) =>
-          // Create a synthetic scrutinee term by combining accumulated partial
-          // term with the new part.
-          val scrutineeTerm = expr.addTerm(scrutineePart, newDefs).term
-          // We don't need to include the entire `IfOpApp` because it might be
-          // very long... Indicating the beginning of the match is enough.
-          val matchRootLoc = (scrutineeTerm.toLoc, isVar.toLoc) match {
-            case (S(first), S(second)) => S(first ++ second)
-            case (_, _)                => N
-          }
-          val scrutinee = makeScrutinee(scrutineeTerm, matchRootLoc)
-          // If there is an alias, we should add the let bindings to clauses.
-          val conjunction = scrutinee.local match {
-            case S(alias) => acc
-            case N        => acc
-          }
-          // We need to make a snapshot because the sub-branches mutate the buffer.
-          // But these changes should not affect sibling branches.
-          val interleavedLetsSnapshot = interleavedLets.clone()
-          // Iterate each match case.
-          lines.foreach {
-            desugarMatchBranch(scrutinee, _, PartialTerm.Empty, conjunction)(interleavedLetsSnapshot)
-          }
-        // For example: "if x == 0 and y is \n ..."
-        case IfOpApp(testPart, Var("and"), consequent) =>
-          val conditions = acc + (desugarConditions(expr.addTerm(testPart, newDefs).term :: Nil))
-          desugarIfBody(consequent, PartialTerm.Empty, conditions)
-        // Otherwise, this is not a pattern matching.
-        // We create a partial term from `lhs` and `op` and dive deeper.
-        case IfOpApp(lhs, op, body) =>
-          desugarIfBody(body, expr.addTermOp(lhs, op, newDefs), acc)
-        // This case is rare. Let's put it aside.
-        case IfLet(isRec, name, rhs, body) =>
-          TODO("please add this rare case to test files")
-        // In this case, the accumulated partial term is discarded.
-        // We create a branch directly from accumulated conditions.
-        case IfElse(term) => branches += (acc.withBindings -> term)
-        case IfBlock(lines) =>
-          lines.foreach {
-            case L(subBody) => desugarIfBody(subBody, expr, acc)
-            case R(NuFunDef(S(isRec), nameVar, _, _, L(term))) =>
-              printlnUCS(s"Found interleaved binding ${nameVar.name}")
-              interleavedLets += LetBinding(LetBinding.Kind.InterleavedLet, isRec, nameVar, term)
-            case R(_) =>
-              throw new Error("unexpected statements at desugarIfBody")
-          }
-      }
-    }(_ => "[desugarIfBody]")
-
-    // Top-level interleaved let bindings.
-    val interleavedLets = Buffer.empty[LetBinding]
-    desugarIfBody(body, PartialTerm.Empty, Conjunction.empty)(interleavedLets)
-    // Add the fallback case to conjunctions if there is any.
-    fallback.foreach { branches += Conjunction.empty -> _ }
-    printlnUCS("Decision paths:")
-    branches.foreach { case conjunction -> term =>
-      printlnUCS(s"+ $conjunction => $term")
-    }
-    branches.toList
-  }(r => s"[desugarIf] produces ${r.size} ${"path".pluralize(r.size)}")
-
-  import MutCaseOf.{MutCase, IfThenElse, Match, MissingCase, Consequent}
-
-  /**
-    * This method obtains a proper key of the given scrutinee
-    * for memorizing patterns belongs to the scrutinee.
-    *
-    * @param scrutinee the scrutinee
-    * @param ctx the context
-    * @param raise we need this to raise errors.
-    * @return the variable name or the variable ID
-    */
-  private def getScurtineeKey(scrutinee: Scrutinee)(implicit ctx: Ctx, raise: Raise): Str \/ Int =
-    traceUCS(s"[getScrutineeKey] $scrutinee") {
-      scrutinee.term match {
-        // The original scrutinee is an reference.
-        case v @ Var(name) => 
-          printlnUCS("The original scrutinee is an reference.")
-          ctx.env.get(name) match {
-            case S(VarSymbol(_, defVar)) => defVar.uid.fold[Str \/ Int](L(v.name))(R(_))
-            case S(_) | N                => L(v.name)
-          }
-        // Otherwise, the scrutinee was localized because it might be effectful.
-        case _ =>
-          printlnUCS("The scrutinee was localized because it might be effectful.")
-          scrutinee.local match {
-            case N => throw new Error("check your `makeScrutinee`")
-            case S(localNameVar) => L(localNameVar.name)
-          }
-      }
-    }()
-
-  /**
-    * Check the exhaustiveness of the given `MutCaseOf`.
-    *
-    * @param t the mutable `CaseOf` of 
-    * @param parentOpt the parent `MutCaseOf`
-    * @param scrutineePatternMap the exhaustiveness map
-    */
-  private def checkExhaustive
-    (t: MutCaseOf, parentOpt: Opt[MutCaseOf])
-    (implicit ctx: Ctx,
-              raise: Raise,
-              exhaustivenessMap: ExhaustivenessMap,
-              subClassMap: SubClassMap)
-  : Unit = traceUCS(s"[checkExhaustive] ${t.describe}") {
-    t match {
-      case _: Consequent => ()
-      case MissingCase =>
-        parentOpt match {
-          case S(IfThenElse(test, whenTrue, whenFalse)) =>
-            if (whenFalse === t)
-              throw new DesugaringException(msg"The case when this is false is not handled: ${test.showDbg}", test.toLoc)
-            else
-              lastWords("`MissingCase` are not supposed to be the true branch of `IfThenElse`")
-          case S(Match(_, _, _)) =>
-            lastWords("`MissingCase` are not supposed to be a case of `Match`")
-          case S(Consequent(_)) | S(MissingCase) | N => die // unreachable
-        }
-      case IfThenElse(condition, whenTrue, whenFalse) =>
-        checkExhaustive(whenFalse, S(t))
-        checkExhaustive(whenTrue, S(t))
-      case Match(scrutinee, branches, default) =>
-        exhaustivenessMap.get(getScurtineeKey(scrutinee)) match {
-          case N => lastWords(s"unreachable case: unknown scrutinee ${scrutinee.term}")
-          case S(_) if default.isDefined =>
-            printlnUCS("The match has a default branch. So, it is always safe.")
-          case S(patternMap) =>
-            printlnUCS(s"The exhaustiveness map is")
-            exhaustivenessMap.foreachEntry { (key, matches) =>
-              printlnUCS(s"- $key -> ${matches.keysIterator.mkString(", ")}")
-            }
-            printlnUCS(s"The scrutinee key is ${getScurtineeKey(scrutinee)}")
-            printlnUCS("Pattern map of the scrutinee:")
-            if (patternMap.isEmpty)
-              printlnUCS("<Empty>")
-            else
-              patternMap.foreachEntry { (key, mutCase) => printlnUCS(s"- $key => $mutCase")}
-            // Compute all classes that can be covered by this match.
-            val coveredClassNames = Set.from[String](branches.iterator.flatMap {
-              case MutCase.Literal(_, _) => Nil
-              case Constructor(Var(className) -> _, _) =>
-                subClassMap.get(className).fold[List[String]](Nil)(identity)
-            })
-            printlnUCS("The match can cover following classes")
-            printlnUCS(coveredClassNames.mkString("{", ", ", "}"))
-            // Filter out missing cases in `branches`.
-            val missingCases = patternMap.removedAll(branches.iterator.map {
-              case MutCase.Literal(lit, _) => R(lit)
-              case MutCase.Constructor(classNameVar -> _, _) =>
-                classNameVar.name.split('#').toList match {
-                  case "Tuple" :: ns :: Nil =>
-                    ns.toIntOption match {
-                      case N => R(classNameVar)
-                      case S(arity) => L(arity)
-                    }
-                  case _ => R(classNameVar)
-                }
-            }).filter { // Remove classes subsumed by super classes.
-              case R(Var(className)) -> _ =>
-                !coveredClassNames.contains(className)
-              case L(_) -> _ => true // Tuple. Don't remove.
-              case R(_) -> _ => true // Literals. Don't remove.
-            }
-            printlnUCS("Missing cases")
-            missingCases.foreachEntry { (key, m) =>
-              printlnUCS(s"- $key -> ${m}")
-            }
-            if (!missingCases.isEmpty) {
-              throw new DesugaringException({
-                val numMissingCases = missingCases.size
-                (msg"The match is not exhaustive." -> scrutinee.matchRootLoc) ::
-                  (msg"The scrutinee at this position misses ${
-                    "case".pluralize(numMissingCases, true)
-                  }." -> scrutinee.term.toLoc) ::
-                  missingCases.iterator.zipWithIndex.flatMap { case ((pattern, locations), index) =>
-                    val patternName = pattern match {
-                      case L(tupleArity) => s"$tupleArity-ary tuple"
-                      case R(litOrCls) => litOrCls.showDbg
-                    }
-                    val progress = s"[Missing Case ${index + 1}/$numMissingCases]"
-                    (msg"$progress `$patternName`" -> N) ::
-                      locations.iterator.zipWithIndex.map { case (loc, index) =>
-                        (if (index === 0) msg"It first appears here." else msg"And here.") -> S(loc)
-                      }.toList
-                  }.toList
-              })
-            }
-        }
-        default.foreach(checkExhaustive(_, S(t)))
-        branches.foreach { branch =>
-          checkExhaustive(branch.consequent, S(t))
-        }
-    }
-  }(_ => s"[checkExhaustive] ${t.describe}")
-
-  /**
-    * Make a term from a mutable case tree.
-    * This should be called after exhaustiveness checking.
-    *
-    * @param m the mutable case tree
-    * @param ctx the context
-    * @return the case expression
-    */
-  private def constructTerm(m: MutCaseOf)(implicit ctx: Ctx): Term = traceUCS("[constructTerm]") {
-    /**
-     * Reconstruct case branches.
-     */
-    def rec2(xs: Ls[MutCase])(
-      implicit defs: Set[Var], scrutinee: Scrutinee, wildcard: Option[MutCaseOf]
-    ): CaseBranches = {
-      xs match {
-        case MutCase.Constructor(className -> fields, cases) :: next =>
-          printlnUCS(s"• Constructor pattern: $className(${fields.iterator.map(x => s"${x._1} -> ${x._2}").mkString(", ")})")
-          val consequent = rec(cases)(defs ++ fields.iterator.map(_._2))
-          val unapplyMtd = ctx.get(className.name) match {
-            case S(CompletedTypeInfo(nd: TypedNuTypeDef)) => nd.td.genUnapply // Declarations from other typing units
-            case S(ti: DelayedTypeInfo) => ti.decl.genUnapply // Declarations in the same typing units
-            case S(_: AbstractConstructor) | S(_: LazyTypeInfo) | S(_: VarSymbol) | N => N // Not found or not a class
-          }
-          val body = (scrutinee.reference, unapplyMtd) match {
-            case (v: Var, S(unapplyMtd)) if !fields.isEmpty =>
-              val visited = new HashMap[Str, Str]()
-              val extraAlias = new ListBuffer[(Str, Str)]()
-              fields.foreach {
-                case (field -> Var(alias)) => visited.get(field) match {
-                  case S(prev) => extraAlias.addOne((prev, alias))
-                  case _ => visited.put(field, alias)
-                }
-              }
-
-              // Well, reading the following piece of code is somewhat overwhelming for me.
-              App(Lam(Tup( /* begin params */
-                N -> Fld(FldFlags.empty, Tup(
-                  fields.distinctBy(_._1).map {
-                    case (_ -> Var(alias)) =>
-                      if (alias === "_") N -> Fld(FldFlags.empty, Var(freshName))
-                      else N -> Fld(FldFlags.empty, Var(alias))
-                  }.toList
-                )) :: Nil
-              ) /* end params */, extraAlias.toList.foldRight(consequent)((lt, rs) => Let(false, Var(lt._2), Var(lt._1), rs))),
-                Tup(N -> Fld(FldFlags.empty, App(Sel(className, Var(unapplyMtd.name) /* ClassName.unapply */),
-                  Tup(N -> Fld(FldFlags.empty, scrutinee.reference) :: Nil)) /* ClassName.unapply(scrutinee) */
-                  ) :: Nil)
-              )
-            case _ => mkLetFromFields(scrutinee, fields.filter(_._2.name =/= "_").toList, consequent)
-          }
-          Case(className, body, rec2(next))(refined = false)
-        case MutCase.Literal(literal, cases) :: next =>
-          printlnUCS(s"• Literal pattern: $literal")
-          Case(literal, rec(cases), rec2(next))(refined = false)
-        case Nil =>
-          wildcard match {
-            case None => 
-              printlnUCS("• No wildcard branch")
-              NoCases
-            case Some(value) =>
-              printlnUCS("• Wildcard branch")
-              Wildcard(rec(value))
-          }
-      }
-    }
-    /**
-     * Reconstruct the entire match.
-     */
-    def rec(m: MutCaseOf)(implicit defs: Set[Var]): Term = traceUCS(s"[rec] ${m.describe} -| {${defs.mkString(", ")}}") {
-      m match {
-        case Consequent(term) =>
-          mkBindings(m.getBindings.toList, term, defs)
-        case Match(scrutinee, branches, wildcard) =>
-          printlnUCS("• Owned let bindings")
-          val ownedBindings = m.getBindings.iterator.filterNot {
-            _.kind === LetBinding.Kind.InterleavedLet
-          }.toList
-          if (ownedBindings.isEmpty)
-            printlnUCS("  * <No bindings>")
-          else
-            ownedBindings.foreach { case LetBinding(kind, _, name, value) =>
-              printlnUCS(s"  * ($kind) $name = $value")
-            }
-          // Collect interleaved let bindings from case branches.
-          // Because they should be declared before 
-          val interleavedBindings = branches.iterator.map(_.consequent).concat(wildcard).flatMap(_.getBindings).filter {
-            _.kind === LetBinding.Kind.InterleavedLet
-          }.toList
-          printlnUCS("• Collect interleaved let bindings from case branches")
-          if (interleavedBindings.isEmpty)
-            printlnUCS("  * <No interleaved bindings>")
-          else
-            interleavedBindings.foreach { case LetBinding(_, _, name, value) =>
-              printlnUCS(s"  * $name = $value")
-            }
-          val resultTerm = if (branches.isEmpty) {
-            // If the match does not have any branches.
-            wildcard match {
-              case None =>
-                // Internal error!
-                printlnUCS("• The match has neither branches nor default case")
-                throw new DesugaringException({
-                  import Message.MessageContext
-                  msg"found an empty match"
-                }, scrutinee.term.toLoc)
-              case Some(default) =>
-                printlnUCS("• Degenerated case: the match only has a wildcard")
-                val subTerm = rec(default)
-                scrutinee.local match {
-                  case N => subTerm
-                  case S(aliasVar) => Let(false, aliasVar, scrutinee.term, subTerm)
-                }
-            }
-          } else {
-            // If the match has some branches.
-            printlnUCS("• The match has some case branches")
-            val cases = traceUCS("• For each case branch"){
-              rec2(branches.toList)(defs, scrutinee, wildcard)
-            }(_ => "• End for each")
-            scrutinee.local match {
-              case N => CaseOf(scrutinee.term, cases)
-              case S(aliasVar) => Let(false, aliasVar, scrutinee.term, CaseOf(aliasVar, cases))
-            }
-          }
-          mkBindings(ownedBindings, mkBindings(interleavedBindings, resultTerm, defs), defs)
-        case MissingCase =>
-          import Message.MessageContext
-          throw new DesugaringException(msg"missing a default branch", N)
-        case IfThenElse(condition, whenTrue, whenFalse) =>
-          val falseBody = mkBindings(whenFalse.getBindings.toList, rec(whenFalse)(defs ++ whenFalse.getBindings.iterator.map(_.name)), defs)
-          val trueBody = mkBindings(whenTrue.getBindings.toList, rec(whenTrue)(defs ++ whenTrue.getBindings.iterator.map(_.name)), defs)
-          val falseBranch = Wildcard(falseBody)
-          val trueBranch = Case(Var("true"), trueBody, falseBranch)(refined = false)
-          CaseOf(condition, trueBranch)
-      }
-    }()
-    val term = rec(m)(Set.from(m.getBindings.iterator.map(_.name)))
-    // Create immutable map from the mutable map.
-    mkBindings(m.getBindings.toList, term, Set.empty)
-  }(_ => "[constructTerm]")
-
-  /**
-    * Generate a chain of field selection to the given scrutinee.
-    *
-    * @param scrutinee the pattern matching scrutinee
-    * @param fields a list of pairs from field names to binding names
-    * @param body the final body
-    */
-  private def mkLetFromFields(scrutinee: Scrutinee, fields: Ls[Str -> Var], body: Term)(implicit ctx: Ctx): Term = {
-    def rec(scrutineeReference: SimpleTerm, fields: Ls[Str -> Var]): Term =
-      fields match {
-        case Nil => body
-        case (field -> (aliasVar @ Var(alias))) :: tail =>
-          scrutinee.term match {
-            // Check if the scrutinee is a `Var` and its name conflicts with
-            // one of the positionals. If so, we create an alias and extract
-            // fields by selecting the alias.
-            case Var(scrutineeName) if alias === scrutineeName =>
-              val scrutineeAlias = Var(freshName)
-              Let(
-                false,
-                scrutineeAlias,
-                scrutinee.reference,
-                Let(
-                  false,
-                  aliasVar,
-                  Sel(scrutineeAlias, Var(field)).desugaredFrom(scrutinee.term),
-                  rec(scrutineeAlias, tail)
-                )
-              )
-            case _ =>
-              Let(
-                false,
-                aliasVar,
-                Sel(scrutineeReference, Var(field)).desugaredFrom(scrutinee.term),
-                rec(scrutineeReference, tail)
-              )
-          }
-      }
-    rec(scrutinee.reference, fields)
-  }
-
-  private def buildCaseTree
-    (paths: Ls[Conjunction -> Term])
-    (implicit raise: Diagnostic => Unit,
-              getScrutineeKey: Scrutinee => Str \/ Int,
-              exhaustivenessMap: ExhaustivenessMap,
-              superClassMap: SuperClassMap)
-  : MutCaseOf = traceUCS("[buildCaseTree]") {
-    paths match {
-      case Nil => MissingCase
-      case (conditions -> term) :: remaining =>
-        val root = MutCaseOf.buildFirst(conditions, term)
-        traceUCS("*** Initial tree ***") {
-          MutCaseOf.show(root).foreach(printlnUCS(_))
-        }()
-        remaining.foreach { path =>
-          root.merge(path)
-          printlnUCS(s"*** Merging `${path._1} => ${path._2}` ***")
-          traceUCS("*** Updated tree ***") {
-            MutCaseOf.show(root).foreach(printlnUCS(_))
-          }()
-        }
-        root
-    }
-  }(_ => "[buildCaseTree]")
-
-  private def getClassHierarchy()(implicit ctx: Ctx): SuperClassMap =
-    traceUCS("[getClassHierarchy]") {
-      // ctx.tyDefs
-      val superClassMap = ctx.tyDefs.iterator
-        .filter(_._2.toLoc.isDefined)
-        .map { case (className, td) =>
-          className -> td.baseClasses.iterator.map(_.name).toList
-        } |> Map.from
-      Desugarer.transitiveClosure(superClassMap)
-    }(_ => "[getClassHierarchy]")
-}
-
-object Desugarer {
-  /**
-    * A map from each scrutinee term to all its cases and the first `MutCase`.
-    */
-  type ExhaustivenessMap = Map[Str \/ Int, Map[Either[Int, SimpleTerm], Buffer[Loc]]]
-
-  type SuperClassMap = Map[String, List[String]]
-
-  type SubClassMap = Map[String, List[String]]
-
-  def reverseGraph(graph: Map[String, List[String]]): Map[String, List[String]] = {
-    graph.iterator.flatMap { case (source, targets) => targets.iterator.map(_ -> source) }
-      .foldLeft(Map.empty[String, List[String]]) { case (map, target -> source) =>
-        map.updatedWith(target) {
-          case None => Some(source :: Nil)
-          case Some(sources) => Some(source :: sources)
-        }
-      }
-  }
-
-  def transitiveClosure(graph: Map[String, List[String]]): Map[String, List[String]] = {
-    def dfs(vertex: String, visited: Set[String]): Set[String] = {
-      if (visited.contains(vertex)) visited
-      else graph.getOrElse(vertex, List())
-        .foldLeft(visited + vertex)((acc, v) => dfs(v, acc))
-    }
-
-    graph.keys.map { vertex =>
-      val closure = dfs(vertex, Set())
-      vertex -> (closure - vertex).toList
-    }.toMap
-  }
-
-  def printGraph(graph: Map[String, List[String]], print: (=> Any) => Unit, title: String, arrow: String): Unit = {
-    print(s"• $title")
-    if (graph.isEmpty)
-      print("  + <Empty>")
-    else
-      graph.foreachEntry { (source, targets) =>
-        print(s"  + $source $arrow " + {
-          if (targets.isEmpty) s"{}"
-          else targets.mkString("{ ", ", ", " }")
-        })
-      }
-  }
-}
\ No newline at end of file
diff --git a/shared/src/main/scala/mlscript/ucs/old/LetBinding.scala b/shared/src/main/scala/mlscript/ucs/old/LetBinding.scala
deleted file mode 100644
index fb217c41dd..0000000000
--- a/shared/src/main/scala/mlscript/ucs/old/LetBinding.scala
+++ /dev/null
@@ -1,46 +0,0 @@
-package mlscript.ucs.old
-
-import mlscript._
-import mlscript.utils._
-import mlscript.utils.shorthands._
-import scala.collection.immutable.Set
-import scala.collection.mutable.{Set => MutSet, Buffer}
-
-final case class LetBinding(val kind: LetBinding.Kind, val recursive: Bool, val name: Var, val term: Term)
-
-object LetBinding {
-  sealed abstract class Kind
-
-  object Kind {
-    case object ScrutineeAlias extends Kind {
-      override def toString: String = "scrutinee alias"
-    }
-    case object FieldExtraction extends Kind {
-      override def toString: String = "pattern destruction"
-    }
-    case object InterleavedLet extends Kind {
-      override def toString: String = "interleaved let"
-    }
-  }
-}
-
-trait WithBindings { this: MutCaseOf =>
-  private val bindingsSet: MutSet[LetBinding] = MutSet.empty
-  private val bindings: Buffer[LetBinding] = Buffer.empty
-
-  def addBindings(newBindings: IterableOnce[LetBinding]): Unit = {
-    newBindings.iterator.foreach {
-      case binding if bindingsSet.contains(binding) => ()
-      case binding =>
-        bindingsSet += binding
-        bindings += binding
-    }
-  }
-
-  def getBindings: Iterable[LetBinding] = bindings
-
-  def withBindings(newBindings: IterableOnce[LetBinding]): MutCaseOf = {
-    addBindings(newBindings)
-    this
-  }
-}
diff --git a/shared/src/main/scala/mlscript/ucs/old/MutCaseOf.scala b/shared/src/main/scala/mlscript/ucs/old/MutCaseOf.scala
deleted file mode 100644
index eac05684bf..0000000000
--- a/shared/src/main/scala/mlscript/ucs/old/MutCaseOf.scala
+++ /dev/null
@@ -1,590 +0,0 @@
-package mlscript.ucs.old
-
-import mlscript._
-import mlscript.utils._
-import mlscript.utils.shorthands._
-import scala.collection.immutable.Set
-import scala.collection.mutable.{Map => MutMap, Set => MutSet, Buffer}
-
-import mlscript.ucs.helpers._
-import MutCaseOf.Consequent
-import scala.collection.immutable
-import Desugarer.{ExhaustivenessMap, SuperClassMap}
-import Clause.MatchAny
-
-sealed abstract class MutCaseOf extends WithBindings {
-  def kind: Str = {
-    import MutCaseOf._
-    this match {
-      case Consequent(_) => "Consequent"
-      case MissingCase => "MissingCase"
-      case IfThenElse(_, _, _) => "IfThenElse"
-      case Match(_, _, _) => "Match"
-    }
-  }
-
-  def duplicate(): MutCaseOf
-
-  def fill(subTree: MutCaseOf): Unit
-
-  def describe: Str
-
-  def isComplete: Bool
-
-  def isExhaustive(implicit getScrutineeKey: Scrutinee => Str \/ Int,
-                            exhaustivenessMap: ExhaustivenessMap): Bool
-
-  def tryMerge
-      (branch: Conjunction -> Term)
-      (implicit raise: Diagnostic => Unit,
-                getScrutineeKey: Scrutinee => Str \/ Int,
-                exhaustivenessMap: ExhaustivenessMap,
-                superClassMap: SuperClassMap): Unit =
-    merge(branch)(_ => (), getScrutineeKey, exhaustivenessMap, superClassMap)
-
-  def merge
-    (branch: Conjunction -> Term)
-    (implicit raise: Diagnostic => Unit,
-              getScrutineeKey: Scrutinee => Str \/ Int,
-              exhaustivenessMap: ExhaustivenessMap,
-              superClassMap: SuperClassMap): Unit
-
-  def mergeDefault
-    (bindings: Ls[LetBinding], default: Term)
-    (implicit raise: Diagnostic => Unit,
-              getScrutineeKey: Scrutinee => Str \/ Int,
-              exhaustivenessMap: ExhaustivenessMap,
-              superClassMap: SuperClassMap): Int
-
-  // TODO: Make it immutable.
-  var locations: Ls[Loc] = Nil
-}
-
-object MutCaseOf {
-  def showScrutinee(scrutinee: Scrutinee): Str =
-    s"«${scrutinee.term.showDbg}»" + (scrutinee.local match {
-      case N => ""
-      case S(Var(alias)) => s" as $alias"
-    })
-
-  def show(t: MutCaseOf): Ls[Str] = {
-    val lines = Buffer.empty[String]
-    def rec(t: MutCaseOf, indent: Int): Unit = {
-      val baseIndent = "  " * indent
-      lazy val bindingLines = t.getBindings.iterator.map {
-        case LetBinding(_, recursive, Var(name), term) =>
-          // Show bindings
-          s"[binding $name = ${term.showDbg}]"
-      }.toList
-      t match {
-        case IfThenElse(condition, whenTrue, whenFalse) =>
-          // Output the `whenTrue` with the prefix "if".
-          bindingLines.foreach { lines += baseIndent + _ }
-          lines += baseIndent + s"if «${condition.showDbg}»"
-          rec(whenTrue, indent + 1)
-          // Output the `whenFalse` case with the prefix "else".
-          lines += s"${baseIndent}else"
-          rec(whenFalse, indent + 1)
-        case Match(scrutinee, branches, default) =>
-          bindingLines.foreach { lines += baseIndent + _ }
-          lines += baseIndent + showScrutinee(scrutinee) + " match"
-          branches.foreach {
-            case MutCase.Literal(literal, consequent) =>
-              lines += s"$baseIndent  case ${literal.showDbg} =>"
-              rec(consequent, indent + 1)
-            case MutCase.Constructor(Var(className) -> fields, consequent) =>
-              lines += s"$baseIndent  case $className =>"
-              fields.foreach { case (field, Var(alias)) =>
-                // Show pattern bindings.
-                lines += s"$baseIndent    [pattern $alias = ${scrutinee.reference.showDbg}.$field]"
-              }
-              rec(consequent, indent + 2)
-          }
-          default.foreach { consequent =>
-            lines += s"$baseIndent  default"
-            rec(consequent, indent + 2)
-          }
-        case Consequent(term) =>
-          bindingLines.foreach { lines += baseIndent + _ }
-          lines += s"$baseIndent«${term.showDbg}»"
-        case MissingCase =>
-          bindingLines.foreach { lines += baseIndent + _ }
-          lines += s"$baseIndent<missing case>"
-      }
-    }
-    rec(t, 0)
-    lines.toList
-  }
-
-  sealed abstract class MutCase {
-    var consequent: MutCaseOf
-
-    @inline
-    def isComplete: Bool = consequent.isComplete
-
-    def duplicate(): MutCase
-
-    /**
-      * Check whether this case can cover the expected class or literal.
-      *
-      * @param expected the expected class name or literal
-      * @param superClassMap a map from each class to its super classes
-      * @return whether the given pattern can be covered by this case
-      */
-    def covers(expected: SimpleTerm)(implicit superClassMap: SuperClassMap): Bool
-
-    // Note 1
-    // ======
-    // A `MutCase` may come from one of two origins.
-    // Direct patterns.
-    // E.g. if x is Y then "aha" else "meh"
-    //         ^^^^^^
-    // Nested patterns.
-    // E.g. if x is Right(Some(x)) then ...
-    //                    ^^^^^^^
-    // The goal is to accurately indicate where the pattern is declared.
-    //
-    // Note 2
-    // ======
-    // A `MutCase` may come from multiple locations.
-    // That is why I'm using a `Set`.
-    //
-    val locations: MutSet[Loc] = MutSet.empty[Loc]
-    def withLocation(locOpt: Opt[Loc]): MutCase = {
-      locations ++= locOpt
-      this
-    }
-    def withLocations(locs: IterableOnce[Loc]): MutCase = {
-      locations ++= locs
-      this
-    }
-  }
-
-  object MutCase {
-    final case class Literal(
-      val literal: SimpleTerm,
-      var consequent: MutCaseOf,
-    ) extends MutCase {
-      override def duplicate(): MutCase =
-        Literal(literal, consequent.duplicate()).withLocations(locations)
-      override def covers(expected: SimpleTerm)(implicit superClassMap: SuperClassMap): Bool =
-        expected match {
-          case _: Lit | Var("true") | Var("false") => expected === literal
-          case Var(_) => false
-        }
-    }
-
-    /**
-      * MutCase is a _mutable_ representation of a case in `MutCaseOf.Match`.
-      *
-      * @param patternFields the alias to the fields
-      * @param consequent the consequential `MutCaseOf`
-      */
-    final case class Constructor(
-      val patternFields: Var -> Buffer[Str -> Var],
-      var consequent: MutCaseOf,
-    ) extends MutCase {
-      override def duplicate(): MutCase =
-        Constructor(patternFields.copy(_2 = patternFields._2.clone()), consequent.duplicate())
-          .withLocations(locations)
-      override def covers(expected: SimpleTerm)(implicit superClassMap: SuperClassMap): Bool =
-        expected match {
-          case lit: Lit => false
-          case Var(tof) if tof === "true" || tof === "false" => false
-          case Var(expectedClassName) if expectedClassName === patternFields._1.name => true
-          case Var(expectedClassName) => 
-            (superClassMap.get(expectedClassName) match {
-              case Some(superClasses) => superClasses.contains(patternFields._1.name)
-              case None =>
-                // Should we raise?
-                false
-            })
-        }
-      def addFields(fields: Iterable[Str -> Var]): Unit =
-        patternFields._2 ++= fields.iterator.filter(!patternFields._2.contains(_))
-    }
-  }
-
-  import Clause.{MatchLiteral, MatchAny, MatchClass, MatchTuple, BooleanTest, Binding}
-
-  // A short-hand for pattern matchings with only true and false branches.
-  final case class IfThenElse(condition: Term, var whenTrue: MutCaseOf, var whenFalse: MutCaseOf) extends MutCaseOf {
-    def describe: Str =
-      s"IfThenElse(${condition.showDbg}, whenTrue = ${whenTrue.kind}, whenFalse = ${whenFalse.kind})"
-
-    def duplicate(): MutCaseOf =
-      IfThenElse(condition, whenTrue.duplicate(), whenFalse.duplicate())
-        .withBindings(getBindings)
-
-    override def fill(subTree: MutCaseOf): Unit = {
-      whenTrue.fill(subTree)
-      if (whenFalse === MissingCase)
-        whenFalse = subTree
-      else
-        whenFalse.fill(subTree)
-    }
-
-    def isComplete: Bool = whenTrue.isComplete && whenFalse.isComplete
-
-    def isExhaustive(implicit getScrutineeKey: Scrutinee => Str \/ Int,
-                              exhaustivenessMap: ExhaustivenessMap): Bool =
-      whenTrue.isExhaustive && whenFalse.isExhaustive
-
-    def merge(branch: Conjunction -> Term)
-        (implicit raise: Diagnostic => Unit,
-                  getScrutineeKey: Scrutinee => Str \/ Int,
-                  exhaustivenessMap: ExhaustivenessMap,
-                  superClassMap: SuperClassMap): Unit =
-      branch match {
-        // The CC is a wildcard. So, we call `mergeDefault`.
-        case Conjunction(Nil, trailingBindings) -> term =>
-          if (mergeDefault(trailingBindings, term) === 0) {
-            import Message.MessageContext
-            raise(WarningReport(
-              msg"Found a redundant else branch" -> term.toLoc :: Nil, newDefs = true))
-          }
-        // The CC is an if-then-else. We create a pattern match of true/false.
-        case Conjunction((head @ BooleanTest(test)) :: tail, trailingBindings) -> term if test === condition =>
-          // If the test is the same. So, we can insert the path to the true branch.
-          whenTrue.addBindings(head.bindings)
-          whenTrue.merge(Conjunction(tail, trailingBindings) -> term)
-        // Otherwise, we try to insert to the true branch.
-        case Conjunction(head :: _, _) -> _ =>
-          whenTrue.tryMerge(branch)
-          whenFalse match {
-            case Consequent(_) =>
-              raise(WarningReport(Message.fromStr("duplicated else in the if-then-else") -> N :: Nil,
-                newDefs = true))
-            case MissingCase =>
-              whenFalse = buildFirst(branch._1, branch._2)
-              whenFalse.addBindings(head.bindings)
-            case _ => whenFalse.merge(branch)
-          }
-      }
-
-    def mergeDefault(bindings: Ls[LetBinding], default: Term)
-        (implicit raise: Diagnostic => Unit,
-                  getScrutineeKey: Scrutinee => Str \/ Int,
-                  exhaustivenessMap: ExhaustivenessMap,
-                  superClassMap: SuperClassMap): Int = {
-      whenTrue.mergeDefault(bindings, default) + {
-        whenFalse match {
-          case Consequent(term) => 0
-          case MissingCase =>
-            whenFalse = Consequent(default).withBindings(bindings)
-            1
-          case _: IfThenElse | _: Match => whenFalse.mergeDefault(bindings, default)
-        }
-      }
-    }
-  }
-  final case class Match(
-    scrutinee: Scrutinee,
-    val branches: Buffer[MutCase],
-    var wildcard: Opt[MutCaseOf]
-  ) extends MutCaseOf {
-    def describe: Str = {
-      val n = branches.length
-      s"Match($scrutinee, ${"branch".pluralize(n, true, true)}, ${
-        wildcard.fold("no wildcard")(n => s"wildcard = ${n.kind}")
-      })"
-    }
-
-    def duplicate(): MutCaseOf =
-      Match(scrutinee, branches.map(_.duplicate()), wildcard.map(_.duplicate()))
-        .withBindings(getBindings)
-
-    override def fill(subTree: MutCaseOf): Unit = {
-      branches.foreach(_.consequent.fill(subTree))
-      wildcard.foreach(_.fill(subTree))
-    }
-
-    def isComplete: Bool =
-      branches.forall(_.consequent.isComplete) && wildcard.forall(_.isComplete)
-
-    def isExhaustive(implicit getScrutineeKey: Scrutinee => Str \/ Int,
-                              exhaustivenessMap: ExhaustivenessMap): Bool = {
-      exhaustivenessMap.get(getScrutineeKey(scrutinee)) match {
-        case None => ??? // TODO: Raise.
-        case Some(patternLocationsMap) =>
-          // Find patterns that are not included in `branches`.
-          patternLocationsMap.keysIterator.filterNot {
-            case L(tupleArity) => branches.iterator.exists {
-              case MutCase.Literal(_, _) => false
-              case MutCase.Constructor(Var(className) -> _, _) =>
-                className === s"Tuple#$tupleArity"
-            }
-            case R(litOrCls) => branches.iterator.exists {
-              case MutCase.Literal(lit, _) => litOrCls === lit
-              case MutCase.Constructor(cls -> _, _) => litOrCls === cls
-            }
-          }.isEmpty
-      }
-    }
-
-    def merge(originalBranch: Conjunction -> Term)
-        (implicit raise: Diagnostic => Unit,
-                  getScrutineeKey: Scrutinee => Str \/ Int,
-                  exhaustivenessMap: ExhaustivenessMap,
-                  superClassMap: SuperClassMap): Unit = {
-      // Remove let bindings that already has been declared.
-      val branch = originalBranch._1.copy(clauses = originalBranch._1.clauses.filter {
-        case Binding(name, value, false) if (getBindings.exists {
-          case LetBinding(LetBinding.Kind.ScrutineeAlias, _, n, v) =>
-            n === name && v === value
-          case _ => false
-        }) => false
-        case _ => true
-      }) -> originalBranch._2
-      // Promote the match against the same scrutinee.
-      branch._1.findClauseMatches(scrutinee) match {
-        // No conditions against the same scrutinee.
-        case N =>
-          branch match {
-            case Conjunction((head @ MatchTuple(scrutinee2, arity, fields)) :: tail, trailingBindings) -> term
-                if scrutinee2 === scrutinee => // Same scrutinee!
-              val tupleClassName = Var(s"Tuple#$arity") // TODO: Find a name known by Typer.
-              branches.find(_.covers(tupleClassName)) match {
-                // No such pattern. We should create a new one.
-                case N | S(MutCase.Literal(_, _)) =>
-                  val newBranch = buildFirst(Conjunction(tail, trailingBindings), term)
-                  newBranch.addBindings(head.bindings)
-                  branches += MutCase.Constructor(tupleClassName -> Buffer.from(fields), newBranch)
-                    .withLocations(head.locations)
-                // Found existing pattern.
-                case S(branch: MutCase.Constructor) =>
-                  branch.consequent.addBindings(head.bindings)
-                  branch.addFields(fields)
-                  branch.consequent.merge(Conjunction(tail, trailingBindings) -> term)
-              }
-            // A wild card case. We should propagate wildcard to every default positions.
-            case Conjunction(Nil, trailingBindings) -> term =>
-              if (mergeDefault(trailingBindings, term) === 0) {
-                import Message.MessageContext
-                raise(WarningReport(
-                  msg"Found a redundant else branch" -> term.toLoc :: Nil,
-                  newDefs = true))
-              }
-            // The conditions to be inserted does not overlap with me.
-            case conjunction -> term =>
-              branches.foreach {
-                _.consequent.tryMerge(conjunction -> term)
-              }
-              wildcard match {
-                // No wildcard. We will create a new one.
-                case N => wildcard = S(buildFirst(conjunction, term))
-                // There is a wildcard case. Just merge!
-                case S(consequent) => consequent.merge(conjunction -> term)
-              }
-          }
-        // Found a match condition against the same scrutinee
-        case S((head @ MatchClass(_, className, fields)) -> remainingConditions) =>
-          // Find all branches which can cover the `className`.
-          val inclusiveBranches = branches.iterator.filter(_.covers(className))
-          if (inclusiveBranches.isEmpty) {
-            // No such pattern. We should create a new one.
-            wildcard match {
-              // If the wildcard branch is incomplete, there might be some
-              // preemptive branches in front of this branch.
-              case Some(default) if !default.isComplete =>
-                val subTree = default.duplicate()
-                subTree.fill(buildFirst(remainingConditions, branch._2))
-                subTree.addBindings(head.bindings)
-                branches += MutCase.Constructor(className -> Buffer.from(fields), subTree)
-                  .withLocations(head.locations)
-              case Some(_) | None =>
-                val newBranch = buildFirst(remainingConditions, branch._2)
-                newBranch.addBindings(head.bindings)
-                branches += MutCase.Constructor(className -> Buffer.from(fields), newBranch)
-                  .withLocations(head.locations)
-            }
-          } else {
-            // Found some branches that can cover the `className`.
-            inclusiveBranches.foreach {
-              case MutCase.Literal(_, _) => () // This shouldn't happen.
-              case matchedCase @ MutCase.Constructor(Var(branchClassName) -> _, _) =>
-                if (branchClassName === className.name) {
-                  // This branch exactly matches the given class name.
-                  // So, we just do a simple merge.
-                  // Merge interleaved bindings.
-                  matchedCase.consequent.addBindings(head.bindings)
-                  matchedCase.addFields(fields)
-                  matchedCase.consequent.merge(remainingConditions -> branch._2)
-                } else {
-                  // This branch matches the super classes of the given class name.
-                  // There will be refinement matches inside the consequent.
-                  // Therefore, we should not merge with `remainingConditions`.
-                  // Instead, we should use the original conjunction.
-                  matchedCase.consequent.addBindings(head.bindings)
-                  matchedCase.addFields(fields)
-                  matchedCase.consequent.merge(branch)
-                }
-            }
-          }
-        case S((head @ MatchLiteral(_, literal)) -> remainingConditions) =>
-          branches.find(_.covers(literal)) match {
-            // No such pattern. We should create a new one.
-            case N | S(MutCase.Constructor(_, _)) =>
-              val newConsequent = buildFirst(remainingConditions, branch._2)
-              newConsequent.addBindings(head.bindings)
-              branches += MutCase.Literal(literal, newConsequent)
-                .withLocations(head.locations)
-            case S(matchCase: MutCase.Literal) =>
-              // Merge interleaved bindings.
-              matchCase.consequent.addBindings(head.bindings)
-              matchCase.consequent.merge(remainingConditions -> branch._2)
-          }
-        case S((head @ MatchAny(_)) -> remainingConditions) =>
-          // Existing branches may be complete but not exhaustive.
-          // Find inexhaustiveness branches and try to merge.
-          branches.iterator.filterNot(_.consequent.isExhaustive).foreach { 
-            _.consequent.tryMerge(remainingConditions -> branch._2)
-          }
-          // Then, let's consider the wildcard branch.
-          wildcard match {
-            // No wildcard. We will create a new one.
-            case N => wildcard = S(buildFirst(remainingConditions, branch._2))
-            // There is a wildcard case. Just merge!
-            case S(consequent) => consequent.merge(remainingConditions -> branch._2)
-          }
-      }
-    }
-
-    def mergeDefault(bindings: Ls[LetBinding], default: Term)
-        (implicit raise: Diagnostic => Unit,
-                  getScrutineeKey: Scrutinee => Str \/ Int,
-                  exhaustivenessMap: ExhaustivenessMap,
-                  superClassMap: SuperClassMap): Int = {
-      branches.iterator.map {
-        case MutCase.Constructor(_, consequent) => consequent.mergeDefault(bindings, default)
-        case MutCase.Literal(_, consequent) => consequent.mergeDefault(bindings, default)
-      }.sum + {
-        wildcard match {
-          case N =>
-            wildcard = S(Consequent(default).withBindings(bindings))
-            1
-          case S(consequent) => consequent.mergeDefault(bindings, default)
-        }
-      }
-    }
-  }
-  final case class Consequent(term: Term) extends MutCaseOf {
-    def describe: Str = s"Consequent(${term.showDbg})"
-
-    override def fill(subTree: MutCaseOf): Unit = ()
-
-    override def duplicate(): MutCaseOf = Consequent(term).withBindings(getBindings)
-
-    def isComplete: Bool = true
-
-    def isExhaustive(implicit getScrutineeKey: Scrutinee => Str \/ Int,
-                              exhaustivenessMap: ExhaustivenessMap): Bool = true
-
-    def merge(branch: Conjunction -> Term)
-        (implicit raise: Diagnostic => Unit,
-                  getScrutineeKey: Scrutinee => Str \/ Int,
-                  exhaustivenessMap: ExhaustivenessMap,
-                  superClassMap: SuperClassMap): Unit =
-      raise {
-        import scala.collection.mutable.ListBuffer
-        val buffer = ListBuffer.empty[Message -> Opt[Loc]]
-        buffer += Message.fromStr("Found a duplicated branch") -> N
-        buffer += Message.fromStr("This branch") -> {
-          val (Conjunction(clauses, _) -> consequent) = branch
-          consequent.toLoc
-          // TODO: Make a complete location. 
-          // clauses match {
-          //   case head :: _ => head.
-          //   case Nil => consequent.toLoc
-          // }
-        }
-        buffer += Message.fromStr("is subsumed by the branch here.") -> term.toLoc
-        WarningReport(buffer.toList, newDefs = true)
-      }
-
-    def mergeDefault(bindings: Ls[LetBinding], default: Term)
-       (implicit raise: Diagnostic => Unit,
-                  getScrutineeKey: Scrutinee => Str \/ Int,
-                  exhaustivenessMap: ExhaustivenessMap,
-                  superClassMap: SuperClassMap): Int = 0
-  }
-  final case object MissingCase extends MutCaseOf {
-    def describe: Str = "MissingCase"
-
-    override def duplicate() = MissingCase
-
-    override def fill(subTree: MutCaseOf): Unit = ()
-
-    def isComplete: Bool = false
-
-    def isExhaustive(implicit getScrutineeKey: Scrutinee => Str \/ Int,
-                              exhaustivenessMap: ExhaustivenessMap): Bool = false
-
-    def merge(branch: Conjunction -> Term)
-      (implicit raise: Diagnostic => Unit,
-                getScrutineeKey: Scrutinee => Str \/ Int,
-                exhaustivenessMap: ExhaustivenessMap,
-                superClassMap: SuperClassMap): Unit =
-      lastWords("`MissingCase` is a placeholder and cannot be merged")
-
-    def mergeDefault(bindings: Ls[LetBinding], default: Term)
-      (implicit raise: Diagnostic => Unit,
-                getScrutineeKey: Scrutinee => Str \/ Int,
-                exhaustivenessMap: ExhaustivenessMap,
-                superClassMap: SuperClassMap): Int = 0
-  }
-
-  def buildFirst(conjunction: Conjunction, term: Term)
-      (implicit getScrutineeKey: Scrutinee => Str \/ Int,
-                exhaustivenessMap: ExhaustivenessMap,
-                superClassMap: SuperClassMap): MutCaseOf = {
-    def rec(conjunction: Conjunction): MutCaseOf = conjunction match {
-      case Conjunction(head :: tail, trailingBindings) =>
-        lazy val (beforeHeadBindings, afterHeadBindings) = head.bindings.partition {
-          case LetBinding(LetBinding.Kind.InterleavedLet, _, _, _) => false
-          case LetBinding(_, _, _, _) => true
-        }
-        val consequentTree = rec(Conjunction(tail, trailingBindings))
-        (head match {
-          case MatchLiteral(scrutinee, literal) =>
-            val branches = Buffer[MutCase](
-              MutCase.Literal(literal, consequentTree.withBindings(afterHeadBindings)).withLocation(literal.toLoc)
-            )
-            Match(scrutinee, branches, N)
-              .withBindings(beforeHeadBindings)
-          case MatchAny(scrutinee) =>
-            Match(scrutinee, Buffer.empty, S(consequentTree.withBindings(afterHeadBindings)))
-              .withBindings(beforeHeadBindings)
-          case MatchClass(scrutinee, className, fields) =>
-            val branches = Buffer[MutCase](
-              MutCase.Constructor(className -> Buffer.from(fields), consequentTree.withBindings(afterHeadBindings))
-                .withLocations(head.locations)
-            )
-            Match(scrutinee, branches, N).withBindings(beforeHeadBindings)
-          case MatchTuple(scrutinee, arity, fields) =>
-            val branches = Buffer[MutCase](
-              MutCase.Constructor(Var(s"Tuple#$arity") -> Buffer.from(fields), consequentTree.withBindings(afterHeadBindings))
-                .withLocations(head.locations)
-            )
-            Match(scrutinee, branches, N).withBindings(beforeHeadBindings)
-          case BooleanTest(test) =>
-            IfThenElse(test, consequentTree, MissingCase)
-              .withBindings(beforeHeadBindings)
-              .withBindings(afterHeadBindings)
-          case Binding(name, term, isField) =>
-            val kind = if (isField)
-              LetBinding.Kind.FieldExtraction
-            else
-              LetBinding.Kind.ScrutineeAlias
-            consequentTree
-              .withBindings(beforeHeadBindings)
-              .withBindings(LetBinding(kind, false, name, term) :: Nil)
-              .withBindings(afterHeadBindings)
-        })
-      case Conjunction(Nil, trailingBindings) =>
-        Consequent(term).withBindings(trailingBindings)
-    }
-
-    rec(conjunction)
-  }
-}
diff --git a/shared/src/main/scala/mlscript/ucs/old/Scrutinee.scala b/shared/src/main/scala/mlscript/ucs/old/Scrutinee.scala
deleted file mode 100644
index 9c9a46239a..0000000000
--- a/shared/src/main/scala/mlscript/ucs/old/Scrutinee.scala
+++ /dev/null
@@ -1,30 +0,0 @@
-package mlscript.ucs.old
-
-import mlscript.{Loc, SimpleTerm, Term, Var}
-import mlscript.utils.lastWords
-import mlscript.utils.shorthands._
-
-// The point is to remember where the scrutinee comes from.
-// Is it from nested patterns? Or is it from a `IfBody`?
-final case class Scrutinee(var local: Opt[Var], term: Term)(val matchRootLoc: Opt[Loc]) {
-  def reference: SimpleTerm = local.getOrElse(term match {
-    case term: SimpleTerm => term
-    case _ => lastWords("`term` must be a `SimpleTerm` when `local` is empty")
-  })
-
-  /**
-    * Create a binding for the scrutinee. If the scrutinee is a `SimpleTerm`,
-    * it returns `None`.
-    *
-    * @return `Some` if the scrutinee is localized, otherwise, `None`.
-    */
-  def asBinding: Opt[LetBinding] = local.map {
-    LetBinding(LetBinding.Kind.ScrutineeAlias, false, _, term)
-  }
-
-  override def toString: String =
-    (local match {
-      case N => ""
-      case S(Var(alias)) => s"$alias @ "
-    }) + s"${term.showDbg}"
-}
diff --git a/shared/src/main/scala/mlscript/ucs/old/helpers.scala b/shared/src/main/scala/mlscript/ucs/old/helpers.scala
deleted file mode 100644
index 4d2df1e754..0000000000
--- a/shared/src/main/scala/mlscript/ucs/old/helpers.scala
+++ /dev/null
@@ -1,47 +0,0 @@
-package mlscript.ucs.old
-
-import scala.collection.mutable.{Set => MutSet}
-
-import mlscript._
-import mlscript.utils.shorthands._
-
-object helpers {
-  /**
-    * Split a term joined by `and` into a list of terms.
-    * E.g. `x and y and z` will be split into `x`, `y`, and `z`.
-    *
-    * @return a list of sub-terms of `t`
-    */
-  def splitAnd(t: Term): Ls[Term] =
-    t match {
-      case App(
-        App(Var("and"),
-            Tup((_ -> Fld(_, lhs)) :: Nil)),
-        Tup((_ -> Fld(_, rhs)) :: Nil)
-      ) => // * Old-style operators
-        splitAnd(lhs) :+ rhs
-      case App(Var("and"), PlainTup(lhs, rhs)) =>
-        splitAnd(lhs) :+ rhs
-      case _ => t :: Nil
-    }
-
-  /**
-    * Generate a chain of `Let` from a list of bindings.
-    *
-    * @param bindings a list of bindings, 
-    * @param body the final body
-    */
-  def mkBindings(bindings: Ls[LetBinding], body: Term, defs: Set[Var]): Term = {
-    def rec(bindings: Ls[LetBinding], defs: Set[Var]): Term =
-      bindings match {
-        case Nil => body
-        case LetBinding(_, isRec, nameVar, value) :: tail =>
-          if (defs.contains(nameVar)) {
-            rec(tail, defs)
-          } else {
-            Let(isRec, nameVar, value, rec(tail, defs + nameVar))
-          }
-      }
-    rec(bindings, defs)
-  }
-}
diff --git a/shared/src/main/scala/mlscript/ucs/package.scala b/shared/src/main/scala/mlscript/ucs/package.scala
index 1e5a3cacc6..4e285538b7 100644
--- a/shared/src/main/scala/mlscript/ucs/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/package.scala
@@ -1,9 +1,10 @@
 package mlscript
 
 import scala.annotation.tailrec
+import utils._, shorthands._
 
 package object ucs {
-  class VariableGenerator(prefix: String) {
+  class VariableGenerator(prefix: Str) {
     private var nextIndex = 0
 
     def apply(): Var = {
@@ -15,7 +16,7 @@ package object ucs {
     def reset(): Unit = nextIndex = 0
   }
 
-  type Lines = List[(Int, String)]
+  type Lines = Ls[(Int, Str)]
 
   implicit class LinesOps(private val lines: Lines) extends AnyVal {
     def indent: Lines = {
@@ -26,20 +27,26 @@ package object ucs {
       }
       rec(Nil, lines)
     }
-    def ##:(prefix: String): Lines = (0, prefix) :: lines.indent
-    def #:(prefix: String): Lines = {
+    def ##:(prefix: Str): Lines = (0, prefix) :: lines.indent
+    def #:(prefix: Str): Lines = {
       lines match {
         case (0, line) :: lines if lines.forall(_._1 > 0) => (0, s"$prefix $line") :: lines
         case lines => (0, prefix) :: lines.indent
       }
     }
-    def @:(prefix: String): Lines = {
+    def @:(prefix: Str): Lines = {
       lines match {
         case (_, line) :: Nil => (0, prefix + " " + line) :: Nil
         case lines => (0, prefix) :: lines.indent
       }
     }
-    def toIndentedString: String =
+    def toIndentedString: Str =
       lines.iterator.map { case (n, line) => "  " * n + line }.mkString("\n")
   }
+
+  // TODO: Remove this exception. The desugarer should work in a non-fatal way.
+  // We may call `lastWords` if unrecoverable errors are found.
+  class DesugaringException(val messages: Ls[Message -> Opt[Loc]]) extends Throwable {
+    def this(message: Message, location: Opt[Loc]) = this(message -> location :: Nil)
+  }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index 5a7a368a55..d85019bbe4 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -3,13 +3,13 @@ package mlscript.ucs.stages
 import mlscript.{Case, CaseBranches, CaseOf, Let, Lit, Loc, NoCases, Term, Var, Wildcard}
 import mlscript.{Diagnostic, ErrorReport, WarningReport}
 import mlscript.Message, Message.MessageContext
-import mlscript.ucs.DesugarUCS
+import mlscript.ucs.Desugarer
 import mlscript.ucs.context.{Context, CaseSet, NamedScrutineeData, MatchRegistry, ScrutineeData, SeenRegistry}
 import mlscript.pretyper.Traceable
 import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
 
-trait CoverageChecking { self: DesugarUCS with Traceable =>
+trait CoverageChecking { self: Desugarer with Traceable =>
   import CoverageChecking._
 
   def checkCoverage(term: Term)(implicit context: Context): Ls[Diagnostic] = {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 01b649dbe6..c67176d3bc 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -1,10 +1,8 @@
 package mlscript.ucs.stages
 
 import mlscript.{App, Asc, Fld, FldFlags, Lit, Sel, Term, Tup, TypeName, Var}
-import mlscript.ucs.PartialTerm
 import mlscript.ucs.syntax.{core => c, source => s}
 import mlscript.ucs.context.{Context, ScrutineeData}
-import mlscript.ucs.helpers.mkBinOp
 import mlscript.utils._, shorthands._
 import mlscript.pretyper.symbol._
 import mlscript.pretyper.{PreTyper, Scope}
@@ -71,7 +69,7 @@ trait Desugaring { self: PreTyper =>
   private def falsePattern(implicit scope: Scope, context: Context) =
     c.Pattern.Class(Var("false").withResolvedClassLikeSymbol, false)
 
-  private def desugarTermSplit(split: s.TermSplit)(implicit termPart: PartialTerm, scope: Scope, context: Context): c.Split =
+  private def desugarTermSplit(split: s.TermSplit)(implicit termPart: PartialTerm.Incomplete, scope: Scope, context: Context): c.Split =
     split match {
       case s.Split.Cons(head, tail) => desugarTermBranch(head) ++ desugarTermSplit(tail)
       case s.Split.Let(rec, nme, rhs, tail) =>
@@ -82,7 +80,7 @@ trait Desugaring { self: PreTyper =>
 
   // This function does not need to can `withCachedTermPart` because all branches assume that
   // `termPart` is either empty or waiting for an RHS.
-  private def desugarTermBranch(branch: s.TermBranch)(implicit termPart: PartialTerm, scope: Scope, context: Context): c.Split =
+  private def desugarTermBranch(branch: s.TermBranch)(implicit termPart: PartialTerm.Incomplete, scope: Scope, context: Context): c.Split =
     trace(s"desugarTermBranch <== $termPart") {
       branch match {
         case s.TermBranch.Boolean(testPart, continuation) =>
@@ -90,17 +88,17 @@ trait Desugaring { self: PreTyper =>
           c.Split.Let(
             rec = false,
             name = test,
-            term = Asc(termPart.addTerm(testPart, true).get, TypeName("Bool")),
+            term = Asc(termPart.addTerm(testPart).get, TypeName("Bool")),
             tail = c.Branch(test, truePattern, desugarTermSplit(continuation)(PartialTerm.Empty, scope + test.symbol, context)) :: c.Split.Nil
           )
         case s.TermBranch.Match(scrutinee, split) =>
-          desugarPatternSplit(termPart.addTerm(scrutinee, true).get, split)
+          desugarPatternSplit(termPart.addTerm(scrutinee).get, split)
         case s.TermBranch.Left(left, continuation) =>
-          desugarOperatorSplit(continuation)(termPart.addTerm(left, true), scope, context)
+          desugarOperatorSplit(continuation)(termPart.addTerm(left), scope, context)
       }
     }()
 
-  private def withCachedTermPart[B <: s.Branch](desugar: (PartialTerm, Scope) => c.Split)(implicit termPart: PartialTerm, scope: Scope, context: Context): c.Split =
+  private def withCachedTermPart[B <: s.Branch](desugar: (PartialTerm.Total, Scope) => c.Split)(implicit termPart: PartialTerm.Total, scope: Scope, context: Context): c.Split =
     termPart.get match {
       case v: Var => desugar(termPart, scope) // No need to cache variables.
       case rhs =>
@@ -108,7 +106,7 @@ trait Desugaring { self: PreTyper =>
         c.Split.Let(false, cache, rhs, desugar(PartialTerm.Total(cache, Nil), scope + cache.symbol))
     }
 
-  private def desugarOperatorSplit(split: s.OperatorSplit)(implicit termPart: PartialTerm, scope: Scope, context: Context): c.Split =
+  private def desugarOperatorSplit(split: s.OperatorSplit)(implicit termPart: PartialTerm.Total, scope: Scope, context: Context): c.Split =
     withCachedTermPart { (termPart, scope) => split match {
       case s.Split.Cons(head, tail) => desugarOperatorBranch(head)(termPart, scope, context) ++ desugarOperatorSplit(tail)(termPart, scope, context)
       case s.Split.Let(rec, nme, rhs, tail) =>
@@ -117,7 +115,7 @@ trait Desugaring { self: PreTyper =>
       case s.Split.Nil => c.Split.Nil
     }}
 
-  private def desugarOperatorBranch(branch: s.OperatorBranch)(implicit termPart: PartialTerm, scope: Scope, context: Context): c.Split =
+  private def desugarOperatorBranch(branch: s.OperatorBranch)(implicit termPart: PartialTerm.Total, scope: Scope, context: Context): c.Split =
     trace(s"desugarOperatorBranch <== $termPart") {
       branch match {
         case s.OperatorBranch.Binary(op, split) => desugarTermSplit(split)(termPart.addOp(op), scope, context)
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 184b36cd75..6ffc8305e1 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -6,7 +6,7 @@ import mlscript.{CaseBranches, Case, Wildcard, NoCases}
 import mlscript.Message, Message.MessageContext
 import mlscript.utils._, shorthands._
 import mlscript.ucs, mlscript.pretyper
-import ucs.{DesugarUCS, Lines, LinesOps, VariableGenerator}
+import ucs.{Desugarer, Lines, LinesOps, VariableGenerator}
 import ucs.context.{Context, ScrutineeData}
 import ucs.display.{showNormalizedTerm, showSplit}
 import ucs.helpers._
@@ -15,7 +15,7 @@ import pretyper.Scope
 import pretyper.symbol._
 import pretyper.{Diagnosable, Traceable}
 
-trait Normalization { self: DesugarUCS with Traceable =>
+trait Normalization { self: Desugarer with Traceable =>
   import Normalization._
 
   // TODO: We might not need the case where `deep` is `false`.
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PartialTerm.scala b/shared/src/main/scala/mlscript/ucs/stages/PartialTerm.scala
new file mode 100644
index 0000000000..c9f8c0e58e
--- /dev/null
+++ b/shared/src/main/scala/mlscript/ucs/stages/PartialTerm.scala
@@ -0,0 +1,48 @@
+package mlscript.ucs.stages
+
+import mlscript.{Term, Var}, mlscript.utils, utils.shorthands._
+import mlscript.ucs.helpers._
+
+/**
+  * A `PartialTerm` represents a possibly incomplete term.
+  * We'd better precisely track detailed locations of each parts.
+  */
+sealed abstract class PartialTerm {
+  /** Individual terms that used to build this `PartialTerm`. */
+  def terms: Iterator[Term]
+
+  override def toString(): String = this match {
+    case PartialTerm.Empty => "<empty>"
+    case PartialTerm.Total(term, _) => s"<total> ${term.showDbg}"
+    case PartialTerm.Half(lhs, op, _) => s"<half> ${lhs.showDbg} ${op.name}"
+  }
+}
+
+object PartialTerm {
+  sealed abstract class Incomplete extends PartialTerm {
+    def addTerm(term: Term): PartialTerm.Total
+  }
+
+  final case object Empty extends Incomplete {
+    override def terms: Iterator[Term] = Iterator.empty
+    def addTerm(term: Term): Total = Total(term, term :: Nil)
+  }
+
+  final case class Total(term: Term, parts: Ls[Term]) extends PartialTerm {
+    override def terms: Iterator[Term] = parts.reverseIterator
+    def addOp(op: Var): Half = Half(term, op, op :: parts)
+    def get: Term = term
+  }
+
+  final case class Half(lhs: Term, op: Var, parts: Ls[Term]) extends Incomplete {
+    override def terms: Iterator[Term] = parts.reverseIterator
+    def addTerm(rhs: Term): Total = {
+      val (realRhs, extraExprOpt) = separatePattern(rhs, true)
+      val leftmost = mkBinOp(lhs, op, realRhs, true)
+      extraExprOpt match {
+        case N            => Total(leftmost, parts)
+        case S(extraExpr) => Total(mkBinOp(leftmost, Var("and"), extraExpr, true), extraExpr :: parts)
+      }
+    }
+  }
+}
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index adf791cfbf..9cfd1f2651 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -1,14 +1,14 @@
 package mlscript.ucs.stages
 
 import mlscript.{Case, CaseBranches, CaseOf, Let, Lit, Loc, NoCases, Term, Var, Wildcard}
-import mlscript.ucs.DesugarUCS
+import mlscript.ucs.Desugarer
 import mlscript.ucs.context.{Context, PatternInfo, ScrutineeData}
 import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
 import mlscript.Message, Message.MessageContext
 import scala.annotation.tailrec
 
-trait PostProcessing { self: DesugarUCS with mlscript.pretyper.Traceable =>
+trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
   import PostProcessing._
 
   def postProcess(term: Term)(implicit context: Context): Term = trace(s"postProcess <== ${term.showDbg}") {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index 5fa77fba4d..384bd91987 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -1,7 +1,7 @@
 package mlscript.ucs.stages
 
 import mlscript.ucs.syntax.source._
-import mlscript.ucs.{DesugarUCS, helpers}
+import mlscript.ucs.{Desugarer, helpers}
 import mlscript.{If, IfBody, IfBlock, IfElse, IfLet, IfOpApp, IfOpsApp, IfThen}
 import mlscript.{Blk, Term, Var, App, Tup, Lit, Fld, Loc, NuFunDef, PlainTup}
 import mlscript.pretyper.Traceable
@@ -16,7 +16,7 @@ import scala.collection.immutable, scala.annotation.tailrec, scala.util.chaining
   * The AST in the paper is more flexible. For example, it allows interleaved
   * `let` bindings in operator splits.
   */
-trait Transformation { self: DesugarUCS with Traceable =>
+trait Transformation { self: Desugarer with Traceable =>
   import Transformation._
 
   /** The entry point of transformation. */
diff --git a/shared/src/main/scala/mlscript/ucs/stages/package.scala b/shared/src/main/scala/mlscript/ucs/stages/package.scala
index 0e09184504..eb442f836f 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/package.scala
@@ -1,7 +1,31 @@
 package mlscript.ucs
 
-import mlscript.{Lit, Term, Var}
+import mlscript.{App, Fld, FldFlags, Lit, PlainTup, Term, Tup, Var}
 import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
 
-package object stages
+package object stages {
+  /**
+    * Make a tuple with only one element. For example,
+    * 
+    * ```scala
+    * mkMonuple(t) = Tup(N -> Fld(false, false, t) :: Nil)
+    * ```
+    *
+    * @param t the sole element
+    * @return a tuple term with the only element
+    */
+  def mkMonuple(t: Term): Tup = Tup(N -> Fld(FldFlags.empty, t) :: Nil)
+
+  /**
+    * Make a binary operation.
+    *
+    * @param lhs the left-hand side term
+    * @param op the operator
+    * @param rhs the right-hand side term
+    * @return something like `App(App(op, lhs), rhs)`
+    */
+  def mkBinOp(lhs: Term, op: Var, rhs: Term, newDefs: Bool): Term =
+    if (newDefs) App(op, PlainTup(lhs, rhs))
+    else App(App(op, mkMonuple(lhs)), mkMonuple(rhs))
+}
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
index 6bd909b509..f81108c882 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
@@ -9,7 +9,7 @@ class App(func: Term, arg: Term) extends Term
 //│ class Abs(param: Str, body: Term) extends Term
 //│ class App(func: Term, arg: Term) extends Term
 
-:ucs:desugar.result
+:ducs:desugar.result
 fun is_value_explicit_refinement(term) =
   if term is refined(Term) and term is
     Abs(_, _) then true
@@ -22,7 +22,7 @@ fun is_value_explicit_refinement(term) =
 //│ | | | | | | |   term*‡ is App then false
 //│ fun is_value_explicit_refinement: (Abs | App | Var) -> Bool
 
-:ucs:normalize.result,postprocess.result
+:ducs:normalize.result,postprocess.result
 fun is_value_automatic_refinement(term) =
   if term is Term and term is
     Abs(_, _) then true
diff --git a/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls b/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls
index 8205836776..2ca0944efc 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/AVLTree.mls
@@ -262,7 +262,7 @@ fun bf(t) =
 //   than placed in parallel, otherwise, the later branches will appear in the
 //   else branch of all its previous branches. **WORK IN PROGRESS**
 //
-// :ucs:postprocess
+// :ducs:postprocess
 fun balance(t: Tree['A]): Tree['A] =
   if t is
     Node(x, l, r, _) and height(r) - height(l)
diff --git a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
index f9ac187c04..7de5c13a56 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
@@ -22,7 +22,7 @@ fun sum(acc, xs) =
 
 // FIXME: Remove redundant `_ -> (ucs$args_xs$Some_0$Cons).1`.
 // Why are they everywhere?
-:ucs:postprocess.result
+:ducs:postprocess.result
 fun test(xs) =
   if xs is
     Some(Cons("add", Cons(x, Cons(y, Nil)))) then x + y
diff --git a/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls b/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
index 6238ea8228..89d276afeb 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
@@ -1,6 +1,6 @@
 :NewDefs
 
-:ucs:postprocess.result,desugared
+:ducs:postprocess.result,desugared
 fun mixed_literals(v) =
   if v is
     true then "true"
@@ -18,7 +18,7 @@ fun mixed_literals(v) =
 //│ ╙──
 //│ fun mixed_literals: (1 | 2 | false | true) -> ("1" | "2" | "false" | "true")
 
-:ucs:postprocess.result
+:ducs:postprocess.result
 fun separated_by_and(v) =
   if v is
     true then "true"
@@ -32,7 +32,7 @@ fun separated_by_and(v) =
 //│ ╙──
 //│ fun separated_by_and: Bool -> ("false" | "true")
 
-:ucs:postprocess.result
+:ducs:postprocess.result
 fun dual_patterns(x, y) =
   if
     x is "some" and y is "none" then 0
@@ -51,7 +51,7 @@ fun dual_patterns(x, y) =
 //│ | | | | | | |       "none" -> 3
 //│ fun dual_patterns: ("none" | "some", "none" | "some") -> (0 | 1 | 2 | 3)
 
-:ucs:postprocess.result
+:ducs:postprocess.result
 fun unordered_dual_patterns(x, y) =
   if
     x is "some" and y is "none" then 0
diff --git a/shared/src/test/diff/ucs/Hygiene.mls b/shared/src/test/diff/ucs/Hygiene.mls
index d2ea541ba6..87fba27ae6 100644
--- a/shared/src/test/diff/ucs/Hygiene.mls
+++ b/shared/src/test/diff/ucs/Hygiene.mls
@@ -7,7 +7,7 @@ class Right[out T](value: T)
 //│ class Left[T](value: T)
 //│ class Right[T](value: T)
 
-:ucs:postprocess.result
+:ducs:postprocess.result
 fun foo(x) = if x is
   Some(Left(y)) then x
   Some(x) then x
diff --git a/shared/src/test/diff/ucs/HygienicBindings.mls b/shared/src/test/diff/ucs/HygienicBindings.mls
index 651de5de98..c7b88ca4ce 100644
--- a/shared/src/test/diff/ucs/HygienicBindings.mls
+++ b/shared/src/test/diff/ucs/HygienicBindings.mls
@@ -39,7 +39,7 @@ fun h0(a) =
 // If a class parameter is bound to the same variable in different branches,
 // the bindings can be merged and can be typed and coverage checked. See the
 // desugared version below.
-:ucs:postprocess.result
+:ducs:postprocess.result
 fun h0'(a) =
   if
     a is Some(x) and x is Left(y) then y
@@ -92,7 +92,7 @@ fun h2(a) =
     a is None then 0
 //│ fun h2: forall 'a. (None | Some[Left['a]]) -> (0 | 'a)
 
-:ucs:postprocess.result
+:ducs:postprocess.result
 fun h3(x, y, f, p) =
   if x is
     _ and f(x) is y and p(x) then y
@@ -125,7 +125,7 @@ h3("anything", "anything", _ => "not me", _ => false) ~~> "anyway"
 //│     = undefined
 
 
-:ucs:postprocess.result
+:ducs:postprocess.result
 fun h4(x, y, p) =
   if x is
     y and p(x) then y
@@ -158,7 +158,7 @@ h4("anything", "not me", _ => false)
 //│ res
 //│     = 'default'
 
-:ucs:postprocess.result
+:ducs:postprocess.result
 fun h5(x, y, p) =
   if x is
     Some(y) and p(x) then y
diff --git a/shared/src/test/diff/ucs/InterleavedLet.mls b/shared/src/test/diff/ucs/InterleavedLet.mls
index f0840717dd..1af6c8f4ce 100644
--- a/shared/src/test/diff/ucs/InterleavedLet.mls
+++ b/shared/src/test/diff/ucs/InterleavedLet.mls
@@ -21,7 +21,7 @@ class Right[B](rightValue: B) extends Either[nothing, B]
 //│ class Left[A](leftValue: A) extends Either
 //│ class Right[B](rightValue: B) extends Either
 
-:ucs:normalize.result
+:ducs:normalize.result
 fun q(x) =
   if
     x is Some and x is Some and x is Some then 0
diff --git a/shared/src/test/diff/ucs/Wildcard.mls b/shared/src/test/diff/ucs/Wildcard.mls
index 006b99bea7..f3ab4a054e 100644
--- a/shared/src/test/diff/ucs/Wildcard.mls
+++ b/shared/src/test/diff/ucs/Wildcard.mls
@@ -195,7 +195,7 @@ class Delta()
 
 // This should generate only one case expression instead of a chain of case
 // expressions. DO check the desugared term!
-:ucs:postprocess.result
+:ducs:postprocess.result
 fun w5(y) =
   if y is
     Alpha then "alpha"
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index e164c35225..5bceb06ce7 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -25,7 +25,7 @@ abstract class ModeType {
   def dbg: Bool
   def dbgParsing: Bool
   def dbgSimplif: Bool
-  def dbgUCS: Bool
+  def dbgUCS: Opt[Set[Str]]
   def fullExceptionStack: Bool
   def stats: Bool
   def stdout: Bool
@@ -150,9 +150,8 @@ class DiffTests
       explainErrors: Bool = false,
       dbg: Bool = false,
       dbgParsing: Bool = false,
-      dbgNuUCS: Opt[Set[Str]] = N,
       dbgSimplif: Bool = false,
-      dbgUCS: Bool = false,
+      dbgUCS: Opt[Set[Str]] = N,
       fullExceptionStack: Bool = false,
       stats: Bool = false,
       stdout: Bool = false,
@@ -215,9 +214,8 @@ class DiffTests
           case "p" => mode.copy(showParse = true)
           case "d" => mode.copy(dbg = true)
           case "dp" => mode.copy(dbgParsing = true)
-          case DebugUCSFlags(ts) => mode.copy(dbgNuUCS = mode.dbgNuUCS.fold(S(ts))(ts0 => S(ts0 ++ ts)))
+          case DebugUCSFlags(x) => mode.copy(dbgUCS = mode.dbgUCS.fold(S(x))(y => S(y ++ x)))
           case "ds" => mode.copy(dbgSimplif = true)
-          case "ducs" => mode.copy(dbg = true, dbgUCS = true)
           case "s" => mode.copy(fullExceptionStack = true)
           case "v" | "verbose" => mode.copy(verbose = true)
           case "ex" | "explain" => mode.copy(expectTypeErrors = true, explainErrors = true)
@@ -471,7 +469,6 @@ class DiffTests
             // if (mode.isDebugging) typer.resetState()
             if (mode.stats) typer.resetStats()
             typer.dbg = mode.dbg
-            typer.dbgUCS = mode.dbgUCS
             // typer.recordProvenances = !noProvs
             typer.recordProvenances = !noProvs && !mode.dbg && !mode.dbgSimplif || mode.explainErrors
             typer.generalizeCurriedFunctions = generalizeCurriedFunctions
@@ -525,7 +522,7 @@ class DiffTests
               val vars: Map[Str, typer.SimpleType] = Map.empty
               val rootTypingUnit = TypingUnit(p.tops)
               val preTyper = new PreTyper {
-                override def debugTopicFilters = mode.dbgNuUCS
+                override def debugTopicFilters = mode.dbgUCS
                 override def emitString(str: String): Unit = output(str)
               }
               // This scope will be passed to typer and code generator after
@@ -1136,7 +1133,8 @@ object DiffTests {
   }
 
   object DebugUCSFlags {
-    private val pattern = "^ucs(?::\\s*([A-Za-z\\.-]+)(,\\s*[A-Za-z\\.-]+)*)?$".r
+    // E.g. "ducs", "ducs:foo", "ducs:foo,bar", "ducs:a.b.c,foo"
+    private val pattern = "^ducs(?::\\s*([A-Za-z\\.-]+)(,\\s*[A-Za-z\\.-]+)*)?$".r
     def unapply(flags: Str): Opt[Set[Str]] =
       flags match {
         case pattern(head, tail) =>

From 559a9672490c39d83c0050e9aedc8c18d67c354d Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 16 Jan 2024 18:34:47 +0800
Subject: [PATCH 074/147] Remove indentation of intermediate results from
 desugarer

---
 .../scala/mlscript/pretyper/PreTyper.scala    |   2 +-
 .../scala/mlscript/pretyper/Traceable.scala   |  13 ++-
 .../main/scala/mlscript/ucs/Desugarer.scala   |  23 ++--
 .../pretyper/ucs/coverage/SealedClasses.mls   |  46 ++++----
 .../pretyper/ucs/stages/Normalization.mls     |  96 ++++++++--------
 .../pretyper/ucs/stages/PostProcessing.mls    |  62 +++++------
 shared/src/test/diff/ucs/Hygiene.mls          |  26 ++---
 shared/src/test/diff/ucs/HygienicBindings.mls | 104 +++++++++---------
 shared/src/test/diff/ucs/InterleavedLet.mls   |   6 +-
 shared/src/test/diff/ucs/Wildcard.mls         |  22 ++--
 10 files changed, 203 insertions(+), 197 deletions(-)

diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index 072c57b97e..c479536be9 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -207,7 +207,7 @@ class PreTyper extends Traceable with Diagnosable with Desugarer {
           maybeSymbol
         })
       }
-      printGraph(edges, println, "inheritance relations", "->")
+      printGraph(edges, println(_), "inheritance relations", "->")
       transitiveClosure(edges).foreachEntry { (self, bases) =>
         self.baseTypes = bases
         println(s"base types of `${self.name}`: ${bases.iterator.map(_.name).mkString(", ")}")
diff --git a/shared/src/main/scala/mlscript/pretyper/Traceable.scala b/shared/src/main/scala/mlscript/pretyper/Traceable.scala
index 7d318d3c24..1c4dc6752d 100644
--- a/shared/src/main/scala/mlscript/pretyper/Traceable.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Traceable.scala
@@ -25,8 +25,13 @@ trait Traceable {
   /** Override this function to redirect debug messages. */
   protected def emitString(str: Str): Unit = scala.Predef.println(str)
   
-  @inline private def printLineByLine(x: => Any): Unit =
-    x.toString.linesIterator.foreach { line => emitString("| " * debugIndent + line) }
+  @inline private def printLineByLine(x: => Any, withIndent: Bool): Unit =
+    x.toString.linesIterator.foreach(
+      if (withIndent)
+        line => emitString("| " * debugIndent + line)
+      else
+        emitString
+    )
 
   protected def trace[T](pre: => Str)(thunk: => T)(post: T => Str = Traceable.noPostTrace): T = {
     println(pre)
@@ -46,8 +51,8 @@ trait Traceable {
   @inline def traceNot[T](pre: => Str)(thunk: => T)(post: T => Str = Traceable.noPostTrace): T =
     thunk
   
-  @inline protected def println(x: => Any): Unit =
-    if (matchTopicFilters) printLineByLine(x)
+  @inline protected def println(x: => Any, withIndent: Bool = true): Unit =
+    if (matchTopicFilters) printLineByLine(x, withIndent)
 }
 
 object Traceable {
diff --git a/shared/src/main/scala/mlscript/ucs/Desugarer.scala b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
index bbf4effb9a..8d3ccf3341 100644
--- a/shared/src/main/scala/mlscript/ucs/Desugarer.scala
+++ b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
@@ -205,10 +205,11 @@ trait Desugarer extends Transformation
       // Stage 0: Transformation
       val transformed = traceWithTopic("transform") {
         println("STEP 0")
-        val transformed = transform(`if`)
-        println("Transformed UCS term:")
-        println(showSplit(transformed))
-        transformed
+        transform(`if`)
+      }
+      traceWithTopic("transform.result") {
+        println("Transformed UCS term:", withIndent = false)
+        println(showSplit(transformed), withIndent = false)
       }
       // Stage 1: Desugaring
       val desugared = traceWithTopic("desugar") {
@@ -216,8 +217,8 @@ trait Desugarer extends Transformation
         desugar(transformed)
       }
       traceWithTopic("desugar.result") {
-        println("Desugared UCS term:")
-        println(showSplit(desugared))
+        println("Desugared UCS term:", withIndent = false)
+        println(showSplit(desugared), withIndent = false)
       }
       traceWithTopic("traverse") {
         println("STEP 1.5")
@@ -229,8 +230,8 @@ trait Desugarer extends Transformation
         normalize(desugared)
       }
       traceWithTopic("normalize.result") {
-        println("Normalized UCS term:")
-        println(showNormalizedTerm(normalized))
+        println("Normalized UCS term:", withIndent = false)
+        println(showNormalizedTerm(normalized), withIndent = false)
       }
       // Stage 3: Post-processing
       val postProcessed = traceWithTopic("postprocess") {
@@ -238,8 +239,8 @@ trait Desugarer extends Transformation
         postProcess(normalized)
       }
       traceWithTopic("postprocess.result") {
-        println("Post-processed UCS term:")
-        println(showNormalizedTerm(postProcessed))
+        println("Post-processed UCS term:", withIndent = false)
+        println(showNormalizedTerm(postProcessed), withIndent = false)
       }
       // Stage 4: Coverage checking
       traceWithTopic("coverage") {
@@ -249,7 +250,7 @@ trait Desugarer extends Transformation
         raiseMany(diagnostics)
       }
       traceWithTopic("desugared") {
-        println(s"Desugared term: ${postProcessed.showDbg}")
+        println(s"Desugared term: ${postProcessed.showDbg}", withIndent = false)
       }
       // Epilogue
       `if`.desugaredTerm = S(postProcessed)
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
index f81108c882..d852038b9e 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
@@ -15,11 +15,11 @@ fun is_value_explicit_refinement(term) =
     Abs(_, _) then true
     Var(_) then false
     App(_, _) then false
-//│ | | | | | | | Desugared UCS term:
-//│ | | | | | | | if term*‡ is refined Term
-//│ | | | | | | |   term*‡ is Abs then true
-//│ | | | | | | |   term*‡ is Var then false
-//│ | | | | | | |   term*‡ is App then false
+//│ Desugared UCS term:
+//│ if term*‡ is refined Term
+//│   term*‡ is Abs then true
+//│   term*‡ is Var then false
+//│   term*‡ is App then false
 //│ fun is_value_explicit_refinement: (Abs | App | Var) -> Bool
 
 :ducs:normalize.result,postprocess.result
@@ -28,24 +28,24 @@ fun is_value_automatic_refinement(term) =
     Abs(_, _) then true
     Var(_) then false
     App(_, _) then false
-//│ | | | | | | | Normalized UCS term:
-//│ | | | | | | | case term*‡ of
-//│ | | | | | | |   refined Term*◊ ->
-//│ | | | | | | |     case term*‡ of
-//│ | | | | | | |       Abs*◊ -> true
-//│ | | | | | | |       _ ->
-//│ | | | | | | |         case term*‡ of
-//│ | | | | | | |           Var*◊ -> false
-//│ | | | | | | |           _ ->
-//│ | | | | | | |             case term*‡ of
-//│ | | | | | | |               App*◊ -> false
-//│ | | | | | | | Post-processed UCS term:
-//│ | | | | | | | case term*‡ of
-//│ | | | | | | |   refined Term*◊ ->
-//│ | | | | | | |     case term*‡ of
-//│ | | | | | | |       Abs*◊ -> true
-//│ | | | | | | |       Var*◊ -> false
-//│ | | | | | | |       App*◊ -> false
+//│ Normalized UCS term:
+//│ case term*‡ of
+//│   refined Term*◊ ->
+//│     case term*‡ of
+//│       Abs*◊ -> true
+//│       _ ->
+//│         case term*‡ of
+//│           Var*◊ -> false
+//│           _ ->
+//│             case term*‡ of
+//│               App*◊ -> false
+//│ Post-processed UCS term:
+//│ case term*‡ of
+//│   refined Term*◊ ->
+//│     case term*‡ of
+//│       Abs*◊ -> true
+//│       Var*◊ -> false
+//│       App*◊ -> false
 //│ fun is_value_automatic_refinement: (Abs | App | Var) -> Bool
 
 :e
diff --git a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
index 7de5c13a56..cbef36d469 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
@@ -30,52 +30,52 @@ fun test(xs) =
     Some(Cons("sum", xs)) then sum(0, xs)
     Some(Nil) then "nothing"
     None then "nothing"
-//│ | | | | | | | Post-processed UCS term:
-//│ | | | | | | | case xs*‡ of
-//│ | | | | | | |   Some*◊ ->
-//│ | | | | | | |     let ucs$args_xs$Some*† = (Some).unapply(xs,)
-//│ | | | | | | |     let xs$Some_0*‡ = (ucs$args_xs$Some).0
-//│ | | | | | | |     case xs$Some_0*‡ of
-//│ | | | | | | |       Cons*◊ ->
-//│ | | | | | | |         let ucs$args_xs$Some_0$Cons*† = (Cons).unapply(xs$Some_0,)
-//│ | | | | | | |         let xs$Some_0$Cons_0*‡ = (ucs$args_xs$Some_0$Cons).0
-//│ | | | | | | |         let xs$Some_0$Cons_1*‡ = (ucs$args_xs$Some_0$Cons).1
-//│ | | | | | | |         case xs$Some_0$Cons_0*‡ of
-//│ | | | | | | |           "add" ->
-//│ | | | | | | |             case xs$Some_0$Cons_1*‡ of
-//│ | | | | | | |               Cons*◊ ->
-//│ | | | | | | |                 let ucs$args_xs$Some_0$Cons_1$Cons*† = (Cons).unapply(xs$Some_0$Cons_1,)
-//│ | | | | | | |                 let x*‡ = (ucs$args_xs$Some_0$Cons_1$Cons).0
-//│ | | | | | | |                 let xs$Some_0$Cons_1$Cons_1*‡ = (ucs$args_xs$Some_0$Cons_1$Cons).1
-//│ | | | | | | |                 case xs$Some_0$Cons_1$Cons_1*‡ of
-//│ | | | | | | |                   Cons*◊ ->
-//│ | | | | | | |                     let ucs$args_xs$Some_0$Cons_1$Cons_1$Cons*† = (Cons).unapply(xs$Some_0$Cons_1$Cons_1,)
-//│ | | | | | | |                     let y*‡ = (ucs$args_xs$Some_0$Cons_1$Cons_1$Cons).0
-//│ | | | | | | |                     let xs$Some_0$Cons_1$Cons_1$Cons_1*‡ = (ucs$args_xs$Some_0$Cons_1$Cons_1$Cons).1
-//│ | | | | | | |                     case xs$Some_0$Cons_1$Cons_1$Cons_1*‡ of
-//│ | | | | | | |                       Nil*† -> +(x, y,)
-//│ | | | | | | |                       _ -> (ucs$args_xs$Some_0$Cons).1
-//│ | | | | | | |                   _ -> (ucs$args_xs$Some_0$Cons).1
-//│ | | | | | | |               _ -> (ucs$args_xs$Some_0$Cons).1
-//│ | | | | | | |           "sum" ->
-//│ | | | | | | |             let xs*‡ = (ucs$args_xs$Some_0$Cons).1
-//│ | | | | | | |             sum(0, xs,)
-//│ | | | | | | |           "mul" ->
-//│ | | | | | | |             case xs$Some_0$Cons_1*‡ of
-//│ | | | | | | |               Cons*◊ ->
-//│ | | | | | | |                 let ucs$args_xs$Some_0$Cons_1$Cons*† = (Cons).unapply(xs$Some_0$Cons_1,)
-//│ | | | | | | |                 let x*‡ = (ucs$args_xs$Some_0$Cons_1$Cons).0
-//│ | | | | | | |                 let xs$Some_0$Cons_1$Cons_1*‡ = (ucs$args_xs$Some_0$Cons_1$Cons).1
-//│ | | | | | | |                 case xs$Some_0$Cons_1$Cons_1*‡ of
-//│ | | | | | | |                   Cons*◊ ->
-//│ | | | | | | |                     let ucs$args_xs$Some_0$Cons_1$Cons_1$Cons*† = (Cons).unapply(xs$Some_0$Cons_1$Cons_1,)
-//│ | | | | | | |                     let y*‡ = (ucs$args_xs$Some_0$Cons_1$Cons_1$Cons).0
-//│ | | | | | | |                     let xs$Some_0$Cons_1$Cons_1$Cons_1*‡ = (ucs$args_xs$Some_0$Cons_1$Cons_1$Cons).1
-//│ | | | | | | |                     case xs$Some_0$Cons_1$Cons_1$Cons_1*‡ of
-//│ | | | | | | |                       Nil*† -> *(x, y,)
-//│ | | | | | | |                       _ -> (ucs$args_xs$Some_0$Cons).1
-//│ | | | | | | |                   _ -> (ucs$args_xs$Some_0$Cons).1
-//│ | | | | | | |               _ -> (ucs$args_xs$Some_0$Cons).1
-//│ | | | | | | |       Nil*† -> "nothing"
-//│ | | | | | | |   None*† -> "nothing"
+//│ Post-processed UCS term:
+//│ case xs*‡ of
+//│   Some*◊ ->
+//│     let ucs$args_xs$Some*† = (Some).unapply(xs,)
+//│     let xs$Some_0*‡ = (ucs$args_xs$Some).0
+//│     case xs$Some_0*‡ of
+//│       Cons*◊ ->
+//│         let ucs$args_xs$Some_0$Cons*† = (Cons).unapply(xs$Some_0,)
+//│         let xs$Some_0$Cons_0*‡ = (ucs$args_xs$Some_0$Cons).0
+//│         let xs$Some_0$Cons_1*‡ = (ucs$args_xs$Some_0$Cons).1
+//│         case xs$Some_0$Cons_0*‡ of
+//│           "add" ->
+//│             case xs$Some_0$Cons_1*‡ of
+//│               Cons*◊ ->
+//│                 let ucs$args_xs$Some_0$Cons_1$Cons*† = (Cons).unapply(xs$Some_0$Cons_1,)
+//│                 let x*‡ = (ucs$args_xs$Some_0$Cons_1$Cons).0
+//│                 let xs$Some_0$Cons_1$Cons_1*‡ = (ucs$args_xs$Some_0$Cons_1$Cons).1
+//│                 case xs$Some_0$Cons_1$Cons_1*‡ of
+//│                   Cons*◊ ->
+//│                     let ucs$args_xs$Some_0$Cons_1$Cons_1$Cons*† = (Cons).unapply(xs$Some_0$Cons_1$Cons_1,)
+//│                     let y*‡ = (ucs$args_xs$Some_0$Cons_1$Cons_1$Cons).0
+//│                     let xs$Some_0$Cons_1$Cons_1$Cons_1*‡ = (ucs$args_xs$Some_0$Cons_1$Cons_1$Cons).1
+//│                     case xs$Some_0$Cons_1$Cons_1$Cons_1*‡ of
+//│                       Nil*† -> +(x, y,)
+//│                       _ -> (ucs$args_xs$Some_0$Cons).1
+//│                   _ -> (ucs$args_xs$Some_0$Cons).1
+//│               _ -> (ucs$args_xs$Some_0$Cons).1
+//│           "sum" ->
+//│             let xs*‡ = (ucs$args_xs$Some_0$Cons).1
+//│             sum(0, xs,)
+//│           "mul" ->
+//│             case xs$Some_0$Cons_1*‡ of
+//│               Cons*◊ ->
+//│                 let ucs$args_xs$Some_0$Cons_1$Cons*† = (Cons).unapply(xs$Some_0$Cons_1,)
+//│                 let x*‡ = (ucs$args_xs$Some_0$Cons_1$Cons).0
+//│                 let xs$Some_0$Cons_1$Cons_1*‡ = (ucs$args_xs$Some_0$Cons_1$Cons).1
+//│                 case xs$Some_0$Cons_1$Cons_1*‡ of
+//│                   Cons*◊ ->
+//│                     let ucs$args_xs$Some_0$Cons_1$Cons_1$Cons*† = (Cons).unapply(xs$Some_0$Cons_1$Cons_1,)
+//│                     let y*‡ = (ucs$args_xs$Some_0$Cons_1$Cons_1$Cons).0
+//│                     let xs$Some_0$Cons_1$Cons_1$Cons_1*‡ = (ucs$args_xs$Some_0$Cons_1$Cons_1$Cons).1
+//│                     case xs$Some_0$Cons_1$Cons_1$Cons_1*‡ of
+//│                       Nil*† -> *(x, y,)
+//│                       _ -> (ucs$args_xs$Some_0$Cons).1
+//│                   _ -> (ucs$args_xs$Some_0$Cons).1
+//│               _ -> (ucs$args_xs$Some_0$Cons).1
+//│       Nil*† -> "nothing"
+//│   None*† -> "nothing"
 //│ fun test: (None | Some[Cons[nothing] | Nil]) -> ("nothing" | Int | List[nothing])
diff --git a/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls b/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
index 89d276afeb..b8b9db5bc4 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
@@ -7,13 +7,13 @@ fun mixed_literals(v) =
     false then "false"
     1 then "1"
     2 then "2"
-//│ | | | | | | | Post-processed UCS term:
-//│ | | | | | | | case v*‡ of
-//│ | | | | | | |   true*† -> "true"
-//│ | | | | | | |   false*† -> "false"
-//│ | | | | | | |   2 -> "2"
-//│ | | | | | | |   1 -> "1"
-//│ | | | | | | | Desugared term: case v of { true => "true"; false => "false"; 2 => "2"; 1 => "1" }
+//│ Post-processed UCS term:
+//│ case v*‡ of
+//│   true*† -> "true"
+//│   false*† -> "false"
+//│   2 -> "2"
+//│   1 -> "1"
+//│ Desugared term: case v of { true => "true"; false => "false"; 2 => "2"; 1 => "1" }
 //│ ╙──
 //│ ╙──
 //│ fun mixed_literals: (1 | 2 | false | true) -> ("1" | "2" | "false" | "true")
@@ -24,10 +24,10 @@ fun separated_by_and(v) =
     true then "true"
     _ and v is
       false then "false"
-//│ | | | | | | | Post-processed UCS term:
-//│ | | | | | | | case v*‡ of
-//│ | | | | | | |   true*† -> "true"
-//│ | | | | | | |   false*† -> "false"
+//│ Post-processed UCS term:
+//│ case v*‡ of
+//│   true*† -> "true"
+//│   false*† -> "false"
 //│ ╙──
 //│ ╙──
 //│ fun separated_by_and: Bool -> ("false" | "true")
@@ -39,16 +39,16 @@ fun dual_patterns(x, y) =
     x is "none" and y is "some" then 1
     x is "some" and y is "some" then 2
     x is "none" and y is "none" then 3
-//│ | | | | | | | Post-processed UCS term:
-//│ | | | | | | | case x*‡ of
-//│ | | | | | | |   "some" ->
-//│ | | | | | | |     case y*‡ of
-//│ | | | | | | |       "none" -> 0
-//│ | | | | | | |       "some" -> 2
-//│ | | | | | | |   "none" ->
-//│ | | | | | | |     case y*‡ of
-//│ | | | | | | |       "some" -> 1
-//│ | | | | | | |       "none" -> 3
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   "some" ->
+//│     case y*‡ of
+//│       "none" -> 0
+//│       "some" -> 2
+//│   "none" ->
+//│     case y*‡ of
+//│       "some" -> 1
+//│       "none" -> 3
 //│ fun dual_patterns: ("none" | "some", "none" | "some") -> (0 | 1 | 2 | 3)
 
 :ducs:postprocess.result
@@ -58,14 +58,14 @@ fun unordered_dual_patterns(x, y) =
     y is "some" and x is "none" then 1
     y is "some" and x is "some" then 2
     x is "none" and y is "none" then 3
-//│ | | | | | | | Post-processed UCS term:
-//│ | | | | | | | case x*‡ of
-//│ | | | | | | |   "some" ->
-//│ | | | | | | |     case y*‡ of
-//│ | | | | | | |       "none" -> 0
-//│ | | | | | | |       "some" -> 2
-//│ | | | | | | |   "none" ->
-//│ | | | | | | |     case y*‡ of
-//│ | | | | | | |       "some" -> 1
-//│ | | | | | | |       "none" -> 3
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   "some" ->
+//│     case y*‡ of
+//│       "none" -> 0
+//│       "some" -> 2
+//│   "none" ->
+//│     case y*‡ of
+//│       "some" -> 1
+//│       "none" -> 3
 //│ fun unordered_dual_patterns: ("none" | "some", "none" | "some") -> (0 | 1 | 2 | 3)
diff --git a/shared/src/test/diff/ucs/Hygiene.mls b/shared/src/test/diff/ucs/Hygiene.mls
index 87fba27ae6..dbcde8e8ad 100644
--- a/shared/src/test/diff/ucs/Hygiene.mls
+++ b/shared/src/test/diff/ucs/Hygiene.mls
@@ -11,19 +11,19 @@ class Right[out T](value: T)
 fun foo(x) = if x is
   Some(Left(y)) then x
   Some(x) then x
-//│ | | | | | Post-processed UCS term:
-//│ | | | | | case x*‡ of
-//│ | | | | |   Some*◊ ->
-//│ | | | | |     let ucs$args_x$Some*† = (Some).unapply(x,)
-//│ | | | | |     let x$Some_0*‡ = (ucs$args_x$Some).0
-//│ | | | | |     case x$Some_0*‡ of
-//│ | | | | |       Left*◊ ->
-//│ | | | | |         let ucs$args_x$Some_0$Left*† = (Left).unapply(x$Some_0,)
-//│ | | | | |         let y*‡ = (ucs$args_x$Some_0$Left).0
-//│ | | | | |         x
-//│ | | | | |       _ ->
-//│ | | | | |         let x*‡ = (ucs$args_x$Some).0
-//│ | | | | |         x
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   Some*◊ ->
+//│     let ucs$args_x$Some*† = (Some).unapply(x,)
+//│     let x$Some_0*‡ = (ucs$args_x$Some).0
+//│     case x$Some_0*‡ of
+//│       Left*◊ ->
+//│         let ucs$args_x$Some_0$Left*† = (Left).unapply(x$Some_0,)
+//│         let y*‡ = (ucs$args_x$Some_0$Left).0
+//│         x
+//│       _ ->
+//│         let x*‡ = (ucs$args_x$Some).0
+//│         x
 //│ fun foo: forall 'T. Some[(Left[anything] | Object & ~#Left) & 'T] -> (Some['T] | 'T)
 
 foo(Some(Left(1)))
diff --git a/shared/src/test/diff/ucs/HygienicBindings.mls b/shared/src/test/diff/ucs/HygienicBindings.mls
index c7b88ca4ce..60bbe08556 100644
--- a/shared/src/test/diff/ucs/HygienicBindings.mls
+++ b/shared/src/test/diff/ucs/HygienicBindings.mls
@@ -45,21 +45,21 @@ fun h0'(a) =
     a is Some(x) and x is Left(y) then y
     a is Some(x) and x is Right(z) then z
     a is None then 0
-//│ | | | | | | | Post-processed UCS term:
-//│ | | | | | | | case a*‡ of
-//│ | | | | | | |   Some*◊ ->
-//│ | | | | | | |     let ucs$args_a$Some*† = (Some).unapply(a,)
-//│ | | | | | | |     let x*‡ = (ucs$args_a$Some).0
-//│ | | | | | | |     case x*‡ of
-//│ | | | | | | |       Left*◊ ->
-//│ | | | | | | |         let ucs$args_x$Left*† = (Left).unapply(x,)
-//│ | | | | | | |         let y*‡ = (ucs$args_x$Left).0
-//│ | | | | | | |         y
-//│ | | | | | | |       Right*◊ ->
-//│ | | | | | | |         let ucs$args_x$Right*† = (Right).unapply(x,)
-//│ | | | | | | |         let z*‡ = (ucs$args_x$Right).0
-//│ | | | | | | |         z
-//│ | | | | | | |   None*† -> 0
+//│ Post-processed UCS term:
+//│ case a*‡ of
+//│   Some*◊ ->
+//│     let ucs$args_a$Some*† = (Some).unapply(a,)
+//│     let x*‡ = (ucs$args_a$Some).0
+//│     case x*‡ of
+//│       Left*◊ ->
+//│         let ucs$args_x$Left*† = (Left).unapply(x,)
+//│         let y*‡ = (ucs$args_x$Left).0
+//│         y
+//│       Right*◊ ->
+//│         let ucs$args_x$Right*† = (Right).unapply(x,)
+//│         let z*‡ = (ucs$args_x$Right).0
+//│         z
+//│   None*† -> 0
 //│ fun h0': forall 'a. (None | Some[Left['a] | Right['a]]) -> (0 | 'a)
 
 // However, if the class parameter is bound to different variables in different
@@ -98,18 +98,18 @@ fun h3(x, y, f, p) =
     _ and f(x) is y and p(x) then y
     None then y
     _ then "anyway"
-//│ | | | | | | | Post-processed UCS term:
-//│ | | | | | | | let ucs$scrut$0*‡ = f(x,)
-//│ | | | | | | | let ucs$shadow$0 = y
-//│ | | | | | | | let y*‡ = ucs$scrut$0
-//│ | | | | | | | let ucs$test$0*† = p(x,) : Bool
-//│ | | | | | | | case ucs$test$0*† of
-//│ | | | | | | |   true*† -> y
-//│ | | | | | | |   _ ->
-//│ | | | | | | |     let y*‡ = ucs$shadow$0
-//│ | | | | | | |     case x*‡ of
-//│ | | | | | | |       None*† -> y
-//│ | | | | | | |       _ -> "anyway"
+//│ Post-processed UCS term:
+//│ let ucs$scrut$0*‡ = f(x,)
+//│ let ucs$shadow$0 = y
+//│ let y*‡ = ucs$scrut$0
+//│ let ucs$test$0*† = p(x,) : Bool
+//│ case ucs$test$0*† of
+//│   true*† -> y
+//│   _ ->
+//│     let y*‡ = ucs$shadow$0
+//│     case x*‡ of
+//│       None*† -> y
+//│       _ -> "anyway"
 //│ fun h3: forall 'a 'b. (Object & 'a, 'b, 'a -> 'b, 'a -> Bool) -> ("anyway" | 'b)
 
 
@@ -131,17 +131,17 @@ fun h4(x, y, p) =
     y and p(x) then y
     None then y
     _ then "default"
-//│ | | | | | | | Post-processed UCS term:
-//│ | | | | | | | let ucs$shadow$0 = y
-//│ | | | | | | | let y*‡ = x
-//│ | | | | | | | let ucs$test$0*† = p(x,) : Bool
-//│ | | | | | | | case ucs$test$0*† of
-//│ | | | | | | |   true*† -> y
-//│ | | | | | | |   _ ->
-//│ | | | | | | |     let y*‡ = ucs$shadow$0
-//│ | | | | | | |     case x*‡ of
-//│ | | | | | | |       None*† -> y
-//│ | | | | | | |       _ -> "default"
+//│ Post-processed UCS term:
+//│ let ucs$shadow$0 = y
+//│ let y*‡ = x
+//│ let ucs$test$0*† = p(x,) : Bool
+//│ case ucs$test$0*† of
+//│   true*† -> y
+//│   _ ->
+//│     let y*‡ = ucs$shadow$0
+//│     case x*‡ of
+//│       None*† -> y
+//│       _ -> "default"
 //│ fun h4: forall 'a 'b. (Object & 'a, 'b, 'a -> Bool) -> ("default" | 'a | 'b)
 
 h4("should be me", "not me", _ => true)
@@ -164,20 +164,20 @@ fun h5(x, y, p) =
     Some(y) and p(x) then y
     None then y
     _ then y
-//│ | | | | | | | Post-processed UCS term:
-//│ | | | | | | | case x*‡ of
-//│ | | | | | | |   Some*◊ ->
-//│ | | | | | | |     let ucs$args_x$Some*† = (Some).unapply(x,)
-//│ | | | | | | |     let ucs$shadow$0 = y
-//│ | | | | | | |     let y*‡ = (ucs$args_x$Some).0
-//│ | | | | | | |     let ucs$test$0*† = p(x,) : Bool
-//│ | | | | | | |     case ucs$test$0*† of
-//│ | | | | | | |       true*† -> y
-//│ | | | | | | |       _ ->
-//│ | | | | | | |         let y*‡ = ucs$shadow$0
-//│ | | | | | | |         y
-//│ | | | | | | |   None*† -> y
-//│ | | | | | | |   _ -> y
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   Some*◊ ->
+//│     let ucs$args_x$Some*† = (Some).unapply(x,)
+//│     let ucs$shadow$0 = y
+//│     let y*‡ = (ucs$args_x$Some).0
+//│     let ucs$test$0*† = p(x,) : Bool
+//│     case ucs$test$0*† of
+//│       true*† -> y
+//│       _ ->
+//│         let y*‡ = ucs$shadow$0
+//│         y
+//│   None*† -> y
+//│   _ -> y
 //│ fun h5: forall 'a. (Object & ~#Some | Some['a], 'a, Some[nothing] -> Bool) -> 'a
 
 h5(Some(1), 2, justTrue) ~~> 1
diff --git a/shared/src/test/diff/ucs/InterleavedLet.mls b/shared/src/test/diff/ucs/InterleavedLet.mls
index 1af6c8f4ce..b17f8fd4cb 100644
--- a/shared/src/test/diff/ucs/InterleavedLet.mls
+++ b/shared/src/test/diff/ucs/InterleavedLet.mls
@@ -25,9 +25,9 @@ class Right[B](rightValue: B) extends Either[nothing, B]
 fun q(x) =
   if
     x is Some and x is Some and x is Some then 0
-//│ | | | | | | | Normalized UCS term:
-//│ | | | | | | | case x*‡ of
-//│ | | | | | | |   Some*◊ -> 0
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   Some*◊ -> 0
 //│ fun q: Some[anything] -> 0
 
 :e
diff --git a/shared/src/test/diff/ucs/Wildcard.mls b/shared/src/test/diff/ucs/Wildcard.mls
index f3ab4a054e..3c6f2e8a44 100644
--- a/shared/src/test/diff/ucs/Wildcard.mls
+++ b/shared/src/test/diff/ucs/Wildcard.mls
@@ -206,17 +206,17 @@ fun w5(y) =
         _ and y is
           Delta then "delta"
           _ then "unknown"
-//│ | | | | | | | Post-processed UCS term:
-//│ | | | | | | | case y*‡ of
-//│ | | | | | | |   Alpha*◊ -> "alpha"
-//│ | | | | | | |   Gamma*◊ -> "gamma"
-//│ | | | | | | |   Delta*◊ -> "delta"
-//│ | | | | | | |   Beta*◊ -> "beta"
-//│ | | | | | | |   _ ->
-//│ | | | | | | |     case y*‡ of
-//│ | | | | | | |       _ ->
-//│ | | | | | | |         case y*‡ of
-//│ | | | | | | |           _ -> "unknown"
+//│ Post-processed UCS term:
+//│ case y*‡ of
+//│   Alpha*◊ -> "alpha"
+//│   Gamma*◊ -> "gamma"
+//│   Delta*◊ -> "delta"
+//│   Beta*◊ -> "beta"
+//│   _ ->
+//│     case y*‡ of
+//│       _ ->
+//│         case y*‡ of
+//│           _ -> "unknown"
 //│ fun w5: (Alpha | Beta | Delta | Gamma | Object & ~#Alpha & ~#Beta & ~#Delta & ~#Gamma) -> ("alpha" | "beta" | "delta" | "gamma" | "unknown")
 
 w5(0)

From 33b33f57730f9d1b529bc9d2e5a33da1a140a8d9 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 16 Jan 2024 20:03:56 +0800
Subject: [PATCH 075/147] Remove `mlscript.ucs.helpers` object

---
 .../scala/mlscript/pretyper/Traceable.scala   |  4 +-
 .../src/main/scala/mlscript/ucs/helpers.scala | 47 -------------------
 .../mlscript/ucs/stages/Normalization.scala   |  1 -
 .../mlscript/ucs/stages/PartialTerm.scala     |  3 +-
 .../mlscript/ucs/stages/Transformation.scala  | 19 ++------
 .../scala/mlscript/ucs/stages/package.scala   | 37 +++++++++++++++
 .../{TransfromUCS.mls => Transformation.mls}  | 33 ++++++++++++-
 7 files changed, 76 insertions(+), 68 deletions(-)
 delete mode 100644 shared/src/main/scala/mlscript/ucs/helpers.scala
 rename shared/src/test/diff/pretyper/ucs/stages/{TransfromUCS.mls => Transformation.mls} (60%)

diff --git a/shared/src/main/scala/mlscript/pretyper/Traceable.scala b/shared/src/main/scala/mlscript/pretyper/Traceable.scala
index 1c4dc6752d..df7aee9d7a 100644
--- a/shared/src/main/scala/mlscript/pretyper/Traceable.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Traceable.scala
@@ -51,8 +51,8 @@ trait Traceable {
   @inline def traceNot[T](pre: => Str)(thunk: => T)(post: T => Str = Traceable.noPostTrace): T =
     thunk
   
-  @inline protected def println(x: => Any, withIndent: Bool = true): Unit =
-    if (matchTopicFilters) printLineByLine(x, withIndent)
+  @inline protected def println(x: => Any, withIndent: Bool = true, force: Bool = false): Unit =
+    if (force || matchTopicFilters) printLineByLine(x, withIndent)
 }
 
 object Traceable {
diff --git a/shared/src/main/scala/mlscript/ucs/helpers.scala b/shared/src/main/scala/mlscript/ucs/helpers.scala
deleted file mode 100644
index da9b302914..0000000000
--- a/shared/src/main/scala/mlscript/ucs/helpers.scala
+++ /dev/null
@@ -1,47 +0,0 @@
-package mlscript.ucs
-
-import scala.collection.mutable.{Set => MutSet}
-
-import mlscript._
-import mlscript.utils.shorthands._
-
-object helpers {
-  import stages.mkBinOp
-
-  /**
-    * Split a term into two parts: the pattern and the extra test.
-    * This is used to extract patterns from UCS conjunctions. For example,
-    * the second line results in `IfThen(Some(xv) and xv == 0, ...)`
-    * in the following case.
-    * 
-    * ```
-    * if x is
-    *   Some(xv) and xv == 0 then ...
-    * ```
-    * 
-    * We must separate `Some(xv)` from the term to complete the pattern
-    * `x is Some(xv)`.
-    *
-    * @param term a term which might contains a pattern and an extra test
-    * @return a tuple, whose the first element is the pattern and the second
-    *   element is the extra test
-    */
-  def separatePattern(term: Term, newDefs: Bool): (Term, Opt[Term]) =
-    term match {
-      case App(
-        App(and @ Var("and"),
-            Tup((_ -> Fld(_, lhs)) :: Nil)),
-        Tup((_ -> Fld(_, rhs)) :: Nil)
-      ) => // * Old-style operators
-        separatePattern(lhs, newDefs) match {
-          case (pattern, N) => (pattern, S(rhs))
-          case (pattern, S(lshRhs)) => (pattern, S(mkBinOp(lshRhs, and, rhs, newDefs)))
-        }
-      case App(and @ Var("and"), PlainTup(lhs, rhs)) =>
-        separatePattern(lhs, newDefs) match {
-          case (pattern, N) => (pattern, S(rhs))
-          case (pattern, S(lshRhs)) => (pattern, S(mkBinOp(lshRhs, and, rhs, newDefs)))
-        }
-      case _ => (term, N)
-    }
-}
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 6ffc8305e1..9fcc757f15 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -9,7 +9,6 @@ import mlscript.ucs, mlscript.pretyper
 import ucs.{Desugarer, Lines, LinesOps, VariableGenerator}
 import ucs.context.{Context, ScrutineeData}
 import ucs.display.{showNormalizedTerm, showSplit}
-import ucs.helpers._
 import ucs.syntax.core.{Pattern, Branch, Split}
 import pretyper.Scope
 import pretyper.symbol._
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PartialTerm.scala b/shared/src/main/scala/mlscript/ucs/stages/PartialTerm.scala
index c9f8c0e58e..7dac085bd7 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PartialTerm.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PartialTerm.scala
@@ -1,7 +1,6 @@
 package mlscript.ucs.stages
 
-import mlscript.{Term, Var}, mlscript.utils, utils.shorthands._
-import mlscript.ucs.helpers._
+import mlscript.{Term, Var}, mlscript.utils._, shorthands._
 
 /**
   * A `PartialTerm` represents a possibly incomplete term.
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index 384bd91987..26f4ab0c90 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -1,13 +1,12 @@
 package mlscript.ucs.stages
 
-import mlscript.ucs.syntax.source._
-import mlscript.ucs.{Desugarer, helpers}
+import mlscript.ucs, ucs.Desugarer, ucs.syntax.source._
 import mlscript.{If, IfBody, IfBlock, IfElse, IfLet, IfOpApp, IfOpsApp, IfThen}
 import mlscript.{Blk, Term, Var, App, Tup, Lit, Fld, Loc, NuFunDef, PlainTup}
 import mlscript.pretyper.Traceable
 import mlscript.Message, Message._
 import mlscript.utils._, shorthands._
-import scala.collection.immutable, scala.annotation.tailrec, scala.util.chaining._
+import collection.immutable, annotation.tailrec, util.chaining._
 
 /**
   * Transform the parsed AST into an AST similar to the one in the paper.
@@ -114,12 +113,8 @@ trait Transformation { self: Desugarer with Traceable =>
     trace(s"transformPatternMatching <== ${body.showDbg}") {
       body match {
         case IfThen(expr, rhs) => 
-          separatePattern(expr) match {
-            case (pattern, S(extraTest)) =>
-              PatternBranch(pattern, transformIfBody(IfThen(extraTest, rhs))).toSplit
-            case (pattern, N) =>
-              PatternBranch(pattern, Split.default(rhs)).toSplit
-          }
+          val ::(head, tail) = splitAnd(expr)
+          PatternBranch(transformPattern(head), transformConjunction(tail, Split.then(rhs), false)).toSplit
         case IfOpApp(lhs, Var("and"), rhs) =>
           val ::(head, tail) = splitAnd(lhs)
           PatternBranch(transformPattern(head), transformConjunction(tail, transformIfBody(rhs), false)).toSplit
@@ -207,12 +202,6 @@ trait Transformation { self: Desugarer with Traceable =>
       EmptyPattern(other)
   }
 
-  private def separatePattern(term: Term): (Pattern, Opt[Term]) = {
-    val (rawPattern, extraTest) = helpers.separatePattern(term, true)
-    println(s"pattern: ${rawPattern.showDbg} ;; test: ${extraTest.fold("_")(_.showDbg)}")
-    (transformPattern(rawPattern), extraTest)
-  }
-
   /**
     * Split a term into a list of terms. Note that the return type is `::[Term]`
     * because there should be at least one term even we don't split. It used to
diff --git a/shared/src/main/scala/mlscript/ucs/stages/package.scala b/shared/src/main/scala/mlscript/ucs/stages/package.scala
index eb442f836f..3be1c55595 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/package.scala
@@ -28,4 +28,41 @@ package object stages {
   def mkBinOp(lhs: Term, op: Var, rhs: Term, newDefs: Bool): Term =
     if (newDefs) App(op, PlainTup(lhs, rhs))
     else App(App(op, mkMonuple(lhs)), mkMonuple(rhs))
+
+  /**
+    * Split a term into two parts: the pattern and the extra test.
+    * This is used to extract patterns from UCS conjunctions. For example,
+    * the second line results in `IfThen(Some(xv) and xv == 0, ...)`
+    * in the following case.
+    * 
+    * ```
+    * if x is
+    *   Some(xv) and xv == 0 then ...
+    * ```
+    * 
+    * We must separate `Some(xv)` from the term to complete the pattern
+    * `x is Some(xv)`.
+    *
+    * @param term a term which might contains a pattern and an extra test
+    * @return a tuple, whose the first element is the pattern and the second
+    *   element is the extra test
+    */
+  def separatePattern(term: Term, newDefs: Bool): (Term, Opt[Term]) =
+    term match {
+      case App(
+        App(and @ Var("and"),
+            Tup((_ -> Fld(_, lhs)) :: Nil)),
+        Tup((_ -> Fld(_, rhs)) :: Nil)
+      ) => // * Old-style operators
+        separatePattern(lhs, newDefs) match {
+          case (pattern, N) => (pattern, S(rhs))
+          case (pattern, S(lshRhs)) => (pattern, S(mkBinOp(lshRhs, and, rhs, newDefs)))
+        }
+      case App(and @ Var("and"), PlainTup(lhs, rhs)) =>
+        separatePattern(lhs, newDefs) match {
+          case (pattern, N) => (pattern, S(rhs))
+          case (pattern, S(lshRhs)) => (pattern, S(mkBinOp(lshRhs, and, rhs, newDefs)))
+        }
+      case _ => (term, N)
+    }
 }
diff --git a/shared/src/test/diff/pretyper/ucs/stages/TransfromUCS.mls b/shared/src/test/diff/pretyper/ucs/stages/Transformation.mls
similarity index 60%
rename from shared/src/test/diff/pretyper/ucs/stages/TransfromUCS.mls
rename to shared/src/test/diff/pretyper/ucs/stages/Transformation.mls
index ef294f2398..2a721769be 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/TransfromUCS.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/Transformation.mls
@@ -30,16 +30,47 @@ class Pair[A, B](x: A, y: B) {
 //│   fun mapSecond: forall 'C0. (f: B -> 'C0) -> Pair[A, 'C0]
 //│ }
 
+:ducs:transform.result
 fun zipWith(f, xs, ys) =
   if xs is
     Cons(x, xs) and ys is Cons(y, ys) and zipWith(f, xs, ys) is Some(tail) then Some(Cons(f(x, y), tail))
     Nil and ys is Nil then Some(Nil)
   else None
+//│ Transformed UCS term:
+//│ if
+//│   xs is
+//│     Cons(x, xs) and ys is Cons(y, ys) and zipWith(f, xs, ys,) is Some(tail) then Some(Cons(f(x, y,), tail,),)
+//│     Nil and ys is Nil then Some(Nil,)
+//│   else None
 //│ fun zipWith: forall 'T 'T0 'T1 'T2. (('T0, 'T1) -> 'T2, Cons['T0] | Object & ~#Cons, Cons['T1] | Object & ~#Cons) -> (None | Some[in List['T2] & 'T out Nil | 'T | Cons['T2]])
 
-
+:ducs:transform.result
 fun getOrElse[T](x: Option[T], default: T): T =
   if x is
     Some(value) then value
     None then default
+//│ Transformed UCS term:
+//│ if x is
+//│   Some(value) then value
+//│   None then default
 //│ fun getOrElse: forall 'T. (x: Option['T], default: 'T) -> 'T
+
+fun m3(x: Int): Bool = x % 3 == 0
+fun m5(x: Int): Bool = x % 5 == 0
+//│ fun m3: (x: Int) -> Bool
+//│ fun m5: (x: Int) -> Bool
+
+:ducs:transform.result
+fun f(x) =
+  if x is
+    Some(v) and m3(v) and m5(v) then "FizzBuzz"
+    Some(v) and m3(v) then "Fizz"
+    Some(v) and m5(v) then "Buzz"
+    else "meh"
+//│ Transformed UCS term:
+//│ if x is
+//│   Some(v) and m3(v,) and m5(v,) then "FizzBuzz"
+//│   Some(v) and m3(v,) then "Fizz"
+//│   Some(v) and m5(v,) then "Buzz"
+//│   else "meh"
+//│ fun f: (Object & ~#Some | Some[Int]) -> ("Buzz" | "Fizz" | "FizzBuzz" | "meh")

From 5c79d80e6158ea9bf231515d1749b8ed605a94d0 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 16 Jan 2024 20:07:08 +0800
Subject: [PATCH 076/147] Rename `ScrutineeData` to `Scrutinee`

---
 .../src/main/scala/mlscript/ucs/Desugarer.scala  |  6 +++---
 .../scala/mlscript/ucs/context/Context.scala     | 10 +++++-----
 .../scala/mlscript/ucs/context/Matchable.scala   | 10 +++++-----
 .../scala/mlscript/ucs/context/PatternInfo.scala | 12 ++++++------
 .../{ScrutineeData.scala => Scrutinee.scala}     | 14 +++++++-------
 .../scala/mlscript/ucs/context/package.scala     |  6 +++---
 .../mlscript/ucs/stages/CoverageChecking.scala   |  6 +++---
 .../scala/mlscript/ucs/stages/Desugaring.scala   |  2 +-
 .../mlscript/ucs/stages/Normalization.scala      | 16 ++++++++--------
 .../mlscript/ucs/stages/PostProcessing.scala     | 16 ++++++++--------
 10 files changed, 49 insertions(+), 49 deletions(-)
 rename shared/src/main/scala/mlscript/ucs/context/{ScrutineeData.scala => Scrutinee.scala} (95%)

diff --git a/shared/src/main/scala/mlscript/ucs/Desugarer.scala b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
index 8d3ccf3341..ca29850af3 100644
--- a/shared/src/main/scala/mlscript/ucs/Desugarer.scala
+++ b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
@@ -1,7 +1,7 @@
 package mlscript.ucs
 
 import collection.mutable.{Map => MutMap}
-import syntax.{source => s, core => c}, stages._, context.{Context, ScrutineeData}
+import syntax.{source => s, core => c}, stages._, context.{Context, Scrutinee}
 import mlscript.ucs.display.{showNormalizedTerm, showSplit}
 import mlscript.pretyper.{PreTyper, Scope}
 import mlscript.pretyper.symbol._
@@ -72,7 +72,7 @@ trait Desugarer extends Transformation
       * A short hand for `nme.symbol.getScrutinee` but add a diagnostic message
       * to a local diagnostic archive (TODO) if there's any error.
       */
-    def getOrCreateScrutinee(implicit context: Context): ScrutineeData = nme.symbolOption match {
+    def getOrCreateScrutinee(implicit context: Context): Scrutinee = nme.symbolOption match {
       case S(symbol: TermSymbol) => symbol.getOrCreateScrutinee
       case S(otherSymbol) => throw new DesugaringException(
         msg"Expected scrutinee symbol, found ${nme.symbol.name}" -> nme.toLoc :: Nil
@@ -81,7 +81,7 @@ trait Desugarer extends Transformation
     }
 
     /** Associate the `Var` with a scrutinee and returns the same `Var`. */
-    def withScrutinee(scrutinee: ScrutineeData)(implicit context: Context): Var = nme.symbolOption match {
+    def withScrutinee(scrutinee: Scrutinee)(implicit context: Context): Var = nme.symbolOption match {
       case S(symbol: TermSymbol) =>
         symbol.addScrutinee(scrutinee)
         nme
diff --git a/shared/src/main/scala/mlscript/ucs/context/Context.scala b/shared/src/main/scala/mlscript/ucs/context/Context.scala
index 3e5941576f..63ccc90623 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Context.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Context.scala
@@ -43,16 +43,16 @@ class Context(originalTerm: If) {
   // ====================
 
   /** The buffer contains all `ScrutineeData` created within this context. */
-  private val scrutineeBuffer: Buffer[ScrutineeData] = Buffer.empty
+  private val scrutineeBuffer: Buffer[Scrutinee] = Buffer.empty
 
-  def freshScrutinee: ScrutineeData = {
-    val scrutinee = new ScrutineeData(this, N)
+  def freshScrutinee: Scrutinee = {
+    val scrutinee = new Scrutinee(this, N)
     scrutineeBuffer += scrutinee
     scrutinee
   }
 
-  private[context] def freshScrutinee(parent: ScrutineeData): ScrutineeData = {
-    val scrutinee = new ScrutineeData(this, S(parent))
+  private[context] def freshScrutinee(parent: Scrutinee): Scrutinee = {
+    val scrutinee = new Scrutinee(this, S(parent))
     scrutineeBuffer += scrutinee
     scrutinee
   }
diff --git a/shared/src/main/scala/mlscript/ucs/context/Matchable.scala b/shared/src/main/scala/mlscript/ucs/context/Matchable.scala
index ab85e6de59..6fec70165e 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Matchable.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Matchable.scala
@@ -14,7 +14,7 @@ trait Matchable {
     * context. The reason why we need this map is that the same symbol may be
     * matched in different UCS terms. Each context corresponds to a UCS term. 
     */
-  private val scrutinees: MutMap[Context, ScrutineeData] = MutMap.empty
+  private val scrutinees: MutMap[Context, Scrutinee] = MutMap.empty
     
   /**
     * Get the scrutinee associated with the symbol in the given context. If
@@ -22,23 +22,23 @@ trait Matchable {
     * given context. **Note**: This function should only be called from the
     * UCS desugarer.
     */
-  private[ucs] def getOrCreateScrutinee(implicit context: Context): ScrutineeData =
+  private[ucs] def getOrCreateScrutinee(implicit context: Context): Scrutinee =
     scrutinees.getOrElseUpdate(context, context.freshScrutinee)
 
   /** Get the scrutinee associated with the symbol in the given context. */
-  def getScrutinee(implicit context: Context): Opt[ScrutineeData] = scrutinees.get(context)
+  def getScrutinee(implicit context: Context): Opt[Scrutinee] = scrutinees.get(context)
 
   /** Check if the symbol is associated with a scrutinee in the given context. */
   def isScrutinee(implicit context: Context): Bool = scrutinees.contains(context)
 
   /** Associate the symbol with a scrutinee in the given context. */
-  private[ucs] def addScrutinee(scrutinee: ScrutineeData)(implicit context: Context): Unit = {
+  private[ucs] def addScrutinee(scrutinee: Scrutinee)(implicit context: Context): Unit = {
     require(!isScrutinee) // It should be impossible to add a scrutinee twice.
     scrutinees += context -> scrutinee
   }
 
   /** Associate the symbol with a scrutinee in the given context and returns the current object. */
-  private[ucs] def withScrutinee(scrutinee: ScrutineeData)(implicit context: Context): this.type = {
+  private[ucs] def withScrutinee(scrutinee: Scrutinee)(implicit context: Context): this.type = {
     addScrutinee(scrutinee)
     this
   }
diff --git a/shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala b/shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala
index 9d6f15e688..07362bed82 100644
--- a/shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala
@@ -32,9 +32,9 @@ abstract class PatternInfo {
 }
 
 object PatternInfo {
-  class ClassLike(val classLikeSymbol: TypeSymbol, scrutinee: ScrutineeData) extends PatternInfo {
+  class ClassLike(val classLikeSymbol: TypeSymbol, scrutinee: Scrutinee) extends PatternInfo {
     private var unappliedVarOpt: Opt[Var] = N
-    private val parameters: MutSortedMap[Int, ScrutineeData] = MutSortedMap.empty
+    private val parameters: MutSortedMap[Int, Scrutinee] = MutSortedMap.empty
 
     /**
       * Get or create a sub-scrutinee for the given parameter index.
@@ -43,7 +43,7 @@ object PatternInfo {
       * @return a `ScrutineeData` for the parameter whose parent scrutinee is the
       *         current scrutinee
       */
-    def getParameter(index: Int): ScrutineeData = {
+    def getParameter(index: Int): Scrutinee = {
       require(index >= 0)
       parameters.getOrElseUpdate(index, scrutinee.freshSubScrutinee)
     }
@@ -73,10 +73,10 @@ object PatternInfo {
       Var(classLikeSymbol.name).withLoc(firstOccurrence).withSymbol(classLikeSymbol)
   }
 
-  class Tuple(scrutinee: ScrutineeData) extends PatternInfo {
-    private val fields: MutSortedMap[Int, ScrutineeData] = MutSortedMap.empty
+  class Tuple(scrutinee: Scrutinee) extends PatternInfo {
+    private val fields: MutSortedMap[Int, Scrutinee] = MutSortedMap.empty
 
-    def getField(index: Int): ScrutineeData =
+    def getField(index: Int): Scrutinee =
       fields.getOrElseUpdate(index, scrutinee.freshSubScrutinee)
 
     override def arity: Opt[Int] = fields.keysIterator.maxOption.map(_ + 1)
diff --git a/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
similarity index 95%
rename from shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
rename to shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
index 4ca6aede96..315d2f0600 100644
--- a/shared/src/main/scala/mlscript/ucs/context/ScrutineeData.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
@@ -10,8 +10,8 @@ import mlscript.IntLit
 import mlscript.StrLit
 import mlscript.UnitLit
 
-class ScrutineeData(val context: Context, parent: Opt[ScrutineeData]) {
-  import ScrutineeData._
+class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
+  import Scrutinee._
 
   private val locations: Buffer[Loc] = Buffer.empty
   private var generatedVarOpt: Opt[Var] = N
@@ -34,7 +34,7 @@ class ScrutineeData(val context: Context, parent: Opt[ScrutineeData]) {
 
   def +=(alias: Var): Unit = alisesSet += alias
 
-  def withAlias(alias: Var): ScrutineeData = { this += alias; this }
+  def withAlias(alias: Var): Scrutinee = { this += alias; this }
 
   def aliasesIterator: Iterator[Var] = alisesSet.iterator
 
@@ -101,7 +101,7 @@ class ScrutineeData(val context: Context, parent: Opt[ScrutineeData]) {
     (classLikePatternsStr ++ tuplePatternStr).mkString(", ")
   }
 
-  def freshSubScrutinee: ScrutineeData = context.freshScrutinee(this)
+  def freshSubScrutinee: Scrutinee = context.freshScrutinee(this)
 
   def toCaseSet: CaseSet = {
     import mlscript.ucs.context.Pattern
@@ -118,14 +118,14 @@ class ScrutineeData(val context: Context, parent: Opt[ScrutineeData]) {
   }
 }
 
-object ScrutineeData {
+object Scrutinee {
   // We might need to move these method to a private `VarOps` because they may
   // emit diagnostics.
 
   import mlscript.Term
   import mlscript.pretyper.symbol.TermSymbol
 
-  def unapply(term: Term)(implicit context: Context): Opt[ScrutineeData] = term match {
+  def unapply(term: Term)(implicit context: Context): Opt[Scrutinee] = term match {
     case v: Var => v.symbol match {
       case symbol: TermSymbol => symbol.getScrutinee
       case _ => N
@@ -134,7 +134,7 @@ object ScrutineeData {
   }
 
   object WithVar {
-    def unapply(term: Term)(implicit context: Context): Opt[(ScrutineeData, Var)] = term match {
+    def unapply(term: Term)(implicit context: Context): Opt[(Scrutinee, Var)] = term match {
       case v @ Var(_) => v.symbol match {
         case symbol: TermSymbol => symbol.getScrutinee.map(_ -> v)
         case _ => N
diff --git a/shared/src/main/scala/mlscript/ucs/context/package.scala b/shared/src/main/scala/mlscript/ucs/context/package.scala
index 03a1e46b9c..bc61762f65 100644
--- a/shared/src/main/scala/mlscript/ucs/context/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/package.scala
@@ -5,9 +5,9 @@ import mlscript.pretyper.symbol.TypeSymbol
 import mlscript.utils._, shorthands._
 
 package object context {
-  type NamedScrutineeData = (Var -> ScrutineeData)
+  type NamedScrutinee = (Var -> Scrutinee)
 
-  type MatchRegistry = Map[NamedScrutineeData, CaseSet]
+  type MatchRegistry = Map[NamedScrutinee, CaseSet]
 
-  type SeenRegistry = Map[NamedScrutineeData, (TypeSymbol, Ls[Loc], CaseSet)]  
+  type SeenRegistry = Map[NamedScrutinee, (TypeSymbol, Ls[Loc], CaseSet)]  
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index d85019bbe4..3bb3c6ffb8 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -4,7 +4,7 @@ import mlscript.{Case, CaseBranches, CaseOf, Let, Lit, Loc, NoCases, Term, Var,
 import mlscript.{Diagnostic, ErrorReport, WarningReport}
 import mlscript.Message, Message.MessageContext
 import mlscript.ucs.Desugarer
-import mlscript.ucs.context.{Context, CaseSet, NamedScrutineeData, MatchRegistry, ScrutineeData, SeenRegistry}
+import mlscript.ucs.context.{Context, CaseSet, NamedScrutinee, MatchRegistry, Scrutinee, SeenRegistry}
 import mlscript.pretyper.Traceable
 import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
@@ -33,7 +33,7 @@ trait CoverageChecking { self: Desugarer with Traceable =>
         case CaseOf(scrutineeVar: Var, Case(Var("true"), body, NoCases)) if context.isTestVar(scrutineeVar) =>
           raiseDesugaringError(msg"missing else branch" -> body.toLoc)
           Nil
-        case CaseOf(ScrutineeData.WithVar(scrutinee, scrutineeVar), cases) =>
+        case CaseOf(Scrutinee.WithVar(scrutinee, scrutineeVar), cases) =>
           println(s"scrutinee: ${scrutineeVar.name}")
           // If the scrutinee is still pending (i.e., not matched yet), then we
           // remove it from the pending list. If the scrutinee is matched, and
@@ -113,7 +113,7 @@ trait CoverageChecking { self: Desugarer with Traceable =>
 
 object CoverageChecking {
   /** Create an `ErrorReport` that explains missing cases. */
-  private def explainMissingCases(scrutinee: NamedScrutineeData, seen: SeenRegistry, missingCases: CaseSet): Opt[ErrorReport] =
+  private def explainMissingCases(scrutinee: NamedScrutinee, seen: SeenRegistry, missingCases: CaseSet): Opt[ErrorReport] =
     if (missingCases.isEmpty) {
       N
     } else {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index c67176d3bc..f634b1715c 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -2,7 +2,7 @@ package mlscript.ucs.stages
 
 import mlscript.{App, Asc, Fld, FldFlags, Lit, Sel, Term, Tup, TypeName, Var}
 import mlscript.ucs.syntax.{core => c, source => s}
-import mlscript.ucs.context.{Context, ScrutineeData}
+import mlscript.ucs.context.{Context, Scrutinee}
 import mlscript.utils._, shorthands._
 import mlscript.pretyper.symbol._
 import mlscript.pretyper.{PreTyper, Scope}
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 9fcc757f15..87af99b3ef 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -7,7 +7,7 @@ import mlscript.Message, Message.MessageContext
 import mlscript.utils._, shorthands._
 import mlscript.ucs, mlscript.pretyper
 import ucs.{Desugarer, Lines, LinesOps, VariableGenerator}
-import ucs.context.{Context, ScrutineeData}
+import ucs.context.{Context, Scrutinee}
 import ucs.display.{showNormalizedTerm, showSplit}
 import ucs.syntax.core.{Pattern, Branch, Split}
 import pretyper.Scope
@@ -120,7 +120,7 @@ trait Normalization { self: Desugarer with Traceable =>
         val trueBranch = normalizeToTerm(continuation.fill(tail, false, false))
         val falseBranch = normalizeToCaseBranches(tail)
         CaseOf(test, Case(nme, trueBranch, falseBranch)(refined = false))
-      case Split.Cons(Branch(ScrutineeData.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Literal(literal), continuation), tail) =>
+      case Split.Cons(Branch(Scrutinee.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Literal(literal), continuation), tail) =>
         println(s"LITERAL: ${scrutineeVar.name} is ${literal.idStr}")
         println(s"entire split: ${showSplit(split)}")
         val concatenatedTrueBranch = continuation.fill(tail, false, false)
@@ -129,7 +129,7 @@ trait Normalization { self: Desugarer with Traceable =>
         // println(s"false branch: ${showSplit(tail)}")
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context))
         CaseOf(scrutineeVar, Case(literal, trueBranch, falseBranch)(refined = false))
-      case Split.Cons(Branch(ScrutineeData.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Class(nme, rfd), continuation), tail) =>
+      case Split.Cons(Branch(Scrutinee.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Class(nme, rfd), continuation), tail) =>
         println(s"CLASS: ${scrutineeVar.name} is ${nme.name}")
         // println(s"match ${scrutineeVar.name} with $nme (has location: ${nme.toLoc.isDefined})")
         val trueBranch = normalizeToTerm(specialize(continuation.fill(tail, false, false), true)(scrutineeVar, scrutinee, pattern, context))
@@ -187,7 +187,7 @@ trait Normalization { self: Desugarer with Traceable =>
     */
   private def specialize
       (split: Split, matchOrNot: Bool)
-      (implicit scrutineeVar: Var, scrutinee: ScrutineeData, pattern: Pattern, context: Context): Split =
+      (implicit scrutineeVar: Var, scrutinee: Scrutinee, pattern: Pattern, context: Context): Split =
   trace[Split](s"S${if (matchOrNot) "+" else "-"} <== ${scrutineeVar.name} is ${pattern}") {
     (matchOrNot, split) match {
       // Name patterns are translated to let bindings.
@@ -199,7 +199,7 @@ trait Normalization { self: Desugarer with Traceable =>
         val falseBranch = specialize(tail, matchOrNot)
         split.copy(head = head.copy(continuation = trueBranch), tail = falseBranch)
       // Class pattern. Positive.
-      case (true, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName, otherRefined), continuation), tail)) =>
+      case (true, split @ Split.Cons(head @ Branch(Scrutinee.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName, otherRefined), continuation), tail)) =>
         val otherClassSymbol = otherClassName.getClassLikeSymbol
         if (scrutinee === otherScrutinee) {
           println(s"scrutinee: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
@@ -243,7 +243,7 @@ trait Normalization { self: Desugarer with Traceable =>
           )
         }
       // Class pattern. Negative
-      case (false, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName, otherRefined), continuation), tail)) =>
+      case (false, split @ Split.Cons(head @ Branch(Scrutinee.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName, otherRefined), continuation), tail)) =>
         val otherClassSymbol = otherClassName.getClassLikeSymbol
         if (scrutinee === otherScrutinee) {
           println(s"scrutinee: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
@@ -281,7 +281,7 @@ trait Normalization { self: Desugarer with Traceable =>
           )
         }
       // Literal pattern. Positive.
-      case (true, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Literal(otherLiteral), continuation), tail)) =>
+      case (true, split @ Split.Cons(head @ Branch(Scrutinee.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Literal(otherLiteral), continuation), tail)) =>
         if (scrutinee === otherScrutinee) {
           println(s"scrutinee: ${scrutineeVar.name} is ${otherScrutineeVar.name}")
           pattern match {
@@ -297,7 +297,7 @@ trait Normalization { self: Desugarer with Traceable =>
           )
         }
       // Literal pattern. Negative.
-      case (false, split @ Split.Cons(head @ Branch(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Literal(otherLiteral), continuation), tail)) =>
+      case (false, split @ Split.Cons(head @ Branch(Scrutinee.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Literal(otherLiteral), continuation), tail)) =>
         if (scrutinee === otherScrutinee) {
           println(s"scrutinee: ${scrutineeVar.name} is ${otherScrutineeVar.name}")
           pattern match {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index 9cfd1f2651..fb496df034 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -2,7 +2,7 @@ package mlscript.ucs.stages
 
 import mlscript.{Case, CaseBranches, CaseOf, Let, Lit, Loc, NoCases, Term, Var, Wildcard}
 import mlscript.ucs.Desugarer
-import mlscript.ucs.context.{Context, PatternInfo, ScrutineeData}
+import mlscript.ucs.context.{Context, PatternInfo, Scrutinee}
 import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
 import mlscript.Message, Message.MessageContext
@@ -14,11 +14,11 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
   def postProcess(term: Term)(implicit context: Context): Term = trace(s"postProcess <== ${term.showDbg}") {
     // Normalized terms are constructed using `Let` and `CaseOf`.
     term match {
-      case top @ CaseOf(ScrutineeData(_), Wildcard(body)) => body
-      case top @ CaseOf(ScrutineeData.WithVar(scrutinee, scrutineeVar), fst @ Case(className: Var, body, NoCases)) =>
+      case top @ CaseOf(Scrutinee(_), Wildcard(body)) => body
+      case top @ CaseOf(Scrutinee.WithVar(scrutinee, scrutineeVar), fst @ Case(className: Var, body, NoCases)) =>
         println(s"UNARY: ${scrutineeVar.name} is ${className.name}")
         top.copy(cases = fst.copy(body = postProcess(body))(refined = fst.refined))
-      case top @ CaseOf(ScrutineeData.WithVar(scrutinee, scrutineeVar), fst @ Case(pat, trueBranch, Wildcard(falseBranch))) =>
+      case top @ CaseOf(Scrutinee.WithVar(scrutinee, scrutineeVar), fst @ Case(pat, trueBranch, Wildcard(falseBranch))) =>
         println(s"BINARY: ${scrutineeVar.name} is ${pat.showDbg}")
         println(s"patterns of `${scrutineeVar.name}`: ${scrutinee.showPatternsDbg}")
         // Post-process the true branch.
@@ -125,12 +125,12 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
   private def disentangleTerm(term: Term)(implicit
       context: Context,
       scrutineeVar: Var,
-      scrutinee: ScrutineeData,
+      scrutinee: Scrutinee,
       pattern: PatternInfo
   ): (Term, Opt[Term]) = {
     def rec(term: Term): (Term, Opt[Term]) =
       term match {
-        case top @ CaseOf(ScrutineeData.WithVar(otherScrutinee, otherScrutineeVar), cases) =>
+        case top @ CaseOf(Scrutinee.WithVar(otherScrutinee, otherScrutineeVar), cases) =>
           if (scrutinee === otherScrutinee) {
             println(s"found a `CaseOf` that matches on `${scrutineeVar.name}`")
             val (n, y) = disentangleMatchedCaseBranches(cases)
@@ -158,7 +158,7 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
   private def disentangleMatchedCaseBranches(cases: CaseBranches)(implicit
       context: Context,
       scrutineeVar: Var,
-      scrutinee: ScrutineeData,
+      scrutinee: Scrutinee,
       pattern: PatternInfo
   ): (CaseBranches, Opt[Term]) =
     cases match {
@@ -187,7 +187,7 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
   private def disentangleUnmatchedCaseBranches(cases: CaseBranches)(implicit
       context: Context,
       scrutineeVar: Var,
-      scrutinee: ScrutineeData,
+      scrutinee: Scrutinee,
       pattern: PatternInfo
   ): (CaseBranches, CaseBranches) =
     cases match {

From 2896a698581093e86c08800ded00299f2e24bba1 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 16 Jan 2024 20:40:30 +0800
Subject: [PATCH 077/147] Remove `TODO`s and fix lack unreachable case warning

---
 .../mlscript/ucs/context/Scrutinee.scala      |  8 +-
 .../src/main/scala/mlscript/ucs/display.scala |  2 -
 .../mlscript/ucs/stages/Desugaring.scala      | 89 ++++++++-----------
 .../pretyper/ucs/patterns/SimpleTuple.mls     | 48 ++++++----
 4 files changed, 73 insertions(+), 74 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
index 315d2f0600..685cbb50c2 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
@@ -23,7 +23,7 @@ class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
   // If we support tuple pattern splice, we need a more expressive key in the
   // map's type.
   private var tuplePatternOpt: Opt[PatternInfo.Tuple] = N
-  private var alisesSet: MutSortedSet[Var] = MutSortedSet.empty
+  private var aliasVarSet: MutSortedSet[Var] = MutSortedSet.empty
 
   private val literalPatterns: MutSortedMap[Lit, PatternInfo.Literal] = MutSortedMap.empty(literalOrdering)
   /**
@@ -32,11 +32,11 @@ class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
     */
   private val booleanPatterns: MutSortedMap[Var, PatternInfo.Boolean] = MutSortedMap.empty(varNameOrdering)
 
-  def +=(alias: Var): Unit = alisesSet += alias
+  def addAliasVar(alias: Var): Unit = aliasVarSet += alias
 
-  def withAlias(alias: Var): Scrutinee = { this += alias; this }
+  def withAliasVar(alias: Var): Scrutinee = { addAliasVar(alias); this }
 
-  def aliasesIterator: Iterator[Var] = alisesSet.iterator
+  def aliasesIterator: Iterator[Var] = aliasVarSet.iterator
 
   /**
     * If there is already a `PatternInfo.ClassLike` for the given symbol, return it.
diff --git a/shared/src/main/scala/mlscript/ucs/display.scala b/shared/src/main/scala/mlscript/ucs/display.scala
index 288c1434e4..2811baee02 100644
--- a/shared/src/main/scala/mlscript/ucs/display.scala
+++ b/shared/src/main/scala/mlscript/ucs/display.scala
@@ -25,7 +25,6 @@ package object display {
   }
 
   def showSplit(split: s.TermSplit)(implicit context: Context): Str = {
-    // TODO: tailrec
     def termSplit(split: s.TermSplit, isFirst: Bool, isAfterAnd: Bool): Lines = split match {
       case s.Split.Cons(head, tail) => (termBranch(head) match {
         case (n, line) :: tail => (n, (if (isAfterAnd) "" else "and ") + s"$line") :: tail
@@ -77,7 +76,6 @@ package object display {
   @inline def showSplit(s: c.Split)(implicit context: Context): Str = showSplit("if", s)
 
   def showSplit(prefix: Str, s: c.Split)(implicit context: Context): Str = {
-    // TODO: tailrec
     def split(s: c.Split, isFirst: Bool, isTopLevel: Bool): Lines = s match {
       case c.Split.Cons(head, tail) => (branch(head) match {
         case (n, line) :: tail => (n, (if (isTopLevel) "" else "") + s"$line") :: tail
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index f634b1715c..d82a2f1852 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -137,12 +137,12 @@ trait Desugaring { self: PreTyper =>
       parameters.iterator.zipWithIndex.map {
         case (_: s.EmptyPattern, _) => N
         case (s.NamePattern(name), index) =>
-          val subScrutinee = classPattern.getParameter(index).withAlias(name)
+          val subScrutinee = classPattern.getParameter(index).withAliasVar(name)
           S(name.withFreshSymbol.withScrutinee(subScrutinee) -> N)
         case (parameterPattern @ (s.ClassPattern(_, _, _) | s.LiteralPattern(_) | s.TuplePattern(_)), index) =>
           val subScrutineeVar = freshSubScrutineeVar(parentScrutineeVar, parentClassLikeSymbol.name, index)
           val symbol = new LocalTermSymbol(subScrutineeVar)
-          symbol.addScrutinee(classPattern.getParameter(index).withAlias(subScrutineeVar))
+          symbol.addScrutinee(classPattern.getParameter(index).withAliasVar(subScrutineeVar))
           S(subScrutineeVar.withSymbol(symbol) -> S(parameterPattern))
         case (pattern, _) =>
           raiseDesugaringError(msg"unsupported pattern" -> pattern.toLoc)
@@ -173,7 +173,7 @@ trait Desugaring { self: PreTyper =>
       scrutineeVar: Var,
       initialScope: Scope,
       refined: Bool)(implicit context: Context): (Scope, c.Split => c.Branch) = {
-    val scrutinee = scrutineeVar.getOrCreateScrutinee.withAlias(scrutineeVar)
+    val scrutinee = scrutineeVar.getOrCreateScrutinee.withAliasVar(scrutineeVar)
     val patternClassSymbol = pattern.nme.resolveClassLikeSymbol(initialScope, context)
     val classPattern = scrutinee.getOrCreateClassPattern(patternClassSymbol)
     println(s"desugarClassPattern: ${scrutineeVar.name} is ${pattern.nme.name}")
@@ -243,7 +243,7 @@ trait Desugaring { self: PreTyper =>
           (scopeWithNestedAll, split => bindPrevious(bindNestedAll(split) :: c.Split.Nil))
         case ((scope, bindPrevious), S(nme -> S(pattern: s.LiteralPattern))) =>
           nme.getOrCreateScrutinee
-             .withAlias(nme)
+             .withAliasVar(nme)
              .getOrCreateLiteralPattern(pattern.literal)
              .addLocation(pattern.literal)
           (scope, makeLiteralTest(nme, pattern.literal)(scope).andThen(bindPrevious))
@@ -271,7 +271,7 @@ trait Desugaring { self: PreTyper =>
         val arity = fields.length
         val subScrutineeVar = freshSubScrutineeVar(parentScrutineeVar, s"Tuple$$$arity", index)
         val symbol = new LocalTermSymbol(subScrutineeVar)
-        symbol.addScrutinee(tuplePattern.getField(index).withAlias(subScrutineeVar))
+        symbol.addScrutinee(tuplePattern.getField(index).withAliasVar(subScrutineeVar))
         S(subScrutineeVar.withSymbol(symbol) -> S(parameterPattern))
       case (pattern, _) =>
         raiseDesugaringError(msg"unsupported pattern" -> pattern.toLoc)
@@ -280,7 +280,7 @@ trait Desugaring { self: PreTyper =>
   }
 
   private def desugarTuplePattern(fields: Ls[s.Pattern], scrutineeVar: Var, initialScope: Scope)(implicit context: Context): (Scope, c.Split => c.Split) = {
-    val scrutinee = scrutineeVar.getOrCreateScrutinee.withAlias(scrutineeVar)
+    val scrutinee = scrutineeVar.getOrCreateScrutinee.withAliasVar(scrutineeVar)
     val nestedPatterns = flattenTupleFields(scrutineeVar, fields)
     val bindFields = nestedPatterns.iterator.zipWithIndex.foldRight[c.Split => c.Split](identity) {
       case ((N, _), bindNextField) => bindNextField
@@ -292,72 +292,55 @@ trait Desugaring { self: PreTyper =>
     desugarNestedPatterns(nestedPatterns, scopeWithFields, bindFields)
   }
 
-  private def desugarPatternSplit(scrutineeTerm: Term, split: s.PatternSplit)(implicit scope: Scope, context: Context): c.Split = {
+  private def desugarPatternSplit(
+      scrutineeTerm: Term,
+      split: s.PatternSplit
+  )(implicit scope: Scope, context: Context): c.Split = {
     def rec(scrutineeVar: Var, split: s.PatternSplit)(implicit scope: Scope): c.Split = split match {
-      // TODO: We should resolve `scrutineeVar`'s symbol and make sure it is a term symbol in the
-      // beginning. So that we can call methods on the symbol directly. Now there are too many
-      // helper functions on `VarOps`.
       case s.Split.Cons(head, tail) =>
+        val scrutineeSymbol = scrutineeVar.getOrResolveTermSymbol
+        val scrutinee = scrutineeSymbol.getOrCreateScrutinee
+        scrutinee.addAliasVar(scrutineeVar)
+        // Some functions that allow me to write less code, this function was
+        // very long before I introduced them.
+        def desugarRight(implicit scope: Scope) =
+          desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context)
+        def desugarTail(implicit scope: Scope) = rec(scrutineeVar, tail)
         head.pattern match {
           case pattern @ s.AliasPattern(_, _) =>
             raiseDesugaringError(msg"alias pattern is not supported for now" -> pattern.toLoc)
-            rec(scrutineeVar, tail)
+            desugarTail
           case s.LiteralPattern(literal) =>
-            scrutineeVar.getOrCreateScrutinee.withAlias(scrutineeVar).getOrCreateLiteralPattern(literal).addLocation(literal)
-            c.Branch(
-              scrutinee = scrutineeVar,
-              pattern = c.Pattern.Literal(literal),
-              continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context)
-            ) :: rec(scrutineeVar, tail)
+            scrutinee.getOrCreateLiteralPattern(literal).addLocation(literal)
+            c.Branch(scrutineeVar, c.Pattern.Literal(literal), desugarRight) :: desugarTail
           case s.ConcretePattern(nme @ (Var("true") | Var("false"))) =>
-            scrutineeVar.getOrCreateScrutinee.withAlias(scrutineeVar).getOrCreateBooleanPattern(nme).addLocation(nme)
+            scrutinee.getOrCreateBooleanPattern(nme).addLocation(nme)
             c.Branch(
               scrutinee = scrutineeVar,
               pattern = c.Pattern.Class(nme.withResolvedClassLikeSymbol, false),
-              continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context)
-            ) :: rec(scrutineeVar, tail)
+              continuation = desugarRight
+            ) :: desugarTail
           case s.ConcretePattern(nme) =>
-            val test = context.freshTest().withFreshSymbol
-            c.Split.Let(
-              rec = false,
-              name = test,
-              term = mkBinOp(scrutineeVar, Var("==="), nme, true),
-              tail = c.Branch(
-                scrutinee = test,
-                pattern = truePattern,
-                continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope + test.symbol, context)
-              ) :: rec(scrutineeVar, tail)
-            )
+            val testVar = context.freshTest().withFreshSymbol
+            val testTerm = mkBinOp(scrutineeVar, Var("==="), nme, true)
+            c.Split.Let(false, testVar, testTerm,
+              c.Branch(testVar, truePattern, desugarRight(scope + testVar.symbol)) :: desugarTail)
           case s.EmptyPattern(_) | s.NamePattern(Var("_")) =>
-            desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context) ++ rec(scrutineeVar, tail)
+            desugarRight ++ desugarTail
           case s.NamePattern(nme) =>
-            // Create a symbol for the binding.
-            val symbol = new LocalTermSymbol(nme)
-            // Share the scrutineeVar's symbol with its aliases.
-            symbol.addScrutinee(scrutineeVar.getOrCreateScrutinee.withAlias(nme))
-            // Associate the symbol with the binding.
-            nme.symbol = symbol
-            // Whoosh! Done.
-            val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scope + nme.symbol, context)
-            c.Branch(scrutineeVar, c.Pattern.Name(nme), continuation) :: rec(scrutineeVar, tail)(scope + nme.symbol)
+            val symbol = freshSymbol(nme).withScrutinee(scrutinee)
+            val scopeWithSymbol = scope + symbol
+            c.Branch(scrutineeVar, c.Pattern.Name(nme.withSymbol(symbol)),
+              desugarRight(scopeWithSymbol)) :: desugarTail(scopeWithSymbol)
           case pattern @ s.ClassPattern(nme, fields, rfd) =>
-            val scrutineeSymbol = scrutineeVar.getOrResolveTermSymbol // TODO: Useless.
             val (scopeWithAll, bindAll) = desugarClassPattern(pattern, scrutineeVar, scope, rfd)
-            val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scopeWithAll, context)
-            bindAll(continuation) :: rec(scrutineeVar, tail)
+            bindAll(desugarRight(scopeWithAll)) :: desugarTail
           case s.TuplePattern(fields) =>
-            val scrutineeSymbol = scrutineeVar.getOrResolveTermSymbol // TODO: Useless.
             val (scopeWithAll, bindAll) = desugarTuplePattern(fields, scrutineeVar, scope)
-            val continuation = desugarTermSplit(head.continuation)(PartialTerm.Empty, scopeWithAll, context)
-            val withBindings = bindAll(continuation)
-            if (withBindings.hasElse) {
-              withBindings
-            } else {
-              withBindings ++ rec(scrutineeVar, tail)
-            }
+            bindAll(desugarRight(scopeWithAll)) ++ desugarTail
           case pattern @ s.RecordPattern(_) =>
             raiseDesugaringError(msg"record pattern is not supported for now" -> pattern.toLoc)
-            rec(scrutineeVar, tail)
+            desugarTail
         }
       case s.Split.Let(isRec, nme, rhs, tail) =>
         c.Split.Let(isRec, nme, rhs, rec(scrutineeVar, tail)(scope + nme.withFreshSymbol.symbol)) // <-- Weird use.
diff --git a/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls b/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls
index ea4536bc6b..0a0144e3d5 100644
--- a/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls
+++ b/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls
@@ -39,6 +39,7 @@ test(12)
 //│ res
 //│     = 0
 
+:w
 // Since pattern destruction is desugared to let bindings, matching with other
 // classes after the tuple pattern will not work.
 class Point(x: Int, y: Int)
@@ -46,13 +47,23 @@ fun discarded_cases(thing) =
   if thing is
     [x, y] then x + y
     Point(x, y) then x + y
+//│ ╔══[WARNING] the case is unreachable
+//│ ║  l.47: 	  if thing is
+//│ ║        	     ^^^^^^^^
+//│ ║  l.48: 	    [x, y] then x + y
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.49: 	    Point(x, y) then x + y
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── because this branch covers the case
+//│ ║  l.48: 	    [x, y] then x + y
+//│ ╙──      	                ^^^^^
 //│ class Point(x: Int, y: Int)
 //│ fun discarded_cases: {0: Int, 1: Int} -> Int
 
 :e
 discarded_cases(Point(0, 0))
 //│ ╔══[ERROR] Type `Point` does not contain member `1`
-//│ ║  l.47: 	    [x, y] then x + y
+//│ ║  l.48: 	    [x, y] then x + y
 //│ ╙──      	        ^
 //│ Int | error
 //│ res
@@ -74,31 +85,38 @@ working_cases(Point(0, 0))
 :e
 working_cases([0, 0])
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.75: 	working_cases([0, 0])
+//│ ║  l.86: 	working_cases([0, 0])
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── tuple literal of type `[0, 0]` is not an instance of type `Object`
-//│ ║  l.75: 	working_cases([0, 0])
+//│ ║  l.86: 	working_cases([0, 0])
 //│ ║        	              ^^^^^^
 //│ ╟── Note: constraint arises from `case` expression:
-//│ ║  l.63: 	  if thing is
+//│ ║  l.74: 	  if thing is
 //│ ║        	     ^^^^^^^^
-//│ ║  l.64: 	    Point(x, y) then x + y
+//│ ║  l.75: 	    Point(x, y) then x + y
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.65: 	    [x, y] then x + y
+//│ ║  l.76: 	    [x, y] then x + y
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── from reference:
-//│ ║  l.63: 	  if thing is
+//│ ║  l.74: 	  if thing is
 //│ ╙──      	     ^^^^^
 //│ Int | error
 //│ res
 //│     = 0
 
+:w
 fun not_working(x) =
   if x is
     [a, b, c] then
       a + b + c
     else
       0
+//│ ╔══[WARNING] the case is unreachable
+//│ ║  l.113: 	      0
+//│ ║         	      ^
+//│ ╟── because this branch covers the case
+//│ ║  l.111: 	      a + b + c
+//│ ╙──       	      ^^^^^^^^^
 //│ fun not_working: {0: Int, 1: Int, 2: Int} -> Int
 
 not_working([1, 2, 3])
@@ -109,19 +127,19 @@ not_working([1, 2, 3])
 :e
 not_working([1, 2])
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.110: 	not_working([1, 2])
+//│ ║  l.128: 	not_working([1, 2])
 //│ ║         	^^^^^^^^^^^^^^^^^^^
 //│ ╟── tuple literal of type `{0: 1, 1: 2}` does not have field '2'
-//│ ║  l.110: 	not_working([1, 2])
+//│ ║  l.128: 	not_working([1, 2])
 //│ ║         	            ^^^^^^
 //│ ╟── Note: constraint arises from field selection:
-//│ ║  l.97: 	  if x is
-//│ ║        	     ^^^^
-//│ ║  l.98: 	    [a, b, c] then
-//│ ║        	^^^^^^^^^^^^
+//│ ║  l.109: 	  if x is
+//│ ║         	     ^^^^
+//│ ║  l.110: 	    [a, b, c] then
+//│ ║         	^^^^^^^^^^^^
 //│ ╟── from reference:
-//│ ║  l.97: 	  if x is
-//│ ╙──      	     ^
+//│ ║  l.109: 	  if x is
+//│ ╙──       	     ^
 //│ Int | error
 //│ res
 //│     = NaN

From fbf7519471808ebad9c36af2acf4b89d838ca8b0 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 16 Jan 2024 20:59:58 +0800
Subject: [PATCH 078/147] Remove `DesugaringException`

---
 .../main/scala/mlscript/ucs/Desugarer.scala   |  24 ++--
 .../src/main/scala/mlscript/ucs/package.scala |   6 -
 shared/src/test/diff/mlscript/Repro.mls       |  40 +-----
 shared/src/test/diff/pretyper/SymbolKind.mls  | 118 ++++++++++++++++++
 4 files changed, 129 insertions(+), 59 deletions(-)
 create mode 100644 shared/src/test/diff/pretyper/SymbolKind.mls

diff --git a/shared/src/main/scala/mlscript/ucs/Desugarer.scala b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
index ca29850af3..35af9094d2 100644
--- a/shared/src/main/scala/mlscript/ucs/Desugarer.scala
+++ b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
@@ -74,10 +74,10 @@ trait Desugarer extends Transformation
       */
     def getOrCreateScrutinee(implicit context: Context): Scrutinee = nme.symbolOption match {
       case S(symbol: TermSymbol) => symbol.getOrCreateScrutinee
-      case S(otherSymbol) => throw new DesugaringException(
-        msg"Expected scrutinee symbol, found ${nme.symbol.name}" -> nme.toLoc :: Nil
-      )
-      case N => throw new DesugaringException(msg"Scrutinee symbol not found" -> nme.toLoc :: Nil)
+      case S(otherSymbol) =>
+        raiseDesugaringError(msg"cannot identifier `${nme.name}` with a scrutinee" -> nme.toLoc)
+        context.freshScrutinee // TODO
+      case N => lastWords(s"`${nme.name}` should be assoicated with a symbol")
     }
 
     /** Associate the `Var` with a scrutinee and returns the same `Var`. */
@@ -85,12 +85,10 @@ trait Desugarer extends Transformation
       case S(symbol: TermSymbol) =>
         symbol.addScrutinee(scrutinee)
         nme
-      case S(otherSymbol) => throw new DesugaringException(
-        msg"Expected scrutinee symbol, found ${nme.symbol.name}" -> nme.toLoc :: Nil
-      )
-      case N => throw new DesugaringException(
-        msg"Scrutinee symbol not found" -> nme.toLoc :: Nil
-      )
+      case S(otherSymbol) =>
+        raiseDesugaringError(msg"cannot identifier `${nme.name}` with a scrutinee" -> nme.toLoc)
+        nme
+      case N => lastWords(s"`${nme.name}` should be assoicated with a symbol")
     }
 
     /**
@@ -201,7 +199,7 @@ trait Desugarer extends Transformation
     */
   protected def traverseIf(`if`: If)(implicit scope: Scope): Unit = {
     implicit val context: Context = new Context(`if`)
-    try trace("traverseIf") {
+    trace("traverseIf") {
       // Stage 0: Transformation
       val transformed = traceWithTopic("transform") {
         println("STEP 0")
@@ -254,9 +252,7 @@ trait Desugarer extends Transformation
       }
       // Epilogue
       `if`.desugaredTerm = S(postProcessed)
-    }(_ => "traverseIf ==> ()") catch {
-      case e: DesugaringException => raiseDesugaringError(e.messages: _*)
-    }
+    }(_ => "traverseIf ==> ()")
   }
   
   /**
diff --git a/shared/src/main/scala/mlscript/ucs/package.scala b/shared/src/main/scala/mlscript/ucs/package.scala
index 4e285538b7..dd2ddf92f6 100644
--- a/shared/src/main/scala/mlscript/ucs/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/package.scala
@@ -43,10 +43,4 @@ package object ucs {
     def toIndentedString: Str =
       lines.iterator.map { case (n, line) => "  " * n + line }.mkString("\n")
   }
-
-  // TODO: Remove this exception. The desugarer should work in a non-fatal way.
-  // We may call `lastWords` if unrecoverable errors are found.
-  class DesugaringException(val messages: Ls[Message -> Opt[Loc]]) extends Throwable {
-    def this(message: Message, location: Opt[Loc]) = this(message -> location :: Nil)
-  }
 }
diff --git a/shared/src/test/diff/mlscript/Repro.mls b/shared/src/test/diff/mlscript/Repro.mls
index 272dfe5e97..34d9bdfef7 100644
--- a/shared/src/test/diff/mlscript/Repro.mls
+++ b/shared/src/test/diff/mlscript/Repro.mls
@@ -1,39 +1 @@
-type Tree = Node | Empty
-class Node: { value: int; left: Tree; right: Tree }
-class Empty
-//│ Defined type alias Tree
-//│ Defined class Node
-//│ Defined class Empty
-
-rec def insert(t, v) = case t of
-  { Node ->
-      let v' = t.value in
-      let l = t.left in
-      let r = t.right in
-      let ucs__test__0 = v < v' : bool in
-      case ucs__test__0 of
-        { true -> Node { value = v'; left = insert(l, v,); right = r }
-        | _ ->
-          let ucs__test__1 = v > v' : bool in
-          case ucs__test__1 of
-            { true -> Node { value = v'; left = l; right = insert(r, v,) }
-            | _ -> t 
-            }
-        }
-  | Empty -> Node { value = v; left = Empty {}; right = Empty {} }
-  }
-//│ insert: (Empty | Node & 'a, int & 'value,) -> ((Node with {left: Empty, right: Empty, value: 'value}) | 'a | 'b)
-//│   where
-//│     'b :> (Node with {
-//│       left: (Node with {left: Empty, right: Empty, value: 'value}) | 'a | 'b,
-//│       right: 'right,
-//│       value: 'value0
-//│     }) | (Node with {
-//│       left: 'left,
-//│       right: (Node with {left: Empty, right: Empty, value: 'value}) | 'a | 'b,
-//│       value: 'value0
-//│     })
-//│     'a <: Tree & {left: 'left, right: 'right, value: int & 'value0}
-//│     'right <: Empty | Node & 'a
-//│     'left <: Empty | Node & 'a
-//│       = [Function: insert]
+:NewDefs
diff --git a/shared/src/test/diff/pretyper/SymbolKind.mls b/shared/src/test/diff/pretyper/SymbolKind.mls
new file mode 100644
index 0000000000..69c88cd593
--- /dev/null
+++ b/shared/src/test/diff/pretyper/SymbolKind.mls
@@ -0,0 +1,118 @@
+:NewDefs
+:ShowPreTyperErrors
+
+type Type = Int
+mixin Mixin1
+mixin Mixin2()
+trait Trait // Trait doesn't have parameters.
+class Class1
+class Class2()
+module Module
+//│ type Type = Int
+//│ mixin Mixin1()
+//│ mixin Mixin2()
+//│ trait Trait
+//│ class Class1 {
+//│   constructor()
+//│ }
+//│ class Class2()
+//│ module Module
+
+fun f(g) = g()
+//│ fun f: forall 'a. (() -> 'a) -> 'a
+
+:e
+f(Type)
+//│ ╔══[ERROR] identifier `Type` is resolved to a type
+//│ ║  l.25: 	f(Type)
+//│ ╙──      	  ^^^^
+//│ ╔══[ERROR] type alias Type cannot be used in term position
+//│ ║  l.25: 	f(Type)
+//│ ╙──      	  ^^^^
+//│ error
+//│ Code generation encountered an error:
+//│   type alias Type is not a valid expression
+
+:e
+id(Mixin1)
+//│ ╔══[ERROR] identifier `Mixin1` is resolved to a type
+//│ ║  l.37: 	id(Mixin1)
+//│ ╙──      	   ^^^^^^
+//│ ╔══[ERROR] mixin Mixin1 cannot be used in term position
+//│ ║  l.37: 	id(Mixin1)
+//│ ╙──      	   ^^^^^^
+//│ error
+//│ res
+//│     = [Function (anonymous)]
+
+:e
+f(Mixin2)
+//│ ╔══[ERROR] identifier `Mixin2` is resolved to a type
+//│ ║  l.49: 	f(Mixin2)
+//│ ╙──      	  ^^^^^^
+//│ ╔══[ERROR] mixin Mixin2 cannot be used in term position
+//│ ║  l.49: 	f(Mixin2)
+//│ ╙──      	  ^^^^^^
+//│ error
+//│ res
+//│ Runtime error:
+//│   TypeError: Class extends value undefined is not a constructor or null
+
+:e
+f(Trait)
+//│ ╔══[ERROR] identifier `Trait` is resolved to a type
+//│ ║  l.62: 	f(Trait)
+//│ ╙──      	  ^^^^^
+//│ ╔══[ERROR] trait Trait cannot be used in term position
+//│ ║  l.62: 	f(Trait)
+//│ ╙──      	  ^^^^^
+//│ error
+//│ Code generation encountered an error:
+//│   trait used in term position
+
+:e
+f(Class1)
+//│ ╔══[ERROR] Construction of unparameterized class Class1 should use the `new` keyword
+//│ ║  l.74: 	f(Class1)
+//│ ╙──      	  ^^^^^^
+//│ Class1
+//│ res
+//│ Runtime error:
+//│   TypeError: Class constructor Class1 cannot be invoked without 'new'
+
+f(Class2)
+//│ Class2
+//│ res
+//│     = Class2 {}
+
+id(Class2)
+//│ () -> Class2
+//│ res
+//│     = [Function (anonymous)] {
+//│         class: [class Class2],
+//│         unapply: [Function: unapply]
+//│       }
+
+:e
+f(Module)
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.97: 	f(Module)
+//│ ║        	^^^^^^^^^
+//│ ╟── reference of type `Module` is not a function
+//│ ║  l.97: 	f(Module)
+//│ ║        	  ^^^^^^
+//│ ╟── Note: constraint arises from application:
+//│ ║  l.21: 	fun f(g) = g()
+//│ ║        	           ^^^
+//│ ╟── from reference:
+//│ ║  l.21: 	fun f(g) = g()
+//│ ╙──      	           ^
+//│ error
+//│ res
+//│ Runtime error:
+//│   TypeError: g is not a function
+
+id(Module)
+//│ Module
+//│ res
+//│     = Module { class: [class Module] }

From e23e7a1ff6f1d0a57addecb42e6aaf86cd676ed2 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 16 Jan 2024 21:05:18 +0800
Subject: [PATCH 079/147] Add a test for `PreTyper`

---
 shared/src/test/diff/pretyper/Errors.mls | 280 ++++++++++++-----------
 1 file changed, 143 insertions(+), 137 deletions(-)

diff --git a/shared/src/test/diff/pretyper/Errors.mls b/shared/src/test/diff/pretyper/Errors.mls
index 9e071a13f1..28349ca025 100644
--- a/shared/src/test/diff/pretyper/Errors.mls
+++ b/shared/src/test/diff/pretyper/Errors.mls
@@ -11,24 +11,30 @@
 // codegen
 // -------
 
+// Nested
+fun main =
+  let f(x: Int): Int = if x is
+    0 then 1
+    else g(x - 1)
+  let g(x: Int): Int = f(x)
+  f
+//│ ╔══[ERROR] identifier `g` not found
+//│ ║  l.18: 	    else g(x - 1)
+//│ ╙──      	         ^
+//│ fun main: (x: Int) -> Int
+
 // SymbolicOps
 fun (>>)(f, g) = x => g(f(x))
 //│ ╔══[PARSE ERROR] Expected a function name; found parenthesis section instead
-//│ ║  l.15: 	fun (>>)(f, g) = x => g(f(x))
+//│ ║  l.27: 	fun (>>)(f, g) = x => g(f(x))
 //│ ╙──      	        ^^^^^^
 //│ ╔══[ERROR] identifier `g` not found
-//│ ║  l.15: 	fun (>>)(f, g) = x => g(f(x))
+//│ ║  l.27: 	fun (>>)(f, g) = x => g(f(x))
 //│ ╙──      	                      ^
 //│ ╔══[ERROR] identifier `f` not found
-//│ ║  l.15: 	fun (>>)(f, g) = x => g(f(x))
+//│ ║  l.27: 	fun (>>)(f, g) = x => g(f(x))
 //│ ╙──      	                        ^
-//│ ╔══[ERROR] identifier not found: g
-//│ ║  l.15: 	fun (>>)(f, g) = x => g(f(x))
-//│ ╙──      	                      ^
-//│ ╔══[ERROR] identifier not found: f
-//│ ║  l.15: 	fun (>>)(f, g) = x => g(f(x))
-//│ ╙──      	                        ^
-//│ fun (>>) <error>: anything -> error
+//│ fun (>>) <error>: Int -> Int
 
 // mlscript
 // --------
@@ -36,10 +42,10 @@ fun (>>)(f, g) = x => g(f(x))
 // Sequence
 let test(x) = log(x); x + 1
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.37: 	let test(x) = log(x); x + 1
+//│ ║  l.43: 	let test(x) = log(x); x + 1
 //│ ╙──      	                      ^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.37: 	let test(x) = log(x); x + 1
+//│ ║  l.43: 	let test(x) = log(x); x + 1
 //│ ╙──      	                      ^
 //│ let test: anything -> ()
 //│ Int
@@ -50,32 +56,32 @@ let test(x) = log(x); x + 1
 // Ascription
 foo(123: Int): Int
 //│ ╔══[ERROR] identifier `foo` not found
-//│ ║  l.51: 	foo(123: Int): Int
+//│ ║  l.57: 	foo(123: Int): Int
 //│ ╙──      	^^^
 //│ ╔══[ERROR] identifier `Int` is resolved to a type
-//│ ║  l.51: 	foo(123: Int): Int
+//│ ║  l.57: 	foo(123: Int): Int
 //│ ╙──      	         ^^^
 //│ ╔══[ERROR] identifier not found: foo
-//│ ║  l.51: 	foo(123: Int): Int
+//│ ║  l.57: 	foo(123: Int): Int
 //│ ╙──      	^^^
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `error` for applying named arguments
-//│ ║  l.51: 	foo(123: Int): Int
+//│ ║  l.57: 	foo(123: Int): Int
 //│ ╙──      	^^^
 //│ Int
 
 // Ascription
 foo(123:Int):Int
 //│ ╔══[ERROR] identifier `foo` not found
-//│ ║  l.67: 	foo(123:Int):Int
+//│ ║  l.73: 	foo(123:Int):Int
 //│ ╙──      	^^^
 //│ ╔══[ERROR] identifier `Int` is resolved to a type
-//│ ║  l.67: 	foo(123:Int):Int
+//│ ║  l.73: 	foo(123:Int):Int
 //│ ╙──      	        ^^^
 //│ ╔══[ERROR] identifier not found: foo
-//│ ║  l.67: 	foo(123:Int):Int
+//│ ║  l.73: 	foo(123:Int):Int
 //│ ╙──      	^^^
 //│ ╔══[ERROR] Cannot retrieve appropriate function signature from type `error` for applying named arguments
-//│ ║  l.67: 	foo(123:Int):Int
+//│ ║  l.73: 	foo(123:Int):Int
 //│ ╙──      	^^^
 //│ Int
 
@@ -85,7 +91,7 @@ fun test =
   let b = 1
   a
 //│ ╔══[ERROR] identifier `b` not found
-//│ ║  l.84: 	  let a = b
+//│ ║  l.90: 	  let a = b
 //│ ╙──      	          ^
 //│ fun test: 1
 
@@ -95,17 +101,17 @@ fun test =
   let b = 1
   a()
 //│ ╔══[ERROR] identifier `b` not found
-//│ ║  l.94: 	  let a() = b
-//│ ╙──      	            ^
+//│ ║  l.100: 	  let a() = b
+//│ ╙──       	            ^
 //│ fun test: 1
 
 // BadClasses
 hello
 //│ ╔══[ERROR] identifier `hello` not found
-//│ ║  l.103: 	hello
+//│ ║  l.109: 	hello
 //│ ╙──       	^^^^^
 //│ ╔══[ERROR] identifier not found: hello
-//│ ║  l.103: 	hello
+//│ ║  l.109: 	hello
 //│ ╙──       	^^^^^
 //│ error
 
@@ -115,7 +121,7 @@ module A {
   val y = x
 }
 //│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.114: 	  val x = y
+//│ ║  l.120: 	  val x = y
 //│ ╙──       	          ^
 //│ module A {
 //│   val x: nothing
@@ -128,7 +134,7 @@ module A {
   val y = 1
 }
 //│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.127: 	  val x = y
+//│ ║  l.133: 	  val x = y
 //│ ╙──       	          ^
 //│ module A {
 //│   val x: 1
@@ -139,10 +145,10 @@ module A {
 mixin M0
 M0
 //│ ╔══[ERROR] identifier `M0` is resolved to a type
-//│ ║  l.140: 	M0
+//│ ║  l.146: 	M0
 //│ ╙──       	^^
 //│ ╔══[ERROR] mixin M0 cannot be used in term position
-//│ ║  l.140: 	M0
+//│ ║  l.146: 	M0
 //│ ╙──       	^^
 //│ mixin M0()
 //│ error
@@ -151,10 +157,10 @@ M0
 mixin Foo(x: Int)
 x
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.152: 	x
+//│ ║  l.158: 	x
 //│ ╙──       	^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.152: 	x
+//│ ║  l.158: 	x
 //│ ╙──       	^
 //│ mixin Foo(x: Int)
 //│ error
@@ -163,10 +169,10 @@ x
 class Foo(x: Int)
 x
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.164: 	x
+//│ ║  l.170: 	x
 //│ ╙──       	^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.164: 	x
+//│ ║  l.170: 	x
 //│ ╙──       	^
 //│ class Foo(x: Int)
 //│ error
@@ -174,10 +180,10 @@ x
 // BadScopes
 class Bar { x }
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.175: 	class Bar { x }
+//│ ║  l.181: 	class Bar { x }
 //│ ╙──       	            ^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.175: 	class Bar { x }
+//│ ║  l.181: 	class Bar { x }
 //│ ╙──       	            ^
 //│ class Bar {
 //│   constructor()
@@ -187,10 +193,10 @@ class Bar { x }
 trait Foo
 Foo
 //│ ╔══[ERROR] identifier `Foo` is resolved to a type
-//│ ║  l.188: 	Foo
+//│ ║  l.194: 	Foo
 //│ ╙──       	^^^
 //│ ╔══[ERROR] trait Foo cannot be used in term position
-//│ ║  l.188: 	Foo
+//│ ║  l.194: 	Foo
 //│ ╙──       	^^^
 //│ trait Foo
 //│ error
@@ -198,35 +204,35 @@ Foo
 // FunPatterns
 fun f3([(x, y,),],) = x + y
 //│ ╔══[ERROR] unsupported pattern shape
-//│ ║  l.199: 	fun f3([(x, y,),],) = x + y
+//│ ║  l.205: 	fun f3([(x, y,),],) = x + y
 //│ ╙──       	        ^^^^^^^
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.199: 	fun f3([(x, y,),],) = x + y
+//│ ║  l.205: 	fun f3([(x, y,),],) = x + y
 //│ ╙──       	                      ^
 //│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.199: 	fun f3([(x, y,),],) = x + y
+//│ ║  l.205: 	fun f3([(x, y,),],) = x + y
 //│ ╙──       	                          ^
 //│ ╔══[ERROR] Unsupported pattern shape:
-//│ ║  l.199: 	fun f3([(x, y,),],) = x + y
+//│ ║  l.205: 	fun f3([(x, y,),],) = x + y
 //│ ╙──       	        ^^^^^^^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.199: 	fun f3([(x, y,),],) = x + y
+//│ ║  l.205: 	fun f3([(x, y,),],) = x + y
 //│ ╙──       	                      ^
 //│ ╔══[ERROR] identifier not found: y
-//│ ║  l.199: 	fun f3([(x, y,),],) = x + y
+//│ ║  l.205: 	fun f3([(x, y,),],) = x + y
 //│ ╙──       	                          ^
 //│ fun f3: ([error]) -> Int
 
 // GenericClassInheritance
 class C1[A] extends C0[A] { val a = a }
 //│ ╔══[ERROR] could not find definition `C0`
-//│ ║  l.221: 	class C1[A] extends C0[A] { val a = a }
+//│ ║  l.227: 	class C1[A] extends C0[A] { val a = a }
 //│ ╙──       	                    ^^
 //│ ╔══[ERROR] identifier `a` not found
-//│ ║  l.221: 	class C1[A] extends C0[A] { val a = a }
+//│ ║  l.227: 	class C1[A] extends C0[A] { val a = a }
 //│ ╙──       	                                    ^
 //│ ╔══[ERROR] Could not find definition `C0`
-//│ ║  l.221: 	class C1[A] extends C0[A] { val a = a }
+//│ ║  l.227: 	class C1[A] extends C0[A] { val a = a }
 //│ ╙──       	                    ^^
 //│ class C1[A] {
 //│   constructor()
@@ -240,10 +246,10 @@ fun foo1 = forall 'A: (x: 'A) => x
 // GenericMethods
 foo1[Int](42)
 //│ ╔══[ERROR] type application syntax is not yet supported
-//│ ║  l.241: 	foo1[Int](42)
+//│ ║  l.247: 	foo1[Int](42)
 //│ ╙──       	^^^^^^^^^
 //│ ╔══[ERROR] Type application syntax is not yet supported
-//│ ║  l.241: 	foo1[Int](42)
+//│ ║  l.247: 	foo1[Int](42)
 //│ ╙──       	^^^^^^^^^
 //│ 42
 
@@ -254,10 +260,10 @@ fun foo2<A>(x: A) = x
 // GenericMethods
 foo2<Int>(42)
 //│ ╔══[ERROR] type application syntax is not yet supported
-//│ ║  l.255: 	foo2<Int>(42)
+//│ ║  l.261: 	foo2<Int>(42)
 //│ ╙──       	^^^^^^^^^
 //│ ╔══[ERROR] Type application syntax is not yet supported
-//│ ║  l.255: 	foo2<Int>(42)
+//│ ║  l.261: 	foo2<Int>(42)
 //│ ╙──       	^^^^^^^^^
 //│ 42
 
@@ -268,10 +274,10 @@ fun foo3[A](x: A) = x
 // GenericMethods
 foo3[Int](42)
 //│ ╔══[ERROR] type application syntax is not yet supported
-//│ ║  l.269: 	foo3[Int](42)
+//│ ║  l.275: 	foo3[Int](42)
 //│ ╙──       	^^^^^^^^^
 //│ ╔══[ERROR] Type application syntax is not yet supported
-//│ ║  l.269: 	foo3[Int](42)
+//│ ║  l.275: 	foo3[Int](42)
 //│ ╙──       	^^^^^^^^^
 //│ 42
 
@@ -282,28 +288,28 @@ module M {
   fun oops(x) = m := x
 }
 //│ ╔══[PARSE ERROR] Unexpected 'mut' keyword in expression position
-//│ ║  l.281: 	  mut val m = None
+//│ ║  l.287: 	  mut val m = None
 //│ ╙──       	  ^^^
 //│ ╔══[PARSE ERROR] Unexpected 'val' keyword in expression position
-//│ ║  l.281: 	  mut val m = None
+//│ ║  l.287: 	  mut val m = None
 //│ ╙──       	      ^^^
 //│ ╔══[ERROR] identifier `:=` not found
-//│ ║  l.282: 	  fun oops(x) = m := x
+//│ ║  l.288: 	  fun oops(x) = m := x
 //│ ╙──       	                  ^^
 //│ ╔══[ERROR] identifier `m` not found
-//│ ║  l.282: 	  fun oops(x) = m := x
+//│ ║  l.288: 	  fun oops(x) = m := x
 //│ ╙──       	                ^
 //│ ╔══[WARNING] unsupported `Eqn`: m = None
-//│ ║  l.281: 	  mut val m = None
+//│ ║  l.287: 	  mut val m = None
 //│ ╙──       	          ^^^^^^^^
 //│ ╔══[ERROR] identifier not found: :=
-//│ ║  l.282: 	  fun oops(x) = m := x
+//│ ║  l.288: 	  fun oops(x) = m := x
 //│ ╙──       	                  ^^
 //│ ╔══[ERROR] identifier not found: m
-//│ ║  l.282: 	  fun oops(x) = m := x
+//│ ║  l.288: 	  fun oops(x) = m := x
 //│ ╙──       	                ^
 //│ ╔══[ERROR] Unexpected equation in this position
-//│ ║  l.281: 	  mut val m = None
+//│ ║  l.287: 	  mut val m = None
 //│ ╙──       	          ^^^^^^^^
 //│ module None
 //│ module M {
@@ -313,64 +319,64 @@ module M {
 // InterfaceMono
 trait What0 extends woooo
 //│ ╔══[ERROR] could not find definition `woooo`
-//│ ║  l.314: 	trait What0 extends woooo
+//│ ║  l.320: 	trait What0 extends woooo
 //│ ╙──       	                    ^^^^^
 //│ ╔══[ERROR] Could not find definition `woooo`
-//│ ║  l.314: 	trait What0 extends woooo
+//│ ║  l.320: 	trait What0 extends woooo
 //│ ╙──       	                    ^^^^^
 //│ trait What0
 
 // Misc
 let f = ((x, y)) => x + y
 //│ ╔══[ERROR] unsupported pattern shape
-//│ ║  l.324: 	let f = ((x, y)) => x + y
+//│ ║  l.330: 	let f = ((x, y)) => x + y
 //│ ╙──       	         ^^^^^^
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.324: 	let f = ((x, y)) => x + y
+//│ ║  l.330: 	let f = ((x, y)) => x + y
 //│ ╙──       	                    ^
 //│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.324: 	let f = ((x, y)) => x + y
+//│ ║  l.330: 	let f = ((x, y)) => x + y
 //│ ╙──       	                        ^
 //│ ╔══[ERROR] Unsupported pattern shape:
-//│ ║  l.324: 	let f = ((x, y)) => x + y
+//│ ║  l.330: 	let f = ((x, y)) => x + y
 //│ ╙──       	         ^^^^^^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.324: 	let f = ((x, y)) => x + y
+//│ ║  l.330: 	let f = ((x, y)) => x + y
 //│ ╙──       	                    ^
 //│ ╔══[ERROR] identifier not found: y
-//│ ║  l.324: 	let f = ((x, y)) => x + y
+//│ ║  l.330: 	let f = ((x, y)) => x + y
 //│ ╙──       	                        ^
 //│ let f: error -> Int
 
 // Misc
 f[1, 2]
 //│ ╔══[ERROR] type application syntax is not yet supported
-//│ ║  l.346: 	f[1, 2]
+//│ ║  l.352: 	f[1, 2]
 //│ ╙──       	^^^^^^^
 //│ ╔══[ERROR] Type application syntax is not yet supported
-//│ ║  l.346: 	f[1, 2]
+//│ ║  l.352: 	f[1, 2]
 //│ ╙──       	^^^^^^^
 //│ error -> Int
 
 // Misc
 let f = (((x, y))) => x + y
 //│ ╔══[ERROR] unsupported pattern shape
-//│ ║  l.356: 	let f = (((x, y))) => x + y
+//│ ║  l.362: 	let f = (((x, y))) => x + y
 //│ ╙──       	          ^^^^^^
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.356: 	let f = (((x, y))) => x + y
+//│ ║  l.362: 	let f = (((x, y))) => x + y
 //│ ╙──       	                      ^
 //│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.356: 	let f = (((x, y))) => x + y
+//│ ║  l.362: 	let f = (((x, y))) => x + y
 //│ ╙──       	                          ^
 //│ ╔══[ERROR] Unsupported pattern shape:
-//│ ║  l.356: 	let f = (((x, y))) => x + y
+//│ ║  l.362: 	let f = (((x, y))) => x + y
 //│ ╙──       	          ^^^^^^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.356: 	let f = (((x, y))) => x + y
+//│ ║  l.362: 	let f = (((x, y))) => x + y
 //│ ╙──       	                      ^
 //│ ╔══[ERROR] identifier not found: y
-//│ ║  l.356: 	let f = (((x, y))) => x + y
+//│ ║  l.362: 	let f = (((x, y))) => x + y
 //│ ╙──       	                          ^
 //│ let f: error -> Int
 
@@ -378,22 +384,22 @@ let f = (((x, y))) => x + y
 let v1 = {mut 1}
 v1.x <- 1
 //│ ╔══[PARSE ERROR] Record field should have a name
-//│ ║  l.378: 	let v1 = {mut 1}
+//│ ║  l.384: 	let v1 = {mut 1}
 //│ ╙──       	              ^
 //│ ╔══[ERROR] identifier `<-` not found
-//│ ║  l.379: 	v1.x <- 1
+//│ ║  l.385: 	v1.x <- 1
 //│ ╙──       	     ^^
 //│ ╔══[ERROR] identifier not found: <-
-//│ ║  l.379: 	v1.x <- 1
+//│ ║  l.385: 	v1.x <- 1
 //│ ╙──       	     ^^
 //│ ╔══[ERROR] Type mismatch in field selection:
-//│ ║  l.379: 	v1.x <- 1
+//│ ║  l.385: 	v1.x <- 1
 //│ ║         	^^^^
 //│ ╟── record literal of type `{mut <error>: ?<error>}` does not have field 'x'
-//│ ║  l.378: 	let v1 = {mut 1}
+//│ ║  l.384: 	let v1 = {mut 1}
 //│ ║         	              ^
 //│ ╟── but it flows into reference with expected type `{x: ?x}`
-//│ ║  l.379: 	v1.x <- 1
+//│ ║  l.385: 	v1.x <- 1
 //│ ╙──       	^^
 //│ let v1: {mut <error>: '<error>}
 //│ error
@@ -403,7 +409,7 @@ v1.x <- 1
 // Mut
 let v2 = [mut x: 1]
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.404: 	let v2 = [mut x: 1]
+//│ ║  l.410: 	let v2 = [mut x: 1]
 //│ ╙──       	              ^
 //│ let v2: [mut x: 'x]
 //│   where
@@ -412,7 +418,7 @@ let v2 = [mut x: 1]
 // Mut
 let v2 = [mut y: 1]
 //│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.413: 	let v2 = [mut y: 1]
+//│ ║  l.419: 	let v2 = [mut y: 1]
 //│ ╙──       	              ^
 //│ let v2: [mut y: 'y]
 //│   where
@@ -433,13 +439,13 @@ class Foo5() extends Foo() {
   fun bar(y: Int) = this.foo + y
 }
 //│ ╔══[ERROR] identifier `bar` not found
-//│ ║  l.432: 	  val x = bar(0)
+//│ ║  l.438: 	  val x = bar(0)
 //│ ╙──       	          ^^^
 //│ ╔══[ERROR] Cannot access `this` while initializing field x
-//│ ║  l.432: 	  val x = bar(0)
+//│ ║  l.438: 	  val x = bar(0)
 //│ ║         	      ^^^^^^^^^^
 //│ ╟── The access to `this` is here
-//│ ║  l.433: 	  fun bar(y: Int) = this.foo + y
+//│ ║  l.439: 	  fun bar(y: Int) = this.foo + y
 //│ ╙──       	                    ^^^^
 //│ class Foo5() extends Foo {
 //│   fun bar: (y: Int) -> Int
@@ -453,10 +459,10 @@ abstract class Foo: (Int -> Int) {
   fun f = this(0)
 }
 //│ ╔══[ERROR] Cannot access `this` while initializing field x
-//│ ║  l.452: 	  val x = f
+//│ ║  l.458: 	  val x = f
 //│ ║         	      ^^^^^
 //│ ╟── The access to `this` is here
-//│ ║  l.453: 	  fun f = this(0)
+//│ ║  l.459: 	  fun f = this(0)
 //│ ╙──       	          ^^^^
 //│ abstract class Foo: Int -> Int {
 //│   fun f: nothing
@@ -466,29 +472,29 @@ abstract class Foo: (Int -> Int) {
 // Object
 Object
 //│ ╔══[ERROR] identifier `Object` not found
-//│ ║  l.467: 	Object
+//│ ║  l.473: 	Object
 //│ ╙──       	^^^^^^
 //│ ╔══[ERROR] Class Object is abstract and cannot be instantiated
-//│ ║  l.467: 	Object
+//│ ║  l.473: 	Object
 //│ ╙──       	^^^^^^
 //│ ╔══[ERROR] Class Object cannot be instantiated as it exposes no constructor
-//│ ║  l.467: 	Object
+//│ ║  l.473: 	Object
 //│ ╙──       	^^^^^^
 //│ error
 
 // OpLam
 x => x.y => y
 //│ ╔══[ERROR] unsupported pattern shape
-//│ ║  l.480: 	x => x.y => y
+//│ ║  l.486: 	x => x.y => y
 //│ ╙──       	     ^^^
 //│ ╔══[ERROR] identifier `y` not found
-//│ ║  l.480: 	x => x.y => y
+//│ ║  l.486: 	x => x.y => y
 //│ ╙──       	            ^
 //│ ╔══[ERROR] Unsupported pattern shape:
-//│ ║  l.480: 	x => x.y => y
+//│ ║  l.486: 	x => x.y => y
 //│ ╙──       	     ^^^
 //│ ╔══[ERROR] identifier not found: y
-//│ ║  l.480: 	x => x.y => y
+//│ ║  l.486: 	x => x.y => y
 //│ ╙──       	            ^
 //│ anything -> error -> error
 
@@ -499,20 +505,20 @@ class Base0(n: Num)
 // ParamOverride
 class Derived0(n: Int) extends Base
 //│ ╔══[ERROR] could not find definition `Base`
-//│ ║  l.500: 	class Derived0(n: Int) extends Base
+//│ ║  l.506: 	class Derived0(n: Int) extends Base
 //│ ╙──       	                               ^^^^
 //│ ╔══[ERROR] Could not find definition `Base`
-//│ ║  l.500: 	class Derived0(n: Int) extends Base
+//│ ║  l.506: 	class Derived0(n: Int) extends Base
 //│ ╙──       	                               ^^^^
 //│ class Derived0(n: Int)
 
 // ParamOverride
 mixin DerivedBad(n: Int) extends Base
 //│ ╔══[ERROR] could not find definition `Base`
-//│ ║  l.510: 	mixin DerivedBad(n: Int) extends Base
+//│ ║  l.516: 	mixin DerivedBad(n: Int) extends Base
 //│ ╙──       	                                 ^^^^
 //│ ╔══[ERROR] mixin definitions cannot yet extend parents
-//│ ║  l.510: 	mixin DerivedBad(n: Int) extends Base
+//│ ║  l.516: 	mixin DerivedBad(n: Int) extends Base
 //│ ╙──       	                                 ^^^^
 //│ mixin DerivedBad(n: Int)
 
@@ -523,65 +529,65 @@ fun foo(x, y) = x + y
 // PartialApp
 foo(2, _)
 //│ ╔══[ERROR] identifier `_` not found
-//│ ║  l.524: 	foo(2, _)
+//│ ║  l.530: 	foo(2, _)
 //│ ╙──       	       ^
 //│ ╔══[ERROR] Widlcard in expression position.
-//│ ║  l.524: 	foo(2, _)
+//│ ║  l.530: 	foo(2, _)
 //│ ╙──       	       ^
 //│ Int
 
 // PartialApp
 _.foo(1)
 //│ ╔══[ERROR] identifier `_` not found
-//│ ║  l.534: 	_.foo(1)
+//│ ║  l.540: 	_.foo(1)
 //│ ╙──       	^
 //│ ╔══[ERROR] Widlcard in expression position.
-//│ ║  l.534: 	_.foo(1)
+//│ ║  l.540: 	_.foo(1)
 //│ ╙──       	^
 //│ error
 
 // PartialApp
 _ + _
 //│ ╔══[ERROR] identifier `_` not found
-//│ ║  l.544: 	_ + _
+//│ ║  l.550: 	_ + _
 //│ ╙──       	^
 //│ ╔══[ERROR] identifier `_` not found
-//│ ║  l.544: 	_ + _
+//│ ║  l.550: 	_ + _
 //│ ╙──       	    ^
 //│ ╔══[ERROR] Widlcard in expression position.
-//│ ║  l.544: 	_ + _
+//│ ║  l.550: 	_ + _
 //│ ╙──       	^
 //│ ╔══[ERROR] Widlcard in expression position.
-//│ ║  l.544: 	_ + _
+//│ ║  l.550: 	_ + _
 //│ ╙──       	    ^
 //│ Int
 
 // PartialApp
 _2 + _1
 //│ ╔══[ERROR] identifier `_2` not found
-//│ ║  l.560: 	_2 + _1
+//│ ║  l.566: 	_2 + _1
 //│ ╙──       	^^
 //│ ╔══[ERROR] identifier `_1` not found
-//│ ║  l.560: 	_2 + _1
+//│ ║  l.566: 	_2 + _1
 //│ ╙──       	     ^^
 //│ ╔══[ERROR] identifier not found: _2
-//│ ║  l.560: 	_2 + _1
+//│ ║  l.566: 	_2 + _1
 //│ ╙──       	^^
 //│ ╔══[ERROR] identifier not found: _1
-//│ ║  l.560: 	_2 + _1
+//│ ║  l.566: 	_2 + _1
 //│ ╙──       	     ^^
 //│ Int
 
 // RefinedPatterns
 refined
 //│ ╔══[ERROR] identifier `refined` not found
-//│ ║  l.576: 	refined
+//│ ║  l.582: 	refined
 //│ ╙──       	^^^^^^^
 //│ ╔══[ERROR] Illegal use of reserved operator: refined
-//│ ║  l.576: 	refined
+//│ ║  l.582: 	refined
 //│ ╙──       	^^^^^^^
 //│ ╔══[ERROR] identifier not found: refined
-//│ ║  l.576: 	refined
+//│ ║  l.582: 	refined
 //│ ╙──       	^^^^^^^
 //│ error
 
@@ -594,13 +600,13 @@ class D() { fun f = 0 }
 // Refinements
 let d = D & { f: 0 }
 //│ ╔══[ERROR] identifier `&` not found
-//│ ║  l.595: 	let d = D & { f: 0 }
+//│ ║  l.601: 	let d = D & { f: 0 }
 //│ ╙──       	          ^
 //│ ╔══[ERROR] Illegal use of reserved operator: &
-//│ ║  l.595: 	let d = D & { f: 0 }
+//│ ║  l.601: 	let d = D & { f: 0 }
 //│ ╙──       	          ^
 //│ ╔══[ERROR] identifier not found: &
-//│ ║  l.595: 	let d = D & { f: 0 }
+//│ ║  l.601: 	let d = D & { f: 0 }
 //│ ╙──       	          ^
 //│ let d: error
 
@@ -611,63 +617,63 @@ x => x + 2
 // Res
 res(1)
 //│ ╔══[ERROR] identifier `res` not found
-//│ ║  l.612: 	res(1)
+//│ ║  l.618: 	res(1)
 //│ ╙──       	^^^
 //│ ╔══[ERROR] identifier not found: res
-//│ ║  l.612: 	res(1)
+//│ ║  l.618: 	res(1)
 //│ ╙──       	^^^
 //│ error
 
 // Uninstantiable
 Int
 //│ ╔══[ERROR] identifier `Int` is resolved to a type
-//│ ║  l.622: 	Int
+//│ ║  l.628: 	Int
 //│ ╙──       	^^^
 //│ ╔══[ERROR] Class Int is abstract and cannot be instantiated
-//│ ║  l.622: 	Int
+//│ ║  l.628: 	Int
 //│ ╙──       	^^^
 //│ ╔══[ERROR] Class Int cannot be instantiated as it exposes no constructor
-//│ ║  l.622: 	Int
+//│ ║  l.628: 	Int
 //│ ╙──       	^^^
 //│ error
 
 // Uninstantiable
 Int()
 //│ ╔══[ERROR] identifier `Int` is resolved to a type
-//│ ║  l.635: 	Int()
+//│ ║  l.641: 	Int()
 //│ ╙──       	^^^
 //│ ╔══[ERROR] Class Int is abstract and cannot be instantiated
-//│ ║  l.635: 	Int()
+//│ ║  l.641: 	Int()
 //│ ╙──       	^^^
 //│ ╔══[ERROR] Class Int cannot be instantiated as it exposes no constructor
-//│ ║  l.635: 	Int()
+//│ ║  l.641: 	Int()
 //│ ╙──       	^^^
 //│ error
 
 // Uninstantiable
 new Int
 //│ ╔══[ERROR] identifier `Int` is resolved to a type
-//│ ║  l.648: 	new Int
+//│ ║  l.654: 	new Int
 //│ ╙──       	    ^^^
 //│ ╔══[ERROR] Class Int is abstract and cannot be instantiated
-//│ ║  l.648: 	new Int
+//│ ║  l.654: 	new Int
 //│ ╙──       	    ^^^
 //│ Int
 
 // Unit
 (1, 2) => 3
 //│ ╔══[WARNING] literal patterns are ignored
-//│ ║  l.658: 	(1, 2) => 3
+//│ ║  l.664: 	(1, 2) => 3
 //│ ╙──       	 ^
 //│ ╔══[WARNING] literal patterns are ignored
-//│ ║  l.658: 	(1, 2) => 3
+//│ ║  l.664: 	(1, 2) => 3
 //│ ╙──       	    ^
 //│ (1, 2) -> 3
 
 // Unit
 1 => (2, 3)
 //│ ╔══[WARNING] literal patterns are ignored
-//│ ║  l.668: 	1 => (2, 3)
+//│ ║  l.674: 	1 => (2, 3)
 //│ ╙──       	^
 //│ 1 -> 3
 
@@ -680,23 +686,23 @@ val d = 1
 // Varargs
 fun test(...xs) = xs.length
 //│ ╔══[PARSE ERROR] Unexpected operator here
-//│ ║  l.681: 	fun test(...xs) = xs.length
+//│ ║  l.687: 	fun test(...xs) = xs.length
 //│ ╙──       	         ^^^
 //│ ╔══[ERROR] identifier `xs` not found
-//│ ║  l.681: 	fun test(...xs) = xs.length
+//│ ║  l.687: 	fun test(...xs) = xs.length
 //│ ╙──       	                  ^^
 //│ ╔══[ERROR] identifier not found: xs
-//│ ║  l.681: 	fun test(...xs) = xs.length
+//│ ║  l.687: 	fun test(...xs) = xs.length
 //│ ╙──       	                  ^^
 //│ fun test: () -> error
 
 // WeirdDefs
 fun fst[x, _] = x
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.694: 	fun fst[x, _] = x
+//│ ║  l.700: 	fun fst[x, _] = x
 //│ ╙──       	                ^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.694: 	fun fst[x, _] = x
+//│ ║  l.700: 	fun fst[x, _] = x
 //│ ╙──       	                ^
 //│ fun fst: error
 
@@ -709,7 +715,7 @@ module EvalAddLit {
 }
 let res = EvalAddLit.eval(add11)
 //│ ╔══[ERROR] identifier `add11` not found
-//│ ║  l.705: 	val add11 = Add(add11)
+//│ ║  l.711: 	val add11 = Add(add11)
 //│ ╙──       	                ^^^^^
 //│ class Add[E](lhs: E)
 //│ val add11: 'E

From 681f294debc4341f4b312a58ff9ebfb545d1e316 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 17 Jan 2024 01:11:02 +0800
Subject: [PATCH 080/147] Remove useless files and fix many minor issues
 mentioned in PR

---
 .../src/main/scala/mlscript/JSBackend.scala   |  16 --
 .../main/scala/mlscript/pretyper/Symbol.scala |   2 +-
 .../scala/mlscript/pretyper/package.scala     |   5 -
 .../mlscript/ucs/stages/PostProcessing.scala  |   4 -
 .../main/scala/mlscript/ucs/syntax/core.scala |   2 +-
 .../scala/mlscript/ucs/syntax/package.scala   |   3 -
 shared/src/test/diff/codegen/NewDefsBug.mls   |  72 --------
 .../src/test/diff/pretyper/Declarations.mls   |  20 ---
 shared/src/test/diff/pretyper/Repro.mls       |   1 +
 todo.md                                       | 163 ------------------
 10 files changed, 3 insertions(+), 285 deletions(-)
 delete mode 100644 shared/src/main/scala/mlscript/pretyper/package.scala
 delete mode 100644 shared/src/main/scala/mlscript/ucs/syntax/package.scala
 delete mode 100644 shared/src/test/diff/codegen/NewDefsBug.mls
 delete mode 100644 shared/src/test/diff/pretyper/Declarations.mls
 delete mode 100644 todo.md

diff --git a/shared/src/main/scala/mlscript/JSBackend.scala b/shared/src/main/scala/mlscript/JSBackend.scala
index febdf926e8..f1805482dd 100644
--- a/shared/src/main/scala/mlscript/JSBackend.scala
+++ b/shared/src/main/scala/mlscript/JSBackend.scala
@@ -116,7 +116,6 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
         else
           throw new UnimplementedError(sym)
       case S(sym: ValueSymbol) =>
-        // Temporary disable this line of code because it invalidates many working test cases.
         if (sym.isByvalueRec.getOrElse(false) && !sym.isLam) throw CodeGenError(s"unguarded recursive use of by-value binding $name")
         sym.visited = true
         val ident = JSIdent(sym.runtimeName)
@@ -200,8 +199,6 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
       JSRecord(fields map { case (key, Fld(_, value)) =>
         key.name -> translateTerm(value)
       })
-    case Sel(receiver, JSBackend.TupleIndex(n)) =>
-      JSField(translateTerm(receiver), n.toString)
     case Sel(receiver, fieldName) =>
       JSField(translateTerm(receiver), fieldName.name)
     // Turn let into an IIFE.
@@ -1596,17 +1593,4 @@ object JSBackend {
 
   def isSafeInteger(value: BigInt): Boolean =
     MinimalSafeInteger <= value && value <= MaximalSafeInteger
-
-  // Temporary measure until we adopt the new tuple index.
-  object TupleIndex {
-    def unapply(fieldName: Var): Opt[Int] = {
-      val name = fieldName.name
-      if (name.startsWith("_") && name.forall(_.isDigit))
-        name.drop(1).toIntOption match {
-          case S(n) if n > 0 => S(n - 1)
-          case _ => N
-        }
-      else N
-    }
-  }
 }
diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index d08cc7b6f7..5a774d0a3f 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -98,4 +98,4 @@ package object symbol {
   class LocalTermSymbol(val nme: Var) extends TermSymbol {
     override def name: Str = nme.name
   }
-}
\ No newline at end of file
+}
diff --git a/shared/src/main/scala/mlscript/pretyper/package.scala b/shared/src/main/scala/mlscript/pretyper/package.scala
deleted file mode 100644
index addb94ce08..0000000000
--- a/shared/src/main/scala/mlscript/pretyper/package.scala
+++ /dev/null
@@ -1,5 +0,0 @@
-package mlscript
-
-import mlscript.utils._, shorthands._
-
-package object pretyper
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index fb496df034..9e26575ce5 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -176,10 +176,6 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
           val (n2, y2) = disentangleMatchedCaseBranches(rest)
           (kase.copy(body = n1, rest = n2)(kase.refined), mergeTerms(y1, y2))
         }
-      // case kase @ Case(otherClassName, body, rest) =>
-      //   println(s"found another case branch matching against $otherClassName")
-      //   val (n, y) = disentangleMatchedCaseBranches(rest)
-      //   kase.copy(rest = n) -> y
     }
 
 
diff --git a/shared/src/main/scala/mlscript/ucs/syntax/core.scala b/shared/src/main/scala/mlscript/ucs/syntax/core.scala
index 92e3d12a8a..4b39414b6b 100644
--- a/shared/src/main/scala/mlscript/ucs/syntax/core.scala
+++ b/shared/src/main/scala/mlscript/ucs/syntax/core.scala
@@ -99,4 +99,4 @@ package object core {
     final case class Else(default: Term) extends Split
     final case object Nil extends Split
   }
-}
\ No newline at end of file
+}
diff --git a/shared/src/main/scala/mlscript/ucs/syntax/package.scala b/shared/src/main/scala/mlscript/ucs/syntax/package.scala
deleted file mode 100644
index bfe2aec74d..0000000000
--- a/shared/src/main/scala/mlscript/ucs/syntax/package.scala
+++ /dev/null
@@ -1,3 +0,0 @@
-package mlscript.ucs
-
-package object syntax
diff --git a/shared/src/test/diff/codegen/NewDefsBug.mls b/shared/src/test/diff/codegen/NewDefsBug.mls
deleted file mode 100644
index 2f004173d0..0000000000
--- a/shared/src/test/diff/codegen/NewDefsBug.mls
+++ /dev/null
@@ -1,72 +0,0 @@
-:NewDefs
-
-:js
-fun foo: Int -> Int
-fun foo = x => x + 1
-class Bar {
-  fun calc(x) = foo(x)
-}
-//│ fun foo: Int -> Int
-//│ class Bar {
-//│   constructor()
-//│   fun calc: Int -> Int
-//│ }
-//│ fun foo: Int -> Int
-//│ // Prelude
-//│ let res;
-//│ class TypingUnit {
-//│   #Bar;
-//│   constructor() {
-//│   }
-//│   get Bar() {
-//│     const qualifier = this;
-//│     if (this.#Bar === undefined) {
-//│       class Bar {
-//│         constructor() {
-//│         }
-//│         calc(x) {
-//│           return foo(x);
-//│         }
-//│       };
-//│       this.#Bar = Bar;
-//│     }
-//│     return this.#Bar;
-//│   }
-//│ }
-//│ const typing_unit = new TypingUnit;
-//│ globalThis.Bar = typing_unit.Bar;
-//│ // Query 1 is empty
-//│ // Query 2
-//│ globalThis.foo = function foo(x) {
-//│   return x + 1;
-//│ };
-//│ // End of generated code
-
-// Note: This test case looks trivial but it was like:
-//
-// ```
-// :re
-// (new Bar()).calc(0)
-// //│ Int
-// //│ res
-// //│ Runtime error:
-// //│   ReferenceError: foo is not defined
-// ```
-//
-// My fix is a little bit hacky. The root of the problem is: when generating
-// code within a class, we need all top-level bindings to be accessible. This
-// part of implementation of new-definition-typing chose to declare all term
-// `NuFunDef` as `ValueSymbol` in advance, but this can lead to the fact that
-// the same symbol is declared multiple times, thus wasting some runtime names.
-// Consequently, the code that references these wasted runtime names are invalid.
-// 
-// Actually, I have a better solution, but it requires adjusting the order of
-// translation, and I don't have much time to spend on this at the moment. So，
-// my current fix is rather hacky. But I will complete this part when `PreTyper`
-// is finished, when replacing the old Scope with the new Scope.
-//
-//                                                      Luyu Cheng on 2023/12/30
-(new Bar()).calc(0)
-//│ Int
-//│ res
-//│     = 1
diff --git a/shared/src/test/diff/pretyper/Declarations.mls b/shared/src/test/diff/pretyper/Declarations.mls
deleted file mode 100644
index 7f07a109d8..0000000000
--- a/shared/src/test/diff/pretyper/Declarations.mls
+++ /dev/null
@@ -1,20 +0,0 @@
-:NewDefs
-:NoJS
-
-
-fun test(x, y) = x + y
-//│ fun test: (Int, Int) -> Int
-
-
-// Functions are hoisted.
-let y = id(42)
-fun id(x) = x
-//│ let y: 42 | 'a
-//│ fun id: forall 'b. ('a & 'b) -> (42 | 'b)
-
-
-// Function bodies can access variables declare after them.
-fun q(x) = x + p
-let p = 0
-//│ fun q: Int -> Int
-//│ let p: 0
diff --git a/shared/src/test/diff/pretyper/Repro.mls b/shared/src/test/diff/pretyper/Repro.mls
index 34d9bdfef7..c660764771 100644
--- a/shared/src/test/diff/pretyper/Repro.mls
+++ b/shared/src/test/diff/pretyper/Repro.mls
@@ -1 +1,2 @@
 :NewDefs
+:ShowPreTyperErrors
diff --git a/todo.md b/todo.md
deleted file mode 100644
index 9f1ebcbc37..0000000000
--- a/todo.md
+++ /dev/null
@@ -1,163 +0,0 @@
-This file will be deleted after we migrate all test cases and fixed all
-problems located by test cases.
-
-### Remaining Tasks
-
-- [x] Report unreachable or redundant cases
-  - [x] shared/src/test/diff/ucs/DirectLines.mls **OLD**
-  - [x] shared/src/test/diff/ucs/SplitAnd.mls
-  - [x] shared/src/test/diff/ucs/WeirdIf.mls
-  - [x] shared/src/test/diff/ucs/Wildcard.mls
-- [x] Hygenic bindings
-  - [ ] shared/src/test/diff/ucs/CrossBranchCapture.mls
-  - [x] shared/src/test/diff/ucs/HygienicBindings.mls
-
-### Test Checklist
-
-- [x] shared/src/test/diff/codegen/AuxiliaryConstructors.mls
-- [x] shared/src/test/diff/codegen/Mixin.mls
-      Fix that `PreTyper` does not traverse type definitions.
-- [x] shared/src/test/diff/codegen/MixinCapture.mls
-- [x] shared/src/test/diff/codegen/Nested.mls
-- [x] shared/src/test/diff/codegen/NewMatching.mls
-      Destructing unparameterized class no longer causes code generation errors.
-- [x] shared/src/test/diff/codegen/ValLet.mls
-- [x] shared/src/test/diff/ecoop23/ComparePointPoly.mls
-      Desugar UCS shorthands in `PreTyper`.
-- [x] shared/src/test/diff/ecoop23/ExpressionProblem.mls
-- [x] shared/src/test/diff/ecoop23/Intro.mls
-- [x] shared/src/test/diff/ecoop23/PolymorphicVariants.mls
-- [x] shared/src/test/diff/ecoop23/SimpleRegionDSL_annot.mls
-- [x] shared/src/test/diff/ecoop23/SimpleRegionDSL_raw.mls
-- [x] shared/src/test/diff/fcp/QML_exist_nu.mls
-- [x] shared/src/test/diff/gadt/Exp1.mls
-- [x] shared/src/test/diff/gadt/Exp2.mls
-- [x] shared/src/test/diff/gadt/ThisMatching.mls
-- [x] shared/src/test/diff/nu/Andong.mls
-- [x] shared/src/test/diff/nu/ArrayProg.mls
-- [x] shared/src/test/diff/nu/BadUCS.mls
-      Add many `:ge` to cases where match scrutinee against mixins.
-      Add dummy class symbol so that we don't need to throw any
-      errors during desugaring.
-- [x] shared/src/test/diff/nu/BasicClassInheritance.mls
-- [x] shared/src/test/diff/nu/BasicClasses.mls
-- [x] shared/src/test/diff/nu/CaseExpr.mls
-- [x] shared/src/test/diff/nu/ClassSignatures.mls
-- [x] shared/src/test/diff/nu/ClassesInMixins.mls
-      Improve error messages in `PreTyper`.
-- [x] shared/src/test/diff/nu/CommaOperator.mls
-- [x] shared/src/test/diff/nu/CtorSubtraction.mls
-- [x] shared/src/test/diff/nu/Eval.mls
-- [x] shared/src/test/diff/nu/EvalNegNeg.mls
-- [x] shared/src/test/diff/nu/ExpressionProblem_repro.mls
-- [x] shared/src/test/diff/nu/ExpressionProblem_small.mls
-- [x] shared/src/test/diff/nu/FilterMap.mls
-- [x] shared/src/test/diff/nu/FlatIfThenElse.mls
-- [x] shared/src/test/diff/nu/FlatMonads.mls
-- [x] shared/src/test/diff/nu/FunnyIndet.mls
-- [x] shared/src/test/diff/nu/GADTMono.mls
-- [x] shared/src/test/diff/nu/GenericClasses.mls
-- [x] shared/src/test/diff/nu/GenericModules.mls
-- [x] shared/src/test/diff/nu/HeungTung.mls
-- [x] shared/src/test/diff/nu/Huawei1.mls
-- [x] shared/src/test/diff/nu/InterfaceMono.mls
-- [ ] shared/src/test/diff/nu/Interfaces.mls
-      What? Traits can't be patterns?
-- [x] shared/src/test/diff/nu/LetRec.mls
-- [x] shared/src/test/diff/nu/ListConsNil.mls
-- [x] shared/src/test/diff/nu/LitMatch.mls
-- [x] shared/src/test/diff/nu/MissingTypeArg.mls
-- [x] shared/src/test/diff/nu/NamedArgs.mls
-- [x] shared/src/test/diff/nu/New.mls **OLD**
-- [x] shared/src/test/diff/nu/NewNew.mls
-- [x] shared/src/test/diff/nu/Object.mls
-- [x] shared/src/test/diff/nu/OpLam.mls
-      Function `extractParameters` no longer raise errors.
-- [x] shared/src/test/diff/nu/OptionFilter.mls
-- [x] shared/src/test/diff/nu/OverrideShorthand.mls
-- [x] shared/src/test/diff/nu/ParamPassing.mls
-- [x] shared/src/test/diff/nu/PolymorphicVariants_Alt.mls
-- [x] shared/src/test/diff/nu/PostHocMixinSignature.mls
-- [x] shared/src/test/diff/nu/PrivateMemberOverriding.mls
-- [x] shared/src/test/diff/nu/SelfRec.mls
-- [x] shared/src/test/diff/nu/Subscripts.mls
-- [x] shared/src/test/diff/nu/TODO_Classes.mls
-- [x] shared/src/test/diff/nu/Unapply.mls
-- [x] shared/src/test/diff/nu/UndefMatching.mls
-- [x] shared/src/test/diff/nu/WeirdUnions.mls
-- [x] shared/src/test/diff/nu/i180.mls
-- [x] shared/src/test/diff/nu/repro0.mls
-      - `PreTyper` does not accept top-level `val` bindings.
-- [x] shared/src/test/diff/nu/repro1.mls
-- [x] shared/src/test/diff/nu/repro_EvalNegNeg.mls
-- [x] shared/src/test/diff/nu/repro_PolymorphicVariants.mls
-- [x] shared/src/test/diff/pretyper/ucs/examples/JSON.mls
-- [x] shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
-- [x] shared/src/test/diff/pretyper/ucs/examples/Option.mls
-- [x] shared/src/test/diff/pretyper/ucs/examples/STLC.mls
-- [x] shared/src/test/diff/ucs/AppSplits.mls
-- [x] shared/src/test/diff/ucs/CrossBranchCapture.mls
-      Fix the mentioned problems.
-      TODO: Warn duplicated pattern bindings.
-- [x] shared/src/test/diff/ucs/DirectLines.mls **OLD**
-      TODO: Warn duplicated else branches.
-- [x] shared/src/test/diff/ucs/ElseIf.mls
-- [x] shared/src/test/diff/ucs/ErrorMessage.mls **OLD**
-- [x] shared/src/test/diff/ucs/Exhaustiveness.mls
-- [x] shared/src/test/diff/ucs/Humiliation.mls **OLD**
-      TODO: Improve scrutinee name display.
-      Generated names should be polished.
-- [x] shared/src/test/diff/ucs/Hygiene.mls
-      Problem fixed!
-- [x] shared/src/test/diff/ucs/HygienicBindings.mls
-      We should fix the shadowing parameters.
-- [x] shared/src/test/diff/ucs/InterleavedLet.mls **OLD**
-      The transformation cannot handle the following case.
-      ```
-      fun mapPartition2(f, xs) =
-        if xs is
-        Nil then Pair(Nil, Nil)
-        Cons(x, xs) and mapPartition(f, xs) is Pair(l, r) and f(x) is
-              Left(v)  then Pair(Cons(v, l), r)
-              Right(v) then Pair(l, Cons(v, r))
-      ```
-      To be specific, `Cons(x, xs) and mapPartition(f, xs) is Pair(l, r)` are
-      not separated. I re-implemented `splitAnd` function.
-- [x] shared/src/test/diff/ucs/JSON.mls
-      Deleted. This one is not completed and we have a new version.
-- [x] shared/src/test/diff/ucs/LeadingAnd.mls
-- [x] shared/src/test/diff/ucs/LitUCS.mls
-- [x] shared/src/test/diff/ucs/MultiwayIf.mls
-- [x] shared/src/test/diff/ucs/NestedBranches.mls
-      Found a bug in transformation.
-- [x] shared/src/test/diff/ucs/NestedOpSplits.mls
-- [x] shared/src/test/diff/ucs/NestedPattern.mls
-- [x] shared/src/test/diff/ucs/NuPlainConditionals.mls
-- [x] shared/src/test/diff/ucs/Or.mls
-- [x] shared/src/test/diff/ucs/OverlappedBranches.mls **OLD**
-      Should report unreachable cases.
-- [x] shared/src/test/diff/ucs/ParseFailures.mls
-- [x] shared/src/test/diff/ucs/PlainConditionals.mls
-      Maybe we should keep this old one...
-- [x] shared/src/test/diff/ucs/SimpleUCS.mls
-      Migrate this test case to new defintion typing.
-      Remove a `???` and raise error during transformation.
-- [x] shared/src/test/diff/ucs/SplitAfterOp.mls
-      Wrap tests in functions so that errors are clearer.
-- [x] shared/src/test/diff/ucs/SplitAnd.mls
-      Should report missing else branches.
-- [x] shared/src/test/diff/ucs/SplitAroundOp.mls
-- [x] shared/src/test/diff/ucs/SplitBeforeOp.mls
-- [x] shared/src/test/diff/ucs/SplitOps.mls
-- [x] shared/src/test/diff/ucs/SplitScrutinee.mls
-      Fixed.
-- [x] shared/src/test/diff/ucs/ThenIndent.mls
-- [x] shared/src/test/diff/ucs/Tree.mls
-- [x] shared/src/test/diff/ucs/TrivialIf.mls **OLD**
-- [x] shared/src/test/diff/ucs/WeirdIf.mls
-      Should report redundant cases.
-- [x] shared/src/test/diff/ucs/WeirdSplit.mls **OLD**
-- [x] shared/src/test/diff/ucs/Wildcard.mls
-      Some unexpected empty splits.
-- [x] shared/src/test/diff/ucs/zipWith.mls
-

From 2086b7f174dd27f81c5d610ede613df43e9c040e Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 17 Jan 2024 01:52:14 +0800
Subject: [PATCH 081/147] Make readable names for generated variables

---
 .../mlscript/ucs/context/PatternInfo.scala    |  3 ++
 .../mlscript/ucs/context/Scrutinee.scala      | 14 ++++++
 .../ucs/stages/CoverageChecking.scala         | 20 +++++---
 .../main/scala/mlscript/utils/package.scala   | 17 +++++++
 shared/src/test/diff/nu/ArrayProg.mls         | 24 +++++-----
 .../pretyper/ucs/coverage/MissingCases.mls    | 48 +++++++++----------
 .../pretyper/ucs/coverage/SealedClasses.mls   |  6 +--
 shared/src/test/diff/ucs/ElseIf.mls           | 24 +++++-----
 shared/src/test/diff/ucs/Exhaustiveness.mls   |  8 ++--
 shared/src/test/diff/ucs/Humiliation.mls      | 28 +++++------
 shared/src/test/diff/ucs/InterleavedLet.mls   |  4 +-
 shared/src/test/diff/ucs/SimpleUCS.mls        | 42 ++++++++--------
 12 files changed, 139 insertions(+), 99 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala b/shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala
index 07362bed82..5d232e5595 100644
--- a/shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala
@@ -36,6 +36,9 @@ object PatternInfo {
     private var unappliedVarOpt: Opt[Var] = N
     private val parameters: MutSortedMap[Int, Scrutinee] = MutSortedMap.empty
 
+    private[context] def findSubScrutinee(scrutinee: Scrutinee): Opt[Int] =
+      parameters.find(_._2 === scrutinee).map(_._1)
+
     /**
       * Get or create a sub-scrutinee for the given parameter index.
       *
diff --git a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
index 685cbb50c2..e45dec1938 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
@@ -116,6 +116,20 @@ class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
     }.toMap[Pattern, Ls[Loc]]
     CaseSet(cases ++ tuplePattern)
   }
+
+  def getReadableName(scrutineeVar: Var): Str = {
+    parent match {
+      case N if context.isGeneratedVar(scrutineeVar) => "term"
+      case N => s"`${scrutineeVar.name}`"
+      case S(parentScrutinee) =>
+        parentScrutinee.classLikePatterns.iterator.flatMap { case (symbol, pattern) =>
+          pattern.findSubScrutinee(this).map(_ -> symbol.name)
+        }.nextOption() match {
+          case S(index -> typeName) => s"${index.toOrdinalWord} argument of `${typeName}`"
+          case N => s"`${scrutineeVar.name}`" // Still not the best.
+        }
+    }
+  }
 }
 
 object Scrutinee {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index 3bb3c6ffb8..2ef80662d3 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -113,22 +113,28 @@ trait CoverageChecking { self: Desugarer with Traceable =>
 
 object CoverageChecking {
   /** Create an `ErrorReport` that explains missing cases. */
-  private def explainMissingCases(scrutinee: NamedScrutinee, seen: SeenRegistry, missingCases: CaseSet): Opt[ErrorReport] =
+  private def explainMissingCases(
+      scrutinee: NamedScrutinee,
+      seen: SeenRegistry,
+      missingCases: CaseSet
+  )(implicit context: Context): Opt[ErrorReport] =
     if (missingCases.isEmpty) {
       N
     } else {
       S(ErrorReport({
-        val lines = (msg"Scrutinee `${scrutinee._1.name}` has ${"missing case".pluralize(missingCases.size, true)}" -> scrutinee._1.toLoc) ::
+        val readableName = scrutinee._2.getReadableName(scrutinee._1)
+        val lines = (msg"$readableName has ${"missing case".pluralize(missingCases.size, true)}" -> scrutinee._1.toLoc) ::
           (missingCases.cases.iterator.flatMap { case (pattern, locations) =>
-            (msg"It can be ${pattern.toString}" -> locations.headOption) :: Nil
+            (msg"it can be ${pattern.toString}" -> locations.headOption) :: Nil
           }.toList)
         if (seen.isEmpty) {
           lines
         } else {
-          seen.iterator.zipWithIndex.map { case ((scrutinee, (classSymbol, locations, cases)), i) =>
-            val prologue = if (i === 0) "When " else ""
-            val epilogue = if (seen.size === 1) "" else if (i === seen.size - 1) ", and" else ","
-            msg"${prologue}scrutinee `${scrutinee._1.name}` is `${classSymbol.name}`$epilogue" -> locations.headOption
+          seen.iterator.zipWithIndex.map { case ((scrutineeVar -> scrutinee, (classSymbol, locations, cases)), i) =>
+            val prologue = if (i === 0) "when " else ""
+            val epilogue = if (seen.size === 1) "" else if (i === seen.size - 2) ", and" else ","
+            val scrutineeName = scrutinee.getReadableName(scrutineeVar)
+            msg"$prologue$scrutineeName is `${classSymbol.name}`$epilogue" -> locations.headOption
           }.toList ::: lines
         }
       }, true, Diagnostic.Desugaring))
diff --git a/shared/src/main/scala/mlscript/utils/package.scala b/shared/src/main/scala/mlscript/utils/package.scala
index adb607a6e0..e8bb4c46fc 100644
--- a/shared/src/main/scala/mlscript/utils/package.scala
+++ b/shared/src/main/scala/mlscript/utils/package.scala
@@ -21,6 +21,23 @@ package object utils {
     def in(xs: A => Bool): Bool = xs(self)
     def in(xs: Seq[_ >: A]): Bool = xs.exists(_ === self)
   }
+
+  implicit class IntOps(private val self: Int) extends AnyVal {
+    def toOrdinalWord: String = {
+      require(self >= 0)
+      self + 1 match {
+        case 1 => "first"
+        case 2 => "second"
+        case 3 => "third"
+        case n => self.toString + (n % 10 match {
+          case 1 => "st"
+          case 2 => "nd"
+          case 3 => "rd"
+          case _ => "th"
+        })
+      }
+    }
+  }
   
   implicit class StringOps(private val self: String) extends AnyVal {
     import collection.mutable
diff --git a/shared/src/test/diff/nu/ArrayProg.mls b/shared/src/test/diff/nu/ArrayProg.mls
index a0b7553fbe..89d7e91979 100644
--- a/shared/src/test/diff/nu/ArrayProg.mls
+++ b/shared/src/test/diff/nu/ArrayProg.mls
@@ -189,14 +189,14 @@ fun add(e) =
     Pair(Numbr(n), Numbr(m))    then 0
     Pair(Vectr(xs),  Vectr(ys)) then 1
     Pair(Vectr(xs),  Numbr(n))  then 2
-//│ ╔══[ERROR] When scrutinee `e` is `Pair`,
+//│ ╔══[ERROR] when `e` is `Pair`, and
 //│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
 //│ ║        	    ^^^^
-//│ ╟── scrutinee `e$Pair_0` is `Numbr`, and
+//│ ╟── first argument of `Pair` is `Numbr`,
 //│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
 //│ ║        	         ^^^^^
-//│ ╟── Scrutinee `e$Pair_1` has 1 missing case
-//│ ╟── It can be class `Vectr`
+//│ ╟── second argument of `Pair` has 1 missing case
+//│ ╟── it can be class `Vectr`
 //│ ║  l.+4: 	    Pair(Vectr(xs),  Vectr(ys)) then 1
 //│ ╙──      	                     ^^^^^
 //│ fun add: Pair[Numbr | Vectr, Numbr] -> (0 | 1 | 2)
@@ -206,24 +206,24 @@ fun add(e) =
   if e is
     Pair(Numbr(n), Numbr(m))    then 0
     Pair(Vectr(xs),  Vectr(ys)) then 1
-//│ ╔══[ERROR] When scrutinee `e` is `Pair`,
+//│ ╔══[ERROR] when `e` is `Pair`, and
 //│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
 //│ ║        	    ^^^^
-//│ ╟── scrutinee `e$Pair_0` is `Numbr`, and
+//│ ╟── first argument of `Pair` is `Numbr`,
 //│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
 //│ ║        	         ^^^^^
-//│ ╟── Scrutinee `e$Pair_1` has 1 missing case
-//│ ╟── It can be class `Vectr`
+//│ ╟── second argument of `Pair` has 1 missing case
+//│ ╟── it can be class `Vectr`
 //│ ║  l.+4: 	    Pair(Vectr(xs),  Vectr(ys)) then 1
 //│ ╙──      	                     ^^^^^
-//│ ╔══[ERROR] When scrutinee `e` is `Pair`,
+//│ ╔══[ERROR] when `e` is `Pair`, and
 //│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
 //│ ║        	    ^^^^
-//│ ╟── scrutinee `e$Pair_0` is `Vectr`, and
+//│ ╟── first argument of `Pair` is `Vectr`,
 //│ ║  l.+4: 	    Pair(Vectr(xs),  Vectr(ys)) then 1
 //│ ║        	         ^^^^^
-//│ ╟── Scrutinee `e$Pair_1` has 1 missing case
-//│ ╟── It can be class `Numbr`
+//│ ╟── second argument of `Pair` has 1 missing case
+//│ ╟── it can be class `Numbr`
 //│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
 //│ ╙──      	                   ^^^^^
 //│ fun add: Pair[Numbr | Vectr, nothing] -> (0 | 1)
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls b/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls
index 9d62846406..d7f68e794f 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/MissingCases.mls
@@ -23,13 +23,13 @@ fun bad_add_missing_SS(x, y) =
     x is Some(xv) and y is None     then xv
     x is None     and y is Some(yv) then yv
     x is None     and y is None     then 0
-//│ ╔══[ERROR] When scrutinee `x` is `Some`
+//│ ╔══[ERROR] when `x` is `Some`
 //│ ║  l.23: 	    x is Some(xv) and y is None     then xv
 //│ ║        	         ^^^^
-//│ ╟── Scrutinee `y` has 1 missing case
+//│ ╟── `y` has 1 missing case
 //│ ║  l.23: 	    x is Some(xv) and y is None     then xv
 //│ ║        	                      ^
-//│ ╟── It can be class `Some`
+//│ ╟── it can be class `Some`
 //│ ║  l.24: 	    x is None     and y is Some(yv) then yv
 //│ ╙──      	                           ^^^^
 //│ fun bad_add_missing_SS: forall 'a. (None | Some['a], None) -> (0 | 'a)
@@ -40,13 +40,13 @@ fun bad_add_missing_SN(x, y) =
     x is Some(xv) and y is Some(yv) then xv + yv
     x is None     and y is Some(yv) then yv
     x is None     and y is None     then 0
-//│ ╔══[ERROR] When scrutinee `x` is `Some`
+//│ ╔══[ERROR] when `x` is `Some`
 //│ ║  l.40: 	    x is Some(xv) and y is Some(yv) then xv + yv
 //│ ║        	         ^^^^
-//│ ╟── Scrutinee `y` has 1 missing case
+//│ ╟── `y` has 1 missing case
 //│ ║  l.40: 	    x is Some(xv) and y is Some(yv) then xv + yv
 //│ ║        	                      ^
-//│ ╟── It can be module `None`
+//│ ╟── it can be module `None`
 //│ ║  l.42: 	    x is None     and y is None     then 0
 //│ ╙──      	                           ^^^^
 //│ fun bad_add_missing_SN: forall 'a. (None | Some[Int], Some[Int & 'a]) -> (Int | 'a)
@@ -57,13 +57,13 @@ fun bad_add_missing_NS(x, y) =
     x is Some(xv) and y is Some(yv) then xv + yv
     x is Some(xv) and y is None     then xv
     x is None     and y is None     then 0
-//│ ╔══[ERROR] When scrutinee `x` is `None`
+//│ ╔══[ERROR] when `x` is `None`
 //│ ║  l.59: 	    x is None     and y is None     then 0
 //│ ║        	         ^^^^
-//│ ╟── Scrutinee `y` has 1 missing case
+//│ ╟── `y` has 1 missing case
 //│ ║  l.59: 	    x is None     and y is None     then 0
 //│ ║        	                      ^
-//│ ╟── It can be class `Some`
+//│ ╟── it can be class `Some`
 //│ ║  l.57: 	    x is Some(xv) and y is Some(yv) then xv + yv
 //│ ╙──      	                           ^^^^
 //│ fun bad_add_missing_NS: (None | Some[Int], None) -> Int
@@ -74,13 +74,13 @@ fun bad_add_missing_NN(x, y) =
     x is Some(xv) and y is Some(yv) then xv + yv
     x is Some(xv) and y is None     then xv
     x is None     and y is Some(yv) then yv
-//│ ╔══[ERROR] When scrutinee `x` is `None`
+//│ ╔══[ERROR] when `x` is `None`
 //│ ║  l.76: 	    x is None     and y is Some(yv) then yv
 //│ ║        	         ^^^^
-//│ ╟── Scrutinee `y` has 1 missing case
+//│ ╟── `y` has 1 missing case
 //│ ║  l.76: 	    x is None     and y is Some(yv) then yv
 //│ ║        	                      ^
-//│ ╟── It can be module `None`
+//│ ╟── it can be module `None`
 //│ ║  l.75: 	    x is Some(xv) and y is None     then xv
 //│ ╙──      	                           ^^^^
 //│ fun bad_add_missing_NN: forall 'a. (None | Some[Int], Some[Int & 'a]) -> (Int | 'a)
@@ -90,22 +90,22 @@ fun bad_add_missing_SS_NN(x, y) =
   if
     x is Some(xv) and y is None     then xv
     x is None     and y is Some(yv) then yv
-//│ ╔══[ERROR] When scrutinee `x` is `Some`
+//│ ╔══[ERROR] when `x` is `Some`
 //│ ║  l.91: 	    x is Some(xv) and y is None     then xv
 //│ ║        	         ^^^^
-//│ ╟── Scrutinee `y` has 1 missing case
+//│ ╟── `y` has 1 missing case
 //│ ║  l.91: 	    x is Some(xv) and y is None     then xv
 //│ ║        	                      ^
-//│ ╟── It can be class `Some`
+//│ ╟── it can be class `Some`
 //│ ║  l.92: 	    x is None     and y is Some(yv) then yv
 //│ ╙──      	                           ^^^^
-//│ ╔══[ERROR] When scrutinee `x` is `None`
+//│ ╔══[ERROR] when `x` is `None`
 //│ ║  l.92: 	    x is None     and y is Some(yv) then yv
 //│ ║        	         ^^^^
-//│ ╟── Scrutinee `y` has 1 missing case
+//│ ╟── `y` has 1 missing case
 //│ ║  l.92: 	    x is None     and y is Some(yv) then yv
 //│ ║        	                      ^
-//│ ╟── It can be module `None`
+//│ ╟── it can be module `None`
 //│ ║  l.91: 	    x is Some(xv) and y is None     then xv
 //│ ╙──      	                           ^^^^
 //│ fun bad_add_missing_SS_NN: forall 'a. (None | Some['a], nothing) -> 'a
@@ -115,22 +115,22 @@ fun bad_add_missing_SN_NS(x, y) =
   if
     x is Some(xv) and y is Some(yv) then xv + yv
     x is None     and y is None     then 0
-//│ ╔══[ERROR] When scrutinee `x` is `Some`
+//│ ╔══[ERROR] when `x` is `Some`
 //│ ║  l.116: 	    x is Some(xv) and y is Some(yv) then xv + yv
 //│ ║         	         ^^^^
-//│ ╟── Scrutinee `y` has 1 missing case
+//│ ╟── `y` has 1 missing case
 //│ ║  l.116: 	    x is Some(xv) and y is Some(yv) then xv + yv
 //│ ║         	                      ^
-//│ ╟── It can be module `None`
+//│ ╟── it can be module `None`
 //│ ║  l.117: 	    x is None     and y is None     then 0
 //│ ╙──       	                           ^^^^
-//│ ╔══[ERROR] When scrutinee `x` is `None`
+//│ ╔══[ERROR] when `x` is `None`
 //│ ║  l.117: 	    x is None     and y is None     then 0
 //│ ║         	         ^^^^
-//│ ╟── Scrutinee `y` has 1 missing case
+//│ ╟── `y` has 1 missing case
 //│ ║  l.117: 	    x is None     and y is None     then 0
 //│ ║         	                      ^
-//│ ╟── It can be class `Some`
+//│ ╟── it can be class `Some`
 //│ ║  l.116: 	    x is Some(xv) and y is Some(yv) then xv + yv
 //│ ╙──       	                           ^^^^
 //│ fun bad_add_missing_SN_NS: (None | Some[Int], nothing) -> Int
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
index d852038b9e..73af7dad23 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
@@ -53,13 +53,13 @@ fun is_value'(term) =
   if term is Term and term is
     Abs(_, _) then true
     Var(_) then false
-//│ ╔══[ERROR] When scrutinee `term` is `Term`
+//│ ╔══[ERROR] when `term` is `Term`
 //│ ║  l.53: 	  if term is Term and term is
 //│ ║        	             ^^^^
-//│ ╟── Scrutinee `term` has 1 missing case
+//│ ╟── `term` has 1 missing case
 //│ ║  l.53: 	  if term is Term and term is
 //│ ║        	                      ^^^^
-//│ ╟── It can be class `App`
+//│ ╟── it can be class `App`
 //│ ║  l.6: 	class App(func: Term, arg: Term) extends Term
 //│ ╙──     	      ^^^
 //│ fun is_value': (Abs | Var) -> Bool
diff --git a/shared/src/test/diff/ucs/ElseIf.mls b/shared/src/test/diff/ucs/ElseIf.mls
index 8f59b0782f..2f52f9b925 100644
--- a/shared/src/test/diff/ucs/ElseIf.mls
+++ b/shared/src/test/diff/ucs/ElseIf.mls
@@ -28,22 +28,22 @@ module Fals
 fun f(x, y) = if x is
     Tru and y is Tru then true
     Fals and y is Fals then false
-//│ ╔══[ERROR] When scrutinee `x` is `Tru`
+//│ ╔══[ERROR] when `x` is `Tru`
 //│ ║  l.29: 	    Tru and y is Tru then true
 //│ ║        	    ^^^
-//│ ╟── Scrutinee `y` has 1 missing case
+//│ ╟── `y` has 1 missing case
 //│ ║  l.29: 	    Tru and y is Tru then true
 //│ ║        	            ^
-//│ ╟── It can be module `Fals`
+//│ ╟── it can be module `Fals`
 //│ ║  l.30: 	    Fals and y is Fals then false
 //│ ╙──      	                  ^^^^
-//│ ╔══[ERROR] When scrutinee `x` is `Fals`
+//│ ╔══[ERROR] when `x` is `Fals`
 //│ ║  l.30: 	    Fals and y is Fals then false
 //│ ║        	    ^^^^
-//│ ╟── Scrutinee `y` has 1 missing case
+//│ ╟── `y` has 1 missing case
 //│ ║  l.30: 	    Fals and y is Fals then false
 //│ ║        	             ^
-//│ ╟── It can be module `Tru`
+//│ ╟── it can be module `Tru`
 //│ ║  l.29: 	    Tru and y is Tru then true
 //│ ╙──      	                 ^^^
 //│ fun f: (Fals | Tru, nothing) -> Bool
@@ -105,22 +105,22 @@ fun f(x, y) = if x is
   else if y is
     Tru and x is Fals then true
     Fals and x is Tru then false
-//│ ╔══[ERROR] When scrutinee `y` is `Tru`
+//│ ╔══[ERROR] when `y` is `Tru`
 //│ ║  l.106: 	    Tru and x is Fals then true
 //│ ║         	    ^^^
-//│ ╟── Scrutinee `x` has 1 missing case
+//│ ╟── `x` has 1 missing case
 //│ ║  l.106: 	    Tru and x is Fals then true
 //│ ║         	            ^
-//│ ╟── It can be module `Tru`
+//│ ╟── it can be module `Tru`
 //│ ║  l.107: 	    Fals and x is Tru then false
 //│ ╙──       	                  ^^^
-//│ ╔══[ERROR] When scrutinee `y` is `Fals`
+//│ ╔══[ERROR] when `y` is `Fals`
 //│ ║  l.107: 	    Fals and x is Tru then false
 //│ ║         	    ^^^^
-//│ ╟── Scrutinee `x` has 1 missing case
+//│ ╟── `x` has 1 missing case
 //│ ║  l.107: 	    Fals and x is Tru then false
 //│ ║         	             ^
-//│ ╟── It can be module `Fals`
+//│ ╟── it can be module `Fals`
 //│ ║  l.106: 	    Tru and x is Fals then true
 //│ ╙──       	                 ^^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
diff --git a/shared/src/test/diff/ucs/Exhaustiveness.mls b/shared/src/test/diff/ucs/Exhaustiveness.mls
index 45abe4607f..1bf9bd51cd 100644
--- a/shared/src/test/diff/ucs/Exhaustiveness.mls
+++ b/shared/src/test/diff/ucs/Exhaustiveness.mls
@@ -19,16 +19,16 @@ fun f(x, y) =
     y is B and
       x is
         A then 4
-//│ ╔══[ERROR] When scrutinee `y` is `B`
+//│ ╔══[ERROR] when `y` is `B`
 //│ ║  l.19: 	    y is B and
 //│ ║        	         ^
-//│ ╟── Scrutinee `x` has 2 missing cases
+//│ ╟── `x` has 2 missing cases
 //│ ║  l.20: 	      x is
 //│ ║        	      ^
-//│ ╟── It can be class `B`
+//│ ╟── it can be class `B`
 //│ ║  l.17: 	        B then 1
 //│ ║        	        ^
-//│ ╟── It can be class `C`
+//│ ╟── it can be class `C`
 //│ ║  l.18: 	        C then 2
 //│ ╙──      	        ^
 //│ fun f: (A, A | B) -> (0 | 1 | 2 | 4)
diff --git a/shared/src/test/diff/ucs/Humiliation.mls b/shared/src/test/diff/ucs/Humiliation.mls
index 9f258cdcba..d61bdb2df6 100644
--- a/shared/src/test/diff/ucs/Humiliation.mls
+++ b/shared/src/test/diff/ucs/Humiliation.mls
@@ -49,24 +49,24 @@ class O()
 fun foo(x) = if x is
   Pair(Z(), Z()) then "zeros"
   Pair(O(), O()) then "ones"
-//│ ╔══[ERROR] When scrutinee `x` is `Pair`,
+//│ ╔══[ERROR] when `x` is `Pair`, and
 //│ ║  l.50: 	  Pair(Z(), Z()) then "zeros"
 //│ ║        	  ^^^^
-//│ ╟── scrutinee `x$Pair_0` is `Z`, and
+//│ ╟── first argument of `Pair` is `Z`,
 //│ ║  l.50: 	  Pair(Z(), Z()) then "zeros"
 //│ ║        	       ^
-//│ ╟── Scrutinee `x$Pair_1` has 1 missing case
-//│ ╟── It can be class `O`
+//│ ╟── second argument of `Pair` has 1 missing case
+//│ ╟── it can be class `O`
 //│ ║  l.51: 	  Pair(O(), O()) then "ones"
 //│ ╙──      	            ^
-//│ ╔══[ERROR] When scrutinee `x` is `Pair`,
+//│ ╔══[ERROR] when `x` is `Pair`, and
 //│ ║  l.50: 	  Pair(Z(), Z()) then "zeros"
 //│ ║        	  ^^^^
-//│ ╟── scrutinee `x$Pair_0` is `O`, and
+//│ ╟── first argument of `Pair` is `O`,
 //│ ║  l.51: 	  Pair(O(), O()) then "ones"
 //│ ║        	       ^
-//│ ╟── Scrutinee `x$Pair_1` has 1 missing case
-//│ ╟── It can be class `Z`
+//│ ╟── second argument of `Pair` has 1 missing case
+//│ ╟── it can be class `Z`
 //│ ║  l.50: 	  Pair(Z(), Z()) then "zeros"
 //│ ╙──      	            ^
 //│ fun foo: Pair[O | Z, nothing] -> ("ones" | "zeros")
@@ -76,11 +76,11 @@ fun foo(x) = if x is
 fun foo(x) = if x is
   [Z(), Z()] then "zeros"
   [O(), O()] then "ones"
-//│ ╔══[ERROR] When scrutinee `x$Tuple$2_0` is `O`
+//│ ╔══[ERROR] when `x$Tuple$2_0` is `O`
 //│ ║  l.78: 	  [O(), O()] then "ones"
 //│ ║        	   ^
-//│ ╟── Scrutinee `x$Tuple$2_1` has 1 missing case
-//│ ╟── It can be class `Z`
+//│ ╟── `x$Tuple$2_1` has 1 missing case
+//│ ╟── it can be class `Z`
 //│ ║  l.77: 	  [Z(), Z()] then "zeros"
 //│ ╙──      	        ^
 //│ fun foo: forall 'a. {0: O | Z, 1: O & 'a} -> ("ones" | "zeros" | 'a)
@@ -136,11 +136,11 @@ fun foo(x) = if x is
   Pair(Z(), Z()) then "zeros"
   Pair(O(), O()) then "ones"
   Pair(y, O()) then x
-//│ ╔══[ERROR] When scrutinee `x` is `Pair`
+//│ ╔══[ERROR] when `x` is `Pair`
 //│ ║  l.136: 	  Pair(Z(), Z()) then "zeros"
 //│ ║         	  ^^^^
-//│ ╟── Scrutinee `x$Pair_1` has 1 missing case
-//│ ╟── It can be class `Z`
+//│ ╟── second argument of `Pair` has 1 missing case
+//│ ╟── it can be class `Z`
 //│ ║  l.136: 	  Pair(Z(), Z()) then "zeros"
 //│ ╙──       	            ^
 //│ fun foo: forall 'B 'A. Pair['A, O & 'B] -> ("ones" | "zeros" | Pair['A, 'B] | 'A)
diff --git a/shared/src/test/diff/ucs/InterleavedLet.mls b/shared/src/test/diff/ucs/InterleavedLet.mls
index b17f8fd4cb..1383082492 100644
--- a/shared/src/test/diff/ucs/InterleavedLet.mls
+++ b/shared/src/test/diff/ucs/InterleavedLet.mls
@@ -39,10 +39,10 @@ fun p(x, y) =
     x is Some and y is Some then 0
 //│ ╔══[ERROR] unexpected empty split found
 //│ ╙──
-//│ ╔══[ERROR] Scrutinee `y` has 1 missing case
+//│ ╔══[ERROR] `y` has 1 missing case
 //│ ║  l.38: 	    y is Some and x is Some then 1
 //│ ║        	    ^
-//│ ╟── It can be module `None`
+//│ ╟── it can be module `None`
 //│ ║  l.37: 	    x is Some and y is None then 0
 //│ ╙──      	                       ^^^^
 //│ fun p: (Object & ~#Some | Some[anything], Some[anything]) -> (0 | 1)
diff --git a/shared/src/test/diff/ucs/SimpleUCS.mls b/shared/src/test/diff/ucs/SimpleUCS.mls
index 4753c4adf4..90291d2fc6 100644
--- a/shared/src/test/diff/ucs/SimpleUCS.mls
+++ b/shared/src/test/diff/ucs/SimpleUCS.mls
@@ -20,40 +20,40 @@ fun f(x, y) =
     Left(xv) and y is Left(yv) then xv + yv
     Right(xv) and y is Right(yv) then xv * yv
     None and y is None then 0
-//│ ╔══[ERROR] When scrutinee `x` is `Left`
+//│ ╔══[ERROR] when `x` is `Left`
 //│ ║  l.20: 	    Left(xv) and y is Left(yv) then xv + yv
 //│ ║        	    ^^^^
-//│ ╟── Scrutinee `y` has 2 missing cases
+//│ ╟── `y` has 2 missing cases
 //│ ║  l.20: 	    Left(xv) and y is Left(yv) then xv + yv
 //│ ║        	                 ^
-//│ ╟── It can be module `None`
+//│ ╟── it can be module `None`
 //│ ║  l.22: 	    None and y is None then 0
 //│ ║        	                  ^^^^
-//│ ╟── It can be class `Right`
+//│ ╟── it can be class `Right`
 //│ ║  l.21: 	    Right(xv) and y is Right(yv) then xv * yv
 //│ ╙──      	                       ^^^^^
-//│ ╔══[ERROR] When scrutinee `x` is `Right`
+//│ ╔══[ERROR] when `x` is `Right`
 //│ ║  l.21: 	    Right(xv) and y is Right(yv) then xv * yv
 //│ ║        	    ^^^^^
-//│ ╟── Scrutinee `y` has 2 missing cases
+//│ ╟── `y` has 2 missing cases
 //│ ║  l.21: 	    Right(xv) and y is Right(yv) then xv * yv
 //│ ║        	                  ^
-//│ ╟── It can be class `Left`
+//│ ╟── it can be class `Left`
 //│ ║  l.20: 	    Left(xv) and y is Left(yv) then xv + yv
 //│ ║        	                      ^^^^
-//│ ╟── It can be module `None`
+//│ ╟── it can be module `None`
 //│ ║  l.22: 	    None and y is None then 0
 //│ ╙──      	                  ^^^^
-//│ ╔══[ERROR] When scrutinee `x` is `None`
+//│ ╔══[ERROR] when `x` is `None`
 //│ ║  l.22: 	    None and y is None then 0
 //│ ║        	    ^^^^
-//│ ╟── Scrutinee `y` has 2 missing cases
+//│ ╟── `y` has 2 missing cases
 //│ ║  l.22: 	    None and y is None then 0
 //│ ║        	             ^
-//│ ╟── It can be class `Left`
+//│ ╟── it can be class `Left`
 //│ ║  l.20: 	    Left(xv) and y is Left(yv) then xv + yv
 //│ ║        	                      ^^^^
-//│ ╟── It can be class `Right`
+//│ ╟── it can be class `Right`
 //│ ║  l.21: 	    Right(xv) and y is Right(yv) then xv * yv
 //│ ╙──      	                       ^^^^^
 //│ fun f: (Left[Int] | None | Right[Int], nothing) -> Int
@@ -114,22 +114,22 @@ fun f(x, y) =
   if x is
     Some(xv) and y is Some(yv) then xv + yv
     None and y is None then 0
-//│ ╔══[ERROR] When scrutinee `x` is `Some`
+//│ ╔══[ERROR] when `x` is `Some`
 //│ ║  l.115: 	    Some(xv) and y is Some(yv) then xv + yv
 //│ ║         	    ^^^^
-//│ ╟── Scrutinee `y` has 1 missing case
+//│ ╟── `y` has 1 missing case
 //│ ║  l.115: 	    Some(xv) and y is Some(yv) then xv + yv
 //│ ║         	                 ^
-//│ ╟── It can be module `None`
+//│ ╟── it can be module `None`
 //│ ║  l.116: 	    None and y is None then 0
 //│ ╙──       	                  ^^^^
-//│ ╔══[ERROR] When scrutinee `x` is `None`
+//│ ╔══[ERROR] when `x` is `None`
 //│ ║  l.116: 	    None and y is None then 0
 //│ ║         	    ^^^^
-//│ ╟── Scrutinee `y` has 1 missing case
+//│ ╟── `y` has 1 missing case
 //│ ║  l.116: 	    None and y is None then 0
 //│ ║         	             ^
-//│ ╟── It can be class `Some`
+//│ ╟── it can be class `Some`
 //│ ║  l.115: 	    Some(xv) and y is Some(yv) then xv + yv
 //│ ╙──       	                      ^^^^
 //│ fun f: (None | Some[Int], nothing) -> Int
@@ -142,13 +142,13 @@ fun f(x, y) =
       None then xv * 2
     None and y is
       Some(yv) then yv * 3
-//│ ╔══[ERROR] When scrutinee `x` is `None`
+//│ ╔══[ERROR] when `x` is `None`
 //│ ║  l.143: 	    None and y is
 //│ ║         	    ^^^^
-//│ ╟── Scrutinee `y` has 1 missing case
+//│ ╟── `y` has 1 missing case
 //│ ║  l.143: 	    None and y is
 //│ ║         	             ^
-//│ ╟── It can be module `None`
+//│ ╟── it can be module `None`
 //│ ║  l.142: 	      None then xv * 2
 //│ ╙──       	      ^^^^
 //│ fun f: (None | Some[Int], Some[Int]) -> Int

From 318d6ebe5e857dcae6a0837aea9580f9be26dbe2 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 17 Jan 2024 02:04:25 +0800
Subject: [PATCH 082/147] Warn about the use of type parameters in patterns

---
 .../mlscript/ucs/stages/Transformation.scala  |  5 ++++-
 shared/src/test/diff/gadt/Exp1.mls            | 20 ++++++-------------
 2 files changed, 10 insertions(+), 15 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index 26f4ab0c90..fcc7ce9f6b 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -2,7 +2,7 @@ package mlscript.ucs.stages
 
 import mlscript.ucs, ucs.Desugarer, ucs.syntax.source._
 import mlscript.{If, IfBody, IfBlock, IfElse, IfLet, IfOpApp, IfOpsApp, IfThen}
-import mlscript.{Blk, Term, Var, App, Tup, Lit, Fld, Loc, NuFunDef, PlainTup}
+import mlscript.{Blk, Term, Var, App, Tup, Lit, Fld, Loc, NuFunDef, TyApp, PlainTup}
 import mlscript.pretyper.Traceable
 import mlscript.Message, Message._
 import mlscript.utils._, shorthands._
@@ -192,6 +192,9 @@ trait Transformation { self: Desugarer with Traceable =>
           raiseDesugaringError(msg"only class patterns can be refined" -> p.toLoc)
           p
       }
+    case App(TyApp(classNme @ Var(_), targs), parameters: Tup) =>
+      raiseDesugaringWarning(msg"type parameters in patterns are currently ignored" -> Loc(targs))
+      ClassPattern(classNme, S(transformTupleTerm(parameters)), refined = false)
     case App(classNme @ Var(_), parameters: Tup) =>
       ClassPattern(classNme, S(transformTupleTerm(parameters)), refined = false)
     case tuple: Tup => TuplePattern(transformTupleTerm(tuple))
diff --git a/shared/src/test/diff/gadt/Exp1.mls b/shared/src/test/diff/gadt/Exp1.mls
index 8daa75e1c0..43b223d3e8 100644
--- a/shared/src/test/diff/gadt/Exp1.mls
+++ b/shared/src/test/diff/gadt/Exp1.mls
@@ -30,21 +30,13 @@ fun f(e) = if e is
 //│     = [Function: res]
 
 
-:e // TODO support
+:w
 fun f(e) = if e is
   Pair['a, 'b](l, r) then [l, r]
-//│ ╔══[ERROR] unknown pattern Pair‹'a, 'b›(l, r,)
-//│ ║  l.35: 	  Pair['a, 'b](l, r) then [l, r]
-//│ ╙──      	  ^^^^^^^^^^^^^^^^^^
-//│ ╔══[ERROR] identifier not found: l
-//│ ║  l.35: 	  Pair['a, 'b](l, r) then [l, r]
-//│ ╙──      	                           ^
-//│ ╔══[ERROR] identifier not found: r
+//│ ╔══[WARNING] type parameters in patterns are currently ignored
 //│ ║  l.35: 	  Pair['a, 'b](l, r) then [l, r]
-//│ ╙──      	                              ^
-//│ fun f: anything -> [error, error]
-//│ Code generation encountered an error:
-//│   unresolved symbol l
+//│ ╙──      	       ^^^^^^
+//│ fun f: forall 'a 'b. Pair['a, 'b] -> ['a, 'b]
 
 
 :e // TODO support
@@ -53,10 +45,10 @@ fun f(e) = if e is
     let f(x: a) = x
     f(l)
 //│ ╔══[ERROR] type identifier not found: a
-//│ ║  l.53: 	    let f(x: a) = x
+//│ ║  l.45: 	    let f(x: a) = x
 //│ ╙──      	             ^
 //│ ╔══[ERROR] identifier not found: l
-//│ ║  l.54: 	    f(l)
+//│ ║  l.46: 	    f(l)
 //│ ╙──      	      ^
 //│ fun f: Pair[anything, anything] -> error
 //│ Code generation encountered an error:

From f266f3af8599fb5cc00fc1b3c5fb6c794a15065b Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 17 Jan 2024 02:25:27 +0800
Subject: [PATCH 083/147] Document functions in `LinesOps`

---
 .../src/main/scala/mlscript/ucs/package.scala | 53 ++++++++++++++-----
 1 file changed, 40 insertions(+), 13 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/package.scala b/shared/src/main/scala/mlscript/ucs/package.scala
index dd2ddf92f6..5976667fe1 100644
--- a/shared/src/main/scala/mlscript/ucs/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/package.scala
@@ -19,27 +19,54 @@ package object ucs {
   type Lines = Ls[(Int, Str)]
 
   implicit class LinesOps(private val lines: Lines) extends AnyVal {
-    def indent: Lines = {
-      @tailrec
-      def rec(acc: Lines, lines: Lines): Lines = lines match {
-        case (n, line) :: tail => rec((n + 1, line) :: acc, tail)
-        case Nil => acc.reverse
-      }
-      rec(Nil, lines)
-    }
+    /** Increase the indentation of all lines by one. */
+    def indent: Lines = lines.map { case (n, line) => (n + 1, line) }
+
+    /**
+      * Prepend a new line and indent the remaining lines. When you want to add
+      * a "title" to several lines and indent them, you should use this function.
+      * 
+      * Suppose we have the following `Lines` representing case branches.
+      * ```
+      * A -> 0
+      * B -> 0
+      * ```
+      * We can prepend string `case x of` to lines and get the following result.
+      * ```
+      * case x of
+      *   A -> 0
+      *   B -> 0
+      * ```
+      */
     def ##:(prefix: Str): Lines = (0, prefix) :: lines.indent
+
+    /**
+      * If the first line does not have indentation and the remaining lines are
+      * indented, prepend the given string to the first line. Otherwise, prepend
+      * the given string to the first line and indent all remaining lines.
+      *
+      * When you want to amend the title of lines, you should use this function.
+      */
     def #:(prefix: Str): Lines = {
       lines match {
         case (0, line) :: lines if lines.forall(_._1 > 0) => (0, s"$prefix $line") :: lines
         case lines => (0, prefix) :: lines.indent
       }
     }
-    def @:(prefix: Str): Lines = {
-      lines match {
-        case (_, line) :: Nil => (0, prefix + " " + line) :: Nil
-        case lines => (0, prefix) :: lines.indent
-      }
+    /**
+      * If there is only one line, prepend the given string to the beginning of
+      * this line. Otherwise, use the given string as the first line and indent
+      * the remaining lines.
+      * 
+      * Similar to `##:`, except this function does not indent if there is only
+      * one line.
+      */
+    def @:(prefix: Str): Lines = lines match {
+      case (_, line) :: Nil => (0, prefix + " " + line) :: Nil
+      case lines => (0, prefix) :: lines.indent
     }
+
+    /** Make a multi-line string. */
     def toIndentedString: Str =
       lines.iterator.map { case (n, line) => "  " * n + line }.mkString("\n")
   }

From 7d0e1f45cda4e69938d0e4e682d592a7890ce8dc Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 17 Jan 2024 02:41:24 +0800
Subject: [PATCH 084/147] Support `as` patterns

---
 .../mlscript/ucs/stages/Desugaring.scala      |  9 ++--
 .../mlscript/ucs/stages/Transformation.scala  |  7 ++++
 shared/src/test/diff/nu/CaseExpr.mls          | 42 ++++++++-----------
 .../pretyper/ucs/examples/LispInterpreter.mls |  7 ++--
 4 files changed, 32 insertions(+), 33 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index d82a2f1852..db238f4989 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -306,10 +306,10 @@ trait Desugaring { self: PreTyper =>
         def desugarRight(implicit scope: Scope) =
           desugarTermSplit(head.continuation)(PartialTerm.Empty, scope, context)
         def desugarTail(implicit scope: Scope) = rec(scrutineeVar, tail)
-        head.pattern match {
-          case pattern @ s.AliasPattern(_, _) =>
-            raiseDesugaringError(msg"alias pattern is not supported for now" -> pattern.toLoc)
-            desugarTail
+        def desugarPatternBranch(pattern: s.Pattern): c.Split = pattern match {
+          case pattern @ s.AliasPattern(aliasVar, nestedPattern) =>
+            scrutinee.addAliasVar(aliasVar.withFreshSymbol)
+            c.Split.Let(false, aliasVar, scrutineeVar, desugarPatternBranch(nestedPattern))
           case s.LiteralPattern(literal) =>
             scrutinee.getOrCreateLiteralPattern(literal).addLocation(literal)
             c.Branch(scrutineeVar, c.Pattern.Literal(literal), desugarRight) :: desugarTail
@@ -342,6 +342,7 @@ trait Desugaring { self: PreTyper =>
             raiseDesugaringError(msg"record pattern is not supported for now" -> pattern.toLoc)
             desugarTail
         }
+        desugarPatternBranch(head.pattern)
       case s.Split.Let(isRec, nme, rhs, tail) =>
         c.Split.Let(isRec, nme, rhs, rec(scrutineeVar, tail)(scope + nme.withFreshSymbol.symbol)) // <-- Weird use.
       case s.Split.Else(default) => c.Split.Else(default)
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index fcc7ce9f6b..98b5a5e856 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -192,6 +192,13 @@ trait Transformation { self: Desugarer with Traceable =>
           raiseDesugaringError(msg"only class patterns can be refined" -> p.toLoc)
           p
       }
+    case App(Var("as"), PlainTup(pattern, alias)) =>
+      alias match {
+        case nme @ Var(_) => AliasPattern(nme, transformPattern(pattern))
+        case other =>
+          raiseDesugaringError(msg"the pattern alias must be a variable" -> other.toLoc)
+          transformPattern(pattern)
+      }
     case App(TyApp(classNme @ Var(_), targs), parameters: Tup) =>
       raiseDesugaringWarning(msg"type parameters in patterns are currently ignored" -> Loc(targs))
       ClassPattern(classNme, S(transformTupleTerm(parameters)), refined = false)
diff --git a/shared/src/test/diff/nu/CaseExpr.mls b/shared/src/test/diff/nu/CaseExpr.mls
index cc358e0fea..35d31e67b5 100644
--- a/shared/src/test/diff/nu/CaseExpr.mls
+++ b/shared/src/test/diff/nu/CaseExpr.mls
@@ -59,28 +59,20 @@ map(succ) of None
 //│     = None { class: [class None extends Option] }
 
 
-:e // TODO support
+
 fun map(f) = case
   Some(x)   then Some(f(x))
   None as n then n
-//│ ╔══[ERROR] type identifier `as` not found
-//│ ║  l.65: 	  None as n then n
-//│ ╙──      	       ^^
-//│ ╔══[ERROR] type identifier not found: as
-//│ ║  l.65: 	  None as n then n
-//│ ╙──      	       ^^
-//│ fun map: forall 'a 'A. ('a -> 'A) -> Some['a] -> (Some['A] | error)
-//│ Code generation encountered an error:
-//│   unresolved symbol as
+//│ fun map: forall 'a 'A. ('a -> 'A) -> (None | Some['a]) -> (None | Some['A])
 
 
 :pe
 case 1
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'case'; found integer literal instead
-//│ ║  l.78: 	case 1
+//│ ║  l.70: 	case 1
 //│ ║        	     ^
 //│ ╟── Note: 'case' expression starts here:
-//│ ║  l.78: 	case 1
+//│ ║  l.70: 	case 1
 //│ ╙──      	^^^^
 //│ anything -> 1
 //│ res
@@ -89,13 +81,13 @@ case 1
 :pe
 case (1 then true)
 //│ ╔══[PARSE ERROR] Unexpected 'then' keyword here
-//│ ║  l.90: 	case (1 then true)
+//│ ║  l.82: 	case (1 then true)
 //│ ╙──      	        ^^^^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'case'; found integer literal instead
-//│ ║  l.90: 	case (1 then true)
+//│ ║  l.82: 	case (1 then true)
 //│ ║        	     ^^^^^^^^^^^^^
 //│ ╟── Note: 'case' expression starts here:
-//│ ║  l.90: 	case (1 then true)
+//│ ║  l.82: 	case (1 then true)
 //│ ╙──      	^^^^
 //│ anything -> 1
 //│ res
@@ -109,16 +101,16 @@ case else 0
 :pe
 case then 1 else 0
 //│ ╔══[PARSE ERROR] Unexpected 'then' keyword in expression position
-//│ ║  l.110: 	case then 1 else 0
+//│ ║  l.102: 	case then 1 else 0
 //│ ╙──       	     ^^^^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'case'; found integer literal instead
-//│ ║  l.110: 	case then 1 else 0
+//│ ║  l.102: 	case then 1 else 0
 //│ ║         	          ^
 //│ ╟── Note: 'case' expression starts here:
-//│ ║  l.110: 	case then 1 else 0
+//│ ║  l.102: 	case then 1 else 0
 //│ ╙──       	^^^^
 //│ ╔══[PARSE ERROR] Expected end of input; found 'else' keyword instead
-//│ ║  l.110: 	case then 1 else 0
+//│ ║  l.102: 	case then 1 else 0
 //│ ╙──       	            ^^^^
 //│ anything -> 1
 //│ res
@@ -132,16 +124,16 @@ case then 1 else 0
 :e
 case x, y then x + y
 //│ ╔══[PARSE ERROR] Expected an expression; found a 'then'/'else' clause instead
-//│ ║  l.133: 	case x, y then x + y
+//│ ║  l.125: 	case x, y then x + y
 //│ ╙──       	        ^^^^^^^^^^^^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'case'; found operator application instead
-//│ ║  l.133: 	case x, y then x + y
+//│ ║  l.125: 	case x, y then x + y
 //│ ║         	     ^^^^^^^^^^^^^^^
 //│ ╟── Note: 'case' expression starts here:
-//│ ║  l.133: 	case x, y then x + y
+//│ ║  l.125: 	case x, y then x + y
 //│ ╙──       	^^^^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.133: 	case x, y then x + y
+//│ ║  l.125: 	case x, y then x + y
 //│ ╙──       	     ^
 //│ anything -> ()
 //│ Code generation encountered an error:
@@ -150,10 +142,10 @@ case x, y then x + y
 :e
 case (x, y) then x + y
 //│ ╔══[ERROR] type identifier `,` not found
-//│ ║  l.151: 	case (x, y) then x + y
+//│ ║  l.143: 	case (x, y) then x + y
 //│ ╙──       	      ^^^^
 //│ ╔══[ERROR] type identifier not found: ,
-//│ ║  l.151: 	case (x, y) then x + y
+//│ ║  l.143: 	case (x, y) then x + y
 //│ ╙──       	      ^^^^
 //│ nothing -> error
 //│ Code generation encountered an error:
diff --git a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
index 9ac35c305b..9d965bfd5d 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
@@ -459,8 +459,8 @@ fun asList(x: Data): List[Data] = if x is DataList(ys) then ys else error
 //│ fun asList: (x: Data) -> List[Data]
 
 fun eval(x: Data, env: Str -> Data): Data = if x is
-  Literal(StrLit(x)) then Literal(StrLit(x))
-  Literal(IntLit(x)) then Literal(IntLit(x))
+  Literal(StrLit(_)) as lit then lit
+  Literal(IntLit(_)) as lit then lit
   Symbol(name) then env(name)
   DataList(Cons(Symbol("val"), tail)) and tail is
     Cons(param, Cons(expr, Cons(rest, Nil))) then
@@ -477,8 +477,7 @@ fun eval(x: Data, env: Str -> Data): Data = if x is
     let ps = map(toName, asList(params))
     Literal(Lambda(args => eval(body, extendParameters(env, ps, args))))
   DataList(Cons(operator, operands)) and eval(operator, env) is
-    Literal(Lambda(f)) then
-      f of map((x) => eval(x, env), operands)
+    Literal(Lambda(f)) then f of map((x) => eval(x, env), operands)
     else error // application of a non-function
   else error // unrecognized program
 //│ fun eval: (x: Data, env: Str -> Data) -> Data

From 5a9eb6d28ab28e104b2b69afed544ee82c0fad08 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <luyu.cheng@connect.ust.hk>
Date: Thu, 18 Jan 2024 22:38:33 +0800
Subject: [PATCH 085/147] Update
 shared/src/test/diff/pretyper/ucs/DualOption.mls

Co-authored-by: Fa1sePRoMiSe <neilkleist@gmail.com>
---
 shared/src/test/diff/pretyper/ucs/DualOption.mls | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shared/src/test/diff/pretyper/ucs/DualOption.mls b/shared/src/test/diff/pretyper/ucs/DualOption.mls
index ab4d61d97e..52a9ffa36d 100644
--- a/shared/src/test/diff/pretyper/ucs/DualOption.mls
+++ b/shared/src/test/diff/pretyper/ucs/DualOption.mls
@@ -1,5 +1,5 @@
 :NewDefs
-:NewDefs
+
 
 abstract class Option[T]
 class Some[T](value: T) extends Option[T]

From a6625feb367a12ca6bee8335d504b215517642ee Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Fri, 19 Jan 2024 22:32:01 +0800
Subject: [PATCH 086/147] Improve coverage checking and rename `PatternInfo` as
 `Pattern`

---
 .../main/scala/mlscript/pretyper/Symbol.scala |   3 +-
 .../scala/mlscript/ucs/context/CaseSet.scala  |  96 +++++++-------
 .../{PatternInfo.scala => Pattern.scala}      |  38 ++++--
 .../mlscript/ucs/context/Scrutinee.scala      |  58 ++++-----
 .../scala/mlscript/ucs/context/package.scala  |  11 +-
 .../ucs/stages/CoverageChecking.scala         |  65 ++++++----
 .../mlscript/ucs/stages/Normalization.scala   |   4 +-
 .../mlscript/ucs/stages/PostProcessing.scala  |  16 +--
 shared/src/test/diff/nu/LitMatch.mls          |   9 +-
 .../pretyper/ucs/SpecilizationCollision.mls   |  49 +++++++
 .../pretyper/ucs/coverage/SealedClasses.mls   |  10 --
 .../diff/pretyper/ucs/patterns/Literals.mls   |  11 +-
 .../pretyper/ucs/stages/PostProcessing.mls    |   4 -
 shared/src/test/diff/ucs/ElseIf.mls           |  47 ++++---
 shared/src/test/diff/ucs/Exhaustiveness.mls   |   3 +
 shared/src/test/diff/ucs/SimpleUCS.mls        |  29 +++--
 shared/src/test/diff/ucs/SplitAfterOp.mls     | 120 ++++++++++--------
 shared/src/test/diff/ucs/WeirdIf.mls          |   2 -
 .../src/test/scala/mlscript/DiffTests.scala   |  13 +-
 19 files changed, 337 insertions(+), 251 deletions(-)
 rename shared/src/main/scala/mlscript/ucs/context/{PatternInfo.scala => Pattern.scala} (76%)

diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index 5a774d0a3f..9ef593ee18 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -28,7 +28,8 @@ package object symbol {
     var baseTypes: Ls[TypeSymbol] = Nil
     var sealedDerivedTypes: Ls[TypeSymbol] = Nil
 
-    @inline def hasSuperType(superType: TypeSymbol): Bool = baseTypes.exists(_ === superType)
+    @inline def hasBaseClass(baseClassLikeSymbol: TypeSymbol): Bool =
+      baseTypes.exists(_ === baseClassLikeSymbol)
 
     def showDbg: Str = s"${defn.kind.str} $name"
   }
diff --git a/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala b/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
index b31f0928d4..aff9d24e5e 100644
--- a/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
@@ -1,40 +1,37 @@
 package mlscript.ucs.context
 
-import mlscript.{Lit, Loc}
+import mlscript.{Lit, Loc, Var}
 import mlscript.pretyper.symbol.TypeSymbol
 import mlscript.utils._, shorthands._
 import mlscript.pretyper.symbol.DummyClassSymbol
 
-sealed abstract class Pattern {
-  override def toString(): String = this match {
-    case Pattern.ClassLike(symbol) =>
-      val kind = symbol match {
-        case _: DummyClassSymbol => "dummy class"
-        case _ => symbol.defn.kind.str
-      }
-      s"$kind `${symbol.name}`"
-    case Pattern.Tuple() => "tuple"
-    case Pattern.Literal(literal) => s"literal $literal"
-  }
-}
-
-object Pattern {
-  final case class ClassLike(symbol: TypeSymbol) extends Pattern
-  // Currently, there is only simple tuple pattern, so we cannot differentiate
-  // between tuple patterns of different arity. That's why the parameter list
-  // is empty for now.
-  final case class Tuple() extends Pattern
-  final case class Literal(literal: Lit) extends Pattern
-}
-
 /**
   * A `CaseSet` represents all patterns that a particular scrutinee is
-  * being matched with within a UCS expression. Each Pattern is associated
-  * with the locations where these patterns appear.
+  * being matched with within a UCS expression.
   *
-  * @param patterns a set of patterns that the scrutinee is matched with.
+  * @param patterns a list of patterns.
   */
-final case class CaseSet(val cases: Map[Pattern, Ls[Loc]]) {
+final case class CaseSet(val patterns: List[Pattern]) {
+  def showInDiagnostics: Str =
+    patterns.iterator.map(_.showInDiagnostics).mkString("[", ", ", "]")
+
+  /** Get a iterator of all class-like patterns. */
+  def classLikePatterns: Iterator[Pattern.ClassLike] = patterns.iterator.flatMap {
+    case pattern: Pattern.ClassLike => S(pattern)
+    case _: Pattern.Boolean | _: Pattern.Literal | _: Pattern.Tuple => N
+  }
+
+  /** Separate a class-like pattern if it appears in `patterns`. */
+  def separate(classLikeSymbol: TypeSymbol): Opt[(Pattern.ClassLike, Ls[Pattern.ClassLike])] = {
+    classLikePatterns.foldRight[(Opt[Pattern.ClassLike], Ls[Pattern.ClassLike])]((N, Nil)) {
+      case (pattern, (S(separated), rest)) => (S(separated), pattern :: rest)
+      case (pattern, (N, rest)) if pattern.classLikeSymbol === classLikeSymbol => (S(pattern), rest)
+      case (pattern, (N, rest)) => (N, pattern :: rest)
+    } match {
+      case (N, _) => N
+      case (S(separated), rest) => S((separated, rest))
+    }
+  }
   /**
     * Split the pattern set into two pattern sets.
     * 
@@ -59,37 +56,30 @@ final case class CaseSet(val cases: Map[Pattern, Ls[Loc]]) {
     *         locations where the pattern appears, the related patterns, and
     *         unrelated patterns.
     */
-  def split(classLikeSymbol: TypeSymbol): Opt[(Ls[Loc], CaseSet, CaseSet)] = {
-    val classLikePattern = Pattern.ClassLike(classLikeSymbol)
-    cases.get(classLikePattern).map { locations =>
-      val withoutSymbol = cases - classLikePattern
-      val relatedPatterns = withoutSymbol.filter {
-        case (Pattern.ClassLike(otherSymbol), _) => otherSymbol.baseTypes.contains(classLikeSymbol)
-        case ((_: Pattern.Tuple | _: Pattern.Literal), _) => false
-      } ++ classLikeSymbol.sealedDerivedTypes.iterator.map { symbol =>
-        Pattern.ClassLike(symbol) -> symbol.defn.nme.toLoc.toList
-      }
-      val unrelatedPatterns = withoutSymbol.filter {
-        case (Pattern.ClassLike(otherSymbol), _) => !otherSymbol.baseTypes.contains(classLikeSymbol)
-        case ((_: Pattern.Tuple | _: Pattern.Literal), _) => true
-      }
-      (locations, copy(relatedPatterns), copy(unrelatedPatterns))
+  def split(classLikeSymbol: TypeSymbol): Opt[(Pattern.ClassLike, CaseSet, CaseSet)] = {
+    separate(classLikeSymbol) match {
+      case N => N
+      case S((pattern, patterns)) =>
+        val (unrelated, related) = patterns.partitionMap { pattern =>
+          if (pattern.classLikeSymbol hasBaseClass classLikeSymbol) {
+            R(pattern)
+          } else {
+            L(pattern)
+          }
+        }
+        S((pattern, CaseSet(related), CaseSet(unrelated)))
     }
   }
 
-  def remove(literal: Lit): CaseSet = {
-    val literalPattern = Pattern.Literal(literal)
-    copy(cases - literalPattern)
+  @inline def remove(boolLit: Var): CaseSet = {
+    require(boolLit.name === "true" || boolLit.name === "false")
+    CaseSet(patterns.filter(!_.matches(boolLit)))
   }
 
-  /** Get an iterator of only patterns. */
-  @inline def patterns: Iterator[Pattern] = cases.iterator.map(_._1)
-
-  @inline def isEmpty: Bool = cases.isEmpty
+  @inline def remove(literal: Lit): CaseSet =
+    CaseSet(patterns.filter(!_.matches(literal)))
 
-  @inline def size: Int = cases.size
-}
+  @inline def isEmpty: Bool = patterns.isEmpty
 
-object CaseSet {
-  def empty: CaseSet = CaseSet(Map.empty)
+  @inline def size: Int = patterns.size
 }
diff --git a/shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala b/shared/src/main/scala/mlscript/ucs/context/Pattern.scala
similarity index 76%
rename from shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala
rename to shared/src/main/scala/mlscript/ucs/context/Pattern.scala
index 5d232e5595..5e209e0bd2 100644
--- a/shared/src/main/scala/mlscript/ucs/context/PatternInfo.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Pattern.scala
@@ -4,8 +4,9 @@ import collection.mutable.{Buffer, SortedMap => MutSortedMap}
 import mlscript.{Lit, Loc, Located, SimpleTerm, TypeName, Var}
 import mlscript.pretyper.symbol.TypeSymbol
 import mlscript.utils._, shorthands._
+import mlscript.pretyper.symbol.DummyClassSymbol
 
-abstract class PatternInfo {
+sealed abstract class Pattern {
   private val locationsBuffer: Buffer[Loc] = Buffer.empty
 
   def addLocation(located: Located): Unit = located.getLoc.foreach(locationsBuffer += _)
@@ -21,6 +22,9 @@ abstract class PatternInfo {
 
   def showDbg: Str
 
+  /** Get a string suitable for diagnostics. */
+  def showInDiagnostics: Str
+
   /**
     * Checks if the pattern is same as expressed by the given `SimpleTerm`. Note
     * that we should pass `pat` of `Case` to this function.
@@ -31,8 +35,8 @@ abstract class PatternInfo {
   def toCasePattern: SimpleTerm
 }
 
-object PatternInfo {
-  class ClassLike(val classLikeSymbol: TypeSymbol, scrutinee: Scrutinee) extends PatternInfo {
+object Pattern {
+  final case class ClassLike(val classLikeSymbol: TypeSymbol, scrutinee: Scrutinee) extends Pattern {
     private var unappliedVarOpt: Opt[Var] = N
     private val parameters: MutSortedMap[Int, Scrutinee] = MutSortedMap.empty
 
@@ -62,11 +66,16 @@ object PatternInfo {
 
     override def showDbg: Str = s"${classLikeSymbol.name}"
 
+    override def showInDiagnostics: Str = s"${(classLikeSymbol match {
+      case dummySymbol: DummyClassSymbol => "class"
+      case otherSymbol: TypeSymbol => otherSymbol.defn.kind.str
+    })} `${classLikeSymbol.name}`"
+
     override def matches(pat: SimpleTerm): Bool =
       pat match {
         case pat: Var => pat.symbolOption match {
           case S(patternSymbol: TypeSymbol) =>
-            patternSymbol === classLikeSymbol || patternSymbol.hasSuperType(classLikeSymbol)
+            patternSymbol === classLikeSymbol || patternSymbol.hasBaseClass(classLikeSymbol)
           case S(_) | N => false
         }
         case _: Lit => false
@@ -76,7 +85,7 @@ object PatternInfo {
       Var(classLikeSymbol.name).withLoc(firstOccurrence).withSymbol(classLikeSymbol)
   }
 
-  class Tuple(scrutinee: Scrutinee) extends PatternInfo {
+  final case class Tuple(scrutinee: Scrutinee) extends Pattern {
     private val fields: MutSortedMap[Int, Scrutinee] = MutSortedMap.empty
 
     def getField(index: Int): Scrutinee =
@@ -86,6 +95,13 @@ object PatternInfo {
 
     override def showDbg: Str = s"tuple#${arity.getOrElse("?")}"
 
+    override def showInDiagnostics: Str =
+      "tuple of " + (arity match {
+        case N => "certain number of elements"
+        case S(1) => "1 element"
+        case S(n) => s"${n} elements"
+      })
+
     override def matches(pat: SimpleTerm): Bool = false
 
     /**
@@ -96,11 +112,13 @@ object PatternInfo {
     override def toCasePattern: SimpleTerm = ???
   }
 
-  class Literal(val literal: Lit) extends PatternInfo {
+  final case class Literal(val literal: Lit) extends Pattern {
     override def arity: Opt[Int] = N
 
     override def showDbg: Str = literal.idStr
 
+    override def showInDiagnostics: Str = s"literal ${literal.idStr}"
+
     override def matches(pat: SimpleTerm): Bool =
       pat match {
         case _: Var => false
@@ -111,17 +129,19 @@ object PatternInfo {
   }
 
   /**
-    * This can be actually merged with `LiteralPatternInfo`. However, there's no
+    * This can be actually merged with `Pattern.Literal`. However, there's no
     * `Lit` sub-classes for Boolean types, so the representation is a little bit
     * awkward, also, it makes sense to consider Boolean patterns separately
     * because we can check the Boolean exhaustiveness with them.
     */
-  class Boolean(val value: Var) extends PatternInfo {
+  final case class Boolean(val value: Var) extends Pattern {
     require(value.name === "true" || value.name === "false")
 
     override def arity: Opt[Int] = N
 
-    override def showDbg: Str = value.toString
+    override def showDbg: Str = value.name
+
+    override def showInDiagnostics: Str = s"Boolean value ${value.name}"
 
     override def matches(pat: SimpleTerm): Bool =
       pat match {
diff --git a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
index e45dec1938..05422bf219 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
@@ -15,22 +15,22 @@ class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
 
   private val locations: Buffer[Loc] = Buffer.empty
   private var generatedVarOpt: Opt[Var] = N
-  private val classLikePatterns: MutSortedMap[TypeSymbol, PatternInfo.ClassLike] = MutSortedMap.empty(classLikeSymbolOrdering)
+  private val classLikePatterns: MutSortedMap[TypeSymbol, Pattern.ClassLike] = MutSortedMap.empty(classLikeSymbolOrdering)
   // Currently we only support simple tuple patterns, so there is only _one_
   // slot for tuple patterns. After we support complex tuple patterns, we need
-  // to extend this fields to a map from tuple arity to `PatternInfo.Tuple`.
-  //    private val tuplePatterns: MutMap[Int, PatternInfo.Tuple] = MutMap.empty
+  // to extend this fields to a map from tuple arity to `Pattern.Tuple`.
+  //    private val tuplePatterns: MutMap[Int, Pattern.Tuple] = MutMap.empty
   // If we support tuple pattern splice, we need a more expressive key in the
   // map's type.
-  private var tuplePatternOpt: Opt[PatternInfo.Tuple] = N
+  private var tuplePatternOpt: Opt[Pattern.Tuple] = N
   private var aliasVarSet: MutSortedSet[Var] = MutSortedSet.empty
 
-  private val literalPatterns: MutSortedMap[Lit, PatternInfo.Literal] = MutSortedMap.empty(literalOrdering)
+  private val literalPatterns: MutSortedMap[Lit, Pattern.Literal] = MutSortedMap.empty(literalOrdering)
   /**
     * The key should be either `Var("true")` or `Var("false")`. We want to keep
     * the type symbol of the variable so that it still work in following stages.
     */
-  private val booleanPatterns: MutSortedMap[Var, PatternInfo.Boolean] = MutSortedMap.empty(varNameOrdering)
+  private val booleanPatterns: MutSortedMap[Var, Pattern.Boolean] = MutSortedMap.empty(varNameOrdering)
 
   def addAliasVar(alias: Var): Unit = aliasVarSet += alias
 
@@ -39,23 +39,23 @@ class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
   def aliasesIterator: Iterator[Var] = aliasVarSet.iterator
 
   /**
-    * If there is already a `PatternInfo.ClassLike` for the given symbol, return it.
-    * Otherwise, create a new `PatternInfo.ClassLike` and return it.
+    * If there is already a `Pattern.ClassLike` for the given symbol, return it.
+    * Otherwise, create a new `Pattern.ClassLike` and return it.
     */
-  def getOrCreateClassPattern(classLikeSymbol: TypeSymbol): PatternInfo.ClassLike =
-    classLikePatterns.getOrElseUpdate(classLikeSymbol, new PatternInfo.ClassLike(classLikeSymbol, this))
+  def getOrCreateClassPattern(classLikeSymbol: TypeSymbol): Pattern.ClassLike =
+    classLikePatterns.getOrElseUpdate(classLikeSymbol, Pattern.ClassLike(classLikeSymbol, this))
 
   /**
     * Get the class pattern but DO NOT create a new one if there isn't. This
     * function is mainly used in post-processing because we don't want to
     * accidentally create new patterns.
     */
-  def getClassPattern(classLikeSymbol: TypeSymbol): Opt[PatternInfo.ClassLike] =
+  def getClassPattern(classLikeSymbol: TypeSymbol): Opt[Pattern.ClassLike] =
     classLikePatterns.get(classLikeSymbol)
 
   /**
-   * If there is already a `PatternInfo.Tuple`, return it. Otherwise, create a
-   * new `PatternInfo.Tuple` and return it.
+   * If there is already a `Pattern.Tuple`, return it. Otherwise, create a
+   * new `Pattern.Tuple` and return it.
    * 
    * **NOTE**: There's only one slot for tuple patterns because we cannot
    * differentiate tuple types in underlying MLscript case terms. In the future,
@@ -63,31 +63,31 @@ class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
    * a signature like this.
    * 
    * ```scala
-   * def getOrCreateTuplePattern(dimension: TupleDimension): PatternInfo.Tuple
+   * def getOrCreateTuplePattern(dimension: TupleDimension): Pattern.Tuple
    * case class TupleDimension(knownArity: Int, hasSplice: Bool)
    * ```
    */
-  def getOrCreateTuplePattern: PatternInfo.Tuple =
+  def getOrCreateTuplePattern: Pattern.Tuple =
     tuplePatternOpt.getOrElse {
-      val tuplePattern = new PatternInfo.Tuple(this)
+      val tuplePattern = Pattern.Tuple(this)
       tuplePatternOpt = S(tuplePattern)
       tuplePattern
     }
 
   /** Get the tuple pattern and create a new one if there isn't. */
-  def getOrCreateLiteralPattern(literal: Lit): PatternInfo.Literal =
-    literalPatterns.getOrElseUpdate(literal, new PatternInfo.Literal(literal))
+  def getOrCreateLiteralPattern(literal: Lit): Pattern.Literal =
+    literalPatterns.getOrElseUpdate(literal, Pattern.Literal(literal))
 
   /**
     * The key should be either `Var("true")` or `Var("false")`. We want to keep
     * the type symbol of the variable so that it still work in following stages.
     */
-  def getOrCreateBooleanPattern(value: Var): PatternInfo.Boolean =
-    booleanPatterns.getOrElseUpdate(value, new PatternInfo.Boolean(value))
+  def getOrCreateBooleanPattern(value: Var): Pattern.Boolean =
+    booleanPatterns.getOrElseUpdate(value, Pattern.Boolean(value))
 
-  def classLikePatternsIterator: Iterator[PatternInfo.ClassLike] = classLikePatterns.valuesIterator
+  def classLikePatternsIterator: Iterator[Pattern.ClassLike] = classLikePatterns.valuesIterator
 
-  def patternsIterator: Iterator[PatternInfo] =
+  def patternsIterator: Iterator[Pattern] =
     classLikePatterns.valuesIterator ++ literalPatterns.valuesIterator ++ booleanPatterns.valuesIterator
 
   /** Get a list of string representation of patterns. Only for debugging. */
@@ -103,19 +103,7 @@ class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
 
   def freshSubScrutinee: Scrutinee = context.freshScrutinee(this)
 
-  def toCaseSet: CaseSet = {
-    import mlscript.ucs.context.Pattern
-    val cases = classLikePatterns.iterator.map { case (symbol, pattern) =>
-      Pattern.ClassLike(symbol) -> pattern.locations
-    }.toMap[Pattern, Ls[Loc]]
-    val tuplePattern = tuplePatternOpt.map { tuplePattern =>
-      Pattern.Tuple() -> tuplePattern.locations
-    }.toMap[Pattern, Ls[Loc]]
-    val literalPatterns = this.literalPatterns.iterator.map { case (literal, pattern) =>
-      Pattern.Literal(literal) -> pattern.locations
-    }.toMap[Pattern, Ls[Loc]]
-    CaseSet(cases ++ tuplePattern)
-  }
+  def toCaseSet: CaseSet = CaseSet(patternsIterator.toList)
 
   def getReadableName(scrutineeVar: Var): Str = {
     parent match {
diff --git a/shared/src/main/scala/mlscript/ucs/context/package.scala b/shared/src/main/scala/mlscript/ucs/context/package.scala
index bc61762f65..6b5d31d9a8 100644
--- a/shared/src/main/scala/mlscript/ucs/context/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/package.scala
@@ -9,5 +9,14 @@ package object context {
 
   type MatchRegistry = Map[NamedScrutinee, CaseSet]
 
-  type SeenRegistry = Map[NamedScrutinee, (TypeSymbol, Ls[Loc], CaseSet)]  
+  // implicit class MatchRegistryOps(val self: MatchRegistry) extends AnyVal {
+  //   def showDbg: Str = 
+  // }
+
+  type SeenRegistry = Map[NamedScrutinee, (TypeSymbol, Ls[Loc], CaseSet)]
+
+  implicit class SeenRegistryOps(val self: SeenRegistry) extends AnyVal {
+    def showDbg: Str = if (self.isEmpty) "empty" else
+      self.iterator.map { case ((k, _), (s, _, _)) => s"${k.name} is ${s.name}" }.mkString(", ")
+  }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index 2ef80662d3..82f2e23109 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -23,18 +23,22 @@ trait CoverageChecking { self: Desugarer with Traceable =>
       pending: MatchRegistry,
       working: MatchRegistry,
       seen: SeenRegistry
-  )(implicit context: Context): Ls[Diagnostic] =
-    trace(s"checkCoverage <== ${term.showDbg}, ${pending.size} pending, ${working.size} working, ${seen.size} seen") {
-      println(s"seen: " + (if (seen.isEmpty) "empty" else
-        seen.iterator.map { case ((k, _), (s, _, _)) => s"${k.name} is ${s.name}" }.mkString(", ")
-      ))
-      term match {
-        case Let(_, _, _, body) => checkCoverage(body, pending, working, seen)
-        case CaseOf(scrutineeVar: Var, Case(Var("true"), body, NoCases)) if context.isTestVar(scrutineeVar) =>
-          raiseDesugaringError(msg"missing else branch" -> body.toLoc)
-          Nil
-        case CaseOf(Scrutinee.WithVar(scrutinee, scrutineeVar), cases) =>
-          println(s"scrutinee: ${scrutineeVar.name}")
+  )(implicit context: Context): Ls[Diagnostic] = {
+    term match {
+      case Let(_, nme, _, body) =>
+        println(s"checkCoverage <== LET `${nme.name}`")
+        checkCoverage(body, pending, working, seen)
+      case CaseOf(scrutineeVar: Var, Case(Var("true"), body, NoCases)) if context.isTestVar(scrutineeVar) =>
+        raiseDesugaringError(msg"missing else branch" -> body.toLoc)
+        Nil
+      case CaseOf(scrutineeVar: Var, Case(Var("true"), whenTrue, Wildcard(whenFalse))) if context.isTestVar(scrutineeVar) =>
+        println(s"checkCoverage <== TEST `${scrutineeVar.name}`")
+        checkCoverage(whenTrue, pending, working, seen) ++
+          checkCoverage(whenFalse, pending, working, seen)
+      case CaseOf(Scrutinee.WithVar(scrutinee, scrutineeVar), cases) =>
+        trace(s"checkCoverage <== ${pending.size} pending, ${working.size} working, ${seen.size} seen") {
+          println(s"CASE ${scrutineeVar.name}")
+          println(s"SEEN: ${seen.showDbg}")
           // If the scrutinee is still pending (i.e., not matched yet), then we
           // remove it from the pending list. If the scrutinee is matched, and
           // there are still classes to be matched, then we find the remaining
@@ -64,28 +68,35 @@ trait CoverageChecking { self: Desugarer with Traceable =>
           // unseen pattern set.
           // Meanwhile, we keep adding diagnostics if we meet warnings and errors.
           cases.foldLeft((unseenPatterns, Nil: Ls[Diagnostic]))({
+            case ((unseenPatterns, diagnostics), (boolLit: Var) -> body)
+                if boolLit.name === "true" || boolLit.name === "false" =>
+              (
+                unseenPatterns.remove(boolLit),
+                diagnostics ++ checkCoverage(body, newPending, working - namedScrutinee, seen)
+              )
             case ((unseenPatterns, diagnostics), (className: Var) -> body) =>
               val classSymbol = className.symbolOption.flatMap(_.typeSymbolOption).getOrElse {
                 throw new Exception(s"$className is not associated with a type symbol")
               }
-              println(s"class symbol: ${classSymbol.name}")
+              println(s"class symbol: `${classSymbol.name}`")
               unseenPatterns.split(classSymbol) match {
-                case S((locations, refiningPatterns, remainingPatterns)) =>
-                  println(s"remove ${className} and it's unrelated patterns from working")
-                  println("unseen patterns: " + unseenPatterns.patterns.mkString("[", ", ", "]"))
-                  println("remaining patterns: " + remainingPatterns.patterns.mkString("[", ", ", "]"))
+                case S((pattern, refiningPatterns, remainingPatterns)) =>
+                  println(s"REMOVE `${className.name}` from working")
+                  println(s"unseen: ${unseenPatterns.showInDiagnostics}")
+                  println(s"remaining: ${remainingPatterns.showInDiagnostics}")
                   // Remove the scrutinee from the working list.
                   val newWorking = if (remainingPatterns.isEmpty)
                     working - namedScrutinee
                   else
                     working.updated(namedScrutinee, remainingPatterns)
                   // Add "`scrutinee` is `className`" to the seen registry.
-                  val newSeen = seen + (namedScrutinee -> (classSymbol, locations, refiningPatterns))
+                  val newSeen = seen + (namedScrutinee -> (classSymbol, pattern.locations, refiningPatterns))
                   (
                     remainingPatterns,
                     diagnostics ++ checkCoverage(body, newPending, newWorking, newSeen)
                   )
                 case N =>
+                  println(s"cannot split the set by ${classSymbol.name}")
                   unseenPatterns -> (diagnostics :+ (seen.get(namedScrutinee) match {
                     case S((`classSymbol`, _, _)) => WarningReport("tautology", Nil, Diagnostic.Desugaring)
                     case S(_) => ErrorReport("contradiction", Nil, Diagnostic.Desugaring)
@@ -99,16 +110,18 @@ trait CoverageChecking { self: Desugarer with Traceable =>
               )
           }) {
             case ((missingCases, diagnostics), N) =>
-              println("remaining cases should are not covered")
-              println("MISSING cases: " + missingCases.patterns.mkString("[", ", ", "]"))
+              println(s"remaining cases are not covered: ${missingCases.showInDiagnostics}")
               diagnostics ++ explainMissingCases(namedScrutinee, seen, missingCases)
             case ((remainingCases, diagnostics), S(default)) =>
               println("remaining cases should be covered by the wildcard")
               checkCoverage(default, newPending, working.updated(namedScrutinee, remainingCases), seen)
           }
-        case other => println("STOP"); Nil
-      }
-    }(ls => s"checkCoverage ==> ${ls.length} diagnostics")
+        }(ls => s"checkCoverage ==> ${ls.length} diagnostics")
+      case other =>
+        println(s"checkCoverage <== TERM ${other.showDbg}")
+        Nil
+    }
+  }
 }
 
 object CoverageChecking {
@@ -124,8 +137,8 @@ object CoverageChecking {
       S(ErrorReport({
         val readableName = scrutinee._2.getReadableName(scrutinee._1)
         val lines = (msg"$readableName has ${"missing case".pluralize(missingCases.size, true)}" -> scrutinee._1.toLoc) ::
-          (missingCases.cases.iterator.flatMap { case (pattern, locations) =>
-            (msg"it can be ${pattern.toString}" -> locations.headOption) :: Nil
+          (missingCases.patterns.iterator.flatMap { pattern =>
+            (msg"it can be ${pattern.showInDiagnostics}" -> pattern.firstOccurrence) :: Nil
           }.toList)
         if (seen.isEmpty) {
           lines
@@ -144,6 +157,6 @@ object CoverageChecking {
   private def showRegistry(registry: MatchRegistry): Str =
     if (registry.isEmpty) "empty" else
       registry.iterator.map { case (scrutineeVar -> scrutinee, matchedClasses) =>
-        matchedClasses.patterns.mkString(s">>> ${scrutineeVar.name} => [", ", ", "]")
+        matchedClasses.patterns.iterator.map(_.showInDiagnostics).mkString(s">>> ${scrutineeVar.name} => [", ", ", "]")
       }.mkString("\n", "\n", "")
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 87af99b3ef..bbcee15887 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -115,7 +115,7 @@ trait Normalization { self: Desugarer with Traceable =>
         val (wrap, realTail) = preventShadowing(nme, tail)
         wrap(Let(false, nme, scrutinee, normalizeToTerm(continuation.fill(realTail, false, true))))
       // Skip Boolean conditions as scrutinees, because they only appear once.
-      case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true"), _), continuation), tail) =>
+      case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true"), _), continuation), tail) if context.isTestVar(test) =>
         println(s"TRUE: ${test.name} is true")
         val trueBranch = normalizeToTerm(continuation.fill(tail, false, false))
         val falseBranch = normalizeToCaseBranches(tail)
@@ -217,7 +217,7 @@ trait Normalization { self: Desugarer with Traceable =>
                   )
                 }
                 specialize(continuation, true) :++ specialize(tail, true)
-              } else if (otherClassSymbol hasSuperType classSymbol) {
+              } else if (otherClassSymbol hasBaseClass classSymbol) {
                 println(s"Case 2: ${otherClassName.name} <: ${className.name}")
                 println(s"${otherClassSymbol.name} is refining ${className.name}")
                 // We should mark `pattern` as refined.
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index 9e26575ce5..dfb3485cbb 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -2,7 +2,7 @@ package mlscript.ucs.stages
 
 import mlscript.{Case, CaseBranches, CaseOf, Let, Lit, Loc, NoCases, Term, Var, Wildcard}
 import mlscript.ucs.Desugarer
-import mlscript.ucs.context.{Context, PatternInfo, Scrutinee}
+import mlscript.ucs.context.{Context, Pattern, Scrutinee}
 import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
 import mlscript.Message, Message.MessageContext
@@ -27,11 +27,11 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
         // Post-process the false branch.
         println("FALSE")
         // Get all patterns, except the current one `pat`.
-        val patternInfoList = scrutinee.patternsIterator.filter(!_.matches(pat)).toList
-        println(s"found ${patternInfoList.length} patterns to distentangle: ${patternInfoList.iterator.map(_.showDbg).mkString(", ")}")
-        val (default, cases) = patternInfoList
+        val patternList = scrutinee.patternsIterator.filter(!_.matches(pat)).toList
+        println(s"found ${patternList.length} patterns to distentangle: ${patternList.iterator.map(_.showDbg).mkString(", ")}")
+        val (default, cases) = patternList
           // For each case class name, distangle case branch body terms from the false branch.
-          .foldLeft[Opt[Term] -> Ls[(PatternInfo, Opt[Loc], Term)]](S(falseBranch) -> Nil) {
+          .foldLeft[Opt[Term] -> Ls[(Pattern, Opt[Loc], Term)]](S(falseBranch) -> Nil) {
             case ((S(remainingTerm), cases), pattern) =>
               println(s"searching for case: ${pattern.showDbg}")
               val (leftoverTerm, extracted) = disentangleTerm(remainingTerm)(
@@ -126,7 +126,7 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
       context: Context,
       scrutineeVar: Var,
       scrutinee: Scrutinee,
-      pattern: PatternInfo
+      pattern: Pattern
   ): (Term, Opt[Term]) = {
     def rec(term: Term): (Term, Opt[Term]) =
       term match {
@@ -159,7 +159,7 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
       context: Context,
       scrutineeVar: Var,
       scrutinee: Scrutinee,
-      pattern: PatternInfo
+      pattern: Pattern
   ): (CaseBranches, Opt[Term]) =
     cases match {
       case NoCases => NoCases -> N
@@ -184,7 +184,7 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
       context: Context,
       scrutineeVar: Var,
       scrutinee: Scrutinee,
-      pattern: PatternInfo
+      pattern: Pattern
   ): (CaseBranches, CaseBranches) =
     cases match {
       case NoCases => NoCases -> NoCases
diff --git a/shared/src/test/diff/nu/LitMatch.mls b/shared/src/test/diff/nu/LitMatch.mls
index 45581782e6..24a76a66e2 100644
--- a/shared/src/test/diff/nu/LitMatch.mls
+++ b/shared/src/test/diff/nu/LitMatch.mls
@@ -22,21 +22,20 @@ b : true | false
 //│     = false
 
 if false is false then 0
-//│ ╙──
 //│ 0
 //│ res
 //│     = 0
 
 fun foo(x) = if x is
   false then 0
-//│ ╙──
 //│ fun foo: false -> 0
 
 fun foo(x) = if x is
   false then 0
   true  then 1
-//│ ╙──
-//│ ╙──
 //│ fun foo: Bool -> (0 | 1)
 
-
+fun foo(x) = if x is
+  0 then "zero"
+  true then "true"
+//│ fun foo: (0 | true) -> ("true" | "zero")
diff --git a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
index a2befb18e1..c8be562599 100644
--- a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
+++ b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
@@ -38,11 +38,60 @@ class Derived(y: Int) extends Base(y + 1)
 //│ class Base(x: Int)
 //│ class Derived(y: Int) extends Base
 
+:ducs:postprocess.result,coverage
 fun example3(t) =
   if t is
     Base(x) and p1(x) then x
     Derived(y) then y
     else 42
+//│ Post-processed UCS term:
+//│ case t*‡ of
+//│   refined Base*◊ ->
+//│     let ucs$args_t$Base*† = (Base).unapply(t,)
+//│     let x*‡ = (ucs$args_t$Base).0
+//│     let ucs$test$0*† = p1(x,) : Bool
+//│     case ucs$test$0*† of
+//│       true*† -> x
+//│       _ ->
+//│         case t*‡ of
+//│           Derived*◊ ->
+//│             let ucs$args_t$Derived*† = (Derived).unapply(t,)
+//│             let y*‡ = (ucs$args_t$Derived).0
+//│             y
+//│           _ -> 42
+//│ | | | | | | | STEP 4
+//│ | | | | | | | collected match registry: 
+//│ | | | | | | | >>> t => [class `Base`, class `Derived`]
+//│ | | | | | | | >>> x => []
+//│ | | | | | | | >>> y => []
+//│ | | | | | | | checkCoverage <== 0 pending, 3 working, 0 seen
+//│ | | | | | | | | CASE t
+//│ | | | | | | | | SEEN: empty
+//│ | | | | | | | | class symbol: `Base`
+//│ | | | | | | | | REMOVE `Base` from working
+//│ | | | | | | | | unseen: [class `Base`, class `Derived`]
+//│ | | | | | | | | remaining: []
+//│ | | | | | | | | checkCoverage <== LET `ucs$args_t$Base`
+//│ | | | | | | | | checkCoverage <== LET `x`
+//│ | | | | | | | | checkCoverage <== LET `ucs$test$0`
+//│ | | | | | | | | checkCoverage <== TEST `ucs$test$0`
+//│ | | | | | | | | checkCoverage <== TERM x
+//│ | | | | | | | | checkCoverage <== 0 pending, 2 working, 1 seen
+//│ | | | | | | | | | CASE t
+//│ | | | | | | | | | SEEN: t is Base
+//│ | | | | | | | | | class symbol: `Derived`
+//│ | | | | | | | | | REMOVE `Derived` from working
+//│ | | | | | | | | | unseen: [class `Derived`]
+//│ | | | | | | | | | remaining: []
+//│ | | | | | | | | | checkCoverage <== LET `ucs$args_t$Derived`
+//│ | | | | | | | | | checkCoverage <== LET `y`
+//│ | | | | | | | | | checkCoverage <== TERM y
+//│ | | | | | | | | | remaining cases should be covered by the wildcard
+//│ | | | | | | | | | checkCoverage <== TERM 42
+//│ | | | | | | | | checkCoverage ==> 0 diagnostics
+//│ | | | | | | | | remaining cases are not covered: []
+//│ | | | | | | | checkCoverage ==> 0 diagnostics
+//│ | | | | | | | Coverage checking result: 0 errors
 //│ fun example3: forall 'a. (Base & {#x: Num & 'a}) -> (Int | 'a)
 
 fun example4(t, x) =
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
index 73af7dad23..a90cc6006e 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/SealedClasses.mls
@@ -48,18 +48,8 @@ fun is_value_automatic_refinement(term) =
 //│       App*◊ -> false
 //│ fun is_value_automatic_refinement: (Abs | App | Var) -> Bool
 
-:e
 fun is_value'(term) =
   if term is Term and term is
     Abs(_, _) then true
     Var(_) then false
-//│ ╔══[ERROR] when `term` is `Term`
-//│ ║  l.53: 	  if term is Term and term is
-//│ ║        	             ^^^^
-//│ ╟── `term` has 1 missing case
-//│ ║  l.53: 	  if term is Term and term is
-//│ ║        	                      ^^^^
-//│ ╟── it can be class `App`
-//│ ║  l.6: 	class App(func: Term, arg: Term) extends Term
-//│ ╙──     	      ^^^
 //│ fun is_value': (Abs | Var) -> Bool
diff --git a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
index 8a1b7fb4f9..1b89a4b196 100644
--- a/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
+++ b/shared/src/test/diff/pretyper/ucs/patterns/Literals.mls
@@ -61,7 +61,6 @@ fun mix(x) = if x is
   true then "true"
   Some(value) then "Some"
   0 then "zero"
-//│ ╙──
 //│ fun mix: (0 | Some[anything] | true) -> ("Some" | "true" | "zero")
 
 [mix(true), mix(Some(1)), mix(0)]
@@ -72,19 +71,19 @@ fun mix(x) = if x is
 :e
 [mix(false), mix(None)]
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.73: 	[mix(false), mix(None)]
+//│ ║  l.72: 	[mix(false), mix(None)]
 //│ ║        	 ^^^^^^^^^^
 //│ ╟── reference of type `false` does not match type `0 | Some[?T] | true`
-//│ ║  l.73: 	[mix(false), mix(None)]
+//│ ║  l.72: 	[mix(false), mix(None)]
 //│ ║        	     ^^^^^
 //│ ╟── Note: constraint arises from reference:
 //│ ║  l.60: 	fun mix(x) = if x is
 //│ ╙──      	                ^
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.73: 	[mix(false), mix(None)]
+//│ ║  l.72: 	[mix(false), mix(None)]
 //│ ║        	             ^^^^^^^^^
 //│ ╟── reference of type `None` does not match type `0 | Some[?T] | true`
-//│ ║  l.73: 	[mix(false), mix(None)]
+//│ ║  l.72: 	[mix(false), mix(None)]
 //│ ║        	                 ^^^^
 //│ ╟── Note: constraint arises from reference:
 //│ ║  l.60: 	fun mix(x) = if x is
@@ -117,8 +116,6 @@ fun bool_patterns(x) =
   if x is
     true then 1
     false then 2
-//│ ╙──
-//│ ╙──
 //│ fun bool_patterns: Bool -> (1 | 2)
 
 fun dual_patterns(x, y) =
diff --git a/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls b/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
index b8b9db5bc4..11f8763ee5 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
@@ -14,8 +14,6 @@ fun mixed_literals(v) =
 //│   2 -> "2"
 //│   1 -> "1"
 //│ Desugared term: case v of { true => "true"; false => "false"; 2 => "2"; 1 => "1" }
-//│ ╙──
-//│ ╙──
 //│ fun mixed_literals: (1 | 2 | false | true) -> ("1" | "2" | "false" | "true")
 
 :ducs:postprocess.result
@@ -28,8 +26,6 @@ fun separated_by_and(v) =
 //│ case v*‡ of
 //│   true*† -> "true"
 //│   false*† -> "false"
-//│ ╙──
-//│ ╙──
 //│ fun separated_by_and: Bool -> ("false" | "true")
 
 :ducs:postprocess.result
diff --git a/shared/src/test/diff/ucs/ElseIf.mls b/shared/src/test/diff/ucs/ElseIf.mls
index 2f52f9b925..a24afcc3e0 100644
--- a/shared/src/test/diff/ucs/ElseIf.mls
+++ b/shared/src/test/diff/ucs/ElseIf.mls
@@ -79,6 +79,24 @@ f(Fals, Fals)
 //│ res
 //│     = false
 
+:e
+fun g(x, y) = if x is
+  true and y is true then true
+  false and y is false then false
+//│ ╔══[ERROR] `y` has 1 missing case
+//│ ║  l.84: 	  true and y is true then true
+//│ ║        	           ^
+//│ ╟── it can be Boolean value false
+//│ ║  l.85: 	  false and y is false then false
+//│ ╙──      	                 ^^^^^
+//│ ╔══[ERROR] `y` has 1 missing case
+//│ ║  l.85: 	  false and y is false then false
+//│ ║        	            ^
+//│ ╟── it can be Boolean value true
+//│ ║  l.84: 	  true and y is true then true
+//│ ╙──      	                ^^^^
+//│ fun g: (Bool, nothing) -> Bool
+
 // Test with real booleans
 fun g(x, y) = if x is
   true and y is true then true
@@ -86,7 +104,6 @@ fun g(x, y) = if x is
   _ and y is
     true then true
     false then false
-//│ ╙──
 //│ fun g: (Object, Bool) -> Bool
 
 // Chained UCS terms
@@ -106,46 +123,46 @@ fun f(x, y) = if x is
     Tru and x is Fals then true
     Fals and x is Tru then false
 //│ ╔══[ERROR] when `y` is `Tru`
-//│ ║  l.106: 	    Tru and x is Fals then true
+//│ ║  l.123: 	    Tru and x is Fals then true
 //│ ║         	    ^^^
 //│ ╟── `x` has 1 missing case
-//│ ║  l.106: 	    Tru and x is Fals then true
+//│ ║  l.123: 	    Tru and x is Fals then true
 //│ ║         	            ^
 //│ ╟── it can be module `Tru`
-//│ ║  l.107: 	    Fals and x is Tru then false
+//│ ║  l.124: 	    Fals and x is Tru then false
 //│ ╙──       	                  ^^^
 //│ ╔══[ERROR] when `y` is `Fals`
-//│ ║  l.107: 	    Fals and x is Tru then false
+//│ ║  l.124: 	    Fals and x is Tru then false
 //│ ║         	    ^^^^
 //│ ╟── `x` has 1 missing case
-//│ ║  l.107: 	    Fals and x is Tru then false
+//│ ║  l.124: 	    Fals and x is Tru then false
 //│ ║         	             ^
 //│ ╟── it can be module `Fals`
-//│ ║  l.106: 	    Tru and x is Fals then true
+//│ ║  l.123: 	    Tru and x is Fals then true
 //│ ╙──       	                 ^^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.106: 	    Tru and x is Fals then true
+//│ ║  l.123: 	    Tru and x is Fals then true
 //│ ║         	            ^^^^^^^^^^^^^^^^^^^
 //│ ╟── class pattern of type `Tru` is not an instance of type `Fals`
-//│ ║  l.103: 	    Tru and y is Tru then true
+//│ ║  l.120: 	    Tru and y is Tru then true
 //│ ║         	    ^^^
 //│ ╟── but it flows into reference with expected type `Fals`
-//│ ║  l.106: 	    Tru and x is Fals then true
+//│ ║  l.123: 	    Tru and x is Fals then true
 //│ ║         	            ^
 //│ ╟── Note: constraint arises from class pattern:
-//│ ║  l.106: 	    Tru and x is Fals then true
+//│ ║  l.123: 	    Tru and x is Fals then true
 //│ ╙──       	                 ^^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.107: 	    Fals and x is Tru then false
+//│ ║  l.124: 	    Fals and x is Tru then false
 //│ ║         	             ^^^^^^^^^^^^^^^^^^^
 //│ ╟── class pattern of type `Fals` is not an instance of type `Tru`
-//│ ║  l.104: 	    Fals and y is Fals then false
+//│ ║  l.121: 	    Fals and y is Fals then false
 //│ ║         	    ^^^^
 //│ ╟── but it flows into reference with expected type `Tru`
-//│ ║  l.107: 	    Fals and x is Tru then false
+//│ ║  l.124: 	    Fals and x is Tru then false
 //│ ║         	             ^
 //│ ╟── Note: constraint arises from class pattern:
-//│ ║  l.107: 	    Fals and x is Tru then false
+//│ ║  l.124: 	    Fals and x is Tru then false
 //│ ╙──       	                  ^^^
 //│ fun f: (Fals | Tru, Fals | Tru) -> Bool
 
diff --git a/shared/src/test/diff/ucs/Exhaustiveness.mls b/shared/src/test/diff/ucs/Exhaustiveness.mls
index 1bf9bd51cd..720a50ce2a 100644
--- a/shared/src/test/diff/ucs/Exhaustiveness.mls
+++ b/shared/src/test/diff/ucs/Exhaustiveness.mls
@@ -46,6 +46,9 @@ class Node[A](value: int, left: Tree[A], right: Tree[A]) {
     >= value then right.find(wanted)
     == value then true
 }
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.47: 	    == value then true
+//│ ╙──      	                  ^^^^
 //│ ╔══[ERROR] Type mismatch in operator application:
 //│ ║  l.44: 	  fun contains(wanted) = if wanted
 //│ ║        	                            ^^^^^^
diff --git a/shared/src/test/diff/ucs/SimpleUCS.mls b/shared/src/test/diff/ucs/SimpleUCS.mls
index 90291d2fc6..ecf9c176b6 100644
--- a/shared/src/test/diff/ucs/SimpleUCS.mls
+++ b/shared/src/test/diff/ucs/SimpleUCS.mls
@@ -174,6 +174,9 @@ fun f(x, y) =
       >  0 then "gt"
       <  0 then "le"
       == 0 then "eq"
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.176: 	      == 0 then "eq"
+//│ ╙──       	                ^^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
 //│ ║  l.176: 	      == 0 then "eq"
 //│ ║         	                ^^^^
@@ -243,19 +246,19 @@ fun f(u, v, w) =
       Right(_) then "right-defined"
     None then "undefined"
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.241: 	    Some(x) and x is
+//│ ║  l.244: 	    Some(x) and x is
 //│ ║         	    ^^^^^^^^^^^^^^^^
-//│ ║  l.242: 	      Left(_) then "left-defined"
+//│ ║  l.245: 	      Left(_) then "left-defined"
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.243: 	      Right(_) then "right-defined"
+//│ ║  l.246: 	      Right(_) then "right-defined"
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ║  l.244: 	    None then "undefined"
+//│ ║  l.247: 	    None then "undefined"
 //│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── operator application of type `Int` does not match type `Left[?A] | Right[?B]`
-//│ ║  l.227: 	  if x - y > 0 then Some(x + y + z) else None
+//│ ║  l.230: 	  if x - y > 0 then Some(x + y + z) else None
 //│ ║         	                         ^^^^^^^^^
 //│ ╟── Note: constraint arises from reference:
-//│ ║  l.241: 	    Some(x) and x is
+//│ ║  l.244: 	    Some(x) and x is
 //│ ║         	                ^
 //│ ╟── from field selection:
 //│ ║  l.4: 	class Some[A](value: A) extends Option[A]
@@ -324,7 +327,7 @@ fun f(x) =
     0 ::
       Nil() then "oh"
 //│ ╔══[ERROR] Syntactic split of patterns are not supported
-//│ ║  l.324: 	    0 ::
+//│ ║  l.327: 	    0 ::
 //│ ╙──       	      ^^
 //│ ╔══[ERROR] unexpected empty split found
 //│ ╙──
@@ -369,22 +372,22 @@ test(false)
 test(0)
 test(1)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.369: 	test(0)
+//│ ║  l.372: 	test(0)
 //│ ║         	^^^^^^^
 //│ ╟── integer literal of type `0` is not an instance of type `Bool`
-//│ ║  l.369: 	test(0)
+//│ ║  l.372: 	test(0)
 //│ ║         	     ^
 //│ ╟── Note: constraint arises from reference:
-//│ ║  l.357: 	fun test(x) = if x then 0 else "oops"
+//│ ║  l.360: 	fun test(x) = if x then 0 else "oops"
 //│ ╙──       	                 ^
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.370: 	test(1)
+//│ ║  l.373: 	test(1)
 //│ ║         	^^^^^^^
 //│ ╟── integer literal of type `1` is not an instance of type `Bool`
-//│ ║  l.370: 	test(1)
+//│ ║  l.373: 	test(1)
 //│ ║         	     ^
 //│ ╟── Note: constraint arises from reference:
-//│ ║  l.357: 	fun test(x) = if x then 0 else "oops"
+//│ ║  l.360: 	fun test(x) = if x then 0 else "oops"
 //│ ╙──       	                 ^
 //│ "oops" | 0 | error
 //│ res
diff --git a/shared/src/test/diff/ucs/SplitAfterOp.mls b/shared/src/test/diff/ucs/SplitAfterOp.mls
index 3c4d96cf1e..f80f90a39b 100644
--- a/shared/src/test/diff/ucs/SplitAfterOp.mls
+++ b/shared/src/test/diff/ucs/SplitAfterOp.mls
@@ -22,6 +22,9 @@ fun f(x, y) =
   if x == y +
     5 then 0
     7 then 0
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.24: 	    7 then 0
+//│ ╙──      	           ^
 //│ ╔══[ERROR] Type mismatch in application:
 //│ ║  l.22: 	  if x == y +
 //│ ║        	            ^
@@ -55,40 +58,43 @@ fun f(x, y) =
   if x == y *
     5 then 0
     6 + 7 then 0
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.60: 	    6 + 7 then 0
+//│ ╙──      	               ^
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.55: 	  if x == y *
+//│ ║  l.58: 	  if x == y *
 //│ ║        	            ^
-//│ ║  l.56: 	    5 then 0
+//│ ║  l.59: 	    5 then 0
 //│ ║        	^^^^^
 //│ ╟── operator application of type `Bool` is not an instance of type `Int`
-//│ ║  l.55: 	  if x == y *
+//│ ║  l.58: 	  if x == y *
 //│ ╙──      	     ^^^^^^
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.55: 	  if x == y *
+//│ ║  l.58: 	  if x == y *
 //│ ║        	            ^
-//│ ║  l.56: 	    5 then 0
+//│ ║  l.59: 	    5 then 0
 //│ ║        	^^^^^
 //│ ╙── application of type `Int` is not an instance of type `Bool`
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.55: 	  if x == y *
+//│ ║  l.58: 	  if x == y *
 //│ ║        	            ^
-//│ ║  l.56: 	    5 then 0
+//│ ║  l.59: 	    5 then 0
 //│ ║        	^^^^^^^^^^^^^
-//│ ║  l.57: 	    6 + 7 then 0
+//│ ║  l.60: 	    6 + 7 then 0
 //│ ║        	^^^^^^^^^
 //│ ╟── operator application of type `Bool` is not an instance of type `Int`
-//│ ║  l.55: 	  if x == y *
+//│ ║  l.58: 	  if x == y *
 //│ ╙──      	     ^^^^^^
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.55: 	  if x == y *
+//│ ║  l.58: 	  if x == y *
 //│ ║        	            ^
-//│ ║  l.56: 	    5 then 0
+//│ ║  l.59: 	    5 then 0
 //│ ║        	^^^^^^^^^^^^^
-//│ ║  l.57: 	    6 + 7 then 0
+//│ ║  l.60: 	    6 + 7 then 0
 //│ ║        	^^^^^^^^^
 //│ ╙── application of type `Int` is not an instance of type `Bool`
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.57: 	    6 + 7 then 0
+//│ ║  l.60: 	    6 + 7 then 0
 //│ ║        	               ^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun f: (Num, Num) -> 0
@@ -99,32 +105,35 @@ fun f(x, y) =
     y +
       5 then 0
       7 then 0
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.107: 	      7 then 0
+//│ ╙──       	             ^
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.99: 	    y +
-//│ ║        	      ^
-//│ ║  l.100: 	      5 then 0
+//│ ║  l.105: 	    y +
+//│ ║         	      ^
+//│ ║  l.106: 	      5 then 0
 //│ ║         	^^^^^^^
 //│ ╟── operator application of type `Bool` is not an instance of type `Int`
-//│ ║  l.98: 	  if x ==
-//│ ║        	     ^^^^
-//│ ║  l.99: 	    y +
-//│ ╙──      	^^^^^^
+//│ ║  l.104: 	  if x ==
+//│ ║         	     ^^^^
+//│ ║  l.105: 	    y +
+//│ ╙──       	^^^^^^
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.99: 	    y +
-//│ ║        	      ^
-//│ ║  l.100: 	      5 then 0
+//│ ║  l.105: 	    y +
+//│ ║         	      ^
+//│ ║  l.106: 	      5 then 0
 //│ ║         	^^^^^^^
 //│ ╙── application of type `Int` is not an instance of type `Bool`
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.99: 	    y +
-//│ ║        	      ^
-//│ ║  l.100: 	      5 then 0
+//│ ║  l.105: 	    y +
+//│ ║         	      ^
+//│ ║  l.106: 	      5 then 0
 //│ ║         	^^^^^^^^^^^^^^
-//│ ║  l.101: 	      7 then 0
+//│ ║  l.107: 	      7 then 0
 //│ ║         	^^^^^^^
 //│ ╙── application of type `Int` is not an instance of type `Bool`
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.101: 	      7 then 0
+//│ ║  l.107: 	      7 then 0
 //│ ║         	             ^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun f: (Num, Num) -> 0
@@ -134,14 +143,14 @@ fun f(x, b) =
   if x ==
     1 and b then 0
 //│ ╔══[ERROR] missing else branch
-//│ ║  l.135: 	    1 and b then 0
+//│ ║  l.144: 	    1 and b then 0
 //│ ╙──       	          ^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.135: 	    1 and b then 0
+//│ ║  l.144: 	    1 and b then 0
 //│ ║         	                 ^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.135: 	    1 and b then 0
+//│ ║  l.144: 	    1 and b then 0
 //│ ║         	          ^^^^^^^^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun f: (Num, Bool) -> 0
@@ -152,16 +161,19 @@ fun toEnglish(x) =
   if x ==
     true then "t"
     0 then "z"
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.163: 	    0 then "z"
+//│ ╙──       	           ^^^
 //│ ╔══[ERROR] Type mismatch in operator application:
-//│ ║  l.152: 	  if x ==
+//│ ║  l.161: 	  if x ==
 //│ ║         	     ^^^^
-//│ ║  l.153: 	    true then "t"
+//│ ║  l.162: 	    true then "t"
 //│ ║         	^^^^^^^^
 //│ ╟── reference of type `true` is not an instance of `Num`
-//│ ║  l.153: 	    true then "t"
+//│ ║  l.162: 	    true then "t"
 //│ ╙──       	    ^^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.154: 	    0 then "z"
+//│ ║  l.163: 	    0 then "z"
 //│ ║         	           ^^^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun toEnglish: Num -> ("t" | "z")
@@ -171,18 +183,21 @@ fun toEnglish(x) =
   if x ==
     0 then "z"
     true then "t"
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.185: 	    true then "t"
+//│ ╙──       	              ^^^
 //│ ╔══[ERROR] Type mismatch in operator application:
-//│ ║  l.171: 	  if x ==
+//│ ║  l.183: 	  if x ==
 //│ ║         	     ^^^^
-//│ ║  l.172: 	    0 then "z"
+//│ ║  l.184: 	    0 then "z"
 //│ ║         	^^^^^^^^^^^^^^
-//│ ║  l.173: 	    true then "t"
+//│ ║  l.185: 	    true then "t"
 //│ ║         	^^^^^^^^
 //│ ╟── reference of type `true` is not an instance of `Num`
-//│ ║  l.173: 	    true then "t"
+//│ ║  l.185: 	    true then "t"
 //│ ╙──       	    ^^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.173: 	    true then "t"
+//│ ║  l.185: 	    true then "t"
 //│ ║         	              ^^^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun toEnglish: Num -> ("t" | "z")
@@ -192,8 +207,11 @@ fun toEnglish(x) =
   if x ==
     1 then "o"
     0 then "z"
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.209: 	    0 then "z"
+//│ ╙──       	           ^^^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.194: 	    0 then "z"
+//│ ║  l.209: 	    0 then "z"
 //│ ║         	           ^^^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun toEnglish: Num -> ("o" | "z")
@@ -210,32 +228,32 @@ fun toEnglish(x) =
   if x ==
     else 1
 //│ ╔══[PARSE ERROR] Unexpected indented block in expression position
-//│ ║  l.211: 	    else 1
+//│ ║  l.229: 	    else 1
 //│ ╙──       	^^^^
 //│ ╔══[PARSE ERROR] Unexpected end of indented block; an expression was expected here
-//│ ║  l.211: 	    else 1
+//│ ║  l.229: 	    else 1
 //│ ╙──       	    ^
 //│ ╔══[PARSE ERROR] Expected 'then'/'else' clause after 'if'; found operator application instead
-//│ ║  l.210: 	  if x ==
+//│ ║  l.228: 	  if x ==
 //│ ║         	     ^^^^
-//│ ║  l.211: 	    else 1
+//│ ║  l.229: 	    else 1
 //│ ║         	^^^^
 //│ ╟── Note: 'if' expression starts here:
-//│ ║  l.210: 	  if x ==
+//│ ║  l.228: 	  if x ==
 //│ ╙──       	  ^^
 //│ ╔══[ERROR] missing else branch
-//│ ║  l.211: 	    else 1
+//│ ║  l.229: 	    else 1
 //│ ╙──       	    ^
 //│ ╔══[ERROR] Type mismatch in operator application:
-//│ ║  l.210: 	  if x ==
+//│ ║  l.228: 	  if x ==
 //│ ║         	     ^^^^
-//│ ║  l.211: 	    else 1
+//│ ║  l.229: 	    else 1
 //│ ║         	^^^^
 //│ ╟── undefined literal of type `()` is not an instance of type `Num`
-//│ ║  l.211: 	    else 1
+//│ ║  l.229: 	    else 1
 //│ ╙──       	    ^
 //│ ╔══[ERROR] Type mismatch in `case` expression:
-//│ ║  l.211: 	    else 1
+//│ ║  l.229: 	    else 1
 //│ ║         	    ^
 //│ ╙── expression of type `Bool` is not an instance of type `true`
 //│ fun toEnglish: Num -> ()
diff --git a/shared/src/test/diff/ucs/WeirdIf.mls b/shared/src/test/diff/ucs/WeirdIf.mls
index 2c1c5c1f4e..1f34f67b96 100644
--- a/shared/src/test/diff/ucs/WeirdIf.mls
+++ b/shared/src/test/diff/ucs/WeirdIf.mls
@@ -99,8 +99,6 @@ fun boolToStr(x) =
   if x is
     true then "yah"
     false then "nah"
-//│ ╙──
-//│ ╙──
 //│ fun boolToStr: Bool -> ("nah" | "yah")
 
 boolToStr of true
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index 5bceb06ce7..60758f26b3 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -1134,15 +1134,10 @@ object DiffTests {
 
   object DebugUCSFlags {
     // E.g. "ducs", "ducs:foo", "ducs:foo,bar", "ducs:a.b.c,foo"
-    private val pattern = "^ducs(?::\\s*([A-Za-z\\.-]+)(,\\s*[A-Za-z\\.-]+)*)?$".r
-    def unapply(flags: Str): Opt[Set[Str]] =
-      flags match {
-        case pattern(head, tail) =>
-          (Option(head), Option(tail)) match {
-            case (N, _) => S(Set.empty)
-            case (S(head), N) => S(Set.single(head))
-            case (S(head), S(tail)) => S(Set.from(head :: tail.split(",").drop(1).toList))
-          }
+    private val pattern = "^ducs(?::(\\s*(?:[A-Za-z\\.-]+)(?:,\\s*[A-Za-z\\.-]+)*))?$".r
+    def unapply(flagsString: Str): Opt[Set[Str]] =
+      flagsString match {
+        case pattern(flags) => Option(flags).map(_.split(",\\s*").toSet)
         case _ => N
       }
   }

From bdb5b0eedd04036e675120746d26c908be056715 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Fri, 19 Jan 2024 23:39:19 +0800
Subject: [PATCH 087/147] Fix `filterMap` test

---
 .../mlscript/ucs/stages/Desugaring.scala      | 13 ++++-
 shared/src/test/diff/nu/FilterMap.mls         | 56 +++++++++++++++----
 2 files changed, 56 insertions(+), 13 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index db238f4989..428e86f02c 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -241,6 +241,10 @@ trait Desugaring { self: PreTyper =>
           println(s"${nme.name} is ${pattern.nme.name}")
           val (scopeWithNestedAll, bindNestedAll) = desugarClassPattern(pattern, nme, scope, pattern.refined)
           (scopeWithNestedAll, split => bindPrevious(bindNestedAll(split) :: c.Split.Nil))
+        case ((scope, bindPrevious), S(nme -> S(pattern @ s.ConcretePattern(Var("true") | Var("false"))))) =>
+          println(s"${nme.name} is ${pattern.nme.name}")
+          val className = pattern.nme.withResolvedClassLikeSymbol(scope, context)
+          (scope, split => bindPrevious(c.Branch(nme, c.Pattern.Class(className, false), (split)) :: c.Split.Nil))
         case ((scope, bindPrevious), S(nme -> S(pattern: s.LiteralPattern))) =>
           nme.getOrCreateScrutinee
              .withAliasVar(nme)
@@ -252,7 +256,7 @@ trait Desugaring { self: PreTyper =>
           (scopeWithNestedAll, bindNestedAll.andThen(bindPrevious))
         // Well, other patterns are not supported yet.
         case (acc, S(nme -> S(pattern))) =>
-          raiseDesugaringError(msg"unsupported pattern is" -> pattern.toLoc)
+          raiseDesugaringError(msg"unsupported pattern" -> pattern.toLoc)
           acc
         // If this parameter is empty (e.g. produced by wildcard), then we do
         // nothing and pass on scope and binder.
@@ -273,8 +277,13 @@ trait Desugaring { self: PreTyper =>
         val symbol = new LocalTermSymbol(subScrutineeVar)
         symbol.addScrutinee(tuplePattern.getField(index).withAliasVar(subScrutineeVar))
         S(subScrutineeVar.withSymbol(symbol) -> S(parameterPattern))
+      case (parameterPattern @ s.ConcretePattern(nme @ (Var("true") | Var("false"))), index) =>
+        val subScrutineeVar = freshSubScrutineeVar(parentScrutineeVar, s"Tuple$$${fields.length}", index)
+        val symbol = new LocalTermSymbol(subScrutineeVar)
+        symbol.addScrutinee(tuplePattern.getField(index).withAliasVar(subScrutineeVar))
+        S(subScrutineeVar.withSymbol(symbol) -> S(parameterPattern))
       case (pattern, _) =>
-        raiseDesugaringError(msg"unsupported pattern" -> pattern.toLoc)
+        raiseDesugaringError(msg"unsupported pattern ${pattern.getClass().getSimpleName()}" -> pattern.toLoc)
         N
     }.toList
   }
diff --git a/shared/src/test/diff/nu/FilterMap.mls b/shared/src/test/diff/nu/FilterMap.mls
index bd4274b329..0ad2fce403 100644
--- a/shared/src/test/diff/nu/FilterMap.mls
+++ b/shared/src/test/diff/nu/FilterMap.mls
@@ -14,24 +14,58 @@
 // 9 { true , Y } -> [ Y | filtermap (F , XS )]
 // 10 end.
 
-
-module Nil
+type List[A] = Cons[A] | Nil
 class Cons[out A](head: A, tail: Cons[A] | Nil)
-//│ module Nil
+module Nil
+//│ type List[A] = Cons[A] | Nil
 //│ class Cons[A](head: A, tail: Cons[A] | Nil)
+//│ module Nil
 
+fun (::) cons(h, t) = Cons(h, t)
+//│ fun (::) cons: forall 'A. ('A, Cons['A] | Nil) -> Cons['A]
 
-// FIXME UCS
-fun filtermap(f, xs) = if xs is
+fun filtermap(f, xs: List['A]) = if xs is
   Nil then Nil
-  Cons(y, ys) and f(ys) is
+  Cons(y, ys) and f(y) is
     false then filtermap(f, ys)
     true then Cons(y, filtermap(f, ys))
-    [true, z] then Cons(y, filtermap(f, ys))
-//│ ╔══[ERROR] unsupported pattern
-//│ ║  l.30: 	    [true, z] then Cons(y, filtermap(f, ys))
-//│ ╙──      	     ^^^^
-//│ fun filtermap: ((Cons[nothing] | Nil) -> (Object & {1: anything} & ~false & ~true | false | true), Cons[anything] | Nil) -> (Cons[nothing] | Nil)
+    [true, z] then Cons(z, filtermap(f, ys))
+//│ fun filtermap: forall 'A 'A0. ('A -> (Object & {0: true, 1: 'A0} & ~false & ~true | false | true), xs: List['A]) -> (Cons['A0] | Nil)
+//│   where
+//│     'A <: 'A0
+
+let xs = 0 :: 1 :: 2 :: 3 :: 4 :: 5 :: 6 :: 7 :: Nil
+//│ let xs: Cons[0 | 1 | 2 | 3 | 4 | 5 | 6 | 7]
+//│ xs
+//│    = Cons {}
+
+fun f(x) = if x % 3 is
+  0 then [true, -x]
+  1 then false
+  _ then true
+//│ fun f: Int -> (Bool | [true, Int])
+
+:e // TODO: Records are not `Object`s
+filtermap(f, xs)
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.49: 	filtermap(f, xs)
+//│ ║        	^^^^^^^^^^^^^^^^
+//│ ╟── tuple literal of type `[true, ?a]` is not an instance of type `Object`
+//│ ║  l.43: 	  0 then [true, -x]
+//│ ║        	         ^^^^^^^^^^
+//│ ╟── Note: constraint arises from `case` expression:
+//│ ║  l.30: 	    false then filtermap(f, ys)
+//│ ║        	    ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.31: 	    true then Cons(y, filtermap(f, ys))
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.32: 	    [true, z] then Cons(z, filtermap(f, ys))
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── from application:
+//│ ║  l.29: 	  Cons(y, ys) and f(y) is
+//│ ╙──      	                  ^^^^
+//│ Cons[Int] | Nil | error
+//│ res
+//│     = Cons {}
 
 
 module Tru

From 37a508cba6fe7efc387c69da11c0a3aae243b19a Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Fri, 19 Jan 2024 23:49:07 +0800
Subject: [PATCH 088/147] No longer use implicit `Set[String]`

---
 .../mlscript/ucs/stages/Normalization.scala   | 49 +++++++++----------
 1 file changed, 23 insertions(+), 26 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index bbcee15887..516c183c24 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -68,15 +68,14 @@ trait Normalization { self: Desugarer with Traceable =>
       * @param generatedVars the generated variables which have been declared
       * @return the concatenated split
       */
-    def fill(those: Split, deep: Bool, shouldReportDiscarded: Bool)(implicit
+    def fill(those: Split, deep: Bool, declaredVars: Set[Var], shouldReportDiscarded: Bool)(implicit
         scope: Scope,
         context: Context,
-        generatedVars: Set[Var],
     ): Split =
-      trace(s"fill <== ${generatedVars.iterator.map(_.name).mkString("{", ", ", "}")}") {
+      trace(s"fill <== ${declaredVars.iterator.map(_.name).mkString("{", ", ", "}")}") {
         println(s"LHS: ${showSplit(these)}")
         println(s"RHS: ${showSplit(those)}")
-        fillImpl(these, those, deep)(scope, context, generatedVars, shouldReportDiscarded)
+        fillImpl(these, those, deep)(scope, context, declaredVars, shouldReportDiscarded)
       }(sp => s"fill ==> ${showSplit(sp)}")
 
     def :++(tail: => Split): Split = {
@@ -100,53 +99,52 @@ trait Normalization { self: Desugarer with Traceable =>
   @inline protected def normalize(split: Split)(implicit
       scope: Scope,
       context: Context
-  ): Term = normalizeToTerm(split)(scope, context, Set.empty)
+  ): Term = normalizeToTerm(split, Set.empty)(scope, context)
 
   private def errorTerm: Term = Var("error")
 
-  private def normalizeToTerm(split: Split)(implicit
+  private def normalizeToTerm(split: Split, declaredVars: Set[Var])(implicit
       scope: Scope,
       context: Context,
-      generatedVars: Set[Var],
   ): Term = trace("normalizeToTerm <==") {
     split match {
       case Split.Cons(Branch(scrutinee, Pattern.Name(nme), continuation), tail) =>
         println(s"ALIAS: ${scrutinee.name} is ${nme.name}")
         val (wrap, realTail) = preventShadowing(nme, tail)
-        wrap(Let(false, nme, scrutinee, normalizeToTerm(continuation.fill(realTail, false, true))))
+        wrap(Let(false, nme, scrutinee, normalizeToTerm(continuation.fill(realTail, false, declaredVars, true), declaredVars)))
       // Skip Boolean conditions as scrutinees, because they only appear once.
       case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true"), _), continuation), tail) if context.isTestVar(test) =>
         println(s"TRUE: ${test.name} is true")
-        val trueBranch = normalizeToTerm(continuation.fill(tail, false, false))
-        val falseBranch = normalizeToCaseBranches(tail)
+        val trueBranch = normalizeToTerm(continuation.fill(tail, false, declaredVars, false), declaredVars)
+        val falseBranch = normalizeToCaseBranches(tail, declaredVars)
         CaseOf(test, Case(nme, trueBranch, falseBranch)(refined = false))
       case Split.Cons(Branch(Scrutinee.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Literal(literal), continuation), tail) =>
         println(s"LITERAL: ${scrutineeVar.name} is ${literal.idStr}")
         println(s"entire split: ${showSplit(split)}")
-        val concatenatedTrueBranch = continuation.fill(tail, false, false)
+        val concatenatedTrueBranch = continuation.fill(tail, false, declaredVars, false)
         // println(s"true branch: ${showSplit(concatenatedTrueBranch)}")
-        val trueBranch = normalizeToTerm(specialize(concatenatedTrueBranch, true)(scrutineeVar, scrutinee, pattern, context))
+        val trueBranch = normalizeToTerm(specialize(concatenatedTrueBranch, true)(scrutineeVar, scrutinee, pattern, context), declaredVars)
         // println(s"false branch: ${showSplit(tail)}")
-        val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context))
+        val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context), declaredVars)
         CaseOf(scrutineeVar, Case(literal, trueBranch, falseBranch)(refined = false))
       case Split.Cons(Branch(Scrutinee.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Class(nme, rfd), continuation), tail) =>
         println(s"CLASS: ${scrutineeVar.name} is ${nme.name}")
         // println(s"match ${scrutineeVar.name} with $nme (has location: ${nme.toLoc.isDefined})")
-        val trueBranch = normalizeToTerm(specialize(continuation.fill(tail, false, false), true)(scrutineeVar, scrutinee, pattern, context))
-        val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context))
+        val trueBranch = normalizeToTerm(specialize(continuation.fill(tail, false, declaredVars, false), true)(scrutineeVar, scrutinee, pattern, context), declaredVars)
+        val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context), declaredVars)
         CaseOf(scrutineeVar, Case(nme, trueBranch, falseBranch)(refined = pattern.refined))
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
         raiseDesugaringError(msg"unsupported pattern: ${pattern.toString}" -> pattern.toLoc)
         errorTerm
-      case Split.Let(_, nme, _, tail) if context.isScrutineeVar(nme) && generatedVars.contains(nme) =>
+      case Split.Let(_, nme, _, tail) if context.isScrutineeVar(nme) && declaredVars.contains(nme) =>
         println(s"LET: SKIP already declared scrutinee ${nme.name}")
-        normalizeToTerm(tail)
+        normalizeToTerm(tail, declaredVars)
       case Split.Let(rec, nme, rhs, tail) if context.isGeneratedVar(nme) =>
         println(s"LET: generated ${nme.name}")
-        Let(rec, nme, rhs, normalizeToTerm(tail)(scope, context, generatedVars + nme))
+        Let(rec, nme, rhs, normalizeToTerm(tail, declaredVars + nme)(scope, context))
       case Split.Let(rec, nme, rhs, tail) =>
         println(s"LET: ${nme.name}")
-        Let(rec, nme, rhs, normalizeToTerm(tail))
+        Let(rec, nme, rhs, normalizeToTerm(tail, declaredVars))
       case Split.Else(default) =>
         println(s"DFLT: ${default.showDbg}")
         default
@@ -156,20 +154,19 @@ trait Normalization { self: Desugarer with Traceable =>
     }
   }(split => "normalizeToTerm ==> " + showNormalizedTerm(split))
 
-  private def normalizeToCaseBranches(split: Split)(implicit
+  private def normalizeToCaseBranches(split: Split, declaredVars: Set[Var])(implicit
       scope: Scope,
       context: Context,
-      generatedVars: Set[Var]
   ): CaseBranches =
     trace(s"normalizeToCaseBranches <==") {
       split match {
         // case Split.Cons(head, Split.Nil) => Case(head.pattern, normalizeToTerm(head.continuation), NoCases)
-        case other: Split.Cons => Wildcard(normalizeToTerm(other))
-        case Split.Let(_, nme, _, tail) if context.isScrutineeVar(nme) && generatedVars.contains(nme) =>
-          normalizeToCaseBranches(tail)
+        case other: Split.Cons => Wildcard(normalizeToTerm(other, declaredVars))
+        case Split.Let(_, nme, _, tail) if context.isScrutineeVar(nme) && declaredVars.contains(nme) =>
+          normalizeToCaseBranches(tail, declaredVars)
         case Split.Let(rec, nme, rhs, tail) =>
-          val newDeclaredBindings = if (context.isGeneratedVar(nme)) generatedVars + nme else generatedVars
-          normalizeToCaseBranches(tail)(scope, context, newDeclaredBindings) match {
+          val newDeclaredVars = if (context.isGeneratedVar(nme)) declaredVars + nme else declaredVars
+          normalizeToCaseBranches(tail, newDeclaredVars)(scope, context) match {
             case NoCases => Wildcard(rhs)
             case Wildcard(term) => Wildcard(Let(rec, nme, rhs, term))
             case _: Case => die

From 1b275ad7f170b85b4150104acbede5f6aa05e886 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Fri, 19 Jan 2024 23:55:58 +0800
Subject: [PATCH 089/147] Normalization's `fill` does not need to be `deep`

---
 .../mlscript/ucs/stages/Normalization.scala   | 32 +++++++------------
 1 file changed, 11 insertions(+), 21 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 516c183c24..800cebb035 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -1,4 +1,3 @@
-
 package mlscript.ucs.stages
 
 import mlscript.{App, CaseOf, Fld, FldFlags, Let, Loc, Sel, Term, Tup, Var, StrLit}
@@ -10,15 +9,13 @@ import ucs.{Desugarer, Lines, LinesOps, VariableGenerator}
 import ucs.context.{Context, Scrutinee}
 import ucs.display.{showNormalizedTerm, showSplit}
 import ucs.syntax.core.{Pattern, Branch, Split}
-import pretyper.Scope
 import pretyper.symbol._
-import pretyper.{Diagnosable, Traceable}
+import pretyper.{Diagnosable, Scope, Traceable}
 
 trait Normalization { self: Desugarer with Traceable =>
   import Normalization._
 
-  // TODO: We might not need the case where `deep` is `false`.
-  private def fillImpl(these: Split, those: Split, deep: Bool)(implicit
+  private def fillImpl(these: Split, those: Split)(implicit
       scope: Scope,
       context: Context,
       generatedVars: Set[Var],
@@ -34,22 +31,16 @@ trait Normalization { self: Desugarer with Traceable =>
       these
     } else (these match {
       case these @ Split.Cons(head, tail) =>
-        if (head.continuation.hasElse || !deep) {
-          these.copy(tail = fillImpl(tail, those, deep))
-        } else {
-          // println(s"found a branch without default ${showSplit(head.continuation)}")
-          val newHead = head.copy(continuation = fillImpl(head.continuation, those, deep))
-          these.copy(head = newHead, tail = fillImpl(tail, those, deep))
-        }
+        these.copy(tail = fillImpl(tail, those))
       case these @ Split.Let(_, nme, _, tail) =>
         println(s"fill let binding ${nme.name}")
         if (scope.getTermSymbol(nme.name).isDefined && (those.freeVars contains nme)) {
           val fresh = context.freshShadowed()
           val thoseWithShadowed = Split.Let(false, nme, fresh, those)
-          val concatenated = these.copy(tail = fillImpl(tail, thoseWithShadowed, deep))
+          val concatenated = these.copy(tail = fillImpl(tail, thoseWithShadowed))
           Split.Let(false, fresh, nme, concatenated)
         } else {
-          these.copy(tail = fillImpl(tail, those, deep)(scope, context, generatedVars + nme, false))
+          these.copy(tail = fillImpl(tail, those)(scope, context, generatedVars + nme, false))
         }
       case _: Split.Else => these
       case Split.Nil =>
@@ -62,20 +53,19 @@ trait Normalization { self: Desugarer with Traceable =>
       * Fill the split into the previous split. 
       *
       * @param those the split to append
-      * @param deep whether we should also fill the leading branches
       * @param shouldReportDiscarded whether we should raise an error if the given
       *                        split is discarded because of the else branch
       * @param generatedVars the generated variables which have been declared
       * @return the concatenated split
       */
-    def fill(those: Split, deep: Bool, declaredVars: Set[Var], shouldReportDiscarded: Bool)(implicit
+    def fill(those: Split, declaredVars: Set[Var], shouldReportDiscarded: Bool)(implicit
         scope: Scope,
         context: Context,
     ): Split =
       trace(s"fill <== ${declaredVars.iterator.map(_.name).mkString("{", ", ", "}")}") {
         println(s"LHS: ${showSplit(these)}")
         println(s"RHS: ${showSplit(those)}")
-        fillImpl(these, those, deep)(scope, context, declaredVars, shouldReportDiscarded)
+        fillImpl(these, those)(scope, context, declaredVars, shouldReportDiscarded)
       }(sp => s"fill ==> ${showSplit(sp)}")
 
     def :++(tail: => Split): Split = {
@@ -111,17 +101,17 @@ trait Normalization { self: Desugarer with Traceable =>
       case Split.Cons(Branch(scrutinee, Pattern.Name(nme), continuation), tail) =>
         println(s"ALIAS: ${scrutinee.name} is ${nme.name}")
         val (wrap, realTail) = preventShadowing(nme, tail)
-        wrap(Let(false, nme, scrutinee, normalizeToTerm(continuation.fill(realTail, false, declaredVars, true), declaredVars)))
+        wrap(Let(false, nme, scrutinee, normalizeToTerm(continuation.fill(realTail, declaredVars, true), declaredVars)))
       // Skip Boolean conditions as scrutinees, because they only appear once.
       case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true"), _), continuation), tail) if context.isTestVar(test) =>
         println(s"TRUE: ${test.name} is true")
-        val trueBranch = normalizeToTerm(continuation.fill(tail, false, declaredVars, false), declaredVars)
+        val trueBranch = normalizeToTerm(continuation.fill(tail, declaredVars, false), declaredVars)
         val falseBranch = normalizeToCaseBranches(tail, declaredVars)
         CaseOf(test, Case(nme, trueBranch, falseBranch)(refined = false))
       case Split.Cons(Branch(Scrutinee.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Literal(literal), continuation), tail) =>
         println(s"LITERAL: ${scrutineeVar.name} is ${literal.idStr}")
         println(s"entire split: ${showSplit(split)}")
-        val concatenatedTrueBranch = continuation.fill(tail, false, declaredVars, false)
+        val concatenatedTrueBranch = continuation.fill(tail, declaredVars, false)
         // println(s"true branch: ${showSplit(concatenatedTrueBranch)}")
         val trueBranch = normalizeToTerm(specialize(concatenatedTrueBranch, true)(scrutineeVar, scrutinee, pattern, context), declaredVars)
         // println(s"false branch: ${showSplit(tail)}")
@@ -130,7 +120,7 @@ trait Normalization { self: Desugarer with Traceable =>
       case Split.Cons(Branch(Scrutinee.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Class(nme, rfd), continuation), tail) =>
         println(s"CLASS: ${scrutineeVar.name} is ${nme.name}")
         // println(s"match ${scrutineeVar.name} with $nme (has location: ${nme.toLoc.isDefined})")
-        val trueBranch = normalizeToTerm(specialize(continuation.fill(tail, false, declaredVars, false), true)(scrutineeVar, scrutinee, pattern, context), declaredVars)
+        val trueBranch = normalizeToTerm(specialize(continuation.fill(tail, declaredVars, false), true)(scrutineeVar, scrutinee, pattern, context), declaredVars)
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context), declaredVars)
         CaseOf(scrutineeVar, Case(nme, trueBranch, falseBranch)(refined = pattern.refined))
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>

From d360660ec8e8cd889699444cccfda53ffcd82546 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 20 Jan 2024 05:08:34 +0800
Subject: [PATCH 090/147] Fix alias patterns

---
 .../scala/mlscript/ucs/context/Context.scala  |   4 +-
 .../mlscript/ucs/stages/Desugaring.scala      | 181 +++++++++++-------
 .../scala/mlscript/ucs/syntax/source.scala    |   2 +-
 .../pretyper/ucs/examples/LispInterpreter.mls |   8 +-
 .../pretyper/ucs/patterns/AliasPattern.mls    |  57 ++++++
 5 files changed, 179 insertions(+), 73 deletions(-)
 create mode 100644 shared/src/test/diff/pretyper/ucs/patterns/AliasPattern.mls

diff --git a/shared/src/main/scala/mlscript/ucs/context/Context.scala b/shared/src/main/scala/mlscript/ucs/context/Context.scala
index 63ccc90623..9a62d9f853 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Context.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Context.scala
@@ -68,7 +68,5 @@ class Context(originalTerm: If) {
 }
 
 object Context {
-  // TODO: Generate fresh prefix in a determinstic way. I tried to use a counter,
-  // but the produced value is not stable across different runs.
-  def freshPrefix(): Str = "ucs"
+  private def freshPrefix(): Str = "ucs"
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 428e86f02c..8b89f5edd4 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -128,27 +128,46 @@ trait Desugaring { self: PreTyper =>
 
   private def flattenClassParameters(
       parentScrutineeVar: Var,
+      parentScrutinee: Scrutinee,
       parentClassLikeSymbol: TypeSymbol,
       parameters: Ls[s.Pattern]
-  )(implicit context: Context): Ls[Opt[Var -> Opt[s.Pattern]]] =
-    trace(s"flattenClassParameters <== ${parentScrutineeVar.name} is ${parentClassLikeSymbol.name}") {
-      // Make it `lazy` so that it will not be created if all fields are wildcards.
-      lazy val classPattern = parentScrutineeVar.getOrCreateScrutinee.getOrCreateClassPattern(parentClassLikeSymbol)
-      parameters.iterator.zipWithIndex.map {
-        case (_: s.EmptyPattern, _) => N
-        case (s.NamePattern(name), index) =>
+  )(implicit context: Context): Ls[Opt[(Var, Opt[s.Pattern], Ls[Var])]] = {
+    // Make it `lazy` so that it will not be created if all fields are wildcards.
+    lazy val classPattern = parentScrutinee.getOrCreateClassPattern(parentClassLikeSymbol)
+    def flattenPattern(
+      parameterPattern: s.Pattern,
+      index: Int,
+      subScrutineeVarOpt: Opt[(Var, Scrutinee)],
+      aliasVars: Ls[Var],
+    ): Opt[(Var, Opt[s.Pattern], Ls[Var])] = { // scrutineeVar, subPattern, aliasVars
+      lazy val (subScrutineeVar, subScrutinee) = subScrutineeVarOpt.getOrElse {
+        val subScrutineeVar = freshSubScrutineeVar(parentScrutineeVar, parentClassLikeSymbol.name, index)
+        val symbol = new LocalTermSymbol(subScrutineeVar)
+        val subScrutinee = classPattern.getParameter(index).withAliasVar(subScrutineeVar.withSymbol(symbol))
+        symbol.addScrutinee(subScrutinee)
+        (subScrutineeVar, subScrutinee)
+      }
+      parameterPattern match {
+        case _: s.EmptyPattern => N
+        case s.NamePattern(name) =>
           val subScrutinee = classPattern.getParameter(index).withAliasVar(name)
-          S(name.withFreshSymbol.withScrutinee(subScrutinee) -> N)
-        case (parameterPattern @ (s.ClassPattern(_, _, _) | s.LiteralPattern(_) | s.TuplePattern(_)), index) =>
-          val subScrutineeVar = freshSubScrutineeVar(parentScrutineeVar, parentClassLikeSymbol.name, index)
-          val symbol = new LocalTermSymbol(subScrutineeVar)
-          symbol.addScrutinee(classPattern.getParameter(index).withAliasVar(subScrutineeVar))
-          S(subScrutineeVar.withSymbol(symbol) -> S(parameterPattern))
-        case (pattern, _) =>
+          S((name.withFreshSymbol.withScrutinee(subScrutinee), N, aliasVars.reverse))
+        case parameterPattern @ (s.ClassPattern(_, _, _) | s.LiteralPattern(_) | s.TuplePattern(_)) =>
+          S((subScrutineeVar, S(parameterPattern), aliasVars.reverse))
+        case parameterPattern @ s.AliasPattern(aliasVar, innerPattern) =>
+          println(s"alias pattern found ${subScrutineeVar.name} -> ${aliasVar.name}")
+          flattenPattern(innerPattern, index, S((subScrutineeVar, subScrutinee)), aliasVar.withFreshSymbol.withScrutinee(subScrutinee) :: aliasVars)
+        case pattern =>
           raiseDesugaringError(msg"unsupported pattern" -> pattern.toLoc)
           N
+      }
+    }
+    trace(s"flattenClassParameters <== ${parentScrutineeVar.name} is ${parentClassLikeSymbol.name}") {
+      parameters.iterator.zipWithIndex.map {
+        case (pattern, index) => flattenPattern(pattern, index, N, Nil)
       }.toList
     }(r => s"flattenClassParameters ==> ${r.mkString(", ")}")
+  }
 
   /**
     * Recursively decompose and flatten a possibly nested class pattern. Any
@@ -188,13 +207,13 @@ trait Desugaring { self: PreTyper =>
           val vari = makeUnappliedVar(scrutineeVar, pattern.nme)
           vari.withSymbol(new LocalTermSymbol(vari))
         }
-        val nestedPatterns = flattenClassParameters(scrutineeVar, patternClassSymbol, parameters)
+        val nestedPatterns = flattenClassParameters(scrutineeVar, scrutinee, patternClassSymbol, parameters)
         println(s"nestedPatterns = $nestedPatterns")
         // First, handle bindings of parameters of the current class pattern.
         val identity = (split: c.Split) => split
         val bindParameters = nestedPatterns.iterator.zipWithIndex.foldRight[c.Split => c.Split](identity) {
           case ((N, _), bindNextParameter) => bindNextParameter
-          case ((S(parameter -> _), index), bindNextParameter) => 
+          case ((S((parameter, _, _)), index), bindNextParameter) => 
             bindNextParameter.andThen { c.Split.Let(false, parameter, Sel(unapp, Var(index.toString)), _) }
         }
         println(s"bindParameters === identity: ${bindParameters === identity}")
@@ -223,77 +242,109 @@ trait Desugaring { self: PreTyper =>
     * @param bindScrutinees a function that adds all bindings to a split
     */
   private def desugarNestedPatterns(
-      nestedPatterns: Ls[Opt[Var -> Opt[s.Pattern]]],
+      nestedPatterns: Ls[Opt[(Var, Opt[s.Pattern], Ls[Var])]],
       scopeWithScrutinees: Scope,
       bindScrutinees: c.Split => c.Split
   )(implicit context: Context): (Scope, c.Split => c.Split) =
     trace("desugarNestedPatterns") {
       nestedPatterns.foldLeft((scopeWithScrutinees, bindScrutinees)) {
-        // If this parameter is not matched with a sub-pattern, then we do
+        // If this parameter is empty (e.g. produced by wildcard), then we do
         // nothing and pass on scope and binder.
-        case (acc, S(_ -> N)) => acc
+        case (acc, N) => acc
         // If this sub-pattern is a class pattern, we need to recursively flatten
         // the class pattern. We will get a scope with all bindings and a function
         // that adds all bindings to a split. The scope can be passed on to the
         // next sub-pattern. The binder needs to be composed with the previous
         // binder.
-        case ((scope, bindPrevious), S(nme -> S(pattern: s.ClassPattern))) =>
-          println(s"${nme.name} is ${pattern.nme.name}")
-          val (scopeWithNestedAll, bindNestedAll) = desugarClassPattern(pattern, nme, scope, pattern.refined)
-          (scopeWithNestedAll, split => bindPrevious(bindNestedAll(split) :: c.Split.Nil))
-        case ((scope, bindPrevious), S(nme -> S(pattern @ s.ConcretePattern(Var("true") | Var("false"))))) =>
-          println(s"${nme.name} is ${pattern.nme.name}")
-          val className = pattern.nme.withResolvedClassLikeSymbol(scope, context)
-          (scope, split => bindPrevious(c.Branch(nme, c.Pattern.Class(className, false), (split)) :: c.Split.Nil))
-        case ((scope, bindPrevious), S(nme -> S(pattern: s.LiteralPattern))) =>
-          nme.getOrCreateScrutinee
-             .withAliasVar(nme)
-             .getOrCreateLiteralPattern(pattern.literal)
-             .addLocation(pattern.literal)
-          (scope, makeLiteralTest(nme, pattern.literal)(scope).andThen(bindPrevious))
-        case ((scope, bindPrevious), S(nme -> S(s.TuplePattern(fields)))) =>
-          val (scopeWithNestedAll, bindNestedAll) = desugarTuplePattern(fields, nme, scope)
-          (scopeWithNestedAll, bindNestedAll.andThen(bindPrevious))
-        // Well, other patterns are not supported yet.
-        case (acc, S(nme -> S(pattern))) =>
-          raiseDesugaringError(msg"unsupported pattern" -> pattern.toLoc)
-          acc
-        // If this parameter is empty (e.g. produced by wildcard), then we do
-        // nothing and pass on scope and binder.
-        case (acc, N) => acc
+        case (acc @ (scope, bindPrevious), S((nme, patternOpt, aliasVars))) =>
+          println(s"subScrut = ${nme.name}; aliasVars = ${aliasVars.iterator.map(_.name).mkString("[", ", ", "]")}")
+          val bindAliasVars = aliasVars.foldRight[c.Split => c.Split](identity[c.Split]) {
+            case (aliasVar, bindNext) => (inner: c.Split) => c.Split.Let(false, aliasVar, nme, bindNext(inner))
+          }
+          patternOpt match {
+            // If this parameter is not matched with a sub-pattern, then we do
+            // nothing and pass on scope and binder.
+            case N => (scope, bindAliasVars.andThen(bindPrevious))
+            case S(pattern) => pattern match {
+              case pattern: s.ClassPattern =>
+                println(s"${nme.name} is ${pattern.nme.name}")
+                val (scopeWithNestedAll, bindNestedAll) = desugarClassPattern(pattern, nme, scope, pattern.refined)
+                (scopeWithNestedAll, split => bindPrevious(bindNestedAll(bindAliasVars(split)) :: c.Split.Nil))
+              case pattern @ s.ConcretePattern(Var("true") | Var("false")) =>
+                println(s"${nme.name} is ${pattern.nme.name}")
+                val className = pattern.nme.withResolvedClassLikeSymbol(scope, context)
+                (scope, split => bindPrevious(c.Branch(nme, c.Pattern.Class(className, false), bindAliasVars(split)) :: c.Split.Nil))
+              case s.LiteralPattern(literal) =>
+                nme.getOrCreateScrutinee
+                  .withAliasVar(nme)
+                  .getOrCreateLiteralPattern(literal)
+                  .addLocation(literal)
+                (scope, bindAliasVars.andThen(makeLiteralTest(nme, literal)(scope)).andThen(bindPrevious))
+              case s.TuplePattern(fields) =>
+                val (scopeWithNestedAll, bindNestedAll) = desugarTuplePattern(fields, nme, scope)
+                (scopeWithNestedAll, bindAliasVars.andThen(bindNestedAll).andThen(bindPrevious))
+              // Well, other patterns are not supported yet.
+              case _ =>
+                raiseDesugaringError(msg"unsupported pattern" -> pattern.toLoc)
+                acc
+            }
+          }
       }
     }()
 
-  private def flattenTupleFields(parentScrutineeVar: Var, fields: Ls[s.Pattern])(implicit context: Context): Ls[Opt[Var -> Opt[s.Pattern]]] = {
+  // TODO: `aliasVars` not computed
+  private def flattenTupleFields(
+      parentScrutineeVar: Var,
+      parentScrutinee: Scrutinee,
+      fields: Ls[s.Pattern]
+  )(implicit context: Context): Ls[Opt[(Var, Opt[s.Pattern], Ls[Var])]] = {
     // Make it `lazy` so that it will not be created if all fields are wildcards.
-    lazy val tuplePattern = parentScrutineeVar.getOrCreateScrutinee.getOrCreateTuplePattern
-    fields.iterator.zipWithIndex.map {
-      case (_: s.EmptyPattern, _) => N
-      case (s.NamePattern(name), index) =>
-        S(name.withFreshSymbol.withScrutinee(tuplePattern.getField(index)) -> N)
-      case (parameterPattern @ (s.ClassPattern(_, _, _) | s.LiteralPattern(_) | s.TuplePattern(_)), index) =>
-        val arity = fields.length
-        val subScrutineeVar = freshSubScrutineeVar(parentScrutineeVar, s"Tuple$$$arity", index)
-        val symbol = new LocalTermSymbol(subScrutineeVar)
-        symbol.addScrutinee(tuplePattern.getField(index).withAliasVar(subScrutineeVar))
-        S(subScrutineeVar.withSymbol(symbol) -> S(parameterPattern))
-      case (parameterPattern @ s.ConcretePattern(nme @ (Var("true") | Var("false"))), index) =>
-        val subScrutineeVar = freshSubScrutineeVar(parentScrutineeVar, s"Tuple$$${fields.length}", index)
+    lazy val tuplePattern = parentScrutinee.getOrCreateTuplePattern
+    lazy val tupleDummyClassName = s"Tuple$$${fields.length}"
+    def flattenPattern(
+        pattern: s.Pattern,
+        index: Int,
+        subScrutineeVarOpt: Opt[(Var, Scrutinee)],
+        aliasVars: Ls[Var],
+    ): Opt[(Var, Opt[s.Pattern], Ls[Var])] = {
+      lazy val (subScrutineeVar, subScrutinee) = subScrutineeVarOpt.getOrElse {
+        val subScrutineeVar = freshSubScrutineeVar(parentScrutineeVar, tupleDummyClassName, index)
         val symbol = new LocalTermSymbol(subScrutineeVar)
-        symbol.addScrutinee(tuplePattern.getField(index).withAliasVar(subScrutineeVar))
-        S(subScrutineeVar.withSymbol(symbol) -> S(parameterPattern))
-      case (pattern, _) =>
-        raiseDesugaringError(msg"unsupported pattern ${pattern.getClass().getSimpleName()}" -> pattern.toLoc)
-        N
-    }.toList
+        val subScrutinee = tuplePattern.getField(index).withAliasVar(subScrutineeVar.withSymbol(symbol))
+        symbol.addScrutinee(subScrutinee)
+        (subScrutineeVar, subScrutinee)
+      }
+      pattern match {
+        case _: s.EmptyPattern => N
+        case s.NamePattern(name) =>
+          S((name.withFreshSymbol.withScrutinee(tuplePattern.getField(index)), N, aliasVars.reverse))
+        case parameterPattern @ (s.ClassPattern(_, _, _) | s.LiteralPattern(_) | s.TuplePattern(_)) =>
+          val subScrutineeVar = freshSubScrutineeVar(parentScrutineeVar, tupleDummyClassName, index)
+          val symbol = new LocalTermSymbol(subScrutineeVar)
+          symbol.addScrutinee(tuplePattern.getField(index).withAliasVar(subScrutineeVar))
+          S((subScrutineeVar.withSymbol(symbol), S(parameterPattern), aliasVars.reverse))
+        case parameterPattern @ s.ConcretePattern(nme @ (Var("true") | Var("false"))) =>
+          val subScrutineeVar = freshSubScrutineeVar(parentScrutineeVar, tupleDummyClassName, index)
+          val symbol = new LocalTermSymbol(subScrutineeVar)
+          symbol.addScrutinee(tuplePattern.getField(index).withAliasVar(subScrutineeVar))
+          S((subScrutineeVar.withSymbol(symbol), S(parameterPattern), aliasVars.reverse))
+        case parameterPattern @ s.AliasPattern(aliasVar, innerPattern) =>
+          println(s"alias pattern found ${subScrutineeVar.name} -> ${aliasVar.name}")
+          flattenPattern(innerPattern, index, S((subScrutineeVar, subScrutinee)), aliasVar.withFreshSymbol.withScrutinee(subScrutinee) :: aliasVars)
+        case pattern =>
+          raiseDesugaringError(msg"unsupported pattern" -> pattern.toLoc)
+          N
+      }
+    }
+    fields.iterator.zipWithIndex.map { case (pattern, index) => flattenPattern(pattern, index, N, Nil) }.toList
   }
 
   private def desugarTuplePattern(fields: Ls[s.Pattern], scrutineeVar: Var, initialScope: Scope)(implicit context: Context): (Scope, c.Split => c.Split) = {
     val scrutinee = scrutineeVar.getOrCreateScrutinee.withAliasVar(scrutineeVar)
-    val nestedPatterns = flattenTupleFields(scrutineeVar, fields)
+    val nestedPatterns = flattenTupleFields(scrutineeVar, scrutinee, fields)
     val bindFields = nestedPatterns.iterator.zipWithIndex.foldRight[c.Split => c.Split](identity) {
       case ((N, _), bindNextField) => bindNextField
-      case ((S(parameter -> _), index), bindNextField) => 
+      case ((S((parameter, _, _)), index), bindNextField) => 
         val indexVar = Var(index.toString).withLoc(parameter.toLoc)
         bindNextField.andThen { c.Split.Let(false, parameter, Sel(scrutineeVar, indexVar), _) }
     }
diff --git a/shared/src/main/scala/mlscript/ucs/syntax/source.scala b/shared/src/main/scala/mlscript/ucs/syntax/source.scala
index 043eff9bcd..2164397539 100644
--- a/shared/src/main/scala/mlscript/ucs/syntax/source.scala
+++ b/shared/src/main/scala/mlscript/ucs/syntax/source.scala
@@ -8,7 +8,7 @@ import scala.collection.immutable
 package object source {
   sealed abstract class Pattern extends Located {
     override def toString(): String = this match {
-      case AliasPattern(nme, pattern) => s"$nme @ $pattern"
+      case AliasPattern(nme, pattern) => s"${nme.name} @ $pattern"
       case LiteralPattern(literal) => literal.idStr
       case ConcretePattern(nme) => s"`${nme.name}`"
       case NamePattern(nme) => nme.name
diff --git a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
index 9d965bfd5d..9553e0c358 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
@@ -258,7 +258,7 @@ isDigits("bruh")
 
 abstract class ParseResult[out A]: Success[A] | Failure
 class Success[out A](value: A) extends ParseResult[A]
-class Failure(error: Str) extends ParseResult
+class Failure(error: Str) extends ParseResult[nothing]
 //│ abstract class ParseResult[A]: Failure | Success[A]
 //│ class Success[A](value: A) extends ParseResult
 //│ class Failure(error: Str) extends ParseResult
@@ -272,15 +272,15 @@ fun parseExpr(tokens: List[Str]): [ParseResult[Data], List[Str]] =
     Cons("(", tail) then parseList(tail)
     Cons(")", _) then [Failure("Unmatched closing parenthesis."), tokens]
     Cons(token, tail) and
-      isDigits(token) then [Success(Literal(IntLit(parseInt(token, 10)))), tail]
-      else [Success(Symbol(token)), tail]
+      isDigits(token) then [(Success of Literal of IntLit of parseInt(token, 10)), tail]
+      else [(Success of Symbol of token), tail]
     Nil then [Failure("Unexpected end of input, expect either `)` or more tokens."), Nil]
 fun parseList(tokens: List[Str]): [ParseResult[DataList], List[Str]] =
   let rec collect(acc, ts) = if ts is
     Cons(")", tail) then [(Success of DataList of reverse of acc), tail]
     Cons and parseExpr(ts) is
       [Success(data), rest] then collect(data :: acc, rest)
-      [Failure(error), rest] then [Failure(error), rest]
+      [Failure(_) as failure, rest] then [failure, rest]
     Nil then [Failure("Unexpected end of input, expect either `)` or more tokens."), Nil]
   collect(Nil, tokens)
 //│ fun parseExpr: (tokens: List[Str]) -> [ParseResult[Data], List[Str]]
diff --git a/shared/src/test/diff/pretyper/ucs/patterns/AliasPattern.mls b/shared/src/test/diff/pretyper/ucs/patterns/AliasPattern.mls
new file mode 100644
index 0000000000..d18adc4b14
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/patterns/AliasPattern.mls
@@ -0,0 +1,57 @@
+:NewDefs
+
+abstract class Option[out A]
+class Some[out A](val value: A) extends Option[A]
+module None extends Option[nothing]
+//│ abstract class Option[A]
+//│ class Some[A](value: A) extends Option
+//│ module None extends Option
+
+:ducs:postprocess.result
+fun map(f) = case
+  Some(x)   then Some(f(x))
+  None as n then n
+//│ Post-processed UCS term:
+//│ case case$scrut*‡ of
+//│   Some*◊ ->
+//│     let ucs$args_case$scrut$Some*† = (Some).unapply(case$scrut,)
+//│     let x*‡ = (ucs$args_case$scrut$Some).0
+//│     Some(f(x,),)
+//│   None*† ->
+//│     let n*† = case$scrut
+//│     n
+//│ fun map: forall 'a 'A. ('a -> 'A) -> (None | Some['a]) -> (None | Some['A])
+
+:ducs:postprocess.result
+fun map(f) = case
+  Some(x as n) then Some of f(n)
+  None as n then n
+//│ Post-processed UCS term:
+//│ case case$scrut*‡ of
+//│   Some*◊ ->
+//│     let ucs$args_case$scrut$Some*† = (Some).unapply(case$scrut,)
+//│     let x*‡ = (ucs$args_case$scrut$Some).0
+//│     let n*‡ = x
+//│     Some(f(n,),)
+//│   None*† ->
+//│     let n*† = case$scrut
+//│     n
+//│ fun map: forall 'a 'A. ('a -> 'A) -> (None | Some['a]) -> (None | Some['A])
+
+:ducs:postprocess.result
+fun foo = case
+  Some(Some(a as b) as c) as d then [a, b, c, d]
+//│ Post-processed UCS term:
+//│ let d*† = case$scrut
+//│ case case$scrut*‡ of
+//│   Some*◊ ->
+//│     let ucs$args_case$scrut$Some*† = (Some).unapply(case$scrut,)
+//│     let case$scrut$Some_0*‡ = (ucs$args_case$scrut$Some).0
+//│     case case$scrut$Some_0*‡ of
+//│       Some*◊ ->
+//│         let ucs$args_case$scrut$Some_0$Some*† = (Some).unapply(case$scrut$Some_0,)
+//│         let a*‡ = (ucs$args_case$scrut$Some_0$Some).0
+//│         let b*‡ = a
+//│         let c*‡ = case$scrut$Some_0
+//│         [a, b, c, d,]
+//│ fun foo: forall 'A 'a. (Some[Some['A]] & 'a) -> ['A, 'A, Some['A], 'a]

From 357e518afbf97b57cbaebbaf85b9629a628e235d Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 20 Jan 2024 05:18:23 +0800
Subject: [PATCH 091/147] Fix possible chaining of wildcards

---
 .../main/scala/mlscript/ucs/stages/PostProcessing.scala   | 8 +++++++-
 shared/src/test/diff/codegen/NewMatching.mls              | 4 ++--
 shared/src/test/diff/ecoop23/PolymorphicVariants.mls      | 2 +-
 shared/src/test/diff/ecoop23/SimpleRegionDSL_annot.mls    | 2 +-
 shared/src/test/diff/ecoop23/SimpleRegionDSL_raw.mls      | 4 ++--
 shared/src/test/diff/pretyper/ucs/examples/ULC.mls        | 2 +-
 shared/src/test/diff/ucs/Wildcard.mls                     | 8 ++------
 7 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index dfb3485cbb..0195383346 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -47,6 +47,7 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
             case ((N, cases), _) => (N, cases)
           }
         println(s"found ${cases.length} case branches")
+        println(s"default branch: ${default.fold("<empty>")(_.showDbg)}")
         val postProcessedDefault = default.map(postProcess)
         // Assemble a `CaseBranches`.
         val actualFalseBranch = cases.foldRight[CaseBranches](
@@ -65,7 +66,12 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
   }(res => s"postProcess ==> ${res.showDbg}")
 
   private def trimEmptyTerm(term: Term): Opt[Term] = term match {
-    case k @ CaseOf(_, cases) => trimEmptyCaseBranches(cases).map(c => k.copy(cases = c))
+    case k @ CaseOf(_, cases) =>
+      trimEmptyCaseBranches(cases).flatMap(_ match {
+        case cases: Case => S(k.copy(cases = cases))
+        case NoCases => N
+        case Wildcard(body) => S(body)
+      })
     case let @ Let(_, _, _, body) => trimEmptyTerm(body).map(t => let.copy(body = t))
     case _ => S(term)
   }
diff --git a/shared/src/test/diff/codegen/NewMatching.mls b/shared/src/test/diff/codegen/NewMatching.mls
index ea173a88d1..526c280d93 100644
--- a/shared/src/test/diff/codegen/NewMatching.mls
+++ b/shared/src/test/diff/codegen/NewMatching.mls
@@ -31,7 +31,7 @@ fun sum(v) =
     Half(_, x) then x
     None(_) then 0
     _ then -1
-//│ fun sum: (Half | None | Object & ~#Half & ~#None & ~#Pos & ~#V0 & ~#V1 & ~#V2 & ~#V22 | Pos | V0 | V1 | V22 | V2) -> Int
+//│ fun sum: Object -> Int
 //│ // Prelude
 //│ class TypingUnit2 {}
 //│ const typing_unit2 = new TypingUnit2;
@@ -39,7 +39,7 @@ fun sum(v) =
 //│ globalThis.sum = function sum(v) {
 //│   return ((() => {
 //│     let a;
-//│     return a = v, a instanceof V0.class ? 0 : a instanceof V22.class ? ((ucs$args_v$V22) => ((v$V22_0) => ((v$V22_1) => v$V22_0 instanceof V2.class ? ((ucs$args_v$V22_0$V2) => ((x1) => ((y1) => v$V22_1 instanceof V2.class ? ((ucs$args_v$V22_1$V2) => ((x2) => ((y2) => x1 + y1 + x2 + y2)(ucs$args_v$V22_1$V2[1]))(ucs$args_v$V22_1$V2[0]))(V2.unapply(v$V22_1)) : -1)(ucs$args_v$V22_0$V2[1]))(ucs$args_v$V22_0$V2[0]))(V2.unapply(v$V22_0)) : -1)(ucs$args_v$V22[1]))(ucs$args_v$V22[0]))(V22.unapply(v)) : a instanceof V2.class ? ((ucs$args_v$V2) => ((a) => ((b) => a + b)(ucs$args_v$V2[1]))(ucs$args_v$V2[0]))(V2.unapply(v)) : a instanceof V1.class ? ((ucs$args_v$V1) => ((a) => a)(ucs$args_v$V1[0]))(V1.unapply(v)) : a instanceof Pos.class ? ((ucs$args_v$Pos) => ((x) => ((ucs$test$0) => ucs$test$0 === true ? x : -1)(x > 0))(ucs$args_v$Pos[0]))(Pos.unapply(v)) : a instanceof None.class ? 0 : a instanceof Half.class ? ((ucs$args_v$Half) => ((x) => x)(ucs$args_v$Half[1]))(Half.unapply(v)) : (v, v, v, v, v, -1);
+//│     return a = v, a instanceof V0.class ? 0 : a instanceof V22.class ? ((ucs$args_v$V22) => ((v$V22_0) => ((v$V22_1) => v$V22_0 instanceof V2.class ? ((ucs$args_v$V22_0$V2) => ((x1) => ((y1) => v$V22_1 instanceof V2.class ? ((ucs$args_v$V22_1$V2) => ((x2) => ((y2) => x1 + y1 + x2 + y2)(ucs$args_v$V22_1$V2[1]))(ucs$args_v$V22_1$V2[0]))(V2.unapply(v$V22_1)) : -1)(ucs$args_v$V22_0$V2[1]))(ucs$args_v$V22_0$V2[0]))(V2.unapply(v$V22_0)) : -1)(ucs$args_v$V22[1]))(ucs$args_v$V22[0]))(V22.unapply(v)) : a instanceof V2.class ? ((ucs$args_v$V2) => ((a) => ((b) => a + b)(ucs$args_v$V2[1]))(ucs$args_v$V2[0]))(V2.unapply(v)) : a instanceof V1.class ? ((ucs$args_v$V1) => ((a) => a)(ucs$args_v$V1[0]))(V1.unapply(v)) : a instanceof Pos.class ? ((ucs$args_v$Pos) => ((x) => ((ucs$test$0) => ucs$test$0 === true ? x : -1)(x > 0))(ucs$args_v$Pos[0]))(Pos.unapply(v)) : a instanceof None.class ? 0 : a instanceof Half.class ? ((ucs$args_v$Half) => ((x) => x)(ucs$args_v$Half[1]))(Half.unapply(v)) : -1;
 //│   })());
 //│ };
 //│ // End of generated code
diff --git a/shared/src/test/diff/ecoop23/PolymorphicVariants.mls b/shared/src/test/diff/ecoop23/PolymorphicVariants.mls
index 4ca877b149..f2712eed0b 100644
--- a/shared/src/test/diff/ecoop23/PolymorphicVariants.mls
+++ b/shared/src/test/diff/ecoop23/PolymorphicVariants.mls
@@ -206,7 +206,7 @@ module Test3 extends EvalVar, EvalExpr, EvalLambda
 Test3.eval(Cons(["c", Abs("d", Var("d"))], Nil), Abs("a", Var("a")))
 //│ 'a
 //│   where
-//│     'a :> Abs[Var] | Numb | Var | App['a] | Abs['a]
+//│     'a :> App['a] | Abs['a] | Abs[Var] | Numb | Var
 //│ res
 //│     = Abs {}
 
diff --git a/shared/src/test/diff/ecoop23/SimpleRegionDSL_annot.mls b/shared/src/test/diff/ecoop23/SimpleRegionDSL_annot.mls
index deffc2a469..003be4a4ec 100644
--- a/shared/src/test/diff/ecoop23/SimpleRegionDSL_annot.mls
+++ b/shared/src/test/diff/ecoop23/SimpleRegionDSL_annot.mls
@@ -346,7 +346,7 @@ fun mk(n) = if n is
   3 then Intersect(mk(n), mk(n))
   4 then Translate(Vector(0, 0), mk(n))
   _ then Scale(Vector(0, 0), mk(n))
-//│ fun mk: forall 'a. (1 | 2 | 3 | 4 | Object & ~1 & ~2 & ~3 & ~4) -> 'a
+//│ fun mk: forall 'a. Object -> 'a
 //│   where
 //│     'a :> Outside['a] | Translate['a] | Intersect['a] | Union['a] | Scale['a]
 
diff --git a/shared/src/test/diff/ecoop23/SimpleRegionDSL_raw.mls b/shared/src/test/diff/ecoop23/SimpleRegionDSL_raw.mls
index beb482557b..9063a7c405 100644
--- a/shared/src/test/diff/ecoop23/SimpleRegionDSL_raw.mls
+++ b/shared/src/test/diff/ecoop23/SimpleRegionDSL_raw.mls
@@ -325,9 +325,9 @@ fun mk(n) = if n is
   3 then Intersect(mk(n), mk(n))
   4 then Translate(Vector(0, 0), mk(n))
   _ then Scale(Vector(0, 0), mk(n))
-//│ fun mk: forall 'a. (1 | 2 | 3 | 4 | Object & ~1 & ~2 & ~3 & ~4) -> 'a
+//│ fun mk: forall 'a. Object -> 'a
 //│   where
-//│     'a :> Outside['a] | Union['a] | Scale['a] | Translate['a] | Intersect['a]
+//│     'a :> Outside['a] | Translate['a] | Intersect['a] | Union['a] | Scale['a]
 
 :re
 TestElim.eliminate(mk(100))
diff --git a/shared/src/test/diff/pretyper/ucs/examples/ULC.mls b/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
index 18ab746454..89e4d3150c 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/ULC.mls
@@ -236,7 +236,7 @@ fun hasFree(t, x) =
     Abs(Var(_), body) then hasFree(body, x)
     App(lhs, rhs) then hasFree(lhs, x) || hasFree(rhs, x)
     _ then false
-//│ fun hasFree: (Abs | App | Object & ~#Abs & ~#App & ~#Var | Var, Eql[Str]) -> Bool
+//│ fun hasFree: (Object, Eql[Str]) -> Bool
 
 fun showHasFree(t, n) =
   showTerm(t) ++ (if hasFree(t, n) then " has " else " DOES NOT have ") ++ "free variable " ++ n
diff --git a/shared/src/test/diff/ucs/Wildcard.mls b/shared/src/test/diff/ucs/Wildcard.mls
index 3c6f2e8a44..738e8b87a8 100644
--- a/shared/src/test/diff/ucs/Wildcard.mls
+++ b/shared/src/test/diff/ucs/Wildcard.mls
@@ -212,12 +212,8 @@ fun w5(y) =
 //│   Gamma*◊ -> "gamma"
 //│   Delta*◊ -> "delta"
 //│   Beta*◊ -> "beta"
-//│   _ ->
-//│     case y*‡ of
-//│       _ ->
-//│         case y*‡ of
-//│           _ -> "unknown"
-//│ fun w5: (Alpha | Beta | Delta | Gamma | Object & ~#Alpha & ~#Beta & ~#Delta & ~#Gamma) -> ("alpha" | "beta" | "delta" | "gamma" | "unknown")
+//│   _ -> "unknown"
+//│ fun w5: Object -> ("alpha" | "beta" | "delta" | "gamma" | "unknown")
 
 w5(0)
 w5(Alpha())

From 21d40e6b4be4a5aba8c0d7a140d4bb861462ddad Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sun, 21 Jan 2024 00:11:52 +0800
Subject: [PATCH 092/147] Improve post-processing and warning of unreachable
 cases

---
 .../main/scala/mlscript/ucs/Desugarer.scala   | 24 +++---
 .../mlscript/ucs/stages/Normalization.scala   |  8 +-
 .../mlscript/ucs/stages/PostProcessing.scala  | 80 +++++++++++--------
 .../test/diff/pretyper/ucs/RecordPattern.mls  |  4 +-
 .../pretyper/ucs/coverage/Unreachable.mls     |  4 +-
 .../pretyper/ucs/patterns/SimpleTuple.mls     |  8 +-
 shared/src/test/diff/ucs/DirectLines.mls      |  4 +-
 .../src/test/diff/ucs/NuPlainConditionals.mls |  8 +-
 .../src/test/diff/ucs/PlainConditionals.mls   |  8 +-
 shared/src/test/diff/ucs/WeirdIf.mls          | 16 ++--
 shared/src/test/diff/ucs/Wildcard.mls         |  8 +-
 11 files changed, 87 insertions(+), 85 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/Desugarer.scala b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
index 35af9094d2..8c3a7a2128 100644
--- a/shared/src/main/scala/mlscript/ucs/Desugarer.scala
+++ b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
@@ -5,7 +5,7 @@ import syntax.{source => s, core => c}, stages._, context.{Context, Scrutinee}
 import mlscript.ucs.display.{showNormalizedTerm, showSplit}
 import mlscript.pretyper.{PreTyper, Scope}
 import mlscript.pretyper.symbol._
-import mlscript.{If, Loc, Message, Var}, Message.MessageContext, mlscript.Diagnostic
+import mlscript.{If, Loc, Located, Message, Var}, Message.MessageContext, mlscript.Diagnostic
 import mlscript.utils._, shorthands._
 import syntax.core.{Branch, Split}
 
@@ -22,6 +22,14 @@ trait Desugarer extends Transformation
   protected def raiseDesugaringError(messages: (Message -> Opt[Loc])*): Unit =
     raiseError(Diagnostic.Desugaring, messages: _*)
 
+  protected def reportUnreachableCase[T <: Located](unreachable: Located, subsumedBy: T, onlyIf: Bool = true): T = {
+    if (onlyIf) raiseDesugaringWarning(
+      msg"this case is unreachable" -> unreachable.toLoc,
+      msg"because it is subsumed by the branch" -> subsumedBy.toLoc
+    )
+    subsumedBy
+  }
+
   /** A shorthand function to raise _desugaring_ warnings without specifying the source. */
   protected def raiseDesugaringWarning(messages: (Message -> Opt[Loc])*): Unit =
     raiseWarning(Diagnostic.Desugaring, messages: _*)
@@ -153,12 +161,7 @@ trait Desugarer extends Transformation
       if (those === s.Split.Nil) these else (these match {
         case s.Split.Cons(head, tail) => s.Split.Cons(head, tail ++ those)
         case s.Split.Let(rec, nme, rhs, tail) => s.Split.Let(rec, nme, rhs, tail ++ those)
-        case s.Split.Else(_) =>
-          raiseDesugaringWarning(
-            msg"unreachable case" -> those.toLoc,
-            msg"because this branch covers the case" -> these.toLoc
-          )
-          these
+        case s.Split.Else(_) => reportUnreachableCase(those, these)
         case s.Split.Nil => those
       })
   }
@@ -178,12 +181,7 @@ trait Desugarer extends Transformation
       if (those === c.Split.Nil) these else (these match {
         case me: c.Split.Cons => me.copy(tail = me.tail ++ those)
         case me: c.Split.Let => me.copy(tail = me.tail ++ those)
-        case _: c.Split.Else =>
-          raiseDesugaringWarning(
-            msg"the case is unreachable" -> those.toLoc,
-            msg"because this branch covers the case" -> these.toLoc
-          )
-          these
+        case _: c.Split.Else => reportUnreachableCase(those, these)
         case c.Split.Nil => those
       })
   }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 800cebb035..c0e26a4ebd 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -22,13 +22,7 @@ trait Normalization { self: Desugarer with Traceable =>
       shouldReportDiscarded: Bool
   ): Split =
     if (these.hasElse) {
-      if (those =/= Split.Nil && shouldReportDiscarded) {
-        raiseDesugaringWarning(
-          msg"the case is unreachable" -> those.toLoc,
-          msg"because this branch already covers the case" -> these.toLoc
-        )
-      }
-      these
+      reportUnreachableCase(those, these, onlyIf = those =/= Split.Nil && shouldReportDiscarded)
     } else (these match {
       case these @ Split.Cons(head, tail) =>
         these.copy(tail = fillImpl(tail, those))
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index 0195383346..a955e9f240 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -27,24 +27,31 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
         // Post-process the false branch.
         println("FALSE")
         // Get all patterns, except the current one `pat`.
-        val patternList = scrutinee.patternsIterator.filter(!_.matches(pat)).toList
-        println(s"found ${patternList.length} patterns to distentangle: ${patternList.iterator.map(_.showDbg).mkString(", ")}")
-        val (default, cases) = patternList
-          // For each case class name, distangle case branch body terms from the false branch.
+        val patterns = scrutinee.patternsIterator.filter(!_.matches(pat)).toList
+        println(s"found ${patterns.length} patterns to distentangle: ${patterns.iterator.map(_.showDbg).mkString(", ")}")
+        val (default, cases) = patterns
+          // Search each pattern in `falseBranch`. If there exists a branch for
+          // the given pattern, we separate the branch body from the term. The
+          // leftover term will be used in next iteration, until there is no
+          // term left (i.e., `leftoverTerm` is `N`).
           .foldLeft[Opt[Term] -> Ls[(Pattern, Opt[Loc], Term)]](S(falseBranch) -> Nil) {
+            // If the remaining term is not empty, we continue our search.
             case ((S(remainingTerm), cases), pattern) =>
-              println(s"searching for case: ${pattern.showDbg}")
+              println(s"searching for branches of pattern ${pattern.showDbg}")
               val (leftoverTerm, extracted) = disentangleTerm(remainingTerm)(
                 context, scrutineeVar, scrutinee, pattern)
               trimEmptyTerm(leftoverTerm) -> (extracted match {
+                // `remainingTerm` does not have branches for `pattern`.
                 case N =>
-                  println(s"no extracted term about ${pattern.showDbg}")
+                  println(s"cannot extract pattern ${pattern.showDbg}")
                   cases
+                // We extracted a term and it needs to be further post-processed.
                 case terms @ S(extractedTerm) => 
-                  println(s"extracted a term about ${pattern.showDbg}")
+                  println(s"extracted a term of pattern ${pattern.showDbg}")
                   (pattern, pattern.firstOccurrence, postProcess(extractedTerm)) :: cases
               })
-            case ((N, cases), _) => (N, cases)
+            // If no terms are left, we pass on `acc` until the iteration ends.
+            case (acc @ (N, _), _) => acc
           }
         println(s"found ${cases.length} case branches")
         println(s"default branch: ${default.fold("<empty>")(_.showDbg)}")
@@ -58,7 +65,7 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
         // Assemble the final `CaseOf`.
         top.copy(cases = fst.copy(body = processedTrueBranch, rest = actualFalseBranch)
           (refined = fst.refined))
-      // We recursively process the body of as`Let` bindings.
+      // We recursively process the body of `Let` bindings.
       case let @ Let(_, _, _, body) => let.copy(body = postProcess(body))
       // Otherwise, this is not a part of a normalized term.
       case other => println(s"CANNOT post-process ${other.showDbg}"); other
@@ -88,6 +95,10 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
       }
   }
 
+  /**
+    * Merge two optional terms. If both are not empty we will call the other
+    * `mergeTerms`.
+    */
   private def mergeTerms(t1: Opt[Term], t2: Opt[Term]): Opt[Term] =
     (t1, t2) match {
       case (N, N) => N
@@ -96,27 +107,29 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
       case (S(t1), S(t2)) => S(mergeTerms(t1, t2))
     }
 
-  private def mergeTerms(t1: Term, t2: Term): Term =
-    trace(s"mergeTerms <== ${t1.showDbg} ${t2.showDbg}") {
-      t1 match {
-        case t1 @ Let(_, _, _, body) => t1.copy(body = mergeTerms(body, t2))
-        case t1 @ CaseOf(scrutinee: Var, cases) =>
-          t1.copy(cases = mergeTermIntoCaseBranches(t2, cases))
-        case _ =>
-          println(s"CANNOT merge. Discard ${t2.showDbg}.")
-          t1
-      }
+  /**
+    * Merge two terms. In most cases, two terms cannot be merged. This function
+    * replaces `Wildcard` in `t1` with `t2`.
+    */
+  private def mergeTerms(t1: Term, t2: Term): Term = {
+    def recTerm(lhs: Term, rhs: Term): Term = lhs match {
+      case lhs @ Let(_, _, _, body) => lhs.copy(body = mergeTerms(body, rhs))
+      case lhs @ CaseOf(scrutinee: Var, cases) =>
+        lhs.copy(cases = recCaseBranches(cases, rhs))
+      case _ => reportUnreachableCase(rhs, lhs)
+    }
+    def recCaseBranches(lhs: CaseBranches, rhs: Term): CaseBranches = lhs match {
+      case NoCases => Wildcard(rhs).withLocOf(rhs)
+      case Wildcard(body) => Wildcard(mergeTerms(body, rhs))
+      case lhs @ Case(_, _, rest) =>
+        lhs.copy(rest = recCaseBranches(rest, rhs))(refined = lhs.refined)
+    }
+    trace(s"mergeTerms <==") {
+      println(s"LHS: ${t1.showDbg}")
+      println(s"RHS: ${t2.showDbg}")
+      recTerm(t1, t2)
     }(merged => s"mergedTerms ==> ${merged.showDbg}")
-
-  private def mergeTermIntoCaseBranches(term: Term, cases: CaseBranches): CaseBranches =
-    trace(s"mergeTermIntoCaseBranches <== ${term.describe} ${cases}") {
-      cases match {
-        case NoCases => Wildcard(term).withLocOf(term)
-        case Wildcard(body) => Wildcard(mergeTerms(body, term))
-        case cases @ Case(_, _, rest) =>
-          cases.copy(rest = mergeTermIntoCaseBranches(term, rest))(refined = cases.refined)
-      }
-    }()
+  }
 
   /**
     * Disentangle case branches that match `scrutinee` against `className` from `term`.
@@ -160,7 +173,9 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
     }({ case (n, y) => s"disentangleTerm ==> `${n.showDbg}` and `${y.fold("<empty>")(_.showDbg)}`" })
   }
 
-  /** Helper function for `disentangleTerm`. */
+  /**
+    * Helper function for `disentangleTerm`.
+    */
   private def disentangleMatchedCaseBranches(cases: CaseBranches)(implicit
       context: Context,
       scrutineeVar: Var,
@@ -184,7 +199,6 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
         }
     }
 
-
   /** Helper function for `disentangleTerm`. */
   private def disentangleUnmatchedCaseBranches(cases: CaseBranches)(implicit
       context: Context,
@@ -210,10 +224,6 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
 }
 
 object PostProcessing {
-  class PostProcessingException(val messages: Ls[Message -> Opt[Loc]]) extends Throwable {
-    def this(message: Message, location: Opt[Loc]) = this(message -> location :: Nil)
-  }
-
   private object typeSymbolOrdering extends Ordering[TypeSymbol] {
     override def compare(x: TypeSymbol, y: TypeSymbol): Int = {
       (x.defn.toLoc, y.defn.toLoc) match {
diff --git a/shared/src/test/diff/pretyper/ucs/RecordPattern.mls b/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
index dead7496bd..68f99b1b5a 100644
--- a/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
+++ b/shared/src/test/diff/pretyper/ucs/RecordPattern.mls
@@ -9,10 +9,10 @@ fun take_1(p) =
 //│ ╔══[ERROR] unknown pattern '{' {x: x, y: y} '}'
 //│ ║  l.7: 	    { x, y } then x + y
 //│ ╙──     	    ^^^^^^^^
-//│ ╔══[WARNING] the case is unreachable
+//│ ╔══[WARNING] this case is unreachable
 //│ ║  l.8: 	    else 0
 //│ ║       	         ^
-//│ ╟── because this branch covers the case
+//│ ╟── because it is subsumed by the branch
 //│ ║  l.7: 	    { x, y } then x + y
 //│ ╙──     	                  ^^^^^
 //│ ╔══[ERROR] identifier not found: x
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls b/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
index 6b3df49e71..ecf896c44e 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/Unreachable.mls
@@ -49,7 +49,7 @@ fun unreachable_1(x) =
       else "screen"
     Some(xv) then "sin"
     None then "tan"
-//│ ╔══[WARNING] the case is unreachable
+//│ ╔══[WARNING] this case is unreachable
 //│ ║  l.46: 	  if x is
 //│ ║        	     ^^^^
 //│ ║  l.47: 	    _ and
@@ -62,7 +62,7 @@ fun unreachable_1(x) =
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^
 //│ ║  l.51: 	    None then "tan"
 //│ ║        	^^^^^^^^^^^^^^^^^^^
-//│ ╟── because this branch covers the case
+//│ ╟── because it is subsumed by the branch
 //│ ║  l.49: 	      else "screen"
 //│ ╙──      	           ^^^^^^^^
 //│ fun unreachable_1: (Object & ~#Some | Some[Eql[1]]) -> ("screen" | "tmux")
diff --git a/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls b/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls
index 0a0144e3d5..57d37d53cd 100644
--- a/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls
+++ b/shared/src/test/diff/pretyper/ucs/patterns/SimpleTuple.mls
@@ -47,14 +47,14 @@ fun discarded_cases(thing) =
   if thing is
     [x, y] then x + y
     Point(x, y) then x + y
-//│ ╔══[WARNING] the case is unreachable
+//│ ╔══[WARNING] this case is unreachable
 //│ ║  l.47: 	  if thing is
 //│ ║        	     ^^^^^^^^
 //│ ║  l.48: 	    [x, y] then x + y
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^
 //│ ║  l.49: 	    Point(x, y) then x + y
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╟── because this branch covers the case
+//│ ╟── because it is subsumed by the branch
 //│ ║  l.48: 	    [x, y] then x + y
 //│ ╙──      	                ^^^^^
 //│ class Point(x: Int, y: Int)
@@ -111,10 +111,10 @@ fun not_working(x) =
       a + b + c
     else
       0
-//│ ╔══[WARNING] the case is unreachable
+//│ ╔══[WARNING] this case is unreachable
 //│ ║  l.113: 	      0
 //│ ║         	      ^
-//│ ╟── because this branch covers the case
+//│ ╟── because it is subsumed by the branch
 //│ ║  l.111: 	      a + b + c
 //│ ╙──       	      ^^^^^^^^^
 //│ fun not_working: {0: Int, 1: Int, 2: Int} -> Int
diff --git a/shared/src/test/diff/ucs/DirectLines.mls b/shared/src/test/diff/ucs/DirectLines.mls
index a04684371e..5028b2caa3 100644
--- a/shared/src/test/diff/ucs/DirectLines.mls
+++ b/shared/src/test/diff/ucs/DirectLines.mls
@@ -46,10 +46,10 @@ fun f(a, b) =
       2 then 2
       _ then 7
     else 3
-//│ ╔══[WARNING] the case is unreachable
+//│ ╔══[WARNING] this case is unreachable
 //│ ║  l.48: 	    else 3
 //│ ║        	         ^
-//│ ╟── because this branch covers the case
+//│ ╟── because it is subsumed by the branch
 //│ ║  l.47: 	      _ then 7
 //│ ╙──      	             ^
 //│ fun f: (Num, Num) -> (0 | 1 | 2 | 7)
diff --git a/shared/src/test/diff/ucs/NuPlainConditionals.mls b/shared/src/test/diff/ucs/NuPlainConditionals.mls
index 299655c68a..4f24071e8e 100644
--- a/shared/src/test/diff/ucs/NuPlainConditionals.mls
+++ b/shared/src/test/diff/ucs/NuPlainConditionals.mls
@@ -58,8 +58,8 @@ fun foo(x) = x is
 //│ ║        	  ^^^^
 //│ ║  l.55: 	  Int
 //│ ╙──      	^^^^^
-//│ ╔══[WARNING] the case is unreachable
-//│ ╙── because this branch covers the case
+//│ ╔══[WARNING] this case is unreachable
+//│ ╙── because it is subsumed by the branch
 //│ fun foo: anything -> true
 
 // TODO proper error
@@ -71,8 +71,8 @@ fun foo(x) = x is
 //│ ║        	  ^^^^^^^^^^^^^^^^^^^^
 //│ ║  l.68: 	  Int
 //│ ╙──      	^^^^^
-//│ ╔══[WARNING] the case is unreachable
-//│ ╙── because this branch covers the case
+//│ ╔══[WARNING] this case is unreachable
+//│ ╙── because it is subsumed by the branch
 //│ fun foo: anything -> true
 
 // TODO support `|`
diff --git a/shared/src/test/diff/ucs/PlainConditionals.mls b/shared/src/test/diff/ucs/PlainConditionals.mls
index 7dc3b959c3..56fdc6d1e6 100644
--- a/shared/src/test/diff/ucs/PlainConditionals.mls
+++ b/shared/src/test/diff/ucs/PlainConditionals.mls
@@ -58,8 +58,8 @@ fun foo(x) = x is
 //│ ║        	  ^^^^
 //│ ║  l.55: 	  Int
 //│ ╙──      	^^^^^
-//│ ╔══[WARNING] the case is unreachable
-//│ ╙── because this branch covers the case
+//│ ╔══[WARNING] this case is unreachable
+//│ ╙── because it is subsumed by the branch
 //│ fun foo: anything -> true
 
 // TODO proper error
@@ -71,8 +71,8 @@ fun foo(x) = x is
 //│ ║        	  ^^^^^^^^^^^^^^^^^^^^
 //│ ║  l.68: 	  Int
 //│ ╙──      	^^^^^
-//│ ╔══[WARNING] the case is unreachable
-//│ ╙── because this branch covers the case
+//│ ╔══[WARNING] this case is unreachable
+//│ ╙── because it is subsumed by the branch
 //│ fun foo: anything -> true
 
 // TODO support `|`
diff --git a/shared/src/test/diff/ucs/WeirdIf.mls b/shared/src/test/diff/ucs/WeirdIf.mls
index 1f34f67b96..bfb09a65a5 100644
--- a/shared/src/test/diff/ucs/WeirdIf.mls
+++ b/shared/src/test/diff/ucs/WeirdIf.mls
@@ -5,16 +5,16 @@ if
   _ then 0
   else 0
 else 1
-//│ ╔══[WARNING] unreachable case
+//│ ╔══[WARNING] this case is unreachable
 //│ ║  l.6: 	  else 0
 //│ ║       	       ^
-//│ ╟── because this branch covers the case
+//│ ╟── because it is subsumed by the branch
 //│ ║  l.5: 	  _ then 0
 //│ ╙──     	         ^
-//│ ╔══[WARNING] unreachable case
+//│ ╔══[WARNING] this case is unreachable
 //│ ║  l.7: 	else 1
 //│ ║       	     ^
-//│ ╟── because this branch covers the case
+//│ ╟── because it is subsumed by the branch
 //│ ║  l.5: 	  _ then 0
 //│ ╙──     	         ^
 //│ 0
@@ -23,10 +23,10 @@ else 1
 
 :w
 if else 0 else 1
-//│ ╔══[WARNING] unreachable case
+//│ ╔══[WARNING] this case is unreachable
 //│ ║  l.25: 	if else 0 else 1
 //│ ║        	               ^
-//│ ╟── because this branch covers the case
+//│ ╟── because it is subsumed by the branch
 //│ ║  l.25: 	if else 0 else 1
 //│ ╙──      	        ^
 //│ 0
@@ -35,10 +35,10 @@ if else 0 else 1
 
 :w
 fun f(x) = if x is else 0 else 1
-//│ ╔══[WARNING] the case is unreachable
+//│ ╔══[WARNING] this case is unreachable
 //│ ║  l.37: 	fun f(x) = if x is else 0 else 1
 //│ ║        	                               ^
-//│ ╟── because this branch covers the case
+//│ ╟── because it is subsumed by the branch
 //│ ║  l.37: 	fun f(x) = if x is else 0 else 1
 //│ ╙──      	                        ^
 //│ fun f: anything -> 0
diff --git a/shared/src/test/diff/ucs/Wildcard.mls b/shared/src/test/diff/ucs/Wildcard.mls
index 738e8b87a8..5dc4fa10da 100644
--- a/shared/src/test/diff/ucs/Wildcard.mls
+++ b/shared/src/test/diff/ucs/Wildcard.mls
@@ -107,10 +107,10 @@ w3(0, _ => false)
 // +  => 1
 fun w3_1(x, f) =
   if f(x) is _ then 0 else 1
-//│ ╔══[WARNING] the case is unreachable
+//│ ╔══[WARNING] this case is unreachable
 //│ ║  l.109: 	  if f(x) is _ then 0 else 1
 //│ ║         	                           ^
-//│ ╟── because this branch covers the case
+//│ ╟── because it is subsumed by the branch
 //│ ║  l.109: 	  if f(x) is _ then 0 else 1
 //│ ╙──       	                    ^
 //│ fun w3_1: forall 'a. ('a, 'a -> anything) -> 0
@@ -126,10 +126,10 @@ w3_1(0, _ => false)
 :w
 fun w3_1_1(x, f) =
   if f(x) is a then a else 0
-//│ ╔══[WARNING] the case is unreachable
+//│ ╔══[WARNING] this case is unreachable
 //│ ║  l.128: 	  if f(x) is a then a else 0
 //│ ║         	                           ^
-//│ ╟── because this branch already covers the case
+//│ ╟── because it is subsumed by the branch
 //│ ║  l.128: 	  if f(x) is a then a else 0
 //│ ╙──       	                    ^
 //│ fun w3_1_1: forall 'a 'b. ('a, 'a -> 'b) -> 'b

From 9dc3e1cfb6566d726b5e856e1213e950170ca18b Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sun, 21 Jan 2024 02:55:23 +0800
Subject: [PATCH 093/147] Support parsing `else` and `_ then` in `IfOpsApp`

---
 .../src/main/scala/mlscript/NewParser.scala   | 33 ++++++++--
 shared/src/test/diff/parser/IfThenElse.mls    |  2 +-
 .../ucs/examples/BinarySearchTree.mls         |  7 +-
 shared/src/test/diff/ucs/LeadingAnd.mls       |  2 +-
 shared/src/test/diff/ucs/ParseFailures.mls    | 64 +++++++++----------
 shared/src/test/diff/ucs/ParserFailures.mls   | 32 +++++++++-
 6 files changed, 92 insertions(+), 48 deletions(-)

diff --git a/shared/src/main/scala/mlscript/NewParser.scala b/shared/src/main/scala/mlscript/NewParser.scala
index 90926da3ce..c302824b4a 100644
--- a/shared/src/main/scala/mlscript/NewParser.scala
+++ b/shared/src/main/scala/mlscript/NewParser.scala
@@ -1058,14 +1058,26 @@ abstract class NewParser(origin: Origin, tokens: Ls[Stroken -> Loc], newDefs: Bo
               R(res)
           }
         case L(rhs) =>
-          L(IfOpsApp(acc, opIfBlock(opv -> rhs :: Nil)))
+          val (opsRhss, els) = opIfBlock(opv -> rhs :: Nil)
+          val opsApp = IfOpsApp(acc, opsRhss)
+          L(els.fold[IfBody](opsApp)(trm => IfBlock(L(opsApp) :: L(IfElse(trm)) :: Nil)))
       }
   }
-  final def opIfBlock(acc: Ls[Var -> IfBody])(implicit et: ExpectThen, fe: FoundErr): Ls[Var -> IfBody] = wrap(acc) { l =>
+  final def opIfBlock(acc: Ls[Var -> IfBody])(implicit et: ExpectThen, fe: FoundErr): (Ls[Var -> IfBody], Opt[Term]) = wrap(acc) { l =>
       cur match {
         case (NEWLINE, _) :: c => // TODO allow let bindings...
           consume
           c match {
+            case (IDENT("_", false), wcLoc) :: _ =>
+              exprOrIf(0) match {
+                case R(rhs) =>
+                  err(msg"expect an operator branch" -> S(wcLoc) :: Nil)
+                  (acc.reverse, N)
+                case L(IfThen(_, els)) => (acc.reverse, S(els))
+                case L(rhs) =>
+                  err(msg"expect 'then' after the wildcard" -> rhs.toLoc :: Nil)
+                  (acc.reverse, N)
+              }
             case (IDENT(opStr2, true), opLoc2) :: _ =>
               consume
               val rhs = exprOrIf(0)
@@ -1075,12 +1087,23 @@ abstract class NewParser(origin: Origin, tokens: Ls[Stroken -> Loc], newDefs: Bo
                 case L(rhs) =>
                   opIfBlock(Var(opStr2).withLoc(S(opLoc2)) -> rhs :: acc)
               }
-            case _ =>
+            case (KEYWORD("else"), elseLoc) :: tail =>
+              consume
+              exprOrIf(0) match {
+                case R(rhs) => (acc.reverse, S(rhs))
+                case L(rhs) =>
+                  err(msg"expect a term" -> rhs.toLoc :: Nil)
+                  (acc.reverse, N)
+              }
+            case (_, headLoc) :: _ =>
               // printDbg(c)
-              ???
+              err(msg"expect an operator" -> S(headLoc) :: Nil)
+              (acc.reverse, N)
+            case Nil =>
+              (acc.reverse, N)
           }
         case _ =>
-          acc.reverse
+          (acc.reverse, N)
       }
   }
   
diff --git a/shared/src/test/diff/parser/IfThenElse.mls b/shared/src/test/diff/parser/IfThenElse.mls
index 7255013bc7..32633f8b2c 100644
--- a/shared/src/test/diff/parser/IfThenElse.mls
+++ b/shared/src/test/diff/parser/IfThenElse.mls
@@ -128,7 +128,7 @@ if a
   == 1 then "true"
   _    then "true"
 //│ |#if| |a|→|>| |0| |#then| |"false"|↵|==| |1| |#then| |"true"|↵|_| |#then| |"true"|←|
-//│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing
+//│ Parsed: {if ‹a ‹· > (0) then "false"; · == (1) then "true"›; else "true"›}
 
 if a ==
   0 then "false"
diff --git a/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls b/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls
index 65d70f8c81..16f5d3b58a 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/BinarySearchTree.mls
@@ -85,14 +85,13 @@ fun insert(t, v) = if t is
   Empty then Node(v, Empty, Empty)
 //│ fun insert: forall 'A. (Empty | Node[Num & 'A], Num & 'A) -> (Node[nothing] | Node['A])
 
-// FIXME
 fun insert'(t, v) = if t is
   Node(v', l, r) and v
     < v' then Node(v', insert(l, v), r)
     > v' then Node(v', l, insert(r, v))
     else t
   Empty then Node(v, Empty, Empty)
-//│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing
+//│ fun insert': forall 'A. (Empty | Node[Num & 'A], Num & 'A) -> (Node[nothing] | Node['A])
 
 insert(Empty, 0) |> show
 insert(Node(0, Empty, Empty), 0) |> show
@@ -356,9 +355,9 @@ fun extractMin(t) =
       extractMin(l) is Pair(m, l') then
         Pair(m, Node(v, l', r))
     Empty then Pair(None, Empty)
-//│ fun extractMin: forall 'A 'A0 'B 'T 'A1. (Empty | Node['A0 & 'T & 'A1]) -> Pair[in 'A out 'A | None, in Tree['A1] & 'B out Empty | 'B | Node['A1] | Tree['A0]]
+//│ fun extractMin: forall 'A 'B 'T 'A0 'A1. (Empty | Node['A1 & 'T & 'A]) -> Pair[in 'A0 out 'A0 | None, in Tree['A] & 'B out Empty | 'B | Node['A] | Tree['A1]]
 //│   where
-//│     'A :> None | Some['T]
+//│     'A0 :> None | Some['T]
 
 extractMin(example1).first ?? "not found"
 extractMin(example1).second |> show
diff --git a/shared/src/test/diff/ucs/LeadingAnd.mls b/shared/src/test/diff/ucs/LeadingAnd.mls
index d25af76465..8df970fa0c 100644
--- a/shared/src/test/diff/ucs/LeadingAnd.mls
+++ b/shared/src/test/diff/ucs/LeadingAnd.mls
@@ -30,5 +30,5 @@ fun f(a, b) = if a is
   Some(av)
     and b is Some(bv) then av + bv
     
-//│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing
+//│ fun f: (Some[Int], Some[Int]) -> Int
 
diff --git a/shared/src/test/diff/ucs/ParseFailures.mls b/shared/src/test/diff/ucs/ParseFailures.mls
index 3d1e101486..6ff6af0953 100644
--- a/shared/src/test/diff/ucs/ParseFailures.mls
+++ b/shared/src/test/diff/ucs/ParseFailures.mls
@@ -1,45 +1,39 @@
 :NewDefs
 :NoJS
 
-// FIXME
 type Tree[A] = Node[A] | Empty
-module Empty {
-  fun contains(wanted) = false
-}
-class Node[A](value: int, left: Tree[A], right: Tree[A]) {
-  fun contains(wanted) = if wanted
-    <= value then left.find(wanted)
-    >= value then right.find(wanted)
-    else true
-}
-//│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing
+module Empty
+class Node[A](value: Int, left: Tree[A], right: Tree[A])
+//│ type Tree[A] = Empty | Node[A]
+//│ module Empty
+//│ class Node[A](value: Int, left: Tree[A], right: Tree[A])
 
-// FIXME
-type Tree[A] = Node[A] | Empty
-module Empty {
-  fun contains(wanted) = false
-}
-class Node[A](value: int, left: Tree[A], right: Tree[A]) {
-  fun contains(wanted) = if wanted
-    <= value then left.find(wanted)
-    >= value then right.find(wanted)
-    _ true
-}
-//│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing
+fun contains(node, wanted) =
+  if node is
+    Node(value, left, right) and wanted
+      <= value then contains(left, wanted)
+      >= value then contains(right, wanted)
+      else true
+    Empty then false
+//│ fun contains: forall 'A. (Empty | Node['A], Num) -> Bool
+
+fun contains'(node, wanted) =
+  if node is
+    Node(value, left, right) and wanted
+      <= value then contains'(left, wanted)
+      >= value then contains'(right, wanted)
+      _ then true
+    Empty then false
+//│ fun contains': forall 'A. (Empty | Node['A], Num) -> Bool
 
-// FIXME
+:pe
+class Z()
+class O()
 fun foo(x, y) = if x is
   Z() and y is O() then 0 else 1
 //│ ╔══[PARSE ERROR] Unexpected 'else' keyword here
-//│ ║  l.32: 	  Z() and y is O() then 0 else 1
+//│ ║  l.33: 	  Z() and y is O() then 0 else 1
 //│ ╙──      	                          ^^^^
-//│ ╔══[ERROR] type identifier `Z` not found
-//│ ║  l.32: 	  Z() and y is O() then 0 else 1
-//│ ╙──      	  ^
-//│ ╔══[ERROR] type identifier `O` not found
-//│ ║  l.32: 	  Z() and y is O() then 0 else 1
-//│ ╙──      	               ^
-//│ ╔══[ERROR] type identifier not found: Z
-//│ ║  l.32: 	  Z() and y is O() then 0 else 1
-//│ ╙──      	  ^
-//│ fun foo: (nothing, anything) -> error
+//│ class Z()
+//│ class O()
+//│ fun foo: (Z, O) -> 0
diff --git a/shared/src/test/diff/ucs/ParserFailures.mls b/shared/src/test/diff/ucs/ParserFailures.mls
index fca068c589..8cad1cc315 100644
--- a/shared/src/test/diff/ucs/ParserFailures.mls
+++ b/shared/src/test/diff/ucs/ParserFailures.mls
@@ -6,7 +6,23 @@ if x
   == 0 then "bad"
   let y = f(z)
   == y * y then 0
-//│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing
+//│ ╔══[PARSE ERROR] expect an operator
+//│ ║  l.7: 	  let y = f(z)
+//│ ╙──     	  ^^^
+//│ ╔══[PARSE ERROR] Unexpected 'let' keyword here
+//│ ║  l.7: 	  let y = f(z)
+//│ ╙──     	  ^^^
+//│ ╔══[ERROR] missing else branch
+//│ ║  l.6: 	  == 0 then "bad"
+//│ ╙──     	            ^^^^^
+//│ ╔══[ERROR] identifier not found: x
+//│ ║  l.5: 	if x
+//│ ╙──     	   ^
+//│ ╔══[ERROR] Type mismatch in `case` expression:
+//│ ║  l.6: 	  == 0 then "bad"
+//│ ║       	            ^^^^^
+//│ ╙── expression of type `Bool` is not an instance of type `true`
+//│ "bad"
 
 // FIXME: Interleaved let bindings are not implemented in `IfOpsApp`.
 fun tt(x) =
@@ -14,5 +30,17 @@ fun tt(x) =
     is A() then "A"
     let y = 0
     is B() then "B"
-//│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing
+//│ ╔══[PARSE ERROR] expect an operator
+//│ ║  l.31: 	    let y = 0
+//│ ╙──      	    ^^^
+//│ ╔══[PARSE ERROR] Unexpected 'let' keyword here
+//│ ║  l.31: 	    let y = 0
+//│ ╙──      	    ^^^
+//│ ╔══[ERROR] type identifier `A` not found
+//│ ║  l.30: 	    is A() then "A"
+//│ ╙──      	       ^
+//│ ╔══[ERROR] type identifier not found: A
+//│ ║  l.30: 	    is A() then "A"
+//│ ╙──      	       ^
+//│ fun tt: nothing -> error
 

From 1cbe59f7e07d27808dc3a413b5572239dea69767 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sun, 21 Jan 2024 03:18:25 +0800
Subject: [PATCH 094/147] Improve the implementation of `freeVars`

---
 shared/src/main/scala/mlscript/helpers.scala | 64 +++++++++++++++-----
 1 file changed, 50 insertions(+), 14 deletions(-)

diff --git a/shared/src/main/scala/mlscript/helpers.scala b/shared/src/main/scala/mlscript/helpers.scala
index 8d9d2578a7..01936a8e0c 100644
--- a/shared/src/main/scala/mlscript/helpers.scala
+++ b/shared/src/main/scala/mlscript/helpers.scala
@@ -802,21 +802,57 @@ trait FieldImpl extends Located { self: Field =>
 trait Located {
   def children: List[Located]
   
-  lazy val freeVars: Set[Var] = this match {
-    case v: Var => Set.single(v)
-    case Sel(receiver, _) => receiver.freeVars
-    case Let(true, nme, rhs, body) => body.freeVars ++ rhs.freeVars - nme
-    case Let(false, nme, rhs, body) => body.freeVars - nme ++ rhs.freeVars
-    case Lam(tup: Tup, body) => body.freeVars -- tup.freeVars
-    case Tup(fields) => fields.iterator.flatMap(_._2.value.freeVars.iterator).toSet
-    case Blk(stmts) => stmts.iterator.foldRight(Set.empty[Var]) {
-      case (NuFunDef(isLetRec, nme, _, _, L(rhs)), fvs) => fvs - nme ++ (isLetRec match {
-        case N | S(true) => rhs.freeVars - nme
-        case S(false) => rhs.freeVars
-      })
-      case (statement, fvs) => fvs ++ statement.freeVars
+  lazy val freeVars: Set[Var] = {
+    def statements(stmts: Ls[Statement]): Set[Var] =
+      stmts.iterator.foldRight(Set.empty[Var]) {
+        case (NuFunDef(isLetRec, nme, _, _, L(rhs)), fvs) => fvs - nme ++ (isLetRec match {
+          case N | S(true) => rhs.freeVars - nme
+          case S(false) => rhs.freeVars
+        })
+        case (td: NuTypeDef, fvs) =>
+          if (td.kind === Mod || td.kind === Cls || td.kind === Trt)
+            fvs - td.nameVar
+          else
+            fvs
+        case (statement, fvs) => fvs ++ statement.freeVars
+      }
+    this match {
+      // TypingUnit
+      case TypingUnit(entities) => statements(entities)
+      // Terms
+      case v: Var => Set.single(v)
+      case Lam(tup: Tup, body) => body.freeVars -- tup.freeVars
+      case App(lhs, rhs) => lhs.freeVars ++ rhs.freeVars
+      case Tup(fields) => fields.iterator.flatMap(_._2.value.freeVars.iterator).toSet
+      case Rcd(fields) => fields.iterator.flatMap(_._2.value.freeVars.iterator).toSet
+      case Sel(receiver, _) => receiver.freeVars
+      case Let(true, nme, rhs, body) => body.freeVars ++ rhs.freeVars - nme
+      case Let(false, nme, rhs, body) => body.freeVars - nme ++ rhs.freeVars
+      case Blk(stmts) => statements(stmts)
+      case Bra(_, trm) => trm.freeVars
+      case Asc(trm, _) => trm.freeVars
+      case Bind(lhs, rhs) => lhs.freeVars ++ rhs.freeVars
+      case Test(trm, _) => trm.freeVars
+      case With(trm, fields) => trm.freeVars ++ fields.freeVars
+      case CaseOf(trm, cases) => cases.foldLeft(trm.freeVars)(_ ++ _._2.freeVars)(_ ++ _.fold(Set.empty[Var])(_.freeVars))
+      case Subs(arr, idx) => arr.freeVars ++ idx.freeVars
+      case Assign(lhs, rhs) => lhs.freeVars ++ rhs.freeVars
+      case Splc(fields) => fields.iterator.flatMap(_.fold(_.freeVars, _.value.freeVars)).toSet
+      case New(head, body) => head.fold(Set.empty[Var])(_._2.freeVars) ++ body.freeVars
+      case NuNew(cls) => cls.freeVars
+      // Because `IfBody` uses the term to represent the pattern, direct
+      // traversal is not correct.
+      case If(_, _) => Set.empty
+      case TyApp(lhs, _) => lhs.freeVars
+      case Where(body, where) => body.freeVars ++ statements(where)
+      case Forall(_, body) => body.freeVars
+      case Inst(body) => body.freeVars
+      case Super() => Set.empty
+      case Eqn(lhs, rhs) => lhs.freeVars ++ rhs.freeVars
+      case Rft(base, decls) => base.freeVars ++ decls.freeVars
+      // Fallback for unsupported terms which is incorrect most of the time.
+      case _ => children.iterator.flatMap(_.freeVars.iterator).toSet
     }
-    case _ => children.iterator.flatMap(_.freeVars.iterator).toSet
   }
   
   private var spanStart: Int = -1

From 4e977d36cb1ef761f035b5ddeb1c028247ebaff9 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sun, 21 Jan 2024 03:29:50 +0800
Subject: [PATCH 095/147] Warn if an outer binding is shadowed by a top-level
 name pattern

---
 .../main/scala/mlscript/pretyper/Symbol.scala    | 12 +++++++++++-
 .../scala/mlscript/ucs/stages/Desugaring.scala   | 12 ++++++++++++
 shared/src/test/diff/nu/BadUCS.mls               | 16 +++++++++++-----
 shared/src/test/diff/ucs/HygienicBindings.mls    | 14 ++++++++++++++
 4 files changed, 48 insertions(+), 6 deletions(-)

diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index 9ef593ee18..3e3785fffc 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -78,13 +78,19 @@ package object symbol {
 
   final class ModuleSymbol(override val defn: NuTypeDef) extends TypeSymbol with TermSymbol {
     require(defn.kind === Mod)
+
+    override def nameVar: Var = defn.nameVar
   }
 
-  sealed trait TermSymbol extends Symbol with Matchable
+  sealed trait TermSymbol extends Symbol with Matchable {
+    def nameVar: Var
+  }
 
   class DefinedTermSymbol(val defn: NuFunDef) extends TermSymbol {
     override def name: Str = defn.name
 
+    override def nameVar: Var = defn.nme
+
     def body: Term \/ Type = defn.rhs
 
     def isFunction: Bool = defn.isLetRec.isEmpty
@@ -94,9 +100,13 @@ package object symbol {
     def isDeclaration: Bool = defn.rhs.isRight
 
     def operatorAlias: Opt[Var] = defn.symbolicNme
+
+    def declaredLoc: Opt[Loc] = defn.nme.toLoc
   }
 
   class LocalTermSymbol(val nme: Var) extends TermSymbol {
     override def name: Str = nme.name
+
+    override def nameVar: Var = nme
   }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 8b89f5edd4..5f8ecf7190 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -388,6 +388,18 @@ trait Desugaring { self: PreTyper =>
           case s.EmptyPattern(_) | s.NamePattern(Var("_")) =>
             desugarRight ++ desugarTail
           case s.NamePattern(nme) =>
+            // If the top-level pattern is a name pattern, we need to check if
+            // `nme` shadows any variables in the scope. For example, code
+            // `fun f(x, y) = if x is y then "yes" else "no"` may read like
+            // `if x === y then "yes" else "no"`.
+            scope.getTermSymbol(nme.name) match {
+              case S(shadowed) =>
+                raiseDesugaringWarning(
+                  msg"the outer binding `${nme.name}`" -> shadowed.nameVar.toLoc,
+                  msg"is shadowed by inner binding `${nme.name}`" -> nme.toLoc
+                )
+              case N => ()
+            }
             val symbol = freshSymbol(nme).withScrutinee(scrutinee)
             val scopeWithSymbol = scope + symbol
             c.Branch(scrutineeVar, c.Pattern.Name(nme.withSymbol(symbol)),
diff --git a/shared/src/test/diff/nu/BadUCS.mls b/shared/src/test/diff/nu/BadUCS.mls
index d5bd9333b0..6a176b3c7a 100644
--- a/shared/src/test/diff/nu/BadUCS.mls
+++ b/shared/src/test/diff/nu/BadUCS.mls
@@ -95,8 +95,14 @@ fun foo(x) = if x is M() then 0
 //│ Code generation encountered an error:
 //│   unknown match case: M
 
-
+:w
 fun foo0(x, y) = if x is y then 0
+//│ ╔══[WARNING] the outer binding `y`
+//│ ║  l.99: 	fun foo0(x, y) = if x is y then 0
+//│ ║        	            ^
+//│ ╟── is shadowed by inner binding `y`
+//│ ║  l.99: 	fun foo0(x, y) = if x is y then 0
+//│ ╙──      	                         ^
 //│ fun foo0: (anything, anything) -> 0
 
 
@@ -107,10 +113,10 @@ fun foo = 0
 :ge
 fun foo0(x) = if x is foo() then 0
 //│ ╔══[ERROR] type identifier `foo` not found
-//│ ║  l.108: 	fun foo0(x) = if x is foo() then 0
+//│ ║  l.114: 	fun foo0(x) = if x is foo() then 0
 //│ ╙──       	                      ^^^
 //│ ╔══[ERROR] can only match on classes and traits
-//│ ║  l.108: 	fun foo0(x) = if x is foo() then 0
+//│ ║  l.114: 	fun foo0(x) = if x is foo() then 0
 //│ ╙──       	                      ^^^
 //│ fun foo0: nothing -> error
 //│ Code generation encountered an error:
@@ -121,10 +127,10 @@ fun foo0(x) = if x is foo() then 0
 // FIXME: Typer.scala:1497
 fun foo(x) = if x is foo() then 0
 //│ ╔══[ERROR] type identifier `foo` not found
-//│ ║  l.122: 	fun foo(x) = if x is foo() then 0
+//│ ║  l.128: 	fun foo(x) = if x is foo() then 0
 //│ ╙──       	                     ^^^
 //│ ╔══[ERROR] can only match on classes and traits
-//│ ║  l.122: 	fun foo(x) = if x is foo() then 0
+//│ ║  l.128: 	fun foo(x) = if x is foo() then 0
 //│ ╙──       	                     ^^^
 //│ /!!!\ Uncaught error: java.lang.Exception: Internal Error: Program reached and unexpected state.
 
diff --git a/shared/src/test/diff/ucs/HygienicBindings.mls b/shared/src/test/diff/ucs/HygienicBindings.mls
index 60bbe08556..56a1ae4023 100644
--- a/shared/src/test/diff/ucs/HygienicBindings.mls
+++ b/shared/src/test/diff/ucs/HygienicBindings.mls
@@ -93,6 +93,7 @@ fun h2(a) =
 //│ fun h2: forall 'a. (None | Some[Left['a]]) -> (0 | 'a)
 
 :ducs:postprocess.result
+:w
 fun h3(x, y, f, p) =
   if x is
     _ and f(x) is y and p(x) then y
@@ -110,6 +111,12 @@ fun h3(x, y, f, p) =
 //│     case x*‡ of
 //│       None*† -> y
 //│       _ -> "anyway"
+//│ ╔══[WARNING] the outer binding `y`
+//│ ║  l.97: 	fun h3(x, y, f, p) =
+//│ ║        	          ^
+//│ ╟── is shadowed by inner binding `y`
+//│ ║  l.99: 	    _ and f(x) is y and p(x) then y
+//│ ╙──      	                  ^
 //│ fun h3: forall 'a 'b. (Object & 'a, 'b, 'a -> 'b, 'a -> Bool) -> ("anyway" | 'b)
 
 
@@ -126,6 +133,7 @@ h3("anything", "anything", _ => "not me", _ => false) ~~> "anyway"
 
 
 :ducs:postprocess.result
+:w
 fun h4(x, y, p) =
   if x is
     y and p(x) then y
@@ -142,6 +150,12 @@ fun h4(x, y, p) =
 //│     case x*‡ of
 //│       None*† -> y
 //│       _ -> "default"
+//│ ╔══[WARNING] the outer binding `y`
+//│ ║  l.137: 	fun h4(x, y, p) =
+//│ ║         	          ^
+//│ ╟── is shadowed by inner binding `y`
+//│ ║  l.139: 	    y and p(x) then y
+//│ ╙──       	    ^
 //│ fun h4: forall 'a 'b. (Object & 'a, 'b, 'a -> Bool) -> ("default" | 'a | 'b)
 
 h4("should be me", "not me", _ => true)

From 0f3cdb8f27a7d07802aa49eb102667a99bda412b Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sun, 21 Jan 2024 03:34:13 +0800
Subject: [PATCH 096/147] Improve warning for shadowed outer bindings

---
 shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala | 2 +-
 shared/src/test/diff/nu/BadUCS.mls                         | 2 +-
 shared/src/test/diff/ucs/HygienicBindings.mls              | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 5f8ecf7190..42d56c0f76 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -396,7 +396,7 @@ trait Desugaring { self: PreTyper =>
               case S(shadowed) =>
                 raiseDesugaringWarning(
                   msg"the outer binding `${nme.name}`" -> shadowed.nameVar.toLoc,
-                  msg"is shadowed by inner binding `${nme.name}`" -> nme.toLoc
+                  msg"is shadowed by name pattern `${nme.name}`" -> nme.toLoc
                 )
               case N => ()
             }
diff --git a/shared/src/test/diff/nu/BadUCS.mls b/shared/src/test/diff/nu/BadUCS.mls
index 6a176b3c7a..e0bba638d5 100644
--- a/shared/src/test/diff/nu/BadUCS.mls
+++ b/shared/src/test/diff/nu/BadUCS.mls
@@ -100,7 +100,7 @@ fun foo0(x, y) = if x is y then 0
 //│ ╔══[WARNING] the outer binding `y`
 //│ ║  l.99: 	fun foo0(x, y) = if x is y then 0
 //│ ║        	            ^
-//│ ╟── is shadowed by inner binding `y`
+//│ ╟── is shadowed by name pattern `y`
 //│ ║  l.99: 	fun foo0(x, y) = if x is y then 0
 //│ ╙──      	                         ^
 //│ fun foo0: (anything, anything) -> 0
diff --git a/shared/src/test/diff/ucs/HygienicBindings.mls b/shared/src/test/diff/ucs/HygienicBindings.mls
index 56a1ae4023..5c7435599f 100644
--- a/shared/src/test/diff/ucs/HygienicBindings.mls
+++ b/shared/src/test/diff/ucs/HygienicBindings.mls
@@ -114,7 +114,7 @@ fun h3(x, y, f, p) =
 //│ ╔══[WARNING] the outer binding `y`
 //│ ║  l.97: 	fun h3(x, y, f, p) =
 //│ ║        	          ^
-//│ ╟── is shadowed by inner binding `y`
+//│ ╟── is shadowed by name pattern `y`
 //│ ║  l.99: 	    _ and f(x) is y and p(x) then y
 //│ ╙──      	                  ^
 //│ fun h3: forall 'a 'b. (Object & 'a, 'b, 'a -> 'b, 'a -> Bool) -> ("anyway" | 'b)
@@ -153,7 +153,7 @@ fun h4(x, y, p) =
 //│ ╔══[WARNING] the outer binding `y`
 //│ ║  l.137: 	fun h4(x, y, p) =
 //│ ║         	          ^
-//│ ╟── is shadowed by inner binding `y`
+//│ ╟── is shadowed by name pattern `y`
 //│ ║  l.139: 	    y and p(x) then y
 //│ ╙──       	    ^
 //│ fun h4: forall 'a 'b. (Object & 'a, 'b, 'a -> Bool) -> ("default" | 'a | 'b)

From 60f97b73aa014a557872d6be2f5ac092f174d922 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 23 Jan 2024 15:42:18 +0800
Subject: [PATCH 097/147] Clean up and make three cases which we failed to
 support

---
 .../src/main/scala/mlscript/JSBackend.scala   | 14 +++--
 .../mlscript/ucs/stages/Normalization.scala   | 11 ++--
 .../pretyper/ucs/stages/Normalization.mls     | 52 ++++++++++++++++++-
 .../src/test/scala/mlscript/DiffTests.scala   |  2 +-
 4 files changed, 66 insertions(+), 13 deletions(-)

diff --git a/shared/src/main/scala/mlscript/JSBackend.scala b/shared/src/main/scala/mlscript/JSBackend.scala
index f1805482dd..6725218cec 100644
--- a/shared/src/main/scala/mlscript/JSBackend.scala
+++ b/shared/src/main/scala/mlscript/JSBackend.scala
@@ -358,6 +358,14 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
       pat match {
         case Var("int") =>
           JSInvoke(JSField(JSIdent("Number"), "isInteger"), scrut :: Nil)
+        case Var("Int") if !oldDefs =>
+          JSInvoke(JSField(JSIdent("Number"), "isInteger"), scrut :: Nil)
+        case Var("Num") if !oldDefs =>
+          JSBinary("===", scrut.typeof(), JSLit("number"))
+        case Var("Bool") if !oldDefs =>
+          JSBinary("===", scrut.typeof(), JSLit("boolean"))
+        case Var("Str") if !oldDefs =>
+          JSBinary("===", scrut.typeof(), JSLit("string"))
         case Var("bool") =>
           JSBinary("===", scrut.member("constructor"), JSLit("Boolean"))
         case Var(s @ ("true" | "false")) =>
@@ -1145,7 +1153,7 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
 }
 
 class JSWebBackend extends JSBackend(allowUnresolvedSymbols = true) {
-  def oldDefs = false
+  override def oldDefs: Bool = false
   
   // Name of the array that contains execution results
   val resultsName: Str = topLevelScope declareRuntimeSymbol "results"
@@ -1271,8 +1279,8 @@ class JSWebBackend extends JSBackend(allowUnresolvedSymbols = true) {
     (JSImmEvalFn(N, Nil, R(polyfill.emit() ::: stmts ::: epilogue), Nil).toSourceCode.toLines, resultNames.toList)
   }
 
-  def apply(pgrm: Pgrm, newDefs: Bool): (Ls[Str], Ls[Str]) =
-    if (newDefs) generateNewDef(pgrm) else generate(pgrm)
+  def apply(pgrm: Pgrm): (Ls[Str], Ls[Str]) =
+    if (!oldDefs) generateNewDef(pgrm) else generate(pgrm)
 }
 
 abstract class JSTestBackend extends JSBackend(allowUnresolvedSymbols = false) {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index c0e26a4ebd..3773ed6b36 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -18,7 +18,7 @@ trait Normalization { self: Desugarer with Traceable =>
   private def fillImpl(these: Split, those: Split)(implicit
       scope: Scope,
       context: Context,
-      generatedVars: Set[Var],
+      declaredVars: Set[Var],
       shouldReportDiscarded: Bool
   ): Split =
     if (these.hasElse) {
@@ -34,12 +34,10 @@ trait Normalization { self: Desugarer with Traceable =>
           val concatenated = these.copy(tail = fillImpl(tail, thoseWithShadowed))
           Split.Let(false, fresh, nme, concatenated)
         } else {
-          these.copy(tail = fillImpl(tail, those)(scope, context, generatedVars + nme, false))
+          these.copy(tail = fillImpl(tail, those)(scope, context, declaredVars + nme, false))
         }
       case _: Split.Else => these
-      case Split.Nil =>
-        // println(s"END, generated vars: ${generatedVars.iterator.map(_.name).mkString(", ")}")
-        those.withoutBindings(generatedVars)
+      case Split.Nil => those.withoutBindings(declaredVars)
     })
 
   private implicit class SplitOps(these: Split) {
@@ -49,7 +47,7 @@ trait Normalization { self: Desugarer with Traceable =>
       * @param those the split to append
       * @param shouldReportDiscarded whether we should raise an error if the given
       *                        split is discarded because of the else branch
-      * @param generatedVars the generated variables which have been declared
+      * @param declaredVars the generated variables which have been declared
       * @return the concatenated split
       */
     def fill(those: Split, declaredVars: Set[Var], shouldReportDiscarded: Bool)(implicit
@@ -306,7 +304,6 @@ trait Normalization { self: Desugarer with Traceable =>
       case (_, end @ (Split.Else(_) | Split.Nil)) => println("the end"); end
     }
   }()
-  // }(showSplit(s"S${if (matchOrNot) "+" else "-"} ==>", _))
 
   /**
     * If you want to prepend `tail` to another `Split` where the `nme` takes
diff --git a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
index cbef36d469..f0c52cf13f 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
@@ -20,8 +20,6 @@ fun sum(acc, xs) =
     Nil then acc
 //│ fun sum: (Int, Cons[Int] | Nil) -> Int
 
-// FIXME: Remove redundant `_ -> (ucs$args_xs$Some_0$Cons).1`.
-// Why are they everywhere?
 :ducs:postprocess.result
 fun test(xs) =
   if xs is
@@ -79,3 +77,53 @@ fun test(xs) =
 //│       Nil*† -> "nothing"
 //│   None*† -> "nothing"
 //│ fun test: (None | Some[Cons[nothing] | Nil]) -> ("nothing" | Int | List[nothing])
+
+:ducs:postprocess.result
+fun test(x, p) = if x is
+  Int and p(x) then "foo"
+  0 then "bar"
+  else "qax"
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   Int*◊ ->
+//│     let ucs$test$0*† = p(x,) : Bool
+//│     case ucs$test$0*† of
+//│       true*† -> "foo"
+//│       _ -> "qax"
+//│   0 -> "bar"
+//│   _ -> "qax"
+//│ fun test: (Object, Int -> Bool) -> ("bar" | "foo" | "qax")
+
+:ducs:postprocess.result
+fun test(x, p) = if x is
+  Str and p(x) then "foo"
+  "lol" then "bar"
+  else "qax"
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   Str*◊ ->
+//│     let ucs$test$0*† = p(x,) : Bool
+//│     case ucs$test$0*† of
+//│       true*† -> "foo"
+//│       _ -> "qax"
+//│   "lol" -> "bar"
+//│   _ -> "qax"
+//│ fun test: (Object, Str -> Bool) -> ("bar" | "foo" | "qax")
+
+:ducs:postprocess.result
+fun test(x, p) = if x is
+  Num and p(x) then "great"
+  2.71828 then "E"
+  3.14159 then "PI"
+  else "other"
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   Num*◊ ->
+//│     let ucs$test$0*† = p(x,) : Bool
+//│     case ucs$test$0*† of
+//│       true*† -> "great"
+//│       _ -> "other"
+//│   3.14159 -> "PI"
+//│   2.71828 -> "E"
+//│   _ -> "other"
+//│ fun test: (Object, Num -> Bool) -> ("E" | "PI" | "great" | "other")
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index 60758f26b3..05f78d9d92 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -198,7 +198,7 @@ class DiffTests
     var newParser = basePath.headOption.contains("parser") || basePath.headOption.contains("compiler")
     
     val backend = new JSTestBackend {
-      def oldDefs = !newDefs
+      override def oldDefs: Bool = !newDefs
     }
     val host = ReplHost()
     val codeGenTestHelpers = new CodeGenTestHelpers(file, output)

From d767fc15f8a2ef1af2e0955b239e6c3516a508b9 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 23 Jan 2024 23:46:51 +0800
Subject: [PATCH 098/147] Simplify normalization and fix refinement to literal
 patterns

---
 .../mlscript/ucs/stages/Desugaring.scala      |  23 +-
 .../mlscript/ucs/stages/Normalization.scala   | 212 +++++++-----------
 .../main/scala/mlscript/ucs/syntax/core.scala |   5 +-
 .../pretyper/ucs/stages/Normalization.mls     |  56 +++--
 .../src/test/diff/ucs/NuPlainConditionals.mls |   2 +-
 .../src/test/diff/ucs/PlainConditionals.mls   |   2 +-
 6 files changed, 141 insertions(+), 159 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 42d56c0f76..7cb2b884da 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -64,10 +64,16 @@ trait Desugaring { self: PreTyper =>
     * A shorthand for making a true pattern, which is useful in desugaring
     * Boolean conditions.
     */
-  private def truePattern(implicit scope: Scope, context: Context) =
-    c.Pattern.Class(Var("true").withResolvedClassLikeSymbol, false)
-  private def falsePattern(implicit scope: Scope, context: Context) =
-    c.Pattern.Class(Var("false").withResolvedClassLikeSymbol, false)
+  private def truePattern(implicit scope: Scope, context: Context) = {
+    val className = Var("true")
+    val classSymbol = className.resolveClassLikeSymbol
+    c.Pattern.Class(className, classSymbol, false)
+  }
+  private def falsePattern(implicit scope: Scope, context: Context) = {
+    val className = Var("false")
+    val classSymbol = className.resolveClassLikeSymbol
+    c.Pattern.Class(className, classSymbol, false)
+  }
 
   private def desugarTermSplit(split: s.TermSplit)(implicit termPart: PartialTerm.Incomplete, scope: Scope, context: Context): c.Split =
     split match {
@@ -227,7 +233,7 @@ trait Desugaring { self: PreTyper =>
     }
     println(s"${scrutineeVar.name}: ${scrutinee.showPatternsDbg}")
     // Last, return the scope with all bindings and a function that adds all matches and bindings to a split.
-    (scopeWithAll, split => c.Branch(scrutineeVar, c.Pattern.Class(pattern.nme, refined), bindAll(split)))
+    (scopeWithAll, split => c.Branch(scrutineeVar, c.Pattern.Class(pattern.nme, patternClassSymbol, refined), bindAll(split)))
   }
 
   /**
@@ -272,8 +278,8 @@ trait Desugaring { self: PreTyper =>
                 (scopeWithNestedAll, split => bindPrevious(bindNestedAll(bindAliasVars(split)) :: c.Split.Nil))
               case pattern @ s.ConcretePattern(Var("true") | Var("false")) =>
                 println(s"${nme.name} is ${pattern.nme.name}")
-                val className = pattern.nme.withResolvedClassLikeSymbol(scope, context)
-                (scope, split => bindPrevious(c.Branch(nme, c.Pattern.Class(className, false), bindAliasVars(split)) :: c.Split.Nil))
+                val classSymbol = pattern.nme.resolveClassLikeSymbol(scope, context)
+                (scope, split => bindPrevious(c.Branch(nme, c.Pattern.Class(pattern.nme, classSymbol, false), bindAliasVars(split)) :: c.Split.Nil))
               case s.LiteralPattern(literal) =>
                 nme.getOrCreateScrutinee
                   .withAliasVar(nme)
@@ -375,9 +381,10 @@ trait Desugaring { self: PreTyper =>
             c.Branch(scrutineeVar, c.Pattern.Literal(literal), desugarRight) :: desugarTail
           case s.ConcretePattern(nme @ (Var("true") | Var("false"))) =>
             scrutinee.getOrCreateBooleanPattern(nme).addLocation(nme)
+            val classSymbol = nme.resolveClassLikeSymbol
             c.Branch(
               scrutinee = scrutineeVar,
-              pattern = c.Pattern.Class(nme.withResolvedClassLikeSymbol, false),
+              pattern = c.Pattern.Class(nme, classSymbol, false),
               continuation = desugarRight
             ) :: desugarTail
           case s.ConcretePattern(nme) =>
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 3773ed6b36..6dbf532e24 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -1,6 +1,6 @@
 package mlscript.ucs.stages
 
-import mlscript.{App, CaseOf, Fld, FldFlags, Let, Loc, Sel, Term, Tup, Var, StrLit}
+import mlscript.{App, CaseOf, DecLit, Fld, FldFlags, IntLit, Let, Loc, Sel, Term, Tup, Var, StrLit}
 import mlscript.{CaseBranches, Case, Wildcard, NoCases}
 import mlscript.Message, Message.MessageContext
 import mlscript.utils._, shorthands._
@@ -13,8 +13,6 @@ import pretyper.symbol._
 import pretyper.{Diagnosable, Scope, Traceable}
 
 trait Normalization { self: Desugarer with Traceable =>
-  import Normalization._
-
   private def fillImpl(these: Split, those: Split)(implicit
       scope: Scope,
       context: Context,
@@ -70,6 +68,46 @@ trait Normalization { self: Desugarer with Traceable =>
       }
     }
   }
+
+  /** We don't care about `Pattern.Name` because they won't appear in `specialize`. */
+  private implicit class PatternOps(val self: Pattern) extends AnyRef {
+    /** Checks if two patterns are the same. */
+    def =:=(other: Pattern): Bool = (self, other) match {
+      case (Pattern.Class(_, s1, _), Pattern.Class(_, s2, _)) => s1 === s2
+      case (Pattern.Literal(l1), Pattern.Literal(l2)) => l1 === l2
+      case (_, _) => false
+    }
+    /** Hard-code sub-typing relations. */
+    def <:<(other: Pattern): Bool = (self, other) match {
+      case (Pattern.Class(Var("true"), _, _), Pattern.Class(Var("Bool"), _, _)) => true
+      case (Pattern.Class(Var("false"), _, _), Pattern.Class(Var("Bool"), _, _)) => true
+      case (Pattern.Class(Var("Int"), _, _), Pattern.Class(Var("Num"), _, _)) => true
+      case (Pattern.Class(_, s1, _), Pattern.Class(_, s2, _)) => s1 hasBaseClass s2
+      case (Pattern.Literal(IntLit(_)), Pattern.Class(Var("Int" | "Num"), _, _)) => true
+      case (Pattern.Literal(StrLit(_)), Pattern.Class(Var("Str"), _, _)) => true
+      case (Pattern.Literal(DecLit(_)), Pattern.Class(Var("Num"), _, _)) => true
+      case (_, _) => false
+    }
+    /**
+      * If two class-like patterns has different `refined` flag. Report the
+      * inconsistency as a warning.
+      */
+    def reportInconsistentRefinedWith(other: Pattern): Unit = (self, other) match {
+      case (Pattern.Class(n1, _, r1), Pattern.Class(n2, _, r2)) if r1 =/= r2 =>
+        def be(value: Bool): Str = if (value) "is" else "is not"
+        raiseDesugaringWarning(
+          msg"inconsistent refined pattern" -> other.toLoc,
+          msg"pattern `${n1.name}` ${be(r1)} refined" -> n1.toLoc,
+          msg"but pattern `${n2.name}` ${be(r2)} refined" -> n2.toLoc
+        )
+      case (_, _) => ()
+    }
+    /** If the pattern is a class-like pattern, override its `refined` flag. */
+    def markAsRefined: Unit = self match {
+      case self: Pattern.Class => self.refined = true
+      case _ => ()
+    }
+  }
   
 
   /**
@@ -95,7 +133,7 @@ trait Normalization { self: Desugarer with Traceable =>
         val (wrap, realTail) = preventShadowing(nme, tail)
         wrap(Let(false, nme, scrutinee, normalizeToTerm(continuation.fill(realTail, declaredVars, true), declaredVars)))
       // Skip Boolean conditions as scrutinees, because they only appear once.
-      case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true"), _), continuation), tail) if context.isTestVar(test) =>
+      case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true"), _, _), continuation), tail) if context.isTestVar(test) =>
         println(s"TRUE: ${test.name} is true")
         val trueBranch = normalizeToTerm(continuation.fill(tail, declaredVars, false), declaredVars)
         val falseBranch = normalizeToCaseBranches(tail, declaredVars)
@@ -109,7 +147,7 @@ trait Normalization { self: Desugarer with Traceable =>
         // println(s"false branch: ${showSplit(tail)}")
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context), declaredVars)
         CaseOf(scrutineeVar, Case(literal, trueBranch, falseBranch)(refined = false))
-      case Split.Cons(Branch(Scrutinee.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Class(nme, rfd), continuation), tail) =>
+      case Split.Cons(Branch(Scrutinee.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Class(nme, _, rfd), continuation), tail) =>
         println(s"CLASS: ${scrutineeVar.name} is ${nme.name}")
         // println(s"match ${scrutineeVar.name} with $nme (has location: ${nme.toLoc.isDefined})")
         val trueBranch = normalizeToTerm(specialize(continuation.fill(tail, declaredVars, false), true)(scrutineeVar, scrutinee, pattern, context), declaredVars)
@@ -160,8 +198,8 @@ trait Normalization { self: Desugarer with Traceable =>
 
   /**
     * Specialize `split` with the assumption that `scrutinee` matches `pattern`.
-    * If `matchOrNot` is `true`, the function keeps branches that agree on
-    * `scrutinee` matches `pattern`. Otherwise, the function removes branches
+    * If `matchOrNot` is `true`, the function _keeps_ branches that agree on
+    * `scrutinee` matches `pattern`. Otherwise, the function _removes_ branches
     * that agree on `scrutinee` matches `pattern`.
     */
   private def specialize
@@ -170,137 +208,51 @@ trait Normalization { self: Desugarer with Traceable =>
   trace[Split](s"S${if (matchOrNot) "+" else "-"} <== ${scrutineeVar.name} is ${pattern}") {
     (matchOrNot, split) match {
       // Name patterns are translated to let bindings.
-      case (_, Split.Cons(Branch(otherScrutineeVar, Pattern.Name(alias), continuation), tail)) =>
-        Split.Let(false, alias, otherScrutineeVar, specialize(continuation, matchOrNot))
-      case (_, split @ Split.Cons(head @ Branch(test, Pattern.Class(Var("true"), _), continuation), tail)) if context.isTestVar(test) =>
-        println(s"found a Boolean test: ${test.showDbg} is true")
-        val trueBranch = specialize(continuation, matchOrNot)
-        val falseBranch = specialize(tail, matchOrNot)
-        split.copy(head = head.copy(continuation = trueBranch), tail = falseBranch)
-      // Class pattern. Positive.
-      case (true, split @ Split.Cons(head @ Branch(Scrutinee.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName, otherRefined), continuation), tail)) =>
-        val otherClassSymbol = otherClassName.getClassLikeSymbol
+      case (m, Split.Cons(Branch(otherScrutineeVar, Pattern.Name(alias), continuation), tail)) =>
+        Split.Let(false, alias, otherScrutineeVar, specialize(continuation, m))
+      case (m, Split.Cons(head @ Branch(test, Pattern.Class(Var("true"), _, _), continuation), tail)) if context.isTestVar(test) =>
+        println(s"TEST: ${test.name} is true")
+        head.copy(continuation = specialize(continuation, m)) :: specialize(tail, m)
+      case (true, split @ Split.Cons(head @ Branch(Scrutinee.WithVar(otherScrutinee, otherScrutineeVar), otherPattern, continuation), tail)) =>
         if (scrutinee === otherScrutinee) {
-          println(s"scrutinee: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
-          pattern match {
-            case classPattern @ Pattern.Class(className, refined) =>
-              val classSymbol = className.getClassLikeSymbol
-              if (classSymbol === otherClassSymbol) {
-                println(s"Case 1: class name: ${className.name} === ${otherClassName.name}")
-                if (otherRefined =/= refined) {
-                  def be(value: Bool): Str = if (value) "is" else "is not"
-                  raiseDesugaringWarning(
-                    msg"inconsistent refined case branches" -> pattern.toLoc,
-                    msg"class pattern ${className.name} ${be(refined)} refined" -> className.toLoc,
-                    msg"but class pattern ${otherClassName.name} ${be(otherRefined)} refined" -> otherClassName.toLoc
-                  )
-                }
-                specialize(continuation, true) :++ specialize(tail, true)
-              } else if (otherClassSymbol hasBaseClass classSymbol) {
-                println(s"Case 2: ${otherClassName.name} <: ${className.name}")
-                println(s"${otherClassSymbol.name} is refining ${className.name}")
-                // We should mark `pattern` as refined.
-                classPattern.refined = true
-                split
-              } else {
-                println(s"Case 3: ${className.name} and ${otherClassName.name} are unrelated")
-                specialize(tail, true)
-              }
-            case _ =>
-              // TODO: Make a case for this. Check if this is a valid case.
-              raiseDesugaringError(
-                msg"pattern ${pattern.toString}" -> pattern.toLoc,
-                msg"is incompatible with class pattern ${otherClassName.name}" -> otherClassName.toLoc,
-              )
-              split
+          println(s"Case 1: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
+          if (otherPattern =:= pattern) {
+            println(s"Case 2.1: $pattern =:= $otherPattern")
+            otherPattern reportInconsistentRefinedWith pattern
+            specialize(continuation, true) :++ specialize(tail, true)
+          } else if (otherPattern <:< pattern) {
+            println(s"Case 2.2: $pattern <:< $otherPattern")
+            pattern.markAsRefined; split
+          } else {
+            println(s"Case 2.3: $pattern are unrelated with $otherPattern")
+            specialize(tail, true)
           }
         } else {
-          // println(s"scrutinee: ${scrutineeVar.name} =/= ${otherScrutineeVar.name}")
-          split.copy(
-            head = head.copy(continuation = specialize(continuation, true)),
-            tail = specialize(tail, true)
-          )
+          println(s"Case 2: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
+          head.copy(continuation = specialize(continuation, true)) :: specialize(tail, true)
         }
-      // Class pattern. Negative
-      case (false, split @ Split.Cons(head @ Branch(Scrutinee.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Class(otherClassName, otherRefined), continuation), tail)) =>
-        val otherClassSymbol = otherClassName.getClassLikeSymbol
+      case (false, split @ Split.Cons(head @ Branch(Scrutinee.WithVar(otherScrutinee, otherScrutineeVar), otherPattern, continuation), tail)) =>
         if (scrutinee === otherScrutinee) {
-          println(s"scrutinee: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
-          pattern match {
-            case Pattern.Class(className, refined) =>
-              println("both of them are class patterns")
-              if (otherRefined =/= refined) {
-                def be(value: Bool): Str = if (value) "is" else "is not"
-                raiseDesugaringWarning(
-                  msg"inconsistent refined case branches" -> pattern.toLoc,
-                  msg"class pattern ${className.name} ${be(refined)} refined" -> className.toLoc,
-                  msg"but class pattern ${otherClassName.name} ${be(otherRefined)} refined" -> otherClassName.toLoc
-                )
-              }
-              val classSymbol = className.getClassLikeSymbol
-              if (className === otherClassName) {
-                println(s"Case 1: class name: ${otherClassName.name} === ${className.name}")
-                specialize(tail, false)
-              } else if (otherClassSymbol.baseTypes contains classSymbol) {
-                println(s"Case 2: class name: ${otherClassName.name} <: ${className.name}")
-                Split.Nil
-              } else {
-                println(s"Case 3: class name: ${otherClassName.name} and ${className.name} are unrelated")
-                split.copy(tail = specialize(tail, false))
-              }
-            case _ =>
-              println(s"different patterns: ${otherClassName.name} and $pattern.toString")
-              split.copy(tail = specialize(tail, false))
+          println(s"Case 1: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
+          otherPattern reportInconsistentRefinedWith pattern
+          if (otherPattern =:= pattern) {
+            println(s"Case 2.1: $pattern =:= $otherPattern")
+            specialize(tail, false)
+          } else if (otherPattern <:< pattern) {
+            println(s"Case 2.2: $pattern <:< $otherPattern")
+            Split.Nil
+          } else {
+            println(s"Case 2.3: $pattern are unrelated with $otherPattern")
+            split.copy(tail = specialize(tail, false))
           }
         } else {
-          println(s"scrutinee: ${scrutineeVar.name} =/= ${otherScrutineeVar.name}")
-          split.copy(
-            head = head.copy(continuation = specialize(continuation, matchOrNot)),
-            tail = specialize(tail, matchOrNot)
-          )
+          println(s"Case 2: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
+          head.copy(continuation = specialize(continuation, false)) :: specialize(tail, false)
         }
-      // Literal pattern. Positive.
-      case (true, split @ Split.Cons(head @ Branch(Scrutinee.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Literal(otherLiteral), continuation), tail)) =>
-        if (scrutinee === otherScrutinee) {
-          println(s"scrutinee: ${scrutineeVar.name} is ${otherScrutineeVar.name}")
-          pattern match {
-            case Pattern.Literal(literal) if literal === otherLiteral =>
-              specialize(continuation, true) :++ specialize(tail, true)
-            case _ => specialize(tail, true)
-          }
-        } else {
-          println(s"scrutinee: ${scrutineeVar.name} is NOT ${otherScrutineeVar.name}")
-          split.copy(
-            head = head.copy(continuation = specialize(continuation, true)),
-            tail = specialize(tail, true)
-          )
-        }
-      // Literal pattern. Negative.
-      case (false, split @ Split.Cons(head @ Branch(Scrutinee.WithVar(otherScrutinee, otherScrutineeVar), Pattern.Literal(otherLiteral), continuation), tail)) =>
-        if (scrutinee === otherScrutinee) {
-          println(s"scrutinee: ${scrutineeVar.name} is ${otherScrutineeVar.name}")
-          pattern match {
-            case Pattern.Literal(literal) if literal === otherLiteral =>
-              specialize(tail, false)
-            case _ =>
-              // No need to check `continuation` because literals don't overlap.
-              split.copy(tail = specialize(tail, false))
-          }
-        } else {
-          println(s"scrutinee: ${scrutineeVar.name} is NOT ${otherScrutineeVar.name}")
-          split.copy(
-            head = head.copy(continuation = specialize(continuation, false)),
-            tail = specialize(tail, false)
-          )
-        }
-      // Other patterns. Not implemented.
-      case (_, split @ Split.Cons(Branch(otherScrutineeVar, pattern, continuation), tail)) =>
-        raiseDesugaringError(msg"found unsupported pattern: ${pattern.toString}" -> pattern.toLoc)
+      case (_, split @ Split.Cons(Branch(_, pattern, _), _)) =>
+        raiseDesugaringError(msg"unsupported pattern" -> pattern.toLoc)
         split
-      case (_, let @ Split.Let(_, nme, _, tail)) =>
-        println(s"let binding ${nme.name}, go next")
-        let.copy(tail = specialize(tail, matchOrNot))
-      // Ending cases remain the same.
+      case (m, let @ Split.Let(_, nme, _, tail)) => let.copy(tail = specialize(tail, m))
       case (_, end @ (Split.Else(_) | Split.Nil)) => println("the end"); end
     }
   }()
@@ -320,5 +272,3 @@ trait Normalization { self: Desugarer with Traceable =>
     case S(_) | N => identity[Term] _ -> tail
   }
 }
-
-object Normalization
diff --git a/shared/src/main/scala/mlscript/ucs/syntax/core.scala b/shared/src/main/scala/mlscript/ucs/syntax/core.scala
index 4b39414b6b..db52d4e754 100644
--- a/shared/src/main/scala/mlscript/ucs/syntax/core.scala
+++ b/shared/src/main/scala/mlscript/ucs/syntax/core.scala
@@ -2,6 +2,7 @@ package mlscript.ucs.syntax
 
 import mlscript.{Diagnostic, Lit, Loc, Located, Message, Term, Var}
 import mlscript.utils._, shorthands._
+import mlscript.pretyper.symbol.TypeSymbol
 
 package object core {
   sealed abstract class Pattern extends Located {
@@ -12,7 +13,7 @@ package object core {
     override def toString(): String = this match {
       case Pattern.Literal(literal) => literal.idStr
       case Pattern.Name(Var(name)) => name
-      case Pattern.Class(Var(name), rfd) => (if (rfd) "refined " else "") + name
+      case Pattern.Class(Var(name), _, rfd) => (if (rfd) "refined " else "") + name
     }
   }
   object Pattern {
@@ -28,7 +29,7 @@ package object core {
       * @param originallyRefined whether the class is marked as refined from
       *                          in source code
       */
-    final case class Class(nme: Var, val originallyRefined: Bool) extends Pattern {
+    final case class Class(nme: Var, symbol: TypeSymbol, val originallyRefined: Bool) extends Pattern {
       override def children: Ls[Located] = nme :: Nil
 
       var refined: Bool = originallyRefined
diff --git a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
index f0c52cf13f..e3a2457328 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
@@ -85,14 +85,15 @@ fun test(x, p) = if x is
   else "qax"
 //│ Post-processed UCS term:
 //│ case x*‡ of
-//│   Int*◊ ->
+//│   refined Int*◊ ->
 //│     let ucs$test$0*† = p(x,) : Bool
 //│     case ucs$test$0*† of
 //│       true*† -> "foo"
-//│       _ -> "qax"
-//│   0 -> "bar"
-//│   _ -> "qax"
-//│ fun test: (Object, Int -> Bool) -> ("bar" | "foo" | "qax")
+//│       _ ->
+//│         case x*‡ of
+//│           0 -> "bar"
+//│           _ -> "qax"
+//│ fun test: forall 'a. (Int & 'a, (Int & 'a) -> Bool) -> ("bar" | "foo" | "qax")
 
 :ducs:postprocess.result
 fun test(x, p) = if x is
@@ -101,14 +102,15 @@ fun test(x, p) = if x is
   else "qax"
 //│ Post-processed UCS term:
 //│ case x*‡ of
-//│   Str*◊ ->
+//│   refined Str*◊ ->
 //│     let ucs$test$0*† = p(x,) : Bool
 //│     case ucs$test$0*† of
 //│       true*† -> "foo"
-//│       _ -> "qax"
-//│   "lol" -> "bar"
-//│   _ -> "qax"
-//│ fun test: (Object, Str -> Bool) -> ("bar" | "foo" | "qax")
+//│       _ ->
+//│         case x*‡ of
+//│           "lol" -> "bar"
+//│           _ -> "qax"
+//│ fun test: forall 'a. (Str & 'a, (Str & 'a) -> Bool) -> ("bar" | "foo" | "qax")
 
 :ducs:postprocess.result
 fun test(x, p) = if x is
@@ -118,12 +120,34 @@ fun test(x, p) = if x is
   else "other"
 //│ Post-processed UCS term:
 //│ case x*‡ of
-//│   Num*◊ ->
+//│   refined Num*◊ ->
 //│     let ucs$test$0*† = p(x,) : Bool
 //│     case ucs$test$0*† of
 //│       true*† -> "great"
-//│       _ -> "other"
-//│   3.14159 -> "PI"
-//│   2.71828 -> "E"
-//│   _ -> "other"
-//│ fun test: (Object, Num -> Bool) -> ("E" | "PI" | "great" | "other")
+//│       _ ->
+//│         case x*‡ of
+//│           2.71828 -> "E"
+//│           _ ->
+//│             case x*‡ of
+//│               3.14159 -> "PI"
+//│               _ -> "other"
+//│ fun test: forall 'a. ('a & (2.71828 | Num & ~2.71828), (Num & 'a) -> Bool) -> ("E" | "PI" | "great" | "other")
+
+:ducs:postprocess.result
+fun test(x, p) = if x is
+  Bool and p(x) then "great"
+  true then "false"
+  false then "true"
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   refined Bool*◊ ->
+//│     let ucs$test$0*† = p(x,) : Bool
+//│     case ucs$test$0*† of
+//│       true*† -> "great"
+//│       _ ->
+//│         case x*‡ of
+//│           true*† -> "false"
+//│           _ ->
+//│             case x*‡ of
+//│               false*† -> "true"
+//│ fun test: forall 'a. ('a & Bool, (Bool & 'a) -> Bool) -> ("false" | "great" | "true")
diff --git a/shared/src/test/diff/ucs/NuPlainConditionals.mls b/shared/src/test/diff/ucs/NuPlainConditionals.mls
index 4f24071e8e..4862ce950b 100644
--- a/shared/src/test/diff/ucs/NuPlainConditionals.mls
+++ b/shared/src/test/diff/ucs/NuPlainConditionals.mls
@@ -96,7 +96,7 @@ fun foo2(x) = x is (Pair(a, b) and a > b) | Int
 //│ fun foo1: nothing -> error
 //│ fun foo2: nothing -> error
 //│ Code generation encountered an error:
-//│   unknown match case: Int
+//│   unresolved symbol |
 
 
 
diff --git a/shared/src/test/diff/ucs/PlainConditionals.mls b/shared/src/test/diff/ucs/PlainConditionals.mls
index 56fdc6d1e6..a90d235b7d 100644
--- a/shared/src/test/diff/ucs/PlainConditionals.mls
+++ b/shared/src/test/diff/ucs/PlainConditionals.mls
@@ -99,7 +99,7 @@ fun foo(x) = x is (Pair(a, b) and a > b) | Int
 //│ fun foo: nothing -> error
 //│ fun foo: nothing -> error
 //│ Code generation encountered an error:
-//│   unknown match case: Int
+//│   unresolved symbol |
 
 
 

From 860d6c8b0c3470889ba9282c29c9b2ea322f9b6b Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 24 Jan 2024 01:53:34 +0800
Subject: [PATCH 099/147] Make coverage checking and normalization consistent

---
 .../main/scala/mlscript/pretyper/Scope.scala  |   1 +
 .../scala/mlscript/ucs/context/CaseSet.scala  |  85 --------------
 .../scala/mlscript/ucs/context/Context.scala  |   9 +-
 .../scala/mlscript/ucs/context/Pattern.scala  |  26 +----
 .../mlscript/ucs/context/Scrutinee.scala      |  17 +--
 .../scala/mlscript/ucs/context/package.scala  |  13 ---
 .../ucs/stages/CoverageChecking.scala         | 107 +++++++++++++++++-
 .../mlscript/ucs/stages/Desugaring.scala      |   2 +-
 .../mlscript/ucs/stages/Normalization.scala   |  20 ++--
 .../scala/mlscript/ucs/stages/package.scala   |  33 +++++-
 shared/src/test/diff/pretyper/Errors.mls      |   2 +-
 .../pretyper/ucs/stages/Normalization.mls     |  29 +++++
 .../pretyper/ucs/stages/PostProcessing.mls    |   4 +-
 shared/src/test/diff/ucs/ElseIf.mls           |   4 +-
 14 files changed, 182 insertions(+), 170 deletions(-)
 delete mode 100644 shared/src/main/scala/mlscript/ucs/context/CaseSet.scala

diff --git a/shared/src/main/scala/mlscript/pretyper/Scope.scala b/shared/src/main/scala/mlscript/pretyper/Scope.scala
index 794fc41450..78323d07de 100644
--- a/shared/src/main/scala/mlscript/pretyper/Scope.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Scope.scala
@@ -99,6 +99,7 @@ object Scope {
       new ModuleSymbol(mod("true")),
       new ModuleSymbol(mod("false")),
       new TypeAliasSymbol(als("nothing")),
+      new DummyClassSymbol(Var("Object")),
       new DummyClassSymbol(Var("Int")),
       new DummyClassSymbol(Var("Num")),
       new DummyClassSymbol(Var("Str")),
diff --git a/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala b/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
deleted file mode 100644
index aff9d24e5e..0000000000
--- a/shared/src/main/scala/mlscript/ucs/context/CaseSet.scala
+++ /dev/null
@@ -1,85 +0,0 @@
-package mlscript.ucs.context
-
-import mlscript.{Lit, Loc, Var}
-import mlscript.pretyper.symbol.TypeSymbol
-import mlscript.utils._, shorthands._
-import mlscript.pretyper.symbol.DummyClassSymbol
-
-/**
-  * A `CaseSet` represents all patterns that a particular scrutinee is
-  * being matched with within a UCS expression.
-  *
-  * @param patterns a list of patterns.
-  */
-final case class CaseSet(val patterns: List[Pattern]) {
-  def showInDiagnostics: Str =
-    patterns.iterator.map(_.showInDiagnostics).mkString("[", ", ", "]")
-
-  /** Get a iterator of all class-like patterns. */
-  def classLikePatterns: Iterator[Pattern.ClassLike] = patterns.iterator.flatMap {
-    case pattern: Pattern.ClassLike => S(pattern)
-    case _: Pattern.Boolean | _: Pattern.Literal | _: Pattern.Tuple => N
-  }
-
-  /** Separate a class-like pattern if it appears in `patterns`. */
-  def separate(classLikeSymbol: TypeSymbol): Opt[(Pattern.ClassLike, Ls[Pattern.ClassLike])] = {
-    classLikePatterns.foldRight[(Opt[Pattern.ClassLike], Ls[Pattern.ClassLike])]((N, Nil)) {
-      case (pattern, (S(separated), rest)) => (S(separated), pattern :: rest)
-      case (pattern, (N, rest)) if pattern.classLikeSymbol === classLikeSymbol => (S(pattern), rest)
-      case (pattern, (N, rest)) => (N, pattern :: rest)
-    } match {
-      case (N, _) => N
-      case (S(separated), rest) => S((separated, rest))
-    }
-  }
-  /**
-    * Split the pattern set into two pattern sets.
-    * 
-    * For example, let A be the base type of B, C, and D. Plus, class `Z` is
-    * unrelated to any of them. Suppose the initial pattern set is
-    * `{ A, B, C, Z }`. Splitting the set results in two sets, one set
-    * contains classes that are compatible with `A`, and the other set
-    * contains classes that are unrelated to `A`.
-    * 
-    * For example, if we split the set with `A`, then we get `{ B, C }` and
-    * set `{ Z }`. Set `{ B, C }` represents that the scrutinee can be further
-    * refined to class `B` or `class C`. Set `{ Z }` represents that if the
-    * scrutinee is not `A`, then it can be `Z`.
-    * 
-    * If `A` is sealed to `B`, `C`, and `D`, then we get `{ B, C, D }` and
-    * `{ Z }`. Because if the scrutinee is assumed to be `A`, then it can also
-    * be `D` other than `B`, `C`.
-    *
-    * @param classLikeSymbol the type symbol represents the class like type
-    * @return If the pattern set doesn't include the given type symbol, this
-    *         returns `None`. Otherwise, the function returns a triplet of the
-    *         locations where the pattern appears, the related patterns, and
-    *         unrelated patterns.
-    */
-  def split(classLikeSymbol: TypeSymbol): Opt[(Pattern.ClassLike, CaseSet, CaseSet)] = {
-    separate(classLikeSymbol) match {
-      case N => N
-      case S((pattern, patterns)) =>
-        val (unrelated, related) = patterns.partitionMap { pattern =>
-          if (pattern.classLikeSymbol hasBaseClass classLikeSymbol) {
-            R(pattern)
-          } else {
-            L(pattern)
-          }
-        }
-        S((pattern, CaseSet(related), CaseSet(unrelated)))
-    }
-  }
-
-  @inline def remove(boolLit: Var): CaseSet = {
-    require(boolLit.name === "true" || boolLit.name === "false")
-    CaseSet(patterns.filter(!_.matches(boolLit)))
-  }
-
-  @inline def remove(literal: Lit): CaseSet =
-    CaseSet(patterns.filter(!_.matches(literal)))
-
-  @inline def isEmpty: Bool = patterns.isEmpty
-
-  @inline def size: Int = patterns.size
-}
diff --git a/shared/src/main/scala/mlscript/ucs/context/Context.scala b/shared/src/main/scala/mlscript/ucs/context/Context.scala
index 9a62d9f853..c3f21d3754 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Context.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Context.scala
@@ -57,14 +57,7 @@ class Context(originalTerm: If) {
     scrutinee
   }
 
-  /**
-    * Create a `MatchRegistry` from the current context.
-    */
-  def toMatchRegistry: MatchRegistry =
-    scrutineeBuffer.iterator.flatMap { scrutinee =>
-      val caseSet = scrutinee.toCaseSet
-      scrutinee.aliasesIterator.map(alias => (alias -> scrutinee) -> caseSet)
-    }.toMap
+  def scrutinees: Iterator[Scrutinee] = scrutineeBuffer.iterator
 }
 
 object Context {
diff --git a/shared/src/main/scala/mlscript/ucs/context/Pattern.scala b/shared/src/main/scala/mlscript/ucs/context/Pattern.scala
index 5e209e0bd2..cfb1d45f56 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Pattern.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Pattern.scala
@@ -5,6 +5,7 @@ import mlscript.{Lit, Loc, Located, SimpleTerm, TypeName, Var}
 import mlscript.pretyper.symbol.TypeSymbol
 import mlscript.utils._, shorthands._
 import mlscript.pretyper.symbol.DummyClassSymbol
+import mlscript.pretyper.symbol.ModuleSymbol
 
 sealed abstract class Pattern {
   private val locationsBuffer: Buffer[Loc] = Buffer.empty
@@ -68,6 +69,7 @@ object Pattern {
 
     override def showInDiagnostics: Str = s"${(classLikeSymbol match {
       case dummySymbol: DummyClassSymbol => "class"
+      case s: ModuleSymbol if s.name === "true" || s.name === "false" => s"Boolean value"
       case otherSymbol: TypeSymbol => otherSymbol.defn.kind.str
     })} `${classLikeSymbol.name}`"
 
@@ -127,28 +129,4 @@ object Pattern {
 
     override def toCasePattern: SimpleTerm = literal.withLoc(firstOccurrence)
   }
-
-  /**
-    * This can be actually merged with `Pattern.Literal`. However, there's no
-    * `Lit` sub-classes for Boolean types, so the representation is a little bit
-    * awkward, also, it makes sense to consider Boolean patterns separately
-    * because we can check the Boolean exhaustiveness with them.
-    */
-  final case class Boolean(val value: Var) extends Pattern {
-    require(value.name === "true" || value.name === "false")
-
-    override def arity: Opt[Int] = N
-
-    override def showDbg: Str = value.name
-
-    override def showInDiagnostics: Str = s"Boolean value ${value.name}"
-
-    override def matches(pat: SimpleTerm): Bool =
-      pat match {
-        case Var(name) => value.name === name
-        case _ => false
-      }
-
-    override def toCasePattern: SimpleTerm = value.withLoc(firstOccurrence)
-  }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
index 05422bf219..b8b0380594 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
@@ -4,7 +4,6 @@ import collection.mutable.{Buffer, SortedMap => MutSortedMap, SortedSet => MutSo
 import mlscript.{Lit, Loc, Var}
 import mlscript.pretyper.symbol.TypeSymbol
 import mlscript.utils._, shorthands._
-import mlscript.ucs.context.CaseSet
 import mlscript.DecLit
 import mlscript.IntLit
 import mlscript.StrLit
@@ -26,11 +25,6 @@ class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
   private var aliasVarSet: MutSortedSet[Var] = MutSortedSet.empty
 
   private val literalPatterns: MutSortedMap[Lit, Pattern.Literal] = MutSortedMap.empty(literalOrdering)
-  /**
-    * The key should be either `Var("true")` or `Var("false")`. We want to keep
-    * the type symbol of the variable so that it still work in following stages.
-    */
-  private val booleanPatterns: MutSortedMap[Var, Pattern.Boolean] = MutSortedMap.empty(varNameOrdering)
 
   def addAliasVar(alias: Var): Unit = aliasVarSet += alias
 
@@ -78,17 +72,10 @@ class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
   def getOrCreateLiteralPattern(literal: Lit): Pattern.Literal =
     literalPatterns.getOrElseUpdate(literal, Pattern.Literal(literal))
 
-  /**
-    * The key should be either `Var("true")` or `Var("false")`. We want to keep
-    * the type symbol of the variable so that it still work in following stages.
-    */
-  def getOrCreateBooleanPattern(value: Var): Pattern.Boolean =
-    booleanPatterns.getOrElseUpdate(value, Pattern.Boolean(value))
-
   def classLikePatternsIterator: Iterator[Pattern.ClassLike] = classLikePatterns.valuesIterator
 
   def patternsIterator: Iterator[Pattern] =
-    classLikePatterns.valuesIterator ++ literalPatterns.valuesIterator ++ booleanPatterns.valuesIterator
+    classLikePatterns.valuesIterator ++ literalPatterns.valuesIterator
 
   /** Get a list of string representation of patterns. Only for debugging. */
   private[ucs] def showPatternsDbg: Str = {
@@ -103,8 +90,6 @@ class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
 
   def freshSubScrutinee: Scrutinee = context.freshScrutinee(this)
 
-  def toCaseSet: CaseSet = CaseSet(patternsIterator.toList)
-
   def getReadableName(scrutineeVar: Var): Str = {
     parent match {
       case N if context.isGeneratedVar(scrutineeVar) => "term"
diff --git a/shared/src/main/scala/mlscript/ucs/context/package.scala b/shared/src/main/scala/mlscript/ucs/context/package.scala
index 6b5d31d9a8..d9c6e3191c 100644
--- a/shared/src/main/scala/mlscript/ucs/context/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/package.scala
@@ -6,17 +6,4 @@ import mlscript.utils._, shorthands._
 
 package object context {
   type NamedScrutinee = (Var -> Scrutinee)
-
-  type MatchRegistry = Map[NamedScrutinee, CaseSet]
-
-  // implicit class MatchRegistryOps(val self: MatchRegistry) extends AnyVal {
-  //   def showDbg: Str = 
-  // }
-
-  type SeenRegistry = Map[NamedScrutinee, (TypeSymbol, Ls[Loc], CaseSet)]
-
-  implicit class SeenRegistryOps(val self: SeenRegistry) extends AnyVal {
-    def showDbg: Str = if (self.isEmpty) "empty" else
-      self.iterator.map { case ((k, _), (s, _, _)) => s"${k.name} is ${s.name}" }.mkString(", ")
-  }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index 82f2e23109..45e92149a9 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -4,7 +4,7 @@ import mlscript.{Case, CaseBranches, CaseOf, Let, Lit, Loc, NoCases, Term, Var,
 import mlscript.{Diagnostic, ErrorReport, WarningReport}
 import mlscript.Message, Message.MessageContext
 import mlscript.ucs.Desugarer
-import mlscript.ucs.context.{Context, CaseSet, NamedScrutinee, MatchRegistry, Scrutinee, SeenRegistry}
+import mlscript.ucs.context.{Context, NamedScrutinee, Pattern, Scrutinee}
 import mlscript.pretyper.Traceable
 import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
@@ -13,15 +13,19 @@ trait CoverageChecking { self: Desugarer with Traceable =>
   import CoverageChecking._
 
   def checkCoverage(term: Term)(implicit context: Context): Ls[Diagnostic] = {
-    val registry = context.toMatchRegistry
+    // Collect an immutable map from scrutinees to patterns.
+    val registry: ScrutineePatternSetMap = context.scrutinees.flatMap { scrutinee =>
+      val caseSet = CaseSet(scrutinee.patternsIterator.toList)
+      scrutinee.aliasesIterator.map(alias => (alias -> scrutinee) -> caseSet)
+    }.toMap
     println("collected match registry: " + showRegistry(registry))
     checkCoverage(term, Map.empty, registry, Map.empty)
   }
 
   private def checkCoverage(
       term: Term,
-      pending: MatchRegistry,
-      working: MatchRegistry,
+      pending: ScrutineePatternSetMap,
+      working: ScrutineePatternSetMap,
       seen: SeenRegistry
   )(implicit context: Context): Ls[Diagnostic] = {
     term match {
@@ -154,9 +158,102 @@ object CoverageChecking {
     }
 
   /** A helper function that prints entries from the given registry line by line. */
-  private def showRegistry(registry: MatchRegistry): Str =
+  private def showRegistry(registry: ScrutineePatternSetMap): Str =
     if (registry.isEmpty) "empty" else
       registry.iterator.map { case (scrutineeVar -> scrutinee, matchedClasses) =>
         matchedClasses.patterns.iterator.map(_.showInDiagnostics).mkString(s">>> ${scrutineeVar.name} => [", ", ", "]")
       }.mkString("\n", "\n", "")
+
+  type ScrutineePatternSetMap = Map[NamedScrutinee, CaseSet]
+
+  type SeenRegistry = Map[NamedScrutinee, (TypeSymbol, Ls[Loc], CaseSet)]
+
+  implicit class SeenRegistryOps(val self: SeenRegistry) extends AnyVal {
+    def showDbg: Str = if (self.isEmpty) "empty" else
+      self.iterator.map { case ((k, _), (s, _, _)) => s"${k.name} is ${s.name}" }.mkString(", ")
+  }
+
+  /**
+    * A `CaseSet` represents all patterns that a particular scrutinee is
+    * being matched with within a UCS expression.
+    *
+    * @param patterns a list of patterns.
+    */
+  final case class CaseSet(val patterns: List[Pattern]) {
+    def showInDiagnostics: Str =
+      patterns.iterator.map(_.showInDiagnostics).mkString("[", ", ", "]")
+
+    /** Get a iterator of all class-like patterns. */
+    def classLikePatterns: Iterator[Pattern.ClassLike] = patterns.iterator.flatMap {
+      case pattern: Pattern.ClassLike => S(pattern)
+      case _: Pattern.Literal | _: Pattern.Tuple => N
+    }
+
+    /** Separate a class-like pattern if it appears in `patterns`. */
+    def separate(classLikeSymbol: TypeSymbol): Opt[(Pattern.ClassLike, Ls[Pattern.ClassLike])] = {
+      classLikePatterns.foldRight[(Opt[Pattern.ClassLike], Ls[Pattern.ClassLike])]((N, Nil)) {
+        case (pattern, (S(separated), rest)) => (S(separated), pattern :: rest)
+        case (pattern, (N, rest)) if pattern.classLikeSymbol === classLikeSymbol => (S(pattern), rest)
+        case (pattern, (N, rest)) => (N, pattern :: rest)
+      } match {
+        case (N, _) => N
+        case (S(separated), rest) => S((separated, rest))
+      }
+    }
+    /**
+      * Split the pattern set into two pattern sets.
+      * 
+      * For example, let A be the base type of B, C, and D. Plus, class `Z` is
+      * unrelated to any of them. Suppose the initial pattern set is
+      * `{ A, B, C, Z }`. Splitting the set results in two sets, one set
+      * contains classes that are compatible with `A`, and the other set
+      * contains classes that are unrelated to `A`.
+      * 
+      * For example, if we split the set with `A`, then we get `{ B, C }` and
+      * set `{ Z }`. Set `{ B, C }` represents that the scrutinee can be further
+      * refined to class `B` or `class C`. Set `{ Z }` represents that if the
+      * scrutinee is not `A`, then it can be `Z`.
+      * 
+      * If `A` is sealed to `B`, `C`, and `D`, then we get `{ B, C, D }` and
+      * `{ Z }`. Because if the scrutinee is assumed to be `A`, then it can also
+      * be `D` other than `B`, `C`.
+      *
+      * @param classLikeSymbol the type symbol represents the class like type
+      * @return If the pattern set doesn't include the given type symbol, this
+      *         returns `None`. Otherwise, the function returns a triplet of the
+      *         locations where the pattern appears, the related patterns, and
+      *         unrelated patterns.
+      */
+    def split(classLikeSymbol: TypeSymbol): Opt[(Pattern.ClassLike, CaseSet, CaseSet)] = {
+      def mk(pattern: Pattern): Opt[Lit \/ TypeSymbol] = pattern match {
+        case Pattern.ClassLike(classLikeSymbol, _) => S(R(classLikeSymbol))
+        case Pattern.Literal(literal) => S(L(literal))
+        case _ => N
+      }
+      separate(classLikeSymbol) match {
+        case N => N
+        case S((pattern, patterns)) =>
+          val (unrelated, related) = patterns.partitionMap { otherPattern =>
+            if (compareCasePattern(mk(otherPattern), mk(pattern))) {
+              R(otherPattern)
+            } else {
+              L(otherPattern)
+            }
+          }
+          S((pattern, CaseSet(related), CaseSet(unrelated)))
+      }
+    }
+
+    @inline def remove(boolLit: Var): CaseSet = {
+      require(boolLit.name === "true" || boolLit.name === "false")
+      CaseSet(patterns.filter(!_.matches(boolLit)))
+    }
+
+    @inline def remove(literal: Lit): CaseSet =
+      CaseSet(patterns.filter(!_.matches(literal)))
+
+    @inline def isEmpty: Bool = patterns.isEmpty
+
+    @inline def size: Int = patterns.size
+  }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 7cb2b884da..d4ef2fd669 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -380,8 +380,8 @@ trait Desugaring { self: PreTyper =>
             scrutinee.getOrCreateLiteralPattern(literal).addLocation(literal)
             c.Branch(scrutineeVar, c.Pattern.Literal(literal), desugarRight) :: desugarTail
           case s.ConcretePattern(nme @ (Var("true") | Var("false"))) =>
-            scrutinee.getOrCreateBooleanPattern(nme).addLocation(nme)
             val classSymbol = nme.resolveClassLikeSymbol
+            scrutinee.getOrCreateClassPattern(classSymbol).addLocation(nme)
             c.Branch(
               scrutinee = scrutineeVar,
               pattern = c.Pattern.Class(nme, classSymbol, false),
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 6dbf532e24..cb3f2c8473 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -1,6 +1,6 @@
 package mlscript.ucs.stages
 
-import mlscript.{App, CaseOf, DecLit, Fld, FldFlags, IntLit, Let, Loc, Sel, Term, Tup, Var, StrLit}
+import mlscript.{App, CaseOf, DecLit, Fld, FldFlags, IntLit, Let, Lit, Loc, Sel, Term, Tup, Var, StrLit}
 import mlscript.{CaseBranches, Case, Wildcard, NoCases}
 import mlscript.Message, Message.MessageContext
 import mlscript.utils._, shorthands._
@@ -77,16 +77,14 @@ trait Normalization { self: Desugarer with Traceable =>
       case (Pattern.Literal(l1), Pattern.Literal(l2)) => l1 === l2
       case (_, _) => false
     }
-    /** Hard-code sub-typing relations. */
-    def <:<(other: Pattern): Bool = (self, other) match {
-      case (Pattern.Class(Var("true"), _, _), Pattern.Class(Var("Bool"), _, _)) => true
-      case (Pattern.Class(Var("false"), _, _), Pattern.Class(Var("Bool"), _, _)) => true
-      case (Pattern.Class(Var("Int"), _, _), Pattern.Class(Var("Num"), _, _)) => true
-      case (Pattern.Class(_, s1, _), Pattern.Class(_, s2, _)) => s1 hasBaseClass s2
-      case (Pattern.Literal(IntLit(_)), Pattern.Class(Var("Int" | "Num"), _, _)) => true
-      case (Pattern.Literal(StrLit(_)), Pattern.Class(Var("Str"), _, _)) => true
-      case (Pattern.Literal(DecLit(_)), Pattern.Class(Var("Num"), _, _)) => true
-      case (_, _) => false
+    /** Checks if `self` can be subsumed under `other`. */
+    def <:<(other: Pattern): Bool = {
+      def mk(pattern: Pattern): Opt[Lit \/ TypeSymbol] = pattern match {
+        case Pattern.Class(_, s, _) => S(R(s))
+        case Pattern.Literal(l) => S(L(l))
+        case _ => N
+      }
+      compareCasePattern(mk(self), mk(other))
     }
     /**
       * If two class-like patterns has different `refined` flag. Report the
diff --git a/shared/src/main/scala/mlscript/ucs/stages/package.scala b/shared/src/main/scala/mlscript/ucs/stages/package.scala
index 3be1c55595..15c98af6b9 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/package.scala
@@ -1,7 +1,7 @@
 package mlscript.ucs
 
-import mlscript.{App, Fld, FldFlags, Lit, PlainTup, Term, Tup, Var}
-import mlscript.pretyper.symbol._
+import mlscript.{App, DecLit, Fld, FldFlags, IntLit, Lit, PlainTup, StrLit, Term, Tup, Var}
+import mlscript.pretyper.symbol.TypeSymbol
 import mlscript.utils._, shorthands._
 
 package object stages {
@@ -65,4 +65,33 @@ package object stages {
         }
       case _ => (term, N)
     }
+
+  /**
+    * Hard-coded subtyping relations used in normalization and coverage checking.
+    * Pass literals in `L` and pass variables together with `TypeSymbol` in `R`.
+    */
+  private[ucs] def compareCasePattern(
+      lhs: Opt[Lit \/ TypeSymbol],
+      rhs: Opt[Lit \/ TypeSymbol]
+  ): Bool = (lhs, rhs) match {
+    case (S(lhs), S(rhs)) => compareCasePattern(lhs, rhs)
+    case (_, _) => false
+  }
+  /**
+    * Hard-coded subtyping relations used in normalization and coverage checking.
+    * Pass literals in `L` and pass variables together with `TypeSymbol` in `R`.
+    */
+  private[stages] def compareCasePattern(
+      lhs: Lit \/ TypeSymbol,
+      rhs: Lit \/ TypeSymbol
+  ): Bool = (lhs, rhs) match {
+    case (_, R(s)) if s.name === "Object" => true
+    case (R(s1), R(s2)) if (s1.name === "true" || s1.name === "false") && s2.name === "Bool" => true
+    case (R(s1), R(s2)) if s1.name === "Int" && s2.name === "Num" => true
+    case (R(s1), R(s2)) => s1 hasBaseClass s2
+    case (L(IntLit(_)), R(s)) if s.name === "Int" || s.name === "Num" => true
+    case (L(StrLit(_)), R(s)) if s.name === "Str" => true
+    case (L(DecLit(_)), R(s)) if s.name === "Num" => true
+    case (_, _) => false
+  }
 }
diff --git a/shared/src/test/diff/pretyper/Errors.mls b/shared/src/test/diff/pretyper/Errors.mls
index 28349ca025..c6226359ec 100644
--- a/shared/src/test/diff/pretyper/Errors.mls
+++ b/shared/src/test/diff/pretyper/Errors.mls
@@ -471,7 +471,7 @@ abstract class Foo: (Int -> Int) {
 
 // Object
 Object
-//│ ╔══[ERROR] identifier `Object` not found
+//│ ╔══[ERROR] identifier `Object` is resolved to a type
 //│ ║  l.473: 	Object
 //│ ╙──       	^^^^^^
 //│ ╔══[ERROR] Class Object is abstract and cannot be instantiated
diff --git a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
index e3a2457328..0225a01ba4 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
@@ -151,3 +151,32 @@ fun test(x, p) = if x is
 //│             case x*‡ of
 //│               false*† -> "true"
 //│ fun test: forall 'a. ('a & Bool, (Bool & 'a) -> Bool) -> ("false" | "great" | "true")
+
+:ducs:postprocess.result
+:ge
+fun test(x, p) = if x is
+  Object and p(x) then "great"
+  Bool and p(x) then "great, again"
+  true then "false"
+  false then "true"
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   refined Object*◊ ->
+//│     let ucs$test$0*† = p(x,) : Bool
+//│     case ucs$test$0*† of
+//│       true*† -> "great"
+//│       _ ->
+//│         case x*‡ of
+//│           refined Bool*◊ ->
+//│             let ucs$test$1*† = p(x,) : Bool
+//│             case ucs$test$1*† of
+//│               true*† -> "great, again"
+//│               _ ->
+//│                 case x*‡ of
+//│                   true*† -> "false"
+//│                   _ ->
+//│                     case x*‡ of
+//│                       false*† -> "true"
+//│ fun test: forall 'a. ('a & Bool, (Object & 'a) -> Bool) -> ("false" | "great" | "great, again" | "true")
+//│ Code generation encountered an error:
+//│   unknown match case: Object
diff --git a/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls b/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
index 11f8763ee5..5ce3d3110c 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/PostProcessing.mls
@@ -10,10 +10,10 @@ fun mixed_literals(v) =
 //│ Post-processed UCS term:
 //│ case v*‡ of
 //│   true*† -> "true"
-//│   false*† -> "false"
 //│   2 -> "2"
 //│   1 -> "1"
-//│ Desugared term: case v of { true => "true"; false => "false"; 2 => "2"; 1 => "1" }
+//│   false*† -> "false"
+//│ Desugared term: case v of { true => "true"; 2 => "2"; 1 => "1"; false => "false" }
 //│ fun mixed_literals: (1 | 2 | false | true) -> ("1" | "2" | "false" | "true")
 
 :ducs:postprocess.result
diff --git a/shared/src/test/diff/ucs/ElseIf.mls b/shared/src/test/diff/ucs/ElseIf.mls
index a24afcc3e0..99df8ea09e 100644
--- a/shared/src/test/diff/ucs/ElseIf.mls
+++ b/shared/src/test/diff/ucs/ElseIf.mls
@@ -86,13 +86,13 @@ fun g(x, y) = if x is
 //│ ╔══[ERROR] `y` has 1 missing case
 //│ ║  l.84: 	  true and y is true then true
 //│ ║        	           ^
-//│ ╟── it can be Boolean value false
+//│ ╟── it can be Boolean value `false`
 //│ ║  l.85: 	  false and y is false then false
 //│ ╙──      	                 ^^^^^
 //│ ╔══[ERROR] `y` has 1 missing case
 //│ ║  l.85: 	  false and y is false then false
 //│ ║        	            ^
-//│ ╟── it can be Boolean value true
+//│ ╟── it can be Boolean value `true`
 //│ ║  l.84: 	  true and y is true then true
 //│ ╙──      	                ^^^^
 //│ fun g: (Bool, nothing) -> Bool

From 89a9c6f71978085bcf3c38dfdfe2b3a37eaa1928 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 24 Jan 2024 02:26:46 +0800
Subject: [PATCH 100/147] Fix post-processing cannot handle test branches

---
 .../mlscript/ucs/stages/PostProcessing.scala     |  3 +++
 .../diff/pretyper/ucs/stages/Normalization.mls   | 16 +++++-----------
 shared/src/test/diff/ucs/OverlappedBranches.mls  |  2 +-
 3 files changed, 9 insertions(+), 12 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index a955e9f240..5d435d33a2 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -14,6 +14,9 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
   def postProcess(term: Term)(implicit context: Context): Term = trace(s"postProcess <== ${term.showDbg}") {
     // Normalized terms are constructed using `Let` and `CaseOf`.
     term match {
+      case top @ CaseOf(testVar: Var, fst @ Case(Var("true"), trueBranch, Wildcard(falseBranch))) if context.isTestVar(testVar) =>
+        println(s"TEST: ${testVar.name}")
+        top.copy(cases = fst.copy(body = postProcess(trueBranch), rest = Wildcard(postProcess(falseBranch)))(refined = fst.refined))
       case top @ CaseOf(Scrutinee(_), Wildcard(body)) => body
       case top @ CaseOf(Scrutinee.WithVar(scrutinee, scrutineeVar), fst @ Case(className: Var, body, NoCases)) =>
         println(s"UNARY: ${scrutineeVar.name} is ${className.name}")
diff --git a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
index 0225a01ba4..4c6c885dc9 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
@@ -127,11 +127,9 @@ fun test(x, p) = if x is
 //│       _ ->
 //│         case x*‡ of
 //│           2.71828 -> "E"
-//│           _ ->
-//│             case x*‡ of
-//│               3.14159 -> "PI"
-//│               _ -> "other"
-//│ fun test: forall 'a. ('a & (2.71828 | Num & ~2.71828), (Num & 'a) -> Bool) -> ("E" | "PI" | "great" | "other")
+//│           3.14159 -> "PI"
+//│           _ -> "other"
+//│ fun test: forall 'a. ('a & (2.71828 | 3.14159 | Num & ~2.71828 & ~3.14159), (Num & 'a) -> Bool) -> ("E" | "PI" | "great" | "other")
 
 :ducs:postprocess.result
 fun test(x, p) = if x is
@@ -147,9 +145,7 @@ fun test(x, p) = if x is
 //│       _ ->
 //│         case x*‡ of
 //│           true*† -> "false"
-//│           _ ->
-//│             case x*‡ of
-//│               false*† -> "true"
+//│           false*† -> "true"
 //│ fun test: forall 'a. ('a & Bool, (Bool & 'a) -> Bool) -> ("false" | "great" | "true")
 
 :ducs:postprocess.result
@@ -174,9 +170,7 @@ fun test(x, p) = if x is
 //│               _ ->
 //│                 case x*‡ of
 //│                   true*† -> "false"
-//│                   _ ->
-//│                     case x*‡ of
-//│                       false*† -> "true"
+//│                   false*† -> "true"
 //│ fun test: forall 'a. ('a & Bool, (Object & 'a) -> Bool) -> ("false" | "great" | "great, again" | "true")
 //│ Code generation encountered an error:
 //│   unknown match case: Object
diff --git a/shared/src/test/diff/ucs/OverlappedBranches.mls b/shared/src/test/diff/ucs/OverlappedBranches.mls
index 132141356a..00a4444662 100644
--- a/shared/src/test/diff/ucs/OverlappedBranches.mls
+++ b/shared/src/test/diff/ucs/OverlappedBranches.mls
@@ -54,7 +54,7 @@ fun f2(x, p) = if x is
   Derived1 then "d1"
   Derived2 then "d2"
   else "otherwise"
-//│ fun f2: forall 'a. ('a & (Base & ~#Derived1 | Derived1), (Base & 'a) -> Bool) -> ("b and p" | "d1" | "d2" | "otherwise")
+//│ fun f2: forall 'a. ('a & (Base & ~#Derived1 & ~#Derived2 | Derived1 | Derived2), (Base & 'a) -> Bool) -> ("b and p" | "d1" | "d2" | "otherwise")
 
 f2(Base(), _ => true) // => b and p
 f2(Base(), _ => false) // otherwise

From 357d7385445d265d9fe1148ea56032e0c44daa33 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 24 Jan 2024 02:30:50 +0800
Subject: [PATCH 101/147] Fix a mistake from a previous commit

---
 js/src/main/scala/Main.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/js/src/main/scala/Main.scala b/js/src/main/scala/Main.scala
index a67f8ce8a3..1cfa2096f5 100644
--- a/js/src/main/scala/Main.scala
+++ b/js/src/main/scala/Main.scala
@@ -159,7 +159,7 @@ object Main {
                             |""".stripMargin
 
           val backend = new JSWebBackend()
-          val (lines, resNames) = backend(pgrm, true)
+          val (lines, resNames) = backend(pgrm)
           val code = lines.mkString("\n")
 
           // TODO: add a toggle button to show js code

From 03ead0e2c386d4bb6ffdc615a9e9e4b198e0a052 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 24 Jan 2024 02:44:59 +0800
Subject: [PATCH 102/147] Clean up `TODO` and document mutable variables

---
 .../main/scala/mlscript/ucs/Desugarer.scala   |  8 +++---
 .../mlscript/ucs/stages/Desugaring.scala      |  1 -
 .../main/scala/mlscript/ucs/syntax/core.scala | 26 +++++++------------
 3 files changed, 13 insertions(+), 22 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/Desugarer.scala b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
index 8c3a7a2128..d5b7719cdf 100644
--- a/shared/src/main/scala/mlscript/ucs/Desugarer.scala
+++ b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
@@ -78,13 +78,13 @@ trait Desugarer extends Transformation
 
     /**
       * A short hand for `nme.symbol.getScrutinee` but add a diagnostic message
-      * to a local diagnostic archive (TODO) if there's any error.
+      * to a local diagnostic archive if there's any error.
       */
     def getOrCreateScrutinee(implicit context: Context): Scrutinee = nme.symbolOption match {
       case S(symbol: TermSymbol) => symbol.getOrCreateScrutinee
       case S(otherSymbol) =>
         raiseDesugaringError(msg"cannot identifier `${nme.name}` with a scrutinee" -> nme.toLoc)
-        context.freshScrutinee // TODO
+        context.freshScrutinee
       case N => lastWords(s"`${nme.name}` should be assoicated with a symbol")
     }
 
@@ -109,7 +109,7 @@ trait Desugarer extends Transformation
         case S(symbol: TermSymbol) => symbol
         case S(otherSymbol) =>
           raiseDesugaringError(msg"identifier `${nme.name}` should be a term" -> nme.toLoc)
-          freshSymbol(nme) // TODO: Maybe we should maintain a "lost" symbol map.
+          freshSymbol(nme)
       }
     }
 
@@ -117,7 +117,7 @@ trait Desugarer extends Transformation
     def resolveTermSymbol(implicit scope: Scope): TermSymbol = {
       val symbol = scope.getTermSymbol(nme.name).getOrElse {
         raiseDesugaringError(msg"identifier `${nme.name}` not found" -> nme.toLoc)
-        freshSymbol(nme) // TODO: Maybe we should maintain a "lost" symbol map.
+        freshSymbol(nme)
       }
       nme.symbol = symbol
       symbol
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index d4ef2fd669..5fe5e56950 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -298,7 +298,6 @@ trait Desugaring { self: PreTyper =>
       }
     }()
 
-  // TODO: `aliasVars` not computed
   private def flattenTupleFields(
       parentScrutineeVar: Var,
       parentScrutinee: Scrutinee,
diff --git a/shared/src/main/scala/mlscript/ucs/syntax/core.scala b/shared/src/main/scala/mlscript/ucs/syntax/core.scala
index db52d4e754..fa73d74e19 100644
--- a/shared/src/main/scala/mlscript/ucs/syntax/core.scala
+++ b/shared/src/main/scala/mlscript/ucs/syntax/core.scala
@@ -24,28 +24,21 @@ package object core {
       override def children: Ls[Located] = nme :: Nil
     }
     /**
-      * TODO: Consider make `refined` immutable.
       * @param nme the name of the class-like symbol
       * @param originallyRefined whether the class is marked as refined from
-      *                          in source code
+      *                          in source AST
       */
-    final case class Class(nme: Var, symbol: TypeSymbol, val originallyRefined: Bool) extends Pattern {
+    final case class Class(nme: Var, symbol: TypeSymbol, originallyRefined: Bool) extends Pattern {
       override def children: Ls[Located] = nme :: Nil
 
+      /**
+        * A mutable field to override the refinement status of the class. 
+        * During normalization, if a case can be further refined in its
+        * descendants branches, we should mark it as `refined`. See relevant
+        * tests in `Normalization.mls`.
+        */
       var refined: Bool = originallyRefined
     }
-
-    def getParametersLoc(parameters: List[Opt[Var]]): Opt[Loc] =
-      parameters.foldLeft(None: Opt[Loc]) {
-        case (acc, N) => acc
-        case (N, S(nme)) => nme.toLoc
-        case (S(loc), S(nme)) => S(nme.toLoc.fold(loc)(loc ++ _))
-      }
-    def getParametersLoc(parameters: Opt[List[Opt[Var]]]): Opt[Loc] =
-      parameters.fold(None: Opt[Loc])(getParametersLoc)
-
-    def showParameters(parameters: Opt[List[Opt[Var]]]): Str =
-      parameters.fold("empty")(_.map(_.fold("_")(_.name)).mkString("[", ", ", "]"))
   }
 
   final case class Branch(scrutinee: Var, pattern: Pattern, continuation: Split) extends Located {
@@ -53,8 +46,7 @@ package object core {
   }
 
   sealed abstract class Split extends Located {
-    @inline
-    def ::(head: Branch): Split = Split.Cons(head, this)
+    @inline def ::(head: Branch): Split = Split.Cons(head, this)
     
     /**
       * Returns true if the split has an else branch.

From 52b4505ed32f590f65d4e65d11f087aa8e1308a6 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 24 Jan 2024 03:07:31 +0800
Subject: [PATCH 103/147] Remove useless helper functions

---
 .../mlscript/ucs/context/Scrutinee.scala      |  6 ++-
 .../scala/mlscript/ucs/context/package.scala  |  9 ----
 .../ucs/stages/CoverageChecking.scala         | 10 ++--
 .../mlscript/ucs/stages/Desugaring.scala      |  4 +-
 .../mlscript/ucs/stages/Normalization.scala   |  8 ++--
 .../mlscript/ucs/stages/PartialTerm.scala     |  8 ++--
 .../mlscript/ucs/stages/PostProcessing.scala  |  6 +--
 .../scala/mlscript/ucs/stages/package.scala   | 47 +++----------------
 8 files changed, 28 insertions(+), 70 deletions(-)
 delete mode 100644 shared/src/main/scala/mlscript/ucs/context/package.scala

diff --git a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
index b8b0380594..9d8dc7b61b 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
@@ -120,10 +120,12 @@ object Scrutinee {
     case _ => N
   }
 
+  type WithVar = Var -> Scrutinee
+
   object WithVar {
-    def unapply(term: Term)(implicit context: Context): Opt[(Scrutinee, Var)] = term match {
+    def unapply(term: Term)(implicit context: Context): Opt[WithVar] = term match {
       case v @ Var(_) => v.symbol match {
-        case symbol: TermSymbol => symbol.getScrutinee.map(_ -> v)
+        case symbol: TermSymbol => symbol.getScrutinee.map(v -> _)
         case _ => N
       }
       case _ => N
diff --git a/shared/src/main/scala/mlscript/ucs/context/package.scala b/shared/src/main/scala/mlscript/ucs/context/package.scala
deleted file mode 100644
index d9c6e3191c..0000000000
--- a/shared/src/main/scala/mlscript/ucs/context/package.scala
+++ /dev/null
@@ -1,9 +0,0 @@
-package mlscript.ucs
-
-import mlscript.{Loc, Var}
-import mlscript.pretyper.symbol.TypeSymbol
-import mlscript.utils._, shorthands._
-
-package object context {
-  type NamedScrutinee = (Var -> Scrutinee)
-}
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index 45e92149a9..2639c99a1c 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -4,7 +4,7 @@ import mlscript.{Case, CaseBranches, CaseOf, Let, Lit, Loc, NoCases, Term, Var,
 import mlscript.{Diagnostic, ErrorReport, WarningReport}
 import mlscript.Message, Message.MessageContext
 import mlscript.ucs.Desugarer
-import mlscript.ucs.context.{Context, NamedScrutinee, Pattern, Scrutinee}
+import mlscript.ucs.context.{Context, Pattern, Scrutinee}
 import mlscript.pretyper.Traceable
 import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
@@ -39,7 +39,7 @@ trait CoverageChecking { self: Desugarer with Traceable =>
         println(s"checkCoverage <== TEST `${scrutineeVar.name}`")
         checkCoverage(whenTrue, pending, working, seen) ++
           checkCoverage(whenFalse, pending, working, seen)
-      case CaseOf(Scrutinee.WithVar(scrutinee, scrutineeVar), cases) =>
+      case CaseOf(Scrutinee.WithVar(scrutineeVar, scrutinee), cases) =>
         trace(s"checkCoverage <== ${pending.size} pending, ${working.size} working, ${seen.size} seen") {
           println(s"CASE ${scrutineeVar.name}")
           println(s"SEEN: ${seen.showDbg}")
@@ -131,7 +131,7 @@ trait CoverageChecking { self: Desugarer with Traceable =>
 object CoverageChecking {
   /** Create an `ErrorReport` that explains missing cases. */
   private def explainMissingCases(
-      scrutinee: NamedScrutinee,
+      scrutinee: Scrutinee.WithVar,
       seen: SeenRegistry,
       missingCases: CaseSet
   )(implicit context: Context): Opt[ErrorReport] =
@@ -164,9 +164,9 @@ object CoverageChecking {
         matchedClasses.patterns.iterator.map(_.showInDiagnostics).mkString(s">>> ${scrutineeVar.name} => [", ", ", "]")
       }.mkString("\n", "\n", "")
 
-  type ScrutineePatternSetMap = Map[NamedScrutinee, CaseSet]
+  type ScrutineePatternSetMap = Map[Scrutinee.WithVar, CaseSet]
 
-  type SeenRegistry = Map[NamedScrutinee, (TypeSymbol, Ls[Loc], CaseSet)]
+  type SeenRegistry = Map[Scrutinee.WithVar, (TypeSymbol, Ls[Loc], CaseSet)]
 
   implicit class SeenRegistryOps(val self: SeenRegistry) extends AnyVal {
     def showDbg: Str = if (self.isEmpty) "empty" else
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 5fe5e56950..1a22952b4c 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -1,6 +1,6 @@
 package mlscript.ucs.stages
 
-import mlscript.{App, Asc, Fld, FldFlags, Lit, Sel, Term, Tup, TypeName, Var}
+import mlscript.{App, Asc, Fld, FldFlags, Lit, Sel, PlainTup, Term, Tup, TypeName, Var}
 import mlscript.ucs.syntax.{core => c, source => s}
 import mlscript.ucs.context.{Context, Scrutinee}
 import mlscript.utils._, shorthands._
@@ -388,7 +388,7 @@ trait Desugaring { self: PreTyper =>
             ) :: desugarTail
           case s.ConcretePattern(nme) =>
             val testVar = context.freshTest().withFreshSymbol
-            val testTerm = mkBinOp(scrutineeVar, Var("==="), nme, true)
+            val testTerm = App(Var("==="), PlainTup(scrutineeVar, nme))
             c.Split.Let(false, testVar, testTerm,
               c.Branch(testVar, truePattern, desugarRight(scope + testVar.symbol)) :: desugarTail)
           case s.EmptyPattern(_) | s.NamePattern(Var("_")) =>
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index cb3f2c8473..8871c34c44 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -136,7 +136,7 @@ trait Normalization { self: Desugarer with Traceable =>
         val trueBranch = normalizeToTerm(continuation.fill(tail, declaredVars, false), declaredVars)
         val falseBranch = normalizeToCaseBranches(tail, declaredVars)
         CaseOf(test, Case(nme, trueBranch, falseBranch)(refined = false))
-      case Split.Cons(Branch(Scrutinee.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Literal(literal), continuation), tail) =>
+      case Split.Cons(Branch(Scrutinee.WithVar(scrutineeVar, scrutinee), pattern @ Pattern.Literal(literal), continuation), tail) =>
         println(s"LITERAL: ${scrutineeVar.name} is ${literal.idStr}")
         println(s"entire split: ${showSplit(split)}")
         val concatenatedTrueBranch = continuation.fill(tail, declaredVars, false)
@@ -145,7 +145,7 @@ trait Normalization { self: Desugarer with Traceable =>
         // println(s"false branch: ${showSplit(tail)}")
         val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context), declaredVars)
         CaseOf(scrutineeVar, Case(literal, trueBranch, falseBranch)(refined = false))
-      case Split.Cons(Branch(Scrutinee.WithVar(scrutinee, scrutineeVar), pattern @ Pattern.Class(nme, _, rfd), continuation), tail) =>
+      case Split.Cons(Branch(Scrutinee.WithVar(scrutineeVar, scrutinee), pattern @ Pattern.Class(nme, _, rfd), continuation), tail) =>
         println(s"CLASS: ${scrutineeVar.name} is ${nme.name}")
         // println(s"match ${scrutineeVar.name} with $nme (has location: ${nme.toLoc.isDefined})")
         val trueBranch = normalizeToTerm(specialize(continuation.fill(tail, declaredVars, false), true)(scrutineeVar, scrutinee, pattern, context), declaredVars)
@@ -211,7 +211,7 @@ trait Normalization { self: Desugarer with Traceable =>
       case (m, Split.Cons(head @ Branch(test, Pattern.Class(Var("true"), _, _), continuation), tail)) if context.isTestVar(test) =>
         println(s"TEST: ${test.name} is true")
         head.copy(continuation = specialize(continuation, m)) :: specialize(tail, m)
-      case (true, split @ Split.Cons(head @ Branch(Scrutinee.WithVar(otherScrutinee, otherScrutineeVar), otherPattern, continuation), tail)) =>
+      case (true, split @ Split.Cons(head @ Branch(Scrutinee.WithVar(otherScrutineeVar, otherScrutinee), otherPattern, continuation), tail)) =>
         if (scrutinee === otherScrutinee) {
           println(s"Case 1: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
           if (otherPattern =:= pattern) {
@@ -229,7 +229,7 @@ trait Normalization { self: Desugarer with Traceable =>
           println(s"Case 2: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
           head.copy(continuation = specialize(continuation, true)) :: specialize(tail, true)
         }
-      case (false, split @ Split.Cons(head @ Branch(Scrutinee.WithVar(otherScrutinee, otherScrutineeVar), otherPattern, continuation), tail)) =>
+      case (false, split @ Split.Cons(head @ Branch(Scrutinee.WithVar(otherScrutineeVar, otherScrutinee), otherPattern, continuation), tail)) =>
         if (scrutinee === otherScrutinee) {
           println(s"Case 1: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
           otherPattern reportInconsistentRefinedWith pattern
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PartialTerm.scala b/shared/src/main/scala/mlscript/ucs/stages/PartialTerm.scala
index 7dac085bd7..dc13f689f0 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PartialTerm.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PartialTerm.scala
@@ -1,6 +1,6 @@
 package mlscript.ucs.stages
 
-import mlscript.{Term, Var}, mlscript.utils._, shorthands._
+import mlscript.{App, PlainTup, Term, Var}, mlscript.utils._, shorthands._
 
 /**
   * A `PartialTerm` represents a possibly incomplete term.
@@ -36,11 +36,11 @@ object PartialTerm {
   final case class Half(lhs: Term, op: Var, parts: Ls[Term]) extends Incomplete {
     override def terms: Iterator[Term] = parts.reverseIterator
     def addTerm(rhs: Term): Total = {
-      val (realRhs, extraExprOpt) = separatePattern(rhs, true)
-      val leftmost = mkBinOp(lhs, op, realRhs, true)
+      val (realRhs, extraExprOpt) = separatePattern(rhs)
+      val leftmost = App(op, PlainTup(lhs, realRhs))
       extraExprOpt match {
         case N            => Total(leftmost, parts)
-        case S(extraExpr) => Total(mkBinOp(leftmost, Var("and"), extraExpr, true), extraExpr :: parts)
+        case S(extraExpr) => Total(App(Var("and"), PlainTup(leftmost, extraExpr)), extraExpr :: parts)
       }
     }
   }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index 5d435d33a2..52d385b1cf 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -18,10 +18,10 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
         println(s"TEST: ${testVar.name}")
         top.copy(cases = fst.copy(body = postProcess(trueBranch), rest = Wildcard(postProcess(falseBranch)))(refined = fst.refined))
       case top @ CaseOf(Scrutinee(_), Wildcard(body)) => body
-      case top @ CaseOf(Scrutinee.WithVar(scrutinee, scrutineeVar), fst @ Case(className: Var, body, NoCases)) =>
+      case top @ CaseOf(Scrutinee.WithVar(scrutineeVar, scrutinee), fst @ Case(className: Var, body, NoCases)) =>
         println(s"UNARY: ${scrutineeVar.name} is ${className.name}")
         top.copy(cases = fst.copy(body = postProcess(body))(refined = fst.refined))
-      case top @ CaseOf(Scrutinee.WithVar(scrutinee, scrutineeVar), fst @ Case(pat, trueBranch, Wildcard(falseBranch))) =>
+      case top @ CaseOf(Scrutinee.WithVar(scrutineeVar, scrutinee), fst @ Case(pat, trueBranch, Wildcard(falseBranch))) =>
         println(s"BINARY: ${scrutineeVar.name} is ${pat.showDbg}")
         println(s"patterns of `${scrutineeVar.name}`: ${scrutinee.showPatternsDbg}")
         // Post-process the true branch.
@@ -152,7 +152,7 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
   ): (Term, Opt[Term]) = {
     def rec(term: Term): (Term, Opt[Term]) =
       term match {
-        case top @ CaseOf(Scrutinee.WithVar(otherScrutinee, otherScrutineeVar), cases) =>
+        case top @ CaseOf(Scrutinee.WithVar(otherScrutineeVar, otherScrutinee), cases) =>
           if (scrutinee === otherScrutinee) {
             println(s"found a `CaseOf` that matches on `${scrutineeVar.name}`")
             val (n, y) = disentangleMatchedCaseBranches(cases)
diff --git a/shared/src/main/scala/mlscript/ucs/stages/package.scala b/shared/src/main/scala/mlscript/ucs/stages/package.scala
index 15c98af6b9..fe25dd0082 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/package.scala
@@ -5,30 +5,6 @@ import mlscript.pretyper.symbol.TypeSymbol
 import mlscript.utils._, shorthands._
 
 package object stages {
-  /**
-    * Make a tuple with only one element. For example,
-    * 
-    * ```scala
-    * mkMonuple(t) = Tup(N -> Fld(false, false, t) :: Nil)
-    * ```
-    *
-    * @param t the sole element
-    * @return a tuple term with the only element
-    */
-  def mkMonuple(t: Term): Tup = Tup(N -> Fld(FldFlags.empty, t) :: Nil)
-
-  /**
-    * Make a binary operation.
-    *
-    * @param lhs the left-hand side term
-    * @param op the operator
-    * @param rhs the right-hand side term
-    * @return something like `App(App(op, lhs), rhs)`
-    */
-  def mkBinOp(lhs: Term, op: Var, rhs: Term, newDefs: Bool): Term =
-    if (newDefs) App(op, PlainTup(lhs, rhs))
-    else App(App(op, mkMonuple(lhs)), mkMonuple(rhs))
-
   /**
     * Split a term into two parts: the pattern and the extra test.
     * This is used to extract patterns from UCS conjunctions. For example,
@@ -47,24 +23,13 @@ package object stages {
     * @return a tuple, whose the first element is the pattern and the second
     *   element is the extra test
     */
-  def separatePattern(term: Term, newDefs: Bool): (Term, Opt[Term]) =
-    term match {
-      case App(
-        App(and @ Var("and"),
-            Tup((_ -> Fld(_, lhs)) :: Nil)),
-        Tup((_ -> Fld(_, rhs)) :: Nil)
-      ) => // * Old-style operators
-        separatePattern(lhs, newDefs) match {
-          case (pattern, N) => (pattern, S(rhs))
-          case (pattern, S(lshRhs)) => (pattern, S(mkBinOp(lshRhs, and, rhs, newDefs)))
-        }
-      case App(and @ Var("and"), PlainTup(lhs, rhs)) =>
-        separatePattern(lhs, newDefs) match {
-          case (pattern, N) => (pattern, S(rhs))
-          case (pattern, S(lshRhs)) => (pattern, S(mkBinOp(lshRhs, and, rhs, newDefs)))
-        }
-      case _ => (term, N)
+  def separatePattern(term: Term): (Term, Opt[Term]) = term match {
+    case App(and @ Var("and"), PlainTup(lhs, rhs)) => separatePattern(lhs) match {
+      case (pattern, N) => (pattern, S(rhs))
+      case (pattern, S(lhsRhs)) => (pattern, S(App(and, PlainTup(lhsRhs, rhs))))
     }
+    case _ => (term, N)
+  }
 
   /**
     * Hard-coded subtyping relations used in normalization and coverage checking.

From 2061c9499393e9edbfd65fdc9bd2621fb29e0813 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 3 Feb 2024 14:26:24 +0800
Subject: [PATCH 104/147] Found a bug in specialization

---
 .../pretyper/ucs/stages/Normalization.mls     | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
index 4c6c885dc9..ec861498f2 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
@@ -112,6 +112,27 @@ fun test(x, p) = if x is
 //│           _ -> "qax"
 //│ fun test: forall 'a. (Str & 'a, (Str & 'a) -> Bool) -> ("bar" | "foo" | "qax")
 
+// This should work, but it doesn't.
+test(0, _ => true)
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.116: 	test(0, _ => true)
+//│ ║         	^^^^^^^^^^^^^^^^^^
+//│ ╟── integer literal of type `0` is not an instance of type `Str`
+//│ ║  l.116: 	test(0, _ => true)
+//│ ║         	     ^
+//│ ╟── Note: constraint arises from class pattern:
+//│ ║  l.100: 	  Str and p(x) then "foo"
+//│ ║         	  ^^^
+//│ ╟── from reference:
+//│ ║  l.99: 	fun test(x, p) = if x is
+//│ ╙──      	                    ^
+//│ TEST CASE FAILURE: There was an unexpected type error
+//│ "bar" | "foo" | "qax" | error
+//│ res
+//│ TEST CASE FAILURE: There was an unexpected runtime error
+//│ Runtime error:
+//│   ReferenceError: string is not defined
+
 :ducs:postprocess.result
 fun test(x, p) = if x is
   Num and p(x) then "great"

From 832858efeeff34fb16f4c0c28142af4843ba3843 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 3 Feb 2024 14:28:49 +0800
Subject: [PATCH 105/147] Fix the specialization bug indicated by previous
 commit

---
 .../src/main/scala/mlscript/JSBackend.scala   |  6 ++--
 .../mlscript/ucs/stages/Normalization.scala   |  2 +-
 .../pretyper/ucs/SpecilizationCollision.mls   |  8 +++--
 .../pretyper/ucs/stages/Normalization.mls     | 29 +++++--------------
 .../src/test/diff/ucs/OverlappedBranches.mls  |  2 +-
 5 files changed, 18 insertions(+), 29 deletions(-)

diff --git a/shared/src/main/scala/mlscript/JSBackend.scala b/shared/src/main/scala/mlscript/JSBackend.scala
index b6cd187597..9c10f8e0d1 100644
--- a/shared/src/main/scala/mlscript/JSBackend.scala
+++ b/shared/src/main/scala/mlscript/JSBackend.scala
@@ -364,11 +364,11 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
         case Var("Int") if !oldDefs =>
           JSInvoke(JSField(JSIdent("Number"), "isInteger"), scrut :: Nil)
         case Var("Num") if !oldDefs =>
-          JSBinary("===", scrut.typeof(), JSLit("number"))
+          JSBinary("===", scrut.typeof(), JSLit(JSLit.makeStringLiteral("number")))
         case Var("Bool") if !oldDefs =>
-          JSBinary("===", scrut.typeof(), JSLit("boolean"))
+          JSBinary("===", scrut.typeof(), JSLit(JSLit.makeStringLiteral("boolean")))
         case Var("Str") if !oldDefs =>
-          JSBinary("===", scrut.typeof(), JSLit("string"))
+          JSBinary("===", scrut.typeof(), JSLit(JSLit.makeStringLiteral("string")))
         case Var("bool") =>
           JSBinary("===", scrut.member("constructor"), JSLit("Boolean"))
         case Var(s @ ("true" | "false")) =>
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 8871c34c44..e136274637 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -238,7 +238,7 @@ trait Normalization { self: Desugarer with Traceable =>
             specialize(tail, false)
           } else if (otherPattern <:< pattern) {
             println(s"Case 2.2: $pattern <:< $otherPattern")
-            Split.Nil
+            specialize(tail, false)
           } else {
             println(s"Case 2.3: $pattern are unrelated with $otherPattern")
             split.copy(tail = specialize(tail, false))
diff --git a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
index c8be562599..5caea1d3bf 100644
--- a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
+++ b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
@@ -59,6 +59,7 @@ fun example3(t) =
 //│             let y*‡ = (ucs$args_t$Derived).0
 //│             y
 //│           _ -> 42
+//│   _ -> 42
 //│ | | | | | | | STEP 4
 //│ | | | | | | | collected match registry: 
 //│ | | | | | | | >>> t => [class `Base`, class `Derived`]
@@ -89,10 +90,11 @@ fun example3(t) =
 //│ | | | | | | | | | remaining cases should be covered by the wildcard
 //│ | | | | | | | | | checkCoverage <== TERM 42
 //│ | | | | | | | | checkCoverage ==> 0 diagnostics
-//│ | | | | | | | | remaining cases are not covered: []
+//│ | | | | | | | | remaining cases should be covered by the wildcard
+//│ | | | | | | | | checkCoverage <== TERM 42
 //│ | | | | | | | checkCoverage ==> 0 diagnostics
 //│ | | | | | | | Coverage checking result: 0 errors
-//│ fun example3: forall 'a. (Base & {#x: Num & 'a}) -> (Int | 'a)
+//│ fun example3: forall 'a. (Base & {#x: Num & 'a} | Object & ~#Base) -> (Int | 'a)
 
 fun example4(t, x) =
   if t is
@@ -103,7 +105,7 @@ fun example4(t, x) =
     // previous branch shadows the variable `x`, a correct implementation
     // should restore the original value of `x` in this branch.
     else 42
-//│ fun example4: forall 'a. (Base & {#x: Num & 'a}, Int) -> (Int | 'a)
+//│ fun example4: forall 'a. (Base & {#x: Num & 'a} | Object & ~#Base, Int) -> (Int | 'a)
 
 example4(Base(-1), 0) ~~> -1
 example4(Base(1), 2) ~~> 42
diff --git a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
index ec861498f2..b2f41c39c8 100644
--- a/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
+++ b/shared/src/test/diff/pretyper/ucs/stages/Normalization.mls
@@ -93,7 +93,8 @@ fun test(x, p) = if x is
 //│         case x*‡ of
 //│           0 -> "bar"
 //│           _ -> "qax"
-//│ fun test: forall 'a. (Int & 'a, (Int & 'a) -> Bool) -> ("bar" | "foo" | "qax")
+//│   _ -> "qax"
+//│ fun test: forall 'a. (Int & 'a | Object & ~Int, (Int & 'a) -> Bool) -> ("bar" | "foo" | "qax")
 
 :ducs:postprocess.result
 fun test(x, p) = if x is
@@ -110,28 +111,13 @@ fun test(x, p) = if x is
 //│         case x*‡ of
 //│           "lol" -> "bar"
 //│           _ -> "qax"
-//│ fun test: forall 'a. (Str & 'a, (Str & 'a) -> Bool) -> ("bar" | "foo" | "qax")
+//│   _ -> "qax"
+//│ fun test: forall 'a. (Object & ~Str | Str & 'a, (Str & 'a) -> Bool) -> ("bar" | "foo" | "qax")
 
-// This should work, but it doesn't.
 test(0, _ => true)
-//│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.116: 	test(0, _ => true)
-//│ ║         	^^^^^^^^^^^^^^^^^^
-//│ ╟── integer literal of type `0` is not an instance of type `Str`
-//│ ║  l.116: 	test(0, _ => true)
-//│ ║         	     ^
-//│ ╟── Note: constraint arises from class pattern:
-//│ ║  l.100: 	  Str and p(x) then "foo"
-//│ ║         	  ^^^
-//│ ╟── from reference:
-//│ ║  l.99: 	fun test(x, p) = if x is
-//│ ╙──      	                    ^
-//│ TEST CASE FAILURE: There was an unexpected type error
-//│ "bar" | "foo" | "qax" | error
+//│ "bar" | "foo" | "qax"
 //│ res
-//│ TEST CASE FAILURE: There was an unexpected runtime error
-//│ Runtime error:
-//│   ReferenceError: string is not defined
+//│     = 'qax'
 
 :ducs:postprocess.result
 fun test(x, p) = if x is
@@ -150,7 +136,8 @@ fun test(x, p) = if x is
 //│           2.71828 -> "E"
 //│           3.14159 -> "PI"
 //│           _ -> "other"
-//│ fun test: forall 'a. ('a & (2.71828 | 3.14159 | Num & ~2.71828 & ~3.14159), (Num & 'a) -> Bool) -> ("E" | "PI" | "great" | "other")
+//│   _ -> "other"
+//│ fun test: forall 'a. (Object & ~Num | 'a & (2.71828 | 3.14159 | Num & ~2.71828 & ~3.14159), (Num & 'a) -> Bool) -> ("E" | "PI" | "great" | "other")
 
 :ducs:postprocess.result
 fun test(x, p) = if x is
diff --git a/shared/src/test/diff/ucs/OverlappedBranches.mls b/shared/src/test/diff/ucs/OverlappedBranches.mls
index 00a4444662..679ccddcfd 100644
--- a/shared/src/test/diff/ucs/OverlappedBranches.mls
+++ b/shared/src/test/diff/ucs/OverlappedBranches.mls
@@ -54,7 +54,7 @@ fun f2(x, p) = if x is
   Derived1 then "d1"
   Derived2 then "d2"
   else "otherwise"
-//│ fun f2: forall 'a. ('a & (Base & ~#Derived1 & ~#Derived2 | Derived1 | Derived2), (Base & 'a) -> Bool) -> ("b and p" | "d1" | "d2" | "otherwise")
+//│ fun f2: forall 'a. (Object & ~#Base | 'a & (Base & ~#Derived1 & ~#Derived2 | Derived1 | Derived2), (Base & 'a) -> Bool) -> ("b and p" | "d1" | "d2" | "otherwise")
 
 f2(Base(), _ => true) // => b and p
 f2(Base(), _ => false) // otherwise

From dd3c35ed9ea5c87260d82a34401ed1cb7a02246c Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 3 Feb 2024 14:32:14 +0800
Subject: [PATCH 106/147] Simplify specialization implementation

---
 .../main/scala/mlscript/ucs/stages/Normalization.scala   | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index e136274637..62a4036c0a 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -233,14 +233,11 @@ trait Normalization { self: Desugarer with Traceable =>
         if (scrutinee === otherScrutinee) {
           println(s"Case 1: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
           otherPattern reportInconsistentRefinedWith pattern
-          if (otherPattern =:= pattern) {
-            println(s"Case 2.1: $pattern =:= $otherPattern")
-            specialize(tail, false)
-          } else if (otherPattern <:< pattern) {
-            println(s"Case 2.2: $pattern <:< $otherPattern")
+          if (otherPattern =:= pattern || otherPattern <:< pattern) {
+            println(s"Case 1.1: $pattern =:= (or <:<) $otherPattern")
             specialize(tail, false)
           } else {
-            println(s"Case 2.3: $pattern are unrelated with $otherPattern")
+            println(s"Case 1.2: $pattern are unrelated with $otherPattern")
             split.copy(tail = specialize(tail, false))
           }
         } else {

From 5783766719c2b049ba5564d37bf8ecada34efe50 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Mon, 19 Feb 2024 17:35:21 +0800
Subject: [PATCH 107/147] Fix refinement information is not passed to
 post-processing

---
 .../scala/mlscript/ucs/context/Pattern.scala  | 14 +++++-
 .../mlscript/ucs/context/Scrutinee.scala      |  4 +-
 .../mlscript/ucs/stages/Desugaring.scala      | 14 +++---
 .../mlscript/ucs/stages/PostProcessing.scala  |  3 +-
 .../src/test/diff/pretyper/ucs/Refinement.mls | 49 +++++++++++++++++++
 5 files changed, 73 insertions(+), 11 deletions(-)
 create mode 100644 shared/src/test/diff/pretyper/ucs/Refinement.mls

diff --git a/shared/src/main/scala/mlscript/ucs/context/Pattern.scala b/shared/src/main/scala/mlscript/ucs/context/Pattern.scala
index cfb1d45f56..8fa96aece8 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Pattern.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Pattern.scala
@@ -34,10 +34,15 @@ sealed abstract class Pattern {
 
   /** Create a `SimpleTerm` which can be used as `pat` of `Case`. */
   def toCasePattern: SimpleTerm
+
+  def refined: Bool
 }
 
 object Pattern {
-  final case class ClassLike(val classLikeSymbol: TypeSymbol, scrutinee: Scrutinee) extends Pattern {
+  final case class ClassLike(
+      val classLikeSymbol: TypeSymbol,
+      scrutinee: Scrutinee
+  )(override val refined: Bool) extends Pattern {
     private var unappliedVarOpt: Opt[Var] = N
     private val parameters: MutSortedMap[Int, Scrutinee] = MutSortedMap.empty
 
@@ -65,7 +70,8 @@ object Pattern {
 
     override def arity: Opt[Int] = parameters.keysIterator.maxOption.map(_ + 1)
 
-    override def showDbg: Str = s"${classLikeSymbol.name}"
+    override def showDbg: Str =
+      (if (refined) "refined " else "") + s"${classLikeSymbol.name}"
 
     override def showInDiagnostics: Str = s"${(classLikeSymbol match {
       case dummySymbol: DummyClassSymbol => "class"
@@ -112,6 +118,8 @@ object Pattern {
       * find an instance of this class.
       */
     override def toCasePattern: SimpleTerm = ???
+
+    override def refined: Bool = ???
   }
 
   final case class Literal(val literal: Lit) extends Pattern {
@@ -128,5 +136,7 @@ object Pattern {
       }
 
     override def toCasePattern: SimpleTerm = literal.withLoc(firstOccurrence)
+
+    override def refined: Bool = false
   }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
index 9d8dc7b61b..999c2cd9cd 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
@@ -36,8 +36,8 @@ class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
     * If there is already a `Pattern.ClassLike` for the given symbol, return it.
     * Otherwise, create a new `Pattern.ClassLike` and return it.
     */
-  def getOrCreateClassPattern(classLikeSymbol: TypeSymbol): Pattern.ClassLike =
-    classLikePatterns.getOrElseUpdate(classLikeSymbol, Pattern.ClassLike(classLikeSymbol, this))
+  def getOrCreateClassPattern(classLikeSymbol: TypeSymbol, refined: Bool): Pattern.ClassLike =
+    classLikePatterns.getOrElseUpdate(classLikeSymbol, Pattern.ClassLike(classLikeSymbol, this)(refined))
 
   /**
     * Get the class pattern but DO NOT create a new one if there isn't. This
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 1a22952b4c..7301ce60e6 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -136,10 +136,11 @@ trait Desugaring { self: PreTyper =>
       parentScrutineeVar: Var,
       parentScrutinee: Scrutinee,
       parentClassLikeSymbol: TypeSymbol,
-      parameters: Ls[s.Pattern]
+      parentRefined: Bool,
+      parameters: Ls[s.Pattern],
   )(implicit context: Context): Ls[Opt[(Var, Opt[s.Pattern], Ls[Var])]] = {
     // Make it `lazy` so that it will not be created if all fields are wildcards.
-    lazy val classPattern = parentScrutinee.getOrCreateClassPattern(parentClassLikeSymbol)
+    lazy val classPattern = parentScrutinee.getOrCreateClassPattern(parentClassLikeSymbol, parentRefined)
     def flattenPattern(
       parameterPattern: s.Pattern,
       index: Int,
@@ -197,10 +198,11 @@ trait Desugaring { self: PreTyper =>
       pattern: s.ClassPattern,
       scrutineeVar: Var,
       initialScope: Scope,
-      refined: Bool)(implicit context: Context): (Scope, c.Split => c.Branch) = {
+      refined: Bool
+  )(implicit context: Context): (Scope, c.Split => c.Branch) = {
     val scrutinee = scrutineeVar.getOrCreateScrutinee.withAliasVar(scrutineeVar)
     val patternClassSymbol = pattern.nme.resolveClassLikeSymbol(initialScope, context)
-    val classPattern = scrutinee.getOrCreateClassPattern(patternClassSymbol)
+    val classPattern = scrutinee.getOrCreateClassPattern(patternClassSymbol, refined)
     println(s"desugarClassPattern: ${scrutineeVar.name} is ${pattern.nme.name}")
     classPattern.addLocation(pattern.nme)
     val (scopeWithAll, bindAll) = pattern.parameters match {
@@ -213,7 +215,7 @@ trait Desugaring { self: PreTyper =>
           val vari = makeUnappliedVar(scrutineeVar, pattern.nme)
           vari.withSymbol(new LocalTermSymbol(vari))
         }
-        val nestedPatterns = flattenClassParameters(scrutineeVar, scrutinee, patternClassSymbol, parameters)
+        val nestedPatterns = flattenClassParameters(scrutineeVar, scrutinee, patternClassSymbol, refined, parameters)
         println(s"nestedPatterns = $nestedPatterns")
         // First, handle bindings of parameters of the current class pattern.
         val identity = (split: c.Split) => split
@@ -380,7 +382,7 @@ trait Desugaring { self: PreTyper =>
             c.Branch(scrutineeVar, c.Pattern.Literal(literal), desugarRight) :: desugarTail
           case s.ConcretePattern(nme @ (Var("true") | Var("false"))) =>
             val classSymbol = nme.resolveClassLikeSymbol
-            scrutinee.getOrCreateClassPattern(classSymbol).addLocation(nme)
+            scrutinee.getOrCreateClassPattern(classSymbol, false).addLocation(nme)
             c.Branch(
               scrutinee = scrutineeVar,
               pattern = c.Pattern.Class(nme, classSymbol, false),
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index 52d385b1cf..2974e30722 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -7,6 +7,7 @@ import mlscript.pretyper.symbol._
 import mlscript.utils._, shorthands._
 import mlscript.Message, Message.MessageContext
 import scala.annotation.tailrec
+import mlscript.ucs.context.Pattern.ClassLike
 
 trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
   import PostProcessing._
@@ -63,7 +64,7 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
         val actualFalseBranch = cases.foldRight[CaseBranches](
           postProcessedDefault.fold[CaseBranches](NoCases)(Wildcard(_))
         ) { case ((pattern, loc, body), rest) =>
-          Case(pattern.toCasePattern, body, rest)(refined = false/*FIXME?*/)
+          Case(pattern.toCasePattern, body, rest)(refined = pattern.refined)
         }
         // Assemble the final `CaseOf`.
         top.copy(cases = fst.copy(body = processedTrueBranch, rest = actualFalseBranch)
diff --git a/shared/src/test/diff/pretyper/ucs/Refinement.mls b/shared/src/test/diff/pretyper/ucs/Refinement.mls
new file mode 100644
index 0000000000..95b2b48a64
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/Refinement.mls
@@ -0,0 +1,49 @@
+:NewDefs
+
+module None
+class Some[out A](val value: A)
+//│ module None
+//│ class Some[A](value: A)
+
+// OK
+:ducs:desugar.result,postprocess.result
+x => if x is
+  refined(None) then x
+//│ Desugared UCS term:
+//│ if x*‡ is refined None then x
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   refined None*† -> x
+//│ forall 'a. (None & 'a) -> (None & 'a)
+//│ res
+//│     = [Function: res]
+
+// OK
+:ducs:desugar.result,postprocess.result
+x => if x is
+  refined(Some) then x
+//│ Desugared UCS term:
+//│ if x*‡ is refined Some then x
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   refined Some*◊ -> x
+//│ forall 'a. (Some[anything] & 'a) -> (Some[anything] & 'a)
+//│ res
+//│     = [Function: res]
+
+// NOT OK
+:ducs:desugar.result,postprocess.result
+x => if x is
+  refined(None) then x
+  refined(Some) then x
+//│ Desugared UCS term:
+//│ if
+//│   x*‡ is refined None then x
+//│   x*‡ is refined Some then x
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   refined None*† -> x
+//│   refined Some*◊ -> x
+//│ (None | Some[anything]) -> nothing
+//│ res
+//│     = [Function: res]

From 6040c9e892aa4d7b9f9d12b29f1a14c9e7f6e23e Mon Sep 17 00:00:00 2001
From: Lionel Parreaux <lionel.parreaux@gmail.com>
Date: Mon, 19 Feb 2024 22:35:03 +0800
Subject: [PATCH 108/147] Add interesting UnboxedOptions test

---
 shared/src/test/diff/ex/UnboxedOptions.mls | 302 +++++++++++++++++++++
 1 file changed, 302 insertions(+)
 create mode 100644 shared/src/test/diff/ex/UnboxedOptions.mls

diff --git a/shared/src/test/diff/ex/UnboxedOptions.mls b/shared/src/test/diff/ex/UnboxedOptions.mls
new file mode 100644
index 0000000000..3c809aed4c
--- /dev/null
+++ b/shared/src/test/diff/ex/UnboxedOptions.mls
@@ -0,0 +1,302 @@
+:NewDefs
+
+
+// * Similar in spirit to https://github.com/sjrd/scala-unboxed-option
+
+// * In these tests, we need to use an `Object` bound to allow pattern-matching on unboxed option values.
+// * This bound is needed by the type system in order to preserve parametricity in the general case.
+// * However, a real implementation could keep the definition of Opt abstract and do away with the `Object` bound
+// * through unchecked casts without compromising safety or parametricity.
+
+
+module None
+class Some[out A](val value: A)
+//│ module None
+//│ class Some[A](value: A)
+
+type Opt[out A] = Some[A] | None | A & ~Some & ~None
+//│ type Opt[A] = None | Some[A] | A & ~None & ~#Some
+
+
+fun some(x) = if x is
+  refined(None) then Some(x)
+  refined(Some) then Some(x)
+  else x
+//│ fun some: forall 'a 'b 'c. (None & 'b | Object & 'c & ~#None & ~#Some | Some[anything] & 'a) -> (Some[None & 'b | Some[anything] & 'a] | 'c)
+
+let some_ = some : forall 'a: (Object & 'a) -> Opt['a]
+//│ let some_: forall 'a. (Object & 'a) -> Opt['a]
+//│ some_
+//│       = [Function: some]
+
+
+fun fold(opt, k, d) = if opt is
+  refined(None) then d
+  refined(Some) then k(opt.value)
+  else k(opt)
+//│ fun fold: forall 'value 'a. (None | Object & 'value & ~#None & ~#Some | Some[anything] & {value: 'value}, 'value -> 'a, 'a) -> 'a
+
+let fold_ = fold : forall 'a, 'b: (Opt['a] & Object, 'a -> 'b, 'b) -> 'b
+//│ let fold_: forall 'a 'b. (Opt['a] & Object, 'a -> 'b, 'b) -> 'b
+//│ fold_
+//│       = [Function: fold]
+
+let fold_ = fold : forall 'a, 'b: (Opt['a & Object], 'a -> 'b, 'b) -> 'b
+//│ let fold_: forall 'a 'b. (Opt[Object & 'a], 'a -> 'b, 'b) -> 'b
+//│ fold_
+//│       = [Function: fold]
+
+
+// * Examples using the annotated definitions, which is what things will look like from the outside world.
+
+let s = some_(42)
+//│ let s: Opt[42]
+//│ s
+//│   = 42
+
+s : Opt[Int]
+//│ Opt[Int]
+//│ res
+//│     = 42
+
+fold_(s, id, 0)
+//│ 0 | 42
+//│ res
+//│     = 42
+
+// * This wont work when `Opt` is made opaque to the outside:
+s : Opt[Opt[Int]]
+//│ Opt[Opt[Int]]
+//│ res
+//│     = 42
+
+let ss = some_(some_(42))
+//│ let ss: Opt[Opt[42]]
+//│ ss
+//│    = 42
+
+:e
+ss : Opt[Int]
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.79: 	ss : Opt[Int]
+//│ ║        	^^
+//│ ╟── type `Some['a]` is not an instance of type `Int`
+//│ ║  l.17: 	type Opt[out A] = Some[A] | None | A & ~Some & ~None
+//│ ║        	                  ^^^^^^^
+//│ ╟── Note: constraint arises from type reference:
+//│ ║  l.79: 	ss : Opt[Int]
+//│ ╙──      	         ^^^
+//│ Opt[Int]
+//│ res
+//│     = 42
+
+ss : Opt[Opt[Int]]
+//│ Opt[Opt[Int]]
+//│ res
+//│     = 42
+
+fold_(ss, o => fold_(o, id, -1), 0)
+//│ -1 | 0 | 42
+//│ res
+//│     = 42
+
+
+let s = some_(None)
+//│ let s: Opt[None]
+//│ s
+//│   = Some {}
+
+:e
+s : Opt[Int]
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.110: 	s : Opt[Int]
+//│ ║         	^
+//│ ╟── reference of type `None` is not an instance of `Int`
+//│ ║  l.104: 	let s = some_(None)
+//│ ║         	              ^^^^
+//│ ╟── Note: constraint arises from type reference:
+//│ ║  l.110: 	s : Opt[Int]
+//│ ╙──       	        ^^^
+//│ Opt[Int]
+//│ res
+//│     = Some {}
+
+s : Opt[Opt[Int]]
+//│ Opt[Opt[Int]]
+//│ res
+//│     = Some {}
+
+fold_(s, o => fold_(o, id, -1), 0)
+//│ -1 | 0
+//│ res
+//│     = -1
+
+some_(some_(None))
+//│ Opt[Opt[None]]
+//│ res
+//│     = Some {}
+
+:e
+ss : Opt[Int]
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.140: 	ss : Opt[Int]
+//│ ║         	^^
+//│ ╟── type `Some['a]` is not an instance of type `Int`
+//│ ║  l.17: 	type Opt[out A] = Some[A] | None | A & ~Some & ~None
+//│ ║        	                  ^^^^^^^
+//│ ╟── Note: constraint arises from type reference:
+//│ ║  l.140: 	ss : Opt[Int]
+//│ ╙──       	         ^^^
+//│ Opt[Int]
+//│ res
+//│     = 42
+
+ss : Opt[Opt[Int]]
+//│ Opt[Opt[Int]]
+//│ res
+//│     = 42
+
+fold_(ss, o => fold_(o, id, -1), 0)
+//│ -1 | 0 | 42
+//│ res
+//│     = 42
+
+
+// * Here we use the precise, unannotated types directly to showcase precise inferred types.
+
+let s = some(42)
+//│ let s: 42 | Some[nothing]
+//│ s
+//│   = 42
+
+s : Opt[Int]
+//│ Opt[Int]
+//│ res
+//│     = 42
+
+fold(s, id, 0)
+//│ 0 | 42
+//│ res
+//│     = 42
+
+s : Opt[Opt[Int]]
+//│ Opt[Opt[Int]]
+//│ res
+//│     = 42
+
+let ss = some(some(42))
+//│ let ss: 42 | Some[Some[nothing]]
+//│ ss
+//│    = 42
+
+:e
+ss : Opt[Int]
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.193: 	ss : Opt[Int]
+//│ ║         	^^
+//│ ╟── application of type `Some[?A]` does not match type `Int | ~Some[anything]`
+//│ ║  l.23: 	  refined(Some) then Some(x)
+//│ ╙──      	                     ^^^^^^^
+//│ Opt[Int]
+//│ res
+//│     = 42
+
+ss : Opt[Opt[Int]]
+//│ Opt[Opt[Int]]
+//│ res
+//│     = 42
+
+fold(ss, o => fold(o, id, -1), 0)
+//│ -1 | 0 | 42
+//│ res
+//│     = 42
+
+
+let s = some(None)
+//│ let s: Some[None]
+//│ s
+//│   = Some {}
+
+:e
+s : Opt[Int]
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.221: 	s : Opt[Int]
+//│ ║         	^
+//│ ╟── reference of type `None` does not match type `Int | ~None`
+//│ ║  l.215: 	let s = some(None)
+//│ ╙──       	             ^^^^
+//│ Opt[Int]
+//│ res
+//│     = Some {}
+
+s : Opt[Opt[Int]]
+//│ Opt[Opt[Int]]
+//│ res
+//│     = Some {}
+
+fold(s, o => fold(o, id, -1), 0)
+//│ -1 | 0
+//│ res
+//│     = -1
+
+some(some(None))
+//│ Some[Some[None]]
+//│ res
+//│     = Some {}
+
+:e
+ss : Opt[Int]
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.248: 	ss : Opt[Int]
+//│ ║         	^^
+//│ ╟── application of type `Some[?A]` does not match type `Int | ~Some[anything]`
+//│ ║  l.23: 	  refined(Some) then Some(x)
+//│ ╙──      	                     ^^^^^^^
+//│ Opt[Int]
+//│ res
+//│     = 42
+
+ss : Opt[Opt[Int]]
+//│ Opt[Opt[Int]]
+//│ res
+//│     = 42
+
+fold(ss, o => fold(o, id, -1), 0)
+//│ -1 | 0 | 42
+//│ res
+//│     = 42
+
+
+// * Demonstration that we can't lift a parametric value into an unboxed option without casts.
+
+fun mk(x: Object) = some(x)
+//│ fun mk: forall 'a. (x: Object) -> (Object & ~#None & ~#Some | Some[None | Some[anything]] | 'a)
+
+:e
+fun mk[A](x: A) = some(x)
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.276: 	fun mk[A](x: A) = some(x)
+//│ ║         	                  ^^^^^^^
+//│ ╟── reference of type `A` is not an instance of type `Object`
+//│ ║  l.276: 	fun mk[A](x: A) = some(x)
+//│ ║         	                       ^
+//│ ╟── Note: constraint arises from `case` expression:
+//│ ║  l.21: 	fun some(x) = if x is
+//│ ║        	                 ^^^^
+//│ ║  l.22: 	  refined(None) then Some(x)
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.23: 	  refined(Some) then Some(x)
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.24: 	  else x
+//│ ║        	^^^^^^^^
+//│ ╟── from reference:
+//│ ║  l.21: 	fun some(x) = if x is
+//│ ║        	                 ^
+//│ ╟── Note: method type parameter A is defined at:
+//│ ║  l.276: 	fun mk[A](x: A) = some(x)
+//│ ╙──       	       ^
+//│ fun mk: forall 'A 'a 'b. (x: 'A) -> (Some[Some[anything] & 'a | 'A & (None | None & ~'a & ~'b | Some[anything])] | error | 'A & ~#None & ~#Some | 'b)
+
+fun mk[A](x: A & Object) = some(x)
+//│ fun mk: forall 'A 'a 'b. (x: Object & 'A) -> (Object & 'A & ~#None & ~#Some | Some[Some[anything] & 'a | 'A & (None | None & ~'a & ~'b | Some[anything])] | 'b)
+

From d4ae8e212350103b844fa2b521c3424b54d5b850 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 19 Mar 2024 18:46:10 +0800
Subject: [PATCH 109/147] Improve debug messages

---
 shared/src/main/scala/mlscript/ucs/display.scala       |  8 ++++----
 .../main/scala/mlscript/ucs/stages/Normalization.scala | 10 +++++-----
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/display.scala b/shared/src/main/scala/mlscript/ucs/display.scala
index 2811baee02..dd34398454 100644
--- a/shared/src/main/scala/mlscript/ucs/display.scala
+++ b/shared/src/main/scala/mlscript/ucs/display.scala
@@ -77,8 +77,8 @@ package object display {
 
   def showSplit(prefix: Str, s: c.Split)(implicit context: Context): Str = {
     def split(s: c.Split, isFirst: Bool, isTopLevel: Bool): Lines = s match {
-      case c.Split.Cons(head, tail) => (branch(head) match {
-        case (n, line) :: tail => (n, (if (isTopLevel) "" else "") + s"$line") :: tail
+      case c.Split.Cons(head, tail) => (branch(head, isTopLevel) match {
+        case (n, line) :: tail => (n, (if (isTopLevel) "" else "and ") + s"$line") :: tail
         case Nil => Nil
       }) ::: split(tail, false, isTopLevel)
       case c.Split.Let(_, nme, rhs, tail) =>
@@ -87,9 +87,9 @@ package object display {
         (if (isFirst) (0, s"then ${term.showDbg}") else (0, s"else ${term.showDbg}")) :: Nil
       case c.Split.Nil => Nil
     }
-    def branch(b: c.Branch): Lines = {
+    def branch(b: c.Branch, isTopLevel: Bool): Lines = {
       val c.Branch(scrutinee, pattern, continuation) = b
-      s"${showVar(scrutinee)} is $pattern" #: split(continuation, true, false)
+      s"${showVar(scrutinee)} is $pattern" #: split(continuation, true, isTopLevel)
     }
     val lines = split(s, true, true)
     (if (prefix.isEmpty) lines else prefix #: lines).toIndentedString
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 62a4036c0a..efb77b7fa4 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -215,18 +215,18 @@ trait Normalization { self: Desugarer with Traceable =>
         if (scrutinee === otherScrutinee) {
           println(s"Case 1: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
           if (otherPattern =:= pattern) {
-            println(s"Case 2.1: $pattern =:= $otherPattern")
+            println(s"Case 1.1: $pattern =:= $otherPattern")
             otherPattern reportInconsistentRefinedWith pattern
             specialize(continuation, true) :++ specialize(tail, true)
           } else if (otherPattern <:< pattern) {
-            println(s"Case 2.2: $pattern <:< $otherPattern")
+            println(s"Case 1.2: $pattern <:< $otherPattern")
             pattern.markAsRefined; split
           } else {
-            println(s"Case 2.3: $pattern are unrelated with $otherPattern")
+            println(s"Case 1.3: $pattern are unrelated with $otherPattern")
             specialize(tail, true)
           }
         } else {
-          println(s"Case 2: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
+          println(s"Case 2: ${scrutineeVar.name} =/= ${otherScrutineeVar.name}")
           head.copy(continuation = specialize(continuation, true)) :: specialize(tail, true)
         }
       case (false, split @ Split.Cons(head @ Branch(Scrutinee.WithVar(otherScrutineeVar, otherScrutinee), otherPattern, continuation), tail)) =>
@@ -241,7 +241,7 @@ trait Normalization { self: Desugarer with Traceable =>
             split.copy(tail = specialize(tail, false))
           }
         } else {
-          println(s"Case 2: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
+          println(s"Case 2: ${scrutineeVar.name} =/= ${otherScrutineeVar.name}")
           head.copy(continuation = specialize(continuation, false)) :: specialize(tail, false)
         }
       case (_, split @ Split.Cons(Branch(_, pattern, _), _)) =>

From 3ff3f0af3b3877cad5604235488b83aec7848462 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Thu, 21 Mar 2024 14:39:00 +0800
Subject: [PATCH 110/147] Fix post-processing Boolean tests

---
 .../mlscript/ucs/stages/PostProcessing.scala  | 19 +++-
 shared/src/test/diff/ucs/Wildcard.mls         | 95 ++++++++++++++++++-
 2 files changed, 108 insertions(+), 6 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index 2974e30722..6a5e3c25f4 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -120,7 +120,9 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
       case lhs @ Let(_, _, _, body) => lhs.copy(body = mergeTerms(body, rhs))
       case lhs @ CaseOf(scrutinee: Var, cases) =>
         lhs.copy(cases = recCaseBranches(cases, rhs))
-      case _ => reportUnreachableCase(rhs, lhs)
+      case _ =>
+        println("unreachable: " + rhs.describe)
+        reportUnreachableCase(rhs, lhs)
     }
     def recCaseBranches(lhs: CaseBranches, rhs: Term): CaseBranches = lhs match {
       case NoCases => Wildcard(rhs).withLocOf(rhs)
@@ -153,6 +155,7 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
   ): (Term, Opt[Term]) = {
     def rec(term: Term): (Term, Opt[Term]) =
       term match {
+        // Disentangle pattern matching
         case top @ CaseOf(Scrutinee.WithVar(otherScrutineeVar, otherScrutinee), cases) =>
           if (scrutinee === otherScrutinee) {
             println(s"found a `CaseOf` that matches on `${scrutineeVar.name}`")
@@ -163,6 +166,20 @@ trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
             val (n, y) = disentangleUnmatchedCaseBranches(cases)
             (top.copy(cases = n), (if (y === NoCases) N else S(top.copy(cases = y))))
           }
+        // Disentangle tests with two case branches
+        case top @ CaseOf(testVar: Var, Case(Var("true"), whenTrue, Wildcard(whenFalse))) if context.isTestVar(testVar) =>
+          println(s"TEST `${testVar.name}`")
+          val (n1, y1) = disentangleTerm(whenTrue)
+          val (n2, y2) = disentangleTerm(whenFalse)
+          (
+            CaseOf(testVar, Case(Var("true"), n1, Wildcard(n2))(false)),
+            (y1, y2) match {
+              case (N, N) => N
+              case (S(t1), N) => S(CaseOf(testVar, Case(Var("true"), t1, Wildcard(n2))(false)))
+              case (N, S(t2)) => S(CaseOf(testVar, Case(Var("true"), n1, Wildcard(t2))(false)))
+              case (S(t1), S(t2)) => S(CaseOf(testVar, Case(Var("true"), t1, Wildcard(t2))(false)))
+            }
+          )
         // For let bindings, we just go deeper.
         case let @ Let(_, _, _, body) =>
           val (n, y) = rec(body)
diff --git a/shared/src/test/diff/ucs/Wildcard.mls b/shared/src/test/diff/ucs/Wildcard.mls
index 5dc4fa10da..f6946d2e43 100644
--- a/shared/src/test/diff/ucs/Wildcard.mls
+++ b/shared/src/test/diff/ucs/Wildcard.mls
@@ -42,13 +42,98 @@ w1(Right(Some(0)), "a", "b")
 //│ res
 //│     = 'Right of Some of 0'
 
+//  Should be
+//  case x of
+//    Some -> 1
+//    None ->
+//      case p(x) of
+//        true -> 2
+//        _ -> 4
+//    _ ->
+//      case p(x) of
+//        true -> 3
+//        _ -> 5
+:ducs:normalize.result,postprocess.result
+fun w2(x, p) =
+  if x is
+    Some then 1
+    _ and p(x) and
+      x is None then 2
+      _ then 3
+    None then 4
+    _ then 5
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   Some*◊ -> 1
+//│   _ ->
+//│     let ucs$test$0*† = p(x,) : Bool
+//│     case ucs$test$0*† of
+//│       true*† ->
+//│         case x*‡ of
+//│           None*† -> 2
+//│           _ -> 3
+//│       _ ->
+//│         case x*‡ of
+//│           None*† -> 4
+//│           _ -> 5
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   Some*◊ -> 1
+//│   None*† ->
+//│     let ucs$test$0*† = p(x,) : Bool
+//│     case ucs$test$0*† of
+//│       true -> 2
+//│       _ -> 4
+//│   _ ->
+//│     let ucs$test$0*† = p(x,) : Bool
+//│     case ucs$test$0*† of
+//│       true -> 3
+//│       _ -> 5
+//│ fun w2: forall 'a. (None | Object & 'a & ~#None & ~#Some | Some[anything], (None | 'a) -> Bool) -> (1 | 2 | 3 | 4 | 5)
+
+//  Should be
+//  case x of
+//    Some -> 1
+//    None ->
+//      case p(x) of
+//        true -> 2
+//        _ -> 3
+//    _ ->
+//      case p(x) of
+//        true -> 2
+//        _ -> 4
+:ducs:normalize.result,postprocess.result
 fun w2(x, p) =
   if x is
     Some then 1
     _ and p(x) then 2
     None then 3
     _ then 4
-//│ fun w2: forall 'a. (Object & 'a & ~#Some | Some[anything], 'a -> Bool) -> (1 | 2 | 3 | 4)
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   Some*◊ -> 1
+//│   _ ->
+//│     let ucs$test$0*† = p(x,) : Bool
+//│     case ucs$test$0*† of
+//│       true*† -> 2
+//│       _ ->
+//│         case x*‡ of
+//│           None*† -> 3
+//│           _ -> 4
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   Some*◊ -> 1
+//│   None*† ->
+//│     let ucs$test$0*† = p(x,) : Bool
+//│     case ucs$test$0*† of
+//│       true -> 2
+//│       _ -> 3
+//│   _ ->
+//│     let ucs$test$0*† = p(x,) : Bool
+//│     case ucs$test$0*† of
+//│       true -> 2
+//│       _ -> 4
+//│ fun w2: forall 'a. (None | Object & 'a & ~#None & ~#Some | Some[anything], (None | 'a) -> Bool) -> (1 | 2 | 3 | 4)
 
 w2(Some(0), x => true)
 w2(None, x => true)
@@ -108,10 +193,10 @@ w3(0, _ => false)
 fun w3_1(x, f) =
   if f(x) is _ then 0 else 1
 //│ ╔══[WARNING] this case is unreachable
-//│ ║  l.109: 	  if f(x) is _ then 0 else 1
+//│ ║  l.194: 	  if f(x) is _ then 0 else 1
 //│ ║         	                           ^
 //│ ╟── because it is subsumed by the branch
-//│ ║  l.109: 	  if f(x) is _ then 0 else 1
+//│ ║  l.194: 	  if f(x) is _ then 0 else 1
 //│ ╙──       	                    ^
 //│ fun w3_1: forall 'a. ('a, 'a -> anything) -> 0
 
@@ -127,10 +212,10 @@ w3_1(0, _ => false)
 fun w3_1_1(x, f) =
   if f(x) is a then a else 0
 //│ ╔══[WARNING] this case is unreachable
-//│ ║  l.128: 	  if f(x) is a then a else 0
+//│ ║  l.213: 	  if f(x) is a then a else 0
 //│ ║         	                           ^
 //│ ╟── because it is subsumed by the branch
-//│ ║  l.128: 	  if f(x) is a then a else 0
+//│ ║  l.213: 	  if f(x) is a then a else 0
 //│ ╙──       	                    ^
 //│ fun w3_1_1: forall 'a 'b. ('a, 'a -> 'b) -> 'b
 

From 587d3382b9e77aa43dd67b88069587d342f90476 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Thu, 21 Mar 2024 14:50:35 +0800
Subject: [PATCH 111/147] Add cases about redundancy and failing to warn of
 unreachable code)

---
 shared/src/test/diff/mlscript/Repro.mls       |  66 ++++++++++
 .../src/test/diff/pretyper/ucs/DualOption.mls | 117 ++++++++++++++++++
 2 files changed, 183 insertions(+)

diff --git a/shared/src/test/diff/mlscript/Repro.mls b/shared/src/test/diff/mlscript/Repro.mls
index 34d9bdfef7..6a07da5de0 100644
--- a/shared/src/test/diff/mlscript/Repro.mls
+++ b/shared/src/test/diff/mlscript/Repro.mls
@@ -1 +1,67 @@
 :NewDefs
+
+class A()
+class B() extends A()
+//│ class A()
+//│ class B() extends A
+
+fun p(x) = true
+//│ fun p: anything -> true
+
+fun f(x) = if
+  x is B and
+    x is A then 1
+    p(x) then 2
+  x is A then 31
+  x is B then 3
+  else 4
+//│ fun f: (B | Object & ~#B) -> (2 | 31 | 3 | 4)
+
+
+
+// FIXME should warn about unreachable code (3 disappears)
+:ducs:postprocess.result
+fun f(x) = if
+  x is A and
+    x is B then 1
+    p(x) then 2
+  x is B then 3
+  else 4
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   refined A*◊ ->
+//│     case x*‡ of
+//│       B*◊ -> 1
+//│       _ ->
+//│         let ucs$test$0*† = p(x,) : Bool
+//│         case ucs$test$0*† of
+//│           true*† -> 2
+//│           _ -> 4
+//│   _ -> 4
+//│ fun f: Object -> (1 | 2 | 4)
+
+
+class X()
+class Y()
+//│ class X()
+//│ class Y()
+
+// FIXME should warn about unreachable code (1 disappears)
+:ducs:postprocess.result
+fun f(x) = if
+  x is X and
+    x is Y then 1
+    p(x) then 2
+  x is Y then 3
+  else 4
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   X*◊ ->
+//│     let ucs$test$0*† = p(x,) : Bool
+//│     case ucs$test$0*† of
+//│       true*† -> 2
+//│       _ -> 4
+//│   Y*◊ -> 3
+//│   _ -> 4
+//│ fun f: Object -> (2 | 3 | 4)
+
diff --git a/shared/src/test/diff/pretyper/ucs/DualOption.mls b/shared/src/test/diff/pretyper/ucs/DualOption.mls
index 52a9ffa36d..5c7921983b 100644
--- a/shared/src/test/diff/pretyper/ucs/DualOption.mls
+++ b/shared/src/test/diff/pretyper/ucs/DualOption.mls
@@ -162,3 +162,120 @@ add_6(Some(5), Some(9))
 //│     = 9
 //│ res
 //│     = 14
+
+
+fun p(x) = true
+//│ fun p: anything -> true
+
+
+// FIXME Remove `case p(x) of true -> 0; _ -> 0`
+:ducs:postprocess.result
+fun add_6(x, y) =
+  if
+    x is Some(xv) and y is Some(yv) then xv + yv
+    y is None     and p(x) and x is Some(xv) then 42
+    y is None     and x is Some(xv) then xv
+    x is None     and y is Some(yv) then yv
+    y is None     and x is None     then 0
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   Some*◊ ->
+//│     let ucs$args_x$Some*† = (Some).unapply(x,)
+//│     let xv*‡ = (ucs$args_x$Some).0
+//│     case y*‡ of
+//│       Some*◊ ->
+//│         let ucs$args_y$Some*† = (Some).unapply(y,)
+//│         let yv*‡ = (ucs$args_y$Some).0
+//│         +(xv, yv,)
+//│       None*† ->
+//│         let ucs$test$0*† = p(x,) : Bool
+//│         case ucs$test$0*† of
+//│           true*† -> 42
+//│           _ -> xv
+//│   None*† ->
+//│     case y*‡ of
+//│       None*† ->
+//│         let ucs$test$0*† = p(x,) : Bool
+//│         case ucs$test$0*† of
+//│           true -> 0
+//│           _ -> 0
+//│       Some*◊ ->
+//│         let ucs$args_y$Some*† = (Some).unapply(y,)
+//│         let yv*‡ = (ucs$args_y$Some).0
+//│         yv
+//│ fun add_6: forall 'a. (None | Some[Int], None | Some[Int & 'a]) -> (Int | 'a)
+
+
+:ducs:postprocess.result
+fun add_7(x, y) =
+  if
+    x is Some(xv) and y is Some(yv) then xv + yv
+    // y is None    and p(x) and x is Some(xv) then 42
+    y is None     and x is Some(xv) then xv
+    y is Some(yv) and p(yv) and x is None then 36
+    y is Some(yv) and x is None then yv
+    y is None     and x is None     then 0
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   Some*◊ ->
+//│     let ucs$args_x$Some*† = (Some).unapply(x,)
+//│     let xv*‡ = (ucs$args_x$Some).0
+//│     case y*‡ of
+//│       Some*◊ ->
+//│         let ucs$args_y$Some*† = (Some).unapply(y,)
+//│         let yv*‡ = (ucs$args_y$Some).0
+//│         +(xv, yv,)
+//│       None*† -> xv
+//│   None*† ->
+//│     case y*‡ of
+//│       None*† -> 0
+//│       Some*◊ ->
+//│         let ucs$args_y$Some*† = (Some).unapply(y,)
+//│         let yv*‡ = (ucs$args_y$Some).0
+//│         let ucs$test$0*† = p(yv,) : Bool
+//│         case ucs$test$0*† of
+//│           true -> 36
+//│           _ -> yv
+//│ fun add_7: forall 'a. (None | Some[Int], None | Some[Int & 'a]) -> (Int | 'a)
+
+
+// FIXME Remove `case p(x) of true -> 0; _ -> 0`
+:ducs:postprocess.result
+fun add_8(x, y) =
+  if
+    x is Some(xv) and y is Some(yv) then xv + yv
+    y is None    and p(x) and x is Some(xv) then 42
+    y is None     and x is Some(xv) then xv
+    y is Some(yv) and p(yv) and x is None then 36
+    y is Some(yv) and x is None then yv
+    y is None     and x is None     then 0
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   Some*◊ ->
+//│     let ucs$args_x$Some*† = (Some).unapply(x,)
+//│     let xv*‡ = (ucs$args_x$Some).0
+//│     case y*‡ of
+//│       Some*◊ ->
+//│         let ucs$args_y$Some*† = (Some).unapply(y,)
+//│         let yv*‡ = (ucs$args_y$Some).0
+//│         +(xv, yv,)
+//│       None*† ->
+//│         let ucs$test$0*† = p(x,) : Bool
+//│         case ucs$test$0*† of
+//│           true*† -> 42
+//│           _ -> xv
+//│   None*† ->
+//│     case y*‡ of
+//│       None*† ->
+//│         let ucs$test$0*† = p(x,) : Bool
+//│         case ucs$test$0*† of
+//│           true -> 0
+//│           _ -> 0
+//│       Some*◊ ->
+//│         let ucs$args_y$Some*† = (Some).unapply(y,)
+//│         let yv*‡ = (ucs$args_y$Some).0
+//│         let ucs$test$1*† = p(yv,) : Bool
+//│         case ucs$test$1*† of
+//│           true -> 36
+//│           _ -> yv
+//│ fun add_8: forall 'a. (None | Some[Int], None | Some[Int & 'a]) -> (Int | 'a)

From 69392b3a02f68072a64d35f961eaa6c65b094670 Mon Sep 17 00:00:00 2001
From: Lionel Parreaux <lionel.parreaux@gmail.com>
Date: Tue, 2 Apr 2024 11:07:35 +0800
Subject: [PATCH 112/147] Fix two codegen problems: selections on naked `new` &
 binary operators in web demo

Also add some missing self types in two tests
---
 bin/mlscript-opt.js                           | 6150 +++++++++--------
 js/src/main/scala/Main.scala                  |    2 +-
 .../src/main/scala/mlscript/JSBackend.scala   |   11 +-
 .../main/scala/mlscript/codegen/Codegen.scala |    4 +-
 .../main/scala/mlscript/codegen/Scope.scala   |    1 +
 shared/src/test/diff/codegen/New.mls          |   79 +
 shared/src/test/diff/nu/CaseExpr.mls          |    4 +-
 shared/src/test/diff/nu/Eval.mls              |    4 +-
 8 files changed, 3216 insertions(+), 3039 deletions(-)

diff --git a/bin/mlscript-opt.js b/bin/mlscript-opt.js
index 85c964de83..e25fc84a8d 100644
--- a/bin/mlscript-opt.js
+++ b/bin/mlscript-opt.js
@@ -1,969 +1,1025 @@
 let typecheck;
 (function(){
-'use strict';var f,ba=Object.freeze({esVersion:6,assumingES6:!0,productionMode:!0,linkerVersion:"1.11.0",fileLevelThis:this}),ca;function da(a){for(var b in a)return b}function fa(a){this.MP=a}fa.prototype.toString=function(){return String.fromCharCode(this.MP)};var ia=function ha(a,b,c){var e=new a.Ja(b[c]);if(c<b.length-1){a=a.NA;c+=1;for(var g=e.a,h=0;h<g.length;h++)g[h]=ha(a,b,c)}return e};
-function ja(a){switch(typeof a){case "string":return ma(na);case "number":return oa(a)?a<<24>>24===a?ma(qa):a<<16>>16===a?ma(ra):ma(ta):va(a)?ma(Aa):ma(Da);case "boolean":return ma(Sa);case "undefined":return ma(Xa);default:return null===a?a.h0():a instanceof fb?ma(hb):a instanceof fa?ma(jb):a&&a.$classData?ma(a.$classData):null}}
-function lb(a){switch(typeof a){case "string":return"java.lang.String";case "number":return oa(a)?a<<24>>24===a?"java.lang.Byte":a<<16>>16===a?"java.lang.Short":"java.lang.Integer":va(a)?"java.lang.Float":"java.lang.Double";case "boolean":return"java.lang.Boolean";case "undefined":return"java.lang.Void";default:return null===a?a.h0():a instanceof fb?"java.lang.Long":a instanceof fa?"java.lang.Character":a&&a.$classData?a.$classData.name:null.ei.name}}
-function ob(a,b){switch(typeof a){case "string":return sb(a,b);case "number":return yb(Ab(),a,b);case "boolean":return a===b?0:a?1:-1;default:return a instanceof fb?Bb(Cb(),a.W,a.Z,b.W,b.Z):a instanceof fa?Eb(a)-Eb(b)|0:a.sk(b)}}
-function Pb(a,b){switch(typeof a){case "string":return a===b;case "number":return Object.is(a,b);case "boolean":return a===b;case "undefined":return a===b;default:return a&&a.$classData||null===a?a=a.h(b):a instanceof fb?b instanceof fb?(b=Qb(b),a=a.W===b.W&&a.Z===b.Z):a=!1:a=a instanceof fa?b instanceof fa?Eb(a)===Eb(b):!1:ac.prototype.h.call(a,b),a}}
-function bc(a){switch(typeof a){case "string":return dc(a);case "number":return ic(a);case "boolean":return a?1231:1237;case "undefined":return 0;default:return a&&a.$classData||null===a?a.y():a instanceof fb?a.W^a.Z:a instanceof fa?Eb(a):ac.prototype.y.call(a)}}function pc(a){return void 0===a?"undefined":a.toString()}function rc(a,b){if(0===b)throw new zc("/ by zero");return a/b|0}function Kc(a,b){if(0===b)throw new zc("/ by zero");return a%b|0}
-function Mc(a){return 2147483647<a?2147483647:-2147483648>a?-2147483648:a|0}function Qc(a,b,c,d,e){if(a!==c||d<b||(b+e|0)<d)for(var g=0;g<e;g=g+1|0)c[d+g|0]=a[b+g|0];else for(g=e-1|0;0<=g;g=g-1|0)c[d+g|0]=a[b+g|0]}var Zc=0,ad=new WeakMap;
-function bd(a){switch(typeof a){case "string":return dc(a);case "number":return ic(a);case "bigint":var b=0;for(a<BigInt(0)&&(a=~a);a!==BigInt(0);)b^=Number(BigInt.asIntN(32,a)),a>>=BigInt(32);return b;case "boolean":return a?1231:1237;case "undefined":return 0;case "symbol":return a=a.description,void 0===a?0:dc(a);default:if(null===a)return 0;b=ad.get(a);void 0===b&&(Zc=b=Zc+1|0,ad.set(a,b));return b}}function dd(a){return"number"===typeof a&&a<<24>>24===a&&1/a!==1/-0}
-function fd(a){return"number"===typeof a&&a<<16>>16===a&&1/a!==1/-0}function oa(a){return"number"===typeof a&&(a|0)===a&&1/a!==1/-0}function va(a){return"number"===typeof a&&(a!==a||Math.fround(a)===a)}function hd(a){return new fa(a)}function Eb(a){return null===a?0:a.MP}function Qb(a){return null===a?ca:a}function id(){return new ac}function ac(){}ac.prototype.constructor=ac;function p(){}p.prototype=ac.prototype;ac.prototype.y=function(){return bd(this)};
-ac.prototype.h=function(a){return this===a};ac.prototype.u=function(){var a=this.y();return lb(this)+"@"+(+(a>>>0)).toString(16)};ac.prototype.toString=function(){return this.u()};function jd(a){if("number"===typeof a){this.a=Array(a);for(var b=0;b<a;b++)this.a[b]=null}else this.a=a}jd.prototype=new p;jd.prototype.constructor=jd;jd.prototype.va=function(a,b,c,d){Qc(this.a,a,b.a,c,d)};jd.prototype.ga=function(){return new jd(this.a.slice())};function nd(){}nd.prototype=jd.prototype;
-function pd(a){if("number"===typeof a){this.a=Array(a);for(var b=0;b<a;b++)this.a[b]=!1}else this.a=a}pd.prototype=new p;pd.prototype.constructor=pd;pd.prototype.va=function(a,b,c,d){Qc(this.a,a,b.a,c,d)};pd.prototype.ga=function(){return new pd(this.a.slice())};function td(a){this.a="number"===typeof a?new Uint16Array(a):a}td.prototype=new p;td.prototype.constructor=td;td.prototype.va=function(a,b,c,d){b.a.set(this.a.subarray(a,a+d|0),c)};td.prototype.ga=function(){return new td(this.a.slice())};
-function vd(a){this.a="number"===typeof a?new Int8Array(a):a}vd.prototype=new p;vd.prototype.constructor=vd;vd.prototype.va=function(a,b,c,d){b.a.set(this.a.subarray(a,a+d|0),c)};vd.prototype.ga=function(){return new vd(this.a.slice())};function wd(a){this.a="number"===typeof a?new Int16Array(a):a}wd.prototype=new p;wd.prototype.constructor=wd;wd.prototype.va=function(a,b,c,d){b.a.set(this.a.subarray(a,a+d|0),c)};wd.prototype.ga=function(){return new wd(this.a.slice())};
-function zd(a){this.a="number"===typeof a?new Int32Array(a):a}zd.prototype=new p;zd.prototype.constructor=zd;zd.prototype.va=function(a,b,c,d){b.a.set(this.a.subarray(a,a+d|0),c)};zd.prototype.ga=function(){return new zd(this.a.slice())};function Ad(a){if("number"===typeof a){this.a=Array(a);for(var b=0;b<a;b++)this.a[b]=ca}else this.a=a}Ad.prototype=new p;Ad.prototype.constructor=Ad;Ad.prototype.va=function(a,b,c,d){Qc(this.a,a,b.a,c,d)};Ad.prototype.ga=function(){return new Ad(this.a.slice())};
-function Bd(a){this.a="number"===typeof a?new Float32Array(a):a}Bd.prototype=new p;Bd.prototype.constructor=Bd;Bd.prototype.va=function(a,b,c,d){b.a.set(this.a.subarray(a,a+d|0),c)};Bd.prototype.ga=function(){return new Bd(this.a.slice())};function Dd(a){this.a="number"===typeof a?new Float64Array(a):a}Dd.prototype=new p;Dd.prototype.constructor=Dd;Dd.prototype.va=function(a,b,c,d){b.a.set(this.a.subarray(a,a+d|0),c)};Dd.prototype.ga=function(){return new Dd(this.a.slice())};
-function Ed(){this.Ja=void 0;this.Kx=this.NA=this.pb=null;this.Lx=0;this.Oy=null;this.Ku="";this.Ny=this.Su=this.EA=this.ZI=void 0;this.name="";this.isJSClass=this.isArrayClass=this.isInterface=this.isPrimitive=!1;this.isInstance=void 0}function Fd(a,b,c,d,e){var g=new Ed;g.pb={};g.Oy=a;g.Ku=b;g.Su=h=>h===g;g.name=c;g.isPrimitive=!0;g.isInstance=()=>!1;void 0!==d&&(g.EA=Kd(g,d,e));return g}
-function q(a,b,c,d,e){var g=new Ed,h=da(a);g.pb=d;g.Ku="L"+c+";";g.Su=k=>!!k.pb[h];g.name=c;g.isInterface=b;g.isInstance=e||(k=>!!(k&&k.$classData&&k.$classData.pb[h]));return g}function Kd(a,b,c,d){var e=new Ed;b.prototype.$classData=e;var g="["+a.Ku;e.Ja=b;e.pb={d:1,vf:1,l:1};e.NA=a;e.Kx=a;e.Lx=1;e.Ku=g;e.name=g;e.isArrayClass=!0;e.Su=d||(h=>e===h);e.Ny=c?h=>new b(new c(h)):h=>new b(h);e.isInstance=h=>h instanceof b;return e}
-function Ld(a){function b(k){if("number"===typeof k){this.a=Array(k);for(var l=0;l<k;l++)this.a[l]=null}else this.a=k}var c=new Ed;b.prototype=new nd;b.prototype.constructor=b;b.prototype.va=function(k,l,m,n){Qc(this.a,k,l.a,m,n)};b.prototype.ga=function(){return new b(this.a.slice())};var d=a.Kx||a,e=a.Lx+1;b.prototype.$classData=c;var g="["+a.Ku;c.Ja=b;c.pb={d:1,vf:1,l:1};c.NA=a;c.Kx=d;c.Lx=e;c.Ku=g;c.name=g;c.isArrayClass=!0;var h=k=>{var l=k.Lx;return l===e?d.Su(k.Kx):l>e&&d===Md};c.Su=h;c.Ny=
-k=>new b(k);c.isInstance=k=>{k=k&&k.$classData;return!!k&&(k===c||h(k))};return c}function Nd(a){a.EA||(a.EA=Ld(a));return a.EA}function ma(a){a.ZI||(a.ZI=new Pd(a));return a.ZI}Ed.prototype.isAssignableFrom=function(a){return this===a||this.Su(a)};Ed.prototype.checkCast=function(){};Ed.prototype.getSuperclass=function(){return this.m2?ma(this.m2):null};Ed.prototype.getComponentType=function(){return this.NA?ma(this.NA):null};
-Ed.prototype.newArrayOfThisClass=function(a){for(var b=this,c=0;c<a.length;c++)b=Nd(b);return ia(b,a,0)};var Md=new Ed;Md.pb={d:1};Md.Ku="Ljava.lang.Object;";Md.Su=a=>!a.isPrimitive;Md.name="java.lang.Object";Md.isInstance=a=>null!==a;Md.EA=Kd(Md,jd,void 0,a=>{var b=a.Lx;return 1===b?!a.Kx.isPrimitive:1<b});ac.prototype.$classData=Md;
-var Qd=Fd(void 0,"V","void",void 0,void 0),Td=Fd(!1,"Z","boolean",pd,void 0),Vd=Fd(0,"C","char",td,Uint16Array),Xd=Fd(0,"B","byte",vd,Int8Array),Yd=Fd(0,"S","short",wd,Int16Array),Zd=Fd(0,"I","int",zd,Int32Array),$d=Fd(null,"J","long",Ad,void 0),ae=Fd(0,"F","float",Bd,Float32Array),ce=Fd(0,"D","double",Dd,Float64Array);
-function fe(a,b){try{t();var c=(0,eval)(b),d=ge(new ie,c);je();var e=le(v(),d);return new me(e)}catch(g){return c=g instanceof oe?g:new pe(g),b=re(),se(b,'\x3cfont color\x3d"red"\x3eRuntime error occurred:\x3c/font\x3e'),c=""+a.rr+c.mj(),se(b,c),se(b,a.rr),se(b,a.rr),t(),new te(b.mf.ha)}}
-function ve(a){var b=re(),c=we("\x3ctr\x3e\n                      |  \x3ctd\x3eName\x3c/td\x3e\n                      |  \x3ctd\x3eValue\x3c/td\x3e\n                      |\x3c/tr\x3e\n                      |");for(se(b,c);!a.b();)c=a.e(),c='\x3ctr\x3e\n                         |  \x3ctd class\x3d"name"\x3e'+xe(xe(c.i(),"  ","\x26nbsp;\x26nbsp;"),"\n","\x3cbr/\x3e")+"\x3c/td\x3e\n                         |  \x3ctd\x3e"+xe(xe(c.j(),"  ","\x26nbsp;\x26nbsp;"),"\n","\x3cbr/\x3e")+"\x3c/td\x3e\n                         |\x3c/tr\x3e\n                         |",
-c=we(c),se(b,c),a=a.g();return b.mf.ha}function ye(a,b){if(null===a)throw ze();return a.qb?a.sb:Ce(a,new De(b))}function Ge(){this.rr="\x3cbr /\x3e"}Ge.prototype=new p;Ge.prototype.constructor=Ge;function Je(a,b){b=b.target;if(b instanceof HTMLTextAreaElement)Ke(a,b.value);else throw new x(b);}
-function Ke(a,b){var c=document.querySelector("#mlscript-output"),d=null;d="";try{var e=Le(Ne(),b),g=Oe(Pe(),e);Qe(g,"","","");var h=Ve(new We,b,g),k=new Xe("\x3cinput\x3e",1,h),l=Ye(new af(k,new z(nb=>{throw nb;}),!1)),m=new bf(k,l),n=cf(m),r=ef(m,new ff(134),new gf("parseAll"));a:{if(r instanceof A){var u=r.A;if(null!==u){var w=u.i(),y=u.j();for(b=r;;){if(b.b())D=!1;else var B=b.e().i(),D=hf(new E(B),lf());if(D)b=b.g();else break}var C=b.Og(),F=C.b()?G(new H,w,y):C.o();if(null===F)throw new x(F);
-var I=F.i(),K=F.j(),N=new mf(new nf(J(new L,["Expected end of input; found "," instead"]))),P=[pf(qf(),I.yb())],T=sf(N,J(new L,P));t();var aa=G(new H,T,new M(K)),Y=O().c;wf(m,new A(aa,Y));break a}}var S=O().c;if(null===S?null!==r:!S.h(r))throw new x(r);}var Z=new xf,ka=new yf(zf(n));Af(Bf(),"Parsed: "+ka+"\n");var X=new Gf(!1,!1,!1,!0),sa=new z(nb=>{throw nb;}),Ia=Hf(If(X));t();var Za=Jf(),Ga=Nf(X,n,t().f,Of(Ia),sa,Za),xa=Pf(Z.qb?Z.sb:ye(Z,X),Ga,(t(),new M(!0)),(Z.qb||ye(Z,X),!0),Ia),Ra=Rf(X,xa,!1,
-Ia);Q();Sf();var Ja=O().c,La=Tf(0,new A(Ra,Ja),!0,"'"),pb=Yf(Ra,La,0),Fb=xe(xe(Zf(pb),"  ","\x26nbsp;\x26nbsp;"),"\n","\x3cbr/\x3e"),Gb=""+we('\x3cdiv\x3e\x3ctable width\x3d"100%"\x3e\n                            |  \x3ctr\x3e\n                            |    \x3ctd colspan\x3d"2"\x3e\x3ch4\x3e\x3ci\x3eTyping Results:\x3c/i\x3e\x3c/h4\x3e\x3c/td\x3e\n                            |  \x3c/tr\x3e\n                            |')+we('\x3ctr\x3e\n                            |  \x3ctd colspan\x3d"2"\x3e'+
-Fb+"\x3c/td\x3e\n                            |\x3c/tr\x3e\n                            |"),Hb=$f(new ag,ka);if(null===Hb)throw new x(Hb);var tb=Hb.j(),kb=Qe(Hb.i(),"","\n",""),gb=fe(a,kb);if(gb instanceof te)var Vb=gb.ca;else{if(!(gb instanceof me))throw new x(gb);Vb=ve(bg(tb,gb.ia))}var bb=""+we('\x3ctr\x3e\n                          |  \x3ctd colspan\x3d"2"\x3e\x3ch4\x3e\x3ci\x3eExecution Results:\x3c/i\x3e\x3c/h4\x3e\x3c/td\x3e\n                          |\x3c/tr\x3e\n                          |')+
-Vb+"\x3c/table\x3e";a=Gb+bb}catch(nb){if(m=nb instanceof oe?nb:new pe(nb),m instanceof cg){n=null;n=re();qf();w=m.Os().m();w=dg(new eg(w,new z(Tb=>Tb.i())));if(m instanceof fg)y='\u2554\u2550\u2550 \x3cstrong style\x3d"color: #E74C3C"\x3e[ERROR]\x3c/strong\x3e ';else{if(!(m instanceof gg))throw new x(m);y='\u2554\u2550\u2550 \x3cstrong style\x3d"color: #F39C12"\x3e[WARNING]\x3c/strong\x3e '}B=-1+m.Os().K()|0;D=D=0;for(C=mg(m.Os());!C.b();){I=C.e();a:{if(null!==I&&(F=I.i(),K=I.Lc(),null!==F)){N=F.i();
-I=F.j();F=ng(new E(K),B);N=og(N,w);ng(new E(K),0)?(K=y+N,se(n,d),se(n,K)):(K=(F&&I.b()?"\u2559\u2500\u2500":"\u255f\u2500\u2500")+" "+N,se(n,d),se(n,K));se(n,a.rr);I.b()?(K=m.Os().K(),K=ng(new E(K),1)):K=!1;K&&(se(n,d),se(n,"\u2559\u2500\u2500"),se(n,a.rr));if(!I.b()){I=I.o();K=pg(I.Wg.os,I.Yg);if(null===K)throw new x(K);P=K.ec|0;T=K.xd|0;ng(new E(D),0)&&(D=D+(-1+P|0)|0);N=pg(I.Wg.os,I.Xg);if(null===N)throw new x(N);K=N.ec|0;N=N.xd|0;for(ka=T;P<=K;)T="l."+(-1+(I.Wg.Uw+P|0)|0)+": ",Y=I.Wg.os.DC.ua(-1+
-P|0),Z=ng(new E(P),K)?N:1+Y.length|0,aa=qg(Q(),Y,0,-1+ka|0),ka='\x3cu style\x3d"text-decoration: #E74C3C dashed underline"\x3e'+qg(Q(),Y,-1+ka|0,-1+Z|0)+"\x3c/u\x3e",Y=qg(Q(),Y,-1+Z|0,Y.length),T="\u2551  "+T+"\t"+aa+ka+Y,se(n,d),se(n,T),se(n,a.rr),ka=1,P=1+P|0,F&&(se(n,d),se(n,"\u2559\u2500\u2500"),se(n,a.rr))}break a}throw new x(I);}C=C.g()}m.Os().b()&&(se(n,d),se(n,"\u2559\u2500\u2500"),se(n,a.rr));a=n.mf.ha}else a='\n      \x3cfont color\x3d"Red"\x3e\n      Unexpected error: '+m+(rg(m),"")+"\x3c/font\x3e"}c.innerHTML=
-a}Ge.prototype.$classData=q({bT:0},!1,"Main$",{bT:1,d:1});var ug;function vg(){ug||(ug=new Ge);return ug}function wg(){}wg.prototype=new p;wg.prototype.constructor=wg;wg.prototype.$classData=q({eT:0},!1,"fastparse.internal.Util$",{eT:1,d:1});var xg;function Pd(a){this.IJ=null;this.ei=a}Pd.prototype=new p;Pd.prototype.constructor=Pd;Pd.prototype.u=function(){return(this.ei.isInterface?"interface ":yg(this)?"":"class ")+this.ei.name};function Dg(a,b){return!!a.ei.isAssignableFrom(b.ei)}
-function Eg(a){return!!a.ei.isArrayClass}function yg(a){return!!a.ei.isPrimitive}
-function Fg(a){if(null===a.IJ){if(Eg(a))var b=Fg(Gg(a))+"[]";else{b=a.ei.name;for(var c=-1+b.length|0;;)if(0<=c&&36===b.charCodeAt(c))c=-1+c|0;else break;if(0<=c){var d=b.charCodeAt(c);d=48<=d&&57>=d}else d=!1;if(d){for(c=-1+c|0;;)if(0<=c?(d=b.charCodeAt(c),d=48<=d&&57>=d):d=!1,d)c=-1+c|0;else break;for(;;)if(0<=c&&36===b.charCodeAt(c))c=-1+c|0;else break}for(;;)if(0<=c?(d=b.charCodeAt(c),d=46!==d&&36!==d):d=!1,d)c=-1+c|0;else break;b=b.substring(1+c|0)}a.IJ=b}return a.IJ}
-function Gg(a){return a.ei.getComponentType()}Pd.prototype.$classData=q({q0:0},!1,"java.lang.Class",{q0:1,d:1});function Hg(){this.MJ=this.LJ=this.Ws=this.VA=null;this.KJ=!1;this.iQ=this.hQ=0;Ig=this;this.VA=new ArrayBuffer(8);this.Ws=new Int32Array(this.VA,0,2);this.LJ=new Float32Array(this.VA,0,2);this.MJ=new Float64Array(this.VA,0,1);this.Ws[0]=16909060;this.hQ=(this.KJ=1===((new Int8Array(this.VA,0,8))[0]|0))?0:1;this.iQ=this.KJ?1:0}Hg.prototype=new p;Hg.prototype.constructor=Hg;
-function Mg(a,b){var c=b|0;if(c===b&&-Infinity!==1/b)return c;a.MJ[0]=b;return(a.Ws[0]|0)^(a.Ws[1]|0)}function Ng(a,b){a.Ws[0]=b;return Math.fround(a.LJ[0])}function Og(a,b){a.LJ[0]=b;return a.Ws[0]|0}function Pg(a,b){a.MJ[0]=b;return new fb(a.Ws[a.iQ]|0,a.Ws[a.hQ]|0)}Hg.prototype.$classData=q({v0:0},!1,"java.lang.FloatingPointBits$",{v0:1,d:1});var Ig;function Qg(){Ig||(Ig=new Hg);return Ig}function Rg(a,b,c,d){this.E0=a;this.kQ=b;this.G0=c;this.F0=d}Rg.prototype=new p;Rg.prototype.constructor=Rg;
-Rg.prototype.$classData=q({D0:0},!1,"java.lang.Long$StringRadixInfo",{D0:1,d:1});function Ug(){}Ug.prototype=new p;Ug.prototype.constructor=Ug;Ug.prototype.$classData=q({H0:0},!1,"java.lang.Math$",{H0:1,d:1});var $g;
-function ah(a,b){var c=bh(a);if(ch().Qx.call(c,b))a=bh(a)[b];else a:for(c=0;;)if(c<(dh(a).length|0)){var d=dh(a)[c];if(0<=b.length&&b.substring(0,d.length)===d){a=""+ih(a)[d]+b.substring(d.length);break a}c=1+c|0}else{a=0<=b.length&&"L"===b.substring(0,1)?b.substring(1):b;break a}return a.split("_").join(".").split("\uff3f").join("_")}
-function bh(a){if(0===(1&a.Lm)<<24>>24&&0===(1&a.Lm)<<24>>24){for(var b={O:"java_lang_Object",T:"java_lang_String"},c=0;22>=c;)2<=c&&(b["T"+c]="scala_Tuple"+c),b["F"+c]="scala_Function"+c,c=1+c|0;a.mQ=b;a.Lm=(1|a.Lm)<<24>>24}return a.mQ}
-function ih(a){0===(2&a.Lm)<<24>>24&&0===(2&a.Lm)<<24>>24&&(a.nQ={sjsr_:"scala_scalajs_runtime_",sjs_:"scala_scalajs_",sci_:"scala_collection_immutable_",scm_:"scala_collection_mutable_",scg_:"scala_collection_generic_",sc_:"scala_collection_",sr_:"scala_runtime_",s_:"scala_",jl_:"java_lang_",ju_:"java_util_"},a.Lm=(2|a.Lm)<<24>>24);return a.nQ}function dh(a){0===(4&a.Lm)<<24>>24&&0===(4&a.Lm)<<24>>24&&(a.lQ=Object.keys(ih(a)),a.Lm=(4|a.Lm)<<24>>24);return a.lQ}
-function jh(a){return(a.stack+"\n").replace(kh("^[\\s\\S]+?\\s+at\\s+")," at ").replace(lh("^\\s+(at eval )?at\\s+","gm"),"").replace(lh("^([^\\(]+?)([\\n])","gm"),"{anonymous}() ($1)$2").replace(lh("^Object.\x3canonymous\x3e\\s*\\(([^\\)]+)\\)","gm"),"{anonymous}() ($1)").replace(lh("^([^\\(]+|\\{anonymous\\}\\(\\)) \\((.+)\\)$","gm"),"$1@$2").split("\n").slice(0,-1)}
-function mh(a){var b=lh("Line (\\d+).*script (?:in )?(\\S+)","i");a=a.message.split("\n");for(var c=[],d=2,e=a.length|0;d<e;){var g=b.exec(a[d]);null!==g&&c.push("{anonymous}()@"+g[2]+":"+g[1]);d=2+d|0}return c}function nh(){this.lQ=this.nQ=this.mQ=null;this.Lm=0}nh.prototype=new p;nh.prototype.constructor=nh;nh.prototype.$classData=q({M0:0},!1,"java.lang.StackTrace$",{M0:1,d:1});var oh;function ph(){}ph.prototype=new p;ph.prototype.constructor=ph;
-function kh(a){sh||(sh=new ph);return new RegExp(a)}function lh(a,b){sh||(sh=new ph);return new RegExp(a,b)}ph.prototype.$classData=q({N0:0},!1,"java.lang.StackTrace$StringRE$",{N0:1,d:1});var sh;function th(){this.oQ=this.pQ=null;uh=this;this.pQ=new vh(!1);this.oQ=new vh(!0)}th.prototype=new p;th.prototype.constructor=th;th.prototype.$classData=q({T0:0},!1,"java.lang.System$Streams$",{T0:1,d:1});var uh;function wh(){uh||(uh=new th);return uh}
-function xh(){this.qQ=this.OJ=null;yh=this;var a={"java.version":"1.8","java.vm.specification.version":"1.8","java.vm.specification.vendor":"Oracle Corporation","java.vm.specification.name":"Java Virtual Machine Specification","java.vm.name":"Scala.js"};a["java.vm.version"]=ba.linkerVersion;a["java.specification.version"]="1.8";a["java.specification.vendor"]="Oracle Corporation";a["java.specification.name"]="Java Platform API Specification";a["file.separator"]="/";a["path.separator"]=":";a["line.separator"]=
-"\n";this.OJ=a;this.qQ=null}xh.prototype=new p;xh.prototype.constructor=xh;function zh(a,b,c){return null!==a.OJ?(a=a.OJ,ch().Qx.call(a,b)?a[b]:c):zh(a.qQ,b,c)}xh.prototype.$classData=q({U0:0},!1,"java.lang.System$SystemProperties$",{U0:1,d:1});var yh;function Ah(){yh||(yh=new xh);return yh}function Bh(){this.Qx=null;Ch=this;this.Qx=Object.prototype.hasOwnProperty}Bh.prototype=new p;Bh.prototype.constructor=Bh;Bh.prototype.$classData=q({W0:0},!1,"java.lang.Utils$Cache$",{W0:1,d:1});var Ch;
-function ch(){Ch||(Ch=new Bh);return Ch}function Dh(a){return!!(a&&a.$classData&&1===a.$classData.Lx&&a.$classData.Kx.pb.uQ)}var Xa=q({uQ:0},!1,"java.lang.Void",{uQ:1,d:1},a=>void 0===a);function Eh(){}Eh.prototype=new p;Eh.prototype.constructor=Eh;function Fh(a,b,c){return b.ei.newArrayOfThisClass([c])}Eh.prototype.$classData=q({X0:0},!1,"java.lang.reflect.Array$",{X0:1,d:1});var Ih;function Jh(){Ih||(Ih=new Eh);return Ih}function Kh(a,b){this.WL=a;this.XL=b}Kh.prototype=new p;
-Kh.prototype.constructor=Kh;Kh.prototype.$classData=q({lT:0},!1,"java.math.BigInteger$QuotAndRem",{lT:1,d:1});function Lh(){}Lh.prototype=new p;Lh.prototype.constructor=Lh;function Mh(a,b){if(0===b.Ya)return 0;a=b.ub<<5;var c=b.Pa.a[-1+b.ub|0];0>b.Ya&&Nh(b)===(-1+b.ub|0)&&(c=-1+c|0);return a=a-Math.clz32(c)|0}function Oh(a,b,c){a=c>>5;c&=31;var d=(b.ub+a|0)+(0===c?0:1)|0,e=new zd(d);Ph(0,e,b.Pa,a,c);b=Qh(b.Ya,d,e);Wh(b);return b}
-function Ph(a,b,c,d,e){if(0===e)c.va(0,b,d,b.a.length-d|0);else{a=32-e|0;b.a[-1+b.a.length|0]=0;for(var g=-1+b.a.length|0;g>d;){var h=g;b.a[h]=b.a[h]|c.a[-1+(g-d|0)|0]>>>a|0;b.a[-1+g|0]=c.a[-1+(g-d|0)|0]<<e;g=-1+g|0}}for(c=0;c<d;)b.a[c]=0,c=1+c|0}function Xh(a,b,c,d){for(var e=a=0;e<d;){var g=e,h=c.a[g];b.a[g]=h<<1|a;a=h>>>31|0;e=1+e|0}0!==a&&(b.a[d]=a)}
-function Yh(a,b,c){a=c>>5;var d=31&c;if(a>=b.ub)return 0>b.Ya?Zh().oC:Zh().Dp;c=b.ub-a|0;var e=new zd(1+c|0);$h(0,e,c,b.Pa,a,d);if(0>b.Ya){for(var g=0;g<a&&0===b.Pa.a[g];)g=1+g|0;var h=0!==b.Pa.a[g]<<(32-d|0);if(g<a||0<d&&h){for(g=0;g<c&&-1===e.a[g];)e.a[g]=0,g=1+g|0;g===c&&(c=1+c|0);a=g;e.a[a]=1+e.a[a]|0}}b=Qh(b.Ya,c,e);Wh(b);return b}
-function $h(a,b,c,d,e,g){for(a=0;a<e;)a=1+a|0;if(0===g)d.va(e,b,0,c);else{var h=32-g|0;for(a=0;a<(-1+c|0);)b.a[a]=d.a[a+e|0]>>>g|0|d.a[1+(a+e|0)|0]<<h,a=1+a|0;b.a[a]=d.a[a+e|0]>>>g|0}}Lh.prototype.$classData=q({mT:0},!1,"java.math.BitLevel$",{mT:1,d:1});var ai;function bi(){ai||(ai=new Lh);return ai}
-function ci(){this.YG=this.ZG=null;di=this;this.ZG=new zd(new Int32Array([-1,-1,31,19,15,13,11,11,10,9,9,8,8,8,8,7,7,7,7,7,7,7,6,6,6,6,6,6,6,6,6,6,6,6,6,6,5]));this.YG=new zd(new Int32Array([-2147483648,1162261467,1073741824,1220703125,362797056,1977326743,1073741824,387420489,1E9,214358881,429981696,815730721,1475789056,170859375,268435456,410338673,612220032,893871739,128E7,1801088541,113379904,148035889,191102976,244140625,308915776,387420489,481890304,594823321,729E6,887503681,1073741824,1291467969,
-1544804416,1838265625,60466176]))}ci.prototype=new p;ci.prototype.constructor=ci;
-function ei(a,b){a=b.Ya;var c=b.ub,d=b.Pa;if(0===a)return"0";if(1===c)return b=(+(d.a[0]>>>0)).toString(10),0>a?"-"+b:b;b="";var e=new zd(c);for(d.va(0,e,0,c);;){var g=0;for(d=-1+c|0;0<=d;){var h=g;g=e.a[d];var k=fi(Cb(),g,h,1E9,0);e.a[d]=k;h=k>>31;var l=65535&k;k=k>>>16|0;var m=Math.imul(51712,l);l=Math.imul(15258,l);var n=Math.imul(51712,k);m=m+((l+n|0)<<16)|0;Math.imul(1E9,h);Math.imul(15258,k);g=g-m|0;d=-1+d|0}d=""+g;for(b="000000000".substring(d.length)+d+b;0!==c&&0===e.a[-1+c|0];)c=-1+c|0;if(0===
+'use strict';var f,aaa=Object.freeze({esVersion:6,assumingES6:!0,productionMode:!0,linkerVersion:"1.11.0",fileLevelThis:this}),aa;function baa(a){for(var b in a)return b}function ba(a){this.eQ=a}ba.prototype.toString=function(){return String.fromCharCode(this.eQ)};var daa=function caa(a,b,c){var e=new a.Ia(b[c]);if(c<b.length-1){a=a.kB;c+=1;for(var g=e.a,h=0;h<g.length;h++)g[h]=caa(a,b,c)}return e};
+function ca(a){switch(typeof a){case "string":return da(fa);case "number":return ha(a)?a<<24>>24===a?da(eaa):a<<16>>16===a?da(faa):da(gaa):ja(a)?da(haa):da(iaa);case "boolean":return da(jaa);case "undefined":return da(la);default:return null===a?a.N0():a instanceof ma?da(kaa):a instanceof ba?da(laa):a&&a.$classData?da(a.$classData):null}}
+function na(a){switch(typeof a){case "string":return"java.lang.String";case "number":return ha(a)?a<<24>>24===a?"java.lang.Byte":a<<16>>16===a?"java.lang.Short":"java.lang.Integer":ja(a)?"java.lang.Float":"java.lang.Double";case "boolean":return"java.lang.Boolean";case "undefined":return"java.lang.Void";default:return null===a?a.N0():a instanceof ma?"java.lang.Long":a instanceof ba?"java.lang.Character":a&&a.$classData?a.$classData.name:null.qi.name}}
+function oa(a,b){switch(typeof a){case "string":return pa(a,b);case "number":return maa(qa(),a,b);case "boolean":return a===b?0:a?1:-1;default:return a instanceof ma?ua(xa(),a.W,a.Y,b.W,b.Y):a instanceof ba?Ea(a)-Ea(b)|0:a.sl(b)}}
+function La(a,b){switch(typeof a){case "string":return a===b;case "number":return Object.is(a,b);case "boolean":return a===b;case "undefined":return a===b;default:return a&&a.$classData||null===a?a=a.i(b):a instanceof ma?b instanceof ma?(b=Za(b),a=a.W===b.W&&a.Y===b.Y):a=!1:a=a instanceof ba?b instanceof ba?Ea(a)===Ea(b):!1:gb.prototype.i.call(a,b),a}}
+function ib(a){switch(typeof a){case "string":return lb(a);case "number":return mb(a);case "boolean":return a?1231:1237;case "undefined":return 0;default:return a&&a.$classData||null===a?a.B():a instanceof ma?a.W^a.Y:a instanceof ba?Ea(a):gb.prototype.B.call(a)}}function nb(a){return void 0===a?"undefined":a.toString()}function pb(a,b){if(0===b)throw new qb("/ by zero");return a/b|0}function Bb(a,b){if(0===b)throw new qb("/ by zero");return a%b|0}
+function Eb(a){return 2147483647<a?2147483647:-2147483648>a?-2147483648:a|0}function Fb(a,b,c,d,e){if(a!==c||d<b||(b+e|0)<d)for(var g=0;g<e;g=g+1|0)c[d+g|0]=a[b+g|0];else for(g=e-1|0;0<=g;g=g-1|0)c[d+g|0]=a[b+g|0]}var Kb=0,Mb=new WeakMap;
+function Qb(a){switch(typeof a){case "string":return lb(a);case "number":return mb(a);case "bigint":var b=0;for(a<BigInt(0)&&(a=~a);a!==BigInt(0);)b^=Number(BigInt.asIntN(32,a)),a>>=BigInt(32);return b;case "boolean":return a?1231:1237;case "undefined":return 0;case "symbol":return a=a.description,void 0===a?0:lb(a);default:if(null===a)return 0;b=Mb.get(a);void 0===b&&(Kb=b=Kb+1|0,Mb.set(a,b));return b}}function Zb(a){return"number"===typeof a&&a<<24>>24===a&&1/a!==1/-0}
+function $b(a){return"number"===typeof a&&a<<16>>16===a&&1/a!==1/-0}function ha(a){return"number"===typeof a&&(a|0)===a&&1/a!==1/-0}function ja(a){return"number"===typeof a&&(a!==a||Math.fround(a)===a)}function hc(a){return new ba(a)}function Ea(a){return null===a?0:a.eQ}function Za(a){return null===a?aa:a}function tc(){return new gb}function gb(){}gb.prototype.constructor=gb;function p(){}p.prototype=gb.prototype;gb.prototype.B=function(){return Qb(this)};
+gb.prototype.i=function(a){return this===a};gb.prototype.u=function(){var a=this.B();return na(this)+"@"+(+(a>>>0)).toString(16)};gb.prototype.toString=function(){return this.u()};function zc(a){if("number"===typeof a){this.a=Array(a);for(var b=0;b<a;b++)this.a[b]=null}else this.a=a}zc.prototype=new p;zc.prototype.constructor=zc;zc.prototype.wa=function(a,b,c,d){Fb(this.a,a,b.a,c,d)};zc.prototype.ia=function(){return new zc(this.a.slice())};function Dc(){}Dc.prototype=zc.prototype;
+function Ec(a){if("number"===typeof a){this.a=Array(a);for(var b=0;b<a;b++)this.a[b]=!1}else this.a=a}Ec.prototype=new p;Ec.prototype.constructor=Ec;Ec.prototype.wa=function(a,b,c,d){Fb(this.a,a,b.a,c,d)};Ec.prototype.ia=function(){return new Ec(this.a.slice())};function Ic(a){this.a="number"===typeof a?new Uint16Array(a):a}Ic.prototype=new p;Ic.prototype.constructor=Ic;Ic.prototype.wa=function(a,b,c,d){b.a.set(this.a.subarray(a,a+d|0),c)};Ic.prototype.ia=function(){return new Ic(this.a.slice())};
+function Pc(a){this.a="number"===typeof a?new Int8Array(a):a}Pc.prototype=new p;Pc.prototype.constructor=Pc;Pc.prototype.wa=function(a,b,c,d){b.a.set(this.a.subarray(a,a+d|0),c)};Pc.prototype.ia=function(){return new Pc(this.a.slice())};function Sc(a){this.a="number"===typeof a?new Int16Array(a):a}Sc.prototype=new p;Sc.prototype.constructor=Sc;Sc.prototype.wa=function(a,b,c,d){b.a.set(this.a.subarray(a,a+d|0),c)};Sc.prototype.ia=function(){return new Sc(this.a.slice())};
+function Xc(a){this.a="number"===typeof a?new Int32Array(a):a}Xc.prototype=new p;Xc.prototype.constructor=Xc;Xc.prototype.wa=function(a,b,c,d){b.a.set(this.a.subarray(a,a+d|0),c)};Xc.prototype.ia=function(){return new Xc(this.a.slice())};function Zc(a){if("number"===typeof a){this.a=Array(a);for(var b=0;b<a;b++)this.a[b]=aa}else this.a=a}Zc.prototype=new p;Zc.prototype.constructor=Zc;Zc.prototype.wa=function(a,b,c,d){Fb(this.a,a,b.a,c,d)};Zc.prototype.ia=function(){return new Zc(this.a.slice())};
+function $c(a){this.a="number"===typeof a?new Float32Array(a):a}$c.prototype=new p;$c.prototype.constructor=$c;$c.prototype.wa=function(a,b,c,d){b.a.set(this.a.subarray(a,a+d|0),c)};$c.prototype.ia=function(){return new $c(this.a.slice())};function ed(a){this.a="number"===typeof a?new Float64Array(a):a}ed.prototype=new p;ed.prototype.constructor=ed;ed.prototype.wa=function(a,b,c,d){b.a.set(this.a.subarray(a,a+d|0),c)};ed.prototype.ia=function(){return new ed(this.a.slice())};
+function fd(){this.Ia=void 0;this.fy=this.kB=this.rb=null;this.gy=0;this.jz=null;this.lv="";this.iz=this.sv=this.bB=this.rJ=void 0;this.name="";this.isJSClass=this.isArrayClass=this.isInterface=this.isPrimitive=!1;this.isInstance=void 0}function gd(a,b,c,d,e){var g=new fd;g.rb={};g.jz=a;g.lv=b;g.sv=h=>h===g;g.name=c;g.isPrimitive=!0;g.isInstance=()=>!1;void 0!==d&&(g.bB=id(g,d,e));return g}
+function q(a,b,c,d,e){var g=new fd,h=baa(a);g.rb=d;g.lv="L"+c+";";g.sv=k=>!!k.rb[h];g.name=c;g.isInterface=b;g.isInstance=e||(k=>!!(k&&k.$classData&&k.$classData.rb[h]));return g}function id(a,b,c,d){var e=new fd;b.prototype.$classData=e;var g="["+a.lv;e.Ia=b;e.rb={g:1,Ff:1,l:1};e.kB=a;e.fy=a;e.gy=1;e.lv=g;e.name=g;e.isArrayClass=!0;e.sv=d||(h=>e===h);e.iz=c?h=>new b(new c(h)):h=>new b(h);e.isInstance=h=>h instanceof b;return e}
+function naa(a){function b(k){if("number"===typeof k){this.a=Array(k);for(var l=0;l<k;l++)this.a[l]=null}else this.a=k}var c=new fd;b.prototype=new Dc;b.prototype.constructor=b;b.prototype.wa=function(k,l,m,n){Fb(this.a,k,l.a,m,n)};b.prototype.ia=function(){return new b(this.a.slice())};var d=a.fy||a,e=a.gy+1;b.prototype.$classData=c;var g="["+a.lv;c.Ia=b;c.rb={g:1,Ff:1,l:1};c.kB=a;c.fy=d;c.gy=e;c.lv=g;c.name=g;c.isArrayClass=!0;var h=k=>{var l=k.gy;return l===e?d.sv(k.fy):l>e&&d===jd};c.sv=h;c.iz=
+k=>new b(k);c.isInstance=k=>{k=k&&k.$classData;return!!k&&(k===c||h(k))};return c}function md(a){a.bB||(a.bB=naa(a));return a.bB}function da(a){a.rJ||(a.rJ=new nd(a));return a.rJ}fd.prototype.isAssignableFrom=function(a){return this===a||this.sv(a)};fd.prototype.checkCast=function(){};fd.prototype.getSuperclass=function(){return this.S2?da(this.S2):null};fd.prototype.getComponentType=function(){return this.kB?da(this.kB):null};
+fd.prototype.newArrayOfThisClass=function(a){for(var b=this,c=0;c<a.length;c++)b=md(b);return daa(b,a,0)};var jd=new fd;jd.rb={g:1};jd.lv="Ljava.lang.Object;";jd.sv=a=>!a.isPrimitive;jd.name="java.lang.Object";jd.isInstance=a=>null!==a;jd.bB=id(jd,zc,void 0,a=>{var b=a.gy;return 1===b?!a.fy.isPrimitive:1<b});gb.prototype.$classData=jd;
+var pd=gd(void 0,"V","void",void 0,void 0),rd=gd(!1,"Z","boolean",Ec,void 0),td=gd(0,"C","char",Ic,Uint16Array),xd=gd(0,"B","byte",Pc,Int8Array),Cd=gd(0,"S","short",Sc,Int16Array),Ed=gd(0,"I","int",Xc,Int32Array),Fd=gd(null,"J","long",Zc,void 0),Gd=gd(0,"F","float",$c,Float32Array),Ld=gd(0,"D","double",ed,Float64Array);
+function oaa(a,b){try{t();var c=(0,eval)(b),d=Md(new Nd,c);Od();var e=Pd(u(),d);return new Ud(e)}catch(g){return c=g instanceof Vd?g:new $d(g),b=ce(),ee(b,'\x3cfont color\x3d"red"\x3eRuntime error occurred:\x3c/font\x3e'),c=""+a.as+c.qj(),ee(b,c),ee(b,a.as),ee(b,a.as),t(),new fe(b.yf.ja)}}
+function paa(a){var b=ce(),c=he("\x3ctr\x3e\n                      |  \x3ctd\x3eName\x3c/td\x3e\n                      |  \x3ctd\x3eValue\x3c/td\x3e\n                      |\x3c/tr\x3e\n                      |");for(ee(b,c);!a.b();)c=a.e(),c='\x3ctr\x3e\n                         |  \x3ctd class\x3d"name"\x3e'+je(je(c.h(),"  ","\x26nbsp;\x26nbsp;"),"\n","\x3cbr/\x3e")+"\x3c/td\x3e\n                         |  \x3ctd\x3e"+je(je(c.j(),"  ","\x26nbsp;\x26nbsp;"),"\n","\x3cbr/\x3e")+"\x3c/td\x3e\n                         |\x3c/tr\x3e\n                         |",
+c=he(c),ee(b,c),a=a.f();return b.yf.ja}function ke(a,b){if(null===a)throw le();return a.sb?a.vb:me(a,new ne(b))}function oe(){this.as="\x3cbr /\x3e"}oe.prototype=new p;oe.prototype.constructor=oe;function qe(a,b){b=b.target;if(b instanceof HTMLTextAreaElement)se(a,b.value);else throw new w(b);}
+function se(a,b){var c=document.querySelector("#mlscript-output"),d=null;d="";try{var e=ue(ve(),b),g=we(xe(),e);ze(g,"","","");var h=Ae(new Fe,b,g),k=new Ge("\x3cinput\x3e",1,h),l=qaa(new Je(k,new y(vb=>{throw vb;}),!1)),m=new Ke(k,l),n=Le(m),r=Me(m,new Ne(136),new Oe("parseAll"));a:{if(r instanceof z){var v=r.z;if(null!==v){var x=v.h(),A=v.j();for(b=r;;){if(b.b())C=!1;else var B=b.e().h(),C=Pe(new E(B),Se());if(C)b=b.f();else break}var D=b.Jg(),F=D.b()?G(new H,x,A):D.o();if(null===F)throw new w(F);
+var I=F.h(),M=F.j(),N=new Te(new Ue(J(new K,["Expected end of input; found "," instead"]))),P=[We(Xe(),I.jb())],T=Ye(N,J(new K,P));t();var Y=G(new H,T,new L(M)),Z=O().c;Ze(m,new z(Y,Z));break a}}var S=O().c;if(null===S?null!==r:!S.i(r))throw new w(r);}var ea=new $e,ia=new cf(ef(n));ff(gf(),"Parsed: "+ia+"\n");var X=new hf(!1,!1,!1,!0),sa=new y(vb=>{throw vb;}),Ja=mf(raa(X));t();var Xa=nf(),Fa=of(X,n,t().d,tf(Ja),sa,Xa),za=saa(ea.sb?ea.vb:ke(ea,X),Fa,(t(),new L(!0)),(ea.sb||ke(ea,X),!0),Ja),Qa=uf(X,
+za,!1,Ja);Q();vf();var Ma=O().c,Ga=wf(0,new z(Qa,Ma),!0,"'"),ab=yf(Qa,0,Ga),Hb=je(je(zf(ab),"  ","\x26nbsp;\x26nbsp;"),"\n","\x3cbr/\x3e"),bc=""+he('\x3cdiv\x3e\x3ctable width\x3d"100%"\x3e\n                            |  \x3ctr\x3e\n                            |    \x3ctd colspan\x3d"2"\x3e\x3ch4\x3e\x3ci\x3eTyping Results:\x3c/i\x3e\x3c/h4\x3e\x3c/td\x3e\n                            |  \x3c/tr\x3e\n                            |')+he('\x3ctr\x3e\n                            |  \x3ctd colspan\x3d"2"\x3e'+
+Hb+"\x3c/td\x3e\n                            |\x3c/tr\x3e\n                            |"),yb=taa(new Af,ia);if(null===yb)throw new w(yb);var tb=yb.j(),eb=ze(yb.h(),"","\n",""),kb=oaa(a,eb);if(kb instanceof fe)var Rb=kb.aa;else{if(!(kb instanceof Ud))throw new w(kb);Rb=paa(Bf(tb,kb.fa))}var Gb=""+he('\x3ctr\x3e\n                          |  \x3ctd colspan\x3d"2"\x3e\x3ch4\x3e\x3ci\x3eExecution Results:\x3c/i\x3e\x3c/h4\x3e\x3c/td\x3e\n                          |\x3c/tr\x3e\n                          |')+
+Rb+"\x3c/table\x3e";a=bc+Gb}catch(vb){if(m=vb instanceof Vd?vb:new $d(vb),m instanceof Df){n=null;n=ce();Xe();x=m.vt().m();x=uaa(new Ef(x,new y(Tb=>Tb.h())));if(m instanceof Ff)A='\u2554\u2550\u2550 \x3cstrong style\x3d"color: #E74C3C"\x3e[ERROR]\x3c/strong\x3e ';else{if(!(m instanceof Gf))throw new w(m);A='\u2554\u2550\u2550 \x3cstrong style\x3d"color: #F39C12"\x3e[WARNING]\x3c/strong\x3e '}B=-1+m.vt().K()|0;C=C=0;for(D=Hf(m.vt());!D.b();){I=D.e();a:{if(null!==I&&(F=I.h(),M=I.Sc(),null!==F)){N=F.h();
+I=F.j();F=Lf(new E(M),B);N=Mf(N,x);Lf(new E(M),0)?(M=A+N,ee(n,d),ee(n,M)):(M=(F&&I.b()?"\u2559\u2500\u2500":"\u255f\u2500\u2500")+" "+N,ee(n,d),ee(n,M));ee(n,a.as);I.b()?(M=m.vt().K(),M=Lf(new E(M),1)):M=!1;M&&(ee(n,d),ee(n,"\u2559\u2500\u2500"),ee(n,a.as));if(!I.b()){I=I.o();M=Nf(I.dh.Us,I.fh);if(null===M)throw new w(M);P=M.kc|0;T=M.Rd|0;Lf(new E(C),0)&&(C=C+(-1+P|0)|0);N=Nf(I.dh.Us,I.eh);if(null===N)throw new w(N);M=N.kc|0;N=N.Rd|0;for(ia=T;P<=M;)T="l."+(-1+(I.dh.rx+P|0)|0)+": ",Z=I.dh.Us.$C.va(-1+
+P|0),ea=Lf(new E(P),M)?N:1+Z.length|0,Y=Of(Q(),Z,0,-1+ia|0),ia='\x3cu style\x3d"text-decoration: #E74C3C dashed underline"\x3e'+Of(Q(),Z,-1+ia|0,-1+ea|0)+"\x3c/u\x3e",Z=Of(Q(),Z,-1+ea|0,Z.length),T="\u2551  "+T+"\t"+Y+ia+Z,ee(n,d),ee(n,T),ee(n,a.as),ia=1,P=1+P|0,F&&(ee(n,d),ee(n,"\u2559\u2500\u2500"),ee(n,a.as))}break a}throw new w(I);}D=D.f()}m.vt().b()&&(ee(n,d),ee(n,"\u2559\u2500\u2500"),ee(n,a.as));a=n.yf.ja}else a='\n      \x3cfont color\x3d"Red"\x3e\n      Unexpected error: '+m+(vaa(m),"")+
+"\x3c/font\x3e"}c.innerHTML=a}oe.prototype.$classData=q({uT:0},!1,"Main$",{uT:1,g:1});var Pf;function Qf(){Pf||(Pf=new oe);return Pf}function Rf(){}Rf.prototype=new p;Rf.prototype.constructor=Rf;Rf.prototype.$classData=q({xT:0},!1,"fastparse.internal.Util$",{xT:1,g:1});var Sf;function nd(a){this.$J=null;this.qi=a}nd.prototype=new p;nd.prototype.constructor=nd;nd.prototype.u=function(){return(this.qi.isInterface?"interface ":Yf(this)?"":"class ")+this.qi.name};
+function Zf(a,b){return!!a.qi.isAssignableFrom(b.qi)}function $f(a){return!!a.qi.isArrayClass}function Yf(a){return!!a.qi.isPrimitive}
+function ag(a){if(null===a.$J){if($f(a))var b=ag(bg(a))+"[]";else{b=a.qi.name;for(var c=-1+b.length|0;;)if(0<=c&&36===b.charCodeAt(c))c=-1+c|0;else break;if(0<=c){var d=b.charCodeAt(c);d=48<=d&&57>=d}else d=!1;if(d){for(c=-1+c|0;;)if(0<=c?(d=b.charCodeAt(c),d=48<=d&&57>=d):d=!1,d)c=-1+c|0;else break;for(;;)if(0<=c&&36===b.charCodeAt(c))c=-1+c|0;else break}for(;;)if(0<=c?(d=b.charCodeAt(c),d=46!==d&&36!==d):d=!1,d)c=-1+c|0;else break;b=b.substring(1+c|0)}a.$J=b}return a.$J}
+function bg(a){return a.qi.getComponentType()}nd.prototype.$classData=q({W0:0},!1,"java.lang.Class",{W0:1,g:1});function cg(){this.dK=this.cK=this.Dt=this.qB=null;this.bK=!1;this.BQ=this.AQ=0;dg=this;this.qB=new ArrayBuffer(8);this.Dt=new Int32Array(this.qB,0,2);this.cK=new Float32Array(this.qB,0,2);this.dK=new Float64Array(this.qB,0,1);this.Dt[0]=16909060;this.AQ=(this.bK=1===((new Int8Array(this.qB,0,8))[0]|0))?0:1;this.BQ=this.bK?1:0}cg.prototype=new p;cg.prototype.constructor=cg;
+function ig(a,b){var c=b|0;if(c===b&&-Infinity!==1/b)return c;a.dK[0]=b;return(a.Dt[0]|0)^(a.Dt[1]|0)}function jg(a,b){a.Dt[0]=b;return Math.fround(a.cK[0])}function kg(a,b){a.cK[0]=b;return a.Dt[0]|0}function lg(a,b){a.dK[0]=b;return new ma(a.Dt[a.BQ]|0,a.Dt[a.AQ]|0)}cg.prototype.$classData=q({a1:0},!1,"java.lang.FloatingPointBits$",{a1:1,g:1});var dg;function mg(){dg||(dg=new cg);return dg}function pg(a,b,c,d){this.j1=a;this.DQ=b;this.l1=c;this.k1=d}pg.prototype=new p;pg.prototype.constructor=pg;
+pg.prototype.$classData=q({i1:0},!1,"java.lang.Long$StringRadixInfo",{i1:1,g:1});function qg(){}qg.prototype=new p;qg.prototype.constructor=qg;qg.prototype.$classData=q({m1:0},!1,"java.lang.Math$",{m1:1,g:1});var rg;
+function sg(a,b){var c=tg(a);if(ug().ny.call(c,b))a=tg(a)[b];else a:for(c=0;;)if(c<(Dg(a).length|0)){var d=Dg(a)[c];if(0<=b.length&&b.substring(0,d.length)===d){a=""+Eg(a)[d]+b.substring(d.length);break a}c=1+c|0}else{a=0<=b.length&&"L"===b.substring(0,1)?b.substring(1):b;break a}return a.split("_").join(".").split("\uff3f").join("_")}
+function tg(a){if(0===(1&a.ln)<<24>>24&&0===(1&a.ln)<<24>>24){for(var b={O:"java_lang_Object",T:"java_lang_String"},c=0;22>=c;)2<=c&&(b["T"+c]="scala_Tuple"+c),b["F"+c]="scala_Function"+c,c=1+c|0;a.FQ=b;a.ln=(1|a.ln)<<24>>24}return a.FQ}
+function Eg(a){0===(2&a.ln)<<24>>24&&0===(2&a.ln)<<24>>24&&(a.GQ={sjsr_:"scala_scalajs_runtime_",sjs_:"scala_scalajs_",sci_:"scala_collection_immutable_",scm_:"scala_collection_mutable_",scg_:"scala_collection_generic_",sc_:"scala_collection_",sr_:"scala_runtime_",s_:"scala_",jl_:"java_lang_",ju_:"java_util_"},a.ln=(2|a.ln)<<24>>24);return a.GQ}function Dg(a){0===(4&a.ln)<<24>>24&&0===(4&a.ln)<<24>>24&&(a.EQ=Object.keys(Eg(a)),a.ln=(4|a.ln)<<24>>24);return a.EQ}
+function Fg(a){return(a.stack+"\n").replace(Gg("^[\\s\\S]+?\\s+at\\s+")," at ").replace(Rg("^\\s+(at eval )?at\\s+","gm"),"").replace(Rg("^([^\\(]+?)([\\n])","gm"),"{anonymous}() ($1)$2").replace(Rg("^Object.\x3canonymous\x3e\\s*\\(([^\\)]+)\\)","gm"),"{anonymous}() ($1)").replace(Rg("^([^\\(]+|\\{anonymous\\}\\(\\)) \\((.+)\\)$","gm"),"$1@$2").split("\n").slice(0,-1)}
+function Sg(a){var b=Rg("Line (\\d+).*script (?:in )?(\\S+)","i");a=a.message.split("\n");for(var c=[],d=2,e=a.length|0;d<e;){var g=b.exec(a[d]);null!==g&&c.push("{anonymous}()@"+g[2]+":"+g[1]);d=2+d|0}return c}function Tg(){this.EQ=this.GQ=this.FQ=null;this.ln=0}Tg.prototype=new p;Tg.prototype.constructor=Tg;Tg.prototype.$classData=q({r1:0},!1,"java.lang.StackTrace$",{r1:1,g:1});var Ug;function Vg(){}Vg.prototype=new p;Vg.prototype.constructor=Vg;
+function Gg(a){Wg||(Wg=new Vg);return new RegExp(a)}function Rg(a,b){Wg||(Wg=new Vg);return new RegExp(a,b)}Vg.prototype.$classData=q({s1:0},!1,"java.lang.StackTrace$StringRE$",{s1:1,g:1});var Wg;function Xg(){this.HQ=this.IQ=null;Yg=this;this.IQ=new Zg(!1);this.HQ=new Zg(!0)}Xg.prototype=new p;Xg.prototype.constructor=Xg;Xg.prototype.$classData=q({y1:0},!1,"java.lang.System$Streams$",{y1:1,g:1});var Yg;function ch(){Yg||(Yg=new Xg);return Yg}
+function dh(){this.JQ=this.fK=null;eh=this;var a={"java.version":"1.8","java.vm.specification.version":"1.8","java.vm.specification.vendor":"Oracle Corporation","java.vm.specification.name":"Java Virtual Machine Specification","java.vm.name":"Scala.js"};a["java.vm.version"]=aaa.linkerVersion;a["java.specification.version"]="1.8";a["java.specification.vendor"]="Oracle Corporation";a["java.specification.name"]="Java Platform API Specification";a["file.separator"]="/";a["path.separator"]=":";a["line.separator"]=
+"\n";this.fK=a;this.JQ=null}dh.prototype=new p;dh.prototype.constructor=dh;function fh(a,b,c){return null!==a.fK?(a=a.fK,ug().ny.call(a,b)?a[b]:c):fh(a.JQ,b,c)}dh.prototype.$classData=q({z1:0},!1,"java.lang.System$SystemProperties$",{z1:1,g:1});var eh;function gh(){eh||(eh=new dh);return eh}function hh(){this.ny=null;oh=this;this.ny=Object.prototype.hasOwnProperty}hh.prototype=new p;hh.prototype.constructor=hh;hh.prototype.$classData=q({B1:0},!1,"java.lang.Utils$Cache$",{B1:1,g:1});var oh;
+function ug(){oh||(oh=new hh);return oh}function ph(a){return!!(a&&a.$classData&&1===a.$classData.gy&&a.$classData.fy.rb.NQ)}var la=q({NQ:0},!1,"java.lang.Void",{NQ:1,g:1},a=>void 0===a);function qh(){}qh.prototype=new p;qh.prototype.constructor=qh;function rh(a,b,c){return b.qi.newArrayOfThisClass([c])}qh.prototype.$classData=q({C1:0},!1,"java.lang.reflect.Array$",{C1:1,g:1});var sh;function th(){sh||(sh=new qh);return sh}function uh(a,b){this.nM=a;this.oM=b}uh.prototype=new p;
+uh.prototype.constructor=uh;uh.prototype.$classData=q({ET:0},!1,"java.math.BigInteger$QuotAndRem",{ET:1,g:1});function xh(){}xh.prototype=new p;xh.prototype.constructor=xh;function yh(a,b){if(0===b.Ya)return 0;a=b.wb<<5;var c=b.Qa.a[-1+b.wb|0];0>b.Ya&&zh(b)===(-1+b.wb|0)&&(c=-1+c|0);return a=a-Math.clz32(c)|0}function Fh(a,b,c){a=c>>5;c&=31;var d=(b.wb+a|0)+(0===c?0:1)|0,e=new Xc(d);Gh(0,e,b.Qa,a,c);b=Hh(b.Ya,d,e);Ih(b);return b}
+function Gh(a,b,c,d,e){if(0===e)c.wa(0,b,d,b.a.length-d|0);else{a=32-e|0;b.a[-1+b.a.length|0]=0;for(var g=-1+b.a.length|0;g>d;){var h=g;b.a[h]=b.a[h]|c.a[-1+(g-d|0)|0]>>>a|0;b.a[-1+g|0]=c.a[-1+(g-d|0)|0]<<e;g=-1+g|0}}for(c=0;c<d;)b.a[c]=0,c=1+c|0}function Nh(a,b,c,d){for(var e=a=0;e<d;){var g=e,h=c.a[g];b.a[g]=h<<1|a;a=h>>>31|0;e=1+e|0}0!==a&&(b.a[d]=a)}
+function Oh(a,b,c){a=c>>5;var d=31&c;if(a>=b.wb)return 0>b.Ya?Ph().MC:Ph().nq;c=b.wb-a|0;var e=new Xc(1+c|0);Qh(0,e,c,b.Qa,a,d);if(0>b.Ya){for(var g=0;g<a&&0===b.Qa.a[g];)g=1+g|0;var h=0!==b.Qa.a[g]<<(32-d|0);if(g<a||0<d&&h){for(g=0;g<c&&-1===e.a[g];)e.a[g]=0,g=1+g|0;g===c&&(c=1+c|0);a=g;e.a[a]=1+e.a[a]|0}}b=Hh(b.Ya,c,e);Ih(b);return b}
+function Qh(a,b,c,d,e,g){for(a=0;a<e;)a=1+a|0;if(0===g)d.wa(e,b,0,c);else{var h=32-g|0;for(a=0;a<(-1+c|0);)b.a[a]=d.a[a+e|0]>>>g|0|d.a[1+(a+e|0)|0]<<h,a=1+a|0;b.a[a]=d.a[a+e|0]>>>g|0}}xh.prototype.$classData=q({FT:0},!1,"java.math.BitLevel$",{FT:1,g:1});var Rh;function Sh(){Rh||(Rh=new xh);return Rh}
+function Th(){this.tH=this.uH=null;Uh=this;this.uH=new Xc(new Int32Array([-1,-1,31,19,15,13,11,11,10,9,9,8,8,8,8,7,7,7,7,7,7,7,6,6,6,6,6,6,6,6,6,6,6,6,6,6,5]));this.tH=new Xc(new Int32Array([-2147483648,1162261467,1073741824,1220703125,362797056,1977326743,1073741824,387420489,1E9,214358881,429981696,815730721,1475789056,170859375,268435456,410338673,612220032,893871739,128E7,1801088541,113379904,148035889,191102976,244140625,308915776,387420489,481890304,594823321,729E6,887503681,1073741824,1291467969,
+1544804416,1838265625,60466176]))}Th.prototype=new p;Th.prototype.constructor=Th;
+function Vh(a,b){a=b.Ya;var c=b.wb,d=b.Qa;if(0===a)return"0";if(1===c)return b=(+(d.a[0]>>>0)).toString(10),0>a?"-"+b:b;b="";var e=new Xc(c);for(d.wa(0,e,0,c);;){var g=0;for(d=-1+c|0;0<=d;){var h=g;g=e.a[d];var k=Wh(xa(),g,h,1E9,0);e.a[d]=k;h=k>>31;var l=65535&k;k=k>>>16|0;var m=Math.imul(51712,l);l=Math.imul(15258,l);var n=Math.imul(51712,k);m=m+((l+n|0)<<16)|0;Math.imul(1E9,h);Math.imul(15258,k);g=g-m|0;d=-1+d|0}d=""+g;for(b="000000000".substring(d.length)+d+b;0!==c&&0===e.a[-1+c|0];)c=-1+c|0;if(0===
 c)break}e=0;for(c=b.length;;)if(e<c&&48===b.charCodeAt(e))e=1+e|0;else break;b=b.substring(e);return 0>a?"-"+b:b}
-function gi(a,b,c){if(0===b.W&&0===b.Z)switch(c){case 0:return"0";case 1:return"0.0";case 2:return"0.00";case 3:return"0.000";case 4:return"0.0000";case 5:return"0.00000";case 6:return"0.000000";default:return(0>c?"0E+":"0E")+(-2147483648===c?"2147483648":""+(-c|0))}else{a=0>b.Z;var d="";var e=18;if(a){var g=b.W;b=b.Z;b=new fb(-g|0,0!==g?~b:-b|0)}g=b.W;for(var h=b.Z;;){b=g;var k=h;h=Cb();g=ki(h,g,k,10,0);h=h.Kc;e=-1+e|0;k=h;var l=g,m=l>>>16|0;l=Math.imul(10,65535&l);m=Math.imul(10,m);m=l+(m<<16)|
-0;Math.imul(10,k);d=""+(b-m|0)+d;b=h;if(0===g&&0===b)break}g=18-e|0;h=g>>31;k=c>>31;b=g-c|0;g=(-2147483648^b)>(-2147483648^g)?-1+(h-k|0)|0:h-k|0;b=-1+b|0;g=-1!==b?g:-1+g|0;if(0<c&&(-1===g?2147483642<=(-2147483648^b):-1<g))if(c=1+b|0,0<c)d=d.substring(0,c)+"."+d.substring(c);else{c=-c|0;for(e=0;e<c;)d="0"+d,e=1+e|0;d="0."+d}else 0!==c&&(c=(0===g?0!==b:0<g)?"E+"+new fb(b,g):"E"+new fb(b,g),d=1<(18-e|0)?d.substring(0,1)+"."+d.substring(1)+c:d+c);return a?"-"+d:d}}
-ci.prototype.$classData=q({nT:0},!1,"java.math.Conversion$",{nT:1,d:1});var di;function li(){di||(di=new ci);return di}function mi(){}mi.prototype=new p;mi.prototype.constructor=mi;
-function ni(a,b,c,d,e,g,h){a=new zd(1+e|0);var k=new zd(1+h|0),l=Math.clz32(g.a[-1+h|0]);0!==l?(Ph(bi(),k,g,0,l),Ph(bi(),a,d,0,l)):(d.va(0,a,0,e),g.va(0,k,0,h));d=k.a[-1+h|0];for(c=-1+c|0;0<=c;){if(a.a[e]===d)g=-1;else{var m=a.a[e],n=a.a[-1+e|0];g=Cb();var r=fi(g,n,m,d,0);m=g.Kc;g=r;var u=65535&r;r=r>>>16|0;var w=65535&d,y=d>>>16|0,B=Math.imul(u,w);w=Math.imul(r,w);u=Math.imul(u,y);u=B+((w+u|0)<<16)|0;Math.imul(m,d);Math.imul(r,y);n=n-u|0;if(0!==g)for(g=1+g|0;;){r=g=-1+g|0;y=k.a[-2+h|0];m=65535&r;
-r=r>>>16|0;B=65535&y;y=y>>>16|0;u=Math.imul(m,B);B=Math.imul(r,B);w=Math.imul(m,y);m=u+((B+w|0)<<16)|0;u=(u>>>16|0)+w|0;u=(Math.imul(r,y)+(u>>>16|0)|0)+(((65535&u)+B|0)>>>16|0)|0;y=n;r=a.a[-2+e|0];B=n+d|0;if(0===((-2147483648^B)<(-2147483648^n)?1:0)&&(n=B,u^=-2147483648,y^=-2147483648,u===y?(-2147483648^m)>(-2147483648^r):u>y))continue;break}}if(n=0!==g){oi();n=a;m=e-h|0;y=k;r=h;u=g;var D=0;var C;for(B=C=0;B<r;){w=B;pi();var F=y.a[w],I=65535&F;F=F>>>16|0;var K=65535&u,N=u>>>16|0,P=Math.imul(I,K);
-K=Math.imul(F,K);var T=Math.imul(I,N);I=P+((K+T|0)<<16)|0;P=(P>>>16|0)+T|0;N=(Math.imul(F,N)+(P>>>16|0)|0)+(((65535&P)+K|0)>>>16|0)|0;F=I+D|0;D=(-2147483648^F)<(-2147483648^I)?1+N|0:N;N=n.a[m+w|0];F=N-F|0;N=(-2147483648^F)>(-2147483648^N)?-1:0;I=C;C=I>>31;I=F+I|0;C=(-2147483648^I)<(-2147483648^F)?1+(N+C|0)|0:N+C|0;n.a[m+w|0]=I;B=1+B|0}u=n.a[m+r|0];y=u-D|0;u=(-2147483648^y)>(-2147483648^u)?-1:0;w=C;B=w>>31;w=y+w|0;n.a[m+r|0]=w;n=0!==((-2147483648^w)<(-2147483648^y)?1+(u+B|0)|0:u+B|0)}if(n)for(g=-1+
-g|0,n=B=u=0;n<h;)m=n,y=a.a[(e-h|0)+m|0],r=y+k.a[m]|0,y=(-2147483648^r)<(-2147483648^y)?1:0,r=u+r|0,y=(-2147483648^r)<(-2147483648^u)?1+(B+y|0)|0:B+y|0,u=r,B=y,a.a[(e-h|0)+m|0]=u,u=B,B=0,n=1+n|0;null!==b&&(b.a[c]=g);e=-1+e|0;c=-1+c|0}if(0!==l)return $h(bi(),k,h,a,0,l),k;a.va(0,k,0,h);return a}
-function qi(a,b,c,d,e){a=0;for(d=-1+d|0;0<=d;){var g=a;a=c.a[d];var h=Cb();g=fi(h,a,g,e,0);h=h.Kc;var k=65535&g,l=g>>>16|0,m=65535&e,n=e>>>16|0,r=Math.imul(k,m);m=Math.imul(l,m);k=Math.imul(k,n);r=r+((m+k|0)<<16)|0;Math.imul(h,e);Math.imul(l,n);a=a-r|0;b.a[d]=g;d=-1+d|0}return a}mi.prototype.$classData=q({oT:0},!1,"java.math.Division$",{oT:1,d:1});var ri;function oi(){ri||(ri=new mi);return ri}
-function si(a,b,c,d){var e=new zd(1+b|0),g=1,h=a.a[0],k=h+c.a[0]|0;e.a[0]=k;h=(-2147483648^k)<(-2147483648^h)?1:0;if(b>=d){for(;g<d;){var l=a.a[g];k=l+c.a[g]|0;l=(-2147483648^k)<(-2147483648^l)?1:0;h=k+h|0;k=(-2147483648^h)<(-2147483648^k)?1+l|0:l;e.a[g]=h;h=k;g=1+g|0}for(;g<b;)c=a.a[g],d=c+h|0,c=(-2147483648^d)<(-2147483648^c)?1:0,e.a[g]=d,h=c,g=1+g|0}else{for(;g<b;)l=a.a[g],k=l+c.a[g]|0,l=(-2147483648^k)<(-2147483648^l)?1:0,h=k+h|0,k=(-2147483648^h)<(-2147483648^k)?1+l|0:l,e.a[g]=h,h=k,g=1+g|0;
-for(;g<d;)a=c.a[g],b=a+h|0,a=(-2147483648^b)<(-2147483648^a)?1:0,e.a[g]=b,h=a,g=1+g|0}0!==h&&(e.a[g]=h);return e}function ti(a,b,c,d){for(var e=new zd(b),g=0,h=0;g<d;){var k=a.a[g],l=k-c.a[g]|0;k=(-2147483648^l)>(-2147483648^k)?-1:0;var m=h;h=m>>31;m=l+m|0;l=(-2147483648^m)<(-2147483648^l)?1+(k+h|0)|0:k+h|0;e.a[g]=m;h=l;g=1+g|0}for(;g<b;)c=a.a[g],l=h,d=l>>31,l=c+l|0,c=(-2147483648^l)<(-2147483648^c)?1+d|0:d,e.a[g]=l,h=c,g=1+g|0;return e}function ui(){}ui.prototype=new p;ui.prototype.constructor=ui;
-function xi(a,b,c){a=b.Ya;var d=c.Ya,e=b.ub,g=c.ub;if(0===a)return c;if(0===d)return b;if(2===(e+g|0)){b=b.Pa.a[0];c=c.Pa.a[0];if(a===d)return d=b+c|0,c=(-2147483648^d)<(-2147483648^b)?1:0,0===c?yi(a,d):Qh(a,2,new zd(new Int32Array([d,c])));d=Zh();0>a?(a=b=c-b|0,c=(-2147483648^b)>(-2147483648^c)?-1:0):(a=c=b-c|0,c=(-2147483648^c)>(-2147483648^b)?-1:0);return zi(d,new fb(a,c))}if(a===d)d=e>=g?si(b.Pa,e,c.Pa,g):si(c.Pa,g,b.Pa,e);else{var h=e!==g?e>g?1:-1:Ai(0,b.Pa,c.Pa,e);if(0===h)return Zh().Dp;1===
-h?d=ti(b.Pa,e,c.Pa,g):(c=ti(c.Pa,g,b.Pa,e),a=d,d=c)}a=Qh(a|0,d.a.length,d);Wh(a);return a}function Ai(a,b,c,d){for(a=-1+d|0;0<=a&&b.a[a]===c.a[a];)a=-1+a|0;return 0>a?0:(-2147483648^b.a[a])<(-2147483648^c.a[a])?-1:1}
-function Bi(a,b,c){var d=b.Ya;a=c.Ya;var e=b.ub,g=c.ub;if(0===a)return b;if(0===d)return Ci(c);if(2===(e+g|0))return b=b.Pa.a[0],e=0,c=c.Pa.a[0],g=0,0>d&&(d=b,b=-d|0,e=0!==d?~e:-e|0),0>a&&(a=c,d=g,c=-a|0,g=0!==a?~d:-d|0),a=Zh(),d=b,b=e,e=g,c=d-c|0,zi(a,new fb(c,(-2147483648^c)>(-2147483648^d)?-1+(b-e|0)|0:b-e|0));var h=e!==g?e>g?1:-1:Ai(Di(),b.Pa,c.Pa,e);if(d===a&&0===h)return Zh().Dp;-1===h?(c=d===a?ti(c.Pa,g,b.Pa,e):si(c.Pa,g,b.Pa,e),a=-a|0):d===a?(c=ti(b.Pa,e,c.Pa,g),a=d):(c=si(b.Pa,e,c.Pa,g),
-a=d);a=Qh(a|0,c.a.length,c);Wh(a);return a}ui.prototype.$classData=q({pT:0},!1,"java.math.Elementary$",{pT:1,d:1});var Ei;function Di(){Ei||(Ei=new ui);return Ei}function Fi(a,b){this.ur=a;this.cw=b}Fi.prototype=new p;Fi.prototype.constructor=Fi;Fi.prototype.h=function(a){return a instanceof Fi?this.ur===a.ur?this.cw===a.cw:!1:!1};Fi.prototype.y=function(){return this.ur<<3|this.cw.pF};Fi.prototype.u=function(){return"precision\x3d"+this.ur+" roundingMode\x3d"+this.cw};
-Fi.prototype.$classData=q({qT:0},!1,"java.math.MathContext",{qT:1,d:1});function Gi(){this.ZL=null;Hi=this;Ii();var a=Pi().qC;this.ZL=new Fi(34,a);Ii();Pi();Ii();Pi();Ii();Pi()}Gi.prototype=new p;Gi.prototype.constructor=Gi;Gi.prototype.$classData=q({rT:0},!1,"java.math.MathContext$",{rT:1,d:1});var Hi;function Ii(){Hi||(Hi=new Gi);return Hi}
-function Qi(a,b,c,d){for(var e,g=e=0;g<c;){var h=g;pi();var k=b.a[h],l=65535&k;k=k>>>16|0;var m=65535&d,n=d>>>16|0,r=Math.imul(l,m);m=Math.imul(k,m);var u=Math.imul(l,n);l=r+((m+u|0)<<16)|0;r=(r>>>16|0)+u|0;k=(Math.imul(k,n)+(r>>>16|0)|0)+(((65535&r)+m|0)>>>16|0)|0;e=l+e|0;k=(-2147483648^e)<(-2147483648^l)?1+k|0:k;a.a[h]=e;e=k;g=1+g|0}return e}function Ri(a,b){for(var c=new zd(a),d=c.a[0]=1;d<a;){var e=d;c.a[e]=Math.imul(c.a[-1+e|0],b);d=1+d|0}}
-function Si(){this.vr=this.wr=null;Ti=this;Ri(10,10);Ri(14,5);this.wr=new (Nd(Ui).Ja)(32);this.vr=new (Nd(Ui).Ja)(32);var a;var b=1;for(var c=a=0;32>c;){var d=c;if(18>=d){pi().vr.a[d]=zi(Zh(),new fb(b,a));var e=pi().wr,g=Zh(),h=a,k=b;e.a[d]=zi(g,new fb(0===(32&d)?k<<d:0,0===(32&d)?(k>>>1|0)>>>(31-d|0)|0|h<<d:k<<d));d=b;b=d>>>16|0;d=Math.imul(5,65535&d);e=Math.imul(5,b);b=d+(e<<16)|0;d=(d>>>16|0)+e|0;a=Math.imul(5,a)+(d>>>16|0)|0}else pi().vr.a[d]=Vi(pi().vr.a[-1+d|0],pi().vr.a[1]),pi().wr.a[d]=Vi(pi().wr.a[-1+
-d|0],Zh().Cp);c=1+c|0}}Si.prototype=new p;Si.prototype.constructor=Si;
-function Wi(a,b,c){for(var d,e=0;e<b;){var g=e;d=0;for(var h=1+g|0;h<b;){pi();var k=a.a[g],l=a.a[h],m=c.a[g+h|0],n=d,r=65535&k;d=k>>>16|0;var u=65535&l;l=l>>>16|0;k=Math.imul(r,u);u=Math.imul(d,u);var w=Math.imul(r,l);r=k+((u+w|0)<<16)|0;k=(k>>>16|0)+w|0;d=(Math.imul(d,l)+(k>>>16|0)|0)+(((65535&k)+u|0)>>>16|0)|0;m=r+m|0;d=(-2147483648^m)<(-2147483648^r)?1+d|0:d;n=m+n|0;m=(-2147483648^n)<(-2147483648^m)?1+d|0:d;c.a[g+h|0]=n;d=m;h=1+h|0}c.a[g+b|0]=d;e=1+e|0}Xh(bi(),c,c,b<<1);for(g=e=d=0;e<b;)m=a.a[e],
-r=a.a[e],n=c.a[g],h=d,l=65535&m,m=m>>>16|0,k=65535&r,d=r>>>16|0,r=Math.imul(l,k),k=Math.imul(m,k),u=Math.imul(l,d),l=r+((k+u|0)<<16)|0,r=(r>>>16|0)+u|0,m=(Math.imul(m,d)+(r>>>16|0)|0)+(((65535&r)+k|0)>>>16|0)|0,n=l+n|0,m=(-2147483648^n)<(-2147483648^l)?1+m|0:m,h=n+h|0,n=(-2147483648^h)<(-2147483648^n)?1+m|0:m,c.a[g]=h,g=1+g|0,h=n+c.a[g]|0,n=(-2147483648^h)<(-2147483648^n)?1:0,c.a[g]=h,d=n,e=1+e|0,g=1+g|0;return c}
-function Xi(a,b,c){if(c.ub>b.ub)var d=c;else d=b,b=c;var e=d,g=b;if(63>g.ub){d=e.ub;b=g.ub;c=d+b|0;a=e.Ya!==g.Ya?-1:1;if(2===c){d=e.Pa.a[0];b=g.Pa.a[0];c=65535&d;d=d>>>16|0;g=65535&b;b=b>>>16|0;e=Math.imul(c,g);g=Math.imul(d,g);var h=Math.imul(c,b);c=e+((g+h|0)<<16)|0;e=(e>>>16|0)+h|0;d=(Math.imul(d,b)+(e>>>16|0)|0)+(((65535&e)+g|0)>>>16|0)|0;a=0===d?yi(a,c):Qh(a,2,new zd(new Int32Array([c,d])))}else{e=e.Pa;g=g.Pa;h=new zd(c);if(0!==d&&0!==b)if(1===d)h.a[b]=Qi(h,g,b,e.a[0]);else if(1===b)h.a[d]=Qi(h,
-e,d,g.a[0]);else if(e===g&&d===b)Wi(e,d,h);else for(var k=0;k<d;){for(var l=k,m=0,n=e.a[l],r=0;r<b;){pi();var u=g.a[r],w=h.a[l+r|0],y=65535&n,B=n>>>16|0,D=65535&u;u=u>>>16|0;var C=Math.imul(y,D);D=Math.imul(B,D);var F=Math.imul(y,u);y=C+((D+F|0)<<16)|0;C=(C>>>16|0)+F|0;B=(Math.imul(B,u)+(C>>>16|0)|0)+(((65535&C)+D|0)>>>16|0)|0;w=y+w|0;B=(-2147483648^w)<(-2147483648^y)?1+B|0:B;m=w+m|0;w=(-2147483648^m)<(-2147483648^w)?1+B|0:B;h.a[l+r|0]=m;m=w;r=1+r|0}h.a[l+b|0]=m;k=1+k|0}a=Qh(a,c,h);Wh(a)}return a}d=
-(-2&e.ub)<<4;c=Yi(e,d);h=Yi(g,d);b=Zi(c,d);k=Bi(Di(),e,b);b=Zi(h,d);g=Bi(Di(),g,b);e=Xi(a,c,h);b=Xi(a,k,g);a=Xi(a,Bi(Di(),c,k),Bi(Di(),g,h));c=e;a=xi(Di(),a,c);a=xi(Di(),a,b);a=Zi(a,d);d=e=Zi(e,d<<1);a=xi(Di(),d,a);return xi(Di(),a,b)}
-function $i(a,b){var c=a.wr.a.length,d=c>>31,e=b.Z;if(e===d?(-2147483648^b.W)<(-2147483648^c):e<d)return a.wr.a[b.W];c=b.Z;if(0===c?-2147483598>=(-2147483648^b.W):0>c)return aj(Zh().Cp,b.W);c=b.Z;if(0===c?-1>=(-2147483648^b.W):0>c)return Zi(aj(a.vr.a[1],b.W),b.W);var g=aj(a.vr.a[1],2147483647);c=g;e=b.Z;var h=-2147483647+b.W|0;d=h;h=1>(-2147483648^h)?e:-1+e|0;for(e=bj(Cb(),b.W,b.Z,2147483647,0);;){var k=d,l=h;if(0===l?-1<(-2147483648^k):0<l)c=Vi(c,g),d=-2147483647+d|0,h=1>(-2147483648^d)?h:-1+h|0;
-else break}c=Vi(c,aj(a.vr.a[1],e));c=Zi(c,2147483647);a=b.Z;d=b=-2147483647+b.W|0;for(h=1>(-2147483648^b)?a:-1+a|0;;)if(b=d,a=h,0===a?-1<(-2147483648^b):0<a)c=Zi(c,2147483647),b=h,a=-2147483647+d|0,b=1>(-2147483648^a)?b:-1+b|0,d=a,h=b;else break;return Zi(c,e)}Si.prototype.$classData=q({sT:0},!1,"java.math.Multiplication$",{sT:1,d:1});var Ti;function pi(){Ti||(Ti=new Si);return Ti}function ij(){}ij.prototype=new p;ij.prototype.constructor=ij;
-function jj(a,b){var c=kj(),d=kj(),e=b.a.length;16<e?lj(a,b,new zd(b.a.length),0,e,c,d):oj(b,0,e,c,d)}function pj(a,b){var c=qj(),d=qj(),e=b.a.length;16<e?lj(a,b,new Ad(b.a.length),0,e,c,d):oj(b,0,e,c,d)}function rj(a,b){var c=sj(),d=sj(),e=b.a.length;16<e?lj(a,b,new wd(b.a.length),0,e,c,d):oj(b,0,e,c,d)}function tj(a,b){var c=uj(),d=uj(),e=b.a.length;16<e?lj(a,b,new td(b.a.length),0,e,c,d):oj(b,0,e,c,d)}
-function vj(a,b){var c=wj(),d=wj(),e=b.a.length;16<e?lj(a,b,new vd(b.a.length),0,e,c,d):oj(b,0,e,c,d)}function xj(a,b,c){c=null===c?yj():c;var d=zj(),e=b.a.length;if(16<e){var g=b.a.length,h=ja(b);lj(a,b,Fh(Jh(),Gg(h),g),0,e,c,d)}else oj(b,0,e,c,d)}
-function lj(a,b,c,d,e,g,h){var k=e-d|0;if(16<k){var l=d+(k/2|0)|0;lj(a,b,c,d,l,g,h);lj(a,b,c,l,e,g,h);for(var m=a=d,n=l;a<e;)m<l&&(n>=e||0>=g.Fa(h.Lj(b,m),h.Lj(b,n)))?(h.jo(c,a,h.Lj(b,m)),m=1+m|0):(h.jo(c,a,h.Lj(b,n)),n=1+n|0),a=1+a|0;c.va(d,b,d,k)}else oj(b,d,e,g,h)}
-function oj(a,b,c,d,e){c=c-b|0;if(2<=c){var g=e.Lj(a,b),h=e.Lj(a,1+b|0);0<d.Fa(g,h)&&(e.jo(a,b,h),e.jo(a,1+b|0,g));for(g=2;g<c;){h=e.Lj(a,b+g|0);if(0>d.Fa(h,e.Lj(a,-1+(b+g|0)|0))){for(var k=b,l=-1+(b+g|0)|0;1<(l-k|0);){var m=(k+l|0)>>>1|0;0>d.Fa(h,e.Lj(a,m))?l=m:k=m}k=k+(0>d.Fa(h,e.Lj(a,k))?0:1)|0;for(l=b+g|0;l>k;)e.jo(a,l,e.Lj(a,-1+l|0)),l=-1+l|0;e.jo(a,k,h)}g=1+g|0}}}
-function Aj(a,b,c){a=0;for(var d=b.a.length;;){if(a===d)return-1-a|0;var e=(a+d|0)>>>1|0,g=b.a[e];g=c===g?0:c<g?-1:1;if(0>g)d=e;else{if(0===g)return e;a=1+e|0}}}function Bj(a,b,c){if(b===c)return!0;if(null===b||null===c)return!1;a=b.a.length;if(c.a.length!==a)return!1;for(var d=0;d!==a;){var e=b.a[d],g=c.a[d],h=g.Z;if(e.W!==g.W||e.Z!==h)return!1;d=1+d|0}return!0}
-function Jj(a,b,c){if(b===c)return!0;if(null===b||null===c)return!1;a=b.a.length;if(c.a.length!==a)return!1;for(var d=0;d!==a;){if(b.a[d]!==c.a[d])return!1;d=1+d|0}return!0}function Kj(a,b,c){if(b===c)return!0;if(null===b||null===c)return!1;a=b.a.length;if(c.a.length!==a)return!1;for(var d=0;d!==a;){if(b.a[d]!==c.a[d])return!1;d=1+d|0}return!0}
-function Lj(a,b,c){if(b===c)return!0;if(null===b||null===c)return!1;a=b.a.length;if(c.a.length!==a)return!1;for(var d=0;d!==a;){if(b.a[d]!==c.a[d])return!1;d=1+d|0}return!0}function Mj(a,b,c){if(b===c)return!0;if(null===b||null===c)return!1;a=b.a.length;if(c.a.length!==a)return!1;for(var d=0;d!==a;){if(b.a[d]!==c.a[d])return!1;d=1+d|0}return!0}
-function Nj(a,b,c){if(b===c)return!0;if(null===b||null===c)return!1;a=b.a.length;if(c.a.length!==a)return!1;for(var d=0;d!==a;){if(b.a[d]!==c.a[d])return!1;d=1+d|0}return!0}function Oj(a,b,c){if(b===c)return!0;if(null===b||null===c)return!1;a=b.a.length;if(c.a.length!==a)return!1;for(var d=0;d!==a;){if(!Object.is(b.a[d],c.a[d]))return!1;d=1+d|0}return!0}
-function Pj(a,b,c){if(b===c)return!0;if(null===b||null===c)return!1;a=b.a.length;if(c.a.length!==a)return!1;for(var d=0;d!==a;){if(!Object.is(b.a[d],c.a[d]))return!1;d=1+d|0}return!0}function Sj(a,b,c){a=b.a.length;for(var d=0;d!==a;)b.a[d]=c,d=1+d|0}function Tj(a,b,c){if(0>c)throw new Uj;a=b.a.length;a=c<a?c:a;var d=ja(b);c=Fh(Jh(),Gg(d),c);b.va(0,c,0,a);return c}function Vj(a,b,c,d){if(0>c)throw new Uj;a=b.a.length;a=c<a?c:a;c=Fh(Jh(),Gg(d),c);b.va(0,c,0,a);return c}
-function Wj(a,b,c){if(0>c)throw new Uj;a=b.a.length;a=c<a?c:a;c=new vd(c);b.va(0,c,0,a);return c}function Xj(a,b,c){if(0>c)throw new Uj;a=b.a.length;a=c<a?c:a;c=new wd(c);b.va(0,c,0,a);return c}function Yj(a,b,c){if(0>c)throw new Uj;a=b.a.length;a=c<a?c:a;c=new zd(c);b.va(0,c,0,a);return c}function Zj(a,b,c){if(0>c)throw new Uj;a=b.a.length;a=c<a?c:a;c=new Ad(c);b.va(0,c,0,a);return c}function ak(a,b,c){if(0>c)throw new Uj;a=b.a.length;a=c<a?c:a;c=new td(c);b.va(0,c,0,a);return c}
-function bk(a,b,c){if(0>c)throw new Uj;a=b.a.length;a=c<a?c:a;c=new pd(c);b.va(0,c,0,a);return c}function ck(a,b,c,d){if(c>d)throw dk(c+" \x3e "+d);a=d-c|0;d=b.a.length-c|0;d=a<d?a:d;var e=ja(b);a=Fh(Jh(),Gg(e),a);b.va(c,a,0,d);return a}ij.prototype.$classData=q({a1:0},!1,"java.util.Arrays$",{a1:1,d:1});var ek;function fk(){ek||(ek=new ij);return ek}
-function gk(){this.wQ=this.xQ=null;hk=this;this.xQ=RegExp("(?:(\\d+)\\$)?([-#+ 0,\\(\x3c]*)(\\d+)?(?:\\.(\\d+))?[%A-Za-z]","g");this.wQ=new zd(new Int32Array([96,126,638,770,32,256,2,126,-1,-1,-1,-1,-1,-1,800,-1,-1,-1,124,-1,-1,-1,-1,544,-1,-1]))}gk.prototype=new p;gk.prototype.constructor=gk;function ik(a,b){if(20>=b)return"00000000000000000000".substring(0,b);for(a="";20<b;)a+="00000000000000000000",b=-20+b|0;return""+a+"00000000000000000000".substring(0,b)}
-gk.prototype.$classData=q({j1:0},!1,"java.util.Formatter$",{j1:1,d:1});var hk;function mk(){hk||(hk=new gk);return hk}function nk(a,b){var c=a.Mq,d=c.length;if(0>b)return new pk(a.Ys,"0",0);if(b>=d)return a;if(53>c.charCodeAt(b))return 0===b?new pk(a.Ys,"0",0):new pk(a.Ys,c.substring(0,b),a.Lq-(d-b|0)|0);for(b=-1+b|0;;)if(0<=b&&57===c.charCodeAt(b))b=-1+b|0;else break;c=0>b?"1":""+c.substring(0,b)+hd(65535&(1+c.charCodeAt(b)|0));return new pk(a.Ys,c,a.Lq-(d-(1+b|0)|0)|0)}
-function pk(a,b,c){this.Ys=a;this.Mq=b;this.Lq=c}pk.prototype=new p;pk.prototype.constructor=pk;function qk(a,b){mk();if(!(0<b))throw new rk("Decimal.round() called with non-positive precision");return nk(a,b)}pk.prototype.u=function(){return"Decimal("+this.Ys+", "+this.Mq+", "+this.Lq+")"};pk.prototype.$classData=q({k1:0},!1,"java.util.Formatter$Decimal",{k1:1,d:1});function sk(){}sk.prototype=new p;sk.prototype.constructor=sk;function tk(){}tk.prototype=sk.prototype;function uk(a){this.Sx=a}
-uk.prototype=new p;uk.prototype.constructor=uk;uk.prototype.h=function(a){return a instanceof uk?Object.is(this.Sx,a.Sx):!1};uk.prototype.y=function(){return bd(this.Sx)};uk.prototype.$classData=q({v1:0},!1,"java.util.IdentityHashMap$IdentityBox",{v1:1,d:1});function vk(a){return!!(a&&a.$classData&&a.$classData.pb.AQ)}function wk(a,b){throw new yk(b,a.fi,a.P);}function zk(a,b){for(var c="",d=b.length,e=0;e!==d;){var g=Ak(b,e);c=""+c+Ck(a,g);e=e+(65536<=g?2:1)|0}return c}
-function Ck(a,b){var c=Dk(Ek(),b);if(128>b)switch(b){case 94:case 36:case 92:case 46:case 42:case 43:case 63:case 40:case 41:case 91:case 93:case 123:case 125:case 124:return"\\"+c;default:return 2!==(66&a.ze)?c:65<=b&&90>=b?"["+c+Dk(Ek(),32+b|0)+"]":97<=b&&122>=b?"["+Dk(Ek(),-32+b|0)+c+"]":c}else return 56320===(-1024&b)?"(?:"+c+")":c}
-function Fk(a){for(var b=a.fi,c=b.length;;){if(a.P!==c)switch(b.charCodeAt(a.P)){case 32:case 9:case 10:case 11:case 12:case 13:a.P=1+a.P|0;continue;case 35:Gk(a);continue}break}}
-function Hk(a,b,c){var d=a.fi,e=d.length,g=a.P,h=g===e?46:d.charCodeAt(g);if(63===h||42===h||43===h||123===h){g=a.fi;var k=a.P;a.P=1+a.P|0;if(123===h){h=g.length;if(a.P===h)var l=!0;else l=g.charCodeAt(a.P),l=!(48<=l&&57>=l);for(l&&wk(a,"Illegal repetition");;)if(a.P!==h?(l=g.charCodeAt(a.P),l=48<=l&&57>=l):l=!1,l)a.P=1+a.P|0;else break;a.P===h&&wk(a,"Illegal repetition");if(44===g.charCodeAt(a.P))for(a.P=1+a.P|0;;)if(a.P!==h?(l=g.charCodeAt(a.P),l=48<=l&&57>=l):l=!1,l)a.P=1+a.P|0;else break;a.P!==
-h&&125===g.charCodeAt(a.P)||wk(a,"Illegal repetition");a.P=1+a.P|0}g=g.substring(k,a.P);if(a.P!==e)switch(d.charCodeAt(a.P)){case 43:return a.P=1+a.P|0,Ik(a,b,c,g);case 63:return a.P=1+a.P|0,""+c+g+"?";default:return""+c+g}else return""+c+g}else return c}
-function Ik(a,b,c,d){for(var e=a.Nm.length|0,g=0;g<e;){var h=g,k=a.Nm[h]|0;k>b&&(a.Nm[h]=1+k|0);g=1+g|0}c=c.replace(Ek().LQ,(l,m,n)=>{0!==(m.length%2|0)&&(n=parseInt(n,10)|0,l=n>b?""+m+(1+n|0):l);return l});a.Mm=1+a.Mm|0;return"(?:(?\x3d("+c+d+"))\\"+(1+b|0)+")"}
-function Jk(a){var b=a.fi,c=b.length;(1+a.P|0)===c&&wk(a,"\\ at end of pattern");a.P=1+a.P|0;var d=b.charCodeAt(a.P);switch(d){case 100:case 68:case 104:case 72:case 115:case 83:case 118:case 86:case 119:case 87:case 112:case 80:switch(a=Kk(a,d),b=a.WJ,b){case 0:return"\\p{"+a.Oq+"}";case 1:return"\\P{"+a.Oq+"}";case 2:return"["+a.Oq+"]";case 3:return Lk(Ek(),a.Oq);default:throw new rk(b);}case 98:if("b{g}"===b.substring(a.P,4+a.P|0))wk(a,"\\b{g} is not supported");else if(0!==(320&a.ze))Nk(a,"\\b with UNICODE_CASE");
-else return a.P=1+a.P|0,"\\b";break;case 66:if(0!==(320&a.ze))Nk(a,"\\B with UNICODE_CASE");else return a.P=1+a.P|0,"\\B";break;case 65:return a.P=1+a.P|0,"(?:^)";case 71:wk(a,"\\G in the middle of a pattern is not supported");break;case 90:return a.P=1+a.P|0,"(?\x3d"+(0!==(1&a.ze)?"\n":"(?:\r\n?|[\n\u0085\u2028\u2029])")+"?$)";case 122:return a.P=1+a.P|0,"(?:$)";case 82:return a.P=1+a.P|0,"(?:\r\n|[\n-\r\u0085\u2028\u2029])";case 88:wk(a,"\\X is not supported");break;case 49:case 50:case 51:case 52:case 53:case 54:case 55:case 56:case 57:var e=
-a.P;for(d=1+e|0;;){if(d!==c){var g=b.charCodeAt(d);g=48<=g&&57>=g}else g=!1;g?(g=b.substring(e,1+d|0),g=(parseInt(g,10)|0)<=(-1+(a.Nm.length|0)|0)):g=!1;if(g)d=1+d|0;else break}b=b.substring(e,d);b=parseInt(b,10)|0;b>(-1+(a.Nm.length|0)|0)&&wk(a,"numbered capturing group \x3c"+b+"\x3e does not exist");b=a.Nm[b]|0;a.P=d;return"(?:\\"+b+")";case 107:return a.P=1+a.P|0,a.P!==c&&60===b.charCodeAt(a.P)||wk(a,"\\k is not followed by '\x3c' for named capturing group"),a.P=1+a.P|0,b=Ok(a),d=a.CF,ch().Qx.call(d,
-b)||wk(a,"named capturing group \x3c"+b+"\x3e does not exit"),b=a.Nm[d[b]|0]|0,a.P=1+a.P|0,"(?:\\"+b+")";case 81:d=1+a.P|0;c=b.indexOf("\\E",d)|0;if(0>c)return a.P=b.length,zk(a,b.substring(d));a.P=2+c|0;return zk(a,b.substring(d,c));default:return Ck(a,Pk(a))}}
-function Pk(a){var b=a.fi,c=Ak(b,a.P);switch(c){case 48:return Qk(a);case 120:return b=a.fi,c=1+a.P|0,c!==b.length&&123===b.charCodeAt(c)?(c=1+c|0,b=b.indexOf("}",c)|0,0>b&&wk(a,"Unclosed hexadecimal escape sequence"),c=Rk(a,c,b,"hexadecimal"),a.P=1+b|0,a=c):(b=Rk(a,c,2+c|0,"hexadecimal"),a.P=2+c|0,a=b),a;case 117:a:{b=a.fi;var d=1+a.P|0;c=4+d|0;d=Rk(a,d,c,"Unicode");a.P=c;var e=2+c|0,g=4+e|0;if(55296===(-1024&d)&&"\\u"===b.substring(c,e)&&(b=Rk(a,e,g,"Unicode"),56320===(-1024&b))){a.P=g;a=(64+(1023&
-d)|0)<<10|1023&b;break a}a=d}return a;case 78:wk(a,"\\N is not supported");break;case 97:return a.P=1+a.P|0,7;case 116:return a.P=1+a.P|0,9;case 110:return a.P=1+a.P|0,10;case 102:return a.P=1+a.P|0,12;case 114:return a.P=1+a.P|0,13;case 101:return a.P=1+a.P|0,27;case 99:return a.P=1+a.P|0,a.P===b.length&&wk(a,"Illegal control escape sequence"),b=Ak(b,a.P),a.P=a.P+(65536<=b?2:1)|0,64^b;default:return(65<=c&&90>=c||97<=c&&122>=c)&&wk(a,"Illegal/unsupported escape sequence"),a.P=a.P+(65536<=c?2:1)|
-0,c}}function Qk(a){var b=a.fi,c=b.length,d=a.P,e=(1+d|0)<c?-48+b.charCodeAt(1+d|0)|0:-1;(0>e||7<e)&&wk(a,"Illegal octal escape sequence");var g=(2+d|0)<c?-48+b.charCodeAt(2+d|0)|0:-1;if(0>g||7<g)return a.P=2+a.P|0,e;if(3<e)return a.P=3+a.P|0,(e<<3)+g|0;b=(3+d|0)<c?-48+b.charCodeAt(3+d|0)|0:-1;if(0>b||7<b)return a.P=3+a.P|0,(e<<3)+g|0;a.P=4+a.P|0;return((e<<6)+(g<<3)|0)+b|0}
-function Rk(a,b,c,d){var e=a.fi,g=e.length;(b===c||c>g)&&wk(a,"Illegal "+d+" escape sequence");for(g=b;g<c;){var h=e.charCodeAt(g);48<=h&&57>=h||65<=h&&70>=h||97<=h&&102>=h||wk(a,"Illegal "+d+" escape sequence");g=1+g|0}6<(c-b|0)?b=1114112:(b=e.substring(b,c),b=parseInt(b,16)|0);1114111<b&&wk(a,"Hexadecimal codepoint is too big");return b}
-function Kk(a,b){a.P=1+a.P|0;switch(b){case 100:case 68:a=Ek().FQ;break;case 104:case 72:a=Ek().IQ;break;case 115:case 83:a=Ek().GQ;break;case 118:case 86:a=Ek().JQ;break;case 119:case 87:a=Ek().HQ;break;case 112:case 80:var c=a.fi,d=a.P;if(d===c.length)c="?";else if(123===c.charCodeAt(d)){d=1+d|0;var e=c.indexOf("}",d)|0;0>e&&wk(a,"Unclosed character family");a.P=e;c=c.substring(d,e)}else c=c.substring(d,1+d|0);d=Ek().ZJ;ch().Qx.call(d,c)||Nk(a,"Unicode character family");c=2!==(66&a.ze)||"Lower"!==
-c&&"Upper"!==c?c:"Alpha";c=Ek().ZJ[c];a.P=1+a.P|0;a=c;break;default:throw new rk(hd(b));}97<=b?b=a:a.VJ?b=a.XJ:(b=a,b.VJ||(b.XJ=new Sk(1^b.WJ,b.Oq),b.VJ=!0),b=b.XJ);return b}
-var Yk=function Tk(a){var c=a.fi,d=c.length;a.P=1+a.P|0;var e=a.P!==d?94===c.charCodeAt(a.P):!1;e&&(a.P=1+a.P|0);for(e=new Uk(2===(66&a.ze),e);a.P!==d;){var g=Ak(c,a.P);a:{switch(g){case 93:return a.P=1+a.P|0,a=e,c=Vk(a),""===a.BF?c:"(?:"+a.BF+c+")";case 38:a.P=1+a.P|0;if(a.P!==d&&38===c.charCodeAt(a.P)){a.P=1+a.P|0;g=e;var h=Vk(g);g.BF+=g.EQ?h+"|":"(?\x3d"+h+")";g.Pl="";g.gg=""}else Wk(a,38,d,c,e);break a;case 91:g=Tk(a);e.Pl=""===e.Pl?g:e.Pl+"|"+g;break a;case 92:a.P=1+a.P|0;a.P===d&&wk(a,"Illegal escape sequence");
-h=c.charCodeAt(a.P);switch(h){case 100:case 68:case 104:case 72:case 115:case 83:case 118:case 86:case 119:case 87:case 112:case 80:g=e;h=Kk(a,h);var k=h.WJ;switch(k){case 0:g.gg=g.gg+("\\p{"+h.Oq)+"}";break;case 1:g.gg=g.gg+("\\P{"+h.Oq)+"}";break;case 2:g.gg=""+g.gg+h.Oq;break;case 3:h=Lk(Ek(),h.Oq);g.Pl=""===g.Pl?h:g.Pl+"|"+h;break;default:throw new rk(k);}break;case 81:a.P=1+a.P|0;g=c.indexOf("\\E",a.P)|0;0>g&&wk(a,"Unclosed character class");h=e;k=c;for(var l=g,m=a.P;m!==l;){var n=Ak(k,m);Xk(h,
-n);m=m+(65536<=n?2:1)|0}a.P=2+g|0;break;default:Wk(a,Pk(a),d,c,e)}break a;case 32:case 9:case 10:case 11:case 12:case 13:if(0!==(4&a.ze))a.P=1+a.P|0;else break;break a;case 35:if(0!==(4&a.ze)){Gk(a);break a}}a.P=a.P+(65536<=g?2:1)|0;Wk(a,g,d,c,e)}}wk(a,"Unclosed character class")};
-function Zk(a){var b=a.fi,c=b.length,d=a.P;if((1+d|0)===c||63!==b.charCodeAt(1+d|0))return a.P=1+d|0,a.Mm=1+a.Mm|0,a.Nm.push(a.Mm),"("+$k(a,!0)+")";(2+d|0)===c&&wk(a,"Unclosed group");var e=b.charCodeAt(2+d|0);if(58===e||61===e||33===e)return a.P=3+d|0,""+b.substring(d,3+d|0)+$k(a,!0)+")";if(60===e){(3+d|0)===c&&wk(a,"Unclosed group");b=b.charCodeAt(3+d|0);if(65<=b&&90>=b||97<=b&&122>=b)return a.P=3+d|0,d=Ok(a),b=a.CF,ch().Qx.call(b,d)&&wk(a,"named capturing group \x3c"+d+"\x3e is already defined"),
-a.Mm=1+a.Mm|0,a.Nm.push(a.Mm),a.CF[d]=-1+(a.Nm.length|0)|0,a.P=1+a.P|0,"("+$k(a,!0)+")";61!==b&&33!==b&&wk(a,"Unknown look-behind group");Nk(a,"Look-behind group")}else{if(62===e)return a.P=3+d|0,a.Mm=1+a.Mm|0,d=a.Mm,"(?:(?\x3d("+$k(a,!0)+"))\\"+d+")";wk(a,"Embedded flag expression in the middle of a pattern is not supported")}}
-function Ok(a){for(var b=a.fi,c=b.length,d=a.P;;){if(a.P!==c){var e=b.charCodeAt(a.P);e=65<=e&&90>=e||97<=e&&122>=e||48<=e&&57>=e}else e=!1;if(e)a.P=1+a.P|0;else break}a.P!==c&&62===b.charCodeAt(a.P)||wk(a,"named capturing group is missing trailing '\x3e'");return b.substring(d,a.P)}
-function Wk(a,b,c,d,e){0!==(4&a.ze)&&Fk(a);a.P!==c&&45===d.charCodeAt(a.P)?(a.P=1+a.P|0,0!==(4&a.ze)&&Fk(a),a.P===c&&wk(a,"Unclosed character class"),c=Ak(d,a.P),91===c||93===c?(Xk(e,b),Xk(e,45)):(a.P=a.P+(65536<=c?2:1)|0,c=92===c?Pk(a):c,c<b&&wk(a,"Illegal character range"),a=al(b)+"-"+al(c),e.gg=56320===(-1024&b)?a+e.gg:e.gg+a,e.DQ&&(a=65<b?b:65,d=90>c?c:90,a<=d&&(d=32+d|0,e.gg+=al(32+a|0)+"-"+al(d)),b=97<b?b:97,c=122>c?c:122,b<=c&&(c=-32+c|0,e.gg+=al(-32+b|0)+"-"+al(c))))):Xk(e,b)}
-function bl(a,b){this.fi=a;this.ze=b;this.$J=!1;this.Mm=this.P=0;this.Nm=[0];this.CF={}}bl.prototype=new p;bl.prototype.constructor=bl;function Nk(a,b){wk(a,b+" is not supported because it requires RegExp features of ECMAScript 2018.\nIf you only target environments with ES2018+, you can enable ES2018 features with\n  scalaJSLinkerConfig ~\x3d { _.withESFeatures(_.withESVersion(ESVersion.ES2018)) }\nor an equivalent configuration depending on your build tool.")}
-function $k(a,b){for(var c=a.fi,d=c.length,e="";a.P!==d;){var g=Ak(c,a.P);a:{switch(g){case 41:return b||wk(a,"Unmatched closing ')'"),a.P=1+a.P|0,e;case 124:a.$J&&!b&&wk(a,"\\G is not supported when there is an alternative at the top level");a.P=1+a.P|0;e+="|";break a;case 32:case 9:case 10:case 11:case 12:case 13:if(0!==(4&a.ze))a.P=1+a.P|0;else break;break a;case 35:if(0!==(4&a.ze))Gk(a);else break;break a;case 63:case 42:case 43:case 123:wk(a,"Dangling meta character '"+Dk(Ek(),g)+"'")}var h=
-a.Mm;switch(g){case 92:g=Jk(a);break;case 91:g=Yk(a);break;case 40:g=Zk(a);break;case 94:a.P=1+a.P|0;g="(?:^)";break;case 36:a.P=1+a.P|0;g="(?:$)";break;case 46:a.P=1+a.P|0;g=0!==(32&a.ze)?"":0!==(1&a.ze)?"\n":"\n\r\u0085\u2028\u2029";g=Lk(Ek(),g);break;default:a.P=a.P+(65536<=g?2:1)|0,g=Ck(a,g)}e=""+e+Hk(a,h,g)}}b&&wk(a,"Unclosed group");return e}
-function Gk(a){for(var b=a.fi,c=b.length;;){if(a.P!==c){var d=b.charCodeAt(a.P);d=!(10===d||13===d||133===d||8232===d||8233===d)}else d=!1;if(d)a.P=1+a.P|0;else break}}bl.prototype.$classData=q({a2:0},!1,"java.util.regex.PatternCompiler",{a2:1,d:1});function cl(a){try{return RegExp("",a),!0}catch(b){return!1}}
-function dl(){this.LQ=this.KQ=null;this.YJ=!1;this.ZJ=this.HQ=this.JQ=this.GQ=this.IQ=this.FQ=null;el=this;this.KQ=RegExp("^\\(\\?([idmsuxU]*)(?:-([idmsuxU]*))?\\)");this.LQ=RegExp("(\\\\+)(\\d+)","g");this.YJ=cl("us");cl("d");this.FQ=new Sk(2,"0-9");this.IQ=new Sk(2,"\t \u00a0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000");this.GQ=new Sk(2,"\t-\r ");this.JQ=new Sk(2,"\n-\r\u0085\u2028\u2029");this.HQ=new Sk(2,"a-zA-Z_0-9");var a={};a.Lower=new Sk(2,"a-z");a.Upper=new Sk(2,"A-Z");a.ASCII=new Sk(2,"\x00-\u007f");
-a.Alpha=new Sk(2,"A-Za-z");a.Digit=new Sk(2,"0-9");a.Alnum=new Sk(2,"0-9A-Za-z");a.Punct=new Sk(2,"!-/:-@[-`{-~");a.Graph=new Sk(2,"!-~");a.Print=new Sk(2," -~");a.Blank=new Sk(2,"\t ");a.Cntrl=new Sk(2,"\x00-\u001f\u007f");a.XDigit=new Sk(2,"0-9A-Fa-f");a.Space=new Sk(2,"\t-\r ");this.ZJ=a}dl.prototype=new p;dl.prototype.constructor=dl;
-function fl(a){Ek();a=new bl(a,0);0!==(256&a.ze)&&(a.ze|=64);var b=0!==(16&a.ze);if(!b){var c=Ek().KQ.exec(a.fi);if(null!==c){var d=c[1];if(void 0!==d)for(var e=d.length,g=0;g<e;){var h=g;a.ze|=il(Ek(),d.charCodeAt(h));g=1+g|0}0!==(256&a.ze)&&(a.ze|=64);d=c[2];if(void 0!==d)for(e=d.length,g=0;g<e;)h=g,a.ze&=~il(Ek(),d.charCodeAt(h)),g=1+g|0;a.P=a.P+c[0].length|0}}0!==(128&a.ze)&&wk(a,"CANON_EQ is not supported");0!==(8&a.ze)&&Nk(a,"MULTILINE");0!==(256&a.ze)&&Nk(a,"UNICODE_CHARACTER_CLASS");b?b=zk(a,
-a.fi):("\\G"===a.fi.substring(a.P,2+a.P|0)&&(a.$J=!0,a.P=2+a.P|0),b=$k(a,!1));c=Ek().YJ?"us":"u";return new jl(a.fi,a.ze,b,66===(66&a.ze)?c+"i":c,a.$J,-1+(a.Nm.length|0)|0,a.Nm,a.CF)}function il(a,b){switch(b){case 105:return 2;case 100:return 1;case 109:return 8;case 115:return 32;case 117:return 64;case 120:return 4;case 85:return 256;default:throw dk("bad in-pattern flag");}}function Lk(a,b){return""!==b?"[^"+b+"]":Ek().YJ?".":"[\\d\\D]"}function Dk(a,b){return String.fromCodePoint(b)}
-dl.prototype.$classData=q({b2:0},!1,"java.util.regex.PatternCompiler$",{b2:1,d:1});var el;function Ek(){el||(el=new dl);return el}function Vk(a){if(a.EQ){var b=Lk(Ek(),a.gg);return""===a.Pl?b:"(?:(?!"+a.Pl+")"+b+")"}return""===a.gg?""===a.Pl?"[^\\d\\D]":"(?:"+a.Pl+")":""===a.Pl?"["+a.gg+"]":"(?:"+a.Pl+"|["+a.gg+"])"}function al(a){var b=Dk(Ek(),a);return 93===a||92===a||45===a||94===a?"\\"+b:b}function Uk(a,b){this.DQ=a;this.EQ=b;this.gg=this.Pl=this.BF=""}Uk.prototype=new p;
-Uk.prototype.constructor=Uk;function Xk(a,b){var c=al(b);a.gg=56320===(-1024&b)?""+c+a.gg:""+a.gg+c;a.DQ&&(65<=b&&90>=b?a.gg=""+a.gg+Dk(Ek(),32+b|0):97<=b&&122>=b&&(a.gg=""+a.gg+Dk(Ek(),-32+b|0)))}Uk.prototype.$classData=q({c2:0},!1,"java.util.regex.PatternCompiler$CharacterClassBuilder",{c2:1,d:1});function Sk(a,b){this.XJ=null;this.VJ=!1;this.WJ=a;this.Oq=b}Sk.prototype=new p;Sk.prototype.constructor=Sk;
-Sk.prototype.$classData=q({d2:0},!1,"java.util.regex.PatternCompiler$CompiledCharClass",{d2:1,d:1});function kl(a){if(0===(1&a.aj)<<24>>24&&0===(1&a.aj)<<24>>24){if(ll()===a)var b=hd(40),c=hd(41);else if(ml()===a)b=hd(123),c=hd(125);else if(nl()===a)b=hd(91),c=hd(93);else if(ol()===a)b=hd(8249),c=hd(8250);else{if(pl()!==a)throw new x(a);b=hd(8594);c=hd(8592)}a.Lt=new ql(Eb(b),Eb(c));a.aj=(1|a.aj)<<24>>24}return a.Lt}function rl(){this.Lt=null;this.aj=this.Kt=this.Jt=0}rl.prototype=new p;
-rl.prototype.constructor=rl;function sl(){}sl.prototype=rl.prototype;function tl(a){0===(2&a.aj)<<24>>24&&0===(2&a.aj)<<24>>24&&(a.Jt=kl(a).dF(),a.aj=(2|a.aj)<<24>>24);return a.Jt}function ul(a){0===(4&a.aj)<<24>>24&&0===(4&a.aj)<<24>>24&&(a.Kt=kl(a).YI(),a.aj=(4|a.aj)<<24>>24);return a.Kt}
-rl.prototype.Sa=function(){if(ll()===this)return"parenthesis";if(ml()===this)return"curly brace";if(nl()===this)return"square bracket";if(ol()===this)return"angle bracket";if(pl()===this)return"indentation";throw new x(this);};function vl(){}vl.prototype=new p;vl.prototype.constructor=vl;function wl(a,b){return xl(new yl).Nb(hd(b),new z(()=>{t();return R()}))}vl.prototype.$classData=q({FT:0},!1,"mlscript.BracketKind$",{FT:1,d:1});var zl;function Al(){zl||(zl=new vl);return zl}
-var Gl=function Bl(a){var c=a.dK();if(c instanceof Cl&&hf(new E(c.qo),a.qo))c=Bl(c);else{c=a.dK();var d=O().c;c=new A(c,d)}d=a.lK();d instanceof Cl&&hf(new E(d.qo),a.qo)?a=Bl(d):(a=a.lK(),d=O().c,a=new A(a,d));return Fl(a,c)};
-function Hl(a){var b=k=>a.qo?hf(new E(k),Il()):hf(new E(k),Jl()),c=Gl(a);a:for(;;)if(c.b()){b=v();break}else{var d=c.e(),e=c.g();if(!0===!!b(d))c=e;else for(;;){if(e.b())b=c;else{d=e.e();if(!0!==!!b(d)){e=e.g();continue}d=e;e=new A(c.e(),v());var g=c.g();for(c=e;g!==d;){var h=new A(g.e(),v());c=c.r=h;g=g.g()}for(g=d=d.g();!d.b();){h=d.e();if(!0===!!b(h)){for(;g!==d;)h=new A(g.e(),v()),c=c.r=h,g=g.g();g=d.g()}d=d.g()}g.b()||(c.r=g);b=e}break a}}return Kl(b)}function Ll(){}Ll.prototype=new p;
-Ll.prototype.constructor=Ll;function Ml(){}Ml.prototype=Ll.prototype;function Ve(a,b,c){a.BM=b;a.DC=c;xg||(xg=new wg);c=Nl();for(var d=0,e=1,g=null;d<b.length;){var h=b.charCodeAt(d);13===h?(Ol(Pl(),g,hd(10))||1!==e||Ql(c,d),e=1):10===h?(Ol(Pl(),g,hd(13))||1!==e||Ql(c,d),e=1):(1===e&&Ql(c,d),e=1+e|0);g=hd(h);d=1+d|0}1===e&&Ql(c,d);Rl();if(0<=c.Tg)b=new zd(c.Tg),c.yc(b,0,2147483647),c=b;else{b=[];for(c=Sl(c).m();c.s();)d=c.t(),b.push(null===d?0:d);c=new zd(new Int32Array(b))}a.CC=c;return a}
-function Tl(){var a=new We;Ve(a,"",Le(Ne(),""));return a}function We(){this.CC=this.DC=this.BM=null}We.prototype=new p;We.prototype.constructor=We;function pg(a,b){var c=a.CC;a:{for(var d=0;d<c.a.length;){if(c.a[d]>b){c=d;break a}d=1+d|0}c=-1}c=-1===c?a.CC.a.length:1>c?1:c;d=a.DC.K();d=-1+(c<d?c:d)|0;b=1+(b-a.CC.a[d]|0)|0;a=a.DC.ua(d);return new Ul(c,a,b)}We.prototype.$classData=q({sU:0},!1,"mlscript.FastParseHelpers",{sU:1,d:1});
-var Bm=function Vl(a,b,c){for(;;){var e=b;if(e instanceof Wl)return c=Xl(c,e.w),new Yl(c);if(e instanceof Zl){var g=e.vn;c=(k=>l=>{if(null!==l){var m=l.i(),n=l.j();if(null!==m&&(m=m.w,null!==n&&(n=n.Da,n instanceof Wl))){l=Xl(k,n.w);m=$l(cm(),m);if(l===m)return l=t().f,G(new H,m,l);t();return G(new H,m,new M(new Yl(l)))}}if(null!==l&&(n=l.i(),m=l.j(),null!==n&&(n=n.w,null!==m)))return l=m.Da,m=$l(cm(),n),t(),l=Vl(a,l,k),G(new H,m,new M(l));throw new x(l);})(c);if(g===v())c=v();else{b=g.e();e=b=new A(c(b),
-v());for(g=g.g();g!==v();){var h=g.e();h=new A(c(h),v());e=e.r=h;g=g.g()}c=b}return new dm(c)}if(e instanceof em)b=e.Ni;else{if(e instanceof fm)return new gm;if(e instanceof hm)b=e.Sh;else{if(e instanceof im){g=e.Ra;c=(k=>l=>{if(null!==l){var m=l.j();if(null!==m)return Vl(a,m.Da,k)}throw new x(l);})(c);if(g===v())c=v();else{b=g.e();e=b=new A(c(b),v());for(g=g.g();g!==v();)h=g.e(),h=new A(c(h),v()),e=e.r=h,g=g.g();c=b}return new jm(c)}if(e instanceof km)b=e.ym;else{if(e instanceof lm||e instanceof
-mm||e instanceof nm||e instanceof om||e instanceof pm||e instanceof qm||e instanceof rm||e instanceof sm||e instanceof tm||e instanceof um||e instanceof vm||e instanceof wm||e instanceof xm||e instanceof ym||e instanceof zm)throw new Am("term "+b+" is not a valid pattern");throw new x(e);}}}}};
-function Cm(a,b,c){if(b instanceof im){var d=b.Ra;b=k=>{if(null!==k){var l=new M(k);if(!l.b()){var m=l.k.i();l=l.k.j();if(t().f===m&&null!==l)return Bm(a,l.Da,c)}}if(null!==k&&(l=new M(k),!l.b()&&(m=l.k.i(),l=l.k.j(),m instanceof M&&(m=m.k,null!==l))))return Bm(a,m,c);throw new x(k);};if(d===v())return v();var e=d.e(),g=e=new A(b(e),v());for(d=d.g();d!==v();){var h=d.e();h=new A(b(h),v());g=g.r=h;d=d.g()}return e}throw new Am("term "+b+" is not a valid parameter list");}
-function Dm(a,b,c){var d=a.kK();d.b()?c=new Em(a.Sa()):(d=d.o(),Fm(c,d).TE=!0,c=new Em(d),d=a.Sa(),c=Gm(cm(),c,d));return b&&!a.CJ()?Gm(cm(),c,"class"):c}
-var Tm=function Hm(a,b,c,d){if(c instanceof Im){var g=c.zr;return Jm(a,b,c.yr,d).aa(Lm(a,c.xr,d),Hm(a,b,g,d))}if(c instanceof Mm)return Lm(a,c.qq,d);if(Nm()===c)return a=t().f,b=O().c,t(),c=new Om(new Em("Error")),d=Pm("non-exhaustive case expression"),g=O().c,c=new Qm(new Rm(c,new A(d,g))),d=O().c,new Sm(a,b,new me(new A(c,d)),O().c);throw new x(c);};
-function Jm(a,b,c,d){return new Um((e,g)=>{var h=!1,k=null;a:{if(c instanceof Wl&&(h=!0,k=c,"int"===k.w)){h=Gm(cm(),new Em("Number"),"isInteger");k=O().c;h=new Rm(h,new A(b,k));break a}if(h&&"bool"===k.w)h=new Vm("\x3d\x3d\x3d",Gm(cm(),b,"constructor"),new Wm("Boolean"));else{if(h){var l=k.w;if("true"===l||"false"===l){h=new Vm("\x3d\x3d\x3d",b,new Wm(l));break a}}if(h&&"string"===k.w)h=new Vm("\x3d\x3d\x3d",Gm(cm(),b,"constructor"),new Wm("String"));else{if(h){h=k.w;k=!1;l=null;var m=Xm(d,h);if(m instanceof
-M&&(k=!0,l=m,m=l.k,m instanceof Ym)){h=new Zm(b,Dm(m,!0,d));break a}if(k&&(k=l.k,k instanceof $m)){h=new Zm(b,Dm(k,!0,d));break a}k=!1;l=null;m=a.Th.Fn.Y(h);m instanceof M&&(k=!0,l=m);if(k&&(m=l.k,m instanceof an)){h=new Em(m.xx);h=Gm(cm(),h,"is");k=J(new L,[b]);h=new Rm(h,(je(),le(v(),k)));break a}if(k&&l.k instanceof bn)throw new Am("cannot match type alias "+h);throw new Am("unknown match case: "+h);}if(c instanceof fm)h=new Vm("\x3d\x3d\x3d",b,Lm(a,c,d));else throw new x(c);}}}return new cn(h,
-e,g)})}function dn(a,b){if(a instanceof A){var c=a.A;a=a.r;t();for(c=en(c,new Em("Object"),!1,b);!a.b();){var d=a.e();c=en(d,c,!0,b);a=a.g()}return new M(c)}b=O().c;if(null===b?null===a:b.h(a))return t().f;throw new x(a);}
-function fn(a,b,c,d,e){var g=b.Qp.w,h=n=>{var r=gn(e,n,new M(!1),!1,t().f);return new hn(r.Ze,new Em("this.#"+n))};if(c===v())h=v();else{var k=c.e(),l=k=new A(h(k),v());for(c=c.g();c!==v();){var m=c.e();m=new A(h(m),v());l=l.r=m;c=c.g()}h=k}l=b.Fw.ca;l instanceof lm?(b=l.El,k=Cm(a,l.Dl,e),t(),k=new M(k),l=b):k=t().f;b=k;a=jn(Lm(a,l,e));k=kn(e.Gn);k instanceof M?(k=k.k,l=O().c,k=new A(k,l)):k=O().c;d.b()?d=O().c:(d=d.o(),d=ln(Fm(e,d)));t();d=mn(mn(h,k),d);h=O().c;d=mn(d,new A(a,h));d=new me(d);if(b instanceof
-M)return new nn(g,b.k,d);if(t().f===b)return new pn(g,d);throw new x(b);}function qn(a,b){b=a.Th.Fn.Y(b);if(b instanceof M){var c=b.k;if(c instanceof an){b=rn(c.wx);c=un(c.wx);for(var d=null,e=null;c!==v();){var g=c.e();for(g=qn(a,g).m();g.s();){var h=new A(g.t(),v());null===e?d=h:e.r=h;e=h}c=c.g()}a=null===d?v():d;return mn(b,a)}}a=b instanceof M&&null!==b.k?!0:t().f===b?!0:!1;if(a)return O().c;throw new x(b);}
-function en(a,b,c,d){a:for(;;)if(a instanceof mm)a=a.kb;else{if(a instanceof Wl){a=a.w;break a}if(a instanceof nm){var e=a.wn;if(null!==e){a=e.w;break a}}if(a instanceof km)a=a.ym;else throw new Am("unsupported parents.");}e=!1;var g=null,h=Xm(d,a);if(h instanceof M&&(e=!0,g=h,g.k instanceof an))return b;if(e){var k=g.k;if(k instanceof wn)return c=Dm(k,!0,d),t(),b=J(new L,[b]),new Rm(c,le(v(),b))}if(e&&(b=g.k)&&b.$classData&&b.$classData.pb.QE&&!c)return Dm(b,!0,d);if(e)throw new Am("unexpected parent symbol "+
-g.k+".");if(t().f===h)throw new Am("unresolved parent "+a+".");throw new x(h);}function xn(a,b){if(null===b)throw ze();return b.qb?b.sb:Ce(b,new yn(a))}function zn(a){a=An(a);if(a instanceof te)return Jl();if(a instanceof me)return a.ia;throw new x(a);}
-function Bn(a,b,c,d,e){var g=u=>{if(null!==u){var w=u.i(),y=u.j();if(w instanceof M&&(w=w.k,null!==y)){var B=y.vc;y=y.Da;if(null!==B)return u=B.pf,y=zn(y),u=new Cn(u?(t(),new M(y)):t().f,y),G(new H,w,u)}}if(null!==u&&(w=u.i(),u=u.j(),t().f===w&&null!==u&&(y=u.vc,w=u.Da,null!==y&&(u=y.pf,w instanceof Wl))))return u?(t(),u=Il(),u=new M(u)):u=t().f,u=new Cn(u,Jl()),G(new H,w,u);Dn("Program reached and unexpected state.")};if(c===v())g=v();else{for(var h=c.e(),k=h=new A(g(h),v()),l=c.g();l!==v();){var m=
-l.e();m=new A(g(m),v());k=k.r=m;l=l.g()}g=h}h=u=>null!==u&&(u=u.j(),null!==u)?u.vc.ri:!1;k=c;a:for(;;)if(k.b()){l=v();break}else if(l=k.e(),c=k.g(),!1===!!h(l))k=c;else for(;;){if(c.b())l=k;else{l=c.e();if(!1!==!!h(l)){c=c.g();continue}l=c;c=new A(k.e(),v());m=k.g();for(k=c;m!==l;){var n=new A(m.e(),v());k=k.r=n;m=m.g()}for(m=l=l.g();!l.b();){n=l.e();if(!1===!!h(n)){for(;m!==l;)n=new A(m.e(),v()),k=k.r=n,m=m.g();m=l.g()}l=l.g()}m.b()||(k.r=m);l=c}break a}h=u=>{if(null!==u){var w=u.i();if(w instanceof
-M)return w.k.w}if(null!==u&&(w=u.i(),u=u.j(),t().f===w&&null!==u&&(u=u.Da,u instanceof Wl)))return u.w;Dn("Program reached and unexpected state.")};if(l===v())h=v();else{c=l.e();k=c=new A(h(c),v());for(l=l.g();l!==v();)m=l.e(),m=new A(h(m),v()),k=k.r=m,l=l.g();h=c}if(d===v())d=v();else{c=d.e();k=c=new A(zn(c),v());for(d=d.g();d!==v();)l=d.e(),l=new A(zn(l),v()),k=k.r=l,d=d.g();d=c}d=d.we(new En(g),Fn());c=Gn();g=Hn(zf(e),new In(a,c,b));b=Hn(zf(e),new Jn(a,c,b));c=u=>{var w=!1,y=null;if(u instanceof
-em){w=!0;y=u;var B=y.Ni;if(B instanceof Wl&&"this"===B.w)return!1}return w&&y.Ni instanceof xm?!1:u instanceof Kn&&(w=u.Sd,y=u.cd,w instanceof M&&!1===!!w.k&&y instanceof te)?!0:u instanceof Ln?!0:!1};l=zf(e);a:for(;;)if(l.b()){c=v();break}else if(m=l.e(),k=l.g(),!1===!!c(m))l=k;else for(;;){if(k.b())c=l;else{m=k.e();if(!1!==!!c(m)){k=k.g();continue}m=k;k=new A(l.e(),v());n=l.g();for(l=k;n!==m;){var r=new A(n.e(),v());l=l.r=r;n=n.g()}for(n=m=m.g();!m.b();){r=m.e();if(!1===!!c(r)){for(;n!==m;)r=new A(n.e(),
-v()),l=l.r=r,n=n.g();n=m.g()}m=m.g()}n.b()||(l.r=n);c=k}break a}a=Hn(zf(e),new Mn(a));return new Nn(d,g,b,c,a,h)}function On(){this.UM=!1;this.Ur=this.Th=null}On.prototype=new p;On.prototype.constructor=On;function Pn(){}Pn.prototype=On.prototype;function Qn(a,b,c,d){a=Rn(a,b,c,d);if(!(a instanceof me)){if(a instanceof te)throw a.ca;throw new x(a);}return a.ia}
-function Rn(a,b,c,d){O();var e=!1,g=null,h=Xm(d,b);a:{if(h instanceof M){e=!0;g=h;var k=g.k;if(k instanceof Sn){k.mP=!0;a.Ur.Az.L(k.rx)||Tn(a.Ur,k.rx,k.CE);b=new Em(k.CE);"error"===k.rx&&(d=v(),b=new Rm(b,d));break a}}if(e&&(k=g.k,k instanceof Un)){if(!k.SZ)throw new Vn(k);b=new Em(k.Hs);break a}if(e&&(k=g.k,k instanceof Wn)){d=k.MI;if((d.b()?0:d.o())&&!k.NI)throw new Am("unguarded recursive use of by-value binding "+b);k.TE=!0;b=new Em(k.Ze);k.MI.b()&&!k.NI&&(d=v(),b=new Rm(b,d));break a}if(e&&(k=
-g.k)&&k.$classData&&k.$classData.pb.QE){b=Dm(k,c,d);break a}if(e&&(c=g.k,c instanceof Xn)){a=c.sx;if((a.b()?0:a.o())&&!c.tx)throw new Am("unguarded recursive use of by-value binding "+b);b=c.hA;if(b.b())throw new Am("unqualified member symbol "+c);b=b.o();c.xP=!0;Fm(d,b).TE=!0;c.gA?b=new Em(b+".#"+c.sq):(b=new Em(b),d=c.sq,b=Gm(cm(),b,d));c.sx.b()&&!c.tx&&(d=v(),b=new Rm(b,d));break a}if(e&&g.k instanceof an)return O(),b=new Am("trait used in term position"),new te(b);if(t().f===h){c=!1;d=d.Fn.Y(b);
-if(d instanceof M&&(c=!0,d.k instanceof bn))return O(),b=new Am("type alias "+b+" is not a valid expression"),new te(b);c&&Dn("register mismatch in scope");if(t().f===d){if(!a.UM)return O(),b=new Am("unresolved symbol "+b),new te(b);b=new Em(b);break a}throw new x(d);}throw new x(h);}return new me(b)}
-function Yn(a,b,c){if(null!==b){var d=b.kb,e=b.hc;if(d instanceof mm){var g=d.kb;d=d.hc;if(g instanceof Wl&&(g=g.w,d instanceof im)){var h=d.Ra;if(h instanceof A&&(d=h.A,h=h.r,null!==d)){var k=new M(d);if(!k.b()&&(d=k.k.i(),k=k.k.j(),t().f===d&&null!==k&&(d=k.Da,k=O().c,(null===k?null===h:k.h(h))&&e instanceof im&&(e=e.Ra,e instanceof A&&(h=e.A,e=e.r,null!==h&&(k=new M(h),!k.b()&&(h=k.k.i(),k=k.k.j(),t().f===h&&null!==k&&(h=k.Da,k=O().c,(null===k?null===e:k.h(e))&&Zn().KC.L(g)))))))))return new Vm(g,
-Lm(a,d,c),Lm(a,h,c))}}}}if(null!==b&&(g=b.kb,e=b.hc,g instanceof Wl&&(g=g.w,e instanceof im&&(d=e.Ra,d instanceof A&&(e=d.A,d=d.r,null!==e&&(h=new M(e),!h.b()&&(e=h.k.i(),h=h.k.j(),t().f===e&&null!==h&&(e=h.Da,d instanceof A&&(h=d.A,d=d.r,null!==h&&(k=new M(h),!k.b()&&(h=k.k.i(),k=k.k.j(),t().f===h&&null!==k&&(h=k.Da,k=O().c,(null===k?null===d:k.h(d))&&Zn().KC.L(g)&&!Rn(a,g,!0,c).TA()))))))))))))return new Vm(g,Lm(a,e,c),Lm(a,h,c));if(null!==b&&(d=b.kb,g=b.hc,d instanceof mm&&(e=d.kb,d=d.hc,e instanceof
-mm&&(h=e.kb,e=e.hc,h instanceof Wl&&"if"===h.w&&e instanceof im&&(h=e.Ra,h instanceof A&&(e=h.A,h=h.r,null!==e&&(e=e.j(),null!==e&&(e=e.Da,k=O().c,(null===k?null===h:k.h(h))&&d instanceof im&&(h=d.Ra,h instanceof A&&(d=h.A,h=h.r,null!==d&&(d=d.j(),null!==d&&(d=d.Da,k=O().c,(null===k?null===h:k.h(h))&&g instanceof im&&(g=g.Ra,g instanceof A&&(h=g.A,g=g.r,null!==h&&(h=h.j(),null!==h&&(h=h.Da,k=O().c,null===k?null===g:k.h(g)))))))))))))))))return new cn(Lm(a,e,c),Lm(a,d,c),Lm(a,h,c));null!==b&&(g=b.kb,
-g instanceof mm&&(g=g.kb,g instanceof mm&&(g=g.kb,g instanceof Wl&&"if"===g.w&&Dn("Program reached and unexpected state."))));if(null!==b&&(g=b.kb,e=b.hc,e instanceof im)){h=e.Ra;b=Lm(a,g,c);g=l=>{if(null!==l){var m=l.j();if(null!==m)return Lm(a,m.Da,c)}throw new x(l);};if(h===v())g=v();else{e=h.e();d=e=new A(g(e),v());for(h=h.g();h!==v();)k=h.e(),k=new A(g(k),v()),d=d.r=k,h=h.g();g=e}return new Rm(b,g)}null!==b&&$n();throw new Am("ill-formed application "+b);}
-function Lm(a,b,c){var d=!1,e=null,g=!1,h=null,k=!1,l=null;if(!b.dd.b()){var m=b.dd;m.b()&&Dn("Program reached and unexpected state.");return Lm(a,m.o(),c)}if(b instanceof Wl)return Qn(a,b.w,!1,c);if(b instanceof xm)return new Em("super");if(b instanceof lm){var n=b.Dl,r=b.El,u=ao(c),w=Cm(a,n,u);return new bo(w,co(u.Gn,Lm(a,r,u)))}if(b instanceof mm)return Yn(a,b,c);if(b instanceof Zl){var y=b.vn,B=Ha=>{if(null!==Ha){var jc=Ha.i(),Rb=Ha.j();if(null!==Rb)return Ha=jc.w,Rb=Lm(a,Rb.Da,c),G(new H,Ha,
-Rb)}throw new x(Ha);};if(y===v())var D=v();else{for(var C=y.e(),F=new A(B(C),v()),I=F,K=y.g();K!==v();){var N=K.e(),P=new A(B(N),v());I=I.r=P;K=K.g()}D=F}return new fo(D,O().c)}if(b instanceof nm){var T=b.Co,aa=b.wn;return Gm(cm(),Lm(a,T,c),aa.w)}if(b instanceof om){d=!0;e=b;var Y=e.Op,S=e.Pp,Z=e.vo;if(!0===e.Wr&&null!==Y){var ka=Y.w;if(S instanceof lm){var X=S.Dl,sa=S.El,Ia=ao(c),Za=Xl(Ia,ka),Ga=ao(Ia),xa=Cm(a,X,Ga),Ra=co(Ga.Gn,Lm(a,sa,Ga));t();var Ja=new M(Za);if(Ra instanceof me)var La=Ra.ia;else{if(!(Ra instanceof
-te))throw new x(Ra);var pb=jn(Ra.ca),Fb=O().c;La=new A(pb,Fb)}var Gb=new go(Ja,xa,La),Hb=t().f,tb=new Yl(Za),kb=O().c,gb=new A(tb,kb),Vb=co(Ia.Gn,Lm(a,Z,Ia)),bb=O().c;return new Sm(Hb,gb,Vb,new A(Gb,bb))}}}if(d){var nb=e.Op;if(!0===e.Wr&&null!==nb)throw new Am("recursive non-function definition "+nb.w+" is not supported");}if(d){var Tb=e.Op,ub=e.Pp,Ub=e.vo;if(null!==Tb){var $a=Tb.w,cb=ao(c),Na=Xl(cb,$a),Ca=t().f,Ba=new Yl(Na),Oa=O().c,wa=new A(Ba,Oa),ea=co(cb.Gn,Lm(a,Ub,cb)),la=Lm(a,ub,c),Ka=O().c;
-return new Sm(Ca,wa,ea,new A(la,Ka))}}if(b instanceof pm){var Ua=b.Rk,ya=ao(c),ib=Ua.m(),Lb=new ho(ib,new z(Ha=>{if(Ha instanceof io){var jc=O().c;return new A(Ha,jc)}if(Ha instanceof Kn){jc=Ha.Qb;var Rb=Ha.bj;null!==jc&&(jc=jc.w,Rb.b()?Rb=R():(Rb=Rb.o(),Rb=new M(Rb.w)),jo(ya,jc,t().f,Rb))}return Ha.Nu().j()}));je();var ec=le(v(),Lb),Mb=t().f,Jb=O().c;t();var Kb=ya.Gn,eb=ec.m(),Wb=new ko(eb),mc=new eg(Wb,new z(Ha=>{if(null!==Ha){var jc=Ha.i(),Rb=Ha.Lc();if(jc instanceof Ln&&(1+Rb|0)===ec.K())return jn(Lm(a,
-jc,ya))}if(null!==Ha&&(jc=Ha.i(),jc instanceof Ln))return new lo(Lm(a,jc,ya));if(null!==Ha){var Uc=Ha.i();if(Uc instanceof Kn){jc=Uc.Sd;Rb=Uc.Qb;var Rc=Uc.bj;Uc=Uc.cd;if(null!==Rb&&(Rb=Rb.w,Uc instanceof te))return Ha=Uc.ca,Rc.b()?Rc=R():(Rc=Rc.o(),Rc=new M(Rc.w)),Uc=jc.b()||mo(new no(a,Ha)),jc=gn(ya,Rb,jc,Uc,Rc),t(),jc=jc.Ze,t(),Ha=Lm(a,Ha,ya),Ha=[G(new H,jc,new M(Ha))],Ha=J(new L,Ha),new oo(le(v(),Ha))}}if(null!==Ha&&(jc=Ha.i(),jc instanceof io)){a:{Ha=O().c;Rc=po(a,new A(jc,Ha),t().f,ya);if(null===
-Rc)throw new x(Rc);Rb=Rc.jj;Ha=Rc.ci;Rc=Rc.Qi;if(Rb instanceof A)Ha=Rb.A,t(),Ha=new M(Ha);else{Uc=O().c;if(null===Uc?null!==Rb:!Uc.h(Rb))throw new x(Rb);if(Ha instanceof A)Ha=Ha.A,t(),Ha=new M(Ha);else{Rb=O().c;if(null===Rb?null!==Ha:!Rb.h(Ha))throw new x(Ha);Rc instanceof A?(Ha=Rc.A,t(),Ha=new M(Ha)):Ha=t().f}}Rb=!1;Rc=null;if(Ha instanceof M&&(Rb=!0,Rc=Ha,Ha=Rc.k,Ha instanceof Ym)){Rb=ao(ya);jc=qo(a,Ha,t().f,!1,Rb);Rb=gn(Rb,"ctor",new M(!1),!1,t().f).Ze;Rc=ro(jc);if(null===Rc)throw new x(Rc);Uc=
-Rc.i();var Cd=Rc.j();if(Ha.xu)t(),t(),Rb=J(new L,[new so(new M(new Em(Ha.ai)))]),Rb=le(v(),Rb);else{t();to();t();Rc=J(new L,[Rb]);Rc=uo(le(v(),Rc));var od=new Em(Rb);t();Uc=new lo(new vo(od,new bo(Uc,new te(new Rm(new Om(new Em(Ha.ai)),Cd)))));Cd=new Em(Rb);Cd=new lo(new vo(Gm(cm(),Cd,"class"),new Em(Ha.ai)));t();Rb=J(new L,[Rc,Uc,Cd,new so(new M(new Em(Rb)))]);Rb=le(v(),Rb)}Ha=Ha.ai;Rc=t().f;Uc=O().c;t();Ha=new hn(Ha,new Sm(Rc,Uc,new me(new A(jc,Rb)),O().c));break a}if(Rb&&(Ha=Rc.k,Ha instanceof
-wn)){jc=ao(ya);Rb=gn(jc,"base",new M(!1),!1,t().f);jc=qo(a,Ha,(t(),new M(Rb)),!1,jc);Ha=Ha.Xo;t();Rb=J(new L,[new Yl(Rb.Ze)]);Rb=le(v(),Rb);t();t();t();jc=J(new L,[new so(new M(new wo(jc)))]);jc=le(v(),jc);Ha=new hn(Ha,new bo(Rb,new me(jc)));break a}if(Rb&&(Rc=Rc.k,Rc instanceof $m)){Ha=ao(ya);Uc=qo(a,Rc,t().f,!1,Ha);Cd=gn(Ha,"ins",new M(!1),!1,t().f).Ze;Ha=Rc.gj;jc=t().f;Rb=O().c;t();t();to();t();od=J(new L,[Cd]);od=uo(le(v(),od));var Va=new vo(new Em(Cd),new Rm(new Om(new Em(Rc.gj)),O().c));Va=
-new lo(Va);var wb=new Em(Cd);Rc=new lo(new vo(Gm(cm(),wb,"class"),new Em(Rc.gj)));t();Rc=J(new L,[Uc,od,Va,Rc,new so(new M(new Em(Cd)))]);Rc=le(v(),Rc);Ha=new hn(Ha,new Sm(jc,Rb,new me(Rc),O().c));break a}throw new Am("unsupported NuTypeDef in local blocks: "+jc);}return Ha}if(null!==Ha&&(Ha.i()instanceof xo||Ha.i()instanceof yo||Ha.i()instanceof Kn||Ha.i()instanceof zo))throw new Am("unsupported definitions in blocks");throw new x(Ha);}));je();var ua=Ao(Kb,le(v(),mc));return new Sm(Mb,Jb,new me(ua),
-O().c)}if(b instanceof rm){g=!0;h=b;var Pa=h.Fp,xb=h.Ep;if(xb instanceof Mm){var Yb=xb.qq,zb=Lm(a,Pa,c),Sb=Lm(a,Yb,c),Ma=O().c;return new Bo(new A(zb,new A(Sb,Ma)))}}if(g){var Ea=h.Fp,ab=h.Ep;if(ab instanceof Im){var Db=ab.yr,mb=ab.xr,vb=ab.zr;if(vb instanceof Mm){var Ya=vb.qq;return Jm(a,Lm(a,Ea,c),Db,c).aa(Lm(a,mb,c),Lm(a,Ya,c))}}}if(g){var Wa=h.Ep,rb=Lm(a,h.Fp,c);if(rb.DJ())return Tm(a,rb,Wa,c);var pa=Co(c);c.Gn.uA.eh(pa);var Fa=new Em(pa),Ib=new vo(Fa,rb),qb=Tm(a,Fa,Wa,c),Nb=O().c;return new Bo(new A(Ib,
-new A(qb,Nb)))}if(b instanceof Do){var fc=b.Rr,Ac=fc.u();Eo||(Eo=new Fo);return new Wm(Ac+(Go(fc)?"":"n"))}if(b instanceof Ho)return new Wm(b.nw.gd.u());if(b instanceof Io)return Pm(b.dx);if(b instanceof Jo)return new Wm(b.Es?"undefined":"null");if(b instanceof em)return Lm(a,b.Ni,c);if(b instanceof qm){var tc=b.wu,vc=b.vu;if(null!==vc){var sc=vc.vn,uc=a.Ur.Az.Y("withConstruct");if(uc instanceof M)var lc=uc.k;else if(t().f===uc)lc=Tn(a.Ur,"withConstruct",Ko(a.Th,"withConstruct"));else throw new x(uc);
-var Wc=new Em(lc),Cc=Lm(a,tc,c),Dc=Ha=>{if(null!==Ha){var jc=Ha.i(),Rb=Ha.j();if(null!==jc&&(jc=jc.w,null!==Rb))return Ha=Lm(a,Rb.Da,c),G(new H,jc,Ha)}throw new x(Ha);};if(sc===v())var Ec=v();else{for(var Ic=sc.e(),Xc=new A(Dc(Ic),v()),Sc=Xc,oc=sc.g();oc!==v();){var qc=oc.e(),Tc=new A(Dc(qc),v());Sc=Sc.r=Tc;oc=oc.g()}Ec=Xc}var Nc=new fo(Ec,O().c),Pc=O().c;return new Rm(Wc,new A(Cc,new A(Nc,Pc)))}}if(b instanceof hm){k=!0;l=b;var Oc=l.Sh;if(!1===l.Sk){if(Oc instanceof mm){var $c=Oc.kb;if($c instanceof
-Wl){var Lc=$c.w;if(Zn().KC.L(Lc))return new Lo(Lm(a,Oc,c))}}return Lm(a,Oc,c)}}if(k)return Lm(a,l.Sh,c);if(b instanceof im){var Zb=b.Ra,ed=Ha=>{if(null!==Ha){var jc=Ha.j();if(null!==jc)return Lm(a,jc.Da,c)}throw new x(Ha);};if(Zb===v())var $b=v();else{for(var Fc=Zb.e(),Yc=new A(ed(Fc),v()),nc=Yc,Ob=Zb.g();Ob!==v();){var cc=Ob.e(),Gc=new A(ed(cc),v());nc=nc.r=Gc;Ob=Ob.g()}$b=Yc}return new Mo($b)}if(b instanceof sm){var Bc=b.gu,qd=Lm(a,b.fu,c),Gd=Lm(a,Bc,c);return No(new Oo,qd,Gd)}if(b instanceof tm)throw new Am("if expression was not desugared");
-if(b instanceof um){var cd=b.gs;if(cd instanceof Wl){var rd=Qn(a,cd.w,!0,c);return rd instanceof Om?rd:new Om(rd)}throw new Am("Unsupported `new` class term: "+cd);}if(b instanceof vm)return Lm(a,b.Ir,c);if(b instanceof km)return Lm(a,b.ym,c);if(b instanceof ym){var Id=b.Ip;if(null!==Id)throw new Am("assignment of "+Id.w+" is not supported outside a constructor");}if(b instanceof tm||b instanceof wm||b instanceof zm)throw new Am("cannot generate code for term "+b);throw new x(b);}
-function ln(a){if(a.TE){a=new hn(a.Ze,new Em("this"));var b=O().c;return new A(a,b)}return O().c}
-function Po(a,b){if(null!==a){var c=a.nb,d=a.eb;if(Qo()===c&&null!==d){c=d.X;a=new Em("globalThis");a=Gm(cm(),a,c);d=new Yl("base");var e=O().c;d=new A(d,e);t();b=new Em(b);b=Gm(cm(),b,c);c=new Em("base");e=O().c;return new lo(new vo(a,new bo(d,new te(new Rm(b,new A(c,e))))))}}if(null!==a&&(c=a.eb,null!==c))return a=c.X,c=new Em("globalThis"),c=Gm(cm(),c,a),b=new Em(b),b=new vo(c,Gm(cm(),b,a)),new lo(b);throw new x(a);}
-function Ro(a,b,c,d){c=gn(d,"base",new M(!1),!1,t().f);a=qo(a,b,(t(),new M(c)),!1,d);d=b.eA;d.b()&&Dn("Program reached and unexpected state.");d=d.o();d=new hn(d,new Em("this"));b=b.Xo;t();c=J(new L,[new Yl(c.Ze)]);c=le(v(),c);t();var e=O().c;d=new A(d,e);t();t();a=J(new L,[new so(new M(new wo(a)))]);a=Fl(le(v(),a),d);return new nn(b,c,new me(a))}
-function So(a,b,c,d){d=qo(a,b,t().f,!1,d);c=new Em("this.#"+b.gj);a=b.fA;a.b()&&Dn("Program reached and unexpected state.");a=a.o();var e=new hn(a,new Em("this"));a=b.gj;t();var g=O().c;e=new A(e,g);t();g=new Vm("\x3d\x3d\x3d",c,new Em("undefined"));t();b=[d,new lo(new vo(c,new Om(new Rm(new Em(b.gj),O().c)))),new lo(new vo(Gm(cm(),c,"class"),new Em(b.gj)))];b=J(new L,b);b=[new To(g,le(v(),b),O().c),new so((t(),new M(c)))];b=J(new L,b);b=Fl(le(v(),b),e);return new pn(a,new me(b))}
-function ro(a){var b=a.Mp;if(b===v())var c=v();else{c=b.e();var d=c=new A(new Yl(c),v());for(b=b.g();b!==v();){var e=b.e();e=new A(new Yl(e),v());d=d.r=e;b=b.g()}}b=a.Mp;if(b===v())a=v();else for(a=b.e(),d=a=new A(new Em(a),v()),b=b.g();b!==v();)e=b.e(),e=new A(new Em(e),v()),d=d.r=e,b=b.g();return G(new H,c,a)}
-function Uo(a,b,c,d){a=qo(a,b,t().f,!1,d);c=ro(a);if(null===c)throw new x(c);var e=c.i(),g=c.j();d=new Em("this.#"+b.ai);c=b.ux;c.b()&&Dn("Program reached and unexpected state.");c=c.o();c=new hn(c,new Em("this"));if(b.xu)t(),e=J(new L,[new lo(new vo(d,new Em(b.ai)))]),e=le(v(),e);else{t();t();var h=new Em("Object");h=Gm(cm(),h,"freeze");t();g=J(new L,[new Rm(new Om(new Em(b.ai)),g)]);g=new Rm(h,le(v(),g));e=new lo(new vo(d,new bo(e,new te(g))));g=new lo(new vo(Gm(cm(),d,"class"),new Em(b.ai)));h=
-Gm(cm(),d,"unapply");var k=new Em(b.ai);e=[e,g,new lo(new vo(h,Gm(cm(),k,"unapply")))];e=J(new L,e);e=le(v(),e)}b=b.ai;t();t();a=[new To(new Vm("\x3d\x3d\x3d",d,new Em("undefined")),new A(new lo(new wo(a)),e),O().c),new so((t(),new M(d)))];a=J(new L,a);a=le(v(),a);return new pn(b,new me(new A(c,a)))}
-function qo(a,b,c,d,e){var g=new xf,h=ao(e,b.u()),k=ao(h,b.Sa()+" inheritance"),l=ao(h,b.Sa()+" body"),m=ao(l,b.Sa()+" constructor"),n=v(),r=Vo(new Wo,n),u=v(),w=Vo(new Wo,u),y=b.iB(),B=ee=>{var Re=ao(l),Ji=Zo(Re,"qualifier");ee=ee.sf.w;var jk=g.qb?g.sb:xn(a,g);Re=new $o(jk.JC,Re,Ji);return G(new H,ee,Re)};if(y===v())var D=v();else{for(var C=y.e(),F=new A(B(C),v()),I=F,K=y.g();K!==v();){var N=K.e(),P=new A(B(N),v());I=I.r=P;K=K.g()}D=F}var T=b.hB(),aa=ee=>{var Re=ao(l),Ji=Zo(Re,"qualifier");ee=ee.Qp.w;
-var jk=g.qb?g.sb:xn(a,g);Re=new $o(jk.JC,Re,Ji);return G(new H,ee,Re)};if(T===v())var Y=v();else{for(var S=T.e(),Z=new A(aa(S),v()),ka=Z,X=T.g();X!==v();){var sa=X.e(),Ia=new A(aa(sa),v());ka=ka.r=Ia;X=X.g()}Y=Z}var Za=mn(D,Y);ap();var Ga=bp(cp(),Za),xa=new dp(Ga),Ra=ep(xa);if(Ra.b()){t();var Ja=Zo(m,"qualifier"),La=new M(Ja)}else{for(var pb=Ra.o(),Fb=(new dp(Ga)).m();Fb.s();){var Gb=Fb.t();if(Gb.uo!==pb.uo)throw new rk("assertion failed: the expected qualifier's runtime name should be "+(pb.uo+", "+
-Gb.uo)+" found");}fp();var Hb=Zo(m,pb.uo);gp(0,Hb===pb.uo);t();La=new M(pb.uo)}for(var tb=b.eK(),kb=un(b.Lu()),gb=null,Vb=null;kb!==v();){for(var bb=kb.e(),nb=qn(a,bb).m();nb.s();){var Tb=new A(nb.t(),v());null===Vb?gb=Tb:Vb.r=Tb;Vb=Tb}kb=kb.g()}var ub=null===gb?v():gb,Ub=mn(tb,ub),$a=new Wo,cb=b.iF();if(cb.b()){var Na=ee=>{var Re=new Xn(ee,new M(!1),!1,!b.Yx().L(ee),La);hp(l,Re);ip(r,Re);gn(k,ee,new M(!1),!1,t().f);return gn(m,ee,new M(!1),!1,t().f).Ze};if(Ub===v())var Ca=v();else{for(var Ba=Ub.e(),
-Oa=new A(Na(Ba),v()),wa=Oa,ea=Ub.g();ea!==v();){var la=ea.e(),Ka=new A(Na(la),v());wa=wa.r=Ka;ea=ea.g()}Ca=Oa}}else{var Ua=cb.o(),ya=ee=>{if(ee.Hx()){var Re=new Xn(ee.i(),new M(!1),!1,!1,La);hp(l,Re);ip(r,Re);ip($a,ee.i())}return gn(m,ee.i(),new M(!1),!1,t().f).Ze};if(Ua===v())Ca=v();else{for(var ib=Ua.e(),Lb=new A(ya(ib),v()),ec=Lb,Mb=Ua.g();Mb!==v();){var Jb=Mb.e(),Kb=new A(ya(Jb),v());ec=ec.r=Kb;Mb=Mb.g()}Ca=Lb}}var eb=$a.ea();if(eb===v())var Wb=v();else{for(var mc=eb.e(),ua=new A(new lo(new vo(new Em("this.#"+
-mc),new Em(mc))),v()),Pa=ua,xb=eb.g();xb!==v();){var Yb=xb.e(),zb=new A(new lo(new vo(new Em("this.#"+Yb),new Em(Yb))),v());Pa=Pa.r=zb;xb=xb.g()}Wb=ua}for(var Sb=b.hB();!Sb.b();){var Ma=Sb.e(),Ea=new Xn(Ma.Qp.w,t().f,!0,!1,La);hp(l,Ea);ip(r,Ea);Sb=Sb.g()}for(var ab=b.HL();!ab.b();){var Db=ab.e().Qp.w,mb=t().f,vb=jo(l,Db,t().f,mb);ip(r,vb);ab=ab.g()}for(var Ya=b.jF();!Ya.b();){var Wa=Ya.e();if(Wa instanceof Kn){var rb=Wa,pa=rb.Sd,Fa=rb.Qb;if(null!==Fa){var Ib=new Xn(Fa.w,pa,!1,!rb.yo,La);hp(l,Ib);
-ip(r,Ib)}}Ya=Ya.g()}var qb=po(a,b.iB(),La,l);if(null===qb)throw new x(qb);var Nb=qb.jj,fc=qb.ci,Ac=qb.Qi;d&&po(a,b.iB(),t().f,a.Th);for(var tc=Nb;!tc.b();){var vc=tc.e();ip(r,vc);ip(w,vc.ai);tc=tc.g()}for(var sc=fc;!sc.b();){var uc=sc.e();ip(r,uc);sc=sc.g()}for(var lc=Ac;!lc.b();){var Wc=lc.e();ip(r,Wc);ip(w,Wc.gj);lc=lc.g()}var Cc=b.hB(),Dc=ee=>fn(a,ee,Ub,La,Ga.yd(ee.Qp.w,new U(()=>{Dn("Program reached and unexpected state.")})).Tt);if(Cc===v())var Ec=v();else{for(var Ic=Cc.e(),Xc=new A(Dc(Ic),v()),
-Sc=Xc,oc=Cc.g();oc!==v();){var qc=oc.e(),Tc=new A(Dc(qc),v());Sc=Sc.r=Tc;oc=oc.g()}Ec=Xc}var Nc=ee=>Ro(a,ee,r.ea(),Ga.yd(ee.Xo,new U(()=>{Dn("Program reached and unexpected state.")})).Tt);if(fc===v())var Pc=v();else{for(var Oc=fc.e(),$c=new A(Nc(Oc),v()),Lc=$c,Zb=fc.g();Zb!==v();){var ed=Zb.e(),$b=new A(Nc(ed),v());Lc=Lc.r=$b;Zb=Zb.g()}Pc=$c}var Fc=mn(Ec,Pc),Yc=ee=>So(a,ee,r.ea(),Ga.yd(ee.gj,new U(()=>{Dn("Program reached and unexpected state.")})).Tt);if(Ac===v())var nc=v();else{for(var Ob=Ac.e(),
-cc=new A(Yc(Ob),v()),Gc=cc,Bc=Ac.g();Bc!==v();){var qd=Bc.e(),Gd=new A(Yc(qd),v());Gc=Gc.r=Gd;Bc=Bc.g()}nc=cc}var cd=mn(Fc,nc),rd=ee=>Uo(a,ee,r.ea(),Ga.yd(ee.ai,new U(()=>{Dn("Program reached and unexpected state.")})).Tt);if(Nb===v())var Id=v();else{for(var Ha=Nb.e(),jc=new A(rd(Ha),v()),Rb=jc,Uc=Nb.g();Uc!==v();){var Rc=Uc.e(),Cd=new A(rd(Rc),v());Rb=Rb.r=Cd;Uc=Uc.g()}Id=jc}var od=mn(cd,Id);if(c instanceof M){var Va=c.k;t();var wb=new M(new Em(Va.Ze))}else wb=dn(b.UG(),e);for(var db=un(b.Lu()),
-Jc=null,Vc=null;db!==v();){var Ta=db.e(),kd=!1,ld=null,qe=e.Fn.Y(Ta);a:{if(qe instanceof M){kd=!0;ld=qe;var Wd=ld.k;if(Wd instanceof an){var Rd=Wd.xx;t();var Me=new M(Rd);break a}}if(kd&&null!==ld.k)Me=t().f;else if(t().f===qe)Me=t().f;else throw new x(qe);}for(var wc=Me.m();wc.s();){var Xb=new A(wc.t(),v());null===Vc?Jc=Xb:Vc.r=Xb;Vc=Xb}db=db.g()}var gc=null===Jc?v():Jc;if(c.b()){var hc=b.UG(),gd=ee=>{if(ee instanceof mm&&(ee=ee.hc,ee instanceof im)){var Re=ee.Ra;ee=kk=>{if(null!==kk){var eo=kk.j();
-if(null!==eo)return Lm(a,eo.Da,k)}throw new x(kk);};if(Re===v())return v();var Ji=Re.e(),jk=Ji=new A(ee(Ji),v());for(Re=Re.g();Re!==v();){var Vg=Re.e();Vg=new A(ee(Vg),v());jk=jk.r=Vg;Re=Re.g()}return Ji}return O().c};if(hc===v())var kc=v();else{for(var ud=hc.e(),za=new A(gd(ud),v()),Qa=za,xc=hc.g();xc!==v();){var yd=xc.e(),be=new A(gd(yd),v());Qa=Qa.r=be;xc=xc.g()}kc=za}for(var yc=kc,Od=null,sd=null;yc!==v();){for(var he=jp(yc.e()).m();he.s();){var ue=new A(he.t(),v());null===sd?Od=ue:sd.r=ue;sd=
-ue}yc=yc.g()}var sg=jp(null===Od?v():Od),Se=t().f;He=sg;Ze=Se}else{var Kf=gn(m,"rest",new M(!1),!1,t().f);t();var $e=J(new L,[new Em("..."+Kf.Ze)]),rf=le(v(),$e);t();var He=rf,Ze=new M(Kf.Ze)}for(var jf=He,tf=Ze,Te=new Wo,hg=b.jF(),eh=null,fh=null;hg!==v();){var tg=hg.e();a:{if(tg instanceof ym){var Jg=tg,Gh=Jg.Ip,zg=Jg.Er;if(null!==Gh){var ig=Gh.w;t();var qh=new vo(new Em("this.#"+ig),Lm(a,zg,m)),gh=[new lo(qh),new hn(gn(m,ig,(t(),new M(!1)),!1,t().f).Ze,new Em("this.#"+ig))],Wg=J(new L,gh);var Uf=
-le(v(),Wg);break a}}if(tg instanceof Ln){var rh=new lo(Lm(a,tg,m)),Rh=O().c;Uf=new A(rh,Rh)}else{if(tg instanceof Kn){var Sg=tg,Hh=Sg.Qb,Xg=Sg.cd;if(null!==Hh){var jg=Hh.w;if(Xg instanceof te){var Ag=Xg.ca;if(Sg.yo){ip($a,jg);t();var Cf=[new lo(new vo(new Em("this.#"+jg),Lm(a,Ag,m))),new hn(gn(m,jg,(t(),new M(!1)),!1,t().f).Ze,new Em("this.#"+jg))],Bg=J(new L,Cf);Uf=le(v(),Bg)}else{var Lf=Xm(l,jg);b:{if(Lf instanceof M){var Df=Lf.k;if(Df instanceof Xn){var kg=Df;break b}}throw new rk("error when handling "+
-jg);}if(kg.xP||Ca.L(jg)){ip(Te,jg);t();var df=[new lo(new vo(new Em("this.#"+jg),Lm(a,Ag,m))),new hn(gn(m,jg,(t(),new M(!1)),!1,t().f).Ze,new Em("this.#"+jg))],Kg=J(new L,df);Uf=le(v(),Kg)}else{var Mf=new hn(gn(m,jg,(t(),new M(!1)),!1,t().f).Ze,Lm(a,Ag,m)),Vf=O().c;Uf=new A(Mf,Vf)}}break a}}}Uf=O().c}}for(var Cg=Uf.m();Cg.s();){var Ef=new A(Cg.t(),v());null===fh?eh=Ef:fh.r=Ef;fh=Ef}hg=hg.g()}var Wf=null===eh?v():eh,de=kn(m.Gn);if(de instanceof M)var Ee=de.k,Sh=O().c,hi=new A(Ee,Sh);else hi=O().c;
-var vi=b.RL();if(vi instanceof M){var Lg=vi.k.Fw;a:{if(null!==Lg){var Tg=Lg.ca;if(Tg instanceof lm){var cj=Tg.Dl,Cj=Tg.El;if(cj instanceof im){var Dj=cj.Ra;if(Dj instanceof A){var wi=Dj.A,Ki=Dj.r;if(null!==wi){var Yg=new M(wi);if(!Yg.b()){var dj=Yg.k.j();if(null!==dj){var ii=dj.Da;if(ii instanceof Wl){var ji=ii.w,Th=O().c;if((null===Th?null===Ki:Th.h(Ki))&&Cj instanceof om){var Ej=Cj.vo;if(Ej instanceof im){var ej=Ej.Ra,xd=Xl(ao(h,"unapply "+b.Sa()),ji),ke=new Yl(xd),Ie=O().c,Qf=new A(ke,Ie);t();
-var hh=ee=>{if(null!==ee){var Re=new M(ee);if(!Re.b()&&(Re=Re.k.j(),null!==Re)){ee=Re.Da;if(ee instanceof nm){var Ji=ee.Co;Re=ee.wn;if(Ji instanceof Wl&&(Ji=Ji.w,null!==Re))return new Em(Ji+"."+Re.w)}return Lm(a,ee,e)}}throw new x(ee);};if(ej===v())var lg=v();else{for(var Uh=ej.e(),Zg=new A(hh(Uh),v()),Vh=Zg,fj=ej.g();fj!==v();){var gj=fj.e(),Li=new A(hh(gj),v());Vh=Vh.r=Li;fj=fj.g()}lg=Zg}var Mi=new nn("unapply",Qf,new te(new Mo(lg))),hj=O().c;var Fj=new A(Mi,hj);break a}}}}}}}}}}throw new Am("invalid unapply method in "+
-b.Sa());}}else Fj=O().c;var Qj=La.b()?O().c:ln(Fm(m,La.k)),Ni=b.Sa(),Gj=Ub;a:for(var Hj;;)if(Gj.b()){Hj=v();break}else{var lk=Gj.e(),md=Gj.g();if(!1===!!b.Yx().L(lk))Gj=md;else for(var Ue=Gj,Jd=md;;){if(Jd.b())Hj=Ue;else{var uf=Jd.e();if(!1!==!!b.Yx().L(uf)){Jd=Jd.g();continue}for(var Dl=Jd,gl=new A(Ue.e(),v()),am=Ue.g(),xk=gl;am!==Dl;){var Ae=new A(am.e(),v());xk=xk.r=Ae;am=am.g()}for(var Ff=Dl.g(),vf=Ff;!Ff.b();){var Xf=Ff.e();if(!1===!!b.Yx().L(Xf)){for(;vf!==Ff;){var Ij=new A(vf.e(),v());xk=xk.r=
-Ij;vf=vf.g()}vf=Ff.g()}Ff=Ff.g()}vf.b()||(xk.r=vf);Hj=gl}break a}}var Rj=$a.ea(),hl=mn(Hj,Rj),El=mn(Te.ea(),Ub),on=mn(mn(mn(Qj,hi),Wb),Wf),Oi=w.ea();return new kp(Ni,Ub,hl,El,wb,jf,Ca,tf,od,gc,on,Oi,!b.iF().b(),Fj)}
-function po(a,b,c,d){for(var e=new Wo,g=new Wo,h=new Wo,k=new Wo,l=b;!l.b();){var m=l.e();a:{if(null!==m){var n=m.nb,r=m.eb,u=m.bg,w=m.Lg,y=m.ti,B=m.Uh;if(Qo()===n&&null!==r){var D=r.X,C=Bn(a,D,(w.b()?new im(O().c):w.o()).Ra,y,B);if(null===C)throw new x(C);var F=C.Aq,I=C.Bq,K=C.Ls,N=C.Ms,P=C.Ns,T=C.Ju;if(u===v())var aa=v();else{for(var Y=u.e(),S=new A(Y.j().X,v()),Z=S,ka=u.g();ka!==v();){var X=ka.e(),sa=new A(X.j().X,v());Z=Z.r=sa;ka=ka.g()}aa=S}var Ia=new wn(D,aa,F,I,K,N,T,P,c);lp(d,Ia);m.Vk.b()&&
-ip(h,Ia);break a}}if(null!==m){var Za=m.nb,Ga=m.eb,xa=m.bg,Ra=m.Lg,Ja=m.ti,La=m.Uh;if(mp()===Za&&null!==Ga){var pb=Ga.X,Fb=Bn(a,pb,(Ra.b()?new im(O().c):Ra.o()).Ra,Ja,La);if(null===Fb)throw new x(Fb);var Gb=Fb.Aq,Hb=Fb.Bq,tb=Fb.Ls,kb=Fb.Ms,gb=Fb.Ns;if(xa===v())var Vb=v();else{for(var bb=xa.e(),nb=new A(bb.j().X,v()),Tb=nb,ub=xa.g();ub!==v();){var Ub=ub.e(),$a=new A(Ub.j().X,v());Tb=Tb.r=$a;ub=ub.g()}Vb=nb}var cb=new $m(pb,Vb,Gb,Hb,tb,kb,Ja,gb,c);lp(d,cb);m.Vk.b()&&ip(k,cb);break a}}if(null!==m){var Na=
-m.nb,Ca=m.eb,Ba=m.bg,Oa=m.xj;if(np()===Na&&null!==Ca){var wa=Ca.X;if(Ba===v())var ea=v();else{for(var la=Ba.e(),Ka=new A(la.j().X,v()),Ua=Ka,ya=Ba.g();ya!==v();){var ib=ya.e(),Lb=new A(ib.j().X,v());Ua=Ua.r=Lb;ya=ya.g()}ea=Ka}op(d,wa,ea,Oa.b()?Jl():Oa.o());break a}}if(null!==m){var ec=m.nb,Mb=m.eb,Jb=m.bg,Kb=m.Lg,eb=m.sm,Wb=m.ti,mc=m.Uh;if(pp()===ec&&null!==Mb){var ua=Mb.X;b:{if(eb instanceof M){var Pa=eb.k;if(null!==Pa){var xb=Pa.Cr,Yb=Pa.Br;if(null!==xb){var zb=xb.Ra;if(null!==Yb){var Sb=Yb.Rk;
-t();var Ma=(Cd=>od=>{if(null!==od){var Va=od.i(),wb=od.j();if(Va instanceof M&&(Va=Va.k,null!==Va&&(Va=Va.w,null!==wb)))return G(new H,Va,wb.vc.ri)}if(null!==od&&(wb=od.i(),od=od.j(),t().f===wb&&null!==od&&(wb=od.vc,od=od.Da,od instanceof Wl)))return G(new H,od.w,wb.ri);throw new Am("Unexpected constructor parameters in "+Cd+".");})(ua);if(zb===v())var Ea=v();else{for(var ab=zb.e(),Db=new A(Ma(ab),v()),mb=Db,vb=zb.g();vb!==v();){var Ya=vb.e(),Wa=new A(Ma(Ya),v());mb=mb.r=Wa;vb=vb.g()}Ea=Db}var rb=
-new M(Ea);var pa=Sb;break b}}}}var Fa=t().f,Ib=O().c;rb=Fa;pa=Ib}var qb=rb,Nb=pa,fc=Bn(a,ua,(Kb.b()?new im(O().c):Kb.o()).Ra,Wb,mc);if(null===fc)throw new x(fc);var Ac=fc.Aq,tc=fc.Bq,vc=fc.Ls,sc=fc.Ms,uc=fc.Ns,lc=fc.Ju;if(Jb===v())var Wc=v();else{for(var Cc=Jb.e(),Dc=new A(Cc.j().X,v()),Ec=Dc,Ic=Jb.g();Ic!==v();){var Xc=Ic.e(),Sc=new A(Xc.j().X,v());Ec=Ec.r=Sc;Ic=Ic.g()}Wc=Dc}var oc=qp(m);b:{if(oc instanceof M){var qc=oc.k;if(null!==qc){var Tc=qc.Sd,Nc=qc.Qb,Pc=qc.qh,Oc=qc.cd;if(Oc instanceof te){var $c=
-Oc.ca;t();var Lc=new rp(!(Tc.b()||!Tc.o()),new sp(ua),Nc,Pc,(O(),new te($c)));var Zb=new M(Lc);break b}}}Zb=t().f}var ed=new Ym(ua,Wc,qb,Ac,tc,Zb,vc,mn(Nb,sc),Wb,lc,uc,c,m.Lg.b());lp(d,ed);m.Vk.b()&&ip(g,ed);break a}}if(null!==m){var $b=m.nb,Fc=m.eb,Yc=m.bg,nc=m.Lg,Ob=m.ti,cc=m.Uh;if(tp()===$b&&null!==Fc){var Gc=Fc.X,Bc=Bn(a,Gc,(nc.b()?new im(O().c):nc.o()).Ra,Ob,cc);if(null===Bc)throw new x(Bc);var qd=Bc.Aq,Gd=Bc.Bq;if(Yc===v())var cd=v();else{for(var rd=Yc.e(),Id=new A(rd.j().X,v()),Ha=Id,jc=Yc.g();jc!==
-v();){var Rb=jc.e(),Uc=new A(Rb.j().X,v());Ha=Ha.r=Uc;jc=jc.g()}cd=Id}var Rc=up(d,Gc,cd,qd,Gd);m.Vk.b()&&ip(e,Rc);break a}}throw new x(m);}l=l.g()}return new vp(e.ea(),g.ea(),h.ea(),k.ea())}function Fo(){this.TM=this.SM=null;Eo=this;this.SM=wp("9007199254740991");this.TM=wp("-9007199254740991")}Fo.prototype=new p;Fo.prototype.constructor=Fo;function Go(a){var b=Eo;return 0>=b.TM.gl(a)?0>=a.gl(b.SM):!1}Fo.prototype.$classData=q({PU:0},!1,"mlscript.JSBackend$",{PU:1,d:1});var Eo;
-function no(a,b){this.bH=null;this.ZU=b;if(null===a)throw null;this.bH=a}no.prototype=new p;no.prototype.constructor=no;function mo(a){var b=a.ZU;if(b instanceof lm)return!0;if(b instanceof hm){var c=b.Sh;if(!1===b.Sk)return mo(new no(a.bH,c))}return b instanceof em?mo(new no(a.bH,b.Ni)):!1}no.prototype.$classData=q({YU:0},!1,"mlscript.JSBackend$TermOps",{YU:1,d:1});function xp(){}xp.prototype=new p;xp.prototype.constructor=xp;function yp(){}yp.prototype=xp.prototype;function zp(){}zp.prototype=new p;
-zp.prototype.constructor=zp;function Pm(a){Ap();return new Wm(Bp(Cp(),a))}function Dp(a,b){return Ep(mg(b).ge(Fp().ce,new Um((c,d)=>{var e=G(new H,c,d);c=e.z;d=e.x;if(null!==d)return e=d.i(),d=d.Lc(),Gp(Gp(c,e instanceof gm?Hp(Fp(),"_"+d):e.xa()),hf(new E(d),-1+b.K()|0)?Fp().ce:Hp(Fp(),", "));throw new x(e);})),!0)}
-function Ip(a,b){return Ep(mg(b).ge(Fp().ce,new Um((c,d)=>{var e=G(new H,c,d);c=e.z;d=e.x;if(null!==d)return e=d.Lc(),Gp(Gp(c,Jp(d.i(),Kp().fz)),hf(new E(e),-1+b.K()|0)?Fp().ce:Hp(Fp(),", "));throw new x(e);})),!0)}zp.prototype.$classData=q({mV:0},!1,"mlscript.JSExpr$",{mV:1,d:1});var Lp;function Ap(){Lp||(Lp=new zp);return Lp}function Mp(){this.cH=null;Np=this;var a=new Op;v();var b=fl("^[A-Za-z$][A-Za-z0-9$]*$");a.SF=b;this.cH=a}Mp.prototype=new p;Mp.prototype.constructor=Mp;
-function Gm(a,b,c){return new Pp(b,new Em(c))}function Qp(a,b){return Rp(new Sp(a.cH.SF,pc(b)))?!Tp().RE.L(b):!1}function $l(a,b){return Qp(a,b)?b:Bp(Cp(),b)}Mp.prototype.$classData=q({pV:0},!1,"mlscript.JSField$",{pV:1,d:1});var Np;function cm(){Np||(Np=new Mp);return Np}
-function Up(a){if(a instanceof Do){fp();a=Vp(new sp("int"));var b=new sp("number");return a.Yb(b)}if(a instanceof Io)return fp(),Vp(new sp("string"));if(a instanceof Ho)return fp(),Vp(new sp("number"));if(a instanceof Jo)return Wp();throw new x(a);}
-function Xp(a){if(a instanceof Do){fp();a=Vp(new sp("Int"));var b=new sp("Num");a=a.Yb(b);b=new sp("Object");return a.Yb(b)}if(a instanceof Io)return fp(),a=Vp(new sp("Str")),b=new sp("Object"),a.Yb(b);if(a instanceof Ho)return fp(),a=Vp(new sp("Num")),b=new sp("Object"),a.Yb(b);if(a instanceof Jo)return fp(),Vp(new sp("Object"));throw new x(a);}function Yp(a){if(a instanceof Wl)return fp(),Vp(a);a=a.Kj().m();a=new ho(a,new z(b=>b.Jm().m()));return Zp($p(),a)}
-function aq(a,b){b.b()||(b=b.o(),a.Tl(b.Yg),a.Sl(b.Xg),t(),a.Om(new M(b.Wg)));return a}
-function bq(a){var b=id();try{if(0>a.Rm()){var c=cq(a),d=new eg(c,new z(I=>I.Yg)),e=dq(),g=eq(d,e);if(g.b())throw fq(new gq,b,t().f);a.Tl(g.o()|0)}if(0>a.Qm()){var h=cq(a),k=new eg(h,new z(I=>I.Xg)),l=dq(),m=hq(k,l);if(m.b())throw fq(new gq,b,t().f);a.Sl(m.o()|0)}var n=a.Pm();if(n.b()){var r=cq(a),u=new eg(r,new z(I=>I.Wg));je();var w=le(v(),u),y=Kl(w)}else{var B=n.o(),D=O().c;y=new A(B,D)}c=y;var C=c.K();if(!hf(new E(C),1))throw new rk("assertion failed: "+c);t();var F=new iq(a.Rm(),a.Qm(),c.e());
-return new M(F)}catch(I){if(I instanceof gq){a=I;if(a.Hg===b)return a.wj();throw a;}throw I;}}
-function jq(a){var b=id();try{var c=kq(a),d=new eg(c,new z(N=>N.Yg)),e=dq(),g=eq(d,e);if(g.b())throw fq(new gq,b,t().f);var h=g.o()|0,k=kq(a),l=new eg(k,new z(N=>N.Xg)),m=dq(),n=hq(l,m);if(n.b())throw fq(new gq,b,t().f);var r=n.o()|0,u=a.Pm();if(u.b()){var w=kq(a),y=new eg(w,new z(N=>N.Wg));je();var B=le(v(),y),D=Kl(B)}else{var C=u.o(),F=O().c;D=new A(C,F)}a=D;fp();var I=a.K();gp(0,hf(new E(I),1));t();var K=new iq(h,r,a.e());return new M(K)}catch(N){if(N instanceof gq){h=N;if(h.Hg===b)return h.wj();
-throw h;}throw N;}}function cq(a){a=a.Kj().m();return new ho(a,new z(b=>b.C().m()))}function kq(a){var b=a.Kj();return new ho(new lq(new A(a,b)),new z(c=>c.C().m()))}function mq(a){a.Tl(-1);a.Sl(-1);a.Om(t().f)}function nq(){}nq.prototype=new p;nq.prototype.constructor=nq;function oq(){}oq.prototype=nq.prototype;function mf(a){this.WM=a}mf.prototype=new p;mf.prototype.constructor=mf;
-function sf(a,b){fp();var c=b.K();gp(0,hf(new E(c),-1+a.WM.hv.K()|0));c=a.WM.hv.Ga(new z(d=>{var e=new nf(J(new L,[d]));d=v();e=e.hv;pq();if(e.K()!==(1+d.K()|0))throw dk("wrong number of arguments ("+d.K()+") for interpolated string with "+e.K()+" parts");d=e.m();e=qq().Oa;var g=d.t(),h=new rq;g=sq(pq(),g);for(h=tq(h,g);e.s();)g=e.t(),h.ha=""+h.ha+g,g=d.t(),g=sq(pq(),g),h.ha=""+h.ha+g;return new uq(h.ha)}));a=c.e();c=c.g();b=new vq(b,b,c);c=new Um((d,e)=>wq(d.wo,e));xq();b=yq(b,c);return new zq(b.Zb(a).ea())}
-mf.prototype.$classData=q({bW:0},!1,"mlscript.Message$MessageContext",{bW:1,d:1});function Aq(){return new Do(Bq())}
-function Cq(a,b,c){if(b<a.Ef&&hf(new E(hd(a.wc.a[b])),hd(46))){for(var d=1+b|0,e=d,g=O().c,h=!1,k=!1,l,m,n,r;;){if(e<a.Ef){var u=a.wc.a[e];if(Dq(u)){var w=new A(hd(u),g);e=1+e|0;g=w;k=!1;continue}if(hf(new E(hd(u)),hd(95))){var y=1+e|0,B=g.b();e=y;h=B;k=!0;continue}var D=Eq(g).m(),C=Qe(D,"","",""),F=h,I=k,K=e;l=C;m=F;n=I;r=K}else{var N=Eq(g).m(),P=Qe(N,"","",""),T=h,aa=k,Y=e;l=P;m=T;n=aa;r=Y}break}var S=l,Z=!!n,ka=r|0;if(m){var X=a.Je;Fq();var sa=sf(new mf(new nf(J(new L,["Leading separator is not allowed"]))),
-v());t();var Ia=Gq(a,-1+d|0,d),Za=G(new H,sa,new M(Ia)),Ga=O().c;X.n(Hq(0,new A(Za,Ga),!0,Iq()))}if(Z){var xa=a.Je;Fq();var Ra=sf(new mf(new nf(J(new L,["Trailing separator is not allowed"]))),v());t();var Ja=Gq(a,-1+ka|0,ka),La=G(new H,Ra,new M(Ja)),pb=O().c;xa.n(Hq(0,new A(La,pb),!0,Iq()))}var Fb=G(new H,""===S?t().f:(t(),new M(S)),ka);var Gb=Fb.z,Hb=Fb.x|0;if(t().f===Gb){var tb=a.Je;Jq();var kb=sf(new mf(new nf(J(new L,["Expect at least one digit after the decimal point"]))),v());t();var gb=Gq(a,
-1+b|0,2+b|0),Vb=G(new H,kb,new M(gb)),bb=O().c;tb.n(Kq(0,new A(Vb,bb),!0,Iq()));var nb="";var Tb=Hb}else{var ub=Fb.z,Ub=Fb.x|0;if(ub instanceof M)nb="."+ub.k,Tb=Ub;else throw new x(Fb);}}else nb="",Tb=b;var $a=nb,cb=Tb|0;if(cb<a.Ef)var Na=a.wc.a[cb],Ca=hf(new E(hd(Na)),hd(101))||hf(new E(hd(Na)),hd(69));else Ca=!1;if(Ca){var Ba=1+cb|0;if(Ba<a.Ef)var Oa=a.wc.a[Ba],wa=hf(new E(hd(Oa)),hd(43))||hf(new E(hd(Oa)),hd(45));else wa=!1;if(wa)var ea=a.wc.a[1+cb|0],la=2+cb|0;else{var Ka=1+cb|0;ea=43;la=Ka}for(var Ua=
-ea,ya=la,ib=ya,Lb=O().c,ec=!1,Mb=!1,Jb,Kb,eb,Wb;;){if(ib<a.Ef){var mc=a.wc.a[ib];if(Dq(mc)){var ua=new A(hd(mc),Lb);ib=1+ib|0;Lb=ua;Mb=!1;continue}if(hf(new E(hd(mc)),hd(95))){var Pa=1+ib|0,xb=Lb.b();ib=Pa;ec=xb;Mb=!0;continue}var Yb=Eq(Lb).m(),zb=Qe(Yb,"","",""),Sb=ec,Ma=Mb,Ea=ib;Jb=zb;Kb=Sb;eb=Ma;Wb=Ea}else{var ab=Eq(Lb).m(),Db=Qe(ab,"","",""),mb=ec,vb=Mb,Ya=ib;Jb=Db;Kb=mb;eb=vb;Wb=Ya}break}var Wa=Jb,rb=!!eb,pa=Wb|0;if(Kb){var Fa=a.Je;Fq();var Ib=sf(new mf(new nf(J(new L,["Leading separator is not allowed"]))),
-v());t();var qb=Gq(a,-1+ya|0,ya),Nb=G(new H,Ib,new M(qb)),fc=O().c;Fa.n(Hq(0,new A(Nb,fc),!0,Iq()))}if(rb){var Ac=a.Je;Fq();var tc=sf(new mf(new nf(J(new L,["Trailing separator is not allowed"]))),v());t();var vc=Gq(a,-1+pa|0,pa),sc=G(new H,tc,new M(vc)),uc=O().c;Ac.n(Hq(0,new A(sc,uc),!0,Iq()))}var lc=G(new H,""===Wa?t().f:(t(),new M(Wa)),pa);var Wc=lc.z,Cc=lc.x|0;if(t().f===Wc){var Dc=a.Je;Jq();var Ec=sf(new mf(new nf(J(new L,["Expect at least one digit after the exponent sign"]))),v());t();var Ic=
-Gq(a,-1+Cc|0,Cc),Xc=G(new H,Ec,new M(Ic)),Sc=O().c;Dc.n(Kq(0,new A(Xc,Sc),!0,Iq()));var oc="";var qc=Cc}else{var Tc=lc.z,Nc=lc.x|0;if(Tc instanceof M)oc="E"+hd(Ua)+Tc.k,qc=Nc;else throw new x(lc);}}else oc="",qc=cb;var Pc=oc,Oc=qc|0,$c=O();0===(1&$c.bt)<<24>>24&&0===(1&$c.bt)<<24>>24&&($c.aR=Lq(),$c.bt=(1|$c.bt)<<24>>24);var Lc=$c.aR;var Zb=new H,ed=""+c+$a+Pc,$b=new Mq;Nq($b,Oq(ed),ed.length);var Fc=Pq($b)<=Lc.ay.ur?Lc.ay:new Fi(Pq($b),Pi().qC);var Yc=new Qq($b,Fc);return G(Zb,new Ho(Yc),Oc)}
-function Rq(a,b,c){var d=a.Je;Jq();t();a=Gq(a,c,1+c|0);b=G(new H,b,new M(a));a=O().c;d.n(Kq(0,new A(b,a),!0,Iq()))}function Sq(a,b,c,d,e){a=G(new H,c,Gq(a,d,b));return new A(a,e)}
-function af(a,b,c){this.wc=this.eN=this.gN=null;this.Ef=0;this.fN=this.lH=this.kH=null;this.Zr=0;this.nW=a;this.Je=b;this.mW=c;a=a.os.BM;b=Tq();c=Tq();if(b===c)a=Oq(a);else if(b=new Uq(a),0<=b.Nh.length)a=new td(b.Nh.length),b.yc(a,0,2147483647);else{a=[];for(b=Vq(new Wq,new Xq(b.Nh));0<b.Rj;)c=b.t(),a.push(Eb(c));a=new td(new Uint16Array(a))}this.wc=a;this.Ef=this.wc.a.length;this.kH=Zp(fp().gv,J(new L,[hd(33),hd(35),hd(37),hd(38),hd(42),hd(43),hd(45),hd(47),hd(58),hd(60),hd(61),hd(62),hd(63),hd(64),
-hd(92),hd(94),hd(124),hd(126),hd(46)]));this.lH=Zp(fp().gv,J(new L,["\x3d\x3e","\x3d",":",";","#"]));this.fN=Zp(fp().gv,J(new L,["with","and","or","is","as"]))}af.prototype=new p;af.prototype.constructor=af;function Yq(a){return Zq($q(),a)||hf(new E(hd(a)),hd(95))?!0:hf(new E(hd(a)),hd(39))}function ar(a){return Yq(a)||Dq(a)||hf(new E(hd(a)),hd(39))}function Dq(a){return 48<=a&&57>=a}
-function br(a,b,c,d){for(;b<a.Ef&&d.n(hd(a.wc.a[b]));)c=new A(hd(a.wc.a[b]),c),b=1+b|0;a=Eq(c).m();return G(new H,Qe(a,"","",""),b)}
-function cr(a,b){if(b<a.Ef)if(48===a.wc.a[b])if((1+b|0)<a.Ef)switch(a.wc.a[1+b|0]){case 120:for(var c=2+b|0,d=c,e=O().c,g=!1,h=!1,k,l,m,n;;){if(d<a.Ef){var r=a.wc.a[d];if(Dq(r)||97<=r&&102>=r||65<=r&&70>=r){var u=new A(hd(r),e);d=1+d|0;e=u;h=!1;continue}if(hf(new E(hd(r)),hd(95))){var w=1+d|0,y=e.b();d=w;g=y;h=!0;continue}var B=Eq(e).m(),D=Qe(B,"","",""),C=g,F=h,I=d;k=D;l=C;m=F;n=I}else{var K=Eq(e).m(),N=Qe(K,"","",""),P=g,T=h,aa=d;k=N;l=P;m=T;n=aa}break}var Y=k,S=!!m,Z=n|0;if(l){var ka=a.Je;Fq();
-var X=sf(new mf(new nf(J(new L,["Leading separator is not allowed"]))),v());t();var sa=Gq(a,-1+c|0,c),Ia=G(new H,X,new M(sa)),Za=O().c;ka.n(Hq(0,new A(Ia,Za),!0,Iq()))}if(S){var Ga=a.Je;Fq();var xa=sf(new mf(new nf(J(new L,["Trailing separator is not allowed"]))),v());t();var Ra=Gq(a,-1+Z|0,Z),Ja=G(new H,xa,new M(Ra)),La=O().c;Ga.n(Hq(0,new A(Ja,La),!0,Iq()))}var pb=G(new H,""===Y?t().f:(t(),new M(Y)),Z),Fb=pb.z,Gb=pb.x|0;if(t().f===Fb){var Hb=a.Je;Jq();var tb=new mf(new nf(J(new L,["Expect at least one ",
-" digit"]))),kb=[pf(qf(),"hexadecimal")],gb=sf(tb,J(new L,kb));t();var Vb=Gq(a,c,2+c|0),bb=G(new H,gb,new M(Vb)),nb=O().c;Hb.n(Kq(0,new A(bb,nb),!0,Iq()));return G(new H,Aq(),Gb)}var Tb=pb.z,ub=pb.x|0;if(Tb instanceof M){var Ub=Tb.k;return G(new H,new Do(ir(jr(),Ub,16)),ub)}throw new x(pb);case 111:for(var $a=2+b|0,cb=$a,Na=O().c,Ca=!1,Ba=!1,Oa,wa,ea,la;;){if(cb<a.Ef){var Ka=a.wc.a[cb];if(48<=Ka&&55>=Ka){var Ua=new A(hd(Ka),Na);cb=1+cb|0;Na=Ua;Ba=!1;continue}if(hf(new E(hd(Ka)),hd(95))){var ya=1+
-cb|0,ib=Na.b();cb=ya;Ca=ib;Ba=!0;continue}var Lb=Eq(Na).m(),ec=Qe(Lb,"","",""),Mb=Ca,Jb=Ba,Kb=cb;Oa=ec;wa=Mb;ea=Jb;la=Kb}else{var eb=Eq(Na).m(),Wb=Qe(eb,"","",""),mc=Ca,ua=Ba,Pa=cb;Oa=Wb;wa=mc;ea=ua;la=Pa}break}var xb=Oa,Yb=!!ea,zb=la|0;if(wa){var Sb=a.Je;Fq();var Ma=sf(new mf(new nf(J(new L,["Leading separator is not allowed"]))),v());t();var Ea=Gq(a,-1+$a|0,$a),ab=G(new H,Ma,new M(Ea)),Db=O().c;Sb.n(Hq(0,new A(ab,Db),!0,Iq()))}if(Yb){var mb=a.Je;Fq();var vb=sf(new mf(new nf(J(new L,["Trailing separator is not allowed"]))),
-v());t();var Ya=Gq(a,-1+zb|0,zb),Wa=G(new H,vb,new M(Ya)),rb=O().c;mb.n(Hq(0,new A(Wa,rb),!0,Iq()))}var pa=G(new H,""===xb?t().f:(t(),new M(xb)),zb),Fa=pa.z,Ib=pa.x|0;if(t().f===Fa){var qb=a.Je;Jq();var Nb=new mf(new nf(J(new L,["Expect at least one "," digit"]))),fc=[pf(qf(),"octal")],Ac=sf(Nb,J(new L,fc));t();var tc=Gq(a,$a,2+$a|0),vc=G(new H,Ac,new M(tc)),sc=O().c;qb.n(Kq(0,new A(vc,sc),!0,Iq()));return G(new H,Aq(),Ib)}var uc=pa.z,lc=pa.x|0;if(uc instanceof M){var Wc=uc.k;return G(new H,new Do(ir(jr(),
-Wc,8)),lc)}throw new x(pa);case 98:for(var Cc=2+b|0,Dc=Cc,Ec=O().c,Ic=!1,Xc=!1,Sc,oc,qc,Tc;;){if(Dc<a.Ef){var Nc=a.wc.a[Dc],Pc=Nc;if(hf(new E(hd(Pc)),hd(48))||hf(new E(hd(Pc)),hd(49))){var Oc=new A(hd(Nc),Ec);Dc=1+Dc|0;Ec=Oc;Xc=!1;continue}if(hf(new E(hd(Nc)),hd(95))){var $c=1+Dc|0,Lc=Ec.b();Dc=$c;Ic=Lc;Xc=!0;continue}var Zb=Eq(Ec).m(),ed=Qe(Zb,"","",""),$b=Ic,Fc=Xc,Yc=Dc;Sc=ed;oc=$b;qc=Fc;Tc=Yc}else{var nc=Eq(Ec).m(),Ob=Qe(nc,"","",""),cc=Ic,Gc=Xc,Bc=Dc;Sc=Ob;oc=cc;qc=Gc;Tc=Bc}break}var qd=Sc,Gd=
-!!qc,cd=Tc|0;if(oc){var rd=a.Je;Fq();var Id=sf(new mf(new nf(J(new L,["Leading separator is not allowed"]))),v());t();var Ha=Gq(a,-1+Cc|0,Cc),jc=G(new H,Id,new M(Ha)),Rb=O().c;rd.n(Hq(0,new A(jc,Rb),!0,Iq()))}if(Gd){var Uc=a.Je;Fq();var Rc=sf(new mf(new nf(J(new L,["Trailing separator is not allowed"]))),v());t();var Cd=Gq(a,-1+cd|0,cd),od=G(new H,Rc,new M(Cd)),Va=O().c;Uc.n(Hq(0,new A(od,Va),!0,Iq()))}var wb=G(new H,""===qd?t().f:(t(),new M(qd)),cd),db=wb.z,Jc=wb.x|0;if(t().f===db){var Vc=a.Je;Jq();
-var Ta=new mf(new nf(J(new L,["Expect at least one "," digit"]))),kd=[pf(qf(),"binary")],ld=sf(Ta,J(new L,kd));t();var qe=Gq(a,Cc,2+Cc|0),Wd=G(new H,ld,new M(qe)),Rd=O().c;Vc.n(Kq(0,new A(Wd,Rd),!0,Iq()));return G(new H,Aq(),Jc)}var Me=wb.z,wc=wb.x|0;if(Me instanceof M){var Xb=Me.k;return G(new H,new Do(ir(jr(),Xb,2)),wc)}throw new x(wb);case 46:case 69:case 101:return Cq(a,1+b|0,"0");default:for(var gc=b,hc=O().c,gd=!1,kc=!1,ud,za,Qa,xc;;){if(gc<a.Ef){var yd=a.wc.a[gc];if(Dq(yd)){var be=new A(hd(yd),
-hc);gc=1+gc|0;hc=be;kc=!1;continue}if(hf(new E(hd(yd)),hd(95))){var yc=1+gc|0,Od=hc.b();gc=yc;gd=Od;kc=!0;continue}var sd=Eq(hc).m(),he=Qe(sd,"","",""),ue=gd,sg=kc,Se=gc;ud=he;za=ue;Qa=sg;xc=Se}else{var Kf=Eq(hc).m(),$e=Qe(Kf,"","",""),rf=gd,He=kc,Ze=gc;ud=$e;za=rf;Qa=He;xc=Ze}break}var jf=ud,tf=!!Qa,Te=xc|0;if(za){var hg=a.Je;Fq();var eh=sf(new mf(new nf(J(new L,["Leading separator is not allowed"]))),v());t();var fh=Gq(a,-1+b|0,b),tg=G(new H,eh,new M(fh)),Jg=O().c;hg.n(Hq(0,new A(tg,Jg),!0,Iq()))}if(tf){var Gh=
-a.Je;Fq();var zg=sf(new mf(new nf(J(new L,["Trailing separator is not allowed"]))),v());t();var ig=Gq(a,-1+Te|0,Te),qh=G(new H,zg,new M(ig)),gh=O().c;Gh.n(Hq(0,new A(qh,gh),!0,Iq()))}var Wg=G(new H,""===jf?t().f:(t(),new M(jf)),Te),Uf=Wg.z,rh=Wg.x|0;if(t().f===Uf){var Rh=a.Je;Jq();var Sg=new mf(new nf(J(new L,["Expect at least one "," digit"]))),Hh=[pf(qf(),"decimal")],Xg=sf(Sg,J(new L,Hh));t();var jg=Gq(a,b,2+b|0),Ag=G(new H,Xg,new M(jg)),Cf=O().c;Rh.n(Kq(0,new A(Ag,Cf),!0,Iq()));return G(new H,
-Aq(),rh)}var Bg=Wg.z,Lf=Wg.x|0;if(Bg instanceof M){var Df=Bg.k;return G(new H,new Do(ir(jr(),Df,10)),Lf)}throw new x(Wg);}else return G(new H,Aq(),1+b|0);else{for(var kg=b,df=O().c,Kg=!1,Mf=!1,Vf,Cg,Ef,Wf;;){if(kg<a.Ef){var de=a.wc.a[kg];if(Dq(de)){var Ee=new A(hd(de),df);kg=1+kg|0;df=Ee;Mf=!1;continue}if(hf(new E(hd(de)),hd(95))){var Sh=1+kg|0,hi=df.b();kg=Sh;Kg=hi;Mf=!0;continue}var vi=Eq(df).m(),Lg=Qe(vi,"","",""),Tg=Kg,cj=Mf,Cj=kg;Vf=Lg;Cg=Tg;Ef=cj;Wf=Cj}else{var Dj=Eq(df).m(),wi=Qe(Dj,"","",
-""),Ki=Kg,Yg=Mf,dj=kg;Vf=wi;Cg=Ki;Ef=Yg;Wf=dj}break}var ii=Vf,ji=!!Ef,Th=Wf|0;if(Cg){var Ej=a.Je;Fq();var ej=sf(new mf(new nf(J(new L,["Leading separator is not allowed"]))),v());t();var xd=Gq(a,-1+b|0,b),ke=G(new H,ej,new M(xd)),Ie=O().c;Ej.n(Hq(0,new A(ke,Ie),!0,Iq()))}if(ji){var Qf=a.Je;Fq();var hh=sf(new mf(new nf(J(new L,["Trailing separator is not allowed"]))),v());t();var lg=Gq(a,-1+Th|0,Th),Uh=G(new H,hh,new M(lg)),Zg=O().c;Qf.n(Hq(0,new A(Uh,Zg),!0,Iq()))}var Vh=G(new H,""===ii?t().f:(t(),
-new M(ii)),Th),fj=Vh.z;if(t().f===fj){var gj=a.Je;Jq();var Li=sf(new mf(new nf(J(new L,["Expect a numeric literal"]))),v());t();var Mi=Gq(a,b,1+b|0),hj=G(new H,Li,new M(Mi)),Fj=O().c;gj.n(Kq(0,new A(hj,Fj),!0,Iq()));return G(new H,Aq(),b)}var Qj=Vh.z,Ni=Vh.x|0;if(Qj instanceof M){var Gj=Qj.k,Hj;if(Hj=Ni<a.Ef){var lk=a.wc.a[Ni];Hj=hf(new E(hd(lk)),hd(46))||hf(new E(hd(lk)),hd(101))||hf(new E(hd(lk)),hd(69))}return Hj?Cq(a,Ni,Gj):G(new H,new Do(wp(Gj)),Ni)}throw new x(Vh);}else{var md=a.Je;Jq();var Ue=
-sf(new mf(new nf(J(new L,["Expect a numeric literal instead of end of input"]))),v());t();var Jd=Gq(a,b,1+b|0),uf=G(new H,Ue,new M(Jd)),Dl=O().c;md.n(Kq(0,new A(uf,Dl),!0,Iq()));return G(new H,Aq(),b)}}
-function kr(a,b){for(var c=!1,d=O().c;;)if(c)if(b<a.Ef)switch(c=a.wc.a[b],c){case 92:d=new A(hd(92),d);b=1+b|0;c=!1;break;case 34:d=new A(hd(34),d);b=1+b|0;c=!1;break;case 110:d=new A(hd(10),d);b=1+b|0;c=!1;break;case 116:d=new A(hd(9),d);b=1+b|0;c=!1;break;case 114:d=new A(hd(13),d);b=1+b|0;c=!1;break;case 98:d=new A(hd(8),d);b=1+b|0;c=!1;break;case 102:d=new A(hd(12),d);b=1+b|0;c=!1;break;default:var e=a.Je;Fq();var g=sf(new mf(new nf(J(new L,["Found invalid escape character"]))),v());t();var h=
-Gq(a,b,1+b|0);g=G(new H,g,new M(h));h=O().c;e.n(Hq(0,new A(g,h),!0,Iq()));d=new A(hd(c),d);b=1+b|0;c=!1}else return c=a.Je,Jq(),e=sf(new mf(new nf(J(new L,["Expect an escape character"]))),v()),t(),a=Gq(a,b,1+b|0),a=G(new H,e,new M(a)),e=O().c,c.n(Kq(0,new A(a,e),!0,Iq())),a=Eq(d).m(),G(new H,Qe(a,"","",""),b);else if(b<a.Ef)switch(c=a.wc.a[b],c){case 92:b=1+b|0;c=!0;break;case 34:case 10:return a=Eq(d).m(),G(new H,Qe(a,"","",""),b);default:d=new A(hd(c),d),b=1+b|0,c=!1}else return a=Eq(d).m(),G(new H,
-Qe(a,"","",""),b)}function Gq(a,b,c){return new iq(b,c,a.nW)}
-function lr(a){for(var b=0,c=O().c,d=O().c;;){if(b>=a.Ef)return jp(d);var e=a.wc.a[b],g=!1;if(32===e){for(var h=b,k=O().c;;)if(h<a.Ef&&hf(new E(hd(a.wc.a[h])),hd(32))){var l=new A(hd(a.wc.a[h]),k);h=1+h|0;k=l}else break;var m=Eq(k).m();Qe(m,"","","");var n=h,r=Sq(a,n,lf(),b,d);b=n;d=r}else if(44===e){var u=1+b|0,w=Sq(a,u,mr(),b,d);b=u;d=w}else if(59===e){var y=1+b|0,B=Sq(a,y,nr(),b,d);b=y;d=B}else if(34===e){var D=kr(a,1+b|0);if(null===D)throw new x(D);var C=D.i(),F=D.Lc(),I=or(fp(),a.wc),K=pr(new qr(I),
-F);if(hf(new E(K),new M(hd(34))))var N=1+F|0;else Rq(a,sf(new mf(new nf(J(new L,["unclosed quotation mark"]))),v()),b),N=F;var P=Sq(a,N,new rr(new Io(C)),b,d);b=N;d=P}else{if(47===e){g=!0;var T=or(fp(),a.wc);if(pr(new qr(T),1+b|0).L(hd(47))){for(var aa=2+b|0,Y=O().c;;)if(aa<a.Ef&&sr(new E(hd(a.wc.a[aa])),hd(10))){var S=new A(hd(a.wc.a[aa]),Y);aa=1+aa|0;Y=S}else break;var Z=Eq(Y).m(),ka=Qe(Z,"","",""),X=aa,sa=Sq(a,X,new tr(ka),b,d);b=X;d=sa;continue}}if(g)var Ia=or(fp(),a.wc),Za=pr(new qr(Ia),1+b|
-0).L(hd(42));else Za=!1;if(Za){var Ga=2+b|0,xa=0;xa=47;var Ra=0;Ra=42;for(var Ja=Ga,La=O().c;;){if(Ja<a.Ef){var pb=a.wc.a[Ja],Fb=sr(new E(hd(xa)),hd(42))?!0:sr(new E(hd(Ra)),hd(47));xa=Ra;Ra=pb;var Gb=Fb}else Gb=!1;if(Gb){var Hb=new A(hd(a.wc.a[Ja]),La);Ja=1+Ja|0;La=Hb}else break}var tb=Eq(La).m(),kb=Qe(tb,"","",""),gb=Ja,Vb=Sq(a,gb,new tr(ur(Q(),kb)),b,d);b=gb;d=Vb}else{var bb=wl(Al(),e);if(!bb.b()){var nb=bb.o();if(nb instanceof te){var Tb=1+b|0,ub=Sq(a,1+b|0,new vr(nb.ca),b,d);b=Tb;d=ub;continue}}var Ub=
-wl(Al(),e);if(!Ub.b()){var $a=Ub.o();if($a instanceof me){var cb=1+b|0,Na=Sq(a,1+b|0,new wr($a.ia),b,d);b=cb;d=Na;continue}}if(10===e){for(var Ca=1+b|0,Ba=Ca,Oa=O().c;;){if(Ba<a.Ef)var wa=a.wc.a[Ba],ea=hf(new E(hd(wa)),hd(32))||hf(new E(hd(wa)),hd(10));else ea=!1;if(ea){var la=new A(hd(a.wc.a[Ba]),Oa);Ba=1+Ba|0;Oa=la}else break}var Ka=Eq(Oa).m(),Ua=Qe(Ka,"","",""),ya=Ba,ib=xr(new yr(new zr(Ua),new z(Rc=>sr(new E(hd(Eb(Rc))),hd(10))))),Lb=c.Og();if((Lb.b()||(Lb.o()|0)<ib)&&0<ib){var ec=new A(ib,c),
-Mb=G(new H,Ar(),Gq(a,Ca,ya)),Jb=new A(Mb,d);b=ya;c=ec;d=Jb}else{for(var Kb=c;;)if(Kb.b()?0:(Kb.e()|0)>ib)Kb=Kb.g();else break;var eb=Kb,Wb=c.K()-eb.K()|0,mc=eb.Og(),ua=mc.b()||(mc.o()|0)<ib?0<ib:!1,Pa=ua?new A(ib,eb):eb;if(a.mW){fp();var xb=Br(Cr(),a.wc,b),Yb=Dr(Cr(),xb,0,10),zb=Yb.a.length,Sb=new (Nd(na).Ja)(zb);if(0<zb){var Ma=0;if(Yb instanceof jd)for(var Ea=Yb;Ma<zb;)Sb.a[Ma]=Er(Eb(Ea.a[Ma])),Ma=1+Ma|0;else if(Yb instanceof zd)for(var ab=Yb;Ma<zb;)Sb.a[Ma]=Er(Eb(ab.a[Ma])),Ma=1+Ma|0;else if(Yb instanceof
-Dd)for(var Db=Yb;Ma<zb;)Sb.a[Ma]=Er(Eb(Db.a[Ma])),Ma=1+Ma|0;else if(Yb instanceof Ad)for(var mb=Yb;Ma<zb;){var vb=mb.a[Ma];Sb.a[Ma]=Er(Eb(new fb(vb.W,vb.Z)));Ma=1+Ma|0}else if(Yb instanceof Bd)for(var Ya=Yb;Ma<zb;)Sb.a[Ma]=Er(Eb(Ya.a[Ma])),Ma=1+Ma|0;else if(null!==Yb)for(;Ma<zb;)Sb.a[Ma]=Er(Eb(hd(Yb.a[Ma]))),Ma=1+Ma|0;else if(Yb instanceof vd)for(var Wa=Yb;Ma<zb;)Sb.a[Ma]=Er(Eb(Wa.a[Ma])),Ma=1+Ma|0;else if(Yb instanceof wd)for(var rb=Yb;Ma<zb;)Sb.a[Ma]=Er(Eb(rb.a[Ma])),Ma=1+Ma|0;else if(Yb instanceof
-pd)for(var pa=Yb;Ma<zb;)Sb.a[Ma]=Er(Eb(pa.a[Ma])),Ma=1+Ma|0;else throw new x(Yb);}var Fa=Fr(Sb),Ib="dbg: "+Qe(Fa,"","","")+"...";Af(Bf(),Ib+"\n");Af(Bf(),new Nn(c,ib,eb,Wb,ua,Pa)+"\n")}if(0<Wb){var qb=ua?G(new H,Ar(),Gq(a,Ca,ya)):G(new H,Gr(),Gq(a,b,ya));O();for(var Nb=new Wo,fc=0;fc<Wb;){var Ac=G(new H,Hr(),Gq(a,-1+Ca|0,ya));ip(Nb,Ac);fc=1+fc|0}var tc=Nb.ea(),vc=Fl(d,tc),sc=new A(qb,vc)}else{var uc=G(new H,Gr(),Gq(a,b,ya));sc=new A(uc,d)}b=ya;c=Pa;d=sc}}else if(Yq(e)){for(var lc=b,Wc=O().c;;)if(lc<
-a.Ef&&ar(a.wc.a[lc])){var Cc=new A(hd(a.wc.a[lc]),Wc);lc=1+lc|0;Wc=Cc}else break;var Dc=Eq(Wc).m(),Ec=Qe(Dc,"","",""),Ic=lc,Xc=Ir().dN.L(Ec)?new Jr(Ec):new Kr(Ec,a.fN.L(Ec)),Sc=Sq(a,Ic,Xc,b,d);b=Ic;d=Sc}else if(a.kH.L(hd(e))){var oc=br(a,b,O().c,a.kH);if(null===oc)throw new x(oc);var qc=oc.i(),Tc=oc.Lc();if("."===qc&&Tc<a.Ef){var Nc=a.wc.a[Tc];if(Yq(Nc)){for(var Pc=Tc,Oc=O().c;;)if(Pc<a.Ef&&ar(a.wc.a[Pc])){var $c=new A(hd(a.wc.a[Pc]),Oc);Pc=1+Pc|0;Oc=$c}else break;var Lc=Eq(Oc).m(),Zb=Qe(Lc,"","",
-""),ed=Pc,$b=Sq(a,ed,new Lr(Zb),b,d);b=ed;d=$b}else if(hf(new E(hd(Nc)),hd(48))&&!((1+Tc|0)<a.Ef&&Dq(a.wc.a[1+Tc|0]))||48<Nc&&57>=Nc){for(var Fc=Tc,Yc=O().c;;)if(Fc<a.Ef&&Dq(a.wc.a[Fc])){var nc=new A(hd(a.wc.a[Fc]),Yc);Fc=1+Fc|0;Yc=nc}else break;var Ob=Eq(Yc).m(),cc=Qe(Ob,"","",""),Gc=Fc,Bc=Sq(a,Gc,new Lr(cc),b,d);b=Gc;d=Bc}else{var qd=Sq(a,Tc,a.lH.L(qc)?new Jr(qc):new Kr(qc,!0),b,d);b=Tc;d=qd}}else{var Gd=Sq(a,Tc,a.lH.L(qc)?new Jr(qc):new Kr(qc,!0),b,d);b=Tc;d=Gd}}else if(Dq(e)){var cd=cr(a,b);if(null===
-cd)throw new x(cd);var rd=cd.Lc(),Id=Sq(a,rd,new rr(cd.i()),b,d);b=rd;d=Id}else{var Ha=new mf(new nf(J(new L,["unexpected character '","'"]))),jc=[pf(qf(),Er(e))];Rq(a,sf(Ha,J(new L,jc)),b);var Rb=1+b|0,Uc=Sq(a,1+b|0,Mr(),b,d);b=Rb;d=Uc}}}}}
-function Er(a){switch(a){case 8:return"\\b";case 9:return"\\t";case 10:return"\\n";case 12:return"\\f";case 13:return"\\r";case 34:return'\\"';case 39:return"\\'";case 92:return"\\\\";default:return Nr($q(),a)?"\\0"+(+(a>>>0)).toString(8):String.fromCharCode(a)}}
-function Ye(a){if(0===(2&a.Zr)<<24>>24&&0===(2&a.Zr)<<24>>24){0===(1&a.Zr)<<24>>24&&0===(1&a.Zr)<<24>>24&&(a.gN=lr(a),a.Zr=(1|a.Zr)<<24>>24);a:for(var b=a.gN,c=!1,d=O().c,e=O().c;;){var g=!1,h=null,k=b;if(k instanceof A){g=!0;h=k;var l=h.A,m=h.r;if(null!==l){var n=l.i(),r=l.j();if(n instanceof vr){var u=G(new H,n.Tw,r),w=G(new H,u,e),y=new A(w,d),B=O().c;b=m;c=!1;d=y;e=B;continue}}}if(g){var D=h.A,C=h.r;if(null!==D){var F=D.i(),I=D.j();if(F instanceof wr){var K=F.fw,N=!1,P=null,T=d;if(T instanceof
-A){N=!0;P=T;var aa=P.A;if(null!==aa){var Y=aa.i();if(null!==Y){var S=Y.i();if(pl()===S&&sr(new E(K),pl())){var Z=new wr(pl()),ka=Or(I),X=G(new H,Z,ka);b=new A(X,b);c=!1;continue}}}}if(N){var sa=P.A,Ia=P.r;if(null!==sa){var Za=sa.i(),Ga=sa.j();if(null!==Za){var xa=Za.i();if(pl()===xa)if(hf(new E(K),pl()))b:{for(var Ra=e;!Ra.b();){var Ja=Ra.e();c:{if(null!==Ja){var La=Ja.i();if(lf()===La||Gr()===La){var pb=!0;break c}}pb=!1}if(!pb){var Fb=!1;break b}Ra=Ra.g()}Fb=!0}else Fb=!1;else Fb=!1;if(Fb){b=C;
-c=!1;d=Ia;e=Ga;continue}}}}if(N){var Gb=P.A,Hb=P.r;if(null!==Gb){var tb=Gb.i(),kb=Gb.j();if(null!==tb){var gb=tb.i(),Vb=tb.j();if(sr(new E(gb),K)){var bb=a.Je;Jq();var nb=new mf(new nf(J(new L,["Mistmatched closing ",""]))),Tb=[pf(qf(),K.Sa())],ub=sf(nb,J(new L,Tb));t();var Ub=G(new H,ub,new M(I)),$a=new mf(new nf(J(new L,["does not correspond to opening ",""]))),cb=[pf(qf(),gb.Sa())],Na=sf($a,J(new L,cb));t();var Ca=G(new H,Na,new M(Vb)),Ba=O().c;bb.n(Kq(0,new A(Ub,new A(Ca,Ba)),!0,Pr()))}var Oa=
-jp(e),wa=new Qr(gb,Oa,Rr(new iq(Vb.Xg,Vb.Xg,Vb.Wg),Or(I))),ea=Rr(Vb,I),la=G(new H,wa,ea),Ka=new A(la,kb);b=C;c=!0;d=Hb;e=Ka;continue}}}var Ua=O().c;if(null===Ua?null===T:Ua.h(T)){var ya=a.Je;Jq();var ib=new mf(new nf(J(new L,["Unexpected closing ",""]))),Lb=[pf(qf(),K.Sa())],ec=sf(ib,J(new L,Lb));t();var Mb=G(new H,ec,new M(I)),Jb=O().c;ya.n(Kq(0,new A(Mb,Jb),!0,Pr()));b=C;c=!1;continue}throw new x(T);}}}if(g){var Kb=h.A,eb=h.r;if(null!==Kb){var Wb=Kb.i(),mc=Kb.j();if(Ar()===Wb){var ua=new vr(pl()),
-Pa=G(new H,ua,mc);b=new A(Pa,eb);c=!1;continue}}}if(g){var xb=h.A,Yb=h.r;if(null!==xb){var zb=xb.i(),Sb=xb.j();if(Hr()===zb){var Ma=new wr(pl()),Ea=G(new H,Ma,Sb);b=new A(Ea,Yb);c=!1;continue}}}if(g){var ab=h.A,Db=h.r;if(null!==ab){var mb=ab.i(),vb=ab.j();if(mb instanceof Kr){var Ya=mb,Wa=Ya.Qf;if("\x3c"===Ya.Df&&!0===Wa&&c){var rb=new vr(ol()),pa=G(new H,rb,vb);b=new A(pa,Db);c=!1;continue}}}}if(g){var Fa=h.A,Ib=h.r;if(null!==Fa){var qb=Fa.i(),Nb=Fa.j();if(qb instanceof Kr){var fc=qb,Ac=fc.Qf;if("\x3e"===
-fc.Df)if(!0===Ac)if(c){var tc=d;b:{if(tc instanceof A){var vc=tc.A;if(null!==vc){var sc=vc.i();if(null!==sc){var uc=sc.i();if(ol()===uc){var lc=!0;break b}}}}lc=!1}}else lc=!1;else lc=!1;else lc=!1;if(lc){var Wc=new wr(ol()),Cc=G(new H,Wc,Nb);b=new A(Cc,Ib);c=!1;continue}}}}if(g){var Dc=h.A,Ec=h.r;if(null!==Dc){var Ic=Dc.i(),Xc=Dc.j();if(Ic instanceof Kr){var Sc=Ic,oc=Sc.Df;if(!0===Sc.Qf){if(c)b:{for(var qc=0,Tc=oc.length;qc<Tc;){if(62!==oc.charCodeAt(qc)){var Nc=!1;break b}qc=1+qc|0}Nc=!0}else Nc=
-!1;if(Nc&&1<oc.length){var Pc=d;b:{if(Pc instanceof A){var Oc=Pc.A;if(null!==Oc){var $c=Oc.i();if(null!==$c){var Lc=$c.i();if(ol()===Lc){var Zb=!0;break b}}}}Zb=!1}}else Zb=!1}else Zb=!1;if(Zb){var ed=new wr(ol()),$b=Or(Xc),Fc=G(new H,ed,$b),Yc=new Kr(Sr(Q(),oc,1),!0),nc=G(new H,Yc,Xc);b=new A(Fc,new A(nc,Ec));c=!1;continue}}}}if(g){var Ob=h.A,cc=h.r;if(null!==Ob){var Gc=Ob.i(),Bc=Ob.j();if(Gc instanceof Kr){var qd=Gc,Gd=qd.Qf;if("\x3e"===qd.Df&&!0===Gd&&c){var cd=a.Je;Fq();var rd=sf(new mf(new nf(J(new L,
-["This looks like an angle bracket, but it does not close any angle bracket section"]))),v());t();var Id=G(new H,rd,new M(Bc)),Ha=sf(new mf(new nf(J(new L,["Add spaces around it if you intended to use `\x3c` as an operator"]))),v()),jc=t().f,Rb=G(new H,Ha,jc),Uc=O().c;cd.n(Hq(0,new A(Id,new A(Rb,Uc)),!0,Pr()));var Rc=G(new H,qd,Bc),Cd=new A(Rc,e);b=cc;c=!1;e=Cd;continue}}}}if(g){var od=h.A,Va=h.r;if(null!==od){var wb=od.i(),db=od.j();if(wb&&wb.$classData&&wb.$classData.pb.xn){var Jc=wb,Vc=!(lf()===
-Jc||Gr()===Jc),Ta=G(new H,Jc,db),kd=new A(Ta,e);b=Va;c=Vc;e=kd;continue}}}var ld=O().c;if(null===ld?null===k:ld.h(k)){var qe=!1,Wd=null,Rd=d;if(Rd instanceof A){qe=!0;Wd=Rd;var Me=Wd.A;if(null!==Me){var wc=Me.i();if(null!==wc){var Xb=wc.i(),gc=wc.j();if(pl()===Xb){var hc=new wr(pl()),gd=G(new H,hc,gc),kc=O().c;b=new A(gd,kc);c=!1;continue}}}}if(qe){var ud=Wd.A;if(null!==ud){var za=ud.i(),Qa=ud.j();if(null!==za){var xc=za.i(),yd=za.j(),be=a.Je;Jq();var yc=new mf(new nf(J(new L,["Unmatched opening ",
-""]))),Od=[pf(qf(),xc.Sa())],sd=sf(yc,J(new L,Od));t();var he=G(new H,sd,new M(yd));if(hf(new E(xc),ol()))var ue=sf(new mf(new nf(J(new L,["Note that `\x3c` without spaces around it is considered as an angle bracket and not as an operator"]))),v()),sg=t().f,Se=G(new H,ue,sg),Kf=O().c,$e=new A(Se,Kf);else $e=O().c;be.n(Kq(0,new A(he,$e),!0,Pr()));var rf=jp(Fl(e,Qa));break a}}}var He=O().c;if(null===He?null===Rd:He.h(Rd)){rf=jp(e);break a}throw new x(Rd);}throw new x(k);}a.eN=rf;a.Zr=(2|a.Zr)<<24>>
-24}return a.eN}af.prototype.$classData=q({kW:0},!1,"mlscript.NewLexer",{kW:1,d:1});function Tr(){this.dN=null;Ur=this;this.dN=Zp(fp().gv,J(new L,"if then else case fun val var of let rec in mut declare class trait mixin interface extends override super new namespace module type where forall exists in out null undefined abstract constructor virtual".split(" ")))}Tr.prototype=new p;Tr.prototype.constructor=Tr;
-function Vr(a,b){if(null!==b&&(a=b.i(),lf()===a))return" ";if(null!==b&&(a=b.i(),mr()===a))return",";if(null!==b&&(a=b.i(),nr()===a))return";";if(null!==b&&(a=b.i(),Gr()===a))return"\u21b5";if(null!==b&&(a=b.i(),Ar()===a))return"\u2192";if(null!==b&&(a=b.i(),Hr()===a))return"\u2190";if(null!==b&&(a=b.i(),Mr()===a))return"\x3cerror\x3e";if(null!==b&&(a=b.i(),a instanceof rr))return a.Dw.vi;if(null!==b&&(a=b.i(),a instanceof Jr&&(a=a.Ta,null!==a)))return"#"+a;if(null!==b&&(a=b.i(),a instanceof Kr&&
-(a=a.Df,null!==a)))return a;if(null!==b&&(a=b.i(),a instanceof Lr&&(a=a.Xw,null!==a)))return"."+a;if(null!==b&&(a=b.i(),a instanceof vr))return b=tl(a.Tw),String.fromCharCode(b);if(null!==b&&(a=b.i(),a instanceof wr))return b=ul(a.fw),String.fromCharCode(b);if(null!==b){var c=b.i();if(c instanceof Qr&&(a=c.Tc,c=c.$d,pl()===a))return b=tl(a),b=String.fromCharCode(b),c=Wr(0,c),a=ul(a),""+b+c+String.fromCharCode(a)}if(null!==b&&(a=b.i(),a instanceof Qr))return b=a.Tc,c=a.$d,a=tl(b),a=String.fromCharCode(a),
-c=Wr(0,c),b=ul(b),""+a+c+String.fromCharCode(b);if(null!==b&&(a=b.i(),a instanceof tr&&(a=a.sC,null!==a)))return"/*"+a+"*/";throw new x(b);}function Wr(a,b){a=b.m();a=new eg(a,new z(c=>Vr(Ir(),c)));return Qe(a,"|","|","|")}Tr.prototype.$classData=q({lW:0},!1,"mlscript.NewLexer$",{lW:1,d:1});var Ur;function Ir(){Ur||(Ur=new Tr);return Ur}
-function Xr(a,b,c,d,e){Yr(a,new U(()=>{var h=e.Gm,k=Zr(b);k=$r(k)?Qe(k,"(",",",")"):as(k)?Zr(b):"("+Zr(b)+")";return"@ "+h+k+"    [at l."+d.Nl+"]"}));try{a.Rd=1+a.Rd|0;var g=c.n(void 0)}finally{a.Rd=-1+a.Rd|0}Yr(a,new U(()=>"\x3d "+g));return g}function bs(a){if(!a.pz){if(!a.pz){var b=cs(a.qz);b.b()?b=R():(b=b.o().j(),b=new M(new iq(b.Xg,b.Xg,b.Wg)));a.MD=b.b()?a.LD:b;a.pz=!0}a.qz=null}return a.MD}function ds(a){a=a.Fl.Og();if(a.b())return R();a=a.o();return new M(a.j())}
-function es(a,b){var c=sf(new mf(new nf(J(new L,["Expected an expression; found a 'then'/'else' clause instead"]))),v());b=G(new H,c,b);c=O().c;wf(a,new A(b,c));return fs(a)}function fs(a){var b=new Jo(!0);a=bs(a);return aq(b,a)}
-var ls=function gs(a,b){var d=hs(a);return d instanceof A&&(d=d.A,null!==d&&(d=d.i(),mr()===d))?(is(a,new ff(374),new gf("otherParents")),d=js(a,ks().Rp.n(hd(44))|0,b,new ff(375)),a=gs(a,b),new A(d,a)):O().c},os=function ms(a){var c=hs(a);if(c instanceof A){var d=c.A;if(null!==d&&(c=d.i(),d=d.j(),c instanceof Kr)){var e=c.Df;if(!1===c.Qf){is(a,new ff(698),new gf("getIdents"));c=new ns((t(),new me(e)),t().f);t();c=aq(c,new M(d));d=hs(a);if(d instanceof A&&(d=d.A,null!==d&&(d=d.i(),mr()===d)))return is(a,
-new ff(702),new gf("getIdents")),a=ms(a),new A(c,a);a=O().c;return new A(c,a)}}}return O().c};function ps(a,b,c){if(a.b())return G(new H,b,c);c instanceof te&&$n();if(c instanceof me){var d=c.ia;if(null!==d)return c=d.vc,d=d.Da,t(),a=new ws(c,new pm(jp(new A(d,a)))),G(new H,b,new me(a))}throw new x(c);}function xs(a,b,c,d,e,g,h,k){a.ND=b;a.qz=c;a.Lw=d;a.Xt=e;a.Wt=g;a.LD=h;a.KD=k;a.Jw=0;a.Rd=0;a.Fl=c;a.Kw=ys(a).mH}
-function zs(){this.qz=this.ND=this.Hw=this.MD=this.Iw=null;this.Lw=!1;this.Xt=null;this.Wt=!1;this.KD=this.LD=null;this.Rd=this.Jw=0;this.Kw=this.Fl=null;this.pz=!1}zs.prototype=new p;zs.prototype.constructor=zs;function As(){}As.prototype=zs.prototype;function Bs(a){null===a.Iw&&null===a.Iw&&(a.Iw=new Cs(a));return a.Iw}function ys(a){null===a.Hw&&null===a.Hw&&(a.Hw=new Ds(a));return a.Hw}function Es(a){var b=new Wl("_$"+a.Jw);a.Jw=1+a.Jw|0;return b}function Fs(a,b,c){Gs(ks(),c)||a.Xt.n(Zr(b))}
-function wf(a,b){Gs(ks(),!1)||a.Xt.n(Kq(Jq(),b,!0,Pr()))}function Yr(a,b){a.VP(new U(()=>""+Hs(Q(),"\u2502 ",a.Rd)+Zr(b)))}
-function Is(a,b){var c=b.n(a);for(b=ef(a,new ff(145),new gf("concludeWith"));;){if(b.b())d=!1;else if(d=b.e(),hf(new E(d.i()),lf())||hf(new E(d.i()),Gr())){is(a,new ff(145),new gf("concludeWith"));var d=!0}else d=!1;if(d)b=b.g();else break}var e=b;a:{if(e instanceof A&&(d=e.A,null!==d)){b=d.i();for(d=d.j();;){if(e.b())g=!1;else{g=e.e().i();var g=hf(new E(g),lf())}if(g)e=e.g();else break}e=e.Og();b=e.b()?G(new H,b,d):e.o();if(null===b)throw new x(b);d=b.i();b=b.j();e=new mf(new nf(J(new L,["Unexpected ",
-" here"])));d=[pf(qf(),d.yb())];d=sf(e,J(new L,d));t();b=G(new H,d,new M(b));d=O().c;wf(a,new A(b,d));break a}b=O().c;if(null===b?null!==e:!b.h(e))throw new x(e);}Yr(a,new U(()=>"Concluded with "+c));return c}function Js(a,b){a.Fl=b;a.Kw=ys(a).mH}function ef(a,b,c){for(a.Wt&&Yr(a,new U(()=>{var d="? "+c.Gm+"\t\tinspects ";var e=Wr(Ir(),Ks(a.Fl,5))+(0<a.Fl.$a(5)?"...":"");return d+e+"    [at l."+b.Nl+"]"}));;)if(a.Fl.b()?0:a.Fl.e().i()instanceof tr)is(a,b,c);else break;return a.Fl}
-function is(a,b,c){a.Wt&&Yr(a,new U(()=>"! "+c.Gm+"\t\tconsumes "+Wr(Ir(),Ks(a.Fl,1))+"    [at l."+b.Nl+"]"));var d=Ls(new Ms(a.Fl));Js(a,d.b()?O().c:d.o())}
-function Ns(a,b,c,d,e,g){var h=id();try{var k=new U(()=>new Ul(b,c,d)),l=new ff(186),m=new gf("skip");Yr(a,new U(()=>{var ka=m.Gm,X=Zr(k);X=$r(X)?Qe(X,"(",",",")"):as(X)?Zr(k):"("+Zr(k)+")";return"@ "+ka+X+"    [at l."+l.Nl+"]"}));try{a.Rd=1+a.Rd|0;Os(fp(),!c.L(b));var n=ef(a,new ff(188),new gf("skip_res"));a:{if(n instanceof A){var r=n.A;if(null!==r){var u=r.i(),w=r.j();if(c.L(u))throw is(a,new ff(191),new gf("skip_res")),fq(new gq,h,Ns(a,b,c,d,e,g));if(sr(new E(u),b)){if(!Gs(ks(),g)){var y=new mf(new nf(J(new L,
-["Expected ","; found "," instead"]))),B=[pf(qf(),b.yb()),pf(qf(),u.yb())],D=sf(y,J(new L,B));t();var C=G(new H,D,new M(w)),F=Zr(e);wf(a,new A(C,F))}var I=G(new H,!1,(t(),new M(w)))}else I=G(new H,!0,(t(),new M(w)));break a}}var K=O().c;if(null===K?null===n:K.h(n)){if(!d&&!Gs(ks(),g)){var N=new mf(new nf(J(new L,["Expected ","; found end of input instead"]))),P=[pf(qf(),b.yb())],T=sf(N,J(new L,P)),aa=bs(a),Y=G(new H,T,aa),S=Zr(e);wf(a,new A(Y,S))}I=G(new H,d,t().f)}else throw new x(n);}is(a,new ff(204),
-new gf("skip"));var Z=I}finally{a.Rd=-1+a.Rd|0}Yr(a,new U(()=>"\x3d "+Z));return Z}catch(ka){if(ka instanceof gq){a=ka;if(a.Hg===h)return a.wj();throw a;}throw ka;}}function Ps(){fp();var a=[lf()];a=J(new L,a);return Zp(0,a)}
-function cf(a){var b=Qs(a,!1,!1),c=h=>{var k=!1,l=null;if(h instanceof te)return l=h.ca,k=sf(new mf(new nf(J(new L,["Unexpected 'then'/'else' clause"]))),v()),l=l.C(),k=G(new H,k,l),l=O().c,wf(a,new A(k,l)),fs(a);if(h instanceof me&&(k=!0,l=h,h=l.ia,h instanceof Rs)||k&&(h=l.ia,h instanceof Ln))return h;if(k&&(k=l.ia,k instanceof zo))return k;$n()};if(b===v())c=v();else{var d=b.e(),e=d=new A(c(d),v());for(b=b.g();b!==v();){var g=b.e();g=new A(c(g),v());e=e.r=g;b=b.g()}c=d}return new Ss(c)}
-function Ts(a){var b=hs(a);if(b instanceof A&&(b=b.A,null!==b)){var c=b.i();if(c instanceof Qr){var d=c.Tc;b=c.$d;if(pl()===d){is(a,new ff(241),new gf("typingUnitMaybeIndented"));t();d=new M(c.Ig);c=c.yb();a=new Us(a,b,d,c);var e=cf(a);for(b=ef(a,new ff(145),new gf("concludeWith"));;)if(b.b()?c=!1:(c=b.e(),hf(new E(c.i()),lf())||hf(new E(c.i()),Gr())?(is(a,new ff(145),new gf("concludeWith")),c=!0):c=!1),c)b=b.g();else break;d=b;a:{if(d instanceof A&&(c=d.A,null!==c)){b=c.i();for(c=c.j();;){if(d.b())g=
-!1;else{g=d.e().i();var g=hf(new E(g),lf())}if(g)d=d.g();else break}d=d.Og();b=d.b()?G(new H,b,c):d.o();if(null===b)throw new x(b);c=b.i();b=b.j();d=new mf(new nf(J(new L,["Unexpected "," here"])));c=[pf(qf(),c.yb())];c=sf(d,J(new L,c));t();b=G(new H,c,new M(b));c=O().c;wf(a,new A(b,c));break a}b=O().c;if(null===b?null!==d:!b.h(d))throw new x(d);}Yr(a,new U(()=>"Concluded with "+e));return e}}}return cf(a)}
-function Vs(a){var b=hs(a);if(b instanceof A&&(b=b.A,null!==b)){var c=b.i();b=b.j();if(c instanceof Qr){var d=c.Tc,e=c.$d;if(ml()===d){is(a,new ff(247),new gf("curlyTypingUnit"));t();t();d=new M(c.Ig);c=c.yb();a=new Us(a,e,d,c);var g=Ts(a);for(c=ef(a,new ff(145),new gf("concludeWith"));;)if(c.b()?e=!1:(e=c.e(),hf(new E(e.i()),lf())||hf(new E(e.i()),Gr())?(is(a,new ff(145),new gf("concludeWith")),e=!0):e=!1),e)c=c.g();else break;d=c;a:{if(d instanceof A&&(e=d.A,null!==e)){c=e.i();for(e=e.j();;){if(d.b())h=
-!1;else{h=d.e().i();var h=hf(new E(h),lf())}if(h)d=d.g();else break}d=d.Og();c=d.b()?G(new H,c,e):d.o();if(null===c)throw new x(c);e=c.i();c=c.j();d=new mf(new nf(J(new L,["Unexpected "," here"])));e=[pf(qf(),e.yb())];e=sf(d,J(new L,e));t();c=G(new H,e,new M(c));e=O().c;wf(a,new A(c,e));break a}c=O().c;if(null===c?null!==d:!c.h(d))throw new x(d);}Yr(a,new U(()=>"Concluded with "+g));t();b=aq(g,new M(b));return new M(b)}}}return t().f}function Ws(a,b,c){return Xs(a,js(a,0,b,c))}
-function Qs(a,b,c){for(;;){var d=!1,e=null,g=ef(a,new ff(304),new gf("block")),h=O().c;if(null===h?null===g:h.h(g))return O().c;if(g instanceof A){d=!0;e=g;var k=e.A;if(null!==k){var l=k.i();if(Gr()===l){is(a,new ff(306),new gf("block"));continue}}}if(d){var m=e.A;if(null!==m){var n=m.i();if(lf()===n){is(a,new ff(307),new gf("block"));continue}}}if(d){var r=e.A;if(null!==r){var u=r.i(),w=r.j();if(u instanceof Jr&&"constructor"===u.Ta){is(a,new ff(309),new gf("block"));var y=hs(a);a:{if(y instanceof
-A){var B=y.A;if(null!==B){var D=B.i(),C=B.j();if(D instanceof Qr){var F=D,I=F.Tc,K=F.$d;if(ll()===I){is(a,new ff(312),new gf("res"));t();var N=new M(F.Ig),P=F.yb(),T=Is(new Us(a,K,N,P),new z(((Ae,Ff)=>vf=>Ys(vf,Ae,Ff))(c,b))),aa=Vs(a),Y=new U(()=>new Ss(O().c)),S=aa.b()?Zr(Y):aa.o(),Z=new im(T);t();var ka=aq(Z,new M(C)),X=new pm(zf(S)),sa=S.C();var Ia=new zo(ka,aq(X,sa));break a}}}}var Za=sf(new mf(new nf(J(new L,["Expect parameter list for the constructor"]))),v());t();var Ga=G(new H,Za,new M(w)),
-xa=O().c;wf(a,new A(Ga,xa));Ia=new zo(new im(O().c),new pm(O().c))}t();t();var Ra=Zs(w,bq(Ia)),Ja=aq(Ia,new M(Ra)),La=new me(Ja),pb=Qs(a,b,c);return new A(La,pb)}}}a:{if(null!==g){var Fb=ys(a).jC(g);if(!Fb.b()){var Gb=Fb.k.i(),Hb=Fb.k.j();if(Hb instanceof A){var tb=Hb.A;if(null!==tb){var kb=tb.i(),gb=tb.j();if(kb instanceof Jr){var Vb=kb.Ta;if("class"===Vb||"infce"===Vb||"trait"===Vb||"mixin"===Vb||"type"===Vb||"module"===Vb){is(a,new ff(324),new gf("t"));var bb=$s(Gb,"declare");if(null!==bb)var nb=
-G(new H,bb.i(),bb.j());else throw new x(bb);var Tb=nb.i(),ub=$s(nb.j(),"abstract");if(null!==ub)var Ub=G(new H,ub.i(),ub.j());else throw new x(ub);var $a=Ub.i();at(Ub.j());switch(Vb){case "class":var cb=pp();break;case "trait":cb=tp();break;case "mixin":cb=Qo();break;case "type":cb=np();break;case "module":cb=mp();break;default:Dn("Program reached and unexpected state.")}var Na=hs(a);b:{if(Na instanceof A){var Ca=Na.A;if(null!==Ca){var Ba=Ca.i(),Oa=Ca.j();if(Ba instanceof Kr){var wa=Ba.Df;is(a,new ff(338),
-new gf("x$19"));var ea=new sp(wa);t();var la=G(new H,aq(ea,new M(Oa)),!0);break b}}}var Ka=Na.Og(),Ua=new U(()=>G(new H,"end of input",bs(a))),ya=new z(Ae=>{t();t();Ae=G(new H,(new z(Ff=>Ff.yb())).n(Ae.i()),Ae.j());return G(new H,Ae.z,bt().n(Ae.x))}),ib=Ka.b()?Zr(Ua):ya.n(Ka.o());if(null!==ib)var Lb=G(new H,ib.i(),ib.j());else throw new x(ib);var ec=Lb.i(),Mb=Lb.j(),Jb=new mf(new nf(J(new L,["Expected a type name; found "," instead"]))),Kb=[pf(qf(),ec)],eb=sf(Jb,J(new L,Kb)),Wb=G(new H,eb,Mb),mc=
-O().c;wf(a,new A(Wb,mc));is(a,new ff(344),new gf("x$19"));var ua=new sp("\x3cerror\x3e"),Pa=ds(a),xb=new z(Ae=>Or(Ae)),Yb=Pa.b()?R():new M(xb.n(Pa.o()));la=G(new H,aq(ua,Yb),!1)}if(null!==la)var zb=G(new H,la.i(),la.Hx());else throw new x(la);var Sb=zb.i(),Ma=hs(a);b:{if(Ma instanceof A){var Ea=Ma.A;if(null!==Ea){var ab=Ea.i();if(ab instanceof Qr){var Db=ab,mb=Db.Tc,vb=Db.$d;if(ol()===mb||nl()===mb){is(a,new ff(350),new gf("tparams"));t();var Ya=new M(Db.Ig),Wa=Db.yb();var rb=Is(new Us(a,vb,Ya,Wa),
-new z(((Ae,Ff)=>vf=>ct(vf,new Um(Xf=>dt(Xf,Ae,Ff))))(c,b)));break b}}}}rb=O().c}var pa=hs(a);b:{if(pa instanceof A){var Fa=pa.A;if(null!==Fa){var Ib=Fa.i(),qb=Fa.j();if(Ib instanceof Qr){var Nb=Ib,fc=Nb.Tc,Ac=Nb.$d;if(ll()===fc){is(a,new ff(367),new gf("params"));t();var tc=new M(Nb.Ig),vc=Nb.yb(),sc=Is(new Us(a,Ac,tc,vc),new z(((Ae,Ff)=>vf=>Ys(vf,Ae,Ff))(c,b)));t();var uc=new im(sc);t();var lc=aq(uc,new M(qb));var Wc=new M(lc);break b}}}}Wc=t().f}var Cc=!1,Dc=null,Ec=hs(a);b:{if(Ec instanceof A){Cc=
-!0;Dc=Ec;var Ic=Dc.A;if(null!==Ic){var Xc=Ic.i();if(Xc instanceof Jr&&"\x3d"===Xc.Ta&&et(new E(cb),np())){is(a,new ff(380),new gf("sigTrm"));t();var Sc=js(a,0,c,new ff(381));var oc=new M(Sc);break b}}}if(Cc){var qc=Dc.A;if(null!==qc){var Tc=qc.i();if(Tc instanceof Jr&&":"===Tc.Ta&&!et(new E(cb),np())){is(a,new ff(383),new gf("sigTrm"));t();var Nc=js(a,0,c,new ff(384));oc=new M(Nc);break b}}}oc=t().f}var Pc=hs(a);b:{if(Pc instanceof A){var Oc=Pc.A;if(null!==Oc){var $c=Oc.i();if($c instanceof Jr&&"extends"===
-$c.Ta){is(a,new ff(392),new gf("ps"));var Lc=js(a,ks().Rp.n(hd(44))|0,c,new ff(393)),Zb=ls(a,c);var ed=new A(Lc,Zb);break b}}}ed=O().c}var $b=Vs(a),Fc=new U(((Ae,Ff)=>()=>{var vf=cs(Ae);if(vf instanceof M){var Xf=vf.k;if(Xf instanceof zm){vf=Xf.cu;Xf=Xf.du;var Ij=jp(Ae).g();return new Ul(Ff,jp(new A(vf,Ij)),Xf)}}return Ff instanceof M&&(Xf=Ff.k,Xf instanceof zm)?(vf=Xf.cu,Xf=Xf.du,new Ul((t(),new M(vf)),Ae,Xf)):new Ul(Ff,Ae,new Ss(O().c))})(ed,oc)),Yc=new z(((Ae,Ff)=>vf=>new Ul(Ae,Ff,vf))(oc,ed)),
-nc=$b.b()?Zr(Fc):Yc.n($b.o());if(null!==nc)var Ob=new Ul(nc.ec,nc.gb,nc.xd);else throw new x(nc);var cc=Ob.ec,Gc=Ob.gb,Bc=Ob.xd,qd=new z(Ae=>Xs(a,Ae)),Gd=cc.b()?R():new M(qd.n(cc.o())),cd=zf(Bc),rd=ft(cd,new z(Ae=>{if(Ae instanceof zo)return t(),new te(Ae);t();return new me(Ae)}));if(null!==rd)var Id=G(new H,rd.i(),rd.j());else throw new x(rd);var Ha=Id.i(),jc=new Ss(Id.j()),Rb=Bc.C(),Uc=aq(jc,Rb);if(0<Ha.$a(1)){var Rc=sf(new mf(new nf(J(new L,["A class may have at most one explicit constructor"]))),
-v());t();var Cd=G(new H,Rc,new M(gb)),od=O().c;wf(a,new A(Cd,od));t()}var Va=Ha.Og(),wb=new io(cb,Sb,rb,Wc,Va,Gd,Gc,t().f,t().f,Uc,Tb,$a);t();t();var db=Zs(Zs(gb,bq(Sb)),bq(wb));aq(wb,new M(db));t();t();var Jc=Zs(gb,bq(wb)),Vc=aq(wb,new M(Jc));var Ta=new me(Vc);break a}}}}}}if(null!==g){var kd=ys(a).jC(g);if(!kd.b()){var ld=kd.k.i(),qe=kd.k.j();if(qe instanceof A){var Wd=qe.A;if(null!==Wd){var Rd=Wd.i(),Me=Wd.j();if(Rd instanceof Jr){var wc=Rd.Ta;if("fun"===wc||"val"===wc||"let"===wc){is(a,new ff(424),
-new gf("t"));var Xb=$s(ld,"declare");if(null!==Xb)var gc=G(new H,Xb.i(),Xb.j());else throw new x(Xb);var hc=gc.i(),gd=$s(gc.j(),"virtual");if(null!==gd)var kc=G(new H,gd.i(),gd.j());else throw new x(gd);var ud=kc.i();at(kc.j());var za=sr(new E(wc),"let"),Qa=hs(a);b:{if(Qa instanceof A){var xc=Qa.A;if(null!==xc){var yd=xc.i();if(yd instanceof Jr&&"rec"===yd.Ta&&"let"===wc){is(a,new ff(431),new gf("isLetRec"));t();var be=new M(!0);break b}}}be="fun"===wc?t().f:(t(),new M(!1))}var yc=hs(a);b:{if(yc instanceof
-A){var Od=yc.A;if(null!==Od){var sd=Od.i(),he=Od.j();if(sd instanceof Qr){var ue=sd,sg=ue.Tc,Se=ue.$d;if(ll()===sg){var Kf=!1,$e=null;if(Se instanceof A){Kf=!0;$e=Se;var rf=$e.A,He=$e.r;if(null!==rf){var Ze=rf.i(),jf=rf.j();if(Ze instanceof Kr){var tf=Ze,Te=tf.Df;if(!0===tf.Qf){is(a,new ff(439),new gf("opStr"));var hg=gt(He,new z(Ae=>hf(new E(Ae.i()),lf())));c:{var eh=O().c;if(null===eh?null!==hg:!eh.h(hg)){if(hg instanceof A){var fh=hg.A;if(null!==fh){var tg=fh.i(),Jg=fh.j(),Gh=new mf(new nf(J(new L,
-["Unexpected "," after symbolic name"]))),zg=[pf(qf(),tg.yb())],ig=sf(Gh,J(new L,zg));t();var qh=G(new H,ig,new M(Jg)),gh=O().c;wf(a,new A(qh,gh));break c}}throw new x(hg);}}t();var Wg=new Wl(Te);t();var Uf=aq(Wg,new M(jf));var rh=new M(Uf);break b}}}}if(Kf){var Rh=$e.A;if(null!==Rh){var Sg=Rh.i(),Hh=Rh.j();is(a,new ff(447),new gf("opStr"));var Xg=new mf(new nf(J(new L,["Expected a symbolic name, found "," instead"]))),jg=[pf(qf(),Sg.yb())],Ag=sf(Xg,J(new L,jg));t();var Cf=G(new H,Ag,new M(Hh)),Bg=
-O().c;wf(a,new A(Cf,Bg));rh=t().f;break b}}var Lf=O().c;if(null===Lf?null===Se:Lf.h(Se)){is(a,new ff(451),new gf("opStr"));var Df=sf(new mf(new nf(J(new L,["Expected a symbolic name between brackets, found nothing"]))),v());t();var kg=G(new H,Df,new M(he)),df=O().c;wf(a,new A(kg,df));rh=t().f;break b}throw new x(Se);}}}}rh=t().f}var Kg=hs(a);b:{if(Kg instanceof A){var Mf=Kg.A;if(null!==Mf){var Vf=Mf.i(),Cg=Mf.j();if(Vf instanceof Kr){var Ef=Vf,Wf=Ef.Df;if(!1===Ef.Qf){is(a,new ff(459),new gf("x$33"));
-var de=new Wl(Wf);t();var Ee=G(new H,aq(de,new M(Cg)),!0);break b}}}}var Sh=Kg.Og(),hi=new U(()=>G(new H,"end of input",bs(a))),vi=new z(Ae=>{t();t();Ae=G(new H,(new z(Ff=>Ff.yb())).n(Ae.i()),Ae.j());return G(new H,Ae.z,bt().n(Ae.x))}),Lg=Sh.b()?Zr(hi):vi.n(Sh.o());if(null!==Lg)var Tg=G(new H,Lg.i(),Lg.j());else throw new x(Lg);var cj=Tg.i(),Cj=Tg.j(),Dj=new mf(new nf(J(new L,["Expected a function name; found "," instead"]))),wi=[pf(qf(),cj)],Ki=sf(Dj,J(new L,wi)),Yg=G(new H,Ki,Cj),dj=O().c;wf(a,
-new A(Yg,dj));is(a,new ff(464),new gf("x$33"));var ii=new Wl("\x3cerror\x3e"),ji=ds(a),Th=new z(Ae=>Or(Ae)),Ej=ji.b()?R():new M(Th.n(ji.o()));Ee=G(new H,aq(ii,Ej),!1)}if(null!==Ee)var ej=G(new H,Ee.i(),Ee.Hx());else throw new x(Ee);var xd=ej.i(),ke=ej.Hx(),Ie=Gs(ks(),c)||!ke;Ta=(new z(((Ae,Ff,vf,Xf,Ij,Rj,hl,El)=>on=>{var Oi=!!on;if("let"===Ae){t();var ee=v(),Re=le(v(),ee)}else{var Ji=hs(a);a:{if(Ji instanceof A){var jk=Ji.A;if(null!==jk){var Vg=jk.i();if(Vg instanceof Qr){var kk=Vg.Tc,eo=Vg.$d;if(ol()===
-kk||nl()===kk){is(a,new ff(471),new gf("tparams"));t();var dr=new M(Vg.Ig),Ud=Vg.yb();Re=ht(Is(new Us(a,eo,dr,Ud),new z(of=>Ys(of,Oi,Oi))),new z(of=>{if(null!==of){var ok=of.i();of=of.j();if(t().f===ok&&null!==of&&(ok=of.vc,of=of.Da,null!==ok)){var fw=ok.si;if(!1===ok.pf&&!1===fw&&of instanceof Wl)return ok=new sp(of.w),of=of.C(),aq(ok,of)}}$n()}));break a}}}}Re=O().c}}var ne=hs(a);a:{if(ne instanceof A){var Fe=ne.A,Bk=ne.r;if(null!==Fe){var sn=Fe.i(),Hc=Fe.j();if(sn instanceof Qr){var Sd=sn.Tc,Hd=
-sn.$d;if(ll()===Sd&&null!==Hd){var Be=Bs(a).jC(Hd);if(!Be.b()){var mj=Be.k.j();if(mj instanceof A){var bm=mj.A,Km=mj.r;if(null!==bm){var tn=bm.i(),ut=bm.j();if(tn instanceof Jr&&"override"===tn.Ta){var pE=new Qr(ll(),Km,sn.Ig),qE=G(new H,pE,Hc);Js(a,new A(qE,Bk));var vt=it(a,Oi,Oi,new ff(483));if(vt instanceof A){var zz=vt.A,gw=vt.r;if(null!==zz){var qs=zz.Ra;if(qs instanceof A){var er=qs.A,hw=qs.r;if(null!==er){var iw=new M(er);if(!iw.b()){var rE=iw.k.i(),wt=iw.k.j();if(t().f===rE&&null!==wt){var xt=
-wt.vc,Az=wt.Da;if(null!==xt){var jw=xt.si,kw=xt.ri;if(!1===xt.pf)if(!1===jw){var lw=O().c;if(null===lw?null===hw:lw.h(hw))var rs=O().c,ss=null===rs?null===gw:rs.h(gw);else ss=!1}else ss=!1;else ss=!1;if(ss){var ts=Es(a),Bz=t().f,sE=new ws(new jt(!1,!1,kw),ts),mw=G(new H,Bz,sE),yt=O().c,tE=new im(new A(mw,yt)),nw=O().c,ow=new A(tE,nw);t();var fr=G(new H,ow,new M(new z(of=>{of=new kt(ts,new Wl("is"),new lt(Az,of));t();var ok=new xm;t();ok=new nm(aq(ok,new M(ut)),Ff);var fw=t().f,wS=new ws(new jt(!1,
-!1,kw),ts);fw=G(new H,fw,wS);wS=O().c;ok=new mm(ok,new im(new A(fw,wS)));return new tm(of,new M(ok))})));break a}}}}}}}}var Cz=sf(new mf(new nf(J(new L,["Unsupported 'override' parameter list shape"]))),v());t();var Dz=G(new H,Cz,new M(sn.Ig)),uE=O().c;wf(a,new A(Dz,uE));fr=G(new H,vt,t().f);break a}}}}}}}}fr=G(new H,it(a,Oi,Oi,new ff(496)),t().f)}if(null!==fr)var us=G(new H,fr.i(),fr.j());else throw new x(fr);var vs=us.i(),zt=us.j(),pw=hs(a);a:{if(pw instanceof A){var qw=pw.A;if(null!==qw){var At=
-qw.i();if(At instanceof Jr&&":"===At.Ta){is(a,new ff(500),new gf("asc"));t();var Ez=Ws(a,Oi,new ff(502));var Xo=new M(Ez);break a}}}Xo=t().f}var gr=hs(a);if(gr instanceof A){var Fz=gr.A;if(null!==Fz){var Gz=Fz.i();if(Gz instanceof Jr&&"\x3d"===Gz.Ta){is(a,new ff(507),new gf("t"));var rw=js(a,0,Oi,new ff(508)),Hz=new U(()=>rw),vE=new z(of=>of.n(rw)),Iz=zt.b()?Zr(Hz):vE.n(zt.o()),Jz=new U(()=>Iz),vn=new z(of=>new em(Iz,of)),hr=Xo.b()?Zr(Jz):vn.n(Xo.o()),sw=hs(a);if(sw instanceof A){var tw=sw.A;if(null!==
-tw){var wE=tw.i(),jM=tw.j();if(wE instanceof Jr&&"in"===wE.Ta&&"let"===Ae){is(a,new ff(513),new gf("t"));if(!Re.b()){var xE=sf(new mf(new nf(J(new L,["Unsupported type parameters on 'let' binding"]))),v());t();var kM=G(new H,xE,new M(jM)),lM=O().c;wf(a,new A(kM,lM))}var uw=js(a,0,Oi,new ff(515));t();var mM=new U(()=>{Dn("Program reached and unexpected state.")}),xS=new om(!(vf.b()?!Zr(mM):!vf.o()),Ff,rw,uw);t();var yS=Zs(Xf,hr.C()),zS=aq(xS,new M(yS));return new me(zS)}}}t();t();var nM=vs.we(hr,new Um((of,
-ok)=>new lm(of,ok))),AS=new Kn(vf,Ff,Ij,Re,new te(nM),Rj,hl,t().f,t().f,El);t();var BS=Zs(Xf,hr.C()),oM=aq(AS,new M(BS));return new me(oM)}}}if(Xo instanceof M){var yE=Xo.k;zt.b()||Dn("Program reached and unexpected state.");t();t();var pM=new mt(O().c,vs.we(yE,new Um((of,ok)=>{of=An(of);if(of instanceof te){var fw=of.ca;Fs(a,new U(()=>fw),Oi);of=Jl()}else if(of instanceof me)of=of.ia;else throw new x(of);return new nt(of,ok)}))),qM=new Kn(vf,Ff,Ij,Re,new me(pM),Rj,hl,t().f,t().f,El);t();var CS=Zs(Xf,
-yE.C()),zE=aq(qM,new M(CS));return new me(zE)}if(t().f===Xo){var rM=gr.Og(),AE=new U(()=>G(new H,"end of input",bs(a))),DS=new z(of=>{t();t();of=G(new H,(new z(ok=>ok.yb())).n(of.i()),of.j());return G(new H,of.z,bt().n(of.x))}),vw=rM.b()?Zr(AE):DS.n(rM.o());if(null!==vw)var BE=G(new H,vw.i(),vw.j());else throw new x(vw);var sM=BE.i(),ES=BE.j(),FS=new mf(new nf(J(new L,["Expected ':' or '\x3d' followed by a function body or signature; found "," instead"]))),GS=[pf(qf(),sM)],kf=sf(FS,J(new L,GS)),Mk=
-G(new H,kf,ES),nj=O().c;wf(a,new A(Mk,nj));is(a,new ff(536),new gf("t"));var Yo=fs(a);t();var CE=O().c;t();var HS=vs.we(Yo,new Um((of,ok)=>new lm(of,ok))),IS=new Kn(vf,Ff,Ij,CE,new te(HS),Rj,hl,t().f,t().f,El);t();var V$=Zs(Xf,Yo.C()),W$=aq(IS,new M(V$));return new me(W$)}throw new x(Xo);})(wc,xd,be,Me,rh,hc,ud,za))).n(Ie);break a}}}}}}Ta=ot(a,0,!1,b,c,new ff(545))}var Qf=hs(a);a:{if(Qf instanceof A){var hh=Qf.A;if(null!==hh){var lg=hh.i();if(lg instanceof Jr&&"\x3d"===lg.Ta){var Uh=!1,Zg=null;if(Ta instanceof
-me){Uh=!0;Zg=Ta;var Vh=Zg.ia;if(Vh instanceof Wl){var fj=Vh;is(a,new ff(550),new gf("finalTerm"));t();var gj=new ym(fj,js(a,0,c,new ff(551)));var Li=new me(gj);break a}}if(Uh){var Mi=Zg.ia;if(Mi instanceof mm){var hj=Mi,Fj=hj.kb,Qj=hj.hc;if(Fj instanceof Wl){var Ni=Fj;is(a,new ff(553),new gf("finalTerm"));t();var Gj=new ym(Ni,new lm(Qj,js(a,0,c,new ff(554))));Li=new me(Gj);break a}}}Li=Ta;break a}}}Li=Ta}var Hj=!1,lk=null,md=hs(a);if(md instanceof A){Hj=!0;lk=md;var Ue=lk.A;if(null!==Ue){var Jd=Ue.i();
-if(nr()===Jd){is(a,new ff(560),new gf("block"));var uf=Qs(a,b,c);return new A(Li,uf)}}}if(Hj){var Dl=lk.A;if(null!==Dl){var gl=Dl.i();if(Gr()===gl){is(a,new ff(561),new gf("block"));var am=Qs(a,b,c);return new A(Li,am)}}}var xk=O().c;return new A(Li,xk)}}function hs(a){for(var b=ef(a,new ff(567),new gf("yeetSpaces"));;){if(b.b())c=!1;else if(c=b.e(),hf(new E(c.i()),lf())||c.i()instanceof tr){is(a,new ff(570),new gf("yeetSpaces"));var c=!0}else c=!1;if(c)b=b.g();else break}return b}
-function it(a,b,c,d){var e=new U(()=>{}),g=new gf("funParams");Yr(a,new U(()=>{var Oa=g.Gm,wa=Zr(e);wa=$r(wa)?Qe(wa,"(",",",")"):as(wa)?Zr(e):"("+Zr(e)+")";return"@ "+Oa+wa+"    [at l."+d.Nl+"]"}));try{a.Rd=1+a.Rd|0;var h=!1,k=null,l=hs(a);a:{if(l instanceof A){h=!0;k=l;var m=k.A;if(null!==m){var n=m.i();if(n instanceof Jr){var r=n.Ta;if("\x3d"===r||":"===r){var u=O().c;break a}}}}if(h){var w=k.A;if(null!==w){var y=w.i();if(y instanceof Jr&&"of"===y.Ta){is(a,new ff(576),new gf("funParams"));var B=
-new im(pt(a,!1,ks().Vt,c,b)),D=it(a,b,c,new ff(578));u=new A(B,D);break a}}}if(h){var C=k.A;if(null!==C){var F=C.i(),I=C.j();if(F instanceof Qr){var K=F.Tc,N=F.$d;if(ll()===K){is(a,new ff(580),new gf("funParams"));t();for(var P=new M(F.Ig),T=F.yb(),aa=new Us(a,N,P,T),Y=Ys(aa,c,b),S=ef(aa,new ff(145),new gf("concludeWith"));;){if(S.b())ka=!1;else{var Z=S.e();if(hf(new E(Z.i()),lf())||hf(new E(Z.i()),Gr())){is(aa,new ff(145),new gf("concludeWith"));var ka=!0}else ka=!1}if(ka)S=S.g();else break}h=S;
-b:{if(h instanceof A){var X=h.A;if(null!==X){var sa=X.i(),Ia=X.j();for(X=h;;){if(X.b())Ga=!1;else var Za=X.e().i(),Ga=hf(new E(Za),lf());if(Ga)X=X.g();else break}var xa=X.Og(),Ra=xa.b()?G(new H,sa,Ia):xa.o();if(null===Ra)throw new x(Ra);var Ja=Ra.i(),La=Ra.j(),pb=new mf(new nf(J(new L,["Unexpected "," here"]))),Fb=[pf(qf(),Ja.yb())],Gb=sf(pb,J(new L,Fb));t();var Hb=G(new H,Gb,new M(La)),tb=O().c;wf(aa,new A(Hb,tb));break b}}var kb=O().c;if(null===kb?null!==h:!kb.h(h))throw new x(h);}Yr(aa,new U(()=>
-"Concluded with "+Y));var gb=new im(Y);t();var Vb=aq(gb,new M(I)),bb=it(a,b,c,new ff(582));u=new A(Vb,bb);break a}}}}if(h){var nb=k.A;if(null!==nb){var Tb=nb.i(),ub=nb.j(),Ub=new mf(new nf(J(new L,["Expected function parameter list; found "," instead"]))),$a=[pf(qf(),Tb.yb())],cb=sf(Ub,J(new L,$a));t();var Na=G(new H,cb,new M(ub)),Ca=O().c;wf(a,new A(Na,Ca));is(a,new ff(587),new gf("funParams"));u=O().c;break a}}var Ba=O().c;if(null===Ba?null===l:Ba.h(l))u=O().c;else throw new x(l);}}finally{a.Rd=
--1+a.Rd|0}Yr(a,new U(()=>"\x3d "+u));return u}function js(a,b,c,d){var e=new U(()=>new qt(b,!0)),g=new gf("expr");Yr(a,new U(()=>{var l=g.Gm,m=Zr(e);m=$r(m)?Qe(m,"(",",",")"):as(m)?Zr(e):"("+Zr(e)+")";return"@ "+l+m+"    [at l."+d.Nl+"]"}));try{a.Rd=1+a.Rd|0;var h=ot(a,b,!0,!1,c,new ff(599));if(h instanceof me)var k=h.ia;else if(h instanceof te)k=es(a,h.ca.C());else throw new x(h);}finally{a.Rd=-1+a.Rd|0}Yr(a,new U(()=>"\x3d "+k));return k}
-function rt(a,b,c,d){var e=hs(a);if(e instanceof A&&(e=e.A,null!==e&&(e=e.i(),Gr()===e))){is(a,d,new gf("exprOrBlockContinuation"));e=Qs(a,b,c);b=h=>{if(h instanceof te)return es(a,h.ca.C());if(h instanceof me)return h.ia;throw new x(h);};if(e===v())b=v();else{c=e.e();d=c=new A(b(c),v());for(e=e.g();e!==v();){var g=e.e();g=new A(b(g),v());d=d.r=g;e=e.g()}b=c}return new pm(b)}return js(a,0,c,d)}
-function ot(a,b,c,d,e,g){var h=id();try{return Xr(a,new U(()=>new qt(b,c)),new z(()=>{var k=!1,l=null,m=ef(a,new ff(620),new gf("exprOrIf"));if(m instanceof A){k=!0;l=m;var n=l.A;if(null!==n){var r=n.i();if(lf()===r&&c)return is(a,new ff(622),new gf("exprOrIf")),ot(a,b,c,d,e,new ff(623))}}if(k){var u=l.A;if(null!==u){var w=u.i();if(w instanceof Qr){var y=w.Tc,B=w.$d;if(pl()===y){var D=B.Og();a:{if(D instanceof M){var C=D.k;if(null!==C){var F=C.i();if(F instanceof Jr){var I=F.Ta;if("then"===I||"else"===
-I){var K=!1;break a}}}}K=!0}}else K=!1;if(K){is(a,new ff(628),new gf("exprOrIf"));t();var N=new M(w.Ig),P=w.yb(),T=Is(new Us(a,B,N,P),new z(Ud=>Qs(Ud,d,e))),aa=ht(T,new z(Ud=>{if(Ud instanceof te)throw t(),Ud=new st(T),fq(new gq,h,new te(Ud));if(Ud instanceof me)return Ud.ia;throw new x(Ud);}));t();var Y=new pm(aa);return new me(Y)}}}}if(k){var S=l.A;if(null!==S){var Z=S.i(),ka=S.j();if(Z instanceof rr){var X=Z.Dw;is(a,new ff(633),new gf("exprOrIf"));t();return tt(a,aq(X,new M(ka)),b,!1,d,e,new ff(634))}}}if(k){var sa=
-l.A;if(null!==sa){var Ia=sa.i(),Za=sa.j();if(Ia instanceof Jr){var Ga=Ia.Ta;if("undefined"===Ga||"null"===Ga){is(a,new ff(636),new gf("exprOrIf"));var xa=new Jo("undefined"===Ga);t();return tt(a,aq(xa,new M(Za)),b,!1,d,e,new ff(637))}}}}if(k){var Ra=l.A;if(null!==Ra){var Ja=Ra.i(),La=Ra.j();if(Ja instanceof Kr){var pb=Ja.Df;if(!1===Ja.Qf){is(a,new ff(639),new gf("exprOrIf"));var Fb=new Wl(pb);t();return tt(a,aq(Fb,new M(La)),b,!1,d,e,new ff(640))}}}}if(k){var Gb=l.A;if(null!==Gb){var Hb=Gb.i(),tb=
-Gb.j();if(Hb instanceof Jr&&"super"===Hb.Ta){is(a,new ff(642),new gf("exprOrIf"));var kb=new xm;t();return tt(a,aq(kb,new M(tb)),b,!1,d,e,new ff(643))}}}if(k){var gb=l.A;if(null!==gb){var Vb=gb.i(),bb=gb.j();if(Vb instanceof Kr&&"~"===Vb.Df){is(a,new ff(645),new gf("exprOrIf"));var nb=js(a,b,e,new ff(646)),Tb=new Wl("~");t();var ub=new mm(aq(Tb,new M(bb)),nb);t();var Ub=Zs(bb,nb.C());return tt(a,aq(ub,new M(Ub)),b,!1,d,e,new ff(647))}}}if(k){var $a=l.A;if(null!==$a){var cb=$a.i();if(cb instanceof
-Qr){var Na=cb.Tc,Ca=cb.$d;if(ll()===Na&&Ca instanceof A){var Ba=Ca.A,Oa=Ca.r;if(null!==Ba){var wa=Ba.i(),ea=Ba.j();if(wa instanceof Kr){var la=wa.Df;if(!0===wa.Qf)var Ka=O().c,Ua=null===Ka?null===Oa:Ka.h(Oa);else Ua=!1;if(Ua){is(a,new ff(649),new gf("exprOrIf"));var ya=new Wl(la);t();return tt(a,aq(ya,new M(ea)),b,!1,d,e,new ff(650))}}}}}}}if(k){var ib=l.A;if(null!==ib){var Lb=ib.i(),ec=ib.j();if(Lb instanceof Qr){var Mb=Lb.Tc,Jb=Lb.$d;if(ll()===Mb||nl()===Mb||ml()===Mb){is(a,new ff(652),new gf("exprOrIf"));
-t();var Kb=new M(Lb.Ig),eb=Lb.yb(),Wb=Is(new Us(a,Jb,Kb,eb),new z(Ud=>Ys(Ud,e,d))),mc=G(new H,Mb,Wb);a:{var ua=mc.z;if(ml()===ua)var Pa=new hm(!0,new Zl(ht(Wb,new z(Ud=>{if(null!==Ud){var ne=new M(Ud);if(!ne.b()){var Fe=ne.k.i();ne=ne.k.j();if(Fe instanceof M)return G(new H,Fe.k,ne)}}if(null!==Ud&&(ne=new M(Ud),!ne.b()&&(Fe=ne.k.i(),ne=ne.k.j(),t().f===Fe&&null!==ne&&(Fe=ne.Da,Fe instanceof Wl))))return G(new H,Fe,ne);if(null!==Ud&&(Fe=new M(Ud),!Fe.b()&&(ne=Fe.k.i(),Fe=Fe.k.j(),t().f===ne)))return Ud=
-sf(new mf(new nf(J(new L,["Record field should have a name"]))),v()),ne=Fe.Da.C(),Ud=G(new H,Ud,ne),ne=O().c,wf(a,new A(Ud,ne)),Ud=new Wl("\x3cerror\x3e"),G(new H,Ud,Fe);throw new x(Ud);}))));else{var xb=mc.z,Yb=mc.x;if(ll()===xb&&Yb instanceof A){var zb=Yb.A,Sb=Yb.r;if(null!==zb){var Ma=zb.i(),Ea=zb.j();if(t().f===Ma&&null!==Ea){var ab=Ea.vc,Db=Ea.Da;if(null!==ab){var mb=ab.si;if(!1===ab.pf)if(!1===mb)var vb=O().c,Ya=null===vb?null===Sb:vb.h(Sb);else Ya=!1;else Ya=!1;if(Ya){Pa=new hm(!1,Db);break a}}}}}var Wa=
-mc.z;if(ll()===Wa){var rb=!1,pa=null,Fa=hs(a);if(Fa instanceof A){rb=!0;pa=Fa;var Ib=pa.A;if(null!==Ib){var qb=Ib.i();if(qb instanceof Jr&&"\x3d\x3e"===qb.Ta){is(a,new ff(669),new gf("bra"));var Nb=js(a,Bt("\x3d\x3e").Lc(),e,new ff(670));Pa=new lm(new im(Wb),Nb);break a}}}if(rb){var fc=pa.A;if(null!==fc){var Ac=fc.i();if(Ac instanceof Kr){var tc=Ac.Qf;if("-\x3e"===Ac.Df&&!0===tc){is(a,new ff(673),new gf("bra"));var vc=js(a,Bt("-\x3e").Lc(),e,new ff(674));Pa=new lm(new im(Wb),vc);break a}}}}var sc=
-O().c;if(null===sc?null===Wb:sc.h(Wb))Pa=new Jo(!0);else{var uc=ht(Wb,new z(Ud=>{if(null!==Ud){var ne=new M(Ud);if(!ne.b()){var Fe=ne.k.i();ne=ne.k.j();if(t().f===Fe&&null!==ne){Fe=ne.vc;ne=ne.Da;var Bk=Ct().Kg;if(null===Bk?null===Fe:Bk.h(Fe))return ne}}}if(null!==Ud&&(ne=new M(Ud),!ne.b()&&(Fe=ne.k.i(),ne=ne.k.j(),null!==ne)))return Ud=ne.Da,ne=sf(new mf(new nf(J(new L,["Illegal position for field specification"]))),v()),Dt(),Fe=Fe.ea(),Fe=Et(0,wq(Fe,Ud)),Fe=G(new H,ne,Fe),ne=O().c,wf(a,new A(Fe,
-ne)),Ud;throw new x(Ud);}));Pa=Ft(uc,new Um((Ud,ne)=>{var Fe=new Wl(",");Dt();var Bk=O().c;Bk=Et(0,new A(Ud,new A(ne,Bk)));Fe=aq(Fe,Bk);Gt();return new mm(Fe,Ht(J(new L,[Ud,ne])))}))}}else Pa=new im(Wb)}}t();return tt(a,aq(Pa,new M(ec)),b,!1,d,e,new ff(693))}}}}if(k){var lc=l.A;if(null!==lc){var Wc=lc.i();if(Wc instanceof Jr&&"forall"===Wc.Ta){is(a,new ff(695),new gf("exprOrIf"));var Cc=os(a),Dc=ef(a,new ff(709),new gf("rest"));a:{if(Dc instanceof A){var Ec=Dc.A;if(null!==Ec){var Ic=Ec.i();if(Ic instanceof
-Jr&&":"===Ic.Ta){is(a,new ff(711),new gf("rest"));var Xc=js(a,0,e,new ff(712));break a}}}var Sc=sf(new mf(new nf(J(new L,["Expected `:` after `forall` section"]))),v()),oc=ds(a),qc=new U(()=>bs(a)),Tc=oc.b()?Zr(qc):oc,Nc=G(new H,Sc,Tc),Pc=O().c;wf(a,new A(Nc,Pc));Xc=fs(a)}t();var Oc=new vm(Cc,Xc);return new me(Oc)}}}if(k){var $c=l.A;if(null!==$c){var Lc=$c.i();if(Lc instanceof Jr&&"let"===Lc.Ta){is(a,new ff(719),new gf("exprOrIf"));var Zb=It(a,O().c,e),ed=!1,$b=null,Fc=hs(a);a:{if(Fc instanceof A){ed=
-!0;$b=Fc;var Yc=$b.A;if(null!==Yc){var nc=Yc.i();var Ob=nc instanceof Jr&&"in"===nc.Ta?!0:nr()===nc?!0:!1;if(Ob){is(a,new ff(723),new gf("body"));var cc=ot(a,0,!0,d,e,new ff(724));break a}}}if(ed){var Gc=$b.A;if(null!==Gc){var Bc=Gc.i();if(Gr()===Bc){is(a,new ff(726),new gf("body"));cc=ot(a,0,!0,d,e,new ff(727));break a}}}t();var qd=new Jo(!0),Gd=ds(a),cd=new z(Ud=>Or(Ud)),rd=Gd.b()?R():new M(cd.n(Gd.o())),Id=aq(qd,rd);cc=new me(Id)}return Zb.we(cc,new Um((Ud,ne)=>{Ud=G(new H,Ud,ne);var Fe=Ud.z,Bk=
-Ud.x;if(null!==Fe&&(ne=Fe.i(),Fe=Fe.j(),Bk instanceof me))return Ud=Bk.ia,t(),Ud=new om(!1,ne,Fe,Ud),new me(Ud);Fe=Ud.z;Bk=Ud.x;if(null!==Fe&&(ne=Fe.i(),Fe=Fe.j(),Bk instanceof te))return Ud=Bk.ca,t(),Ud=new Jt(!1,ne,Fe,Ud),new te(Ud);throw new x(Ud);}))}}}if(k){var Ha=l.A;if(null!==Ha){var jc=Ha.i(),Rb=Ha.j();if(jc instanceof Jr&&"new"===jc.Ta){is(a,new ff(736),new gf("exprOrIf"));var Uc=js(a,ks().Rp.n(hd(46))|0,e,new ff(737)),Rc=new um(Uc);t();var Cd=Zs(Rb,Uc.C());return tt(a,aq(Rc,new M(Cd)),b,
-!1,d,e,new ff(738))}}}if(k){var od=l.A;if(null!==od){var Va=od.i(),wb=od.j();if(Va instanceof Jr&&"else"===Va.Ta){is(a,new ff(740),new gf("exprOrIf"));var db=hs(a);if(db instanceof A){var Jc=db.A;if(null!==Jc){var Vc=Jc.i();Gr()===Vc&&(is(a,new ff(743),new gf("exprOrIf")),$n())}}var Ta=js(a,0,e,new ff(746));t();var kd=new Kt(Ta);t();var ld=Zs(wb,Ta.C()),qe=aq(kd,new M(ld));return new te(qe)}}}if(k){var Wd=l.A;if(null!==Wd){var Rd=Wd.i(),Me=Wd.j();if(Rd instanceof Jr&&"case"===Rd.Ta){is(a,new ff(750),
-new gf("exprOrIf"));var wc=ot(a,0,!0,!0,e,new ff(751));if(wc instanceof te){var Xb=wc.ca;t();Gt();var gc=[new Wl("case$scrut")],hc=new lm(Ht(J(new L,gc)),new tm(new kt(new Wl("case$scrut"),new Wl("is"),Xb),t().f));return new me(hc)}if(wc instanceof me){var gd=wc.ia,kc=new mf(new nf(J(new L,["Expected 'then'/'else' clause after 'case'; found "," instead"]))),ud=[pf(qf(),Lt(gd))],za=sf(kc,J(new L,ud)),Qa=gd.C(),xc=G(new H,za,Qa),yd=sf(new mf(new nf(J(new L,["Note: 'case' expression starts here:"]))),
-v());t();var be=G(new H,yd,new M(Me)),yc=O().c;wf(a,new A(xc,new A(be,yc)));t();Gt();var Od=[new Wl("case$scrut")],sd=new lm(Ht(J(new L,Od)),new tm(new Kt(gd),t().f));return new me(sd)}throw new x(wc);}}}if(k){var he=l.A;if(null!==he){var ue=he.i(),sg=he.j();if(ue instanceof Jr&&"if"===ue.Ta){is(a,new ff(761),new gf("exprOrIf"));ef(a,new ff(762),new gf("exprOrIf"));var Se=ot(a,0,!0,!0,e,new ff(764));if(Se instanceof te){var Kf=Se.ca,$e=!1,rf=null,He=hs(a);a:{if(He instanceof A){$e=!0;rf=He;var Ze=
-rf.A;if(null!==Ze){var jf=Ze.i();if(jf instanceof Jr&&"else"===jf.Ta){is(a,new ff(768),new gf("els"));t();var tf=rt(a,d,e,new ff(769));var Te=new M(tf);break a}}}if($e){var hg=rf.A,eh=rf.r;if(null!==hg){var fh=hg.i();if(Gr()===fh&&eh instanceof A){var tg=eh.A;if(null!==tg){var Jg=tg.i();if(Jg instanceof Jr&&"else"===Jg.Ta){is(a,new ff(771),new gf("els"));is(a,new ff(772),new gf("els"));t();var Gh=js(a,0,e,new ff(773));Te=new M(Gh);break a}}}}}if($e){var zg=rf.A;if(null!==zg){var ig=zg.i();if(ig instanceof
-Qr){var qh=ig.Tc,gh=ig.$d;if(pl()===qh&&gh instanceof A){var Wg=gh.A,Uf=gh.r;if(null!==Wg){var rh=Wg.i();if(rh instanceof Jr&&"else"===rh.Ta){is(a,new ff(775),new gf("els"));t();var Rh=new M(ig.Ig),Sg=ig.yb(),Hh=new Us(a,Uf,Rh,Sg);t();var Xg=Is(Hh,new z(Ud=>js(Ud,0,e,new ff(777))));Te=new M(Xg);break a}}}}}}Te=t().f}t();var jg=new tm(Kf,Te);return new me(jg)}if(Se instanceof me){var Ag=Se.ia,Cf=hs(a);if(Cf instanceof A){var Bg=Cf.A;if(null!==Bg){var Lf=Bg.i();if(Lf instanceof Qr){var Df=Lf.Tc,kg=
-Lf.$d;if(pl()===Df&&kg instanceof A){var df=kg.A,Kg=kg.r;if(null!==df){var Mf=df.i();if(Mf instanceof Jr&&"then"===Mf.Ta){is(a,new ff(784),new gf("exprOrIf"));t();var Vf=new M(Lf.Ig),Cg=Lf.yb(),Ef=new Us(a,Kg,Vf,Cg),Wf=js(Ef,0,e,new ff(786)),de=!1,Ee=null,Sh=hs(Ef);a:{if(Sh instanceof A){de=!0;Ee=Sh;var hi=Ee.A;if(null!==hi){var vi=hi.i();if(vi instanceof Jr&&"else"===vi.Ta){is(Ef,new ff(789),new gf("els"));t();var Lg=Is(Ef,new z(Ud=>js(Ud,0,e,new ff(790))));var Tg=new M(Lg);break a}}}if(de){var cj=
-Ee.A,Cj=Ee.r;if(null!==cj){var Dj=cj.i();if(Gr()===Dj&&Cj instanceof A){var wi=Cj.A;if(null!==wi){var Ki=wi.i();if(Ki instanceof Jr&&"else"===Ki.Ta){is(Ef,new ff(792),new gf("els"));is(Ef,new ff(793),new gf("els"));t();var Yg=Is(Ef,new z(Ud=>js(Ud,0,e,new ff(795))));Tg=new M(Yg);break a}}}}}Is(Ef,new z(()=>{}));Tg=t().f}t();var dj=new tm(new lt(Ag,Wf),Tg);return new me(dj)}}}}}}a:{if(Cf instanceof A){var ii=Cf.A;if(null!==ii){var ji=ii.i(),Th=ii.j(),Ej=new mf(new nf(J(new L,[""," followed by ",""]))),
-ej=[pf(qf(),Lt(Ag)),pf(qf(),ji.yb())],xd=sf(Ej,J(new L,ej));t();var ke=Mt(Nt(),Ag.C()).we(Th,new Um((Ud,ne)=>Rr(Ud,ne)));var Ie=G(new H,xd,new M(ke));break a}}var Qf=O().c;if(null===Qf?null===Cf:Qf.h(Cf)){var hh=new mf(new nf(J(new L,["",""]))),lg=[pf(qf(),Lt(Ag))];Ie=G(new H,sf(hh,J(new L,lg)),Ag.C())}else throw new x(Cf);}if(null!==Ie)var Uh=G(new H,Ie.i(),Ie.j());else throw new x(Ie);var Zg=Uh.j(),Vh=sf(new mf(new nf(J(new L,["Expected 'then'/'else' clause after 'if'; found "," instead"]))),J(new L,
-[Uh.i()])),fj=G(new H,Vh,Zg),gj=sf(new mf(new nf(J(new L,["Note: 'if' expression starts here:"]))),v());t();var Li=G(new H,gj,new M(sg)),Mi=O().c;wf(a,new A(fj,new A(Li,Mi)));t();var hj=new tm(new lt(Ag,fs(a)),t().f);return new me(hj)}throw new x(Se);}}}var Fj=O().c;if(null===Fj?null===m:Fj.h(m)){var Qj=new mf(new nf(J(new L,["Unexpected end of ","; an expression was expected here"]))),Ni=[pf(qf(),a.KD)],Gj=sf(Qj,J(new L,Ni)),Hj=bs(a),lk=G(new H,Gj,Hj),md=O().c;wf(a,new A(lk,md));t();var Ue=fs(a);
-return new me(Ue)}if(k){var Jd=l.A;if(null!==Jd){var uf=Jd.i(),Dl=Jd.j();if(nr()===uf){t();var gl=new Jo(!0);t();var am=aq(gl,new M(Dl));return new me(am)}}}if(k){var xk=l.A;if(null!==xk){var Ae=xk.i(),Ff=xk.j();if(Ae instanceof Kr){var vf=Ae.Qf;if("-"===Ae.Df&&!0===vf){is(a,new ff(822),new gf("exprOrIf"));var Xf=new Wl("-");t();var Ij=aq(Xf,new M(Ff)),Rj=js(a,Bt("-").Lc(),e,new ff(824));if(Rj instanceof Do)return tt(a,new Do(Ot(Rj.Rr)),b,!1,d,e,new ff(826));if(null!==Rj){if(a.Lw){Gt();var hl=[new Do(Bq()),
-Rj],El=new mm(Ij,Ht(J(new L,hl)))}else{Gt();var on=[new Do(Bq())],Oi=new mm(Ij,Ht(J(new L,on)));Gt();El=new mm(Oi,Ht(J(new L,[Rj])))}return tt(a,El,b,!1,d,e,new ff(828))}throw new x(Rj);}}}}if(k){var ee=l.A;if(null!==ee){var Re=ee.i(),Ji=ee.j(),jk=new mf(new nf(J(new L,["Unexpected "," in expression position"]))),Vg=[pf(qf(),Re.yb())],kk=sf(jk,J(new L,Vg));t();var eo=G(new H,kk,new M(Ji)),dr=O().c;wf(a,new A(eo,dr));is(a,new ff(835),new gf("exprOrIf"));return ot(a,b,!0,d,!0,new ff(836))}}throw new x(m);
-}),g,new gf("exprOrIf"))}catch(k){if(k instanceof gq){g=k;if(g.Hg===h)return g.wj();throw g;}throw k;}}
-function tt(a,b,c,d,e,g,h){return Xr(a,new U(()=>new Ul(c,"`"+b+"`",d)),new z(()=>{var k=!1,l=null,m=ef(a,new ff(844),new gf("exprCont"));if(m instanceof A){k=!0;l=m;var n=l.A;if(null!==n){var r=n.i(),u=n.j();if(mr()===r&&hf(new E(c),0)){is(a,new ff(846),new gf("exprCont"));var w=hs(a);if(w instanceof A){var y=w.A;if(null!==y){var B=y.i();Gr()===B&&is(a,new ff(848),new gf("exprCont"))}}var D=js(a,c,g,new ff(851));t();var C=new Wl(",");t();var F=aq(C,new M(u));Gt();var I=new mm(F,Ht(J(new L,[b,D])));
-return new me(I)}}}if(k){var K=l.A,N=l.r;if(null!==K){var P=K.i();if(P instanceof Jr&&"\x3d\x3e"===P.Ta&&N instanceof A){var T=N.A;if(null!==T){var aa=T.i();if(Gr()===aa&&Bt("\x3d\x3e").Gx()>c){is(a,new ff(854),new gf("exprCont"));var Y=new pm(zf(cf(a)));t();Gt();var S=new lm(Ht(J(new L,[b])),Y);return new me(S)}}}}}if(k){var Z=l.A;if(null!==Z){var ka=Z.i();if(ka instanceof Jr&&"\x3d\x3e"===ka.Ta&&Bt("\x3d\x3e").Gx()>c){is(a,new ff(858),new gf("exprCont"));var X=js(a,1,g,new ff(859));Gt();var sa=
-new lm(Ht(J(new L,[b])),X);return tt(a,sa,c,d,e,g,new ff(861))}}}if(k){var Ia=l.A,Za=l.r;if(null!==Ia){var Ga=Ia.i(),xa=Ia.j();if(Ga instanceof Kr&&"."===Ga.Df&&Za instanceof A){var Ra=Za.A;if(null!==Ra){var Ja=Ra.i(),La=Ra.j();if(Ja instanceof Qr){var pb=Ja.Tc,Fb=Ja.$d;if(nl()===pb){is(a,new ff(863),new gf("exprCont"));is(a,new ff(864),new gf("exprCont"));t();var Gb=new M(Ja.Ig),Hb=Ja.yb(),tb=Is(new Us(a,Fb,Gb,Hb),new z(de=>js(de,0,g,new ff(866)))),kb=new sm(b,tb);t();var gb=Zs(Rr(xa,La),tb.C()),
-Vb=aq(kb,new M(gb));return tt(a,Vb,c,d,e,g,new ff(868))}}}}}}if(k){var bb=l.A;if(null!==bb){var nb=bb.i(),Tb=bb.j();if(nb instanceof Kr){var ub=nb.Df;if(!0===nb.Qf&&Bt(ub).Gx()>c){is(a,new ff(870),new gf("exprCont"));var Ub=new Wl(ub);t();var $a=aq(Ub,new M(Tb)),cb=hs(a);if(cb instanceof A){var Na=cb.A;if(null!==Na){var Ca=Na.i();Gr()===Ca&&is(a,new ff(873),new gf("exprCont"))}}var Ba=ot(a,Bt(ub).Lc(),!0,e,g,new ff(876));if(Ba instanceof te){var Oa=Ba.ca;t();var wa=new kt(b,$a,Oa);return new te(wa)}if(Ba instanceof
-me){var ea=Ba.ia;if("with"===ub)a:if(ea instanceof Zl)var la=new qm(b,ea);else{if(ea instanceof hm){var Ka=ea.Sh;if(!0===ea.Sk&&Ka instanceof Zl){la=new qm(b,Ka);break a}}var Ua=new mf(new nf(J(new L,["record literal expected here; found ",""]))),ya=[pf(qf(),Lt(ea))],ib=sf(Ua,J(new L,ya)),Lb=ea.C(),ec=G(new H,ib,Lb),Mb=O().c;wf(a,new A(ec,Mb));la=b}else if(a.Lw)Gt(),la=new mm($a,Ht(J(new L,[b,ea])));else{Gt();var Jb=new mm($a,Ht(J(new L,[b])));Gt();la=new mm(Jb,Ht(J(new L,[ea])))}return tt(a,la,c,
-d,e,g,new ff(880))}throw new x(Ba);}}}}if(k){var Kb=l.A;if(null!==Kb){var eb=Kb.i();if(eb instanceof Jr&&":"===eb.Ta&&c<=(ks().Rp.n(hd(58))|0)){is(a,new ff(897),new gf("exprCont"));t();var Wb=new em(b,Ws(a,g,new ff(898)));return new me(Wb)}}}if(k){var mc=l.A;if(null!==mc){var ua=mc.i(),Pa=mc.j();if(ua instanceof Jr&&"where"===ua.Ta&&1>=c){is(a,new ff(900),new gf("exprCont"));var xb=Ts(a),Yb=new wm(b,zf(xb));t();var zb=aq(Yb,new M(Pa));return tt(a,zb,c,!1,e,g,new ff(903))}}}if(k){var Sb=l.A;if(null!==
-Sb){var Ma=Sb.i();if(lf()===Ma)return is(a,new ff(905),new gf("exprCont")),tt(a,b,c,d,e,g,new ff(906))}}if(k){var Ea=l.A;if(null!==Ea){var ab=Ea.i(),Db=Ea.j();if(ab instanceof Lr){var mb=ab.Xw;is(a,new ff(908),new gf("exprCont"));var vb=new Wl(mb);t();return tt(a,new nm(b,aq(vb,new M(Db))),c,d,e,g,new ff(909))}}}if(k){var Ya=l.A;if(null!==Ya){var Wa=Ya.i();if(Wa instanceof Qr){var rb=Wa.Tc,pa=Wa.$d;if(pl()===rb&&pa instanceof A){var Fa=pa.A,Ib=pa.r;if(null!==Fa){var qb=Fa.i(),Nb=Fa.j();if(qb instanceof
-Lr){var fc=qb.Xw;if(1>=c){is(a,new ff(912),new gf("exprCont"));t();var Ac=new M(Wa.Ig),tc=Wa.yb(),vc=Is(new Us(a,Ib,Ac,tc),new z(de=>{var Ee=new Wl(fc);t();return tt(de,new nm(b,aq(Ee,new M(Nb))),0,!0,e,g,new ff(913))}));if(d){if(vc instanceof te){var sc=vc.ca;t();return new te(sc)}if(vc instanceof me)return tt(a,vc.ia,0,d,e,g,new ff(916));throw new x(vc);}return vc}}}}}}}if(k){var uc=l.A;if(null!==uc){var lc=uc.i();if(lc instanceof Qr){var Wc=lc.Tc,Cc=lc.$d;if(pl()===Wc&&Cc instanceof A){var Dc=
-Cc.A,Ec=Cc.r;if(null!==Dc){var Ic=Dc.i(),Xc=Dc.j();if(Ic instanceof Kr){var Sc=Ic.Df;if(!0===Ic.Qf){is(a,new ff(920),new gf("exprCont"));t();var oc=new M(lc.Ig),qc=lc.yb();return Is(new Us(a,Ec,oc,qc),new z(de=>Pt(de,b,Sc,Xc,e,g,new ff(921))))}}}}}}}if(k){var Tc=l.A;if(null!==Tc){var Nc=Tc.i();if(Nc instanceof Jr&&"then"===Nc.Ta&&hf(new E(c),0)){is(a,new ff(924),new gf("exprCont"));t();var Pc=new lt(b,rt(a,e,g,new ff(925)));return new te(Pc)}}}if(k){var Oc=l.A,$c=l.r;if(null!==Oc){var Lc=Oc.i();if(Gr()===
-Lc&&$c instanceof A){var Zb=$c.A;if(null!==Zb){var ed=Zb.i();if(ed instanceof Jr&&"then"===ed.Ta&&hf(new E(c),0)){is(a,new ff(927),new gf("exprCont"));is(a,new ff(928),new gf("exprCont"));t();var $b=new lt(b,rt(a,e,g,new ff(929)));return new te($b)}}}}}if(k){var Fc=l.A;if(null!==Fc){var Yc=Fc.i();if(Gr()===Yc&&d)return is(a,new ff(931),new gf("exprCont")),tt(a,b,0,d,e,g,new ff(932))}}if(k){var nc=l.A;if(null!==nc){var Ob=nc.i(),cc=nc.j();if(Ob instanceof Qr){var Gc=Ob.Tc,Bc=Ob.$d;if(ml()===Gc&&c<=
-ks().oH){is(a,new ff(935),new gf("exprCont"));t();var qd=new M(Ob.Ig),Gd=Ob.yb(),cd=Is(new Us(a,Bc,qd,Gd),new z(de=>Ts(de)));t();var rd=aq(cd,new M(cc));return tt(a,new zm(b,rd),c,d,e,g,new ff(937))}}}}if(k){var Id=l.A;if(null!==Id){var Ha=Id.i();a:if(mr()===Ha)var jc=!0;else if(nr()===Ha)jc=!0;else if(Gr()===Ha)jc=!0;else{if(Ha instanceof Jr){var Rb=Ha.Ta;if("then"===Rb||"else"===Rb||"in"===Rb||"\x3d"===Rb){jc=!0;break a}}if(Ha instanceof Kr&&!0===Ha.Qf)jc=!0;else{if(Ha instanceof Qr){var Uc=Ha.Tc;
-if(ml()===Uc){jc=!0;break a}}jc=!1}}if(jc)return t(),new me(b)}}if(k){var Rc=l.A;if(null!==Rc){var Cd=Rc.i();if(Cd instanceof Jr&&"of"===Cd.Ta&&1>=c){is(a,new ff(943),new gf("exprCont"));var od=Ys(a,g,e),Va=new mm(b,new im(od));return tt(a,Va,c,d,e,g,new ff(946))}}}if(k){var wb=l.A;if(null!==wb){var db=wb.i();if(db instanceof Qr){var Jc=db.Tc,Vc=db.$d;if(pl()===Jc&&Vc instanceof A){var Ta=Vc.A,kd=Vc.r;if(null!==Ta){var ld=Ta.i();if(ld instanceof Jr&&"of"===ld.Ta&&1>=c){is(a,new ff(948),new gf("exprCont"));
-t();var qe=new M(db.Ig),Wd=db.yb(),Rd=Is(new Us(a,kd,qe,Wd),new z(de=>{var Ee=Ys(de,g,e);return tt(de,new mm(b,new im(Ee)),0,!0,e,g,new ff(956))}));if(Rd instanceof te){var Me=Rd.ca;t();return new te(Me)}if(Rd instanceof me)return tt(a,Rd.ia,0,d,e,g,new ff(961));throw new x(Rd);}}}}}}if(k){var wc=l.A;if(null!==wc){var Xb=wc.i();if(Xb instanceof Qr){var gc=Xb.Tc,hc=Xb.$d;if(pl()===gc&&hc instanceof A){var gd=hc.A;if(null!==gd){var kc=gd.i();if(kc instanceof Jr){var ud=kc.Ta;if("then"===ud||"else"===
-ud)return t(),new me(b)}}}}}}if(k){var za=l.A;if(null!==za){var Qa=za.i();if(Qa instanceof Qr){var xc=Qa.Tc,yd=Qa.$d;if(pl()===xc&&yd instanceof A){var be=yd.A;if(null!==be){var yc=be.i();if(yc instanceof Qr){var Od=yc.Tc;if((ll()===Od||nl()===Od)&&1>=c){is(a,new ff(977),new gf("exprCont"));t();var sd=new M(Qa.Ig),he=Qa.yb(),ue=Is(new Us(a,yd,sd,he),new z(de=>tt(de,b,0,!0,e,g,new ff(978))));if(ue instanceof te){var sg=ue.ca;t();return new te(sg)}if(ue instanceof me)return tt(a,ue.ia,0,d,e,g,new ff(981));
-throw new x(ue);}}}}}}}if(k){var Se=l.A;if(null!==Se){var Kf=Se.i(),$e=Se.j();if(Kf instanceof Qr){var rf=Kf.Tc,He=Kf.$d;if(ol()===rf||nl()===rf){is(a,new ff(985),new gf("exprCont"));t();var Ze=new M(Kf.Ig),jf=Kf.yb(),tf=Is(new Us(a,He,Ze,jf),new z(de=>Ys(de,g,e))),Te=new km(b,ht(tf,new z(de=>{if(null!==de){var Ee=de.i();de=de.j();if(t().f===Ee&&null!==de&&(Ee=de.vc,de=de.Da,null!==Ee)){var Sh=Ee.si;if(!1===Ee.pf&&!1===Sh){Ee=An(de);if(Ee instanceof te){var hi=Ee.ca;Fs(a,new U(()=>hi),g);return Jl()}if(Ee instanceof
-me)return Ee.ia;throw new x(Ee);}}}$n()}))),hg=b.C(),eh=new U(()=>bt().n($e)),fh=new z(de=>{de=Rr(de,$e);return bt().n(de)}),tg=hg.b()?Zr(eh):fh.n(hg.o()),Jg=aq(Te,tg);return tt(a,Jg,c,d,e,g,new ff(995))}}}}if(k){var Gh=l.A;if(null!==Gh){var zg=Gh.i(),ig=Gh.j();if(zg instanceof Qr){var qh=zg.Tc,gh=zg.$d;if(ll()===qh&&c<=ks().oH){is(a,new ff(1004),new gf("exprCont"));t();var Wg=new M(zg.Ig),Uf=zg.yb(),rh=Is(new Us(a,gh,Wg,Uf),new z(de=>Ys(de,g,e))),Rh=new im(rh);t();var Sg=new mm(b,aq(Rh,new M(ig)));
-return tt(a,Sg,c,d,e,g,new ff(1007))}}}}if(k){var Hh=l.A;if(null!==Hh){var Xg=Hh.i();if(Xg instanceof Jr&&"of"===Xg.Ta){is(a,new ff(1010),new gf("exprCont"));var jg=Ys(a,g,e),Ag=new mm(b,new im(jg));return tt(a,Ag,c,d,e,g,new ff(1014))}}}if(k){var Cf=l.A.i();a:{if(Cf instanceof Jr){var Bg=Cf.Ta;if(":"===Bg||"of"===Bg||"where"===Bg||"extends"===Bg){var Lf=!0;break a}}if(nr()===Cf)Lf=!0;else{if(Cf instanceof Qr){var Df=Cf.Tc;if(ll()===Df||nl()===Df){Lf=!0;break a}}if(Cf instanceof Qr){var kg=Cf.Tc,
-df=Cf.$d;if(pl()===kg&&df instanceof A){var Kg=df.A;if(null!==Kg){var Mf=Kg.i();b:if(Mf instanceof Jr&&"of"===Mf.Ta)var Vf=!0;else if(nr()===Mf)Vf=!0;else{if(Mf instanceof Qr){var Cg=Mf.Tc;if(ll()===Cg||nl()===Cg){Vf=!0;break b}}Vf=Mf instanceof Lr?!0:!1}if(Vf){Lf=!0;break a}}}}Lf=!1}}if(!Lf){var Ef=Ys(a,g,e),Wf=new mm(b,new im(Ef));Fs(a,new U(()=>{Fq();var de=sf(new mf(new nf(J(new L,["Paren-less applications should use the 'of' keyword"]))),v()),Ee=Wf.C();de=G(new H,de,Ee);Ee=O().c;return Hq(0,
-new A(de,Ee),!0,Qt())}),g);return tt(a,Wf,c,d,e,g,new ff(1030))}}t();return new me(b)}),h,new gf("exprCont"))}
-function Pt(a,b,c,d,e,g,h){var k=new U(()=>G(new H,"`"+b+"`",c)),l=new gf("opBlock");Yr(a,new U(()=>{var Ja=l.Gm,La=Zr(k);La=$r(La)?Qe(La,"(",",",")"):as(La)?Zr(k):"("+Zr(k)+")";return"@ "+Ja+La+"    [at l."+h.Nl+"]"}));try{a.Rd=1+a.Rd|0;var m=new Wl(c);t();var n=aq(m,new M(d)),r=ot(a,0,!0,e,g,new ff(1038));if(r instanceof me){var u=r.ia;Gt();var w=new mm(n,Ht(J(new L,[b,u]))),y=ef(a,new ff(1043),new gf("opBlock"));a:{if(y instanceof A){var B=y.A,D=y.r;if(null!==B){var C=B.i();if(Gr()===C){is(a,new ff(1045),
-new gf("opBlock"));d=!1;m=null;if(D instanceof A){d=!0;m=D;var F=m.A;if(null!==F){var I=F.i(),K=F.j();if(I instanceof Kr){var N=I.Df;if(!0===I.Qf){is(a,new ff(1048),new gf("opBlock"));var P=Pt(a,w,N,K,e,g,new ff(1049));break a}}}}if(d){var T=m.A;if(null!==T){var aa=T.i(),Y=T.j(),S=new mf(new nf(J(new L,["Unexpected "," in operator block"]))),Z=[pf(qf(),aa.yb())],ka=sf(S,J(new L,Z));t();var X=G(new H,ka,new M(Y)),sa=O().c;wf(a,new A(X,sa));is(a,new ff(1052),new gf("opBlock"));t();P=new me(w);break a}}var Ia=
-O().c;if(null===Ia?null===D:Ia.h(D)){t();P=new me(w);break a}throw new x(D);}}}t();P=new me(w)}}else if(r instanceof te){var Za=r.ca;t();var Ga=G(new H,n,Za),xa=O().c,Ra=new Rt(b,St(a,new A(Ga,xa),e,g));P=new te(Ra)}else throw new x(r);}finally{a.Rd=-1+a.Rd|0}Yr(a,new U(()=>"\x3d "+P));return P}
-function St(a,b,c,d){var e=new U(()=>b),g=new ff(1064),h=new gf("opIfBlock");Yr(a,new U(()=>{var N=h.Gm,P=Zr(e);P=$r(P)?Qe(P,"(",",",")"):as(P)?Zr(e):"("+Zr(e)+")";return"@ "+N+P+"    [at l."+g.Nl+"]"}));try{a.Rd=1+a.Rd|0;var k=ef(a,new ff(1065),new gf("opIfBlock"));a:{if(k instanceof A){var l=k.A,m=k.r;if(null!==l){var n=l.i();if(Gr()===n){is(a,new ff(1067),new gf("opIfBlock"));if(m instanceof A){var r=m.A;if(null!==r){var u=r.i(),w=r.j();if(u instanceof Kr){var y=u.Df;if(!0===u.Qf){is(a,new ff(1070),
-new gf("opIfBlock"));var B=ot(a,0,!0,c,d,new ff(1071));if(B instanceof me)$n();else if(B instanceof te){var D=B.ca,C=new Wl(y);t();var F=aq(C,new M(w)),I=G(new H,F,D);var K=St(a,new A(I,b),c,d);break a}else throw new x(B);}}}}$n()}}}K=jp(b)}}finally{a.Rd=-1+a.Rd|0}Yr(a,new U(()=>"\x3d "+K));return K}
-function dt(a,b,c){var d=!1,e=null,g=hs(a);a:{if(g instanceof A){d=!0;e=g;g=e.A;var h=e.r;if(null!==g){var k=g.i();g=g.j();if(k instanceof Jr&&"in"===k.Ta&&h instanceof A&&(k=h.A,null!==k&&(h=k.i(),k=k.j(),h instanceof Jr&&"out"===h.Ta))){is(a,new ff(1097),new gf("vinfo"));t();d=G(new H,Tt().En,Rr(g,k));d=new M(d);break a}}}if(d&&(h=e.A,null!==h&&(g=h.i(),h=h.j(),g instanceof Jr&&"in"===g.Ta))){is(a,new ff(1100),new gf("vinfo"));t();d=G(new H,Tt().cA,h);d=new M(d);break a}if(d&&(e=e.A,null!==e&&(d=
-e.i(),e=e.j(),d instanceof Jr&&"out"===d.Ta))){is(a,new ff(1103),new gf("vinfo"));t();d=G(new H,Tt().bA,e);d=new M(d);break a}d=t().f}e=hs(a);if(e instanceof A&&(g=e.A,null!==g&&(e=g.i(),g=g.j(),e instanceof Kr&&(h=e.Df,!1===e.Qf)))){is(a,new ff(1109),new gf("typeParams"));e=new sp(h);t();e=aq(e,new M(g));g=hs(a);if(g instanceof A&&(g=g.A,null!==g&&(g=g.i(),mr()===g)))return is(a,new ff(1113),new gf("typeParams")),d.b()?d=R():(d=d.o(),d=new M(d.i())),d=G(new H,d,e),a=dt(a,b,c),new A(d,a);d.b()?a=
-R():(a=d.o(),a=new M(a.i()));a=G(new H,a,e);b=O().c;return new A(a,b)}a:{if(d instanceof M&&(b=d.k,null!==b)){b=b.j();c=sf(new mf(new nf(J(new L,["dangling variance information"]))),v());t();b=G(new H,c,new M(b));c=O().c;wf(a,new A(b,c));break a}if(t().f!==d)throw new x(d);}return O().c}
-function ct(a,b){var c=ef(a,new ff(1130),new gf("maybeIndented"));if(c instanceof A&&(c=c.A,null!==c)){var d=c.i();if(d instanceof Qr){var e=d.Tc;c=d.$d;if(pl()===e)a:{if(e=c.Og(),e instanceof M&&(e=e.k,null!==e&&(e=e.i(),e instanceof Jr&&(e=e.Ta,"then"===e||"else"===e)))){e=!1;break a}e=!0}else e=!1;if(e){is(a,new ff(1135),new gf("maybeIndented"));t();e=new M(d.Ig);d=d.yb();a=new Us(a,c,e,d);var g=b.aa(a,!0);for(b=ef(a,new ff(145),new gf("concludeWith"));;)if(b.b()?c=!1:(c=b.e(),hf(new E(c.i()),
-lf())||hf(new E(c.i()),Gr())?(is(a,new ff(145),new gf("concludeWith")),c=!0):c=!1),c)b=b.g();else break;d=b;a:{if(d instanceof A&&(c=d.A,null!==c)){b=c.i();for(c=c.j();;)if(d.b()?e=!1:(e=d.e().i(),e=hf(new E(e),lf())),e)d=d.g();else break;d=d.Og();b=d.b()?G(new H,b,c):d.o();if(null===b)throw new x(b);c=b.i();b=b.j();d=new mf(new nf(J(new L,["Unexpected "," here"])));c=[pf(qf(),c.yb())];c=sf(d,J(new L,c));t();b=G(new H,c,new M(b));c=O().c;wf(a,new A(b,c));break a}b=O().c;if(null===b?null!==d:!b.h(d))throw new x(d);
-}Yr(a,new U(()=>"Concluded with "+g));return g}}}return b.aa(a,!1)}
-function Ys(a,b,c){var d=ef(a,new ff(1130),new gf("maybeIndented"));a:{if(d instanceof A&&(d=d.A,null!==d)){var e=d.i();if(e instanceof Qr){var g=e.Tc;d=e.$d;if(pl()===g)b:{if(g=d.Og(),g instanceof M&&(g=g.k,null!==g&&(g=g.i(),g instanceof Jr&&(g=g.Ta,"then"===g||"else"===g)))){g=!1;break b}g=!0}else g=!1;if(g){is(a,new ff(1135),new gf("maybeIndented"));t();g=new M(e.Ig);e=e.yb();a=new Us(a,d,g,e);var h=pt(a,!0,ks().Vt,b,c);for(b=ef(a,new ff(145),new gf("concludeWith"));;)if(b.b()?c=!1:(c=b.e(),hf(new E(c.i()),
-lf())||hf(new E(c.i()),Gr())?(is(a,new ff(145),new gf("concludeWith")),c=!0):c=!1),c)b=b.g();else break;d=b;b:{if(d instanceof A&&(c=d.A,null!==c)){b=c.i();for(c=c.j();;)if(d.b()?e=!1:(e=d.e().i(),e=hf(new E(e),lf())),e)d=d.g();else break;d=d.Og();b=d.b()?G(new H,b,c):d.o();if(null===b)throw new x(b);c=b.i();b=b.j();d=new mf(new nf(J(new L,["Unexpected "," here"])));c=[pf(qf(),c.yb())];c=sf(d,J(new L,c));t();b=G(new H,c,new M(b));c=O().c;wf(a,new A(b,c));break b}b=O().c;if(null===b?null!==d:!b.h(d))throw new x(d);
-}Yr(a,new U(()=>"Concluded with "+h));a=h;break a}}}a=pt(a,!1,ks().Vt,b,c)}return a}
-function pt(a,b,c,d,e){b=Ut(a,O().c,O().c,b,c,d,e);for(d=c=null;b!==v();){var g=b.e();a:{if(null!==g){e=g.i();var h=g.j();if(h instanceof te){h=h.ca;g=sf(new mf(new nf(J(new L,["Unexpected 'then'/'else' clause"]))),v());h=h.C();g=G(new H,g,h);h=O().c;wf(a,new A(g,h));g=new ws(Ct().Kg,fs(a));e=G(new H,e,g);g=O().c;e=new A(e,g);break a}}if(null!==g&&(e=g.i(),h=g.j(),h instanceof me)){e=G(new H,e,h.ia);g=O().c;e=new A(e,g);break a}throw new x(g);}for(e=new lq(e);e.s();)g=new A(e.t(),v()),null===d?c=
-g:d.r=g,d=g;b=b.g()}return null===c?v():c}
-function Ut(a,b,c,d,e,g,h){var k=new U(()=>G(new H,b,c)),l=new ff(1173),m=new gf("argsOrIf");Yr(a,new U(()=>{var Ib=m.Gm,qb=Zr(k);qb=$r(qb)?Qe(qb,"(",",",")"):as(qb)?Zr(k):"("+Zr(k)+")";return"@ "+Ib+qb+"    [at l."+l.Nl+"]"}));try{a.Rd=1+a.Rd|0;var n=!1,r=null,u=ef(a,new ff(1175),new gf("argsOrIf"));a:{var w=O().c;if(null===w?null===u:w.h(u))if(c instanceof A){var y=c.A,B=c.r,D=t().f;t();var C=new ws(Ct().Kg,new pm(jp(new A(y,B)))),F=G(new H,D,new me(C));var I=jp(new A(F,b));break a}else{var K=O().c;
-if(null===K?null===c:K.h(c)){I=jp(b);break a}else throw new x(c);}if(u instanceof A){n=!0;r=u;var N=r.A;if(null!==N){var P=N.i();if(lf()===P){is(a,new ff(1184),new gf("argsOrIf"));I=Ut(a,b,c,d,e,g,h);break a}}}if(n){var T=r.A;if(null!==T){var aa=T.i();if(Gr()===aa){gp(fp(),c.b());I=jp(b);break a}}}if(n){var Y=r.A;if(null!==Y){var S=Y.i();if(S instanceof Kr){var Z=S.Df;if(!0===S.Qf&&sr(new E(Z),"-")){gp(fp(),c.b());I=jp(b);break a}}}}var ka=hs(a);b:{if(ka instanceof A){var X=ka.A;if(null!==X){var sa=
-X.i(),Ia=X.j();if(sa instanceof Jr&&"val"===sa.Ta){is(a,new ff(1198),new gf("argVal"));t();var Za=new M(Ia);break b}}}Za=t().f}var Ga=hs(a);b:{if(Ga instanceof A){var xa=Ga.A;if(null!==xa){var Ra=xa.i(),Ja=xa.j();if(Ra instanceof Jr&&"mut"===Ra.Ta){is(a,new ff(1204),new gf("argMut"));t();var La=new M(Ja);break b}}}La=t().f}var pb=hs(a);b:{if(pb instanceof A){var Fb=pb.A;if(null!==Fb){var Gb=Fb.i(),Hb=Fb.j();if(Gb instanceof Jr&&"#"===Gb.Ta){is(a,new ff(1210),new gf("argSpec"));t();var tb=new M(Hb);
-break b}}}tb=t().f}n=!1;r=null;var kb=hs(a);b:{if(kb instanceof A){n=!0;r=kb;var gb=r.A,Vb=r.r;if(null!==gb){var bb=gb.i(),nb=gb.j();if(bb instanceof Kr){var Tb=bb.Df;if(!1===bb.Qf&&Vb instanceof A){var ub=Vb.A;if(null!==ub){var Ub=ub.i();if(Ub instanceof Jr&&":"===Ub.Ta){is(a,new ff(1216),new gf("argName"));is(a,new ff(1217),new gf("argName"));t();var $a=new Wl(Tb);t();var cb=aq($a,new M(nb));var Na=new M(cb);break b}}}}}}if(n){var Ca=r.A,Ba=r.r;if(null!==Ca){var Oa=Ca.i(),wa=Ca.j();if(Oa instanceof
-rr){var ea=Oa.Dw;if(ea instanceof Do){var la=ea.Rr;if(Ba instanceof A){var Ka=Ba.A;if(null!==Ka){var Ua=Ka.i();if(Ua instanceof Jr&&":"===Ua.Ta){is(a,new ff(1220),new gf("argName"));is(a,new ff(1221),new gf("argName"));t();var ya=new Wl(la.u());t();var ib=aq(ya,new M(wa));Na=new M(ib);break b}}}}}}}Na=t().f}var Lb=ot(a,e,!0,h,g,new ff(1226));if(Lb instanceof me)var ec=Lb.ia,Mb=new me(new ws(new jt(!La.b(),!tb.b(),!Za.b()),ec));else Mb=Lb;e=!1;Za=null;var Jb=ef(a,new ff(1234),new gf("argsOrIf"));if(Jb instanceof
-A){e=!0;Za=Jb;var Kb=Za.A,eb=Za.r;if(null!==Kb){var Wb=Kb.i();if(mr()===Wb&&eb instanceof A){var mc=eb.A;if(null!==mc){var ua=mc.i();if(Gr()===ua){is(a,new ff(1236),new gf("argsOrIf"));is(a,new ff(1237),new gf("argsOrIf"));var Pa=ps(c,Na,Mb);I=Ut(a,new A(Pa,b),O().c,d,ks().Vt,g,h);break a}}}}}if(e){var xb=Za.A;if(null!==xb){var Yb=xb.i();if(mr()===Yb){is(a,new ff(1240),new gf("argsOrIf"));var zb=ps(c,Na,Mb);I=Ut(a,new A(zb,b),O().c,d,ks().Vt,g,h);break a}}}if(e){var Sb=Za.A;if(null!==Sb){var Ma=Sb.i();
-if(Gr()===Ma&&d){is(a,new ff(1243),new gf("argsOrIf"));if(Na instanceof M){var Ea=Na.k,ab=sf(new mf(new nf(J(new L,["Unexpected named argument name here"]))),v()),Db=Ea.C(),mb=G(new H,ab,Db),vb=O().c;wf(a,new A(mb,vb))}else if(t().f!==Na)throw new x(Na);Na=!1;Mb instanceof te&&$n();if(Mb instanceof me){Na=!0;var Ya=Mb.ia;if(null!==Ya){var Wa=Ya.vc,rb=Ya.Da;if(null!==Wa){var pa=Wa.si;if(!1===Wa.pf&&!1===pa){I=Ut(a,b,new A(rb,c),d,ks().Vt,g,h);break a}}}}Na&&$n();throw new x(Mb);}}}var Fa=ps(c,Na,Mb);
-I=jp(new A(Fa,b))}}finally{a.Rd=-1+a.Rd|0}Yr(a,new U(()=>"\x3d "+I));return I}
-function It(a,b,c){for(;;){var d=!1,e=null,g=ef(a,new ff(1263),new gf("bindings"));if(g instanceof A&&(d=!0,e=g,g=e.A,null!==g&&(g=g.i(),lf()===g))){is(a,new ff(1265),new gf("bindings"));continue}if(d&&(g=e.A,null!==g&&(g=g.i(),g=Gr()===g?!0:g instanceof Kr&&!0===g.Qf?!0:nr()===g?!0:!1,g)))return jp(b);if(d&&(d=e.A,null!==d&&(e=d.i(),d=d.j(),e instanceof Kr&&(g=e.Df,!1===e.Qf)))){is(a,new ff(1270),new gf("bindings"));e=Ns(a,new Jr("\x3d"),Ps(),!1,new U(()=>O().c),c);if(null===e)throw new x(e);e=e.Xc();
-e=Gs(ks(),c)||!e;e=js(a,0,e,new ff(1272));g=new Wl(g);t();d=aq(g,new M(d));g=ef(a,new ff(1279),new gf("bindings"));if(g instanceof A&&(g=g.A,null!==g&&(g=g.i(),mr()===g))){is(a,new ff(1281),new gf("bindings"));d=G(new H,d,e);b=new A(d,b);continue}a=G(new H,d,e);return jp(new A(a,b))}return O().c}}function Xs(a,b){b=An(b);if(b instanceof te)return b=b.ca,Gs(ks(),!1)||a.Xt.n(b),Jl();if(b instanceof me)return b.ia;throw new x(b);}
-function Vt(){this.Vt=this.iN=0;this.Rp=null;this.oH=0;Wt=this;this.iN=0;this.Vt=1+this.iN|0;O();var a=J(new L,";;;;;;,;\x3d;@;:;|;/ \\;^;\x26;!;\x3c \x3e;+ -;* %;;.".split(";"));a=le(v(),a);a=mg(a);for(var b=null,c=null;a!==v();){var d=a.e();if(null===d)throw new x(d);var e=d.i();d=d.Lc();for(var g=e.length,h=Xt(g),k=0;k<g;){var l=e.charCodeAt(k);hf(new E(hd(l)),hd(32))||(l=String.fromCharCode(l),h.ha=""+h.ha+l);k=1+k|0}e=g===h.K()?e:h.ha;g=e.length;h=new jd(g);for(k=0;k<g;){l=k;var m=e.charCodeAt(k);
-h.a[l]=G(new H,hd(m),1+d|0);k=1+k|0}for(d=Yt(new Zt,(new $t(h)).Zm);d.s();)e=new A(d.t(),v()),null===c?b=e:c.r=e,c=e;a=a.g()}a=null===b?v():b;ap();this.Rp=bp(cp(),a).SL(2147483647);this.oH=-1+(this.Rp.n(hd(46))|0)|0}Vt.prototype=new p;Vt.prototype.constructor=Vt;function Gs(a,b){return hf(new E(b),!0)}
-function Bt(a){var b=ks();switch(a){case "is":return new au(4,4);case "and":return new au(3,3);case "or":return new au(2,2);case "\x3d\x3e":return a=b.Rp.n(hd(46))|0,new au(a,1);default:a:{for(var c=a.length,d=0;d<c;){var e=a.charCodeAt(d);if(Zq($q(),e)){c=d;break a}d=1+d|0}c=-1}if(-1!==c)return new au(5,5);c=bu(Q(),a);return new au(b.Rp.n(hd(cu(Q(),a)))|0,(b.Rp.n(hd(c))|0)-(hf(new E(hd(c)),hd(64))||hf(new E(hd(c)),hd(47))||hf(new E(hd(c)),hd(44))||hf(new E(hd(c)),hd(58))?1:0)|0)}}
-Vt.prototype.$classData=q({pW:0},!1,"mlscript.NewParser$",{pW:1,d:1});var Wt;function ks(){Wt||(Wt=new Vt);return Wt}function Cs(a){this.nH=null;if(null===a)throw null;this.nH=a}Cs.prototype=new p;Cs.prototype.constructor=Cs;
-Cs.prototype.jC=function(a){if(a instanceof A){var b=a.A,c=a.r;if(null!==b&&(b=b.i(),lf()===b&&null!==c&&(c=Bs(this.nH).jC(c),!c.b()))){var d=c.k.i();a=c.k.j();t();a=G(new H,new U(()=>{Zr(d);is(this.nH,new ff(94),new gf("unapply"))}),a);return new M(a)}}t();a=G(new H,new U(()=>{}),a);return new M(a)};Cs.prototype.$classData=q({tW:0},!1,"mlscript.NewParser$Spaces$",{tW:1,d:1});
-function du(a,b){if(a instanceof eu){var c=a.lc,d=a.Jd,e=a.be,g=a.rf;a=b?fu(e):e;c.b()?e=!0:(e=c.o(),e instanceof gu?(e=e.ed,Q(),e=new sp(hu(0,e.vi)),e=!!g.Y(e).b()):e=!0);e=e?c:R();c=new iu(g);e.b()||(g=e.o(),e=V(g.p),a=ju(g,a,e,!1));a=ku(c,a,new Um((h,k)=>{var l=V(h.p);return ju(h,k,l,!1)}));if(b){Cr();if(0<=d.Q())b=d.Q(),b=new (Nd(lu).Ja)(b),d.yc(b,0,2147483647),d=b;else{b=null;b=[];for(d=d.m();d.s();)c=d.t(),b.push(null===c?null:c);d=new (Nd(lu).Ja)(b)}b=mu();c=ap().wa;b=nu(d,new ou(b,c))}else if(0<=
-d.Q())b=d.Q(),b=new (Nd(lu).Ja)(b),d.yc(b,0,2147483647);else{b=null;b=[];for(d=d.m();d.s();)c=d.t(),b.push(null===c?null:c);b=new (Nd(lu).Ja)(b)}d=(h,k)=>{var l=V(h.p);return ju(h,k,l,!1)};if(null===b)throw ze();if(null!==b){c=b.a.length;for(g=0;g<c;)a=d(a,b.a[g]),g=1+g|0;d=a}else if(b instanceof zd){c=b.a.length;for(g=0;g<c;)a=d(a,b.a[g]),g=1+g|0;d=a}else if(b instanceof Dd){c=b.a.length;for(g=0;g<c;)a=d(a,b.a[g]),g=1+g|0;d=a}else if(b instanceof Ad){c=b.a.length;for(g=0;g<c;)e=b.a[g],a=d(a,new fb(e.W,
-e.Z)),g=1+g|0;d=a}else if(b instanceof Bd){c=b.a.length;for(g=0;g<c;)a=d(a,b.a[g]),g=1+g|0;d=a}else if(b instanceof td){c=b.a.length;for(g=0;g<c;)a=d(a,hd(b.a[g])),g=1+g|0;d=a}else if(b instanceof vd){c=b.a.length;for(g=0;g<c;)a=d(a,b.a[g]),g=1+g|0;d=a}else if(b instanceof wd){c=b.a.length;for(g=0;g<c;)a=d(a,b.a[g]),g=1+g|0;d=a}else if(b instanceof pd){c=b.a.length;for(g=0;g<c;)a=d(a,b.a[g]),g=1+g|0;d=a}else{if(!Dh(b))throw new x(b);c=b.a.length;for(g=0;g<c;)a=d(a,b.a[g]),g=1+g|0;d=a}return d}d=pu(a.Ea);
-if(null!==d&&d===a)return a.Ea.Na;throw new x(a);}function qu(a,b,c,d){if(null===a)throw ze();if(a.lo)return a.mo;var e=ru().U();return su(a,tu(d.Mb,b,c,!0,e))}function uu(a,b,c,d){if(null===a)throw ze();if(a.lo)return a.mo;b=b.Xb;var e=ru().U();return su(a,tu(d,b,c,!0,e))}function vu(a,b,c,d){if(null===a)throw ze();if(a.lo)return a.mo;var e=ru().U();return su(a,tu(d.Xb,b,c,!0,e))}
-var aaa=function wu(a,b,c,d){if(b instanceof A){var g=b.A,h=b.r;if(null!==g){b=g.Mb;var k=g.Xb,l=new xu,m=new xu,n=new xu,r=c.Mb,u=ru().U();if((r=tu(b,r,d,!0,u))&&(n.lo?n.mo:vu(n,k,d,c)))return new A(c,h);if((l.lo?l.mo:qu(l,b,d,c))&&(m.lo?m.mo:uu(m,c,d,k)))return new A(g,h);if(r&&(l.lo?l.mo:qu(l,b,d,c)))return a=a.Ea,c=c.Xb,d=V(k.p),g=new yu(a,b,ju(k,c,d,!1),g.Bj),new A(g,h);if((m.lo?m.mo:uu(m,c,d,k))&&(n.lo?n.mo:vu(n,k,d,c)))return a=a.Ea,c=c.Mb,d=V(b.p),g=new yu(a,zu(b,c,d,!1),k,g.Bj),new A(g,h);
-h=wu(a,h,c,d);return new A(g,h)}}h=O().c;if(null===h?null===b:h.h(b))return h=O().c,new A(c,h);throw new x(b);};function Au(){this.PD=null;this.rz=!1;this.Ea=null}Au.prototype=new p;Au.prototype.constructor=Au;function Bu(){}f=Bu.prototype=Au.prototype;f.iC=function(){var a=this.nf(!1),b=O().c;return new A(a,b)};f.nf=function(a){return a?du(this,!0):this.gc()};f.gc=function(){this.rz||this.rz||(this.PD=du(this,!1),this.rz=!0);return this.PD};
-f.rb=function(a,b){if(this instanceof eu){var c=this.Jd,d=this.be,e=this.rf,g=this.lc.m();g=new eg(g,new z(m=>m.rb(a,b)));g=Cu(g,new U(()=>{var m=c.m();return new eg(m,new z(n=>n.rb(a,b)))})).mb(new U(()=>{Du();var m=d.Ba.m();m=Eu(0,m);return new eg(m,new z(n=>n.rb(a,b)))})).mb(new U(()=>{Du();var m=e.m();m=Eu(0,m);return new eg(m,new z(n=>n.rb(a,b)))}));if(g.s()){if(!g.s())throw Fu("empty.reduceLeft");for(var h=!0,k=null;g.s();){var l=g.t();h?(k=l,h=!1):(k|=0,l|=0,k=k>l?k:l)}g=new M(k)}else g=R();
-return(g.b()?this.Ea.md:g.o())|0}g=pu(this.Ea);if(null!==g&&g===this)return this.Ea.md;throw new x(this);};function baa(a,b,c,d,e){if(a instanceof eu){var g=a.lc,h=a.Jd,k=a.be,l=a.rf;a=a.Ea;g.b()?g=R():(g=g.o(),g=new M(g.Ts(b,c,d,e)));k=Gu(k,b,c,d,e);l=new Hu(new Iu(l),new z(u=>Ju(u,b,c,d,e)));var m=Ku(),n=mu(),r=ap().wa;return new eu(a,g,h,k,(new Lu(m,new ou(n,r))).qc(l))}h=pu(a.Ea);if(null!==h&&h===a)return a;throw new x(a);}
-function caa(a,b){var c=pu(a.Ea);if(null!==c&&c===a){c=a.Ea;var d=t().f;Mu();var e=mu(),g=ap().wa;b=Nu(b,new ou(e,g));a=Ou(Pu(a.Ea));e=Ku();g=mu();var h=ap().wa;return new eu(c,d,b,a,e.Ch(new ou(g,h)))}if(a instanceof eu)return c=a.be,d=a.rf,new eu(a.Ea,a.lc,a.Jd.Yb(b),c,d);throw new x(a);}
-function Qu(a,b,c,d,e){var g=G(new H,a,b),h=g.z,k=g.x;if(pu(a.Ea)===h&&k instanceof Ru){t();var l=a.Ea;t();var m=new M(k),n=Mu(),r=mu(),u=ap().wa,w=n.fg(new ou(r,u)),y=Su(e)?k.Ap():Ou(Pu(a.Ea)),B=Ku(),D=mu(),C=ap().wa,F=new eu(l,m,w,y,B.Ch(new ou(D,C)));return new M(F)}var I=g.z,K=g.x;if(pu(a.Ea)===I&&K instanceof Tu){t();var N=a.Ea;t();var P=new M(K),T=Mu(),aa=mu(),Y=ap().wa,S=T.fg(new ou(aa,Y)),Z=Ou(Pu(a.Ea)),ka=Ku(),X=mu(),sa=ap().wa,Ia=new eu(N,P,S,Z,ka.Ch(new ou(X,sa)));return new M(Ia)}var Za=
-g.z,Ga=g.x;if(pu(a.Ea)===Za&&Ga instanceof Uu){t();var xa=a.Ea,Ra=t().f;Mu();var Ja=mu(),La=ap().wa,pb=Nu(Ga,new ou(Ja,La)),Fb=Ou(Pu(a.Ea)),Gb=Ku(),Hb=mu(),tb=ap().wa,kb=new eu(xa,Ra,pb,Fb,Gb.Ch(new ou(Hb,tb)));return new M(kb)}var gb=g.z,Vb=g.x;if(gb instanceof eu){var bb=gb.lc,nb=gb.Jd,Tb=gb.be,ub=gb.rf;if(Vb instanceof Uu){t();var Ub=new eu(a.Ea,bb,nb.Yb(Vb),Tb,ub);return new M(Ub)}}var $a=g.z,cb=g.x;if($a instanceof eu){var Na=$a.lc,Ca=$a.Jd,Ba=$a.be,Oa=$a.rf;if(cb instanceof Tu){var wa=null;
-wa=Ba;var ea=G(new H,Na,cb);a:{var la=ea.z,Ka=ea.x;if(la instanceof M){var Ua=la.k;if(Ua instanceof gu&&Ka instanceof gu){var ya=daa(Ua,Ka);break a}}var ib=ea.z,Lb=ea.x;if(ib instanceof M){var ec=ib.k;if(ec instanceof yu){var Mb=ec.Mb,Jb=ec.Xb;if(Lb instanceof yu){var Kb=Lb.Mb,eb=Lb.Xb;if(a.Ea.yI&&!c){t();var Wb=a.Ea,mc=V(Mb.p),ua=zu(Mb,Kb,mc,!1),Pa=V(Jb.p),xb=new yu(Wb,ua,ju(Jb,eb,Pa,!1),ec.Bj);ya=new M(xb);break a}}}}var Yb=ea.z;if(Yb instanceof M){var zb=Yb.k;if(zb instanceof yu){var Sb=zb.Mb;
-if(null!==Sb){var Ma=Vu(Wu(a.Ea),Sb,d);if(!Ma.b()){var Ea=Ma.k;if(Ea instanceof Ru){var ab=Ea.Ub;if(ea.x instanceof Xu||ea.x instanceof yu)b:{for(var Db=ab;!Db.b();){var mb=Db.e().j().oa;if(Yu(mb,d)){var vb=!0;break b}Db=Db.g()}vb=!1}else vb=!1;if(vb){t();ya=new M(cb);break a}}}}}}var Ya=ea.z,Wa=ea.x;if(Ya instanceof M&&Ya.k instanceof Xu&&Wa instanceof yu){var rb=Wa.Mb;if(null!==rb){var pa=Vu(Wu(a.Ea),rb,d);if(!pa.b()){var Fa=pa.k;if(Fa instanceof Ru){b:{for(var Ib=Fa.Ub;!Ib.b();){var qb=Ib.e().j().oa;
-if(Yu(qb,d)){var Nb=!0;break b}Ib=Ib.g()}Nb=!1}if(Nb){ya=Ya;break a}}}}}var fc=ea.z,Ac=ea.x;if(fc instanceof M){var tc=fc.k;if(tc instanceof Xu){var vc=tc.Wh;if(Ac instanceof yu){t();var sc=new Xu(a.Ea,aaa(a,vc,Ac,d),tc.fq);ya=new M(sc);break a}}}var uc=ea.z;if(uc instanceof M){var lc=uc.k;if(lc instanceof yu&&(ea.x instanceof Xu||ea.x instanceof yu)){var Wc=a.Ea;t();var Cc=a.Ea,Dc=O().c,Ec=new Xu(Cc,new A(lc,Dc),cb.qa());return Qu(new eu(Wc,new M(Ec),Ca,Ba,Oa),cb,c,d,e)}}var Ic=ea.z,Xc=ea.x;if(Ic instanceof
-M&&Ic.k instanceof Xu&&Xc instanceof Xu){var Sc=Xc.Wh;if(Sc instanceof A){var oc=Sc.A,qc=Sc.r,Tc=O().c;if(null===Tc?null===qc:Tc.h(qc))return Qu(a,oc,c,d,e);var Nc=Qu(a,oc,c,d,e);return Nc.b()?R():Qu(Nc.o(),new Xu(a.Ea,qc,Xc.fq),c,d,e)}}var Pc=ea.z,Oc=ea.x;if(Pc instanceof M){var $c=Pc.k;if($c instanceof Ru){var Lc=$c.Ub;if(Oc instanceof Ru){var Zb=Oc.Ub,ed=Lc.K();if(hf(new E(ed),Zb.K())){if(Su(e)){for(var $b=a.Ea,Fc=wa.Ba,Yc=Oc.Ap().Ba,nc=mu(),Ob=ap().wa,cc=new ou(nc,Ob),Gc=Ku(),Bc=Fc.Q()+Yc.Q()|
-0,qd=Zu(Zu($u(8<Bc?Bc:8),Fc),Yc),Gd=ru().U(),cd=Sl(qd).m();cd.s();){var rd=cd.t(),Id=rd.i(),Ha=Gd.Y(Id);if(Ha instanceof M)var jc=Ha.k,Rb=av(jc,rd.j(),V(jc.Ua));else{if(R()!==Ha)throw new x(Ha);Rb=rd.j()}Gd.Vi(Id,Rb)}var Uc=cp(),Rc=bv(Gc,(new cv(Uc)).qc(Gd),cc);je();var Cd=le(v(),Rc);wa=new dv($b,Cd,V(a.Ea))}t();var od=a.Ea,Va=ev(Lc,Zb),wb=new Ru(od,Va,V(a.Ea));ya=new M(wb)}else ya=t().f;break a}}}var db=ea.z,Jc=ea.x;if(db instanceof M){var Vc=db.k;if(Vc instanceof fv){var Ta=Vc.ld;if(Jc instanceof
-Ru){var kd=Jc.Ub;if(Su(e)){for(var ld=a.Ea,qe=wa.Ba,Wd=Jc.Ap().Ba,Rd=mu(),Me=ap().wa,wc=new ou(Rd,Me),Xb=Ku(),gc=qe.Q()+Wd.Q()|0,hc=Zu(Zu($u(8<gc?gc:8),qe),Wd),gd=ru().U(),kc=Sl(hc).m();kc.s();){var ud=kc.t(),za=ud.i(),Qa=gd.Y(za);if(Qa instanceof M)var xc=Qa.k,yd=av(xc,ud.j(),V(xc.Ua));else{if(R()!==Qa)throw new x(Qa);yd=ud.j()}gd.Vi(za,yd)}var be=cp(),yc=bv(Xb,(new cv(be)).qc(gd),wc);je();var Od=le(v(),yc);wa=new dv(ld,Od,V(a.Ea))}t();var sd=a.Ea,he=Vg=>{var kk=Vg.i();Vg=av(Ta,Vg.j(),V(Ta.Ua));
-return G(new H,kk,Vg)};if(kd===v())var ue=v();else{for(var sg=kd.e(),Se=new A(he(sg),v()),Kf=Se,$e=kd.g();$e!==v();){var rf=$e.e(),He=new A(he(rf),v());Kf=Kf.r=He;$e=$e.g()}ue=Se}var Ze=new Ru(sd,ue,V(a.Ea));ya=new M(Ze);break a}}}var jf=ea.z,tf=ea.x;if(jf instanceof M){var Te=jf.k;if(Te instanceof Ru){var hg=Te.Ub;if(tf instanceof fv){var eh=tf.ld;t();var fh=a.Ea,tg=Vg=>{var kk=Vg.i();Vg=av(Vg.j(),eh,V(Vg.j().Ua));return G(new H,kk,Vg)};if(hg===v())var Jg=v();else{for(var Gh=hg.e(),zg=new A(tg(Gh),
-v()),ig=zg,qh=hg.g();qh!==v();){var gh=qh.e(),Wg=new A(tg(gh),v());ig=ig.r=Wg;qh=qh.g()}Jg=zg}var Uf=new Ru(fh,Jg,V(a.Ea));ya=new M(Uf);break a}}}var rh=ea.z,Rh=ea.x;if(rh instanceof M){var Sg=rh.k;if(Sg instanceof fv){var Hh=Sg.ld;if(Rh instanceof fv){var Xg=Rh.ld;t();var jg=a.Ea,Ag=av(Hh,Xg,V(Hh.Ua)),Cf=new fv(jg,Ag,V(a.Ea));ya=new M(Cf);break a}}}var Bg=ea.z,Lf=ea.x;if(Bg instanceof M){var Df=Bg.k;if(Df instanceof gv){var kg=Df.Bc,df=Df.Ye;if(Lf instanceof gv){var Kg=Lf.Bc;if(hf(new E(df),Lf.Ye)){t();
-var Mf=a.Ea,Vf=V(kg.p),Cg=ju(kg,Kg,Vf,!1),Ef=new gv(Mf,Cg,df,Df.Lo);ya=new M(Ef);break a}}}}var Wf=ea.z,de=ea.x;if(Wf instanceof M){var Ee=Wf.k;if(de instanceof gv){t();var Sh=a.Ea,hi=V(Ee.p),vi=ju(Ee,de,hi,!1),Lg=Mu(),Tg=mu(),cj=ap().wa,Cj=Lg.fg(new ou(Tg,cj)),Dj=new gv(Sh,vi,Cj,V(a.Ea));ya=new M(Dj);break a}}var wi=ea.z,Ki=ea.x;if(wi instanceof M){var Yg=wi.k;if(Yg instanceof gv){t();var dj=a.Ea,ii=V(Yg.p),ji=ju(Yg,Ki,ii,!1),Th=Mu(),Ej=mu(),ej=ap().wa,xd=Th.fg(new ou(Ej,ej)),ke=new gv(dj,ji,xd,
-V(a.Ea));ya=new M(ke);break a}}var Ie=ea.z;if(Ie instanceof M&&hv(Ie.k)&&Ie.k.p===a.Ea&&(ea.x instanceof yu||ea.x instanceof iv||ea.x instanceof Xu))var Qf=!0;else{var hh=ea.z;if(hh instanceof M&&(hh.k instanceof yu||hh.k instanceof iv||hh.k instanceof Xu)&&hv(ea.x)&&ea.x.p===a.Ea)Qf=!0;else{var lg=ea.z;if(lg instanceof M&&lg.k instanceof yu&&(ea.x instanceof iv||ea.x instanceof Xu))Qf=!0;else{var Uh=ea.z;if(Uh instanceof M&&(Uh.k instanceof iv||Uh.k instanceof Xu)&&ea.x instanceof yu)Qf=!0;else{var Zg=
-ea.z;if(Zg instanceof M&&Zg.k instanceof iv&&ea.x instanceof Xu)Qf=!0;else{var Vh=ea.z;Qf=Vh instanceof M&&Vh.k instanceof Xu&&ea.x instanceof iv?!0:!1}}}}}if(Qf)ya=t().f;else{b:{var fj=ea.z;if(fj instanceof M){var gj=fj.k;if(gj instanceof Xu){var Li=gj.Wh,Mi=O().c;if(null===Mi?null===Li:Mi.h(Li)){var hj=!0;break b}}}var Fj=ea.x;if(ea.z instanceof M&&Fj instanceof Xu){var Qj=Fj.Wh,Ni=O().c;if(null===Ni?null===Qj:Ni.h(Qj)){hj=!0;break b}}hj=!1}hj&&Dn("Program reached and unexpected state.");var Gj=
-ea.z;var Hj=Gj instanceof M&&Gj.k instanceof jv?!0:ea.z instanceof M&&ea.x instanceof jv?!0:!1;Hj&&$n();var lk=ea.z,md=ea.x;if(t().f===lk&&md instanceof Ru){if(Su(e)){for(var Ue=a.Ea,Jd=wa.Ba,uf=md.Ap().Ba,Dl=mu(),gl=ap().wa,am=new ou(Dl,gl),xk=Ku(),Ae=Jd.Q()+uf.Q()|0,Ff=Zu(Zu($u(8<Ae?Ae:8),Jd),uf),vf=ru().U(),Xf=Sl(Ff).m();Xf.s();){var Ij=Xf.t(),Rj=Ij.i(),hl=vf.Y(Rj);if(hl instanceof M)var El=hl.k,on=av(El,Ij.j(),V(El.Ua));else{if(R()!==hl)throw new x(hl);on=Ij.j()}vf.Vi(Rj,on)}var Oi=cp(),ee=bv(xk,
-(new cv(Oi)).qc(vf),am);je();var Re=le(v(),ee);wa=new dv(Ue,Re,V(a.Ea))}t();ya=new M(cb)}else{var Ji=ea.z;if(t().f===Ji)t(),ya=new M(cb);else throw new x(ea);}}}if(ya.b())return R();var jk=ya.o();return new M(new eu(a.Ea,(t(),new M(jk)),Ca,wa,Oa))}}throw new x(g);}
-function kv(a,b){var c=pu(a.Ea);if(null!==c&&c===a){a=a.Ea;c=t().f;var d=Mu(),e=mu(),g=ap().wa;d=d.fg(new ou(e,g));e=Ku();g=mu();var h=ap().wa;return new eu(a,c,d,b,e.Ch(new ou(g,h)))}if(a instanceof eu)return c=a.lc,d=a.Jd,e=a.rf,h=g=a.Ea,b=lv(a.be.Ba,b.Ba),new eu(g,c,d,new dv(h,b,V(a.Ea)),e);throw new x(a);}
-function mv(a,b,c,d,e){var g=pu(a.Ea);if(null!==g&&g===a){t();e=a.Ea;g=t().f;var h=Mu(),k=mu(),l=ap().wa;h=h.fg(new ou(k,l));k=Ou(Pu(a.Ea));Ku();b=G(new H,b.ob,b);l=mu();var m=ap().wa;b=new eu(e,g,h,k,nv(b,new ou(l,m)));return new M(b)}if(a instanceof eu){g=a.lc;h=a.Jd;k=a.be;l=a.rf;m=b.ob;var n=l.Y(b.ob);if(n.b())n=b;else{n=n.o();var r=new ov(b.Vb);fp();var u=pv(r.Lb,n.Vb);gp(0,hf(new E(u),0));t();n=qv(n,new M(!0),new Um((w,y)=>{var B=r.Lb.e();r.Lb=r.Lb.g();var D=!1,C=null;if(w instanceof M&&(D=
-!0,C=w,!0===!!C.k))return w=V(y.p),ju(y,B,w,!1);if(D&&!1===!!C.k)return w=V(y.p),zu(y,B,w,!1);if(t().f===w){if(c)return w=rv(a.Ea),D=V(y.p),D=zu(y,B,D,!1),C=V(y.p),sv(w,D,ju(y,B,C,!1),tv(rv(a.Ea)),d);w=rv(a.Ea);D=V(y.p);D=ju(y,B,D,!1);C=V(y.p);return sv(w,D,zu(y,B,C,!1),tv(rv(a.Ea)),d)}throw new x(w);}),d);n=new uv(a.Ea,b.ob,n,b.Ml)}l=l.km(m,n);g=new eu(a.Ea,g,h,k,l);b=vv(b,d);b.b()?(t(),b=new M(g)):(b=b.o(),b=Qu(g,b,c,d,e));return b}throw new x(a);}
-function wv(a,b,c,d,e){var g=id();try{var h=G(new H,a,b),k=h.x;if(pu(a.Ea)===k)return t(),new M(a);var l=h.z;if(pu(a.Ea)===l)return t(),new M(b);var m=h.x;if(m instanceof eu){var n=m.lc,r=m.be,u=m.rf,w=m.Jd.m(),y=new iu(u);if(n.b())var B=bt().n(kv(a,r));else{var D=n.o();B=Qu(kv(a,r),D,c,d,e)}for(a=B;y.gt.s();){b=a;var C=y.t();h=C;if(b.b())throw fq(new gq,g,t().f);a=mv(b.o(),h,c,d,e)}for(y=a;w.s();){C=y;var F=w.t();a=F;if(C.b())throw fq(new gq,g,t().f);y=Qu(C.o(),a,c,d,e)}return y}throw new x(h);}catch(I){if(I instanceof
-gq){c=I;if(c.Hg===g)return c.wj();throw c;}throw I;}}
-f.aw=function(a,b){var c=G(new H,this,a),d=c.z,e=c.x;if(d instanceof eu&&(d=d.be,e instanceof xv))return a=this.Ea,c=G(new H,e.pe,e.qe),e=O().c,a=new dv(a,new A(c,e),V(this.Ea)),c=ru().U(),tu(d,a,b,!0,c);var g=c.z,h=c.x;if(g instanceof eu&&(d=g.lc,h instanceof yv)){e=h.lb;c=h.Ic;a:{for(h=h.bc;!h.b();){var k=h.e();b:{if(d instanceof M){var l=d.k;if(l instanceof gu){k=hf(new E(k.Pn()),l.ed)?!0:(g.RD?g.QD:zv(g)).L(k.Pn());break b}}k=!1}if(k){g=!0;break a}h=h.g()}g=!1}if(g)a=!0;else a:{if(g=!1,h=null,
-e instanceof M&&(g=!0,h=e,k=h.k,k instanceof me&&(k=k.ia,null!==k))){a=this.aw(k,b);break a}if(g&&(k=h.k,k instanceof te&&(k=k.ca,k instanceof yu||k instanceof Xu||k instanceof iv||k instanceof Ru))){d.b()?a=!1:(a=d.o(),d=ru().U(),a=tu(a,k,b,!0,d));break a}if(g&&(d=h.k,d instanceof te&&d.ca instanceof gv))return a=a.gc(),this.gc(),this.gc(),c=ru().U(),d=this.gc(),tu(d,a,b,!0,c);if(t().f===e)a=!1;else throw new x(e);}if(a)return!0;d=!1;for(a=c.m();!d&&a.s();){c=a.t();if(null===c)throw new x(c);c=c.j();
-this.gc();this.gc();d=ru().U();e=this.gc();d=tu(e,c,b,!0,d)}return d}b=c.z;if(pu(this.Ea)===b)return!1;b=c.x;if(Av(this.Ea)===b)return!1;throw new x(c);};
-function Bv(a,b,c){var d=G(new H,a,b);b=d.x;if(pu(a.Ea)===b)return!0;b=d.z;if(pu(a.Ea)===b)return!1;a=d.z;var e=d.x;if(a instanceof eu){var g=a.lc,h=a.Jd;b=a.be;a=a.rf;if(e instanceof eu){var k=e.lc,l=e.Jd;d=e.be;e=e.rf;if(k.b())g=!0;else if(k=k.o(),g.b())g=!1;else{g=g.o();var m=ru().U();g=tu(g,k,c,!0,m)}g&&Cv(l,h)?(h=ru().U(),b=tu(b,d,c,!0,h)):b=!1;if(b){b=new iu(e);for(h=!0;h&&b.gt.s();){h=b.t();d=new iu(a);for(e=!1;!e&&d.gt.s();)e=d.t(),l=ru().U(),e=tu(e,h,c,!0,l);h=e}return h}return!1}}throw new x(d);
-}function Dv(a){return pu(a.Ea)===a}
-function Ev(a,b){if(a instanceof xv){var c=a.Aa;b=G(new H,a.pe,a.qe);var d=O().c;return new dv(c,new A(b,d),V(a.Aa))}if(a instanceof yv){c=a.bc;var e=a.lb;d=a.Ic;if(e.b())a=a.Aa.tb;else if(a=e.o(),a instanceof me)a=a.ia.nf(b);else{if(!(a instanceof te))throw new x(a);a=a.ca}d=new iu(d);a=ku(d,a,new Um((g,h)=>{var k=V(g.p);return zu(g,h,k,!1)}));b&&(b=mu(),d=ap().wa,c=Fv(c,new ou(b,d)));return c.ge(a,new Um((g,h)=>{var k=V(g.p);return zu(g,h,k,!1)}))}c=Av(a.Aa);if(null!==c&&c===a)return a.Aa.tb;throw new x(a);
-}function Gv(a,b){if(null===b)throw null;a.Aa=b}function Hv(){this.sz=null;this.Nw=!1;this.Aa=null}Hv.prototype=new p;Hv.prototype.constructor=Hv;function Iv(){}Iv.prototype=Hv.prototype;Hv.prototype.iC=function(){var a=this.nf(!1),b=O().c;return new A(a,b)};Hv.prototype.nf=function(a){return a?Ev(this,!0):this.gc()};Hv.prototype.gc=function(){this.Nw||this.Nw||(this.sz=Ev(this,!1),this.Nw=!0);return this.sz};
-function Jv(a,b,c,d){var e=Av(a.Aa);if(null!==e&&e===a){t();e=a.Aa;var g=O().c,h=t().f;Ku();b=G(new H,b.ob,b);var k=mu(),l=ap().wa;b=new yv(e,g,h,nv(b,new ou(k,l)));return new M(b)}if(a instanceof xv){e=a.pe;b=a.qe;h=!1;g=null;k=Av(a.Aa);if(null!==k&&k===a)return t(),b=new xv(a.Aa,e,b),new M(b);if(a instanceof xv&&(k=a.pe,l=a.qe,hf(new E(k),e)))return t(),b=new xv(a.Aa,k,Kv(l,b,V(l.Ua))),new M(b);if(a instanceof yv){h=!0;g=a;k=g.bc;var m=g.lb;l=g.Ic;if(t().f===m)return t(),g=a.Aa,t(),t(),b=new xv(a.Aa,
-e,b),b=new yv(g,k,new M(new me(b)),l),new M(b)}if(h&&(h=g.bc,k=g.lb,g=g.Ic,k instanceof M&&(k=k.k,k instanceof me&&(l=k.ia,null!==l&&(k=l.pe,l=l.qe,hf(new E(k),e))))))return t(),e=a.Aa,t(),t(),b=new xv(a.Aa,k,Kv(l,b,V(l.Ua))),b=new yv(e,h,new M(new me(b)),g),new M(b);if(a instanceof xv||a instanceof yv)return t().f;throw new x(a);}if(a instanceof yv){e=a.bc;g=a.lb;h=a.Ic;k=b.ob;l=h.Y(b.ob);if(!l.b()){l=l.o();var n=new ov(b.Vb);fp();m=pv(n.Lb,l.Vb);gp(0,hf(new E(m),0));t();l=qv(l,new M(!0),new Um((r,
-u)=>{var w=n.Lb.e();n.Lb=n.Lb.g();var y=!1,B=null;if(r instanceof M&&(y=!0,B=r,!0===!!B.k))return r=V(u.p),zu(u,w,r,!1);if(y&&!1===!!B.k)return r=V(u.p),ju(u,w,r,!1);if(t().f===r){if(c)return r=rv(a.Aa),y=V(u.p),y=ju(u,w,y,!1),B=V(u.p),sv(r,y,zu(u,w,B,!1),tv(rv(a.Aa)),d);r=rv(a.Aa);y=V(u.p);y=zu(u,w,y,!1);B=V(u.p);return sv(r,y,ju(u,w,B,!1),tv(rv(a.Aa)),d)}throw new x(r);}),d);b=new uv(a.Aa,b.ob,l,b.Ml)}b=h.km(k,b);t();b=new yv(a.Aa,e,g,b);return new M(b)}throw new x(a);}
-function Lv(a,b,c,d){var e=id();try{if(b instanceof yv){for(var g=b.bc,h=b.lb,k=new iu(b.Ic);k.gt.s();){var l=a,m=k.t(),n=Jv(l,m,c,d);if(n.b())throw fq(new gq,e,t().f);a=n.o()}for(;!g.b();){c=a;var r=g.e(),u=Mv(c,r);if(u.b())throw fq(new gq,e,t().f);a=u.o();g=g.g()}r=a;t();if(h.b())var w=r;else{var y=h.o();if(y instanceof me){var B=y.ia;var D=G(new H,B.pe,B.qe);var C=Nv(r,D);if(C.b())throw fq(new gq,e,t().f);w=C.o()}else{if(!(y instanceof te))throw new x(y);var F=Mv(r,y.ca);if(F.b())throw fq(new gq,
-e,t().f);w=F.o()}}return new M(w)}if(b instanceof xv){l=b.pe;var I=b.qe;h=!1;w=null;var K=Av(a.Aa);if(null!==K&&K===a){t();var N=new xv(a.Aa,l,I);return new M(N)}if(a instanceof xv){var P=a.pe,T=a.qe;if(hf(new E(P),l)){t();var aa=new xv(a.Aa,P,Kv(T,I,V(T.Ua)));return new M(aa)}}if(a instanceof yv){h=!0;w=a;var Y=w.bc,S=w.lb,Z=w.Ic;if(t().f===S){t();var ka=a.Aa;t();t();var X=new xv(a.Aa,l,I),sa=new yv(ka,Y,new M(new me(X)),Z);return new M(sa)}}if(h){var Ia=w.bc,Za=w.lb,Ga=w.Ic;if(Za instanceof M){var xa=
-Za.k;if(xa instanceof me){var Ra=xa.ia;if(null!==Ra){var Ja=Ra.pe,La=Ra.qe;if(hf(new E(Ja),l)){t();var pb=a.Aa;t();t();var Fb=new xv(a.Aa,Ja,Kv(La,I,V(La.Ua))),Gb=new yv(pb,Ia,new M(new me(Fb)),Ga);return new M(Gb)}}}}}if(a instanceof xv||a instanceof yv)return t().f;throw new x(a);}if(Av(a.Aa)===b)return t(),new M(a);throw new x(b);}catch(Hb){if(Hb instanceof gq){h=Hb;if(h.Hg===e)return h.wj();throw h;}throw Hb;}}
-function eaa(a,b,c){var d=Av(a.Aa);if(null!==d&&d===a||Av(a.Aa)===b)return t(),a=Av(a.Aa),new M(a);if(a instanceof xv){d=a.pe;var e=a.qe;if(b instanceof xv){var g=b.qe;if(hf(new E(d),b.pe))return t(),a=new xv(a.Aa,d,av(e,g,V(e.Ua))),new M(a)}}if(a instanceof yv&&(d=a.bc,g=a.lb,e=a.Ic,g instanceof M&&(g=g.k,g instanceof me&&(g=g.ia,b instanceof yv)))){var h=b.bc,k=b.lb,l=b.Ic;if(k instanceof M&&(k=k.k,k instanceof me&&(k=k.ia,hf(new E(d),h)&&hf(new E(e),l)&&hf(new E(g.pe),k.pe))))return t(),c=a.Aa,
-t(),t(),a=new xv(a.Aa,g.pe,av(g.qe,k.qe,V(g.qe.Ua))),a=new yv(c,d,new M(new me(a)),e),new M(a)}return a instanceof yv&&(d=a.bc,e=a.lb,g=a.Ic,b instanceof yv&&(l=b.lb,h=b.Ic,hf(new E(d),b.bc)&&hf(new E(e),l)?(b=g.eB(),b=hf(new E(b),h.eB())):b=!1,b))?(t(),a=new yv(a.Aa,d,e,Ov(a.Aa,!1,g,h,c)),new M(a)):t().f}
-function faa(a,b){var c=Av(a.Aa);if(null!==c&&c===a){c=a.Aa;a=O().c;b=new A(b,a);a=t().f;var d=Ku(),e=mu(),g=ap().wa;return new yv(c,b,a,d.Ch(new ou(e,g)))}if(a instanceof xv)return c=a.Aa,d=O().c,b=new A(b,d),t(),t(),a=new M(new me(a)),d=Ku(),e=mu(),g=ap().wa,new yv(c,b,a,d.Ch(new ou(e,g)));if(a instanceof yv)return new yv(a.Aa,new A(b,a.bc),a.lb,a.Ic);throw new x(a);}
-function Mv(a,b){var c=G(new H,a,b),d=c.z,e=c.x;if(Av(a.Aa)===d&&hv(e)){t();var g=a.Aa,h=O().c,k=new A(e,h),l=t().f,m=Ku(),n=mu(),r=ap().wa,u=new yv(g,k,l,m.Ch(new ou(n,r)));return new M(u)}var w=c.z,y=c.x;if(Av(a.Aa)===w&&y instanceof Pv){t();var B=a.Aa,D=O().c;t();t();var C=new M(new te(y)),F=Ku(),I=mu(),K=ap().wa,N=new yv(B,D,C,F.Ch(new ou(I,K)));return new M(N)}var P=c.z,T=c.x;if(P instanceof yv){var aa=P.bc,Y=P.lb,S=P.Ic;if(T instanceof gu){t();var Z=new yv(a.Aa,aa.L(T)?aa:new A(T,aa),Y,S);return new M(Z)}}var ka=
-c.z,X=c.x;if(ka instanceof yv){var sa=ka.bc,Ia=ka.lb,Za=ka.Ic;if(t().f===Ia&&X instanceof Pv){t();var Ga=a.Aa;t();t();var xa=new yv(Ga,sa,new M(new te(X)),Za);return new M(xa)}}var Ra=c.z,Ja=c.x;if(Ra instanceof yv){var La=Ra.bc,pb=Ra.lb,Fb=Ra.Ic;if(pb instanceof M){var Gb=pb.k;if(Gb instanceof te){var Hb=Gb.ca;if(Hb instanceof Ru){var tb=Hb.Ub;if(Ja instanceof Ru){var kb=Ja.Ub,gb=tb.K();if(sr(new E(gb),kb.K())){var Vb=a.Aa;t();t();var bb=Qv(Hb);return Mv(new yv(Vb,La,new M(new te(bb)),Fb),Qv(Ja))}t();
-var nb=a.Aa;t();t();var Tb=a.Aa,ub=new vq(tb,tb,kb),Ub=new Um((He,Ze)=>{He=G(new H,He,Ze);Ze=He.z;var jf=He.x;if(null!==Ze){var tf=Ze.i();Ze=Ze.j();if(tf instanceof M&&(tf=tf.k,null!==jf)){var Te=jf.i();jf=jf.j();if(Te instanceof M)return He=hf(new E(tf),Te.k)?(t(),new M(tf)):t().f,G(new H,He,Kv(Ze,jf,V(Ze.Ua)))}}jf=He.z;tf=He.x;if(null!==jf&&(Ze=jf.i(),jf=jf.j(),null!==tf))return He=tf.i(),tf=tf.j(),He=Ze.b()?He:Ze,G(new H,He,Kv(jf,tf,V(jf.Ua)));throw new x(He);});xq();var $a=Rv(ub,Ub),cb=new Ru(Tb,
-$a,V(a.Aa)),Na=new yv(nb,La,new M(new te(cb)),Fb);return new M(Na)}}}}}var Ca=c.z,Ba=c.x;if(Ca instanceof yv){var Oa=Ca.lb;if(Oa instanceof M){var wa=Oa.k;if(wa instanceof te&&wa.ca instanceof fv&&Ba instanceof Ru)return Mv(a,Qv(Ba))}}var ea=c.z,la=c.x;if(ea instanceof yv){var Ka=ea.bc,Ua=ea.lb,ya=ea.Ic;if(Ua instanceof M){var ib=Ua.k;if(ib instanceof te){var Lb=ib.ca;if(Lb instanceof Ru&&la instanceof fv){var ec=a.Aa;t();t();var Mb=Qv(Lb);return Mv(new yv(ec,Ka,new M(new te(Mb)),ya),la)}}}}var Jb=
-c.z,Kb=c.x;if(Jb instanceof yv){var eb=Jb.bc,Wb=Jb.lb,mc=Jb.Ic;if(Wb instanceof M){var ua=Wb.k;if(ua instanceof te){var Pa=ua.ca;if(Pa instanceof fv){var xb=Pa.ld;if(Kb instanceof fv){var Yb=Kb.ld;t();var zb=a.Aa;t();t();var Sb=a.Aa,Ma=Kv(xb,Yb,V(xb.Ua)),Ea=new fv(Sb,Ma,V(a.Aa)),ab=new yv(zb,eb,new M(new te(Ea)),mc);return new M(ab)}}}}}a:{var Db=c.z;if(Db instanceof yv){var mb=Db.lb;if(mb instanceof M){var vb=mb.k;if(vb instanceof te&&vb.ca instanceof gv){var Ya=!0;break a}}}Ya=c.x instanceof gv?
-!0:!1}Ya&&Dn("Program reached and unexpected state.");var Wa=c.z;if(Wa instanceof yv){var rb=Wa.lb;if(rb instanceof M){var pa=rb.k;if(pa instanceof te&&hf(new E(b),pa.ca))return t(),new M(a)}}var Fa=c.z,Ib=c.x;if(Fa instanceof yv){var qb=Fa.bc,Nb=Fa.lb,fc=Fa.Ic;if(Nb instanceof M){var Ac=Nb.k;if(Ac instanceof te){var tc=Ac.ca;if(tc instanceof yu){var vc=tc.Mb,sc=tc.Xb;if(Ib instanceof yu){var uc=Ib.Mb,lc=Ib.Xb;t();var Wc=a.Aa;t();t();var Cc=a.Aa,Dc=V(vc.p),Ec=ju(vc,uc,Dc,!1),Ic=V(sc.p),Xc=zu(sc,lc,
-Ic,!1),Sc=new yu(Cc,Ec,Xc,V(a.Aa)),oc=new yv(Wc,qb,new M(new te(Sc)),fc);return new M(oc)}}}}}var qc=c.z,Tc=c.x;if(qc instanceof yv){var Nc=qc.bc,Pc=qc.lb,Oc=qc.Ic;if(Pc instanceof M){var $c=Pc.k;if($c instanceof te){var Lc=$c.ca;if(Lc instanceof Xu){var Zb=Lc.Wh;if(Tc instanceof yu){var ed=Tc.Mb,$b=Tc.Xb;t();var Fc=a.Aa;t();t();var Yc=a.Aa,nc=He=>{if(null!==He){var Ze=He.Mb,jf=He.Xb,tf=a.Aa,Te=V(Ze.p);Ze=ju(Ze,ed,Te,!1);Te=V(jf.p);return new yu(tf,Ze,zu(jf,$b,Te,!1),He.Bj)}throw new x(He);};if(Zb===
-v())var Ob=v();else{for(var cc=Zb.e(),Gc=new A(nc(cc),v()),Bc=Gc,qd=Zb.g();qd!==v();){var Gd=qd.e(),cd=new A(nc(Gd),v());Bc=Bc.r=cd;qd=qd.g()}Ob=Gc}var rd=new Xu(Yc,Ob,Lc.fq),Id=new yv(Fc,Nc,new M(new te(rd)),Oc);return new M(Id)}}}}}var Ha=c.z,jc=c.x;if(Ha instanceof yv){var Rb=Ha.bc,Uc=Ha.lb,Rc=Ha.Ic;if(Uc instanceof M){var Cd=Uc.k;if(Cd instanceof te){var od=Cd.ca;if(od instanceof yu&&jc instanceof Xu){var Va=a.Aa;t();t();return Mv(new yv(Va,Rb,new M(new te(jc)),Rc),od)}}}}a:{var wb=c.z;if(wb instanceof
-yv){var db=wb.lb;if(db instanceof M){var Jc=db.k;if(Jc instanceof te&&Jc.ca instanceof Xu){var Vc=!0;break a}}}Vc=c.x instanceof Xu?!0:!1}if(Vc)return t().f;var Ta=c.z,kd=c.x;if(Ta instanceof yv){var ld=Ta.bc,qe=Ta.lb,Wd=Ta.Ic;if(kd instanceof Uu){t();var Rd=new yv(a.Aa,ld.L(kd)?ld:new A(kd,ld),qe,Wd);return new M(Rd)}}var Me=c.z,wc=c.x;if(Me instanceof xv&&hv(wc)){t();var Xb=a.Aa,gc=O().c,hc=new A(wc,gc);t();t();var gd=new M(new me(Me)),kc=Ku(),ud=mu(),za=ap().wa,Qa=new yv(Xb,hc,gd,kc.Ch(new ou(ud,
-za)));return new M(Qa)}if(c.z instanceof xv&&(c.x instanceof yu||c.x instanceof iv))return t().f;a:{var xc=c.z;if(xc instanceof yv){var yd=xc.lb;if(yd instanceof M){var be=yd.k;if(be instanceof te&&be.ca instanceof yu&&c.x instanceof iv){var yc=!0;break a}}}var Od=c.z;if(Od instanceof yv){var sd=Od.lb;if(sd instanceof M){var he=sd.k;if(he instanceof te&&he.ca instanceof iv&&c.x instanceof yu){yc=!0;break a}}}var ue=c.z;if(ue instanceof yv){var sg=ue.lb;if(sg instanceof M&&sg.k instanceof me&&(c.x instanceof
-yu||c.x instanceof iv)){yc=!0;break a}}yc=!1}if(yc)return t().f;a:{var Se=c.z;if(Se instanceof yv){var Kf=Se.lb;if(Kf instanceof M){var $e=Kf.k;if($e instanceof te&&$e.ca instanceof jv){var rf=!0;break a}}}rf=c.x instanceof jv?!0:!1}rf&&$n();throw new x(c);}
-function Nv(a,b){var c=!1,d=null,e=Av(a.Aa);if(null!==e&&e===a)return t(),a=new xv(a.Aa,b.i(),b.j()),new M(a);if(a instanceof xv){e=a.pe;var g=a.qe;if(hf(new E(e),b.i()))return t(),a=new xv(a.Aa,e,Kv(g,b.j(),V(g.Ua))),new M(a)}if(a instanceof yv){c=!0;d=a;e=d.bc;var h=d.lb;g=d.Ic;if(t().f===h)return t(),d=a.Aa,t(),t(),a=new xv(a.Aa,b.i(),b.j()),a=new yv(d,e,new M(new me(a)),g),new M(a)}if(c&&(c=d.bc,e=d.lb,d=d.Ic,e instanceof M&&(e=e.k,e instanceof me&&(g=e.ia,null!==g&&(e=g.pe,h=g.qe,hf(new E(e),
-b.i()))))))return t(),g=a.Aa,t(),t(),a=new xv(a.Aa,e,Kv(h,b.j(),V(h.Ua))),a=new yv(g,c,new M(new me(a)),d),new M(a);if(a instanceof xv||a instanceof yv)return t().f;throw new x(a);}
-Hv.prototype.aw=function(a,b){var c=G(new H,this,a),d=c.z;a=c.x;if(d instanceof yv){var e=d.bc,g=d.lb;d=d.Ic;if(g instanceof M&&(g=g.k,g instanceof me&&(g=g.ia,a instanceof xv))){if(e.b()){c=new iu(d);for(e=!0;e&&c.gt.s();){e=c.t();d=a.gc();var h=ru().U();e=tu(e,d,b,!0,h)}c=e}else c=!1;return c?g.aw(a,b):!1}}a=c.x;if(c.z instanceof yv&&a instanceof xv)return!1;a=c.x;if(c.z instanceof xv&&a instanceof yv&&(a=a.lb,a instanceof M&&(a=a.k,a instanceof me)))return this.aw(a.ia,b);a=c.x;if(c.z instanceof
-xv&&a instanceof yv&&(a=a.lb,a=a instanceof M&&a.k instanceof te?!0:t().f===a?!0:!1,a))return!1;e=c.z;a=c.x;if(e instanceof xv&&(g=e.pe,e=e.qe,a instanceof xv))return c=a.qe,hf(new E(g),a.pe)?(a=ru().U(),Sv(e,c,b,a)):!1;e=c.z;g=c.x;if(e instanceof yv&&(h=e.bc,a=e.lb,e=e.Ic,g instanceof yv)){d=g.bc;c=g.lb;g=g.Ic;a:{for(;!h.b();){var k=h.e();b:{for(var l=d;!l.b();){var m=l.e().Pn();if(hf(new E(m),k.Pn())){k=!0;break b}l=l.g()}k=!1}if(!k){d=!1;break a}h=h.g()}d=!0}if(d){d=!0;for(e=e.m();d&&e.s();){d=
-e.t();if(null===d)throw new x(d);d=d.j();k=!1;for(h=g.m();!k&&h.s();){k=h.t();if(null===k)throw new x(k);k=k.j();l=ru().U();k=tu(d,k,b,!0,l)}d=k}g=d}else g=!1;return g?a instanceof M&&(g=a.k,g instanceof te&&(g=g.ca,c instanceof M&&(c=c.k,c instanceof te)))?(a=c.ca,c=ru().U(),tu(g,a,b,!0,c)):t().f===a?!0:!1:!1}b=c.z;if(Av(this.Aa)===b)return!0;b=c.x;if(Av(this.Aa)===b)return!1;throw new x(c);};function Tv(a){return Av(a.Aa)===a}
-function gaa(a){var b=Of(a.Kd),c=a.ue,d=a.bh,e=1+b.fa|0,g=ru().U();e=new Uv(b.V,b.Vc,b.Xa,b.kd,e,b.Ac,b.vb,b.fb,b.ud,g);Vv(e,Wv(a));if(hf(new E(a.mE),!0)){Xv(a.J,sf(new mf(new nf(J(new L,["Unhandled cyclic parent specification"]))),v()),a.Kb.C(),a.ue);var h=O().c}else try{a.mE=!0;for(var k=Yv(a),l=g=null;k!==v();){var m=k.e();a:{if(null!==m){var n=m.Gu,r=m.Ks,u=m.zq,w=m.Hu,y=m.Iu;if(null!==r){var B=r.w,D=a.J.pa,C=a.J;if(C.D){var F=Hs(Q(),"| ",C.q)+(e.fa+". Typing parent spec ")+n;Af(Bf(),F+"\n")}C.q=
-1+C.q|0;try{var I=u.NP(a.ue);if(I instanceof Zv){var K=I,N=w.b()?t().f:(t(),new M(w)),P=a.ue,T=$v(a),aa=aw(a,K,r,N,e,P,T);if(null===aa)throw new x(aa);var Y=aa.i(),S=a.Kd,Z=bw(K,I.Ca(),!1,S,Y),ka=pv(y,Z.Il);if(sr(new E(ka),0)){var X=a.J,sa=new mf(new nf(J(new L,["mixin "," expects "," parameter(s); got ",""]))),Ia=pf(qf(),B);qf();var Za=Z.Il.K(),Ga=pf(0,""+Za);qf();var xa=y.K(),Ra=[Ia,Ga,pf(0,""+xa)],Ja=sf(sa,J(new L,Ra));Dt();var La=ap(),pb=y.Gb(La.wa).j();Xv(X,Ja,Et(0,new A(r,pb)),a.ue)}var Fb=
-Z.Il,Gb=new vq(Fb,Fb,y),Hb=new Um(((mb,vb)=>(Ya,Wa)=>{var rb=G(new H,Ya,Wa);Ya=rb.z;var pa=rb.x;if(null!==Ya&&(Wa=new M(Ya),!Wa.b()&&(Ya=Wa.k.i(),Wa=Wa.k.j(),null!==pa&&(pa=new M(pa),!pa.b())))){var Fa=pa.k.j();if(null!==Fa&&(pa=Fa.vc,Fa=Fa.Da,null!==pa)){rb=pa.si;var Ib=pa.ri;if(pa.pf||rb||Ib)throw new rk("assertion failed: TODO");rb=cw(a.J,Fa,mb,a.ue,$v(a),!0);pa=Wa.Ma;if(!pa.b()){pa=pa.o();Fa=a.ue;Ib=a.bh;var qb=dw(a.J).Cb;ew(a.J,pa,rb,Fa,Ib,mb,qb)}pa=Wa.oa;Fa=a.ue;Ib=a.bh;qb=dw(a.J).Cb;ew(a.J,
-rb,pa,Fa,Ib,mb,qb);pa=vb.zj.n(Ya.w).Jq();Wa=Wa.Ma.b()?new ww(a.J,Wa.Ma,rb,V(a.J)):new ww(a.J,Wa.Ma,Wa.oa,V(a.J));return Mt(Nt(),pa?new M(new xw(a.J,Ya,Wa,pa,mb.fa)):R())}}throw new x(rb);})(e,Z));xq();var tb=yq(Gb,Hb),kb=a.J;if(kb.D){var gb=Hs(Q(),"| ",kb.q)+"Mixin arg members "+tb;Af(Bf(),gb+"\n")}t();var Vb=new vp(Z,tb,Jf(),n.C()),bb=new M(Vb)}else if(I instanceof yw){K=I;y.b()||Xv(a.J,sf(new mf(new nf(J(new L,["trait arguments are not yet supported"]))),v()),n.C(),a.ue);var nb=w.b()?t().f:(t(),
-new M(w)),Tb=a.ue,ub=$v(a),Ub=aw(a,K,r,nb,e,Tb,ub);if(null===Ub)throw new x(Ub);var $a=Ub.i(),cb=Ub.j(),Na=a.Kd,Ca=zw(K,I.Ca(),!1,Na,$a),Ba=O().c;t();var Oa=new vp(Ca,Ba,cb.oe(Ca.xm),n.C());bb=new M(Oa)}else if(I instanceof Aw){K=I;var wa=w.b()?t().f:(t(),new M(w)),ea=a.ue,la=$v(a),Ka=aw(a,K,r,wa,e,ea,la);if(null===Ka)throw new x(Ka);var Ua=Ka.i(),ya=Ka.j(),ib=a.Kd,Lb=Bw(K,I.Ca(),!1,ib,Ua),ec=Lb.Wk;if(ec instanceof M){var Mb=ec.k;Cw(a,Mb.K(),y,B,r);var Jb=new vq(Mb,Mb,y),Kb=new Um((mb=>(vb,Ya)=>{Ya=
-G(new H,vb,Ya);a:{vb=Ya.z;var Wa=Ya.x;if(null!==vb&&(vb=new M(vb),!vb.b()&&(vb=vb.k.j(),null!==Wa&&(Wa=new M(Wa),!Wa.b())))){var rb=Wa.k.j();if(null!==rb&&(Wa=rb.vc,rb=rb.Da,null!==Wa)){Ya=Wa.si;var pa=Wa.ri;if(Wa.pf||Ya||pa)throw new rk("assertion failed: TODO");Ya=cw(a.J,rb,mb,a.ue,$v(a),!0);Wa=a.ue;rb=a.bh;pa=dw(a.J).Cb;ew(a.J,Ya,vb,Wa,rb,mb,pa);break a}}throw new x(Ya);}})(e));xq();Rv(Jb,Kb);var eb=O().c}else{if(t().f!==ec)throw new x(ec);var Wb=Lb.yj;if(Wb instanceof M){var mc=Wb.k;Cw(a,mc.K(),
-y,B,r);var ua=new vq(mc,mc,y),Pa=new Um(((mb,vb)=>(Ya,Wa)=>{var rb=G(new H,Ya,Wa);Ya=rb.z;var pa=rb.x;if(null!==Ya&&(Wa=new M(Ya),!Wa.b()&&(Ya=Wa.k.i(),Wa=Wa.k.j(),null!==pa&&(pa=new M(pa),!pa.b())))){var Fa=pa.k.j();if(null!==Fa&&(pa=Fa.vc,Fa=Fa.Da,null!==pa)){rb=pa.si;var Ib=pa.ri;if(pa.pf||rb||Ib)throw new rk("assertion failed: TODO");rb=cw(a.J,Fa,mb,a.ue,$v(a),!0);pa=Wa.Ma;if(!pa.b()){pa=pa.o();Fa=a.ue;Ib=a.bh;var qb=dw(a.J).Cb;ew(a.J,pa,rb,Fa,Ib,mb,qb)}pa=Wa.oa;Fa=a.ue;Ib=a.bh;qb=dw(a.J).Cb;
-ew(a.J,rb,pa,Fa,Ib,mb,qb);pa=vb.ui.n(Ya.w).Jq();Wa=Wa.Ma.b()?new ww(a.J,Wa.Ma,rb,V(a.J)):new ww(a.J,Wa.Ma,Wa.oa,V(a.J));return Mt(Nt(),pa?new M(new xw(a.J,Ya,Wa,pa,mb.fa)):R())}}throw new x(rb);})(e,Lb));xq();eb=yq(ua,Pa)}else{if(t().f!==Wb)throw new x(Wb);Cw(a,0,y,B,r);eb=O().c}}var xb=a.J;if(xb.D){var Yb=Hs(Q(),"| ",xb.q)+"Class arg members "+eb;Af(Bf(),Yb+"\n")}t();var zb=new vp(Lb,eb,ya.oe(Lb.vm),n.C());bb=new M(zb)}else if(I instanceof Dw)Xv(a.J,sf(new mf(new nf(J(new L,["Cannot inherit from a type alias"]))),
-v()),n.C(),a.ue),bb=t().f;else if(I instanceof xw)Xv(a.J,sf(new mf(new nf(J(new L,["Cannot inherit from a parameter"]))),v()),n.C(),a.ue),bb=t().f;else if(I instanceof Ew)Xv(a.J,sf(new mf(new nf(J(new L,["Cannot inherit from a function"]))),v()),n.C(),a.ue),bb=t().f;else if(I instanceof Fw)bb=t().f;else throw new x(I);}finally{C.q=-1+C.q|0}if(Gw(new E(D),C.pa)&&C.D){var Sb=""+Hs(Q(),"| ",C.q)+D.n(bb);Af(Bf(),Sb+"\n")}var Ma=bb;break a}}throw new x(m);}for(var Ea=Ma.m();Ea.s();){var ab=new A(Ea.t(),
-v());null===l?g=ab:l.r=ab;l=ab}k=k.g()}h=null===g?v():g}finally{a.mE=!1}k=e.hb;gp(fp(),b.V.$h||e.hb.b());if(!k.b()){m=b.V.pa;Ma=b.V;Ma.D&&(n=Hs(Q(),"| ",Ma.q)+"UNSTASHING... (out)",Af(Bf(),n+"\n"));Ma.q=1+Ma.q|0;try{k.ya(new z(mb=>{if(null!==mb){var vb=mb.i();for(mb=mb.j().m();mb.s();){var Ya=mb.t();a:{if(null!==Ya){var Wa=Ya.j();if(!0===Ya.Xc()){Ya=dw(b.V).Cb;ew(b.V,Wa,vb,c,d,b,Ya);break a}}if(null!==Ya&&(Wa=Ya.j(),!1===Ya.Xc())){Ya=dw(b.V).Cb;ew(b.V,vb,Wa,c,d,b,Ya);break a}throw new x(Ya);}}}else throw new x(mb);
-}));k.eg();var Db=void 0}finally{Ma.q=-1+Ma.q|0}Gw(new E(m),Ma.pa)&&Ma.D&&(Db=""+Hs(Q(),"| ",Ma.q)+m.n(Db),Af(Bf(),Db+"\n"))}return h}
-var haa=function Hw(a,b,c){var e=O().c;if(null===e?null===b:e.h(b))return c;if(b instanceof A){var g=b.A;e=b.r;if(null!==g){var h=g.Ks;g=g.zq;if(null!==h){b=h.w;h=!1;var k=null;if(g instanceof Iw){h=g.lu;if(tp()===h||pp()===h||mp()===h)return fp(),b=Vp(new sp(b)),g=Jw(g),c=b.af(g).af(c),Hw(a,e,c);if(Kw()===h||Qo()===h||np()===h)return Hw(a,e,c);throw new x(h);}if(g instanceof Lw){h=!0;k=g;var l=k.rh;if(l instanceof yw)return fp(),c=Vp(new sp(b)).af(l.bq).af(c),Hw(a,e,c)}if(h&&(l=k.rh,l instanceof
-Aw))return fp(),c=Vp(new sp(b)).af(l.zo).af(c),Hw(a,e,c);if(h&&(k.rh instanceof xw||k.rh instanceof Ew||k.rh instanceof Dw||k.rh instanceof Zv||k.rh instanceof Fw))return Hw(a,e,c);throw new x(g);}}}throw new x(b);};
-function iaa(a){var b=Of(a.Kd),c=a.ue,d=a.bh,e=1+b.fa|0,g=ru().U(),h=new Uv(b.V,b.Vc,b.Xa,b.kd,e,b.Ac,b.vb,b.fb,b.ud,g);e=a.Kb;if(e instanceof io){var k=e.bg;e=r=>{var u=r.j(),w=a.J,y=a.J,B=r.j().C();t();y=Mw(new Nw,y,B,"type parameter",new M(r.j().X),!0);B=t().f;t();var D=new M(r.j().X),C=O().c,F=O().c;return new Ul(u,new Ow(w,h.fa,C,F,B,D,!1,y),r.i())};if(k===v())e=v();else{g=k.e();var l=g=new A(e(g),v());for(k=k.g();k!==v();){var m=k.e();m=new A(e(m),v());l=l.r=m;k=k.g()}e=g}}else{if(!(e instanceof
-Kn))throw new x(e);k=e.qh;e=r=>{var u=a.J,w=a.J,y=r.C();t();w=Mw(new Nw,w,y,"method type parameter",new M(r.X),!0);y=t().f;t();var B=new M(r.X),D=O().c,C=O().c;return new Ul(r,new Ow(u,h.fa,D,C,y,B,!1,w),t().f)};if(k===v())e=v();else{g=k.e();l=g=new A(e(g),v());for(k=k.g();k!==v();)m=k.e(),m=new A(e(m),v()),l=l.r=m,k=k.g();e=g}}g=h.hb;gp(fp(),b.V.$h||h.hb.b());if(!g.b()){l=b.V.pa;k=b.V;k.D&&(m=Hs(Q(),"| ",k.q)+"UNSTASHING... (out)",Af(Bf(),m+"\n"));k.q=1+k.q|0;try{g.ya(new z(r=>{if(null!==r){var u=
-r.i();for(r=r.j().m();r.s();){var w=r.t();a:{if(null!==w){var y=w.j();if(!0===w.Xc()){w=dw(b.V).Cb;ew(b.V,y,u,c,d,b,w);break a}}if(null!==w&&(y=w.j(),!1===w.Xc())){w=dw(b.V).Cb;ew(b.V,u,y,c,d,b,w);break a}throw new x(w);}}}else throw new x(r);}));g.eg();var n=void 0}finally{k.q=-1+k.q|0}Gw(new E(l),k.pa)&&k.D&&(n=""+Hs(Q(),"| ",k.q)+l.n(n),Af(Bf(),n+"\n"))}return e}
-function jaa(a){var b=a.pg(),c=h=>{if(null!==h){var k=h.gb;return G(new H,h.ec.X,new Pw(a.J,k,k.Zh))}throw new x(h);};if(b===v())return v();var d=b.e(),e=d=new A(c(d),v());for(b=b.g();b!==v();){var g=b.e();g=new A(c(g),v());e=e.r=g;b=b.g()}return d}function kaa(a){var b=ru();a=a.pg().m();return b.Ib(new eg(a,new z(c=>{var d=c.gb;c=c.xd;c=c.b()?Tt().En:c.o();return G(new H,d,c)})))}
-function laa(a){var b=Of(a.Kd),c=a.ue,d=a.bh,e=1+b.fa|0,g=ru().U(),h=new Uv(b.V,b.Vc,b.Xa,b.kd,e,b.Ac,b.vb,b.fb,b.ud,g),k=a.Kb;if(k instanceof io)if(e=k.Lg,e.b())e=R();else{var l=e.o().Ra;e=u=>{if(null!==u){var w=u.i(),y=u.j();if(w instanceof M&&(w=w.k,null!==y)){var B=y.vc;y=y.Da;if(null!==B){var D=B.si;if(B.pf||D)throw new rk("assertion failed: TODO");B=An(y);if(B instanceof me)return u=B.ia,B=Jf(),u=Qw(a.J,u,h,a.ue,$v(a),B),B=a.J,y=t().f,u=new ww(B,y,u,V(a.J)),G(new H,w,u);$n()}}}if(null!==u&&
-(w=u.i(),B=u.j(),t().f===w&&null!==B&&(u=B.vc,w=B.Da,null!==u&&(B=u.pf,u=u.si,w instanceof Wl)))){if(B||u)throw new rk("assertion failed: TODO");u=a.J;B=t().f;y=a.J;D=new mf(new nf(J(new L,[""," parameters currently need type annotations"])));qf();Q();var C=[pf(0,hu(0,k.nb.td))];y=Xv(y,sf(D,J(new L,C)),w.C(),a.ue);u=new ww(u,B,y,V(a.J));return G(new H,w,u)}$n()};if(l===v())e=v();else{g=l.e();var m=g=new A(e(g),v());for(l=l.g();l!==v();){var n=l.e();n=new A(e(n),v());m=m.r=n;l=l.g()}e=g}e=new M(e)}else{if(!(k instanceof
-Kn))throw new x(k);e=t().f}g=h.hb;gp(fp(),b.V.$h||h.hb.b());if(!g.b()){m=b.V.pa;l=b.V;l.D&&(n=Hs(Q(),"| ",l.q)+"UNSTASHING... (out)",Af(Bf(),n+"\n"));l.q=1+l.q|0;try{g.ya(new z(u=>{if(null!==u){var w=u.i();for(u=u.j().m();u.s();){var y=u.t();a:{if(null!==y){var B=y.j();if(!0===y.Xc()){y=dw(b.V).Cb;ew(b.V,B,w,c,d,b,y);break a}}if(null!==y&&(B=y.j(),!1===y.Xc())){y=dw(b.V).Cb;ew(b.V,w,B,c,d,b,y);break a}throw new x(y);}}}else throw new x(u);}));g.eg();var r=void 0}finally{l.q=-1+l.q|0}Gw(new E(m),l.pa)&&
-l.D&&(r=""+Hs(Q(),"| ",l.q)+m.n(r),Af(Bf(),r+"\n"))}return e}function maa(a){var b=Rw(a),c=b.b()?O().c:b.o();b=h=>{var k=h.i().w;h=new Sw(a.J,h.j().oa,h.i());return G(new H,k,h)};if(c===v())return v();var d=c.e(),e=d=new A(b(d),v());for(c=c.g();c!==v();){var g=c.e();g=new A(b(g),v());e=e.r=g;c=c.g()}return d}
-function naa(a){var b=a.Kb;if(b instanceof io){var c=Of(a.Kd),d=a.ue,e=a.bh,g=1+c.fa|0,h=ru().U(),k=new Uv(c.V,c.Vc,c.Xa,c.kd,g,c.Ac,c.vb,c.fb,c.ud,h);h=zf(b.Uh);je();g=new Wo;je();for(b=new Wo;!h.b();){var l=h.e();a:{if(l instanceof Kn){var m=l;var n=m.Sd,r=m.cd;n=t().f===n?!0:n instanceof M&&!1===!!n.k?!0:!1;if(n&&r instanceof me){l=r.ia;t();m=G(new H,m,l);m=new te(m);break a}}t();m=new me(l)}if(m instanceof te)ip(g,m.ca);else if(m instanceof me)ip(b,m.ia);else throw new x(m);h=h.g()}l=g.ea();b=
-Hn(b.ea(),new Tw(a));Vv(k,Wv(a));g=w=>{if(null!==w){var y=w.i();w=w.j();var B=a.ue,D=a.bh;dw(k.V);var C=1+k.fa|0,F=ru().U(),I=new Uv(k.V,k.Vc,k.Xa,k.kd,C,k.Ac,k.vb,k.fb,k.ud,F);C=$v(a);var K=y.qh;F=Y=>{var S=Y.X,Z=a.J,ka=a.J,X=Y.C();t();ka=Mw(new Nw,ka,X,"method type parameter",new M(Y.X),!0);X=t().f;t();Y=new M(Y.X);var sa=O().c,Ia=O().c;Z=new Ow(Z,I.fa,sa,Ia,X,Y,!1,ka);return G(new H,S,Z)};if(K===v())F=v();else{var N=K.e(),P=N=new A(F(N),v());for(K=K.g();K!==v();){var T=K.e();T=new A(F(T),v());
-P=P.r=T;K=K.g()}F=N}C=C.oe(F);F=a.ue;N=Jf();C=Qw(a.J,w,I,F,C,N);F=a.J;Dt();w=Mw(new Nw,F,Et(0,new A(w,new A(y.Qb,y.qh))),"signature of member `"+y.Qb.w+"`",(Uw(a.J),t().f),(Uw(a.J),!1));w=Vw(C.p,C,w);gp(fp(),k.V.$h||I.hb.b());ru().U();C=Ww(k.V);F=I.hb.m();F=new ho(F,new z(Y=>{if(null!==Y){var S=Y.i();Y=Y.j().m();return new eg(Y,new z(Z=>{if(null!==Z){var ka=Z.Xc();Z=Z.j();gp(fp(),Z.Ca()>k.fa);return ka?G(new H,Z,S):G(new H,S,Z)}throw new x(Z);}))}throw new x(Y);}));je();w=Xw(C,le(v(),F),w);C=k.V;
-C.D&&(C=Hs(Q(),"| ",C.q)+("Inferred poly constr: "+w+"  \u2014\u2014 where ")+Yw(w),Af(Bf(),C+"\n"));k.V.D&&sr(new E(w),w)&&(C=k.V,C.D&&(C=Hs(Q(),"| ",C.q)+("Refreshed:            "+w+"  \u2014\u2014 where ")+Yw(w),Af(Bf(),C+"\n")));w=Zw($w(k.V),k.fa,w);I.hb.eg();C=I.hb;gp(fp(),k.V.$h||I.hb.b());if(!C.b()){F=k.V.pa;N=k.V;N.D&&(P=Hs(Q(),"| ",N.q)+"UNSTASHING... (out)",Af(Bf(),P+"\n"));N.q=1+N.q|0;try{C.ya(new z(Y=>{if(null!==Y){var S=Y.i();for(Y=Y.j().m();Y.s();){var Z=Y.t();a:{if(null!==Z){var ka=
-Z.j();if(!0===Z.Xc()){Z=dw(k.V).Cb;ew(k.V,ka,S,B,D,k,Z);break a}}if(null!==Z&&(ka=Z.j(),!1===Z.Xc())){Z=dw(k.V).Cb;ew(k.V,S,ka,B,D,k,Z);break a}throw new x(Z);}}}else throw new x(Y);}));C.eg();var aa=void 0}finally{N.q=-1+N.q|0}Gw(new E(F),N.pa)&&N.D&&(aa=""+Hs(Q(),"| ",N.q)+F.n(aa),Af(Bf(),aa+"\n"))}return G(new H,y,w)}throw new x(w);};if(l===v())g=v();else{h=l.e();m=h=new A(g(h),v());for(l=l.g();l!==v();)r=l.e(),r=new A(g(r),v()),m=m.r=r,l=l.g();g=h}h=k.hb;gp(fp(),c.V.$h||k.hb.b());if(!h.b()){m=
-c.V.pa;l=c.V;l.D&&(r=Hs(Q(),"| ",l.q)+"UNSTASHING... (out)",Af(Bf(),r+"\n"));l.q=1+l.q|0;try{h.ya(new z(w=>{if(null!==w){var y=w.i();for(w=w.j().m();w.s();){var B=w.t();a:{if(null!==B){var D=B.j();if(!0===B.Xc()){B=dw(c.V).Cb;ew(c.V,D,y,d,e,c,B);break a}}if(null!==B&&(D=B.j(),!1===B.Xc())){B=dw(c.V).Cb;ew(c.V,y,D,d,e,c,B);break a}throw new x(B);}}}else throw new x(w);}));h.eg();var u=void 0}finally{l.q=-1+l.q|0}Gw(new E(m),l.pa)&&l.D&&(u=""+Hs(Q(),"| ",l.q)+m.n(u),Af(Bf(),u+"\n"))}u=g}else{if(!(b instanceof
-Kn))throw new x(b);u=O().c;b=O().c}return G(new H,u,b)}function oaa(a){var b=paa(a).m();b=new eg(b,new z(d=>d.Qb.w));var c=Zp($p(),b);b=ax(a).m();b=new eg(b,new z(d=>{if(null!==d){var e=d.i(),g=e.Qb.w;d=new Ew(a.J,1+a.kx|0,e,d.j(),c.L(e.Qb.w));return G(new H,g,d)}throw new x(d);}));je();return le(v(),b)}
-function qaa(a){var b=a.Kb;if(b instanceof io)return a=Yv(a).m(),a=new ho(a,new z(c=>{c=c.zq;return c instanceof Iw?bx(c):c instanceof Lw&&(c=c.rh,c instanceof cx)?c.Sw:Wp()})),Zp($p(),a);if(b instanceof Kn)return Wp();throw new x(b);}
-function raa(a){a=a.Kb;if(a instanceof io)return a=(new dx(a.Lg)).XE,a=(a.b()?O().c:a.o().Ra).m(),a=new ho(a,new z(b=>{if(null!==b){var c=b.i(),d=b.j();if(c instanceof M&&(c=c.k,null!==d))return d.vc.ri?R():new M(c)}if(null!==b&&(c=b.i(),d=b.j(),t().f===c&&null!==d&&(c=d.vc,d=d.Da,d instanceof Wl)))return c.ri?R():new M(d);null!==b&&(d=b.i(),c=b.j(),t().f===d&&null!==c&&Dn("Program reached and unexpected state."));throw new x(b);})),Zp($p(),a);if(a instanceof Kn)return Wp();throw new x(a);}
-function saa(a){var b=a.Kb;if(b instanceof io){var c=b.Lg;c=(c.b()?new im(O().c):c.o()).Ra.m();c=new ho(c,new z(l=>l.i()));c=Cu(c,new U(()=>{var l=zf(b.Uh).m();return new ex(l,new fx(a))}));c=Zp($p(),c);var d=gx(a);c=c.af(d);var e=a.pg();d=l=>{if(null!==l){var m=l.ec;if(null!==m)return l=new Wl(b.eb.X+"#"+m.X),m=m.C(),aq(l,m)}throw new x(l);};if(e===v())d=v();else{var g=e.e(),h=g=new A(d(g),v());for(e=e.g();e!==v();){var k=e.e();k=new A(d(k),v());h=h.r=k;e=e.g()}d=g}return c.af(d)}if(b instanceof
-Kn)return Wp();throw new x(b);}
-function taa(a){var b=Rw(a);b=b.b()?O().c:b.o();ap();b=b.Li();var c=gx(a);b=b.IF(c);c=ax(a).m();b=b.oe(new eg(c,new z(k=>{var l=k.i().Qb;k=k.j();var m=V(a.J);k=new ww(k.p,R(),k,m);return G(new H,l,k)})));c=hx(a);for(var d=null,e=null;c!==v();){for(var g=c.e().ci.m();g.s();){var h=new A(g.t(),v());null===e?d=h:e.r=h;e=h}c=c.g()}c=null===d?v():d;for(e=d=null;c!==v();){h=c.e();a:{if(null!==h&&(g=h.i(),h=h.j(),h instanceof xw)){g=new Wl(g);g=G(new H,g,h.cg);h=O().c;g=new A(g,h);break a}g=O().c}for(g=
-g.m();g.s();)h=new A(g.t(),v()),null===e?d=h:e.r=h,e=h;c=c.g()}return b.oe(null===d?v():d)}
-function aw(a,b,c,d,e,g,h){var k=c.w;if(!d.b()){var l=d.o(),m=b.pg(),n=l.K();m=m.$a(n);if(sr(new E(m),0)){m=a.J;n=new mf(new nf(J(new L,[""," "," expects "," type parameter(s); got ",""])));var r=pf(qf(),b.zd().td);k=pf(qf(),k);qf();var u=b.pg().K();u=pf(0,""+u);qf();var w=l.K();r=[r,k,u,pf(0,""+w)];Xv(m,sf(n,J(new L,r)),Et(Dt(),new A(c,l)),g)}}l=a.J;if(d.b())d=R();else{r=d.o();d=y=>{var B=Jf();return Qw(a.J,y,e,g,h,B)};if(r===v())d=v();else{m=r.e();n=m=new A(d(m),v());for(r=r.g();r!==v();)k=r.e(),
-k=new A(d(k),v()),n=n.r=k,r=r.g();d=m}d=new M(d)}return ix(l,b,c,d,e)}
-function jx(a,b){var c=a.yn,d=new U(()=>a.ws?(Xv(a.J,sf(new mf(new nf(J(new L,["Unhandled cyclic definition"]))),v()),a.Kb.C(),b),new Fw(a.J,a.Kb)):kx(a.J,new U(()=>"Completing "+lx(a.Kb)),new U(()=>{mx(a.J,new U(()=>{var Na=a.pg();return"Type params "+Qe(Na,""," ","")}));mx(a.J,new U(()=>{var Na=Mt(Nt(),Rw(a));return"Params "+Qe(Na,""," ","")}));try{a.ws=!0;var e=a.Kb;if(e instanceof Kn){var g=!1,h=e.cd;a:{if(h instanceof me){g=!0;var k=h.ia;if(k instanceof mt){var l=k.qs,m=k.ps;nx(a,e,b);var n=
-new z(Na=>{var Ca=$v(a),Ba=ht(l,new z(Oa=>{if(Oa instanceof te){Oa=Oa.ca.X;var wa=a.J,ea=V(a.J),la=t().f,Ka=t().f,Ua=O().c,ya=O().c;wa=new Ow(wa,1,Ua,ya,la,Ka,!1,ea);return G(new H,Oa,wa)}Dn("Program reached and unexpected state.")}));ap();Ca=Ca.oe(bp(cp(),Ba));Ba=Jf();return Qw(a.J,m,Na,b,Ca,Ba)}),r=a.bh;dw(a.Kd.V);var u=ox(a.Kd,n,b,r);var w=new Ew(a.J,a.Kd.fa,e,new px(a.J,a.Kd.fa,u),!1);break a}}g&&Dn("Program reached and unexpected state.");if(h instanceof te){var y=h.ca;h=!1;k=null;var B=e.Sd;
-if(B instanceof M&&(h=!0,k=B,!0===!!k.k)){nx(a,e,b);w=new Ew(a.J,a.Kd.fa,e,cw(a.J,new om(!0,e.Qb,y,e.Qb),a.Kd,b,$v(a),!0),!0);break a}if(h&&!1===!!k.k){nx(a,e,b);w=new Ew(a.J,a.Kd.fa,e,cw(a.J,y,a.Kd,b,$v(a),!0),!0);break a}if(t().f===B){var D=a.Kd,C=qx(a.Kd,new z(Na=>{var Ca=e.qh,Ba=rx(a);Ca=pv(Ca,Ba);Ca=hf(new E(Ca),0);Ba=new U(()=>G(new H,e.qh,rx(a)));if(!Ca)throw new rk("assertion failed: "+Zr(Ba));Ca=$v(a).oe(rx(a));return(new z(Oa=>{if(hf(new E(Na.fa),1)||!e.VD.b())var wa=!0;else{wa=e.UD;var ea=
-new z(la=>{la=la.DF();return Gw(new E(la),Qo())});wa=!wa.b()&&!!ea.n(wa.o())}return wa?cw(a.J,y,Na,b,Oa,!1):(new z(la=>{mx(a.J,new U(()=>"Not typing polymorphicall (cf. not top level or not annotated)"));return cw(a.J,y,la,b,Oa,!1)})).n(D)})).n(Ca)}),b,a.bh),F=Mw(new Nw,a.J,e.C(),"definition of method "+e.Qb.w,(Uw(a.J),t().f),(Uw(a.J),!1)),I=Vw(C.p,C,F);w=new Ew(a.J,a.Kd.fa,e,I,!0);break a}throw new x(B);}throw new x(h);}qx(a.Kd,new z(Na=>{var Ca=w.Vh,Ba=sx(a),Oa=a.bh,wa=dw(a.J).Cb;ew(a.J,Ca,Ba,b,
-Oa,Na,wa)}),b,a.bh);var K=w}else if(e instanceof io){if((et(new E(e.nb),mp())||et(new E(e.nb),Qo()))&&!e.sm.b()){g=a.J;var N=new mf(new nf(J(new L,["Explicit "," constructors are not supported"]))),P=[pf(qf(),e.nb.td)],T=sf(N,J(new L,P)),aa=e.sm,Y=new U(()=>t().f),S=new z(Na=>Na.C());Xv(g,T,aa.b()?Zr(Y):S.n(aa.o()),b)}var Z=e.nb;if(tp()===Z){var ka=e.Lg;if(ka instanceof M){var X=ka.k;Xv(a.J,sf(new mf(new nf(J(new L,["trait parameters are not yet supported"]))),v()),X.C(),b)}K=qx(Of(a.Kd),new z(Na=>
-{Vv(Na,Wv(a));Vv(Na,ht(ax(a),new z(ya=>{var ib=ya.i().sf.w;ya=new Sw(a.J,ya.j(),ya.i().Qb);return G(new H,ib,ya)})));var Ca=new Sw(a.J,tx(a),new Wl("this"));Ca=G(new H,"this",Ca);Na.Xa.S(Ca);Ca=hx(a);var Ba=ux(a.J,e,V(a.J),Na),Oa=O().c,wa=Jf(),ea=e.xj,la=new U(()=>a.J.Na),Ka=new z(()=>vx(a,Na,e,b));Ca=uaa(a,Ca,Ba,Oa,wa,ea.b()?Zr(la):Ka.n(ea.o()),b,e);if(null!==Ca)Oa=new vp(Ca.Jj,Ca.jj,Ca.ci,Ca.Qi);else throw new x(Ca);Ca=Oa.jj;Ba=Oa.ci;Oa=Oa.Qi;ea=zf(e.Uh);for(wa=new z(ya=>{if(ya instanceof Kn&&ya.cd instanceof
-te)return Xv(a.J,sf(new mf(new nf(J(new L,["Method implementations in traits are not yet supported"]))),v()),ya.C(),b)});!ea.b();)wa.n(ea.e()),ea=ea.g();var Ua=Nf(a.J,e.Uh,(t(),new M(e)),Na,b,$v(a));wa=Ca.m();wa=new eg(wa,new z(ya=>{var ib=ya.Sa();return G(new H,ib,ya)}));wa=Cu(wa,new U(()=>ht(Ua.ok,new z(ya=>{var ib=ya.Sa();return G(new H,ib,ya)})))).mb(new U(()=>wx(a)));ap();wa=bp(cp(),wa);xx(a,ht(wx(a),new z(ya=>ya.j())),Ca,O().c,b,e);return new yw(a.J,a.Kd.fa,e,a.pg(),wa,a.J.Na,Oa,Jw(a),Ba)}),
-b,a.bh)}else if(np()===Z){var sa=e.Lg,Ia=new U(()=>new im(O().c));if(!(sa.b()?Zr(Ia):sa.o()).Ra.b()){var Za=a.J,Ga=sf(new mf(new nf(J(new L,["Type alias definitions cannot have value parameters"]))),v()),xa=e.Lg,Ra=new U(()=>new im(O().c)),Ja=(xa.b()?Zr(Ra):xa.o()).C(),La=G(new H,Ga,Ja),pb=O().c;yx(Za,new A(La,pb),b)}if(!e.ti.b()){var Fb=a.J,Gb=sf(new mf(new nf(J(new L,["Type alias definitions cannot extend parents"]))),v()),Hb=Et(Dt(),e.ti),tb=G(new H,Gb,Hb),kb=O().c;yx(Fb,new A(tb,kb),b)}var gb=
-e.xj;if(gb instanceof M)var Vb=gb.k,bb=qx(a.Kd,new z(Na=>{var Ca=$v(a),Ba=Jf();return Qw(a.J,Vb,Na,b,Ca,Ba)}),b,a.bh);else if(t().f===gb)bb=Xv(a.J,sf(new mf(new nf(J(new L,["Type alias definition requires a right-hand side"]))),v()),e.C(),b);else throw new x(gb);K=new Dw(a.J,a.Kd.fa,e,a.pg(),bb)}else if(pp()===Z||mp()===Z)K=qx(Of(a.Kd),new z(Na=>{var Ca=new xf;if(et(new E(e.nb),mp())&&!Rw(a).b()){var Ba=a.J,Oa=new mf(new nf(J(new L,[""," parameters are not supported"])));qf();Q();var wa=[pf(0,hu(0,
-e.nb.td))];Oa=sf(Oa,J(new L,wa));wa=Rw(a);var ea=new U(()=>e.eb.C()),la=new z(Ea=>{Dt();Ea=Ea.m();return Et(0,new eg(Ea,new z(ab=>ab.i())))});Xv(Ba,Oa,wa.b()?Zr(ea):la.n(wa.o()),b)}if(e.rm.b()&&e.Vk.b())if(Ba=e.xj,Ba instanceof M)Oa=Ba.k,Ba=a.J,wa=new mf(new nf(J(new L,["Self-type annotations have no effects on non-abstract "," definitions"]))),ea=[pf(qf(),e.nb.td)],wa=sf(wa,J(new L,ea)),Oa=Oa.C(),Oa=G(new H,wa,Oa),wa=sf(new mf(new nf(J(new L,["Did you mean to use `extends` and inherit from a parent class?"]))),
-v()),ea=t().f,wa=G(new H,wa,ea),ea=O().c,zx(Ba,new A(Oa,new A(wa,ea)),b);else if(t().f!==Ba)throw new x(Ba);Vv(Na,Wv(a));Vv(Na,ht(ax(a),new z(Ea=>{var ab=Ea.i().sf.w;Ea=new Sw(a.J,Ea.j(),Ea.i().Qb);return G(new H,ab,Ea)})));Ba=e.xj;Oa=new U(()=>a.J.Na);wa=new z(()=>vx(a,Na,e,b));Ba=Ba.b()?Zr(Oa):wa.n(Ba.o());Oa=a.J;wa=a.Kb.C();Oa=Mw(new Nw,Oa,wa,Ax(a.Kb),(Uw(a.J),t().f),(Uw(a.J),!1));wa=tx(a);ea=ht(a.pg(),new z(Ea=>{if(null!==Ea){var ab=Ea.ec;Ea=Ea.gb;var Db=e.eb.X+"#"+ab.X,mb=new Pw(a.J,Ea,Ea.Zh),
-vb=a.J;Db=new sp(Db);ab=ab.C();return new xw(vb,aq(Db,ab),new ww(a.J,(t(),new M(mb)),mb,Ea.Zh),!0,Na.fa)}throw new x(Ea);}));var Ka=ht(ea,new z(Ea=>{var ab=Ea.cj.pr();return G(new H,ab,Ea.cg)}));la=Rw(a);var Ua=new z(Ea=>{Ea=Bx(Du(),Ea);var ab=Bx(Du(),Ka);ab=Zp($p(),ab);return Cx(Ea,ab)});la=!(!la.b()&&Ua.n(la.o()));Ua=new U(()=>{$n()});if(!la)throw new rk("assertion failed: "+Zr(Ua));la=a.J;Ua=O().c;var ya=a.J,ib=Et(Dt(),e.ti),Lb=new z(Ea=>Or(Ea));la=new dv(la,Ua,Mw(new Nw,ya,ib.b()?R():new M(Lb.n(ib.o())),
-"Object",(Uw(a.J),t().f),(Uw(a.J),!1)));Ua=Rw(a);ya=new U(()=>O().c);Ua=ht(Ua.b()?Zr(ya):Ua.o(),new z(Ea=>new xw(a.J,Ea.i(),Ea.j(),!Dx(a).L(Ea.i()),Na.fa)));Ca=vaa(a,hx(a),waa(Ca.qb?Ca.sb:xaa(a,Ca),la,mn(ea,Ua),t().f,O().c,O().c,Jf(),Ba),wa,Na,b,Oa,e,Ka,Ba);if(null!==Ca)wa=new Nn(Ca.$p,Ca.js,Ca.Yt,Ca.ls,Ca.ks,Ca.tm);else throw new x(Ca);ea=wa.Aq;var ec=wa.Bq,Mb=wa.Ls,Jb=wa.Ms;Ca=wa.Ns;wa=wa.Ju;la=new Sw(a.J,tx(a),new Wl("this"));la=G(new H,"this",la);Na.Xa.S(la);ea=new Sw(a.J,ea,new Wl("super"));
-ea=G(new H,"super",ea);Na.Xa.S(ea);ea=Nf(a.J,e.Uh,(t(),new M(e)),Na,b,$v(a));la=Mb.jK(new z(Ea=>Ea.Iq()));if(null!==la)la=G(new H,la.i(),la.j());else throw new x(la);var Kb=la.i();mx(a.J,new U(()=>"baseClsImplemMembers "+Kb));var eb=ea.ok,Wb=ht(wx(a),new z(Ea=>Ea.j()));kx(a.J,new U(()=>"Checking `this` accesses..."),new U(()=>{var Ea=Ex(eb,new z(Ya=>Ya.Iq()),!1),ab=zf(e.Uh);ab=Ex(ab,new z(Ya=>!(Ya instanceof Rs)),!1);var Db=e.sm,mb=new U(()=>O().c),vb=new z(Ya=>Ya.Br.Rk);Db=Db.b()?Zr(mb):vb.n(Db.o());
-yaa(a,Ea,mn(ab,Db),Mb,Wb,b)}),a.J.pa);ea=eb.m().mb(new U(()=>ec));ea=new eg(ea,new z(Ea=>Ea.Sa()));var mc=Zp($p(),ea);ea=Kb.m();ea=new Fx(ea,new z(Ea=>Ea.Sa()));ea=new Gx(ea,new z(Ea=>mc.L(Ea.Sa())),!0);je();var ua=le(v(),ea);kx(a.J,new U(()=>"Checking base class implementations against inherited signatures..."),new U(()=>{xx(a,ua,Jb,O().c,b,e)}),a.J.pa);var Pa=Hx(a,Mb,Jb,e,b);ea=eb.m().mb(new U(()=>ec));ea=new Fx(ea,new z(Ea=>Ea.Sa()));je();var xb=le(v(),ea);kx(a.J,new U(()=>"Checking new implementations against inherited signatures..."),
-new U(()=>{var Ea=Wb.m().mb(new U(()=>Pa));Ea=new Fx(Ea,new z(ab=>ab.Sa()));je();xx(a,xb,le(v(),Ea),Wb,b,e)}),a.J.pa);ea=mn(mn(eb,ec),Kb);ea=Ix(ea,new z(Ea=>Ea.Sa()));kx(a.J,new U(()=>"Checking new signatures against inherited signatures..."),new U(()=>{xx(a,Wb,Pa,Wb,b,e)}),a.J.pa);la=Wb.m().mb(new U(()=>Pa.m()));la=new Fx(la,new z(Ea=>Ea.Sa()));la=new Gx(la,new z(Ea=>Ea.Iq()),!0);je();Jx(a,ea,le(v(),la),e,b);ea=ht(mn(Pa,ea),new z(Ea=>{var ab=Ea.Sa();return G(new H,ab,Ea)}));ap();var Yb=bp(cp(),ea).oe(wx(a));
-mx(a.J,new U(()=>"allMembers "+Yb));ea=e.sm;a:{if(ea instanceof M){var zb=ea.k;if(null!==zb){var Sb=zb.Cr,Ma=zb.Br;ya=qx(Of(a.Kd),new z(Ea=>{for(var ab=ht(Sb.Ra,new z(pa=>{if(null!==pa){var Fa=pa.i(),Ib=pa.j();if(Fa instanceof M&&(Fa=Fa.k,null!==Ib)){var qb=Ib.vc;Ib=Ib.Da;if(null!==qb){var Nb=qb.si,fc=qb.ri,Ac=new U(()=>"TODO");if(qb.pf||Nb)throw new rk("assertion failed: "+Zr(Ac));fc&&Kx(a,Fa.C(),b);qb=An(Ib);if(qb instanceof me)return pa=qb.ia,qb=Jf(),pa=Qw(a.J,pa,Ea,b,$v(a),qb),G(new H,Fa,pa);
-$n()}}}if(null!==pa&&(qb=pa.i(),Fa=pa.j(),t().f===qb&&null!==Fa&&(Nb=Fa.vc,Fa=Fa.Da,null!==Nb&&(qb=Nb.pf,Ib=Nb.si,Nb=Nb.ri,Fa instanceof Wl)))){pa=new U(()=>"TODO");if(qb||Ib)throw new rk("assertion failed: "+Zr(pa));Nb&&Kx(a,Fa.C(),b);pa=a.J;qb=Lx(a.J,Fa,!1);Ib=t().f;t();Nb=new M(Fa.w);fc=O().c;Ac=O().c;pa=new Ow(pa,Ea.fa,fc,Ac,Ib,Nb,!1,qb);return G(new H,Fa,pa)}if(null!==pa&&(Fa=pa.i(),qb=pa.j(),t().f===Fa&&null!==qb))return Fa=qb.Da,pa=new Wl("\x3cerror\x3e"),Fa=Xv(a.J,sf(new mf(new nf(J(new L,
-["Unsupported constructor parameter shape"]))),v()),Fa.C(),b),G(new H,pa,Fa);throw new x(pa);})),Db=new z(pa=>{if(null!==pa){var Fa=pa.i(),Ib=Fa.w;pa=new Sw(a.J,pa.j(),Fa);Ib=G(new H,Ib,pa);Ea.Xa.S(Ib)}else throw new x(pa);}),mb=ab;!mb.b();)Db.n(mb.e()),mb=mb.g();var vb=Mw(new Nw,a.J,zb.C(),"auxiliary class constructor",(Uw(a.J),t().f),(Uw(a.J),!1));null!==Ma?Db=Ma.Rk:(Db=O().c,Db=new A(Ma,Db));mb=ru();Du();var Ya=Rw(a),Wa=new U(()=>O().c);Ya=Ya.b()?Zr(Wa):Ya.o();var rb=mb.Ib(Mx(0,Ya,bt()));for(mb=
-new z(pa=>{if(pa instanceof ym){var Fa=pa.Ip,Ib=pa.Er;return rb.Gt(Fa,new z(qb=>{var Nb=!1,fc=null;if(qb instanceof M){Nb=!0;fc=qb;var Ac=fc.k;if(Ac instanceof M)return Nb=Ac.k,qb=cw(a.J,Ib,Ea,b,$v(a),!1),Nb=Nb.oa,fc=dw(a.J).Cb,ew(a.J,qb,Nb,b,vb,Ea,fc),Nb=Fa.w,qb=new Sw(a.J,qb,Fa),qb=G(new H,Nb,qb),Ea.Xa.S(qb),t(),qb=t().f,new M(qb)}if(Nb&&(Nb=fc.k,t().f===Nb))return qb=a.J,Nb=new mf(new nf(J(new L,["Class parameter '","' was already set"]))),fc=[pf(qf(),Fa.w)],Xv(qb,sf(Nb,J(new L,fc)),Fa.C(),b),
-t().f;if(t().f===qb)return qb=a.J,Nb=new mf(new nf(J(new L,["Unknown class parameter '","'"]))),fc=[pf(qf(),Fa.w)],Xv(qb,sf(Nb,J(new L,fc)),Fa.C(),b),t().f;throw new x(qb);}))}if(Nx(pa))return Ox(a.J,pa,!1,Ea,b,$v(a),!1);Dn("Program reached and unexpected state.")});!Db.b();)mb.n(Db.e()),Db=Db.g();t();return new M(ab)}),b,Oa);break a}}if(t().f===ea)ya=t().f;else throw new x(ea);}Px||(Px=new Qx);Oa=a.J;ea=a.Kd.fa;la=a.pg();Ua=Rw(a);ib=new U(()=>{Nt();var Ea=Rw(a).b()&&et(new E(e.nb),pp())?!!e.rm.b():
-!1;return Rx(0,Ea,new U(()=>O().c))});ya=ya.b()?Zr(ib):ya;Ba=new Aw(Oa,ea,e,la,Ua,ya,Yb,a.J.Na,e.rm.b()?Ba:wa,Jw(a),Ca);return zaa(Ba,new z(Ea=>Sx(Ea,Na)))}),b,a.bh);else if(Qo()===Z){if(!e.ti.b()){var nb=a.J,Tb=sf(new mf(new nf(J(new L,["mixin definitions cannot yet extend parents"]))),v()),ub=Et(Dt(),e.ti),Ub=G(new H,Tb,ub),$a=O().c;yx(nb,new A(Ub,$a),b)}var cb=a.Kd;K=qx(Of(a.Kd),new z(Na=>{Vv(Na,Wv(a));Vv(Na,ht(ax(a),new z(ya=>{var ib=ya.i().sf.w;ya=new Sw(a.J,ya.j(),ya.i().Qb);return G(new H,
-ib,ya)})));var Ca=Rw(a),Ba=new z(ya=>ht(ya,new z(ib=>{var Lb=ib.i().w;ib=new xw(a.J,ib.i(),ib.j(),!Dx(a).L(ib.i()),Na.fa);return G(new H,Lb,ib)})));Ca=Ca.b()?R():new M(Ba.n(Ca.o()));Ba=new U(()=>O().c);Ca=Ca.b()?Zr(Ba):Ca.o();ap();Ca=Ca.Li();Ba=a.J;var Oa=V(a.J),wa=t().f;t();var ea=new M("this"),la=O().c,Ka=O().c;Ba=new Ow(Ba,Na.fa,la,Ka,wa,ea,!1,Oa);Oa=a.J;wa=V(a.J);ea=t().f;t();la=new M("super");Ka=O().c;var Ua=O().c;Oa=new Ow(Oa,Na.fa,Ka,Ua,ea,la,!1,wa);wa=new Sw(a.J,Ba,new Wl("this"));wa=G(new H,
-"this",wa);Na.Xa.S(wa);wa=new Sw(a.J,Oa,new Wl("super"));wa=G(new H,"super",wa);Na.Xa.S(wa);wa=Nf(a.J,e.Uh,(t(),new M(e)),Na,b,$v(a)).ok;ea=ht(wx(a),new z(ya=>ya.j()));xx(a,wa,ea,ea,b,e);Jx(a,wa,ea,e,b);wa=ht(wa,new z(ya=>{var ib=ya.Sa();return G(new H,ib,ya)}));ap();Ca=Ca.oe(bp(cp(),wa)).oe(wx(a));wa=a.J;ea=cb.fa;la=a.pg();Ka=Rw(a);Ua=new U(()=>O().c);return new Zv(wa,ea,e,Ba,Oa,la,Ka.b()?Zr(Ua):Ka.o(),Ca)}),b,a.bh)}else throw new x(Z);}else throw new x(e);}finally{a.ws=!1}a.yn=(t(),new M(K));return K}),
-new z(e=>{var g=e.FF();var h=O().c;g=new Tx(g,new A(e,h),t().f);g=Yw(g);return"Completed "+e+" where "+g})));return c.b()?Zr(d):c.o()}
-function Ux(a,b,c,d){var e=a.Kb;if(e instanceof Kn){if(a.ws)return b=a.J,b.D&&(b=Hs(Q(),"| ",b.q)+"Already computing! Using TV: "+sx(a),Af(Bf(),b+"\n")),sx(a);a=jx(a,d);if(a instanceof Ew)return a.Vh;Dn("Program reached and unexpected state.")}else if(e instanceof io){if(e.sm.b())return Vx(a.J,b,c,e,a.kx,a.pg(),Rw(a),t().f,Jw(a),d);e=jx(a,d);if(e instanceof Aw)return Vx(e.ic,b,c,e.Gf,e.um,e.Zg,e.yj,e.Wk,0,d);if(e instanceof Fw)return Wx(a.J);Dn("Program reached and unexpected state.")}else throw new x(e);
-}function Cw(a,b,c,d,e){var g=c.$a(b);if(sr(new E(g),0)){g=a.J;var h=new mf(new nf(J(new L,["class "," expects "," parameter(s); got ",""])));d=pf(qf(),d);b=pf(qf(),""+b);qf();var k=c.K();b=[d,b,pf(0,""+k)];h=sf(h,J(new L,b));Dt();b=ap();c=c.Gb(b.wa).j();Xv(g,h,Et(0,new A(e,c)),a.ue)}}function nx(a,b,c){b.qh.b()||Xv(a.J,sf(new mf(new nf(J(new L,["Type parameters are not yet supported in this position"]))),v()),b.qh.e().C(),c)}
-function Xx(a,b){if(Yx(a.jd))return!0;a=b.Y(a.Sa());return a instanceof M&&(a=a.k,a instanceof Ew)?!a.jd.Ow.b():!1}
-function Zx(a,b,c,d,e,g,h,k){var l=b.WD;if(l.b()){b=b.wz;l=t().f;for(b=b.m();b.s();){var m=l;l=b.t();if(m.b())a:{if(m=c.Y(l.i().w),m instanceof M&&(m=m.k,m instanceof Ew)){if(d.b())var n=!0;else n=d.o(),n=sr(new E(n),l.i().w);if(n&&!e.L(l.i().w)){n=l.j();if(n instanceof M&&(!g||Xx(m,h))){l=n;break a}m=$x(m);t();l=ay(a,m,new M(l.i().w),new A(l.i().w,e),!1,c,k,h);break a}}l=t().f}else l=m}return l}return l}
-function ay(a,b,c,d,e,g,h,k){if(c.b())return Zx(a,b,g,c,d,e,k,h);var l=c.o();if(ja(h)!==ma(by)){var m=h.Y(l);if(m instanceof M)h=m.k;else{if(R()!==m)throw new x(m);a=Zx(a,b,g,c,d,e,k,h);cy(h,l,a,!1);h=a}}else{m=dy(W(),l);m^=m>>>16|0;var n=m&(-1+h.cb.a.length|0),r=h.cb.a[n];r=null===r?null:ey(r,l,m);null!==r?h=r.ph:(r=h.cb,a=Zx(a,b,g,c,d,e,k,h),(1+h.Of|0)>=h.At&&fy(h,h.cb.a.length<<1),gy(h,l,a,!1,m,r===h.cb?n:m&(-1+h.cb.a.length|0)),h=a)}return h}
-function hy(a,b,c,d,e,g){b.wz.ya(new z(h=>{if(h.j().b()){var k=d.Y(h.i().w);if(k instanceof M){var l=k.k;if(l instanceof Ew&&Xx(l,g)){k=a.J;var m=new mf(new nf(J(new L,["Unqualified access to virtual member ",""])));h=[pf(qf(),h.i().w)];h=sf(m,J(new L,h));h=G(new H,h,c);m=sf(new mf(new nf(J(new L,["Declared here:"]))),v());l=l.jd.C();l=G(new H,m,l);m=O().c;return yx(k,new A(h,new A(l,m)),e)}}}}))}
-function iy(a,b){var c=a.j(),d=b.j();if(c instanceof M&&(c=c.k,d instanceof M&&jy(c,d.k)))return a=G(new H,a.i(),d),b=O().c,new A(a,b);d=O().c;return new A(a,new A(b,d))}
-function yaa(a,b,c,d,e,g){ky();var h=v();h=ly(h);var k=y=>{var B=y.Sa();return G(new H,B,y)};if(e===v())k=v();else{var l=e.e(),m=l=new A(k(l),v());for(e=e.g();e!==v();){var n=e.e();n=new A(k(n),v());m=m.r=n;e=e.g()}k=l}ap();k=bp(cp(),k);d=d.m().mb(new U(()=>b));d=new eg(d,new z(y=>{var B=y.Sa();return G(new H,B,y)}));ap();d=k.oe(bp(cp(),d));for(l=b;!l.b();){m=l.e();if(m instanceof Ew){var r=m;m=r.jd;e=$x(r);if(!m.Sd.b()){t();n=r.Sa();n=new M(n);var u=r.Sa(),w=O().c;n=ay(a,e,n,new A(u,w),!0,d,h,k);
-if(n instanceof M)u=n.k,n=a.J,w=new mf(new nf(J(new L,["Cannot access `this` while initializing field ",""]))),r=[pf(qf(),r.Sa())],r=sf(w,J(new L,r)),w=m.C(),r=G(new H,r,w),w=sf(new mf(new nf(J(new L,["The access to `this` is here"]))),v()),u=u.C(),yx(n,iy(r,G(new H,w,u)),g);else if(t().f!==n)throw new x(n);}hy(a,e,m.C(),d,g,k)}l=l.g()}for(;!c.b();){l=c.e();a:{if(l instanceof em&&(m=l.Ni,m instanceof Wl&&"this"===m.w))break a;m=my(a.J,l);e=ay(a,m,t().f,O().c,!1,d,h,k);if(e instanceof M)n=e.k,e=a.J,
-r=sf(new mf(new nf(J(new L,["Cannot access `this` during object initialization"]))),v()),u=l.C(),r=G(new H,r,u),u=sf(new mf(new nf(J(new L,["The access to `this` is here"]))),v()),n=n.C(),yx(e,iy(r,G(new H,u,n)),g);else if(t().f!==e)throw new x(e);hy(a,m,l.C(),d,g,k)}c=c.g()}}
-function Jx(a,b,c,d,e){for(var g=ru().U();!b.b();){var h=b.e();g.Gt(h.Sa(),new z(((m,n,r)=>u=>{if(u instanceof M){u=a.J;var w=new mf(new nf(J(new L,["Duplicated `","` member definition in `","`"]))),y=[pf(qf(),m.Sa()),pf(qf(),n.sf.w)];Xv(u,sf(w,J(new L,y)),m.C(),r);return t().f}if(t().f===u)return t(),new M(m);throw new x(u);})(h,d,e)));b=b.g()}if(d.Vk.b()&&sr(new E(d.nb),tp())&&d.rm.b())for(;!c.b();){h=c.e();b=g.Y(h.Sa());if(!(b instanceof M))if(t().f===b){b=a.J;var k=new mf(new nf(J(new L,["Member `",
-"` is declared (or its declaration is inherited) but is not implemented in `","`"]))),l=[pf(qf(),h.Sa()),pf(qf(),d.eb.X)];k=sf(k,J(new L,l));l=d.eb.C();k=G(new H,k,l);l=sf(new mf(new nf(J(new L,["Declared here:"]))),v());h=h.C();h=G(new H,l,h);l=O().c;yx(b,new A(k,new A(h,l)),e)}else throw new x(b);c=c.g()}}
-function xx(a,b,c,d,e,g){var h=a.Kd,k=a.bh,l=1+h.fa|0,m=ru().U();l=new Uv(h.V,h.Vc,h.Xa,h.kd,l,h.Ac,h.vb,h.fb,h.ud,m);for(m=ru().U();!c.b();){var n=c.e();m.Gt(n.Sa(),new z((B=>D=>{if(D instanceof M)Dn("Program reached and unexpected state.");else{if(t().f===D)return t(),new M(B);throw new x(D);}})(n)));c=c.g()}for(;!b.b();){c=b.e();n=a.J;n.D&&(n=Hs(Q(),"| ",n.q)+("Checking overriding for "+c+" against "+m.Y(c.Sa()))+"...",Af(Bf(),n+"\n"));var r=G(new H,c,m.Y(c.Sa()));a:if(n=r.x,t().f!==n){n=r.z;var u=
-r.x;if(n&&n.$classData&&n.$classData.pb.ZD&&u instanceof M&&(u=u.k)&&u.$classData&&u.$classData.pb.ZD){c=u;if(!c.Jq())break a;if(c instanceof Ew&&!Yx(c.jd)&&!d.L(c)){r=a.J;u=new mf(new nf(J(new L,[""," member `","` is not virtual and cannot be overridden"])));qf();Q();var w=n.zd().td;w=[pf(0,hu(0,w)),pf(qf(),n.Sa())];u=sf(u,J(new L,w));n=n.C();n=G(new H,u,n);u=sf(new mf(new nf(J(new L,["Originally declared here:"]))),v());c=c.C();c=G(new H,u,c);u=O().c;yx(r,new A(n,new A(c,u)),e);break a}if(c instanceof
-xw&&!d.L(c)){r=a.J;u=new mf(new nf(J(new L,["Inherited parameter named `","` is not virtual and cannot be overridden"])));w=[pf(qf(),n.Sa())];u=sf(u,J(new L,w));n=n.C();n=G(new H,u,n);u=sf(new mf(new nf(J(new L,["Originally declared here:"]))),v());c=c.C();c=G(new H,u,c);u=O().c;yx(r,new A(n,new A(c,u)),e);break a}n=n.no();r=n.qa();c=c.no();u=dw(a.J).Cb;ew(a.J,n,c,e,r,l,u);break a}n=r.x;if(n instanceof M)r=n.k,n=a.J,u=new mf(new nf(J(new L,[""," member `","` cannot override "," member of the same name declared in parent"]))),
-qf(),Q(),w=c.zd().td,c=[pf(0,hu(0,w)),pf(qf(),c.Sa()),pf(qf(),r.zd().td)],c=sf(u,J(new L,c)),u=g.C(),c=G(new H,c,u),u=sf(new mf(new nf(J(new L,["Originally declared here:"]))),v()),r=r.C(),r=G(new H,u,r),u=O().c,yx(n,new A(c,new A(r,u)),e);else throw new x(r);}b=b.g()}a=l.hb;gp(fp(),h.V.$h||l.hb.b());if(!a.b()){d=h.V.pa;g=h.V;g.D&&(l=Hs(Q(),"| ",g.q)+"UNSTASHING... (out)",Af(Bf(),l+"\n"));g.q=1+g.q|0;try{a.ya(new z(B=>{if(null!==B){var D=B.i();for(B=B.j().m();B.s();){var C=B.t();a:{if(null!==C){var F=
-C.j();if(!0===C.Xc()){C=dw(h.V).Cb;ew(h.V,F,D,e,k,h,C);break a}}if(null!==C&&(F=C.j(),!1===C.Xc())){C=dw(h.V).Cb;ew(h.V,D,F,e,k,h,C);break a}throw new x(C);}}}else throw new x(B);}));a.eg();var y=void 0}finally{g.q=-1+g.q|0}Gw(new E(d),g.pa)&&g.D&&(y=""+Hs(Q(),"| ",g.q)+d.n(y),Af(Bf(),y+"\n"))}}
-function Aaa(a,b,c,d,e){var g=new z(y=>{var B=y.Ca();B=hf(new E(B),b.Ca());var D=new U(()=>new au(b.Ca(),y.Ca()));if(!B)throw new rk("assertion failed: "+Zr(D));});c.b()||g.n(c.o());g=G(new H,b,c);c=g.z;var h=g.x;if(c instanceof Ew&&h instanceof M){var k=h.k;if(k instanceof Ew){gp(fp(),!(c.ns&&k.ns));d=G(new H,c.jd.Sd,k.jd.Sd);a:{e=d.z;d=d.x;if(e instanceof M&&(e=!!e.k,d instanceof M)){d=!!d.k;t();e=new M(e||d);break a}e=t().f}d=c.jd.Qb;g=t().f;h=c.jd.qh;var l=c.jd.cd,m=c.jd.tz,n=c.jd.Ow,r=t().f,
-u=c.jd.UD,w=new U(()=>k.jd.UD);e=new Kn(e,d,g,h,l,m,n,r,u.b()?Zr(w):u,c.jd.yo);t();a=a.J;d=c.Bo;g=c.Vh;h=k.Vh;l=V(c.Vh.p);e=new Ew(a,d,e,ju(g,h,l,!1),c.ns||k.ns);return new M(e)}}c=g.z;h=g.x;if(c instanceof xw&&h instanceof M&&(h=h.k,h instanceof xw)){if(c.tn){if(h.tn)return t(),e=new xw(a.J,c.cj,av(c.cg,h.cg,V(c.cg.Ua)),!0,c.vz),new M(e);t();return new M(c)}t();return new M(h)}c=g.z;h=g.x;if(c instanceof xw&&h instanceof M&&(h=h.k,h instanceof Ew))return t(),e=a.J,a=c.vz,d=h.jd,g=c.cg.oa,h=h.Vh,
-c=V(c.cg.oa.p),e=new Ew(e,a,d,ju(g,h,c,!1),!0),new M(e);c=g.z;h=g.x;if(c instanceof Ew&&h instanceof M&&(h=h.k,h instanceof xw))return t(),e=a.J,a=c.Bo,d=c.jd,g=h.cg.oa,c=c.Vh,h=V(h.cg.oa.p),e=new Ew(e,a,d,ju(g,c,h,!1),!0),new M(e);c=g.z;h=g.x;if(t().f===h)return t(),new M(c);h=g.z;c=g.x;if(c instanceof M)return c=c.k,a=a.J,g=new mf(new nf(J(new L,["Intersection of "," member and "," members currently unsupported"]))),l=[pf(qf(),h.zd().td),pf(qf(),c.zd().td)],g=sf(g,J(new L,l)),d=d.C(),d=G(new H,
-g,d),g=new mf(new nf(J(new L,["The "," member is defined here:"]))),l=[pf(qf(),h.zd().td)],g=sf(g,J(new L,l)),h=h.C(),g=G(new H,g,h),h=new mf(new nf(J(new L,["The "," member is defined here:"]))),l=[pf(qf(),c.zd().td)],h=sf(h,J(new L,l)),c=c.C(),c=G(new H,h,c),h=O().c,yx(a,new A(d,new A(g,new A(c,h))),e),t().f;throw new x(g);}
-function Hx(a,b,c,d,e){var g=m=>{var n=m.Sa();return G(new H,n,m)};if(c===v())g=v();else{var h=c.e(),k=h=new A(g(h),v());for(c=c.g();c!==v();){var l=c.e();l=new A(g(l),v());k=k.r=l;c=c.g()}g=h}ap();for(g=bp(cp(),g);!b.b();)h=b.e(),g=g.kC(h.Sa(),new z(((m,n,r)=>u=>Aaa(a,m,u,n,r))(h,d,e))),b=b.g();return g.aT().ea()}
-function vx(a,b,c,d){var e=Of(b),g=a.bh,h=1+e.fa|0,k=ru().U();h=new Uv(e.V,e.Vc,e.Xa,e.kd,h,e.Ac,e.vb,e.fb,e.ud,k);c=c.xj;c=c.b()?Jl():c.o();k=$v(a);var l=Jf();c=Qw(a.J,c,h,d,k,l);k=ru().U();c=c.Dc(b.fa,!0,h,k);k=h.hb;gp(fp(),e.V.$h||h.hb.b());if(!k.b()){h=e.V.pa;l=e.V;if(l.D){var m=Hs(Q(),"| ",l.q)+"UNSTASHING... (out)";Af(Bf(),m+"\n")}l.q=1+l.q|0;try{k.ya(new z(u=>{if(null!==u){var w=u.i();for(u=u.j().m();u.s();){var y=u.t();a:{if(null!==y){var B=y.j();if(!0===y.Xc()){y=dw(e.V).Cb;ew(e.V,B,w,d,
-g,e,y);break a}}if(null!==y&&(B=y.j(),!1===y.Xc())){y=dw(e.V).Cb;ew(e.V,w,B,d,g,e,y);break a}throw new x(y);}}}else throw new x(u);}));k.eg();var n=void 0}finally{l.q=-1+l.q|0}Gw(new E(h),l.pa)&&l.D&&(n=""+Hs(Q(),"| ",l.q)+h.n(n),Af(Bf(),n+"\n"))}n=a.J;h=V(a.J);k=t().f;l=t().f;m=O().c;var r=O().c;n=new Ow(n,b.fa,m,r,k,l,!1,h);h=a.bh;k=dw(a.J).Cb;ew(a.J,c,n,d,h,b,k);b=ny(n);if(b instanceof A&&(a=b.A,b=b.r,c=O().c,null===c?null===b:c.h(b)))return a;Dn("Program reached and unexpected state.")}
-function uaa(a,b,c,d,e,g,h,k){for(;;){var l=!1,m=null,n=b;if(n instanceof A){l=!0;m=n;var r=m.A;b=m.r;if(null!==r){var u=r.Jj,w=r.jj;r=r.ci;if(u instanceof yw){m=u;if(!w.b())throw new rk("assertion failed: "+w);n=a;l=c;w=m.lk;c=V(c.p);c=ju(l,w,c,!1);l=new dp(m.kk);je();d=Hx(a,d,le(v(),l),k,h);e=e.oe(r);a=g;r=m.lk;g=V(g.p);g=ju(a,r,g,!1);a=n;continue}}}if(l&&(b=m.A,r=m.r,null!==b)){b=b.Qi;Xv(a.J,sf(new mf(new nf(J(new L,["A trait can only inherit from other traits"]))),v()),b,h);b=r;continue}h=O().c;
-if(null===h?null===n:h.h(n))return new vp(c,d,e,g);throw new x(n);}}function xaa(a,b){if(null===b)throw ze();return b.qb?b.sb:Ce(b,new oy(a))}
-function vaa(a,b,c,d,e,g,h,k,l,m){for(var n=a;;){var r=b;if(r instanceof A){var u=r,w=u.A,y=u.r;if(null!==w){var B=w.Jj,D=w.jj,C=w.ci,F=w.Qi,I=n.J;if(I.D){var K=Hs(Q(),"| ",I.q)+"\x3d\x3e Inheriting from "+B;Af(Bf(),K+"\n")}if(B instanceof Zv){var N=B;gp(fp(),hf(new E(d.Va),e.fa));fp();var P=N.Xk.Ca();gp(0,hf(new E(P),e.fa));fp();var T=N.Zk.Ca();gp(0,hf(new E(T),e.fa));var aa=c.$p,Y=N.Xk,S=dw(n.J).Cb;ew(n.J,aa,Y,g,h,e,S);var Z=N.Zk,ka=dw(n.J).Cb;ew(n.J,d,Z,g,h,e,ka);gp(fp(),C.b());var X=N.zj.Qd(),
-sa=new Gx(X,new z(db=>py(db)),!0),Ia=mn(D,sa),Za=n.J,Ga=c.$p,xa=n.J,Ra=Hn(Ia,new qy(n)),Ja=new dv(xa,Ra,V(n.J)),La=new ry(Za,Ga,Ja,V(n.J)),pb=n,Fb=c,Gb=mn(Ia,c.js),Hb=new sy(Fb.uz,La,Gb,c.Zt,c.Yt,c.ls,c.ks,c.tm);n=pb;b=y;c=Hb;continue}else if(B instanceof yw){var tb=B;if(!D.b())throw new rk("assertion failed: "+D);var kb=n,gb=n,Vb=c.ls,bb=tb.kk.Qd(),nb=new Gx(bb,new z(db=>py(db)),!0);je();var Tb=Hx(gb,Vb,le(v(),nb),k,g),ub=c.ks.oe(C),Ub=c.tm,$a=tb.lk,cb=V(c.tm.p),Na=ju(Ub,$a,cb,!1),Ca=new sy(c.uz,
-c.$p,c.js,c.Zt,c.Yt,Tb,ub,Na);n=kb;b=y;c=Ca;continue}else if(B instanceof Aw){var Ba=B,Oa=Ba.Gf.eb.X,wa=c.Zt,ea=n;if(!wa.b()){var la=wa.o(),Ka=ea.J,Ua=new mf(new nf(J(new L,["Cannot inherit from more than one base class: "," and ",""]))),ya=[pf(qf(),la),pf(qf(),Oa)];Xv(Ka,sf(Ua,J(new L,ya)),F,g)}var ib=Ba.ui.Qd();je();var Lb=le(v(),ib);if(Lb.b())var ec=je().LB;else{je();var Mb=new Wo;je();for(var Jb=new Wo,Kb=Lb.m();Kb.s();){var eb=Kb.t();ip(py(eb)?Mb:Jb,eb)}var Wb=G(new H,Mb.ea(),Jb.ea());var mc=
-Wb.z;if(v().h(mc))ec=G(new H,v(),Lb);else{var ua=Wb.x;ec=v().h(ua)?G(new H,Lb,v()):Wb}}if(null===ec)throw new x(ec);var Pa=n.J;if(Pa.D){var xb=Hs(Q(),"| ",Pa.q)+"argMembs "+D;Af(Bf(),xb+"\n")}var Yb=n.J;if(Yb.D){var zb=Hs(Q(),"| ",Yb.q)+"selfSig "+Ba.jk;Af(Bf(),zb+"\n")}var Sb=n;t();var Ma=new M(Oa),Ea=Ba.ui.Qd(),ab=mn(D,Ea),Db=c.ks.oe(C),mb=c.tm,vb=Ba.jk,Ya=V(c.tm.p),Wa=ju(mb,vb,Ya,!1),rb=new sy(c.uz,c.$p,c.js,Ma,ab,c.ls,Db,Wa);n=Sb;b=y;c=rb;continue}else if(B instanceof Dw){b=y;continue}else throw new x(B);
-}}var pa=O().c;if(null===pa?null===r:pa.h(r)){var Fa=n.J,Ib=c;if(Fa.D){var qb=Hs(Q(),"| ",Fa.q)+"Done inheriting: "+Ib;Af(Bf(),qb+"\n")}var Nb=n.J,fc=c.$p,Ac=n.J,tc=Rw(n),vc=tc.b()?O().c:tc.o(),sc=k.Lg,uc=sc.b()?new im(O().c):sc.o(),lc=new dv(Ac,vc,Lx(n.J,uc,!0)),Wc=new ry(Nb,fc,lc,V(n.J)),Cc=ty(n.J,k,V(n.J),e),Dc=V(Wc.p),Ec=ju(Wc,Cc,Dc,!1),Ic=n.J;Dt();var Xc=k.bg;if(Xc===v())var Sc=v();else{for(var oc=Xc.e(),qc=new A(oc.j(),v()),Tc=qc,Nc=Xc.g();Nc!==v();){var Pc=Nc.e(),Oc=new A(Pc.j(),v());Tc=Tc.r=
-Oc;Nc=Nc.g()}Sc=qc}var $c=Et(0,Sc);Uw(n.J);var Lc=t().f,Zb=new dv(Ic,l,Mw(new Nw,n.J,$c,"type parameters",Lc,!0)),ed=V(Ec.p),$b=ju(Ec,Zb,ed,!1),Fc=n,Yc=n.J.pa,nc=n.J;if(nc.D){var Ob=Hs(Q(),"| ",nc.q)+(e.fa+". Finalizing inheritance with "+$b+" \x3c: ")+d;Af(Bf(),Ob+"\n")}nc.q=1+nc.q|0;try{gp(fp(),hf(new E(d.Va),e.fa));var cc=V($b.p),Gc=ju($b,m,cc,!1),Bc=dw(Fc.J).Cb;ew(Fc.J,Gc,d,g,h,e,Bc);var qd=void 0}finally{nc.q=-1+nc.q|0}if(Gw(new E(Yc),nc.pa)&&nc.D){var Gd=""+Hs(Q(),"| ",nc.q)+Yc.n(qd);Af(Bf(),
-Gd+"\n")}if(k.rm.b()){var cd=n,rd=c,Id=n.J.pa,Ha=n.J;if(Ha.D){var jc=Hs(Q(),"| ",Ha.q)+"Checking self signature...";Af(Bf(),jc+"\n")}Ha.q=1+Ha.q|0;try{var Rb=rd.tm,Uc=dw(cd.J).Cb;ew(cd.J,$b,Rb,g,h,e,Uc);var Rc=void 0}finally{Ha.q=-1+Ha.q|0}if(Gw(new E(Id),Ha.pa)&&Ha.D){var Cd=""+Hs(Q(),"| ",Ha.q)+Id.n(Rc);Af(Bf(),Cd+"\n")}}var od=c.tm,Va=V(c.tm.p),wb=ju(od,m,Va,!1);return new sy(c.uz,$b,c.js,c.Zt,c.Yt,c.ls,c.ks,wb)}throw new x(r);}}
-function Kx(a,b,c){Xv(a.J,sf(new mf(new nf(J(new L,["Cannot use `val` in constructor parameters"]))),v()),b,c)}function py(a){return a instanceof xw?!(a.cj instanceof sp):!1}function uy(a,b,c){return a.ml(t().f,!1,new Um((d,e)=>b.n(e)),c)}function vy(a){return!!(a&&a.$classData&&a.$classData.pb.CH)}function wy(){}wy.prototype=new p;wy.prototype.constructor=wy;function xy(a,b){return xl(new yy).Nb(b,new z(()=>{t();return R()}))}wy.prototype.$classData=q({hX:0},!1,"mlscript.OpApp$",{hX:1,d:1});var zy;
-function Ay(){zy||(zy=new wy);return zy}function By(){this.td=null}By.prototype=new p;By.prototype.constructor=By;function Cy(){}Cy.prototype=By.prototype;function Dy(){}Dy.prototype=new p;Dy.prototype.constructor=Dy;function Ht(a){a=a.m();a=new eg(a,new z(b=>G(new H,t().f,new ws(Ct().Kg,b))));je();return new im(le(v(),a))}
-function Ey(a,b){if(b instanceof im){a=b.Ra;a:{for(b=a;!b.b();){var c=b.e();if(!(c.i().b()&&hf(new E(c.j().vc.pf),!1)&&hf(new E(c.j().vc.si),!1))){b=!1;break a}b=b.g()}b=!0}if(b){t();if(a===v())a=v();else{b=a.e();c=b=new A(b.j().Da,v());for(a=a.g();a!==v();){var d=a.e();d=new A(d.j().Da,v());c=c.r=d;a=a.g()}a=b}return new M(a)}}return t().f}Dy.prototype.$classData=q({mX:0},!1,"mlscript.PlainTup$",{mX:1,d:1});var Fy;function Gt(){Fy||(Fy=new Dy);return Fy}
-function Gy(){this.EH=this.Az=null;ky();var a=v();this.Az=ly(a);Hy();a=v();this.EH=Iy(a)}Gy.prototype=new p;Gy.prototype.constructor=Gy;function Tn(a,b,c){cy(a.Az,b,c,!1);return c}Gy.prototype.$classData=q({oX:0},!1,"mlscript.Polyfill",{oX:1,d:1});
-function Jy(a,b,c){a=new Yl("x");var d=new Yl("y"),e=O().c;a=new A(a,new A(d,e));d=new Em("arguments");d=Gm(cm(),d,"length");d=new Vm("\x3d\x3d\x3d",d,new Wm("2"));e=jn(new Vm(b,new Em("x"),new Em("y")));var g=O().c;e=new A(e,g);g=new Yl("y");var h=O().c;g=new A(g,h);t();b=jn(new bo(g,new te(new Vm(b,new Em("x"),new Em("y")))));g=O().c;b=new To(d,e,new A(b,g));d=O().c;return new Ky(c,a,new A(b,d))}
-function Ly(a,b,c){a=J(new L,[new Yl("x")]);b=[jn(new My(b,new Em("x")))];b=J(new L,b);return new Ky(c,(je(),le(v(),a)),(je(),le(v(),b)))}
-function Ny(){this.zN=this.yN=null;Oy=this;var a=Nl();Ql(a,new Py("prettyPrint",new z(b=>{var c=new Em("value"),d=new Yl("value"),e=O().c;d=new A(d,e);e=new My("typeof",c);var g=J(new L,[c]);g=jn(new Rm(new Em("String"),(je(),le(v(),g))));var h=O().c;g=new A(g,h);h=Pm("number");var k=O().c;h=G(new H,h,k);k=Pm("boolean");var l=Gm(cm(),c,"toString"),m=v();l=jn(new Rm(l,m));m=O().c;k=G(new H,k,new A(l,m));l=Pm("function");m=Gm(cm(),c,"name");var n=Pm("\x3canonymous\x3e");m=new Vm("??",m,n);n=Pm("[Function: ");
-m=new Vm("+",n,m);n=Pm("]");m=jn(new Vm("+",m,n));n=O().c;l=G(new H,l,new A(m,n));m=Pm("string");n=Pm('"');n=new Vm("+",n,c);var r=Pm('"');n=jn(new Vm("+",n,r));r=O().c;m=G(new H,m,new A(n,r));n=Pm("undefined");r=jn(Pm("undefined"));var u=O().c;n=G(new H,n,new A(r,u));r=Pm("object");u=new Vm("\x3d\x3d\x3d",c,new Em("null"));var w=jn(Pm("null")),y=O().c;w=new A(w,y);y=Gm(cm(),c,"constructor");y=Gm(cm(),y,"name");var B=Pm(" ");y=new Vm("+",y,B);B=new Em("JSON");B=Gm(cm(),B,"stringify");var D=J(new L,
-[c,new Em("undefined"),new Em("2")]);B=new Rm(B,(je(),le(v(),D)));y=jn(new Vm("+",y,B));B=O().c;y=new A(y,B);B=new Em("_");c=J(new L,[c]);c=jn(new Rm(new Em("String"),(je(),le(v(),c))));D=O().c;c=new Qy(y,new Ry(B,new A(c,D)));y=O().c;c=new To(u,w,new A(c,y));u=O().c;c=[h,k,l,m,n,G(new H,r,new A(c,u))];e=Baa(e,g,J(new L,c));g=O().c;return new Ky(b,d,new A(e,g))})));Ql(a,new Py("withConstruct",new z(b=>{var c=new Em("Object"),d=new Em("target"),e=new Em("fields"),g=J(new L,[new Yl("target"),new Yl("fields")]),
-h=new My("typeof",d),k=Pm("string");h=new Vm("\x3d\x3d\x3d",h,k);k=new My("typeof",d);var l=Pm("number");h=new Vm("||",h,new Vm("\x3d\x3d\x3d",k,l));k=new My("typeof",d);l=Pm("boolean");h=new Vm("||",h,new Vm("\x3d\x3d\x3d",k,l));k=new My("typeof",d);l=Pm("bigint");h=new Vm("||",h,new Vm("\x3d\x3d\x3d",k,l));k=new My("typeof",d);l=Pm("symbol");h=new Vm("||",h,new Vm("\x3d\x3d\x3d",k,l));k=Gm(cm(),c,"assign");l=J(new L,[d,e]);k=jn(new Rm(k,(je(),le(v(),l))));l=O().c;h=new To(h,new A(k,l),O().c);k=
-new Vm("||",new Vm("||",new Vm("||",new Vm("instanceof",d,new Em("String")),new Vm("instanceof",d,new Em("Number"))),new Vm("instanceof",d,new Em("Boolean"))),new Vm("instanceof",d,new Em("BigInt")));l=Gm(cm(),c,"assign");var m=Gm(cm(),d,"valueOf"),n=v();m=J(new L,[new Rm(m,n),d,e]);l=jn(new Rm(l,(je(),le(v(),m))));m=O().c;k=new To(k,new A(l,m),O().c);l=new Em("Array");l=Gm(cm(),l,"isArray");m=J(new L,[d]);l=new Rm(l,(je(),le(v(),m)));t();m=new Em("Array");m=Gm(cm(),m,"from");n=J(new L,[d]);m=new Rm(m,
-(je(),le(v(),n)));m=new hn("clone",m);n=new Yl("key");var r=[Sy(No(new Oo,new Em("clone"),new Em("key")),No(new Oo,d,new Em("key")))];r=J(new L,r);n=new Ty(n,d,(je(),le(v(),r)));r=new Yl("key");var u=[Sy(No(new Oo,new Em("clone"),new Em("key")),No(new Oo,e,new Em("key")))];u=J(new L,u);r=new Ty(r,e,(je(),le(v(),u)));m=[m,n,r,jn(new Em("clone"))];m=J(new L,m);l=new To(l,le(v(),m),O().c);m=new Vm("\x3d\x3d",d,new Wm("null"));n=Gm(cm(),c,"assign");r=[new fo(O().c,O().c),new fo(O().c,O().c),e];r=J(new L,
-r);n=jn(new Rm(n,(je(),le(v(),r))));r=O().c;m=new To(m,new A(n,r),O().c);n=Gm(cm(),c,"assign");e=[new fo(O().c,O().c),d,e];e=J(new L,e);e=new hn("copy",new Rm(n,(je(),le(v(),e))));n=Gm(cm(),c,"setPrototypeOf");r=new Em("copy");c=Gm(cm(),c,"getPrototypeOf");d=J(new L,[d]);d=[r,new Rm(c,(je(),le(v(),d)))];d=J(new L,d);d=new Rm(n,(je(),le(v(),d)));d=[h,k,l,m,e,new lo(d),jn(new Em("copy"))];d=J(new L,d);return new Ky(b,(je(),le(v(),g)),(je(),le(v(),d)))})));Ql(a,new Uy("toString",new z(b=>{var c=J(new L,
-[new Yl("x")]),d=J(new L,[new Em("x")]);d=[jn(new Rm(new Em("String"),(je(),le(v(),d))))];d=J(new L,d);return new Ky(b,(je(),le(v(),c)),(je(),le(v(),d)))})));Ql(a,new Uy("id",new z(b=>{var c=J(new L,[new Yl("x")]),d=[jn(new Em("x"))];d=J(new L,d);return new Ky(b,(je(),le(v(),c)),(je(),le(v(),d)))})));Ql(a,new Uy("emptyArray",new z(b=>{var c=v(),d=[jn(new Mo(O().c))];d=J(new L,d);return new Ky(b,c,(je(),le(v(),d)))})));Ql(a,new Uy("succ",new z(b=>{var c=J(new L,[new Yl("x")]),d=[jn(new Vm("+",new Em("x"),
-new Wm("1")))];d=J(new L,d);return new Ky(b,(je(),le(v(),c)),(je(),le(v(),d)))})));Ql(a,new Uy("error",new z(b=>{var c=v(),d=new Om(new Em("Error")),e=[Pm("an error was thrown")];e=J(new L,e);d=new Rm(d,(je(),le(v(),e)));d=J(new L,[new Qm(d)]);return new Ky(b,c,(je(),le(v(),d)))})));Ql(a,new Uy("length",new z(b=>{var c=J(new L,[new Yl("x")]),d=new Em("x");d=[jn(Gm(cm(),d,"length"))];d=J(new L,d);return new Ky(b,(je(),le(v(),c)),(je(),le(v(),d)))})));Ql(a,new Uy("concat",new z(b=>Jy(Vy(),"+",b))));
-Ql(a,new Uy("join",new z(b=>{var c=J(new L,[new Yl("...xs")]),d=new Em("xs");d=Gm(cm(),d,"join");var e=[new Wm(Bp(Cp(),""))];e=J(new L,e);d=[jn(new Rm(d,(je(),le(v(),e))))];d=J(new L,d);return new Ky(b,(je(),le(v(),c)),(je(),le(v(),d)))})));Ql(a,new Uy("add",new z(b=>Jy(Vy(),"+",b))));Ql(a,new Uy("sub",new z(b=>Jy(Vy(),"-",b))));Ql(a,new Uy("mul",new z(b=>Jy(Vy(),"*",b))));Ql(a,new Uy("div",new z(b=>Jy(Vy(),"/",b))));Ql(a,new Uy("gt",new z(b=>Jy(Vy(),"\x3e",b))));Ql(a,new Uy("not",new z(b=>Ly(Vy(),
-"!",b))));Ql(a,new Uy("negate",new z(b=>Ly(Vy(),"-",b))));Ql(a,new Uy("eq",new z(b=>Jy(Vy(),"\x3d\x3d\x3d",b))));Ql(a,new Uy("ne",new z(b=>Jy(Vy(),"!\x3d\x3d",b))));Ql(a,new Uy("sgt",new z(b=>Jy(Vy(),"\x3e",b))));Ql(a,new Uy("slt",new z(b=>Jy(Vy(),"\x3c",b))));Ql(a,new Uy("sge",new z(b=>Jy(Vy(),"\x3e\x3d",b))));Ql(a,new Uy("sle",new z(b=>Jy(Vy(),"\x3c\x3d",b))));Ql(a,new Uy("eq",new z(b=>Jy(Vy(),"\x3d\x3d\x3d",b))));Ql(a,new Uy("unit",new z(b=>Ly(Vy(),"undefined",b))));Ql(a,new Uy("log",new z(b=>
-{var c=J(new L,[new Yl("x")]),d=J(new L,[new Em("x")]);d=[jn(new Rm(new Em("console.info"),(je(),le(v(),d))))];d=J(new L,d);return new Ky(b,(je(),le(v(),c)),(je(),le(v(),d)))})));Ql(a,new Uy("discard",new z(b=>{var c=J(new L,[new Yl("x")]),d=v();return new Ky(b,(je(),le(v(),c)),d)})));je();this.yN=le(v(),a);this.zN=Wy(Xy(),ht(this.yN,new z(b=>G(new H,b.Sa(),b))))}Ny.prototype=new p;Ny.prototype.constructor=Ny;Ny.prototype.$classData=q({pX:0},!1,"mlscript.Polyfill$",{pX:1,d:1});var Oy;
-function Vy(){Oy||(Oy=new Ny);return Oy}function Yy(){}Yy.prototype=new p;Yy.prototype.constructor=Yy;function Zy(){}Zy.prototype=Yy.prototype;function $y(a){this.Hf=a}$y.prototype=new p;$y.prototype.constructor=$y;function az(a,b){return new $y(mn(a.Hf,b.Hf))}
-function Gp(a,b){var c=b.Hf;if(c instanceof A){var d=c.A;c=c.r;if(a.Hf.b())return b;b=a.Hf.uJ();t();a=a.Hf.Fc();a=J(new L,[new bz(""+a.dq+d.dq,a.ss)]);a=le(v(),a);return new $y(Fl(Fl(c,a),b))}d=O().c;if(null===d?null===c:d.h(c))return a;throw new x(c);}function cz(a){var b=a.Hf;if(b===v())a=v();else{a=b.e();var c=a=new A(dz(a),v());for(b=b.g();b!==v();){var d=b.e();d=new A(dz(d),v());c=c.r=d;b=b.g()}}return new $y(a)}
-function Ep(a,b){if(b)switch(a.Hf.K()){case 0:return Hp(Fp(),"()");case 1:var c=a.Hf;if(c===v())b=v();else for(b=c.e(),a=b=new A(ez(b),v()),c=c.g();c!==v();){var d=c.e();d=new A(ez(d),v());a=a.r=d;c=c.g()}return new $y(b);default:return c=a.Hf.e(),b=a.Hf.g().zb(1),d=a.Hf.Fc(),a=new bz("("+c.dq,c.ss),t(),c=J(new L,[new bz(""+d.dq+")",d.ss)]),b=Fl(le(v(),c),b),new $y(new A(a,b))}else return a}
-function fz(a){switch(a.Hf.K()){case 0:case 1:return a;default:var b=a.Hf.e(),c=a.Hf.g().zb(1);a=a.Hf.Fc();b=new bz("("+b.dq,b.ss);t();a=J(new L,[new bz(""+a.dq+")",a.ss)]);c=Fl(le(v(),a),c);return new $y(new A(b,c))}}function gz(a){if(0===a.Hf.K())return Hp(Fp(),"{}");var b=new bz("{",0),c=a.Hf;if(c===v())a=v();else{a=c.e();var d=a=new A(dz(a),v());for(c=c.g();c!==v();){var e=c.e();e=new A(dz(e),v());d=d.r=e;c=c.g()}}t();d=J(new L,[new bz("}",0)]);a=Fl(le(v(),d),a);return new $y(new A(b,a))}
-$y.prototype.u=function(){return Qe(this.Hf,"","\n","")};$y.prototype.$classData=q({FX:0},!1,"mlscript.SourceCode",{FX:1,d:1});function hz(){this.CN=this.ce=this.BN=this.GH=this.bx=this.Ez=null;iz=this;Hp(Fp()," \x26 ");this.Ez=Hp(Fp()," ");this.bx=Hp(Fp(),";");Hp(Fp(),": ");Hp(Fp()," | ");this.GH=Hp(Fp(),",");this.BN=Hp(Fp(),", ");this.ce=jz(Fp(),O().c);Hp(Fp(),"{");Hp(Fp(),"}");Hp(Fp(),"\x3c");Hp(Fp(),"\x3e");this.CN=Hp(Fp()," \x3d\x3e ");Hp(Fp()," \x3d ")}hz.prototype=new p;
-hz.prototype.constructor=hz;function Hp(a,b){t();a=J(new L,[new bz(b,0)]);return new $y(le(v(),a))}function jz(a,b){if(b===v())a=v();else{a=b.e();var c=a=new A(new bz(a,0),v());for(b=b.g();b!==v();){var d=b.e();d=new A(new bz(d,0),v());c=c.r=d;b=b.g()}}return new $y(a)}function kz(a){for(var b=Fp().ce;!a.b();){var c=a.e();b=az(b,c);a=a.g()}return b}
-function lz(a){var b=O().c;if(null===b?null===a:b.h(a))return Hp(Fp(),"{}");if(a instanceof A){b=a.A;var c=a.r,d=O().c;if(null===d?null===c:d.h(c))return 0<b.Hf.$a(1)?az(az(Hp(Fp(),"{"),cz(b)),Hp(Fp(),"}")):Gp(Gp(Hp(Fp(),"{ "),b),Hp(Fp()," }"))}return az(mg(a).ge(Hp(Fp(),"{"),new Um((e,g)=>{var h=G(new H,e,g);e=h.z;g=h.x;if(null!==g)return h=g.i(),az(e,cz(hf(new E(1+g.Lc()|0),a.K())?h:Gp(h,Fp().GH)));throw new x(h);})),Hp(Fp(),"}"))}
-function mz(a){var b=O().c;if(null===b?null===a:b.h(a))return Hp(Fp(),"[]");if(a instanceof A){b=a.A;var c=a.r,d=O().c;if(null===d?null===c:d.h(c))return 0<b.Hf.$a(1)?az(az(Hp(Fp(),"["),cz(b)),Hp(Fp(),"]")):Gp(Gp(Hp(Fp(),"["),b),Hp(Fp(),"]"))}return az(mg(a).ge(Hp(Fp(),"["),new Um((e,g)=>{var h=G(new H,e,g);e=h.z;g=h.x;if(null!==g)return h=g.i(),az(e,cz(hf(new E(1+g.Lc()|0),a.K())?h:Gp(h,Fp().GH)));throw new x(h);})),Hp(Fp(),"]"))}
-function Caa(a,b,c){return mg(b).ge(a.ce,new Um((d,e)=>{var g=G(new H,d,e);d=g.z;e=g.x;if(null!==e)return g=e.Lc(),Gp(Gp(d,e.i()),hf(new E(g),-1+b.K()|0)?Fp().ce:c);throw new x(g);}))}hz.prototype.$classData=q({GX:0},!1,"mlscript.SourceCode$",{GX:1,d:1});var iz;function Fp(){iz||(iz=new hz);return iz}function bz(a,b){this.dq=a;this.ss=b}bz.prototype=new p;bz.prototype.constructor=bz;function dz(a){return new bz(a.dq,1+a.ss|0)}function ez(a){return new bz("("+a.dq+")",a.ss)}
-bz.prototype.u=function(){return""+Hs(Q(),"  ",this.ss)+this.dq};bz.prototype.$classData=q({HX:0},!1,"mlscript.SourceLine",{HX:1,d:1});function nz(){}nz.prototype=new p;nz.prototype.constructor=nz;function oz(){}oz.prototype=nz.prototype;
-nz.prototype.yb=function(){var a=!1,b=null;if(lf()===this)return"space";if(mr()===this)return"comma";if(nr()===this)return"semicolon";if(Gr()===this)return"newline";if(Ar()===this)return"indentation";if(Hr()===this)return"deindentation";if(Mr()===this)return"error";if(this instanceof rr)return"literal";if(this instanceof Jr)return a=this.Ta,b=pz(Q(),a),b.b()?b=!1:(b=b.o(),b=Eb(b),b=Zq($q(),b)),b?"'"+a+"' keyword":"'"+a+"'";if(this instanceof Kr)return this.Qf?"operator":"identifier";if(this instanceof
-Lr)return"selector";if(this instanceof vr)return"opening "+this.Tw.Sa();if(this instanceof wr)return"closing "+this.fw.Sa();if(this instanceof Qr){a=!0;b=this;var c=b.Tc;if(pl()===c)return"indented block"}if(a)return b.Tc.Sa()+" section";if(this instanceof tr)return"comment";throw new x(this);};
-function qz(a){a=a.Ra.m();a=new eg(a,new z(b=>{if(null!==b){var c=b.i();b=b.j();var d=b.vc.pf?"mut ":"",e=b.vc.ri?"val ":"",g=b.vc.si?"#":"";c=c.b()?"":c.o().w+": ";return d+e+g+c+rz(b.Da,!1)+","}throw new x(b);}));return Qe(a,""," ","")}function sz(){}sz.prototype=new p;sz.prototype.constructor=sz;sz.prototype.$classData=q({UX:0},!1,"mlscript.TypeDefs$VarianceStore$",{UX:1,d:1});function tz(a){a=a.m();a=new eg(a,new z(b=>""+uz(b.j())+b.i()));return Qe(a,"",", ","")}
-function vz(a,b,c,d,e){c=wz(xz(a),c);c=yz(b,c,e);if(a.D){var g=Hs(Q(),"| ",a.q)+"allVarPols: "+tz(c);Af(Bf(),g+"\n")}g=ru().U();return Daa(a,b,e,g,c,d,e)}function Kz(a,b,c,d){var e=new xf;if(a.D){var g=Hs(Q(),"| ",a.q);if(e.qb)e=e.sb;else{if(null===e)throw ze();if(e.qb)e=e.sb;else{var h=wz(xz(a),c);e=Ce(e,yz(b,h,d))}}g=g+"allVarPols: "+tz(e);Af(Bf(),g+"\n")}g=Lz().U();return Eaa(a,b,c,t().f,d,d,g)}
-function Mz(a,b,c,d,e){var g=new xf,h=new xf,k=new Nz;k=Faa(k);var l=Lz().U(),m=Lz().U();Oz(g.qb?g.sb:Gaa(a,g,e,k,l,m),wz(xz(a),d),b);a.D&&(g=Hs(Q(),"| ",a.q)+"[inv] "+Qe(l,"",", ",""),Af(Bf(),g+"\n"));if(a.D){g=Hs(Q(),"| ",a.q);var n=k.m();n=new eg(n,new z(B=>{t();return""+uz(new M(B.i().Xc()))+B.i().j()+" "+B.Lc()}));g=g+"[nums] "+Qe(n,""," ; ","");Af(Bf(),g+"\n")}var r=new Nz;g=Lz().U();n=Lz().U();Pz(a,b,wz(xz(a),d),h,e,g,n,r);for(h=r.kn;null!==h;)g=h.jn,gp(fp(),!g.b()),h=h.gm;a.D&&(h=Hs(Q(),"| ",
-a.q),g=new eg(new Qz(r),new z(B=>{t();return""+uz(new M(B.i().Xc()))+B.i().j()+" "+Qe(B.j(),"{",",","}")})),h=h+"[occs] "+Qe(g,""," ; ",""),Af(Bf(),h+"\n"));var u=ru().U();m=m.m();m=new eg(m,new z(B=>B.i()));h=mu();g=ap().wa;h=new ou(h,g);m=Rz(Mu(),m,h);h=Sz(m,u,e);var w=new ov(h);a.D&&(h=Hs(Q(),"| ",a.q)+"[vars] "+m,Af(Bf(),h+"\n"));a.D&&(h=Hs(Q(),"| ",a.q)+"[rec] "+w.Lb,Af(Bf(),h+"\n"));for(h=k.m();h.s();){var y=h.t();a:{if(null!==y&&(g=y.i(),n=y.Lc(),null!==g)){y=g.Xc();g=g.j();gp(fp(),0<n);hf(new E(n),
-1)&&!k.L(G(new H,!y,g))&&(n=a,n.D&&(n=Hs(Q(),"| ",n.q)+"0[1] "+g,Af(Bf(),n+"\n")),n=R(),g=G(new H,g,n),u.S(g));break a}throw new x(y);}}m.ya(new z(B=>{if(!w.Lb.L(B)){var D=G(new H,r.Y(G(new H,!0,B)),r.Y(G(new H,!1,B)));var C=D.x;if(D.z instanceof M&&R()===C)C=!0;else{C=D.z;var F=D.x;C=R()===C&&F instanceof M?!0:!1}if(C)return a.D&&(D=Hs(Q(),"| ",a.q)+"1[!] "+B,Af(Bf(),D+"\n")),D=R(),B=G(new H,B,D),u.S(B);if(!sr(new E(D),G(new H,R(),R())))throw new rk("assertion failed: "+B+" has no occurrences...");
-}}));m.ya(new z(B=>{if(B.Wb.b()&&!u.L(B)){if(a.D){var D=Hs(Q(),"| ",a.q)+("2[v] "+B+" "+r.Y(G(new H,!0,B))+" ")+r.Y(G(new H,!1,B));Af(Bf(),D+"\n")}D=r.Y(G(new H,!0,B)).m();for(D=new ho(D,new z(T=>T.m()));D.s();){var C=D.t();if(C instanceof Tu||C instanceof uv)if(w.Lb.L(B))F=!1;else{F=r.Y(G(new H,!1,B));var F=F.b()?!1:F.o().L(C)}else F=!1;if(F){F=rv(a);for(var I=Tz(B),K=C;!I.b();){var N=I.e(),P=V(K.p);K=Uz(K,N,P);I=I.g()}I=K;K=ny(B);N=C;for(C=K;!C.b();)K=N,N=C.e(),P=V(K.p),N=zu(K,N,P,!1),C=C.g();F=
-Vz(F,I,N,V(rv(a).pu));C=a;C.D&&(C=Hs(Q(),"| ",C.q)+("  [..] "+B+" :\x3d ")+F,Af(Bf(),C+"\n"));t();F=G(new H,B,new M(F));u.S(F)}else if(C instanceof Ow&&((et(new E(C),B)||u.L(C)||u.L(B)?0:!w.Lb.L(B))?(F=r.Y(G(new H,!1,B)),F=F.b()?!1:F.o().L(C)):F=!1,F)){F=rv(a);I=Tz(B);for(K=C;!I.b();)N=I.e(),P=V(K.p),K=Uz(K,N,P),I=I.g();I=K;K=ny(B);N=C;for(C=K;!C.b();)K=N,N=C.e(),P=V(K.p),N=zu(K,N,P,!1),C=C.g();F=Vz(F,I,N,V(rv(a).pu));C=a;C.D&&(C=Hs(Q(),"| ",C.q)+("  [..] "+B+" :\x3d ")+F,Af(Bf(),C+"\n"));t();F=G(new H,
-B,new M(F));u.S(F)}}}}));m.ya(new z(B=>{if(B.Wb.b()&&!u.L(B)){var D=a.pa;if(a.D){var C=Hs(Q(),"| ",a.q),F=Mt(Nt(),r.Y(G(new H,!0,B)));F=Qe(F,"","","");var I=Mt(Nt(),r.Y(G(new H,!1,B)));C=C+("3[v] "+B+" +"+F+" -")+Qe(I,"","","");Af(Bf(),C+"\n")}a.q=1+a.q|0;try{Wz(a,!0,r,B,u);Wz(a,!1,r,B,u);var K=void 0}finally{a.q=-1+a.q|0}Gw(new E(D),a.pa)&&a.D&&(B=""+Hs(Q(),"| ",a.q)+D.n(K),Af(Bf(),B+"\n"))}}));a.D&&(h=Hs(Q(),"| ",a.q),g=u.Ga(new z(B=>B.i().u()+" -\x3e "+B.j())),h=h+"[sub] "+Qe(g,"",", ",""),Af(Bf(),
-h+"\n"));a.D&&(h=Hs(Q(),"| ",a.q)+"[bounds] "+Yw(b),Af(Bf(),h+"\n"));w.Lb=Sz(m,u,e);a.D&&(m=Hs(Q(),"| ",a.q)+"[rec] "+w.Lb,Af(Bf(),m+"\n"));m=ru().U();h=Wp();return Haa(a,b,wz(xz(a),d),h,e,u,c,m,l,w,k,r)}
-function Xz(a,b,c,d){var e=wz(xz(a),(t(),new M(c))),g=yz(b,e,d);a.D&&(e=Hs(Q(),"| ",a.q)+"allVarPols: "+tz(g),Af(Bf(),e+"\n"));e=Lz().U();g=g.m();var h=new Yz(a);g=new ex(g,h);g=new Gx(g,new z(k=>{if(null!==k){var l=k.i(),m=k.j();if(null!==l)return Zz(l.j(),!1).L(m)}throw new x(k);}),!1);ap();g=bp(cp(),g);a.D&&(h=Hs(Q(),"| ",a.q)+"consed: "+g,Af(Bf(),h+"\n"));return Iaa(a,(t(),new M(c)),b,d,e,g)}
-function Jaa(a,b,c,d){c=wz(xz(a),c);var e=yz(b,c,d);a.D&&(c=Hs(Q(),"| ",a.q)+"allVarPols: "+tz(e),Af(Bf(),c+"\n"));Lz().U();var g=ru().U();e.ya(new z(h=>{if(null!==h){var k=h.i();h=h.j();if(h instanceof M){var l=!!h.k;a.D&&(h=Hs(Q(),"| ",a.q)+"Consider "+k,Af(Bf(),h+"\n"));h=k.Wb;if(h.b())h=R();else{h=h.o();var m=O().c;h=new M(new A(h,m))}h=h.b()?l?ny(k):Tz(k):h.o();if(h instanceof A){var n=h.A;h=h.r;m=O().c;(null===m?null===h:m.h(h))&&e.ya(new z(r=>{if(null!==r){var u=r.i();r=r.j();if(r instanceof
-M&&(r=!!r.k,hf(new E(r),l)&&Gw(new E(u),k)&&!g.L(k)&&!g.L(u))){var w=u.Wb;if(w.b())w=R();else{w=w.o();var y=O().c;w=new M(new A(w,y))}w=w.b()?r?ny(u):Tz(u):w.o();if(w instanceof A&&(r=w.A,w=w.r,y=O().c,null===y?null===w:y.h(w))&&(a.D&&(w=Hs(Q(),"| ",a.q)+("Consider "+k+" ~ ")+u,Af(Bf(),w+"\n")),$z(a,n,r,k,u)))return a.D&&(r=Hs(Q(),"| ",a.q)+("Yes! "+u+" :\x3d ")+k,Af(Bf(),r+"\n")),u=G(new H,u,k),g.S(u)}}}))}}}}));a.D&&(c=Hs(Q(),"| ",a.q)+"[subs] "+g,Af(Bf(),c+"\n"));return g.b()?b:Kaa(a,b,(ap(),bp(cp(),
-g)),d)}function Laa(a,b,c,d){return c.Ai(b,new U(()=>{if(d)return b;var e=V(a);t();var g=new M(b),h=b.dg,k=O().c,l=O().c;e=new Ow(a,b.Va,k,l,g,h,!1,e);a.D&&(g=Hs(Q(),"| ",a.q)+("Renewed "+b+" ~\x3e ")+e,Af(Bf(),g+"\n"));return e}))}function Daa(a,b,c,d,e,g,h){if(b instanceof aA)return bA(a,b,t().f,t().f,d,e,c,g,h);if(b instanceof cA){dA(a);t();var k=new M(b);if(!k.b())return Maa(k.k,new z(l=>bA(a,l,t().f,t().f,d,e,c,g,h)),c)}throw new x(b);}
-function eA(a,b,c,d,e,g,h,k){if(null===b)throw ze();if(b.qb)return b.sb;var l=c.Ua,m=c.Ma;m.b()?m=R():(m=m.o(),m=new M(bA(a,m,t().f,t().f,d,e,g,h,k)));return Ce(b,new ww(l,m,bA(a,c.oa,t().f,t().f,d,e,g,h,k),c.vd))}
-var bA=function fA(a,b,c,d,e,g,h,k,l){var n=id();try{var r=!1,u=null,w=!1,y=null;if(b instanceof Pw){var B=b.Xh;if(null!==B)return fA(a,B,c,t().f,e,g,h,k,l)}if(b instanceof Ow){if(c.b())var D=!0;else{var C=c.o().j();D=hf(new E(C),b)}var F=D?c:R();if(!F.b()){var I=F.o().Xc();throw fq(new gq,n,new gA(a,I,V(a)));}var K=new hA(!1),N=e.Ai(b,new U(()=>{K.ko=!0;return Laa(a,b,e,k)}));if(K.ko){var P=b.Wb;if(P instanceof M){var T=P.k,aa=!1,Y=null,S=iA(g,b);a:if(S.b()||!N.Wb.b()){t();var Z=fA(a,T,t().f,t().f,
-e,g,h,k,l);jA(N,new M(Z))}else{t().f===S&&Dn("Program reached and unexpected state.");if(S instanceof M&&(aa=!0,Y=S,!0===!!Y.k)){t();var ka=G(new H,!0,b),X=fA(a,T,new M(ka),t().f,e,g,h,k,l),sa=O().c,Ia=new A(X,sa);b:for(var Za;;)if(Ia.b()){Za=v();break}else{var Ga=Ia.e(),xa=Ia.g();if(!0===!!Yu(Ga,h))Ia=xa;else for(var Ra=Ia,Ja=xa;;){if(Ja.b())Za=Ra;else{var La=Ja.e();if(!0!==!!Yu(La,h)){Ja=Ja.g();continue}for(var pb=Ja,Fb=new A(Ra.e(),v()),Gb=Ra.g(),Hb=Fb;Gb!==pb;){var tb=new A(Gb.e(),v());Hb=Hb.r=
-tb;Gb=Gb.g()}for(var kb=pb.g(),gb=kb;!kb.b();){var Vb=kb.e();if(!0===!!Yu(Vb,h)){for(;gb!==kb;){var bb=new A(gb.e(),v());Hb=Hb.r=bb;gb=gb.g()}gb=kb.g()}kb=kb.g()}gb.b()||(Hb.r=gb);Za=Fb}break b}}kA(N,Za);break a}if(aa&&!1===!!Y.k){t();var nb=G(new H,!1,b),Tb=fA(a,T,new M(nb),t().f,e,g,h,k,l),ub=O().c,Ub=new A(Tb,ub);b:for(var $a;;)if(Ub.b()){$a=v();break}else{var cb=Ub.e(),Na=Ub.g();if(!0===!!lA(cb,h))Ub=Na;else for(var Ca=Ub,Ba=Na;;){if(Ba.b())$a=Ca;else{var Oa=Ba.e();if(!0!==!!lA(Oa,h)){Ba=Ba.g();
-continue}for(var wa=Ba,ea=new A(Ca.e(),v()),la=Ca.g(),Ka=ea;la!==wa;){var Ua=new A(la.e(),v());Ka=Ka.r=Ua;la=la.g()}for(var ya=wa.g(),ib=ya;!ya.b();){var Lb=ya.e();if(!0===!!lA(Lb,h)){for(;ib!==ya;){var ec=new A(ib.e(),v());Ka=Ka.r=ec;ib=ib.g()}ib=ya.g()}ya=ya.g()}ib.b()||(Ka.r=ib);$a=ea}break b}}mA(N,$a)}else throw new x(S);}}else if(t().f===P){var Mb=iA(g,b);if(Mb.b())var Jb=!0;else{var Kb=!!Mb.o();Jb=hf(new E(Kb),!0)}if(Jb){var eb=ny(b),Wb=Eq(eb).m(),mc=new eg(Wb,new z(Lg=>{t();var Tg=G(new H,
-!0,b);return fA(a,Lg,new M(Tg),t().f,e,g,h,k,l)}));if(mc.s()){if(!mc.s())throw Fu("empty.reduceLeft");for(var ua=!0,Pa=null;mc.s();){var xb=mc.t();if(ua)Pa=xb,ua=!1;else{var Yb=Pa,zb=xb,Sb=V(Yb.p);Pa=zu(Yb,zb,Sb,!1)}}Ma=new M(Pa)}else var Ma=R();if(Ma.b())var Ea=!0;else{var ab=Ma.o();Ea=!Yu(ab,h)}var Db=(Ea?Ma:R()).ea()}else Db=O().c;kA(N,Db);var mb=iA(g,b);if(mb.b())var vb=!0;else{var Ya=!!mb.o();vb=hf(new E(Ya),!1)}if(vb){var Wa=Tz(b),rb=Eq(Wa).m(),pa=new eg(rb,new z(Lg=>{t();var Tg=G(new H,!1,
-b);return fA(a,Lg,new M(Tg),t().f,e,g,h,k,l)}));if(pa.s()){if(!pa.s())throw Fu("empty.reduceLeft");for(var Fa=!0,Ib=null;pa.s();){var qb=pa.t();if(Fa)Ib=qb,Fa=!1;else{var Nb=Ib,fc=qb,Ac=V(Nb.p);Ib=Uz(Nb,fc,Ac)}}tc=new M(Ib)}else var tc=R();if(tc.b())var vc=!0;else{var sc=tc.o();vc=!lA(sc,h)}var uc=(vc?tc:R()).ea()}else uc=O().c;mA(N,uc)}else throw new x(P);}return N}if(b instanceof nA){r=!0;u=b;var lc=u.cc,Wc=u.dc;if(!0===u.nc){var Cc=fA(a,lc,c,d,e,g,h,k,l),Dc=fA(a,Wc,c,d,e,g,h,k,l),Ec=V(Cc.p);return zu(Cc,
-Dc,Ec,!1)}}if(r){var Ic=u.cc,Xc=u.dc;if(!1===u.nc){var Sc=fA(a,Ic,c,d,e,g,h,k,l),oc=fA(a,Xc,c,d,e,g,h,k,l),qc=V(Sc.p);return ju(Sc,oc,qc,!1)}}if(b instanceof oA){var Tc=b.xc;if(c.b())var Nc=R();else{var Pc=c.o();t();Nc=new M(G(new H,!Pc.i(),Pc.j()))}var Oc=fA(a,Tc,Nc,t().f,e,g,h,k,l);return pA(Oc,Tc.qa(),!1)}if(b instanceof qA){w=!0;y=b;var $c=y.yi;if(k)return new qA(a,fA(a,$c,c,d,e,g,h,k,l),$c.qa())}if(w)return fA(a,y.yi,c,d,e,g,h,k,l);if(b instanceof uv&&a.xE.L(b.ob)&&rA(b,h))return fA(a,sA(b,h),
-c,t().f,e,g,h,k,l);if(b instanceof dv){for(var Lc=b.Ba,Zb=Pu(a),ed=Lc,$b=null,Fc=null;ed!==v();){var Yc=ed.e();a:{if(null!==Yc){var nc=Yc.i(),Ob=Yc.j();if(null!==nc){var cc=nc.w,Gc=new xf;b:{for(var Bc=cc.length,qd=0;qd<Bc;){var Gd=cc.charCodeAt(qd);if(!sr(new E(hd(Gd)),hd(35))){var cd=qd;break b}qd=1+qd|0}cd=-1}var rd=-1===cd?cc:cc.substring(0,cd),Id=Sr(Q(),cc,1+rd.length|0);if(""===Id||""===rd){var Ha=Gc.qb?Gc.sb:eA(a,Gc,Ob,e,g,h,k,l),jc=G(new H,nc,Ha),Rb=O().c;var Uc=new A(jc,Rb);break a}else{var Rc=
-h.vb.Y(rd);if(Rc instanceof M){var Cd=Rc.k,od=Cd.iu;if(od.b())var Va=Gc.qb?Gc.sb:eA(a,Gc,Ob,e,g,h,k,l),wb=G(new H,nc,Va),db=O().c,Jc=new A(wb,db);else{var Vc=od.o();b:{for(var Ta=Cd.zm;!Ta.b();){if(Ta.e().i().X===Id){var kd=new M(Ta.e());break b}Ta=Ta.g()}kd=R()}kd.b()&&Dn("Program reached and unexpected state.");var ld=Vc.n(kd.o().j());b:{if(null!==ld){var qe=ld.Vd;if(!0===ld.wd&&!0===qe){Jc=O().c;break b}}if(null!==ld){var Wd=ld.Vd;if(ld.wd){t();var Rd=new ww(a,new M(a.tb),fA(a,Ob.oa,t().f,t().f,
-e,g,h,k,l),Ob.vd),Me=G(new H,nc,Rd),wc=O().c;Jc=new A(Me,wc)}else if(Wd){var Xb=Ob.Ma;if(Xb.b())var gc=R();else{var hc=Xb.o();gc=new M(fA(a,hc,t().f,t().f,e,g,h,k,l))}var gd=new ww(a,gc,a.Na,Ob.vd),kc=G(new H,nc,gd),ud=O().c;Jc=new A(kc,ud)}else{var za=Gc.qb?Gc.sb:eA(a,Gc,Ob,e,g,h,k,l),Qa=G(new H,nc,za),xc=O().c;Jc=new A(Qa,xc)}}else throw new x(ld);}}Uc=Jc;break a}else{if(t().f!==Rc)throw new x(Rc);var yd=h.fb.Y(rd);if(!(yd instanceof M))throw t().f===yd&&Dn("'"+rd+"' not found"),new x(yd);var be=
-!1,yc=null,Od=yd.k.yn;if(Od instanceof M){be=!0;yc=Od;var sd=yc.k;if(sd instanceof Aw){var he=sd;b:{for(var ue=he.Zg;!ue.b();){if(ue.e().ec.X===Id){var sg=new M(ue.e());break b}ue=ue.g()}sg=R()}sg.b()&&Dn("Program reached and unexpected state.");var Se=tA(he,sg.o().gb,h);if(null!==Se){var Kf=Se.Vd;if(!0===Se.wd&&!0===Kf){Uc=O().c;break a}}if(null!==Se){var $e=Se.Vd;if(Se.wd){t();var rf=new ww(a,new M(a.tb),fA(a,Ob.oa,t().f,t().f,e,g,h,k,l),Ob.vd),He=G(new H,nc,rf),Ze=O().c;Uc=new A(He,Ze)}else if($e){var jf=
-Ob.Ma;if(jf.b())var tf=R();else{var Te=jf.o();tf=new M(fA(a,Te,t().f,t().f,e,g,h,k,l))}var hg=new ww(a,tf,a.Na,Ob.vd),eh=G(new H,nc,hg),fh=O().c;Uc=new A(eh,fh)}else{var tg=Gc.qb?Gc.sb:eA(a,Gc,Ob,e,g,h,k,l),Jg=G(new H,nc,tg),Gh=O().c;Uc=new A(Jg,Gh)}break a}throw new x(Se);}}if(be){var zg=yc.k;if(zg instanceof yw){var ig=zg.nk.m();b:{for(;ig.s();){var qh=ig.t();if(qh.ec.X===Id){var gh=new M(qh);break b}}gh=R()}var Wg=gh.b()?R():gh.o().xd,Uf=Wg.b()?Tt().En:Wg.o();if(null!==Uf){var rh=Uf.Vd;if(!0===
-Uf.wd&&!0===rh){Uc=O().c;break a}}if(null!==Uf){var Rh=Uf.Vd;if(Uf.wd){t();var Sg=new ww(a,new M(a.tb),fA(a,Ob.oa,t().f,t().f,e,g,h,k,l),Ob.vd),Hh=G(new H,nc,Sg),Xg=O().c;Uc=new A(Hh,Xg)}else if(Rh){var jg=Ob.Ma;if(jg.b())var Ag=R();else{var Cf=jg.o();Ag=new M(fA(a,Cf,t().f,t().f,e,g,h,k,l))}var Bg=new ww(a,Ag,a.Na,Ob.vd),Lf=G(new H,nc,Bg),Df=O().c;Uc=new A(Lf,Df)}else{var kg=Gc.qb?Gc.sb:eA(a,Gc,Ob,e,g,h,k,l),df=G(new H,nc,kg),Kg=O().c;Uc=new A(df,Kg)}break a}throw new x(Uf);}}be&&$n();t().f===Od&&
-$n();throw new x(Od);}}}}throw new x(Yc);}for(var Mf=Uc.m();Mf.s();){var Vf=new A(Mf.t(),v());null===Fc?$b=Vf:Fc.r=Vf;Fc=Vf}ed=ed.g()}return uA(Zb,null===$b?v():$b,b.qa())}if(b instanceof px){var Cg=b.Ld,Ef=fA(a,b.ve,c,(t(),new M(Cg)),e,g,h,k,l);if(d instanceof M){var Wf=d.k|0;if(a.oq){var de=new Uv(l.V,l.Vc,l.Xa,l.kd,1+Wf|0,l.Ac,l.vb,l.fb,l.ud,l.hb),Ee=new px(a,Cg,Ef);return vA(Ee,de)}}return Zw($w(a),Cg,Ef)}if(b instanceof yu){var Sh=b.Xb;return new yu(a,fA(a,b.Mb,t().f,t().f,e,g,h,k,l),fA(a,Sh,
-t().f,d,e,g,h,k,l),b.Bj)}var hi=t().f;return wA(b,hi,!0,new Um((Lg,Tg)=>fA(a,Tg,t().f,t().f,e,g,h,k,l)),h)}catch(Lg){if(Lg instanceof gq){var vi=Lg;if(vi.Hg===n)return vi.wj();throw vi;}throw Lg;}};
-function Naa(a,b,c,d,e,g,h,k){if(null===b)throw ze();if(b.qb)return b.sb;Du();var l=w=>{w=w.i().w;a:{for(var y=w.length,B=0;B<y;){var D=w.charCodeAt(B);if(!sr(new E(hd(D)),hd(35))){y=B;break a}B=1+B|0}y=-1}return d.L(-1===y?w:w.substring(0,y))},m=c.Ba;a:for(;;)if(m.b()){l=v();break}else{var n=m.e();c=m.g();if(!0===!!l(n))m=c;else for(;;){if(c.b())l=m;else{n=c.e();if(!0!==!!l(n)){c=c.g();continue}n=c;c=new A(m.e(),v());var r=m.g();for(m=c;r!==n;){var u=new A(r.e(),v());m=m.r=u;r=r.g()}for(r=n=n.g();!n.b();){u=
-n.e();if(!0===!!l(u)){for(;r!==n;)u=new A(r.e(),v()),m=m.r=u,r=r.g();r=n.g()}n=n.g()}r.b()||(m.r=r);l=c}break a}}return Ce(b,Mx(0,l,new z(w=>{var y=w.Ua,B=w.Ma;if(B.b())B=R();else{B=B.o();if(e.b())var D=R();else D=!!e.o(),D=new M(!D);B=new M(xA(a,B,D,t().f,g,h,k))}return new ww(y,B,xA(a,w.oa,e,t().f,g,h,k),w.vd)})))}function yA(a,b,c,d,e,g,h,k){return b.qb?b.sb:Naa(a,b,c,d,e,g,h,k)}
-function zA(a,b,c,d,e,g,h){mx(a,new U(()=>"DNF: "+b));var k=ft(b.ae,new z(r=>{if(null!==r){var u=r.ag,w=r.$f,y=r.Sf;if(Dv(r.Zf)&&u.b()&&(!Tv(w)||!y.b()))return t(),new te(r)}t();return new me(r)}));if(null!==k)k=G(new H,k.i(),k.j());else throw new x(k);var l=k.i();k=k.j();if(l.b())l=a.tb;else{l=AA(l,a.Na,new Um((r,u)=>{u=u.nf(!1);var w=V(u.p);u=pA(u,w,!1);w=V(r.p);return ju(r,u,w,!1)}));var m=new z(r=>!r);l=xA(a,l,c.b()?R():new M(m.n(c.o())),t().f,e,g,h);m=V(l.p);l=pA(l,m,!1)}m=mu();var n=ap().wa;
-k=ht(Fv(k,new ou(m,n)),new z(r=>{r.ag.ya(new z(u=>{BA(a,u,h,e,g)}));r.Sf.ya(new z(u=>{BA(a,u,h,e,g)}));return Oaa(r,new z(u=>{if(u instanceof eu){var w=u.lc,y=u.Jd,B=u.be,D=u.rf,C=new z(za=>{if(null!==za){var Qa=za.i(),xc=za.j();if(null!==xc)return za=new uv(a,xc.ob,qv(xc,c,new Um((yd,be)=>xA(a,be,yd,t().f,e,g,h)),e),xc.Ml),G(new H,Qa,za)}throw new x(za);}),F=mu(),I=ap().wa,K=D.OQ(C,new ou(F,I)),N=y.m(),P=new ex(N,new CA(a)),T=Zp($p(),P),aa=!1,Y=null;if(w instanceof M){aa=!0;Y=w;var S=Y.k;if(S instanceof
-gu){var Z=S.ed,ka=S.kE;if(Z instanceof Wl){var X=Z.w;if(!a.Em.L(X)&&e.vb.L(hu(Q(),X))&&!a.Qc){var sa=hu(Q(),X),Ia=new sp(sa),Za=e.vb.n(sa),Ga=B.Ba;ap();var xa=bp(cp(),Ga),Ra=Mx(Du(),B.Ba,new z(za=>DA(za,new z(Qa=>{var xc=new z(yd=>!yd);return xA(a,Qa,c.b()?R():new M(xc.n(c.o())),t().f,e,g,h)}),new z(Qa=>xA(a,Qa,c,t().f,e,g,h))))),Ja=new dv(B.p,Ra,B.Cj);mx(a,new U(()=>"rcd2 "+Ja));var La=EA(Za),pb=Za.Kl,Fb=ht(mg(Za.zm),new z(za=>{if(null!==za){var Qa=za.i(),xc=za.Lc();if(null!==Qa){var yd=Qa.j(),be=
-new Wl(Ia.X+"#"+Qa.i().X);za=K.Y(Ia);Qa=new z(yc=>{yc=FA(yc.Vb,xc);return(new z(Od=>{t();return new ww(a,new M(Od),Od,V(a))})).n(yc)});za=za.b()?R():new M(Qa.n(za.o()));za=Mt(Nt(),za);Qa=Ja.Ba.m();Qa=new Gx(Qa,new z(yc=>hf(new E(yc.i()),be)),!1);Qa=new eg(Qa,new z(yc=>yc.j()));za=za.hl(Qa).ge(G(new H,a.tb,a.Na),new Um((yc,Od)=>{var sd=G(new H,yc,Od);yc=sd.z;var he=sd.x;if(null!==yc&&(Od=yc.i(),yc=yc.j(),null!==he)){sd=he.Ma;he=he.oa;var ue=new U(()=>a.tb);sd=sd.b()?Zr(ue):sd.o();ue=V(Od.p);Od=zu(Od,
-sd,ue,!1);sd=V(yc.p);return G(new H,Od,ju(yc,he,sd,!1))}throw new x(sd);}));return(new z(yc=>{if(null!==yc){var Od=yc.i();yc=yc.j();var sd=La.n(yd);if(null!==sd){var he=sd.Vd;if(!0===sd.wd&&!0===he)return sv(rv(a),a.tb,a.Na,tv(rv(a)),e)}if(null!==sd&&(he=sd.Vd,!1===sd.wd&&!1===he))return sv(rv(a),Od,yc,tv(rv(a)),e);if(null!==sd)return sd.wd?yc:Od;throw new x(sd);}throw new x(yc);})).n(za)}}throw new x(za);})),Gb=new uv(a,pb,Fb,V(a));mx(a,new U(()=>"typeRef "+Gb));var Hb=GA(a,HA(Gb,!0,!1,e),!0,e);
-mx(a,new U(()=>"clsFields "+Qe(Hb,"",", ","")));ka.Ga(new z(za=>hu(Q(),za.X))).Yb(sa).af(T);var tb=new dv(a,Ex(Ja.Ba,new z(za=>{if(null!==za){var Qa=za.i(),xc=za.j();za=Hb.Y(Qa);var yd=new z(be=>{var yc=ru().U();if(Sv(be,xc,e,yc))return!0;yc=xa.Y(Qa);var Od=new z(sd=>{var he=ru().U();return Sv(be,sd,e,he)});return!yc.b()&&!!Od.n(yc.o())});return!za.b()&&!!yd.n(za.o())}throw new x(za);}),!0),Ja.Cj),kb=Ja.Ba,gb=ap(),Vb=kb.Gb(gb.wa).i(),bb=Zp($p(),Vb),nb=Hb.oj(),Tb=new Gx(nb,new z(za=>IA(Ne(),za.w)?
-!0:bb.L(za)),!0),ub=mu(),Ub=ap().wa,$a=new ou(ub,Ub),cb=Rz(Mu(),Tb,$a),Na=cb.b()?Gb:JA(Gb,cb);if(Ja.Ba.il(new z(za=>{if(null!==za){var Qa=za.i(),xc=za.j();za=Hb.Y(Qa);var yd=new z(be=>{var yc=ru().U();if(Sv(xc,be,e,yc))return!0;yc=xa.Y(Qa);var Od=new z(sd=>{var he=ru().U();return Sv(sd,be,e,he)});return!yc.b()&&!!Od.n(yc.o())});return za.b()||!!yd.n(za.o())}throw new x(za);}))){var Ca=fu(tb),Ba=V(Gb.p);Oa=ju(Gb,Ca,Ba,!1)}else if(tb.Ba.b())var Oa=Na;else{var wa=fu(tb);Oa=new ry(a,Na,wa,V(a))}Cr();
-Cr();var ea=new KA(ma(lu)),la=LA(y,ea),Ka=mu(),Ua=ap().wa,ya=nu(la,new ou(Ka,Ua)),ib=MA(ya,Oa,new Um((za,Qa)=>{var xc=V(za.p);return ju(za,Qa,xc,!1)})),Lb=K.rj(Za.Kl),ec=new iu(Lb);return NA(ec,ib,new Um((za,Qa)=>{var xc=V(za.p);return ju(za,Qa,xc,!1)}))}}}}if(aa){var Mb=Y.k;if(Mb instanceof gu){var Jb=Mb.ed,Kb=Mb.kE;if(Jb instanceof Wl){var eb=Jb.w;if(!a.Em.L(eb)&&e.fb.L(eb)&&!e.fb.n(eb).yn.b()){var Wb=new sp(eb),mc=e.fb.n(eb).yn;a:{if(mc instanceof M){var ua=mc.k;if(ua instanceof Aw){var Pa=ua;
-break a}}Dn("Program reached and unexpected state.")}var xb=B.Ba;ap();var Yb=bp(cp(),xb),zb=Mx(Du(),B.Ba,new z(za=>DA(za,new z(Qa=>{var xc=new z(yd=>!yd);return xA(a,Qa,c.b()?R():new M(xc.n(c.o())),t().f,e,g,h)}),new z(Qa=>xA(a,Qa,c,t().f,e,g,h))))),Sb=new dv(B.p,zb,B.Cj);mx(a,new U(()=>"rcd2 "+Sb));var Ma=Pa.Gf.eb,Ea=ht(mg(Pa.Zg),new z(za=>{if(null!==za){var Qa=za.i(),xc=za.Lc();if(null!==Qa){var yd=Qa.gb,be=new Wl(Wb.X+"#"+Qa.ec.X);za=K.Y(Wb);Qa=new z(yc=>{yc=FA(yc.Vb,xc);return(new z(Od=>{t();
-return new ww(a,new M(Od),Od,V(a))})).n(yc)});za=za.b()?R():new M(Qa.n(za.o()));za=Mt(Nt(),za);Qa=Sb.Ba.m();Qa=new Gx(Qa,new z(yc=>hf(new E(yc.i()),be)),!1);Qa=new eg(Qa,new z(yc=>yc.j()));za=za.hl(Qa).ge(G(new H,a.tb,a.Na),new Um((yc,Od)=>{var sd=G(new H,yc,Od);yc=sd.z;var he=sd.x;if(null!==yc&&(Od=yc.i(),yc=yc.j(),null!==he)){sd=he.Ma;he=he.oa;var ue=new U(()=>a.tb);sd=sd.b()?Zr(ue):sd.o();ue=V(Od.p);Od=zu(Od,sd,ue,!1);sd=V(yc.p);return G(new H,Od,ju(yc,he,sd,!1))}throw new x(sd);}));return(new z(yc=>
-{if(null!==yc){var Od=yc.i();yc=yc.j();var sd=tA(Pa,yd,e);if(null!==sd){var he=sd.Vd;if(!0===sd.wd&&!0===he)return sv(rv(a),a.tb,a.Na,tv(rv(a)),e)}if(null!==sd&&(he=sd.Vd,!1===sd.wd&&!1===he))return sv(rv(a),Od,yc,tv(rv(a)),e);if(null!==sd)return sd.wd?yc:Od;throw new x(sd);}throw new x(yc);})).n(za)}}throw new x(za);})),ab=new uv(a,Ma,Ea,V(a));mx(a,new U(()=>"typeRef "+ab));var Db=GA(a,HA(ab,!0,!1,e),!0,e);mx(a,new U(()=>"clsFields "+Qe(Db,"",", ","")));Kb.Ga(new z(za=>hu(Q(),za.X))).Yb(eb).af(T);
-var mb=new dv(a,Ex(Sb.Ba,new z(za=>{if(null!==za){var Qa=za.i(),xc=za.j();za=Db.Y(Qa);var yd=new z(be=>{var yc=ru().U();if(Sv(be,xc,e,yc))return!0;yc=Yb.Y(Qa);var Od=new z(sd=>{var he=ru().U();return Sv(be,sd,e,he)});return!yc.b()&&!!Od.n(yc.o())});return!za.b()&&!!yd.n(za.o())}throw new x(za);}),!0),Sb.Cj),vb=Sb.Ba,Ya=ap(),Wa=vb.Gb(Ya.wa).i();Zp($p(),Wa);Cr();Cr();var rb=new KA(ma(lu)),pa=LA(y,rb),Fa=mu(),Ib=ap().wa,qb=nu(pa,new ou(Fa,Ib)),Nb=V(ab.p),fc=MA(qb,ju(ab,mb,Nb,!1),new Um((za,Qa)=>{var xc=
-V(za.p);return ju(za,Qa,xc,!1)})),Ac=K.rj(Pa.Gf.eb),tc=new iu(Ac);return NA(tc,fc,new Um((za,Qa)=>{var xc=V(za.p);return ju(za,Qa,xc,!1)}))}}}}var vc=new xf,sc=!1,uc=null;a:{if(w instanceof M){sc=!0;uc=w;var lc=uc.k;if(lc instanceof Ru){var Wc=lc.Ub,Cc=Wc.K(),Dc=Ex(B.Ba,new z(za=>{Q();return T.L(Paa(za.i().w,new z(Qa=>sr(new E(hd(Eb(Qa))),hd(35)))))}),!0),Ec=ft(Dc,new z(za=>{var Qa=OA(za.i()),xc=new PA(0,Cc,1),yd=new z(be=>QA(xc,be|0));Qa=Qa.b()||yd.n(Qa.o())?Qa:R();yd=new z(be=>G(new H,be|0,za.j()));
-Qa=Qa.b()?R():new M(yd.n(Qa.o()));yd=new U(()=>za);if(Qa.b())return O(),Qa=Zr(yd),new me(Qa);O();Qa=Qa.o();return new te(Qa)}));if(null!==Ec)var Ic=G(new H,Ec.i(),Ec.j());else throw new x(Ec);var Xc=Ic.i(),Sc=Ic.j();ap();var oc=bp(cp(),Xc),qc=Wc.m(),Tc=new ko(qc),Nc=new eg(Tc,new z(za=>{if(null!==za){var Qa=za.i(),xc=za.Lc();if(null!==Qa)return za=Qa.i(),Qa=Qa.j(),xc=oc.yd(xc,new U(()=>{var yd=a.Na,be=V(a);return new ww(yd.p,R(),yd,be)})),xc=DA(av(Qa,xc,V(Qa.Ua)),new z(yd=>{var be=new z(yc=>!yc);
-return xA(a,yd,c.b()?R():new M(be.n(c.o())),t().f,e,g,h)}),new z(yd=>xA(a,yd,c,t().f,e,g,h))),G(new H,za,xc)}throw new x(za);}));je();var Pc=le(v(),Nc);t();var Oc=new Ru(a,Pc,lc.gq),$c=new M(Oc),Lc=Mx(Du(),Sc,new z(za=>DA(za,new z(Qa=>{var xc=new z(yd=>!yd);return xA(a,Qa,c.b()?R():new M(xc.n(c.o())),t().f,e,g,h)}),new z(Qa=>xA(a,Qa,c,t().f,e,g,h)))));var Zb=G(new H,$c,Lc);break a}}if(sc){var ed=uc.k;if(ed instanceof gu){t();var $b=new M(ed),Fc=yA(a,vc,B,T,c,e,g,h);Zb=G(new H,$b,Fc);break a}}if(sc){var Yc=
-uc.k;if(Yc instanceof yu){var nc=Yc.Mb,Ob=Yc.Xb;t();var cc=new z(za=>!za),Gc=xA(a,nc,c.b()?R():new M(cc.n(c.o())),t().f,e,g,h),Bc=new U(()=>Rx(Nt(),RA(b),new U(()=>b.db))),qd=new yu(a,Gc,xA(a,Ob,c,d.b()?Zr(Bc):d,e,g,h),Yc.Bj),Gd=new M(qd),cd=yA(a,vc,B,T,c,e,g,h);Zb=G(new H,Gd,cd);break a}}if(sc){var rd=uc.k;if(rd instanceof Xu){t();var Id=SA(rd,c,new Um((za,Qa)=>xA(a,Qa,za,t().f,e,g,h))),Ha=new M(Id),jc=yA(a,vc,B,T,c,e,g,h);Zb=G(new H,Ha,jc);break a}}if(sc){var Rb=uc.k;if(Rb instanceof fv){var Uc=
-Rb.ld;t();var Rc=new fv(a,DA(Uc,new z(za=>{var Qa=new z(xc=>!xc);return xA(a,za,c.b()?R():new M(Qa.n(c.o())),t().f,e,g,h)}),new z(za=>xA(a,za,c,t().f,e,g,h))),Rb.ix),Cd=new M(Rc),od=yA(a,vc,B,T,c,e,g,h);Zb=G(new H,Cd,od);break a}}if(sc){var Va=uc.k;if(Va instanceof jv){t();var wb=TA(Va,new z(za=>xA(a,za,c,t().f,e,g,h)),new z(za=>{var Qa=new z(xc=>!xc);return xA(a,za,c.b()?R():new M(Qa.n(c.o())),t().f,e,g,h)}),new z(za=>xA(a,za,c,t().f,e,g,h)),Va.ou),db=new M(wb),Jc=yA(a,vc,B,T,c,e,g,h);Zb=G(new H,
-db,Jc);break a}}if(sc){var Vc=uc.k;if(Vc instanceof gv){var Ta=Vc.Bc,kd=Vc.Ye;if(Ta instanceof nA&&null!==kd&&kd.b()){t();var ld=new gv(a,UA(Ta,new z(za=>xA(a,za,c,t().f,e,g,h))),kd,Vc.Lo),qe=new M(ld),Wd=yA(a,vc,B,T,c,e,g,h);Zb=G(new H,qe,Wd);break a}}}if(sc){var Rd=uc.k;if(Rd instanceof gv){var Me=Rd.Bc,wc=Rd.Ye;t();var Xb=new gv(a,xA(a,Me,c,t().f,e,g,h),wc,Rd.Lo),gc=new M(Xb),hc=yA(a,vc,B,T,c,e,g,h);Zb=G(new H,gc,hc);break a}}if(t().f===w){var gd=t().f,kc=yA(a,vc,B,T,c,e,g,h);Zb=G(new H,gd,kc)}else throw new x(w);
-}if(null!==Zb)var ud=G(new H,Zb.i(),Zb.j());else throw new x(Zb);return(new eu(a,ud.i(),y,fu(new dv(B.p,ud.j(),B.Cj)),K)).nf(!0)}if(pu(a)===u)return a.Na;throw new x(u);}),new z(u=>{if(Av(a)===u)return a.tb;if(u instanceof xv){var w=u.pe,y=DA(u.qe,new z(F=>{var I=new z(K=>!K);return xA(a,F,c.b()?R():new M(I.n(c.o())),t().f,e,g,h)}),new z(F=>xA(a,F,c,t().f,e,g,h)));w=G(new H,w,y);y=O().c;return new dv(a,new A(w,y),V(a))}if(u instanceof yv){w=u.bc;y=u.lb;u=u.Ic;var B=!1,D=null;a:{if(y instanceof M){B=
-!0;D=y;var C=D.k;if(C instanceof me&&(C=C.ia,null!==C)){y=(new xv(a,C.pe,DA(C.qe,new z(F=>{var I=new z(K=>!K);return xA(a,F,c.b()?R():new M(I.n(c.o())),t().f,e,g,h)}),new z(F=>xA(a,F,c,t().f,e,g,h))))).nf(!0);break a}}if(B&&(B=D.k,B instanceof te)){y=xA(a,B.ca,c,t().f,e,g,h);break a}if(t().f===y)y=a.tb;else throw new x(y);}u=new iu(u);u=new eg(u,new z(F=>xA(a,F,c,t().f,e,g,h)));u=NA(u,a.tb,new Um((F,I)=>{var K=V(F.p);return zu(F,I,K,!1)}));B=mu();D=ap().wa;w=Fv(w,new ou(B,D)).ge(y,new Um((F,I)=>{var K=
-V(F.p);return zu(F,I,K,!1)}));y=V(u.p);return zu(u,w,y,!1)}throw new x(u);}))}));k=AA(k,a.tb,new Um((r,u)=>{var w=V(r.p);return zu(r,u,w,!1)}));k=(new z(r=>{a:{var u=VA(r,!0);r=O().c;for(u=Eq(u).m();u.s();){var w=u.t();b:{for(var y=r;!y.b();){var B=y.e(),D=ru().U();if(tu(w,B,e,!0,D)){y=!0;break b}y=y.g()}y=!1}y||(r=new A(w,r))}u=O().c;if(null===u?null===r:u.h(r))r=a.tb;else{if(r instanceof A&&(u=r.A,w=r.r,y=O().c,null===y?null===w:y.h(w))){r=u;break a}if(r===v())r=v();else{u=r.e();w=u=new A(VA(u,
-!1),v());for(r=r.g();r!==v();)y=r.e(),y=new A(VA(y,!1),v()),w=w.r=y,r=r.g();r=u}r=WA(a,r)}}return r})).n(k);m=V(k.p);k=zu(k,l,m,!1);l=ht(b.Ff,new z(r=>{if(null!==r){var u=r.j();return G(new H,xA(a,r.i(),(t(),new M(!0)),t().f,e,g,h),xA(a,u,(t(),new M(!1)),t().f,e,g,h))}throw new x(r);}));k=Xw(Ww(a),l,k);return d instanceof M&&(l=d.k|0,a.oq)?(l=new Uv(g.V,g.Vc,g.Xa,g.kd,1+l|0,g.Ac,g.vb,g.fb,g.ud,g.hb),k=new px(a,b.db,k),vA(k,l)):Zw($w(a),b.db,k)}
-function Eaa(a,b,c,d,e,g,h){d=a.pa;if(a.D){var k=Hs(Q(),"| ",a.q)+("normLike["+uz(c)+"] ")+b;Af(Bf(),k+"\n")}a.q=1+a.q|0;try{a:if(b instanceof aA)var l=xA(a,b,c,t().f,e,g,h);else{if(b instanceof cA){dA(a);t();var m=new M(b);if(!m.b()){l=XA(m.k,c,new Um((n,r)=>xA(a,r,n,t().f,e,g,h)),e);break a}}throw new x(b);}}finally{a.q=-1+a.q|0}Gw(new E(d),a.pa)&&a.D&&(b=""+Hs(Q(),"| ",a.q)+d.n(l),Af(Bf(),b+"\n"));return l}
-function xA(a,b,c,d,e,g,h){var k=new z(P=>"~\x3e "+P);if(a.D){var l=Hs(Q(),"| ",a.q)+("norm["+uz(c)+"] ")+b;Af(Bf(),l+"\n")}a.q=1+a.q|0;try{if(c instanceof M){var m=!!c.k,n=a.tf,r=O().c;YA(a);var u=Wp(),w=zA(a,ZA(YA(a),n,r,b,m,e,!0,!1,u),c,d,e,g,h)}else if(t().f===c){var y=a.tf,B=O().c;YA(a);var D=Wp(),C=ZA(YA(a),y,B,b,!1,e,!0,!1,D),F=a.tf,I=O().c;YA(a);var K=Wp(),N=ZA(YA(a),F,I,b,!0,e,!0,!1,K);w=sv(rv(a),zA(a,C,(t(),new M(!1)),d,e,g,h),zA(a,N,(t(),new M(!0)),d,e,g,h),tv(rv(a)),e)}else throw new x(c);
-}finally{a.q=-1+a.q|0}Gw(new E(k),a.pa)&&a.D&&(a=""+Hs(Q(),"| ",a.q)+k.n(w),Af(Bf(),a+"\n"));return w}
-function BA(a,b,c,d,e){var g=new $A(c);if(!g.Fm.L(b))if(g.Fm.S(b),g=b.Wb,g instanceof M)g=g.k,t(),a=xA(a,g,t().f,t().f,d,e,c),jA(b,new M(a));else if(t().f===g){var h=ny(b);if(h===v())g=v();else{g=h.e();var k=g=new A(xA(a,g,(t(),new M(!0)),t().f,d,e,c),v());for(h=h.g();h!==v();){var l=h.e();l=new A(xA(a,l,(t(),new M(!0)),t().f,d,e,c),v());k=k.r=l;h=h.g()}}kA(b,g);h=Tz(b);if(h===v())a=v();else{g=h.e();k=g=new A(xA(a,g,(t(),new M(!1)),t().f,d,e,c),v());for(h=h.g();h!==v();)l=h.e(),l=new A(xA(a,l,(t(),
-new M(!1)),t().f,d,e,c),v()),k=k.r=l,h=h.g();a=g}mA(b,a)}else throw new x(g);}function Gaa(a,b,c,d,e,g){if(null===b)throw ze();return b.qb?b.sb:Ce(b,new aB(a,c,d,e,g))}function Pz(a,b,c,d,e,g,h,k){if(d.qb)a=d.sb;else{if(null===d)throw ze();a=d.qb?d.sb:Ce(d,new bB(a,e,g,h,k,d))}Oz(a,c,b.ZS())}
-var Qaa=function cB(a,b,c,d,e,g,h,k,l,m){var r=a.pa;if(a.D){var u=Hs(Q(),"| ",a.q)+("go "+b+"   ("+Qe(c,"",", ",""))+")";Af(Bf(),u+"\n")}a.q=1+a.q|0;try{var w=dB(b);a:if(w instanceof Ow){if(c.eh(w)){var y=w.Wb;if(y instanceof M)cB(a,y.k,c,d,e,g,h,k,l,m);else if(t().f===y){var B=d.zg(w.Va);if(B instanceof M)for(var D=B.k?ny(w):Tz(w);!D.b();){var C=D.e();cB(a,C,c,d,e,g,h,k,l,m);D=D.g()}else if(t().f===B){var F=a.pa;if(a.D){var I=Hs(Q(),"| ",a.q)+"Analyzing invar-occ of "+w;Af(Bf(),I+"\n")}a.q=1+a.q|
-0;try{Pz(a,w,d,g,h,k,l,m);var K=void 0}finally{a.q=-1+a.q|0}if(Gw(new E(F),a.pa)&&a.D){var N=""+Hs(Q(),"| ",a.q)+F.n(K);Af(Bf(),N+"\n")}}else throw new x(B);}else throw new x(y);}}else{if(w instanceof nA){var P=w.cc,T=w.dc;if(hf(new E(w.nc),e)){cB(a,P,c,d,e,g,h,k,l,m);cB(a,T,c,d,e,g,h,k,l,m);break a}}c.S(b)}var aa=void 0}finally{a.q=-1+a.q|0}Gw(new E(r),a.pa)&&a.D&&(a=""+Hs(Q(),"| ",a.q)+r.n(aa),Af(Bf(),a+"\n"))};
-function eB(a,b,c,d,e,g){hf(new E(b),c)?c=d:(Lz(),c=Lz().U().S(e));a.D&&(a=Hs(Q(),"| ",a.q)+("\x3e\x3e\x3e\x3e occs["+fB(b)+e+"] :\x3d "+c+"  \x3c~ ")+g.Y(G(new H,b,e)),Af(Bf(),a+"\n"));a=g.Y(G(new H,b,e));if(a instanceof M)a.k.mJ(c);else if(R()===a)b=G(new H,b,e),e=c.Ob().U(),g.Qh(b,e.oc(c));else throw new x(a);}
-function gB(a,b,c,d,e,g,h,k,l){var m=Lz().U();if(a.D){var n=Hs(Q(),"| ",a.q)+("\x3e\x3e Processing "+b+" at ["+uz((t(),new M(d))))+"]";Af(Bf(),n+"\n")}Qaa(a,b,m,c,d,g,h,k,l,e);a.D&&(b=Hs(Q(),"| ",a.q)+"\x3e\x3e Occurrences "+m,Af(Bf(),b+"\n"));m.ya(new z(r=>{if(r instanceof Ow){var u=c.zg(r.Va);if(u instanceof M)eB(a,!!u.k,d,m,r,e);else if(t().f===u)eB(a,!0,d,m,r,e),eB(a,!1,d,m,r,e);else throw new x(u);}}));m.ya(new z(r=>{r instanceof Ow||Pz(a,r,c,g,h,k,l,e)}))}
-function Sz(a,b,c){a=a.m();a=new Gx(a,new z(d=>{var e;if(e=!b.L(d)){a:{e=d.Wb;if(e.b())e=ny(d);else{e=e.o();var g=O().c;e=new A(e,g)}for(g=d.p.tb;!e.b();){var h=e.e(),k=V(g.p);g=zu(g,h,k,!1);e=e.g()}e=g;g=xz(d.p).Ej;e=yz(e,g,c).Y(d);if(e instanceof M&&(e=e.k,e=t().f===e?!0:e instanceof M&&!0===!!e.k?!0:!1,e)){e=!0;break a}e=!1}if(!e)a:{e=d.Wb;e.b()?e=Tz(d):(e=e.o(),g=O().c,e=new A(e,g));for(g=d.p.Na;!e.b();)h=e.e(),k=V(g.p),g=ju(g,h,k,!1),e=e.g();e=g;g=xz(d.p).nx;d=yz(e,g,c).Y(d);if(d instanceof M&&
-(d=d.k,d=t().f===d?!0:d instanceof M&&!1===!!d.k?!0:!1,d)){e=!0;break a}e=!1}}return e}),!1);return Zp($p(),a)}
-function Wz(a,b,c,d,e){var g=c.Y(G(new H,b,d)).m();for(g=new ho(g,new z(Y=>Y.m()));g.s();){var h=g.t();if(h instanceof Ow&&(et(new E(h),d)?0:h.Wb.b())&&!e.L(h)&&(!d.dg.b()||h.dg.b()||e.L(d))&&hf(new E(d.Va),h.Va)){var k=a.pa,l=a;if(l.D){var m=Hs(Q(),"| ",l.q),n=uz((t(),new M(b))),r=Mt(Nt(),c.Y(G(new H,b,h)));m=m+("[w] "+h+" "+n)+Qe(r,"","","");Af(Bf(),m+"\n")}l.q=1+l.q|0;try{var u=b?Tz(d):ny(d),w=b?Tz(h):ny(h),y=Zp($p(),u);if(sr(new E(y),Zp($p(),w))){if(m=a,m.D){var B=Hs(Q(),"| ",m.q)+(d+" and "+
-h)+" have non-equal other bounds and won't be merged";Af(Bf(),B+"\n")}}else{var D=c.Y(G(new H,b,h));if(D.b()||D.o().L(d)){m=a;if(m.D){var C=Hs(Q(),"| ",m.q)+("  [U] "+h+" :\x3d ")+d;Af(Bf(),C+"\n")}t();var F=G(new H,h,new M(d));e.S(F);kA(d,Fl(ny(d),ny(h)));mA(d,Fl(Tz(d),Tz(h)));var I=O().c;kA(h,new A(d,I));var K=O().c;mA(h,new A(d,K));var N=c.Y(G(new H,!b,h));if(!N.b()){var P=N.o(),T=c.Y(G(new H,!b,d));if(T instanceof M)T.k.mJ(new z(((Y,S)=>Z=>hf(new E(Z),Y)||S.L(Z))(d,P)));else if(t().f===T)c.Qh(G(new H,
-!b,d),P);else throw new x(T);}}}var aa=void 0}finally{l.q=-1+l.q|0}Gw(new E(k),l.pa)&&l.D&&(h=""+Hs(Q(),"| ",l.q)+k.n(aa),Af(Bf(),h+"\n"))}}}function hB(a,b,c,d,e,g,h,k,l,m,n,r,u,w,y,B){var D=d.Wb;if(D instanceof M)D=D.k;else{if(t().f!==D)throw new x(D);D=iB(a,b,b?ny(d):Tz(d))}return jB(a,D,new kB(c,d.Va,b),e,g,h,k,l,m,n,r,u,w,y,B)}
-function Haa(a,b,c,d,e,g,h,k,l,m,n,r){if(b instanceof aA)return jB(a,b,c,d,t().f,d,g,h,e,k,!0,l,m,n,r);if(b instanceof cA){dA(a);t();var u=new M(b);if(!u.b())return Raa(u.k,c,new Um((w,y)=>jB(a,y,w,d,t().f,d,g,h,e,k,!0,l,m,n,r)),e)}throw new x(b);}
-function lB(a,b,c,d,e,g,h,k,l,m,n,r,u){if(null!==b){var w=b.Ma,y=b.oa;if(w instanceof M&&hf(new E(w.k),y))return c=jB(a,y,new mB(c),d,t().f,d,e,g,h,k,l,m,n,r,u),new ww(a,(t(),new M(c)),c,b.vd)}w=b.Ua;y=b.Ma;y.b()?y=R():(y=y.o(),y=new M(jB(a,y,new nB(c),d,t().f,d,e,g,h,k,l,m,n,r,u)));return new ww(w,y,jB(a,b.oa,c,d,t().f,d,e,g,h,k,l,m,n,r,u),b.vd)}
-function oB(a,b,c,d,e,g,h,k,l,m,n,r,u,w,y,B){var D=a.pa;a.D&&(c=Hs(Q(),"| ",a.q)+("Setting [\u00b1] bounds of "+b+"... (failing "+uz(c)+", inlineBounds "+d+", !occursInvariantly "+!e.L(g)+", !recVars.contains(tv) "+!h.Lb.L(g))+")",Af(Bf(),c+"\n"));a.q=1+a.q|0;try{var C=g.Wb;if(C instanceof M){var F=C.k;t();var I=jB(a,F,new mB(k),l,m,l,r,u,w,y,d,e,h,n,B);jA(b,new M(I))}else if(t().f===C){if(n.L(G(new H,!0,g))){var K=ny(g);m=Ra=>{var Ja=new kB(k,g.Va,!0);fp();return jB(a,Ra,Ja,Vp(g),t().f,l,r,u,w,y,
-d,e,h,n,B)};if(K===v())var N=v();else{var P=K.e(),T=new A(m(P),v());P=T;for(var aa=K.g();aa!==v();){var Y=aa.e(),S=new A(m(Y),v());P=P.r=S;aa=aa.g()}N=T}kA(b,N)}if(n.L(G(new H,!1,g))){var Z=Tz(g);K=Ra=>{var Ja=new kB(k,g.Va,!1);fp();return jB(a,Ra,Ja,Vp(g),t().f,l,r,u,w,y,d,e,h,n,B)};if(Z===v())var ka=v();else{var X=Z.e(),sa=new A(K(X),v());X=sa;for(var Ia=Z.g();Ia!==v();){var Za=Ia.e(),Ga=new A(K(Za),v());X=X.r=Ga;Ia=Ia.g()}ka=sa}mA(b,ka)}}else throw new x(C);var xa=b}finally{a.q=-1+a.q|0}Gw(new E(D),
-a.pa)&&a.D&&(b=""+Hs(Q(),"| ",a.q)+D.n(xa),Af(Bf(),b+"\n"));return xa}
-var jB=function pB(a,b,c,d,e,g,h,k,l,m,n,r,u,w,y){var D=new z(cc=>"~\x3e "+cc);if(a.D){var C=Hs(Q(),"| ",a.q)+("transform["+uz(c.cl)+"] "+b+"   ("+Qe(d,"",", ","")+")  "+c+"  ")+e;Af(Bf(),C+"\n")}a.q=1+a.q|0;try{var F=!1,I=null,K=!1,N=null;a:if(b instanceof dv){var P=b.Ba;var T=new dv(a,Mx(Du(),P,new z(cc=>lB(a,cc,c,g,h,k,l,m,n,r,u,w,y))),b.qa())}else if(b instanceof Ru){var aa=b.Ub;T=new Ru(a,Mx(Du(),aa,new z(cc=>lB(a,cc,c,g,h,k,l,m,n,r,u,w,y))),b.qa())}else if(b instanceof fv)T=new fv(a,lB(a,b.ld,
-c,g,h,k,l,m,n,r,u,w,y),b.qa());else if(b instanceof jv){var Y=b.zn,S=cc=>{if(cc instanceof te)return cc=cc.ca,t(),cc=pB(a,cc,c,g,t().f,g,h,k,l,m,n,r,u,w,y),new te(cc);if(cc instanceof me)return cc=cc.ia,t(),cc=lB(a,cc,c,g,h,k,l,m,n,r,u,w,y),new me(cc);throw new x(cc);};if(Y===v())var Z=v();else{for(var ka=Y.e(),X=new A(S(ka),v()),sa=X,Ia=Y.g();Ia!==v();){var Za=Ia.e(),Ga=new A(S(Za),v());sa=sa.r=Ga;Ia=Ia.g()}Z=X}T=new jv(a,Z,b.qa())}else if(b instanceof yu){var xa=b.Xb;T=new yu(a,pB(a,b.Mb,new nB(c),
-g,t().f,g,h,k,l,m,n,r,u,w,y),pB(a,xa,c,g,e,g,h,k,l,m,n,r,u,w,y),b.qa())}else if(b instanceof Xu)T=Saa(b,c,new Um((cc,Gc)=>pB(a,Gc,cc,d,e,g,h,k,l,m,n,r,u,w,y)));else if(b instanceof Pw)T=pB(a,b.Xh,c,d,t().f,g,h,k,l,m,n,r,u,w,y);else if(qB(b)||b instanceof rB||b instanceof gA)T=b;else{if(b instanceof Ow&&(F=!0,I=b,d.L(I))){var Ra=!1,Ja=null,La=c.zg(I.Va);if(La instanceof M&&(Ra=!0,Ja=La,!0===!!Ja.k)){T=a.tb;break a}if(Ra&&!1===!!Ja.k){T=a.Na;break a}if(t().f===La){T=pB(a,I,c,d.tk(I),t().f,g,h,k,l,m,
-n,r,u,w,y);break a}throw new x(La);}if(F){var pb=!1,Fb=null,Gb=h.Y(I);if(Gb instanceof M){pb=!0;Fb=Gb;var Hb=Fb.k;if(Hb instanceof M){var tb=Hb.k;if(a.D){var kb=Hs(Q(),"| ",a.q)+"-\x3e "+tb;Af(Bf(),kb+"\n")}T=pB(a,tb,c,d.Yb(I),e,g,h,k,l,m,n,r,u,w,y);break a}}if(pb){var gb=Fb.k;if(t().f===gb){var Vb=I;if(a.D){var bb=Hs(Q(),"| ",a.q)+"-\x3e bound "+c.zg(Vb.Va);Af(Bf(),bb+"\n")}var nb=c.zg(I.Va);if(!k&&(ny(I).b()&&nb.L(!0)||Tz(I).b()&&nb.L(!1)||ny(I).b()&&Tz(I).b())){var Tb=new Wl("?"),ub=Wp();T=new gu(a,
-Tb,ub,V(a))}else{var Ub=I;nb.b()&&Dn("Should not be replacing an invariant type variable by its bound...");var $a=!!nb.o();T=hB(a,$a,c,Ub,d.Yb(Ub),e,g,h,k,l,m,n,r,u,w,y)}break a}}if(t().f===Gb){var cb=new hA(!0),Na=m.Ai(I,new U((cc=>()=>{cb.ko=!1;var Gc=V(a);t();var Bc=new M(cc),qd=cc.dg,Gd=O().c,cd=O().c;Gc=new Ow(a,cc.Va,Gd,cd,Bc,qd,!1,Gc);a.D&&(Bc=Hs(Q(),"| ",a.q)+("Renewed "+cc+" ~\x3e ")+Gc,Af(Bf(),Bc+"\n"));return Gc})(I))),Ca=c.zg(I.Va);if(Ca instanceof M){var Ba=!!Ca.k;if(n&&!r.L(I)&&!u.Lb.L(I)){var Oa=
-I;if(a.D){var wa=Hs(Q(),"| ",a.q)+("Inlining ["+fB(Ba)+"] bounds of "+Oa+" (~\x3e "+Na)+")";Af(Bf(),wa+"\n")}if(Ba){var ea=hB(a,!0,c,I,d.Yb(I),e,g,h,k,l,m,n,r,u,w,y),la=V(ea.p);T=zu(ea,Na,la,!1)}else{var Ka=hB(a,!1,c,I,d.Yb(I),e,g,h,k,l,m,n,r,u,w,y),Ua=V(Ka.p);T=ju(Ka,Na,Ua,!1)}break a}}if(!cb.ko){if(Ca instanceof M){var ya=!!Ca.k;if(y.Y(G(new H,!ya,I)).b()&&I.Wb.b()){var ib=ya?ny(I):Tz(I);b:{for(var Lb=ib;!Lb.b();){var ec=Lb.e();if(ec instanceof Ow)var Mb=h.Y(ec),Jb=Mb.b()?!0:!Mb.o().b();else Jb=
-!1;if(!Jb){var Kb=!1;break b}Lb=Lb.g()}Kb=!0}if(Kb){var eb=I;if(a.D){var Wb=Hs(Q(),"| ",a.q)+("NEW SUBS "+eb)+" -\x3e N";Af(Bf(),Wb+"\n")}var mc=I,ua=t().f,Pa=G(new H,mc,ua);h.S(Pa);var xb=iB(a,ya,ib);T=pB(a,xb,c,d.Yb(I),e,g,h,k,l,m,n,r,u,w,y)}else T=oB(a,Na,Ca,n,r,I,u,c,g,e,w,h,k,l,m,y);break a}}T=oB(a,Na,Ca,n,r,I,u,c,g,e,w,h,k,l,m,y);break a}T=Na;break a}throw new x(Gb);}if(b instanceof nA){K=!0;N=b;var Yb=N.cc,zb=N.dc;if(!0===N.nc){var Sb=pB(a,Yb,c,d,e,g,h,k,l,m,n,r,u,w,y),Ma=pB(a,zb,c,d,e,g,h,
-k,l,m,n,r,u,w,y),Ea=V(Sb.p);T=zu(Sb,Ma,Ea,!1);break a}}if(K){var ab=N.cc,Db=N.dc;if(!1===N.nc){var mb=pB(a,ab,c,d,e,g,h,k,l,m,n,r,u,w,y),vb=pB(a,Db,c,d,e,g,h,k,l,m,n,r,u,w,y),Ya=V(mb.p);T=ju(mb,vb,Ya,!1);break a}}if(b instanceof oA){var Wa=pB(a,b.xc,new nB(c),g,t().f,g,h,k,l,m,n,r,u,w,y),rb=V(Wa.p);T=pA(Wa,rb,!1)}else{if(b instanceof ry){var pa=b.hq,Fa=b.Ko;if(null!==Fa){var Ib=Fa.Ba,qb=pB(a,pa,c,g,e,g,h,k,l,m,n,r,u,w,y),Nb=Mx(Du(),Ib,new z(cc=>{var Gc=cc.Ua,Bc=cc.Ma;Bc.b()?Bc=R():(Bc=Bc.o(),Bc=new M(pB(a,
-Bc,new nB(c),g,t().f,g,h,k,l,m,n,r,u,w,y)));return new ww(Gc,Bc,pB(a,cc.oa,c,g,t().f,g,h,k,l,m,n,r,u,w,y),cc.vd)})),fc=new dv(a,Nb,V(a));T=new ry(a,qb,fc,V(a));break a}}if(b instanceof sB){tB(a);t();var Ac=b.gc(),tc=new M(Ac);if(!tc.b()){T=pB(a,tc.k,c,d,e,g,h,k,l,m,n,r,u,w,y);break a}}if(b instanceof uv)T=new uv(a,b.ob,uB(b,c,new Um((cc,Gc)=>pB(a,Gc,cc,g,t().f,g,h,k,l,m,n,r,u,w,y)),l),b.Ml);else if(b instanceof gv){var vc=b.Bc,sc=b.Ye;if(sc.b())T=pB(a,vc,c,g,e,g,h,k,l,m,n,r,u,w,y);else if(hf(new E(c.cl),
-(t(),new M(!0)))){var uc=pB(a,vc,c,g,e,g,h,k,l,m,n,r,u,w,y);T=vB(uc,sc)}else{var lc=pB(a,vc,c,g,e,g,h,k,l,m,n,r,u,w,y);T=JA(lc,sc)}}else if(b instanceof wB){var Wc=b.vg,Cc=b.Jf,Dc=c.cl;if(Dc.b()){var Ec=rv(a),Ic=pB(a,Wc,xz(a).ru,d,e,g,h,k,l,m,n,r,u,w,y),Xc=pB(a,Cc,xz(a).Ej,d,e,g,h,k,l,m,n,r,u,w,y);T=Vz(Ec,Ic,Xc,V(a))}else T=Dc.o()?pB(a,Cc,c,d,t().f,g,h,k,l,m,n,r,u,w,y):pB(a,Wc,c,d,t().f,g,h,k,l,m,n,r,u,w,y)}else if(b instanceof px){var Sc=b.Ld,oc=pB(a,b.ve,new xB(c,Sc),d,(t(),new M(Sc)),g,h,k,l,m,
-n,r,u,w,y);if(e instanceof M){var qc=e.k|0;if(a.oq){var Tc=new Uv(l.V,l.Vc,l.Xa,l.kd,1+qc|0,l.Ac,l.vb,l.fb,l.ud,l.hb),Nc=new px(a,Sc,oc);T=vA(Nc,Tc);break a}}T=Zw($w(a),Sc,oc)}else if(b instanceof yB){var Pc=b.Aj,Oc=b.ej,$c=cc=>{if(null!==cc){var Gc=cc.j();return G(new H,pB(a,cc.i(),xz(a).Ej,g,t().f,g,h,k,l,m,n,r,u,w,y),pB(a,Gc,xz(a).nx,g,t().f,g,h,k,l,m,n,r,u,w,y))}throw new x(cc);};if(Pc===v())var Lc=v();else{for(var Zb=Pc.e(),ed=new A($c(Zb),v()),$b=ed,Fc=Pc.g();Fc!==v();){var Yc=Fc.e(),nc=new A($c(Yc),
-v());$b=$b.r=nc;Fc=Fc.g()}Lc=ed}T=new yB(a,Lc,pB(a,Oc,c,d,t().f,g,h,k,l,m,n,r,u,w,y))}else throw new x(b);}}}finally{a.q=-1+a.q|0}if(Gw(new E(D),a.pa)&&a.D){var Ob=""+Hs(Q(),"| ",a.q)+D.n(T);Af(Bf(),Ob+"\n")}return T};function zB(a,b,c,d,e,g,h,k){if(null===b)throw ze();return b.qb?b.sb:Ce(b,wA(c,d,!0,new Um((l,m)=>AB(a,l,m,e,h,g,k)),g))}
-var AB=function BB(a,b,c,d,e,g,h){for(;;){var l=!1,m=null,n=CB(c);if(n instanceof Ow&&(l=!0,m=n,DB(a),n=m.Wb,!n.b()))return b=n.o(),d=new $A(e),c=m,l=a,a=m,d.Fm.L(c)||(d.Fm.S(c),t(),e=BB(l,t().f,b,(t(),new M(a)),e,g,h),jA(a,new M(e))),m;if(l){d=new $A(e);c=m;b=a;a=m;if(!d.Fm.L(c)){d.Fm.S(c);n=ny(a);d=((u,w,y,B,D)=>C=>BB(u,(t(),new M(!0)),C,(t(),new M(w)),y,B,D))(b,a,e,g,h);if(n===v())d=v();else{c=n.e();l=c=new A(d(c),v());for(n=n.g();n!==v();){var r=n.e();r=new A(d(r),v());l=l.r=r;n=n.g()}d=c}kA(a,
-d);d=Tz(a);e=((u,w,y,B,D)=>C=>BB(u,(t(),new M(!1)),C,(t(),new M(w)),y,B,D))(b,a,e,g,h);if(d===v())e=v();else{g=d.e();h=g=new A(e(g),v());for(b=d.g();b!==v();)d=b.e(),d=new A(e(d),v()),h=h.r=d,b=b.g();e=g}mA(a,e)}return m}m=new xf;if(b instanceof M){n=!!b.k;l=h.Y(G(new H,n,c));if(l instanceof M&&(l=l.k,d.b()?r=!0:(r=d.o(),r=Gw(new E(r),l)),r)){m=a;m.D&&(m=Hs(Q(),"| ",m.q)+("!unskid-1! "+c+" -\x3e ")+l,Af(Bf(),m+"\n"));c=l;continue}l=m.qb?m.sb:zB(a,m,c,b,d,g,e,h);l=h.Y(G(new H,n,l));if(l instanceof
-M&&(l=l.k,d.b()?n=!0:(n=d.o(),n=Gw(new E(n),l)),n)){r=n=a;n.D&&(m=Hs(Q(),"| ",n.q)+("!unskid-2! "+(m.qb?m.sb:zB(r,m,c,b,d,g,e,h))+" -\x3e ")+l,Af(Bf(),m+"\n"));c=l;continue}return m.qb?m.sb:zB(a,m,c,b,d,g,e,h)}if(t().f===b)return m.qb?m.sb:zB(a,m,c,b,d,g,e,h);throw new x(b);}};function Iaa(a,b,c,d,e,g){if(c instanceof aA)return AB(a,b,c,t().f,e,d,g);if(c instanceof cA){dA(a);t();var h=new M(c);if(!h.b())return XA(h.k,b,new Um((k,l)=>AB(a,k,l,t().f,e,d,g)),d)}throw new x(c);}
-function EB(a,b,c){a.D&&(a=Hs(Q(),"| ",a.q)+("Nope("+Fg(ja(b))+"): "+b+" ~ ")+c,Af(Bf(),a+"\n"));return!1}function FB(a,b,c,d,e,g,h){if(null!==b){var k=b.Ma,l=b.oa;if(k instanceof M&&(k=k.k,null!==c)){var m=c.Ma,n=c.oa;if(m instanceof M)return $z(a,k,m.k,d,e)&&$z(a,l,n,d,e)}}return null!==b&&(l=b.Ma,b=b.oa,t().f===l&&null!==c&&(l=c.Ma,c=c.oa,t().f===l))?$z(a,b,c,d,e):EB(a,g,h)}
-var $z=function GB(a,b,c,d,e){for(;;){var h=b,k=c;if((null===d?null===h:HB(d,h))&&(null===e?null===k:HB(e,k))||(null===e?null===h:HB(e,h))&&(null===d?null===k:HB(d,k)))return!0;if(h instanceof Ow){var l=h;if(k instanceof Ow)return et(new E(l),k)||EB(a,b,c)}if(h instanceof oA){var m=h.xc;if(k instanceof oA){var n=k.xc;b=m;c=n;continue}}if(h instanceof gu){var r=h.ed;if(k instanceof gu)return hf(new E(r),k.ed)||EB(a,b,c)}if(h instanceof fv){var u=h.ld;if(k instanceof fv)return FB(a,u,k.ld,d,e,b,c)}if(h instanceof
-Ru){var w=h.Ub;if(k instanceof Ru){var y=k.Ub,B=w.K();if(hf(new E(B),y.K())||EB(a,b,c)){if(w===v())var D=v();else{for(var C=w.e(),F=new A(C.j(),v()),I=F,K=w.g();K!==v();){var N=K.e(),P=new A(N.j(),v());I=I.r=P;K=K.g()}D=F}if(y===v())var T=v();else{for(var aa=y.e(),Y=new A(aa.j(),v()),S=Y,Z=y.g();Z!==v();){var ka=Z.e(),X=new A(ka.j(),v());S=S.r=X;Z=Z.g()}T=Y}for(var sa=new vq(D,D,T),Ia=a,Za=b,Ga=c,xa=sa.Sj.m(),Ra=sa.Tj.m(),Ja=!1;!Ja&&xa.s()&&Ra.s();){var La=xa.t(),pb=Ra.t();Ja=!FB(Ia,La,pb,d,e,Za,
-Ga)}return!Ja}return!1}}if(h instanceof yu){var Fb=h,Gb=Fb.Mb,Hb=Fb.Xb;if(k instanceof yu){var tb=k,kb=tb.Xb;if(GB(a,Gb,tb.Mb,d,e)){b=Hb;c=kb;continue}else return!1}}if(h instanceof gv){var gb=h,Vb=gb.Bc,bb=gb.Ye;if(k instanceof gv){var nb=k,Tb=nb.Ye;return GB(a,Vb,nb.Bc,d,e)&&(hf(new E(bb),Tb)||EB(a,b,c))}}if(h instanceof IB){var ub=h.Io;if(k instanceof IB)return hf(new E(ub),k.Io)||EB(a,b,c)}if(h instanceof Pw){var Ub=h.Xh;if(k instanceof Pw)return hf(new E(Ub),k.Xh)||EB(a,b,c)}if(h instanceof gA){var $a=
-h.sh;if(k instanceof gA)return hf(new E($a),k.sh)||EB(a,b,c)}if(h instanceof wB){var cb=h,Na=cb.vg,Ca=cb.Jf;if(k instanceof wB){var Ba=k,Oa=Ba.Jf;if(GB(a,Na,Ba.vg,d,e)){b=Ca;c=Oa;continue}else return!1}}if(h instanceof nA){var wa=h,ea=wa.nc,la=wa.cc,Ka=wa.dc;if(k instanceof nA){var Ua=k,ya=Ua.cc,ib=Ua.dc;if((hf(new E(ea),Ua.nc)||EB(a,b,c))&&GB(a,la,ya,d,e)){b=Ka;c=ib;continue}else return!1}}if(h instanceof dv){var Lb=h.Ba;if(k instanceof dv){var ec=k.Ba,Mb=Lb.K();if(hf(new E(Mb),ec.K())){for(var Jb=
-new vq(Lb,Lb,ec),Kb=a,eb=b,Wb=c,mc=Jb.Sj.m(),ua=Jb.Tj.m(),Pa=!1;!Pa&&mc.s()&&ua.s();){var xb=mc.t(),Yb=ua.t(),zb=xb,Sb=Yb;Pa=!((hf(new E(zb.i()),Sb.i())||EB(Kb,eb,Wb))&&FB(Kb,zb.j(),Sb.j(),d,e,eb,Wb))}return!Pa}return!1}}if(h instanceof ry){var Ma=h,Ea=Ma.hq,ab=Ma.Ko;if(k instanceof ry){var Db=k,mb=Db.Ko;if(GB(a,Ea,Db.hq,d,e)){b=ab;c=mb;continue}else return!1}}if(h instanceof sB){var vb=h;tB(a);t();var Ya=vb.gc(),Wa=new M(Ya);if(!Wa.b()){b=Wa.k;continue}}if(k instanceof sB){var rb=k;tB(a);t();var pa=
-rb.gc(),Fa=new M(pa);if(!Fa.b()){c=Fa.k;continue}}if(h instanceof uv){var Ib=h,qb=Ib.ob,Nb=Ib.Vb;if(k instanceof uv){var fc=k,Ac=fc.Vb;if(hf(new E(qb),fc.ob)||EB(a,b,c)){for(var tc=new vq(Nb,Nb,Ac),vc=a,sc=tc.Sj.m(),uc=tc.Tj.m(),lc=!1;!lc&&sc.s()&&uc.s();){var Wc=sc.t(),Cc=uc.t();lc=!GB(vc,Wc,Cc,d,e)}return!lc}return!1}}return EB(a,b,c)}};function JB(){this.Fo=null}JB.prototype=new p;JB.prototype.constructor=JB;function KB(){}KB.prototype=JB.prototype;
-function Pf(a,b,c,d,e){var g=a.Mi;g.D&&(g=Hs(Q(),"| ",g.q)+"\u2b24 Initial: "+b,Af(Bf(),g+"\n"));g=a.Mi;g.D&&(g=Hs(Q(),"| ",g.q)+" where: "+Yw(b),Af(Bf(),g+"\n"));b=vz(a.Fo,b,c,!1,e);g=a.Mi;g.D&&(g=Hs(Q(),"| ",g.q)+"\u2b24 Cleaned up: "+b,Af(Bf(),g+"\n"));g=a.Mi;g.D&&(g=Hs(Q(),"| ",g.q)+" where: "+Yw(b),Af(Bf(),g+"\n"));c.b()||(g=!!c.o(),b=Xz(a.Fo,b,g,e));g=a.Mi;g.D&&(g=Hs(Q(),"| ",g.q)+"\u2b24 Unskid: "+b,Af(Bf(),g+"\n"));g=a.Mi;g.D&&(g=Hs(Q(),"| ",g.q)+" where: "+Yw(b),Af(Bf(),g+"\n"));b=Mz(a.Fo,
-b,d,c,e);g=a.Mi;g.D&&(g=Hs(Q(),"| ",g.q)+"\u2b24 Type after simplification: "+b,Af(Bf(),g+"\n"));g=a.Mi;g.D&&(g=Hs(Q(),"| ",g.q)+" where: "+Yw(b),Af(Bf(),g+"\n"));b=Kz(a.Fo,b,c,e);g=a.Mi;g.D&&(g=Hs(Q(),"| ",g.q)+"\u2b24 Normalized: "+b,Af(Bf(),g+"\n"));g=a.Mi;g.D&&(g=Hs(Q(),"| ",g.q)+" where: "+Yw(b),Af(Bf(),g+"\n"));b=vz(a.Fo,b,c,!0,e);g=a.Mi;g.D&&(g=Hs(Q(),"| ",g.q)+"\u2b24 Cleaned up: "+b,Af(Bf(),g+"\n"));g=a.Mi;g.D&&(g=Hs(Q(),"| ",g.q)+" where: "+Yw(b),Af(Bf(),g+"\n"));c.b()||(g=!!c.o(),b=Xz(a.Fo,
-b,g,e));g=a.Mi;g.D&&(g=Hs(Q(),"| ",g.q)+"\u2b24 Unskid: "+b,Af(Bf(),g+"\n"));g=a.Mi;g.D&&(g=Hs(Q(),"| ",g.q)+" where: "+Yw(b),Af(Bf(),g+"\n"));b=Mz(a.Fo,b,d,c,e);d=a.Mi;d.D&&(d=Hs(Q(),"| ",d.q)+"\u2b24 Resim: "+b,Af(Bf(),d+"\n"));d=a.Mi;d.D&&(d=Hs(Q(),"| ",d.q)+" where: "+Yw(b),Af(Bf(),d+"\n"));b=Jaa(a.Fo,b,c,e);c=a.Mi;c.D&&(c=Hs(Q(),"| ",c.q)+"\u2b24 Factored: "+b,Af(Bf(),c+"\n"));a=a.Mi;a.D&&(a=Hs(Q(),"| ",a.q)+" where: "+Yw(b),Af(Bf(),a+"\n"));return b}
-function LB(a,b){this.LN=null;this.MN=b;if(null===a)throw null;this.LN=a}LB.prototype=new p;LB.prototype.constructor=LB;function MB(a,b){var c=a.LN;a=a.MN;b=b.m();return new LB(c,a.oe(new eg(b,new z(d=>{if(null!==d)return G(new H,d.gb,d.ec);throw new x(d);}))))}LB.prototype.$classData=q({mY:0},!1,"mlscript.Typer$ExpCtx$1",{mY:1,d:1});function NB(a){this.VH=null;if(null===a)throw null;this.VH=a}NB.prototype=new p;NB.prototype.constructor=NB;
-function OB(a,b,c,d){if(c.Ac&&Taa(b)){c=(new dx(c.Vc)).XE;c=c.b()?t().f:PB(c.o(),b.w);c=xl(new QB(a)).Nb(c,new z(()=>{t();return R()}));var e=new RB(a,b,d);xl(e).Nb(c,new z(()=>{t();return R()}));return SB(TB(a.VH),b,d)}return t().f}NB.prototype.$classData=q({oY:0},!1,"mlscript.Typer$ValidPatVar$",{oY:1,d:1});function UB(a){this.WH=null;if(null===a)throw null;this.WH=a}UB.prototype=new p;UB.prototype.constructor=UB;
-function SB(a,b,c){t();a.WH.dP.L(b.w)&&Xv(a.WH,pf(qf(),"Illegal use of reserved operator: "+b.w),b.C(),c);return new M(b.w)}UB.prototype.$classData=q({rY:0},!1,"mlscript.Typer$ValidVar$",{rY:1,d:1});function VB(){}VB.prototype=new p;VB.prototype.constructor=VB;VB.prototype.$classData=q({tY:0},!1,"mlscript.TyperDatatypes$AssignedVariable$",{tY:1,d:1});function WB(){}WB.prototype=new p;WB.prototype.constructor=WB;WB.prototype.$classData=q({NY:0},!1,"mlscript.TyperDatatypes$OtherTypeLike$",{NY:1,d:1});
-function XB(){}XB.prototype=new p;XB.prototype.constructor=XB;XB.prototype.$classData=q({SY:0},!1,"mlscript.TyperDatatypes$ProxyType$",{SY:1,d:1});function YB(a){this.yO=null;if(null===a)throw null;this.yO=a}YB.prototype=new p;YB.prototype.constructor=YB;function Uaa(a,b,c,d){return a.yO.oq?Vaa(b,b.ve,Wp(),b.Ld,c,d):t().f}YB.prototype.$classData=q({XY:0},!1,"mlscript.TyperDatatypes$SplittablePolyFun$",{XY:1,d:1});function ZB(a,b){if(null===b)throw null;a.J=b}function $B(){this.J=null}
-$B.prototype=new p;$B.prototype.constructor=$B;function aC(){}aC.prototype=$B.prototype;function bC(){}bC.prototype=new p;bC.prototype.constructor=bC;bC.prototype.$classData=q({gZ:0},!1,"mlscript.TyperDatatypes$TypeVariable$",{gZ:1,d:1});
-var Waa=function cC(a,b,c,d,e,g,h,k){for(;;){var m=c.Y(b);if(m instanceof M){if(b=m.k,!d)return b}else{if(t().f===m){var n=!1;m=null;var r=b;if(r instanceof Ow){n=!0;m=r;DB(a);var u=m.Wb;if(!u.b())return b=u.o(),e.yd(m,new U(((w,y,B,D,C,F,I,K,N)=>()=>{var P=y.Zh;t();var T=new M(y),aa=y.dg,Y=O().c,S=O().c;P=new Ow(w,y.Va,Y,S,T,aa,!1,P);T=G(new H,y,P);B.S(T);t();T=cC(w,D,C,F,B,I,K,N);jA(P,new M(T));return P})(a,m,e,b,c,d,g,h,k)))}if(n&&ny(m).b()&&Tz(m).b())return c=G(new H,m,m),e.S(c),m;if(n)return e.yd(m,
-new U(((w,y,B,D,C,F,I,K)=>()=>{var N=y.Zh;t();var P=new M(y),T=y.dg,aa=O().c,Y=O().c;N=new Ow(w,y.Va,aa,Y,P,T,!1,N);P=G(new H,y,N);B.S(P);Y=ny(y);P=(Z=>ka=>cC(Z,ka,D,C,B,F,I,K))(w);if(Y===v())P=v();else{T=Y.e();aa=T=new A(P(T),v());for(Y=Y.g();Y!==v();){var S=Y.e();S=new A(P(S),v());aa=aa.r=S;Y=Y.g()}P=T}kA(N,P);Y=Tz(y);P=(Z=>ka=>cC(Z,ka,D,C,B,F,I,K))(w);if(Y===v())P=v();else{T=Y.e();aa=T=new A(P(T),v());for(Y=Y.g();Y!==v();)S=Y.e(),S=new A(P(S),v()),aa=aa.r=S,Y=Y.g();P=T}mA(N,P);return N})(a,m,e,
-c,d,g,h,k)));if(r instanceof px&&(m=r,m.Ld<g)){b=Wp();b=dC(m,g,b,h,k);continue}return UA(b,new z(((w,y,B,D,C,F,I)=>K=>cC(w,K,y,B,D,C,F,I))(a,c,d,e,g,h,k)))}throw new x(m);}}};function eC(a,b){b=b.m();b=new eg(b,new z(g=>{for(var h=a.Na;!g.b();){var k=g.e(),l=V(h.p);h=ju(h,k,l,!1);g=g.g()}return h}));for(var c=a.tb;b.s();){var d=b.t(),e=V(c.p);c=zu(c,d,e,!1)}return c}function Xaa(a){a.Uo=0;a.Dm=0;a.Wo=0;a.Vo=0;a.pa=new z(()=>"");a.q=0}
-function fC(){this.Cn=this.Bn=this.Dn=null;this.Vo=this.Wo=this.Dm=this.Uo=0;this.pa=null;this.q=0}fC.prototype=new p;fC.prototype.constructor=fC;function gC(){}gC.prototype=fC.prototype;function Yaa(a){null===a.Dn&&null===a.Dn&&(a.Dn=new hC(a));return a.Dn}function Wu(a){null===a.Bn&&null===a.Bn&&(a.Bn=new iC(a));return a.Bn}function xz(a){null===a.Cn&&null===a.Cn&&(a.Cn=new jC(a));return a.Cn}
-function kx(a,b,c,d){mx(a,b);a.q=1+a.q|0;try{var e=Zr(c)}finally{a.q=-1+a.q|0}Gw(new E(d),a.pa)&&a.D&&(a=""+Hs(Q(),"| ",a.q)+d.n(e),Af(Bf(),a+"\n"));return e}function mx(a,b){a.D&&(a=""+Hs(Q(),"| ",a.q)+Zr(b),Af(Bf(),a+"\n"))}function fB(a){if(!0===a)return"+";if(!1===a)return"-";throw new x(a);}function uz(a){if(a instanceof M)return fB(!!a.k);if(t().f===a)return"\x3d";throw new x(a);}
-function lv(a,b){var c=a.Q()+b.Q()|0;b=Zu(Zu($u(8<c?c:8),a),b);a=ru().U();for(b=Sl(b).m();b.s();){var d=b.t();c=d.i();var e=a.Y(c);if(e instanceof M)e=e.k,d=av(e,d.j(),V(e.Ua));else{if(R()!==e)throw new x(e);d=d.j()}a.Vi(c,d)}b=cp();a=(new cv(b)).qc(a);je();return le(v(),a)}
-function kC(a,b){ap();b=bp(cp(),b);for(var c=null,d=null;a!==v();){var e=a.e();if(null===e)throw new x(e);var g=e.i();e=e.j();var h=b.Y(g);h.b()?g=R():(h=h.o(),e=Kv(e,h,V(e.Ua)),g=new M(G(new H,g,e)));for(g=g.m();g.s();)e=new A(g.t(),v()),null===d?c=e:d.r=e,d=e;a=a.g()}return null===c?v():c}
-function Kaa(a,b,c,d){if(b instanceof aA)return lC(a,b,c,!0,d);if(b instanceof cA){dA(a);t();var e=new M(b);if(!e.b()){b=e.k;var g=b.ok;e=m=>uy(m,new z(n=>lC(a,n,c,!0,d)),d);if(g===v())e=v();else{var h=g.e(),k=h=new A(e(h),v());for(g=g.g();g!==v();){var l=g.e();l=new A(e(l),v());k=k.r=l;g=g.g()}e=h}b=b.Jl;b.b()?b=R():(b=b.o(),b=new M(lC(a,b,c,!0,d)));return new Tx(a,e,b)}}throw new x(b);}
-function lC(a,b,c,d,e){var g=ru().U(),h=ru().U(),k=c.Qd();k=new eg(k,new z(r=>r.Ca()));if(k.s()){if(!k.s())throw Fu("empty.reduceLeft");for(var l=!0,m=null;k.s();){var n=k.t();l?(m=n,l=!1):(m|=0,n|=0,m=m>n?m:n)}k=new M(m)}else k=R();k=(k.b()?a.md:k.o())|0;return Waa(a,b,c,d,g,k,e,h)}
-function ev(a,b){fp();var c=a.K();Os(0,hf(new E(c),b.K()));a=new vq(a,a,b);b=new Um((d,e)=>{d=G(new H,d,e);e=d.z;var g=d.x;if(null!==e){var h=e.i();e=e.j();if(h instanceof M&&(h=h.k,null!==g)){var k=g.i();g=g.j();if(k instanceof M&&sr(new E(h),k.k))return d=t().f,G(new H,d,av(e,g,V(e.Ua)))}}g=d.z;h=d.x;if(null!==g&&(e=g.i(),g=g.j(),null!==h))return d=h.i(),h=h.j(),d=e.b()?d:e,G(new H,d,av(g,h,V(g.Ua)));throw new x(d);});xq();return Rv(a,b)}
-function mC(a,b){fp();var c=a.K();Os(0,hf(new E(c),b.K()));a=new vq(a,a,b);b=new Um((d,e)=>{d=G(new H,d,e);e=d.z;var g=d.x;if(null!==e){var h=e.i();e=e.j();if(h instanceof M&&(h=h.k,null!==g)){var k=g.i();g=g.j();if(k instanceof M)return d=hf(new E(h),k.k)?new M(h):R(),G(new H,d,Kv(e,g,V(e.Ua)))}}e=d.z;g=d.x;if(null!==e&&(e=e.j(),null!==g))return d=g.j(),g=t().f,G(new H,g,Kv(e,d,V(e.Ua)));throw new x(d);});xq();return Rv(a,b)}
-function WA(a,b){var c=id();try{var d=new z(bb=>"yes: "+bb);if(a.D){var e=Hs(Q(),"| ",a.q);if(b===v())var g=v();else{var h=b.e(),k=new A(Qe(h,""," \x26 ",""),v());h=k;for(var l=b.g();l!==v();){var m=l.e(),n=new A(Qe(m,""," \x26 ",""),v());h=h.r=n;l=l.g()}g=k}var r=e+"factorize? "+Qe(g,""," | ","");Af(Bf(),r+"\n")}a.q=1+a.q|0;try{if(0>=b.$a(1))throw fq(new gq,c,eC(a,b));var u=ru().U();for(e=b;!e.b();){for(var w=e.e();!w.b();){var y=w.e();y instanceof Ow?(g=y,u.Qh(g,1+(u.yd(g,new U(()=>0))|0)|0)):y instanceof
-Uu?(g=y,u.Qh(g,1+(u.yd(g,new U(()=>0))|0)|0)):y instanceof nC?(g=y,u.Qh(g,1+(u.yd(g,new U(()=>0))|0)|0)):y instanceof oC&&(g=y,u.Qh(g,1+(u.yd(g,new U(()=>0))|0)|0));w=w.g()}e=e.g()}if(a.D){var B=Hs(Q(),"| ",a.q)+"Factors "+Qe(u,"",", ","");Af(Bf(),B+"\n")}var D=new z(bb=>bb.Lc()),C=dq(),F=pC(u,D,C);a:{if(F instanceof M){var I=F.k;if(null!==I){var K=I.i(),N=I.Lc();if(1<N){je();var P=new Wo;je();for(var T=new Wo;!b.b();){var aa=b.e(),Y=aa.L(K)?(t(),new te(aa)):(t(),new me(aa));if(Y instanceof te)ip(P,
-Y.ca);else if(Y instanceof me)ip(T,Y.ia);else throw new x(Y);b=b.g()}var S=P.ea(),Z=T.ea();if(a.D){var ka=Hs(Q(),"| ",a.q)+("Factor "+K+" -\x3e ")+Qe(S,"",", ","");Af(Bf(),ka+"\n")}var X=S.K();if(!hf(new E(X),N))throw new rk("assertion failed: "+G(new H,S,N));N=bb=>{var nb=bb;a:for(;;)if(nb.b()){bb=v();break}else{var Tb=nb.e();bb=nb.g();if(!0===!!hf(new E(Tb),K))nb=bb;else for(;;){if(bb.b())bb=nb;else{Tb=bb.e();if(!0!==!!hf(new E(Tb),K)){bb=bb.g();continue}Tb=bb;bb=new A(nb.e(),v());var ub=nb.g();
-for(nb=bb;ub!==Tb;){var Ub=new A(ub.e(),v());nb=nb.r=Ub;ub=ub.g()}for(ub=Tb=Tb.g();!Tb.b();){Ub=Tb.e();if(!0===!!hf(new E(Ub),K)){for(;ub!==Tb;)Ub=new A(ub.e(),v()),nb=nb.r=Ub,ub=ub.g();ub=Tb.g()}Tb=Tb.g()}ub.b()||(nb.r=ub)}break a}}return bb};if(S===v())var sa=v();else{var Ia=S.e(),Za=new A(N(Ia),v());Ia=Za;for(var Ga=S.g();Ga!==v();){var xa=Ga.e(),Ra=new A(N(xa),v());Ia=Ia.r=Ra;Ga=Ga.g()}sa=Za}var Ja=WA(a,sa),La=V(K.p),pb=ju(K,Ja,La,!1);if(0<qC(u,1)){S=!1;for(var Fb=u.m();!S&&Fb.s();){var Gb=Fb.t();
-S=Gw(new E(Gb.i()),K)?1<Gb.Lc():!1}var Hb=S}else Hb=!1;var tb=Hb?WA(a,Z):eC(a,Z),kb=V(tb.p);var gb=zu(tb,pb,kb,!1);break a}}}gb=eC(a,b)}}finally{a.q=-1+a.q|0}if(Gw(new E(d),a.pa)&&a.D){var Vb=""+Hs(Q(),"| ",a.q)+d.n(gb);Af(Bf(),Vb+"\n")}return gb}catch(bb){if(bb instanceof gq){a=bb;if(a.Hg===c)return a.wj();throw a;}throw bb;}}
-function rC(a,b,c,d){Du();return new dv(a,Mx(0,b.Ba,new z(e=>{var g=e.Ua,h=e.Ma;if(h.b())h=R();else{h=h.o();if(c.b())var k=R();else k=!!c.o(),k=new M(!k);h=new M(d.aa(k,h))}return new ww(g,h,d.aa(c,e.oa),e.vd)})),b.Cj)}
-function Zaa(a,b,c,d){var e=!1,g=null;if(b instanceof yu){g=b.Mb;e=b.Xb;if(c.b())var h=R();else h=!!c.o(),h=new M(!h);return new yu(a,d.aa(h,g),d.aa(c,e),b.qa())}if(b instanceof Xu)return SA(b,c,d);if(b instanceof Ru)return g=b.Ub,new Ru(a,Mx(Du(),g,new z(l=>{var m=l.Ua,n=l.Ma;if(n.b())n=R();else{n=n.o();if(c.b())var r=R();else r=!!c.o(),r=new M(!r);n=new M(d.aa(r,n))}return new ww(m,n,d.aa(c,l.oa),l.vd)})),b.qa());if(b instanceof fv){g=b.ld;e=g.Ua;h=g.Ma;if(h.b())h=R();else{h=h.o();if(c.b())var k=
-R();else k=!!c.o(),k=new M(!k);h=new M(d.aa(k,h))}return new fv(a,new ww(e,h,d.aa(c,g.oa),g.vd),b.qa())}if(b instanceof jv)return TA(b,new z(l=>d.aa(c,l)),new z(l=>{if(c.b())var m=R();else m=!!c.o(),m=new M(!m);return d.aa(m,l)}),new z(l=>d.aa(c,l)),b.ou);if(b instanceof gv&&(e=!0,g=b,h=g.Bc,k=g.Ye,h instanceof nA&&null!==k&&k.b()))return new gv(a,UA(h,new z(l=>d.aa(c,l))),k,g.Lo);if(e)return e=g.Ye,new gv(a,d.aa(c,g.Bc),e,b.qa());if(b instanceof gu)return b;throw new x(b);}
-function iB(a,b,c){if(b){for(a=a.tb;!c.b();){b=c.e();var d=V(a.p);a=zu(a,b,d,!1);c=c.g()}return a}for(a=a.Na;!c.b();)b=c.e(),d=V(a.p),a=ju(a,b,d,!1),c=c.g();return a}function sC(a,b){return hf(new E(b),a.tf)?"^":5<b?"^"+b:Hs(Q(),"'",b)}function iC(a){this.PO=null;if(null===a)throw null;this.PO=a}iC.prototype=new p;iC.prototype.constructor=iC;
-function Vu(a,b,c){a:for(var d=Wp();;){var e=b;if(e instanceof uv){var g=e;if(rA(g,c)){b=sA(g,c);continue}}if(e instanceof sB)b=e.gc();else{if(e instanceof Ow&&(DB(a.PO),g=e.Wb,!g.b()&&(g=g.o(),!d.L(e)))){d=d.Yb(e);b=g;continue}t();a=new M(b);break a}}return a}iC.prototype.$classData=q({lZ:0},!1,"mlscript.TyperHelpers$AliasOf$",{lZ:1,d:1});function tC(a,b,c){a.cl=c;if(null===b)throw null;a.Cm=b;a.As=0}function uC(){this.cl=null;this.As=0;this.Cm=null}uC.prototype=new p;uC.prototype.constructor=uC;
-function vC(){}vC.prototype=uC.prototype;uC.prototype.u=function(){return this.$v()};function jC(a){this.SO=this.TO=this.nx=this.ru=this.Ej=null;if(null===a)throw null;this.SO=a;t();this.Ej=new wC(this,new M(!0));t();this.ru=new wC(this,new M(!1));this.nx=new kB(this.Ej,a.md,!1);a=t().f;this.TO=new wC(this,a)}jC.prototype=new p;jC.prototype.constructor=jC;
-function wz(a,b){var c=!1,d=null;if(b instanceof M&&(c=!0,d=b,!0===!!d.k))return a.Ej;if(c&&!1===!!d.k)return a.ru;if(t().f===b)return a.TO;throw new x(b);}jC.prototype.$classData=q({mZ:0},!1,"mlscript.TyperHelpers$PolMap$",{mZ:1,d:1});
-var aba=function $aa(a,b,c,d,e){for(;;){if(a.su.oq){if(b instanceof px)return a=b,t(),new M(a);if(b instanceof uv){var h=b;if(!c.L(h.ob)){b=xC(h,d,e);c=h=c.Yb(h.ob);continue}}if(b instanceof sB){b=b.gc();continue}if(b instanceof Ow){h=b;DB(a.su);var k=h.Wb;if(!k.b()&&(k=k.o(),!c.L(h))){h=c.Yb(h);b=k;c=h;continue}}if(b instanceof yu){h=b.Mb;e=$aa(a,b.Xb,c,d,e);c=new yC(e,new z(l=>null!==l));e=c.TQ;c=c.z2;e=e.b()||c.n(e.o())?e:R();if(e.b())return R();e=e.o();if(null!==e)c=e.Ld,k=e.ve,h.Ca()>c?(c=h.Ca(),
-k=Wp(),d=zC(e,c,k,d),a=new px(a.su,d.Ld,new yu(a.su,h,d.ve,b.Bj))):a=new px(a.su,c,new yu(a.su,h,k,b.Bj));else throw new x(e);return new M(a)}}return t().f}};function hC(a){this.su=null;if(null===a)throw null;this.su=a}hC.prototype=new p;hC.prototype.constructor=hC;function bba(a,b,c,d){return aba(a,b,Wp(),c,d)}hC.prototype.$classData=q({sZ:0},!1,"mlscript.TyperHelpers$PolyFunction$",{sZ:1,d:1});
-function vA(a,b){var c=ru().U(),d=a.p;d.D&&(d=Hs(Q(),"| ",d.q)+("INST ["+a.Ld+"]   ")+a,Af(Bf(),d+"\n"));d=a.p;d.D&&(d=Hs(Q(),"| ",d.q)+"  where  "+Yw(a),Af(Bf(),d+"\n"));c=a.ve.Dc(a.Ld,!1,b,c);d=a.p;d.D&&(b=Hs(Q(),"| ",d.q)+("TO ["+b.fa+"] ~\x3e  ")+c,Af(Bf(),b+"\n"));a=a.p;a.D&&(a=Hs(Q(),"| ",a.q)+"  where  "+Yw(c),Af(Bf(),a+"\n"));return c}function cba(a,b){var c=ru().U();return a.ve.Dc(a.Ld,!0,b,c)}function zC(a,b,c,d){var e=ru().U();return dC(a,b,c,d,e)}
-function dC(a,b,c,d,e){Os(fp(),b>=a.Ld);if(hf(new E(b),a.Ld))return a;var g=a.p,h=a.Ld,k=a.ve,l=a.p.tf;d=new Uv(d.V,d.Vc,d.Xa,d.kd,1+b|0,d.Ac,d.vb,d.fb,d.ud,d.hb);return new px(g,b,AC(a.p,k,l,d,h,c,e,!1))}
-function Vaa(a,b,c,d,e,g){for(;;){var h=!1,k=null;if(b instanceof yu){c=b;k=c.Mb;b=c.Xb;h=BC(b,d,a.p.tf);g=a.p;g.D&&(g=Hs(Q(),"| ",g.q)+"could be distribbed: "+h,Af(Bf(),g+"\n"));if(h.b())return t().f;g=BC(k,d,a.p.tf);var l=a.p;l.D&&(l=Hs(Q(),"| ",l.q)+"cannot be distribbed: "+g,Af(Bf(),l+"\n"));if(h.Zx(g).b())return t().f;h=1+d|0;l=new z(n=>n.Va);var m=dq();l=pC(g,l,m);m=a;l=l.b()?m.p.md:l.o().Va;h=h>l?h:l;b=new px(a.p,d,b);l=a.p;l.D&&(l=Hs(Q(),"| ",l.q)+"inner: "+b,Af(Bf(),l+"\n"));e=new yu(a.p,
-k,zC(b,h,g,e),c.Bj);c=a.p;c.D&&(c=Hs(Q(),"| ",c.q)+"raised: "+e,Af(Bf(),c+"\n"));c=a.p;c.D&&(c=Hs(Q(),"| ",c.q)+"  where: "+Yw(e),Af(Bf(),c+"\n"));if(g.b())return t(),new M(e);t();d=new px(a.p,d,e);return new M(d)}if(b instanceof uv&&(l=b,!c.L(l.ob))){k=xC(l,e,g);c=c.Yb(l.ob);b=k;continue}if(b instanceof sB)b=k=b.gc();else{if(b instanceof Ow&&(h=!0,k=b,DB(a.p),l=k.Wb,!l.b()&&(l=l.o(),!c.L(k)))){c=c.Yb(k);b=l;continue}if(h&&k.Va>d&&!c.L(k)){b=a;h=ny(k);l=a.p.tb;for(a=h;!a.b();)h=l,l=a.e(),m=V(h.p),
-l=zu(h,l,m,!1),a=a.g();h=l;c=c.Yb(k);a=b;b=h}else if(b instanceof px)k=b,b=k.Ld,d=d<b?d:b,b=k.ve;else return t().f}}}function CC(a){if(a instanceof Ow)return a;Dn(a+" was not a type variable")}
-function HB(a,b){if(a instanceof qA)return hf(new E(a.yi),b);if(a instanceof Ow)return b instanceof Ow?hf(new E(a.Jo),b.Jo):b instanceof qA&&b.p===a.p?hf(new E(a),b.yi):!1;if(null!==a&&as(a)){if(b instanceof aA&&b.p===a.p){if(b instanceof qA)return hf(new E(a),b.yi);if(b instanceof Ow)return!1;if(null!==b&&as(b)){if(a.E(b)&&hf(new E(a.G()),b.G())){a=new DC(a);for(b=new DC(b);a.s()&&b.s();){var c=a.t();if(sr(new E(c),b.t()))return!1}return!a.s()&&!b.s()}return!1}throw new x(b);}return!1}throw new x(a);
-}function dba(a){return a instanceof Ow?eba(a):UA(a,new z(b=>EC(b)))}function EC(a){hf(new E(a.p.nm),a.Ud)||(a.Td=dba(a),a.Ud=a.p.nm);return a.Td}
-function UA(a,b){if(a instanceof wB){var c=a.vg,d=a.Jf;return FC(rv(a.p),b.n(c),b.n(d),V(rv(a.p).pu))}if(a instanceof yu)return c=a.Xb,new yu(a.p,b.n(a.Mb),b.n(c),a.qa());if(a instanceof Xu)return SA(a,t().f,new Um((l,m)=>b.n(m)));if(a instanceof dv)return c=a.Ba,new dv(a.p,Mx(Du(),c,new z(l=>DA(l,b,b))),a.qa());if(a instanceof Ru)return c=a.Ub,new Ru(a.p,Mx(Du(),c,new z(l=>DA(l,b,b))),a.qa());if(a instanceof jv)return TA(a,b,b,b,a.ou);if(a instanceof fv)return new fv(a.p,DA(a.ld,b,b),a.qa());if(a instanceof
-nA)return c=a.dc,new nA(a.p,a.nc,b.n(a.cc),b.n(c),a.qa());if(a instanceof oA)return new oA(a.p,b.n(a.xc),a.qa());if(a instanceof gv)return c=a.Ye,new gv(a.p,b.n(a.Bc),c,a.qa());if(a instanceof qA)return new qA(a.p,b.n(a.yi),a.qa());if(a instanceof ry){c=a.Ko;d=a.p;var e=b.n(a.hq),g=a.p;Du();return new ry(d,e,new dv(g,Mx(0,c.Ba,new z(l=>DA(l,b,b))),c.Cj),a.qa())}if(a instanceof sB&&(tB(a.p),t(),c=a.gc(),c=new M(c),!c.b()))return b.n(c.k);if(a instanceof uv){c=a.ob;var h=a.Vb;d=a.p;if(h===v())e=v();
-else for(e=h.e(),g=e=new A(b.n(e),v()),h=h.g();h!==v();){var k=h.e();k=new A(b.n(k),v());g=g.r=k;h=h.g()}return new uv(d,c,e,a.qa())}if(a instanceof px)return new px(a.p,a.Ld,b.n(a.ve));if(a instanceof yB){h=a.Aj;c=a.ej;a=a.p;d=l=>{var m=b.n(l.i());l=b.n(l.j());return G(new H,m,l)};if(h===v())d=v();else{e=h.e();g=e=new A(d(e),v());for(h=h.g();h!==v();)k=h.e(),k=new A(d(k),v()),g=g.r=k,h=h.g();d=e}return new yB(a,d,b.n(c))}if(a instanceof Ow||hv(a)||a instanceof gA)return a;throw new x(a);}
-function wA(a,b,c,d,e){var g=!1,h=null,k=!1,l=null,m=!1,n=null;if(a instanceof wB){g=!0;h=a;var r=h.vg,u=h.Jf;if(c&&!b.b())return b.b()&&Dn("Program reached and unexpected state."),b.o()?d.aa((t(),new M(!0)),u):d.aa((t(),new M(!1)),r)}if(g)return c=h.vg,e=h.Jf,FC(rv(a.p),d.aa((t(),new M(!1)),c),d.aa((t(),new M(!0)),e),V(rv(a.p).pu));if(a instanceof dv)return rC(a.p,a,b,d);if(a instanceof gv&&(g=a.Bc,h=a.Ye,c))return a=d.aa(b,g),JA(a,h);if(a instanceof Tu)return Zaa(a.p,a,b,d);if(a instanceof nA&&
-(k=!0,l=a,g=l.nc,r=l.cc,h=l.dc,c)){if(g)return a=d.aa(b,r),c=d.aa(b,h),e=V(a.p),zu(a,c,e,!1);a=d.aa(b,r);c=d.aa(b,h);e=V(a.p);return ju(a,c,e,!1)}if(k)return c=l.dc,new nA(a.p,l.nc,d.aa(b,l.cc),d.aa(b,c),a.qa());if(a instanceof oA&&(m=!0,n=a,l=n.xc,c))return b.b()?c=R():(c=!!b.o(),c=new M(!c)),c=d.aa(c,l),pA(c,a.qa(),!1);if(m)return c=n.xc,e=a.p,b.b()?l=R():(l=!!b.o(),l=new M(!l)),new oA(e,d.aa(l,c),a.qa());if(a instanceof qA)return new qA(a.p,d.aa(b,a.yi),a.qa());if(a instanceof ry)return c=a.Ko,
-e=a.p,l=d.aa(b,a.hq),m=a.p,Du(),new ry(e,l,new dv(m,Mx(0,c.Ba,new z(w=>{var y=w.Ua,B=w.Ma;if(B.b())B=R();else{B=B.o();if(b.b())var D=R();else D=!!b.o(),D=new M(!D);B=new M(d.aa(D,B))}return new ww(y,B,d.aa(b,w.oa),w.vd)})),c.Cj),a.qa());if(a instanceof sB&&(tB(a.p),t(),l=a.gc(),l=new M(l),!l.b()))return d.aa(b,l.k);if(a instanceof uv)return new uv(a.p,a.ob,qv(a,b,d,e),a.qa());if(a instanceof px)return e=a.Ld,l=a.ve,c?Zw($w(a.p),e,d.aa(b,l)):new px(a.p,e,d.aa(b,l));if(a instanceof yB){n=a.Aj;c=a.ej;
-a=a.p;e=w=>{var y=d.aa((t(),new M(!0)),w.i());w=d.aa((t(),new M(!1)),w.j());return G(new H,y,w)};if(n===v())e=v();else{l=n.e();m=l=new A(e(l),v());for(n=n.g();n!==v();)k=n.e(),k=new A(e(k),v()),m=m.r=k,n=n.g();e=l}return new yB(a,e,d.aa(b,c))}if(a instanceof Ow||hv(a)||a instanceof gA)return a;throw new x(a);}
-var zu=function fba(a,b,c,d){var g=a.p.Na;if(null===g?null===a:HB(g,a))return a;g=a.p.tb;if(null===g?null===a:HB(g,a))return b;if(a instanceof dv&&b instanceof yu)return a.p.Na;if(a instanceof dv&&(g=a.Ba,b instanceof dv))return new dv(a.p,kC(g,b.Ba),c);if(a instanceof Ru&&(g=a.Ub,b instanceof Ru)){var h=b.Ub,k=pv(g,h);if(hf(new E(k),0))return new Ru(a.p,mC(g,h),a.gq)}return d?(null===b?null===a:HB(b,a))?a:a instanceof oA&&(d=a.xc,null===b?null===d:HB(b,d))?a.p.Na:new nA(a.p,!0,b,a,c):fba(b,a,c,!0)},
-Uz=function gba(a,b,c){if(a instanceof yu){var e=a.Mb,g=a.Xb;if(b instanceof yu){var h=b.Mb,k=b.Xb;if(a.p.yI)return a=a.p,b=V(e.p),e=zu(e,h,b,!1),h=V(g.p),new yu(a,e,gba(g,k,h),c)}}return ju(a,b,c,!1)},ju=function GC(a,b,c,d){a:{var g=a.p.Na;if(null===g?null===a:HB(g,a))g=!0;else{if(a instanceof dv){g=a.Ba;var h=O().c;if(null===h?null===g:h.h(g)){g=!0;break a}}g=!1}}if(g)return b;g=a.p.tb;if((null===g?null===a:HB(g,a))||a instanceof gu&&b instanceof yu)return a.p.tb;if(a instanceof dv&&(g=a.Ba,b instanceof
-dv)){h=b.Ba;a=a.p;b=mu();d=ap().wa;b=new ou(b,d);d=Ku();var k=g.Q()+h.Q()|0;h=Zu(Zu($u(8<k?k:8),g),h);g=ru().U();for(h=Sl(h).m();h.s();){var l=h.t();k=l.i();var m=g.Y(k);if(m instanceof M)m=m.k,l=av(m,l.j(),V(m.Ua));else{if(R()!==m)throw new x(m);l=l.j()}g.Vi(k,l)}h=cp();b=bv(d,(new cv(h)).qc(g),b);je();return new dv(a,le(v(),b),c)}return a instanceof Ru&&(g=a.Ub,b instanceof Ru)?(c=b.Ub,b=pv(g,c),sr(new E(b),0)?a.p.tb:new Ru(a.p,ev(g,c),a.gq)):d?(null===b?null===a:HB(b,a))?a:d?a instanceof oA&&(d=
-a.xc,null===b?null===d:HB(b,d))?a.p.tb:new nA(a.p,!1,b,a,c):GC(b,a,c,!0):GC(b,a,c,!0)},pA=function HC(a,b,c){var e=!1,g=null;if(a instanceof gA)return new gA(a.p,!a.sh,V(a.p));if(a instanceof nA){e=!0;g=a;var h=g.cc,k=g.dc;if(!0===g.nc)return a=V(h.p),a=HC(h,a,!1),b=V(k.p),k=HC(k,b,!1),b=V(a.p),ju(a,k,b,!1)}return e&&(h=g.cc,k=g.dc,!1===g.nc&&c)?(a=V(h.p),a=HC(h,a,!1),b=V(k.p),k=HC(k,b,!1),b=V(a.p),zu(a,k,b,!1)):a instanceof oA?a.xc:new oA(a.p,a,b)};
-function hba(a,b,c){var d=ru().U();return tu(a,b,c,!0,d)?(d=ru().U(),tu(b,a,c,!0,d)):!1}
-var tu=function IC(a,b,c,d,e){var h=hf(new E(d),!0)&&!a.p.zE;a.p.Wo=1+a.p.Wo|0;if(!JC(a)&&(et(new E(a),b)||hf(new E(a),b)))return!0;var k=G(new H,a,b);var l=k.x;if(l instanceof gA&&!1===l.sh)var m=!0;else{var n=k.z;m=n instanceof gA&&!0===n.sh?!0:!1}if(m)return!0;var r=k.z;if(r instanceof sB){tB(a.p);t();var u=r.gc(),w=new M(u);if(!w.b())return IC(w.k,b,c,d,e)}var y=k.x;if(y instanceof sB){tB(a.p);t();var B=y.gc(),D=new M(B);if(!D.b())return IC(a,D.k,c,d,e)}if((hv(k.z)&&hv(k.x)||k.z instanceof Ow&&
-k.x instanceof Ow)&&hf(new E(a),b))return!0;var C=k.z,F=k.x;if(C instanceof iv&&F instanceof fv)return Sv(C.Mj(),F.ld,c,e);var I=k.z,K=k.x;if(I instanceof Ru){var N=I.Ub;if(K instanceof Ru){var P=K.Ub,T=pv(N,P);if(hf(new E(T),0)){for(var aa=new vq(N,N,P),Y=aa.Sj.m(),S=aa.Tj.m(),Z=!1;!Z&&Y.s()&&S.s();){var ka=Y.t(),X=S.t(),sa=G(new H,ka,X);a:{var Ia=sa.z,Za=sa.x;if(null!==Ia){var Ga=Ia.j();if(null!==Za){var xa=Sv(Ga,Za.j(),c,e);break a}}throw new x(sa);}Z=!xa}return!Z}return!1}}var Ra=k.z;if(Ra instanceof
-dv){var Ja=Ra.Ba,La=O().c;if(null===La?null===Ja:La.h(Ja))return IC(a.p.Na,b,c,d,e)}var pb=k.x;if(pb instanceof dv){var Fb=pb.Ba,Gb=O().c;if(null===Gb?null===Fb:Gb.h(Fb))return IC(a,a.p.Na,c,d,e)}var Hb=k.z,tb=k.x;if(Hb instanceof gu){var kb=Hb.ed;if(tb instanceof gu){var gb=tb.ed;return hf(new E(kb),gb)?!0:Hb.dv().L(gb)}}var Vb=k.z;if(Vb instanceof wB)return IC(Vb.Jf,b,c,d,e);var bb=k.x;if(bb instanceof wB)return IC(a,bb.vg,c,d,e);var nb=k.z,Tb=k.x;if(nb instanceof yu){var ub=nb.Mb,Ub=nb.Xb;if(Tb instanceof
-yu){var $a=Tb.Mb,cb=Tb.Xb,Na=Rb=>IC($a,ub,c,d,Rb)&&IC(Ub,cb,c,d,Rb);if(h)var Ca=e.Ux(new z(Rb=>G(new H,Rb.i(),!0))),Ba=Na(Ca);else Ba=Na(e);return!!Ba}}var Oa=k.z;if(Oa instanceof nA){var wa=Oa.cc,ea=Oa.dc;if(!0===Oa.nc)return IC(wa,b,c,d,e)&&IC(ea,b,c,d,e)}var la=k.x;if(la instanceof nA){var Ka=la.cc,Ua=la.dc;if(!1===la.nc)return IC(a,Ka,c,d,e)&&IC(a,Ua,c,d,e)}var ya=k.z;if(ya instanceof nA){var ib=ya.cc,Lb=ya.dc;if(!1===ya.nc)return IC(ib,b,c,d,e)||IC(Lb,b,c,d,e)}var ec=k.x;if(ec instanceof nA){var Mb=
-ec.cc,Jb=ec.dc;if(!0===ec.nc)return IC(a,Mb,c,d,e)||IC(a,Jb,c,d,e)}var Kb=k.z,eb=k.x;if(Kb instanceof dv){var Wb=Kb.Ba;if(eb instanceof dv){var mc=eb.Ba,ua=Rb=>{for(var Uc=mc;!Uc.b();){var Rc=Uc.e();a:{for(var Cd=Wb;!Cd.b();){var od=Cd.e().i();if(hf(new E(od),Rc.i())){Cd=new M(Cd.e());break a}Cd=Cd.g()}Cd=R()}if(Cd.b()||!Sv(Cd.o().j(),Rc.j(),c,Rb))return!1;Uc=Uc.g()}return!0};if(h)var Pa=e.Ux(new z(Rb=>G(new H,Rb.i(),!0))),xb=ua(Pa);else xb=ua(e);return!!xb}}if(k.x instanceof gv||(k.z instanceof Ow||
-k.x instanceof Ow)&&!h)return!1;if((k.z instanceof Ow||k.x instanceof Ow)&&e.L(G(new H,a,b)))return!!e.n(G(new H,a,b));var Yb=k.z;if(Yb instanceof Ow){e.Qh(G(new H,a,b),!1);var zb=Yb.Wb;if(zb instanceof M)var Sb=IC(zb.k,b,c,d,e);else{if(t().f!==zb)throw new x(zb);a:{for(var Ma=Tz(Yb);!Ma.b();){var Ea=Ma.e();if(IC(Ea,b,c,d,e)){Sb=!0;break a}Ma=Ma.g()}Sb=!1}}Sb&&e.Qh(G(new H,a,b),!0);return Sb}var ab=k.x;if(ab instanceof Ow){e.Qh(G(new H,a,b),!1);var Db=ab.Wb;if(Db instanceof M)var mb=IC(a,Db.k,c,d,
-e);else{if(t().f!==Db)throw new x(Db);a:{for(var vb=ny(ab);!vb.b();){var Ya=vb.e();if(IC(a,Ya,c,d,e)){mb=!0;break a}vb=vb.g()}mb=!1}}mb&&e.Qh(G(new H,a,b),!0);return mb}var Wa=k.z;if(Wa instanceof yB){var rb=Wa.Aj,pa=Wa.ej,Fa=O().c;if(null===Fa?null===rb:Fa.h(rb))return IC(pa,b,c,d,e)}var Ib=k.x;if(Ib instanceof yB)return IC(a,Ib.ej,c,d,e);var qb=k.x;if(qb instanceof oA){var Nb=qb.xc,fc=V(a.p),Ac=ju(a,Nb,fc,!1);return IC(Ac,a.p.tb,c,d,e)}var tc=k.z;if(tc instanceof oA){var vc=tc.xc,sc=a.p.Na,uc=V(b.p),
-lc=zu(b,vc,uc,!1);return IC(sc,lc,c,d,e)}var Wc=k.z;if(Wc instanceof uv&&a.p.Em.L(Wc.ob.X)&&rA(Wc,c)){var Cc=sA(Wc,c);return IC(Cc,b,c,d,e)}var Dc=k.x;if(Dc instanceof uv&&a.p.Em.L(Dc.ob.X)&&rA(Dc,c)){var Ec=sA(Dc,c);return IC(a,Ec,c,d,e)}var Ic=k.z;if(Ic instanceof uv){var Xc=c.vb.Y(Ic.ob.X);if(Xc instanceof M){var Sc=Xc.k;if(b instanceof uv&&hf(new E(b.ob),Ic.ob)){for(var oc=EA(Sc),qc=Sc.zm,Tc=ap(),Nc=qc.Gb(Tc.wa).j(),Pc=KC(new vq(Nc,Nc,Ic.Vb),b.Vb),Oc=Pc.SK.m(),$c=Pc.TK.m(),Lc=Pc.UK.m(),Zb=!1;!Zb&&
-Oc.s()&&$c.s()&&Lc.s();){var ed=Oc.t(),$b=$c.t(),Fc=Lc.t(),Yc=$b,nc=Fc,Ob=oc.n(ed);Zb=!((Ob.Vd||IC(Yc,nc,c,d,e))&&(Ob.wd||IC(nc,Yc,c,d,e)))}return!Zb}if(et(new E(Sc.dj),pp())){var cc=LC(a.p,Sc,V(a.p),c);return IC(cc,b,c,d,e)}return!1}if(t().f===Xc)return!1;throw new x(Xc);}if(k.x instanceof uv||k.z instanceof px||k.x instanceof px)return!1;var Gc=k.x;if(Gc instanceof Xu){for(var Bc=Gc.Wh;!Bc.b();){var qd=Bc.e();if(!IC(a,qd,c,d,e))return!1;Bc=Bc.g()}return!0}var Gd=k.z;if(Gd instanceof Xu){for(var cd=
-Gd.Wh;!cd.b();){var rd=cd.e();if(IC(rd,b,c,d,e))return!0;cd=cd.g()}return!1}if(k.z instanceof yB||k.z instanceof gv||k.z instanceof iv||k.x instanceof iv||k.z instanceof Uu||k.x instanceof Uu||k.z instanceof yu||k.x instanceof yu||k.z instanceof dv&&hv(k.x)||hv(k.z)&&k.x instanceof dv)return!1;var Id=k.x;if(Id instanceof gA&&!0===Id.sh)var Ha=!0;else{var jc=k.z;Ha=jc instanceof gA&&!1===jc.sh?!0:!1}if(Ha)return!1;throw new x(k);};function lA(a,b){var c=ru().U();return tu(a.p.Na,a,b,!0,c)}
-function Yu(a,b){var c=a.p.tb,d=ru().U();return tu(a,c,b,!0,d)}function JA(a,b){return b.b()?a:a instanceof gv?new gv(a.p,a.Bc,a.Ye.af(b),a.qa()):new gv(a.p,a,b,V(a.p))}
-var vB=function MC(a,b){if(b.b())return a;var d=!1,e=null,g=!1,h=null;if(a instanceof gv)return new gv(a.p,a.Bc,a.Ye.af(b),a.qa());if(a instanceof yu)return a;if(a instanceof nA){d=!0;e=a;var k=e.cc,l=e.dc;if(!0===e.nc)return a=JA(k,b),b=JA(l,b),h=V(a.p),zu(a,b,h,!1)}if(d&&(d=e.cc,l=e.dc,!1===e.nc))return a=JA(d,b),b=JA(l,b),h=V(a.p),ju(a,b,h,!1);if(a instanceof dv){h=a.p;g=a.Ba;a:for(;;)if(g.b()){b=v();break}else if(l=g.e(),e=g.g(),!1===!b.L(l.i()))g=e;else for(;;){if(e.b())b=g;else{l=e.e();if(!1!==
-!b.L(l.i())){e=e.g();continue}l=e;e=new A(g.e(),v());d=g.g();for(g=e;d!==l;)k=new A(d.e(),v()),g=g.r=k,d=d.g();for(d=l=l.g();!l.b();){k=l.e();if(!1===!b.L(k.i())){for(;d!==l;)k=new A(d.e(),v()),g=g.r=k,d=d.g();d=l.g()}l=l.g()}d.b()||(g.r=d);b=e}break a}return new dv(h,b,a.Cj)}if(a instanceof Ru){var m=a.Ub;b=b.uk(new z(n=>{var r=OA(n);n=m.K();if(r.b())return!1;r=r.o()|0;return r!==n&&!(0>r||r>n)}));if(b.b())return a;a=a.Ap();e=a.Ba;a:for(;;)if(e.b()){b=v();break}else if(g=e.e(),h=e.g(),!0===!!b.L(g.i()))e=
-h;else for(;;){if(h.b())b=e;else{g=h.e();if(!0!==!!b.L(g.i())){h=h.g();continue}g=h;h=new A(e.e(),v());l=e.g();for(e=h;l!==g;)d=new A(l.e(),v()),e=e.r=d,l=l.g();for(l=g=g.g();!g.b();){d=g.e();if(!0===!!b.L(d.i())){for(;l!==g;)d=new A(l.e(),v()),e=e.r=d,l=l.g();l=g.g()}g=g.g()}l.b()||(e.r=l);b=h}break a}return new dv(a.p,b,a.Cj)}if(a instanceof fv)return a;a instanceof jv&&$n();if(a instanceof oA&&(g=!0,h=a,h.xc instanceof gu||h.xc instanceof yu||h.xc instanceof dv))return h;if(g&&(e=h.xc,e instanceof
-nA||e instanceof gA||e instanceof oA))return a=pA(e,h.Tz,!0),MC(a,b);if(a instanceof gA)return a;if(a instanceof qA)return new qA(a.p,MC(a.yi,b),a.oE);if(a instanceof sB&&(tB(a.p),t(),h=a.gc(),h=new M(h),!h.b()))return MC(h.k,b);if(hv(a))return a;if(a instanceof wB)return MC(a.Jf,b);if(a instanceof Ow||a instanceof oA||a instanceof uv)return new gv(a.p,a,b,V(a.p));if(a instanceof px)return h=a.Ld,e=a.ve,Zw($w(a.p),h,MC(e,b));if(a instanceof Xu||a instanceof yB)return a;throw new x(a);},NC=function iba(a,
-b){a=dB(a);return a instanceof uv&&rA(a,b)?(a=sA(a,b),iba(a,b)):a},QC=function OC(a,b,c,d,e){var h=!1,k=null,l=PC(e)?a:NC(a,d);if(l instanceof gA)return new gA(a.p,!l.sh,V(a.p));if(l instanceof nA){h=!0;k=l;var m=k.cc,n=k.dc;if(!0===k.nc)return a=OC(m,b,c,d,e),c=OC(n,b,c,d,e),b=V(a.p),ju(a,c,b,!1)}return h&&(h=k.cc,n=k.dc,!1===k.nc)?(a=OC(h,b,c,d,e),c=OC(n,b,c,d,e),b=V(a.p),zu(a,c,b,!1)):l instanceof oA?(b=b.n(l.xc),Vw(b.p,b,c)):l instanceof uv&&!PC(e)&&rA(l,d)?(a=sA(l,d),OC(a,b,c,d,e)):l instanceof
-dv||l instanceof yu?a.p.tb:new oA(a.p,b.n(l),c)},jba=function RC(a,b,c){if(a instanceof oA)return QC(a.xc,new z(m=>RC(m,b,c)),a.qa(),b,c);if(a instanceof gv){var e=a.Bc,g=a.Ye;if(g.b())return RC(e,b,c);var h=!1,k=null;e=PC(c)?dB(e):NC(e,b);g=vB(e,g);if(g instanceof gv){h=!0;k=g;e=k.Bc;var l=k.Ye;if(e instanceof nA)return k=e.dc,new nA(a.p,e.nc,vB(e.cc,l),vB(k,l),e.lE)}return h&&(h=k.Bc,k=k.Ye,h instanceof oA)?(h=h.xc,h=QC(h,new z(m=>RC(m,b,c)),h.qa(),b,c),k=vB(h,k),k instanceof gv&&(h=k.Bc,h instanceof
-oA)?(h=h.xc,h instanceof Ow||h instanceof gu||h instanceof dv?k:PC(c)?k:Dn(a+"  "+k+"  ("+ja(h)+")")):k):g}return a},dB=function kba(a){if(a instanceof sB){tB(a.p);t();var c=a.gc();c=new M(c);if(!c.b())return kba(c.k)}return a},CB=function lba(a){return a instanceof qA?lba(a.yi):a},mba=function SC(a){var c=dB(a);return c instanceof gv?SC(c.Bc):c instanceof px?SC(c.ve):c instanceof wB?SC(c.Jf):a},VA=function TC(a,b){var d=!1,e=null;if(a instanceof gA&&b===a.sh)return O().c;if(a instanceof nA){var g=
-a.cc,h=a.dc;if(b===a.nc)return a=TC(g,b),Fl(TC(h,b),a)}if(a instanceof oA&&(d=!0,e=a,h=e.xc,h instanceof Ow&&!b))return a=new nC(a.p,h),b=O().c,new A(a,b);if(d&&(d=e.xc,d instanceof Uu&&!b))return a=new oC(a.p,d),b=O().c,new A(a,b);if(a instanceof qA)return TC(a.yi,b);b=O().c;return new A(a,b)};function BC(a,b,c){var d=Lz().U(),e=Lz().U();nba(a,a,b,c,e,d);return Zp($p(),d)}function UC(a,b){t();return VC(a,new M(!0),a,b)}function WC(a,b){t();return VC(a,new M(!1),a,b)}
-function VC(a,b,c,d){c=lC(a.p,c,Jf(),!1,d);b=Kz(a.p,c,b,d);return Rf(a.p,b,!0,d)}var nba=function XC(a,b,c,d,e,g){for(;;){if(c<d&&b.Ca()>c)if(b instanceof Ow){if(!e.L(b))for(e.S(b),b.Va>c&&b.Va<=d&&g.S(b),b=YC(b,!0);!b.b();){var k=b.e();XC(a,k,c,d,e,g);b=b.g()}}else if(b instanceof px){k=b.Ld;d=k<d?k:d;b=b.ve;continue}else for(b=YC(b,!0);!b.b();)k=b.e(),XC(a,k,c,d,e,g),b=b.g();break}};function ZC(a,b,c){a.$z=c;if(null===b)throw null;a.nq=b}function $C(){this.nq=this.$z=null}$C.prototype=new p;
-$C.prototype.constructor=$C;function aD(){}aD.prototype=$C.prototype;function Oz(a,b,c){if(c instanceof aA)a.Rb(b,c);else{if(c instanceof cA){dA(a.nq);t();var d=new M(c);if(!d.b()){c=d.k;for(d=c.ok;!d.b();){var e=d.e();bD(a,b,e);d=d.g()}c=c.Jl;c.b()||(c=c.o(),a.Rb(b,c));return}}throw new x(c);}}
-function bD(a,b,c){if(c instanceof Dw){var d=c.Gl;for(c=c.ik.m();c.s();){var e=c.t();a.Rb(new mB(b),e.gb)}a.Rb(b,d)}else if(c instanceof Aw){var g=c.yj,h=c.Wk,k=c.ui;d=c.wm;e=c.jk;var l=c.vm;for(c=c.Zg.m();c.s();){var m=c.t();a.Rb(new mB(b),m.gb)}if(!g.b())for(c=g.o();!c.b();)g=c.e(),a.$o(b,g.j()),c=c.g();if(!h.b())for(c=h.o();!c.b();)h=c.e(),a.Rb(new nB(b),h.j()),c=c.g();for(c=k.Qd();c.s();)k=c.t(),bD(a,b,k);a.Rb(new nB(b),d);a.Rb(new nB(b),e);for(c=l.Qd();c.s();)d=c.t(),bD(a,b,d)}else if(c instanceof
-yw){k=c.kk;d=c.un;e=c.lk;l=c.xm;for(c=c.nk.m();c.s();)h=c.t(),a.Rb(new mB(b),h.gb);for(c=k.Qd();c.s();)k=c.t(),bD(a,b,k);a.Rb(new nB(b),d);a.Rb(b,e);for(c=l.Qd();c.s();)d=c.t(),bD(a,b,d)}else if(c instanceof Zv){d=c.Zk;e=c.Xk;k=c.Il;l=c.zj;for(c=c.$k.m();c.s();)h=c.t(),a.Rb(new mB(b),h.gb);for(c=k;!c.b();)k=c.e(),a.$o(b,k.j()),c=c.g();for(c=l.Qd();c.s();)l=c.t(),bD(a,b,l);a.Rb(new nB(b),d);a.Rb(new nB(b),e)}else if(c instanceof xw)a.$o(b,c.cg);else if(c instanceof Ew)a.Rb(b,c.Vh);else if(!(c instanceof
-Fw))throw new x(c);}
-$C.prototype.Rb=function(a,b){var c=!1,d=null;a:{if(b instanceof Ow){c=!0;d=b;DB(this.nq);var e=d.Wb;if(!e.b()){b=e.o();this.Rb(a,b);break a}}if(c){b=a.zg(d.Va);if(sr(new E(b),(t(),new M(!1))))for(e=ny(d),c=new kB(a,d.Va,!0);!e.b();){var g=e.e();this.Rb(c,g);e=e.g()}if(sr(new E(b),(t(),new M(!0))))for(b=Tz(d),a=new kB(a,d.Va,!1);!b.b();)d=b.e(),this.Rb(a,d),b=b.g()}else if(b instanceof yu)d=b.Mb,b=b.Xb,this.Rb(new nB(a),d),this.Rb(a,b);else if(b instanceof Xu)for(b=b.Wh;!b.b();)d=b.e(),this.Rb(a,
-d),b=b.g();else if(b instanceof nA)d=b.dc,this.Rb(a,b.cc),this.Rb(a,d);else if(b instanceof dv)for(b=b.Ba,d=ap(),b=b.Gb(d.wa).j();!b.b();)d=b.e(),this.$o(a,d),b=b.g();else if(b instanceof Ru)for(b=b.Ub,d=ap(),b=b.Gb(d.wa).j();!b.b();)d=b.e(),this.$o(a,d),b=b.g();else if(b instanceof fv)this.$o(a,b.ld);else if(b instanceof jv)for(b=b.zn;!b.b();){d=b.e();if(d instanceof te)this.Rb(a,d.ca);else if(d instanceof me)this.$o(a,d.ia);else throw new x(d);b=b.g()}else if(b instanceof oA)b=b.xc,this.Rb(new nB(a),
-b);else if(!(b instanceof gA)){if(b instanceof sB&&(tB(this.nq),t(),d=b.gc(),d=new M(d),!d.b())){this.Rb(a,d.k);break a}if(!(qB(b)||b instanceof rB))if(b instanceof Pw)this.Rb(a,b.Xh);else if(b instanceof uv)uB(b,a,new Um((h,k)=>{this.Rb(h,k)}),this.$z);else if(b instanceof gv)this.Rb(a,b.Bc);else if(b instanceof wB)d=b.vg,b=b.Jf,c=(h,k)=>{this.Rb(h,k)},sr(new E(a.cl),(t(),new M(!0)))&&(e=xz(a.Cm).ru,c(e,d)),sr(new E(a.cl),(t(),new M(!1)))&&(a=xz(a.Cm).Ej,c(a,b));else if(b instanceof px)d=b.ve,this.Rb(new xB(a,
-b.Ld),d);else if(b instanceof yB){d=b.ej;for(b=b.Aj;!b.b();){e=b.e();if(null!==e)c=e.i(),e=e.j(),this.Rb(xz(this.nq).Ej,c),this.Rb(xz(this.nq).nx,e);else throw new x(e);b=b.g()}this.Rb(a,d)}else throw new x(b);}}};$C.prototype.$o=function(a,b){var c=b.Ma,d=new nB(a);c.b()||(c=c.o(),this.Rb(d,c));this.Rb(a,b.oa)};function cD(a,b,c){var d=c.Ma;d.b()?d=!1:(d=d.o(),d=hf(new E(d),c.oa));d?a.Rb(new mB(b),c.oa):$C.prototype.$o.call(a,b,c)}
-function dD(a,b,c){var d=!1,e=null;if(a instanceof Ow){d=!0;e=a;DB(a.p);var g=e.Wb;if(!g.b()){var h=g.o(),k=G(new H,b,h),l=O().c;return new A(k,l)}}if(d){var m=b.zg(e.Va);if(sr(new E(m),(t(),new M(!1)))){var n=ny(e),r=(Xb=>gc=>{var hc=new kB(b,Xb.Va,!0);return G(new H,hc,gc)})(e);if(n===v())var u=v();else{for(var w=n.e(),y=new A(r(w),v()),B=y,D=n.g();D!==v();){var C=D.e(),F=new A(r(C),v());B=B.r=F;D=D.g()}u=y}}else u=O().c;if(sr(new E(m),(t(),new M(!0)))){var I=Tz(e),K=(Xb=>gc=>{var hc=new kB(b,Xb.Va,
-!1);return G(new H,hc,gc)})(e);if(I===v())var N=v();else{for(var P=I.e(),T=new A(K(P),v()),aa=T,Y=I.g();Y!==v();){var S=Y.e(),Z=new A(K(S),v());aa=aa.r=Z;Y=Y.g()}N=T}}else N=O().c;return Fl(N,u)}if(a instanceof yu){var ka=a.Mb,X=a.Xb,sa=new nB(b),Ia=G(new H,sa,ka),Za=G(new H,b,X),Ga=O().c;return new A(Ia,new A(Za,Ga))}if(a instanceof Xu){var xa=a.Wh;if(xa===v())return v();for(var Ra=xa.e(),Ja=new A(G(new H,b,Ra),v()),La=Ja,pb=xa.g();pb!==v();){var Fb=pb.e(),Gb=new A(G(new H,b,Fb),v());La=La.r=Gb;
-pb=pb.g()}return Ja}if(a instanceof nA){var Hb=a.dc,tb=G(new H,b,a.cc),kb=G(new H,b,Hb),gb=O().c;return new A(tb,new A(kb,gb))}if(a instanceof dv){for(var Vb=a.Ba,bb=ap(),nb=Vb.Gb(bb.wa).j(),Tb=null,ub=null;nb!==v();){for(var Ub=nb.e(),$a=eD(b,Ub).m();$a.s();){var cb=new A($a.t(),v());null===ub?Tb=cb:ub.r=cb;ub=cb}nb=nb.g()}return null===Tb?v():Tb}if(a instanceof Ru){for(var Na=a.Ub,Ca=ap(),Ba=Na.Gb(Ca.wa).j(),Oa=null,wa=null;Ba!==v();){for(var ea=Ba.e(),la=eD(b,ea).m();la.s();){var Ka=new A(la.t(),
-v());null===wa?Oa=Ka:wa.r=Ka;wa=Ka}Ba=Ba.g()}return null===Oa?v():Oa}if(a instanceof fv)return eD(b,a.ld);if(a instanceof jv){for(var Ua=a.zn,ya=null,ib=null;Ua!==v();){var Lb=Ua.e();if(Lb instanceof te)var ec=G(new H,b,Lb.ca),Mb=O().c,Jb=new A(ec,Mb);else{if(!(Lb instanceof me))throw new x(Lb);Jb=eD(b,Lb.ia)}for(var Kb=Jb.m();Kb.s();){var eb=new A(Kb.t(),v());null===ib?ya=eb:ib.r=eb;ib=eb}Ua=Ua.g()}return null===ya?v():ya}if(a instanceof oA){var Wb=a.xc,mc=new nB(b),ua=G(new H,mc,Wb),Pa=O().c;return new A(ua,
-Pa)}if(a instanceof gA)return O().c;if(a instanceof sB){tB(a.p);t();var xb=a.gc(),Yb=new M(xb);if(!Yb.b()){var zb=G(new H,b,Yb.k),Sb=O().c;return new A(zb,Sb)}}if(qB(a)||a instanceof rB)return O().c;if(a instanceof Pw){var Ma=G(new H,b,a.Xh),Ea=O().c;return new A(Ma,Ea)}if(a instanceof uv)return uB(a,b,new Um((Xb,gc)=>G(new H,Xb,gc)),c);if(a instanceof gv){var ab=G(new H,b,a.Bc),Db=O().c;return new A(ab,Db)}if(a instanceof wB){var mb=a.vg,vb=a.Jf,Ya=xz(a.p).ru,Wa=G(new H,Ya,mb),rb=xz(a.p).Ej,pa=G(new H,
-rb,vb),Fa=O().c;return new A(Wa,new A(pa,Fa))}if(a instanceof px){var Ib=G(new H,b,a.ve),qb=O().c;return new A(Ib,qb)}if(a instanceof yB){for(var Nb=a.ej,fc=a.Aj,Ac=null,tc=null;fc!==v();){for(var vc=fc.e(),sc=xz(a.p).Ej,uc=G(new H,sc,vc.i()),lc=xz(a.p).nx,Wc=G(new H,lc,vc.j()),Cc=O().c,Dc=new lq(new A(uc,new A(Wc,Cc)));Dc.s();){var Ec=new A(Dc.t(),v());null===tc?Ac=Ec:tc.r=Ec;tc=Ec}fc=fc.g()}var Ic=null===Ac?v():Ac,Xc=G(new H,b,Nb),Sc=O().c;return Fl(new A(Xc,Sc),Ic)}if(a instanceof cA){dA(a.p);
-t();var oc=new M(a);if(!oc.b()){for(var qc=oc.k,Tc=qc.ok,Nc=null,Pc=null;Tc!==v();){var Oc=Tc.e();if(Oc instanceof Dw){var $c=Oc,Lc=$c.ik,Zb=(Xb=>gc=>{var hc=new mB(Xb);return G(new H,hc,gc.gb)})(b);if(Lc===v())var ed=v();else{for(var $b=Lc.e(),Fc=new A(Zb($b),v()),Yc=Fc,nc=Lc.g();nc!==v();){var Ob=nc.e(),cc=new A(Zb(Ob),v());Yc=Yc.r=cc;nc=nc.g()}ed=Fc}var Gc=G(new H,b,$c.Gl),Bc=O().c,qd=Fl(new A(Gc,Bc),ed)}else if(Oc instanceof Ew){var Gd=Oc,cd=xz(a.p).Ej,rd=G(new H,cd,Gd.Vh),Id=O().c;qd=new A(rd,
-Id)}else if(Oc instanceof Zv){var Ha=Oc,jc=Ha.$k.m(),Rb=new eg(jc,new z((Xb=>gc=>{var hc=new mB(Xb);return G(new H,hc,gc.gb)})(b)));qd=Cu(Rb,new U(((Xb,gc,hc)=>()=>{var gd=Xb.zj.Qd();return new ho(gd,new z(kc=>fD(a,kc,gc,hc)))})(Ha,b,c))).mb(new U(((Xb,gc)=>()=>{t();var hc=new nB(Xb);hc=G(new H,hc,gc.Xk);return new M(hc)})(b,Ha))).mb(new U(((Xb,gc)=>()=>{t();var hc=new nB(Xb);hc=G(new H,hc,gc.Zk);return new M(hc)})(b,Ha)))}else if(Oc instanceof Aw){var Uc=Oc,Rc=Uc.Zg.m(),Cd=new eg(Rc,new z((Xb=>gc=>
-{var hc=new mB(Xb);return G(new H,hc,gc.gb)})(b)));qd=Cu(Cd,new U((Xb=>()=>{for(var gc=Xb.yj.ea(),hc=null,gd=null;gc!==v();){for(var kc=gc.e(),ud=null,za=null;kc!==v();){var Qa=kc.e();for(Qa=eD(xz(a.p).Ej,Qa.j()).m();Qa.s();){var xc=new A(Qa.t(),v());null===za?ud=xc:za.r=xc;za=xc}kc=kc.g()}for(kc=(null===ud?v():ud).m();kc.s();)ud=new A(kc.t(),v()),null===gd?hc=ud:gd.r=ud,gd=ud;gc=gc.g()}return null===hc?v():hc})(Uc))).mb(new U((Xb=>()=>{for(var gc=Xb.Wk.ea(),hc=null,gd=null;gc!==v();){var kc=gc.e(),
-ud=yd=>{var be=xz(a.p).ru;return G(new H,be,yd.j())};if(kc===v())ud=v();else{var za=kc.e(),Qa=za=new A(ud(za),v());for(kc=kc.g();kc!==v();){var xc=kc.e();xc=new A(ud(xc),v());Qa=Qa.r=xc;kc=kc.g()}ud=za}for(ud=ud.m();ud.s();)za=new A(ud.t(),v()),null===gd?hc=za:gd.r=za,gd=za;gc=gc.g()}return null===hc?v():hc})(Uc))).mb(new U(((Xb,gc,hc)=>()=>{var gd=Xb.ui.Qd();return new ho(gd,new z(kc=>fD(a,kc,gc,hc)))})(Uc,b,c))).mb(new U(((Xb,gc)=>()=>{t();var hc=new nB(Xb);hc=G(new H,hc,gc.wm);return new M(hc)})(b,
-Uc))).mb(new U(((Xb,gc)=>()=>{t();var hc=G(new H,Xb,gc.jk);return new M(hc)})(b,Uc))).mb(new U(((Xb,gc,hc)=>()=>{var gd=Xb.vm.Qd();return new ho(gd,new z(kc=>fD(a,kc,gc,hc)))})(Uc,b,c)))}else if(Oc instanceof yw){var od=Oc,Va=od.nk.m(),wb=new eg(Va,new z((Xb=>gc=>{var hc=new mB(Xb);return G(new H,hc,gc.gb)})(b)));qd=Cu(wb,new U(((Xb,gc,hc)=>()=>{var gd=Xb.kk.Qd();return new ho(gd,new z(kc=>fD(a,kc,gc,hc)))})(od,b,c))).mb(new U(((Xb,gc)=>()=>{t();var hc=new nB(Xb);hc=G(new H,hc,gc.un);return new M(hc)})(b,
-od))).mb(new U(((Xb,gc)=>()=>{t();var hc=G(new H,Xb,gc.lk);return new M(hc)})(b,od))).mb(new U(((Xb,gc,hc)=>()=>{var gd=Xb.xm.Qd();return new ho(gd,new z(kc=>fD(a,kc,gc,hc)))})(od,b,c)))}else if(Oc instanceof xw)qd=eD(b,Oc.cg);else{if(!(Oc instanceof Fw))throw new x(Oc);qd=t().f}for(var db=qd.m();db.s();){var Jc=new A(db.t(),v());null===Pc?Nc=Jc:Pc.r=Jc;Pc=Jc}Tc=Tc.g()}var Vc=null===Nc?v():Nc,Ta=qc.Jl.ea();if(Ta===v())var kd=v();else{for(var ld=Ta.e(),qe=new A(G(new H,b,ld),v()),Wd=qe,Rd=Ta.g();Rd!==
-v();){var Me=Rd.e(),wc=new A(G(new H,b,Me),v());Wd=Wd.r=wc;Rd=Rd.g()}kd=qe}return Fl(kd,Vc)}}throw new x(a);}function yz(a,b,c){var d=ru().U(),e=Lz().U();oba(a,b,!1,a.p.tf,a,!1,d,e,c);a=mu();b=ap().wa;a=new ou(a,b);return bv(Ku(),d,a)}
-var pba=function gD(a,b){if(b instanceof Ew){var d=b.Vh,e=O().c;return new A(d,e)}if(b instanceof Dw)return d=b.ik.m(),d=new eg(d,new z(h=>h.gb)),Cu(d,new U(()=>{t();return new M(b.Gl)}));if(b instanceof Zv)return d=b.$k.m(),d=new eg(d,new z(h=>h.gb)),Cu(d,new U(()=>{var h=b.zj.Qd();return new ho(h,new z(k=>gD(a,k)))})).mb(new U(()=>{t();return new M(b.Xk)})).mb(new U(()=>{t();return new M(b.Zk)}));if(b instanceof Aw)return d=b.Zg.m(),d=new eg(d,new z(h=>h.gb)),Cu(d,new U(()=>{for(var h=b.yj.ea(),
-k=null,l=null;h!==v();){for(var m=h.e(),n=null,r=null;m!==v();){var u=m.e(),w=u.j().Ma.ea();u=u.j().oa;var y=O().c;for(w=Fl(new A(u,y),w).m();w.s();)u=new A(w.t(),v()),null===r?n=u:r.r=u,r=u;m=m.g()}for(m=(null===n?v():n).m();m.s();)n=new A(m.t(),v()),null===l?k=n:l.r=n,l=n;h=h.g()}return null===k?v():k})).mb(new U(()=>{for(var h=b.Wk.ea(),k=null,l=null;h!==v();){var m=h.e();for(m=Eu(Du(),m);m.s();){var n=new A(m.t(),v());null===l?k=n:l.r=n;l=n}h=h.g()}return null===k?v():k})).mb(new U(()=>{var h=
-b.ui.Qd();return new ho(h,new z(k=>gD(a,k)))})).mb(new U(()=>{t();return new M(b.wm)})).mb(new U(()=>{t();return new M(b.jk)}));if(b instanceof yw)return d=b.nk.m(),d=new eg(d,new z(h=>h.gb)),Cu(d,new U(()=>{var h=b.kk.Qd();return new ho(h,new z(k=>gD(a,k)))})).mb(new U(()=>{t();return new M(b.un)})).mb(new U(()=>{t();return new M(b.lk)})).mb(new U(()=>{var h=b.xm.Qd();return new ho(h,new z(k=>gD(a,k)))}));if(b instanceof xw){d=b.cg.Ma.ea();e=b.cg.oa;var g=O().c;return Fl(new A(e,g),d)}if(b instanceof
-Fw)return O().c;throw new x(b);};
-function YC(a,b){var c=!1,d=null;if(a instanceof Ow){c=!0;d=a;DB(a.p);var e=d.Wb;if(!e.b())return a=e.o(),b?(b=O().c,new A(a,b)):O().c}if(c)return b?(a=ny(d),Fl(Tz(d),a)):O().c;if(a instanceof yu)return b=a.Mb,a=a.Xb,d=O().c,new A(b,new A(a,d));if(a instanceof Xu)return a.Wh;if(a instanceof nA)return b=a.cc,a=a.dc,d=O().c,new A(b,new A(a,d));if(a instanceof dv){a=a.Ba;for(d=b=null;a!==v();){e=a.e();c=e.j().Ma.ea();e=e.j().oa;var g=O().c;for(c=Fl(new A(e,g),c).m();c.s();)e=new A(c.t(),v()),null===
-d?b=e:d.r=e,d=e;a=a.g()}return null===b?v():b}if(a instanceof Ru){a=a.Ub;for(d=b=null;a!==v();){e=a.e();c=e.j().Ma.ea();e=e.j().oa;g=O().c;for(c=Fl(new A(e,g),c).m();c.s();)e=new A(c.t(),v()),null===d?b=e:d.r=e,d=e;a=a.g()}return null===b?v():b}if(a instanceof fv)return b=a.ld,a=b.Ma.ea(),b=b.oa,d=O().c,mn(a,new A(b,d));if(a instanceof oA)return a=a.xc,b=O().c,new A(a,b);if(a instanceof gA)return O().c;if(a instanceof sB&&(tB(a.p),t(),b=a.gc(),b=new M(b),!b.b()))return a=b.k,b=O().c,new A(a,b);if(qB(a)||
-a instanceof rB)return O().c;if(a instanceof Pw)return a=a.Xh,b=O().c,new A(a,b);if(a instanceof uv)return a.Vb;if(a instanceof gv)return a=a.Bc,b=O().c,new A(a,b);if(a instanceof wB)return b=a.vg,a=a.Jf,d=O().c,new A(b,new A(a,d));if(a instanceof px)return a=a.ve,b=O().c,new A(a,b);if(a instanceof yB){b=a.ej;a=a.Aj;for(c=d=null;a!==v();){g=a.e();e=g.i();g=g.j();var h=O().c;for(e=new lq(new A(e,new A(g,h)));e.s();)g=new A(e.t(),v()),null===c?d=g:c.r=g,c=g;a=a.g()}a=null===d?v():d;d=O().c;return Fl(new A(b,
-d),a)}if(a instanceof jv){a=a.zn;for(d=b=null;a!==v();){c=a.e();if(c instanceof te)c=c.ca,e=O().c,c=new A(c,e);else{if(!(c instanceof me))throw new x(c);e=c.ia;c=e.Ma.ea();e=e.oa;g=O().c;c=Fl(new A(e,g),c)}for(c=c.m();c.s();)e=new A(c.t(),v()),null===d?b=e:d.r=e,d=e;a=a.g()}return null===b?v():b}if(a instanceof cA&&(dA(a.p),t(),b=new M(a),!b.b())){b=b.k;d=b.ok;for(e=c=null;d!==v();){g=d.e();for(g=pba(a,g).m();g.s();)h=new A(g.t(),v()),null===e?c=h:e.r=h,e=h;d=d.g()}a=null===c?v():c;return Fl(b.Jl.ea(),
-a)}throw new x(a);}function Zz(a,b){var c=Lz().U(),d=O().c;qba(new A(a,d),c,b);a=Mu();O();b=new z(e=>e.Jo);d=dq();return Rz(a,c,new hD(d,b))}
-function Yw(a){var b=Zz(a,!0).m();b=new Gx(b,new z(c=>{if(c.Wb.b()){var d=Tz(c);c=ny(c);return!mn(d,c).b()}return!0}),!1);b=new eg(b,new z(c=>{if(null!==c){DB(a.p);var d=c.Wb;if(!d.b())return d=d.o(),"\n\t\t"+c.u()+" :\x3d "+d}d=c.u();if(ny(c).b())var e="";else e=ny(c),e=" :\x3e "+Qe(e,""," | ","");Tz(c).b()?c="":(c=Tz(c),c=" \x3c: "+Qe(c,""," \x26 ",""));return"\n\t\t"+d+e+c}));return Qe(b,"","","")}
-function eD(a,b){var c=b.Ma;if(c.b())c=R();else{c=c.o();var d=new nB(a);c=new M(G(new H,d,c))}c=c.ea();a=G(new H,a,b.oa);b=O().c;return Fl(new A(a,b),c)}function fD(a,b,c,d){if(b instanceof xw)return c=b.cg,eD(xz(a.p).Ej,c);if(b instanceof Ew)return c=G(new H,c,b.Vh),d=O().c,new A(c,d);if(b&&b.$classData&&b.$classData.pb.ms){a=a.p;var e=O().c;b=new Tx(a,new A(b,e),t().f);return dD(b,c,d)}throw new x(b);}
-var oba=function iD(a,b,c,d,e,g,h,k,l){for(;;){if(e instanceof Ow){if(g&&e.Va>d){g=a.p;g.D&&(g=Hs(Q(),"| ",g.q)+"Quantified! "+e,Af(Bf(),g+"\n"));break}var n=b.zg(e.Va);c||h.Gt(e,new z((y=>B=>{if(B instanceof M&&sr(new E(B.k),y))return t(),B=t().f,new M(B);t();return new M(y)})(n)));if(n instanceof M){n=!!n.k;var r=G(new H,e,n);k.L(r)?n=!1:(n=G(new H,e,n),k.S(n),n=!0)}else{if(t().f!==n)throw new x(n);n=G(new H,e,!0);k.L(n)?(n=G(new H,e,!1),n=k.L(n)):n=!1;n?n=!1:(n=G(new H,e,!0),k.S(n),n=G(new H,e,
-!1),k.S(n),n=!0)}if(n)for(b=dD(e,b,l);!b.b();)e=b.e(),iD(a,e.i(),c,d,e.j(),g,h,k,l),b=b.g()}else{if(e instanceof sB&&(n=e,tB(a.p),t(),n=n.gc(),n=new M(n),!n.b())){e=n.k;continue}if(e instanceof Xu)for(e=e.Wh;!e.b();)n=e.e(),iD(a,b,c,d,n,g,h,k,l),e=e.g();else{if(e instanceof oA){e=e.xc;b=new nB(b);continue}if(e instanceof gv){e=e.Bc;continue}if(e instanceof wB){b=e.vg;e=e.Jf;iD(a,xz(a.p).ru,c,d,b,g,h,k,l);b=a;n=xz(a.p).Ej;a=b;b=n;continue}if(e instanceof yB){var u=e;e=u.ej;n=a;r=d;for(u=u.Aj;!u.b();){var w=
-u.e();iD(n,xz(n.p).Ej,!1,r,w.i(),g,h,k,l);iD(n,xz(n.p).nx,!1,r,w.j(),g,h,k,l);u=u.g()}continue}if(e instanceof nA){n=e.dc;iD(a,b,c,d,e.cc,g,h,k,l);e=n;continue}if(e instanceof px){b=new xB(b,e.Ld);n=e.Ld;d=d<n?d:n;e=e.ve;continue}b=dD(e,b,l);c=a;for(a=b;!a.b();)b=a.e(),iD(c,b.i(),!1,d,b.j(),g,h,k,l),a=a.g()}}break}};
-function qba(a,b,c){for(;;){var d=!1,e=null,g=a;if(g instanceof A){d=!0;e=g;var h=e.A;a=e.r;if(h instanceof Ow){e=h;b.L(e)||(b.S(e),e=YC(e,c),a=Fl(a,e));continue}}if(d){a=e.r;e=YC(e.A,c);a=Fl(a,e);continue}b=O().c;if(null===b?null!==g:!b.h(g))throw new x(g);break}}function rA(a,b){a=b.fb.Y(a.ob.X);if(a.b())return!0;a=a.o();return vy(a.lu)?!0:!a.yn.b()}
-function xC(a,b,c){var d=b.fb.Y(a.ob.X);if(d instanceof M){if(d=d.k,!vy(d.lu)&&(jx(d,c),d.yn.b()))return Wx(a.p)}else if(t().f!==d)throw new x(d);return HA(a,!0,!0,b)}function sA(a,b){Os(fp(),rA(a,b));return HA(a,!0,!0,b)}
-function HA(a,b,c,d){var e=d.fb.Y(a.ob.X);if(e.b())e=R();else{e=e.o();var g=new xf,h=!1,k=null,l=e.yn;a:{if(l instanceof M&&(h=!0,k=l,l=k.k,l instanceof Dw)){fp();e=l.ik.K();gp(0,hf(new E(e),a.Vb.K()));e=a.p;g=l.Gl;c=l.ik;c=new vq(c,c,a.Vb);l=new Um((m,n)=>{m=new Pw(a.p,m.gb,V(a.p));return G(new H,m,n)});xq();c=Rv(c,l);ap();e=lC(e,g,c.Li(),!1,d);break a}if(h&&(l=k.k,l instanceof yw)){fp();h=l.nk.K();gp(0,hf(new E(h),a.Vb.K()));h=a.p;k=new Wl(l.mk.eb.X);k=aq(k,a.Ml.Ia);t();h=ix(h,l,k,new M(a.Vb),d);
-if(null===h)throw new x(h);h=h.i();c=c?(dw(a.p),l.lk.Dc(l.cq,!1,d,h)):a.p.Na;l=ux(a.p,l.mk,V(a.p),d);h=V(c.p);c=ju(c,l,h,!1);e=g.qb?g.sb:jD(a,g,e);g=V(c.p);e=ju(c,e,g,!1);break a}if(h&&(l=k.k,l instanceof Aw)){fp();h=l.Zg.K();gp(0,hf(new E(h),a.Vb.K()));h=a.p;k=new Wl(l.Gf.eb.X);k=aq(k,a.Ml.Ia);t();h=ix(h,l,k,new M(a.Vb),d);if(null===h)throw new x(h);h=h.i();c=c?(dw(a.p),l.jk.Dc(l.um,!1,d,h)):a.p.Na;l=ty(a.p,l.Gf,V(a.p),d);h=V(l.p);c=ju(l,c,h,!1);e=g.qb?g.sb:jD(a,g,e);g=V(c.p);e=ju(c,e,g,!1);break a}l=
-!1;c=null;h=e.Kb;if(h instanceof io&&(l=!0,c=h,rba(c.nb))){fp();l=c.bg.K();gp(0,hf(new E(l),a.Vb.K()));c=ty(a.p,c,V(a.p),d);e=g.qb?g.sb:jD(a,g,e);g=V(c.p);e=ju(c,e,g,!1);break a}l&&et(new E(c.nb),tp())?(fp(),l=c.bg.K(),gp(0,hf(new E(l),a.Vb.K())),c=ux(a.p,c,V(a.p),d),e=g.qb?g.sb:jD(a,g,e),g=V(c.p),e=ju(c,e,g,!1)):(l&&et(new E(c.nb),np())&&Dn("cannot expand unforced type alias"),e=Wx(a.p))}e=new M(e)}if(e.b()){c=new xf;g=d.vb.n(a.ob.X);fp();e=a.Vb.K();Os(0,hf(new E(e),g.zm.K()));e=a.p;l=g.dj;if(np()===
-l)b=g.fx;else{if(mp()===l)throw kD("Namespaces are not supported yet.");if(pp()===l)l=LC(a.p,g,a.Ml,d),h=g.fx,k=V(l.p),l=ju(l,h,k,!1),b=c.qb?c.sb:lD(a,c,b,g),c=V(l.p),b=ju(l,b,c,!1);else{if(tp()!==l)throw Qo()===l&&Dn("mixins cannot be used as types"),new x(l);l=mD(a.p,g,a.Ml);h=g.fx;k=V(l.p);l=ju(l,h,k,!1);b=c.qb?c.sb:lD(a,c,b,g);c=V(l.p);b=ju(l,b,c,!1)}}g=g.EN;g=new nD(new vq(g,g,a.Vb));ap();d=lC(e,b,bp(cp(),g),!1,d)}else d=e.o();return d}
-function sba(a,b){a=b.fb.Y(a.ob.X);return a instanceof M?(a=a.k.Kb,a instanceof io&&a.rm.b()?!a.xj.b():!0):!0}
-function vv(a,b){var c=a.qI;if(c.b()){c=!1;var d=null,e=b.vb.Y(a.ob.X);a:{if(e instanceof M&&(c=!0,d=e,e=d.k,null!==e&&(et(new E(e.dj),pp())||et(new E(e.dj),mp())))){t();b=LC(a.p,e,V(a.p),b);b=new M(b);break a}if(c&&(c=d.k,null!==c&&et(new E(c.dj),tp()))){b=t().f;break a}c=b.fb.Y(a.ob.X);if(c instanceof M&&(c=c.k.Kb,c instanceof io&&(et(new E(c.nb),pp())||et(new E(c.nb),mp())))){t();b=ty(a.p,c,V(a.p),b);b=new M(b);break a}b=t().f}a.qI=(t(),new M(b));a=b}else a=c.o();return a}
-function qv(a,b,c,d){var e=d.vb.Y(a.ob.X);if(e instanceof M)e=e.k,d=e.iu,e=e.zm;else{if(t().f!==e)throw new x(e);e=d.fb.n(a.ob.X);d=t().f;var g=e.pg();if(g===v())e=v();else{e=g.e();var h=e=new A(G(new H,e.ec,e.gb),v());for(g=g.g();g!==v();){var k=g.e();k=new A(G(new H,k.ec,k.gb),v());h=h.r=k;g=g.g()}}}if(d.b()){g=a.Vb;d=m=>c.aa(t().f,m);if(g===v())return v();e=g.e();h=e=new A(d(e),v());for(g=g.g();g!==v();)k=g.e(),k=new A(d(k),v()),h=h.r=k,g=g.g();return e}var l=d.o();fp();d=pv(e,a.Vb);gp(0,hf(new E(d),
-0));d=new vq(e,e,a.Vb);e=new Um((m,n)=>{n=G(new H,m,n);var r=n.z;m=n.x;if(null!==r){n=l.n(r.j());if(null!==n&&(r=n.Vd,!0===n.wd&&!0===r))return m=t().f,c.aa(m,new wB(a.p,a.p.tb,a.p.Na,V(a.p)));if(null!==n)return r=n.Vd,n.wd?n=b:r?b.b()?n=R():(n=!!b.o(),n=new M(!n)):n=t().f,c.aa(n,m);throw new x(n);}throw new x(n);});xq();return Rv(d,e)}
-function uB(a,b,c,d){var e=id();try{var g=d.vb.Y(a.ob.X);if(g instanceof M)var h=g.k,k=h.iu,l=h.zm;else{if(t().f!==g)throw new x(g);var m=d.fb.yd(a.ob.X,new U(()=>{throw fq(new gq,e,O().c);})),n=bt().n(oD(m)),r=m.pg();if(r===v())var u=v();else{var w=r.e(),y=new A(G(new H,w.ec,w.gb),v());d=y;for(var B=r.g();B!==v();){var D=B.e(),C=new A(G(new H,D.ec,D.gb),v());d=d.r=C;B=B.g()}u=y}k=n;l=u}if(k.b()){var F=a.Vb,I=ka=>c.aa(new mB(b),ka);if(F===v())return v();var K=F.e(),N=new A(I(K),v());K=N;for(var P=
-F.g();P!==v();){var T=P.e(),aa=new A(I(T),v());K=K.r=aa;P=P.g()}return N}var Y=k.o();fp();I=pv(l,a.Vb);gp(0,hf(new E(I),0));var S=new vq(l,l,a.Vb),Z=new Um((ka,X)=>{X=G(new H,ka,X);var sa=X.z;ka=X.x;if(null!==sa){X=Y.n(sa.j());if(null!==X&&(sa=X.Vd,!0===X.wd&&!0===sa))return ka=new mB(b),c.aa(ka,new wB(a.p,a.p.tb,a.p.Na,V(a.p)));if(null!==X)return sa=X.Vd,c.aa(X.wd?b:sa?new nB(b):new mB(b),ka);throw new x(X);}throw new x(X);});xq();return Rv(S,Z)}catch(ka){if(ka instanceof gq){F=ka;if(F.Hg===e)return F.wj();
-throw F;}throw ka;}}function jD(a,b,c){if(null===b)throw ze();if(b.qb)return b.sb;var d=a.p;c=c.pg();c=new vq(c,c,a.Vb);var e=new Um((g,h)=>{var k=G(new H,g,h);h=k.z;g=k.x;if(null!==h){k=h.ec;h=h.xd;var l=new Wl(a.ob.X+"#"+k.X);k=k.C();k=aq(l,k);l=pD(a.p);h=h.b()?Tt().En:h.o();g=qD(l,h,g,g,V(a.p));return G(new H,k,g)}throw new x(k);});xq();c=Rv(c,e);return Ce(b,new dv(d,c,V(a.p)))}
-function lD(a,b,c,d){if(null===b)throw ze();if(b.qb)return b.sb;if(c){c=Pu(a.p);var e=d.zm,g=m=>{if(null!==m){var n=m.i();m=m.j();var r=EA(d);n=new Wl(a.ob.X+"#"+n.X);m=new ww(a.p,new M(r.n(m).wd?a.p.tb:m),r.n(m).Vd?a.p.Na:m,a.Ml);return G(new H,n,m)}throw new x(m);};if(e===v())g=v();else{var h=e.e(),k=h=new A(g(h),v());for(e=e.g();e!==v();){var l=e.e();l=new A(g(l),v());k=k.r=l;e=e.g()}g=h}c=uA(c,g,V(a.p))}else c=a.p.Na;return Ce(b,c)}
-function rD(a){var b=!1,c=pz(Q(),a.w);if(c instanceof M&&(b=!0,48===Eb(c.k)))return hf(new E(a.w.length),1);if(b){a=a.w;b=0;for(c=a.length;b<c;){var d=a.charCodeAt(b),e=$q();if(!(256>d?48<=d&&57>=d:9===sD(e,d)))return!1;b=1+b|0}return!0}if(t().f===c)return!1;throw new x(c);}function OA(a){return rD(a)?(a=a.w,tD(uD(),a)):t().f}
-function Taa(a){var b=cu(Q(),a.w);Zq($q(),b)?(b=cu(Q(),a.w),b=vD($q(),b)):b=!1;b?b=!0:(b=cu(Q(),a.w),b=hf(new E(hd(b)),hd(95)));b?b=!0:(b=cu(Q(),a.w),b=hf(new E(hd(b)),hd(36)));return b&&sr(new E(a.w),"true")?sr(new E(a.w),"false"):!1}function wD(a){a.fK(rn(a.Lu()))}var uba=function tba(a,b){if(a.Yo.L(b))return!0;a=a.HI;if(a.b())return!1;a=a.o();return tba(a,b)};
-function xD(a,b){var c=id();try{if(""===b)return a.GI.t();yD();var d=String.fromCharCode(39),e=String.fromCharCode(36),g=b.split(d).join(e);if(a.Yo.L(g)?0:!Tp().RE.L(g))return g;for(b=1;;){d=""+g+b;if(!a.Yo.L(d))throw fq(new gq,c,d);if(2147483647===b)break;b=1+b|0}throw new Am(""===g?"Cannot allocate a runtime name":"Cannot allocate a runtime name starting with '"+g+"'");}catch(h){if(h instanceof gq){a=h;if(a.Hg===c)return a.wj();throw a;}throw h;}}
-function jo(a,b,c,d){var e=!1,g=null,h=a.vx.Y(b);a:{if(h instanceof M){e=!0;g=h;var k=g.k;if(k instanceof Wn&&k.AP){b=new Un(b,k.Ze,!1,c,!0);break a}}if(e)b=new Un(b,g.k.ep(),!0,c,!0);else if(t().f===h)b=new Un(b,xD(a,b),!1,c,!0);else throw new x(h);}hp(a,b);d.b()||(d=d.o(),hp(a,new Un(d,b.Hs,!1,c,!0)));return b}
-function zD(a,b){a.HI=b;ky();b=v();a.Fn=ly(b);ky();b=v();a.vx=ly(b);Hy();b=v();a.Yo=Iy(b);ky();b=v();a.rA=ly(b);a.Gn=new AD;a.GI=new ho(new BD(1,1,2147483647,!1),new z(c=>{c|=0;var d=yD().zP;c=vba(d,c);c=new eg(c,new z(e=>{var g=Qe(e,"","","");return G(new H,e,g)}));c=new Gx(c,new z(e=>{if(null!==e)return!uba(a,e.j());throw new x(e);}),!1);return new eg(c,new z(e=>{if(null!==e)return e.j();throw new x(e);}))}));return a}function CD(){this.GI=this.Gn=this.rA=this.Yo=this.vx=this.Fn=this.HI=null}
-CD.prototype=new p;CD.prototype.constructor=CD;function lp(a,b){a.Fn.Vi(b.Sn(),b);a.vx.Vi(b.Sn(),b);a.Yo.eh(b.ep())}function hp(a,b){a.vx.Vi(b.Sn(),b);a.Yo.eh(b.ep())}function Xm(a,b){var c=a.vx.Y(b);return c.b()?(a=a.HI,a.b()?R():Xm(a.o(),b)):c}function up(a,b,c,d,e){var g=xD(a,b);b=new an(b,g,c,d,e);lp(a,b);return b}function op(a,b,c,d){b=new bn(b,c,d);a.Fn.Vi(b.tq,b)}
-function gn(a,b,c,d,e){var g=!1,h=null,k=a.vx.Y(b);a:{if(k instanceof M&&(g=!0,h=k,k=h.k,k instanceof Un&&!k.tA)){g=k.Hs;break a}if(g&&(k=h.k,k instanceof Wn&&k.AP)){g=k.Ze;break a}if(g&&(g=h.k,g instanceof Sn&&!g.mP)){g=g.CE;break a}g=xD(a,b)}b=new Wn(b,g,c,d,!1);hp(a,b);e.b()||(e=e.o(),hp(a,new Wn(e,g,c,d,!1)));return b}function Zo(a,b){b=xD(a,b);t();b=new Wn("this",b,new M(!1),!1,!1);cy(a.rA,b.Ze,b,!1);hp(a,b);return b.Ze}
-function Fm(a,b){var c=a.rA;a=()=>{throw new Am("qualifier "+b+" not found");};if(ja(c)!==ma(by))if(c=c.Y(b),c instanceof M)a=c.k;else{if(R()!==c)throw new x(c);a=a()}else{var d=dy(W(),b);d^=d>>>16|0;c=c.cb.a[d&(-1+c.cb.a.length|0)];c=null===c?null:ey(c,b,d);a=null===c?a():c.ph}return a}function Co(a){var b=a.GI.t();a.Yo.eh(b);return b}function Ko(a,b){b=xD(a,b);a.Yo.eh(b);return b}
-function Xl(a,b){if(Qp(cm(),b))var c=b;else if(Tp().RE.L(b))c=b+"$";else{yD();c=String.fromCharCode(39);var d=String.fromCharCode(36);c=b.split(c).join(d)}c=xD(a,c);hp(a,new Wn(b,c,new M(!1),!1,!1));return c}function ao(a){var b=zD(new CD,(t(),new M(a)));a=a.rA;for(var c=a.cb.a.length,d=0;d<c;){var e=a.cb.a[d];if(null!==e)for(;;){var g=e.Kk,h=e.ph;b.Yo.eh(g);cy(b.rA,g,h,!1);if(null!==e.Id)e=e.Id;else break}d=1+d|0}return b}CD.prototype.$classData=q({PZ:0},!1,"mlscript.codegen.Scope",{PZ:1,d:1});
-function DD(){this.zP=null;ED=this;t();fp();var a=new Uq("abcdefghijklmnopqrstuvwxyz");this.zP=le(v(),a)}DD.prototype=new p;DD.prototype.constructor=DD;DD.prototype.$classData=q({QZ:0},!1,"mlscript.codegen.Scope$",{QZ:1,d:1});var ED;function yD(){ED||(ED=new DD);return ED}
-function FD(){this.RE=null;GD=this;this.RE=Zp(fp().gv,J(new L,"break case catch class const continue debugger default delete do else export extends finally for function if import in instanceof new return super switch this throw try typeof var void while with yield enum abstract boolean byte char double final float goto int long native short synchronized throws transient volatile".split(" ")))}FD.prototype=new p;FD.prototype.constructor=FD;
-FD.prototype.$classData=q({TZ:0},!1,"mlscript.codegen.Symbol$",{TZ:1,d:1});var GD;function Tp(){GD||(GD=new FD);return GD}function HD(){this.BP="??"}HD.prototype=new p;HD.prototype.constructor=HD;HD.prototype.$classData=q({ZZ:0},!1,"mlscript.package$",{ZZ:1,d:1});var ID;function JD(){ID||(ID=new HD);return ID}function KD(a){a.$e=O().c}function LD(){this.$e=null}LD.prototype=new p;LD.prototype.constructor=LD;function MD(){}MD.prototype=LD.prototype;
-function ND(a){if(a.$e.b())return"";var b=a.$e;a=O().c;if(null===a?null===b:a.h(b))a="";else{if(b===v())a=v();else{a=b.e();var c=a=new A(a.Hj.w,v());for(b=b.g();b!==v();){var d=b.e();d=new A(d.Hj.w,v());c=c.r=d;b=b.g()}}a=Qe(a,"(",", ",")")}return" with "+a}var xba=function wba(a,b,c,d){return c.L(b)?c:d.yd(b,new U(()=>v())).ge(c.Yb(b),new Um((g,h)=>wba(a,h,g,d)))};function OD(){}OD.prototype=new p;OD.prototype.constructor=OD;
-function yba(a,b){a=b.m();a=new ho(a,new z(e=>{if(null!==e){var g=e.i();e=e.j().m();return new eg(e,new z(h=>G(new H,h,g)))}throw new x(e);}));for(b=Jf();a.s();){var c=a.t();b=G(new H,b,c);a:{c=b.z;var d=b.x;if(null!==d&&(d=new M(d),!d.b())){b=c.kC(d.k.i(),new z((e=>g=>{if(R()===g)return g=O().c,new M(new A(e,g));if(g instanceof M)return new M(new A(e,g.k));throw new x(g);})(d.k.j())));break a}throw new x(b);}}return b}
-function zba(a,b){var c=b.Pq().Ga(new z(d=>{fp();var e=v();e=xba(a,d,Zp(0,e),b).tk(d);je();e=le(v(),e);return G(new H,d,e)}));ap();return c.Li()}function PD(a,b,c,d,e){c.n(new U(()=>"\u2022 "+d));b.b()?c.n(new U(()=>"  + \x3cEmpty\x3e")):b.Ag(new Um((g,h)=>{c.n(new U(()=>"  + "+g+" "+e+" "+(h.b()?"{}":Qe(h,"{ ",", "," }"))))}))}OD.prototype.$classData=q({j_:0},!1,"mlscript.ucs.Desugarer$",{j_:1,d:1});var QD;function RD(){QD||(QD=new OD);return QD}function SD(){}SD.prototype=new p;
-SD.prototype.constructor=SD;function TD(){}TD.prototype=SD.prototype;function UD(a,b){if(null===a)throw ze();if(a.qb)return a.sb;b=b.bi.m();b=new eg(b,new z(c=>{if(null!==c){var d=c.Hj,e=c.vq;if(null!==d)return"[binding "+d.w+" \x3d "+rz(e,!1)+"]"}throw new x(c);}));je();return Ce(a,le(v(),b))}
-var Aba=function VD(a,b,c,d){for(;;){var g=new xf,h=Hs(Q(),"  ",c),k=b;if(k instanceof WD){var l=k,m=l.wq;k=l.rk;l=l.uh;for(b=g.qb?g.sb:UD(g,b);!b.b();)g=b.e(),d.S(""+h+g),b=b.g();b=h+("if \u00ab"+rz(m,!1))+"\u00bb";d.S(b);VD(a,k,1+c|0,d);d.S(h+"else");h=1+c|0;b=l;c=h}else{if(k instanceof XD){l=k;k=l.Hn;m=l.ch;l=l.ij;for(b=g.qb?g.sb:UD(g,b);!b.b();)g=b.e(),d.S(""+h+g),b=b.g();b=""+h;var n=k;g=rz(n.dh,!1);n=n.In;a:if(t().f===n)n="";else{if(n instanceof M){var r=n.k;if(null!==r){n=" as "+r.w;break a}}throw new x(n);
-}d.S(b+("\u00ab"+g+"\u00bb"+n)+" match");b=c;for(m=m.m();m.s();)a:if(n=m.t(),n instanceof YD)g=n.Zo,n=h+"  case "+rz(n.xq,!1)+" \x3d\x3e",d.S(n),VD(a,g,1+b|0,d);else{if(n instanceof ZD&&(g=n,r=g.Ij,g=g.dl,null!==r)){var u=new M(r);if(!u.b()&&(r=u.k.i(),u=u.k.j(),null!==r)){d.S(h+"  case "+r.w+" \x3d\x3e");for(n=u.m();n.s();)b:{if(u=n.t(),null!==u){r=u.i();var w=u.j();if(null!==w){u=w.w;w=$D(k);r=h+"    [pattern "+u+" \x3d "+rz(w,!1)+"."+r+"]";d.S(r);break b}}throw new x(u);}VD(a,g,2+b|0,d);break a}}throw new x(n);
-}l.b()||(k=l.o(),d.S(h+"  default"),VD(a,k,2+c|0,d))}else if(k instanceof aE){a=k.Is;for(c=g.qb?g.sb:UD(g,b);!c.b();)k=c.e(),d.S(""+h+k),c=c.g();h=h+"\u00ab"+rz(a,!1)+"\u00bb";d.S(h)}else if(bE()===k){for(a=g.qb?g.sb:UD(g,b);!a.b();)c=a.e(),d.S(""+h+c),a=a.g();d.S(h+"\x3cmissing case\x3e")}else throw new x(k);break}}};
-function cE(a,b){if(null===a)throw ze();if(a.qb)return a.sb;b=b.$e;if(b.b())b=je().LB;else{je();var c=new Wo;je();for(var d=new Wo,e=b.m();e.s();){var g=e.t(),h=g;a:{if(null!==h){var k=h.uq;if(dE()===k){h=!1;break a}}if(null!==h)h=!0;else throw new x(h);}ip(h?c:d,g)}c=G(new H,c.ea(),d.ea());d=c.z;v().h(d)?b=G(new H,v(),b):(d=c.x,b=v().h(d)?G(new H,b,v()):c)}if(null===b)throw new x(b);return Ce(a,G(new H,b.i(),b.j()))}
-function eE(a,b,c){if(a.qb)a=a.sb;else{if(null===a)throw ze();a=a.qb?a.sb:Ce(a,(b.qb?b.sb:cE(b,c)).i())}return a}function fE(a,b,c){if(a.qb)a=a.sb;else{if(null===a)throw ze();a=a.qb?a.sb:Ce(a,(b.qb?b.sb:cE(b,c)).j())}return a}
-var KE=function Bba(a,b,c){if(null!==b){var e=b.Pi,g=b.hj;if(e instanceof A){b=e.A;var h=new xf,k=new xf,l=new xf;c=Bba(a,new gE(e.r,g),c);if(b instanceof hE)return a=b.Ex,g=b.Dx,e=iE(),l=fE(l,h,b),l=new YD(g,jE(c,l)),c=g.C(),l.Js.oc(c),l=kE(e,J(new L,[l])),l=new XD(a,l,t().f),b=eE(k,h,b),jE(l,b);if(b instanceof lE)return a=b.Ax,e=mE(iE()),t(),l=fE(l,h,b),l=jE(c,l),l=new XD(a,e,new M(l)),b=eE(k,h,b),jE(l,b);if(b instanceof nE){a=b.Cx;g=b.Bx;var m=b.yA;e=iE();m=iE().jl(m);g=G(new H,g,m);l=fE(l,h,b);
-l=[oE(new ZD(g,jE(c,l)),b.av())];l=kE(e,J(new L,l));l=new XD(a,l,t().f);b=eE(k,h,b);return jE(l,b)}if(b instanceof DE)return a=b.Cu,m=b.Bu,g=b.Fx,e=iE(),m=new Wl("Tuple#"+m),g=iE().jl(g),g=G(new H,m,g),l=fE(l,h,b),l=[oE(new ZD(g,jE(c,l)),b.av())],l=kE(e,J(new L,l)),l=new XD(a,l,t().f),b=eE(k,h,b),jE(l,b);if(b instanceof EE)return c=new WD(b.zx,c,bE()),k=eE(k,h,b),k=jE(c,k),b=fE(l,h,b),jE(k,b);if(b instanceof FE)return a=b.zu,e=b.Au,b.yx?(GE||(GE=new HE),g=GE):g=IE(),k=eE(k,h,b),k=jE(c,k),c=new JE(g,
-!1,a,e),a=O().c,k=jE(k,new A(c,a)),b=fE(l,h,b),jE(k,b);throw new x(b);}}if(null!==b&&(k=b.Pi,h=b.hj,l=O().c,null===l?null===k:l.h(k)))return b=new aE(c),jE(b,h);throw new x(b);};function LE(){}LE.prototype=new p;LE.prototype.constructor=LE;function ME(a,b){var c=mE(iE());Aba(a,b,0,c);return c.ea()}LE.prototype.$classData=q({p_:0},!1,"mlscript.ucs.MutCaseOf$",{p_:1,d:1});var NE;function OE(){NE||(NE=new LE);return NE}function PE(){this.Js=null}PE.prototype=new p;PE.prototype.constructor=PE;
-function QE(){}QE.prototype=PE.prototype;function oE(a,b){a.Js.oc(b);return a}function RE(){}RE.prototype=new p;RE.prototype.constructor=RE;function SE(){}SE.prototype=RE.prototype;function TE(a,b){for(b=b.m();b.s();){var c=b.t();a.Du.L(c)||(a.Du.S(c),a.bi.S(c))}}function jE(a,b){TE(a,b);return a}
-var UE=function Cba(a,b,c,d){for(;;){var g=b;b=O().c;if(null===b?null===g:b.h(g))return d;if(g instanceof A){var h=g;b=h.A;h=h.r;if(null!==b){g=b.BA;var k=b.Hj;b=b.vq;if(c.L(k)){b=h;continue}else return new om(g,k,b,Cba(a,h,c.Yb(k),d))}}throw new x(g);}};function VE(){}VE.prototype=new p;VE.prototype.constructor=VE;function WE(a){var b=t().f;a=new ws(Ct().Kg,a);b=G(new H,b,a);a=O().c;return new im(new A(b,a))}
-function XE(a,b,c,d,e){return e?(Gt(),new mm(c,Ht(J(new L,[b,d])))):new mm(new mm(c,WE(b)),WE(d))}
-function YE(a,b){var c=!1,d=null;if(b instanceof mm){c=!0;d=b;var e=d.kb,g=d.hc;if(e instanceof mm){var h=e.kb;e=e.hc;if(h instanceof Wl&&"and"===h.w&&e instanceof im&&(e=e.Ra,e instanceof A&&(h=e.A,e=e.r,null!==h&&(h=new M(h),!h.b()&&(h=h.k.j(),null!==h))))){h=h.Da;var k=O().c;if((null===k?null===e:k.h(e))&&g instanceof im&&(g=g.Ra,g instanceof A&&(e=g.A,g=g.r,null!==e&&(e=new M(e),!e.b()&&(e=e.k.j(),null!==e&&(e=e.Da,k=O().c,null===k?null===g:k.h(g)))))))return a=YE(a,h),wq(a,e)}}}if(c&&(c=d.kb,
-d=d.hc,c instanceof Wl&&"and"===c.w&&null!==d&&(d=Ey(Gt(),d),!d.b()&&null!==d.o()&&0===d.o().$a(2))))return b=d.o(),b=FA(b,0),d=d.o(),d=FA(d,1),a=YE(a,b),wq(a,d);a=O().c;return new A(b,a)}
-function ZE(a,b,c){var d=!1,e=null;if(b instanceof mm){d=!0;e=b;var g=e.kb,h=e.hc;if(g instanceof mm){var k=g.kb;g=g.hc;if(k instanceof Wl&&"and"===k.w&&g instanceof im){var l=g.Ra;if(l instanceof A&&(g=l.A,l=l.r,null!==g&&(g=new M(g),!g.b()&&(g=g.k.j(),null!==g)))){g=g.Da;var m=O().c;if((null===m?null===l:m.h(l))&&h instanceof im&&(l=h.Ra,l instanceof A&&(h=l.A,l=l.r,null!==h&&(h=new M(h),!h.b()&&(h=h.k.j(),null!==h&&(h=h.Da,m=O().c,null===m?null===l:m.h(l))))))){a=ZE(a,g,c);if(null!==a&&(b=a.i(),
-e=a.j(),t().f===e))return G(new H,b,(t(),new M(h)));if(null!==a&&(b=a.i(),e=a.j(),e instanceof M))return a=e.k,t(),c=XE(0,a,k,h,c),G(new H,b,new M(c));throw new x(a);}}}}}if(d&&(k=e.kb,e=e.hc,k instanceof Wl&&"and"===k.w&&null!==e&&(e=Ey(Gt(),e),!e.b()&&null!==e.o()&&0===e.o().$a(2)))){b=e.o();d=FA(b,0);b=e.o();b=FA(b,1);a=ZE(a,d,c);if(null!==a&&(e=a.i(),d=a.j(),t().f===d))return G(new H,e,(t(),new M(b)));if(null!==a&&(e=a.i(),d=a.j(),d instanceof M))return a=d.k,t(),c=XE(0,a,k,b,c),G(new H,e,new M(c));
-throw new x(a);}return G(new H,b,t().f)}VE.prototype.$classData=q({D_:0},!1,"mlscript.ucs.helpers$",{D_:1,d:1});var $E;function aF(){$E||($E=new VE);return $E}q({E_:0},!1,"mlscript.utils.algorithms$",{E_:1,d:1});function bF(){}bF.prototype=new p;bF.prototype.constructor=bF;
-function Dba(a,b,c,d){a=G(new H,b,c);c=a.z;b=a.x;if(c instanceof M&&(c=c.k,b instanceof M))return a=d.aa(c,b.k),bt().n(a);d=a.z;if(d instanceof M)return d;d=a.x;if(d instanceof M)return d;d=a.z;b=a.x;if(R()===d&&R()===b)return R();throw new x(a);}function cF(){dF();throw kD("please add this rare case to test files");}function Dn(a){dF();var b=new eF;fF(b,"Internal Error: "+a,null,!0);throw b;}bF.prototype.$classData=q({G_:0},!1,"mlscript.utils.package$",{G_:1,d:1});var gF;
-function dF(){gF||(gF=new bF);return gF}function E(a){this.Eu=a}E.prototype=new p;E.prototype.constructor=E;function hf(a,b){a=a.Eu;return Ol(Pl(),a,b)}function sr(a,b){a=a.Eu;return!Ol(Pl(),a,b)}function et(a,b){return Object.is(a.Eu,b)}function Gw(a,b){return!Object.is(a.Eu,b)}function ng(a,b){a=a.Eu;return Ol(Pl(),a,b)}function Eba(a,b){return!!b.n(a.Eu)}function Fba(a,b){return b.Ln(new z(c=>hf(new E(c),a.Eu)))}E.prototype.$classData=q({H_:0},!1,"mlscript.utils.package$AnyOps",{H_:1,d:1});
-function hF(){}hF.prototype=new p;hF.prototype.constructor=hF;function iF(a,b){a=b.m();return a.s()?Qe(a,"[",", ","]"):""}function jF(a,b){a=b.m();a=new eg(a,new z(c=>{Ne();c=pc(c);var d=Le(Ne(),c);c=new kF;for(d=Sl(d).m();d.s();){var e=d.t();lF(c,"\t"+e)}return"\n"+Qe(c.ak,"","\n","")}));return Qe(a,"","","")}hF.prototype.$classData=q({I_:0},!1,"mlscript.utils.package$IterableOps$",{I_:1,d:1});var mF;function nF(){mF||(mF=new hF);return mF}function Ms(a){this.RI=a}Ms.prototype=new p;
-Ms.prototype.constructor=Ms;function oF(a){var b=Gba(),c=a.RI;a=O().c;for(c=jp(c);!c.b();){var d=c.e();a=a.b()||!b.aa(a.e(),d)?new A(d,a):a;c=c.g()}return a}function Gba(){return new Um((a,b)=>hf(new E(a),b))}function Ls(a){if(a.RI.b())return t().f;t();a=a.RI.g();return new M(a)}Ms.prototype.$classData=q({J_:0},!1,"mlscript.utils.package$ListHelpers",{J_:1,d:1});function $A(a){this.Fm=a}$A.prototype=new p;$A.prototype.constructor=$A;
-$A.prototype.$classData=q({K_:0},!1,"mlscript.utils.package$MutSetHelpers",{K_:1,d:1});function dx(a){this.XE=a}dx.prototype=new p;dx.prototype.constructor=dx;dx.prototype.$classData=q({L_:0},!1,"mlscript.utils.package$OptionHelpers",{L_:1,d:1});function pF(){}pF.prototype=new p;pF.prototype.constructor=pF;function qF(a,b,c){a=Hba(Du(),b,c);je();return le(v(),a)}function Mx(a,b,c){a=rF(Du(),b,c);je();return le(v(),a)}
-function Hba(a,b,c){a=b.m();return new eg(a,new z(d=>{var e=c.n(d.i());return G(new H,e,d.j())}))}function rF(a,b,c){a=b.m();return new eg(a,new z(d=>{var e=d.i();d=c.n(d.j());return G(new H,e,d)}))}function Bx(a,b){a=b.m();return new eg(a,new z(c=>c.i()))}function Eu(a,b){a=b.m();return new eg(a,new z(c=>c.j()))}pF.prototype.$classData=q({M_:0},!1,"mlscript.utils.package$PairIterableOps$",{M_:1,d:1});var sF;function Du(){sF||(sF=new pF);return sF}function Vp(a){return tF(uF(new vF,a))}
-q({N_:0},!1,"mlscript.utils.package$SetObjectHelpers",{N_:1,d:1});function nv(a,b){return Ku().bv(b).S(a).Eb()}q({O_:0},!1,"mlscript.utils.package$SortedMapObjectHelpers",{O_:1,d:1});function Nu(a,b){return Mu().jB(b).S(a).Eb()}q({P_:0},!1,"mlscript.utils.package$SortedSetObjectHelpers",{P_:1,d:1});function wF(){}wF.prototype=new p;wF.prototype.constructor=wF;
-function Le(a,b){xF();a=[re()];a=J(new L,a);a=yF(a);for(var c=b.length,d=0;d<c;){var e=b.charCodeAt(d);if(hf(new E(hd(e)),hd(10))){var g=re();Ql(a,g)}else g=zF(a).mf,e=String.fromCharCode(e),g.ha=""+g.ha+e;d=1+d|0}b=new kF;for(a=Sl(a).m();a.s();)c=a.t().mf.ha,lF(b,c);return b.ak}
-function Iba(a){var b=Le(Ne(),a);je();var c=le(v(),b);if(c instanceof A){b=c.A;var d=c.r;if(d instanceof A){if(d===v())a=v();else for(c=a=new A("  "+d.A,v()),d=d.r;d!==v();){var e=d.e();e=new A("  "+e,v());c=c.r=e;d=d.g()}return b+"\n"+Qe(a,"","\n","")}}return a}function IA(a,b){return""!==b?(a=cu(Q(),b),AF($q(),a)):!1}function BF(a,b){hf(new E(b.length),0)?a=!0:(a=b.charCodeAt(0),a=!AF($q(),a));if(a)return b;Q();a=b.charCodeAt(0);$q();a=65535&Jba(a);return CF(b,a)}
-function DF(a,b,c,d){return 1<c?b+(d?"es":"s"):b}wF.prototype.$classData=q({Q_:0},!1,"mlscript.utils.package$StringOps$",{Q_:1,d:1});var EF;function Ne(){EF||(EF=new wF);return EF}function FF(){this.f=null;GF=this;O();O();Nt();HF||(HF=new IF);this.f=R();O();O();O()}FF.prototype=new p;FF.prototype.constructor=FF;function bt(){t();return new z(a=>new M(a))}FF.prototype.$classData=q({R_:0},!1,"mlscript.utils.shorthands$",{R_:1,d:1});var GF;function t(){GF||(GF=new FF);return GF}
-function fb(a,b){this.W=a;this.Z=b}fb.prototype=new p;fb.prototype.constructor=fb;f=fb.prototype;f.h=function(a){return a instanceof fb?this.W===a.W&&this.Z===a.Z:!1};f.y=function(){return this.W^this.Z};f.u=function(){return JF(Cb(),this.W,this.Z)};f.MA=function(){return this.W<<24>>24};f.gC=function(){return this.W<<16>>16};f.Ri=function(){return this.W};f.ll=function(){return Qb(this)};
-f.Pu=function(){Cb();var a=this.W,b=this.Z;if(0>b){var c=-a|0;a=0!==a?~b:-b|0}else c=a,a=b;c=4294967296*+(a>>>0)+ +((0===(-2097152&a)||0===(65535&c)?c:32768|-65536&c)>>>0);return Math.fround(0>b?-c:c)};f.ap=function(){return KF(Cb(),this.W,this.Z)};f.sk=function(a){return Bb(Cb(),this.W,this.Z,a.W,a.Z)};f.$classData=q({V_:0},!1,"org.scalajs.linker.runtime.RuntimeLong",{V_:1,d:1});function LF(a,b,c){return 0===(-2097152&c)?""+(4294967296*c+ +(b>>>0)):MF(a,b,c,1E9,0,2)}
-function NF(a,b,c,d,e){return 0===(-2097152&c)?0===(-2097152&e)?(c=(4294967296*c+ +(b>>>0))/(4294967296*e+ +(d>>>0)),a.Kc=c/4294967296|0,c|0):a.Kc=0:0===e&&0===(d&(-1+d|0))?(d=31-Math.clz32(d)|0,a.Kc=c>>>d|0,b>>>d|0|c<<1<<(31-d|0)):0===d&&0===(e&(-1+e|0))?(b=31-Math.clz32(e)|0,a.Kc=0,c>>>b|0):MF(a,b,c,d,e,0)|0}
-function MF(a,b,c,d,e,g){var h=(0!==e?Math.clz32(e):32+Math.clz32(d)|0)-(0!==c?Math.clz32(c):32+Math.clz32(b)|0)|0,k=h,l=0===(32&k)?d<<k:0,m=0===(32&k)?(d>>>1|0)>>>(31-k|0)|0|e<<k:d<<k;k=b;var n=c;for(b=c=0;0<=h&&0!==(-2097152&n);){var r=k,u=n,w=l,y=m;if(u===y?(-2147483648^r)>=(-2147483648^w):(-2147483648^u)>=(-2147483648^y))r=n,u=m,n=k-l|0,r=(-2147483648^n)>(-2147483648^k)?-1+(r-u|0)|0:r-u|0,k=n,n=r,32>h?c|=1<<h:b|=1<<h;h=-1+h|0;r=m>>>1|0;l=l>>>1|0|m<<31;m=r}h=n;if(h===e?(-2147483648^k)>=(-2147483648^
-d):(-2147483648^h)>=(-2147483648^e))h=4294967296*n+ +(k>>>0),d=4294967296*e+ +(d>>>0),1!==g&&(m=h/d,e=m/4294967296|0,l=c,c=m=l+(m|0)|0,b=(-2147483648^m)<(-2147483648^l)?1+(b+e|0)|0:b+e|0),0!==g&&(d=h%d,k=d|0,n=d/4294967296|0);if(0===g)return a.Kc=b,c;if(1===g)return a.Kc=n,k;a=""+k;return""+(4294967296*b+ +(c>>>0))+"000000000".substring(a.length)+a}function OF(){this.Kc=0}OF.prototype=new p;OF.prototype.constructor=OF;
-function JF(a,b,c){return c===b>>31?""+b:0>c?"-"+LF(a,-b|0,0!==b?~c:-c|0):LF(a,b,c)}function KF(a,b,c){return 0>c?-(4294967296*+((0!==b?~c:-c|0)>>>0)+ +((-b|0)>>>0)):4294967296*c+ +(b>>>0)}function Bb(a,b,c,d,e){return c===e?b===d?0:(-2147483648^b)<(-2147483648^d)?-1:1:c<e?-1:1}
-function ki(a,b,c,d,e){if(0===(d|e))throw new zc("/ by zero");if(c===b>>31){if(e===d>>31){if(-2147483648===b&&-1===d)return a.Kc=0,-2147483648;c=rc(b,d);a.Kc=c>>31;return c}return-2147483648===b&&-2147483648===d&&0===e?a.Kc=-1:a.Kc=0}if(0>c){var g=-b|0;b=0!==b?~c:-c|0}else g=b,b=c;if(0>e){var h=-d|0;d=0!==d?~e:-e|0}else h=d,d=e;g=NF(a,g,b,h,d);if(0<=(c^e))return g;c=a.Kc;a.Kc=0!==g?~c:-c|0;return-g|0}
-function fi(a,b,c,d,e){if(0===(d|e))throw new zc("/ by zero");return 0===c?0===e?(a.Kc=0,0===d?rc(0,0):+(b>>>0)/+(d>>>0)|0):a.Kc=0:NF(a,b,c,d,e)}
-function bj(a,b,c,d,e){if(0===(d|e))throw new zc("/ by zero");if(c===b>>31){if(e===d>>31)return-1!==d?(c=Kc(b,d),a.Kc=c>>31,c):a.Kc=0;if(-2147483648===b&&-2147483648===d&&0===e)return a.Kc=0;a.Kc=c;return b}if(0>c)var g=-b|0,h=0!==b?~c:-c|0;else g=b,h=c;0>e?(b=-d|0,d=0!==d?~e:-e|0):(b=d,d=e);0===(-2097152&h)?0===(-2097152&d)?(b=(4294967296*h+ +(g>>>0))%(4294967296*d+ +(b>>>0)),a.Kc=b/4294967296|0,b|=0):(a.Kc=h,b=g):0===d&&0===(b&(-1+b|0))?(a.Kc=0,b=g&(-1+b|0)):0===b&&0===(d&(-1+d|0))?(a.Kc=h&(-1+
-d|0),b=g):b=MF(a,g,h,b,d,1)|0;return 0>c?(c=a.Kc,a.Kc=0!==b?~c:-c|0,-b|0):b}OF.prototype.$classData=q({W_:0},!1,"org.scalajs.linker.runtime.RuntimeLong$",{W_:1,d:1});var PF;function Cb(){PF||(PF=new OF);return PF}function QF(){this.mK=this.mB=null;RF=this;this.mB=new zd(0);this.mK=new jd(0)}QF.prototype=new p;QF.prototype.constructor=QF;QF.prototype.$classData=q({r2:0},!1,"scala.Array$EmptyArrays$",{r2:1,d:1});var RF;function SF(){RF||(RF=new QF);return RF}function TF(){}TF.prototype=new p;
-TF.prototype.constructor=TF;function UF(){}UF.prototype=TF.prototype;function yC(a,b){this.TQ=null;this.z2=b;if(null===a)throw null;this.TQ=a}yC.prototype=new p;yC.prototype.constructor=yC;yC.prototype.$classData=q({y2:0},!1,"scala.Option$WithFilter",{y2:1,d:1});function VF(){this.VQ=this.fv=null;WF=this;this.fv=new z(()=>XF().fv);this.VQ=new YF}VF.prototype=new p;VF.prototype.constructor=VF;function ZF(a,b){return a.fv===b}VF.prototype.$classData=q({A2:0},!1,"scala.PartialFunction$",{A2:1,d:1});
-var WF;function XF(){WF||(WF=new VF);return WF}function $F(){}$F.prototype=new p;$F.prototype.constructor=$F;function Kba(a,b){gp(fp(),b);return a}$F.prototype.$classData=q({H2:0},!1,"scala.Predef$Ensuring$",{H2:1,d:1});var aG;function bG(a){this.WQ=null;if(null===a)throw null;this.WQ=a}bG.prototype=new p;bG.prototype.constructor=bG;function Lba(a,b){return Mba(pq(),a.WQ.hv,b)}bG.prototype.$classData=q({O2:0},!1,"scala.StringContext$s$",{O2:1,d:1});function cG(){}cG.prototype=new p;
-cG.prototype.constructor=cG;
-function Dr(a,b,c,d){a=0<c?c:0;c=dG(eG(),b);d=d<c?d:c;if(d>a){if(b instanceof jd)return ck(fk(),b,a,d);if(b instanceof zd){fk();if(a>d)throw dk(a+" \x3e "+d);d=d-a|0;c=b.a.length-a|0;c=d<c?d:c;d=new zd(d);b.va(a,d,0,c);return d}if(b instanceof Dd){fk();if(a>d)throw dk(a+" \x3e "+d);d=d-a|0;c=b.a.length-a|0;c=d<c?d:c;d=new Dd(d);b.va(a,d,0,c);return d}if(b instanceof Ad){fk();if(a>d)throw dk(a+" \x3e "+d);d=d-a|0;c=b.a.length-a|0;c=d<c?d:c;d=new Ad(d);b.va(a,d,0,c);return d}if(b instanceof Bd){fk();
-if(a>d)throw dk(a+" \x3e "+d);d=d-a|0;c=b.a.length-a|0;c=d<c?d:c;d=new Bd(d);b.va(a,d,0,c);return d}if(b instanceof td){fk();if(a>d)throw dk(a+" \x3e "+d);d=d-a|0;c=b.a.length-a|0;c=d<c?d:c;d=new td(d);b.va(a,d,0,c);return d}if(b instanceof vd){fk();if(a>d)throw dk(a+" \x3e "+d);d=d-a|0;c=b.a.length-a|0;c=d<c?d:c;d=new vd(d);b.va(a,d,0,c);return d}if(b instanceof wd){fk();if(a>d)throw dk(a+" \x3e "+d);d=d-a|0;c=b.a.length-a|0;c=d<c?d:c;d=new wd(d);b.va(a,d,0,c);return d}if(b instanceof pd){fk();if(a>
-d)throw dk(a+" \x3e "+d);d=d-a|0;c=b.a.length-a|0;c=d<c?d:c;d=new pd(d);b.va(a,d,0,c);return d}throw new x(b);}return fG(gG(),Gg(ja(b))).gi(0)}function Br(a,b,c){return Dr(Cr(),b,c,dG(eG(),b))}
-function hG(a){if(a instanceof jd)return Yt(new Zt,a);if(a instanceof zd)return new iG(a);if(a instanceof Dd)return new jG(a);if(a instanceof Ad)return new kG(a);if(a instanceof Bd)return new lG(a);if(a instanceof td)return new mG(a);if(a instanceof vd)return new nG(a);if(a instanceof wd)return new oG(a);if(a instanceof pd)return new pG(a);if(Dh(a))return new qG(a);if(null===a)throw ze();throw new x(a);}
-function nu(a,b){var c=dG(eG(),a);if(1>=c)return rG(eG(),a);if(a instanceof jd)return c=Tj(fk(),a,c),xj(fk(),c,b),c;if(a instanceof zd){if(b===dq())return c=Yj(fk(),a,c),jj(fk(),c),c}else if(a instanceof Ad){if(b===sG())return c=Zj(fk(),a,c),pj(fk(),c),c}else if(a instanceof td){if(b===tG())return c=ak(fk(),a,c),tj(fk(),c),c}else if(a instanceof vd){if(b===uG())return c=Wj(fk(),a,c),vj(fk(),c),c}else if(a instanceof wd){if(b===vG())return c=Xj(fk(),a,c),rj(fk(),c),c}else if(a instanceof pd&&b===wG()){c=
-bk(fk(),a,c);var d=xG();b=wG();yG(d,c,c.a.length,b);return c}300>c?(c=rG(eG(),a),yG(xG(),c,dG(eG(),c),b)):(zG(),AG(),Dg(ma(Md),Gg(ja(a)))?d=yg(ma(Md))?BG(a,c):Vj(fk(),a,c,ma(Nd(Md))):(d=new jd(c),CG(zG(),a,0,d,0,dG(eG(),a))),xj(fk(),d,b),zG(),b=fG(gG(),Gg(ja(a))),a=b.jh(),null!==a&&a===ma(Qd)?c=DG(c):Dg(a,Gg(ja(d)))?yg(a)?c=BG(d,c):(b=Fh(Jh(),a,0),b=ja(b),c=Vj(fk(),d,c,b)):(c=b.gi(c),CG(zG(),d,0,c,0,dG(eG(),d))));return c}
-function MA(a,b,c){if(null===a)throw ze();if(a instanceof jd){for(var d=dG(eG(),a),e=0;e<d;)b=c.aa(b,EG(eG(),a,e)),e=1+e|0;return b}if(a instanceof zd){d=a.a.length;for(e=0;e<d;)b=c.aa(b,a.a[e]),e=1+e|0;return b}if(a instanceof Dd){d=a.a.length;for(e=0;e<d;)b=c.aa(b,a.a[e]),e=1+e|0;return b}if(a instanceof Ad){d=a.a.length;for(e=0;e<d;)b=c.aa(b,a.a[e]),e=1+e|0;return b}if(a instanceof Bd){d=a.a.length;for(e=0;e<d;)b=c.aa(b,a.a[e]),e=1+e|0;return b}if(a instanceof td){d=a.a.length;for(e=0;e<d;)b=c.aa(b,
-hd(a.a[e])),e=1+e|0;return b}if(a instanceof vd){d=a.a.length;for(e=0;e<d;)b=c.aa(b,a.a[e]),e=1+e|0;return b}if(a instanceof wd){d=a.a.length;for(e=0;e<d;)b=c.aa(b,a.a[e]),e=1+e|0;return b}if(a instanceof pd){d=a.a.length;for(e=0;e<d;)b=c.aa(b,a.a[e]),e=1+e|0;return b}if(Dh(a)){d=a.a.length;for(e=0;e<d;)b=c.aa(b,a.a[e]),e=1+e|0;return b}throw new x(a);}cG.prototype.$classData=q({T3:0},!1,"scala.collection.ArrayOps$",{T3:1,d:1});var FG;function Cr(){FG||(FG=new cG);return FG}function GG(){}
-GG.prototype=new p;GG.prototype.constructor=GG;function HG(a,b){a=b+~(b<<9)|0;a^=a>>>14|0;a=a+(a<<4)|0;return a^(a>>>10|0)}GG.prototype.$classData=q({q4:0},!1,"scala.collection.Hashing$",{q4:1,d:1});var IG;function JG(){IG||(IG=new GG);return IG}function KG(a,b){for(a=a.m();a.s();)b.n(a.t())}function Cv(a,b){var c=!0;for(a=a.m();c&&a.s();)c=!!b.n(a.t());return c}function Cx(a,b){var c=!1;for(a=a.m();!c&&a.s();)c=!!b.n(a.t());return c}
-function LG(a,b){for(a=a.m();a.s();){var c=a.t();if(b.n(c))return new M(c)}return R()}function NA(a,b,c){for(a=a.m();a.s();)b=c.aa(b,a.t());return b}function ku(a,b,c){return a.Rc().ge(b,new Um((d,e)=>c.aa(e,d)))}function MG(a,b){a=a.m();if(!a.s())throw Fu("empty.reduceLeft");for(var c=!0,d=null;a.s();){var e=a.t();c?(d=e,c=!1):d=b.aa(d,e)}return d}function Ft(a,b){if(!a.m().s())throw Fu("empty.reduceRight");return a.Rc().Bi(new Um((c,d)=>b.aa(d,c)))}
-function xr(a){if(0<=a.Q())return a.Q();a=a.m();for(var b=0;a.s();)b=1+b|0,a.t();return b}function NG(a,b,c,d){a=a.m();var e=c,g=dG(eG(),b)-c|0;for(d=c+(d<g?d:g)|0;e<d&&a.s();)OG(eG(),b,e,a.t()),e=1+e|0;return e-c|0}function Nba(a){return a.b()?0:a.Bi(new Um((b,c)=>(b|0)+(c|0)|0))}function PG(a,b){if(a.b())throw Fu("empty.min");return a.Bi(new Um((c,d)=>b.ol(c,d)))}function eq(a,b){return a.b()?R():new M(a.Ui(b))}
-function QG(a,b){if(a.b())throw Fu("empty.max");return a.Bi(new Um((c,d)=>b.nl(c,d)))}function hq(a,b){return a.b()?R():new M(a.Ti(b))}function Oba(a,b,c){if(a.b())throw Fu("empty.maxBy");var d=new ov(null),e=new ov(null),g=new hA(!0);a.ya(new z(h=>{var k=b.n(h);if(g.ko||c.wk(k,d.Lb))e.Lb=h,d.Lb=k,g.ko=!1}));return e.Lb}function pC(a,b,c){return a.b()?R():new M(Oba(a,b,c))}function Qe(a,b,c,d){return a.b()?""+b+d:a.vh(re(),b,c,d).mf.ha}
-function RG(a,b,c,d,e){var g=b.mf;0!==c.length&&(g.ha=""+g.ha+c);a=a.m();if(a.s())for(c=a.t(),g.ha=""+g.ha+c;a.s();)g.ha=""+g.ha+d,c=a.t(),g.ha=""+g.ha+c;0!==e.length&&(g.ha=""+g.ha+e);return b}function LA(a,b){if(0<=a.Q())return b=b.gi(a.Q()),a.yc(b,0,2147483647),b;var c=b.jh(),d=c===ma(Vd);b=[];for(a=a.m();a.s();){var e=a.t();b.push(d?Eb(e):null===e?c.ei.Oy:e)}return Nd((c===ma(Qd)?ma(Xa):c===ma(SG)||c===ma(TG)?ma(Md):c).ei).Ny(b)}
-function Eq(a){var b=v();for(a=a.m();a.s();){var c=a.t();b=new A(c,b)}return b}function UG(a,b){this.Q4=a;this.eG=b}UG.prototype=new p;UG.prototype.constructor=UG;UG.prototype.$classData=q({P4:0},!1,"scala.collection.Iterator$ConcatIteratorCell",{P4:1,d:1});function vq(a,b,c){this.RK=a;this.Sj=b;this.Tj=c}vq.prototype=new p;vq.prototype.constructor=vq;function KC(a,b){return new VG(a.RK,a.Sj,a.Tj,b)}function Rv(a,b){b=new WG(a,b);return a.RK.Ob().Ib(b)}
-function yq(a,b){b=new XG(a,b);return a.RK.Ob().Ib(b)}function YG(a,b){var c=a.Sj.m();for(a=a.Tj.m();c.s()&&a.s();)b.aa(c.t(),a.t())}function ZG(a){var b=a.Sj.Q();if(0===b)return 0;a=a.Tj.Q();return 0===a?0:b<a?b:a}vq.prototype.u=function(){return this.Sj+".lazyZip("+this.Tj+")"};vq.prototype.$classData=q({U4:0},!1,"scala.collection.LazyZip2",{U4:1,d:1});function VG(a,b,c,d){this.SK=b;this.TK=c;this.UK=d}VG.prototype=new p;VG.prototype.constructor=VG;
-function $G(a,b){var c=a.SK.m(),d=a.TK.m();for(a=a.UK.m();c.s()&&d.s()&&a.s();){var e=c.t(),g=d.t(),h=a.t();(0,b.JL)(e,g,h)}}VG.prototype.u=function(){return this.SK+".lazyZip("+this.TK+").lazyZip("+this.UK+")"};VG.prototype.$classData=q({a5:0},!1,"scala.collection.LazyZip3",{a5:1,d:1});function aH(){}aH.prototype=new p;aH.prototype.constructor=aH;
-function CF(a,b){var c=Xt(a.length);c.ha=""+c.ha+a;a=c.ha;if(0>=a.length)throw b=new bH,fF(b,"String index out of range: 0",null,!0),b;c.ha=""+a.substring(0,0)+hd(b)+a.substring(1);return c.ha}function cH(a,b,c){return 0<=dH(b,c)}function qg(a,b,c,d){a=0<c?c:0;c=b.length;d=d<c?d:c;return a>=d?"":b.substring(a,d)}function Hs(a,b,c){if(0>=c)return"";a=Xt(Math.imul(b.length,c));for(var d=0;d<c;)a.ha=""+a.ha+b,d=1+d|0;return a.ha}
-function hu(a,b){null===b||0===b.length?a=!0:(a=b.charCodeAt(0),a=!vD($q(),a));if(a)return b;Q();a=b.charCodeAt(0);$q();a=65535&Pba(a);return CF(b,a)}function Zf(a){return"\n"===a.substring(a.length-1|0)?a.substring(0,a.length-1|0):a}function we(a){Q();var b=Xt(a.length);for(a=new eH(a,!1);a.Xi<a.my;){for(var c=fH(a),d=c.length,e=0;;)if(e<d&&32>=c.charCodeAt(e))e=1+e|0;else break;c=e<d&&124===c.charCodeAt(e)?c.substring(1+e|0):c;b.ha=""+b.ha+c}return b.ha}
-function Qba(a,b){a=b.Ga(new z(c=>{Q();return c instanceof gH?c.YS():c})).vj(AG());return Rba(hH(),a)}function cu(a,b){if(""===b)throw iH("head of empty String");return b.charCodeAt(0)}function pz(a,b){return""===b?R():new M(hd(b.charCodeAt(0)))}function bu(a,b){if(""===b)throw iH("last of empty String");return b.charCodeAt(-1+b.length|0)}function Sr(a,b,c){Q();a=b.length;return qg(0,b,c<a?c:a,b.length)}function ur(a,b){Q();a=b.length-2|0;Q();var c=b.length;return qg(0,b,0,a<c?a:c)}
-function Sba(a,b,c){a:{Q();a=b.length;for(var d=0;d<a;){if(c.n(hd(b.charCodeAt(d)))){b=d;break a}d=1+d|0}b=-1}return-1!==b}function Paa(a,b){a:{for(var c=a.length,d=0;d<c;){var e=a.charCodeAt(d);if(!b.n(hd(e))){b=d;break a}d=1+d|0}b=-1}return-1===b?a:a.substring(0,b)}aH.prototype.$classData=q({F5:0},!1,"scala.collection.StringOps$",{F5:1,d:1});var jH;function Q(){jH||(jH=new aH);return jH}
-function kH(a,b,c,d){for(var e=1;;){if(e===c)return b?-2147483648===a?R():new M(-a|0):new M(a);if(-214748364>a)return R();var g=d.charCodeAt(e);g=lH($q(),g,10);if(-1===g||-214748364===a&&9===g)return R();e=1+e|0;a=Math.imul(10,a)-g|0}}function mH(){}mH.prototype=new p;mH.prototype.constructor=mH;function tD(a,b){a=b.length;if(0===a)return R();var c=b.charCodeAt(0),d=lH($q(),c,10);return 1===a?-1<d?new M(d):R():-1<d?kH(-d|0,!0,a,b):43===c?kH(0,!0,a,b):45===c?kH(0,!1,a,b):R()}
-mH.prototype.$classData=q({K5:0},!1,"scala.collection.StringParsers$",{K5:1,d:1});var nH;function uD(){nH||(nH=new mH);return nH}function oH(a,b){null===a.Ck&&(a.Ck=new zd(pH().OB<<1),a.Xn=new (Nd(qH).Ja)(pH().OB));a.ji=1+a.ji|0;var c=a.ji<<1,d=1+(a.ji<<1)|0;a.Xn.a[a.ji]=b;a.Ck.a[c]=0;a.Ck.a[d]=b.kB()}function rH(a,b){a.Gc=0;a.$m=0;a.ji=-1;b.RA()&&oH(a,b);b.Mx()&&(a.lh=b,a.Gc=0,a.$m=b.Xx())}function sH(){this.$m=this.Gc=0;this.lh=null;this.ji=0;this.Xn=this.Ck=null}sH.prototype=new p;
-sH.prototype.constructor=sH;function tH(){}tH.prototype=sH.prototype;sH.prototype.s=function(){var a;if(!(a=this.Gc<this.$m))a:{for(;0<=this.ji;){a=this.ji<<1;var b=this.Ck.a[a];if(b<this.Ck.a[1+(this.ji<<1)|0]){var c=this.Ck;c.a[a]=1+c.a[a]|0;a=this.Xn.a[this.ji].QA(b);a.RA()&&oH(this,a);if(a.Mx()){this.lh=a;this.Gc=0;this.$m=a.Xx();a=!0;break a}}else this.ji=-1+this.ji|0}a=!1}return a};function uH(a,b){a.Dk=1+a.Dk|0;a.vv.a[a.Dk]=b;a.uv.a[a.Dk]=-1+b.kB()|0}
-function vH(a){for(;0<=a.Dk;){var b=a.uv.a[a.Dk];a.uv.a[a.Dk]=-1+b|0;if(0<=b)b=a.vv.a[a.Dk].QA(b),uH(a,b);else if(b=a.vv.a[a.Dk],a.Dk=-1+a.Dk|0,b.Mx())return a.mt=b,a.Wj=-1+b.Xx()|0,!0}return!1}function wH(a,b){a.Wj=-1;a.Dk=-1;a.uv=new zd(1+pH().OB|0);a.vv=new (Nd(qH).Ja)(1+pH().OB|0);uH(a,b);vH(a)}function xH(){this.Wj=0;this.mt=null;this.Dk=0;this.vv=this.uv=null}xH.prototype=new p;xH.prototype.constructor=xH;function yH(){}yH.prototype=xH.prototype;
-xH.prototype.s=function(){return 0<=this.Wj||vH(this)};function zH(){this.TR=0;AH=this;try{var a=zh(Ah(),"scala.collection.immutable.IndexedSeq.defaultApplyPreferredMaxLength","64");var b=BH(CH(),a,10)}catch(c){throw c;}this.TR=b}zH.prototype=new p;zH.prototype.constructor=zH;zH.prototype.$classData=q({A6:0},!1,"scala.collection.immutable.IndexedSeqDefaults$",{A6:1,d:1});var AH;function DH(){this.pL=null}DH.prototype=new p;DH.prototype.constructor=DH;
-function EH(a){a=a.pL;if(null===a)throw FH("uninitialized");return Zr(a)}function GH(a,b){if(null!==a.pL)throw FH("already initialized");a.pL=b}DH.prototype.$classData=q({F6:0},!1,"scala.collection.immutable.LazyList$LazyBuilder$DeferredState",{F6:1,d:1});function HH(){this.wy=null;IH=this;this.wy=new JH(0,0,(KH(),new jd(0)),(Rl(),new zd(0)),0,0)}HH.prototype=new p;HH.prototype.constructor=HH;HH.prototype.$classData=q({j7:0},!1,"scala.collection.immutable.MapNode$",{j7:1,d:1});var IH;
-function LH(){IH||(IH=new HH);return IH}function MH(a,b){var c=new NH;a=b+" is out of bounds (min 0, max "+(-1+dG(eG(),a)|0);fF(c,a,null,!0);return c}function OH(){}OH.prototype=new p;OH.prototype.constructor=OH;function PH(){}PH.prototype=OH.prototype;function QH(a,b){if(0>b)throw MH(a,b);if(b>(-1+a.a.length|0))throw MH(a,b);var c=new zd(-1+a.a.length|0);a.va(0,c,0,b);a.va(1+b|0,c,b,-1+(a.a.length-b|0)|0);return c}
-function RH(a,b,c){if(0>b)throw MH(a,b);if(b>a.a.length)throw MH(a,b);var d=new zd(1+a.a.length|0);a.va(0,d,0,b);d.a[b]=c;a.va(b,d,1+b|0,a.a.length-b|0);return d}var qH=q({NB:0},!1,"scala.collection.immutable.Node",{NB:1,d:1});OH.prototype.$classData=qH;function SH(){this.OB=0;TH=this;this.OB=Mc(+Math.ceil(6.4))}SH.prototype=new p;SH.prototype.constructor=SH;function UH(a,b,c){return 31&(b>>>c|0)}function VH(a,b){return 1<<b}function WH(a,b,c){a=b&(-1+c|0);return XH(CH(),a)}
-function YH(a,b,c,d){return-1===b?c:WH(0,b,d)}SH.prototype.$classData=q({p7:0},!1,"scala.collection.immutable.Node$",{p7:1,d:1});var TH;function pH(){TH||(TH=new SH);return TH}var Uba=function Tba(a,b,c){for(;;)if(null!==b.ra&&Tba(a,b.ra,c),c.n(G(new H,b.Wa,b.Tb)),null!==b.sa)b=b.sa;else break},Wba=function Vba(a,b,c){for(;;)if(null!==b.ra&&Vba(a,b.ra,c),c.n(b.Wa),null!==b.sa)b=b.sa;else break},Yba=function Xba(a,b,c){for(;;)if(null!==b.ra&&Xba(a,b.ra,c),c.aa(b.Wa,b.Tb),null!==b.sa)b=b.sa;else break};
-function ZH(a){return null===a?null:$H(a)}function aI(a,b,c,d,e){return new bI(b,c,d,e,1+((null===d?0:2147483647&d.da)+(null===e?0:2147483647&e.da)|0)|0|(a?-2147483648:0))}function cI(a,b){if(a.ra===b)return a;if(0<=b.da){var c=b.ra,d=b.sa;return null!==c&&0<=c.da?dI(b,$H(c),eI(a,d)):null!==d&&0<=d.da?dI(d,fI(b,d.ra),eI(a,d.sa)):gI(a,b)}return gI(a,b)}
-function hI(a,b){if(a.sa===b)return a;if(0<=b.da){var c=b.ra;if(null!==c&&0<=c.da)return dI(c,fI(a,c.ra),eI(b,c.sa));var d=b.sa;return null!==d&&0<=d.da?dI(b,fI(a,c),$H(d)):iI(a,b)}return iI(a,b)}
-var Zba=function jI(a,b,c,d,e,g){if(null===b)return kI(c,d,null,null);if(Object.is(c,b.Wa))return e?lI(b,d):b;var k=g.Fa(c,b.Wa);return 0>k?cI(b,jI(a,b.ra,c,d,e,g)):0<k?hI(b,jI(a,b.sa,c,d,e,g)):e&&!Object.is(d,b.Tb)?lI(b,d):b},$ba=function mI(a,b,c,d,e){if(null===b)return kI(d,e,null,null);var h=1+nI(0,b.ra)|0;return c<h?cI(b,mI(a,b.ra,c,d,e)):c>h?hI(b,mI(a,b.sa,c-h|0,d,e)):b},pI=function aca(a,b,c){for(;;){if(null===b||0>=c)return b;if(c>=(2147483647&b.da))return null;var e=nI(0,b.ra);if(c>e)c=-1+
-(c-e|0)|0,b=b.sa;else{if(c===e)return oI(a,null,b.Wa,b.Tb,b.sa);c=aca(a,b.ra,c);return oI(a,c,b.Wa,b.Tb,b.sa)}}},qI=function bca(a,b,c){for(;;){if(null===b||0>=c)return null;if(c>=(2147483647&b.da))return b;var e=nI(0,b.ra);if(c<=e)b=b.ra;else return c===(1+e|0)?(a=$ba(a,b.ra,c,b.Wa,b.Tb),null===a||0>a.da||(b=a.ra,null!==b&&0<=b.da?b=!0:(b=a.sa,b=null!==b&&0<=b.da),a=b?$H(a):a)):a=oI(a,b.ra,b.Wa,b.Tb,bca(a,b.sa,-1+(c-e|0)|0)),a}},yI=function rI(a,b,c,d){if(null===b)return null;var g=d.Fa(c,b.Wa);
-if(0>g){a=rI(a,b.ra,c,d);if(a===b.ra)return b;c=b.ra;null!==c&&0>c.da?b=sI(b,a,b.sa):a===b.ra&&0<=b.da||(c=b.sa,b=new bI(b.Wa,b.Tb,a,b.sa,1+((null===a?0:2147483647&a.da)+(null===c?0:2147483647&c.da)|0)|0));return b}if(0<g){a=rI(a,b.sa,c,d);if(a===b.sa)return b;c=b.sa;null!==c&&0>c.da?(c=b.ra,null!==a&&0<=a.da?b=tI(b,c,$H(a)):null!==c&&0>c.da?b=uI(b,vI(c),a):(null!==c&&0<=c.da?(d=c.sa,d=null!==d&&0>d.da):d=!1,d?b=tI(c.sa,uI(c,vI(c.ra),c.sa.ra),wI(b,c.sa.sa,a)):(xI(),b=void 0))):a===b.sa&&0<=b.da||
-(c=b.ra,b=new bI(b.Wa,b.Tb,b.ra,a,1+((null===c?0:2147483647&c.da)+(null===a?0:2147483647&a.da)|0)|0));return b}return cca(a,b.ra,b.sa)};
-function uI(a,b,c){if(null!==b&&0<=b.da){if(null!==c&&0<=c.da)return tI(a,$H(b),$H(c));var d=b.ra;if(null!==d&&0<=d.da)return dI(b,$H(b.ra),wI(a,b.sa,c));d=b.sa;return null!==d&&0<=d.da?dI(b.sa,fI(b,b.sa.ra),wI(a,b.sa.sa,c)):wI(a,b,c)}if(null!==c&&0<=c.da){d=c.sa;if(null!==d&&0<=d.da)return dI(c,wI(a,b,c.ra),$H(c.sa));d=c.ra;return null!==d&&0<=d.da?dI(c.ra,wI(a,b,c.ra.ra),wI(c,c.ra.sa,c.sa)):wI(a,b,c)}return wI(a,b,c)}
-function sI(a,b,c){if(null!==b&&0<=b.da)return tI(a,$H(b),c);if(null!==c&&0>c.da)return uI(a,b,vI(c));if(null!==c&&0<=c.da){var d=c.ra;d=null!==d&&0>d.da}else d=!1;if(d)return tI(c.ra,wI(a,b,c.ra.ra),uI(c,c.ra.sa,vI(c.sa)));xI()}
-var cca=function zI(a,b,c){return null===b?c:null===c?b:0<=b.da?0<=c.da?(a=zI(a,b.sa,c.ra),null!==a&&0<=a.da?dI(a,iI(b,a.ra),gI(c,a.sa)):iI(b,gI(c,a))):iI(b,zI(a,b.sa,c)):0>c.da?(a=zI(a,b.sa,c.ra),null!==a&&0<=a.da?dI(a,iI(b,a.ra),gI(c,a.sa)):sI(b,b.ra,gI(c,a))):gI(c,zI(a,b,c.ra))},eca=function dca(a,b,c,d,e,g,h){if((null===b?0:0>b.da?(-1+g|0)<<1:-1+(g<<1)|0)===(h/2|0)<<1)return kI(c,d,b,e);var l=null!==b&&0>b.da;a=dca(a,b.sa,c,d,e,l?-1+g|0:g,h);l&&null!==a&&0<=a.da?(c=a.sa,c=null!==c&&0<=c.da):c=
-!1;return c?kI(a.Wa,a.Tb,AI(b.Wa,b.Tb,b.ra,a.ra),$H(a.sa)):aI(l,b.Wa,b.Tb,b.ra,a)},gca=function fca(a,b,c,d,e,g,h){if((null===e?0:0>e.da?(-1+h|0)<<1:-1+(h<<1)|0)===(g/2|0)<<1)return kI(c,d,b,e);var l=null!==e&&0>e.da;a=fca(a,b,c,d,e.ra,g,l?-1+h|0:h);l&&null!==a&&0<=a.da?(b=a.ra,b=null!==b&&0<=b.da):b=!1;return b?kI(a.Wa,a.Tb,$H(a.ra),AI(e.Wa,e.Tb,a.sa,e.sa)):aI(l,e.Wa,e.Tb,a,e.sa)},CI=function BI(a,b,c,d){if(null===b)return new vp(null,null,null,c);var g=d.Fa(c,b.Wa);if(0===g)return new vp(b.ra,b,
-b.sa,b.Wa);if(0>g){c=BI(a,b.ra,c,d);if(null===c)throw new x(c);d=c.Qi;return new vp(c.Jj,c.jj,oI(a,c.ci,b.Wa,b.Tb,b.sa),d)}c=BI(a,b.sa,c,d);if(null===c)throw new x(c);d=c.jj;g=c.ci;var h=c.Qi;return new vp(oI(a,b.ra,b.Wa,b.Tb,c.Jj),d,g,h)},ica=function hca(a,b){if(null===b.sa)return new Ul(b.ra,b.Wa,b.Tb);var d=hca(a,b.sa);if(null===d)throw new x(d);var e=d.gb,g=d.xd;return new Ul(oI(a,b.ra,b.Wa,b.Tb,d.ec),e,g)},jca=function DI(a,b,c,d){if(null===b||b===c)return c;if(null===c)return b;var g=CI(a,
-b,c.Wa,d);if(null===g)throw new x(g);var h=g.ci;b=g.Qi;g=DI(a,g.Jj,c.ra,d);d=DI(a,h,c.sa,d);return oI(a,g,b,c.Tb,d)},GI=function EI(a,b,c,d){if(null===b||null===c)return b;if(b===c)return null;var g=CI(a,b,c.Wa,d);if(null===g)throw new x(g);b=g.ci;g=EI(a,g.Jj,c.ra,d);c=EI(a,b,c.sa,d);return FI(a,g,c)},kca=function HI(a,b,c,d,e){switch(c){case 0:return null;case 1:return aI(b!==d||1===b,e.t(),null,null,null);default:var h=(-1+c|0)/2|0,k=HI(a,1+b|0,h,d,e),l=e.t();a=HI(a,1+b|0,(-1+c|0)-h|0,d,e);return AI(l,
-null,k,a)}},lca=function II(a,b,c,d,e){switch(c){case 0:return null;case 1:var h=d.t();if(null===h)throw new x(h);return aI(b!==e||1===b,h.i(),h.j(),null,null);default:var k=(-1+c|0)/2|0;h=II(a,1+b|0,k,d,e);var l=d.t();if(null===l)throw new x(l);var m=l.i();l=l.j();b=II(a,1+b|0,(-1+c|0)-k|0,d,e);return AI(m,l,h,b)}},mca=function JI(a,b,c){var e=b.Wa,g=b.Tb,h=b.ra,k=b.sa,l=null===h?null:JI(a,h,c),m=!!c.aa(e,g);c=null===k?null:JI(a,k,c);return m?l===h&&c===k?b:oI(a,l,e,g,c):FI(a,l,c)};
-function KI(a,b){if(null===a)throw ze();return a.qb?a.sb:Ce(a,new LI(b))}function MI(a){for(var b=0;;){if(null===a)return 1+b|0;b=0>a.da?1+b|0:b;a=a.ra}}function NI(){this.hS=null;OI=this;this.hS=G(new H,null,null)}NI.prototype=new p;NI.prototype.constructor=NI;function PI(a,b,c,d){for(;;){if(null===b)return null;a=d.Fa(c,b.Wa);if(0>a)b=b.ra;else if(0<a)b=b.sa;else return b}}function nI(a,b){return null===b?0:2147483647&b.da}function QI(a,b,c,d,e,g){return ZH(Zba(a,b,c,d,e,g))}
-function RI(a,b){if(null===b)throw iH("empty tree");for(a=b;;)if(null!==a.ra)a=a.ra;else break;return a}function SI(a,b){if(null===b)throw iH("empty tree");for(a=b;;)if(null!==a.sa)a=a.sa;else break;return a}function kI(a,b,c,d){return new bI(a,b,c,d,1+((null===c?0:2147483647&c.da)+(null===d?0:2147483647&d.da)|0)|0)}function AI(a,b,c,d){return new bI(a,b,c,d,1+((null===c?0:2147483647&c.da)+(null===d?0:2147483647&d.da)|0)|-2147483648)}
-function TI(a,b,c){var d=32-Math.clz32(c)|0;return kca(a,1,c,d,b)}function UI(a,b,c){return null===b?null:ZH(mca(a,b,c))}function nca(a,b,c){if(null===b)return G(new H,null,null);if(null===b)return a.hS;a=new xf;VI(a.qb?a.sb:KI(a,c),b);return G(new H,ZH((a.qb?a.sb:KI(a,c)).EG),ZH((a.qb?a.sb:KI(a,c)).DG))}function WI(a,b,c,d){return ZH(jca(a,b,c,d))}
-function oI(a,b,c,d,e){var g=MI(b),h=MI(e);return g>h?(a=eca(a,b,c,d,e,g,null===e?0:0>e.da?(-1+h|0)<<1:-1+(h<<1)|0),null!==a&&0<=a.da?(b=a.sa,b=null!==b&&0<=b.da):b=!1,b?$H(a):a):h>g?(a=gca(a,b,c,d,e,null===b?0:0>b.da?(-1+g|0)<<1:-1+(g<<1)|0,h),null!==a&&0<=a.da?(b=a.ra,b=null!==b&&0<=b.da):b=!1,b?$H(a):a):aI(null!==b&&0<=b.da||null!==e&&0<=e.da,c,d,b,e)}function FI(a,b,c){if(null===b)return c;if(null===c)return b;b=ica(a,b);if(null===b)throw new x(b);return oI(a,b.ec,b.gb,b.xd,c)}
-NI.prototype.$classData=q({v7:0},!1,"scala.collection.immutable.RedBlackTree$",{v7:1,d:1});var OI;function XI(){OI||(OI=new NI);return OI}function YI(){this.Ik=null}YI.prototype=new p;YI.prototype.constructor=YI;function ZI(){}ZI.prototype=YI.prototype;function $I(a){return null===a?a:0===(2147483647&a.da)?aJ(bJ(a)):$H(a)}
-function cJ(a,b){if(0<=b.da){var c=b.ra,d=b.sa;if(XI(),null!==c&&0<=c.da)return c=bJ(c),d=dJ(a,d),eJ(b,c,d);if(XI(),null!==d&&0<=d.da)return c=d.sa,b=fJ(b,d.ra),a=dJ(a,c),eJ(d,b,a)}a.ra===b?d=a:0===(2147483647&a.da)?(a.ra=b,d=a):d=new bI(a.Wa,a.Tb,b,a.sa,-2147483648&a.da);return d}
-function gJ(a,b){if(0<=b.da){var c=b.ra;if(XI(),null!==c&&0<=c.da){var d=fJ(a,c.ra);b=dJ(b,c.sa);return eJ(c,d,b)}d=b.sa;if(XI(),null!==d&&0<=d.da)return c=fJ(a,c),d=bJ(d),eJ(b,c,d)}a.sa===b?b=a:0===(2147483647&a.da)?(a.sa=b,b=a):b=new bI(a.Wa,a.Tb,a.ra,b,-2147483648&a.da);return b}function bI(a,b,c,d,e){this.Wa=a;this.Tb=b;this.ra=c;this.sa=d;this.da=e}bI.prototype=new p;bI.prototype.constructor=bI;
-bI.prototype.u=function(){return(0<=this.da?"RedTree":"BlackTree")+"("+this.Wa+", "+this.Tb+", "+this.ra+", "+this.sa+")"};function aJ(a){if(0===(2147483647&a.da)){var b=1;null!==a.ra&&(aJ(a.ra),b=b+(2147483647&a.ra.da)|0);null!==a.sa&&(aJ(a.sa),b=b+(2147483647&a.sa.da)|0);a.da|=b}return a}function bJ(a){return 0>a.da?a:0===(2147483647&a.da)?(a.da=-2147483648,a):new bI(a.Wa,a.Tb,a.ra,a.sa,-2147483648)}
-function hJ(a,b){return Object.is(b,a.Tb)?a:0===(2147483647&a.da)?(a.Tb=b,a):new bI(a.Wa,b,a.ra,a.sa,-2147483648&a.da)}function eJ(a,b,c){return a.ra===b&&a.sa===c?a:0===(2147483647&a.da)?(a.ra=b,a.sa=c,a):new bI(a.Wa,a.Tb,b,c,-2147483648&a.da)}function dJ(a,b){return a.ra===b&&0>a.da?a:0===(2147483647&a.da)?(a.da=-2147483648,a.ra=b,a):new bI(a.Wa,a.Tb,b,a.sa,-2147483648)}
-function fJ(a,b){return a.sa===b&&0>a.da?a:0===(2147483647&a.da)?(a.da=-2147483648,a.sa=b,a):new bI(a.Wa,a.Tb,a.ra,b,-2147483648)}function $H(a){return 0>a.da?a:new bI(a.Wa,a.Tb,a.ra,a.sa,-2147483648^a.da)}function vI(a){return 0<=a.da?a:new bI(a.Wa,a.Tb,a.ra,a.sa,-2147483648^a.da)}function lI(a,b){return Object.is(b,a.Tb)?a:new bI(a.Wa,b,a.ra,a.sa,a.da)}
-function gI(a,b){if(b===a.ra)return a;var c=a.sa;return new bI(a.Wa,a.Tb,b,a.sa,-2147483648&a.da|1+((null===b?0:2147483647&b.da)+(null===c?0:2147483647&c.da)|0)|0)}function iI(a,b){if(b===a.sa)return a;var c=a.ra;return new bI(a.Wa,a.Tb,a.ra,b,-2147483648&a.da|1+((null===c?0:2147483647&c.da)+(null===b?0:2147483647&b.da)|0)|0)}function eI(a,b){if(b===a.ra&&0>a.da)return a;var c=a.sa;return new bI(a.Wa,a.Tb,b,a.sa,1+((null===b?0:2147483647&b.da)+(null===c?0:2147483647&c.da)|0)|-2147483648)}
-function fI(a,b){if(b===a.sa&&0>a.da)return a;var c=a.ra;return new bI(a.Wa,a.Tb,a.ra,b,1+((null===c?0:2147483647&c.da)+(null===b?0:2147483647&b.da)|0)|-2147483648)}function dI(a,b,c){return b===a.ra&&c===a.sa?a:new bI(a.Wa,a.Tb,b,c,-2147483648&a.da|1+((null===b?0:2147483647&b.da)+(null===c?0:2147483647&c.da)|0)|0)}function tI(a,b,c){return b===a.ra&&c===a.sa&&0<=a.da?a:new bI(a.Wa,a.Tb,b,c,1+((null===b?0:2147483647&b.da)+(null===c?0:2147483647&c.da)|0)|0)}
-function wI(a,b,c){return b===a.ra&&c===a.sa&&0>a.da?a:new bI(a.Wa,a.Tb,b,c,1+((null===b?0:2147483647&b.da)+(null===c?0:2147483647&c.da)|0)|-2147483648)}var iJ=q({A7:0},!1,"scala.collection.immutable.RedBlackTree$Tree",{A7:1,d:1});bI.prototype.$classData=iJ;function LI(a){this.C7=a;this.DG=this.EG=null}LI.prototype=new p;LI.prototype.constructor=LI;
-function VI(a,b){var c=b.Wa,d=b.Tb,e=b.ra,g=b.sa,h=null,k=null,l=null,m=null;null!==e&&(VI(a,e),h=a.EG,k=a.DG);var n=!!a.C7.aa(c,d);null!==g&&(VI(a,g),l=a.EG,m=a.DG);h=n?h===e&&l===g?b:oI(XI(),h,c,d,l):FI(XI(),h,l);b=n?FI(XI(),k,m):k===e&&m===g?b:oI(XI(),k,c,d,m);a.EG=h;a.DG=b}LI.prototype.$classData=q({B7:0},!1,"scala.collection.immutable.RedBlackTree$partitioner$1$",{B7:1,d:1});function jJ(){this.Lv=null;kJ=this;this.Lv=new lJ(0,0,(KH(),new jd(0)),(Rl(),new zd(0)),0,0)}jJ.prototype=new p;
-jJ.prototype.constructor=jJ;jJ.prototype.$classData=q({R7:0},!1,"scala.collection.immutable.SetNode$",{R7:1,d:1});var kJ;function mJ(){kJ||(kJ=new jJ);return kJ}
-var pca=function oca(a,b,c,d,e){for(;;){if(1===b){b=c;var h=d,k=e;nJ(a,1,0===h&&k===b.a.length?b:ck(fk(),b,h,k))}else{h=Math.imul(5,-1+b|0);var l=1<<h;k=d>>>h|0;h=e>>>h|0;d&=-1+l|0;e&=-1+l|0;if(0===d)if(0===e)e=c,nJ(a,b,0===k&&h===e.a.length?e:ck(fk(),e,k,h));else{h>k&&(d=c,nJ(a,b,0===k&&h===d.a.length?d:ck(fk(),d,k,h)));h=c.a[h];b=-1+b|0;c=h;d=0;continue}else if(h===k){h=c.a[k];b=-1+b|0;c=h;continue}else if(oca(a,-1+b|0,c.a[k],d,l),0===e)h>(1+k|0)&&(e=c,k=1+k|0,nJ(a,b,0===k&&h===e.a.length?e:ck(fk(),
-e,k,h)));else{h>(1+k|0)&&(d=c,k=1+k|0,nJ(a,b,0===k&&h===d.a.length?d:ck(fk(),d,k,h)));h=c.a[h];b=-1+b|0;c=h;d=0;continue}}break}};function nJ(a,b,c){b<=a.Jk?b=11-b|0:(a.Jk=b,b=-1+b|0);a.jb.a[b]=c}
-var rca=function qca(a,b){if(null===a.jb.a[-1+b|0])if(b===a.Jk)a.jb.a[-1+b|0]=a.jb.a[11-b|0],a.jb.a[11-b|0]=null;else{qca(a,1+b|0);var d=a.jb.a[-1+(1+b|0)|0];a.jb.a[-1+b|0]=d.a[0];if(1===d.a.length)a.jb.a[-1+(1+b|0)|0]=null,a.Jk===(1+b|0)&&null===a.jb.a[11-(1+b|0)|0]&&(a.Jk=b);else{var e=d.a.length;a.jb.a[-1+(1+b|0)|0]=ck(fk(),d,1,e)}}},tca=function sca(a,b){if(null===a.jb.a[11-b|0])if(b===a.Jk)a.jb.a[11-b|0]=a.jb.a[-1+b|0],a.jb.a[-1+b|0]=null;else{sca(a,1+b|0);var d=a.jb.a[11-(1+b|0)|0];a.jb.a[11-
-b|0]=d.a[-1+d.a.length|0];if(1===d.a.length)a.jb.a[11-(1+b|0)|0]=null,a.Jk===(1+b|0)&&null===a.jb.a[-1+(1+b|0)|0]&&(a.Jk=b);else{var e=-1+d.a.length|0;a.jb.a[11-(1+b|0)|0]=ck(fk(),d,0,e)}}};function oJ(a,b){this.jb=null;this.Jk=this.Ey=this.eo=0;this.rS=a;this.qS=b;this.jb=new (Nd(Nd(Md)).Ja)(11);this.Jk=this.Ey=this.eo=0}oJ.prototype=new p;oJ.prototype.constructor=oJ;
-function pJ(a,b,c){var d=Math.imul(c.a.length,1<<Math.imul(5,-1+b|0)),e=a.rS-a.Ey|0;e=0<e?e:0;var g=a.qS-a.Ey|0;g=g<d?g:d;g>e&&(pca(a,b,c,e,g),a.eo=a.eo+(g-e|0)|0);a.Ey=a.Ey+d|0}
-oJ.prototype.Vl=function(){if(32>=this.eo){if(0===this.eo)return qJ();var a=this.jb.a[0],b=this.jb.a[10];if(null!==a)if(null!==b){var c=a.a.length+b.a.length|0,d=Tj(fk(),a,c);b.va(0,d,a.a.length,b.a.length);var e=d}else e=a;else if(null!==b)e=b;else{var g=this.jb.a[1];e=null!==g?g.a[0]:this.jb.a[9].a[0]}return new rJ(e)}rca(this,1);tca(this,1);var h=this.Jk;if(6>h){var k=this.jb.a[-1+this.Jk|0],l=this.jb.a[11-this.Jk|0];if(null!==k&&null!==l)if(30>=(k.a.length+l.a.length|0)){var m=this.jb,n=this.Jk,
-r=k.a.length+l.a.length|0,u=Tj(fk(),k,r);l.va(0,u,k.a.length,l.a.length);m.a[-1+n|0]=u;this.jb.a[11-this.Jk|0]=null}else h=1+h|0;else 30<(null!==k?k:l).a.length&&(h=1+h|0)}var w=this.jb.a[0],y=this.jb.a[10],B=w.a.length,D=h;switch(D){case 2:var C=sJ().Sc,F=this.jb.a[1];if(null!==F)var I=F;else{var K=this.jb.a[9];I=null!==K?K:C}var N=new tJ(w,B,I,y,this.eo);break;case 3:var P=sJ().Sc,T=this.jb.a[1],aa=null!==T?T:P,Y=sJ().Xf,S=this.jb.a[2];if(null!==S)var Z=S;else{var ka=this.jb.a[8];Z=null!==ka?ka:
-Y}var X=Z,sa=sJ().Sc,Ia=this.jb.a[9];N=new uJ(w,B,aa,B+(aa.a.length<<5)|0,X,null!==Ia?Ia:sa,y,this.eo);break;case 4:var Za=sJ().Sc,Ga=this.jb.a[1],xa=null!==Ga?Ga:Za,Ra=sJ().Xf,Ja=this.jb.a[2],La=null!==Ja?Ja:Ra,pb=sJ().Zj,Fb=this.jb.a[3];if(null!==Fb)var Gb=Fb;else{var Hb=this.jb.a[7];Gb=null!==Hb?Hb:pb}var tb=Gb,kb=sJ().Xf,gb=this.jb.a[8],Vb=null!==gb?gb:kb,bb=sJ().Sc,nb=this.jb.a[9],Tb=B+(xa.a.length<<5)|0;N=new vJ(w,B,xa,Tb,La,Tb+(La.a.length<<10)|0,tb,Vb,null!==nb?nb:bb,y,this.eo);break;case 5:var ub=
-sJ().Sc,Ub=this.jb.a[1],$a=null!==Ub?Ub:ub,cb=sJ().Xf,Na=this.jb.a[2],Ca=null!==Na?Na:cb,Ba=sJ().Zj,Oa=this.jb.a[3],wa=null!==Oa?Oa:Ba,ea=sJ().wt,la=this.jb.a[4];if(null!==la)var Ka=la;else{var Ua=this.jb.a[6];Ka=null!==Ua?Ua:ea}var ya=Ka,ib=sJ().Zj,Lb=this.jb.a[7],ec=null!==Lb?Lb:ib,Mb=sJ().Xf,Jb=this.jb.a[8],Kb=null!==Jb?Jb:Mb,eb=sJ().Sc,Wb=this.jb.a[9],mc=B+($a.a.length<<5)|0,ua=mc+(Ca.a.length<<10)|0;N=new wJ(w,B,$a,mc,Ca,ua,wa,ua+(wa.a.length<<15)|0,ya,ec,Kb,null!==Wb?Wb:eb,y,this.eo);break;
-case 6:var Pa=sJ().Sc,xb=this.jb.a[1],Yb=null!==xb?xb:Pa,zb=sJ().Xf,Sb=this.jb.a[2],Ma=null!==Sb?Sb:zb,Ea=sJ().Zj,ab=this.jb.a[3],Db=null!==ab?ab:Ea,mb=sJ().wt,vb=this.jb.a[4],Ya=null!==vb?vb:mb,Wa=sJ().IG,rb=this.jb.a[5];if(null!==rb)var pa=rb;else{var Fa=this.jb.a[5];pa=null!==Fa?Fa:Wa}var Ib=pa,qb=sJ().wt,Nb=this.jb.a[6],fc=null!==Nb?Nb:qb,Ac=sJ().Zj,tc=this.jb.a[7],vc=null!==tc?tc:Ac,sc=sJ().Xf,uc=this.jb.a[8],lc=null!==uc?uc:sc,Wc=sJ().Sc,Cc=this.jb.a[9],Dc=B+(Yb.a.length<<5)|0,Ec=Dc+(Ma.a.length<<
-10)|0,Ic=Ec+(Db.a.length<<15)|0;N=new xJ(w,B,Yb,Dc,Ma,Ec,Db,Ic,Ya,Ic+(Ya.a.length<<20)|0,Ib,fc,vc,lc,null!==Cc?Cc:Wc,y,this.eo);break;default:throw new x(D);}return N};oJ.prototype.u=function(){return"VectorSliceBuilder(lo\x3d"+this.rS+", hi\x3d"+this.qS+", len\x3d"+this.eo+", pos\x3d"+this.Ey+", maxDim\x3d"+this.Jk+")"};oJ.prototype.$classData=q({s8:0},!1,"scala.collection.immutable.VectorSliceBuilder",{s8:1,d:1});
-function yJ(){this.IG=this.wt=this.Zj=this.Xf=this.Sc=this.xL=null;zJ=this;this.xL=new jd(0);this.Sc=new (Nd(Nd(Md)).Ja)(0);this.Xf=new (Nd(Nd(Nd(Md))).Ja)(0);this.Zj=new (Nd(Nd(Nd(Nd(Md)))).Ja)(0);this.wt=new (Nd(Nd(Nd(Nd(Nd(Md))))).Ja)(0);this.IG=new (Nd(Nd(Nd(Nd(Nd(Nd(Md)))))).Ja)(0)}yJ.prototype=new p;yJ.prototype.constructor=yJ;function AJ(a,b,c){a=b.a.length;var d=new jd(1+a|0);b.va(0,d,0,a);d.a[a]=c;return d}
-function BJ(a,b,c){a=1+b.a.length|0;b=Tj(fk(),b,a);b.a[-1+b.a.length|0]=c;return b}function CJ(a,b,c){a=new jd(1+c.a.length|0);c.va(0,a,1,c.a.length);a.a[0]=b;return a}function DJ(a,b,c){a=Gg(ja(c));var d=1+c.a.length|0;a=Fh(Jh(),a,d);c.va(0,a,1,c.a.length);a.a[0]=b;return a}function EJ(a,b,c,d){var e=0,g=c.a.length;if(0===b)for(;e<g;)d.n(c.a[e]),e=1+e|0;else for(b=-1+b|0;e<g;)EJ(a,b,c.a[e],d),e=1+e|0}
-function FJ(a,b,c){for(var d=0;d<b.a.length;){var e=b.a[d];a=c.n(e);if(!Object.is(e,a)){e=a;a=new jd(b.a.length);0<d&&b.va(0,a,0,d);a.a[d]=e;for(d=1+d|0;d<b.a.length;)a.a[d]=c.n(b.a[d]),d=1+d|0;return a}d=1+d|0}return b}function GJ(a,b,c,d){if(1===b)return FJ(0,c,d);for(var e=0;e<c.a.length;){var g=c.a[e],h=GJ(a,-1+b|0,g,d);if(g!==h){g=Gg(ja(c));var k=c.a.length;g=Fh(Jh(),g,k);0<e&&c.va(0,g,0,e);g.a[e]=h;for(h=1+e|0;h<c.a.length;)g.a[h]=GJ(a,-1+b|0,c.a[h],d),h=1+h|0;return g}e=1+e|0}return c}
-function HJ(a,b,c){if(IJ(c))if(0>=c.Pk(32-b.a.length|0))switch(a=c.ka(),a){case 0:return null;case 1:return BJ(0,b,c.e());default:return a=b.a.length+a|0,a=Tj(fk(),b,a),c.yc(a,b.a.length,2147483647),a}else return null;else return a=c.Q(),0<a&&a<=(32-b.a.length|0)?(a=b.a.length+a|0,a=Tj(fk(),b,a),c.m().yc(a,b.a.length,2147483647),a):null}yJ.prototype.$classData=q({t8:0},!1,"scala.collection.immutable.VectorStatics$",{t8:1,d:1});var zJ;function sJ(){zJ||(zJ=new yJ);return zJ}
-var JJ=q({DL:0},!0,"scala.collection.mutable.HashEntry",{DL:1,d:1});function KJ(a,b,c,d){this.Kk=a;this.bk=b;this.ph=c;this.Id=d}KJ.prototype=new p;KJ.prototype.constructor=KJ;function ey(a,b,c){for(;;){if(c===a.bk&&Ol(Pl(),b,a.Kk))return a;if(null===a.Id||a.bk>c)return null;a=a.Id}}KJ.prototype.ya=function(a){for(var b=this;;)if(a.n(G(new H,b.Kk,b.ph)),null!==b.Id)b=b.Id;else break};KJ.prototype.Ag=function(a){for(var b=this;;)if(a.aa(b.Kk,b.ph),null!==b.Id)b=b.Id;else break};
-KJ.prototype.u=function(){return"Node("+this.Kk+", "+this.ph+", "+this.bk+") -\x3e "+this.Id};var LJ=q({g9:0},!1,"scala.collection.mutable.HashMap$Node",{g9:1,d:1});KJ.prototype.$classData=LJ;function MJ(a,b,c){this.Lk=a;this.ck=b;this.He=c}MJ.prototype=new p;MJ.prototype.constructor=MJ;MJ.prototype.ya=function(a){for(var b=this;;)if(a.n(b.Lk),null!==b.He)b=b.He;else break};MJ.prototype.u=function(){return"Node("+this.Lk+", "+this.ck+") -\x3e "+this.He};
-var NJ=q({n9:0},!1,"scala.collection.mutable.HashSet$Node",{n9:1,d:1});MJ.prototype.$classData=NJ;function OJ(){}OJ.prototype=new p;OJ.prototype.constructor=OJ;function PJ(a,b,c){a=c>>31;var d=b>>31,e=65535&c,g=c>>>16|0,h=65535&b,k=b>>>16|0,l=Math.imul(e,h);h=Math.imul(g,h);var m=Math.imul(e,k);e=l+((h+m|0)<<16)|0;l=(l>>>16|0)+m|0;b=(((Math.imul(c,d)+Math.imul(a,b)|0)+Math.imul(g,k)|0)+(l>>>16|0)|0)+(((65535&l)+h|0)>>>16|0)|0;return ki(Cb(),e,b,1E3,0)}
-OJ.prototype.$classData=q({p9:0},!1,"scala.collection.mutable.HashTable$",{p9:1,d:1});var QJ;function RJ(){QJ||(QJ=new OJ);return QJ}function SJ(){}SJ.prototype=new p;SJ.prototype.constructor=SJ;function TJ(a,b){if(b!==a)throw new UJ;}SJ.prototype.$classData=q({J9:0},!1,"scala.collection.mutable.MutationTracker$",{J9:1,d:1});var VJ;function WJ(){VJ||(VJ=new SJ)}function XJ(a,b,c){for(;;){if(null===a)return null;var d=c.Fa(b,a.ho);if(0>d)a=a.Oc;else if(0<d)a=a.uc;else return a}}
-function YJ(a,b){if(null!==b){var c=b.uc;b.uc=c.Oc;null!==c.Oc&&(c.Oc.ab=b);c.ab=b.ab;null===b.ab?a.ni=c:b===b.ab.Oc?b.ab.Oc=c:b.ab.uc=c;c.Oc=b;b.ab=c}}function ZJ(a,b){if(null!==b){var c=b.Oc;b.Oc=c.uc;null!==c.uc&&(c.uc.ab=b);c.ab=b.ab;null===b.ab?a.ni=c:b===b.ab.uc?b.ab.uc=c:b.ab.Oc=c;c.uc=b;b.ab=c}}function $J(a,b,c){null===b.ab?a.ni=c:b===b.ab.Oc?b.ab.Oc=c:b.ab.uc=c;null!==c&&(c.ab=b.ab)}
-var vca=function uca(a,b,c){for(;;)if(null!==b.Oc&&uca(a,b.Oc,c),c.n(G(new H,b.ho,b.lr)),null!==b.uc)b=b.uc;else break},xca=function wca(a,b,c){for(;;){var e=b.Oc;null!==e&&wca(a,e,c);c.aa(b.ho,b.lr);b=b.uc;if(null===b)break}};function aK(){}aK.prototype=new p;aK.prototype.constructor=aK;function bK(a){return null!==a&&a.Pc}function cK(a){return null===a||!a.Pc}function dK(a){for(;;){if(null===a.Oc)return a;a=a.Oc}}
-function eK(a,b){if(null!==b.uc)return dK(b.uc);a=b;for(b=a.ab;null!==b&&a===b.uc;)a=b,b=b.ab;return b}aK.prototype.$classData=q({O9:0},!1,"scala.collection.mutable.RedBlackTree$",{O9:1,d:1});var fK;function gK(){fK||(fK=new aK);return fK}function hK(a,b,c,d,e,g){this.ho=a;this.lr=b;this.Pc=c;this.Oc=d;this.uc=e;this.ab=g}hK.prototype=new p;hK.prototype.constructor=hK;hK.prototype.u=function(){return"Node("+this.ho+", "+this.lr+", "+this.Pc+", "+this.Oc+", "+this.uc+")"};
-hK.prototype.$classData=q({R9:0},!1,"scala.collection.mutable.RedBlackTree$Node",{R9:1,d:1});function iK(a,b){this.ni=a;this.Ly=b}iK.prototype=new p;iK.prototype.constructor=iK;iK.prototype.$classData=q({S9:0},!1,"scala.collection.mutable.RedBlackTree$Tree",{S9:1,d:1});
-function jK(a,b){if(b instanceof fa)return b=Eb(b),a.FJ()&&a.Ri()===b;if(dd(b))return b|=0,a.EJ()&&a.MA()===b;if(fd(b))return b|=0,a.GJ()&&a.gC()===b;if(oa(b))return b|=0,a.oF()&&a.Ri()===b;if(b instanceof fb){var c=Qb(b);b=c.W;c=c.Z;a=a.ll();return a.W===b&&a.Z===c}return va(b)?(b=Math.fround(b),a.Pu()===b):"number"===typeof b?(b=+b,a.ap()===b):!1}
-function kK(){this.dR=this.c=this.eR=this.cR=this.bR=this.aR=null;this.bt=0;lK=this;mK();this.cR=mK();nK();Pe();qq();this.eR=je();this.c=v();this.dR=oK();pK();mu();qK||(qK=new rK);sK||(sK=new tK);uK||(uK=new vK)}kK.prototype=new p;kK.prototype.constructor=kK;function jr(){var a=O();0===(2&a.bt)<<24>>24&&0===(2&a.bt)<<24>>24&&(a.bR=wK(),a.bt=(2|a.bt)<<24>>24);return a.bR}kK.prototype.$classData=q({n3:0},!1,"scala.package$",{n3:1,d:1});var lK;function O(){lK||(lK=new kK);return lK}function xK(){}
-xK.prototype=new p;xK.prototype.constructor=xK;function Ol(a,b,c){if(b===c)c=!0;else if(yK(b))a:if(yK(c))c=zK(0,b,c);else{if(c instanceof fa){if("number"===typeof b){c=+b===Eb(c);break a}if(b instanceof fb){a=Qb(b);b=a.Z;c=Eb(c);c=a.W===c&&b===c>>31;break a}}c=null===b?null===c:Pb(b,c)}else c=b instanceof fa?yca(b,c):null===b?null===c:Pb(b,c);return c}
-function zK(a,b,c){if("number"===typeof b)return a=+b,"number"===typeof c?a===+c:c instanceof fb?(b=Qb(c),c=b.W,b=b.Z,a===KF(Cb(),c,b)):c instanceof gH?c.h(a):!1;if(b instanceof fb){b=Qb(b);a=b.W;b=b.Z;if(c instanceof fb){c=Qb(c);var d=c.Z;return a===c.W&&b===d}return"number"===typeof c?(c=+c,KF(Cb(),a,b)===c):c instanceof gH?c.h(new fb(a,b)):!1}return null===b?null===c:Pb(b,c)}
-function yca(a,b){if(b instanceof fa)return Eb(a)===Eb(b);if(yK(b)){if("number"===typeof b)return+b===Eb(a);if(b instanceof fb){b=Qb(b);var c=b.Z;a=Eb(a);return b.W===a&&c===a>>31}return null===b?null===a:Pb(b,a)}return null===a&&null===b}xK.prototype.$classData=q({s$:0},!1,"scala.runtime.BoxesRunTime$",{s$:1,d:1});var AK;function Pl(){AK||(AK=new xK);return AK}var SG=q({y$:0},!1,"scala.runtime.Null$",{y$:1,d:1});function BK(){}BK.prototype=new p;BK.prototype.constructor=BK;
-BK.prototype.$classData=q({B$:0},!1,"scala.runtime.RichInt$",{B$:1,d:1});var CK;function DK(){}DK.prototype=new p;DK.prototype.constructor=DK;function EG(a,b,c){if(b instanceof jd||b instanceof zd||b instanceof Dd||b instanceof Ad||b instanceof Bd)return b.a[c];if(b instanceof td)return hd(b.a[c]);if(b instanceof vd||b instanceof wd||b instanceof pd)return b.a[c];if(null===b)throw ze();throw new x(b);}
-function OG(a,b,c,d){if(b instanceof jd)b.a[c]=d;else if(b instanceof zd)b.a[c]=d|0;else if(b instanceof Dd)b.a[c]=+d;else if(b instanceof Ad)b.a[c]=Qb(d);else if(b instanceof Bd)b.a[c]=Math.fround(d);else if(b instanceof td)b.a[c]=Eb(d);else if(b instanceof vd)b.a[c]=d|0;else if(b instanceof wd)b.a[c]=d|0;else if(b instanceof pd)b.a[c]=!!d;else{if(null===b)throw ze();throw new x(b);}}
-function dG(a,b){Jh();if(b instanceof jd||b instanceof pd||b instanceof td||b instanceof vd||b instanceof wd||b instanceof zd||b instanceof Ad||b instanceof Bd||b instanceof Dd)a=b.a.length;else throw dk("argument type mismatch");return a}function rG(a,b){if(b instanceof jd||b instanceof zd||b instanceof Dd||b instanceof Ad||b instanceof Bd||b instanceof td||b instanceof vd||b instanceof wd||b instanceof pd)return b.ga();if(null===b)throw ze();throw new x(b);}
-function EK(a){eG();return Qe(new DC(a),a.H()+"(",",",")")}DK.prototype.$classData=q({C$:0},!1,"scala.runtime.ScalaRunTime$",{C$:1,d:1});var FK;function eG(){FK||(FK=new DK);return FK}function GK(){}GK.prototype=new p;GK.prototype.constructor=GK;GK.prototype.B=function(a,b){a=this.dp(a,b);return-430675100+Math.imul(5,a<<13|a>>>19|0)|0};GK.prototype.dp=function(a,b){b=Math.imul(-862048943,b);b=Math.imul(461845907,b<<15|b>>>17|0);return a^b};
-GK.prototype.La=function(a,b){a^=b;a=Math.imul(-2048144789,a^(a>>>16|0));a=Math.imul(-1028477387,a^(a>>>13|0));return a^(a>>>16|0)};function HK(a,b){a=b.W;b=b.Z;return b===a>>31?a:a^b}function IK(a,b){a=Mc(b);if(a===b)return a;a=Cb();if(-0x7fffffffffffffff>b){a.Kc=-2147483648;var c=0}else if(0x7fffffffffffffff<=b)a.Kc=2147483647,c=-1;else{c=b|0;var d=b/4294967296|0;a.Kc=0>b&&0!==c?-1+d|0:d}a=a.Kc;return KF(Cb(),c,a)===b?c^a:Mg(Qg(),b)}
-function dy(a,b){return null===b?0:"number"===typeof b?IK(0,+b):b instanceof fb?(a=Qb(b),HK(0,new fb(a.W,a.Z))):bc(b)}function JK(a,b){throw KK(new LK,""+b);}GK.prototype.$classData=q({F$:0},!1,"scala.runtime.Statics$",{F$:1,d:1});var MK;function W(){MK||(MK=new GK);return MK}function NK(){}NK.prototype=new p;NK.prototype.constructor=NK;NK.prototype.$classData=q({G$:0},!1,"scala.runtime.Statics$PFMarker$",{G$:1,d:1});var OK;function PK(){OK||(OK=new NK);return OK}function QK(){}QK.prototype=new p;
-QK.prototype.constructor=QK;function xI(){RK||(RK=new QK);throw SK("Defect: invariance violation");}QK.prototype.$classData=q({D3:0},!1,"scala.sys.package$",{D3:1,d:1});var RK;function Qx(){}Qx.prototype=new p;Qx.prototype.constructor=Qx;function zaa(a,b){b.n(a);return a}Qx.prototype.$classData=q({E3:0},!1,"scala.util.ChainingOps$",{E3:1,d:1});var Px;function TK(a){this.fR=a}TK.prototype=new p;TK.prototype.constructor=TK;TK.prototype.u=function(){return"DynamicVariable("+this.fR+")"};
-TK.prototype.$classData=q({F3:0},!1,"scala.util.DynamicVariable",{F3:1,d:1});function UK(){}UK.prototype=new p;UK.prototype.constructor=UK;
-function VK(a,b,c,d){c=c-b|0;if(!(2>c)){if(0<d.Fa(EG(eG(),a,b),EG(eG(),a,1+b|0))){var e=EG(eG(),a,b);OG(eG(),a,b,EG(eG(),a,1+b|0));OG(eG(),a,1+b|0,e)}for(e=2;e<c;){var g=EG(eG(),a,b+e|0);if(0>d.Fa(g,EG(eG(),a,-1+(b+e|0)|0))){for(var h=b,k=-1+(b+e|0)|0;1<(k-h|0);){var l=(h+k|0)>>>1|0;0>d.Fa(g,EG(eG(),a,l))?k=l:h=l}h=h+(0>d.Fa(g,EG(eG(),a,h))?0:1)|0;for(k=b+e|0;k>h;)OG(eG(),a,k,EG(eG(),a,-1+k|0)),k=-1+k|0;OG(eG(),a,h,g)}e=1+e|0}}}
-function WK(a,b,c,d,e,g,h){if(32>(d-c|0))VK(b,c,d,e);else{var k=(c+d|0)>>>1|0;g=null===g?h.gi(k-c|0):g;WK(a,b,c,k,e,g,h);WK(a,b,k,d,e,g,h);XK(b,c,k,d,e,g)}}function XK(a,b,c,d,e,g){if(0<e.Fa(EG(eG(),a,-1+c|0),EG(eG(),a,c))){for(var h=b,k=c-b|0,l=0;h<c;)OG(eG(),g,l,EG(eG(),a,h)),h=1+h|0,l=1+l|0;for(l=0;h<d&&l<k;)0>e.Fa(EG(eG(),a,h),EG(eG(),g,l))?(OG(eG(),a,b,EG(eG(),a,h)),h=1+h|0):(OG(eG(),a,b,EG(eG(),g,l)),l=1+l|0),b=1+b|0;for(;l<k;)OG(eG(),a,b,EG(eG(),g,l)),l=1+l|0,b=1+b|0}}
-function yG(a,b,c,d){if(b instanceof jd){if(1<dG(eG(),b)&&null===d)throw YK("Ordering");a=fk();d=null===d?yj():d;var e=zj();if(0>c)throw dk("fromIndex(0) \x3e toIndex("+c+")");if(16<(c-0|0)){var g=b.a.length,h=ja(b);lj(a,b,Fh(Jh(),Gg(h),g),0,c,d,e)}else oj(b,0,c,d,e)}else if(b instanceof zd)if(d===dq())jj(fk(),b);else if(e=Rl(),32>(c-0|0))VK(b,0,c,d);else{g=(0+c|0)>>>1|0;h=new zd(g-0|0);if(32>(g-0|0))VK(b,0,g,d);else{var k=(0+g|0)>>>1|0;WK(a,b,0,k,d,h,e);WK(a,b,k,g,d,h,e);XK(b,0,k,g,d,h)}32>(c-g|
-0)?VK(b,g,c,d):(k=(g+c|0)>>>1|0,WK(a,b,g,k,d,h,e),WK(a,b,k,c,d,h,e),XK(b,g,k,c,d,h));XK(b,0,g,c,d,h)}else if(b instanceof Dd)e=ZK(),32>(c-0|0)?VK(b,0,c,d):(g=(0+c|0)>>>1|0,h=new Dd(g-0|0),32>(g-0|0)?VK(b,0,g,d):(k=(0+g|0)>>>1|0,WK(a,b,0,k,d,h,e),WK(a,b,k,g,d,h,e),XK(b,0,k,g,d,h)),32>(c-g|0)?VK(b,g,c,d):(k=(g+c|0)>>>1|0,WK(a,b,g,k,d,h,e),WK(a,b,k,c,d,h,e),XK(b,g,k,c,d,h)),XK(b,0,g,c,d,h));else if(b instanceof Ad)d===sG()?pj(fk(),b):(e=$K(),32>(c-0|0)?VK(b,0,c,d):(g=(0+c|0)>>>1|0,h=new Ad(g-0|0),32>
-(g-0|0)?VK(b,0,g,d):(k=(0+g|0)>>>1|0,WK(a,b,0,k,d,h,e),WK(a,b,k,g,d,h,e),XK(b,0,k,g,d,h)),32>(c-g|0)?VK(b,g,c,d):(k=(g+c|0)>>>1|0,WK(a,b,g,k,d,h,e),WK(a,b,k,c,d,h,e),XK(b,g,k,c,d,h)),XK(b,0,g,c,d,h)));else if(b instanceof Bd)e=aL(),32>(c-0|0)?VK(b,0,c,d):(g=(0+c|0)>>>1|0,h=new Bd(g-0|0),32>(g-0|0)?VK(b,0,g,d):(k=(0+g|0)>>>1|0,WK(a,b,0,k,d,h,e),WK(a,b,k,g,d,h,e),XK(b,0,k,g,d,h)),32>(c-g|0)?VK(b,g,c,d):(k=(g+c|0)>>>1|0,WK(a,b,g,k,d,h,e),WK(a,b,k,c,d,h,e),XK(b,g,k,c,d,h)),XK(b,0,g,c,d,h));else if(b instanceof
-td)d===tG()?tj(fk(),b):(e=Tq(),32>(c-0|0)?VK(b,0,c,d):(g=(0+c|0)>>>1|0,h=new td(g-0|0),32>(g-0|0)?VK(b,0,g,d):(k=(0+g|0)>>>1|0,WK(a,b,0,k,d,h,e),WK(a,b,k,g,d,h,e),XK(b,0,k,g,d,h)),32>(c-g|0)?VK(b,g,c,d):(k=(g+c|0)>>>1|0,WK(a,b,g,k,d,h,e),WK(a,b,k,c,d,h,e),XK(b,g,k,c,d,h)),XK(b,0,g,c,d,h)));else if(b instanceof vd)d===uG()?vj(fk(),b):(e=bL(),32>(c-0|0)?VK(b,0,c,d):(g=(0+c|0)>>>1|0,h=new vd(g-0|0),32>(g-0|0)?VK(b,0,g,d):(k=(0+g|0)>>>1|0,WK(a,b,0,k,d,h,e),WK(a,b,k,g,d,h,e),XK(b,0,k,g,d,h)),32>(c-g|0)?
-VK(b,g,c,d):(k=(g+c|0)>>>1|0,WK(a,b,g,k,d,h,e),WK(a,b,k,c,d,h,e),XK(b,g,k,c,d,h)),XK(b,0,g,c,d,h)));else if(b instanceof wd)d===vG()?rj(fk(),b):(e=cL(),32>(c-0|0)?VK(b,0,c,d):(g=(0+c|0)>>>1|0,h=new wd(g-0|0),32>(g-0|0)?VK(b,0,g,d):(k=(0+g|0)>>>1|0,WK(a,b,0,k,d,h,e),WK(a,b,k,g,d,h,e),XK(b,0,k,g,d,h)),32>(c-g|0)?VK(b,g,c,d):(k=(g+c|0)>>>1|0,WK(a,b,g,k,d,h,e),WK(a,b,k,c,d,h,e),XK(b,g,k,c,d,h)),XK(b,0,g,c,d,h)));else if(b instanceof pd)if(d===wG()){for(d=c=0;c<b.a.length;)b.a[c]||(d=1+d|0),c=1+c|0;for(c=
-0;c<d;)b.a[c]=!1,c=1+c|0;for(;c<b.a.length;)b.a[c]=!0,c=1+c|0}else e=dL(),32>(c-0|0)?VK(b,0,c,d):(g=(0+c|0)>>>1|0,h=new pd(g-0|0),32>(g-0|0)?VK(b,0,g,d):(k=(0+g|0)>>>1|0,WK(a,b,0,k,d,h,e),WK(a,b,k,g,d,h,e),XK(b,0,k,g,d,h)),32>(c-g|0)?VK(b,g,c,d):(k=(g+c|0)>>>1|0,WK(a,b,g,k,d,h,e),WK(a,b,k,c,d,h,e),XK(b,g,k,c,d,h)),XK(b,0,g,c,d,h));else{if(null===b)throw ze();throw new x(b);}}UK.prototype.$classData=q({M3:0},!1,"scala.util.Sorting$",{M3:1,d:1});var eL;function xG(){eL||(eL=new UK);return eL}
-function fL(){}fL.prototype=new p;fL.prototype.constructor=fL;function gL(){}gL.prototype=fL.prototype;fL.prototype.B=function(a,b){a=this.dp(a,b);return-430675100+Math.imul(5,a<<13|a>>>19|0)|0};fL.prototype.dp=function(a,b){b=Math.imul(-862048943,b);b=Math.imul(461845907,b<<15|b>>>17|0);return a^b};fL.prototype.La=function(a,b){return hL(a^b)};function hL(a){a=Math.imul(-2048144789,a^(a>>>16|0));a=Math.imul(-1028477387,a^(a>>>13|0));return a^(a>>>16|0)}
-function iL(a,b,c){var d=a.B(-889275714,dc("Tuple2"));d=a.B(d,b);d=a.B(d,c);return a.La(d,2)}function jL(a){var b=kL(),c=a.G();if(0===c)return dc(a.H());var d=b.B(-889275714,dc(a.H()));for(var e=0;e<c;){var g=a.I(e);d=b.B(d,dy(W(),g));e=1+e|0}return b.La(d,c)}function lL(a,b,c){var d=0,e=0,g=0,h=1;for(b=b.m();b.s();){var k=b.t();k=dy(W(),k);d=d+k|0;e^=k;h=Math.imul(h,1|k);g=1+g|0}c=a.B(c,d);c=a.B(c,e);c=a.dp(c,h);return a.La(c,g)}
-function mL(a,b,c){var d=c;c=dG(eG(),b);switch(c){case 0:return a.La(d,0);case 1:return c=d,b=EG(eG(),b,0),a.La(a.B(c,dy(W(),b)),1);default:var e=EG(eG(),b,0),g=dy(W(),e);e=d=a.B(d,g);var h=EG(eG(),b,1);h=dy(W(),h);var k=h-g|0;for(g=2;g<c;){d=a.B(d,h);var l=EG(eG(),b,g);l=dy(W(),l);if(k!==(l-h|0)){d=a.B(d,l);for(g=1+g|0;g<c;)e=EG(eG(),b,g),d=a.B(d,dy(W(),e)),g=1+g|0;return a.La(d,c)}h=l;g=1+g|0}return hL(a.B(a.B(e,k),h))}}
-function nL(a,b,c){var d=b.a.length;switch(d){case 0:return a.La(c,0);case 1:return a.La(a.B(c,b.a[0]?1231:1237),1);default:var e=b.a[0]?1231:1237,g=c=a.B(c,e),h=b.a[1]?1231:1237;e=h-e|0;for(var k=2;k<d;){c=a.B(c,h);var l=b.a[k]?1231:1237;if(e!==(l-h|0)){c=a.B(c,l);for(k=1+k|0;k<d;)c=a.B(c,b.a[k]?1231:1237),k=1+k|0;return a.La(c,d)}h=l;k=1+k|0}return hL(a.B(a.B(g,e),h))}}
-function oL(a,b,c){var d=b.a.length;switch(d){case 0:return a.La(c,0);case 1:return a.La(a.B(c,b.a[0]),1);default:var e=b.a[0],g=c=a.B(c,e),h=b.a[1];e=h-e|0;for(var k=2;k<d;){c=a.B(c,h);var l=b.a[k];if(e!==(l-h|0)){c=a.B(c,l);for(k=1+k|0;k<d;)c=a.B(c,b.a[k]),k=1+k|0;return a.La(c,d)}h=l;k=1+k|0}return hL(a.B(a.B(g,e),h))}}
-function pL(a,b,c){var d=b.a.length;switch(d){case 0:return a.La(c,0);case 1:return a.La(a.B(c,b.a[0]),1);default:var e=b.a[0],g=c=a.B(c,e),h=b.a[1];e=h-e|0;for(var k=2;k<d;){c=a.B(c,h);var l=b.a[k];if(e!==(l-h|0)){c=a.B(c,l);for(k=1+k|0;k<d;)c=a.B(c,b.a[k]),k=1+k|0;return a.La(c,d)}h=l;k=1+k|0}return hL(a.B(a.B(g,e),h))}}
-function qL(a,b,c){var d=b.a.length;switch(d){case 0:return a.La(c,0);case 1:return b=b.a[0],a.La(a.B(c,IK(W(),b)),1);default:var e=b.a[0],g=IK(W(),e);e=c=a.B(c,g);var h=b.a[1];h=IK(W(),h);var k=h-g|0;for(g=2;g<d;){c=a.B(c,h);var l=b.a[g];l=IK(W(),l);if(k!==(l-h|0)){c=a.B(c,l);for(g=1+g|0;g<d;)e=b.a[g],c=a.B(c,IK(W(),e)),g=1+g|0;return a.La(c,d)}h=l;g=1+g|0}return hL(a.B(a.B(e,k),h))}}
-function rL(a,b,c){var d=c;c=b.a.length;switch(c){case 0:return a.La(d,0);case 1:return c=d,b=b.a[0],W(),a.La(a.B(c,IK(0,b)),1);default:var e=b.a[0],g=IK(W(),e);e=d=a.B(d,g);var h=b.a[1];h=IK(W(),h);var k=h-g|0;for(g=2;g<c;){d=a.B(d,h);var l=b.a[g];l=IK(W(),l);if(k!==(l-h|0)){d=a.B(d,l);for(g=1+g|0;g<c;)e=b.a[g],W(),d=a.B(d,IK(0,e)),g=1+g|0;return a.La(d,c)}h=l;g=1+g|0}return hL(a.B(a.B(e,k),h))}}
-function sL(a,b,c){var d=b.a.length;switch(d){case 0:return a.La(c,0);case 1:return a.La(a.B(c,b.a[0]),1);default:var e=b.a[0],g=c=a.B(c,e),h=b.a[1];e=h-e|0;for(var k=2;k<d;){c=a.B(c,h);var l=b.a[k];if(e!==(l-h|0)){c=a.B(c,l);for(k=1+k|0;k<d;)c=a.B(c,b.a[k]),k=1+k|0;return a.La(c,d)}h=l;k=1+k|0}return hL(a.B(a.B(g,e),h))}}
-function tL(a,b,c){var d=b.a.length;switch(d){case 0:return a.La(c,0);case 1:return d=b.a[0],b=d.W,d=d.Z,a.La(a.B(c,HK(W(),new fb(b,d))),1);default:var e=b.a[0],g=e.W;e=e.Z;e=HK(W(),new fb(g,e));g=c=a.B(c,e);var h=b.a[1],k=h.W;h=h.Z;k=HK(W(),new fb(k,h));h=k-e|0;for(e=2;e<d;){c=a.B(c,k);var l=b.a[e],m=l.W;l=l.Z;m=HK(W(),new fb(m,l));if(h!==(m-k|0)){c=a.B(c,m);for(e=1+e|0;e<d;)k=b.a[e],g=k.W,k=k.Z,c=a.B(c,HK(W(),new fb(g,k))),e=1+e|0;return a.La(c,d)}k=m;e=1+e|0}return hL(a.B(a.B(g,h),k))}}
-function uL(a,b,c){var d=b.a.length;switch(d){case 0:return a.La(c,0);case 1:return a.La(a.B(c,b.a[0]),1);default:var e=b.a[0],g=c=a.B(c,e),h=b.a[1];e=h-e|0;for(var k=2;k<d;){c=a.B(c,h);var l=b.a[k];if(e!==(l-h|0)){c=a.B(c,l);for(k=1+k|0;k<d;)c=a.B(c,b.a[k]),k=1+k|0;return a.La(c,d)}h=l;k=1+k|0}return hL(a.B(a.B(g,e),h))}}
-function vL(a,b,c){b=b.a.length;switch(b){case 0:return a.La(c,0);case 1:return a.La(a.B(c,0),1);default:for(var d=c=a.B(c,0),e=0,g=e,h=2;h<b;){c=a.B(c,e);if(g!==(-e|0)){c=a.B(c,0);for(h=1+h|0;h<b;)c=a.B(c,0),h=1+h|0;return a.La(c,b)}e=0;h=1+h|0}return hL(a.B(a.B(d,g),e))}}function wL(){}wL.prototype=new p;wL.prototype.constructor=wL;wL.prototype.$classData=q({Q3:0},!1,"scala.util.hashing.package$",{Q3:1,d:1});var xL;function yL(){}yL.prototype=new p;yL.prototype.constructor=yL;function zL(){}
-zL.prototype=yL.prototype;function bf(a,b){this.qz=this.ND=this.Hw=this.MD=this.Iw=null;this.Lw=!1;this.Xt=null;this.Wt=!1;this.KD=this.LD=null;this.Rd=this.Jw=0;this.Kw=this.Fl=null;this.pz=!1;xs(this,a,b,!0,new z(c=>{throw c;}),!1,t().f,(ks(),"input"))}bf.prototype=new As;bf.prototype.constructor=bf;bf.prototype.VP=function(a){this.Wt&&(a=Zr(a),Af(Bf(),a+"\n"))};bf.prototype.$classData=q({cT:0},!1,"Main$$anon$1",{cT:1,oW:1,d:1});
-function De(a){this.Fo=null;this.Mi=a;if(null===a)throw null;this.Fo=a}De.prototype=new KB;De.prototype.constructor=De;De.prototype.$classData=q({dT:0},!1,"Main$SimplifyPipeline$1$",{dT:1,gaa:1,d:1});
-function sD(a,b){0===(4&a.Oj)<<24>>24&&0===(4&a.Oj)<<24>>24&&(a.aQ=new zd(new Int32Array([1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,5,1,2,5,1,3,2,1,3,2,1,3,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,
+function waa(a,b,c){if(0===b.W&&0===b.Y)switch(c){case 0:return"0";case 1:return"0.0";case 2:return"0.00";case 3:return"0.000";case 4:return"0.0000";case 5:return"0.00000";case 6:return"0.000000";default:return(0>c?"0E+":"0E")+(-2147483648===c?"2147483648":""+(-c|0))}else{a=0>b.Y;var d="";var e=18;if(a){var g=b.W;b=b.Y;b=new ma(-g|0,0!==g?~b:-b|0)}g=b.W;for(var h=b.Y;;){b=g;var k=h;h=xa();g=$h(h,g,k,10,0);h=h.Qc;e=-1+e|0;k=h;var l=g,m=l>>>16|0;l=Math.imul(10,65535&l);m=Math.imul(10,m);m=l+(m<<16)|
+0;Math.imul(10,k);d=""+(b-m|0)+d;b=h;if(0===g&&0===b)break}g=18-e|0;h=g>>31;k=c>>31;b=g-c|0;g=(-2147483648^b)>(-2147483648^g)?-1+(h-k|0)|0:h-k|0;b=-1+b|0;g=-1!==b?g:-1+g|0;if(0<c&&(-1===g?2147483642<=(-2147483648^b):-1<g))if(c=1+b|0,0<c)d=d.substring(0,c)+"."+d.substring(c);else{c=-c|0;for(e=0;e<c;)d="0"+d,e=1+e|0;d="0."+d}else 0!==c&&(c=(0===g?0!==b:0<g)?"E+"+new ma(b,g):"E"+new ma(b,g),d=1<(18-e|0)?d.substring(0,1)+"."+d.substring(1)+c:d+c);return a?"-"+d:d}}
+Th.prototype.$classData=q({GT:0},!1,"java.math.Conversion$",{GT:1,g:1});var Uh;function bi(){Uh||(Uh=new Th);return Uh}function ci(){}ci.prototype=new p;ci.prototype.constructor=ci;
+function di(a,b,c,d,e,g,h){a=new Xc(1+e|0);var k=new Xc(1+h|0),l=Math.clz32(g.a[-1+h|0]);0!==l?(Gh(Sh(),k,g,0,l),Gh(Sh(),a,d,0,l)):(d.wa(0,a,0,e),g.wa(0,k,0,h));d=k.a[-1+h|0];for(c=-1+c|0;0<=c;){if(a.a[e]===d)g=-1;else{var m=a.a[e],n=a.a[-1+e|0];g=xa();var r=Wh(g,n,m,d,0);m=g.Qc;g=r;var v=65535&r;r=r>>>16|0;var x=65535&d,A=d>>>16|0,B=Math.imul(v,x);x=Math.imul(r,x);v=Math.imul(v,A);v=B+((x+v|0)<<16)|0;Math.imul(m,d);Math.imul(r,A);n=n-v|0;if(0!==g)for(g=1+g|0;;){r=g=-1+g|0;A=k.a[-2+h|0];m=65535&r;
+r=r>>>16|0;B=65535&A;A=A>>>16|0;v=Math.imul(m,B);B=Math.imul(r,B);x=Math.imul(m,A);m=v+((B+x|0)<<16)|0;v=(v>>>16|0)+x|0;v=(Math.imul(r,A)+(v>>>16|0)|0)+(((65535&v)+B|0)>>>16|0)|0;A=n;r=a.a[-2+e|0];B=n+d|0;if(0===((-2147483648^B)<(-2147483648^n)?1:0)&&(n=B,v^=-2147483648,A^=-2147483648,v===A?(-2147483648^m)>(-2147483648^r):v>A))continue;break}}if(n=0!==g){ei();n=a;m=e-h|0;A=k;r=h;v=g;var C=0;var D;for(B=D=0;B<r;){x=B;fi();var F=A.a[x],I=65535&F;F=F>>>16|0;var M=65535&v,N=v>>>16|0,P=Math.imul(I,M);
+M=Math.imul(F,M);var T=Math.imul(I,N);I=P+((M+T|0)<<16)|0;P=(P>>>16|0)+T|0;N=(Math.imul(F,N)+(P>>>16|0)|0)+(((65535&P)+M|0)>>>16|0)|0;F=I+C|0;C=(-2147483648^F)<(-2147483648^I)?1+N|0:N;N=n.a[m+x|0];F=N-F|0;N=(-2147483648^F)>(-2147483648^N)?-1:0;I=D;D=I>>31;I=F+I|0;D=(-2147483648^I)<(-2147483648^F)?1+(N+D|0)|0:N+D|0;n.a[m+x|0]=I;B=1+B|0}v=n.a[m+r|0];A=v-C|0;v=(-2147483648^A)>(-2147483648^v)?-1:0;x=D;B=x>>31;x=A+x|0;n.a[m+r|0]=x;n=0!==((-2147483648^x)<(-2147483648^A)?1+(v+B|0)|0:v+B|0)}if(n)for(g=-1+
+g|0,n=B=v=0;n<h;)m=n,A=a.a[(e-h|0)+m|0],r=A+k.a[m]|0,A=(-2147483648^r)<(-2147483648^A)?1:0,r=v+r|0,A=(-2147483648^r)<(-2147483648^v)?1+(B+A|0)|0:B+A|0,v=r,B=A,a.a[(e-h|0)+m|0]=v,v=B,B=0,n=1+n|0;null!==b&&(b.a[c]=g);e=-1+e|0;c=-1+c|0}if(0!==l)return Qh(Sh(),k,h,a,0,l),k;a.wa(0,k,0,h);return a}
+function gi(a,b,c,d,e){a=0;for(d=-1+d|0;0<=d;){var g=a;a=c.a[d];var h=xa();g=Wh(h,a,g,e,0);h=h.Qc;var k=65535&g,l=g>>>16|0,m=65535&e,n=e>>>16|0,r=Math.imul(k,m);m=Math.imul(l,m);k=Math.imul(k,n);r=r+((m+k|0)<<16)|0;Math.imul(h,e);Math.imul(l,n);a=a-r|0;b.a[d]=g;d=-1+d|0}return a}ci.prototype.$classData=q({HT:0},!1,"java.math.Division$",{HT:1,g:1});var hi;function ei(){hi||(hi=new ci);return hi}
+function ii(a,b,c,d){var e=new Xc(1+b|0),g=1,h=a.a[0],k=h+c.a[0]|0;e.a[0]=k;h=(-2147483648^k)<(-2147483648^h)?1:0;if(b>=d){for(;g<d;){var l=a.a[g];k=l+c.a[g]|0;l=(-2147483648^k)<(-2147483648^l)?1:0;h=k+h|0;k=(-2147483648^h)<(-2147483648^k)?1+l|0:l;e.a[g]=h;h=k;g=1+g|0}for(;g<b;)c=a.a[g],d=c+h|0,c=(-2147483648^d)<(-2147483648^c)?1:0,e.a[g]=d,h=c,g=1+g|0}else{for(;g<b;)l=a.a[g],k=l+c.a[g]|0,l=(-2147483648^k)<(-2147483648^l)?1:0,h=k+h|0,k=(-2147483648^h)<(-2147483648^k)?1+l|0:l,e.a[g]=h,h=k,g=1+g|0;
+for(;g<d;)a=c.a[g],b=a+h|0,a=(-2147483648^b)<(-2147483648^a)?1:0,e.a[g]=b,h=a,g=1+g|0}0!==h&&(e.a[g]=h);return e}function ji(a,b,c,d){for(var e=new Xc(b),g=0,h=0;g<d;){var k=a.a[g],l=k-c.a[g]|0;k=(-2147483648^l)>(-2147483648^k)?-1:0;var m=h;h=m>>31;m=l+m|0;l=(-2147483648^m)<(-2147483648^l)?1+(k+h|0)|0:k+h|0;e.a[g]=m;h=l;g=1+g|0}for(;g<b;)c=a.a[g],l=h,d=l>>31,l=c+l|0,c=(-2147483648^l)<(-2147483648^c)?1+d|0:d,e.a[g]=l,h=c,g=1+g|0;return e}function ki(){}ki.prototype=new p;ki.prototype.constructor=ki;
+function li(a,b,c){a=b.Ya;var d=c.Ya,e=b.wb,g=c.wb;if(0===a)return c;if(0===d)return b;if(2===(e+g|0)){b=b.Qa.a[0];c=c.Qa.a[0];if(a===d)return d=b+c|0,c=(-2147483648^d)<(-2147483648^b)?1:0,0===c?qi(a,d):Hh(a,2,new Xc(new Int32Array([d,c])));d=Ph();0>a?(a=b=c-b|0,c=(-2147483648^b)>(-2147483648^c)?-1:0):(a=c=b-c|0,c=(-2147483648^c)>(-2147483648^b)?-1:0);return ri(d,new ma(a,c))}if(a===d)d=e>=g?ii(b.Qa,e,c.Qa,g):ii(c.Qa,g,b.Qa,e);else{var h=e!==g?e>g?1:-1:si(0,b.Qa,c.Qa,e);if(0===h)return Ph().nq;1===
+h?d=ji(b.Qa,e,c.Qa,g):(c=ji(c.Qa,g,b.Qa,e),a=d,d=c)}a=Hh(a|0,d.a.length,d);Ih(a);return a}function si(a,b,c,d){for(a=-1+d|0;0<=a&&b.a[a]===c.a[a];)a=-1+a|0;return 0>a?0:(-2147483648^b.a[a])<(-2147483648^c.a[a])?-1:1}
+function ti(a,b,c){var d=b.Ya;a=c.Ya;var e=b.wb,g=c.wb;if(0===a)return b;if(0===d)return ui(c);if(2===(e+g|0))return b=b.Qa.a[0],e=0,c=c.Qa.a[0],g=0,0>d&&(d=b,b=-d|0,e=0!==d?~e:-e|0),0>a&&(a=c,d=g,c=-a|0,g=0!==a?~d:-d|0),a=Ph(),d=b,b=e,e=g,c=d-c|0,ri(a,new ma(c,(-2147483648^c)>(-2147483648^d)?-1+(b-e|0)|0:b-e|0));var h=e!==g?e>g?1:-1:si(vi(),b.Qa,c.Qa,e);if(d===a&&0===h)return Ph().nq;-1===h?(c=d===a?ji(c.Qa,g,b.Qa,e):ii(c.Qa,g,b.Qa,e),a=-a|0):d===a?(c=ji(b.Qa,e,c.Qa,g),a=d):(c=ii(b.Qa,e,c.Qa,g),
+a=d);a=Hh(a|0,c.a.length,c);Ih(a);return a}ki.prototype.$classData=q({IT:0},!1,"java.math.Elementary$",{IT:1,g:1});var wi;function vi(){wi||(wi=new ki);return wi}function xi(a,b){this.ds=a;this.Fw=b}xi.prototype=new p;xi.prototype.constructor=xi;xi.prototype.i=function(a){return a instanceof xi?this.ds===a.ds?this.Fw===a.Fw:!1:!1};xi.prototype.B=function(){return this.ds<<3|this.Fw.NF};xi.prototype.u=function(){return"precision\x3d"+this.ds+" roundingMode\x3d"+this.Fw};
+xi.prototype.$classData=q({JT:0},!1,"java.math.MathContext",{JT:1,g:1});function yi(){this.qM=null;zi=this;Ai();var a=Bi().OC;this.qM=new xi(34,a);Ai();Bi();Ai();Bi();Ai();Bi()}yi.prototype=new p;yi.prototype.constructor=yi;yi.prototype.$classData=q({KT:0},!1,"java.math.MathContext$",{KT:1,g:1});var zi;function Ai(){zi||(zi=new yi);return zi}
+function Fi(a,b,c,d){for(var e,g=e=0;g<c;){var h=g;fi();var k=b.a[h],l=65535&k;k=k>>>16|0;var m=65535&d,n=d>>>16|0,r=Math.imul(l,m);m=Math.imul(k,m);var v=Math.imul(l,n);l=r+((m+v|0)<<16)|0;r=(r>>>16|0)+v|0;k=(Math.imul(k,n)+(r>>>16|0)|0)+(((65535&r)+m|0)>>>16|0)|0;e=l+e|0;k=(-2147483648^e)<(-2147483648^l)?1+k|0:k;a.a[h]=e;e=k;g=1+g|0}return e}function Gi(a,b){for(var c=new Xc(a),d=c.a[0]=1;d<a;){var e=d;c.a[e]=Math.imul(c.a[-1+e|0],b);d=1+d|0}}
+function Hi(){this.es=this.fs=null;Ii=this;Gi(10,10);Gi(14,5);this.fs=new (md(Ji).Ia)(32);this.es=new (md(Ji).Ia)(32);var a;var b=1;for(var c=a=0;32>c;){var d=c;if(18>=d){fi().es.a[d]=ri(Ph(),new ma(b,a));var e=fi().fs,g=Ph(),h=a,k=b;e.a[d]=ri(g,new ma(0===(32&d)?k<<d:0,0===(32&d)?(k>>>1|0)>>>(31-d|0)|0|h<<d:k<<d));d=b;b=d>>>16|0;d=Math.imul(5,65535&d);e=Math.imul(5,b);b=d+(e<<16)|0;d=(d>>>16|0)+e|0;a=Math.imul(5,a)+(d>>>16|0)|0}else fi().es.a[d]=Ki(fi().es.a[-1+d|0],fi().es.a[1]),fi().fs.a[d]=Ki(fi().fs.a[-1+
+d|0],Ph().mq);c=1+c|0}}Hi.prototype=new p;Hi.prototype.constructor=Hi;
+function Li(a,b,c){for(var d,e=0;e<b;){var g=e;d=0;for(var h=1+g|0;h<b;){fi();var k=a.a[g],l=a.a[h],m=c.a[g+h|0],n=d,r=65535&k;d=k>>>16|0;var v=65535&l;l=l>>>16|0;k=Math.imul(r,v);v=Math.imul(d,v);var x=Math.imul(r,l);r=k+((v+x|0)<<16)|0;k=(k>>>16|0)+x|0;d=(Math.imul(d,l)+(k>>>16|0)|0)+(((65535&k)+v|0)>>>16|0)|0;m=r+m|0;d=(-2147483648^m)<(-2147483648^r)?1+d|0:d;n=m+n|0;m=(-2147483648^n)<(-2147483648^m)?1+d|0:d;c.a[g+h|0]=n;d=m;h=1+h|0}c.a[g+b|0]=d;e=1+e|0}Nh(Sh(),c,c,b<<1);for(g=e=d=0;e<b;)m=a.a[e],
+r=a.a[e],n=c.a[g],h=d,l=65535&m,m=m>>>16|0,k=65535&r,d=r>>>16|0,r=Math.imul(l,k),k=Math.imul(m,k),v=Math.imul(l,d),l=r+((k+v|0)<<16)|0,r=(r>>>16|0)+v|0,m=(Math.imul(m,d)+(r>>>16|0)|0)+(((65535&r)+k|0)>>>16|0)|0,n=l+n|0,m=(-2147483648^n)<(-2147483648^l)?1+m|0:m,h=n+h|0,n=(-2147483648^h)<(-2147483648^n)?1+m|0:m,c.a[g]=h,g=1+g|0,h=n+c.a[g]|0,n=(-2147483648^h)<(-2147483648^n)?1:0,c.a[g]=h,d=n,e=1+e|0,g=1+g|0;return c}
+function Mi(a,b,c){if(c.wb>b.wb)var d=c;else d=b,b=c;var e=d,g=b;if(63>g.wb){d=e.wb;b=g.wb;c=d+b|0;a=e.Ya!==g.Ya?-1:1;if(2===c){d=e.Qa.a[0];b=g.Qa.a[0];c=65535&d;d=d>>>16|0;g=65535&b;b=b>>>16|0;e=Math.imul(c,g);g=Math.imul(d,g);var h=Math.imul(c,b);c=e+((g+h|0)<<16)|0;e=(e>>>16|0)+h|0;d=(Math.imul(d,b)+(e>>>16|0)|0)+(((65535&e)+g|0)>>>16|0)|0;a=0===d?qi(a,c):Hh(a,2,new Xc(new Int32Array([c,d])))}else{e=e.Qa;g=g.Qa;h=new Xc(c);if(0!==d&&0!==b)if(1===d)h.a[b]=Fi(h,g,b,e.a[0]);else if(1===b)h.a[d]=Fi(h,
+e,d,g.a[0]);else if(e===g&&d===b)Li(e,d,h);else for(var k=0;k<d;){for(var l=k,m=0,n=e.a[l],r=0;r<b;){fi();var v=g.a[r],x=h.a[l+r|0],A=65535&n,B=n>>>16|0,C=65535&v;v=v>>>16|0;var D=Math.imul(A,C);C=Math.imul(B,C);var F=Math.imul(A,v);A=D+((C+F|0)<<16)|0;D=(D>>>16|0)+F|0;B=(Math.imul(B,v)+(D>>>16|0)|0)+(((65535&D)+C|0)>>>16|0)|0;x=A+x|0;B=(-2147483648^x)<(-2147483648^A)?1+B|0:B;m=x+m|0;x=(-2147483648^m)<(-2147483648^x)?1+B|0:B;h.a[l+r|0]=m;m=x;r=1+r|0}h.a[l+b|0]=m;k=1+k|0}a=Hh(a,c,h);Ih(a)}return a}d=
+(-2&e.wb)<<4;c=Ni(e,d);h=Ni(g,d);b=Oi(c,d);k=ti(vi(),e,b);b=Oi(h,d);g=ti(vi(),g,b);e=Mi(a,c,h);b=Mi(a,k,g);a=Mi(a,ti(vi(),c,k),ti(vi(),g,h));c=e;a=li(vi(),a,c);a=li(vi(),a,b);a=Oi(a,d);d=e=Oi(e,d<<1);a=li(vi(),d,a);return li(vi(),a,b)}
+function Pi(a,b){var c=a.fs.a.length,d=c>>31,e=b.Y;if(e===d?(-2147483648^b.W)<(-2147483648^c):e<d)return a.fs.a[b.W];c=b.Y;if(0===c?-2147483598>=(-2147483648^b.W):0>c)return Qi(Ph().mq,b.W);c=b.Y;if(0===c?-1>=(-2147483648^b.W):0>c)return Oi(Qi(a.es.a[1],b.W),b.W);var g=Qi(a.es.a[1],2147483647);c=g;e=b.Y;var h=-2147483647+b.W|0;d=h;h=1>(-2147483648^h)?e:-1+e|0;for(e=Ri(xa(),b.W,b.Y,2147483647,0);;){var k=d,l=h;if(0===l?-1<(-2147483648^k):0<l)c=Ki(c,g),d=-2147483647+d|0,h=1>(-2147483648^d)?h:-1+h|0;
+else break}c=Ki(c,Qi(a.es.a[1],e));c=Oi(c,2147483647);a=b.Y;d=b=-2147483647+b.W|0;for(h=1>(-2147483648^b)?a:-1+a|0;;)if(b=d,a=h,0===a?-1<(-2147483648^b):0<a)c=Oi(c,2147483647),b=h,a=-2147483647+d|0,b=1>(-2147483648^a)?b:-1+b|0,d=a,h=b;else break;return Oi(c,e)}Hi.prototype.$classData=q({LT:0},!1,"java.math.Multiplication$",{LT:1,g:1});var Ii;function fi(){Ii||(Ii=new Hi);return Ii}function Si(){}Si.prototype=new p;Si.prototype.constructor=Si;
+function Ti(a,b){var c=Ui(),d=Ui(),e=b.a.length;16<e?Vi(a,b,new Xc(b.a.length),0,e,c,d):Zi(b,0,e,c,d)}function $i(a,b){var c=aj(),d=aj(),e=b.a.length;16<e?Vi(a,b,new Zc(b.a.length),0,e,c,d):Zi(b,0,e,c,d)}function bj(a,b){var c=cj(),d=cj(),e=b.a.length;16<e?Vi(a,b,new Sc(b.a.length),0,e,c,d):Zi(b,0,e,c,d)}function dj(a,b){var c=ej(),d=ej(),e=b.a.length;16<e?Vi(a,b,new Ic(b.a.length),0,e,c,d):Zi(b,0,e,c,d)}
+function fj(a,b){var c=gj(),d=gj(),e=b.a.length;16<e?Vi(a,b,new Pc(b.a.length),0,e,c,d):Zi(b,0,e,c,d)}function hj(a,b,c){c=null===c?ij():c;var d=jj(),e=b.a.length;if(16<e){var g=b.a.length,h=ca(b);Vi(a,b,rh(th(),bg(h),g),0,e,c,d)}else Zi(b,0,e,c,d)}
+function Vi(a,b,c,d,e,g,h){var k=e-d|0;if(16<k){var l=d+(k/2|0)|0;Vi(a,b,c,d,l,g,h);Vi(a,b,c,l,e,g,h);for(var m=a=d,n=l;a<e;)m<l&&(n>=e||0>=g.Da(h.Wj(b,m),h.Wj(b,n)))?(h.Qo(c,a,h.Wj(b,m)),m=1+m|0):(h.Qo(c,a,h.Wj(b,n)),n=1+n|0),a=1+a|0;c.wa(d,b,d,k)}else Zi(b,d,e,g,h)}
+function Zi(a,b,c,d,e){c=c-b|0;if(2<=c){var g=e.Wj(a,b),h=e.Wj(a,1+b|0);0<d.Da(g,h)&&(e.Qo(a,b,h),e.Qo(a,1+b|0,g));for(g=2;g<c;){h=e.Wj(a,b+g|0);if(0>d.Da(h,e.Wj(a,-1+(b+g|0)|0))){for(var k=b,l=-1+(b+g|0)|0;1<(l-k|0);){var m=(k+l|0)>>>1|0;0>d.Da(h,e.Wj(a,m))?l=m:k=m}k=k+(0>d.Da(h,e.Wj(a,k))?0:1)|0;for(l=b+g|0;l>k;)e.Qo(a,l,e.Wj(a,-1+l|0)),l=-1+l|0;e.Qo(a,k,h)}g=1+g|0}}}
+function kj(a,b,c){a=0;for(var d=b.a.length;;){if(a===d)return-1-a|0;var e=(a+d|0)>>>1|0,g=b.a[e];g=c===g?0:c<g?-1:1;if(0>g)d=e;else{if(0===g)return e;a=1+e|0}}}function pj(a,b,c){if(b===c)return!0;if(null===b||null===c)return!1;a=b.a.length;if(c.a.length!==a)return!1;for(var d=0;d!==a;){var e=b.a[d],g=c.a[d],h=g.Y;if(e.W!==g.W||e.Y!==h)return!1;d=1+d|0}return!0}
+function qj(a,b,c){if(b===c)return!0;if(null===b||null===c)return!1;a=b.a.length;if(c.a.length!==a)return!1;for(var d=0;d!==a;){if(b.a[d]!==c.a[d])return!1;d=1+d|0}return!0}function sj(a,b,c){if(b===c)return!0;if(null===b||null===c)return!1;a=b.a.length;if(c.a.length!==a)return!1;for(var d=0;d!==a;){if(b.a[d]!==c.a[d])return!1;d=1+d|0}return!0}
+function tj(a,b,c){if(b===c)return!0;if(null===b||null===c)return!1;a=b.a.length;if(c.a.length!==a)return!1;for(var d=0;d!==a;){if(b.a[d]!==c.a[d])return!1;d=1+d|0}return!0}function uj(a,b,c){if(b===c)return!0;if(null===b||null===c)return!1;a=b.a.length;if(c.a.length!==a)return!1;for(var d=0;d!==a;){if(b.a[d]!==c.a[d])return!1;d=1+d|0}return!0}
+function vj(a,b,c){if(b===c)return!0;if(null===b||null===c)return!1;a=b.a.length;if(c.a.length!==a)return!1;for(var d=0;d!==a;){if(b.a[d]!==c.a[d])return!1;d=1+d|0}return!0}function wj(a,b,c){if(b===c)return!0;if(null===b||null===c)return!1;a=b.a.length;if(c.a.length!==a)return!1;for(var d=0;d!==a;){if(!Object.is(b.a[d],c.a[d]))return!1;d=1+d|0}return!0}
+function xj(a,b,c){if(b===c)return!0;if(null===b||null===c)return!1;a=b.a.length;if(c.a.length!==a)return!1;for(var d=0;d!==a;){if(!Object.is(b.a[d],c.a[d]))return!1;d=1+d|0}return!0}function yj(a,b,c){a=b.a.length;for(var d=0;d!==a;)b.a[d]=c,d=1+d|0}function zj(a,b,c){if(0>c)throw new Aj;a=b.a.length;a=c<a?c:a;var d=ca(b);c=rh(th(),bg(d),c);b.wa(0,c,0,a);return c}function Cj(a,b,c,d){if(0>c)throw new Aj;a=b.a.length;a=c<a?c:a;c=rh(th(),bg(d),c);b.wa(0,c,0,a);return c}
+function Dj(a,b,c){if(0>c)throw new Aj;a=b.a.length;a=c<a?c:a;c=new Pc(c);b.wa(0,c,0,a);return c}function Ej(a,b,c){if(0>c)throw new Aj;a=b.a.length;a=c<a?c:a;c=new Sc(c);b.wa(0,c,0,a);return c}function Fj(a,b,c){if(0>c)throw new Aj;a=b.a.length;a=c<a?c:a;c=new Xc(c);b.wa(0,c,0,a);return c}function Gj(a,b,c){if(0>c)throw new Aj;a=b.a.length;a=c<a?c:a;c=new Zc(c);b.wa(0,c,0,a);return c}function Hj(a,b,c){if(0>c)throw new Aj;a=b.a.length;a=c<a?c:a;c=new Ic(c);b.wa(0,c,0,a);return c}
+function Ij(a,b,c){if(0>c)throw new Aj;a=b.a.length;a=c<a?c:a;c=new Ec(c);b.wa(0,c,0,a);return c}function Jj(a,b,c,d){if(c>d)throw Kj(c+" \x3e "+d);a=d-c|0;d=b.a.length-c|0;d=a<d?a:d;var e=ca(b);a=rh(th(),bg(e),a);b.wa(c,a,0,d);return a}Si.prototype.$classData=q({G1:0},!1,"java.util.Arrays$",{G1:1,g:1});var Lj;function Pj(){Lj||(Lj=new Si);return Lj}
+function Qj(){this.PQ=this.QQ=null;Rj=this;this.QQ=RegExp("(?:(\\d+)\\$)?([-#+ 0,\\(\x3c]*)(\\d+)?(?:\\.(\\d+))?[%A-Za-z]","g");this.PQ=new Xc(new Int32Array([96,126,638,770,32,256,2,126,-1,-1,-1,-1,-1,-1,800,-1,-1,-1,124,-1,-1,-1,-1,544,-1,-1]))}Qj.prototype=new p;Qj.prototype.constructor=Qj;function Sj(a,b){if(20>=b)return"00000000000000000000".substring(0,b);for(a="";20<b;)a+="00000000000000000000",b=-20+b|0;return""+a+"00000000000000000000".substring(0,b)}
+Qj.prototype.$classData=q({P1:0},!1,"java.util.Formatter$",{P1:1,g:1});var Rj;function Tj(){Rj||(Rj=new Qj);return Rj}function Uj(a,b){var c=a.wr,d=c.length;if(0>b)return new Vj(a.Ft,"0",0);if(b>=d)return a;if(53>c.charCodeAt(b))return 0===b?new Vj(a.Ft,"0",0):new Vj(a.Ft,c.substring(0,b),a.vr-(d-b|0)|0);for(b=-1+b|0;;)if(0<=b&&57===c.charCodeAt(b))b=-1+b|0;else break;c=0>b?"1":""+c.substring(0,b)+hc(65535&(1+c.charCodeAt(b)|0));return new Vj(a.Ft,c,a.vr-(d-(1+b|0)|0)|0)}
+function Vj(a,b,c){this.Ft=a;this.wr=b;this.vr=c}Vj.prototype=new p;Vj.prototype.constructor=Vj;function Wj(a,b){Tj();if(!(0<b))throw new Yj("Decimal.round() called with non-positive precision");return Uj(a,b)}Vj.prototype.u=function(){return"Decimal("+this.Ft+", "+this.wr+", "+this.vr+")"};Vj.prototype.$classData=q({Q1:0},!1,"java.util.Formatter$Decimal",{Q1:1,g:1});function Zj(){}Zj.prototype=new p;Zj.prototype.constructor=Zj;function ak(){}ak.prototype=Zj.prototype;function bk(a){this.py=a}
+bk.prototype=new p;bk.prototype.constructor=bk;bk.prototype.i=function(a){return a instanceof bk?Object.is(this.py,a.py):!1};bk.prototype.B=function(){return Qb(this.py)};bk.prototype.$classData=q({a2:0},!1,"java.util.IdentityHashMap$IdentityBox",{a2:1,g:1});function ck(a){return!!(a&&a.$classData&&a.$classData.rb.TQ)}function dk(a,b){throw new ek(b,a.ri,a.P);}function fk(a,b){for(var c="",d=b.length,e=0;e!==d;){var g=gk(b,e);c=""+c+hk(a,g);e=e+(65536<=g?2:1)|0}return c}
+function hk(a,b){var c=ik(jk(),b);if(128>b)switch(b){case 94:case 36:case 92:case 46:case 42:case 43:case 63:case 40:case 41:case 91:case 93:case 123:case 125:case 124:return"\\"+c;default:return 2!==(66&a.Ue)?c:65<=b&&90>=b?"["+c+ik(jk(),32+b|0)+"]":97<=b&&122>=b?"["+ik(jk(),-32+b|0)+c+"]":c}else return 56320===(-1024&b)?"(?:"+c+")":c}
+function kk(a){for(var b=a.ri,c=b.length;;){if(a.P!==c)switch(b.charCodeAt(a.P)){case 32:case 9:case 10:case 11:case 12:case 13:a.P=1+a.P|0;continue;case 35:lk(a);continue}break}}
+function xaa(a,b,c){var d=a.ri,e=d.length,g=a.P,h=g===e?46:d.charCodeAt(g);if(63===h||42===h||43===h||123===h){g=a.ri;var k=a.P;a.P=1+a.P|0;if(123===h){h=g.length;if(a.P===h)var l=!0;else l=g.charCodeAt(a.P),l=!(48<=l&&57>=l);for(l&&dk(a,"Illegal repetition");;)if(a.P!==h?(l=g.charCodeAt(a.P),l=48<=l&&57>=l):l=!1,l)a.P=1+a.P|0;else break;a.P===h&&dk(a,"Illegal repetition");if(44===g.charCodeAt(a.P))for(a.P=1+a.P|0;;)if(a.P!==h?(l=g.charCodeAt(a.P),l=48<=l&&57>=l):l=!1,l)a.P=1+a.P|0;else break;a.P!==
+h&&125===g.charCodeAt(a.P)||dk(a,"Illegal repetition");a.P=1+a.P|0}g=g.substring(k,a.P);if(a.P!==e)switch(d.charCodeAt(a.P)){case 43:return a.P=1+a.P|0,yaa(a,b,c,g);case 63:return a.P=1+a.P|0,""+c+g+"?";default:return""+c+g}else return""+c+g}else return c}
+function yaa(a,b,c,d){for(var e=a.nn.length|0,g=0;g<e;){var h=g,k=a.nn[h]|0;k>b&&(a.nn[h]=1+k|0);g=1+g|0}c=c.replace(jk().dR,(l,m,n)=>{0!==(m.length%2|0)&&(n=parseInt(n,10)|0,l=n>b?""+m+(1+n|0):l);return l});a.mn=1+a.mn|0;return"(?:(?\x3d("+c+d+"))\\"+(1+b|0)+")"}
+function zaa(a){var b=a.ri,c=b.length;(1+a.P|0)===c&&dk(a,"\\ at end of pattern");a.P=1+a.P|0;var d=b.charCodeAt(a.P);switch(d){case 100:case 68:case 104:case 72:case 115:case 83:case 118:case 86:case 119:case 87:case 112:case 80:switch(a=mk(a,d),b=a.nK,b){case 0:return"\\p{"+a.yr+"}";case 1:return"\\P{"+a.yr+"}";case 2:return"["+a.yr+"]";case 3:return nk(jk(),a.yr);default:throw new Yj(b);}case 98:if("b{g}"===b.substring(a.P,4+a.P|0))dk(a,"\\b{g} is not supported");else if(0!==(320&a.Ue))ok(a,"\\b with UNICODE_CASE");
+else return a.P=1+a.P|0,"\\b";break;case 66:if(0!==(320&a.Ue))ok(a,"\\B with UNICODE_CASE");else return a.P=1+a.P|0,"\\B";break;case 65:return a.P=1+a.P|0,"(?:^)";case 71:dk(a,"\\G in the middle of a pattern is not supported");break;case 90:return a.P=1+a.P|0,"(?\x3d"+(0!==(1&a.Ue)?"\n":"(?:\r\n?|[\n\u0085\u2028\u2029])")+"?$)";case 122:return a.P=1+a.P|0,"(?:$)";case 82:return a.P=1+a.P|0,"(?:\r\n|[\n-\r\u0085\u2028\u2029])";case 88:dk(a,"\\X is not supported");break;case 49:case 50:case 51:case 52:case 53:case 54:case 55:case 56:case 57:var e=
+a.P;for(d=1+e|0;;){if(d!==c){var g=b.charCodeAt(d);g=48<=g&&57>=g}else g=!1;g?(g=b.substring(e,1+d|0),g=(parseInt(g,10)|0)<=(-1+(a.nn.length|0)|0)):g=!1;if(g)d=1+d|0;else break}b=b.substring(e,d);b=parseInt(b,10)|0;b>(-1+(a.nn.length|0)|0)&&dk(a,"numbered capturing group \x3c"+b+"\x3e does not exist");b=a.nn[b]|0;a.P=d;return"(?:\\"+b+")";case 107:return a.P=1+a.P|0,a.P!==c&&60===b.charCodeAt(a.P)||dk(a,"\\k is not followed by '\x3c' for named capturing group"),a.P=1+a.P|0,b=pk(a),d=a.$F,ug().ny.call(d,
+b)||dk(a,"named capturing group \x3c"+b+"\x3e does not exit"),b=a.nn[d[b]|0]|0,a.P=1+a.P|0,"(?:\\"+b+")";case 81:d=1+a.P|0;c=b.indexOf("\\E",d)|0;if(0>c)return a.P=b.length,fk(a,b.substring(d));a.P=2+c|0;return fk(a,b.substring(d,c));default:return hk(a,qk(a))}}
+function qk(a){var b=a.ri,c=gk(b,a.P);switch(c){case 48:return Aaa(a);case 120:return b=a.ri,c=1+a.P|0,c!==b.length&&123===b.charCodeAt(c)?(c=1+c|0,b=b.indexOf("}",c)|0,0>b&&dk(a,"Unclosed hexadecimal escape sequence"),c=rk(a,c,b,"hexadecimal"),a.P=1+b|0,a=c):(b=rk(a,c,2+c|0,"hexadecimal"),a.P=2+c|0,a=b),a;case 117:a:{b=a.ri;var d=1+a.P|0;c=4+d|0;d=rk(a,d,c,"Unicode");a.P=c;var e=2+c|0,g=4+e|0;if(55296===(-1024&d)&&"\\u"===b.substring(c,e)&&(b=rk(a,e,g,"Unicode"),56320===(-1024&b))){a.P=g;a=(64+(1023&
+d)|0)<<10|1023&b;break a}a=d}return a;case 78:dk(a,"\\N is not supported");break;case 97:return a.P=1+a.P|0,7;case 116:return a.P=1+a.P|0,9;case 110:return a.P=1+a.P|0,10;case 102:return a.P=1+a.P|0,12;case 114:return a.P=1+a.P|0,13;case 101:return a.P=1+a.P|0,27;case 99:return a.P=1+a.P|0,a.P===b.length&&dk(a,"Illegal control escape sequence"),b=gk(b,a.P),a.P=a.P+(65536<=b?2:1)|0,64^b;default:return(65<=c&&90>=c||97<=c&&122>=c)&&dk(a,"Illegal/unsupported escape sequence"),a.P=a.P+(65536<=c?2:1)|
+0,c}}function Aaa(a){var b=a.ri,c=b.length,d=a.P,e=(1+d|0)<c?-48+b.charCodeAt(1+d|0)|0:-1;(0>e||7<e)&&dk(a,"Illegal octal escape sequence");var g=(2+d|0)<c?-48+b.charCodeAt(2+d|0)|0:-1;if(0>g||7<g)return a.P=2+a.P|0,e;if(3<e)return a.P=3+a.P|0,(e<<3)+g|0;b=(3+d|0)<c?-48+b.charCodeAt(3+d|0)|0:-1;if(0>b||7<b)return a.P=3+a.P|0,(e<<3)+g|0;a.P=4+a.P|0;return((e<<6)+(g<<3)|0)+b|0}
+function rk(a,b,c,d){var e=a.ri,g=e.length;(b===c||c>g)&&dk(a,"Illegal "+d+" escape sequence");for(g=b;g<c;){var h=e.charCodeAt(g);48<=h&&57>=h||65<=h&&70>=h||97<=h&&102>=h||dk(a,"Illegal "+d+" escape sequence");g=1+g|0}6<(c-b|0)?b=1114112:(b=e.substring(b,c),b=parseInt(b,16)|0);1114111<b&&dk(a,"Hexadecimal codepoint is too big");return b}
+function mk(a,b){a.P=1+a.P|0;switch(b){case 100:case 68:a=jk().YQ;break;case 104:case 72:a=jk().aR;break;case 115:case 83:a=jk().ZQ;break;case 118:case 86:a=jk().bR;break;case 119:case 87:a=jk().$Q;break;case 112:case 80:var c=a.ri,d=a.P;if(d===c.length)c="?";else if(123===c.charCodeAt(d)){d=1+d|0;var e=c.indexOf("}",d)|0;0>e&&dk(a,"Unclosed character family");a.P=e;c=c.substring(d,e)}else c=c.substring(d,1+d|0);d=jk().qK;ug().ny.call(d,c)||ok(a,"Unicode character family");c=2!==(66&a.Ue)||"Lower"!==
+c&&"Upper"!==c?c:"Alpha";c=jk().qK[c];a.P=1+a.P|0;a=c;break;default:throw new Yj(hc(b));}97<=b?b=a:a.mK?b=a.oK:(b=a,b.mK||(b.oK=new sk(1^b.nK,b.yr),b.mK=!0),b=b.oK);return b}
+var Caa=function Baa(a){var c=a.ri,d=c.length;a.P=1+a.P|0;var e=a.P!==d?94===c.charCodeAt(a.P):!1;e&&(a.P=1+a.P|0);for(e=new tk(2===(66&a.Ue),e);a.P!==d;){var g=gk(c,a.P);a:{switch(g){case 93:return a.P=1+a.P|0,a=e,c=uk(a),""===a.ZF?c:"(?:"+a.ZF+c+")";case 38:a.P=1+a.P|0;if(a.P!==d&&38===c.charCodeAt(a.P)){a.P=1+a.P|0;g=e;var h=uk(g);g.ZF+=g.XQ?h+"|":"(?\x3d"+h+")";g.bm="";g.pg=""}else vk(a,38,d,c,e);break a;case 91:g=Baa(a);e.bm=""===e.bm?g:e.bm+"|"+g;break a;case 92:a.P=1+a.P|0;a.P===d&&dk(a,"Illegal escape sequence");
+h=c.charCodeAt(a.P);switch(h){case 100:case 68:case 104:case 72:case 115:case 83:case 118:case 86:case 119:case 87:case 112:case 80:g=e;h=mk(a,h);var k=h.nK;switch(k){case 0:g.pg=g.pg+("\\p{"+h.yr)+"}";break;case 1:g.pg=g.pg+("\\P{"+h.yr)+"}";break;case 2:g.pg=""+g.pg+h.yr;break;case 3:h=nk(jk(),h.yr);g.bm=""===g.bm?h:g.bm+"|"+h;break;default:throw new Yj(k);}break;case 81:a.P=1+a.P|0;g=c.indexOf("\\E",a.P)|0;0>g&&dk(a,"Unclosed character class");h=e;k=c;for(var l=g,m=a.P;m!==l;){var n=gk(k,m);wk(h,
+n);m=m+(65536<=n?2:1)|0}a.P=2+g|0;break;default:vk(a,qk(a),d,c,e)}break a;case 32:case 9:case 10:case 11:case 12:case 13:if(0!==(4&a.Ue))a.P=1+a.P|0;else break;break a;case 35:if(0!==(4&a.Ue)){lk(a);break a}}a.P=a.P+(65536<=g?2:1)|0;vk(a,g,d,c,e)}}dk(a,"Unclosed character class")};
+function Daa(a){var b=a.ri,c=b.length,d=a.P;if((1+d|0)===c||63!==b.charCodeAt(1+d|0))return a.P=1+d|0,a.mn=1+a.mn|0,a.nn.push(a.mn),"("+xk(a,!0)+")";(2+d|0)===c&&dk(a,"Unclosed group");var e=b.charCodeAt(2+d|0);if(58===e||61===e||33===e)return a.P=3+d|0,""+b.substring(d,3+d|0)+xk(a,!0)+")";if(60===e){(3+d|0)===c&&dk(a,"Unclosed group");b=b.charCodeAt(3+d|0);if(65<=b&&90>=b||97<=b&&122>=b)return a.P=3+d|0,d=pk(a),b=a.$F,ug().ny.call(b,d)&&dk(a,"named capturing group \x3c"+d+"\x3e is already defined"),
+a.mn=1+a.mn|0,a.nn.push(a.mn),a.$F[d]=-1+(a.nn.length|0)|0,a.P=1+a.P|0,"("+xk(a,!0)+")";61!==b&&33!==b&&dk(a,"Unknown look-behind group");ok(a,"Look-behind group")}else{if(62===e)return a.P=3+d|0,a.mn=1+a.mn|0,d=a.mn,"(?:(?\x3d("+xk(a,!0)+"))\\"+d+")";dk(a,"Embedded flag expression in the middle of a pattern is not supported")}}
+function pk(a){for(var b=a.ri,c=b.length,d=a.P;;){if(a.P!==c){var e=b.charCodeAt(a.P);e=65<=e&&90>=e||97<=e&&122>=e||48<=e&&57>=e}else e=!1;if(e)a.P=1+a.P|0;else break}a.P!==c&&62===b.charCodeAt(a.P)||dk(a,"named capturing group is missing trailing '\x3e'");return b.substring(d,a.P)}
+function vk(a,b,c,d,e){0!==(4&a.Ue)&&kk(a);a.P!==c&&45===d.charCodeAt(a.P)?(a.P=1+a.P|0,0!==(4&a.Ue)&&kk(a),a.P===c&&dk(a,"Unclosed character class"),c=gk(d,a.P),91===c||93===c?(wk(e,b),wk(e,45)):(a.P=a.P+(65536<=c?2:1)|0,c=92===c?qk(a):c,c<b&&dk(a,"Illegal character range"),a=yk(b)+"-"+yk(c),e.pg=56320===(-1024&b)?a+e.pg:e.pg+a,e.WQ&&(a=65<b?b:65,d=90>c?c:90,a<=d&&(d=32+d|0,e.pg+=yk(32+a|0)+"-"+yk(d)),b=97<b?b:97,c=122>c?c:122,b<=c&&(c=-32+c|0,e.pg+=yk(-32+b|0)+"-"+yk(c))))):wk(e,b)}
+function zk(a,b){this.ri=a;this.Ue=b;this.rK=!1;this.mn=this.P=0;this.nn=[0];this.$F={}}zk.prototype=new p;zk.prototype.constructor=zk;function ok(a,b){dk(a,b+" is not supported because it requires RegExp features of ECMAScript 2018.\nIf you only target environments with ES2018+, you can enable ES2018 features with\n  scalaJSLinkerConfig ~\x3d { _.withESFeatures(_.withESVersion(ESVersion.ES2018)) }\nor an equivalent configuration depending on your build tool.")}
+function xk(a,b){for(var c=a.ri,d=c.length,e="";a.P!==d;){var g=gk(c,a.P);a:{switch(g){case 41:return b||dk(a,"Unmatched closing ')'"),a.P=1+a.P|0,e;case 124:a.rK&&!b&&dk(a,"\\G is not supported when there is an alternative at the top level");a.P=1+a.P|0;e+="|";break a;case 32:case 9:case 10:case 11:case 12:case 13:if(0!==(4&a.Ue))a.P=1+a.P|0;else break;break a;case 35:if(0!==(4&a.Ue))lk(a);else break;break a;case 63:case 42:case 43:case 123:dk(a,"Dangling meta character '"+ik(jk(),g)+"'")}var h=
+a.mn;switch(g){case 92:g=zaa(a);break;case 91:g=Caa(a);break;case 40:g=Daa(a);break;case 94:a.P=1+a.P|0;g="(?:^)";break;case 36:a.P=1+a.P|0;g="(?:$)";break;case 46:a.P=1+a.P|0;g=0!==(32&a.Ue)?"":0!==(1&a.Ue)?"\n":"\n\r\u0085\u2028\u2029";g=nk(jk(),g);break;default:a.P=a.P+(65536<=g?2:1)|0,g=hk(a,g)}e=""+e+xaa(a,h,g)}}b&&dk(a,"Unclosed group");return e}
+function lk(a){for(var b=a.ri,c=b.length;;){if(a.P!==c){var d=b.charCodeAt(a.P);d=!(10===d||13===d||133===d||8232===d||8233===d)}else d=!1;if(d)a.P=1+a.P|0;else break}}zk.prototype.$classData=q({G2:0},!1,"java.util.regex.PatternCompiler",{G2:1,g:1});function Ak(a){try{return RegExp("",a),!0}catch(b){return!1}}
+function Bk(){this.dR=this.cR=null;this.pK=!1;this.qK=this.$Q=this.bR=this.ZQ=this.aR=this.YQ=null;Ck=this;this.cR=RegExp("^\\(\\?([idmsuxU]*)(?:-([idmsuxU]*))?\\)");this.dR=RegExp("(\\\\+)(\\d+)","g");this.pK=Ak("us");Ak("d");this.YQ=new sk(2,"0-9");this.aR=new sk(2,"\t \u00a0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000");this.ZQ=new sk(2,"\t-\r ");this.bR=new sk(2,"\n-\r\u0085\u2028\u2029");this.$Q=new sk(2,"a-zA-Z_0-9");var a={};a.Lower=new sk(2,"a-z");a.Upper=new sk(2,"A-Z");a.ASCII=new sk(2,"\x00-\u007f");
+a.Alpha=new sk(2,"A-Za-z");a.Digit=new sk(2,"0-9");a.Alnum=new sk(2,"0-9A-Za-z");a.Punct=new sk(2,"!-/:-@[-`{-~");a.Graph=new sk(2,"!-~");a.Print=new sk(2," -~");a.Blank=new sk(2,"\t ");a.Cntrl=new sk(2,"\x00-\u001f\u007f");a.XDigit=new sk(2,"0-9A-Fa-f");a.Space=new sk(2,"\t-\r ");this.qK=a}Bk.prototype=new p;Bk.prototype.constructor=Bk;
+function Dk(a){jk();a=new zk(a,0);0!==(256&a.Ue)&&(a.Ue|=64);var b=0!==(16&a.Ue);if(!b){var c=jk().cR.exec(a.ri);if(null!==c){var d=c[1];if(void 0!==d)for(var e=d.length,g=0;g<e;){var h=g;a.Ue|=Ek(jk(),d.charCodeAt(h));g=1+g|0}0!==(256&a.Ue)&&(a.Ue|=64);d=c[2];if(void 0!==d)for(e=d.length,g=0;g<e;)h=g,a.Ue&=~Ek(jk(),d.charCodeAt(h)),g=1+g|0;a.P=a.P+c[0].length|0}}0!==(128&a.Ue)&&dk(a,"CANON_EQ is not supported");0!==(8&a.Ue)&&ok(a,"MULTILINE");0!==(256&a.Ue)&&ok(a,"UNICODE_CHARACTER_CLASS");b?b=fk(a,
+a.ri):("\\G"===a.ri.substring(a.P,2+a.P|0)&&(a.rK=!0,a.P=2+a.P|0),b=xk(a,!1));c=jk().pK?"us":"u";return new Fk(a.ri,a.Ue,b,66===(66&a.Ue)?c+"i":c,a.rK,-1+(a.nn.length|0)|0,a.nn,a.$F)}function Ek(a,b){switch(b){case 105:return 2;case 100:return 1;case 109:return 8;case 115:return 32;case 117:return 64;case 120:return 4;case 85:return 256;default:throw Kj("bad in-pattern flag");}}function nk(a,b){return""!==b?"[^"+b+"]":jk().pK?".":"[\\d\\D]"}function ik(a,b){return String.fromCodePoint(b)}
+Bk.prototype.$classData=q({H2:0},!1,"java.util.regex.PatternCompiler$",{H2:1,g:1});var Ck;function jk(){Ck||(Ck=new Bk);return Ck}function uk(a){if(a.XQ){var b=nk(jk(),a.pg);return""===a.bm?b:"(?:(?!"+a.bm+")"+b+")"}return""===a.pg?""===a.bm?"[^\\d\\D]":"(?:"+a.bm+")":""===a.bm?"["+a.pg+"]":"(?:"+a.bm+"|["+a.pg+"])"}function yk(a){var b=ik(jk(),a);return 93===a||92===a||45===a||94===a?"\\"+b:b}function tk(a,b){this.WQ=a;this.XQ=b;this.pg=this.bm=this.ZF=""}tk.prototype=new p;
+tk.prototype.constructor=tk;function wk(a,b){var c=yk(b);a.pg=56320===(-1024&b)?""+c+a.pg:""+a.pg+c;a.WQ&&(65<=b&&90>=b?a.pg=""+a.pg+ik(jk(),32+b|0):97<=b&&122>=b&&(a.pg=""+a.pg+ik(jk(),-32+b|0)))}tk.prototype.$classData=q({I2:0},!1,"java.util.regex.PatternCompiler$CharacterClassBuilder",{I2:1,g:1});function sk(a,b){this.oK=null;this.mK=!1;this.nK=a;this.yr=b}sk.prototype=new p;sk.prototype.constructor=sk;
+sk.prototype.$classData=q({J2:0},!1,"java.util.regex.PatternCompiler$CompiledCharClass",{J2:1,g:1});function Hk(a){if(0===(1&a.ci)<<24>>24&&0===(1&a.ci)<<24>>24){if(Ik()===a)var b="(",c=")";else if(Jk()===a)b="{",c="}";else if(Kk()===a)b="[",c="]";else if(Lk()===a)b="\u2039",c="\u203a";else if(Mk()===a)b="\u2192",c="\u2190";else if(Nk()===a)b='code"',c='"';else if(Ok()===a)b='code"""',c='"""';else{if(Pk()!==a)throw new w(a);b="${";c="}"}a.Wo=G(new H,b,c);a.ci=(1|a.ci)<<24>>24}return a.Wo}
+function Qk(){this.Vo=this.Uo=this.Wo=null;this.ci=0}Qk.prototype=new p;Qk.prototype.constructor=Qk;function Rk(){}Rk.prototype=Qk.prototype;function Sk(a){0===(2&a.ci)<<24>>24&&0===(2&a.ci)<<24>>24&&(a.Uo=Hk(a).h(),a.ci=(2|a.ci)<<24>>24);return a.Uo}function Tk(a){0===(4&a.ci)<<24>>24&&0===(4&a.ci)<<24>>24&&(a.Vo=Hk(a).j(),a.ci=(4|a.ci)<<24>>24);return a.Vo}
+Qk.prototype.Ua=function(){if(Ik()===this)return"parenthesis";if(Jk()===this)return"curly brace";if(Kk()===this)return"square bracket";if(Lk()===this)return"angle bracket";if(Mk()===this)return"indentation";if(Nk()===this)return"quasiquote";if(Ok()===this)return"quasiquote triple";if(Pk()===this)return"unquote";throw new w(this);};function Uk(){}Uk.prototype=new p;Uk.prototype.constructor=Uk;function Vk(a,b){return Wk(new Xk).Ob(hc(b),new y(()=>{t();return R()}))}
+Uk.prototype.$classData=q({$T:0},!1,"mlscript.BracketKind$",{$T:1,g:1});var Yk;function Zk(){Yk||(Yk=new Uk);return Yk}var Eaa=function bl(a){var c=a.vK();if(c instanceof cl&&Pe(new E(c.Yo),a.Yo))c=bl(c);else{c=a.vK();var d=O().c;c=new z(c,d)}d=a.DK();d instanceof cl&&Pe(new E(d.Yo),a.Yo)?a=bl(d):(a=a.DK(),d=O().c,a=new z(a,d));return dl(a,c)};
+function Faa(a){var b=k=>a.Yo?Pe(new E(k),el()):Pe(new E(k),gl()),c=Eaa(a);a:for(;;)if(c.b()){b=u();break}else{var d=c.e(),e=c.f();if(!0===!!b(d))c=e;else for(;;){if(e.b())b=c;else{d=e.e();if(!0!==!!b(d)){e=e.f();continue}d=e;e=new z(c.e(),u());var g=c.f();for(c=e;g!==d;){var h=new z(g.e(),u());c=c.p=h;g=g.f()}for(g=d=d.f();!d.b();){h=d.e();if(!0===!!b(h)){for(;g!==d;)h=new z(g.e(),u()),c=c.p=h,g=g.f();g=d.f()}d=d.f()}g.b()||(c.p=g);b=e}break a}}return hl(b)}function il(){}il.prototype=new p;
+il.prototype.constructor=il;function jl(){}jl.prototype=il.prototype;function Ae(a,b,c){a.TM=b;a.$C=c;Sf||(Sf=new Rf);c=kl();for(var d=0,e=1,g=null;d<b.length;){var h=b.charCodeAt(d);13===h?(ml(nl(),g,hc(10))||1!==e||ol(c,d),e=1):10===h?(ml(nl(),g,hc(13))||1!==e||ol(c,d),e=1):(1===e&&ol(c,d),e=1+e|0);g=hc(h);d=1+d|0}1===e&&ol(c,d);rl();if(0<=c.Zg)b=new Xc(c.Zg),c.Gc(b,0,2147483647),c=b;else{b=[];for(c=sl(c).m();c.s();)d=c.t(),b.push(null===d?0:d);c=new Xc(new Int32Array(b))}a.ZC=c;return a}
+function Gaa(){var a=new Fe;Ae(a,"",ue(ve(),""));return a}function Fe(){this.ZC=this.$C=this.TM=null}Fe.prototype=new p;Fe.prototype.constructor=Fe;function Nf(a,b){var c=a.ZC;a:{for(var d=0;d<c.a.length;){if(c.a[d]>b){c=d;break a}d=1+d|0}c=-1}c=-1===c?a.ZC.a.length:1>c?1:c;d=a.$C.K();d=-1+(c<d?c:d)|0;b=1+(b-a.ZC.a[d]|0)|0;a=a.$C.va(d);return new tl(c,a,b)}Fe.prototype.$classData=q({QU:0},!1,"mlscript.FastParseHelpers",{QU:1,g:1});
+var hm=function ul(a,b,c){for(;;){var e=b;if(e instanceof vl)return c=wl(c,e.x),new xl(c);if(e instanceof yl){var g=e.ll;c=(k=>l=>{if(null!==l){var m=l.h(),n=l.j();if(null!==m&&(m=m.x,null!==n&&(n=n.ya,n instanceof vl))){l=wl(k,n.x);m=zl(Al(),m);if(l===m)return l=t().d,G(new H,m,l);t();return G(new H,m,new L(new xl(l)))}}if(null!==l&&(n=l.h(),m=l.j(),null!==n&&(n=n.x,null!==m)))return l=m.ya,m=zl(Al(),n),t(),l=ul(a,l,k),G(new H,m,new L(l));throw new w(l);})(c);if(g===u())c=u();else{b=g.e();e=b=new z(c(b),
+u());for(g=g.f();g!==u();){var h=g.e();h=new z(c(h),u());e=e.p=h;g=g.f()}c=b}return new Bl(c)}if(e instanceof Cl)b=e.ai;else{if(e instanceof Dl)return new El;if(e instanceof Fl)b=e.gg;else{if(e instanceof Gl){g=e.Ra;c=(k=>l=>{if(null!==l){var m=l.j();if(null!==m)return ul(a,m.ya,k)}throw new w(l);})(c);if(g===u())c=u();else{b=g.e();e=b=new z(c(b),u());for(g=g.f();g!==u();)h=g.e(),h=new z(c(h),u()),e=e.p=h,g=g.f();c=b}return new Hl(c)}if(e instanceof Il)b=e.nl;else if(e instanceof Kl)b=e.cp;else if(e instanceof
+Ml)b=e.Ml;else{if(e instanceof Ol||e instanceof Pl||e instanceof Ql||e instanceof Rl||e instanceof Sl||e instanceof Tl||e instanceof Ul||e instanceof Vl||e instanceof Wl||e instanceof Xl||e instanceof Yl||e instanceof Zl||e instanceof $l||e instanceof am||e instanceof bm||e instanceof cm||e instanceof dm||e instanceof em||e instanceof fm)throw new gm("term "+b+" is not a valid pattern");throw new w(e);}}}}};
+function im(a,b,c){if(b instanceof Gl){var d=b.Ra;b=k=>{if(null!==k){var l=new L(k);if(!l.b()){var m=l.k.h();l=l.k.j();if(t().d===m&&null!==l)return hm(a,l.ya,c)}}if(null!==k&&(l=new L(k),!l.b()&&(m=l.k.h(),l=l.k.j(),m instanceof L&&(m=m.k,null!==l))))return hm(a,m,c);throw new w(k);};if(d===u())return u();var e=d.e(),g=e=new z(b(e),u());for(d=d.f();d!==u();){var h=d.e();h=new z(b(h),u());g=g.p=h;d=d.f()}return e}throw new gm("term "+b+" is not a valid parameter list");}
+function jm(a,b,c){var d=a.CK();d.b()?c=new km(a.Ua()):(d=d.o(),lm(c,d).sF=!0,c=new km(d),d=a.Ua(),c=om(Al(),c,d));return b&&!a.UJ()?om(Al(),c,"class"):c}function pm(a,b){a=new vl(a);var c=h=>{var k=t().d;h=new sm(tm().Cg,h);return G(new H,k,h)};if(b===u())c=u();else{var d=b.e(),e=d=new z(c(d),u());for(b=b.f();b!==u();){var g=b.e();g=new z(c(g),u());e=e.p=g;b=b.f()}c=d}return new Pl(a,new Gl(c))}
+var Iaa=function Haa(a,b,c,d,e){if(b instanceof um){var h=b.Tn,k=b.Un;b=vm(a,b.Xo,c,d,e);h=vm(a,h,c,d,e);a=Haa(a,k,c,d,e);if(a instanceof fe)return a=a.aa,t(),c=O().c,b=pm("Case",new z(b,new z(h,new z(a,c)))),new fe(b);if(a instanceof Ud){a=a.fa;if(b instanceof wm)return t(),b=new um(b,h,a),new Ud(b);xm("Program reached and unexpected state.")}else throw new w(a);}else{if(b instanceof ym){b=b.dn;if(d)return t(),b=vm(a,b,c,d,e),h=O().c,b=pm("Wildcard",new z(b,h)),new fe(b);t();b=new ym(vm(a,b,c,d,
+e));return new Ud(b)}if(zm()===b){if(d)return t(),b=pm("NoCases",O().c),new fe(b);t();b=zm();return new Ud(b)}throw new w(b);}};function Am(a){switch(a){case "+.":return"+";case "-.":return"-";case "*.":return"*";default:return a}}
+var vm=function Bm(a,b,c,d,e){for(;;){var h=!1,k=null,l=b;if(l instanceof vl){var m=l.x,n=e.xH.L(m);if(d||n){var r=Cm(c,m);if(r.b())throw new gm("unbound free variable "+m+" is not supported yet.");var v=r.o().zo();if(n){var x=new vl(v),A=O().c;return pm("Var",new z(x,A))}var B=new Dm(v),C=O().c;return pm("Var",new z(B,C))}return b}if(l instanceof Em){var D=l;if(d){var F=O().c;return pm("IntLit",new z(D,F))}return D}if(l instanceof Fm){var I=l;if(d){var M=O().c;return pm("DecLit",new z(I,M))}return I}if(l instanceof
+Dm){var N=l;if(d){var P=O().c;return pm("StrLit",new z(N,P))}return N}if(l instanceof Gm){var T=l;if(d){var Y=O().c;return pm("UnitLit",new z(T,Y))}return T}if(l instanceof Ol){var Z=l,S=Z.Ej,ea=Z.Fj;if(d){var ia=Hm(c);if(S instanceof Gl){var X=S.Ra,sa=(Jh=>If=>{if(null!==If){var Hg=new L(If);if(!Hg.b()){var He=Hg.k.h();Hg=Hg.k.j();if(t().d===He&&null!==Hg&&(He=Hg.ya,He instanceof vl))return If=He.x,wl(Jh,If),He=Im(Jh,If,(t(),new L(!1)),!1,t().d).re,G(new H,If,He)}}if(null!==If&&(He=new L(If),!He.b()&&
+(He=He.k.h(),He instanceof L&&(He=He.k,null!==He))))return If=He.x,wl(Jh,If),He=Im(Jh,If,(t(),new L(!1)),!1,t().d).re,G(new H,If,He);throw new gm("parameter "+If+" is not supported in quasiquote");})(ia);if(X===u())var Ja=u();else{for(var Xa=X.e(),Fa=new z(sa(Xa),u()),za=Fa,Qa=X.f();Qa!==u();){var Ma=Qa.e(),Ga=new z(sa(Ma),u());za=za.p=Ga;Qa=Qa.f()}Ja=Fa}var ab=d,Hb=e.xH;if(Ja===u())var bc=u();else{for(var yb=Ja.e(),tb=new z(yb.h(),u()),eb=tb,kb=Ja.f();kb!==u();){var Rb=kb.e(),Gb=new z(Rb.h(),u());
+eb=eb.p=Gb;kb=kb.f()}bc=tb}for(var vb=Bm(a,ea,ia,ab,new Jm(a,Hb.Ce(bc))),Tb=Km(Ja);!Tb.b();){var Nb=Tb.e(),ic=vb,Va=new vl(Nb.j()),cb=new Dm(Nb.h()),zb=O().c,Ub=pm("freshName",new z(cb,zb)),jb=new vl(Nb.j()),db=O().c,ub=pm("Var",new z(jb,db)),Aa=O().c;vb=new Rl(!1,Va,Ub,pm("Lam",new z(ub,new z(ic,Aa))));Tb=Tb.f()}return vb}throw new gm("term "+S+" is not a valid parameter list");}return new Ol(S,Bm(a,ea,c,d,e))}if(l instanceof fm){var va=l.jt;if(d){var Ra=Hm(c);b=va;c=Ra;d=!1;continue}else throw new gm("unquoted term should be wrapped by quotes.");
+}if(l instanceof em){var rb=l.Iq,xb=Hm(c),mc=Bm(a,rb,xb,!0,e);if(d)throw new gm("nested quotation is not allowed.");return mc}if(l instanceof Pl){h=!0;k=l;var Ha=k.Za,Ka=k.Qb;if(Ha instanceof vl){var Oa=Ha.x;if(Ka instanceof Gl){var Na=Ka.Ra;if(Na instanceof z){var Da=Na,ta=Da.z,Ya=Da.p;if(null!==ta){var dc=new L(ta);if(!dc.b()){var ka=dc.k.h(),ya=dc.k.j();if(t().d===ka&&null!==ya){var Sa=ya.yb,xc=ya.ya;if(Ya instanceof z){var Sb=Ya,uc=Sb.z,Lb=Sb.p;if(null!==uc){var lc=new L(uc);if(!lc.b()){var Xb=
+lc.k.h(),ec=lc.k.j();if(t().d===Xb&&null!==ec){var Ab=ec.yb,Ob=ec.ya,fb=O().c;if((null===fb?null===Lb:fb.i(Lb))&&Lm().gD.L(Am(Oa))&&(!Mm(a,Oa,!0,c).tv()||Nm(new E(Oa),Am(Oa)))){if(d){var Wa=new Dm(Am(Oa)),bb=O().c,Ia=pm("Var",new z(Wa,bb)),Ua=Bm(a,xc,c,d,e),pc=Bm(a,Ob,c,d,e),sc=O().c;return pm("App",new z(Ia,new z(Ua,new z(pc,sc))))}var Ba=new vl(Oa),ob=t().d,nc=new sm(Sa,Bm(a,xc,c,d,e)),Ib=G(new H,ob,nc),vc=t().d,Vb=new sm(Ab,Bm(a,Ob,c,d,e)),fc=G(new H,vc,Vb),Bc=O().c;return new Pl(Ba,new Gl(new z(Ib,
+new z(fc,Bc))))}}}}}}}}}}}}if(h){var Pb=k.Za,Jb=k.Qb;if(d){var gc=Bm(a,Pb,c,d,e),Cb=Bm(a,Jb,c,d,e),cc=O().c;return pm("App",new z(gc,new z(Cb,cc)))}return new Pl(Bm(a,Pb,c,d,e),Bm(a,Jb,c,d,e))}if(l instanceof yl){var yc=l.ll;if(d){for(var Mc=c,qc=d,oc=yc,Qc=null,jc=null;oc!==u();){for(var sb=oc.e(),Gc=new Dm(sb.h().x),Wb=O().c,Cc=pm("Var",new z(Gc,Wb)),Fc=Bm(a,sb.j().ya,Mc,qc,e),qd=O().c,Yb=new Om(new z(Cc,new z(Fc,qd)));Yb.s();){var Nc=new z(Yb.t(),u());null===jc?Qc=Nc:jc.p=Nc;jc=Nc}oc=oc.f()}return pm("Rcd",
+null===Qc?u():Qc)}var ad=((Jh,If,Hg)=>He=>G(new H,He.h(),new sm(He.j().yb,Bm(a,He.j().ya,Jh,If,Hg))))(c,d,e);if(yc===u())var Uc=u();else{for(var cd=yc.e(),kc=new z(ad(cd),u()),Vc=kc,Hc=yc.f();Hc!==u();){var rc=Hc.e(),sd=new z(ad(rc),u());Vc=Vc.p=sd;Hc=Hc.f()}Uc=kc}return new yl(Uc)}if(l instanceof Fl){var Kc=l,Qd=Kc.bi,Ad=Kc.gg;if(d){var kd=Bm(a,Ad,c,d,e),Hd=O().c;return pm("Bra",new z(kd,Hd))}return new Fl(Qd,Bm(a,Ad,c,d,e))}if(l instanceof Ql){var Rd=l,Bd=Rd.Vl,ae=Rd.ml;if(null!==ae){var dd=ae.x;
+if(d){var od=Bm(a,Bd,c,d,e),Ta=new Dm(dd),wb=O().c,$a=pm("Var",new z(Ta,wb)),wa=O().c;return pm("Sel",new z(od,new z($a,wa)))}return new Ql(Bm(a,Bd,c,d,e),ae)}}if(l instanceof Rl){var hb=l,ra=hb.ep,wc=hb.Zn,ac=hb.$n,Id=hb.Mm;if(null!==wc){var ud=wc.x,be=Hm(c);if(d){wl(be,ud);var re=Im(be,ud,(t(),new L(!1)),!1,t().d).re,pe=new vl(re),bd=new Dm(ud),Rc=O().c,Wc=pm("freshName",new z(bd,Rc)),Wd=new vl(re),zd=O().c,Pa=pm("Var",new z(Wd,zd)),Db=Bm(a,ac,c,d,e),Oc=d,Tc=e.xH,Sd=O().c,Jc=Bm(a,Id,be,Oc,new Jm(a,
+Tc.Ce(new z(ud,Sd)))),vd=O().c;return new Rl(!1,pe,Wc,pm("Let",new z(Pa,new z(Db,new z(Jc,vd)))))}return new Rl(ra,new vl(ud),Bm(a,ac,c,d,e),Bm(a,Id,be,d,e))}}if(l instanceof Sl){var hd=l.Dj,de=((Jh,If,Hg)=>He=>{if(He instanceof Pm)return Bm(a,He,Jh,If,Hg);throw new gm("statement "+He+" is not supported in quasiquotes");})(Hm(c),d,e);if(hd===u())var ye=u();else{for(var jf=hd.e(),af=new z(de(jf),u()),pf=af,kf=hd.f();kf!==u();){var Be=kf.e(),Kd=new z(de(Be),u());pf=pf.p=Kd;kf=kf.f()}ye=af}return d?
+pm("Blk",ye):new Sl(ye)}if(l instanceof Gl){var ld=l.Ra;if(d){for(var Jd=c,Dd=d,Xd=ld,Yc=null,Ce=null;Xd!==u();){var te=Xd.e();a:{if(null!==te){var Ie=new L(te);if(!Ie.b()){var Jf=Ie.k.h(),df=Ie.k.j();if(Jf instanceof L){var vg=Jf.k;if(null!==vg){var wg=vg.x;if(null!==df){var xg=df.yb,eg=df.ya,vh=new vl(wg),fg=O().c,ih=pm("Var",new z(vh,fg)),Ig=Bm(a,eg,Jd,Dd,e),Tf=Xm(xg),Jg=pm("Fld",new z(Ig,Tf)),jh=O().c;var yg=new z(ih,new z(Jg,jh));break a}}}}}if(null!==te){var gg=new L(te);if(!gg.b()){var Cf=
+gg.k.h(),Uf=gg.k.j();if(t().d===Cf&&null!==Uf){var $g=Uf.yb,Ah=Bm(a,Uf.ya,Jd,Dd,e),Kg=Xm($g),Vf=pm("Fld",new z(Ah,Kg)),hg=O().c;yg=new z(Vf,hg);break a}}}throw new w(te);}for(var zg=new Om(yg);zg.s();){var Lg=new z(zg.t(),u());null===Ce?Yc=Lg:Ce.p=Lg;Ce=Lg}Xd=Xd.f()}return pm("Tup",null===Yc?u():Yc)}var Mg=((Jh,If,Hg)=>He=>{if(null!==He){var lj=new L(He);if(!lj.b()){var Wi=lj.k.h();lj=lj.k.j();if(null!==lj)return He=new sm(lj.yb,Bm(a,lj.ya,Jh,If,Hg)),G(new H,Wi,He)}}throw new w(He);})(c,d,e);if(ld===
+u())var Wf=u();else{for(var Ng=ld.e(),Kf=new z(Mg(Ng),u()),xf=Kf,Og=ld.f();Og!==u();){var mi=Og.e(),Ci=new z(Mg(mi),u());xf=xf.p=Ci;Og=Og.f()}Wf=Kf}return new Gl(Wf)}if(l instanceof Vl){var Xh=l,wh=Xh.lp,Bh=Xh.mp;if(d){var ng=Bm(a,wh,c,d,e),kh=Bm(a,Bh,c,d,e),Kh=O().c;return pm("Subs",new z(ng,new z(kh,Kh)))}return new Vl(Bm(a,wh,c,d,e),Bm(a,Bh,c,d,e))}if(l instanceof Cl){var ni=l,Lh=ni.ai,lh=ni.Fm;if(d){b=Lh;continue}else return new Cl(Bm(a,Lh,c,d,e),lh)}if(l instanceof Tl){var Ch=l,Dh=Ch.br,Yh=Ch.ar;
+if(null!==Yh){var ah=Yh.ll;if(d){var oi=Bm(a,Dh,c,d,e),mj=Bm(a,Yh,c,d,e),wd=O().c;return pm("With",new z(oi,new z(mj,wd)))}var ge=Bm(a,Dh,c,d,e),De=((Jh,If,Hg)=>He=>G(new H,He.h(),new sm(He.j().yb,Bm(a,He.j().ya,Jh,If,Hg))))(c,d,e);if(ah===u())var qf=u();else{for(var og=ah.e(),Xf=new z(De(og),u()),mh=Xf,Ag=ah.f();Ag!==u();){var Bg=Ag.e(),Eh=new z(De(Bg),u());mh=mh.p=Eh;Ag=Ag.f()}qf=Xf}return new Tl(ge,new yl(qf))}}if(l instanceof Ul){var Pg=l,Di=Pg.Sn,Mh=Iaa(a,Pg.Hm,c,d,e);if(Mh instanceof fe){var pi=
+Mh.aa,Xi=Bm(a,Di,c,d,e),Qg=O().c;return pm("CaseOf",new z(Xi,new z(pi,Qg)))}if(Mh instanceof Ud){var nh=Mh.fa;return new Ul(Bm(a,Di,c,d,e),nh)}throw new w(Mh);}if(b.oc.b()){if(l instanceof Wl){var bh=l,Mj=bh.Gm,Nj=bh.Qn;if(!d)return new Wl(Bm(a,Mj,c,d,e),Bm(a,Nj,c,d,e))}if(l instanceof Yl){var ie=l.hp;if(!d)return new Yl(Bm(a,ie,c,d,e))}if(l instanceof Il){var Ac=l,Ve=Ac.nl,Td=Ac.np;if(!d)return new Il(Bm(a,Ve,c,d,e),Td)}if(l instanceof Zl){var lf=l,Yi=lf.qq,Jl=lf.$o;if(!d)return new Zl(Yi,Bm(a,Jl,
+c,d,e))}if(l instanceof Kl){var ll=l.cp;if(!d)return new Kl(Bm(a,ll,c,d,e))}if(l instanceof am&&!d)return b;if(l instanceof bm){var Bj=l,$k=Bj.Vn,Zh=Bj.Zo;if(!d)return new bm($k,Bm(a,Zh,c,d,e))}if(l instanceof Ml){var Ei=l,Yd=Ei.Ml;return new Ml(Bm(a,Ei.gs,c,d,e),Bm(a,Yd,c,d,e))}if(l instanceof dm){var bf=l,rf=bf.$q,Cg=bf.Zq;if(!d)return new dm(Bm(a,rf,c,d,e),Bm(a,Cg,c,d,e))}if(l instanceof Xl||l instanceof $l||l instanceof cm||l instanceof Wl||l instanceof Yl||l instanceof Il||l instanceof Zl||l instanceof
+Kl||l instanceof am||l instanceof bm||l instanceof dm)throw new gm("this quote syntax is not supported yet.");throw new w(l);}var nj=b.oc;nj.b()&&xm("Program reached and unexpected state.");b=nj.o()}},en=function Jaa(a,b,c,d){if(c instanceof um){var g=c.Un;return Ym(a,b,c.Xo,d).ba(Zm(a,c.Tn,d),Jaa(a,b,g,d))}if(c instanceof ym)return Zm(a,c.dn,d);if(zm()===c)return a=t().d,b=O().c,t(),c=new $m(new km("Error")),d=an("non-exhaustive case expression"),g=O().c,c=new bn(new cn(c,new z(d,g))),d=O().c,new dn(a,
+b,new Ud(new z(c,d)),O().c);throw new w(c);};
+function Ym(a,b,c,d){return new fn((e,g)=>{var h=!1,k=null;a:{if(c instanceof vl&&(h=!0,k=c,"int"===k.x)){h=om(Al(),new km("Number"),"isInteger");k=O().c;h=new cn(h,new z(b,k));break a}if(h&&"bool"===k.x)h=new gn("\x3d\x3d\x3d",om(Al(),b,"constructor"),new hn("Boolean"));else{if(h){var l=k.x;if("true"===l||"false"===l){h=new gn("\x3d\x3d\x3d",b,new hn(l));break a}}if(h&&"string"===k.x)h=new gn("\x3d\x3d\x3d",om(Al(),b,"constructor"),new hn("String"));else{if(h){h=k.x;k=!1;l=null;var m=Cm(d,h);if(m instanceof
+L&&(k=!0,l=m,m=l.k,m instanceof jn)){h=new kn(b,jm(m,!0,d));break a}if(k&&(k=l.k,k instanceof ln)){h=new kn(b,jm(k,!0,d));break a}k=!1;l=null;m=a.di.ko.U(h);m instanceof L&&(k=!0,l=m);if(k&&(m=l.k,m instanceof mn)){h=new km(m.Tx);h=om(Al(),h,"is");k=J(new K,[b]);h=new cn(h,(Od(),Pd(u(),k)));break a}if(k&&l.k instanceof nn)throw new gm("cannot match type alias "+h);throw new gm("unknown match case: "+h);}if(c instanceof Dl)h=new gn("\x3d\x3d\x3d",b,Zm(a,c,d));else throw new w(c);}}}return new on(h,
+e,g)})}function Kaa(a,b){if(a instanceof z){var c=a.z;a=a.p;t();for(c=pn(c,new km("Object"),!1,b);!a.b();){var d=a.e();c=pn(d,c,!0,b);a=a.f()}return new L(c)}b=O().c;if(null===b?null===a:b.i(a))return t().d;throw new w(a);}
+function Laa(a,b,c,d,e){var g=b.uq.x,h=n=>{var r=Im(e,n,new L(!1),!1,t().d);return new qn(r.re,new km("this.#"+n))};if(c===u())h=u();else{var k=c.e(),l=k=new z(h(k),u());for(c=c.f();c!==u();){var m=c.e();m=new z(h(m),u());l=l.p=m;c=c.f()}h=k}l=b.bx.aa;l instanceof Ol?(b=l.Fj,k=im(a,l.Ej,e),t(),k=new L(k),l=b):k=t().d;b=k;a=rn(Zm(a,l,e));k=sn(e.lo);k instanceof L?(k=k.k,l=O().c,k=new z(k,l)):k=O().c;d.b()?d=O().c:(d=d.o(),d=tn(lm(e,d)));t();d=un(un(h,k),d);h=O().c;d=un(d,new z(a,h));d=new Ud(d);if(b instanceof
+L)return new vn(g,b.k,d);if(t().d===b)return new wn(g,d);throw new w(b);}function xn(a,b){b=a.di.ko.U(b);if(b instanceof L){var c=b.k;if(c instanceof mn){b=yn(c.Sx);c=zn(c.Sx);for(var d=null,e=null;c!==u();){var g=c.e();for(g=xn(a,g).m();g.s();){var h=new z(g.t(),u());null===e?d=h:e.p=h;e=h}c=c.f()}a=null===d?u():d;return un(b,a)}}a=b instanceof L&&null!==b.k?!0:t().d===b?!0:!1;if(a)return O().c;throw new w(b);}function An(a){return a?new vl("true"):new vl("false")}
+function Xm(a){var b=An(a.je),c=An(a.ch);a=An(a.Bh);var d=O().c;return new z(b,new z(c,new z(a,d)))}
+function pn(a,b,c,d){a:for(;;)if(a instanceof Pl)a=a.Za;else{if(a instanceof vl){a=a.x;break a}if(a instanceof Ql){var e=a.ml;if(null!==e){a=e.x;break a}}if(a instanceof Il)a=a.nl;else throw new gm("unsupported parents.");}e=!1;var g=null,h=Cm(d,a);if(h instanceof L&&(e=!0,g=h,g.k instanceof mn))return b;if(e){var k=g.k;if(k instanceof Hn)return c=jm(k,!0,d),t(),b=J(new K,[b]),new cn(c,Pd(u(),b))}if(e&&(b=g.k)&&b.$classData&&b.$classData.rb.pF&&!c)return jm(b,!0,d);if(e)throw new gm("unexpected parent symbol "+
+g.k+".");if(t().d===h)throw new gm("unresolved parent "+a+".");throw new w(h);}function Mn(a,b){if(null===b)throw le();return b.sb?b.vb:me(b,new On(a))}function Pn(a){a=Qn(a);if(a instanceof fe)return gl();if(a instanceof Ud)return a.fa;throw new w(a);}
+function Rn(a,b,c,d,e){var g=v=>{if(null!==v){var x=v.h(),A=v.j();if(x instanceof L&&(x=x.k,null!==A)){var B=A.yb;A=A.ya;if(null!==B)return v=B.je,A=Pn(A),v=new Sn(v?(t(),new L(A)):t().d,A),G(new H,x,v)}}if(null!==v&&(x=v.h(),v=v.j(),t().d===x&&null!==v&&(A=v.yb,x=v.ya,null!==A&&(v=A.je,x instanceof vl))))return v?(t(),v=el(),v=new L(v)):v=t().d,v=new Sn(v,gl()),G(new H,x,v);xm("Program reached and unexpected state.")};if(c===u())g=u();else{for(var h=c.e(),k=h=new z(g(h),u()),l=c.f();l!==u();){var m=
+l.e();m=new z(g(m),u());k=k.p=m;l=l.f()}g=h}h=v=>null!==v&&(v=v.j(),null!==v)?v.yb.Bh:!1;k=c;a:for(;;)if(k.b()){l=u();break}else if(l=k.e(),c=k.f(),!1===!!h(l))k=c;else for(;;){if(c.b())l=k;else{l=c.e();if(!1!==!!h(l)){c=c.f();continue}l=c;c=new z(k.e(),u());m=k.f();for(k=c;m!==l;){var n=new z(m.e(),u());k=k.p=n;m=m.f()}for(m=l=l.f();!l.b();){n=l.e();if(!1===!!h(n)){for(;m!==l;)n=new z(m.e(),u()),k=k.p=n,m=m.f();m=l.f()}l=l.f()}m.b()||(k.p=m);l=c}break a}h=v=>{if(null!==v){var x=v.h();if(x instanceof
+L)return x.k.x}if(null!==v&&(x=v.h(),v=v.j(),t().d===x&&null!==v&&(v=v.ya,v instanceof vl)))return v.x;xm("Program reached and unexpected state.")};if(l===u())h=u();else{c=l.e();k=c=new z(h(c),u());for(l=l.f();l!==u();)m=l.e(),m=new z(h(m),u()),k=k.p=m,l=l.f();h=c}if(d===u())d=u();else{c=d.e();k=c=new z(Pn(c),u());for(d=d.f();d!==u();)l=d.e(),l=new z(Pn(l),u()),k=k.p=l,d=d.f();d=c}d=d.mf(new Tn(g),Un());c=Vn();g=Wn(ef(e),new Xn(a,c,b));b=Wn(ef(e),new Yn(a,c,b));c=v=>{var x=!1,A=null;if(v instanceof
+Cl){x=!0;A=v;var B=A.ai;if(B instanceof vl&&"this"===B.x)return!1}return x&&A.ai instanceof am?!1:v instanceof Zn&&(x=v.wd,A=v.Yc,x instanceof L&&!1===!!x.k&&A instanceof fe)?!0:v instanceof Pm?!0:!1};l=ef(e);a:for(;;)if(l.b()){c=u();break}else if(m=l.e(),k=l.f(),!1===!!c(m))l=k;else for(;;){if(k.b())c=l;else{m=k.e();if(!1!==!!c(m)){k=k.f();continue}m=k;k=new z(l.e(),u());n=l.f();for(l=k;n!==m;){var r=new z(n.e(),u());l=l.p=r;n=n.f()}for(n=m=m.f();!m.b();){r=m.e();if(!1===!!c(r)){for(;n!==m;)r=new z(n.e(),
+u()),l=l.p=r,n=n.f();n=m.f()}m=m.f()}n.b()||(l.p=n);c=k}break a}a=Wn(ef(e),new ao(a));return new bo(d,g,b,c,a,h)}function co(){this.Cs=this.di=null}co.prototype=new p;co.prototype.constructor=co;function eo(){}eo.prototype=co.prototype;function fo(a,b,c,d){a=Mm(a,b,c,d);if(!(a instanceof Ud)){if(a instanceof fe)throw a.aa;throw new w(a);}return a.fa}
+function Mm(a,b,c,d){O();var e=!1,g=null,h=Cm(d,b);a:{if(h instanceof L){e=!0;g=h;var k=g.k;if(k instanceof go){k.DP=!0;a.Cs.Yz.L(k.Nx)||ho(a.Cs,k.Nx,k.bF);b=new km(k.bF);"error"===k.Nx&&(d=u(),b=new cn(b,d));break a}}if(e&&(k=g.k,k instanceof io)){if(!k.z_)throw new jo(k);b=new km(k.nt);break a}if(e&&(k=g.k,k instanceof ko)){d=k.hJ;if((d.b()?0:d.o())&&!k.iJ)throw new gm("unguarded recursive use of by-value binding "+b);k.sF=!0;b=new km(k.re);k.hJ.b()&&!k.iJ&&(d=u(),b=new cn(b,d));break a}if(e&&(k=
+g.k)&&k.$classData&&k.$classData.rb.pF){b=jm(k,c,d);break a}if(e&&(c=g.k,c instanceof lo)){e=c.Ox;if((e.b()?0:e.o())&&!c.Px)throw new gm("unguarded recursive use of by-value binding "+b);b=c.FA;if(b.b())throw new gm("unqualified member symbol "+c);b=b.o();c.OP=!0;lm(d,b).sF=!0;c.EA?b=new km(b+".#"+c.dr):(b=new km(b),d=c.dr,b=om(Al(),b,d));c.Ox.b()&&!c.Px&&(d=u(),b=new cn(b,d));break a}if(e&&g.k instanceof mn)return O(),b=new gm("trait used in term position"),new fe(b);if(t().d===h){e=!1;d=d.ko.U(b);
+if(d instanceof L&&(e=!0,d.k instanceof nn))return O(),b=new gm("type alias "+b+" is not a valid expression"),new fe(b);e&&xm("register mismatch in scope");if(t().d===d)return O(),b=new gm("unresolved symbol "+b),new fe(b);throw new w(d);}throw new w(h);}return new Ud(b)}
+function Maa(a,b,c){if(null!==b){var d=b.Za,e=b.Qb;if(d instanceof Pl){var g=d.Qb;if(d.Za instanceof vl&&g instanceof Gl&&(d=g.Ra,d instanceof z&&(g=d.z,d=d.p,null!==g))){var h=new L(g);h.b()||(g=h.k.h(),h=h.k.j(),t().d===g&&null!==h&&(g=O().c,(null===g?null===d:g.i(d))&&e instanceof Gl&&(e=e.Ra,e instanceof z&&(d=e.z,e=e.p,null!==d&&(g=new L(d),g.b()||(d=g.k.h(),g=g.k.j(),t().d===d&&null!==g&&(d=O().c,null===d?null===e:d.i(e))))))))}}}if(null!==b&&(e=b.Za,d=b.Qb,e instanceof vl&&(e=e.x,d instanceof
+Gl&&(g=d.Ra,g instanceof z&&(d=g.z,g=g.p,null!==d&&(h=new L(d),!h.b()&&(d=h.k.h(),h=h.k.j(),t().d===d&&null!==h&&(d=h.ya,g instanceof z&&(h=g.z,g=g.p,null!==h))))))))){var k=new L(h);if(!k.b()&&(h=k.k.h(),k=k.k.j(),t().d===h&&null!==k&&(h=k.ya,k=O().c,(null===k?null===g:k.i(g))&&Lm().gD.L(Am(e))&&(!Mm(a,e,!0,c).tv()||Nm(new E(e),Am(e))))))return new gn(Am(e),Zm(a,d,c),Zm(a,h,c))}if(null!==b&&(g=b.Za,e=b.Qb,g instanceof Pl&&(d=g.Za,g=g.Qb,d instanceof Pl&&(h=d.Za,d=d.Qb,h instanceof vl&&"if"===h.x&&
+d instanceof Gl&&(h=d.Ra,h instanceof z&&(d=h.z,h=h.p,null!==d&&(d=d.j(),null!==d&&(d=d.ya,k=O().c,(null===k?null===h:k.i(h))&&g instanceof Gl&&(h=g.Ra,h instanceof z&&(g=h.z,h=h.p,null!==g&&(g=g.j(),null!==g&&(g=g.ya,k=O().c,(null===k?null===h:k.i(h))&&e instanceof Gl&&(e=e.Ra,e instanceof z&&(h=e.z,e=e.p,null!==h&&(h=h.j(),null!==h&&(h=h.ya,k=O().c,null===k?null===e:k.i(e)))))))))))))))))return new on(Zm(a,d,c),Zm(a,g,c),Zm(a,h,c));null!==b&&(e=b.Za,e instanceof Pl&&(e=e.Za,e instanceof Pl&&(e=
+e.Za,e instanceof vl&&"if"===e.x&&xm("Program reached and unexpected state."))));if(null!==b&&(e=b.Za,d=b.Qb,d instanceof Gl)){h=d.Ra;b=Zm(a,e,c);e=l=>{if(null!==l){var m=l.j();if(null!==m)return Zm(a,m.ya,c)}throw new w(l);};if(h===u())e=u();else{d=h.e();g=d=new z(e(d),u());for(h=h.f();h!==u();)k=h.e(),k=new z(e(k),u()),g=g.p=k,h=h.f();e=d}return new cn(b,e)}null!==b&&no();throw new gm("ill-formed application "+b);}
+function Zm(a,b,c){var d=!1,e=null,g=!1,h=null,k=!1,l=null;if(!b.oc.b()){var m=b.oc;m.b()&&xm("Program reached and unexpected state.");return Zm(a,m.o(),c)}if(b instanceof vl)return fo(a,b.x,!1,c);if(b instanceof am)return new km("super");if(b instanceof Ol){var n=b.Ej,r=b.Fj,v=Hm(c),x=im(a,n,v);return new oo(x,po(v.lo,Zm(a,r,v)))}if(b instanceof Pl)return Maa(a,b,c);if(b instanceof yl){var A=b.ll,B=wa=>{if(null!==wa){var hb=wa.h(),ra=wa.j();if(null!==ra)return wa=hb.x,ra=Zm(a,ra.ya,c),G(new H,wa,
+ra)}throw new w(wa);};if(A===u())var C=u();else{for(var D=A.e(),F=new z(B(D),u()),I=F,M=A.f();M!==u();){var N=M.e(),P=new z(B(N),u());I=I.p=P;M=M.f()}C=F}return new vo(C,O().c)}if(b instanceof Ql){var T=b.Vl,Y=b.ml;return om(Al(),Zm(a,T,c),Y.x)}if(b instanceof Rl){d=!0;e=b;var Z=e.Zn,S=e.$n,ea=e.Mm;if(!0===e.ep&&null!==Z){var ia=Z.x;if(S instanceof Ol){var X=S.Ej,sa=S.Fj,Ja=Hm(c),Xa=wl(Ja,ia),Fa=Hm(Ja),za=im(a,X,Fa),Qa=po(Fa.lo,Zm(a,sa,Fa));t();var Ma=new L(Xa);if(Qa instanceof Ud)var Ga=Qa.fa;else{if(!(Qa instanceof
+fe))throw new w(Qa);var ab=rn(Qa.aa),Hb=O().c;Ga=new z(ab,Hb)}var bc=new wo(Ma,za,Ga),yb=t().d,tb=new xl(Xa),eb=O().c,kb=new z(tb,eb),Rb=po(Ja.lo,Zm(a,ea,Ja)),Gb=O().c;return new dn(yb,kb,Rb,new z(bc,Gb))}}}if(d){var vb=e.Zn;if(!0===e.ep&&null!==vb)throw new gm("recursive non-function definition "+vb.x+" is not supported");}if(d){var Tb=e.Zn,Nb=e.$n,ic=e.Mm;if(null!==Tb){var Va=Tb.x,cb=Hm(c),zb=wl(cb,Va),Ub=t().d,jb=new xl(zb),db=O().c,ub=new z(jb,db),Aa=po(cb.lo,Zm(a,ic,cb)),va=Zm(a,Nb,c),Ra=O().c;
+return new dn(Ub,ub,Aa,new z(va,Ra))}}if(b instanceof Sl){var rb=b.Dj,xb=Hm(c),mc=rb.m(),Ha=new xo(mc,new y(wa=>{if(wa instanceof yo){var hb=O().c;return new z(wa,hb)}if(wa instanceof Zn){hb=wa.Rb;var ra=wa.hj;null!==hb&&(hb=hb.x,ra.b()?ra=R():(ra=ra.o(),ra=new L(ra.x)),zo(xb,hb,t().d,ra))}return wa.nv().j()}));Od();var Ka=Pd(u(),Ha),Oa=t().d,Na=O().c;t();var Da=xb.lo,ta=Ka.m(),Ya=new Ao(ta),dc=new Ef(Ya,new y(wa=>{if(null!==wa){var hb=wa.h(),ra=wa.Sc();if(hb instanceof Pm&&(1+ra|0)===Ka.K())return rn(Zm(a,
+hb,xb))}if(null!==wa&&(hb=wa.h(),hb instanceof Pm))return new Bo(Zm(a,hb,xb));if(null!==wa){var wc=wa.h();if(wc instanceof Zn){hb=wc.wd;ra=wc.Rb;var ac=wc.hj;wc=wc.Yc;if(null!==ra&&(ra=ra.x,wc instanceof fe))return wa=wc.aa,ac.b()?ac=R():(ac=ac.o(),ac=new L(ac.x)),wc=hb.b()||Co(new Do(a,wa)),hb=Im(xb,ra,hb,wc,ac),t(),hb=hb.re,t(),wa=Zm(a,wa,xb),wa=[G(new H,hb,new L(wa))],wa=J(new K,wa),new Eo(Pd(u(),wa))}}if(null!==wa&&(hb=wa.h(),hb instanceof yo)){a:{wa=O().c;ac=Fo(a,new z(hb,wa),t().d,xb);if(null===
+ac)throw new w(ac);ra=ac.oj;wa=ac.oi;ac=ac.Xi;if(ra instanceof z)wa=ra.z,t(),wa=new L(wa);else{wc=O().c;if(null===wc?null!==ra:!wc.i(ra))throw new w(ra);if(wa instanceof z)wa=wa.z,t(),wa=new L(wa);else{ra=O().c;if(null===ra?null!==wa:!ra.i(wa))throw new w(wa);ac instanceof z?(wa=ac.z,t(),wa=new L(wa)):wa=t().d}}ra=!1;ac=null;if(wa instanceof L&&(ra=!0,ac=wa,wa=ac.k,wa instanceof jn)){ra=Hm(xb);hb=Go(a,wa,t().d,!1,ra);ra=Im(ra,"ctor",new L(!1),!1,t().d).re;ac=Ho(hb);if(null===ac)throw new w(ac);wc=
+ac.h();var Id=ac.j();if(wa.$u)t(),t(),ra=J(new K,[new Io(new L(new km(wa.mi)))]),ra=Pd(u(),ra);else{t();Jo();t();ac=J(new K,[ra]);ac=Ko(Pd(u(),ac));var ud=new km(ra);t();wc=new Bo(new Lo(ud,new oo(wc,new fe(new cn(new $m(new km(wa.mi)),Id)))));Id=new km(ra);Id=new Bo(new Lo(om(Al(),Id,"class"),new km(wa.mi)));t();ra=J(new K,[ac,wc,Id,new Io(new L(new km(ra)))]);ra=Pd(u(),ra)}wa=wa.mi;ac=t().d;wc=O().c;t();wa=new qn(wa,new dn(ac,wc,new Ud(new z(hb,ra)),O().c));break a}if(ra&&(wa=ac.k,wa instanceof
+Hn)){hb=Hm(xb);ra=Im(hb,"base",new L(!1),!1,t().d);hb=Go(a,wa,(t(),new L(ra)),!1,hb);wa=wa.Hp;t();ra=J(new K,[new xl(ra.re)]);ra=Pd(u(),ra);t();t();t();hb=J(new K,[new Io(new L(new Mo(hb)))]);hb=Pd(u(),hb);wa=new qn(wa,new oo(ra,new Ud(hb)));break a}if(ra&&(ac=ac.k,ac instanceof ln)){wa=Hm(xb);wc=Go(a,ac,t().d,!1,wa);Id=Im(wa,"ins",new L(!1),!1,t().d).re;wa=ac.lj;hb=t().d;ra=O().c;t();t();Jo();t();ud=J(new K,[Id]);ud=Ko(Pd(u(),ud));var be=new Lo(new km(Id),new cn(new $m(new km(ac.lj)),O().c));be=
+new Bo(be);var re=new km(Id);ac=new Bo(new Lo(om(Al(),re,"class"),new km(ac.lj)));t();ac=J(new K,[wc,ud,be,ac,new Io(new L(new km(Id)))]);ac=Pd(u(),ac);wa=new qn(wa,new dn(hb,ra,new Ud(ac),O().c));break a}throw new gm("unsupported NuTypeDef in local blocks: "+hb);}return wa}if(null!==wa&&(wa.h()instanceof No||wa.h()instanceof Oo||wa.h()instanceof Zn||wa.h()instanceof Po))throw new gm("unsupported definitions in blocks");throw new w(wa);}));Od();var ka=Qo(Da,Pd(u(),dc));return new dn(Oa,Na,new Ud(ka),
+O().c)}if(b instanceof Ul){g=!0;h=b;var ya=h.Sn,Sa=h.Hm;if(Sa instanceof ym){var xc=Sa.dn,Sb=Zm(a,ya,c),uc=Zm(a,xc,c),Lb=O().c;return new Ro(new z(Sb,new z(uc,Lb)))}}if(g){var lc=h.Sn,Xb=h.Hm;if(Xb instanceof um){var ec=Xb.Xo,Ab=Xb.Tn,Ob=Xb.Un;if(Ob instanceof ym){var fb=Ob.dn;return Ym(a,Zm(a,lc,c),ec,c).ba(Zm(a,Ab,c),Zm(a,fb,c))}}}if(g){var Wa=h.Hm,bb=Zm(a,h.Sn,c);if(bb.VJ())return en(a,bb,Wa,c);var Ia=Naa(c);c.lo.SA.oh(Ia);var Ua=new km(Ia),pc=new Lo(Ua,bb),sc=en(a,Ua,Wa,c),Ba=O().c;return new Ro(new z(pc,
+new z(sc,Ba)))}if(b instanceof Em){var ob=b.rq,nc=ob.u();So||(So=new To);return new hn(nc+(Oaa(ob)?"":"n"))}if(b instanceof Fm)return new hn(b.uu.gd.u());if(b instanceof Dm)return an(b.Lu);if(b instanceof Gm)return new hn(b.Xq?"undefined":"null");if(b instanceof Cl)return Zm(a,b.ai,c);if(b instanceof Tl){var Ib=b.br,vc=b.ar;if(null!==vc){var Vb=vc.ll,fc=a.Cs.Yz.U("withConstruct");if(fc instanceof L)var Bc=fc.k;else if(t().d===fc)Bc=ho(a.Cs,"withConstruct",Uo(a.di,"withConstruct"));else throw new w(fc);
+var Pb=new km(Bc),Jb=Zm(a,Ib,c),gc=wa=>{if(null!==wa){var hb=wa.h(),ra=wa.j();if(null!==hb&&(hb=hb.x,null!==ra))return wa=Zm(a,ra.ya,c),G(new H,hb,wa)}throw new w(wa);};if(Vb===u())var Cb=u();else{for(var cc=Vb.e(),yc=new z(gc(cc),u()),Mc=yc,qc=Vb.f();qc!==u();){var oc=qc.e(),Qc=new z(gc(oc),u());Mc=Mc.p=Qc;qc=qc.f()}Cb=yc}var jc=new vo(Cb,O().c),sb=O().c;return new cn(Pb,new z(Jb,new z(jc,sb)))}}if(b instanceof Fl){k=!0;l=b;var Gc=l.gg;if(!1===l.bi){if(Gc instanceof Pl){var Wb=Gc.Za;if(Wb instanceof
+vl){var Cc=Wb.x;if(Lm().gD.L(Cc))return new Vo(Zm(a,Gc,c))}}return Zm(a,Gc,c)}}if(k)return Zm(a,l.gg,c);if(b instanceof Gl){var Fc=b.Ra,qd=wa=>{if(null!==wa){var hb=wa.j();if(null!==hb)return Zm(a,hb.ya,c)}throw new w(wa);};if(Fc===u())var Yb=u();else{for(var Nc=Fc.e(),ad=new z(qd(Nc),u()),Uc=ad,cd=Fc.f();cd!==u();){var kc=cd.e(),Vc=new z(qd(kc),u());Uc=Uc.p=Vc;cd=cd.f()}Yb=ad}return new Wo(Yb)}if(b instanceof Vl){var Hc=b.mp,rc=Zm(a,b.lp,c),sd=Zm(a,Hc,c);return Xo(new Yo,rc,sd)}if(b instanceof dm){var Kc=
+b.$q,Qd=b.Zq,Ad=t().d,kd=O().c;t();var Hd=new Zo(Zm(a,Kc,c),Zm(a,Qd,c)),Rd=O().c;return new dn(Ad,kd,new Ud(new z(Hd,Rd)),O().c)}if(b instanceof Wl){var Bd=b.Gm,ae=b.Qn;if(Bd instanceof Vl||Bd instanceof Ql||Bd instanceof vl)return new $o("void",new Lo(Zm(a,Bd,c),Zm(a,ae,c)));throw new gm("illegal assignemnt left-hand side: "+Bd);}if(b instanceof Kl)return Zm(a,b.cp,c);if(b instanceof Xl)throw new gm("if expression was not desugared");if(b instanceof Yl){var dd=b.hp;if(dd instanceof vl){var od=fo(a,
+dd.x,!0,c);return od instanceof $m?od:new $m(od)}throw new gm("Unsupported `new` class term: "+dd);}if(b instanceof Zl)return Zm(a,b.$o,c);if(b instanceof Il)return Zm(a,b.nl,c);if(b instanceof bm){var Ta=b.Vn;if(null!==Ta)throw new gm("assignment of "+Ta.x+" is not supported outside a constructor");}if(b instanceof em){var wb=b.Iq,$a=Hm(c);return Zm(a,vm(a,wb,$a,!0,new Jm(a,ap())),$a)}if(b instanceof Ml)return Zm(a,b.Ml,c);if(b instanceof Xl||b instanceof $l||b instanceof cm||b instanceof fm)throw new gm("cannot generate code for term "+
+b);throw new w(b);}function tn(a){if(a.sF){a=new qn(a.re,new km("this"));var b=O().c;return new z(a,b)}return O().c}
+function bp(a,b){if(null!==a){var c=a.pb,d=a.gb;if(cp()===c&&null!==d){c=d.V;a=new km("globalThis");a=om(Al(),a,c);d=new xl("base");var e=O().c;d=new z(d,e);t();b=new km(b);b=om(Al(),b,c);c=new km("base");e=O().c;return new Bo(new Lo(a,new oo(d,new fe(new cn(b,new z(c,e))))))}}if(null!==a&&(c=a.gb,null!==c))return a=c.V,c=new km("globalThis"),c=om(Al(),c,a),b=new km(b),b=new Lo(c,om(Al(),b,a)),new Bo(b);throw new w(a);}
+function Paa(a,b,c,d){c=Im(d,"base",new L(!1),!1,t().d);a=Go(a,b,(t(),new L(c)),!1,d);d=b.CA;d.b()&&xm("Program reached and unexpected state.");d=d.o();d=new qn(d,new km("this"));b=b.Hp;t();c=J(new K,[new xl(c.re)]);c=Pd(u(),c);t();var e=O().c;d=new z(d,e);t();t();a=J(new K,[new Io(new L(new Mo(a)))]);a=dl(Pd(u(),a),d);return new vn(b,c,new Ud(a))}
+function Qaa(a,b,c,d){d=Go(a,b,t().d,!1,d);c=new km("this.#"+b.lj);a=b.DA;a.b()&&xm("Program reached and unexpected state.");a=a.o();var e=new qn(a,new km("this"));a=b.lj;t();var g=O().c;e=new z(e,g);t();g=new gn("\x3d\x3d\x3d",c,new km("undefined"));t();b=[d,new Bo(new Lo(c,new $m(new cn(new km(b.lj),O().c)))),new Bo(new Lo(om(Al(),c,"class"),new km(b.lj)))];b=J(new K,b);b=[new dp(g,Pd(u(),b),O().c),new Io((t(),new L(c)))];b=J(new K,b);b=dl(Pd(u(),b),e);return new wn(a,new Ud(b))}
+function Ho(a){var b=a.sq;if(b===u())var c=u();else{c=b.e();var d=c=new z(new xl(c),u());for(b=b.f();b!==u();){var e=b.e();e=new z(new xl(e),u());d=d.p=e;b=b.f()}}b=a.sq;if(b===u())a=u();else for(a=b.e(),d=a=new z(new km(a),u()),b=b.f();b!==u();)e=b.e(),e=new z(new km(e),u()),d=d.p=e,b=b.f();return G(new H,c,a)}
+function Raa(a,b,c,d){a=Go(a,b,t().d,!1,d);c=Ho(a);if(null===c)throw new w(c);var e=c.h(),g=c.j();d=new km("this.#"+b.mi);c=b.Qx;c.b()&&xm("Program reached and unexpected state.");c=c.o();c=new qn(c,new km("this"));if(b.$u)t(),e=J(new K,[new Bo(new Lo(d,new km(b.mi)))]),e=Pd(u(),e);else{t();t();var h=new km("Object");h=om(Al(),h,"freeze");t();g=J(new K,[new cn(new $m(new km(b.mi)),g)]);g=new cn(h,Pd(u(),g));e=new Bo(new Lo(d,new oo(e,new fe(g))));g=new Bo(new Lo(om(Al(),d,"class"),new km(b.mi)));
+h=om(Al(),d,"unapply");var k=new km(b.mi);e=[e,g,new Bo(new Lo(h,om(Al(),k,"unapply")))];e=J(new K,e);e=Pd(u(),e)}b=b.mi;t();t();a=[new dp(new gn("\x3d\x3d\x3d",d,new km("undefined")),new z(new Bo(new Mo(a)),e),O().c),new Io((t(),new L(d)))];a=J(new K,a);a=Pd(u(),a);return new wn(b,new Ud(new z(c,a)))}
+function Go(a,b,c,d,e){var g=new $e,h=Hm(e,b.u()),k=Hm(h,b.Ua()+" inheritance"),l=Hm(h,b.Ua()+" body"),m=Hm(l,b.Ua()+" constructor"),n=u(),r=ep(new fp,n),v=u(),x=ep(new fp,v),A=b.FB(),B=Zd=>{var sf=Hm(l),oj=gp(sf,"qualifier");Zd=Zd.Cf.x;var al=g.sb?g.vb:Mn(a,g);sf=new np(al.fD,sf,oj);return G(new H,Zd,sf)};if(A===u())var C=u();else{for(var D=A.e(),F=new z(B(D),u()),I=F,M=A.f();M!==u();){var N=M.e(),P=new z(B(N),u());I=I.p=P;M=M.f()}C=F}var T=b.EB(),Y=Zd=>{var sf=Hm(l),oj=gp(sf,"qualifier");Zd=Zd.uq.x;
+var al=g.sb?g.vb:Mn(a,g);sf=new np(al.fD,sf,oj);return G(new H,Zd,sf)};if(T===u())var Z=u();else{for(var S=T.e(),ea=new z(Y(S),u()),ia=ea,X=T.f();X!==u();){var sa=X.e(),Ja=new z(Y(sa),u());ia=ia.p=Ja;X=X.f()}Z=ea}var Xa=un(C,Z);op();var Fa=pp(qp(),Xa),za=new rp(Fa),Qa=sp(za);if(Qa.b()){t();var Ma=gp(m,"qualifier"),Ga=new L(Ma)}else{for(var ab=Qa.o(),Hb=(new rp(Fa)).m();Hb.s();){var bc=Hb.t();if(bc.dp!==ab.dp)throw new Yj("assertion failed: the expected qualifier's runtime name should be "+(ab.dp+
+", "+bc.dp)+" found");}tp();var yb=gp(m,ab.dp);up(0,yb===ab.dp);t();Ga=new L(ab.dp)}for(var tb=b.wK(),eb=zn(b.mv()),kb=null,Rb=null;eb!==u();){for(var Gb=eb.e(),vb=xn(a,Gb).m();vb.s();){var Tb=new z(vb.t(),u());null===Rb?kb=Tb:Rb.p=Tb;Rb=Tb}eb=eb.f()}var Nb=null===kb?u():kb,ic=un(tb,Nb),Va=new fp,cb=b.GF();if(cb.b()){var zb=Zd=>{var sf=new lo(Zd,new L(!1),!1,!b.vy().L(Zd),Ga);vp(l,sf);wp(r,sf);Im(k,Zd,new L(!1),!1,t().d);return Im(m,Zd,new L(!1),!1,t().d).re};if(ic===u())var Ub=u();else{for(var jb=
+ic.e(),db=new z(zb(jb),u()),ub=db,Aa=ic.f();Aa!==u();){var va=Aa.e(),Ra=new z(zb(va),u());ub=ub.p=Ra;Aa=Aa.f()}Ub=db}}else{var rb=cb.o(),xb=Zd=>{if(Zd.cy()){var sf=new lo(Zd.h(),new L(!1),!1,!1,Ga);vp(l,sf);wp(r,sf);sf=G(new H,!1,Zd.h());wp(Va,sf)}return Im(m,Zd.h(),new L(!1),!1,t().d).re};if(rb===u())Ub=u();else{for(var mc=rb.e(),Ha=new z(xb(mc),u()),Ka=Ha,Oa=rb.f();Oa!==u();){var Na=Oa.e(),Da=new z(xb(Na),u());Ka=Ka.p=Da;Oa=Oa.f()}Ub=Ha}}var ta=Va.ha(),Ya=Zd=>{if(null!==Zd)return Zd=Zd.j(),new Bo(new Lo(new km("this.#"+
+Zd),new km(Zd)));throw new w(Zd);};if(ta===u())var dc=u();else{for(var ka=ta.e(),ya=new z(Ya(ka),u()),Sa=ya,xc=ta.f();xc!==u();){var Sb=xc.e(),uc=new z(Ya(Sb),u());Sa=Sa.p=uc;xc=xc.f()}dc=ya}for(var Lb=b.EB();!Lb.b();){var lc=Lb.e(),Xb=new lo(lc.uq.x,t().d,!0,!1,Ga);vp(l,Xb);wp(r,Xb);Lb=Lb.f()}for(var ec=b.ZL();!ec.b();){var Ab=ec.e().uq.x,Ob=t().d,fb=zo(l,Ab,t().d,Ob);wp(r,fb);ec=ec.f()}for(var Wa=b.HF();!Wa.b();){var bb=Wa.e();if(bb instanceof Zn){var Ia=bb,Ua=Ia.wd,pc=Ia.Rb;if(null!==pc){var sc=
+new lo(pc.x,Ua,!1,!Ia.Pl,Ga);vp(l,sc);wp(r,sc)}}Wa=Wa.f()}var Ba=Fo(a,b.FB(),Ga,l);if(null===Ba)throw new w(Ba);var ob=Ba.oj,nc=Ba.oi,Ib=Ba.Xi;d&&Fo(a,b.FB(),t().d,a.di);for(var vc=ob;!vc.b();){var Vb=vc.e();wp(r,Vb);wp(x,Vb.mi);vc=vc.f()}for(var fc=nc;!fc.b();){var Bc=fc.e();wp(r,Bc);fc=fc.f()}for(var Pb=Ib;!Pb.b();){var Jb=Pb.e();wp(r,Jb);wp(x,Jb.lj);Pb=Pb.f()}var gc=b.EB(),Cb=Zd=>Laa(a,Zd,ic,Ga,Fa.Se(Zd.uq.x,new U(()=>{xm("Program reached and unexpected state.")})).zu);if(gc===u())var cc=u();else{for(var yc=
+gc.e(),Mc=new z(Cb(yc),u()),qc=Mc,oc=gc.f();oc!==u();){var Qc=oc.e(),jc=new z(Cb(Qc),u());qc=qc.p=jc;oc=oc.f()}cc=Mc}var sb=Zd=>Paa(a,Zd,r.ha(),Fa.Se(Zd.Hp,new U(()=>{xm("Program reached and unexpected state.")})).zu);if(nc===u())var Gc=u();else{for(var Wb=nc.e(),Cc=new z(sb(Wb),u()),Fc=Cc,qd=nc.f();qd!==u();){var Yb=qd.e(),Nc=new z(sb(Yb),u());Fc=Fc.p=Nc;qd=qd.f()}Gc=Cc}var ad=un(cc,Gc),Uc=Zd=>Qaa(a,Zd,r.ha(),Fa.Se(Zd.lj,new U(()=>{xm("Program reached and unexpected state.")})).zu);if(Ib===u())var cd=
+u();else{for(var kc=Ib.e(),Vc=new z(Uc(kc),u()),Hc=Vc,rc=Ib.f();rc!==u();){var sd=rc.e(),Kc=new z(Uc(sd),u());Hc=Hc.p=Kc;rc=rc.f()}cd=Vc}var Qd=un(ad,cd),Ad=Zd=>Raa(a,Zd,r.ha(),Fa.Se(Zd.mi,new U(()=>{xm("Program reached and unexpected state.")})).zu);if(ob===u())var kd=u();else{for(var Hd=ob.e(),Rd=new z(Ad(Hd),u()),Bd=Rd,ae=ob.f();ae!==u();){var dd=ae.e(),od=new z(Ad(dd),u());Bd=Bd.p=od;ae=ae.f()}kd=Rd}var Ta=un(Qd,kd);if(c instanceof L){var wb=c.k;t();var $a=new L(new km(wb.re))}else $a=Kaa(b.pH(),
+e);for(var wa=zn(b.mv()),hb=null,ra=null;wa!==u();){var wc=wa.e(),ac=!1,Id=null,ud=e.ko.U(wc);a:{if(ud instanceof L){ac=!0;Id=ud;var be=Id.k;if(be instanceof mn){var re=be.Tx;t();var pe=new L(re);break a}}if(ac&&null!==Id.k)pe=t().d;else if(t().d===ud)pe=t().d;else throw new w(ud);}for(var bd=pe.m();bd.s();){var Rc=new z(bd.t(),u());null===ra?hb=Rc:ra.p=Rc;ra=Rc}wa=wa.f()}var Wc=null===hb?u():hb;if(c.b()){var Wd=b.pH(),zd=Zd=>{if(Zd instanceof Pl&&(Zd=Zd.Qb,Zd instanceof Gl)){var sf=Zd.Ra;Zd=Qm=>
+{if(null!==Qm){var Rm=Qm.j();if(null!==Rm)return Zm(a,Rm.ya,k)}throw new w(Qm);};if(sf===u())return u();var oj=sf.e(),al=oj=new z(Zd(oj),u());for(sf=sf.f();sf!==u();){var Ll=sf.e();Ll=new z(Zd(Ll),u());al=al.p=Ll;sf=sf.f()}return oj}return O().c};if(Wd===u())var Pa=u();else{for(var Db=Wd.e(),Oc=new z(zd(Db),u()),Tc=Oc,Sd=Wd.f();Sd!==u();){var Jc=Sd.e(),vd=new z(zd(Jc),u());Tc=Tc.p=vd;Sd=Sd.f()}Pa=Oc}for(var hd=Pa,de=null,ye=null;hd!==u();){for(var jf=Km(hd.e()).m();jf.s();){var af=new z(jf.t(),u());
+null===ye?de=af:ye.p=af;ye=af}hd=hd.f()}var pf=Km(null===de?u():de),kf=t().d;Jd=pf;Dd=kf}else{var Be=Im(m,"rest",new L(!1),!1,t().d);t();var Kd=J(new K,[new km("..."+Be.re)]),ld=Pd(u(),Kd);t();var Jd=ld,Dd=new L(Be.re)}for(var Xd=Jd,Yc=Dd,Ce=new fp,te=b.HF(),Ie=null,Jf=null;te!==u();){var df=te.e();a:{if(df instanceof bm){var vg=df,wg=vg.Vn,xg=vg.Zo;if(null!==wg){var eg=wg.x;t();var vh=new Lo(new km("this.#"+eg),Zm(a,xg,m)),fg=[new Bo(vh),new qn(Im(m,eg,(t(),new L(!1)),!1,t().d).re,new km("this.#"+
+eg))],ih=J(new K,fg);var Ig=Pd(u(),ih);break a}}if(df instanceof Pm){var Tf=new Bo(Zm(a,df,m)),Jg=O().c;Ig=new z(Tf,Jg)}else{if(df instanceof Zn){var jh=df,yg=jh.Rb,gg=jh.Yc;if(null!==yg){var Cf=yg.x;if(gg instanceof fe){var Uf=gg.aa;if(jh.Pl){var $g=!jh.Om.b(),Ah=G(new H,$g,Cf);wp(Va,Ah);t();var Kg=[new Bo(new Lo(new km("this.#"+Cf),Zm(a,Uf,m))),new qn(Im(m,Cf,(t(),new L(!1)),!1,t().d).re,new km("this.#"+Cf))],Vf=J(new K,Kg);Ig=Pd(u(),Vf)}else{var hg=Cm(l,Cf);b:{if(hg instanceof L){var zg=hg.k;if(zg instanceof
+lo){var Lg=zg;break b}}throw new Yj("error when handling "+Cf);}if(Lg.OP||Ub.L(Cf)){wp(Ce,Cf);t();var Mg=[new Bo(new Lo(new km("this.#"+Cf),Zm(a,Uf,m))),new qn(Im(m,Cf,(t(),new L(!1)),!1,t().d).re,new km("this.#"+Cf))],Wf=J(new K,Mg);Ig=Pd(u(),Wf)}else{var Ng=new qn(Im(m,Cf,(t(),new L(!1)),!1,t().d).re,Zm(a,Uf,m)),Kf=O().c;Ig=new z(Ng,Kf)}}break a}}}Ig=O().c}}for(var xf=Ig.m();xf.s();){var Og=new z(xf.t(),u());null===Jf?Ie=Og:Jf.p=Og;Jf=Og}te=te.f()}var mi=null===Ie?u():Ie,Ci=sn(m.lo);if(Ci instanceof
+L)var Xh=Ci.k,wh=O().c,Bh=new z(Xh,wh);else Bh=O().c;var ng=b.iM();if(ng instanceof L){var kh=ng.k.bx;a:{if(null!==kh){var Kh=kh.aa;if(Kh instanceof Ol){var ni=Kh.Ej,Lh=Kh.Fj;if(ni instanceof Gl){var lh=ni.Ra;if(lh instanceof z){var Ch=lh.z,Dh=lh.p;if(null!==Ch){var Yh=new L(Ch);if(!Yh.b()){var ah=Yh.k.j();if(null!==ah){var oi=ah.ya;if(oi instanceof vl){var mj=oi.x,wd=O().c;if((null===wd?null===Dh:wd.i(Dh))&&Lh instanceof Rl){var ge=Lh.Mm;if(ge instanceof Gl){var De=ge.Ra,qf=wl(Hm(h,"unapply "+b.Ua()),
+mj),og=new xl(qf),Xf=O().c,mh=new z(og,Xf);t();var Ag=Zd=>{if(null!==Zd){var sf=new L(Zd);if(!sf.b()&&(sf=sf.k.j(),null!==sf)){Zd=sf.ya;if(Zd instanceof Ql){var oj=Zd.Vl;sf=Zd.ml;if(oj instanceof vl&&(oj=oj.x,null!==sf))return new km(oj+"."+sf.x)}return Zm(a,Zd,e)}}throw new w(Zd);};if(De===u())var Bg=u();else{for(var Eh=De.e(),Pg=new z(Ag(Eh),u()),Di=Pg,Mh=De.f();Mh!==u();){var pi=Mh.e(),Xi=new z(Ag(pi),u());Di=Di.p=Xi;Mh=Mh.f()}Bg=Pg}var Qg=new vn("unapply",mh,new fe(new Wo(Bg))),nh=O().c;var bh=
+new z(Qg,nh);break a}}}}}}}}}}throw new gm("invalid unapply method in "+b.Ua());}}else bh=O().c;var Mj=Ga.b()?O().c:tn(lm(m,Ga.k)),Nj=b.Ua(),ie=ic;a:for(var Ac;;)if(ie.b()){Ac=u();break}else{var Ve=ie.e(),Td=ie.f();if(!1===!!b.vy().L(Ve))ie=Td;else for(var lf=ie,Yi=Td;;){if(Yi.b())Ac=lf;else{var Jl=Yi.e();if(!1!==!!b.vy().L(Jl)){Yi=Yi.f();continue}for(var ll=Yi,Bj=new z(lf.e(),u()),$k=lf.f(),Zh=Bj;$k!==ll;){var Ei=new z($k.e(),u());Zh=Zh.p=Ei;$k=$k.f()}for(var Yd=ll.f(),bf=Yd;!Yd.b();){var rf=Yd.e();
+if(!1===!!b.vy().L(rf)){for(;bf!==Yd;){var Cg=new z(bf.e(),u());Zh=Zh.p=Cg;bf=bf.f()}bf=Yd.f()}Yd=Yd.f()}bf.b()||(Zh.p=bf);Ac=Bj}break a}}if(Ac===u())var nj=u();else{for(var Jh=Ac.e(),If=new z(G(new H,!1,Jh),u()),Hg=If,He=Ac.f();He!==u();){var lj=He.e(),Wi=new z(G(new H,!1,lj),u());Hg=Hg.p=Wi;He=He.f()}nj=If}var Oj=Va.ha(),mo=un(nj,Oj),mm=un(Ce.ha(),ic),nm=un(un(un(Mj,Bh),dc),mi),dq=x.ha();return new xp(Nj,ic,mo,mm,$a,Xd,Ub,Yc,Ta,Wc,nm,dq,!b.GF().b(),bh)}
+function Fo(a,b,c,d){for(var e=new fp,g=new fp,h=new fp,k=new fp,l=b;!l.b();){var m=l.e();a:{if(null!==m){var n=m.pb,r=m.gb,v=m.hg,x=m.Sg,A=m.Di,B=m.ei;if(cp()===n&&null!==r){var C=r.V,D=Rn(a,C,(x.b()?new Gl(O().c):x.o()).Ra,A,B);if(null===D)throw new w(D);var F=D.lr,I=D.mr,M=D.rt,N=D.st,P=D.tt,T=D.kv;if(v===u())var Y=u();else{for(var Z=v.e(),S=new z(Z.j().V,u()),ea=S,ia=v.f();ia!==u();){var X=ia.e(),sa=new z(X.j().V,u());ea=ea.p=sa;ia=ia.f()}Y=S}var Ja=new Hn(C,Y,F,I,M,N,T,P,c);yp(d,Ja);m.fl.b()&&
+wp(h,Ja);break a}}if(null!==m){var Xa=m.pb,Fa=m.gb,za=m.hg,Qa=m.Sg,Ma=m.Di,Ga=m.ei;if(zp()===Xa&&null!==Fa){var ab=Fa.V,Hb=Rn(a,ab,(Qa.b()?new Gl(O().c):Qa.o()).Ra,Ma,Ga);if(null===Hb)throw new w(Hb);var bc=Hb.lr,yb=Hb.mr,tb=Hb.rt,eb=Hb.st,kb=Hb.tt;if(za===u())var Rb=u();else{for(var Gb=za.e(),vb=new z(Gb.j().V,u()),Tb=vb,Nb=za.f();Nb!==u();){var ic=Nb.e(),Va=new z(ic.j().V,u());Tb=Tb.p=Va;Nb=Nb.f()}Rb=vb}var cb=new ln(ab,Rb,bc,yb,tb,eb,Ma,kb,c);yp(d,cb);m.fl.b()&&wp(k,cb);break a}}if(null!==m){var zb=
+m.pb,Ub=m.gb,jb=m.hg,db=m.Hj;if(Ap()===zb&&null!==Ub){var ub=Ub.V;if(jb===u())var Aa=u();else{for(var va=jb.e(),Ra=new z(va.j().V,u()),rb=Ra,xb=jb.f();xb!==u();){var mc=xb.e(),Ha=new z(mc.j().V,u());rb=rb.p=Ha;xb=xb.f()}Aa=Ra}Saa(d,ub,Aa,db.b()?gl():db.o());break a}}if(null!==m){var Ka=m.pb,Oa=m.gb,Na=m.hg,Da=m.Sg,ta=m.Qm,Ya=m.Di,dc=m.ei;if(Bp()===Ka&&null!==Oa){var ka=Oa.V;b:{if(ta instanceof L){var ya=ta.k;if(null!==ya){var Sa=ya.ks,xc=ya.js;if(null!==Sa){var Sb=Sa.Ra;if(null!==xc){var uc=xc.Dj;
+t();var Lb=(dd=>od=>{if(null!==od){var Ta=od.h(),wb=od.j();if(Ta instanceof L&&(Ta=Ta.k,null!==Ta&&(Ta=Ta.x,null!==wb)))return G(new H,Ta,wb.yb.Bh)}if(null!==od&&(wb=od.h(),od=od.j(),t().d===wb&&null!==od&&(wb=od.yb,od=od.ya,od instanceof vl)))return G(new H,od.x,wb.Bh);throw new gm("Unexpected constructor parameters in "+dd+".");})(ka);if(Sb===u())var lc=u();else{for(var Xb=Sb.e(),ec=new z(Lb(Xb),u()),Ab=ec,Ob=Sb.f();Ob!==u();){var fb=Ob.e(),Wa=new z(Lb(fb),u());Ab=Ab.p=Wa;Ob=Ob.f()}lc=ec}var bb=
+new L(lc);var Ia=uc;break b}}}}var Ua=t().d,pc=O().c;bb=Ua;Ia=pc}var sc=bb,Ba=Ia,ob=Rn(a,ka,(Da.b()?new Gl(O().c):Da.o()).Ra,Ya,dc);if(null===ob)throw new w(ob);var nc=ob.lr,Ib=ob.mr,vc=ob.rt,Vb=ob.st,fc=ob.tt,Bc=ob.kv;if(Na===u())var Pb=u();else{for(var Jb=Na.e(),gc=new z(Jb.j().V,u()),Cb=gc,cc=Na.f();cc!==u();){var yc=cc.e(),Mc=new z(yc.j().V,u());Cb=Cb.p=Mc;cc=cc.f()}Pb=gc}var qc=Cp(m);b:{if(qc instanceof L){var oc=qc.k;if(null!==oc){var Qc=oc.wd,jc=oc.Rb,sb=oc.Ch,Gc=oc.Yc;if(Gc instanceof fe){var Wb=
+Gc.aa;t();var Cc=new Dp(!(Qc.b()||!Qc.o()),new Ep(ka),jc,sb,(O(),new fe(Wb)));var Fc=new L(Cc);break b}}}Fc=t().d}var qd=new jn(ka,Pb,sc,nc,Ib,Fc,vc,un(Ba,Vb),Ya,Bc,fc,c,m.Sg.b());yp(d,qd);m.fl.b()&&wp(g,qd);break a}}if(null!==m){var Yb=m.pb,Nc=m.gb,ad=m.hg,Uc=m.Sg,cd=m.Di,kc=m.ei;if(Fp()===Yb&&null!==Nc){var Vc=Nc.V,Hc=Rn(a,Vc,(Uc.b()?new Gl(O().c):Uc.o()).Ra,cd,kc);if(null===Hc)throw new w(Hc);var rc=Hc.lr,sd=Hc.mr;if(ad===u())var Kc=u();else{for(var Qd=ad.e(),Ad=new z(Qd.j().V,u()),kd=Ad,Hd=ad.f();Hd!==
+u();){var Rd=Hd.e(),Bd=new z(Rd.j().V,u());kd=kd.p=Bd;Hd=Hd.f()}Kc=Ad}var ae=Taa(d,Vc,Kc,rc,sd);m.fl.b()&&wp(e,ae);break a}}throw new w(m);}l=l.f()}return new Gp(e.ha(),g.ha(),h.ha(),k.ha())}function To(){this.kN=this.jN=null;So=this;this.jN=Hp("9007199254740991");this.kN=Hp("-9007199254740991")}To.prototype=new p;To.prototype.constructor=To;function Oaa(a){var b=So;return 0>=b.kN.$l(a)?0>=a.$l(b.jN):!1}To.prototype.$classData=q({nV:0},!1,"mlscript.JSBackend$",{nV:1,g:1});var So;
+function Jm(a,b){this.xH=b;if(null===a)throw null;}Jm.prototype=new p;Jm.prototype.constructor=Jm;Jm.prototype.$classData=q({uV:0},!1,"mlscript.JSBackend$FreeVars",{uV:1,g:1});function Do(a,b){this.yH=null;this.yV=b;if(null===a)throw null;this.yH=a}Do.prototype=new p;Do.prototype.constructor=Do;function Co(a){var b=a.yV;if(b instanceof Ol)return!0;if(b instanceof Fl){var c=b.gg;if(!1===b.bi)return Co(new Do(a.yH,c))}return b instanceof Cl?Co(new Do(a.yH,b.ai)):!1}
+Do.prototype.$classData=q({xV:0},!1,"mlscript.JSBackend$TermOps",{xV:1,g:1});function Ip(){}Ip.prototype=new p;Ip.prototype.constructor=Ip;function Jp(){}Jp.prototype=Ip.prototype;function Kp(){}Kp.prototype=new p;Kp.prototype.constructor=Kp;function an(a){Lp();return new hn(Mp(Np(),a))}
+function Op(a,b){return Pp(Hf(b).De(Qp().ye,new fn((c,d)=>{var e=G(new H,c,d);c=e.y;d=e.w;if(null!==d)return e=d.h(),d=d.Sc(),Rp(Rp(c,e instanceof El?Sp(Qp(),"_"+d):e.xa()),Pe(new E(d),-1+b.K()|0)?Qp().ye:Sp(Qp(),", "));throw new w(e);})),!0)}function Tp(a,b){return Pp(Hf(b).De(Qp().ye,new fn((c,d)=>{var e=G(new H,c,d);c=e.y;d=e.w;if(null!==d)return e=d.Sc(),Rp(Rp(c,Up(d.h(),Vp().Az)),Pe(new E(e),-1+b.K()|0)?Qp().ye:Sp(Qp(),", "));throw new w(e);})),!0)}
+Kp.prototype.$classData=q({MV:0},!1,"mlscript.JSExpr$",{MV:1,g:1});var Wp;function Lp(){Wp||(Wp=new Kp);return Wp}function Xp(){this.zH=null;Yp=this;var a=new Zp;u();var b=Dk("^[A-Za-z$][A-Za-z0-9$]*$");a.nG=b;this.zH=a}Xp.prototype=new p;Xp.prototype.constructor=Xp;function om(a,b,c){return new $p(b,new km(c))}function aq(a,b){return bq(new cq(a.zH.nG,nb(b)))?!eq().qF.L(b):!1}function zl(a,b){return aq(a,b)?b:Mp(Np(),b)}Xp.prototype.$classData=q({PV:0},!1,"mlscript.JSField$",{PV:1,g:1});var Yp;
+function Al(){Yp||(Yp=new Xp);return Yp}function fq(a){if(a instanceof Em){tp();a=gq(new Ep("int"));var b=new Ep("number");return a.bc(b)}if(a instanceof Dm)return tp(),gq(new Ep("string"));if(a instanceof Fm)return tp(),gq(new Ep("number"));if(a instanceof Gm)return ap();throw new w(a);}
+function yq(a){if(a instanceof Em){tp();a=gq(new Ep("Int"));var b=new Ep("Num");a=a.bc(b);b=new Ep("Object");return a.bc(b)}if(a instanceof Dm)return tp(),a=gq(new Ep("Str")),b=new Ep("Object"),a.bc(b);if(a instanceof Fm)return tp(),a=gq(new Ep("Num")),b=new Ep("Object"),a.bc(b);if(a instanceof Gm)return tp(),gq(new Ep("Object"));throw new w(a);}function zq(a){if(a instanceof vl)return tp(),gq(a);a=a.Vj().m();a=new xo(a,new y(b=>b.jn().m()));return Aq(Bq(),a)}
+function Cq(a,b){b.b()||(b=b.o(),a.fm(b.fh),a.em(b.eh),t(),a.on(new L(b.dh)));return a}
+function Dq(a){var b=tc();try{if(0>a.rn()){var c=Eq(a),d=new Ef(c,new y(I=>I.fh)),e=Fq(),g=Gq(d,e);if(g.b())throw Hq(new Iq,b,t().d);a.fm(g.o()|0)}if(0>a.qn()){var h=Eq(a),k=new Ef(h,new y(I=>I.eh)),l=Fq(),m=Jq(k,l);if(m.b())throw Hq(new Iq,b,t().d);a.em(m.o()|0)}var n=a.pn();if(n.b()){var r=Eq(a),v=new Ef(r,new y(I=>I.dh));Od();var x=Pd(u(),v),A=hl(x)}else{var B=n.o(),C=O().c;A=new z(B,C)}c=A;var D=c.K();if(!Pe(new E(D),1))throw new Yj("assertion failed: "+c);t();var F=new Kq(a.rn(),a.qn(),c.e());
+return new L(F)}catch(I){if(I instanceof Iq){a=I;if(a.Qg===b)return a.Cj();throw a;}throw I;}}
+function Lq(a){var b=tc();try{var c=Mq(a),d=new Ef(c,new y(N=>N.fh)),e=Fq(),g=Gq(d,e);if(g.b())throw Hq(new Iq,b,t().d);var h=g.o()|0,k=Mq(a),l=new Ef(k,new y(N=>N.eh)),m=Fq(),n=Jq(l,m);if(n.b())throw Hq(new Iq,b,t().d);var r=n.o()|0,v=a.pn();if(v.b()){var x=Mq(a),A=new Ef(x,new y(N=>N.dh));Od();var B=Pd(u(),A),C=hl(B)}else{var D=v.o(),F=O().c;C=new z(D,F)}a=C;tp();var I=a.K();up(0,Pe(new E(I),1));t();var M=new Kq(h,r,a.e());return new L(M)}catch(N){if(N instanceof Iq){h=N;if(h.Qg===b)return h.Cj();
+throw h;}throw N;}}function Eq(a){a=a.Vj().m();return new xo(a,new y(b=>b.A().m()))}function Mq(a){var b=a.Vj();return new xo(new Om(new z(a,b)),new y(c=>c.A().m()))}function Nq(a){a.fm(-1);a.em(-1);a.on(t().d)}function Oq(){}Oq.prototype=new p;Oq.prototype.constructor=Oq;function Pq(){}Pq.prototype=Oq.prototype;function Te(a){this.mN=a}Te.prototype=new p;Te.prototype.constructor=Te;
+function Ye(a,b){tp();var c=b.K();up(0,Pe(new E(c),-1+a.mN.Jv.K()|0));c=a.mN.Jv.Ja(new y(d=>{var e=new Ue(J(new K,[d]));d=u();e=e.Jv;Qq();if(e.K()!==(1+d.K()|0))throw Kj("wrong number of arguments ("+d.K()+") for interpolated string with "+e.K()+" parts");d=e.m();e=Rq().Pa;var g=d.t(),h=new Sq;g=Tq(Qq(),g);for(h=Uq(h,g);e.s();)g=e.t(),h.ja=""+h.ja+g,g=d.t(),g=Tq(Qq(),g),h.ja=""+h.ja+g;return new Vq(h.ja)}));a=c.e();c=c.f();b=new Wq(b,b,c);c=new fn((d,e)=>Xq(d.fp,e));Yq();b=Zq(b,c);return new $q(b.cc(a).ha())}
+Te.prototype.$classData=q({CW:0},!1,"mlscript.Message$MessageContext",{CW:1,g:1});function ar(){return new Em(br())}
+function cr(a,b,c){if(b<a.we&&Pe(new E(hc(a.$b.a[b])),hc(46))){for(var d=1+b|0,e=d,g=O().c,h=!1,k=!1,l,m,n,r;;){if(e<a.we){var v=a.$b.a[e];if(dr(v)){var x=new z(hc(v),g);e=1+e|0;g=x;k=!1;continue}if(Pe(new E(hc(v)),hc(95))){var A=1+e|0,B=g.b();e=A;h=B;k=!0;continue}var C=er(g).m(),D=ze(C,"","",""),F=h,I=k,M=e;l=D;m=F;n=I;r=M}else{var N=er(g).m(),P=ze(N,"","",""),T=h,Y=k,Z=e;l=P;m=T;n=Y;r=Z}break}var S=l,ea=!!n,ia=r|0;if(m){var X=a.Le;fr();var sa=Ye(new Te(new Ue(J(new K,["Leading separator is not allowed"]))),
+u());t();var Ja=gr(a,-1+d|0,d),Xa=G(new H,sa,new L(Ja)),Fa=O().c;X.n(hr(0,new z(Xa,Fa),!0,ir()))}if(ea){var za=a.Le;fr();var Qa=Ye(new Te(new Ue(J(new K,["Trailing separator is not allowed"]))),u());t();var Ma=gr(a,-1+ia|0,ia),Ga=G(new H,Qa,new L(Ma)),ab=O().c;za.n(hr(0,new z(Ga,ab),!0,ir()))}var Hb=G(new H,""===S?t().d:(t(),new L(S)),ia);var bc=Hb.y,yb=Hb.w|0;if(t().d===bc){var tb=a.Le;jr();var eb=Ye(new Te(new Ue(J(new K,["Expect at least one digit after the decimal point"]))),u());t();var kb=gr(a,
+1+b|0,2+b|0),Rb=G(new H,eb,new L(kb)),Gb=O().c;tb.n(kr(0,new z(Rb,Gb),!0,ir()));var vb="";var Tb=yb}else{var Nb=Hb.y,ic=Hb.w|0;if(Nb instanceof L)vb="."+Nb.k,Tb=ic;else throw new w(Hb);}}else vb="",Tb=b;var Va=vb,cb=Tb|0;if(cb<a.we)var zb=a.$b.a[cb],Ub=Pe(new E(hc(zb)),hc(101))||Pe(new E(hc(zb)),hc(69));else Ub=!1;if(Ub){var jb=1+cb|0;if(jb<a.we)var db=a.$b.a[jb],ub=Pe(new E(hc(db)),hc(43))||Pe(new E(hc(db)),hc(45));else ub=!1;if(ub)var Aa=a.$b.a[1+cb|0],va=2+cb|0;else{var Ra=1+cb|0;Aa=43;va=Ra}for(var rb=
+Aa,xb=va,mc=xb,Ha=O().c,Ka=!1,Oa=!1,Na,Da,ta,Ya;;){if(mc<a.we){var dc=a.$b.a[mc];if(dr(dc)){var ka=new z(hc(dc),Ha);mc=1+mc|0;Ha=ka;Oa=!1;continue}if(Pe(new E(hc(dc)),hc(95))){var ya=1+mc|0,Sa=Ha.b();mc=ya;Ka=Sa;Oa=!0;continue}var xc=er(Ha).m(),Sb=ze(xc,"","",""),uc=Ka,Lb=Oa,lc=mc;Na=Sb;Da=uc;ta=Lb;Ya=lc}else{var Xb=er(Ha).m(),ec=ze(Xb,"","",""),Ab=Ka,Ob=Oa,fb=mc;Na=ec;Da=Ab;ta=Ob;Ya=fb}break}var Wa=Na,bb=!!ta,Ia=Ya|0;if(Da){var Ua=a.Le;fr();var pc=Ye(new Te(new Ue(J(new K,["Leading separator is not allowed"]))),
+u());t();var sc=gr(a,-1+xb|0,xb),Ba=G(new H,pc,new L(sc)),ob=O().c;Ua.n(hr(0,new z(Ba,ob),!0,ir()))}if(bb){var nc=a.Le;fr();var Ib=Ye(new Te(new Ue(J(new K,["Trailing separator is not allowed"]))),u());t();var vc=gr(a,-1+Ia|0,Ia),Vb=G(new H,Ib,new L(vc)),fc=O().c;nc.n(hr(0,new z(Vb,fc),!0,ir()))}var Bc=G(new H,""===Wa?t().d:(t(),new L(Wa)),Ia);var Pb=Bc.y,Jb=Bc.w|0;if(t().d===Pb){var gc=a.Le;jr();var Cb=Ye(new Te(new Ue(J(new K,["Expect at least one digit after the exponent sign"]))),u());t();var cc=
+gr(a,-1+Jb|0,Jb),yc=G(new H,Cb,new L(cc)),Mc=O().c;gc.n(kr(0,new z(yc,Mc),!0,ir()));var qc="";var oc=Jb}else{var Qc=Bc.y,jc=Bc.w|0;if(Qc instanceof L)qc="E"+hc(rb)+Qc.k,oc=jc;else throw new w(Bc);}}else qc="",oc=cb;var sb=qc,Gc=oc|0,Wb=O();0===(1&Wb.Jt)<<24>>24&&0===(1&Wb.Jt)<<24>>24&&(Wb.tR=lr(),Wb.Jt=(1|Wb.Jt)<<24>>24);var Cc=Wb.tR;var Fc=new H,qd=""+c+Va+sb,Yb=new mr;nr(Yb,or(qd),qd.length);var Nc=pr(Yb)<=Cc.xy.ds?Cc.xy:new xi(pr(Yb),Bi().OC);var ad=new tr(Yb,Nc);return G(Fc,new Fm(ad),Gc)}
+function Uaa(a,b,c){var d=a.Le;jr();t();a=gr(a,c,1+c|0);b=G(new H,b,new L(a));a=O().c;d.n(kr(0,new z(b,a),!0,ir()))}function Hr(a,b,c,d,e){a=G(new H,c,gr(a,d,b));return new z(a,e)}
+function Je(a,b,c){this.$b=this.uN=this.vN=null;this.we=0;this.HH=this.JH=this.IH=null;this.Gs=0;this.OW=a;this.Le=b;this.NW=c;a=a.Us.TM;b=Ir();c=Ir();if(b===c)a=or(a);else if(b=new Jr(a),0<=b.Xh.length)a=new Ic(b.Xh.length),b.Gc(a,0,2147483647);else{a=[];for(b=Kr(new Lr,new Mr(b.Xh));0<b.bk;)c=b.t(),a.push(Ea(c));a=new Ic(new Uint16Array(a))}this.$b=a;this.we=this.$b.a.length;this.IH=Aq(tp().Iv,J(new K,[hc(33),hc(35),hc(37),hc(38),hc(42),hc(43),hc(45),hc(47),hc(58),hc(60),hc(61),hc(62),hc(63),hc(64),
+hc(92),hc(94),hc(124),hc(126),hc(46)]));this.JH=Aq(tp().Iv,J(new K,"\x3d\x3e \x3d : ; # `".split(" ")));this.HH=Aq(tp().Iv,J(new K,["with","and","or","is","as"]))}Je.prototype=new p;Je.prototype.constructor=Je;function Nr(a){return Or(Pr(),a)||Pe(new E(hc(a)),hc(95))?!0:Pe(new E(hc(a)),hc(39))}function Qr(a){return Nr(a)||dr(a)||Pe(new E(hc(a)),hc(39))}function dr(a){return 48<=a&&57>=a}
+function Rr(a,b,c,d){return d<c.length&&(b+d|0)<a.we&&Pe(new E(hc(a.$b.a[b+d|0])),hc(c.charCodeAt(d)))?Rr(a,b,c,1+d|0):d>=c.length}function Vaa(a,b,c,d){for(;b<a.we&&d.n(hc(a.$b.a[b]));)c=new z(hc(a.$b.a[b]),c),b=1+b|0;a=er(c).m();return G(new H,ze(a,"","",""),b)}
+function Waa(a,b){if(b<a.we)if(48===a.$b.a[b])if((1+b|0)<a.we)switch(a.$b.a[1+b|0]){case 120:for(var c=2+b|0,d=c,e=O().c,g=!1,h=!1,k,l,m,n;;){if(d<a.we){var r=a.$b.a[d];if(dr(r)||97<=r&&102>=r||65<=r&&70>=r){var v=new z(hc(r),e);d=1+d|0;e=v;h=!1;continue}if(Pe(new E(hc(r)),hc(95))){var x=1+d|0,A=e.b();d=x;g=A;h=!0;continue}var B=er(e).m(),C=ze(B,"","",""),D=g,F=h,I=d;k=C;l=D;m=F;n=I}else{var M=er(e).m(),N=ze(M,"","",""),P=g,T=h,Y=d;k=N;l=P;m=T;n=Y}break}var Z=k,S=!!m,ea=n|0;if(l){var ia=a.Le;fr();
+var X=Ye(new Te(new Ue(J(new K,["Leading separator is not allowed"]))),u());t();var sa=gr(a,-1+c|0,c),Ja=G(new H,X,new L(sa)),Xa=O().c;ia.n(hr(0,new z(Ja,Xa),!0,ir()))}if(S){var Fa=a.Le;fr();var za=Ye(new Te(new Ue(J(new K,["Trailing separator is not allowed"]))),u());t();var Qa=gr(a,-1+ea|0,ea),Ma=G(new H,za,new L(Qa)),Ga=O().c;Fa.n(hr(0,new z(Ma,Ga),!0,ir()))}var ab=G(new H,""===Z?t().d:(t(),new L(Z)),ea),Hb=ab.y,bc=ab.w|0;if(t().d===Hb){var yb=a.Le;jr();var tb=new Te(new Ue(J(new K,["Expect at least one ",
+" digit"]))),eb=[We(Xe(),"hexadecimal")],kb=Ye(tb,J(new K,eb));t();var Rb=gr(a,c,2+c|0),Gb=G(new H,kb,new L(Rb)),vb=O().c;yb.n(kr(0,new z(Gb,vb),!0,ir()));return G(new H,ar(),bc)}var Tb=ab.y,Nb=ab.w|0;if(Tb instanceof L){var ic=Tb.k;return G(new H,new Em(Sr(Tr(),ic,16)),Nb)}throw new w(ab);case 111:for(var Va=2+b|0,cb=Va,zb=O().c,Ub=!1,jb=!1,db,ub,Aa,va;;){if(cb<a.we){var Ra=a.$b.a[cb];if(48<=Ra&&55>=Ra){var rb=new z(hc(Ra),zb);cb=1+cb|0;zb=rb;jb=!1;continue}if(Pe(new E(hc(Ra)),hc(95))){var xb=1+
+cb|0,mc=zb.b();cb=xb;Ub=mc;jb=!0;continue}var Ha=er(zb).m(),Ka=ze(Ha,"","",""),Oa=Ub,Na=jb,Da=cb;db=Ka;ub=Oa;Aa=Na;va=Da}else{var ta=er(zb).m(),Ya=ze(ta,"","",""),dc=Ub,ka=jb,ya=cb;db=Ya;ub=dc;Aa=ka;va=ya}break}var Sa=db,xc=!!Aa,Sb=va|0;if(ub){var uc=a.Le;fr();var Lb=Ye(new Te(new Ue(J(new K,["Leading separator is not allowed"]))),u());t();var lc=gr(a,-1+Va|0,Va),Xb=G(new H,Lb,new L(lc)),ec=O().c;uc.n(hr(0,new z(Xb,ec),!0,ir()))}if(xc){var Ab=a.Le;fr();var Ob=Ye(new Te(new Ue(J(new K,["Trailing separator is not allowed"]))),
+u());t();var fb=gr(a,-1+Sb|0,Sb),Wa=G(new H,Ob,new L(fb)),bb=O().c;Ab.n(hr(0,new z(Wa,bb),!0,ir()))}var Ia=G(new H,""===Sa?t().d:(t(),new L(Sa)),Sb),Ua=Ia.y,pc=Ia.w|0;if(t().d===Ua){var sc=a.Le;jr();var Ba=new Te(new Ue(J(new K,["Expect at least one "," digit"]))),ob=[We(Xe(),"octal")],nc=Ye(Ba,J(new K,ob));t();var Ib=gr(a,Va,2+Va|0),vc=G(new H,nc,new L(Ib)),Vb=O().c;sc.n(kr(0,new z(vc,Vb),!0,ir()));return G(new H,ar(),pc)}var fc=Ia.y,Bc=Ia.w|0;if(fc instanceof L){var Pb=fc.k;return G(new H,new Em(Sr(Tr(),
+Pb,8)),Bc)}throw new w(Ia);case 98:for(var Jb=2+b|0,gc=Jb,Cb=O().c,cc=!1,yc=!1,Mc,qc,oc,Qc;;){if(gc<a.we){var jc=a.$b.a[gc],sb=jc;if(Pe(new E(hc(sb)),hc(48))||Pe(new E(hc(sb)),hc(49))){var Gc=new z(hc(jc),Cb);gc=1+gc|0;Cb=Gc;yc=!1;continue}if(Pe(new E(hc(jc)),hc(95))){var Wb=1+gc|0,Cc=Cb.b();gc=Wb;cc=Cc;yc=!0;continue}var Fc=er(Cb).m(),qd=ze(Fc,"","",""),Yb=cc,Nc=yc,ad=gc;Mc=qd;qc=Yb;oc=Nc;Qc=ad}else{var Uc=er(Cb).m(),cd=ze(Uc,"","",""),kc=cc,Vc=yc,Hc=gc;Mc=cd;qc=kc;oc=Vc;Qc=Hc}break}var rc=Mc,sd=
+!!oc,Kc=Qc|0;if(qc){var Qd=a.Le;fr();var Ad=Ye(new Te(new Ue(J(new K,["Leading separator is not allowed"]))),u());t();var kd=gr(a,-1+Jb|0,Jb),Hd=G(new H,Ad,new L(kd)),Rd=O().c;Qd.n(hr(0,new z(Hd,Rd),!0,ir()))}if(sd){var Bd=a.Le;fr();var ae=Ye(new Te(new Ue(J(new K,["Trailing separator is not allowed"]))),u());t();var dd=gr(a,-1+Kc|0,Kc),od=G(new H,ae,new L(dd)),Ta=O().c;Bd.n(hr(0,new z(od,Ta),!0,ir()))}var wb=G(new H,""===rc?t().d:(t(),new L(rc)),Kc),$a=wb.y,wa=wb.w|0;if(t().d===$a){var hb=a.Le;jr();
+var ra=new Te(new Ue(J(new K,["Expect at least one "," digit"]))),wc=[We(Xe(),"binary")],ac=Ye(ra,J(new K,wc));t();var Id=gr(a,Jb,2+Jb|0),ud=G(new H,ac,new L(Id)),be=O().c;hb.n(kr(0,new z(ud,be),!0,ir()));return G(new H,ar(),wa)}var re=wb.y,pe=wb.w|0;if(re instanceof L){var bd=re.k;return G(new H,new Em(Sr(Tr(),bd,2)),pe)}throw new w(wb);case 46:case 69:case 101:return cr(a,1+b|0,"0");default:for(var Rc=b,Wc=O().c,Wd=!1,zd=!1,Pa,Db,Oc,Tc;;){if(Rc<a.we){var Sd=a.$b.a[Rc];if(dr(Sd)){var Jc=new z(hc(Sd),
+Wc);Rc=1+Rc|0;Wc=Jc;zd=!1;continue}if(Pe(new E(hc(Sd)),hc(95))){var vd=1+Rc|0,hd=Wc.b();Rc=vd;Wd=hd;zd=!0;continue}var de=er(Wc).m(),ye=ze(de,"","",""),jf=Wd,af=zd,pf=Rc;Pa=ye;Db=jf;Oc=af;Tc=pf}else{var kf=er(Wc).m(),Be=ze(kf,"","",""),Kd=Wd,ld=zd,Jd=Rc;Pa=Be;Db=Kd;Oc=ld;Tc=Jd}break}var Dd=Pa,Xd=!!Oc,Yc=Tc|0;if(Db){var Ce=a.Le;fr();var te=Ye(new Te(new Ue(J(new K,["Leading separator is not allowed"]))),u());t();var Ie=gr(a,-1+b|0,b),Jf=G(new H,te,new L(Ie)),df=O().c;Ce.n(hr(0,new z(Jf,df),!0,ir()))}if(Xd){var vg=
+a.Le;fr();var wg=Ye(new Te(new Ue(J(new K,["Trailing separator is not allowed"]))),u());t();var xg=gr(a,-1+Yc|0,Yc),eg=G(new H,wg,new L(xg)),vh=O().c;vg.n(hr(0,new z(eg,vh),!0,ir()))}var fg=G(new H,""===Dd?t().d:(t(),new L(Dd)),Yc),ih=fg.y,Ig=fg.w|0;if(t().d===ih){var Tf=a.Le;jr();var Jg=new Te(new Ue(J(new K,["Expect at least one "," digit"]))),jh=[We(Xe(),"decimal")],yg=Ye(Jg,J(new K,jh));t();var gg=gr(a,b,2+b|0),Cf=G(new H,yg,new L(gg)),Uf=O().c;Tf.n(kr(0,new z(Cf,Uf),!0,ir()));return G(new H,
+ar(),Ig)}var $g=fg.y,Ah=fg.w|0;if($g instanceof L){var Kg=$g.k;return G(new H,new Em(Sr(Tr(),Kg,10)),Ah)}throw new w(fg);}else return G(new H,ar(),1+b|0);else{for(var Vf=b,hg=O().c,zg=!1,Lg=!1,Mg,Wf,Ng,Kf;;){if(Vf<a.we){var xf=a.$b.a[Vf];if(dr(xf)){var Og=new z(hc(xf),hg);Vf=1+Vf|0;hg=Og;Lg=!1;continue}if(Pe(new E(hc(xf)),hc(95))){var mi=1+Vf|0,Ci=hg.b();Vf=mi;zg=Ci;Lg=!0;continue}var Xh=er(hg).m(),wh=ze(Xh,"","",""),Bh=zg,ng=Lg,kh=Vf;Mg=wh;Wf=Bh;Ng=ng;Kf=kh}else{var Kh=er(hg).m(),ni=ze(Kh,"","",
+""),Lh=zg,lh=Lg,Ch=Vf;Mg=ni;Wf=Lh;Ng=lh;Kf=Ch}break}var Dh=Mg,Yh=!!Ng,ah=Kf|0;if(Wf){var oi=a.Le;fr();var mj=Ye(new Te(new Ue(J(new K,["Leading separator is not allowed"]))),u());t();var wd=gr(a,-1+b|0,b),ge=G(new H,mj,new L(wd)),De=O().c;oi.n(hr(0,new z(ge,De),!0,ir()))}if(Yh){var qf=a.Le;fr();var og=Ye(new Te(new Ue(J(new K,["Trailing separator is not allowed"]))),u());t();var Xf=gr(a,-1+ah|0,ah),mh=G(new H,og,new L(Xf)),Ag=O().c;qf.n(hr(0,new z(mh,Ag),!0,ir()))}var Bg=G(new H,""===Dh?t().d:(t(),
+new L(Dh)),ah),Eh=Bg.y;if(t().d===Eh){var Pg=a.Le;jr();var Di=Ye(new Te(new Ue(J(new K,["Expect a numeric literal"]))),u());t();var Mh=gr(a,b,1+b|0),pi=G(new H,Di,new L(Mh)),Xi=O().c;Pg.n(kr(0,new z(pi,Xi),!0,ir()));return G(new H,ar(),b)}var Qg=Bg.y,nh=Bg.w|0;if(Qg instanceof L){var bh=Qg.k,Mj;if(Mj=nh<a.we){var Nj=a.$b.a[nh];Mj=Pe(new E(hc(Nj)),hc(46))||Pe(new E(hc(Nj)),hc(101))||Pe(new E(hc(Nj)),hc(69))}return Mj?cr(a,nh,bh):G(new H,new Em(Hp(bh)),nh)}throw new w(Bg);}else{var ie=a.Le;jr();var Ac=
+Ye(new Te(new Ue(J(new K,["Expect a numeric literal instead of end of input"]))),u());t();var Ve=gr(a,b,1+b|0),Td=G(new H,Ac,new L(Ve)),lf=O().c;ie.n(kr(0,new z(Td,lf),!0,ir()));return G(new H,ar(),b)}}
+function Xaa(a,b,c){if(c)d=!1;else{d=Ur(tp(),a.$b);d=Vr(new Wr(d),b);var d=Pe(new E(d),new L(hc(34)))}if(d)return 1+b|0;if(c&&Rr(a,b,'"""',0))return 3+b|0;c=a.Le;jr();d=Ye(new Te(new Ue(J(new K,["unclosed quotation mark"]))),u());t();a=gr(a,b,1+b|0);a=G(new H,d,new L(a));d=O().c;c.n(kr(0,new z(a,d),!0,ir()));return b}
+function Yaa(a,b,c,d){for(var e=!1;;)if(e)if(b<a.we)switch(e=a.$b.a[b],e){case 92:c=new z(hc(92),c);b=1+b|0;e=!1;break;case 34:c=new z(hc(34),c);b=1+b|0;e=!1;break;case 110:c=new z(hc(10),c);b=1+b|0;e=!1;break;case 116:c=new z(hc(9),c);b=1+b|0;e=!1;break;case 114:c=new z(hc(13),c);b=1+b|0;e=!1;break;case 98:c=new z(hc(8),c);b=1+b|0;e=!1;break;case 102:c=new z(hc(12),c);b=1+b|0;e=!1;break;default:var g=a.Le;fr();var h=Ye(new Te(new Ue(J(new K,["Found invalid escape character"]))),u());t();var k=gr(a,
+b,1+b|0);h=G(new H,h,new L(k));k=O().c;g.n(hr(0,new z(h,k),!0,ir()));c=new z(hc(e),c);b=1+b|0;e=!1}else return d=a.Le,jr(),e=Ye(new Te(new Ue(J(new K,["Expect an escape character"]))),u()),t(),a=gr(a,b,1+b|0),a=G(new H,e,new L(a)),e=O().c,d.n(kr(0,new z(a,e),!0,ir())),a=er(c).m(),G(new H,ze(a,"","",""),b);else if(d)if(b<a.we)if(e=a.$b.a[b],34===e){if(Rr(a,b,'"""',0)&&!Rr(a,1+b|0,'"""',0))return a=er(c).m(),G(new H,ze(a,"","",""),b);c=new z(hc(34),c);b=1+b|0;e=!1}else c=new z(hc(e),c),b=1+b|0,e=!1;
+else return a=er(c).m(),G(new H,ze(a,"","",""),b);else if(b<a.we)switch(e=a.$b.a[b],e){case 92:b=1+b|0;e=!0;break;case 34:case 10:return a=er(c).m(),G(new H,ze(a,"","",""),b);default:c=new z(hc(e),c),b=1+b|0,e=!1}else return a=er(c).m(),G(new H,ze(a,"","",""),b)}function gr(a,b,c){return new Kq(b,c,a.OW)}
+function Zaa(a){for(var b=0,c=O().c,d=O().c,e=O().c;;){if(b>=a.we)return Km(d);var g=a.$b.a[b],h=!1,k=!1;if(32===g){for(var l=b,m=O().c;;)if(l<a.we&&Pe(new E(hc(a.$b.a[l])),hc(32))){var n=new z(hc(a.$b.a[l]),m);l=1+l|0;m=n}else break;var r=er(m).m();ze(r,"","","");var v=l,x=Hr(a,v,Se(),b,d);b=v;d=x}else if(44===g){var A=1+b|0,B=Hr(a,A,Xr(),b,d);b=A;d=B}else if(96===g){var C=1+b|0,D=Hr(a,1+b|0,Yr(),b,d);b=C;d=D}else if(99===g&&(Rr(a,b,Sk(Nk()),0)||Rr(a,b,Sk(Ok()),0))){var F=Rr(a,b,Sk(Ok()),0)?Ok():
+Nk(),I=Sk(F).length,M=b+I|0,N=Hr(a,b+I|0,new Zr(F),b,d),P=new z(F,e);b=M;d=N;e=P}else{if(36===g&&(h=!0,Rr(a,b,Sk(Pk()),0))){var T=2+b|0,Y=Hr(a,2+b|0,new Zr(Pk()),b,d);b=T;d=Y;continue}if(h&&(1+b|0)<a.we&&Nr(a.$b.a[1+b|0])){for(var Z=1+b|0,S=O().c;;)if(Z<a.we&&Qr(a.$b.a[Z])){var ea=new z(hc(a.$b.a[Z]),S);Z=1+Z|0;S=ea}else break;var ia=er(S).m(),X=ze(ia,"","",""),sa=Z,Ja=Pk(),Xa=$r().GH.L(X)?new as(X):new bs(X,a.HH.L(X)),Fa=G(new H,Xa,gr(a,1+b|0,sa)),za=O().c,Qa=Hr(a,sa,new cs(Ja,new z(Fa,za),gr(a,
+b,sa)),b,d);b=sa;d=Qa}else if(59===g){var Ma=1+b|0,Ga=Hr(a,Ma,ds(),b,d);b=Ma;d=Ga}else if(34===g){var ab=e;if(ab instanceof z)var Hb=ab,bc=Hb.p,yb=Pe(new E(Hb.z),Ok()),tb=bc;else{var eb=O().c;if(null===eb?null!==ab:!eb.i(ab))throw new w(ab);var kb=O().c;yb=!1;tb=kb}var Rb=!!yb,Gb=tb;if(Rb&&Rr(a,b,Tk(Ok()),0)){var vb=Tk(Ok()).length,Tb=b+vb|0,Nb=Hr(a,b+vb|0,new es(Ok()),b,d);b=Tb;d=Nb;e=Gb}else if(Rb?0:!e.b()){var ic=1+b|0,Va=Hr(a,1+b|0,new es(Nk()),b,d);b=ic;d=Va;e=Gb}else{var cb=Rr(a,b,'"""',0),
+zb=Yaa(a,b+(cb?3:1)|0,O().c,cb);if(null===zb)throw new w(zb);var Ub=zb.h(),jb=Xaa(a,zb.Sc(),cb),db=Hr(a,jb,new fs(new Dm(Ub)),b,d);b=jb;d=db}}else{if(47===g){k=!0;var ub=Ur(tp(),a.$b);if(Vr(new Wr(ub),1+b|0).L(hc(47))){for(var Aa=2+b|0,va=O().c;;)if(Aa<a.we&&Nm(new E(hc(a.$b.a[Aa])),hc(10))){var Ra=new z(hc(a.$b.a[Aa]),va);Aa=1+Aa|0;va=Ra}else break;var rb=er(va).m(),xb=ze(rb,"","",""),mc=Aa,Ha=Hr(a,mc,new gs(xb),b,d);b=mc;d=Ha;continue}}if(k)var Ka=Ur(tp(),a.$b),Oa=Vr(new Wr(Ka),1+b|0).L(hc(42));
+else Oa=!1;if(Oa){var Na=2+b|0,Da=0;Da=47;var ta=0;ta=42;for(var Ya=Na,dc=O().c;;){if(Ya<a.we){var ka=a.$b.a[Ya],ya=Nm(new E(hc(Da)),hc(42))?!0:Nm(new E(hc(ta)),hc(47));Da=ta;ta=ka;var Sa=ya}else Sa=!1;if(Sa){var xc=new z(hc(a.$b.a[Ya]),dc);Ya=1+Ya|0;dc=xc}else break}var Sb=er(dc).m(),uc=ze(Sb,"","",""),Lb=Ya,lc=Hr(a,Lb,new gs($aa(Q(),uc)),b,d);b=Lb;d=lc}else{var Xb=Vk(Zk(),g);if(!Xb.b()){var ec=Xb.o();if(ec instanceof fe){var Ab=1+b|0,Ob=Hr(a,1+b|0,new Zr(ec.aa),b,d);b=Ab;d=Ob;continue}}var fb=Vk(Zk(),
+g);if(!fb.b()){var Wa=fb.o();if(Wa instanceof Ud){var bb=1+b|0,Ia=Hr(a,1+b|0,new es(Wa.fa),b,d);b=bb;d=Ia;continue}}if(10===g){for(var Ua=1+b|0,pc=Ua,sc=O().c;;){if(pc<a.we)var Ba=a.$b.a[pc],ob=Pe(new E(hc(Ba)),hc(32))||Pe(new E(hc(Ba)),hc(10));else ob=!1;if(ob){var nc=new z(hc(a.$b.a[pc]),sc);pc=1+pc|0;sc=nc}else break}var Ib=er(sc).m(),vc=ze(Ib,"","",""),Vb=pc,fc=hs(new is(new js(vc),new y(kf=>Nm(new E(hc(Ea(kf))),hc(10))))),Bc=c.Jg();if((Bc.b()||(Bc.o()|0)<fc)&&0<fc){var Pb=new z(fc,c),Jb=G(new H,
+ks(),gr(a,Ua,Vb)),gc=new z(Jb,d);b=Vb;c=Pb;d=gc}else{for(var Cb=c;;)if(Cb.b()?0:(Cb.e()|0)>fc)Cb=Cb.f();else break;var cc=Cb,yc=c.K()-cc.K()|0,Mc=cc.Jg(),qc=Mc.b()||(Mc.o()|0)<fc?0<fc:!1,oc=qc?new z(fc,cc):cc;if(a.NW){tp();var Qc=ls(ms(),a.$b,b),jc=ns(ms(),Qc,0,10),sb=jc.a.length,Gc=new (md(fa).Ia)(sb);if(0<sb){var Wb=0;if(jc instanceof zc)for(var Cc=jc;Wb<sb;)Gc.a[Wb]=os(Ea(Cc.a[Wb])),Wb=1+Wb|0;else if(jc instanceof Xc)for(var Fc=jc;Wb<sb;)Gc.a[Wb]=os(Ea(Fc.a[Wb])),Wb=1+Wb|0;else if(jc instanceof
+ed)for(var qd=jc;Wb<sb;)Gc.a[Wb]=os(Ea(qd.a[Wb])),Wb=1+Wb|0;else if(jc instanceof Zc)for(var Yb=jc;Wb<sb;){var Nc=Yb.a[Wb];Gc.a[Wb]=os(Ea(new ma(Nc.W,Nc.Y)));Wb=1+Wb|0}else if(jc instanceof $c)for(var ad=jc;Wb<sb;)Gc.a[Wb]=os(Ea(ad.a[Wb])),Wb=1+Wb|0;else if(null!==jc)for(;Wb<sb;)Gc.a[Wb]=os(Ea(hc(jc.a[Wb]))),Wb=1+Wb|0;else if(jc instanceof Pc)for(var Uc=jc;Wb<sb;)Gc.a[Wb]=os(Ea(Uc.a[Wb])),Wb=1+Wb|0;else if(jc instanceof Sc)for(var cd=jc;Wb<sb;)Gc.a[Wb]=os(Ea(cd.a[Wb])),Wb=1+Wb|0;else if(jc instanceof
+Ec)for(var kc=jc;Wb<sb;)Gc.a[Wb]=os(Ea(kc.a[Wb])),Wb=1+Wb|0;else throw new w(jc);}var Vc=ps(Gc),Hc="dbg: "+ze(Vc,"","","")+"...";ff(gf(),Hc+"\n");ff(gf(),new bo(c,fc,cc,yc,qc,oc)+"\n")}if(0<yc){var rc=qc?G(new H,ks(),gr(a,Ua,Vb)):G(new H,qs(),gr(a,b,Vb));O();for(var sd=new fp,Kc=0;Kc<yc;){var Qd=G(new H,rs(),gr(a,-1+Ua|0,Vb));wp(sd,Qd);Kc=1+Kc|0}var Ad=sd.ha(),kd=dl(d,Ad),Hd=new z(rc,kd)}else{var Rd=G(new H,qs(),gr(a,b,Vb));Hd=new z(Rd,d)}b=Vb;c=oc;d=Hd}}else if(Nr(g)){for(var Bd=b,ae=O().c;;)if(Bd<
+a.we&&Qr(a.$b.a[Bd])){var dd=new z(hc(a.$b.a[Bd]),ae);Bd=1+Bd|0;ae=dd}else break;var od=er(ae).m(),Ta=ze(od,"","",""),wb=Bd,$a=$r().GH.L(Ta)?new as(Ta):new bs(Ta,a.HH.L(Ta)),wa=Hr(a,wb,$a,b,d);b=wb;d=wa}else if(a.IH.L(hc(g))){var hb=Vaa(a,b,O().c,a.IH);if(null===hb)throw new w(hb);var ra=hb.h(),wc=hb.Sc();if("."===ra&&wc<a.we){var ac=a.$b.a[wc];if(Nr(ac)){for(var Id=wc,ud=O().c;;)if(Id<a.we&&Qr(a.$b.a[Id])){var be=new z(hc(a.$b.a[Id]),ud);Id=1+Id|0;ud=be}else break;var re=er(ud).m(),pe=ze(re,"","",
+""),bd=Id,Rc=Hr(a,bd,new ss(pe),b,d);b=bd;d=Rc}else if(Pe(new E(hc(ac)),hc(48))&&!((1+wc|0)<a.we&&dr(a.$b.a[1+wc|0]))||48<ac&&57>=ac){for(var Wc=wc,Wd=O().c;;)if(Wc<a.we&&dr(a.$b.a[Wc])){var zd=new z(hc(a.$b.a[Wc]),Wd);Wc=1+Wc|0;Wd=zd}else break;var Pa=er(Wd).m(),Db=ze(Pa,"","",""),Oc=Wc,Tc=Hr(a,Oc,new ss(Db),b,d);b=Oc;d=Tc}else{var Sd=Hr(a,wc,a.JH.L(ra)?new as(ra):new bs(ra,!0),b,d);b=wc;d=Sd}}else{var Jc=Hr(a,wc,a.JH.L(ra)?new as(ra):new bs(ra,!0),b,d);b=wc;d=Jc}}else if(dr(g)){var vd=Waa(a,b);
+if(null===vd)throw new w(vd);var hd=vd.Sc(),de=Hr(a,hd,new fs(vd.h()),b,d);b=hd;d=de}else{var ye=new Te(new Ue(J(new K,["unexpected character '","'"]))),jf=[We(Xe(),os(g))];Uaa(a,Ye(ye,J(new K,jf)),b);var af=1+b|0,pf=Hr(a,1+b|0,ts(),b,d);b=af;d=pf}}}}}}
+function os(a){switch(a){case 8:return"\\b";case 9:return"\\t";case 10:return"\\n";case 12:return"\\f";case 13:return"\\r";case 34:return'\\"';case 39:return"\\'";case 92:return"\\\\";default:return us(Pr(),a)?"\\0"+(+(a>>>0)).toString(8):String.fromCharCode(a)}}
+function qaa(a){if(0===(2&a.Gs)<<24>>24&&0===(2&a.Gs)<<24>>24){0===(1&a.Gs)<<24>>24&&0===(1&a.Gs)<<24>>24&&(a.vN=Zaa(a),a.Gs=(1|a.Gs)<<24>>24);a:for(var b=a.vN,c=!1,d=O().c,e=O().c;;){var g=!1,h=null,k=b;if(k instanceof z){g=!0;h=k;var l=h.z,m=h.p;if(null!==l){var n=l.h(),r=l.j();if(Yr()===n&&m instanceof z){var v=m,x=v.z,A=v.p;if(null!==x){var B=x.h(),C=x.j();if(B instanceof bs){var D=B,F=D.ke;if("\x3c"===D.ae&&!0===F){var I=G(new H,new bs("\x3c",!0),C),M=G(new H,Yr(),r),N=new z(I,new z(M,e));b=
+A;c=!1;e=N;continue}}}}}}if(g){var P=h.z,T=h.p;if(null!==P){var Y=P.h(),Z=P.j();if(Yr()===Y&&T instanceof z){var S=T,ea=S.z,ia=S.p;if(null!==ea){var X=ea.h(),sa=ea.j();if(X instanceof bs){var Ja=X,Xa=Ja.ke;if("\x3e"===Ja.ae&&!0===Xa){var Fa=G(new H,new bs("\x3e",!0),sa),za=G(new H,Yr(),Z),Qa=new z(Fa,new z(za,e));b=ia;c=!1;e=Qa;continue}}}}}}if(g){var Ma=h.z,Ga=h.p;if(null!==Ma){var ab=Ma.h(),Hb=Ma.j();if(ab instanceof Zr){var bc=G(new H,ab.qx,Hb),yb=G(new H,bc,e),tb=new z(yb,d),eb=O().c;b=Ga;c=!1;
+d=tb;e=eb;continue}}}if(g){var kb=h.z,Rb=h.p;if(null!==kb){var Gb=kb.h(),vb=kb.j();if(Gb instanceof es){var Tb=Gb.Iw,Nb=!1,ic=null,Va=d;if(Va instanceof z){Nb=!0;ic=Va;var cb=ic.z;if(null!==cb){var zb=cb.h();if(null!==zb){var Ub=zb.h();if(Mk()===Ub&&Nm(new E(Tb),Mk())){var jb=new es(Mk()),db=vs(vb),ub=G(new H,jb,db);b=new z(ub,b);c=!1;continue}}}}if(Nb){var Aa=ic.z,va=ic.p;if(null!==Aa){var Ra=Aa.h(),rb=Aa.j();if(null!==Ra){var xb=Ra.h();if(Mk()===xb)if(Pe(new E(Tb),Mk()))b:{for(var mc=e;!mc.b();){var Ha=
+mc.e();c:{if(null!==Ha){var Ka=Ha.h();if(Se()===Ka||qs()===Ka){var Oa=!0;break c}}Oa=!1}if(!Oa){var Na=!1;break b}mc=mc.f()}Na=!0}else Na=!1;else Na=!1;if(Na){b=Rb;c=!1;d=va;e=rb;continue}}}}if(Nb){var Da=ic.z,ta=ic.p;if(null!==Da){var Ya=Da.h(),dc=Da.j();if(null!==Ya){var ka=Ya.h(),ya=Ya.j();if(Nm(new E(ka),Tb)&&(!Pe(new E(ka),Pk())||!Pe(new E(Tb),Jk()))){var Sa=a.Le;jr();var xc=new Te(new Ue(J(new K,["Mistmatched closing ",""]))),Sb=[We(Xe(),Tb.Ua())],uc=Ye(xc,J(new K,Sb));t();var Lb=G(new H,uc,
+new L(vb)),lc=new Te(new Ue(J(new K,["does not correspond to opening ",""]))),Xb=[We(Xe(),ka.Ua())],ec=Ye(lc,J(new K,Xb));t();var Ab=G(new H,ec,new L(ya)),Ob=O().c;Sa.n(kr(0,new z(Lb,new z(Ab,Ob)),!0,ws()))}var fb=Km(e),Wa=new cs(ka,fb,xs(new Kq(ya.eh,ya.eh,ya.dh),vs(vb))),bb=xs(ya,vb),Ia=G(new H,Wa,bb),Ua=new z(Ia,dc);b=Rb;c=!0;d=ta;e=Ua;continue}}}var pc=O().c;if(null===pc?null===Va:pc.i(Va)){var sc=a.Le;jr();var Ba=new Te(new Ue(J(new K,["Unexpected closing ",""]))),ob=[We(Xe(),Tb.Ua())],nc=Ye(Ba,
+J(new K,ob));t();var Ib=G(new H,nc,new L(vb)),vc=O().c;sc.n(kr(0,new z(Ib,vc),!0,ws()));b=Rb;c=!1;continue}throw new w(Va);}}}if(g){var Vb=h.z,fc=h.p;if(null!==Vb){var Bc=Vb.h(),Pb=Vb.j();if(ks()===Bc){var Jb=new Zr(Mk()),gc=G(new H,Jb,Pb);b=new z(gc,fc);c=!1;continue}}}if(g){var Cb=h.z,cc=h.p;if(null!==Cb){var yc=Cb.h(),Mc=Cb.j();if(rs()===yc){var qc=new es(Mk()),oc=G(new H,qc,Mc);b=new z(oc,cc);c=!1;continue}}}if(g){var Qc=h.z,jc=h.p;if(null!==Qc){var sb=Qc.h(),Gc=Qc.j();if(sb instanceof bs){var Wb=
+sb,Cc=Wb.ke;if("\x3c"===Wb.ae&&!0===Cc&&c){var Fc=new Zr(Lk()),qd=G(new H,Fc,Gc);b=new z(qd,jc);c=!1;continue}}}}if(g){var Yb=h.z,Nc=h.p;if(null!==Yb){var ad=Yb.h(),Uc=Yb.j();if(ad instanceof bs){var cd=ad,kc=cd.ke;if("\x3e"===cd.ae)if(!0===kc)if(c){var Vc=d;b:{if(Vc instanceof z){var Hc=Vc.z;if(null!==Hc){var rc=Hc.h();if(null!==rc){var sd=rc.h();if(Lk()===sd){var Kc=!0;break b}}}}Kc=!1}}else Kc=!1;else Kc=!1;else Kc=!1;if(Kc){var Qd=new es(Lk()),Ad=G(new H,Qd,Uc);b=new z(Ad,Nc);c=!1;continue}}}}if(g){var kd=
+h.z,Hd=h.p;if(null!==kd){var Rd=kd.h(),Bd=kd.j();if(Rd instanceof bs){var ae=Rd,dd=ae.ae;if(!0===ae.ke){if(c)b:{for(var od=0,Ta=dd.length;od<Ta;){if(62!==dd.charCodeAt(od)){var wb=!1;break b}od=1+od|0}wb=!0}else wb=!1;if(wb&&1<dd.length){var $a=d;b:{if($a instanceof z){var wa=$a.z;if(null!==wa){var hb=wa.h();if(null!==hb){var ra=hb.h();if(Lk()===ra){var wc=!0;break b}}}}wc=!1}}else wc=!1}else wc=!1;if(wc){var ac=new es(Lk()),Id=vs(Bd),ud=G(new H,ac,Id),be=new bs(ys(Q(),dd,1),!0),re=G(new H,be,Bd);
+b=new z(ud,new z(re,Hd));c=!1;continue}}}}if(g){var pe=h.z,bd=h.p;if(null!==pe){var Rc=pe.h(),Wc=pe.j();if(Rc instanceof bs){var Wd=Rc,zd=Wd.ke;if("\x3e"===Wd.ae&&!0===zd&&c){var Pa=a.Le;fr();var Db=Ye(new Te(new Ue(J(new K,["This looks like an angle bracket, but it does not close any angle bracket section"]))),u());t();var Oc=G(new H,Db,new L(Wc)),Tc=Ye(new Te(new Ue(J(new K,["Add spaces around it if you intended to use `\x3c` as an operator"]))),u()),Sd=t().d,Jc=G(new H,Tc,Sd),vd=O().c;Pa.n(hr(0,
+new z(Oc,new z(Jc,vd)),!0,ws()));var hd=G(new H,Wd,Wc),de=new z(hd,e);b=bd;c=!1;e=de;continue}}}}if(g){var ye=h.z,jf=h.p;if(null!==ye){var af=ye.h(),pf=ye.j();if(af&&af.$classData&&af.$classData.rb.Wm){var kf=af,Be=!(Se()===kf||qs()===kf),Kd=G(new H,kf,pf),ld=new z(Kd,e);b=jf;c=Be;e=ld;continue}}}var Jd=O().c;if(null===Jd?null===k:Jd.i(k)){var Dd=!1,Xd=null,Yc=d;if(Yc instanceof z){Dd=!0;Xd=Yc;var Ce=Xd.z;if(null!==Ce){var te=Ce.h();if(null!==te){var Ie=te.h(),Jf=te.j();if(Mk()===Ie){var df=new es(Mk()),
+vg=G(new H,df,Jf),wg=O().c;b=new z(vg,wg);c=!1;continue}}}}if(Dd){var xg=Xd.z;if(null!==xg){var eg=xg.h(),vh=xg.j();if(null!==eg){var fg=eg.h(),ih=eg.j(),Ig=a.Le;jr();var Tf=new Te(new Ue(J(new K,["Unmatched opening ",""]))),Jg=[We(Xe(),fg.Ua())],jh=Ye(Tf,J(new K,Jg));t();var yg=G(new H,jh,new L(ih));if(Pe(new E(fg),Lk()))var gg=Ye(new Te(new Ue(J(new K,["Note that `\x3c` without spaces around it is considered as an angle bracket and not as an operator"]))),u()),Cf=t().d,Uf=G(new H,gg,Cf),$g=O().c,
+Ah=new z(Uf,$g);else Ah=O().c;Ig.n(kr(0,new z(yg,Ah),!0,ws()));var Kg=Km(dl(e,vh));break a}}}var Vf=O().c;if(null===Vf?null===Yc:Vf.i(Yc)){Kg=Km(e);break a}throw new w(Yc);}throw new w(k);}a.uN=Kg;a.Gs=(2|a.Gs)<<24>>24}return a.uN}Je.prototype.$classData=q({LW:0},!1,"mlscript.NewLexer",{LW:1,g:1});
+function zs(){this.GH=null;As=this;this.GH=Aq(tp().Iv,J(new K,"if then else case fun val var of let rec in mut set do while declare class trait mixin interface extends override super new namespace module type where forall exists in out null undefined abstract constructor virtual".split(" ")))}zs.prototype=new p;zs.prototype.constructor=zs;
+function aba(a,b){if(null!==b&&(a=b.h(),Se()===a))return" ";if(null!==b&&(a=b.h(),Xr()===a))return",";if(null!==b&&(a=b.h(),ds()===a))return";";if(null!==b&&(a=b.h(),qs()===a))return"\u21b5";if(null!==b&&(a=b.h(),ks()===a))return"\u2192";if(null!==b&&(a=b.h(),rs()===a))return"\u2190";if(null!==b&&(a=b.h(),ts()===a))return"\x3cerror\x3e";if(null!==b&&(a=b.h(),Yr()===a))return"`";if(null!==b&&(a=b.h(),a instanceof fs))return a.Cu.Dh;if(null!==b&&(a=b.h(),a instanceof as&&(a=a.Na,null!==a)))return"#"+
+a;if(null!==b&&(a=b.h(),a instanceof bs&&(a=a.ae,null!==a)))return a;if(null!==b&&(a=b.h(),a instanceof ss&&(a=a.ux,null!==a)))return"."+a;if(null!==b&&(a=b.h(),a instanceof Zr))return Sk(a.qx);if(null!==b&&(a=b.h(),a instanceof es))return Tk(a.Iw);if(null!==b){var c=b.h();if(c instanceof cs&&(a=c.Cc,c=c.td,Mk()===a))return""+Sk(a)+Bs(0,c)+Tk(a)}if(null!==b&&(a=b.h(),a instanceof cs))return b=a.Cc,a=a.td,""+Sk(b)+Bs(0,a)+Tk(b);if(null!==b&&(a=b.h(),a instanceof gs&&(a=a.PC,null!==a)))return"/*"+a+
+"*/";throw new w(b);}function Bs(a,b){a=b.m();a=new Ef(a,new y(c=>aba($r(),c)));return ze(a,"|","|","|")}zs.prototype.$classData=q({MW:0},!1,"mlscript.NewLexer$",{MW:1,g:1});var As;function $r(){As||(As=new zs);return As}function Cs(a,b,c,d,e){Ds(a,new U(()=>{var h=e.fn,k=Es(b);k=Fs(k)?ze(k,"(",",",")"):Gs(k)?Es(b):"("+Es(b)+")";return"@ "+h+k+"    [at l."+d.Zl+"]"}));try{a.le=1+a.le|0;var g=c.n(void 0)}finally{a.le=-1+a.le|0}Ds(a,new U(()=>"\x3d "+g));return g}
+function Hs(a){if(!a.Kz){if(!a.Kz){var b=Is(a.Lz);b.b()?b=R():(b=b.o().j(),b=new L(new Kq(b.eh,b.eh,b.dh)));a.lE=b.b()?a.kE:b;a.Kz=!0}a.Lz=null}return a.lE}function Js(a){a=a.Ol.Jg();if(a.b())return R();a=a.o();return new L(a.j())}function Ks(a,b){var c=Ye(new Te(new Ue(J(new K,["Expected an expression; found a 'then'/'else' clause instead"]))),u());b=G(new H,c,b);c=O().c;Ze(a,new z(b,c));return Ls(a)}
+function Ms(a,b){var c=Ye(new Te(new Ue(J(new K,["This quote syntax is not supported yet"]))),u());b=G(new H,c,b);c=O().c;Ze(a,new z(b,c));return Ls(a)}
+function Ns(a,b,c,d,e){var g=bba(a,O().c,d);if(b){var h=!1,k=null,l=Os(a);a:{if(l instanceof z){h=!0;k=l;var m=k.z,n=k.p;if(null!==m&&(m=m.h(),Yr()===m&&n instanceof z&&(n=n.z,null!==n&&(n=n.h(),n instanceof as&&"in"===n.Na)))){Ps(a,e,new Oe("body"));Ps(a,e,new Oe("body"));c=Qs(a,0,!0,O().c,c,d,e);break a}}if(h&&(n=k.z,null!==n&&(n=n.h(),qs()===n))){Ps(a,e,new Oe("body"));l=Rs(a,c,d);c=r=>{if(r instanceof fe)return Ks(a,r.aa.A());if(r instanceof Ud)return r.fa;throw new w(r);};if(l===u())c=u();else{d=
+l.e();e=d=new z(c(d),u());for(l=l.f();l!==u();)h=l.e(),h=new z(c(h),u()),e=e.p=h,l=l.f();c=d}t();c=new Sl(c);c=new Ud(c);break a}if(h&&(c=k.z,null!==c)){d=c.h();c=c.j();e=new Te(new Ue(J(new K,["Expected '`in'; found "," instead"])));d=[We(Xe(),d.jb())];d=Ye(e,J(new K,d));t();c=G(new H,d,new L(c));d=O().c;Ze(a,new z(c,d));t();c=Ls(a);c=new Ud(c);break a}c=O().c;if(null===c?null===l:c.i(l))c=Ye(new Te(new Ue(J(new K,["Expected '`in'; found end of input instead"]))),u()),d=Hs(a),c=G(new H,c,d),d=O().c,
+Ze(a,new z(c,d)),t(),c=Ls(a),c=new Ud(c);else throw new w(l);}}else a:{if(l=!1,h=null,k=Os(a),k instanceof z&&(l=!0,h=k,k=h.z,null!==k&&(k=k.h(),k=k instanceof as&&"in"===k.Na?!0:ds()===k?!0:!1,k))){Ps(a,e,new Oe("body"));c=Qs(a,0,!0,O().c,c,d,e);break a}if(l&&(l=h.z,null!==l&&(l=l.h(),qs()===l))){Ps(a,e,new Oe("body"));c=Qs(a,0,!0,O().c,c,d,e);break a}t();c=new Gm(!0);d=Js(a);d.b()?d=R():(d=d.o(),d=new L(vs(d)));c=Cq(c,d);c=new Ud(c)}for(g=Km(g);!g.b();){d=g.e();c=G(new H,d,c);a:{l=c.y;e=c.w;if(null!==
+l&&(d=l.h(),l=l.j(),e instanceof Ud&&(e=e.fa,b))){t();c=new em(new Rl(!1,d,new fm(l),new fm(e)));c=new Ud(c);break a}l=c.y;e=c.w;if(null!==l&&(d=l.h(),l=l.j(),e instanceof Ud)){c=e.fa;t();c=new Rl(!1,d,l,c);c=new Ud(c);break a}d=c.w;if(null!==c.y&&d instanceof fe&&(d=d.aa,b)){t();c=Ms(a,d.A());c=new Ud(c);break a}l=c.y;e=c.w;if(null!==l&&(d=l.h(),l=l.j(),e instanceof fe)){c=e.aa;t();c=new Ss(!1,d,l,c);c=new fe(c);break a}throw new w(c);}g=g.f()}return c}
+function Ts(a,b){for(b=Km(b);!b.b();){var c=b.e();a=new Ml(c,a);b=b.f()}return a}function Ls(a){var b=new Gm(!0);a=Hs(a);return Cq(b,a)}var dba=function cba(a,b){var d=Os(a);return d instanceof z&&(d=d.z,null!==d&&(d=d.h(),Xr()===d))?(Ps(a,new Ne(382),new Oe("otherParents")),d=Us(a,Vs().ao.n(hc(44))|0,b,new Ne(383)),a=cba(a,b),new z(d,a)):O().c};
+function Ws(a,b){for(var c=O().c;;){var d=!1,e=null,g=Me(a,new Ne(579),new Oe("rec"));if(g instanceof z&&(d=!0,e=g,g=e.z,null!==g&&(g=g.h(),Se()===g))){Ps(a,new Ne(581),new Oe("rec"));continue}if(d&&(g=e.z,null!==g&&(g=g.h(),qs()===g&&b))){Ps(a,new Ne(584),new Oe("rec"));continue}if(d&&(g=e.z,d=e.p,null!==g)){var h=g.h();e=g.j();if(h instanceof bs&&(g=h,h=g.ke,"@"===g.ae&&!0===h)){Ps(a,new Ne(587),new Oe("rec"));a:{if(d instanceof z&&(g=d.z,null!==g&&(h=g.h(),g=g.j(),h instanceof bs))){var k=h.ae;
+if(!1===h.ke){d=k;e=g;break a}}d=d.Jg();d.b()?(d="end of input",h=Hs(a)):(g=d.o(),t(),t(),d=g.h().jb(),h=g=it().n(g.j()));g=d;d=h;h=new Te(new Ue(J(new K,["Expected an identifier; found "," instead"])));g=[We(Xe(),g)];g=Ye(h,J(new K,g));d=G(new H,g,d);g=O().c;Ze(a,new z(d,g));d="\x3cerror\x3e"}Ps(a,new Ne(595),new Oe("rec"));d=new vl(d);t();e=Cq(d,new L(e));c=new z(e,c);continue}}return Km(c)}}
+var fba=function eba(a){var c=Os(a);if(c instanceof z){var d=c.z;if(null!==d&&(c=d.h(),d=d.j(),c instanceof bs)){var e=c.ae;if(!1===c.ke){Ps(a,new Ne(832),new Oe("getIdents"));c=new jt((t(),new Ud(e)),t().d);t();c=Cq(c,new L(d));d=Os(a);if(d instanceof z&&(d=d.z,null!==d&&(d=d.h(),Xr()===d)))return Ps(a,new Ne(836),new Oe("getIdents")),a=eba(a),new z(c,a);a=O().c;return new z(c,a)}}}return O().c};
+function kt(a,b,c){if(a.b())return G(new H,b,c);c instanceof fe&&no();if(c instanceof Ud){var d=c.fa;if(null!==d)return c=d.yb,d=d.ya,t(),a=new sm(c,new Sl(Km(new z(d,a)))),G(new H,b,new Ud(a))}throw new w(c);}function lt(a,b,c,d,e,g,h,k){a.mE=b;a.Lz=c;a.hx=d;a.Fu=e;a.Eu=g;a.kE=h;a.jE=k;a.fx=0;a.le=0;a.Ol=c;a.gx=mt(a).KH}function nt(){this.Lz=this.mE=this.dx=this.lE=this.ex=null;this.hx=!1;this.Fu=null;this.Eu=!1;this.jE=this.kE=null;this.le=this.fx=0;this.gx=this.Ol=null;this.Kz=!1}
+nt.prototype=new p;nt.prototype.constructor=nt;function ot(){}ot.prototype=nt.prototype;function pt(a){null===a.ex&&null===a.ex&&(a.ex=new qt(a));return a.ex}function mt(a){null===a.dx&&null===a.dx&&(a.dx=new rt(a));return a.dx}function gba(a){var b=new vl("_$"+a.fx);a.fx=1+a.fx|0;return b}function st(a,b,c){tt(Vs(),c)||a.Fu.n(Es(b))}function Ze(a,b){tt(Vs(),!1)||a.Fu.n(kr(jr(),b,!0,ws()))}function Ds(a,b){a.nQ(new U(()=>""+ut(Q(),"\u2502 ",a.le)+Es(b)))}
+function vt(a,b){var c=b.n(a);for(b=Me(a,new Ne(147),new Oe("concludeWith"));;){if(b.b())d=!1;else if(d=b.e(),Pe(new E(d.h()),Se())||Pe(new E(d.h()),qs())){Ps(a,new Ne(147),new Oe("concludeWith"));var d=!0}else d=!1;if(d)b=b.f();else break}var e=b;a:{if(e instanceof z&&(d=e.z,null!==d)){b=d.h();for(d=d.j();;){if(e.b())g=!1;else{g=e.e().h();var g=Pe(new E(g),Se())}if(g)e=e.f();else break}e=e.Jg();b=e.b()?G(new H,b,d):e.o();if(null===b)throw new w(b);d=b.h();b=b.j();e=new Te(new Ue(J(new K,["Unexpected ",
+" here"])));d=[We(Xe(),d.jb())];d=Ye(e,J(new K,d));t();b=G(new H,d,new L(b));d=O().c;Ze(a,new z(b,d));break a}b=O().c;if(null===b?null!==e:!b.i(e))throw new w(e);}Ds(a,new U(()=>"Concluded with "+c));return c}function wt(a,b){a.Ol=b;a.gx=mt(a).KH}function Me(a,b,c){for(a.Eu&&Ds(a,new U(()=>{var d="? "+c.fn+"\t\tinspects ";var e=Bs($r(),xt(a.Ol,5))+(0<a.Ol.ab(5)?"...":"");return d+e+"    [at l."+b.Zl+"]"}));;)if(a.Ol.b()?0:a.Ol.e().h()instanceof gs)Ps(a,b,c);else break;return a.Ol}
+function Ps(a,b,c){a.Eu&&Ds(a,new U(()=>"! "+c.fn+"\t\tconsumes "+Bs($r(),xt(a.Ol,1))+"    [at l."+b.Zl+"]"));var d=hba(new yt(a.Ol));wt(a,d.b()?O().c:d.o())}
+function zt(a,b,c,d,e,g){var h=tc();try{var k=new U(()=>new tl(b,c,d)),l=new Ne(188),m=new Oe("skip");Ds(a,new U(()=>{var ia=m.fn,X=Es(k);X=Fs(X)?ze(X,"(",",",")"):Gs(X)?Es(k):"("+Es(k)+")";return"@ "+ia+X+"    [at l."+l.Zl+"]"}));try{a.le=1+a.le|0;At(tp(),!c.L(b));var n=Me(a,new Ne(190),new Oe("skip_res"));a:{if(n instanceof z){var r=n.z;if(null!==r){var v=r.h(),x=r.j();if(c.L(v))throw Ps(a,new Ne(193),new Oe("skip_res")),Hq(new Iq,h,zt(a,b,c,d,e,g));if(Nm(new E(v),b)){if(!tt(Vs(),g)){var A=new Te(new Ue(J(new K,
+["Expected ","; found "," instead"]))),B=[We(Xe(),b.jb()),We(Xe(),v.jb())],C=Ye(A,J(new K,B));t();var D=G(new H,C,new L(x)),F=Es(e);Ze(a,new z(D,F))}var I=G(new H,!1,(t(),new L(x)))}else I=G(new H,!0,(t(),new L(x)));break a}}var M=O().c;if(null===M?null===n:M.i(n)){if(!d&&!tt(Vs(),g)){var N=new Te(new Ue(J(new K,["Expected ","; found end of input instead"]))),P=[We(Xe(),b.jb())],T=Ye(N,J(new K,P)),Y=Hs(a),Z=G(new H,T,Y),S=Es(e);Ze(a,new z(Z,S))}I=G(new H,d,t().d)}else throw new w(n);}Ps(a,new Ne(206),
+new Oe("skip"));var ea=I}finally{a.le=-1+a.le|0}Ds(a,new U(()=>"\x3d "+ea));return ea}catch(ia){if(ia instanceof Iq){a=ia;if(a.Qg===h)return a.Cj();throw a;}throw ia;}}function Bt(){tp();var a=[Se()];a=J(new K,a);return Aq(0,a)}
+function Le(a){var b=Rs(a,!1,!1),c=h=>{var k=!1,l=null;if(h instanceof fe)return l=h.aa,k=Ye(new Te(new Ue(J(new K,["Unexpected 'then'/'else' clause"]))),u()),l=l.A(),k=G(new H,k,l),l=O().c,Ze(a,new z(k,l)),Ls(a);if(h instanceof Ud&&(k=!0,l=h,h=l.fa,h instanceof Ct)||k&&(h=l.fa,h instanceof Pm))return h;if(k&&(k=l.fa,k instanceof Po))return k;no()};if(b===u())c=u();else{var d=b.e(),e=d=new z(c(d),u());for(b=b.f();b!==u();){var g=b.e();g=new z(c(g),u());e=e.p=g;b=b.f()}c=d}return new Dt(c)}
+function Et(a){var b=Os(a);if(b instanceof z&&(b=b.z,null!==b)){var c=b.h();if(c instanceof cs){var d=c.Cc;b=c.td;if(Mk()===d){Ps(a,new Ne(243),new Oe("typingUnitMaybeIndented"));t();d=new L(c.Mf);c=c.jb();a=new Ft(a,b,d,c);var e=Le(a);for(b=Me(a,new Ne(147),new Oe("concludeWith"));;)if(b.b()?c=!1:(c=b.e(),Pe(new E(c.h()),Se())||Pe(new E(c.h()),qs())?(Ps(a,new Ne(147),new Oe("concludeWith")),c=!0):c=!1),c)b=b.f();else break;d=b;a:{if(d instanceof z&&(c=d.z,null!==c)){b=c.h();for(c=c.j();;){if(d.b())g=
+!1;else{g=d.e().h();var g=Pe(new E(g),Se())}if(g)d=d.f();else break}d=d.Jg();b=d.b()?G(new H,b,c):d.o();if(null===b)throw new w(b);c=b.h();b=b.j();d=new Te(new Ue(J(new K,["Unexpected "," here"])));c=[We(Xe(),c.jb())];c=Ye(d,J(new K,c));t();b=G(new H,c,new L(b));c=O().c;Ze(a,new z(b,c));break a}b=O().c;if(null===b?null!==d:!b.i(d))throw new w(d);}Ds(a,new U(()=>"Concluded with "+e));return e}}}return Le(a)}
+function Gt(a){var b=Os(a);if(b instanceof z&&(b=b.z,null!==b)){var c=b.h();b=b.j();if(c instanceof cs){var d=c.Cc,e=c.td;if(Jk()===d){Ps(a,new Ne(249),new Oe("curlyTypingUnit"));t();t();d=new L(c.Mf);c=c.jb();a=new Ft(a,e,d,c);var g=Et(a);for(c=Me(a,new Ne(147),new Oe("concludeWith"));;)if(c.b()?e=!1:(e=c.e(),Pe(new E(e.h()),Se())||Pe(new E(e.h()),qs())?(Ps(a,new Ne(147),new Oe("concludeWith")),e=!0):e=!1),e)c=c.f();else break;d=c;a:{if(d instanceof z&&(e=d.z,null!==e)){c=e.h();for(e=e.j();;){if(d.b())h=
+!1;else{h=d.e().h();var h=Pe(new E(h),Se())}if(h)d=d.f();else break}d=d.Jg();c=d.b()?G(new H,c,e):d.o();if(null===c)throw new w(c);e=c.h();c=c.j();d=new Te(new Ue(J(new K,["Unexpected "," here"])));e=[We(Xe(),e.jb())];e=Ye(d,J(new K,e));t();c=G(new H,e,new L(c));e=O().c;Ze(a,new z(c,e));break a}c=O().c;if(null===c?null!==d:!c.i(d))throw new w(d);}Ds(a,new U(()=>"Concluded with "+g));t();b=Cq(g,new L(b));return new L(b)}}}return t().d}function Ht(a,b,c){return It(a,Us(a,0,b,c))}
+function Rs(a,b,c){for(;;){var d=Ws(a,!0),e=!1,g=null,h=Me(a,new Ne(312),new Oe("block")),k=O().c;if(null===k?null===h:k.i(h))return O().c;if(h instanceof z){e=!0;g=h;var l=g.z;if(null!==l){var m=l.h();if(qs()===m){Ps(a,new Ne(314),new Oe("block"));continue}}}if(e){var n=g.z;if(null!==n){var r=n.h();if(Se()===r){Ps(a,new Ne(315),new Oe("block"));continue}}}if(e){var v=g.z;if(null!==v){var x=v.h(),A=v.j();if(x instanceof as&&"constructor"===x.Na){Ps(a,new Ne(317),new Oe("block"));var B=Os(a);a:{if(B instanceof
+z){var C=B.z;if(null!==C){var D=C.h(),F=C.j();if(D instanceof cs){var I=D,M=I.Cc,N=I.td;if(Ik()===M){Ps(a,new Ne(320),new Oe("res"));t();var P=new L(I.Mf),T=I.jb(),Y=vt(new Ft(a,N,P,T),new y(((Yd,bf)=>rf=>Jt(rf,Yd,bf))(c,b))),Z=Gt(a),S=new U(()=>new Dt(O().c)),ea=Z.b()?Es(S):Z.o(),ia=new Gl(Y);t();var X=Cq(ia,new L(F)),sa=new Sl(ef(ea)),Ja=ea.A();var Xa=new Po(X,Cq(sa,Ja));break a}}}}var Fa=Ye(new Te(new Ue(J(new K,["Expect parameter list for the constructor"]))),u());t();var za=G(new H,Fa,new L(A)),
+Qa=O().c;Ze(a,new z(za,Qa));Xa=new Po(new Gl(O().c),new Sl(O().c))}t();t();var Ma=Kt(A,Dq(Xa)),Ga=Cq(Xa,new L(Ma)),ab=new Ud(Ga),Hb=Rs(a,b,c);return new z(ab,Hb)}}}a:{if(null!==h){var bc=mt(a).HC(h);if(!bc.b()){var yb=bc.k.h(),tb=bc.k.j();if(tb instanceof z){var eb=tb.z;if(null!==eb){var kb=eb.h(),Rb=eb.j();if(kb instanceof as){var Gb=kb.Na;if("class"===Gb||"infce"===Gb||"trait"===Gb||"mixin"===Gb||"type"===Gb||"module"===Gb){Ps(a,new Ne(332),new Oe("t"));var vb=Lt(yb,"declare");if(null!==vb)var Tb=
+G(new H,vb.h(),vb.j());else throw new w(vb);var Nb=Tb.h(),ic=Lt(Tb.j(),"abstract");if(null!==ic)var Va=G(new H,ic.h(),ic.j());else throw new w(ic);var cb=Va.h();Mt(Va.j());switch(Gb){case "class":var zb=Bp();break;case "trait":zb=Fp();break;case "mixin":zb=cp();break;case "type":zb=Ap();break;case "module":zb=zp();break;default:xm("Program reached and unexpected state.")}var Ub=Os(a);b:{if(Ub instanceof z){var jb=Ub.z;if(null!==jb){var db=jb.h(),ub=jb.j();if(db instanceof bs){var Aa=db.ae;Ps(a,new Ne(346),
+new Oe("x$19"));var va=new Ep(Aa);t();var Ra=G(new H,Cq(va,new L(ub)),!0);break b}}}var rb=Ub.Jg(),xb=new U(()=>G(new H,"end of input",Hs(a))),mc=new y(Yd=>{t();t();Yd=G(new H,(new y(bf=>bf.jb())).n(Yd.h()),Yd.j());return G(new H,Yd.y,it().n(Yd.w))}),Ha=rb.b()?Es(xb):mc.n(rb.o());if(null!==Ha)var Ka=G(new H,Ha.h(),Ha.j());else throw new w(Ha);var Oa=Ka.h(),Na=Ka.j(),Da=new Te(new Ue(J(new K,["Expected a type name; found "," instead"]))),ta=[We(Xe(),Oa)],Ya=Ye(Da,J(new K,ta)),dc=G(new H,Ya,Na),ka=
+O().c;Ze(a,new z(dc,ka));Ps(a,new Ne(352),new Oe("x$19"));var ya=new Ep("\x3cerror\x3e"),Sa=Js(a),xc=new y(Yd=>vs(Yd)),Sb=Sa.b()?R():new L(xc.n(Sa.o()));Ra=G(new H,Cq(ya,Sb),!1)}if(null!==Ra)var uc=G(new H,Ra.h(),Ra.cy());else throw new w(Ra);var Lb=uc.h(),lc=Os(a);b:{if(lc instanceof z){var Xb=lc.z;if(null!==Xb){var ec=Xb.h();if(ec instanceof cs){var Ab=ec,Ob=Ab.Cc,fb=Ab.td;if(Lk()===Ob||Kk()===Ob){Ps(a,new Ne(358),new Oe("tparams"));t();var Wa=new L(Ab.Mf),bb=Ab.jb();var Ia=vt(new Ft(a,fb,Wa,bb),
+new y(((Yd,bf)=>rf=>iba(rf,new fn(Cg=>Nt(Cg,Yd,bf))))(c,b)));break b}}}}Ia=O().c}var Ua=Os(a);b:{if(Ua instanceof z){var pc=Ua.z;if(null!==pc){var sc=pc.h(),Ba=pc.j();if(sc instanceof cs){var ob=sc,nc=ob.Cc,Ib=ob.td;if(Ik()===nc){Ps(a,new Ne(375),new Oe("params"));t();var vc=new L(ob.Mf),Vb=ob.jb(),fc=vt(new Ft(a,Ib,vc,Vb),new y(((Yd,bf)=>rf=>Jt(rf,Yd,bf))(c,b)));t();var Bc=new Gl(fc);t();var Pb=Cq(Bc,new L(Ba));var Jb=new L(Pb);break b}}}}Jb=t().d}var gc=!1,Cb=null,cc=Os(a);b:{if(cc instanceof z){gc=
+!0;Cb=cc;var yc=Cb.z;if(null!==yc){var Mc=yc.h();if(Mc instanceof as&&"\x3d"===Mc.Na&&Ot(new E(zb),Ap())){Ps(a,new Ne(388),new Oe("sigTrm"));t();var qc=Us(a,0,c,new Ne(389));var oc=new L(qc);break b}}}if(gc){var Qc=Cb.z;if(null!==Qc){var jc=Qc.h();if(jc instanceof as&&":"===jc.Na&&!Ot(new E(zb),Ap())){Ps(a,new Ne(391),new Oe("sigTrm"));t();var sb=Us(a,0,c,new Ne(392));oc=new L(sb);break b}}}oc=t().d}var Gc=Os(a);b:{if(Gc instanceof z){var Wb=Gc.z;if(null!==Wb){var Cc=Wb.h();if(Cc instanceof as&&"extends"===
+Cc.Na){Ps(a,new Ne(400),new Oe("ps"));var Fc=Us(a,Vs().ao.n(hc(44))|0,c,new Ne(401)),qd=dba(a,c);var Yb=new z(Fc,qd);break b}}}Yb=O().c}var Nc=Gt(a),ad=new U(((Yd,bf)=>()=>{var rf=Is(Yd);if(rf instanceof L){var Cg=rf.k;if(Cg instanceof cm){rf=Cg.Ys;Cg=Cg.Zs;var nj=Km(Yd).f();return new tl(bf,Km(new z(rf,nj)),Cg)}}return bf instanceof L&&(Cg=bf.k,Cg instanceof cm)?(rf=Cg.Ys,Cg=Cg.Zs,new tl((t(),new L(rf)),Yd,Cg)):new tl(bf,Yd,new Dt(O().c))})(Yb,oc)),Uc=new y(((Yd,bf)=>rf=>new tl(Yd,bf,rf))(oc,Yb)),
+cd=Nc.b()?Es(ad):Uc.n(Nc.o());if(null!==cd)var kc=new tl(cd.kc,cd.hb,cd.Rd);else throw new w(cd);var Vc=kc.kc,Hc=kc.hb,rc=kc.Rd,sd=new y(Yd=>It(a,Yd)),Kc=Vc.b()?R():new L(sd.n(Vc.o())),Qd=ef(rc),Ad=Pt(Qd,new y(Yd=>{if(Yd instanceof Po)return t(),new fe(Yd);t();return new Ud(Yd)}));if(null!==Ad)var kd=G(new H,Ad.h(),Ad.j());else throw new w(Ad);var Hd=kd.h(),Rd=new Dt(kd.j()),Bd=rc.A(),ae=Cq(Rd,Bd);if(0<Hd.ab(1)){var dd=Ye(new Te(new Ue(J(new K,["A class may have at most one explicit constructor"]))),
+u());t();var od=G(new H,dd,new L(Rb)),Ta=O().c;Ze(a,new z(od,Ta));t()}var wb=Hd.Jg(),$a=new yo(zb,Lb,Ia,Jb,wb,Kc,Hc,t().d,t().d,ae,Nb,cb,d);t();t();var wa=Kt(Kt(Rb,Dq(Lb)),Dq($a));Cq($a,new L(wa));t();t();var hb=Kt(Rb,Dq($a)),ra=Cq($a,new L(hb));var wc=new Ud(ra);break a}}}}}}if(null!==h){var ac=mt(a).HC(h);if(!ac.b()){var Id=ac.k.h(),ud=ac.k.j();if(ud instanceof z){var be=ud.z;if(null!==be){var re=be.h(),pe=be.j();if(re instanceof as){var bd=re.Na;if("fun"===bd||"val"===bd||"let"===bd){Ps(a,new Ne(432),
+new Oe("t"));var Rc=Lt(Id,"declare");if(null!==Rc)var Wc=G(new H,Rc.h(),Rc.j());else throw new w(Rc);var Wd=Wc.h(),zd=Lt(Wc.j(),"virtual");if(null!==zd)var Pa=G(new H,zd.h(),zd.j());else throw new w(zd);var Db=Pa.h(),Oc=Lt(Pa.j(),"mut");if(null!==Oc)var Tc=G(new H,Oc.h(),Oc.j());else throw new w(Oc);var Sd=Tc.h();Mt(Tc.j());var Jc=Nm(new E(bd),"let"),vd=Os(a);b:{if(vd instanceof z){var hd=vd.z;if(null!==hd){var de=hd.h();if(de instanceof as&&"rec"===de.Na&&"let"===bd){Ps(a,new Ne(440),new Oe("isLetRec"));
+t();var ye=new L(!0);break b}}}ye="fun"===bd?t().d:(t(),new L(!1))}var jf=Os(a);b:{if(jf instanceof z){var af=jf.z;if(null!==af){var pf=af.h(),kf=af.j();if(pf instanceof cs){var Be=pf,Kd=Be.Cc,ld=Be.td;if(Ik()===Kd){var Jd=!1,Dd=null;if(ld instanceof z){Jd=!0;Dd=ld;var Xd=Dd.z,Yc=Dd.p;if(null!==Xd){var Ce=Xd.h(),te=Xd.j();if(Ce instanceof bs){var Ie=Ce,Jf=Ie.ae;if(!0===Ie.ke){Ps(a,new Ne(448),new Oe("opStr"));var df=jba(Yc,new y(Yd=>Pe(new E(Yd.h()),Se())));c:{var vg=O().c;if(null===vg?null!==df:
+!vg.i(df)){if(df instanceof z){var wg=df.z;if(null!==wg){var xg=wg.h(),eg=wg.j(),vh=new Te(new Ue(J(new K,["Unexpected "," after symbolic name"]))),fg=[We(Xe(),xg.jb())],ih=Ye(vh,J(new K,fg));t();var Ig=G(new H,ih,new L(eg)),Tf=O().c;Ze(a,new z(Ig,Tf));break c}}throw new w(df);}}t();var Jg=new vl(Jf);t();var jh=Cq(Jg,new L(te));var yg=new L(jh);break b}}}}if(Jd){var gg=Dd.z;if(null!==gg){var Cf=gg.h(),Uf=gg.j();Ps(a,new Ne(456),new Oe("opStr"));var $g=new Te(new Ue(J(new K,["Expected a symbolic name, found ",
+" instead"]))),Ah=[We(Xe(),Cf.jb())],Kg=Ye($g,J(new K,Ah));t();var Vf=G(new H,Kg,new L(Uf)),hg=O().c;Ze(a,new z(Vf,hg));yg=t().d;break b}}var zg=O().c;if(null===zg?null===ld:zg.i(ld)){Ps(a,new Ne(460),new Oe("opStr"));var Lg=Ye(new Te(new Ue(J(new K,["Expected a symbolic name between brackets, found nothing"]))),u());t();var Mg=G(new H,Lg,new L(kf)),Wf=O().c;Ze(a,new z(Mg,Wf));yg=t().d;break b}throw new w(ld);}}}}yg=t().d}var Ng=Os(a);b:{if(Ng instanceof z){var Kf=Ng.z;if(null!==Kf){var xf=Kf.h(),
+Og=Kf.j();if(xf instanceof bs){var mi=xf,Ci=mi.ae;if(!1===mi.ke){Ps(a,new Ne(468),new Oe("x$34"));var Xh=new vl(Ci);t();var wh=G(new H,Cq(Xh,new L(Og)),!0);break b}}}}var Bh=Ng.Jg(),ng=new U(()=>G(new H,"end of input",Hs(a))),kh=new y(Yd=>{t();t();Yd=G(new H,(new y(bf=>bf.jb())).n(Yd.h()),Yd.j());return G(new H,Yd.y,it().n(Yd.w))}),Kh=Bh.b()?Es(ng):kh.n(Bh.o());if(null!==Kh)var ni=G(new H,Kh.h(),Kh.j());else throw new w(Kh);var Lh=ni.h(),lh=ni.j(),Ch=new Te(new Ue(J(new K,["Expected a function name; found ",
+" instead"]))),Dh=[We(Xe(),Lh)],Yh=Ye(Ch,J(new K,Dh)),ah=G(new H,Yh,lh),oi=O().c;Ze(a,new z(ah,oi));Ps(a,new Ne(473),new Oe("x$34"));var mj=new vl("\x3cerror\x3e"),wd=Js(a),ge=new y(Yd=>vs(Yd)),De=wd.b()?R():new L(ge.n(wd.o()));wh=G(new H,Cq(mj,De),!1)}if(null!==wh)var qf=G(new H,wh.h(),wh.cy());else throw new w(wh);var og=qf.h(),Xf=qf.cy(),mh=tt(Vs(),c)||!Xf;wc=(new y(((Yd,bf,rf,Cg,nj,Jh,If,Hg,He,lj)=>Wi=>{var Oj=!!Wi;if("let"===Yd){t();var mo=u(),mm=Pd(u(),mo)}else{var nm=Os(a);a:{if(nm instanceof
+z){var dq=nm.z;if(null!==dq){var Zd=dq.h();if(Zd instanceof cs){var sf=Zd.Cc,oj=Zd.td;if(Lk()===sf||Kk()===sf){Ps(a,new Ne(480),new Oe("tparams"));t();var al=new L(Zd.Mf),Ll=Zd.jb();mm=Qt(vt(new Ft(a,oj,al,Ll),new y(Ca=>Jt(Ca,Oj,Oj))),new y(Ca=>{if(null!==Ca){var Lc=Ca.h();Ca=Ca.j();if(t().d===Lc&&null!==Ca&&(Lc=Ca.yb,Ca=Ca.ya,null!==Lc)){var yd=Lc.ch;if(!1===Lc.je&&!1===yd&&Ca instanceof vl)return Lc=new Ep(Ca.x),Ca=Ca.A(),Cq(Lc,Ca)}}no()}));break a}}}}mm=O().c}}var Qm=Os(a);a:{if(Qm instanceof z){var Rm=
+Qm.z,hq=Qm.p;if(null!==Rm){var Bn=Rm.h(),hp=Rm.j();if(Bn instanceof cs){var ru=Bn.Cc,qr=Bn.td;if(Ik()===ru&&null!==qr){var Xs=pt(a).HC(qr);if(!Xs.b()){var rr=Xs.k.j();if(rr instanceof z){var iq=rr.z,qo=rr.p;if(null!==iq){var qm=iq.h(),jq=iq.j();if(qm instanceof as&&"override"===qm.Na){var pl=new cs(Ik(),qo,Bn.Mf),ro=G(new H,pl,hp);wt(a,new z(ro,hq));var Cn=Rt(a,Oj,Oj,new Ne(492));if(Cn instanceof z){var ip=Cn.z,so=Cn.p;if(null!==ip){var Dn=ip.Ra;if(Dn instanceof z){var sr=Dn.z,kq=Dn.p;if(null!==sr){var ql=
+new L(sr);if(!ql.b()){var Ys=ql.k.h(),Sm=ql.k.j();if(t().d===Ys&&null!==Sm){var Nl=Sm.yb,jp=Sm.ya;if(null!==Nl){var lq=Nl.ch,mq=Nl.Bh;if(!1===Nl.je)if(!1===lq){var Tm=O().c;if(null===Tm?null===kq:Tm.i(kq))var En=O().c,to=null===En?null===so:En.i(so);else to=!1}else to=!1;else to=!1;if(to){var Fn=gba(a),nq=t().d,Um=new sm(new St(!1,!1,mq),Fn),kp=G(new H,nq,Um),oq=O().c,su=new Gl(new z(kp,oq)),Gn=O().c,ur=new z(su,Gn);t();var In=G(new H,ur,new L(new y(Ca=>{Ca=new Tt(Fn,new vl("is"),new Ut(jp,Ca));t();
+var Lc=new am;t();Lc=new Ql(Cq(Lc,new L(jq)),bf);var yd=t().d,Qe=new sm(new St(!1,!1,mq),Fn);yd=G(new H,yd,Qe);Qe=O().c;Lc=new Pl(Lc,new Gl(new z(yd,Qe)));return new Xl(Ca,new L(Lc))})));break a}}}}}}}}var Zs=Ye(new Te(new Ue(J(new K,["Unsupported 'override' parameter list shape"]))),u());t();var $s=G(new H,Zs,new L(Bn.Mf)),pq=O().c;Ze(a,new z($s,pq));In=G(new H,Cn,t().d);break a}}}}}}}}In=G(new H,Rt(a,Oj,Oj,new Ne(505)),t().d)}if(null!==In)var vr=G(new H,In.h(),In.j());else throw new w(In);var Vm=
+vr.h(),Jn=vr.j(),wr=Os(a);a:{if(wr instanceof z){var at=wr.z;if(null!==at){var xr=at.h();if(xr instanceof as&&":"===xr.Na){Ps(a,new Ne(509),new Oe("asc"));t();var lp=Ht(a,Oj,new Ne(511));var Kn=new L(lp);break a}}}Kn=t().d}var qq=Os(a);if(qq instanceof z){var yr=qq.z;if(null!==yr){var rq=yr.h();if(rq instanceof as&&"\x3d"===rq.Na){Ps(a,new Ne(516),new Oe("t"));var sq=Us(a,0,Oj,new Ne(517)),bt=new U(()=>sq),tq=new y(Ca=>Ca.n(sq)),zr=Jn.b()?Es(bt):tq.n(Jn.o()),ct=new U(()=>zr),Ar=new y(Ca=>new Cl(zr,
+Ca)),uq=Kn.b()?Es(ct):Ar.n(Kn.o()),Br=Os(a);if(Br instanceof z){var Ln=Br.z;if(null!==Ln){var vq=Ln.h(),Cr=Ln.j();if(vq instanceof as&&"in"===vq.Na&&"let"===Yd){Ps(a,new Ne(522),new Oe("t"));if(!mm.b()){var tu=Ye(new Te(new Ue(J(new K,["Unsupported type parameters on 'let' binding"]))),u());t();var uu=G(new H,tu,new L(Cr)),dt=O().c;Ze(a,new z(uu,dt))}var vu=Us(a,0,Oj,new Ne(524));t();var Dr=new U(()=>{xm("Program reached and unexpected state.")}),uo=new Rl(!(rf.b()?!Es(Dr):!rf.o()),bf,sq,vu);t();
+var Er=Kt(Cg,uq.A()),et=Cq(uo,new L(Er));return new Ud(et)}}}t();t();var ft=Vm.mf(uq,new fn((Ca,Lc)=>new Ol(Ca,Lc))),gt=new Zn(rf,bf,nj,mm,new fe(ft),Jh,If,Hg,t().d,t().d,He,lj);t();var Wm=Kt(Cg,uq.A()),Fr=Cq(gt,new L(Wm));return new Ud(Fr)}}}if(Kn instanceof L){var mp=Kn.k;Jn.b()||xm("Program reached and unexpected state.");t();t();var wu=new Vt(O().c,Vm.mf(mp,new fn((Ca,Lc)=>{Ca=Qn(Ca);if(Ca instanceof fe){var yd=Ca.aa;st(a,new U(()=>yd),Oj);Ca=gl()}else if(Ca instanceof Ud)Ca=Ca.fa;else throw new w(Ca);
+return new Wt(Ca,Lc)}))),ht=new Zn(rf,bf,nj,mm,new Ud(wu),Jh,If,Hg,t().d,t().d,He,lj);t();var wq=Kt(Cg,mp.A()),xq=Cq(ht,new L(wq));return new Ud(xq)}if(t().d===Kn){var Gr=qq.Jg(),xu=new U(()=>G(new H,"end of input",Hs(a))),yu=new y(Ca=>{t();t();Ca=G(new H,(new y(Lc=>Lc.jb())).n(Ca.h()),Ca.j());return G(new H,Ca.y,it().n(Ca.w))}),Re=Gr.b()?Es(xu):yu.n(Gr.o());if(null!==Re)var rj=G(new H,Re.h(),Re.j());else throw new w(Re);var ai=rj.h(),rm=rj.j(),Nn=new Te(new Ue(J(new K,["Expected ':' or '\x3d' followed by a function body or signature; found ",
+" instead"]))),zu=[We(Xe(),ai)],Au=Ye(Nn,J(new K,zu)),Av=G(new H,Au,rm),oy=O().c;Ze(a,new z(Av,oy));Ps(a,new Ne(545),new Oe("t"));var Bv=Ls(a);t();var Cv=O().c;t();var py=Vm.mf(Bv,new fn((Ca,Lc)=>new Ol(Ca,Lc))),qy=new Zn(rf,bf,nj,Cv,new fe(py),Jh,If,Hg,t().d,t().d,He,lj);t();var Dv=Kt(Cg,Bv.A()),Ee=Cq(qy,new L(Dv));return new Ud(Ee)}throw new w(Kn);})(bd,og,ye,pe,yg,Wd,Db,Sd,Jc,d))).n(mh);break a}}}}}}wc=Qs(a,0,!1,d,b,c,new Ne(554))}var Ag=Os(a);a:{if(Ag instanceof z){var Bg=Ag.z;if(null!==Bg){var Eh=
+Bg.h();if(Eh instanceof as&&"\x3d"===Eh.Na){var Pg=!1,Di=null;if(wc instanceof Ud){Pg=!0;Di=wc;var Mh=Di.fa;if(Mh instanceof vl){var pi=Mh;Ps(a,new Ne(559),new Oe("finalTerm"));t();var Xi=new bm(pi,Us(a,0,c,new Ne(560)));var Qg=new Ud(Xi);break a}}if(Pg){var nh=Di.fa;if(nh instanceof Pl){var bh=nh,Mj=bh.Za,Nj=bh.Qb;if(Mj instanceof vl){var ie=Mj;Ps(a,new Ne(562),new Oe("finalTerm"));t();var Ac=new bm(ie,new Ol(Nj,Us(a,0,c,new Ne(563))));Qg=new Ud(Ac);break a}}}Qg=wc;break a}}}Qg=wc}var Ve=!1,Td=null,
+lf=Os(a);if(lf instanceof z){Ve=!0;Td=lf;var Yi=Td.z;if(null!==Yi){var Jl=Yi.h();if(ds()===Jl){Ps(a,new Ne(570),new Oe("block"));var ll=Rs(a,b,c);return new z(Qg,ll)}}}if(Ve){var Bj=Td.z;if(null!==Bj){var $k=Bj.h();if(qs()===$k){Ps(a,new Ne(571),new Oe("block"));var Zh=Rs(a,b,c);return new z(Qg,Zh)}}}var Ei=O().c;return new z(Qg,Ei)}}
+function Os(a){for(var b=Me(a,new Ne(606),new Oe("yeetSpaces"));;){if(b.b())c=!1;else if(c=b.e(),Pe(new E(c.h()),Se())||c.h()instanceof gs){Ps(a,new Ne(609),new Oe("yeetSpaces"));var c=!0}else c=!1;if(c)b=b.f();else break}return b}
+function Rt(a,b,c,d){var e=new U(()=>{}),g=new Oe("funParams");Ds(a,new U(()=>{var db=g.fn,ub=Es(e);ub=Fs(ub)?ze(ub,"(",",",")"):Gs(ub)?Es(e):"("+Es(e)+")";return"@ "+db+ub+"    [at l."+d.Zl+"]"}));try{a.le=1+a.le|0;var h=!1,k=null,l=Os(a);a:{if(l instanceof z){h=!0;k=l;var m=k.z;if(null!==m){var n=m.h();if(n instanceof as){var r=n.Na;if("\x3d"===r||":"===r){var v=O().c;break a}}}}if(h){var x=k.z;if(null!==x){var A=x.h();if(A instanceof as&&"of"===A.Na){Ps(a,new Ne(615),new Oe("funParams"));var B=
+new Gl(Xt(a,!1,Vs().Du,c,b)),C=Rt(a,b,c,new Ne(617));v=new z(B,C);break a}}}if(h){var D=k.z;if(null!==D){var F=D.h(),I=D.j();if(F instanceof cs){var M=F.Cc,N=F.td;if(Ik()===M){Ps(a,new Ne(619),new Oe("funParams"));t();for(var P=new L(F.Mf),T=F.jb(),Y=new Ft(a,N,P,T),Z=Jt(Y,c,b),S=Me(Y,new Ne(147),new Oe("concludeWith"));;){if(S.b())ia=!1;else{var ea=S.e();if(Pe(new E(ea.h()),Se())||Pe(new E(ea.h()),qs())){Ps(Y,new Ne(147),new Oe("concludeWith"));var ia=!0}else ia=!1}if(ia)S=S.f();else break}h=S;b:{if(h instanceof
+z){var X=h.z;if(null!==X){var sa=X.h(),Ja=X.j();for(X=h;;){if(X.b())Fa=!1;else var Xa=X.e().h(),Fa=Pe(new E(Xa),Se());if(Fa)X=X.f();else break}var za=X.Jg(),Qa=za.b()?G(new H,sa,Ja):za.o();if(null===Qa)throw new w(Qa);var Ma=Qa.h(),Ga=Qa.j(),ab=new Te(new Ue(J(new K,["Unexpected "," here"]))),Hb=[We(Xe(),Ma.jb())],bc=Ye(ab,J(new K,Hb));t();var yb=G(new H,bc,new L(Ga)),tb=O().c;Ze(Y,new z(yb,tb));break b}}var eb=O().c;if(null===eb?null!==h:!eb.i(h))throw new w(h);}Ds(Y,new U(()=>"Concluded with "+
+Z));var kb=new Gl(Z);t();var Rb=Cq(kb,new L(I)),Gb=Rt(a,b,c,new Ne(621));v=new z(Rb,Gb);break a}}}}if(h){var vb=k.z;if(null!==vb){var Tb=vb.h(),Nb=vb.j(),ic=new Te(new Ue(J(new K,["Expected function parameter list; found "," instead"]))),Va=[We(Xe(),Tb.jb())],cb=Ye(ic,J(new K,Va));t();var zb=G(new H,cb,new L(Nb)),Ub=O().c;Ze(a,new z(zb,Ub));Ps(a,new Ne(626),new Oe("funParams"));v=O().c;break a}}var jb=O().c;if(null===jb?null===l:jb.i(l))v=O().c;else throw new w(l);}}finally{a.le=-1+a.le|0}Ds(a,new U(()=>
+"\x3d "+v));return v}function Us(a,b,c,d){var e=new U(()=>new Yt(b,!0)),g=new Oe("expr");Ds(a,new U(()=>{var m=g.fn,n=Es(e);n=Fs(n)?ze(n,"(",",",")"):Gs(n)?Es(e):"("+Es(e)+")";return"@ "+m+n+"    [at l."+d.Zl+"]"}));try{a.le=1+a.le|0;var h=O().c,k=Qs(a,b,!0,h,!1,c,new Ne(643));if(k instanceof Ud)var l=k.fa;else if(k instanceof fe)l=Ks(a,k.aa.A());else throw new w(k);}finally{a.le=-1+a.le|0}Ds(a,new U(()=>"\x3d "+l));return l}
+function Zt(a,b,c,d){var e=Os(a);if(e instanceof z&&(e=e.z,null!==e&&(e=e.h(),qs()===e))){Ps(a,d,new Oe("exprOrBlockContinuation"));e=Rs(a,b,c);b=h=>{if(h instanceof fe)return Ks(a,h.aa.A());if(h instanceof Ud)return h.fa;throw new w(h);};if(e===u())b=u();else{c=e.e();d=c=new z(b(c),u());for(e=e.f();e!==u();){var g=e.e();g=new z(b(g),u());d=d.p=g;e=e.f()}b=c}return new Sl(b)}return Us(a,0,c,d)}
+function Qs(a,b,c,d,e,g,h){var k=tc();try{return Cs(a,new U(()=>new Yt(b,c)),new y(()=>{var l=Ws(a,!1);l.b()||Os(a);var m=un(d,l),n=!1,r=null,v=Me(a,new Ne(710),new Oe("res"));a:{if(v instanceof z){n=!0;r=v;var x=r.z;if(null!==x){var A=x.h();if(Se()===A&&c){Ps(a,new Ne(712),new Oe("res"));var B=Qs(a,b,c,O().c,e,g,new Ne(713));break a}}}if(n){var C=r.z;if(null!==C){var D=C.h();if(D instanceof cs){var F=D.Cc,I=D.td;if(Mk()===F){var M=I.Jg();b:{if(M instanceof L){var N=M.k;if(null!==N){var P=N.h();if(P instanceof
+as){var T=P.Na;if("then"===T||"else"===T){var Y=!1;break b}}}}Y=!0}}else Y=!1;if(Y){Ps(a,new Ne(718),new Oe("res"));t();var Z=new L(D.Mf),S=D.jb(),ea=vt(new Ft(a,I,Z,S),new y(Ee=>Rs(Ee,e,g))),ia=Qt(ea,new y(Ee=>{if(Ee instanceof fe)throw t(),Ee=new $t(ea),Hq(new Iq,k,new fe(Ee));if(Ee instanceof Ud)return Ee.fa;throw new w(Ee);}));t();var X=new Sl(ia);B=new Ud(X);break a}}}}if(n){var sa=r.z;if(null!==sa){var Ja=sa.h(),Xa=sa.j();if(Yr()===Ja){Ps(a,new Ne(723),new Oe("res"));var Fa=!1,za=null,Qa=Me(a,
+new Ne(724),new Oe("res"));if(Qa instanceof z){Fa=!0;za=Qa;var Ma=za.z;if(null!==Ma){var Ga=Ma.h(),ab=Ma.j();if(Ga instanceof bs){var Hb=Ga.ae;if(!1===Ga.ke){Ps(a,new Ne(726),new Oe("res"));var bc=new em(new vl(Hb));t();var yb=xs(Xa,ab);B=au(a,Cq(bc,new L(yb)),b,!1,e,g,new Ne(727));break a}}}}if(Fa){var tb=za.z;if(null!==tb){var eb=tb.h(),kb=tb.j();if(eb instanceof fs){var Rb=eb.Cu;Ps(a,new Ne(729),new Oe("res"));t();var Gb=new em(Cq(Rb,new L(kb)));t();var vb=xs(Xa,kb);B=au(a,Cq(Gb,new L(vb)),b,!1,
+e,g,new Ne(730));break a}}}if(Fa){var Tb=za.z;if(null!==Tb){var Nb=Tb.h(),ic=Tb.j();if(Nb instanceof as&&"let"===Nb.Na){Ps(a,new Ne(732),new Oe("res"));var Va=Ns(a,!0,e,g,new Ne(733));if(Va instanceof Ud){var cb=Va.fa;t();t();var zb=Kt(Xa,cb.A()),Ub=Cq(cb,new L(zb));B=new Ud(Ub)}else{t();var jb=Ms(a,(t(),new L(ic)));B=new Ud(jb)}break a}}}if(Fa){var db=za.z;if(null!==db){var ub=db.h(),Aa=db.j();if(ub instanceof as&&"if"===ub.Na){var va=Qs(a,b,c,O().c,e,g,new Ne(738));if(va instanceof Ud){var Ra=va.fa;
+if(Ra instanceof Xl){var rb=Ra.bp,xb=Ra.zs;if(rb instanceof Ut){var mc=rb.Km,Ha=rb.Lm;t();var Ka=new Ut(new fm(mc),new fm(Ha)),Oa=new y(Ee=>new fm(Ee)),Na=new em(new Xl(Ka,xb.b()?R():new L(Oa.n(xb.o()))));t();var Da=Kt(Xa,Ra.A()),ta=Cq(Na,new L(Da));B=new Ud(ta);break a}}}t();var Ya=Ms(a,(t(),new L(Aa)));B=new Ud(Ya);break a}}}if(Fa){var dc=za.z;if(null!==dc){var ka=dc.h(),ya=dc.j();if(ka instanceof cs){var Sa=ka.Cc,xc=ka.td;if(Ik()===Sa){Ps(a,new Ne(745),new Oe("res"));t();var Sb=new L(ka.Mf),uc=
+ka.jb(),Lb=vt(new Ft(a,xc,Sb,uc),new y(Ee=>Jt(Ee,g,e)));b:{if(Lb instanceof z){var lc=Lb.z,Xb=Lb.p;if(null!==lc){var ec=lc.h(),Ab=lc.j();if(t().d===ec&&null!==Ab){var Ob=Ab.yb,fb=Ab.ya;if(null!==Ob){var Wa=Ob.ch;if(!1===Ob.je)if(!1===Wa)var bb=O().c,Ia=null===bb?null===Xb:bb.i(Xb);else Ia=!1;else Ia=!1;if(Ia){var Ua=new em(new Fl(!1,fb));t();var pc=Kt(ya,fb.A());var sc=Cq(Ua,new L(pc));break b}}}}}sc=Ms(a,(t(),new L(ya)))}B=au(a,sc,b,!1,e,g,new Ne(750));break a}}}}t();var Ba=Ms(a,(t(),new L(Xa)));
+B=new Ud(Ba);break a}}}if(n){var ob=r.z;if(null!==ob){var nc=ob.h(),Ib=ob.j();if(nc instanceof fs){var vc=nc.Cu;Ps(a,new Ne(754),new Oe("res"));t();B=au(a,Cq(vc,new L(Ib)),b,!1,e,g,new Ne(755));break a}}}if(n){var Vb=r.z;if(null!==Vb){var fc=Vb.h(),Bc=Vb.j();if(fc instanceof as){var Pb=fc.Na;if("undefined"===Pb||"null"===Pb){Ps(a,new Ne(757),new Oe("res"));var Jb=new Gm("undefined"===Pb);t();B=au(a,Cq(Jb,new L(Bc)),b,!1,e,g,new Ne(758));break a}}}}if(n){var gc=r.z;if(null!==gc){var Cb=gc.h(),cc=gc.j();
+if(Cb instanceof bs){var yc=Cb.ae;if(!1===Cb.ke){Ps(a,new Ne(760),new Oe("res"));var Mc=new vl(yc);t();B=au(a,Cq(Mc,new L(cc)),b,!1,e,g,new Ne(761));break a}}}}if(n){var qc=r.z;if(null!==qc){var oc=qc.h(),Qc=qc.j();if(oc instanceof cs){var jc=oc.Cc,sb=oc.td;if(Nk()===jc||Ok()===jc){Ps(a,new Ne(763),new Oe("res"));t();var Gc=new L(oc.Mf),Wb=oc.jb(),Cc=vt(new Ft(a,sb,Gc,Wb),new y(Ee=>Us(Ee,0,g,new Ne(764)))),Fc=new em(Cc);t();B=au(a,Cq(Fc,new L(Qc)),b,!1,e,g,new Ne(765));break a}}}}if(n){var qd=r.z;
+if(null!==qd){var Yb=qd.h(),Nc=qd.j();if(Yb instanceof cs){var ad=Yb.Cc,Uc=Yb.td;if(Pk()===ad){Ps(a,new Ne(767),new Oe("res"));t();var cd=new L(Yb.Mf),kc=Yb.jb(),Vc=vt(new Ft(a,Uc,cd,kc),new y(Ee=>Us(Ee,0,g,new Ne(768)))),Hc=new fm(Vc);t();B=au(a,Cq(Hc,new L(Nc)),b,!1,e,g,new Ne(769));break a}}}}if(n){var rc=r.z;if(null!==rc){var sd=rc.h(),Kc=rc.j();if(sd instanceof as&&"super"===sd.Na){Ps(a,new Ne(771),new Oe("res"));var Qd=new am;t();B=au(a,Cq(Qd,new L(Kc)),b,!1,e,g,new Ne(772));break a}}}if(n){var Ad=
+r.z;if(null!==Ad){var kd=Ad.h(),Hd=Ad.j();if(kd instanceof bs&&"~"===kd.ae){Ps(a,new Ne(774),new Oe("res"));var Rd=Us(a,b,g,new Ne(775)),Bd=new vl("~");t();var ae=new Pl(Cq(Bd,new L(Hd)),Rd);t();var dd=Kt(Hd,Rd.A());B=au(a,Cq(ae,new L(dd)),b,!1,e,g,new Ne(776));break a}}}if(n){var od=r.z;if(null!==od){var Ta=od.h();if(Ta instanceof cs){var wb=Ta.Cc,$a=Ta.td;if(Ik()===wb&&$a instanceof z){var wa=$a.z,hb=$a.p;if(null!==wa){var ra=wa.h(),wc=wa.j();if(ra instanceof bs){var ac=ra.ae;if(!0===ra.ke)var Id=
+O().c,ud=null===Id?null===hb:Id.i(hb);else ud=!1;if(ud){Ps(a,new Ne(778),new Oe("res"));var be=new vl(ac);t();B=au(a,Cq(be,new L(wc)),b,!1,e,g,new Ne(779));break a}}}}}}}if(n){var re=r.z;if(null!==re){var pe=re.h(),bd=re.j();if(pe instanceof cs){var Rc=pe.Cc,Wc=pe.td;if(Ik()===Rc||Kk()===Rc||Jk()===Rc){Ps(a,new Ne(781),new Oe("res"));t();var Wd=new L(pe.Mf),zd=pe.jb(),Pa=vt(new Ft(a,Wc,Wd,zd),new y(Ee=>Jt(Ee,g,e))),Db=G(new H,Rc,Pa);b:{var Oc=Db.y;if(Jk()===Oc)var Tc=new Fl(!0,new yl(Qt(Pa,new y(Ee=>
+{if(null!==Ee){var Ca=new L(Ee);if(!Ca.b()){var Lc=Ca.k.h();Ca=Ca.k.j();if(Lc instanceof L)return G(new H,Lc.k,Ca)}}if(null!==Ee&&(Ca=new L(Ee),!Ca.b()&&(Lc=Ca.k.h(),Ca=Ca.k.j(),t().d===Lc&&null!==Ca&&(Lc=Ca.ya,Lc instanceof vl))))return G(new H,Lc,Ca);if(null!==Ee&&(Lc=new L(Ee),!Lc.b()&&(Ca=Lc.k.h(),Lc=Lc.k.j(),t().d===Ca)))return Ee=Ye(new Te(new Ue(J(new K,["Record field should have a name"]))),u()),Ca=Lc.ya.A(),Ee=G(new H,Ee,Ca),Ca=O().c,Ze(a,new z(Ee,Ca)),Ee=new vl("\x3cerror\x3e"),G(new H,
+Ee,Lc);throw new w(Ee);}))));else{var Sd=Db.y,Jc=Db.w;if(Ik()===Sd&&Jc instanceof z){var vd=Jc.z,hd=Jc.p;if(null!==vd){var de=vd.h(),ye=vd.j();if(t().d===de&&null!==ye){var jf=ye.yb,af=ye.ya;if(null!==jf){var pf=jf.ch;if(!1===jf.je)if(!1===pf)var kf=O().c,Be=null===kf?null===hd:kf.i(hd);else Be=!1;else Be=!1;if(Be){Tc=new Fl(!1,af);break b}}}}}var Kd=Db.y;if(Ik()===Kd){var ld=!1,Jd=null,Dd=Os(a);if(Dd instanceof z){ld=!0;Jd=Dd;var Xd=Jd.z;if(null!==Xd){var Yc=Xd.h();if(Yc instanceof as&&"\x3d\x3e"===
+Yc.Na){Ps(a,new Ne(798),new Oe("bra"));var Ce=Us(a,bu("\x3d\x3e").Sc(),g,new Ne(799));Tc=new Ol(new Gl(Pa),Ce);break b}}}if(ld){var te=Jd.z,Ie=Jd.p;if(null!==te){var Jf=te.h();if(Yr()===Jf&&Ie instanceof z){var df=Ie.z;if(null!==df){var vg=df.h();if(vg instanceof as&&"\x3d\x3e"===vg.Na){var wg=au(a,new Gl(Pa),0,!0,e,g,new Ne(802));if(wg instanceof fe){Tc=Ms(a,wg.aa.A());break b}else if(wg instanceof Ud){Tc=wg.fa;break b}else throw new w(wg);}}}}}if(ld){var xg=Jd.z;if(null!==xg){var eg=xg.h();if(eg instanceof
+bs){var vh=eg.ke;if("-\x3e"===eg.ae&&!0===vh){Ps(a,new Ne(807),new Oe("bra"));var fg=Us(a,bu("-\x3e").Sc(),g,new Ne(808));Tc=new Ol(new Gl(Pa),fg);break b}}}}var ih=O().c;if(null===ih?null===Pa:ih.i(Pa))Tc=new Gm(!0);else{var Ig=Qt(Pa,new y(Ee=>{if(null!==Ee){var Ca=new L(Ee);if(!Ca.b()){var Lc=Ca.k.h();Ca=Ca.k.j();if(t().d===Lc&&null!==Ca){Lc=Ca.yb;Ca=Ca.ya;var yd=tm().Cg;if(null===yd?null===Lc:yd.i(Lc))return Ca}}}if(null!==Ee&&(Ca=new L(Ee),!Ca.b()&&(Lc=Ca.k.h(),Ca=Ca.k.j(),null!==Ca)))return Ee=
+Ca.ya,Ca=Ye(new Te(new Ue(J(new K,["Illegal position for field specification"]))),u()),cu(),Lc=Lc.ha(),Lc=du(0,Xq(Lc,Ee)),Lc=G(new H,Ca,Lc),Ca=O().c,Ze(a,new z(Lc,Ca)),Ee;throw new w(Ee);}));Tc=kba(Ig,new fn((Ee,Ca)=>{var Lc=new vl(",");cu();var yd=O().c;yd=du(0,new z(Ee,new z(Ca,yd)));Lc=Cq(Lc,yd);eu();return new Pl(Lc,fu(0,J(new K,[Ee,Ca])))}))}}else Tc=new Gl(Pa)}}t();B=au(a,Cq(Tc,new L(bd)),b,!1,e,g,new Ne(827));break a}}}}if(n){var Tf=r.z;if(null!==Tf){var Jg=Tf.h();if(Jg instanceof as&&"forall"===
+Jg.Na){Ps(a,new Ne(829),new Oe("res"));var jh=fba(a),yg=Me(a,new Ne(843),new Oe("rest"));b:{if(yg instanceof z){var gg=yg.z;if(null!==gg){var Cf=gg.h();if(Cf instanceof as&&":"===Cf.Na){Ps(a,new Ne(845),new Oe("rest"));var Uf=Us(a,0,g,new Ne(846));break b}}}var $g=Ye(new Te(new Ue(J(new K,["Expected `:` after `forall` section"]))),u()),Ah=Js(a),Kg=new U(()=>Hs(a)),Vf=Ah.b()?Es(Kg):Ah,hg=G(new H,$g,Vf),zg=O().c;Ze(a,new z(hg,zg));Uf=Ls(a)}t();var Lg=new Zl(jh,Uf);B=new Ud(Lg);break a}}}if(n){var Mg=
+r.z;if(null!==Mg){var Wf=Mg.h(),Ng=Mg.j();if(Wf instanceof as&&"while"===Wf.Na){Ps(a,new Ne(853),new Oe("res"));var Kf=Us(a,0,g,new Ne(854)),xf=zt(a,new as("do"),Bt(),!1,new U(()=>O().c),g);if(null===xf)throw new w(xf);var Og=Us(a,0,g,new Ne(856)),mi=new dm(Kf,Og);t();var Ci=Kt(Ng,Og.A());B=au(a,Cq(mi,new L(Ci)),b,!1,e,g,new Ne(857));break a}}}if(n){var Xh=r.z;if(null!==Xh){var wh=Xh.h(),Bh=Xh.j();if(wh instanceof as&&"set"===wh.Na){Ps(a,new Ne(859),new Oe("res"));var ng=Us(a,0,g,new Ne(860)),kh=
+zt(a,new as("\x3d"),Bt(),!1,new U(()=>O().c),g);if(null!==kh)var Kh=kh.Rc();else throw new w(kh);var ni=tt(Vs(),g)||!Kh,Lh=Us(a,0,ni,new Ne(862)),lh=new Wl(ng,Lh);t();var Ch=Kt(Bh,Lh.A());B=au(a,Cq(lh,new L(Ch)),b,!1,e,g,new Ne(863));break a}}}if(n){var Dh=r.z;if(null!==Dh){var Yh=Dh.h();if(Yh instanceof as&&"let"===Yh.Na){Ps(a,new Ne(865),new Oe("res"));B=Ns(a,!1,e,g,new Ne(866));break a}}}if(n){var ah=r.z;if(null!==ah){var oi=ah.h(),mj=ah.j();if(oi instanceof as&&"new"===oi.Na){Ps(a,new Ne(868),
+new Oe("res"));var wd=Us(a,Vs().ao.n(hc(46))|0,g,new Ne(869)),ge=new Yl(wd);t();var De=Kt(mj,wd.A());B=au(a,Cq(ge,new L(De)),b,!1,e,g,new Ne(870));break a}}}if(n){var qf=r.z;if(null!==qf){var og=qf.h(),Xf=qf.j();if(og instanceof as&&"else"===og.Na){Ps(a,new Ne(872),new Oe("res"));var mh=Os(a);if(mh instanceof z){var Ag=mh.z;if(null!==Ag){var Bg=Ag.h();qs()===Bg&&(Ps(a,new Ne(875),new Oe("res")),no())}}var Eh=Us(a,0,g,new Ne(878));t();var Pg=new gu(Eh);t();var Di=Kt(Xf,Eh.A()),Mh=Cq(Pg,new L(Di));
+B=new fe(Mh);break a}}}if(n){var pi=r.z;if(null!==pi){var Xi=pi.h(),Qg=pi.j();if(Xi instanceof as&&"case"===Xi.Na){Ps(a,new Ne(882),new Oe("res"));var nh=O().c,bh=Qs(a,0,!0,nh,!0,g,new Ne(883));if(bh instanceof fe){var Mj=bh.aa;t();eu();var Nj=[new vl("case$scrut")],ie=new Ol(fu(0,J(new K,Nj)),new Xl(new Tt(new vl("case$scrut"),new vl("is"),Mj),t().d));B=new Ud(ie);break a}else if(bh instanceof Ud){var Ac=bh.fa,Ve=new Te(new Ue(J(new K,["Expected 'then'/'else' clause after 'case'; found "," instead"]))),
+Td=[We(Xe(),hu(Ac))],lf=Ye(Ve,J(new K,Td)),Yi=Ac.A(),Jl=G(new H,lf,Yi),ll=Ye(new Te(new Ue(J(new K,["Note: 'case' expression starts here:"]))),u());t();var Bj=G(new H,ll,new L(Qg)),$k=O().c;Ze(a,new z(Jl,new z(Bj,$k)));t();eu();var Zh=[new vl("case$scrut")],Ei=new Ol(fu(0,J(new K,Zh)),new Xl(new gu(Ac),t().d));B=new Ud(Ei);break a}else throw new w(bh);}}}if(n){var Yd=r.z;if(null!==Yd){var bf=Yd.h(),rf=Yd.j();if(bf instanceof as&&"if"===bf.Na){Ps(a,new Ne(893),new Oe("res"));var Cg=O().c,nj=Qs(a,0,
+!0,Cg,!0,g,new Ne(894));if(nj instanceof fe){var Jh=nj.aa,If=!1,Hg=null,He=Os(a);b:{if(He instanceof z){If=!0;Hg=He;var lj=Hg.z;if(null!==lj){var Wi=lj.h();if(Wi instanceof as&&"else"===Wi.Na){Ps(a,new Ne(898),new Oe("els"));t();var Oj=Zt(a,e,g,new Ne(899));var mo=new L(Oj);break b}}}if(If){var mm=Hg.z,nm=Hg.p;if(null!==mm){var dq=mm.h();if(qs()===dq&&nm instanceof z){var Zd=nm.z;if(null!==Zd){var sf=Zd.h();if(sf instanceof as&&"else"===sf.Na){Ps(a,new Ne(901),new Oe("els"));Ps(a,new Ne(902),new Oe("els"));
+t();var oj=Us(a,0,g,new Ne(903));mo=new L(oj);break b}}}}}if(If){var al=Hg.z;if(null!==al){var Ll=al.h();if(Ll instanceof cs){var Qm=Ll.Cc,Rm=Ll.td;if(Mk()===Qm&&Rm instanceof z){var hq=Rm.z,Bn=Rm.p;if(null!==hq){var hp=hq.h();if(hp instanceof as&&"else"===hp.Na){Ps(a,new Ne(905),new Oe("els"));t();var ru=new L(Ll.Mf),qr=Ll.jb(),Xs=new Ft(a,Bn,ru,qr);t();var rr=vt(Xs,new y(Ee=>Us(Ee,0,g,new Ne(907))));mo=new L(rr);break b}}}}}}mo=t().d}t();var iq=new Xl(Jh,mo);B=new Ud(iq);break a}else if(nj instanceof
+Ud){var qo=nj.fa,qm=Os(a);if(qm instanceof z){var jq=qm.z;if(null!==jq){var pl=jq.h();if(pl instanceof cs){var ro=pl.Cc,Cn=pl.td;if(Mk()===ro&&Cn instanceof z){var ip=Cn.z,so=Cn.p;if(null!==ip){var Dn=ip.h();if(Dn instanceof as&&"then"===Dn.Na){Ps(a,new Ne(914),new Oe("res"));t();var sr=new L(pl.Mf),kq=pl.jb(),ql=new Ft(a,so,sr,kq),Ys=Us(ql,0,g,new Ne(916)),Sm=!1,Nl=null,jp=Os(ql);b:{if(jp instanceof z){Sm=!0;Nl=jp;var lq=Nl.z;if(null!==lq){var mq=lq.h();if(mq instanceof as&&"else"===mq.Na){Ps(ql,
+new Ne(919),new Oe("els"));t();var Tm=vt(ql,new y(Ee=>Us(Ee,0,g,new Ne(920))));var En=new L(Tm);break b}}}if(Sm){var to=Nl.z,Fn=Nl.p;if(null!==to){var nq=to.h();if(qs()===nq&&Fn instanceof z){var Um=Fn.z;if(null!==Um){var kp=Um.h();if(kp instanceof as&&"else"===kp.Na){Ps(ql,new Ne(922),new Oe("els"));Ps(ql,new Ne(923),new Oe("els"));t();var oq=vt(ql,new y(Ee=>Us(Ee,0,g,new Ne(925))));En=new L(oq);break b}}}}}vt(ql,new y(()=>{}));En=t().d}t();var su=new Xl(new Ut(qo,Ys),En);B=new Ud(su);break a}}}}}}b:{if(qm instanceof
+z){var Gn=qm.z;if(null!==Gn){var ur=Gn.h(),In=Gn.j(),Zs=new Te(new Ue(J(new K,[""," followed by ",""]))),$s=[We(Xe(),hu(qo)),We(Xe(),ur.jb())],pq=Ye(Zs,J(new K,$s));t();var vr=iu(ju(),qo.A()).mf(In,new fn((Ee,Ca)=>xs(Ee,Ca)));var Vm=G(new H,pq,new L(vr));break b}}var Jn=O().c;if(null===Jn?null===qm:Jn.i(qm)){var wr=new Te(new Ue(J(new K,["",""]))),at=[We(Xe(),hu(qo))];Vm=G(new H,Ye(wr,J(new K,at)),qo.A())}else throw new w(qm);}if(null!==Vm)var xr=G(new H,Vm.h(),Vm.j());else throw new w(Vm);var lp=
+xr.j(),Kn=Ye(new Te(new Ue(J(new K,["Expected 'then'/'else' clause after 'if'; found "," instead"]))),J(new K,[xr.h()])),qq=G(new H,Kn,lp),yr=Ye(new Te(new Ue(J(new K,["Note: 'if' expression starts here:"]))),u());t();var rq=G(new H,yr,new L(rf)),sq=O().c;Ze(a,new z(qq,new z(rq,sq)));t();var bt=new Xl(new Ut(qo,Ls(a)),t().d);B=new Ud(bt);break a}else throw new w(nj);}}}var tq=O().c;if(null===tq?null===v:tq.i(v)){var zr=new Te(new Ue(J(new K,["Unexpected end of ","; an expression was expected here"]))),
+ct=[We(Xe(),a.jE)],Ar=Ye(zr,J(new K,ct)),uq=Hs(a),Br=G(new H,Ar,uq),Ln=O().c;Ze(a,new z(Br,Ln));t();var vq=Ls(a);B=new Ud(vq)}else{if(n){var Cr=r.z;if(null!==Cr){var tu=Cr.h(),uu=Cr.j();if(ds()===tu){t();var dt=new Gm(!0);t();var vu=Cq(dt,new L(uu));B=new Ud(vu);break a}}}if(n){var Dr=r.z;if(null!==Dr){var uo=Dr.h(),Er=Dr.j();if(uo instanceof bs){var et=uo.ke;if("-"===uo.ae&&!0===et){Ps(a,new Ne(951),new Oe("res"));var ft=new vl("-");t();var gt=Cq(ft,new L(Er)),Wm=Us(a,bu("-").Sc(),g,new Ne(953));
+if(Wm instanceof Em){B=au(a,new Em(lba(Wm.rq)),b,!1,e,g,new Ne(955));break a}else if(null!==Wm){if(a.hx){eu();var Fr=[new Em(br()),Wm],mp=new Pl(gt,fu(0,J(new K,Fr)))}else{eu();var wu=[new Em(br())],ht=new Pl(gt,fu(0,J(new K,wu)));eu();mp=new Pl(ht,fu(0,J(new K,[Wm])))}B=au(a,mp,b,!1,e,g,new Ne(957));break a}else throw new w(Wm);}}}}if(n){var wq=r.z;if(null!==wq){var xq=wq.h(),Gr=wq.j(),xu=new Te(new Ue(J(new K,["Unexpected "," in expression position"]))),yu=[We(Xe(),xq.jb())],Re=Ye(xu,J(new K,yu));
+t();var rj=G(new H,Re,new L(Gr)),ai=O().c;Ze(a,new z(rj,ai));Ps(a,new Ne(964),new Oe("res"));var rm=O().c;B=Qs(a,b,!0,rm,e,!0,new Ne(965));break a}}throw new w(v);}}if(m.b())return B;if(B instanceof fe){var Nn=B.aa;if(Nn instanceof Ut){var zu=Nn.Km,Au=Nn.Lm;O();var Av=new Ut(Ts(zu,m),Au);return new fe(Av)}var oy=Ye(new Te(new Ue(J(new K,["Unexpected annotation"]))),u()),Bv=m.e().A(),Cv=G(new H,oy,Bv),py=O().c;Ze(a,new z(Cv,py));t();return new fe(Nn)}if(B instanceof Ud){var qy=B.fa;t();var Dv=Ts(qy,
+m);return new Ud(Dv)}throw new w(B);}),h,new Oe("exprOrIf"))}catch(l){if(l instanceof Iq){h=l;if(h.Qg===k)return h.Cj();throw h;}throw l;}}
+function au(a,b,c,d,e,g,h){return Cs(a,new U(()=>new tl(c,"`"+b+"`",d)),new y(()=>{var k=!1,l=null,m=Me(a,new Ne(990),new Oe("exprCont"));if(m instanceof z){k=!0;l=m;var n=l.z;if(null!==n){var r=n.h();if(Yr()===r){var v=!1,x=null,A=Me(a,new Ne(991),new Oe("exprCont"));if(A instanceof z){v=!0;x=A;var B=x.p;if(B instanceof z){var C=B.z;if(null!==C){var D=C.h();if(D instanceof as&&"\x3d\x3e"===D.Na&&bu("\x3d\x3e").ut()>c){Ps(a,new Ne(993),new Oe("exprCont"));Ps(a,new Ne(994),new Oe("exprCont"));var F=
+b instanceof Gl?b:fu(eu(),J(new K,[b]));return au(a,new em(new Ol(F,new fm(Us(a,1,g,new Ne(998))))),c,d,e,g,new Ne(995))}}}}if(v){var I=x.p;if(I instanceof z){var M=I.z;if(null!==M){var N=M.h(),P=M.j();if(N instanceof cs){var T=N.Cc,Y=N.td;if(Ik()===T){Ps(a,new Ne(1E3),new Oe("exprCont"));Ps(a,new Ne(1001),new Oe("exprCont"));t();var Z=new L(N.Mf),S=N.jb(),ea=Qt(vt(new Ft(a,Y,Z,S),new y(ie=>Jt(ie,g,e))),new y(ie=>{if(null!==ie){var Ac=new L(ie);if(!Ac.b()){var Ve=Ac.k.h();Ac=Ac.k.j();if(null!==Ac)return ie=
+new sm(Ac.yb,new fm(Ac.ya)),G(new H,Ve,ie)}}throw new w(ie);})),ia=new fm(b),X=new Gl(ea);t();var sa=new Pl(ia,Cq(X,new L(P)));return au(a,new em(sa),c,d,e,g,new Ne(1006))}}}}}if(v){var Ja=x.p;if(Ja instanceof z){var Xa=Ja.z;if(null!==Xa){var Fa=Xa.h(),za=Xa.j();if(Fa instanceof bs){var Qa=Fa.ae;if(!0===Fa.ke){if(bu(Qa).ut()>c){Ps(a,new Ne(1009),new Oe("exprCont"));Ps(a,new Ne(1010),new Oe("exprCont"));var Ma=new vl(Qa);t();var Ga=Cq(Ma,new L(za)),ab=Os(a);if(ab instanceof z){var Hb=ab.z;if(null!==
+Hb){var bc=Hb.h();qs()===bc&&Ps(a,new Ne(1013),new Oe("exprCont"))}}var yb=Qs(a,bu(Qa).Sc(),!0,O().c,e,g,new Ne(1016));if(yb instanceof fe){t();var tb=Ms(a,(t(),new L(za)));return new Ud(tb)}if(yb instanceof Ud){var eb=yb.fa;if("with"===Qa)var kb=Ms(a,(t(),new L(za)));else{eu();var Rb=[new fm(b),new fm(eb)];kb=new em(new Pl(Ga,fu(0,J(new K,Rb))))}return au(a,kb,c,d,e,g,new Ne(1018))}throw new w(yb);}t();return new Ud(b)}}}}}if(v){var Gb=x.p;if(Gb instanceof z){var vb=Gb.z;if(null!==vb){var Tb=vb.h();
+if(Tb instanceof as&&"in"===Tb.Na)return t(),new Ud(b)}}}Ps(a,new Ne(1028),new Oe("exprCont"));Ms(a,b.A());t();return new Ud(b)}}}if(k){var Nb=l.z;if(null!==Nb){var ic=Nb.h(),Va=Nb.j();if(Xr()===ic&&Pe(new E(c),0)){Ps(a,new Ne(1033),new Oe("exprCont"));var cb=Os(a);if(cb instanceof z){var zb=cb.z;if(null!==zb){var Ub=zb.h();qs()===Ub&&Ps(a,new Ne(1035),new Oe("exprCont"))}}var jb=Us(a,c,g,new Ne(1038));t();var db=new vl(",");t();var ub=Cq(db,new L(Va));eu();var Aa=new Pl(ub,fu(0,J(new K,[b,jb])));
+return new Ud(Aa)}}}if(k){var va=l.z,Ra=l.p;if(null!==va){var rb=va.h();if(rb instanceof as&&"\x3d\x3e"===rb.Na&&Ra instanceof z){var xb=Ra.z;if(null!==xb){var mc=xb.h();if(qs()===mc&&bu("\x3d\x3e").ut()>c){Ps(a,new Ne(1041),new Oe("exprCont"));var Ha=new Sl(ef(Le(a)));t();eu();var Ka=new Ol(fu(0,J(new K,[b])),Ha);return new Ud(Ka)}}}}}if(k){var Oa=l.z;if(null!==Oa){var Na=Oa.h();if(Na instanceof as&&"\x3d\x3e"===Na.Na&&bu("\x3d\x3e").ut()>c){Ps(a,new Ne(1045),new Oe("exprCont"));var Da=Us(a,1,g,
+new Ne(1046));eu();var ta=new Ol(fu(0,J(new K,[b])),Da);return au(a,ta,c,d,e,g,new Ne(1048))}}}if(k){var Ya=l.z,dc=l.p;if(null!==Ya){var ka=Ya.h(),ya=Ya.j();if(ka instanceof bs&&"."===ka.ae&&dc instanceof z){var Sa=dc.z;if(null!==Sa){var xc=Sa.h(),Sb=Sa.j();if(xc instanceof cs){var uc=xc.Cc,Lb=xc.td;if(Kk()===uc){Ps(a,new Ne(1050),new Oe("exprCont"));Ps(a,new Ne(1051),new Oe("exprCont"));t();var lc=new L(xc.Mf),Xb=xc.jb(),ec=vt(new Ft(a,Lb,lc,Xb),new y(ie=>Us(ie,0,g,new Ne(1053)))),Ab=new Vl(b,ec);
+t();var Ob=Kt(xs(ya,Sb),ec.A()),fb=Cq(Ab,new L(Ob));return au(a,fb,c,d,e,g,new Ne(1055))}}}}}}if(k){var Wa=l.z;if(null!==Wa){var bb=Wa.h(),Ia=Wa.j();if(bb instanceof bs){var Ua=bb.ae;if(!0===bb.ke&&bu(Ua).ut()>c){Ps(a,new Ne(1057),new Oe("exprCont"));var pc=new vl(Ua);t();var sc=Cq(pc,new L(Ia)),Ba=Os(a);if(Ba instanceof z){var ob=Ba.z;if(null!==ob){var nc=ob.h();qs()===nc&&Ps(a,new Ne(1060),new Oe("exprCont"))}}var Ib=Qs(a,bu(Ua).Sc(),!0,O().c,e,g,new Ne(1063));if(Ib instanceof fe){var vc=Ib.aa;
+t();var Vb=new Tt(b,sc,vc);return new fe(Vb)}if(Ib instanceof Ud){var fc=Ib.fa;if("with"===Ua)a:if(fc instanceof yl)var Bc=new Tl(b,fc);else{if(fc instanceof Fl){var Pb=fc.gg;if(!0===fc.bi&&Pb instanceof yl){Bc=new Tl(b,Pb);break a}}var Jb=new Te(new Ue(J(new K,["record literal expected here; found ",""]))),gc=[We(Xe(),hu(fc))],Cb=Ye(Jb,J(new K,gc)),cc=fc.A(),yc=G(new H,Cb,cc),Mc=O().c;Ze(a,new z(yc,Mc));Bc=b}else if(a.hx)eu(),Bc=new Pl(sc,fu(0,J(new K,[b,fc])));else{eu();var qc=new Pl(sc,fu(0,J(new K,
+[b])));eu();Bc=new Pl(qc,fu(0,J(new K,[fc])))}return au(a,Bc,c,d,e,g,new Ne(1067))}throw new w(Ib);}}}}if(k){var oc=l.z;if(null!==oc){var Qc=oc.h();if(Qc instanceof as&&":"===Qc.Na&&c<=(Vs().ao.n(hc(58))|0)){Ps(a,new Ne(1084),new Oe("exprCont"));t();var jc=new Cl(b,Ht(a,g,new Ne(1085)));return new Ud(jc)}}}if(k){var sb=l.z;if(null!==sb){var Gc=sb.h(),Wb=sb.j();if(Gc instanceof as&&"where"===Gc.Na&&1>=c){Ps(a,new Ne(1087),new Oe("exprCont"));var Cc=Et(a),Fc=new $l(b,ef(Cc));t();var qd=Cq(Fc,new L(Wb));
+return au(a,qd,c,!1,e,g,new Ne(1090))}}}if(k){var Yb=l.z;if(null!==Yb){var Nc=Yb.h();if(Se()===Nc)return Ps(a,new Ne(1092),new Oe("exprCont")),au(a,b,c,d,e,g,new Ne(1093))}}if(k){var ad=l.z;if(null!==ad){var Uc=ad.h(),cd=ad.j();if(Uc instanceof ss){var kc=Uc.ux;Ps(a,new Ne(1095),new Oe("exprCont"));var Vc=new vl(kc);t();return au(a,new Ql(b,Cq(Vc,new L(cd))),c,d,e,g,new Ne(1096))}}}if(k){var Hc=l.z;if(null!==Hc){var rc=Hc.h();if(rc instanceof cs){var sd=rc.Cc,Kc=rc.td;if(Mk()===sd&&Kc instanceof z){var Qd=
+Kc.z,Ad=Kc.p;if(null!==Qd){var kd=Qd.h(),Hd=Qd.j();if(kd instanceof ss){var Rd=kd.ux;if(1>=c){Ps(a,new Ne(1099),new Oe("exprCont"));t();var Bd=new L(rc.Mf),ae=rc.jb(),dd=vt(new Ft(a,Ad,Bd,ae),new y(ie=>{var Ac=new vl(Rd);t();return au(ie,new Ql(b,Cq(Ac,new L(Hd))),0,!0,e,g,new Ne(1100))}));if(d){if(dd instanceof fe){var od=dd.aa;t();return new fe(od)}if(dd instanceof Ud)return au(a,dd.fa,0,d,e,g,new Ne(1103));throw new w(dd);}return dd}}}}}}}if(k){var Ta=l.z;if(null!==Ta){var wb=Ta.h();if(wb instanceof
+cs){var $a=wb.Cc,wa=wb.td;if(Mk()===$a&&wa instanceof z){var hb=wa.z,ra=wa.p;if(null!==hb){var wc=hb.h(),ac=hb.j();if(wc instanceof bs){var Id=wc.ae;if(!0===wc.ke){Ps(a,new Ne(1107),new Oe("exprCont"));t();var ud=new L(wb.Mf),be=wb.jb();return vt(new Ft(a,ra,ud,be),new y(ie=>ku(ie,b,Id,ac,e,g,new Ne(1108))))}}}}}}}if(k){var re=l.z;if(null!==re){var pe=re.h();if(pe instanceof as&&"then"===pe.Na&&Pe(new E(c),0)){Ps(a,new Ne(1111),new Oe("exprCont"));t();var bd=new Ut(b,Zt(a,e,g,new Ne(1112)));return new fe(bd)}}}if(k){var Rc=
+l.z,Wc=l.p;if(null!==Rc){var Wd=Rc.h();if(qs()===Wd&&Wc instanceof z){var zd=Wc.z;if(null!==zd){var Pa=zd.h();if(Pa instanceof as&&"then"===Pa.Na&&Pe(new E(c),0)){Ps(a,new Ne(1114),new Oe("exprCont"));Ps(a,new Ne(1115),new Oe("exprCont"));t();var Db=new Ut(b,Zt(a,e,g,new Ne(1116)));return new fe(Db)}}}}}if(k){var Oc=l.z;if(null!==Oc){var Tc=Oc.h();if(qs()===Tc&&d)return Ps(a,new Ne(1118),new Oe("exprCont")),au(a,b,0,d,e,g,new Ne(1119))}}if(k){var Sd=l.z;if(null!==Sd){var Jc=Sd.h(),vd=Sd.j();if(Jc instanceof
+cs){var hd=Jc.Cc,de=Jc.td;if(Jk()===hd&&c<=Vs().MH){Ps(a,new Ne(1122),new Oe("exprCont"));t();var ye=new L(Jc.Mf),jf=Jc.jb(),af=vt(new Ft(a,de,ye,jf),new y(ie=>Et(ie)));t();var pf=Cq(af,new L(vd));return au(a,new cm(b,pf),c,d,e,g,new Ne(1124))}}}}if(k){var kf=l.z;if(null!==kf){var Be=kf.h();a:if(Xr()===Be)var Kd=!0;else if(ds()===Be)Kd=!0;else if(qs()===Be)Kd=!0;else{if(Be instanceof as){var ld=Be.Na;if("then"===ld||"else"===ld||"in"===ld||"\x3d"===ld||"do"===ld){Kd=!0;break a}}if(Be instanceof bs&&
+!0===Be.ke)Kd=!0;else{if(Be instanceof cs){var Jd=Be.Cc;if(Jk()===Jd){Kd=!0;break a}}Kd=!1}}if(Kd)return t(),new Ud(b)}}if(k){var Dd=l.z;if(null!==Dd){var Xd=Dd.h();if(Xd instanceof as&&"of"===Xd.Na&&1>=c){Ps(a,new Ne(1130),new Oe("exprCont"));var Yc=Jt(a,g,e),Ce=new Pl(b,new Gl(Yc));return au(a,Ce,c,d,e,g,new Ne(1133))}}}if(k){var te=l.z;if(null!==te){var Ie=te.h();if(Ie instanceof cs){var Jf=Ie.Cc,df=Ie.td;if(Mk()===Jf&&df instanceof z){var vg=df.z,wg=df.p;if(null!==vg){var xg=vg.h();if(xg instanceof
+as&&"of"===xg.Na&&1>=c){Ps(a,new Ne(1135),new Oe("exprCont"));t();var eg=new L(Ie.Mf),vh=Ie.jb(),fg=vt(new Ft(a,wg,eg,vh),new y(ie=>{var Ac=Jt(ie,g,e);return au(ie,new Pl(b,new Gl(Ac)),0,!0,e,g,new Ne(1143))}));if(fg instanceof fe){var ih=fg.aa;t();return new fe(ih)}if(fg instanceof Ud)return au(a,fg.fa,0,d,e,g,new Ne(1148));throw new w(fg);}}}}}}if(k){var Ig=l.z;if(null!==Ig){var Tf=Ig.h();if(Tf instanceof cs){var Jg=Tf.Cc,jh=Tf.td;if(Mk()===Jg&&jh instanceof z){var yg=jh.z;if(null!==yg){var gg=
+yg.h();if(gg instanceof as){var Cf=gg.Na;if("then"===Cf||"else"===Cf)return t(),new Ud(b)}}}}}}if(k){var Uf=l.z;if(null!==Uf){var $g=Uf.h();if($g instanceof cs){var Ah=$g.Cc,Kg=$g.td;if(Mk()===Ah&&Kg instanceof z){var Vf=Kg.z;if(null!==Vf){var hg=Vf.h();if(hg instanceof cs){var zg=hg.Cc;if((Ik()===zg||Kk()===zg)&&1>=c){Ps(a,new Ne(1164),new Oe("exprCont"));t();var Lg=new L($g.Mf),Mg=$g.jb(),Wf=vt(new Ft(a,Kg,Lg,Mg),new y(ie=>au(ie,b,0,!0,e,g,new Ne(1165))));if(Wf instanceof fe){var Ng=Wf.aa;t();return new fe(Ng)}if(Wf instanceof
+Ud)return au(a,Wf.fa,0,d,e,g,new Ne(1168));throw new w(Wf);}}}}}}}if(k){var Kf=l.z;if(null!==Kf){var xf=Kf.h(),Og=Kf.j();if(xf instanceof cs){var mi=xf.Cc,Ci=xf.td;if(Lk()===mi||Kk()===mi){Ps(a,new Ne(1172),new Oe("exprCont"));t();var Xh=new L(xf.Mf),wh=xf.jb(),Bh=vt(new Ft(a,Ci,Xh,wh),new y(ie=>Jt(ie,g,e))),ng=new Il(b,Qt(Bh,new y(ie=>{if(null!==ie){var Ac=ie.h();ie=ie.j();if(t().d===Ac&&null!==ie&&(Ac=ie.yb,ie=ie.ya,null!==Ac)){var Ve=Ac.ch;if(!1===Ac.je&&!1===Ve){Ac=Qn(ie);if(Ac instanceof fe){var Td=
+Ac.aa;st(a,new U(()=>Td),g);return gl()}if(Ac instanceof Ud)return Ac.fa;throw new w(Ac);}}}no()}))),kh=b.A(),Kh=new U(()=>it().n(Og)),ni=new y(ie=>{ie=xs(ie,Og);return it().n(ie)}),Lh=kh.b()?Es(Kh):ni.n(kh.o()),lh=Cq(ng,Lh);return au(a,lh,c,d,e,g,new Ne(1182))}}}}if(k){var Ch=l.z;if(null!==Ch){var Dh=Ch.h(),Yh=Ch.j();if(Dh instanceof cs){var ah=Dh.Cc,oi=Dh.td;if(Ik()===ah&&c<=Vs().MH){Ps(a,new Ne(1191),new Oe("exprCont"));t();var mj=new L(Dh.Mf),wd=Dh.jb(),ge=vt(new Ft(a,oi,mj,wd),new y(ie=>Jt(ie,
+g,e))),De=new Gl(ge);t();var qf=new Pl(b,Cq(De,new L(Yh)));return au(a,qf,c,d,e,g,new Ne(1194))}}}}if(k){var og=l.z;if(null!==og){var Xf=og.h();if(Xf instanceof as&&"of"===Xf.Na){Ps(a,new Ne(1197),new Oe("exprCont"));var mh=Jt(a,g,e),Ag=new Pl(b,new Gl(mh));return au(a,Ag,c,d,e,g,new Ne(1201))}}}if(k){var Bg=l.z.h();a:{if(Bg instanceof as){var Eh=Bg.Na;if(":"===Eh||"of"===Eh||"where"===Eh||"extends"===Eh){var Pg=!0;break a}}if(ds()===Bg)Pg=!0;else{if(Bg instanceof cs){var Di=Bg.Cc;if(Ik()===Di||Kk()===
+Di){Pg=!0;break a}}if(Bg instanceof cs){var Mh=Bg.Cc,pi=Bg.td;if(Mk()===Mh&&pi instanceof z){var Xi=pi.z;if(null!==Xi){var Qg=Xi.h();b:if(Qg instanceof as&&"of"===Qg.Na)var nh=!0;else if(ds()===Qg)nh=!0;else{if(Qg instanceof cs){var bh=Qg.Cc;if(Ik()===bh||Kk()===bh){nh=!0;break b}}nh=Qg instanceof ss?!0:!1}if(nh){Pg=!0;break a}}}}Pg=!1}}if(!Pg){var Mj=Jt(a,g,e),Nj=new Pl(b,new Gl(Mj));st(a,new U(()=>{fr();var ie=Ye(new Te(new Ue(J(new K,["Paren-less applications should use the 'of' keyword"]))),u()),
+Ac=Nj.A();ie=G(new H,ie,Ac);Ac=O().c;return hr(0,new z(ie,Ac),!0,lu())}),g);return au(a,Nj,c,d,e,g,new Ne(1217))}}t();return new Ud(b)}),h,new Oe("exprCont"))}
+function ku(a,b,c,d,e,g,h){var k=new U(()=>G(new H,"`"+b+"`",c)),l=new Oe("opBlock");Ds(a,new U(()=>{var Ma=l.fn,Ga=Es(k);Ga=Fs(Ga)?ze(Ga,"(",",",")"):Gs(Ga)?Es(k):"("+Es(k)+")";return"@ "+Ma+Ga+"    [at l."+h.Zl+"]"}));try{a.le=1+a.le|0;var m=new vl(c);t();var n=Cq(m,new L(d)),r=Qs(a,0,!0,O().c,e,g,new Ne(1225));if(r instanceof Ud){var v=r.fa;eu();var x=new Pl(n,fu(0,J(new K,[b,v]))),A=Me(a,new Ne(1230),new Oe("opBlock"));a:{if(A instanceof z){var B=A.z,C=A.p;if(null!==B){var D=B.h();if(qs()===D){Ps(a,
+new Ne(1232),new Oe("opBlock"));d=!1;m=null;if(C instanceof z){d=!0;m=C;var F=m.z;if(null!==F){var I=F.h(),M=F.j();if(I instanceof bs){var N=I.ae;if(!0===I.ke){Ps(a,new Ne(1235),new Oe("opBlock"));var P=ku(a,x,N,M,e,g,new Ne(1236));break a}}}}if(d){var T=m.z;if(null!==T){var Y=T.h(),Z=T.j(),S=new Te(new Ue(J(new K,["Unexpected "," in operator block"]))),ea=[We(Xe(),Y.jb())],ia=Ye(S,J(new K,ea));t();var X=G(new H,ia,new L(Z)),sa=O().c;Ze(a,new z(X,sa));Ps(a,new Ne(1239),new Oe("opBlock"));t();P=new Ud(x);
+break a}}var Ja=O().c;if(null===Ja?null===C:Ja.i(C)){t();P=new Ud(x);break a}throw new w(C);}}}t();P=new Ud(x)}}else if(r instanceof fe){var Xa=r.aa;t();var Fa=G(new H,n,Xa),za=O().c,Qa=new mu(b,nu(a,new z(Fa,za),e,g));P=new fe(Qa)}else throw new w(r);}finally{a.le=-1+a.le|0}Ds(a,new U(()=>"\x3d "+P));return P}
+function nu(a,b,c,d){var e=new U(()=>b),g=new Ne(1251),h=new Oe("opIfBlock");Ds(a,new U(()=>{var N=h.fn,P=Es(e);P=Fs(P)?ze(P,"(",",",")"):Gs(P)?Es(e):"("+Es(e)+")";return"@ "+N+P+"    [at l."+g.Zl+"]"}));try{a.le=1+a.le|0;var k=Me(a,new Ne(1252),new Oe("opIfBlock"));a:{if(k instanceof z){var l=k.z,m=k.p;if(null!==l){var n=l.h();if(qs()===n){Ps(a,new Ne(1254),new Oe("opIfBlock"));if(m instanceof z){var r=m.z;if(null!==r){var v=r.h(),x=r.j();if(v instanceof bs){var A=v.ae;if(!0===v.ke){Ps(a,new Ne(1257),
+new Oe("opIfBlock"));var B=Qs(a,0,!0,O().c,c,d,new Ne(1258));if(B instanceof Ud)no();else if(B instanceof fe){var C=B.aa,D=new vl(A);t();var F=Cq(D,new L(x)),I=G(new H,F,C);var M=nu(a,new z(I,b),c,d);break a}else throw new w(B);}}}}no()}}}M=Km(b)}}finally{a.le=-1+a.le|0}Ds(a,new U(()=>"\x3d "+M));return M}
+function Nt(a,b,c){var d=!1,e=null,g=Os(a);a:{if(g instanceof z){d=!0;e=g;g=e.z;var h=e.p;if(null!==g){var k=g.h();g=g.j();if(k instanceof as&&"in"===k.Na&&h instanceof z&&(k=h.z,null!==k&&(h=k.h(),k=k.j(),h instanceof as&&"out"===h.Na))){Ps(a,new Ne(1284),new Oe("vinfo"));t();d=G(new H,ou().Yl,xs(g,k));d=new L(d);break a}}}if(d&&(h=e.z,null!==h&&(g=h.h(),h=h.j(),g instanceof as&&"in"===g.Na))){Ps(a,new Ne(1287),new Oe("vinfo"));t();d=G(new H,ou().AA,h);d=new L(d);break a}if(d&&(e=e.z,null!==e&&(d=
+e.h(),e=e.j(),d instanceof as&&"out"===d.Na))){Ps(a,new Ne(1290),new Oe("vinfo"));t();d=G(new H,ou().Zu,e);d=new L(d);break a}d=t().d}e=Os(a);if(e instanceof z&&(g=e.z,null!==g&&(e=g.h(),g=g.j(),e instanceof bs&&(h=e.ae,!1===e.ke)))){Ps(a,new Ne(1296),new Oe("typeParams"));e=new Ep(h);t();e=Cq(e,new L(g));g=Os(a);if(g instanceof z&&(g=g.z,null!==g&&(g=g.h(),Xr()===g)))return Ps(a,new Ne(1300),new Oe("typeParams")),d.b()?d=R():(d=d.o(),d=new L(d.h())),d=G(new H,d,e),a=Nt(a,b,c),new z(d,a);d.b()?a=
+R():(a=d.o(),a=new L(a.h()));a=G(new H,a,e);b=O().c;return new z(a,b)}a:{if(d instanceof L&&(b=d.k,null!==b)){b=b.j();c=Ye(new Te(new Ue(J(new K,["dangling variance information"]))),u());t();b=G(new H,c,new L(b));c=O().c;Ze(a,new z(b,c));break a}if(t().d!==d)throw new w(d);}return O().c}
+function iba(a,b){var c=Me(a,new Ne(1317),new Oe("maybeIndented"));if(c instanceof z&&(c=c.z,null!==c)){var d=c.h();if(d instanceof cs){var e=d.Cc;c=d.td;if(Mk()===e)a:{if(e=c.Jg(),e instanceof L&&(e=e.k,null!==e&&(e=e.h(),e instanceof as&&(e=e.Na,"then"===e||"else"===e)))){e=!1;break a}e=!0}else e=!1;if(e){Ps(a,new Ne(1322),new Oe("maybeIndented"));t();e=new L(d.Mf);d=d.jb();a=new Ft(a,c,e,d);var g=b.ba(a,!0);for(b=Me(a,new Ne(147),new Oe("concludeWith"));;)if(b.b()?c=!1:(c=b.e(),Pe(new E(c.h()),
+Se())||Pe(new E(c.h()),qs())?(Ps(a,new Ne(147),new Oe("concludeWith")),c=!0):c=!1),c)b=b.f();else break;d=b;a:{if(d instanceof z&&(c=d.z,null!==c)){b=c.h();for(c=c.j();;)if(d.b()?e=!1:(e=d.e().h(),e=Pe(new E(e),Se())),e)d=d.f();else break;d=d.Jg();b=d.b()?G(new H,b,c):d.o();if(null===b)throw new w(b);c=b.h();b=b.j();d=new Te(new Ue(J(new K,["Unexpected "," here"])));c=[We(Xe(),c.jb())];c=Ye(d,J(new K,c));t();b=G(new H,c,new L(b));c=O().c;Ze(a,new z(b,c));break a}b=O().c;if(null===b?null!==d:!b.i(d))throw new w(d);
+}Ds(a,new U(()=>"Concluded with "+g));return g}}}return b.ba(a,!1)}
+function Jt(a,b,c){var d=Me(a,new Ne(1317),new Oe("maybeIndented"));a:{if(d instanceof z&&(d=d.z,null!==d)){var e=d.h();if(e instanceof cs){var g=e.Cc;d=e.td;if(Mk()===g)b:{if(g=d.Jg(),g instanceof L&&(g=g.k,null!==g&&(g=g.h(),g instanceof as&&(g=g.Na,"then"===g||"else"===g)))){g=!1;break b}g=!0}else g=!1;if(g){Ps(a,new Ne(1322),new Oe("maybeIndented"));t();g=new L(e.Mf);e=e.jb();a=new Ft(a,d,g,e);var h=Xt(a,!0,Vs().Du,b,c);for(b=Me(a,new Ne(147),new Oe("concludeWith"));;)if(b.b()?c=!1:(c=b.e(),Pe(new E(c.h()),
+Se())||Pe(new E(c.h()),qs())?(Ps(a,new Ne(147),new Oe("concludeWith")),c=!0):c=!1),c)b=b.f();else break;d=b;b:{if(d instanceof z&&(c=d.z,null!==c)){b=c.h();for(c=c.j();;)if(d.b()?e=!1:(e=d.e().h(),e=Pe(new E(e),Se())),e)d=d.f();else break;d=d.Jg();b=d.b()?G(new H,b,c):d.o();if(null===b)throw new w(b);c=b.h();b=b.j();d=new Te(new Ue(J(new K,["Unexpected "," here"])));c=[We(Xe(),c.jb())];c=Ye(d,J(new K,c));t();b=G(new H,c,new L(b));c=O().c;Ze(a,new z(b,c));break b}b=O().c;if(null===b?null!==d:!b.i(d))throw new w(d);
+}Ds(a,new U(()=>"Concluded with "+h));a=h;break a}}}a=Xt(a,!1,Vs().Du,b,c)}return a}
+function Xt(a,b,c,d,e){b=pu(a,O().c,O().c,b,c,d,e);for(d=c=null;b!==u();){var g=b.e();a:{if(null!==g){e=g.h();var h=g.j();if(h instanceof fe){h=h.aa;g=Ye(new Te(new Ue(J(new K,["Unexpected 'then'/'else' clause"]))),u());h=h.A();g=G(new H,g,h);h=O().c;Ze(a,new z(g,h));g=new sm(tm().Cg,Ls(a));e=G(new H,e,g);g=O().c;e=new z(e,g);break a}}if(null!==g&&(e=g.h(),h=g.j(),h instanceof Ud)){e=G(new H,e,h.fa);g=O().c;e=new z(e,g);break a}throw new w(g);}for(e=new Om(e);e.s();)g=new z(e.t(),u()),null===d?c=
+g:d.p=g,d=g;b=b.f()}return null===c?u():c}
+function pu(a,b,c,d,e,g,h){var k=new U(()=>G(new H,b,c)),l=new Ne(1360),m=new Oe("argsOrIf");Ds(a,new U(()=>{var pc=m.fn,sc=Es(k);sc=Fs(sc)?ze(sc,"(",",",")"):Gs(sc)?Es(k):"("+Es(k)+")";return"@ "+pc+sc+"    [at l."+l.Zl+"]"}));try{a.le=1+a.le|0;var n=!1,r=null,v=Me(a,new Ne(1362),new Oe("argsOrIf"));a:{var x=O().c;if(null===x?null===v:x.i(v))if(c instanceof z){var A=c.z,B=c.p,C=t().d;t();var D=new sm(tm().Cg,new Sl(Km(new z(A,B)))),F=G(new H,C,new Ud(D));var I=Km(new z(F,b));break a}else{var M=O().c;
+if(null===M?null===c:M.i(c)){I=Km(b);break a}else throw new w(c);}if(v instanceof z){n=!0;r=v;var N=r.z;if(null!==N){var P=N.h();if(Se()===P){Ps(a,new Ne(1371),new Oe("argsOrIf"));I=pu(a,b,c,d,e,g,h);break a}}}if(n){var T=r.z;if(null!==T){var Y=T.h();if(qs()===Y){up(tp(),c.b());I=Km(b);break a}}}if(n){var Z=r.z;if(null!==Z){var S=Z.h();if(S instanceof bs){var ea=S.ae;if(!0===S.ke&&Nm(new E(ea),"-")){up(tp(),c.b());I=Km(b);break a}}}}var ia=Os(a);b:{if(ia instanceof z){var X=ia.z;if(null!==X){var sa=
+X.h(),Ja=X.j();if(sa instanceof as&&"val"===sa.Na){Ps(a,new Ne(1385),new Oe("argVal"));t();var Xa=new L(Ja);break b}}}Xa=t().d}var Fa=Os(a);b:{if(Fa instanceof z){var za=Fa.z;if(null!==za){var Qa=za.h(),Ma=za.j();if(Qa instanceof as&&"mut"===Qa.Na){Ps(a,new Ne(1391),new Oe("argMut"));t();var Ga=new L(Ma);break b}}}Ga=t().d}var ab=Os(a);b:{if(ab instanceof z){var Hb=ab.z;if(null!==Hb){var bc=Hb.h(),yb=Hb.j();if(bc instanceof as&&"#"===bc.Na){Ps(a,new Ne(1397),new Oe("argSpec"));t();var tb=new L(yb);
+break b}}}tb=t().d}n=!1;r=null;var eb=Os(a);b:{if(eb instanceof z){n=!0;r=eb;var kb=r.z,Rb=r.p;if(null!==kb){var Gb=kb.h(),vb=kb.j();if(Gb instanceof bs){var Tb=Gb.ae;if(!1===Gb.ke&&Rb instanceof z){var Nb=Rb.z;if(null!==Nb){var ic=Nb.h();if(ic instanceof as&&":"===ic.Na){Ps(a,new Ne(1403),new Oe("argName"));Ps(a,new Ne(1404),new Oe("argName"));t();var Va=new vl(Tb);t();var cb=Cq(Va,new L(vb));var zb=new L(cb);break b}}}}}}if(n){var Ub=r.z,jb=r.p;if(null!==Ub){var db=Ub.h(),ub=Ub.j();if(db instanceof
+fs){var Aa=db.Cu;if(Aa instanceof Em){var va=Aa.rq;if(jb instanceof z){var Ra=jb.z;if(null!==Ra){var rb=Ra.h();if(rb instanceof as&&":"===rb.Na){Ps(a,new Ne(1407),new Oe("argName"));Ps(a,new Ne(1408),new Oe("argName"));t();var xb=new vl(va.u());t();var mc=Cq(xb,new L(ub));zb=new L(mc);break b}}}}}}}zb=t().d}var Ha=Qs(a,e,!0,O().c,h,g,new Ne(1413));if(Ha instanceof Ud)var Ka=Ha.fa,Oa=new Ud(new sm(new St(!Ga.b(),!tb.b(),!Xa.b()),Ka));else Oa=Ha;e=!1;Xa=null;var Na=Me(a,new Ne(1421),new Oe("argsOrIf"));
+if(Na instanceof z){e=!0;Xa=Na;var Da=Xa.z,ta=Xa.p;if(null!==Da){var Ya=Da.h();if(Xr()===Ya&&ta instanceof z){var dc=ta.z;if(null!==dc){var ka=dc.h();if(qs()===ka){Ps(a,new Ne(1423),new Oe("argsOrIf"));Ps(a,new Ne(1424),new Oe("argsOrIf"));var ya=kt(c,zb,Oa);I=pu(a,new z(ya,b),O().c,d,Vs().Du,g,h);break a}}}}}if(e){var Sa=Xa.z;if(null!==Sa){var xc=Sa.h();if(Xr()===xc){Ps(a,new Ne(1427),new Oe("argsOrIf"));var Sb=kt(c,zb,Oa);I=pu(a,new z(Sb,b),O().c,d,Vs().Du,g,h);break a}}}if(e){var uc=Xa.z;if(null!==
+uc){var Lb=uc.h();if(qs()===Lb&&d){Ps(a,new Ne(1430),new Oe("argsOrIf"));if(zb instanceof L){var lc=zb.k,Xb=Ye(new Te(new Ue(J(new K,["Unexpected named argument name here"]))),u()),ec=lc.A(),Ab=G(new H,Xb,ec),Ob=O().c;Ze(a,new z(Ab,Ob))}else if(t().d!==zb)throw new w(zb);zb=!1;Oa instanceof fe&&no();if(Oa instanceof Ud){zb=!0;var fb=Oa.fa;if(null!==fb){var Wa=fb.yb,bb=fb.ya;if(null!==Wa){var Ia=Wa.ch;if(!1===Wa.je&&!1===Ia){I=pu(a,b,new z(bb,c),d,Vs().Du,g,h);break a}}}}zb&&no();throw new w(Oa);}}}var Ua=
+kt(c,zb,Oa);I=Km(new z(Ua,b))}}finally{a.le=-1+a.le|0}Ds(a,new U(()=>"\x3d "+I));return I}
+function bba(a,b,c){for(;;){var d=!1,e=null,g=Me(a,new Ne(1450),new Oe("bindings"));if(g instanceof z&&(d=!0,e=g,g=e.z,null!==g&&(g=g.h(),Se()===g))){Ps(a,new Ne(1452),new Oe("bindings"));continue}if(d&&(g=e.z,null!==g&&(g=g.h(),g=qs()===g?!0:g instanceof bs&&!0===g.ke?!0:ds()===g?!0:!1,g)))return Km(b);if(d&&(d=e.z,null!==d&&(e=d.h(),d=d.j(),e instanceof bs&&(g=e.ae,!1===e.ke)))){Ps(a,new Ne(1457),new Oe("bindings"));e=zt(a,new as("\x3d"),Bt(),!1,new U(()=>O().c),c);if(null===e)throw new w(e);e=
+e.Rc();e=tt(Vs(),c)||!e;e=Us(a,0,e,new Ne(1459));g=new vl(g);t();d=Cq(g,new L(d));g=Me(a,new Ne(1466),new Oe("bindings"));if(g instanceof z&&(g=g.z,null!==g&&(g=g.h(),Xr()===g))){Ps(a,new Ne(1468),new Oe("bindings"));d=G(new H,d,e);b=new z(d,b);continue}a=G(new H,d,e);return Km(new z(a,b))}return O().c}}function It(a,b){b=Qn(b);if(b instanceof fe)return b=b.aa,tt(Vs(),!1)||a.Fu.n(b),gl();if(b instanceof Ud)return b.fa;throw new w(b);}
+function qu(){this.Du=this.xN=0;this.ao=null;this.MH=0;Bu=this;this.xN=0;this.Du=1+this.xN|0;O();var a=J(new K,";;;;;;,;\x3d;@;:;|;/ \\;^;\x26;!;\x3c \x3e;+ -;* %;;.".split(";"));a=Pd(u(),a);a=Hf(a);for(var b=null,c=null;a!==u();){var d=a.e();if(null===d)throw new w(d);var e=d.h();d=d.Sc();for(var g=e.length,h=Cu(g),k=0;k<g;){var l=e.charCodeAt(k);Pe(new E(hc(l)),hc(32))||(l=String.fromCharCode(l),h.ja=""+h.ja+l);k=1+k|0}e=g===h.K()?e:h.ja;g=e.length;h=new zc(g);for(k=0;k<g;){l=k;var m=e.charCodeAt(k);
+h.a[l]=G(new H,hc(m),1+d|0);k=1+k|0}for(d=Du(new Eu,(new Fu(h)).vn);d.s();)e=new z(d.t(),u()),null===c?b=e:c.p=e,c=e;a=a.f()}a=null===b?u():b;op();this.ao=pp(qp(),a).jM(2147483647);this.MH=-1+(this.ao.n(hc(46))|0)|0}qu.prototype=new p;qu.prototype.constructor=qu;function tt(a,b){return Pe(new E(b),!0)}
+function bu(a){var b=Vs();switch(a){case "is":return new Gu(4,4);case "and":return new Gu(3,3);case "or":return new Gu(2,2);case "\x3d\x3e":return a=b.ao.n(hc(46))|0,new Gu(a,1);case "+.":case "-.":case "*.":return new Gu(b.ao.n(hc(Hu(Q(),a)))|0,b.ao.n(hc(Hu(Q(),a)))|0);default:a:{for(var c=a.length,d=0;d<c;){var e=a.charCodeAt(d);if(Or(Pr(),e)){c=d;break a}d=1+d|0}c=-1}if(-1!==c)return new Gu(5,5);c=Iu(Q(),a);return new Gu(b.ao.n(hc(Hu(Q(),a)))|0,(b.ao.n(hc(c))|0)-(Pe(new E(hc(c)),hc(64))||Pe(new E(hc(c)),
+hc(47))||Pe(new E(hc(c)),hc(44))||Pe(new E(hc(c)),hc(58))?1:0)|0)}}qu.prototype.$classData=q({QW:0},!1,"mlscript.NewParser$",{QW:1,g:1});var Bu;function Vs(){Bu||(Bu=new qu);return Bu}function qt(a){this.LH=null;if(null===a)throw null;this.LH=a}qt.prototype=new p;qt.prototype.constructor=qt;
+qt.prototype.HC=function(a){if(a instanceof z){var b=a.z,c=a.p;if(null!==b&&(b=b.h(),Se()===b&&null!==c&&(c=pt(this.LH).HC(c),!c.b()))){var d=c.k.h();a=c.k.j();t();a=G(new H,new U(()=>{Es(d);Ps(this.LH,new Ne(96),new Oe("unapply"))}),a);return new L(a)}}t();a=G(new H,new U(()=>{}),a);return new L(a)};qt.prototype.$classData=q({UW:0},!1,"mlscript.NewParser$Spaces$",{UW:1,g:1});
+function Ju(a,b){if(a instanceof Ku){var c=a.fc,d=a.vd,e=a.be,g=a.Me;a=b?Lu(e):e;c.b()?e=!0:(e=c.o(),e instanceof Mu?(e=e.pd,Q(),e=new Ep(Nu(0,e.Dh)),e=!!g.U(e).b()):e=!0);e=e?c:R();c=new Ou(g);e.b()||(g=e.o(),e=V(g.q),a=Pu(g,a,e,!1));a=Qu(c,a,new fn((h,k)=>{var l=V(h.q);return Pu(h,k,l,!1)}));if(b){ms();if(0<=d.Q())b=d.Q(),b=new (md(Ru).Ia)(b),d.Gc(b,0,2147483647),d=b;else{b=null;b=[];for(d=d.m();d.s();)c=d.t(),b.push(null===c?null:c);d=new (md(Ru).Ia)(b)}b=Su();c=op().ga;b=Tu(d,new Uu(b,c))}else if(0<=
+d.Q())b=d.Q(),b=new (md(Ru).Ia)(b),d.Gc(b,0,2147483647);else{b=null;b=[];for(d=d.m();d.s();)c=d.t(),b.push(null===c?null:c);b=new (md(Ru).Ia)(b)}d=(h,k)=>{var l=V(h.q);return Pu(h,k,l,!1)};if(null===b)throw le();if(null!==b){c=b.a.length;for(g=0;g<c;)a=d(a,b.a[g]),g=1+g|0;d=a}else if(b instanceof Xc){c=b.a.length;for(g=0;g<c;)a=d(a,b.a[g]),g=1+g|0;d=a}else if(b instanceof ed){c=b.a.length;for(g=0;g<c;)a=d(a,b.a[g]),g=1+g|0;d=a}else if(b instanceof Zc){c=b.a.length;for(g=0;g<c;)e=b.a[g],a=d(a,new ma(e.W,
+e.Y)),g=1+g|0;d=a}else if(b instanceof $c){c=b.a.length;for(g=0;g<c;)a=d(a,b.a[g]),g=1+g|0;d=a}else if(b instanceof Ic){c=b.a.length;for(g=0;g<c;)a=d(a,hc(b.a[g])),g=1+g|0;d=a}else if(b instanceof Pc){c=b.a.length;for(g=0;g<c;)a=d(a,b.a[g]),g=1+g|0;d=a}else if(b instanceof Sc){c=b.a.length;for(g=0;g<c;)a=d(a,b.a[g]),g=1+g|0;d=a}else if(b instanceof Ec){c=b.a.length;for(g=0;g<c;)a=d(a,b.a[g]),g=1+g|0;d=a}else{if(!ph(b))throw new w(b);c=b.a.length;for(g=0;g<c;)a=d(a,b.a[g]),g=1+g|0;d=a}return d}d=Vu(a.Fa);
+if(null!==d&&d===a)return a.Fa.La;throw new w(a);}function Wu(a,b,c,d){if(null===a)throw le();if(a.Ro)return a.So;var e=Xu().X();return Yu(a,Zu(d.Nb,b,c,!0,e))}function $u(a,b,c,d){if(null===a)throw le();if(a.Ro)return a.So;b=b.ac;var e=Xu().X();return Yu(a,Zu(d,b,c,!0,e))}function av(a,b,c,d){if(null===a)throw le();if(a.Ro)return a.So;var e=Xu().X();return Yu(a,Zu(d.ac,b,c,!0,e))}
+var nba=function mba(a,b,c,d){if(b instanceof z){var g=b.z,h=b.p;if(null!==g){b=g.Nb;var k=g.ac,l=new bv,m=new bv,n=new bv,r=c.Nb,v=Xu().X();if((r=Zu(b,r,d,!0,v))&&(n.Ro?n.So:av(n,k,d,c)))return new z(c,h);if((l.Ro?l.So:Wu(l,b,d,c))&&(m.Ro?m.So:$u(m,c,d,k)))return new z(g,h);if(r&&(l.Ro?l.So:Wu(l,b,d,c)))return a=a.Fa,c=c.ac,d=V(k.q),g=new cv(a,b,Pu(k,c,d,!1),g.Mj),new z(g,h);if((m.Ro?m.So:$u(m,c,d,k))&&(n.Ro?n.So:av(n,k,d,c)))return a=a.Fa,c=c.Nb,d=V(b.q),g=new cv(a,dv(b,c,d,!1),k,g.Mj),new z(g,
+h);h=mba(a,h,c,d);return new z(g,h)}}h=O().c;if(null===h?null===b:h.i(b))return h=O().c,new z(c,h);throw new w(b);};function fv(){this.pE=null;this.Mz=!1;this.Fa=null}fv.prototype=new p;fv.prototype.constructor=fv;function gv(){}gv.prototype=fv.prototype;
+function oba(a,b){var c=G(new H,a,b),d=c.y,e=c.w;if(d instanceof Ku){var g=d.fc;b=d.vd;var h=d.be;d=d.Me;if(e instanceof Ku){c=e.vd;a=e.be;var k=e.Me;e=G(new H,g,e.fc);a:{var l=e.y;g=e.w;if(l instanceof L&&(l=l.k,g instanceof L)){e=pba(l,g.k);break a}g=e.w;if(e.y instanceof L&&t().d===g)e=-1;else if(g=e.y,l=e.w,t().d===g&&l instanceof L)e=1;else if(g=e.y,l=e.w,t().d===g&&t().d===l)e=0;else throw new w(e);}if(Nm(new E(e),0))return e;e=G(new H,sp(d),sp(k));a:{l=e.y;g=e.w;if(l instanceof L&&(l=l.k,null!==
+l&&(l=l.h(),g instanceof L&&(g=g.k,null!==g)))){e=pa(l.V,g.h().V);break a}g=e.w;if(e.y instanceof L&&t().d===g)e=1;else if(g=e.y,l=e.w,t().d===g&&l instanceof L)e=-1;else if(g=e.y,l=e.w,t().d===g&&t().d===l)e=0;else throw new w(e);}if(Nm(new E(e),0))return e;e=-hv(d,k)|0;if(Nm(new E(e),0))return e;d=c.ka();e=iv(b,d);return Nm(new E(e),0)?e:e=jv(h.Ba,a.Ba)}}b=c.y;if(Vu(a.Fa)===b)return 1;b=c.w;if(Vu(a.Fa)===b)return-1;throw new w(c);}f=fv.prototype;
+f.GC=function(){var a=this.zf(!1),b=O().c;return new z(a,b)};f.zf=function(a){return a?Ju(this,!0):this.mc()};f.mc=function(){this.Mz||this.Mz||(this.pE=Ju(this,!1),this.Mz=!0);return this.pE};
+f.ub=function(a,b){if(this instanceof Ku){var c=this.vd,d=this.be,e=this.Me,g=this.fc.m();g=new Ef(g,new y(m=>m.ub(a,b)));g=kv(g,new U(()=>{var m=c.m();return new Ef(m,new y(n=>n.ub(a,b)))})).nb(new U(()=>{lv();var m=d.Ba.m();m=mv(0,m);return new Ef(m,new y(n=>n.ub(a,b)))})).nb(new U(()=>{lv();var m=e.m();m=mv(0,m);return new Ef(m,new y(n=>n.ub(a,b)))}));if(g.s()){if(!g.s())throw nv("empty.reduceLeft");for(var h=!0,k=null;g.s();){var l=g.t();h?(k=l,h=!1):(k|=0,l|=0,k=k>l?k:l)}g=new L(k)}else g=R();
+return(g.b()?this.Fa.Gd:g.o())|0}g=Vu(this.Fa);if(null!==g&&g===this)return this.Fa.Gd;throw new w(this);};function qba(a,b,c,d,e){if(a instanceof Ku){var g=a.fc,h=a.vd,k=a.be,l=a.Me;a=a.Fa;g.b()?g=R():(g=g.o(),g=new L(g.At(b,c,d,e)));k=ov(k,b,c,d,e);l=new pv(new qv(l),new y(v=>rv(v,b,c,d,e)));var m=sv(),n=Su(),r=op().ga;return new Ku(a,g,h,k,(new tv(m,new Uu(n,r))).vc(l))}h=Vu(a.Fa);if(null!==h&&h===a)return a;throw new w(a);}
+function rba(a,b){var c=Vu(a.Fa);if(null!==c&&c===a){c=a.Fa;var d=t().d;uv();var e=Su(),g=op().ga;b=vv(b,new Uu(e,g));a=wv(xv(a.Fa));e=sv();g=Su();var h=op().ga;return new Ku(c,d,b,a,e.Hd(new Uu(g,h)))}if(a instanceof Ku)return c=a.be,d=a.Me,new Ku(a.Fa,a.fc,a.vd.bc(b),c,d);throw new w(a);}
+function yv(a,b,c,d,e){var g=G(new H,a,b),h=g.y,k=g.w;if(Vu(a.Fa)===h&&k instanceof zv){t();var l=a.Fa;t();var m=new L(k),n=uv(),r=Su(),v=op().ga,x=n.ng(new Uu(r,v)),A=Ev(e)?k.kq():wv(xv(a.Fa)),B=sv(),C=Su(),D=op().ga,F=new Ku(l,m,x,A,B.Hd(new Uu(C,D)));return new L(F)}var I=g.y,M=g.w;if(Vu(a.Fa)===I&&M instanceof Fv){t();var N=a.Fa;t();var P=new L(M),T=uv(),Y=Su(),Z=op().ga,S=T.ng(new Uu(Y,Z)),ea=wv(xv(a.Fa)),ia=sv(),X=Su(),sa=op().ga,Ja=new Ku(N,P,S,ea,ia.Hd(new Uu(X,sa)));return new L(Ja)}var Xa=
+g.y,Fa=g.w;if(Vu(a.Fa)===Xa&&Fa instanceof Gv){t();var za=a.Fa,Qa=t().d;uv();var Ma=Su(),Ga=op().ga,ab=vv(Fa,new Uu(Ma,Ga)),Hb=wv(xv(a.Fa)),bc=sv(),yb=Su(),tb=op().ga,eb=new Ku(za,Qa,ab,Hb,bc.Hd(new Uu(yb,tb)));return new L(eb)}var kb=g.y,Rb=g.w;if(kb instanceof Ku){var Gb=kb.fc,vb=kb.vd,Tb=kb.be,Nb=kb.Me;if(Rb instanceof Gv){t();var ic=new Ku(a.Fa,Gb,vb.bc(Rb),Tb,Nb);return new L(ic)}}var Va=g.y,cb=g.w;if(Va instanceof Ku){var zb=Va.fc,Ub=Va.vd,jb=Va.be,db=Va.Me;if(cb instanceof Fv){var ub=null;
+ub=jb;var Aa=G(new H,zb,cb);a:{var va=Aa.y,Ra=Aa.w;if(va instanceof L){var rb=va.k;if(rb instanceof Mu&&Ra instanceof Mu){var xb=sba(rb,Ra);break a}}var mc=Aa.y,Ha=Aa.w;if(mc instanceof L){var Ka=mc.k;if(Ka instanceof cv){var Oa=Ka.Nb,Na=Ka.ac;if(Ha instanceof cv){var Da=Ha.Nb,ta=Ha.ac;if(a.Fa.UI&&!c){t();var Ya=a.Fa,dc=V(Oa.q),ka=dv(Oa,Da,dc,!1),ya=V(Na.q),Sa=new cv(Ya,ka,Pu(Na,ta,ya,!1),Ka.Mj);xb=new L(Sa);break a}}}}var xc=Aa.y;if(xc instanceof L){var Sb=xc.k;if(Sb instanceof cv){var uc=Sb.Nb;
+if(null!==uc){var Lb=Hv(Iv(a.Fa),uc,d);if(!Lb.b()){var lc=Lb.k;if(lc instanceof zv){var Xb=lc.Yb;if(Aa.w instanceof Jv||Aa.w instanceof cv)b:{for(var ec=Xb;!ec.b();){var Ab=ec.e().j().ra;if(Kv(Ab,d)){var Ob=!0;break b}ec=ec.f()}Ob=!1}else Ob=!1;if(Ob){t();xb=new L(cb);break a}}}}}}var fb=Aa.y,Wa=Aa.w;if(fb instanceof L&&fb.k instanceof Jv&&Wa instanceof cv){var bb=Wa.Nb;if(null!==bb){var Ia=Hv(Iv(a.Fa),bb,d);if(!Ia.b()){var Ua=Ia.k;if(Ua instanceof zv){b:{for(var pc=Ua.Yb;!pc.b();){var sc=pc.e().j().ra;
+if(Kv(sc,d)){var Ba=!0;break b}pc=pc.f()}Ba=!1}if(Ba){xb=fb;break a}}}}}var ob=Aa.y,nc=Aa.w;if(ob instanceof L){var Ib=ob.k;if(Ib instanceof Jv){var vc=Ib.gi;if(nc instanceof cv){t();var Vb=new Jv(a.Fa,nba(a,vc,nc,d),Ib.Mq);xb=new L(Vb);break a}}}var fc=Aa.y;if(fc instanceof L){var Bc=fc.k;if(Bc instanceof cv&&(Aa.w instanceof Jv||Aa.w instanceof cv)){var Pb=a.Fa;t();var Jb=a.Fa,gc=O().c,Cb=new Jv(Jb,new z(Bc,gc),cb.ma());return yv(new Ku(Pb,new L(Cb),Ub,jb,db),cb,c,d,e)}}var cc=Aa.y,yc=Aa.w;if(cc instanceof
+L&&cc.k instanceof Jv&&yc instanceof Jv){var Mc=yc.gi;if(Mc instanceof z){var qc=Mc.z,oc=Mc.p,Qc=O().c;if(null===Qc?null===oc:Qc.i(oc))return yv(a,qc,c,d,e);var jc=yv(a,qc,c,d,e);return jc.b()?R():yv(jc.o(),new Jv(a.Fa,oc,yc.Mq),c,d,e)}}var sb=Aa.y,Gc=Aa.w;if(sb instanceof L){var Wb=sb.k;if(Wb instanceof zv){var Cc=Wb.Yb;if(Gc instanceof zv){var Fc=Gc.Yb,qd=Cc.K();if(Pe(new E(qd),Fc.K())){if(Ev(e)){for(var Yb=a.Fa,Nc=ub.Ba,ad=Gc.kq().Ba,Uc=Su(),cd=op().ga,kc=new Uu(Uc,cd),Vc=sv(),Hc=Nc.Q()+ad.Q()|
+0,rc=Lv(Lv(Mv(8<Hc?Hc:8),Nc),ad),sd=Xu().X(),Kc=sl(rc).m();Kc.s();){var Qd=Kc.t(),Ad=Qd.h(),kd=sd.U(Ad);if(kd instanceof L)var Hd=kd.k,Rd=Nv(Hd,Qd.j(),V(Hd.Va));else{if(R()!==kd)throw new w(kd);Rd=Qd.j()}sd.bj(Ad,Rd)}var Bd=qp(),ae=Ov(Vc,(new Pv(Bd)).vc(sd),kc);Od();var dd=Pd(u(),ae);ub=new Qv(Yb,dd,V(a.Fa))}t();var od=a.Fa,Ta=Rv(Cc,Fc),wb=new zv(od,Ta,V(a.Fa));xb=new L(wb)}else xb=t().d;break a}}}var $a=Aa.y,wa=Aa.w;if($a instanceof L){var hb=$a.k;if(hb instanceof Sv){var ra=hb.Fd;if(wa instanceof
+zv){var wc=wa.Yb;if(Ev(e)){for(var ac=a.Fa,Id=ub.Ba,ud=wa.kq().Ba,be=Su(),re=op().ga,pe=new Uu(be,re),bd=sv(),Rc=Id.Q()+ud.Q()|0,Wc=Lv(Lv(Mv(8<Rc?Rc:8),Id),ud),Wd=Xu().X(),zd=sl(Wc).m();zd.s();){var Pa=zd.t(),Db=Pa.h(),Oc=Wd.U(Db);if(Oc instanceof L)var Tc=Oc.k,Sd=Nv(Tc,Pa.j(),V(Tc.Va));else{if(R()!==Oc)throw new w(Oc);Sd=Pa.j()}Wd.bj(Db,Sd)}var Jc=qp(),vd=Ov(bd,(new Pv(Jc)).vc(Wd),pe);Od();var hd=Pd(u(),vd);ub=new Qv(ac,hd,V(a.Fa))}t();var de=a.Fa,ye=Wi=>{var Oj=Wi.h();Wi=Nv(ra,Wi.j(),V(ra.Va));
+return G(new H,Oj,Wi)};if(wc===u())var jf=u();else{for(var af=wc.e(),pf=new z(ye(af),u()),kf=pf,Be=wc.f();Be!==u();){var Kd=Be.e(),ld=new z(ye(Kd),u());kf=kf.p=ld;Be=Be.f()}jf=pf}var Jd=new zv(de,jf,V(a.Fa));xb=new L(Jd);break a}}}var Dd=Aa.y,Xd=Aa.w;if(Dd instanceof L){var Yc=Dd.k;if(Yc instanceof zv){var Ce=Yc.Yb;if(Xd instanceof Sv){var te=Xd.Fd;t();var Ie=a.Fa,Jf=Wi=>{var Oj=Wi.h();Wi=Nv(Wi.j(),te,V(Wi.j().Va));return G(new H,Oj,Wi)};if(Ce===u())var df=u();else{for(var vg=Ce.e(),wg=new z(Jf(vg),
+u()),xg=wg,eg=Ce.f();eg!==u();){var vh=eg.e(),fg=new z(Jf(vh),u());xg=xg.p=fg;eg=eg.f()}df=wg}var ih=new zv(Ie,df,V(a.Fa));xb=new L(ih);break a}}}var Ig=Aa.y,Tf=Aa.w;if(Ig instanceof L){var Jg=Ig.k;if(Jg instanceof Sv){var jh=Jg.Fd;if(Tf instanceof Sv){var yg=Tf.Fd;t();var gg=a.Fa,Cf=Nv(jh,yg,V(jh.Va)),Uf=new Sv(gg,Cf,V(a.Fa));xb=new L(Uf);break a}}}var $g=Aa.y,Ah=Aa.w;if($g instanceof L){var Kg=$g.k;if(Kg instanceof Tv){var Vf=Kg.Ic,hg=Kg.kf;if(Ah instanceof Tv){var zg=Ah.Ic;if(Pe(new E(hg),Ah.kf)){t();
+var Lg=a.Fa,Mg=V(Vf.q),Wf=Pu(Vf,zg,Mg,!1),Ng=new Tv(Lg,Wf,hg,Kg.vp);xb=new L(Ng);break a}}}}var Kf=Aa.y,xf=Aa.w;if(Kf instanceof L){var Og=Kf.k;if(xf instanceof Tv){t();var mi=a.Fa,Ci=V(Og.q),Xh=Pu(Og,xf,Ci,!1),wh=uv(),Bh=Su(),ng=op().ga,kh=wh.ng(new Uu(Bh,ng)),Kh=new Tv(mi,Xh,kh,V(a.Fa));xb=new L(Kh);break a}}var ni=Aa.y,Lh=Aa.w;if(ni instanceof L){var lh=ni.k;if(lh instanceof Tv){t();var Ch=a.Fa,Dh=V(lh.q),Yh=Pu(lh,Lh,Dh,!1),ah=uv(),oi=Su(),mj=op().ga,wd=ah.ng(new Uu(oi,mj)),ge=new Tv(Ch,Yh,wd,
+V(a.Fa));xb=new L(ge);break a}}var De=Aa.y;if(De instanceof L&&Uv(De.k)&&De.k.q===a.Fa&&(Aa.w instanceof cv||Aa.w instanceof Vv||Aa.w instanceof Jv))var qf=!0;else{var og=Aa.y;if(og instanceof L&&(og.k instanceof cv||og.k instanceof Vv||og.k instanceof Jv)&&Uv(Aa.w)&&Aa.w.q===a.Fa)qf=!0;else{var Xf=Aa.y;if(Xf instanceof L&&Xf.k instanceof cv&&(Aa.w instanceof Vv||Aa.w instanceof Jv))qf=!0;else{var mh=Aa.y;if(mh instanceof L&&(mh.k instanceof Vv||mh.k instanceof Jv)&&Aa.w instanceof cv)qf=!0;else{var Ag=
+Aa.y;if(Ag instanceof L&&Ag.k instanceof Vv&&Aa.w instanceof Jv)qf=!0;else{var Bg=Aa.y;qf=Bg instanceof L&&Bg.k instanceof Jv&&Aa.w instanceof Vv?!0:!1}}}}}if(qf)xb=t().d;else{b:{var Eh=Aa.y;if(Eh instanceof L){var Pg=Eh.k;if(Pg instanceof Jv){var Di=Pg.gi,Mh=O().c;if(null===Mh?null===Di:Mh.i(Di)){var pi=!0;break b}}}var Xi=Aa.w;if(Aa.y instanceof L&&Xi instanceof Jv){var Qg=Xi.gi,nh=O().c;if(null===nh?null===Qg:nh.i(Qg)){pi=!0;break b}}pi=!1}pi&&xm("Program reached and unexpected state.");var bh=
+Aa.y;var Mj=bh instanceof L&&bh.k instanceof Wv?!0:Aa.y instanceof L&&Aa.w instanceof Wv?!0:!1;Mj&&no();var Nj=Aa.y,ie=Aa.w;if(t().d===Nj&&ie instanceof zv){if(Ev(e)){for(var Ac=a.Fa,Ve=ub.Ba,Td=ie.kq().Ba,lf=Su(),Yi=op().ga,Jl=new Uu(lf,Yi),ll=sv(),Bj=Ve.Q()+Td.Q()|0,$k=Lv(Lv(Mv(8<Bj?Bj:8),Ve),Td),Zh=Xu().X(),Ei=sl($k).m();Ei.s();){var Yd=Ei.t(),bf=Yd.h(),rf=Zh.U(bf);if(rf instanceof L)var Cg=rf.k,nj=Nv(Cg,Yd.j(),V(Cg.Va));else{if(R()!==rf)throw new w(rf);nj=Yd.j()}Zh.bj(bf,nj)}var Jh=qp(),If=Ov(ll,
+(new Pv(Jh)).vc(Zh),Jl);Od();var Hg=Pd(u(),If);ub=new Qv(Ac,Hg,V(a.Fa))}t();xb=new L(cb)}else{var He=Aa.y;if(t().d===He)t(),xb=new L(cb);else throw new w(Aa);}}}if(xb.b())return R();var lj=xb.o();return new L(new Ku(a.Fa,(t(),new L(lj)),Ub,ub,db))}}throw new w(g);}
+function Xv(a,b){var c=Vu(a.Fa);if(null!==c&&c===a){a=a.Fa;c=t().d;var d=uv(),e=Su(),g=op().ga;d=d.ng(new Uu(e,g));e=sv();g=Su();var h=op().ga;return new Ku(a,c,d,b,e.Hd(new Uu(g,h)))}if(a instanceof Ku)return c=a.fc,d=a.vd,e=a.Me,h=g=a.Fa,b=Yv(a.be.Ba,b.Ba),new Ku(g,c,d,new Qv(h,b,V(a.Fa)),e);throw new w(a);}
+function Zv(a,b,c,d,e){var g=Vu(a.Fa);if(null!==g&&g===a){t();e=a.Fa;g=t().d;var h=uv(),k=Su(),l=op().ga;h=h.ng(new Uu(k,l));k=wv(xv(a.Fa));sv();b=G(new H,b.qb,b);l=Su();var m=op().ga;b=new Ku(e,g,h,k,$v(b,new Uu(l,m)));return new L(b)}if(a instanceof Ku){g=a.fc;h=a.vd;k=a.be;l=a.Me;m=b.qb;var n=l.U(b.qb);if(n.b())n=b;else{n=n.o();var r=new aw(b.Zb);tp();var v=jv(r.rc,n.Zb);up(0,Pe(new E(v),0));t();n=bw(n,new L(!0),new fn((x,A)=>{var B=r.rc.e();r.rc=r.rc.f();var C=!1,D=null;if(x instanceof L&&(C=
+!0,D=x,!0===!!D.k))return x=V(A.q),Pu(A,B,x,!1);if(C&&!1===!!D.k)return x=V(A.q),dv(A,B,x,!1);if(t().d===x){if(c)return x=cw(a.Fa),C=V(A.q),C=dv(A,B,C,!1),D=V(A.q),dw(x,C,Pu(A,B,D,!1),ew(cw(a.Fa)),d);x=cw(a.Fa);C=V(A.q);C=Pu(A,B,C,!1);D=V(A.q);return dw(x,C,dv(A,B,D,!1),ew(cw(a.Fa)),d)}throw new w(x);}),d);n=new fw(a.Fa,b.qb,n,b.Xl)}l=l.Dm(m,n);g=new Ku(a.Fa,g,h,k,l);b=gw(b,d);b.b()?(t(),b=new L(g)):(b=b.o(),b=yv(g,b,c,d,e));return b}throw new w(a);}
+function hw(a,b,c,d,e){var g=tc();try{var h=G(new H,a,b),k=h.w;if(Vu(a.Fa)===k)return t(),new L(a);var l=h.y;if(Vu(a.Fa)===l)return t(),new L(b);var m=h.w;if(m instanceof Ku){var n=m.fc,r=m.be,v=m.Me,x=m.vd.m(),A=new Ou(v);if(n.b())var B=it().n(Xv(a,r));else{var C=n.o();B=yv(Xv(a,r),C,c,d,e)}for(a=B;A.Ot.s();){b=a;var D=A.t();h=D;if(b.b())throw Hq(new Iq,g,t().d);a=Zv(b.o(),h,c,d,e)}for(A=a;x.s();){D=A;var F=x.t();a=F;if(D.b())throw Hq(new Iq,g,t().d);A=yv(D.o(),a,c,d,e)}return A}throw new w(h);}catch(I){if(I instanceof
+Iq){c=I;if(c.Qg===g)return c.Cj();throw c;}throw I;}}
+f.Dw=function(a,b){var c=G(new H,this,a),d=c.y,e=c.w;if(d instanceof Ku&&(d=d.be,e instanceof iw))return a=this.Fa,c=G(new H,e.me,e.Ne),e=O().c,a=new Qv(a,new z(c,e),V(this.Fa)),c=Xu().X(),Zu(d,a,b,!0,c);var g=c.y,h=c.w;if(g instanceof Ku&&(d=g.fc,h instanceof jw)){e=h.mb;c=h.Dc;a:{for(h=h.Xb;!h.b();){var k=h.e();b:{if(d instanceof L){var l=d.k;if(l instanceof Mu){k=Pe(new E(k.uo()),l.pd)?!0:(g.rE?g.qE:kw(g)).L(k.uo());break b}}k=!1}if(k){g=!0;break a}h=h.f()}g=!1}if(g)a=!0;else a:{if(g=!1,h=null,
+e instanceof L&&(g=!0,h=e,k=h.k,k instanceof Ud&&(k=k.fa,null!==k))){a=this.Dw(k,b);break a}if(g&&(k=h.k,k instanceof fe&&(k=k.aa,k instanceof cv||k instanceof Jv||k instanceof Vv||k instanceof zv))){d.b()?a=!1:(a=d.o(),d=Xu().X(),a=Zu(a,k,b,!0,d));break a}if(g&&(d=h.k,d instanceof fe&&d.aa instanceof Tv))return a=a.mc(),this.mc(),this.mc(),c=Xu().X(),d=this.mc(),Zu(d,a,b,!0,c);if(t().d===e)a=!1;else throw new w(e);}if(a)return!0;d=!1;for(a=c.m();!d&&a.s();){c=a.t();if(null===c)throw new w(c);c=c.j();
+this.mc();this.mc();d=Xu().X();e=this.mc();d=Zu(e,c,b,!0,d)}return d}b=c.y;if(Vu(this.Fa)===b)return!1;b=c.w;if(lw(this.Fa)===b)return!1;throw new w(c);};
+function mw(a,b,c){var d=G(new H,a,b);b=d.w;if(Vu(a.Fa)===b)return!0;b=d.y;if(Vu(a.Fa)===b)return!1;a=d.y;var e=d.w;if(a instanceof Ku){var g=a.fc,h=a.vd;b=a.be;a=a.Me;if(e instanceof Ku){var k=e.fc,l=e.vd;d=e.be;e=e.Me;if(k.b())g=!0;else if(k=k.o(),g.b())g=!1;else{g=g.o();var m=Xu().X();g=Zu(g,k,c,!0,m)}g&&nw(l,h)?(h=Xu().X(),b=Zu(b,d,c,!0,h)):b=!1;if(b){b=new Ou(e);for(h=!0;h&&b.Ot.s();){h=b.t();d=new Ou(a);for(e=!1;!e&&d.Ot.s();)e=d.t(),l=Xu().X(),e=Zu(e,h,c,!0,l);h=e}return h}return!1}}throw new w(d);
+}function ow(a){return Vu(a.Fa)===a}
+function pw(a,b){if(a instanceof iw){var c=a.Aa;b=G(new H,a.me,a.Ne);var d=O().c;return new Qv(c,new z(b,d),V(a.Aa))}if(a instanceof jw){c=a.Xb;var e=a.mb;d=a.Dc;if(e.b())a=a.Aa.ib;else if(a=e.o(),a instanceof Ud)a=a.fa.zf(b);else{if(!(a instanceof fe))throw new w(a);a=a.aa}d=new Ou(d);a=Qu(d,a,new fn((g,h)=>{var k=V(g.q);return dv(g,h,k,!1)}));b&&(b=Su(),d=op().ga,c=qw(c,new Uu(b,d)));return c.De(a,new fn((g,h)=>{var k=V(g.q);return dv(g,h,k,!1)}))}c=lw(a.Aa);if(null!==c&&c===a)return a.Aa.ib;throw new w(a);
+}function rw(a,b){if(null===b)throw null;a.Aa=b}function sw(){this.Nz=null;this.jx=!1;this.Aa=null}sw.prototype=new p;sw.prototype.constructor=sw;function tw(){}tw.prototype=sw.prototype;
+function tba(a,b){var c=G(new H,a,b),d=c.y;b=c.w;if(d instanceof iw&&(d=d.me,b instanceof iw))return pa(d.Dh,b.me.Dh);b=c.y;var e=c.w;if(b instanceof jw&&(d=b.Xb,b=b.Dc,e instanceof jw)){c=e.Xb;a=e.Dc;e=Su();var g=op().ga;e=Gq(d,new Uu(e,g));if(e instanceof L){e=e.k;g=Su();var h=op().ga;g=Gq(c,new Uu(g,h));if(g instanceof L)c=uw(e,g.k);else{if(t().d!==g)throw new w(g);d=d.K();d=new vw(d);c=c.K();Fq();d=d.al;c=d===c?0:d<c?-1:1}}else{if(t().d!==e)throw new w(e);d=d.K();d=new vw(d);c=c.K();Fq();d=d.al;
+c=d===c?0:d<c?-1:1}if(Nm(new E(c),0))return c;c=G(new H,sp(b),sp(a));a:{e=c.y;d=c.w;if(e instanceof L&&(e=e.k,null!==e&&(e=e.h(),d instanceof L&&(d=d.k,null!==d)))){c=pa(e.V,d.h().V);break a}d=c.w;if(c.y instanceof L&&t().d===d)c=1;else if(d=c.y,e=c.w,t().d===d&&e instanceof L)c=-1;else if(d=c.y,e=c.w,t().d===d&&t().d===e)c=0;else throw new w(c);}return Nm(new E(c),0)?c:c=-hv(b,a)|0}if(c.y instanceof jw)return-1;if(c.w instanceof jw)return 1;if(c.y instanceof iw)return-1;if(c.w instanceof iw)return 1;
+b=c.y;d=c.w;if(lw(a.Aa)===b&&lw(a.Aa)===d)return 0;throw new w(c);}sw.prototype.GC=function(){var a=this.zf(!1),b=O().c;return new z(a,b)};sw.prototype.zf=function(a){return a?pw(this,!0):this.mc()};sw.prototype.mc=function(){this.jx||this.jx||(this.Nz=pw(this,!1),this.jx=!0);return this.Nz};
+function ww(a,b,c,d){var e=lw(a.Aa);if(null!==e&&e===a){t();e=a.Aa;var g=O().c,h=t().d;sv();b=G(new H,b.qb,b);var k=Su(),l=op().ga;b=new jw(e,g,h,$v(b,new Uu(k,l)));return new L(b)}if(a instanceof iw){e=a.me;b=a.Ne;h=!1;g=null;k=lw(a.Aa);if(null!==k&&k===a)return t(),b=new iw(a.Aa,e,b),new L(b);if(a instanceof iw&&(k=a.me,l=a.Ne,Pe(new E(k),e)))return t(),b=new iw(a.Aa,k,xw(l,b,V(l.Va))),new L(b);if(a instanceof jw){h=!0;g=a;k=g.Xb;var m=g.mb;l=g.Dc;if(t().d===m)return t(),g=a.Aa,t(),t(),b=new iw(a.Aa,
+e,b),b=new jw(g,k,new L(new Ud(b)),l),new L(b)}if(h&&(h=g.Xb,k=g.mb,g=g.Dc,k instanceof L&&(k=k.k,k instanceof Ud&&(l=k.fa,null!==l&&(k=l.me,l=l.Ne,Pe(new E(k),e))))))return t(),e=a.Aa,t(),t(),b=new iw(a.Aa,k,xw(l,b,V(l.Va))),b=new jw(e,h,new L(new Ud(b)),g),new L(b);if(a instanceof iw||a instanceof jw)return t().d;throw new w(a);}if(a instanceof jw){e=a.Xb;g=a.mb;h=a.Dc;k=b.qb;l=h.U(b.qb);if(!l.b()){l=l.o();var n=new aw(b.Zb);tp();m=jv(n.rc,l.Zb);up(0,Pe(new E(m),0));t();l=bw(l,new L(!0),new fn((r,
+v)=>{var x=n.rc.e();n.rc=n.rc.f();var A=!1,B=null;if(r instanceof L&&(A=!0,B=r,!0===!!B.k))return r=V(v.q),dv(v,x,r,!1);if(A&&!1===!!B.k)return r=V(v.q),Pu(v,x,r,!1);if(t().d===r){if(c)return r=cw(a.Aa),A=V(v.q),A=Pu(v,x,A,!1),B=V(v.q),dw(r,A,dv(v,x,B,!1),ew(cw(a.Aa)),d);r=cw(a.Aa);A=V(v.q);A=dv(v,x,A,!1);B=V(v.q);return dw(r,A,Pu(v,x,B,!1),ew(cw(a.Aa)),d)}throw new w(r);}),d);b=new fw(a.Aa,b.qb,l,b.Xl)}b=h.Dm(k,b);t();b=new jw(a.Aa,e,g,b);return new L(b)}throw new w(a);}
+function yw(a,b,c,d){var e=tc();try{if(b instanceof jw){for(var g=b.Xb,h=b.mb,k=new Ou(b.Dc);k.Ot.s();){var l=a,m=k.t(),n=ww(l,m,c,d);if(n.b())throw Hq(new Iq,e,t().d);a=n.o()}for(;!g.b();){c=a;var r=g.e(),v=zw(c,r);if(v.b())throw Hq(new Iq,e,t().d);a=v.o();g=g.f()}r=a;t();if(h.b())var x=r;else{var A=h.o();if(A instanceof Ud){var B=A.fa;var C=G(new H,B.me,B.Ne);var D=Aw(r,C);if(D.b())throw Hq(new Iq,e,t().d);x=D.o()}else{if(!(A instanceof fe))throw new w(A);var F=zw(r,A.aa);if(F.b())throw Hq(new Iq,
+e,t().d);x=F.o()}}return new L(x)}if(b instanceof iw){l=b.me;var I=b.Ne;h=!1;x=null;var M=lw(a.Aa);if(null!==M&&M===a){t();var N=new iw(a.Aa,l,I);return new L(N)}if(a instanceof iw){var P=a.me,T=a.Ne;if(Pe(new E(P),l)){t();var Y=new iw(a.Aa,P,xw(T,I,V(T.Va)));return new L(Y)}}if(a instanceof jw){h=!0;x=a;var Z=x.Xb,S=x.mb,ea=x.Dc;if(t().d===S){t();var ia=a.Aa;t();t();var X=new iw(a.Aa,l,I),sa=new jw(ia,Z,new L(new Ud(X)),ea);return new L(sa)}}if(h){var Ja=x.Xb,Xa=x.mb,Fa=x.Dc;if(Xa instanceof L){var za=
+Xa.k;if(za instanceof Ud){var Qa=za.fa;if(null!==Qa){var Ma=Qa.me,Ga=Qa.Ne;if(Pe(new E(Ma),l)){t();var ab=a.Aa;t();t();var Hb=new iw(a.Aa,Ma,xw(Ga,I,V(Ga.Va))),bc=new jw(ab,Ja,new L(new Ud(Hb)),Fa);return new L(bc)}}}}}if(a instanceof iw||a instanceof jw)return t().d;throw new w(a);}if(lw(a.Aa)===b)return t(),new L(a);throw new w(b);}catch(yb){if(yb instanceof Iq){h=yb;if(h.Qg===e)return h.Cj();throw h;}throw yb;}}
+function uba(a,b,c){var d=lw(a.Aa);if(null!==d&&d===a||lw(a.Aa)===b)return t(),a=lw(a.Aa),new L(a);if(a instanceof iw){d=a.me;var e=a.Ne;if(b instanceof iw){var g=b.Ne;if(Pe(new E(d),b.me))return t(),a=new iw(a.Aa,d,Nv(e,g,V(e.Va))),new L(a)}}if(a instanceof jw&&(d=a.Xb,g=a.mb,e=a.Dc,g instanceof L&&(g=g.k,g instanceof Ud&&(g=g.fa,b instanceof jw)))){var h=b.Xb,k=b.mb,l=b.Dc;if(k instanceof L&&(k=k.k,k instanceof Ud&&(k=k.fa,Pe(new E(d),h)&&Pe(new E(e),l)&&Pe(new E(g.me),k.me))))return t(),c=a.Aa,
+t(),t(),a=new iw(a.Aa,g.me,Nv(g.Ne,k.Ne,V(g.Ne.Va))),a=new jw(c,d,new L(new Ud(a)),e),new L(a)}return a instanceof jw&&(d=a.Xb,e=a.mb,g=a.Dc,b instanceof jw&&(l=b.mb,h=b.Dc,Pe(new E(d),b.Xb)&&Pe(new E(e),l)?(b=g.AB(),b=Pe(new E(b),h.AB())):b=!1,b))?(t(),a=new jw(a.Aa,d,e,Bw(a.Aa,!1,g,h,c)),new L(a)):t().d}
+function vba(a,b){var c=lw(a.Aa);if(null!==c&&c===a){c=a.Aa;a=O().c;b=new z(b,a);a=t().d;var d=sv(),e=Su(),g=op().ga;return new jw(c,b,a,d.Hd(new Uu(e,g)))}if(a instanceof iw)return c=a.Aa,d=O().c,b=new z(b,d),t(),t(),a=new L(new Ud(a)),d=sv(),e=Su(),g=op().ga,new jw(c,b,a,d.Hd(new Uu(e,g)));if(a instanceof jw)return new jw(a.Aa,new z(b,a.Xb),a.mb,a.Dc);throw new w(a);}
+function zw(a,b){var c=G(new H,a,b),d=c.y,e=c.w;if(lw(a.Aa)===d&&Uv(e)){t();var g=a.Aa,h=O().c,k=new z(e,h),l=t().d,m=sv(),n=Su(),r=op().ga,v=new jw(g,k,l,m.Hd(new Uu(n,r)));return new L(v)}var x=c.y,A=c.w;if(lw(a.Aa)===x&&A instanceof Cw){t();var B=a.Aa,C=O().c;t();t();var D=new L(new fe(A)),F=sv(),I=Su(),M=op().ga,N=new jw(B,C,D,F.Hd(new Uu(I,M)));return new L(N)}var P=c.y,T=c.w;if(P instanceof jw){var Y=P.Xb,Z=P.mb,S=P.Dc;if(T instanceof Mu){t();var ea=new jw(a.Aa,Y.L(T)?Y:new z(T,Y),Z,S);return new L(ea)}}var ia=
+c.y,X=c.w;if(ia instanceof jw){var sa=ia.Xb,Ja=ia.mb,Xa=ia.Dc;if(t().d===Ja&&X instanceof Cw){t();var Fa=a.Aa;t();t();var za=new jw(Fa,sa,new L(new fe(X)),Xa);return new L(za)}}var Qa=c.y,Ma=c.w;if(Qa instanceof jw){var Ga=Qa.Xb,ab=Qa.mb,Hb=Qa.Dc;if(ab instanceof L){var bc=ab.k;if(bc instanceof fe){var yb=bc.aa;if(yb instanceof zv){var tb=yb.Yb;if(Ma instanceof zv){var eb=Ma.Yb,kb=tb.K();if(Nm(new E(kb),eb.K())){var Rb=a.Aa;t();t();var Gb=Dw(yb);return zw(new jw(Rb,Ga,new L(new fe(Gb)),Hb),Dw(Ma))}t();
+var vb=a.Aa;t();t();var Tb=a.Aa,Nb=new Wq(tb,tb,eb),ic=new fn((ld,Jd)=>{ld=G(new H,ld,Jd);Jd=ld.y;var Dd=ld.w;if(null!==Jd){var Xd=Jd.h();Jd=Jd.j();if(Xd instanceof L&&(Xd=Xd.k,null!==Dd)){var Yc=Dd.h();Dd=Dd.j();if(Yc instanceof L)return ld=Pe(new E(Xd),Yc.k)?(t(),new L(Xd)):t().d,G(new H,ld,xw(Jd,Dd,V(Jd.Va)))}}Dd=ld.y;Xd=ld.w;if(null!==Dd&&(Jd=Dd.h(),Dd=Dd.j(),null!==Xd))return ld=Xd.h(),Xd=Xd.j(),ld=Jd.b()?ld:Jd,G(new H,ld,xw(Dd,Xd,V(Dd.Va)));throw new w(ld);});Yq();var Va=Ew(Nb,ic),cb=new zv(Tb,
+Va,V(a.Aa)),zb=new jw(vb,Ga,new L(new fe(cb)),Hb);return new L(zb)}}}}}var Ub=c.y,jb=c.w;if(Ub instanceof jw){var db=Ub.mb;if(db instanceof L){var ub=db.k;if(ub instanceof fe&&ub.aa instanceof Sv&&jb instanceof zv)return zw(a,Dw(jb))}}var Aa=c.y,va=c.w;if(Aa instanceof jw){var Ra=Aa.Xb,rb=Aa.mb,xb=Aa.Dc;if(rb instanceof L){var mc=rb.k;if(mc instanceof fe){var Ha=mc.aa;if(Ha instanceof zv&&va instanceof Sv){var Ka=a.Aa;t();t();var Oa=Dw(Ha);return zw(new jw(Ka,Ra,new L(new fe(Oa)),xb),va)}}}}var Na=
+c.y,Da=c.w;if(Na instanceof jw){var ta=Na.Xb,Ya=Na.mb,dc=Na.Dc;if(Ya instanceof L){var ka=Ya.k;if(ka instanceof fe){var ya=ka.aa;if(ya instanceof Sv){var Sa=ya.Fd;if(Da instanceof Sv){var xc=Da.Fd;t();var Sb=a.Aa;t();t();var uc=a.Aa,Lb=xw(Sa,xc,V(Sa.Va)),lc=new Sv(uc,Lb,V(a.Aa)),Xb=new jw(Sb,ta,new L(new fe(lc)),dc);return new L(Xb)}}}}}a:{var ec=c.y;if(ec instanceof jw){var Ab=ec.mb;if(Ab instanceof L){var Ob=Ab.k;if(Ob instanceof fe&&Ob.aa instanceof Tv){var fb=!0;break a}}}fb=c.w instanceof Tv?
+!0:!1}fb&&xm("Program reached and unexpected state.");var Wa=c.y;if(Wa instanceof jw){var bb=Wa.mb;if(bb instanceof L){var Ia=bb.k;if(Ia instanceof fe&&Pe(new E(b),Ia.aa))return t(),new L(a)}}var Ua=c.y,pc=c.w;if(Ua instanceof jw){var sc=Ua.Xb,Ba=Ua.mb,ob=Ua.Dc;if(Ba instanceof L){var nc=Ba.k;if(nc instanceof fe){var Ib=nc.aa;if(Ib instanceof cv){var vc=Ib.Nb,Vb=Ib.ac;if(pc instanceof cv){var fc=pc.Nb,Bc=pc.ac;t();var Pb=a.Aa;t();t();var Jb=a.Aa,gc=V(vc.q),Cb=Pu(vc,fc,gc,!1),cc=V(Vb.q),yc=dv(Vb,Bc,
+cc,!1),Mc=new cv(Jb,Cb,yc,V(a.Aa)),qc=new jw(Pb,sc,new L(new fe(Mc)),ob);return new L(qc)}}}}}var oc=c.y,Qc=c.w;if(oc instanceof jw){var jc=oc.Xb,sb=oc.mb,Gc=oc.Dc;if(sb instanceof L){var Wb=sb.k;if(Wb instanceof fe){var Cc=Wb.aa;if(Cc instanceof Jv){var Fc=Cc.gi;if(Qc instanceof cv){var qd=Qc.Nb,Yb=Qc.ac;t();var Nc=a.Aa;t();t();var ad=a.Aa,Uc=ld=>{if(null!==ld){var Jd=ld.Nb,Dd=ld.ac,Xd=a.Aa,Yc=V(Jd.q);Jd=Pu(Jd,qd,Yc,!1);Yc=V(Dd.q);return new cv(Xd,Jd,dv(Dd,Yb,Yc,!1),ld.Mj)}throw new w(ld);};if(Fc===
+u())var cd=u();else{for(var kc=Fc.e(),Vc=new z(Uc(kc),u()),Hc=Vc,rc=Fc.f();rc!==u();){var sd=rc.e(),Kc=new z(Uc(sd),u());Hc=Hc.p=Kc;rc=rc.f()}cd=Vc}var Qd=new Jv(ad,cd,Cc.Mq),Ad=new jw(Nc,jc,new L(new fe(Qd)),Gc);return new L(Ad)}}}}}var kd=c.y,Hd=c.w;if(kd instanceof jw){var Rd=kd.Xb,Bd=kd.mb,ae=kd.Dc;if(Bd instanceof L){var dd=Bd.k;if(dd instanceof fe){var od=dd.aa;if(od instanceof cv&&Hd instanceof Jv){var Ta=a.Aa;t();t();return zw(new jw(Ta,Rd,new L(new fe(Hd)),ae),od)}}}}a:{var wb=c.y;if(wb instanceof
+jw){var $a=wb.mb;if($a instanceof L){var wa=$a.k;if(wa instanceof fe&&wa.aa instanceof Jv){var hb=!0;break a}}}hb=c.w instanceof Jv?!0:!1}if(hb)return t().d;var ra=c.y,wc=c.w;if(ra instanceof jw){var ac=ra.Xb,Id=ra.mb,ud=ra.Dc;if(wc instanceof Gv){t();var be=new jw(a.Aa,ac.L(wc)?ac:new z(wc,ac),Id,ud);return new L(be)}}var re=c.y,pe=c.w;if(re instanceof iw&&Uv(pe)){t();var bd=a.Aa,Rc=O().c,Wc=new z(pe,Rc);t();t();var Wd=new L(new Ud(re)),zd=sv(),Pa=Su(),Db=op().ga,Oc=new jw(bd,Wc,Wd,zd.Hd(new Uu(Pa,
+Db)));return new L(Oc)}if(c.y instanceof iw&&(c.w instanceof cv||c.w instanceof Vv))return t().d;a:{var Tc=c.y;if(Tc instanceof jw){var Sd=Tc.mb;if(Sd instanceof L){var Jc=Sd.k;if(Jc instanceof fe&&Jc.aa instanceof cv&&c.w instanceof Vv){var vd=!0;break a}}}var hd=c.y;if(hd instanceof jw){var de=hd.mb;if(de instanceof L){var ye=de.k;if(ye instanceof fe&&ye.aa instanceof Vv&&c.w instanceof cv){vd=!0;break a}}}var jf=c.y;if(jf instanceof jw){var af=jf.mb;if(af instanceof L&&af.k instanceof Ud&&(c.w instanceof
+cv||c.w instanceof Vv)){vd=!0;break a}}vd=!1}if(vd)return t().d;a:{var pf=c.y;if(pf instanceof jw){var kf=pf.mb;if(kf instanceof L){var Be=kf.k;if(Be instanceof fe&&Be.aa instanceof Wv){var Kd=!0;break a}}}Kd=c.w instanceof Wv?!0:!1}Kd&&no();throw new w(c);}
+function Aw(a,b){var c=!1,d=null,e=lw(a.Aa);if(null!==e&&e===a)return t(),a=new iw(a.Aa,b.h(),b.j()),new L(a);if(a instanceof iw){e=a.me;var g=a.Ne;if(Pe(new E(e),b.h()))return t(),a=new iw(a.Aa,e,xw(g,b.j(),V(g.Va))),new L(a)}if(a instanceof jw){c=!0;d=a;e=d.Xb;var h=d.mb;g=d.Dc;if(t().d===h)return t(),d=a.Aa,t(),t(),a=new iw(a.Aa,b.h(),b.j()),a=new jw(d,e,new L(new Ud(a)),g),new L(a)}if(c&&(c=d.Xb,e=d.mb,d=d.Dc,e instanceof L&&(e=e.k,e instanceof Ud&&(g=e.fa,null!==g&&(e=g.me,h=g.Ne,Pe(new E(e),
+b.h()))))))return t(),g=a.Aa,t(),t(),a=new iw(a.Aa,e,xw(h,b.j(),V(h.Va))),a=new jw(g,c,new L(new Ud(a)),d),new L(a);if(a instanceof iw||a instanceof jw)return t().d;throw new w(a);}
+sw.prototype.Dw=function(a,b){var c=G(new H,this,a),d=c.y;a=c.w;if(d instanceof jw){var e=d.Xb,g=d.mb;d=d.Dc;if(g instanceof L&&(g=g.k,g instanceof Ud&&(g=g.fa,a instanceof iw))){if(e.b()){c=new Ou(d);for(e=!0;e&&c.Ot.s();){e=c.t();d=a.mc();var h=Xu().X();e=Zu(e,d,b,!0,h)}c=e}else c=!1;return c?g.Dw(a,b):!1}}a=c.w;if(c.y instanceof jw&&a instanceof iw)return!1;a=c.w;if(c.y instanceof iw&&a instanceof jw&&(a=a.mb,a instanceof L&&(a=a.k,a instanceof Ud)))return this.Dw(a.fa,b);a=c.w;if(c.y instanceof
+iw&&a instanceof jw&&(a=a.mb,a=a instanceof L&&a.k instanceof fe?!0:t().d===a?!0:!1,a))return!1;e=c.y;a=c.w;if(e instanceof iw&&(g=e.me,e=e.Ne,a instanceof iw))return c=a.Ne,Pe(new E(g),a.me)?(a=Xu().X(),Fw(e,c,b,a)):!1;e=c.y;g=c.w;if(e instanceof jw&&(h=e.Xb,a=e.mb,e=e.Dc,g instanceof jw)){d=g.Xb;c=g.mb;g=g.Dc;a:{for(;!h.b();){var k=h.e();b:{for(var l=d;!l.b();){var m=l.e().uo();if(Pe(new E(m),k.uo())){k=!0;break b}l=l.f()}k=!1}if(!k){d=!1;break a}h=h.f()}d=!0}if(d){d=!0;for(e=e.m();d&&e.s();){d=
+e.t();if(null===d)throw new w(d);d=d.j();k=!1;for(h=g.m();!k&&h.s();){k=h.t();if(null===k)throw new w(k);k=k.j();l=Xu().X();k=Zu(d,k,b,!0,l)}d=k}g=d}else g=!1;return g?a instanceof L&&(g=a.k,g instanceof fe&&(g=g.aa,c instanceof L&&(c=c.k,c instanceof fe)))?(a=c.aa,c=Xu().X(),Zu(g,a,b,!0,c)):t().d===a?!0:!1:!1}b=c.y;if(lw(this.Aa)===b)return!0;b=c.w;if(lw(this.Aa)===b)return!1;throw new w(c);};function Gw(a){return lw(a.Aa)===a}
+function wba(a){var b=tf(a.cd),c=a.ne,d=a.jg,e=1+b.da|0,g=Hw(),h=Su(),k=op().ga;g=g.Hd(new Uu(h,k));e=new Iw(b.S,b.Ec,b.hc,b.Ed,e,b.Pc,b.Zc,b.Lb,b.yc,b.tb,b.$a,b.od,g);Jw(e,Kw(a));if(Pe(new E(a.LE),!0)){Lw(a.J,Ye(new Te(new Ue(J(new K,["Unhandled cyclic parent specification"]))),u()),a.Ab.A(),a.ne);var l=O().c}else try{a.LE=!0;var m=Mw(a);for(h=g=null;m!==u();){var n=m.e();a:{if(null!==n){var r=n.hv,v=n.qt,x=n.kr,A=n.iv,B=n.jv;if(null!==v){var C=v.x,D=a.J.qa,F=a.J;if(F.F){var I=ut(Q(),"| ",F.r)+(e.da+
+". Typing parent spec ")+r;ff(gf(),I+"\n")}F.r=1+F.r|0;try{var M=x.fQ(a.ne);if(M instanceof Nw){k=M;var N=A.b()?t().d:(t(),new L(A)),P=a.ne,T=Ow(a),Y=Pw(a,k,v,N,e,P,T);if(null===Y)throw new w(Y);var Z=Y.h(),S=a.cd,ea=Qw(k,M.Ea(),!1,S,Z),ia=jv(B,ea.Tl);if(Nm(new E(ia),0)){var X=a.J,sa=new Te(new Ue(J(new K,["mixin "," expects "," parameter(s); got ",""]))),Ja=We(Xe(),C);Xe();var Xa=ea.Tl.K(),Fa=We(0,""+Xa);Xe();var za=B.K(),Qa=[Ja,Fa,We(0,""+za)],Ma=Ye(sa,J(new K,Qa));cu();var Ga=op(),ab=B.Gb(Ga.ga).j();
+Lw(X,Ma,du(0,new z(v,ab)),a.ne)}var Hb=ea.Tl,bc=new Wq(Hb,Hb,B),yb=new fn(((Ab,Ob)=>(fb,Wa)=>{var bb=G(new H,fb,Wa);fb=bb.y;var Ia=bb.w;if(null!==fb&&(Wa=new L(fb),!Wa.b()&&(fb=Wa.k.h(),Wa=Wa.k.j(),null!==Ia&&(Ia=new L(Ia),!Ia.b())))){var Ua=Ia.k.j();if(null!==Ua&&(Ia=Ua.yb,Ua=Ua.ya,null!==Ia)){bb=Ia.ch;var pc=Ia.Bh;if(Ia.je||bb||pc)throw new Yj("assertion failed: TODO");bb=Rw(a.J,Ua,Ab,a.ne,Ow(a),!0);Ia=Wa.Oa;if(!Ia.b()){Ia=Ia.o();Ua=a.ne;pc=a.jg;var sc=Sw(a.J).ob;Tw(a.J,Ia,bb,Ua,pc,Ab,sc)}Ia=Wa.ra;
+Ua=a.ne;pc=a.jg;sc=Sw(a.J).ob;Tw(a.J,bb,Ia,Ua,pc,Ab,sc);Ia=Ob.Jj.n(fb.x).Mp();Wa=Wa.Oa.b()?new Uw(a.J,Wa.Oa,bb,V(a.J)):new Uw(a.J,Wa.Oa,Wa.ra,V(a.J));return iu(ju(),Ia?new L(new Vw(a.J,fb,Wa,Ia,Ab.da)):R())}}throw new w(bb);})(e,ea));Yq();var tb=Zq(bc,yb),eb=a.J;if(eb.F){var kb=ut(Q(),"| ",eb.r)+"Mixin arg members "+tb;ff(gf(),kb+"\n")}t();var Rb=new Gp(ea,tb,nf(),r.A()),Gb=new L(Rb)}else if(M instanceof Ww){k=M;B.b()||Lw(a.J,Ye(new Te(new Ue(J(new K,["trait arguments are not yet supported"]))),u()),
+r.A(),a.ne);var vb=A.b()?t().d:(t(),new L(A)),Tb=a.ne,Nb=Ow(a),ic=Pw(a,k,v,vb,e,Tb,Nb);if(null===ic)throw new w(ic);var Va=ic.h(),cb=ic.j(),zb=a.cd,Ub=Xw(k,M.Ea(),!1,zb,Va),jb=O().c;t();var db=new Gp(Ub,jb,cb.bf(Ub.Vm),r.A());Gb=new L(db)}else if(M instanceof Yw){k=M;var ub=A.b()?t().d:(t(),new L(A)),Aa=a.ne,va=Ow(a),Ra=Pw(a,k,v,ub,e,Aa,va);if(null===Ra)throw new w(Ra);var rb=Ra.h(),xb=Ra.j(),mc=a.cd,Ha=Zw(k,M.Ea(),!1,mc,rb),Ka=Ha.gl;if(Ka instanceof L){var Oa=Ka.k;$w(a,Oa.K(),B,C,v);var Na=new Wq(Oa,
+Oa,B),Da=new fn((Ab=>(Ob,fb)=>{fb=G(new H,Ob,fb);a:{Ob=fb.y;var Wa=fb.w;if(null!==Ob&&(Ob=new L(Ob),!Ob.b()&&(Ob=Ob.k.j(),null!==Wa&&(Wa=new L(Wa),!Wa.b())))){var bb=Wa.k.j();if(null!==bb&&(Wa=bb.yb,bb=bb.ya,null!==Wa)){fb=Wa.ch;var Ia=Wa.Bh;if(Wa.je||fb||Ia)throw new Yj("assertion failed: TODO");fb=Rw(a.J,bb,Ab,a.ne,Ow(a),!0);Wa=a.ne;bb=a.jg;Ia=Sw(a.J).ob;Tw(a.J,fb,Ob,Wa,bb,Ab,Ia);break a}}throw new w(fb);}})(e));Yq();Ew(Na,Da);var ta=O().c}else{if(t().d!==Ka)throw new w(Ka);var Ya=Ha.Ij;if(Ya instanceof
+L){var dc=Ya.k;$w(a,dc.K(),B,C,v);var ka=new Wq(dc,dc,B),ya=new fn(((Ab,Ob)=>(fb,Wa)=>{var bb=G(new H,fb,Wa);fb=bb.y;var Ia=bb.w;if(null!==fb&&(Wa=new L(fb),!Wa.b()&&(fb=Wa.k.h(),Wa=Wa.k.j(),null!==Ia&&(Ia=new L(Ia),!Ia.b())))){var Ua=Ia.k.j();if(null!==Ua&&(Ia=Ua.yb,Ua=Ua.ya,null!==Ia)){bb=Ia.ch;var pc=Ia.Bh;if(Ia.je||bb||pc)throw new Yj("assertion failed: TODO");bb=Rw(a.J,Ua,Ab,a.ne,Ow(a),!0);Ia=Wa.Oa;if(!Ia.b()){Ia=Ia.o();Ua=a.ne;pc=a.jg;var sc=Sw(a.J).ob;Tw(a.J,Ia,bb,Ua,pc,Ab,sc)}Ia=Wa.ra;Ua=
+a.ne;pc=a.jg;sc=Sw(a.J).ob;Tw(a.J,bb,Ia,Ua,pc,Ab,sc);Ia=Ob.Ei.n(fb.x).Mp();Wa=Wa.Oa.b()?new Uw(a.J,Wa.Oa,bb,V(a.J)):new Uw(a.J,Wa.Oa,Wa.ra,V(a.J));return iu(ju(),Ia?new L(new Vw(a.J,fb,Wa,Ia,Ab.da)):R())}}throw new w(bb);})(e,Ha));Yq();ta=Zq(ka,ya)}else{if(t().d!==Ya)throw new w(Ya);$w(a,0,B,C,v);ta=O().c}}var Sa=a.J;if(Sa.F){var xc=ut(Q(),"| ",Sa.r)+"Class arg members "+ta;ff(gf(),xc+"\n")}t();var Sb=new Gp(Ha,ta,xb.bf(Ha.Tm),r.A());Gb=new L(Sb)}else if(M instanceof ax)Lw(a.J,Ye(new Te(new Ue(J(new K,
+["Cannot inherit from a type alias"]))),u()),r.A(),a.ne),Gb=t().d;else if(M instanceof Vw)Lw(a.J,Ye(new Te(new Ue(J(new K,["Cannot inherit from a parameter"]))),u()),r.A(),a.ne),Gb=t().d;else if(M instanceof bx)Lw(a.J,Ye(new Te(new Ue(J(new K,["Cannot inherit from a function"]))),u()),r.A(),a.ne),Gb=t().d;else if(M instanceof cx)Gb=t().d;else throw new w(M);}finally{F.r=-1+F.r|0}if(dx(new E(D),F.qa)&&F.F){var uc=""+ut(Q(),"| ",F.r)+D.n(Gb);ff(gf(),uc+"\n")}var Lb=Gb;break a}}throw new w(n);}for(var lc=
+Lb.m();lc.s();){var Xb=new z(lc.t(),u());null===h?g=Xb:h.p=Xb;h=Xb}m=m.f()}l=null===g?u():g}finally{a.LE=!1}m=e.cb;up(tp(),b.S.li||e.cb.b());if(!m.b()){n=b.S.qa;Lb=b.S;Lb.F&&(r=ut(Q(),"| ",Lb.r)+"UNSTASHING... (out)",ff(gf(),r+"\n"));Lb.r=1+Lb.r|0;try{m.Ca(new y(Ab=>{if(null!==Ab){var Ob=Ab.h();for(Ab=Ab.j().m();Ab.s();){var fb=Ab.t();a:{if(null!==fb){var Wa=fb.j();if(!0===fb.Rc()){fb=Sw(b.S).ob;Tw(b.S,Wa,Ob,c,d,b,fb);break a}}if(null!==fb&&(Wa=fb.j(),!1===fb.Rc())){fb=Sw(b.S).ob;Tw(b.S,Ob,Wa,c,d,
+b,fb);break a}throw new w(fb);}}}else throw new w(Ab);}));m.mg();var ec=void 0}finally{Lb.r=-1+Lb.r|0}dx(new E(n),Lb.qa)&&Lb.F&&(ec=""+ut(Q(),"| ",Lb.r)+n.n(ec),ff(gf(),ec+"\n"))}return l}
+var xba=function ex(a,b,c){var e=O().c;if(null===e?null===b:e.i(b))return c;if(b instanceof z){var g=b.z;e=b.p;if(null!==g){var h=g.qt;g=g.kr;if(null!==h){b=h.x;h=!1;var k=null;if(g instanceof fx){h=g.Qu;if(Fp()===h||Bp()===h||zp()===h)return tp(),b=gq(new Ep(b)),g=gx(g),c=b.Ce(g).Ce(c),ex(a,e,c);if(hx()===h||cp()===h||Ap()===h)return ex(a,e,c);throw new w(h);}if(g instanceof ix){h=!0;k=g;var l=k.kh;if(l instanceof Ww)return tp(),c=gq(new Ep(b)).Ce(l.Gq).Ce(c),ex(a,e,c)}if(h&&(l=k.kh,l instanceof
+Yw))return tp(),c=gq(new Ep(b)).Ce(l.ip).Ce(c),ex(a,e,c);if(h&&(k.kh instanceof Vw||k.kh instanceof bx||k.kh instanceof ax||k.kh instanceof Nw||k.kh instanceof cx))return ex(a,e,c);throw new w(g);}}}throw new w(b);};
+function yba(a){var b=tf(a.cd),c=a.ne,d=a.jg,e=1+b.da|0,g=Hw(),h=Su(),k=op().ga;g=g.Hd(new Uu(h,k));var l=new Iw(b.S,b.Ec,b.hc,b.Ed,e,b.Pc,b.Zc,b.Lb,b.yc,b.tb,b.$a,b.od,g);e=a.Ab;if(e instanceof yo)if(k=e.hg,e=r=>{var v=r.j(),x=a.J,A=a.J,B=r.j().A();t();A=jx(new kx,A,B,"type parameter",new L(r.j().V),!0);B=t().d;t();var C=new L(r.j().V),D=O().c,F=O().c;return new tl(v,new lx(x,l.da,D,F,B,C,!1,A),r.h())},k===u())e=u();else{g=k.e();h=g=new z(e(g),u());for(k=k.f();k!==u();){var m=k.e();m=new z(e(m),
+u());h=h.p=m;k=k.f()}e=g}else{if(!(e instanceof Zn))throw new w(e);k=e.Ch;e=r=>{var v=a.J,x=a.J,A=r.A();t();x=jx(new kx,x,A,"method type parameter",new L(r.V),!0);A=t().d;t();var B=new L(r.V),C=O().c,D=O().c;return new tl(r,new lx(v,l.da,C,D,A,B,!1,x),t().d)};if(k===u())e=u();else{g=k.e();h=g=new z(e(g),u());for(k=k.f();k!==u();)m=k.e(),m=new z(e(m),u()),h=h.p=m,k=k.f();e=g}}g=l.cb;up(tp(),b.S.li||l.cb.b());if(!g.b()){h=b.S.qa;k=b.S;k.F&&(m=ut(Q(),"| ",k.r)+"UNSTASHING... (out)",ff(gf(),m+"\n"));
+k.r=1+k.r|0;try{g.Ca(new y(r=>{if(null!==r){var v=r.h();for(r=r.j().m();r.s();){var x=r.t();a:{if(null!==x){var A=x.j();if(!0===x.Rc()){x=Sw(b.S).ob;Tw(b.S,A,v,c,d,b,x);break a}}if(null!==x&&(A=x.j(),!1===x.Rc())){x=Sw(b.S).ob;Tw(b.S,v,A,c,d,b,x);break a}throw new w(x);}}}else throw new w(r);}));g.mg();var n=void 0}finally{k.r=-1+k.r|0}dx(new E(h),k.qa)&&k.F&&(n=""+ut(Q(),"| ",k.r)+h.n(n),ff(gf(),n+"\n"))}return e}
+function zba(a){var b=a.Ag(),c=h=>{if(null!==h){var k=h.hb;return G(new H,h.kc.V,new mx(a.J,k,k.ji))}throw new w(h);};if(b===u())return u();var d=b.e(),e=d=new z(c(d),u());for(b=b.f();b!==u();){var g=b.e();g=new z(c(g),u());e=e.p=g;b=b.f()}return d}function Aba(a){var b=Xu();a=a.Ag().m();return b.Ib(new Ef(a,new y(c=>{var d=c.hb;c=c.Rd;c=c.b()?ou().Yl:c.o();return G(new H,d,c)})))}
+function Bba(a){var b=tf(a.cd),c=a.ne,d=a.jg,e=1+b.da|0,g=Hw(),h=Su(),k=op().ga;g=g.Hd(new Uu(h,k));e=new Iw(b.S,b.Ec,b.hc,b.Ed,e,b.Pc,b.Zc,b.Lb,b.yc,b.tb,b.$a,b.od,g);g=a.Ab;if(g instanceof yo)if(h=g.Sg,h.b())a=R();else{h=h.o().Ra;for(var l=k=null;h!==u();){var m=h.e();a:{if(null!==m){var n=m.h(),r=m.j();if(n instanceof L&&(n=n.k,null!==r)){var v=r.yb;r=r.ya;if(null!==v){m=v.ch;if(v.je||m)throw new Yj("assertion failed: TODO");m=nx(r,a.ne);m=ox(a.J,m,e,a.ne,Ow(a),a.dt);v=a.J;r=t().d;m=new Uw(v,r,
+m,V(a.J));m=G(new H,n,m);n=O().c;m=new z(m,n);break a}}}if(null!==m&&(v=m.h(),n=m.j(),t().d===v&&null!==n&&(v=n.yb,r=n.ya,null!==v&&(n=v.je,v=v.ch,r instanceof vl)))){m=r;if(n||v)throw new Yj("assertion failed: TODO");n=a.J;v=t().d;r=a.J;var x=new Te(new Ue(J(new K,[""," parameters currently need type annotations"])));Xe();Q();var A=[We(0,Nu(0,g.pb.ld))];r=Lw(r,Ye(x,J(new K,A)),m.A(),a.ne);n=new Uw(n,v,r,V(a.J));m=G(new H,m,n);n=O().c;m=new z(m,n);break a}if(null!==m)m=m.j(),Lw(a.J,Ye(new Te(new Ue(J(new K,
+["Unsupported field specification"]))),u()),m.A(),a.ne),m=O().c;else throw new w(m);}for(m=m.m();m.s();)n=new z(m.t(),u()),null===l?k=n:l.p=n,l=n;h=h.f()}a=new L(null===k?u():k)}else{if(!(g instanceof Zn))throw new w(g);a=t().d}g=e.cb;up(tp(),b.S.li||e.cb.b());if(!g.b()){e=b.S.qa;h=b.S;h.F&&(k=ut(Q(),"| ",h.r)+"UNSTASHING... (out)",ff(gf(),k+"\n"));h.r=1+h.r|0;try{g.Ca(new y(C=>{if(null!==C){var D=C.h();for(C=C.j().m();C.s();){var F=C.t();a:{if(null!==F){var I=F.j();if(!0===F.Rc()){F=Sw(b.S).ob;Tw(b.S,
+I,D,c,d,b,F);break a}}if(null!==F&&(I=F.j(),!1===F.Rc())){F=Sw(b.S).ob;Tw(b.S,D,I,c,d,b,F);break a}throw new w(F);}}}else throw new w(C);}));g.mg();var B=void 0}finally{h.r=-1+h.r|0}dx(new E(e),h.qa)&&h.F&&(B=""+ut(Q(),"| ",h.r)+e.n(B),ff(gf(),B+"\n"))}return a}
+function Cba(a){var b=px(a),c=b.b()?O().c:b.o();b=h=>{var k=h.h().x;h=new qx(a.J,h.j().ra,h.h());return G(new H,k,h)};if(c===u())return u();var d=c.e(),e=d=new z(b(d),u());for(c=c.f();c!==u();){var g=c.e();g=new z(b(g),u());e=e.p=g;c=c.f()}return d}
+function Dba(a){var b=a.Ab;if(b instanceof yo){var c=tf(a.cd),d=a.ne,e=a.jg,g=1+c.da|0,h=Hw(),k=Su(),l=op().ga;h=h.Hd(new Uu(k,l));var m=new Iw(c.S,c.Ec,c.hc,c.Ed,g,c.Pc,c.Zc,c.Lb,c.yc,c.tb,c.$a,c.od,h);h=ef(b.ei);Od();g=new fp;Od();for(b=new fp;!h.b();){k=h.e();a:{if(k instanceof Zn){l=k;var n=l.Yc;if(n instanceof Ud&&(n=n.fa,!rx(l))){t();k=G(new H,l,n);k=new fe(k);break a}}t();k=new Ud(k)}if(k instanceof fe)wp(g,k.aa);else if(k instanceof Ud)wp(b,k.fa);else throw new w(k);h=h.f()}l=g.ha();b=Wn(b.ha(),
+new sx(a));Jw(m,Kw(a));g=v=>{if(null!==v){var x=v.h();v=v.j();var A=a.ne,B=a.jg;Sw(m.S);var C=1+m.da|0,D=Hw(),F=Su(),I=op().ga;D=D.Hd(new Uu(F,I));var M=new Iw(m.S,m.Ec,m.hc,m.Ed,C,m.Pc,m.Zc,m.Lb,m.yc,m.tb,m.$a,m.od,D);C=Ow(a);var N=x.Ch;D=Y=>{var Z=Y.V,S=a.J,ea=a.J,ia=Y.A();t();ea=jx(new kx,ea,ia,"method type parameter",new L(Y.V),!0);ia=t().d;t();Y=new L(Y.V);var X=O().c,sa=O().c;S=new lx(S,M.da,X,sa,ia,Y,!1,ea);return G(new H,Z,S)};if(N===u())D=u();else{F=N.e();I=F=new z(D(F),u());for(N=N.f();N!==
+u();){var P=N.e();P=new z(D(P),u());I=I.p=P;N=N.f()}D=F}C=C.bf(D);C=ox(a.J,v,M,a.ne,C,a.dt);D=a.J;cu();v=jx(new kx,D,du(0,new z(v,new z(x.Rb,x.Ch))),"signature of member `"+x.Rb.x+"`",(tx(a.J),t().d),(tx(a.J),!1));v=ux(C.q,C,v);up(tp(),m.S.li||M.cb.b());Xu().X();C=vx(m.S);D=M.cb.m();D=new xo(D,new y(Y=>{if(null!==Y){var Z=Y.h();Y=Y.j().m();return new Ef(Y,new y(S=>{if(null!==S){var ea=S.Rc();S=S.j();up(tp(),S.Ea()>m.da);return ea?G(new H,S,Z):G(new H,Z,S)}throw new w(S);}))}throw new w(Y);}));Od();
+v=wx(C,Pd(u(),D),v);C=m.S;C.F&&(C=ut(Q(),"| ",C.r)+("Inferred poly constr: "+v+"  \u2014\u2014 where ")+xx(v),ff(gf(),C+"\n"));m.S.F&&Nm(new E(v),v)&&(C=m.S,C.F&&(C=ut(Q(),"| ",C.r)+("Refreshed:            "+v+"  \u2014\u2014 where ")+xx(v),ff(gf(),C+"\n")));v=yx(zx(m.S),m.da,v);M.cb.mg();C=M.cb;up(tp(),m.S.li||M.cb.b());if(!C.b()){D=m.S.qa;F=m.S;F.F&&(I=ut(Q(),"| ",F.r)+"UNSTASHING... (out)",ff(gf(),I+"\n"));F.r=1+F.r|0;try{C.Ca(new y(Y=>{if(null!==Y){var Z=Y.h();for(Y=Y.j().m();Y.s();){var S=Y.t();
+a:{if(null!==S){var ea=S.j();if(!0===S.Rc()){S=Sw(m.S).ob;Tw(m.S,ea,Z,A,B,m,S);break a}}if(null!==S&&(ea=S.j(),!1===S.Rc())){S=Sw(m.S).ob;Tw(m.S,Z,ea,A,B,m,S);break a}throw new w(S);}}}else throw new w(Y);}));C.mg();var T=void 0}finally{F.r=-1+F.r|0}dx(new E(D),F.qa)&&F.F&&(T=""+ut(Q(),"| ",F.r)+D.n(T),ff(gf(),T+"\n"))}return G(new H,x,v)}throw new w(v);};if(l===u())g=u();else{h=l.e();k=h=new z(g(h),u());for(l=l.f();l!==u();)n=l.e(),n=new z(g(n),u()),k=k.p=n,l=l.f();g=h}h=m.cb;up(tp(),c.S.li||m.cb.b());
+if(!h.b()){k=c.S.qa;l=c.S;l.F&&(n=ut(Q(),"| ",l.r)+"UNSTASHING... (out)",ff(gf(),n+"\n"));l.r=1+l.r|0;try{h.Ca(new y(v=>{if(null!==v){var x=v.h();for(v=v.j().m();v.s();){var A=v.t();a:{if(null!==A){var B=A.j();if(!0===A.Rc()){A=Sw(c.S).ob;Tw(c.S,B,x,d,e,c,A);break a}}if(null!==A&&(B=A.j(),!1===A.Rc())){A=Sw(c.S).ob;Tw(c.S,x,B,d,e,c,A);break a}throw new w(A);}}}else throw new w(v);}));h.mg();var r=void 0}finally{l.r=-1+l.r|0}dx(new E(k),l.qa)&&l.F&&(r=""+ut(Q(),"| ",l.r)+k.n(r),ff(gf(),r+"\n"))}r=
+g}else{if(!(b instanceof Zn))throw new w(b);r=O().c;b=O().c}return G(new H,r,b)}function Eba(a){var b=Fba(a).m();b=new Ef(b,new y(d=>d.Rb.x));var c=Aq(Bq(),b);b=Ax(a).m();b=new Ef(b,new y(d=>{if(null!==d){var e=d.h(),g=e.Rb.x;d=new bx(a.J,1+a.Ru|0,e,d.j(),c.L(e.Rb.x));return G(new H,g,d)}throw new w(d);}));Od();return Pd(u(),b)}
+function Gba(a){var b=a.Ab;if(b instanceof yo)return a=Mw(a).m(),a=new xo(a,new y(c=>{c=c.kr;return c instanceof fx?Bx(c):c instanceof ix&&(c=c.kh,c instanceof Cx)?c.px:ap()})),Aq(Bq(),a);if(b instanceof Zn)return ap();throw new w(b);}
+function Hba(a){a=a.Ab;if(a instanceof yo)return a=(new Dx(a.Sg)).wF,a=(a.b()?O().c:a.o().Ra).m(),a=new xo(a,new y(b=>{if(null!==b){var c=b.h(),d=b.j();if(c instanceof L&&(c=c.k,null!==d))return d.yb.Bh?R():new L(c)}if(null!==b&&(c=b.h(),d=b.j(),t().d===c&&null!==d&&(c=d.yb,d=d.ya,d instanceof vl)))return c.Bh?R():new L(d);null!==b&&(d=b.h(),c=b.j(),t().d===d&&null!==c&&xm("Program reached and unexpected state."));throw new w(b);})),Aq(Bq(),a);if(a instanceof Zn)return ap();throw new w(a);}
+function Iba(a){var b=a.Ab;if(b instanceof yo){var c=b.Sg;c=(c.b()?new Gl(O().c):c.o()).Ra.m();c=new xo(c,new y(l=>l.h()));c=kv(c,new U(()=>{var l=ef(b.ei).m();return new Ex(l,new Fx(a))}));c=Aq(Bq(),c);var d=Gx(a);c=c.Ce(d);var e=a.Ag();d=l=>{if(null!==l){var m=l.kc;if(null!==m)return l=new vl(b.gb.V+"#"+m.V),m=m.A(),Cq(l,m)}throw new w(l);};if(e===u())d=u();else{var g=e.e(),h=g=new z(d(g),u());for(e=e.f();e!==u();){var k=e.e();k=new z(d(k),u());h=h.p=k;e=e.f()}d=g}return c.Ce(d)}if(b instanceof
+Zn)return ap();throw new w(b);}
+function Jba(a){var b=px(a);b=b.b()?O().c:b.o();op();b=b.Ti();var c=Gx(a);b=b.dG(c);c=Ax(a).m();b=b.bf(new Ef(c,new y(k=>{var l=k.h().Rb;if(k.h().Om.b()){k=k.j();var m=V(a.J);k=new Uw(k.q,R(),k,m)}else m=a.J,t(),k=new Uw(m,new L(k.j()),k.j(),k.j().ma());return G(new H,l,k)})));c=Hx(a);for(var d=null,e=null;c!==u();){for(var g=c.e().oi.m();g.s();){var h=new z(g.t(),u());null===e?d=h:e.p=h;e=h}c=c.f()}c=null===d?u():d;for(e=d=null;c!==u();){h=c.e();a:{if(null!==h&&(g=h.h(),h=h.j(),h instanceof Vw)){g=
+new vl(g);g=G(new H,g,h.ig);h=O().c;g=new z(g,h);break a}g=O().c}for(g=g.m();g.s();)h=new z(g.t(),u()),null===e?d=h:e.p=h,e=h;c=c.f()}return b.bf(null===d?u():d)}
+function Kba(a){var b=a.Ab;if(b instanceof Zn){var c=a.J;if(c.F){c=ut(Q(),"| ",c.r);var d=b.Rb.x,e=Ix(b),g=a.cd.da,h=b.kx.b(),k=b.Qz;k.b()?k=!1:(k=k.o().CB(),k=dx(new E(k),cp()));ff(gf(),c+("Type "+d+" polymorphically? "+e+" \x26\x26 ("+g+" \x3d\x3d\x3d 0 || "+!h+" || ")+k+"\n")}if(Ix(b)){if(Pe(new E(a.cd.da),0)||!b.kx.b())return!0;a=b.Qz;if(a.b())return!1;a=a.o().CB();return dx(new E(a),cp())}return!1}xm("Program reached and unexpected state.")}
+function Pw(a,b,c,d,e,g,h){var k=c.x;if(!d.b()){var l=d.o(),m=b.Ag(),n=l.K();m=m.ab(n);if(Nm(new E(m),0)){m=a.J;n=new Te(new Ue(J(new K,[""," "," expects "," type parameter(s); got ",""])));var r=We(Xe(),b.fd().ld);k=We(Xe(),k);Xe();var v=b.Ag().K();v=We(0,""+v);Xe();var x=l.K();r=[r,k,v,We(0,""+x)];Lw(m,Ye(n,J(new K,r)),du(cu(),new z(c,l)),g)}}l=a.J;if(d.b())a=R();else{n=d.o();if(n===u())a=u();else{d=n.e();m=d=new z(ox(a.J,d,e,g,h,a.dt),u());for(n=n.f();n!==u();)r=n.e(),r=new z(ox(a.J,r,e,g,h,a.dt),
+u()),m=m.p=r,n=n.f();a=d}a=new L(a)}return Jx(l,b,c,a,e)}
+function Kx(a,b){var c=a.eo,d=new U(()=>a.ct?(Lw(a.J,Ye(new Te(new Ue(J(new K,["Unhandled cyclic definition"]))),u()),a.Ab.A(),b),new cx(a.J,a.Ab)):Lx(a.J,new U(()=>"Completing "+Mx(a.Ab)),new U(()=>{Nx(a.J,new U(()=>{var Ha=a.Ag();return"Type params "+ze(Ha,""," ","")}));Nx(a.J,new U(()=>{var Ha=iu(ju(),px(a));return"Params "+ze(Ha,""," ","")}));try{a.ct=!0;var e=a.Ab;if(e instanceof Zn){var g=!1,h=e.Yc;a:{if(h instanceof Ud){g=!0;var k=h.fa;if(k instanceof Vt){var l=k.Ws,m=k.Vs;Ox(a,e,b);var n=
+new y(Ha=>{var Ka=Ow(a),Oa=Qt(l,new y(Na=>{if(Na instanceof fe){Na=Na.aa.V;var Da=a.J,ta=V(a.J),Ya=t().d,dc=t().d,ka=O().c,ya=O().c;Da=new lx(Da,1,ka,ya,Ya,dc,!1,ta);return G(new H,Na,Da)}xm("Program reached and unexpected state.")}));op();Ka=Ka.bf(pp(qp(),Oa));Oa=nf();return ox(a.J,m,Ha,b,Ka,Oa)}),r=a.jg;Sw(a.cd.S);var v=Px(a.cd,n,b,r);var x=new bx(a.J,a.cd.da,e,new Qx(a.J,a.cd.da,v),!1);break a}}g&&xm("Program reached and unexpected state.");if(h instanceof fe){var A=h.aa;e.wd.b()||Ox(a,e,b);var B=
+(Rx(a)?0:!e.wd.b())?!e.Pl:!1;if(Rx(a))var C=Sx(a.cd,new y(Ha=>{var Ka=e.Ch,Oa=Tx(a);Ka=jv(Ka,Oa);Ka=Pe(new E(Ka),0);Oa=new U(()=>G(new H,e.Ch,Tx(a)));if(!Ka)throw new Yj("assertion failed: "+Es(Oa));Ka=Ow(a).bf(Tx(a));return(new y(Na=>Rw(a.J,A,Ha,b,Na,B))).n(Ka)}),b,a.jg);else if(e.Om.b())C=Rw(a.J,A,a.cd,b,Ow(a),B);else{var D=Rw(a.J,A,a.cd,b,Ow(a),B),F=Ux(a),I=a.jg,M=a.cd,N=Sw(a.J).ob;Tw(a.J,D,F,b,I,M,N);C=Ux(a)}var P=a.J,T=e.A(),Y=e.wd;if(Y instanceof L)var Z=e.Pl?"value":"let binding";else if(t().d===
+Y)Z="method";else throw new w(Y);var S=jx(new kx,P,T,"definition of "+Z+" "+e.Rb.x,(tx(a.J),t().d),(tx(a.J),!1));x=new bx(a.J,a.cd.da,e,ux(C.q,C,S),!0)}else throw new w(h);}Sx(a.cd,new y(Ha=>{var Ka=x.hh,Oa=Ux(a),Na=a.jg,Da=Sw(a.J).ob;Tw(a.J,Ka,Oa,b,Na,Ha,Da)}),b,a.jg);for(var ea=new y(Ha=>{Ha=Rw(a.J,Ha,a.cd,b,Ow(a),!1);var Ka=a.J.RE,Oa=a.jg,Na=a.cd,Da=Sw(a.J).ob;Tw(a.J,Ha,Ka,b,Oa,Na,Da)}),ia=e.Oz;!ia.b();)ea.n(ia.e()),ia=ia.f();var X=x}else if(e instanceof yo){if((Ot(new E(e.pb),zp())||Ot(new E(e.pb),
+cp()))&&!e.Qm.b()){g=a.J;var sa=new Te(new Ue(J(new K,["Explicit "," constructors are not supported"]))),Ja=[We(Xe(),e.pb.ld)],Xa=Ye(sa,J(new K,Ja)),Fa=e.Qm,za=new U(()=>t().d),Qa=new y(Ha=>Ha.A());Lw(g,Xa,Fa.b()?Es(za):Qa.n(Fa.o()),b)}for(var Ma=new y(Ha=>{Ha=Rw(a.J,Ha,a.cd,b,Ow(a),!1);var Ka=a.J.RE,Oa=a.jg,Na=a.cd,Da=Sw(a.J).ob;Tw(a.J,Ha,Ka,b,Oa,Na,Da)}),Ga=e.Rz;!Ga.b();)Ma.n(Ga.e()),Ga=Ga.f();var ab=e.pb;if(Fp()===ab){var Hb=e.Sg;if(Hb instanceof L){var bc=Hb.k;Lw(a.J,Ye(new Te(new Ue(J(new K,
+["trait parameters are not yet supported"]))),u()),bc.A(),b)}X=Sx(tf(a.cd),new y(Ha=>{Jw(Ha,Kw(a));Jw(Ha,Qt(Ax(a),new y(ya=>{var Sa=ya.h().Cf.x;ya=new qx(a.J,ya.j(),ya.h().Rb);return G(new H,Sa,ya)})));var Ka=new qx(a.J,Vx(a),new vl("this"));Wx(Ha,G(new H,"this",Ka));Ka=Hx(a);var Oa=Xx(a.J,e,V(a.J),Ha),Na=O().c,Da=nf(),ta=e.Hj,Ya=new U(()=>a.J.La),dc=new y(()=>Yx(a,Ha,e,b));Ka=Lba(a,Ka,Oa,Na,Da,ta.b()?Es(Ya):dc.n(ta.o()),b,e);if(null!==Ka)Na=new Gp(Ka.Uj,Ka.oj,Ka.oi,Ka.Xi);else throw new w(Ka);Ka=
+Na.oj;Oa=Na.oi;Na=Na.Xi;ta=ef(e.ei);for(Da=new y(ya=>{if(ya instanceof Zn&&ya.Yc instanceof fe)return Lw(a.J,Ye(new Te(new Ue(J(new K,["Method implementations in traits are not yet supported"]))),u()),ya.A(),b)});!ta.b();)Da.n(ta.e()),ta=ta.f();var ka=of(a.J,e.ei,(t(),new L(e)),Ha,b,Ow(a));Da=Ka.m();Da=new Ef(Da,new y(ya=>{var Sa=ya.Ua();return G(new H,Sa,ya)}));Da=kv(Da,new U(()=>Qt(ka.xk,new y(ya=>{var Sa=ya.Ua();return G(new H,Sa,ya)})))).nb(new U(()=>Zx(a)));op();Da=pp(qp(),Da);$x(a,Qt(Zx(a),
+new y(ya=>ya.j())),Ka,O().c,b,e);return new Ww(a.J,a.cd.da,e,a.Ag(),Da,a.J.La,Na,gx(a),Oa)}),b,a.jg)}else if(Ap()===ab){var yb=e.Sg,tb=new U(()=>new Gl(O().c));if(!(yb.b()?Es(tb):yb.o()).Ra.b()){var eb=a.J,kb=Ye(new Te(new Ue(J(new K,["Type alias definitions cannot have value parameters"]))),u()),Rb=e.Sg,Gb=new U(()=>new Gl(O().c)),vb=(Rb.b()?Es(Gb):Rb.o()).A(),Tb=G(new H,kb,vb),Nb=O().c;ay(eb,new z(Tb,Nb),b)}if(!e.Di.b()){var ic=a.J,Va=Ye(new Te(new Ue(J(new K,["Type alias definitions cannot extend parents"]))),
+u()),cb=du(cu(),e.Di),zb=G(new H,Va,cb),Ub=O().c;ay(ic,new z(zb,Ub),b)}var jb=e.Hj;if(jb instanceof L)var db=jb.k,ub=Sx(a.cd,new y(Ha=>ox(a.J,db,Ha,b,Ow(a),a.dt)),b,a.jg);else if(t().d===jb)ub=Lw(a.J,Ye(new Te(new Ue(J(new K,["Type alias definition requires a right-hand side"]))),u()),e.A(),b);else throw new w(jb);X=new ax(a.J,a.cd.da,e,a.Ag(),ub)}else if(Bp()===ab||zp()===ab)X=Sx(tf(a.cd),new y(Ha=>{var Ka=new $e;if(Ot(new E(e.pb),zp())&&!px(a).b()){var Oa=a.J,Na=new Te(new Ue(J(new K,[""," parameters are not supported"])));
+Xe();Q();var Da=[We(0,Nu(0,e.pb.ld))];Na=Ye(Na,J(new K,Da));Da=px(a);var ta=new U(()=>e.gb.A()),Ya=new y(Ba=>{cu();Ba=Ba.m();return du(0,new Ef(Ba,new y(ob=>ob.h())))});Lw(Oa,Na,Da.b()?Es(ta):Ya.n(Da.o()),b)}if(e.Pm.b()&&e.fl.b())if(Oa=e.Hj,Oa instanceof L)Na=Oa.k,Oa=a.J,Da=new Te(new Ue(J(new K,["Self-type annotations have no effects on non-abstract "," definitions"]))),ta=[We(Xe(),e.pb.ld)],Da=Ye(Da,J(new K,ta)),Na=Na.A(),Na=G(new H,Da,Na),Da=Ye(new Te(new Ue(J(new K,["Did you mean to use `extends` and inherit from a parent class?"]))),
+u()),ta=t().d,Da=G(new H,Da,ta),ta=O().c,by(Oa,new z(Na,new z(Da,ta)),b);else if(t().d!==Oa)throw new w(Oa);Jw(Ha,Kw(a));Jw(Ha,Qt(Ax(a),new y(Ba=>{var ob=Ba.h().Cf.x;Ba=new qx(a.J,Ba.j(),Ba.h().Rb);return G(new H,ob,Ba)})));Oa=e.Hj;Na=new U(()=>a.J.La);Da=new y(()=>Yx(a,Ha,e,b));Oa=Oa.b()?Es(Na):Da.n(Oa.o());Na=a.J;Da=a.Ab.A();Na=jx(new kx,Na,Da,cy(a.Ab),(tx(a.J),t().d),(tx(a.J),!1));Da=Vx(a);ta=Qt(a.Ag(),new y(Ba=>{if(null!==Ba){var ob=Ba.kc;Ba=Ba.hb;var nc=e.gb.V+"#"+ob.V,Ib=new mx(a.J,Ba,Ba.ji),
+vc=a.J;nc=new Ep(nc);ob=ob.A();return new Vw(vc,Cq(nc,ob),new Uw(a.J,(t(),new L(Ib)),Ib,Ba.ji),!0,Ha.da)}throw new w(Ba);}));var dc=Qt(ta,new y(Ba=>{var ob=Ba.ij.Zr();return G(new H,ob,Ba.ig)}));Ya=px(a);var ka=new y(Ba=>{Ba=dy(lv(),Ba);var ob=dy(lv(),dc);ob=Aq(Bq(),ob);return ey(Ba,ob)});Ya=!(!Ya.b()&&ka.n(Ya.o()));ka=new U(()=>{no()});if(!Ya)throw new Yj("assertion failed: "+Es(ka));Ya=a.J;ka=O().c;var ya=a.J,Sa=du(cu(),e.Di),xc=new y(Ba=>vs(Ba));Ya=new Qv(Ya,ka,jx(new kx,ya,Sa.b()?R():new L(xc.n(Sa.o())),
+"Object",(tx(a.J),t().d),(tx(a.J),!1)));ka=px(a);ya=new U(()=>O().c);ka=Qt(ka.b()?Es(ya):ka.o(),new y(Ba=>new Vw(a.J,Ba.h(),Ba.j(),!fy(a).L(Ba.h()),Ha.da)));Ka=Mba(a,Hx(a),Nba(Ka.sb?Ka.vb:Oba(a,Ka),Ya,un(ta,ka),t().d,O().c,O().c,nf(),Oa),Da,Ha,b,Na,e,dc,Oa);if(null!==Ka)Da=new bo(Ka.Eq,Ka.Os,Ka.Gu,Ka.Qs,Ka.Ps,Ka.Rm);else throw new w(Ka);ta=Da.lr;var Sb=Da.mr,uc=Da.rt,Lb=Da.st;Ka=Da.tt;Da=Da.kv;Ya=new qx(a.J,Vx(a),new vl("this"));Wx(Ha,G(new H,"this",Ya));ta=new qx(a.J,ta,new vl("super"));Wx(Ha,G(new H,
+"super",ta));ta=of(a.J,e.ei,(t(),new L(e)),Ha,b,Ow(a));Ya=uc.BK(new y(Ba=>Ba.tr()));if(null!==Ya)Ya=G(new H,Ya.h(),Ya.j());else throw new w(Ya);var lc=Ya.h();Nx(a.J,new U(()=>"baseClsImplemMembers "+lc));var Xb=ta.xk,ec=Qt(Zx(a),new y(Ba=>Ba.j()));Lx(a.J,new U(()=>"Checking `this` accesses..."),new U(()=>{var Ba=gy(Xb,new y(Vb=>Vb.tr()),!1),ob=ef(e.ei);ob=gy(ob,new y(Vb=>!(Vb instanceof Ct)),!1);var nc=e.Qm,Ib=new U(()=>O().c),vc=new y(Vb=>Vb.js.Dj);nc=nc.b()?Es(Ib):vc.n(nc.o());Pba(a,Ba,un(ob,nc),
+uc,ec,b)}),a.J.qa);ta=Xb.m().nb(new U(()=>Sb));ta=new Ef(ta,new y(Ba=>Ba.Ua()));var Ab=Aq(Bq(),ta);ta=lc.m();ta=new hy(ta,new y(Ba=>Ba.Ua()));ta=new iy(ta,new y(Ba=>Ab.L(Ba.Ua())),!0);Od();var Ob=Pd(u(),ta);Lx(a.J,new U(()=>"Checking base class implementations against inherited signatures..."),new U(()=>{$x(a,Ob,Lb,O().c,b,e)}),a.J.qa);var fb=jy(a,uc,Lb,e,b);ta=Xb.m().nb(new U(()=>Sb));ta=new hy(ta,new y(Ba=>Ba.Ua()));Od();var Wa=Pd(u(),ta);Lx(a.J,new U(()=>"Checking new implementations against inherited signatures..."),
+new U(()=>{var Ba=ec.m().nb(new U(()=>fb));Ba=new hy(Ba,new y(ob=>ob.Ua()));Od();$x(a,Wa,Pd(u(),Ba),ec,b,e)}),a.J.qa);ta=un(un(Xb,Sb),lc);var bb=ky(ta,new y(Ba=>Ba.Ua()));Lx(a.J,new U(()=>"Checking new signatures against inherited signatures..."),new U(()=>{$x(a,ec,fb,ec,b,e)}),a.J.qa);Lx(a.J,new U(()=>"Checking signature implementations..."),new U(()=>{var Ba=ec.m().nb(new U(()=>fb.m()));Ba=new hy(Ba,new y(ob=>ob.Ua()));Ba=new iy(Ba,new y(ob=>ob.tr()),!0);Od();ly(a,bb,Pd(u(),Ba),e,b)}),a.J.qa);ta=
+Qt(un(fb,bb),new y(Ba=>{var ob=Ba.Ua();return G(new H,ob,Ba)}));op();var Ia=pp(qp(),ta).bf(Zx(a));Nx(a.J,new U(()=>"allMembers "+Ia));ta=e.Qm;a:{if(ta instanceof L){var Ua=ta.k;if(null!==Ua){var pc=Ua.ks,sc=Ua.js;ya=Sx(tf(a.cd),new y(Ba=>{for(var ob=Qt(pc.Ra,new y(Pb=>{if(null!==Pb){var Jb=Pb.h(),gc=Pb.j();if(Jb instanceof L&&(Jb=Jb.k,null!==gc)){var Cb=gc.yb;gc=gc.ya;if(null!==Cb){var cc=Cb.ch,yc=Cb.Bh,Mc=new U(()=>"TODO");if(Cb.je||cc)throw new Yj("assertion failed: "+Es(Mc));yc&&my(a,Jb.A(),b);
+Cb=Qn(gc);if(Cb instanceof Ud)return Pb=ox(a.J,Cb.fa,Ba,b,Ow(a),a.dt),G(new H,Jb,Pb);no()}}}if(null!==Pb&&(Cb=Pb.h(),Jb=Pb.j(),t().d===Cb&&null!==Jb&&(cc=Jb.yb,Jb=Jb.ya,null!==cc&&(Cb=cc.je,gc=cc.ch,cc=cc.Bh,Jb instanceof vl)))){Pb=new U(()=>"TODO");if(Cb||gc)throw new Yj("assertion failed: "+Es(Pb));cc&&my(a,Jb.A(),b);Pb=a.J;Cb=ny(a.J,Jb,!1);gc=t().d;t();cc=new L(Jb.x);yc=O().c;Mc=O().c;Pb=new lx(Pb,Ba.da,yc,Mc,gc,cc,!1,Cb);return G(new H,Jb,Pb)}if(null!==Pb&&(Jb=Pb.h(),Cb=Pb.j(),t().d===Jb&&null!==
+Cb))return Jb=Cb.ya,Pb=new vl("\x3cerror\x3e"),Jb=Lw(a.J,Ye(new Te(new Ue(J(new K,["Unsupported constructor parameter shape"]))),u()),Jb.A(),b),G(new H,Pb,Jb);throw new w(Pb);})),nc=new y(Pb=>{if(null!==Pb){var Jb=Pb.h(),gc=Jb.x;Pb=new qx(a.J,Pb.j(),Jb);Wx(Ba,G(new H,gc,Pb))}else throw new w(Pb);}),Ib=ob;!Ib.b();)nc.n(Ib.e()),Ib=Ib.f();var vc=jx(new kx,a.J,Ua.A(),"auxiliary class constructor",(tx(a.J),t().d),(tx(a.J),!1));null!==sc?nc=sc.Dj:(nc=O().c,nc=new z(sc,nc));Ib=Xu();lv();var Vb=px(a),fc=
+new U(()=>O().c);Vb=Vb.b()?Es(fc):Vb.o();var Bc=Ib.Ib(ry(0,Vb,it()));for(Ib=new y(Pb=>{if(Pb instanceof bm){var Jb=Pb.Vn,gc=Pb.Zo;return Bc.ou(Jb,new y(Cb=>{var cc=!1,yc=null;if(Cb instanceof L){cc=!0;yc=Cb;var Mc=yc.k;if(Mc instanceof L)return cc=Mc.k,Cb=Rw(a.J,gc,Ba,b,Ow(a),!1),cc=cc.ra,yc=Sw(a.J).ob,Tw(a.J,Cb,cc,b,vc,Ba,yc),cc=Jb.x,Cb=new qx(a.J,Cb,Jb),Wx(Ba,G(new H,cc,Cb)),t(),Cb=t().d,new L(Cb)}if(cc&&(cc=yc.k,t().d===cc))return Cb=a.J,cc=new Te(new Ue(J(new K,["Class parameter '","' was already set"]))),
+yc=[We(Xe(),Jb.x)],Lw(Cb,Ye(cc,J(new K,yc)),Jb.A(),b),t().d;if(t().d===Cb)return Cb=a.J,cc=new Te(new Ue(J(new K,["Unknown class parameter '","'"]))),yc=[We(Xe(),Jb.x)],Lw(Cb,Ye(cc,J(new K,yc)),Jb.A(),b),t().d;throw new w(Cb);}))}if(sy(Pb))return ty(a.J,Pb,!1,Ba,b,Ow(a),!1);xm("Program reached and unexpected state.")});!nc.b();)Ib.n(nc.e()),nc=nc.f();t();return new L(ob)}),b,Na);break a}}if(t().d===ta)ya=t().d;else throw new w(ta);}Ia.og(new fn((Ba,ob)=>{Ba=G(new H,Ba,ob);var nc=Ba.y,Ib=Ba.w;if(Ib instanceof
+bx&&!Ib.Mb.Om.b()){var vc=uy(Ib.hh);if(!Ib.Mb.Yc.tv()&&Ib.Mb.kx.b())if(vc instanceof lx&&vc.Sb.b()){Ba=vy(vc);Ba=Qba(Ba,new fn((fc,Bc)=>{var Pb=V(fc.q);return dv(fc,Bc,Pb,!1)}));ob=new U(()=>{var fc=a.J,Bc=new Te(new Ue(J(new K,["Could not infer a type for unused mutable field ",""]))),Pb=[We(Xe(),nc)];return Lw(fc,Ye(Bc,J(new K,Pb)),Ib.Mb.A(),b)});var Vb=Ba.b()?Es(ob):Ba.o();Nx(a.J,new U(()=>"Setting type of "+nc+" based on inferred lower bounds: "+vc+" :\x3d "+Vb));wy(vc,(t(),new L(Vb)))}else xm(vc.u())}}));
+xy||(xy=new yy);Na=a.J;ta=a.cd.da;Ya=a.Ag();ka=px(a);Sa=new U(()=>{ju();var Ba=px(a).b()&&Ot(new E(e.pb),Bp())?!!e.Pm.b():!1;return zy(0,Ba,new U(()=>O().c))});ya=ya.b()?Es(Sa):ya;Oa=new Yw(Na,ta,e,Ya,ka,ya,Ia,a.J.La,e.Pm.b()?Oa:Da,gx(a),Ka);return Rba(Oa,new y(Ba=>Ay(Ba,Ha)))}),b,a.jg);else if(cp()===ab){if(!e.Di.b()){var Aa=a.J,va=Ye(new Te(new Ue(J(new K,["mixin definitions cannot yet extend parents"]))),u()),Ra=du(cu(),e.Di),rb=G(new H,va,Ra),xb=O().c;ay(Aa,new z(rb,xb),b)}var mc=a.cd;X=Sx(tf(a.cd),
+new y(Ha=>{Jw(Ha,Kw(a));Jw(Ha,Qt(Ax(a),new y(ya=>{var Sa=ya.h().Cf.x;ya=new qx(a.J,ya.j(),ya.h().Rb);return G(new H,Sa,ya)})));var Ka=px(a),Oa=new y(ya=>Qt(ya,new y(Sa=>{var xc=Sa.h().x;Sa=new Vw(a.J,Sa.h(),Sa.j(),!fy(a).L(Sa.h()),Ha.da);return G(new H,xc,Sa)})));Ka=Ka.b()?R():new L(Oa.n(Ka.o()));Oa=new U(()=>O().c);Ka=Ka.b()?Es(Oa):Ka.o();op();Ka=Ka.Ti();Oa=a.J;var Na=V(a.J),Da=t().d;t();var ta=new L("this"),Ya=O().c,dc=O().c;Oa=new lx(Oa,Ha.da,Ya,dc,Da,ta,!1,Na);Na=a.J;Da=V(a.J);ta=t().d;t();Ya=
+new L("super");dc=O().c;var ka=O().c;Na=new lx(Na,Ha.da,dc,ka,ta,Ya,!1,Da);Da=new qx(a.J,Oa,new vl("this"));Wx(Ha,G(new H,"this",Da));Da=new qx(a.J,Na,new vl("super"));Wx(Ha,G(new H,"super",Da));Da=of(a.J,e.ei,(t(),new L(e)),Ha,b,Ow(a)).xk;ta=Qt(Zx(a),new y(ya=>ya.j()));$x(a,Da,ta,ta,b,e);ly(a,Da,ta,e,b);Da=Qt(Da,new y(ya=>{var Sa=ya.Ua();return G(new H,Sa,ya)}));op();Ka=Ka.bf(pp(qp(),Da)).bf(Zx(a));Da=a.J;ta=mc.da;Ya=a.Ag();dc=px(a);ka=new U(()=>O().c);return new Nw(Da,ta,e,Oa,Na,Ya,dc.b()?Es(ka):
+dc.o(),Ka)}),b,a.jg)}else throw new w(ab);}else throw new w(e);}finally{a.ct=!1}a.eo=(t(),new L(X));return X}),new y(e=>{var g=e.bG();var h=O().c;g=new By(g,new z(e,h),t().d);g=xx(g);return"Completed "+e+" where "+g})));return c.b()?Es(d):c.o()}
+function Cy(a,b,c,d){var e=a.Ab;if(e instanceof Zn){if(a.ct)return b=a.J,b.F&&(b=ut(Q(),"| ",b.r)+"Already computing! Using TV: "+Ux(a),ff(gf(),b+"\n")),Ux(a);a=Kx(a,d);if(a instanceof bx)return a.hh;xm("Program reached and unexpected state.")}else if(e instanceof yo){if(e.Qm.b())return Dy(a.J,b,c,e,a.Ru,a.Ag(),px(a),t().d,gx(a),d);e=Kx(a,d);if(e instanceof Yw)return Dy(e.nc,b,c,e.Rf,e.Sm,e.gh,e.Ij,e.gl,0,d);if(e instanceof cx)return Ey(a.J);xm("Program reached and unexpected state.")}else throw new w(e);
+}function $w(a,b,c,d,e){var g=c.ab(b);if(Nm(new E(g),0)){g=a.J;var h=new Te(new Ue(J(new K,["class "," expects "," parameter(s); got ",""])));d=We(Xe(),d);b=We(Xe(),""+b);Xe();var k=c.K();b=[d,b,We(0,""+k)];h=Ye(h,J(new K,b));cu();b=op();c=c.Gb(b.ga).j();Lw(g,h,du(0,new z(e,c)),a.ne)}}function Ox(a,b,c){b.Ch.b()||Lw(a.J,Ye(new Te(new Ue(J(new K,["Type parameters are not yet supported in this position"]))),u()),b.Ch.e().A(),c)}
+function Fy(a,b){if(Gy(a.Mb))return!0;a=b.U(a.Ua());return a instanceof L&&(a=a.k,a instanceof bx)?!a.Mb.lx.b():!1}
+function Hy(a,b,c,d,e,g,h,k){var l=b.uE;if(l.b()){b=b.Uz;l=t().d;for(b=b.m();b.s();){var m=l;l=b.t();if(m.b())a:{if(m=c.U(l.h().x),m instanceof L&&(m=m.k,m instanceof bx)){if(d.b())var n=!0;else n=d.o(),n=Nm(new E(n),l.h().x);if(n&&!e.L(l.h().x)){n=l.j();if(n instanceof L&&(!g||Fy(m,h))){l=n;break a}m=Iy(m);t();l=Jy(a,m,new L(l.h().x),new z(l.h().x,e),!1,c,k,h);break a}}l=t().d}else l=m}return l}return l}
+function Jy(a,b,c,d,e,g,h,k){if(c.b())return Hy(a,b,g,c,d,e,k,h);var l=c.o();if(ca(h)!==da(Ky)){var m=h.U(l);if(m instanceof L)h=m.k;else{if(R()!==m)throw new w(m);a=Hy(a,b,g,c,d,e,k,h);Ly(h,l,a,!1);h=a}}else{m=My(W(),l);m^=m>>>16|0;var n=m&(-1+h.eb.a.length|0),r=h.eb.a[n];r=null===r?null:Ny(r,l,m);null!==r?h=r.Ah:(r=h.eb,a=Hy(a,b,g,c,d,e,k,h),(1+h.Xf|0)>=h.hu&&Oy(h,h.eb.a.length<<1),Py(h,l,a,!1,m,r===h.eb?n:m&(-1+h.eb.a.length|0)),h=a)}return h}
+function Qy(a,b,c,d,e,g){b.Uz.Ca(new y(h=>{if(h.j().b()){var k=d.U(h.h().x);if(k instanceof L){var l=k.k;if(l instanceof bx&&Fy(l,g)){k=a.J;var m=new Te(new Ue(J(new K,["Unqualified access to virtual member ",""])));h=[We(Xe(),h.h().x)];h=Ye(m,J(new K,h));h=G(new H,h,c);m=Ye(new Te(new Ue(J(new K,["Declared here:"]))),u());l=l.Mb.A();l=G(new H,m,l);m=O().c;return ay(k,new z(h,new z(l,m)),e)}}}}))}
+function Ry(a,b){var c=a.j(),d=b.j();if(c instanceof L&&(c=c.k,d instanceof L&&Sy(c,d.k)))return a=G(new H,a.h(),d),b=O().c,new z(a,b);d=O().c;return new z(a,new z(b,d))}
+function Pba(a,b,c,d,e,g){Ty();var h=u();h=Uy(h);var k=A=>{var B=A.Ua();return G(new H,B,A)};if(e===u())k=u();else{var l=e.e(),m=l=new z(k(l),u());for(e=e.f();e!==u();){var n=e.e();n=new z(k(n),u());m=m.p=n;e=e.f()}k=l}op();k=pp(qp(),k);d=d.m().nb(new U(()=>b));d=new Ef(d,new y(A=>{var B=A.Ua();return G(new H,B,A)}));op();d=k.bf(pp(qp(),d));for(l=b;!l.b();){m=l.e();if(m instanceof bx){var r=m;m=r.Mb;e=Iy(r);if(!m.wd.b()){t();n=r.Ua();n=new L(n);var v=r.Ua(),x=O().c;n=Jy(a,e,n,new z(v,x),!0,d,h,k);
+if(n instanceof L)v=n.k,n=a.J,x=new Te(new Ue(J(new K,["Cannot access `this` while initializing field ",""]))),r=[We(Xe(),r.Ua())],r=Ye(x,J(new K,r)),x=m.A(),r=G(new H,r,x),x=Ye(new Te(new Ue(J(new K,["The access to `this` is here"]))),u()),v=v.A(),ay(n,Ry(r,G(new H,x,v)),g);else if(t().d!==n)throw new w(n);}Qy(a,e,m.A(),d,g,k)}l=l.f()}for(;!c.b();){l=c.e();a:{if(l instanceof Cl&&(m=l.ai,m instanceof vl&&"this"===m.x))break a;m=Vy(a.J,l);e=Jy(a,m,t().d,O().c,!1,d,h,k);if(e instanceof L)n=e.k,e=a.J,
+r=Ye(new Te(new Ue(J(new K,["Cannot access `this` during object initialization"]))),u()),v=l.A(),r=G(new H,r,v),v=Ye(new Te(new Ue(J(new K,["The access to `this` is here"]))),u()),n=n.A(),ay(e,Ry(r,G(new H,v,n)),g);else if(t().d!==e)throw new w(e);Qy(a,m,l.A(),d,g,k)}c=c.f()}}
+function Wy(a,b,c,d,e){a=a.J;var g=new Te(new Ue(J(new K,["Member `","` is declared (or its declaration is inherited) but is not implemented in `","`"]))),h=[We(Xe(),c.Ua()),We(Xe(),d.gb.V)];g=Ye(g,J(new K,h));d=d.gb.A();d=G(new H,g,d);g=Ye(new Te(new Ue(J(new K,["Declared here:"]))),u());c=c.A();c=G(new H,g,c);ay(a,new z(d,new z(c,b)),e)}
+function ly(a,b,c,d,e){for(var g=Xu().X();!b.b();){var h=b.e();g.ou(h.Ua(),new y(((m,n,r)=>v=>{if(v instanceof L){v=a.J;var x=new Te(new Ue(J(new K,["Duplicated `","` member definition in `","`"]))),A=[We(Xe(),m.Ua()),We(Xe(),n.Cf.x)];Lw(v,Ye(x,J(new K,A)),m.A(),r);return t().d}if(t().d===v)return t(),new L(m);throw new w(v);})(h,d,e)));b=b.f()}if(d.fl.b()&&Nm(new E(d.pb),Fp())&&d.Pm.b())for(;!c.b();){b=c.e();h=g.U(b.Ua());if(h instanceof L){if(h=h.k,!h.Mp()){var k=new Te(new Ue(J(new K,["Note: ",
+" member `","` is private and cannot be used as a valid implementation"]))),l=[We(Xe(),h.fd().ld),We(Xe(),b.Ua())];k=Ye(k,J(new K,l));h=h.A();h=G(new H,k,h);k=O().c;Wy(a,new z(h,k),b,d,e)}}else if(t().d===h)Wy(a,O().c,b,d,e);else throw new w(h);c=c.f()}}
+function $x(a,b,c,d,e,g){var h=a.cd,k=a.jg,l=1+h.da|0,m=Hw(),n=Su(),r=op().ga;m=m.Hd(new Uu(n,r));l=new Iw(h.S,h.Ec,h.hc,h.Ed,l,h.Pc,h.Zc,h.Lb,h.yc,h.tb,h.$a,h.od,m);for(m=Xu().X();!c.b();)n=c.e(),m.ou(n.Ua(),new y((C=>D=>{if(D instanceof L)xm("Program reached and unexpected state.");else{if(t().d===D)return t(),new L(C);throw new w(D);}})(n))),c=c.f();for(;!b.b();){c=b.e();n=a.J;n.F&&(n=ut(Q(),"| ",n.r)+("Checking overriding for "+c+" against "+m.U(c.Ua()))+"...",ff(gf(),n+"\n"));r=G(new H,c,m.U(c.Ua()));
+a:if(n=r.w,t().d!==n){n=r.y;var v=r.w;if(n&&n.$classData&&n.$classData.rb.xE&&v instanceof L&&(v=v.k)&&v.$classData&&v.$classData.rb.xE){c=v;if(!c.Mp())break a;if(c instanceof bx&&!Gy(c.Mb)&&!d.L(c)){r=a.J;v=new Te(new Ue(J(new K,[""," member '","' is not virtual and cannot be overridden"])));Xe();Q();var x=n.fd().ld;x=[We(0,Nu(0,x)),We(Xe(),n.Ua())];v=Ye(v,J(new K,x));n=n.A();n=G(new H,v,n);v=Ye(new Te(new Ue(J(new K,["Originally declared here:"]))),u());c=c.A();c=G(new H,v,c);v=O().c;ay(r,new z(n,
+new z(c,v)),e);break a}if(c instanceof Vw&&!d.L(c)){r=a.J;v=new Te(new Ue(J(new K,["Inherited parameter named '","' is not virtual and cannot be overridden"])));x=[We(Xe(),n.Ua())];v=Ye(v,J(new K,x));n=n.A();n=G(new H,v,n);v=Ye(new Te(new Ue(J(new K,["Originally declared here:"]))),u());c=c.A();c=G(new H,v,c);v=O().c;ay(r,new z(n,new z(c,v)),e);break a}if(n instanceof bx&&rx(n.Mb)){r=a.J;v=new Te(new Ue(J(new K,["Cannot implement "," member '","' with a let binding"])));x=[We(Xe(),n.fd().ld),We(Xe(),
+n.Ua())];v=Ye(v,J(new K,x));x=n.A();v=G(new H,v,x);x=Ye(new Te(new Ue(J(new K,["Originally declared here:"]))),u());var A=c.A();x=G(new H,x,A);A=O().c;ay(r,new z(v,new z(x,A)),e)}n=n.Nn();r=n.ma();c=c.Nn();v=Sw(a.J).ob;Tw(a.J,n,c,e,r,l,v);break a}n=r.w;if(n instanceof L)r=n.k,n=a.J,v=new Te(new Ue(J(new K,[""," member '","' cannot override "," member of the same name declared in parent"]))),Xe(),Q(),x=c.fd().ld,c=[We(0,Nu(0,x)),We(Xe(),c.Ua()),We(Xe(),r.fd().ld)],c=Ye(v,J(new K,c)),v=g.A(),c=G(new H,
+c,v),v=Ye(new Te(new Ue(J(new K,["Originally declared here:"]))),u()),r=r.A(),r=G(new H,v,r),v=O().c,ay(n,new z(c,new z(r,v)),e);else throw new w(r);}b=b.f()}a=l.cb;up(tp(),h.S.li||l.cb.b());if(!a.b()){d=h.S.qa;g=h.S;g.F&&(l=ut(Q(),"| ",g.r)+"UNSTASHING... (out)",ff(gf(),l+"\n"));g.r=1+g.r|0;try{a.Ca(new y(C=>{if(null!==C){var D=C.h();for(C=C.j().m();C.s();){var F=C.t();a:{if(null!==F){var I=F.j();if(!0===F.Rc()){F=Sw(h.S).ob;Tw(h.S,I,D,e,k,h,F);break a}}if(null!==F&&(I=F.j(),!1===F.Rc())){F=Sw(h.S).ob;
+Tw(h.S,D,I,e,k,h,F);break a}throw new w(F);}}}else throw new w(C);}));a.mg();var B=void 0}finally{g.r=-1+g.r|0}dx(new E(d),g.qa)&&g.F&&(B=""+ut(Q(),"| ",g.r)+d.n(B),ff(gf(),B+"\n"))}}
+function Sba(a,b,c,d,e){var g=new y(B=>{var C=B.Ea();C=Pe(new E(C),b.Ea());var D=new U(()=>new Gu(b.Ea(),B.Ea()));if(!C)throw new Yj("assertion failed: "+Es(D));});c.b()||g.n(c.o());g=G(new H,b,c);c=g.y;var h=g.w;if(c instanceof bx&&h instanceof L){var k=h.k;if(k instanceof bx){up(tp(),!(c.Ts&&k.Ts));d=G(new H,c.Mb.wd,k.Mb.wd);a:{e=d.y;d=d.w;if(e instanceof L&&(e=!!e.k,d instanceof L)){d=!!d.k;t();e=new L(e||d);break a}e=t().d}d=c.Mb.Rb;g=t().d;h=c.Mb.Ch;var l=c.Mb.Yc,m=c.Mb.Pz,n=c.Mb.lx,r=c.Mb.Om,
+v=t().d,x=c.Mb.Qz,A=new U(()=>k.Mb.Qz);e=new Zn(e,d,g,h,l,m,n,r,v,x.b()?Es(A):x,c.Mb.Pl,c.Mb.Oz);t();a=a.J;d=c.jp;g=c.hh;h=k.hh;l=V(c.hh.q);a=new bx(a,d,e,Pu(g,h,l,!1),c.Ts||k.Ts);return new L(a)}}c=g.y;h=g.w;if(c instanceof Vw&&h instanceof L&&(h=h.k,h instanceof Vw)){if(c.bo){if(h.bo)return t(),a=new Vw(a.J,c.ij,Nv(c.ig,h.ig,V(c.ig.Va)),!0,c.Tz),new L(a);t();return new L(c)}t();return new L(h)}c=g.y;h=g.w;if(c instanceof Vw&&h instanceof L&&(h=h.k,h instanceof bx))return t(),a=a.J,e=c.Tz,d=h.Mb,
+g=c.ig.ra,h=h.hh,c=V(c.ig.ra.q),a=new bx(a,e,d,Pu(g,h,c,!1),!0),new L(a);c=g.y;h=g.w;if(c instanceof bx&&h instanceof L&&(h=h.k,h instanceof Vw))return t(),a=a.J,e=c.jp,d=c.Mb,g=h.ig.ra,c=c.hh,h=V(h.ig.ra.q),a=new bx(a,e,d,Pu(g,c,h,!1),!0),new L(a);c=g.y;h=g.w;if(t().d===h)return t(),new L(c);h=g.y;c=g.w;if(c instanceof L)return c=c.k,a=a.J,g=new Te(new Ue(J(new K,["Intersection of "," member and "," members currently unsupported"]))),l=[We(Xe(),h.fd().ld),We(Xe(),c.fd().ld)],g=Ye(g,J(new K,l)),d=
+d.A(),d=G(new H,g,d),g=new Te(new Ue(J(new K,["The "," member is defined here:"]))),l=[We(Xe(),h.fd().ld)],g=Ye(g,J(new K,l)),h=h.A(),g=G(new H,g,h),h=new Te(new Ue(J(new K,["The "," member is defined here:"]))),l=[We(Xe(),c.fd().ld)],h=Ye(h,J(new K,l)),c=c.A(),c=G(new H,h,c),h=O().c,ay(a,new z(d,new z(g,new z(c,h))),e),t().d;throw new w(g);}
+function jy(a,b,c,d,e){var g=m=>{var n=m.Ua();return G(new H,n,m)};if(c===u())g=u();else{var h=c.e(),k=h=new z(g(h),u());for(c=c.f();c!==u();){var l=c.e();l=new z(g(l),u());k=k.p=l;c=c.f()}g=h}op();for(g=pp(qp(),g);!b.b();)h=b.e(),g=g.IC(h.Ua(),new y(((m,n,r)=>v=>Sba(a,m,v,n,r))(h,d,e))),b=b.f();return g.tT().ha()}
+function Yx(a,b,c,d){var e=tf(b),g=a.jg,h=1+e.da|0,k=Hw(),l=Su(),m=op().ga;k=k.Hd(new Uu(l,m));h=new Iw(e.S,e.Ec,e.hc,e.Ed,h,e.Pc,e.Zc,e.Lb,e.yc,e.tb,e.$a,e.od,k);c=c.Hj;c=ox(a.J,c.b()?gl():c.o(),h,d,Ow(a),a.dt);k=Xu().X();c=c.Kc(b.da,!0,h,k);k=h.cb;up(tp(),e.S.li||h.cb.b());if(!k.b()){h=e.S.qa;l=e.S;l.F&&(m=ut(Q(),"| ",l.r)+"UNSTASHING... (out)",ff(gf(),m+"\n"));l.r=1+l.r|0;try{k.Ca(new y(v=>{if(null!==v){var x=v.h();for(v=v.j().m();v.s();){var A=v.t();a:{if(null!==A){var B=A.j();if(!0===A.Rc()){A=
+Sw(e.S).ob;Tw(e.S,B,x,d,g,e,A);break a}}if(null!==A&&(B=A.j(),!1===A.Rc())){A=Sw(e.S).ob;Tw(e.S,x,B,d,g,e,A);break a}throw new w(A);}}}else throw new w(v);}));k.mg();var n=void 0}finally{l.r=-1+l.r|0}dx(new E(h),l.qa)&&l.F&&(n=""+ut(Q(),"| ",l.r)+h.n(n),ff(gf(),n+"\n"))}n=a.J;h=V(a.J);k=t().d;l=t().d;m=O().c;var r=O().c;n=new lx(n,b.da,m,r,k,l,!1,h);h=a.jg;k=Sw(a.J).ob;Tw(a.J,c,n,d,h,b,k);b=vy(n);if(b instanceof z&&(a=b.z,b=b.p,c=O().c,null===c?null===b:c.i(b)))return a;xm("Program reached and unexpected state.")}
+function Lba(a,b,c,d,e,g,h,k){for(;;){var l=!1,m=null,n=b;if(n instanceof z){l=!0;m=n;var r=m.z;b=m.p;if(null!==r){var v=r.Uj,x=r.oj;r=r.oi;if(v instanceof Ww){m=v;if(!x.b())throw new Yj("assertion failed: "+x);n=a;l=c;x=m.uk;c=V(c.q);c=Pu(l,x,c,!1);l=new rp(m.tk);Od();d=jy(a,d,Pd(u(),l),k,h);e=e.bf(r);a=g;r=m.uk;g=V(g.q);g=Pu(a,r,g,!1);a=n;continue}}}if(l&&(b=m.z,r=m.p,null!==b)){b=b.Xi;Lw(a.J,Ye(new Te(new Ue(J(new K,["A trait can only inherit from other traits"]))),u()),b,h);b=r;continue}h=O().c;
+if(null===h?null===n:h.i(n))return new Gp(c,d,e,g);throw new w(n);}}function Oba(a,b){if(null===b)throw le();return b.sb?b.vb:me(b,new Xy(a))}
+function Mba(a,b,c,d,e,g,h,k,l,m){for(var n=a;;){var r=b;if(r instanceof z){var v=r,x=v.z,A=v.p;if(null!==x){var B=x.Uj,C=x.oj,D=x.oi,F=x.Xi,I=n.J;if(I.F){var M=ut(Q(),"| ",I.r)+"\x3d\x3e Inheriting from "+B;ff(gf(),M+"\n")}if(B instanceof Nw){var N=B;up(tp(),Pe(new E(d.Xa),e.da));tp();var P=N.hl.Ea();up(0,Pe(new E(P),e.da));tp();var T=N.jl.Ea();up(0,Pe(new E(T),e.da));var Y=c.Eq,Z=N.hl,S=Sw(n.J).ob;Tw(n.J,Y,Z,g,h,e,S);var ea=N.jl,ia=Sw(n.J).ob;Tw(n.J,d,ea,g,h,e,ia);up(tp(),D.b());var X=N.Jj.ie(),
+sa=new iy(X,new y($a=>Yy($a)),!0),Ja=un(C,sa),Xa=n.J,Fa=c.Eq,za=n.J,Qa=Wn(Ja,new Zy(n)),Ma=new Qv(za,Qa,V(n.J)),Ga=new $y(Xa,Fa,Ma,V(n.J)),ab=n,Hb=c,bc=un(Ja,c.Os),yb=new az(Hb.Sz,Ga,bc,c.Hu,c.Gu,c.Qs,c.Ps,c.Rm);n=ab;b=A;c=yb;continue}else if(B instanceof Ww){var tb=B;if(!C.b())throw new Yj("assertion failed: "+C);var eb=n,kb=n,Rb=c.Qs,Gb=tb.tk.ie(),vb=new iy(Gb,new y($a=>Yy($a)),!0);Od();var Tb=jy(kb,Rb,Pd(u(),vb),k,g),Nb=c.Ps.bf(D),ic=c.Rm,Va=tb.uk,cb=V(c.Rm.q),zb=Pu(ic,Va,cb,!1),Ub=new az(c.Sz,
+c.Eq,c.Os,c.Hu,c.Gu,Tb,Nb,zb);n=eb;b=A;c=Ub;continue}else if(B instanceof Yw){var jb=B,db=jb.Rf.gb.V,ub=c.Hu,Aa=n;if(!ub.b()){var va=ub.o(),Ra=Aa.J,rb=new Te(new Ue(J(new K,["Cannot inherit from more than one base class: "," and ",""]))),xb=[We(Xe(),va),We(Xe(),db)];Lw(Ra,Ye(rb,J(new K,xb)),F,g)}var mc=jb.Ei.ie();Od();var Ha=Pd(u(),mc);if(Ha.b())var Ka=Od().jC;else{Od();var Oa=new fp;Od();for(var Na=new fp,Da=Ha.m();Da.s();){var ta=Da.t();wp(Yy(ta)?Oa:Na,ta)}var Ya=G(new H,Oa.ha(),Na.ha());var dc=
+Ya.y;if(u().i(dc))Ka=G(new H,u(),Ha);else{var ka=Ya.w;Ka=u().i(ka)?G(new H,Ha,u()):Ya}}if(null===Ka)throw new w(Ka);var ya=n.J;if(ya.F){var Sa=ut(Q(),"| ",ya.r)+"argMembs "+C;ff(gf(),Sa+"\n")}var xc=n.J;if(xc.F){var Sb=ut(Q(),"| ",xc.r)+"selfSig "+jb.sk;ff(gf(),Sb+"\n")}var uc=n;t();var Lb=new L(db),lc=jb.Ei.ie(),Xb=un(C,lc),ec=c.Ps.bf(D),Ab=c.Rm,Ob=jb.sk,fb=V(c.Rm.q),Wa=Pu(Ab,Ob,fb,!1),bb=new az(c.Sz,c.Eq,c.Os,Lb,Xb,c.Qs,ec,Wa);n=uc;b=A;c=bb;continue}else if(B instanceof ax){b=A;continue}else throw new w(B);
+}}var Ia=O().c;if(null===Ia?null===r:Ia.i(r)){var Ua=n.J,pc=c;if(Ua.F){var sc=ut(Q(),"| ",Ua.r)+"Done inheriting: "+pc;ff(gf(),sc+"\n")}var Ba=n.J,ob=c.Eq,nc=n.J,Ib=px(n),vc=Ib.b()?O().c:Ib.o(),Vb=k.Sg,fc=Vb.b()?new Gl(O().c):Vb.o(),Bc=new Qv(nc,vc,ny(n.J,fc,!0)),Pb=new $y(Ba,ob,Bc,V(n.J)),Jb=bz(n.J,k,V(n.J),e),gc=V(Pb.q),Cb=Pu(Pb,Jb,gc,!1),cc=n.J;cu();var yc=k.hg;if(yc===u())var Mc=u();else{for(var qc=yc.e(),oc=new z(qc.j(),u()),Qc=oc,jc=yc.f();jc!==u();){var sb=jc.e(),Gc=new z(sb.j(),u());Qc=Qc.p=
+Gc;jc=jc.f()}Mc=oc}var Wb=du(0,Mc);tx(n.J);var Cc=t().d,Fc=new Qv(cc,l,jx(new kx,n.J,Wb,"type parameters",Cc,!0)),qd=V(Cb.q),Yb=Pu(Cb,Fc,qd,!1),Nc=n,ad=n.J.qa,Uc=n.J;if(Uc.F){var cd=ut(Q(),"| ",Uc.r)+(e.da+". Finalizing inheritance with "+Yb+" \x3c: ")+d;ff(gf(),cd+"\n")}Uc.r=1+Uc.r|0;try{up(tp(),Pe(new E(d.Xa),e.da));var kc=V(Yb.q),Vc=Pu(Yb,m,kc,!1),Hc=Sw(Nc.J).ob;Tw(Nc.J,Vc,d,g,h,e,Hc);var rc=void 0}finally{Uc.r=-1+Uc.r|0}if(dx(new E(ad),Uc.qa)&&Uc.F){var sd=""+ut(Q(),"| ",Uc.r)+ad.n(rc);ff(gf(),
+sd+"\n")}if(k.Pm.b()){var Kc=n,Qd=c,Ad=n.J.qa,kd=n.J;if(kd.F){var Hd=ut(Q(),"| ",kd.r)+"Checking self signature...";ff(gf(),Hd+"\n")}kd.r=1+kd.r|0;try{var Rd=Qd.Rm,Bd=Sw(Kc.J).ob;Tw(Kc.J,Yb,Rd,g,h,e,Bd);var ae=void 0}finally{kd.r=-1+kd.r|0}if(dx(new E(Ad),kd.qa)&&kd.F){var dd=""+ut(Q(),"| ",kd.r)+Ad.n(ae);ff(gf(),dd+"\n")}}var od=c.Rm,Ta=V(c.Rm.q),wb=Pu(od,m,Ta,!1);return new az(c.Sz,Yb,c.Os,c.Hu,c.Gu,c.Qs,c.Ps,wb)}throw new w(r);}}
+function my(a,b,c){Lw(a.J,Ye(new Te(new Ue(J(new K,["Cannot use `val` in constructor parameters"]))),u()),b,c)}function Yy(a){return a instanceof Vw?!(a.ij instanceof Ep):!1}function cz(a,b,c){return a.yl(t().d,!1,new fn((d,e)=>b.n(e)),c)}function dz(a){return!!(a&&a.$classData&&a.$classData.rb.ZH)}function ez(){}ez.prototype=new p;ez.prototype.constructor=ez;function fz(a,b){return Wk(new gz).Ob(b,new y(()=>{t();return R()}))}ez.prototype.$classData=q({JX:0},!1,"mlscript.OpApp$",{JX:1,g:1});var hz;
+function iz(){hz||(hz=new ez);return hz}function jz(){this.ld=null}jz.prototype=new p;jz.prototype.constructor=jz;function kz(){}kz.prototype=jz.prototype;function lz(){}lz.prototype=new p;lz.prototype.constructor=lz;function fu(a,b){a=b.m();a=new Ef(a,new y(c=>G(new H,t().d,new sm(tm().Cg,c))));Od();return new Gl(Pd(u(),a))}
+function mz(a,b){if(b instanceof Gl){a=b.Ra;a:{for(b=a;!b.b();){var c=b.e();if(!(c.h().b()&&Pe(new E(c.j().yb.je),!1)&&Pe(new E(c.j().yb.ch),!1))){b=!1;break a}b=b.f()}b=!0}if(b){t();if(a===u())a=u();else{b=a.e();c=b=new z(b.j().ya,u());for(a=a.f();a!==u();){var d=a.e();d=new z(d.j().ya,u());c=c.p=d;a=a.f()}a=b}return new L(a)}}return t().d}lz.prototype.$classData=q({OX:0},!1,"mlscript.PlainTup$",{OX:1,g:1});var nz;function eu(){nz||(nz=new lz);return nz}
+function oz(){this.aI=this.Yz=null;Ty();var a=u();this.Yz=Uy(a);pz();a=u();this.aI=qz(a)}oz.prototype=new p;oz.prototype.constructor=oz;function ho(a,b,c){Ly(a.Yz,b,c,!1);return c}oz.prototype.$classData=q({QX:0},!1,"mlscript.Polyfill",{QX:1,g:1});
+function rz(a,b,c){a=new xl("x");var d=new xl("y"),e=O().c;a=new z(a,new z(d,e));d=new km("arguments");d=om(Al(),d,"length");d=new gn("\x3d\x3d\x3d",d,new hn("2"));e=rn(new gn(b,new km("x"),new km("y")));var g=O().c;e=new z(e,g);g=new xl("y");var h=O().c;g=new z(g,h);t();b=rn(new oo(g,new fe(new gn(b,new km("x"),new km("y")))));g=O().c;b=new dp(d,e,new z(b,g));d=O().c;return new sz(c,a,new z(b,d))}
+function tz(a,b,c){a=J(new K,[new xl("x")]);b=[rn(new $o(b,new km("x")))];b=J(new K,b);return new sz(c,(Od(),Pd(u(),a)),(Od(),Pd(u(),b)))}
+function uz(){this.PN=this.ON=null;vz=this;var a=kl();ol(a,new wz("prettyPrint",new y(b=>{var c=new km("value"),d=new xl("value"),e=O().c;d=new z(d,e);e=new $o("typeof",c);var g=J(new K,[c]);g=rn(new cn(new km("String"),(Od(),Pd(u(),g))));var h=O().c;g=new z(g,h);h=an("number");var k=O().c;h=G(new H,h,k);k=an("boolean");var l=om(Al(),c,"toString"),m=u();l=rn(new cn(l,m));m=O().c;k=G(new H,k,new z(l,m));l=an("function");m=om(Al(),c,"name");var n=an("\x3canonymous\x3e");m=new gn("??",m,n);n=an("[Function: ");
+m=new gn("+",n,m);n=an("]");m=rn(new gn("+",m,n));n=O().c;l=G(new H,l,new z(m,n));m=an("string");n=an('"');n=new gn("+",n,c);var r=an('"');n=rn(new gn("+",n,r));r=O().c;m=G(new H,m,new z(n,r));n=an("undefined");r=rn(an("undefined"));var v=O().c;n=G(new H,n,new z(r,v));r=an("object");v=new gn("\x3d\x3d\x3d",c,new km("null"));var x=rn(an("null")),A=O().c;x=new z(x,A);A=om(Al(),c,"constructor");A=om(Al(),A,"name");var B=an(" ");A=new gn("+",A,B);B=new km("JSON");B=om(Al(),B,"stringify");var C=J(new K,
+[c,new km("undefined"),new km("2")]);B=new cn(B,(Od(),Pd(u(),C)));A=rn(new gn("+",A,B));B=O().c;A=new z(A,B);B=new km("_");c=J(new K,[c]);c=rn(new cn(new km("String"),(Od(),Pd(u(),c))));C=O().c;c=new xz(A,new yz(B,new z(c,C)));A=O().c;c=new dp(v,x,new z(c,A));v=O().c;c=[h,k,l,m,n,G(new H,r,new z(c,v))];e=Tba(e,g,J(new K,c));g=O().c;return new sz(b,d,new z(e,g))})));ol(a,new wz("withConstruct",new y(b=>{var c=new km("Object"),d=new km("target"),e=new km("fields"),g=J(new K,[new xl("target"),new xl("fields")]),
+h=new $o("typeof",d),k=an("string");h=new gn("\x3d\x3d\x3d",h,k);k=new $o("typeof",d);var l=an("number");h=new gn("||",h,new gn("\x3d\x3d\x3d",k,l));k=new $o("typeof",d);l=an("boolean");h=new gn("||",h,new gn("\x3d\x3d\x3d",k,l));k=new $o("typeof",d);l=an("bigint");h=new gn("||",h,new gn("\x3d\x3d\x3d",k,l));k=new $o("typeof",d);l=an("symbol");h=new gn("||",h,new gn("\x3d\x3d\x3d",k,l));k=om(Al(),c,"assign");l=J(new K,[d,e]);k=rn(new cn(k,(Od(),Pd(u(),l))));l=O().c;h=new dp(h,new z(k,l),O().c);k=
+new gn("||",new gn("||",new gn("||",new gn("instanceof",d,new km("String")),new gn("instanceof",d,new km("Number"))),new gn("instanceof",d,new km("Boolean"))),new gn("instanceof",d,new km("BigInt")));l=om(Al(),c,"assign");var m=om(Al(),d,"valueOf"),n=u();m=J(new K,[new cn(m,n),d,e]);l=rn(new cn(l,(Od(),Pd(u(),m))));m=O().c;k=new dp(k,new z(l,m),O().c);l=new km("Array");l=om(Al(),l,"isArray");m=J(new K,[d]);l=new cn(l,(Od(),Pd(u(),m)));t();m=new km("Array");m=om(Al(),m,"from");n=J(new K,[d]);m=new cn(m,
+(Od(),Pd(u(),n)));m=new qn("clone",m);n=new xl("key");var r=[zz(Xo(new Yo,new km("clone"),new km("key")),Xo(new Yo,d,new km("key")))];r=J(new K,r);n=new Az(n,d,(Od(),Pd(u(),r)));r=new xl("key");var v=[zz(Xo(new Yo,new km("clone"),new km("key")),Xo(new Yo,e,new km("key")))];v=J(new K,v);r=new Az(r,e,(Od(),Pd(u(),v)));m=[m,n,r,rn(new km("clone"))];m=J(new K,m);l=new dp(l,Pd(u(),m),O().c);m=new gn("\x3d\x3d",d,new hn("null"));n=om(Al(),c,"assign");r=[new vo(O().c,O().c),new vo(O().c,O().c),e];r=J(new K,
+r);n=rn(new cn(n,(Od(),Pd(u(),r))));r=O().c;m=new dp(m,new z(n,r),O().c);n=om(Al(),c,"assign");e=[new vo(O().c,O().c),d,e];e=J(new K,e);e=new qn("copy",new cn(n,(Od(),Pd(u(),e))));n=om(Al(),c,"setPrototypeOf");r=new km("copy");c=om(Al(),c,"getPrototypeOf");d=J(new K,[d]);d=[r,new cn(c,(Od(),Pd(u(),d)))];d=J(new K,d);d=new cn(n,(Od(),Pd(u(),d)));d=[h,k,l,m,e,new Bo(d),rn(new km("copy"))];d=J(new K,d);return new sz(b,(Od(),Pd(u(),g)),(Od(),Pd(u(),d)))})));ol(a,new Bz("toString",new y(b=>{var c=J(new K,
+[new xl("x")]),d=J(new K,[new km("x")]);d=[rn(new cn(new km("String"),(Od(),Pd(u(),d))))];d=J(new K,d);return new sz(b,(Od(),Pd(u(),c)),(Od(),Pd(u(),d)))})));ol(a,new Bz("id",new y(b=>{var c=J(new K,[new xl("x")]),d=[rn(new km("x"))];d=J(new K,d);return new sz(b,(Od(),Pd(u(),c)),(Od(),Pd(u(),d)))})));ol(a,new Bz("emptyArray",new y(b=>{var c=u(),d=[rn(new Wo(O().c))];d=J(new K,d);return new sz(b,c,(Od(),Pd(u(),d)))})));ol(a,new Bz("succ",new y(b=>{var c=J(new K,[new xl("x")]),d=[rn(new gn("+",new km("x"),
+new hn("1")))];d=J(new K,d);return new sz(b,(Od(),Pd(u(),c)),(Od(),Pd(u(),d)))})));ol(a,new Bz("error",new y(b=>{var c=u(),d=new $m(new km("Error")),e=[an("an error was thrown")];e=J(new K,e);d=new cn(d,(Od(),Pd(u(),e)));d=J(new K,[new bn(d)]);return new sz(b,c,(Od(),Pd(u(),d)))})));ol(a,new Bz("length",new y(b=>{var c=J(new K,[new xl("x")]),d=new km("x");d=[rn(om(Al(),d,"length"))];d=J(new K,d);return new sz(b,(Od(),Pd(u(),c)),(Od(),Pd(u(),d)))})));ol(a,new Bz("concat",new y(b=>rz(Cz(),"+",b))));
+ol(a,new Bz("join",new y(b=>{var c=J(new K,[new xl("...xs")]),d=new km("xs");d=om(Al(),d,"join");var e=[new hn(Mp(Np(),""))];e=J(new K,e);d=[rn(new cn(d,(Od(),Pd(u(),e))))];d=J(new K,d);return new sz(b,(Od(),Pd(u(),c)),(Od(),Pd(u(),d)))})));ol(a,new Bz("add",new y(b=>rz(Cz(),"+",b))));ol(a,new Bz("sub",new y(b=>rz(Cz(),"-",b))));ol(a,new Bz("mul",new y(b=>rz(Cz(),"*",b))));ol(a,new Bz("div",new y(b=>rz(Cz(),"/",b))));ol(a,new Bz("gt",new y(b=>rz(Cz(),"\x3e",b))));ol(a,new Bz("not",new y(b=>tz(Cz(),
+"!",b))));ol(a,new Bz("negate",new y(b=>tz(Cz(),"-",b))));ol(a,new Bz("eq",new y(b=>rz(Cz(),"\x3d\x3d\x3d",b))));ol(a,new Bz("ne",new y(b=>rz(Cz(),"!\x3d\x3d",b))));ol(a,new Bz("sgt",new y(b=>rz(Cz(),"\x3e",b))));ol(a,new Bz("slt",new y(b=>rz(Cz(),"\x3c",b))));ol(a,new Bz("sge",new y(b=>rz(Cz(),"\x3e\x3d",b))));ol(a,new Bz("sle",new y(b=>rz(Cz(),"\x3c\x3d",b))));ol(a,new Bz("eq",new y(b=>rz(Cz(),"\x3d\x3d\x3d",b))));ol(a,new Bz("unit",new y(b=>tz(Cz(),"undefined",b))));ol(a,new Bz("log",new y(b=>
+{var c=J(new K,[new xl("x")]),d=J(new K,[new km("x")]);d=[rn(new cn(new km("console.info"),(Od(),Pd(u(),d))))];d=J(new K,d);return new sz(b,(Od(),Pd(u(),c)),(Od(),Pd(u(),d)))})));ol(a,new Bz("discard",new y(b=>{var c=J(new K,[new xl("x")]),d=u();return new sz(b,(Od(),Pd(u(),c)),d)})));Od();this.ON=Pd(u(),a);this.PN=Dz(Ez(),Qt(this.ON,new y(b=>G(new H,b.Ua(),b))))}uz.prototype=new p;uz.prototype.constructor=uz;uz.prototype.$classData=q({RX:0},!1,"mlscript.Polyfill$",{RX:1,g:1});var vz;
+function Cz(){vz||(vz=new uz);return vz}function Fz(){}Fz.prototype=new p;Fz.prototype.constructor=Fz;function Gz(){}Gz.prototype=Fz.prototype;function Hz(a){this.$f=a}Hz.prototype=new p;Hz.prototype.constructor=Hz;function Iz(a,b){return new Hz(un(a.$f,b.$f))}
+function Rp(a,b){var c=b.$f;if(c instanceof z){var d=c.z;c=c.p;if(a.$f.b())return b;b=a.$f.MJ();t();a=a.$f.Mc();a=J(new K,[new Jz(""+a.Kq+d.Kq,a.$s)]);a=Pd(u(),a);return new Hz(dl(dl(c,a),b))}d=O().c;if(null===d?null===c:d.i(c))return a;throw new w(c);}function Kz(a){var b=a.$f;if(b===u())a=u();else{a=b.e();var c=a=new z(Lz(a),u());for(b=b.f();b!==u();){var d=b.e();d=new z(Lz(d),u());c=c.p=d;b=b.f()}}return new Hz(a)}
+function Pp(a,b){if(b)switch(a.$f.K()){case 0:return Sp(Qp(),"()");case 1:var c=a.$f;if(c===u())b=u();else for(b=c.e(),a=b=new z(Mz(b),u()),c=c.f();c!==u();){var d=c.e();d=new z(Mz(d),u());a=a.p=d;c=c.f()}return new Hz(b);default:return c=a.$f.e(),b=a.$f.f().Bb(1),d=a.$f.Mc(),a=new Jz("("+c.Kq,c.$s),t(),c=J(new K,[new Jz(""+d.Kq+")",d.$s)]),b=dl(Pd(u(),c),b),new Hz(new z(a,b))}else return a}
+function Nz(a){switch(a.$f.K()){case 0:case 1:return a;default:var b=a.$f.e(),c=a.$f.f().Bb(1);a=a.$f.Mc();b=new Jz("("+b.Kq,b.$s);t();a=J(new K,[new Jz(""+a.Kq+")",a.$s)]);c=dl(Pd(u(),a),c);return new Hz(new z(b,c))}}function Oz(a){if(0===a.$f.K())return Sp(Qp(),"{}");var b=new Jz("{",0),c=a.$f;if(c===u())a=u();else{a=c.e();var d=a=new z(Lz(a),u());for(c=c.f();c!==u();){var e=c.e();e=new z(Lz(e),u());d=d.p=e;c=c.f()}}t();d=J(new K,[new Jz("}",0)]);a=dl(Pd(u(),d),a);return new Hz(new z(b,a))}
+Hz.prototype.u=function(){return ze(this.$f,"","\n","")};Hz.prototype.$classData=q({iY:0},!1,"mlscript.SourceCode",{iY:1,g:1});function Pz(){this.SN=this.ye=this.RN=this.cI=this.zx=this.bA=null;Qz=this;Sp(Qp()," \x26 ");this.bA=Sp(Qp()," ");this.zx=Sp(Qp(),";");Sp(Qp(),": ");Sp(Qp()," | ");this.cI=Sp(Qp(),",");this.RN=Sp(Qp(),", ");this.ye=Rz(Qp(),O().c);Sp(Qp(),"{");Sp(Qp(),"}");Sp(Qp(),"\x3c");Sp(Qp(),"\x3e");this.SN=Sp(Qp()," \x3d\x3e ");Sp(Qp()," \x3d ")}Pz.prototype=new p;
+Pz.prototype.constructor=Pz;function Sp(a,b){t();a=J(new K,[new Jz(b,0)]);return new Hz(Pd(u(),a))}function Rz(a,b){if(b===u())a=u();else{a=b.e();var c=a=new z(new Jz(a,0),u());for(b=b.f();b!==u();){var d=b.e();d=new z(new Jz(d,0),u());c=c.p=d;b=b.f()}}return new Hz(a)}function Sz(a){for(var b=Qp().ye;!a.b();){var c=a.e();b=Iz(b,c);a=a.f()}return b}
+function Tz(a){var b=O().c;if(null===b?null===a:b.i(a))return Sp(Qp(),"{}");if(a instanceof z){b=a.z;var c=a.p,d=O().c;if(null===d?null===c:d.i(c))return 0<b.$f.ab(1)?Iz(Iz(Sp(Qp(),"{"),Kz(b)),Sp(Qp(),"}")):Rp(Rp(Sp(Qp(),"{ "),b),Sp(Qp()," }"))}return Iz(Hf(a).De(Sp(Qp(),"{"),new fn((e,g)=>{var h=G(new H,e,g);e=h.y;g=h.w;if(null!==g)return h=g.h(),Iz(e,Kz(Pe(new E(1+g.Sc()|0),a.K())?h:Rp(h,Qp().cI)));throw new w(h);})),Sp(Qp(),"}"))}
+function Uz(a){var b=O().c;if(null===b?null===a:b.i(a))return Sp(Qp(),"[]");if(a instanceof z){b=a.z;var c=a.p,d=O().c;if(null===d?null===c:d.i(c))return 0<b.$f.ab(1)?Iz(Iz(Sp(Qp(),"["),Kz(b)),Sp(Qp(),"]")):Rp(Rp(Sp(Qp(),"["),b),Sp(Qp(),"]"))}return Iz(Hf(a).De(Sp(Qp(),"["),new fn((e,g)=>{var h=G(new H,e,g);e=h.y;g=h.w;if(null!==g)return h=g.h(),Iz(e,Kz(Pe(new E(1+g.Sc()|0),a.K())?h:Rp(h,Qp().cI)));throw new w(h);})),Sp(Qp(),"]"))}
+function Uba(a,b,c){return Hf(b).De(a.ye,new fn((d,e)=>{var g=G(new H,d,e);d=g.y;e=g.w;if(null!==e)return g=e.Sc(),Rp(Rp(d,e.h()),Pe(new E(g),-1+b.K()|0)?Qp().ye:c);throw new w(g);}))}Pz.prototype.$classData=q({jY:0},!1,"mlscript.SourceCode$",{jY:1,g:1});var Qz;function Qp(){Qz||(Qz=new Pz);return Qz}function Jz(a,b){this.Kq=a;this.$s=b}Jz.prototype=new p;Jz.prototype.constructor=Jz;function Lz(a){return new Jz(a.Kq,1+a.$s|0)}function Mz(a){return new Jz("("+a.Kq+")",a.$s)}
+Jz.prototype.u=function(){return""+ut(Q(),"  ",this.$s)+this.Kq};Jz.prototype.$classData=q({kY:0},!1,"mlscript.SourceLine",{kY:1,g:1});function Vz(){}Vz.prototype=new p;Vz.prototype.constructor=Vz;function Wz(){}Wz.prototype=Vz.prototype;
+Vz.prototype.jb=function(){var a=!1,b=null;if(Se()===this)return"space";if(Xr()===this)return"comma";if(ds()===this)return"semicolon";if(qs()===this)return"newline";if(ks()===this)return"indentation";if(rs()===this)return"deindentation";if(ts()===this)return"error";if(Yr()===this)return"quote";if(this instanceof fs)return"literal";if(this instanceof as)return a=this.Na,b=Xz(Q(),a),b.b()?b=!1:(b=b.o(),b=Ea(b),b=Or(Pr(),b)),b?"'"+a+"' keyword":"'"+a+"'";if(this instanceof bs)return this.ke?"operator":
+"identifier";if(this instanceof ss)return"selector";if(this instanceof Zr)return"opening "+this.qx.Ua();if(this instanceof es)return"closing "+this.Iw.Ua();if(this instanceof cs){a=!0;b=this;var c=b.Cc;if(Mk()===c)return"indented block"}if(a)return b.Cc.Ua()+" section";if(this instanceof gs)return"comment";throw new w(this);};
+function Yz(a){a=a.Ra.m();a=new Ef(a,new y(b=>{if(null!==b){var c=b.h();b=b.j();var d=b.yb.je?"mut ":"",e=b.yb.Bh?"val ":"",g=b.yb.ch?"#":"";c=c.b()?"":c.o().x+": ";return d+e+g+c+Zz(b.ya,!1)+","}throw new w(b);}));return ze(a,""," ","")}function $z(a,b){a=a.Ra.m();a=new Ef(a,new y(c=>{if(null!==c){var d=c.h();c=c.j();var e=c.yb.je?"mut ":"",g=c.yb.Bh?"val ":"",h=c.yb.ch?"#":"";d=d.b()?"":d.o().x+": ";return e+g+h+d+aA(c.ya,!1,b)}throw new w(c);}));return ze(a,"",", ","")}function bA(){}
+bA.prototype=new p;bA.prototype.constructor=bA;bA.prototype.$classData=q({xY:0},!1,"mlscript.TypeDefs$VarianceStore$",{xY:1,g:1});function cA(a){a=a.m();a=new Ef(a,new y(b=>""+dA(b.j())+b.h()));return ze(a,"",", ","")}function eA(a,b,c,d,e,g){c=fA(gA(a),c);c=hA(b,c,g);if(a.F){var h=ut(Q(),"| ",a.r)+"allVarPols: "+cA(c);ff(gf(),h+"\n")}h=Xu().X();return Vba(a,b,g,h,c,d,e,g)}
+function iA(a,b,c,d){var e=new $e;if(a.F){var g=ut(Q(),"| ",a.r);if(e.sb)e=e.vb;else{if(null===e)throw le();if(e.sb)e=e.vb;else{var h=fA(gA(a),c);e=me(e,hA(b,h,d))}}g=g+"allVarPols: "+cA(e);ff(gf(),g+"\n")}g=jA().X();return Wba(a,b,c,t().d,d,d,g)}
+function kA(a,b,c,d,e){var g=new $e,h=new $e,k=new lA;k=Xba(k);var l=jA().X(),m=jA().X();mA(g.sb?g.vb:Yba(a,g,e,k,l,m),fA(gA(a),d),b);a.F&&(g=ut(Q(),"| ",a.r)+"[inv] "+ze(l,"",", ",""),ff(gf(),g+"\n"));if(a.F){g=ut(Q(),"| ",a.r);var n=k.m();n=new Ef(n,new y(B=>{t();return""+dA(new L(B.h().Rc()))+B.h().j()+" "+B.Sc()}));g=g+"[nums] "+ze(n,""," ; ","");ff(gf(),g+"\n")}var r=Xu().X();g=jA().X();n=jA().X();nA(a,b,fA(gA(a),d),h,e,g,n,r);r.Ca(new y(B=>{up(tp(),!B.j().b())}));a.F&&(h=ut(Q(),"| ",a.r),g=
+r.m(),g=new Ef(g,new y(B=>{t();return""+dA(new L(B.h().Rc()))+B.h().j()+" "+ze(B.j(),"{",",","}")})),h=h+"[occs] "+ze(g,""," ; ",""),ff(gf(),h+"\n"));var v=Xu().X();m=m.m();m=new Ef(m,new y(B=>B.h()));h=Su();g=op().ga;h=new Uu(h,g);m=oA(uv(),m,h);h=pA(m,v,e);var x=new aw(h);a.F&&(h=ut(Q(),"| ",a.r)+"[vars] "+m,ff(gf(),h+"\n"));a.F&&(h=ut(Q(),"| ",a.r)+"[rec] "+x.rc,ff(gf(),h+"\n"));for(h=k.m();h.s();){var A=h.t();a:{if(null!==A&&(g=A.h(),n=A.Sc(),null!==g)){A=g.Rc();g=g.j();up(tp(),0<n);Pe(new E(n),
+1)&&!k.L(G(new H,!A,g))&&(n=a,n.F&&(n=ut(Q(),"| ",n.r)+"0[1] "+g,ff(gf(),n+"\n")),n=R(),g=G(new H,g,n),v.$(g));break a}throw new w(A);}}m.Ca(new y(B=>{if(!x.rc.L(B)){var C=G(new H,r.U(G(new H,!0,B)),r.U(G(new H,!1,B)));var D=C.w;if(C.y instanceof L&&R()===D)D=!0;else{D=C.y;var F=C.w;D=R()===D&&F instanceof L?!0:!1}if(D)return a.F&&(C=ut(Q(),"| ",a.r)+"1[!] "+B,ff(gf(),C+"\n")),C=R(),B=G(new H,B,C),v.$(B);if(!Nm(new E(C),G(new H,R(),R())))throw new Yj("assertion failed: "+B+" has no occurrences...");
+}}));m.Ca(new y(B=>{if(B.Sb.b()&&!v.L(B)){if(a.F){var C=ut(Q(),"| ",a.r)+("2[v] "+B+" "+r.U(G(new H,!0,B))+" ")+r.U(G(new H,!1,B));ff(gf(),C+"\n")}C=r.U(G(new H,!0,B)).m();for(C=new xo(C,new y(T=>new qA(T)));C.s();){var D=C.t();if(D instanceof Fv||D instanceof fw)if(x.rc.L(B))F=!1;else{F=r.U(G(new H,!1,B));var F=F.b()?!1:F.o().L(D)}else F=!1;if(F){F=cw(a);for(var I=rA(B),M=D;!I.b();){var N=I.e(),P=V(M.q);M=sA(M,N,P);I=I.f()}I=M;M=vy(B);N=D;for(D=M;!D.b();)M=N,N=D.e(),P=V(M.q),N=dv(M,N,P,!1),D=D.f();
+F=tA(F,I,N,V(cw(a).Vu));D=a;D.F&&(D=ut(Q(),"| ",D.r)+("  [..] "+B+" :\x3d ")+F,ff(gf(),D+"\n"));t();F=G(new H,B,new L(F));v.$(F)}else if(D instanceof lx&&((Ot(new E(D),B)||v.L(D)||v.L(B)?0:!x.rc.L(B))?(F=r.U(G(new H,!1,B)),F=F.b()?!1:F.o().L(D)):F=!1,F)){F=cw(a);I=rA(B);for(M=D;!I.b();)N=I.e(),P=V(M.q),M=sA(M,N,P),I=I.f();I=M;M=vy(B);N=D;for(D=M;!D.b();)M=N,N=D.e(),P=V(M.q),N=dv(M,N,P,!1),D=D.f();F=tA(F,I,N,V(cw(a).Vu));D=a;D.F&&(D=ut(Q(),"| ",D.r)+("  [..] "+B+" :\x3d ")+F,ff(gf(),D+"\n"));t();F=
+G(new H,B,new L(F));v.$(F)}}}}));m.Ca(new y(B=>{if(B.Sb.b()&&!v.L(B)){var C=a.qa;if(a.F){var D=ut(Q(),"| ",a.r),F=iu(ju(),r.U(G(new H,!0,B)));F=ze(F,"","","");var I=iu(ju(),r.U(G(new H,!1,B)));D=D+("3[v] "+B+" +"+F+" -")+ze(I,"","","");ff(gf(),D+"\n")}a.r=1+a.r|0;try{uA(a,!0,r,B,v);uA(a,!1,r,B,v);var M=void 0}finally{a.r=-1+a.r|0}dx(new E(C),a.qa)&&a.F&&(B=""+ut(Q(),"| ",a.r)+C.n(M),ff(gf(),B+"\n"))}}));a.F&&(h=ut(Q(),"| ",a.r),g=v.Ja(new y(B=>B.h().u()+" -\x3e "+B.j())),h=h+"[sub] "+ze(g,"",", ",
+""),ff(gf(),h+"\n"));a.F&&(h=ut(Q(),"| ",a.r)+"[bounds] "+xx(b),ff(gf(),h+"\n"));x.rc=pA(m,v,e);a.F&&(m=ut(Q(),"| ",a.r)+"[rec] "+x.rc,ff(gf(),m+"\n"));m=Xu().X();h=ap();return Zba(a,b,fA(gA(a),d),h,e,v,c,m,l,x,k,r)}
+function vA(a,b,c,d){var e=fA(gA(a),(t(),new L(c))),g=hA(b,e,d);a.F&&(e=ut(Q(),"| ",a.r)+"allVarPols: "+cA(g),ff(gf(),e+"\n"));e=jA().X();g=g.m();var h=new wA(a);g=new Ex(g,h);g=new iy(g,new y(k=>{if(null!==k){var l=k.h(),m=k.j();if(null!==l)return xA(l.j(),!1).L(m)}throw new w(k);}),!1);op();g=pp(qp(),g);a.F&&(h=ut(Q(),"| ",a.r)+"consed: "+g,ff(gf(),h+"\n"));return $ba(a,(t(),new L(c)),b,d,e,g)}
+function aca(a,b,c,d){c=fA(gA(a),c);var e=hA(b,c,d);a.F&&(c=ut(Q(),"| ",a.r)+"allVarPols: "+cA(e),ff(gf(),c+"\n"));jA().X();var g=Xu().X();e.Ca(new y(h=>{if(null!==h){var k=h.h();h=h.j();if(h instanceof L){var l=!!h.k;a.F&&(h=ut(Q(),"| ",a.r)+"Consider "+k,ff(gf(),h+"\n"));h=k.Sb;if(h.b())h=R();else{h=h.o();var m=O().c;h=new L(new z(h,m))}h=h.b()?l?vy(k):rA(k):h.o();if(h instanceof z){var n=h.z;h=h.p;m=O().c;(null===m?null===h:m.i(h))&&e.Ca(new y(r=>{if(null!==r){var v=r.h();r=r.j();if(r instanceof
+L&&(r=!!r.k,Pe(new E(r),l)&&dx(new E(v),k)&&!g.L(k)&&!g.L(v))){var x=v.Sb;if(x.b())x=R();else{x=x.o();var A=O().c;x=new L(new z(x,A))}x=x.b()?r?vy(v):rA(v):x.o();if(x instanceof z&&(r=x.z,x=x.p,A=O().c,null===A?null===x:A.i(x))&&(a.F&&(x=ut(Q(),"| ",a.r)+("Consider "+k+" ~ ")+v,ff(gf(),x+"\n")),yA(a,n,r,k,v)))return a.F&&(r=ut(Q(),"| ",a.r)+("Yes! "+v+" :\x3d ")+k,ff(gf(),r+"\n")),v=G(new H,v,k),g.$(v)}}}))}}}}));a.F&&(c=ut(Q(),"| ",a.r)+"[subs] "+g,ff(gf(),c+"\n"));return g.b()?b:bca(a,b,(op(),pp(qp(),
+g)),d)}function cca(a,b,c,d){return c.Hk(b,new U(()=>{if(d)return b;var e=V(a);t();var g=new L(b),h=b.kg,k=O().c,l=O().c;e=new lx(a,b.Xa,k,l,g,h,!1,e);a.F&&(g=ut(Q(),"| ",a.r)+("Renewed "+b+" ~\x3e ")+e,ff(gf(),g+"\n"));return e}))}function Vba(a,b,c,d,e,g,h,k){if(b instanceof zA)return AA(a,b,t().d,t().d,d,e,c,g,h,k);if(b instanceof BA){CA(a);t();var l=new L(b);if(!l.b())return dca(l.k,new y(m=>AA(a,m,t().d,t().d,d,e,c,g,h,k)),c)}throw new w(b);}
+function DA(a,b,c,d,e,g,h,k,l){if(null===b)throw le();if(b.sb)return b.vb;var m=c.Va,n=c.Oa;n.b()?n=R():(n=n.o(),n=new L(AA(a,n,t().d,t().d,d,e,g,h,k,l)));return me(b,new Uw(m,n,AA(a,c.ra,t().d,t().d,d,e,g,h,k,l),c.Pd))}
+var AA=function EA(a,b,c,d,e,g,h,k,l,m){var r=tc();try{var v=!1,x=null,A=!1,B=null;if(b instanceof mx){var C=b.hi;if(null!==C)return EA(a,C,c,t().d,e,g,h,k,l,m)}if(b instanceof lx){if(c.b())var D=!0;else{var F=c.o().j();D=Pe(new E(F),b)}var I=D?c:R();if(!I.b()){var M=I.o().Rc();throw Hq(new Iq,r,new FA(a,M,V(a)));}var N=new GA(!1),P=e.Hk(b,new U(()=>{N.Am=!0;return cca(a,b,e,l)}));if(N.Am){var T=b.Sb;if(T instanceof L){var Y=T.k,Z=!1,S=null,ea=HA(g,b);a:if(ea.b()||!P.Sb.b()){t();var ia=EA(a,Y,t().d,
+t().d,e,g,h,k,l,m);wy(P,new L(ia))}else{t().d===ea&&xm("Program reached and unexpected state.");if(ea instanceof L&&(Z=!0,S=ea,!0===!!S.k)){t();var X=G(new H,!0,b),sa=EA(a,Y,new L(X),t().d,e,g,h,k,l,m),Ja=O().c,Xa=new z(sa,Ja);b:for(var Fa;;)if(Xa.b()){Fa=u();break}else{var za=Xa.e(),Qa=Xa.f();if(!0===!!Kv(za,h))Xa=Qa;else for(var Ma=Xa,Ga=Qa;;){if(Ga.b())Fa=Ma;else{var ab=Ga.e();if(!0!==!!Kv(ab,h)){Ga=Ga.f();continue}for(var Hb=Ga,bc=new z(Ma.e(),u()),yb=Ma.f(),tb=bc;yb!==Hb;){var eb=new z(yb.e(),
+u());tb=tb.p=eb;yb=yb.f()}for(var kb=Hb.f(),Rb=kb;!kb.b();){var Gb=kb.e();if(!0===!!Kv(Gb,h)){for(;Rb!==kb;){var vb=new z(Rb.e(),u());tb=tb.p=vb;Rb=Rb.f()}Rb=kb.f()}kb=kb.f()}Rb.b()||(tb.p=Rb);Fa=bc}break b}}IA(P,Fa);break a}if(Z&&!1===!!S.k){t();var Tb=G(new H,!1,b),Nb=EA(a,Y,new L(Tb),t().d,e,g,h,k,l,m),ic=O().c,Va=new z(Nb,ic);b:for(var cb;;)if(Va.b()){cb=u();break}else{var zb=Va.e(),Ub=Va.f();if(!0===!!JA(zb,h))Va=Ub;else for(var jb=Va,db=Ub;;){if(db.b())cb=jb;else{var ub=db.e();if(!0!==!!JA(ub,
+h)){db=db.f();continue}for(var Aa=db,va=new z(jb.e(),u()),Ra=jb.f(),rb=va;Ra!==Aa;){var xb=new z(Ra.e(),u());rb=rb.p=xb;Ra=Ra.f()}for(var mc=Aa.f(),Ha=mc;!mc.b();){var Ka=mc.e();if(!0===!!JA(Ka,h)){for(;Ha!==mc;){var Oa=new z(Ha.e(),u());rb=rb.p=Oa;Ha=Ha.f()}Ha=mc.f()}mc=mc.f()}Ha.b()||(rb.p=Ha);cb=va}break b}}KA(P,cb)}else throw new w(ea);}}else if(t().d===T){var Na=HA(g,b);if(Na.b())var Da=!0;else{var ta=!!Na.o();Da=Pe(new E(ta),!0)}if(Da){if(k)var Ya=vy(b),dc=er(Ya).m();else dc=vy(b).m();var ka=
+new Ef(dc,new y(ng=>{t();var kh=G(new H,!0,b);return EA(a,ng,new L(kh),t().d,e,g,h,k,l,m)}));if(ka.s()){if(!ka.s())throw nv("empty.reduceLeft");for(var ya=!0,Sa=null;ka.s();){var xc=ka.t();if(ya)Sa=xc,ya=!1;else{var Sb=Sa,uc=xc,Lb=V(Sb.q);Sa=dv(Sb,uc,Lb,!1)}}lc=new L(Sa)}else var lc=R();if(lc.b())var Xb=!0;else{var ec=lc.o();Xb=!Kv(ec,h)}var Ab=(Xb?lc:R()).ha()}else Ab=O().c;IA(P,Ab);var Ob=HA(g,b);if(Ob.b())var fb=!0;else{var Wa=!!Ob.o();fb=Pe(new E(Wa),!1)}if(fb){if(k)var bb=rA(b),Ia=er(bb).m();
+else Ia=rA(b).m();var Ua=new Ef(Ia,new y(ng=>{t();var kh=G(new H,!1,b);return EA(a,ng,new L(kh),t().d,e,g,h,k,l,m)}));if(Ua.s()){if(!Ua.s())throw nv("empty.reduceLeft");for(var pc=!0,sc=null;Ua.s();){var Ba=Ua.t();if(pc)sc=Ba,pc=!1;else{var ob=sc,nc=Ba,Ib=V(ob.q);sc=sA(ob,nc,Ib)}}vc=new L(sc)}else var vc=R();if(vc.b())var Vb=!0;else{var fc=vc.o();Vb=!JA(fc,h)}var Bc=(Vb?vc:R()).ha()}else Bc=O().c;KA(P,Bc)}else throw new w(T);}return P}if(b instanceof LA){v=!0;x=b;var Pb=x.ic,Jb=x.jc;if(!0===x.tc){var gc=
+EA(a,Pb,c,d,e,g,h,k,l,m),Cb=EA(a,Jb,c,d,e,g,h,k,l,m),cc=V(gc.q);return dv(gc,Cb,cc,!1)}}if(v){var yc=x.ic,Mc=x.jc;if(!1===x.tc){var qc=EA(a,yc,c,d,e,g,h,k,l,m),oc=EA(a,Mc,c,d,e,g,h,k,l,m),Qc=V(qc.q);return Pu(qc,oc,Qc,!1)}}if(b instanceof MA){var jc=b.Fc;if(c.b())var sb=R();else{var Gc=c.o();t();sb=new L(G(new H,!Gc.h(),Gc.j()))}var Wb=EA(a,jc,sb,t().d,e,g,h,k,l,m),Cc=jc.ma();return NA(Wb,Cc,!1)}if(b instanceof OA){A=!0;B=b;var Fc=B.Hi;if(l)return new OA(a,EA(a,Fc,c,d,e,g,h,k,l,m),Fc.ma())}if(A)return EA(a,
+B.Hi,c,d,e,g,h,k,l,m);if(b instanceof fw&&a.XE.L(b.qb)&&PA(b,h))return EA(a,QA(b,h),c,t().d,e,g,h,k,l,m);if(b instanceof Qv){for(var qd=b.Ba,Yb=xv(a),Nc=qd,ad=null,Uc=null;Nc!==u();){var cd=Nc.e();a:{if(null!==cd){var kc=cd.h(),Vc=cd.j();if(null!==kc){var Hc=kc.x,rc=new $e;b:{for(var sd=Hc.length,Kc=0;Kc<sd;){var Qd=Hc.charCodeAt(Kc);if(!Nm(new E(hc(Qd)),hc(35))){var Ad=Kc;break b}Kc=1+Kc|0}Ad=-1}var kd=-1===Ad?Hc:Hc.substring(0,Ad),Hd=ys(Q(),Hc,1+kd.length|0);if(""===Hd||""===kd){var Rd=rc.sb?rc.vb:
+DA(a,rc,Vc,e,g,h,k,l,m),Bd=G(new H,kc,Rd),ae=O().c;var dd=new z(Bd,ae);break a}else{var od=h.tb.U(kd);if(od instanceof L){var Ta=od.k,wb=Ta.Nu;if(wb.b())var $a=rc.sb?rc.vb:DA(a,rc,Vc,e,g,h,k,l,m),wa=G(new H,kc,$a),hb=O().c,ra=new z(wa,hb);else{var wc=wb.o();b:{for(var ac=Ta.Xm;!ac.b();){if(ac.e().h().V===Hd){var Id=new L(ac.e());break b}ac=ac.f()}Id=R()}Id.b()&&xm("Program reached and unexpected state.");var ud=wc.n(Id.o().j());b:{if(null!==ud){var be=ud.qe;if(!0===ud.Qd&&!0===be){ra=O().c;break b}}if(null!==
+ud){var re=ud.qe;if(ud.Qd){t();var pe=new Uw(a,new L(a.ib),EA(a,Vc.ra,t().d,t().d,e,g,h,k,l,m),Vc.Pd),bd=G(new H,kc,pe),Rc=O().c;ra=new z(bd,Rc)}else if(re){var Wc=Vc.Oa;if(Wc.b())var Wd=R();else{var zd=Wc.o();Wd=new L(EA(a,zd,t().d,t().d,e,g,h,k,l,m))}var Pa=new Uw(a,Wd,a.La,Vc.Pd),Db=G(new H,kc,Pa),Oc=O().c;ra=new z(Db,Oc)}else{var Tc=rc.sb?rc.vb:DA(a,rc,Vc,e,g,h,k,l,m),Sd=G(new H,kc,Tc),Jc=O().c;ra=new z(Sd,Jc)}}else throw new w(ud);}}dd=ra;break a}else{if(t().d!==od)throw new w(od);var vd=h.$a.U(kd);
+if(!(vd instanceof L))throw t().d===vd&&xm("'"+kd+"' not found"),new w(vd);var hd=!1,de=null,ye=vd.k.eo;if(ye instanceof L){hd=!0;de=ye;var jf=de.k;if(jf instanceof Yw){var af=jf;b:{for(var pf=af.gh;!pf.b();){if(pf.e().kc.V===Hd){var kf=new L(pf.e());break b}pf=pf.f()}kf=R()}kf.b()&&xm("Program reached and unexpected state.");var Be=RA(af,kf.o().hb,h);if(null!==Be){var Kd=Be.qe;if(!0===Be.Qd&&!0===Kd){dd=O().c;break a}}if(null!==Be){var ld=Be.qe;if(Be.Qd){t();var Jd=new Uw(a,new L(a.ib),EA(a,Vc.ra,
+t().d,t().d,e,g,h,k,l,m),Vc.Pd),Dd=G(new H,kc,Jd),Xd=O().c;dd=new z(Dd,Xd)}else if(ld){var Yc=Vc.Oa;if(Yc.b())var Ce=R();else{var te=Yc.o();Ce=new L(EA(a,te,t().d,t().d,e,g,h,k,l,m))}var Ie=new Uw(a,Ce,a.La,Vc.Pd),Jf=G(new H,kc,Ie),df=O().c;dd=new z(Jf,df)}else{var vg=rc.sb?rc.vb:DA(a,rc,Vc,e,g,h,k,l,m),wg=G(new H,kc,vg),xg=O().c;dd=new z(wg,xg)}break a}throw new w(Be);}}if(hd){var eg=de.k;if(eg instanceof Ww){var vh=eg.wk.m();b:{for(;vh.s();){var fg=vh.t();if(fg.kc.V===Hd){var ih=new L(fg);break b}}ih=
+R()}var Ig=ih.b()?R():ih.o().Rd,Tf=Ig.b()?ou().Yl:Ig.o();if(null!==Tf){var Jg=Tf.qe;if(!0===Tf.Qd&&!0===Jg){dd=O().c;break a}}if(null!==Tf){var jh=Tf.qe;if(Tf.Qd){t();var yg=new Uw(a,new L(a.ib),EA(a,Vc.ra,t().d,t().d,e,g,h,k,l,m),Vc.Pd),gg=G(new H,kc,yg),Cf=O().c;dd=new z(gg,Cf)}else if(jh){var Uf=Vc.Oa;if(Uf.b())var $g=R();else{var Ah=Uf.o();$g=new L(EA(a,Ah,t().d,t().d,e,g,h,k,l,m))}var Kg=new Uw(a,$g,a.La,Vc.Pd),Vf=G(new H,kc,Kg),hg=O().c;dd=new z(Vf,hg)}else{var zg=rc.sb?rc.vb:DA(a,rc,Vc,e,g,
+h,k,l,m),Lg=G(new H,kc,zg),Mg=O().c;dd=new z(Lg,Mg)}break a}throw new w(Tf);}}hd&&no();t().d===ye&&no();throw new w(ye);}}}}throw new w(cd);}for(var Wf=dd.m();Wf.s();){var Ng=new z(Wf.t(),u());null===Uc?ad=Ng:Uc.p=Ng;Uc=Ng}Nc=Nc.f()}return SA(Yb,null===ad?u():ad,b.ma())}if(b instanceof Qx){var Kf=b.de,xf=EA(a,b.Re,c,(t(),new L(Kf)),e,g,h,k,l,m);if(d instanceof L){var Og=d.k|0;if(a.Wq){var mi=new Iw(m.S,m.Ec,m.hc,m.Ed,1+Og|0,m.Pc,m.Zc,m.Lb,m.yc,m.tb,m.$a,m.od,m.cb),Ci=new Qx(a,Kf,xf);return TA(Ci,
+mi)}}return yx(zx(a),Kf,xf)}if(b instanceof cv){var Xh=b.ac;return new cv(a,EA(a,b.Nb,t().d,t().d,e,g,h,k,l,m),EA(a,Xh,t().d,d,e,g,h,k,l,m),b.Mj)}var wh=t().d;return UA(b,wh,!0,new fn((ng,kh)=>EA(a,kh,t().d,t().d,e,g,h,k,l,m)),h)}catch(ng){if(ng instanceof Iq){var Bh=ng;if(Bh.Qg===r)return Bh.Cj();throw Bh;}throw ng;}};
+function eca(a,b,c,d,e,g,h,k){if(null===b)throw le();if(b.sb)return b.vb;lv();var l=x=>{x=x.h().x;a:{for(var A=x.length,B=0;B<A;){var C=x.charCodeAt(B);if(!Nm(new E(hc(C)),hc(35))){A=B;break a}B=1+B|0}A=-1}return d.L(-1===A?x:x.substring(0,A))},m=c.Ba;a:for(;;)if(m.b()){l=u();break}else{var n=m.e();c=m.f();if(!0===!!l(n))m=c;else for(;;){if(c.b())l=m;else{n=c.e();if(!0!==!!l(n)){c=c.f();continue}n=c;c=new z(m.e(),u());var r=m.f();for(m=c;r!==n;){var v=new z(r.e(),u());m=m.p=v;r=r.f()}for(r=n=n.f();!n.b();){v=
+n.e();if(!0===!!l(v)){for(;r!==n;)v=new z(r.e(),u()),m=m.p=v,r=r.f();r=n.f()}n=n.f()}r.b()||(m.p=r);l=c}break a}}return me(b,ry(0,l,new y(x=>{var A=x.Va,B=x.Oa;if(B.b())B=R();else{B=B.o();if(e.b())var C=R();else C=!!e.o(),C=new L(!C);B=new L(VA(a,B,C,t().d,g,h,k))}return new Uw(A,B,VA(a,x.ra,e,t().d,g,h,k),x.Pd)})))}function WA(a,b,c,d,e,g,h,k){return b.sb?b.vb:eca(a,b,c,d,e,g,h,k)}
+function XA(a,b,c,d,e,g,h){Nx(a,new U(()=>"DNF: "+b));var k=Pt(b.xe,new y(n=>{if(null!==n){var r=n.Pf,v=n.Of,x=n.Af;if(ow(n.Nf)&&r.b()&&(!Gw(v)||!x.b()))return t(),new fe(n)}t();return new Ud(n)}));if(null!==k)k=G(new H,k.h(),k.j());else throw new w(k);var l=k.h();k=k.j();if(l.b())l=a.ib;else{l=YA(l,a.La,new fn((n,r)=>{r=r.zf(!0);var v=V(r.q);r=NA(r,v,!1);v=V(n.q);return Pu(n,r,v,!1)}));var m=new y(n=>!n);l=VA(a,l,c.b()?R():new L(m.n(c.o())),t().d,e,g,h);m=V(l.q);l=NA(l,m,!1)}m=ZA($A(a));k=Qt(qw(k,
+m),new y(n=>{n.Pf.Ca(new y(r=>{aB(a,r,h,e,g)}));n.Af.Ca(new y(r=>{aB(a,r,h,e,g)}));return fca(n,new y(r=>{if(r instanceof Ku){var v=r.fc,x=r.vd,A=r.be,B=r.Me,C=new y(Pa=>{if(null!==Pa){var Db=Pa.h(),Oc=Pa.j();if(null!==Oc)return Pa=new fw(a,Oc.qb,bw(Oc,c,new fn((Tc,Sd)=>VA(a,Sd,Tc,t().d,e,g,h)),e),Oc.Xl),G(new H,Db,Pa)}throw new w(Pa);}),D=Su(),F=op().ga,I=B.gR(C,new Uu(D,F)),M=x.m(),N=new Ex(M,new bB(a)),P=Aq(Bq(),N),T=!1,Y=null;if(v instanceof L){T=!0;Y=v;var Z=Y.k;if(Z instanceof Mu){var S=Z.pd,
+ea=Z.JE;if(S instanceof vl){var ia=S.x;if(!a.cn.L(ia)&&e.tb.L(Nu(Q(),ia))&&!a.$c){var X=Nu(Q(),ia),sa=new Ep(X),Ja=e.tb.n(X),Xa=A.Ba;op();var Fa=pp(qp(),Xa),za=ry(lv(),A.Ba,new y(Pa=>cB(Pa,new y(Db=>{var Oc=new y(Tc=>!Tc);return VA(a,Db,c.b()?R():new L(Oc.n(c.o())),t().d,e,g,h)}),new y(Db=>VA(a,Db,c,t().d,e,g,h))))),Qa=new Qv(A.q,za,A.Nj);Nx(a,new U(()=>"rcd2 "+Qa));var Ma=dB(Ja),Ga=Ja.Wl,ab=Qt(Hf(Ja.Xm),new y(Pa=>{if(null!==Pa){var Db=Pa.h(),Oc=Pa.Sc();if(null!==Db){var Tc=Db.j(),Sd=new vl(sa.V+
+"#"+Db.h().V);Pa=I.U(sa);Db=new y(Jc=>{Jc=eB(Jc.Zb,Oc);return(new y(vd=>{t();return new Uw(a,new L(vd),vd,V(a))})).n(Jc)});Pa=Pa.b()?R():new L(Db.n(Pa.o()));Pa=iu(ju(),Pa);Db=Qa.Ba.m();Db=new iy(Db,new y(Jc=>Pe(new E(Jc.h()),Sd)),!1);Db=new Ef(Db,new y(Jc=>Jc.j()));Pa=Pa.tl(Db).De(G(new H,a.ib,a.La),new fn((Jc,vd)=>{var hd=G(new H,Jc,vd);Jc=hd.y;var de=hd.w;if(null!==Jc&&(vd=Jc.h(),Jc=Jc.j(),null!==de)){hd=de.Oa;de=de.ra;var ye=new U(()=>a.ib);hd=hd.b()?Es(ye):hd.o();ye=V(vd.q);vd=dv(vd,hd,ye,!1);
+hd=V(Jc.q);return G(new H,vd,Pu(Jc,de,hd,!1))}throw new w(hd);}));return(new y(Jc=>{if(null!==Jc){var vd=Jc.h();Jc=Jc.j();var hd=Ma.n(Tc);if(null!==hd){var de=hd.qe;if(!0===hd.Qd&&!0===de)return dw(cw(a),a.ib,a.La,ew(cw(a)),e)}if(null!==hd&&(de=hd.qe,!1===hd.Qd&&!1===de))return dw(cw(a),vd,Jc,ew(cw(a)),e);if(null!==hd)return hd.Qd?Jc:vd;throw new w(hd);}throw new w(Jc);})).n(Pa)}}throw new w(Pa);})),Hb=new fw(a,Ga,ab,V(a));Nx(a,new U(()=>"typeRef "+Hb));var bc=fB(a,gB(Hb,!0,!1,e),!0,e);Nx(a,new U(()=>
+"clsFields "+ze(bc,"",", ","")));ea.Ja(new y(Pa=>Nu(Q(),Pa.V))).bc(X).Ce(P);var yb=new Qv(a,gy(Qa.Ba,new y(Pa=>{if(null!==Pa){var Db=Pa.h(),Oc=Pa.j();Pa=bc.U(Db);var Tc=new y(Sd=>{var Jc=Xu().X();if(Fw(Sd,Oc,e,Jc))return!0;Jc=Fa.U(Db);var vd=new y(hd=>{var de=Xu().X();return Fw(Sd,hd,e,de)});return!Jc.b()&&!!vd.n(Jc.o())});return!Pa.b()&&!!Tc.n(Pa.o())}throw new w(Pa);}),!0),Qa.Nj),tb=Qa.Ba,eb=op(),kb=tb.Gb(eb.ga).h(),Rb=Aq(Bq(),kb),Gb=bc.tj(),vb=new iy(Gb,new y(Pa=>hB(ve(),Pa.x)?!0:Rb.L(Pa)),!0),
+Tb=Su(),Nb=op().ga,ic=new Uu(Tb,Nb),Va=oA(uv(),vb,ic),cb=Va.b()?Hb:iB(Hb,Va);if(Qa.Ba.ul(new y(Pa=>{if(null!==Pa){var Db=Pa.h(),Oc=Pa.j();Pa=bc.U(Db);var Tc=new y(Sd=>{var Jc=Xu().X();if(Fw(Oc,Sd,e,Jc))return!0;Jc=Fa.U(Db);var vd=new y(hd=>{var de=Xu().X();return Fw(hd,Sd,e,de)});return!Jc.b()&&!!vd.n(Jc.o())});return Pa.b()||!!Tc.n(Pa.o())}throw new w(Pa);}))){var zb=Lu(yb),Ub=V(Hb.q);jb=Pu(Hb,zb,Ub,!1)}else if(yb.Ba.b())var jb=cb;else{var db=Lu(yb);jb=new $y(a,cb,db,V(a))}ms();ms();var ub=new jB(da(Ru)),
+Aa=kB(x,ub),va=Su(),Ra=op().ga,rb=Tu(Aa,new Uu(va,Ra)),xb=lB(rb,jb,new fn((Pa,Db)=>{var Oc=V(Pa.q);return Pu(Pa,Db,Oc,!1)})),mc=I.xj(Ja.Wl),Ha=new Ou(mc);return mB(Ha,xb,new fn((Pa,Db)=>{var Oc=V(Pa.q);return Pu(Pa,Db,Oc,!1)}))}}}}if(T){var Ka=Y.k;if(Ka instanceof Mu){var Oa=Ka.pd,Na=Ka.JE;if(Oa instanceof vl){var Da=Oa.x;if(!a.cn.L(Da)&&e.$a.L(Da)&&!e.$a.n(Da).eo.b()){var ta=new Ep(Da),Ya=e.$a.n(Da).eo;a:{if(Ya instanceof L){var dc=Ya.k;if(dc instanceof Yw){var ka=dc;break a}}xm("Program reached and unexpected state.")}var ya=
+A.Ba;op();var Sa=pp(qp(),ya),xc=ry(lv(),A.Ba,new y(Pa=>cB(Pa,new y(Db=>{var Oc=new y(Tc=>!Tc);return VA(a,Db,c.b()?R():new L(Oc.n(c.o())),t().d,e,g,h)}),new y(Db=>VA(a,Db,c,t().d,e,g,h))))),Sb=new Qv(A.q,xc,A.Nj);Nx(a,new U(()=>"rcd2 "+Sb));var uc=ka.Rf.gb,Lb=Qt(Hf(ka.gh),new y(Pa=>{if(null!==Pa){var Db=Pa.h(),Oc=Pa.Sc();if(null!==Db){var Tc=Db.hb,Sd=new vl(ta.V+"#"+Db.kc.V);Pa=I.U(ta);Db=new y(Jc=>{Jc=eB(Jc.Zb,Oc);return(new y(vd=>{t();return new Uw(a,new L(vd),vd,V(a))})).n(Jc)});Pa=Pa.b()?R():
+new L(Db.n(Pa.o()));Pa=iu(ju(),Pa);Db=Sb.Ba.m();Db=new iy(Db,new y(Jc=>Pe(new E(Jc.h()),Sd)),!1);Db=new Ef(Db,new y(Jc=>Jc.j()));Pa=Pa.tl(Db).De(G(new H,a.ib,a.La),new fn((Jc,vd)=>{var hd=G(new H,Jc,vd);Jc=hd.y;var de=hd.w;if(null!==Jc&&(vd=Jc.h(),Jc=Jc.j(),null!==de)){hd=de.Oa;de=de.ra;var ye=new U(()=>a.ib);hd=hd.b()?Es(ye):hd.o();ye=V(vd.q);vd=dv(vd,hd,ye,!1);hd=V(Jc.q);return G(new H,vd,Pu(Jc,de,hd,!1))}throw new w(hd);}));return(new y(Jc=>{if(null!==Jc){var vd=Jc.h();Jc=Jc.j();var hd=RA(ka,Tc,
+e);if(null!==hd){var de=hd.qe;if(!0===hd.Qd&&!0===de)return dw(cw(a),a.ib,a.La,ew(cw(a)),e)}if(null!==hd&&(de=hd.qe,!1===hd.Qd&&!1===de))return dw(cw(a),vd,Jc,ew(cw(a)),e);if(null!==hd)return hd.Qd?Jc:vd;throw new w(hd);}throw new w(Jc);})).n(Pa)}}throw new w(Pa);})),lc=new fw(a,uc,Lb,V(a));Nx(a,new U(()=>"typeRef "+lc));var Xb=fB(a,gB(lc,!0,!1,e),!0,e);Nx(a,new U(()=>"clsFields "+ze(Xb,"",", ","")));Na.Ja(new y(Pa=>Nu(Q(),Pa.V))).bc(Da).Ce(P);var ec=new Qv(a,gy(Sb.Ba,new y(Pa=>{if(null!==Pa){var Db=
+Pa.h(),Oc=Pa.j();Pa=Xb.U(Db);var Tc=new y(Sd=>{var Jc=Xu().X();if(Fw(Sd,Oc,e,Jc))return!0;Jc=Sa.U(Db);var vd=new y(hd=>{var de=Xu().X();return Fw(Sd,hd,e,de)});return!Jc.b()&&!!vd.n(Jc.o())});return!Pa.b()&&!!Tc.n(Pa.o())}throw new w(Pa);}),!0),Sb.Nj),Ab=Sb.Ba,Ob=op(),fb=Ab.Gb(Ob.ga).h();Aq(Bq(),fb);ms();ms();var Wa=new jB(da(Ru)),bb=kB(x,Wa),Ia=Su(),Ua=op().ga,pc=Tu(bb,new Uu(Ia,Ua)),sc=V(lc.q),Ba=lB(pc,Pu(lc,ec,sc,!1),new fn((Pa,Db)=>{var Oc=V(Pa.q);return Pu(Pa,Db,Oc,!1)})),ob=I.xj(ka.Rf.gb),nc=
+new Ou(ob);return mB(nc,Ba,new fn((Pa,Db)=>{var Oc=V(Pa.q);return Pu(Pa,Db,Oc,!1)}))}}}}var Ib=new $e,vc=!1,Vb=null;a:{if(v instanceof L){vc=!0;Vb=v;var fc=Vb.k;if(fc instanceof zv){var Bc=fc.Yb,Pb=Bc.K(),Jb=gy(A.Ba,new y(Pa=>{Q();return P.L(gca(Pa.h().x,new y(Db=>Nm(new E(hc(Ea(Db))),hc(35)))))}),!0),gc=Pt(Jb,new y(Pa=>{var Db=nB(Pa.h()),Oc=new oB(0,Pb,1),Tc=new y(Sd=>pB(Oc,Sd|0));Db=Db.b()||Tc.n(Db.o())?Db:R();Tc=new y(Sd=>G(new H,Sd|0,Pa.j()));Db=Db.b()?R():new L(Tc.n(Db.o()));Tc=new U(()=>Pa);
+if(Db.b())return O(),Db=Es(Tc),new Ud(Db);O();Db=Db.o();return new fe(Db)}));if(null!==gc)var Cb=G(new H,gc.h(),gc.j());else throw new w(gc);var cc=Cb.h(),yc=Cb.j();op();var Mc=pp(qp(),cc),qc=Bc.m(),oc=new Ao(qc),Qc=new Ef(oc,new y(Pa=>{if(null!==Pa){var Db=Pa.h(),Oc=Pa.Sc();if(null!==Db)return Pa=Db.h(),Db=Db.j(),Oc=Mc.Se(Oc,new U(()=>{var Tc=a.La,Sd=V(a);return new Uw(Tc.q,R(),Tc,Sd)})),Oc=cB(Nv(Db,Oc,V(Db.Va)),new y(Tc=>{var Sd=new y(Jc=>!Jc);return VA(a,Tc,c.b()?R():new L(Sd.n(c.o())),t().d,e,
+g,h)}),new y(Tc=>VA(a,Tc,c,t().d,e,g,h))),G(new H,Pa,Oc)}throw new w(Pa);}));Od();var jc=Pd(u(),Qc);t();var sb=new zv(a,jc,fc.Nq),Gc=new L(sb),Wb=ry(lv(),yc,new y(Pa=>cB(Pa,new y(Db=>{var Oc=new y(Tc=>!Tc);return VA(a,Db,c.b()?R():new L(Oc.n(c.o())),t().d,e,g,h)}),new y(Db=>VA(a,Db,c,t().d,e,g,h)))));var Cc=G(new H,Gc,Wb);break a}}if(vc){var Fc=Vb.k;if(Fc instanceof Mu){t();var qd=new L(Fc),Yb=WA(a,Ib,A,P,c,e,g,h);Cc=G(new H,qd,Yb);break a}}if(vc){var Nc=Vb.k;if(Nc instanceof cv){var ad=Nc.Nb,Uc=
+Nc.ac;t();var cd=new y(Pa=>!Pa),kc=VA(a,ad,c.b()?R():new L(cd.n(c.o())),t().d,e,g,h),Vc=new U(()=>zy(ju(),qB(b),new U(()=>b.fb))),Hc=new cv(a,kc,VA(a,Uc,c,d.b()?Es(Vc):d,e,g,h),Nc.Mj),rc=new L(Hc),sd=WA(a,Ib,A,P,c,e,g,h);Cc=G(new H,rc,sd);break a}}if(vc){var Kc=Vb.k;if(Kc instanceof Jv){t();var Qd=rB(Kc,c,new fn((Pa,Db)=>VA(a,Db,Pa,t().d,e,g,h))),Ad=new L(Qd),kd=WA(a,Ib,A,P,c,e,g,h);Cc=G(new H,Ad,kd);break a}}if(vc){var Hd=Vb.k;if(Hd instanceof Sv){var Rd=Hd.Fd;t();var Bd=new Sv(a,cB(Rd,new y(Pa=>
+{var Db=new y(Oc=>!Oc);return VA(a,Pa,c.b()?R():new L(Db.n(c.o())),t().d,e,g,h)}),new y(Pa=>VA(a,Pa,c,t().d,e,g,h))),Hd.Fx),ae=new L(Bd),dd=WA(a,Ib,A,P,c,e,g,h);Cc=G(new H,ae,dd);break a}}if(vc){var od=Vb.k;if(od instanceof Wv){t();var Ta=sB(od,new y(Pa=>VA(a,Pa,c,t().d,e,g,h)),new y(Pa=>{var Db=new y(Oc=>!Oc);return VA(a,Pa,c.b()?R():new L(Db.n(c.o())),t().d,e,g,h)}),new y(Pa=>VA(a,Pa,c,t().d,e,g,h)),od.Uu),wb=new L(Ta),$a=WA(a,Ib,A,P,c,e,g,h);Cc=G(new H,wb,$a);break a}}if(vc){var wa=Vb.k;if(wa instanceof
+Tv){var hb=wa.Ic,ra=wa.kf;if(hb instanceof LA&&null!==ra&&ra.b()){t();var wc=new Tv(a,tB(hb,new y(Pa=>VA(a,Pa,c,t().d,e,g,h))),ra,wa.vp),ac=new L(wc),Id=WA(a,Ib,A,P,c,e,g,h);Cc=G(new H,ac,Id);break a}}}if(vc){var ud=Vb.k;if(ud instanceof Tv){var be=ud.Ic,re=ud.kf;t();var pe=new Tv(a,VA(a,be,c,t().d,e,g,h),re,ud.vp),bd=new L(pe),Rc=WA(a,Ib,A,P,c,e,g,h);Cc=G(new H,bd,Rc);break a}}if(t().d===v){var Wc=t().d,Wd=WA(a,Ib,A,P,c,e,g,h);Cc=G(new H,Wc,Wd)}else throw new w(v);}if(null!==Cc)var zd=G(new H,Cc.h(),
+Cc.j());else throw new w(Cc);return(new Ku(a,zd.h(),x,Lu(new Qv(A.q,zd.j(),A.Nj)),I)).zf(!0)}if(Vu(a)===r)return a.La;throw new w(r);}),new y(r=>{if(lw(a)===r)return a.ib;if(r instanceof iw){var v=r.me,x=cB(r.Ne,new y(D=>{var F=new y(I=>!I);return VA(a,D,c.b()?R():new L(F.n(c.o())),t().d,e,g,h)}),new y(D=>VA(a,D,c,t().d,e,g,h)));v=G(new H,v,x);x=O().c;return new Qv(a,new z(v,x),V(a))}if(r instanceof jw){v=r.Xb;x=r.mb;r=r.Dc;var A=!1,B=null;a:{if(x instanceof L){A=!0;B=x;var C=B.k;if(C instanceof Ud&&
+(C=C.fa,null!==C)){x=(new iw(a,C.me,cB(C.Ne,new y(D=>{var F=new y(I=>!I);return VA(a,D,c.b()?R():new L(F.n(c.o())),t().d,e,g,h)}),new y(D=>VA(a,D,c,t().d,e,g,h))))).zf(!0);break a}}if(A&&(A=B.k,A instanceof fe)){x=VA(a,A.aa,c,t().d,e,g,h);break a}if(t().d===x)x=a.ib;else throw new w(x);}r=new Ou(r);r=new Ef(r,new y(D=>VA(a,D,c,t().d,e,g,h)));r=mB(r,a.ib,new fn((D,F)=>{var I=V(D.q);return dv(D,F,I,!1)}));A=Su();B=op().ga;v=qw(v,new Uu(A,B)).De(x,new fn((D,F)=>{var I=V(D.q);return dv(D,F,I,!1)}));x=
+V(r.q);return dv(r,v,x,!1)}throw new w(r);}))}));k=YA(k,a.ib,new fn((n,r)=>{var v=V(n.q);return dv(n,r,v,!1)}));k=(new y(n=>{a:{var r=uB(n,!0);n=O().c;for(r=er(r).m();r.s();){var v=r.t();b:{for(var x=n;!x.b();){var A=x.e(),B=Xu().X();if(Zu(v,A,e,!0,B)){x=!0;break b}x=x.f()}x=!1}x||(n=new z(v,n))}r=O().c;if(null===r?null===n:r.i(n))n=a.ib;else{if(n instanceof z&&(r=n.z,v=n.p,x=O().c,null===x?null===v:x.i(v))){n=r;break a}if(n===u())n=u();else{r=n.e();v=r=new z(uB(r,!1),u());for(n=n.f();n!==u();)x=
+n.e(),x=new z(uB(x,!1),u()),v=v.p=x,n=n.f();n=r}n=vB(a,n)}}return n})).n(k);m=V(k.q);k=dv(k,l,m,!1);l=Qt(b.Qf,new y(n=>{if(null!==n){var r=n.j();return G(new H,VA(a,n.h(),(t(),new L(!0)),t().d,e,g,h),VA(a,r,(t(),new L(!1)),t().d,e,g,h))}throw new w(n);}));k=wx(vx(a),l,k);return d instanceof L&&(l=d.k|0,a.Wq)?(l=new Iw(g.S,g.Ec,g.hc,g.Ed,1+l|0,g.Pc,g.Zc,g.Lb,g.yc,g.tb,g.$a,g.od,g.cb),k=new Qx(a,b.fb,k),TA(k,l)):yx(zx(a),b.fb,k)}
+function Wba(a,b,c,d,e,g,h){d=a.qa;if(a.F){var k=ut(Q(),"| ",a.r)+("normLike["+dA(c)+"] ")+b;ff(gf(),k+"\n")}a.r=1+a.r|0;try{a:if(b instanceof zA)var l=VA(a,b,c,t().d,e,g,h);else{if(b instanceof BA){CA(a);t();var m=new L(b);if(!m.b()){l=wB(m.k,c,new fn((n,r)=>VA(a,r,n,t().d,e,g,h)),e);break a}}throw new w(b);}}finally{a.r=-1+a.r|0}dx(new E(d),a.qa)&&a.F&&(b=""+ut(Q(),"| ",a.r)+d.n(l),ff(gf(),b+"\n"));return l}
+function VA(a,b,c,d,e,g,h){var k=new y(P=>"~\x3e "+P);if(a.F){var l=ut(Q(),"| ",a.r)+("norm["+dA(c)+"] ")+b;ff(gf(),l+"\n")}a.r=1+a.r|0;try{if(c instanceof L){var m=!!c.k,n=a.Df,r=O().c;xB(a);var v=ap(),x=XA(a,yB(xB(a),n,r,b,m,e,!0,!1,v),c,d,e,g,h)}else if(t().d===c){var A=a.Df,B=O().c;xB(a);var C=ap(),D=yB(xB(a),A,B,b,!1,e,!0,!1,C),F=a.Df,I=O().c;xB(a);var M=ap(),N=yB(xB(a),F,I,b,!0,e,!0,!1,M);x=dw(cw(a),XA(a,D,(t(),new L(!1)),d,e,g,h),XA(a,N,(t(),new L(!0)),d,e,g,h),ew(cw(a)),e)}else throw new w(c);
+}finally{a.r=-1+a.r|0}dx(new E(k),a.qa)&&a.F&&(a=""+ut(Q(),"| ",a.r)+k.n(x),ff(gf(),a+"\n"));return x}
+function aB(a,b,c,d,e){var g=new zB(c);if(!g.en.L(b))if(g.en.$(b),g=b.Sb,g instanceof L)g=g.k,t(),a=VA(a,g,t().d,t().d,d,e,c),wy(b,new L(a));else if(t().d===g){g=vy(b);if(g.b())g=R();else{g=g.m();if(!g.s())throw nv("empty.reduceLeft");for(var h=!0,k=null;g.s();){var l=g.t();if(h)k=l,h=!1;else{var m=V(k.q);k=dv(k,l,m,!1)}}g=new L(k)}g.b()?(t(),g=O().c):(g=g.o(),g=VA(a,g,(t(),new L(!0)),t().d,d,e,c),h=O().c,g=new z(g,h));IA(b,g);g=rA(b);if(g.b())g=R();else{g=g.m();if(!g.s())throw nv("empty.reduceLeft");
+h=!0;for(k=null;g.s();)l=g.t(),h?(k=l,h=!1):(m=V(k.q),k=Pu(k,l,m,!1));g=new L(k)}g.b()?(t(),a=O().c):(g=g.o(),a=VA(a,g,(t(),new L(!1)),t().d,d,e,c),c=O().c,a=new z(a,c));KA(b,a)}else throw new w(g);}function Yba(a,b,c,d,e,g){if(null===b)throw le();return b.sb?b.vb:me(b,new AB(a,c,d,e,g))}function nA(a,b,c,d,e,g,h,k){if(d.sb)a=d.vb;else{if(null===d)throw le();a=d.sb?d.vb:me(d,new BB(a,e,g,h,k,d))}mA(a,c,b.rT())}
+var hca=function CB(a,b,c,d,e,g,h,k,l,m){var r=a.qa;if(a.F){var v=ut(Q(),"| ",a.r)+("go "+b+"   ("+ze(c,"",", ",""))+")";ff(gf(),v+"\n")}a.r=1+a.r|0;try{var x=DB(b);a:if(x instanceof lx){if(EB(c,x)){var A=x.Sb;if(A instanceof L)CB(a,A.k,c,d,e,g,h,k,l,m);else if(t().d===A){var B=d.Ig(x.Xa);if(B instanceof L)for(var C=B.k?vy(x):rA(x);!C.b();){var D=C.e();CB(a,D,c,d,e,g,h,k,l,m);C=C.f()}else if(t().d===B){var F=a.qa;if(a.F){var I=ut(Q(),"| ",a.r)+"Analyzing invar-occ of "+x;ff(gf(),I+"\n")}a.r=1+a.r|
+0;try{nA(a,x,d,g,h,k,l,m);var M=void 0}finally{a.r=-1+a.r|0}if(dx(new E(F),a.qa)&&a.F){var N=""+ut(Q(),"| ",a.r)+F.n(M);ff(gf(),N+"\n")}}else throw new w(B);}else throw new w(A);}}else{if(x instanceof LA){var P=x.ic,T=x.jc;if(Pe(new E(x.tc),e)){CB(a,P,c,d,e,g,h,k,l,m);CB(a,T,c,d,e,g,h,k,l,m);break a}}FB(c,b)}var Y=void 0}finally{a.r=-1+a.r|0}dx(new E(r),a.qa)&&a.F&&(a=""+ut(Q(),"| ",a.r)+r.n(Y),ff(gf(),a+"\n"))};
+function GB(a,b,c,d,e,g){Pe(new E(b),c)?c=d:(jA(),c=jA().X().$(e));a.F&&(a=ut(Q(),"| ",a.r)+("\x3e\x3e\x3e\x3e occs["+HB(b)+e+"] :\x3d "+c+"  \x3c~ ")+g.U(G(new H,b,e)),ff(gf(),a+"\n"));a=g.U(G(new H,b,e));if(a instanceof L){if(b=a.k,e=c,!b.b()){IB();if(0<=b.Q())g=b.Q(),g=new zc(g),b.Gc(g,0,2147483647);else{g=[];for(c=b.m();c.s();)a=c.t(),g.push(null===a?null:a);g=new zc(g)}c=g.a.length;for(a=0;a<c;)d=g.a[a],e.n(d)||b.Bm(d),a=1+a|0}}else if(R()===a)g.bh(G(new H,b,e),JB(KB(),c));else throw new w(a);
+}function LB(a,b,c,d,e,g,h,k,l){var m=new MB;if(a.F){var n=ut(Q(),"| ",a.r)+("\x3e\x3e Processing "+b+" at ["+dA((t(),new L(d))))+"]";ff(gf(),n+"\n")}hca(a,b,m,c,d,g,h,k,l,e);a.F&&(b=ut(Q(),"| ",a.r)+"\x3e\x3e Occurrences "+m,ff(gf(),b+"\n"));for(b=m.ku;null!==b;){n=b.zw;if(n instanceof lx){var r=c.Ig(n.Xa);if(r instanceof L)GB(a,!!r.k,d,m,n,e);else if(t().d===r)GB(a,!0,d,m,n,e),GB(a,!1,d,m,n,e);else throw new w(r);}b=b.Mo}for(d=m.ku;null!==d;)m=d.zw,m instanceof lx||nA(a,m,c,g,h,k,l,e),d=d.Mo}
+function pA(a,b,c){a=a.m();a=new iy(a,new y(d=>{var e;if(e=!b.L(d)){a:{e=d.Sb;if(e.b())e=vy(d);else{e=e.o();var g=O().c;e=new z(e,g)}for(g=d.q.ib;!e.b();){var h=e.e(),k=V(g.q);g=dv(g,h,k,!1);e=e.f()}e=g;g=gA(d.q).Pj;e=hA(e,g,c).U(d);if(e instanceof L&&(e=e.k,e=t().d===e?!0:e instanceof L&&!0===!!e.k?!0:!1,e)){e=!0;break a}e=!1}if(!e)a:{e=d.Sb;e.b()?e=rA(d):(e=e.o(),g=O().c,e=new z(e,g));for(g=d.q.La;!e.b();)h=e.e(),k=V(g.q),g=Pu(g,h,k,!1),e=e.f();e=g;g=gA(d.q).Jx;d=hA(e,g,c).U(d);if(d instanceof L&&
+(d=d.k,d=t().d===d?!0:d instanceof L&&!1===!!d.k?!0:!1,d)){e=!0;break a}e=!1}}return e}),!1);return Aq(Bq(),a)}
+function uA(a,b,c,d,e){var g=c.U(G(new H,b,d)).m();for(g=new xo(g,new y(Fa=>new qA(Fa)));g.s();){var h=g.t();if(h instanceof lx){var k=h;if((Ot(new E(k),d)?0:k.Sb.b())&&!e.L(k)&&(!d.kg.b()||k.kg.b()||e.L(d))&&Pe(new E(d.Xa),k.Xa)){h=a.qa;var l=a;if(l.F){var m=ut(Q(),"| ",l.r),n=dA((t(),new L(b))),r=iu(ju(),c.U(G(new H,b,k)));m=m+("[w] "+k+" "+n)+ze(r,"","","");ff(gf(),m+"\n")}l.r=1+l.r|0;try{var v=b?rA(d):vy(d),x=b?rA(k):vy(k),A=Aq(Bq(),v);if(Nm(new E(A),Aq(Bq(),x))){if(m=a,m.F){var B=ut(Q(),"| ",
+m.r)+(d+" and "+k)+" have non-equal other bounds and won't be merged";ff(gf(),B+"\n")}}else{var C=c.U(G(new H,b,k));if(C.b()||C.o().L(d)){m=a;if(m.F){var D=ut(Q(),"| ",m.r)+("  [U] "+k+" :\x3d ")+d;ff(gf(),D+"\n")}t();var F=G(new H,k,new L(d));e.$(F);IA(d,dl(vy(d),vy(k)));KA(d,dl(rA(d),rA(k)));var I=O().c;IA(k,new z(d,I));var M=O().c;KA(k,new z(d,M));var N=c.U(G(new H,!b,k));if(!N.b()){var P=N.o(),T=c.U(G(new H,!b,d));if(T instanceof L){var Y=T.k;if(!Y.b()){IB();if(0<=Y.ka()){var Z=Y.ka(),S=new zc(Z);
+NB(Y,S,0,2147483647);var ea=S}else{k=null;k=[];for(var ia=new qA(Y);ia.s();){var X=ia.t();k.push(null===X?null:X)}ea=new zc(k)}var sa=ea.a.length;for(k=0;k<sa;){var Ja=ea.a[k];m=Ja;Pe(new E(m),d)||P.L(m)||Y.IB(Ja);k=1+k|0}}}else if(t().d===T)c.bh(G(new H,!b,d),P);else throw new w(T);}}}var Xa=void 0}finally{l.r=-1+l.r|0}dx(new E(h),l.qa)&&l.F&&(h=""+ut(Q(),"| ",l.r)+h.n(Xa),ff(gf(),h+"\n"))}}}}
+function OB(a,b,c,d,e,g,h,k,l,m,n,r,v,x,A,B){var C=d.Sb;if(C instanceof L)C=C.k;else{if(t().d!==C)throw new w(C);C=PB(a,b,b?vy(d):rA(d))}return QB(a,C,new RB(c,d.Xa,b),e,g,h,k,l,m,n,r,v,x,A,B)}function Zba(a,b,c,d,e,g,h,k,l,m,n,r){if(b instanceof zA)return QB(a,b,c,d,t().d,d,g,h,e,k,!0,l,m,n,r);if(b instanceof BA){CA(a);t();var v=new L(b);if(!v.b())return ica(v.k,c,new fn((x,A)=>QB(a,A,x,d,t().d,d,g,h,e,k,!0,l,m,n,r)),e)}throw new w(b);}
+function SB(a,b,c,d,e,g,h,k,l,m,n,r,v){if(null!==b){var x=b.Oa,A=b.ra;if(x instanceof L&&Pe(new E(x.k),A))return c=QB(a,A,new TB(c),d,t().d,d,e,g,h,k,l,m,n,r,v),new Uw(a,(t(),new L(c)),c,b.Pd)}x=b.Va;A=b.Oa;A.b()?A=R():(A=A.o(),A=new L(QB(a,A,new UB(c),d,t().d,d,e,g,h,k,l,m,n,r,v)));return new Uw(x,A,QB(a,b.ra,c,d,t().d,d,e,g,h,k,l,m,n,r,v),b.Pd)}
+function VB(a,b,c,d,e,g,h,k,l,m,n,r,v,x,A,B){var C=a.qa;a.F&&(c=ut(Q(),"| ",a.r)+("Setting [\u00b1] bounds of "+b+"... (failing "+dA(c)+", inlineBounds "+d+", !occursInvariantly "+!e.L(g)+", !recVars.contains(tv) "+!h.rc.L(g))+")",ff(gf(),c+"\n"));a.r=1+a.r|0;try{var D=g.Sb;if(D instanceof L){var F=D.k;t();var I=QB(a,F,new TB(k),l,m,l,r,v,x,A,d,e,h,n,B);wy(b,new L(I))}else if(t().d===D){if(n.L(G(new H,!0,g))){var M=vy(g);m=Qa=>{var Ma=new RB(k,g.Xa,!0);tp();return QB(a,Qa,Ma,gq(g),t().d,l,r,v,x,A,
+d,e,h,n,B)};if(M===u())var N=u();else{var P=M.e(),T=new z(m(P),u());P=T;for(var Y=M.f();Y!==u();){var Z=Y.e(),S=new z(m(Z),u());P=P.p=S;Y=Y.f()}N=T}IA(b,N)}if(n.L(G(new H,!1,g))){var ea=rA(g);M=Qa=>{var Ma=new RB(k,g.Xa,!1);tp();return QB(a,Qa,Ma,gq(g),t().d,l,r,v,x,A,d,e,h,n,B)};if(ea===u())var ia=u();else{var X=ea.e(),sa=new z(M(X),u());X=sa;for(var Ja=ea.f();Ja!==u();){var Xa=Ja.e(),Fa=new z(M(Xa),u());X=X.p=Fa;Ja=Ja.f()}ia=sa}KA(b,ia)}}else throw new w(D);var za=b}finally{a.r=-1+a.r|0}dx(new E(C),
+a.qa)&&a.F&&(b=""+ut(Q(),"| ",a.r)+C.n(za),ff(gf(),b+"\n"));return za}
+var QB=function WB(a,b,c,d,e,g,h,k,l,m,n,r,v,x,A){var C=new y(kc=>"~\x3e "+kc);if(a.F){var D=ut(Q(),"| ",a.r)+("transform["+dA(c.ol)+"] "+b+"   ("+ze(d,"",", ","")+")  "+c+"  ")+e;ff(gf(),D+"\n")}a.r=1+a.r|0;try{var F=!1,I=null,M=!1,N=null;a:if(b instanceof Qv){var P=b.Ba;var T=new Qv(a,ry(lv(),P,new y(kc=>SB(a,kc,c,g,h,k,l,m,n,r,v,x,A))),b.ma())}else if(b instanceof zv){var Y=b.Yb;T=new zv(a,ry(lv(),Y,new y(kc=>SB(a,kc,c,g,h,k,l,m,n,r,v,x,A))),b.ma())}else if(b instanceof Sv)T=new Sv(a,SB(a,b.Fd,
+c,g,h,k,l,m,n,r,v,x,A),b.ma());else if(b instanceof Wv){var Z=b.fo,S=kc=>{if(kc instanceof fe)return kc=kc.aa,t(),kc=WB(a,kc,c,g,t().d,g,h,k,l,m,n,r,v,x,A),new fe(kc);if(kc instanceof Ud)return kc=kc.fa,t(),kc=SB(a,kc,c,g,h,k,l,m,n,r,v,x,A),new Ud(kc);throw new w(kc);};if(Z===u())var ea=u();else{for(var ia=Z.e(),X=new z(S(ia),u()),sa=X,Ja=Z.f();Ja!==u();){var Xa=Ja.e(),Fa=new z(S(Xa),u());sa=sa.p=Fa;Ja=Ja.f()}ea=X}T=new Wv(a,ea,b.ma())}else if(b instanceof cv){var za=b.ac;T=new cv(a,WB(a,b.Nb,new UB(c),
+g,t().d,g,h,k,l,m,n,r,v,x,A),WB(a,za,c,g,e,g,h,k,l,m,n,r,v,x,A),b.ma())}else if(b instanceof Jv)T=jca(b,c,new fn((kc,Vc)=>WB(a,Vc,kc,d,e,g,h,k,l,m,n,r,v,x,A)));else if(b instanceof mx)T=WB(a,b.hi,c,d,t().d,g,h,k,l,m,n,r,v,x,A);else if(XB(b)||b instanceof YB||b instanceof FA)T=b;else{if(b instanceof lx&&(F=!0,I=b,d.L(I))){var Qa=!1,Ma=null,Ga=c.Ig(I.Xa);if(Ga instanceof L&&(Qa=!0,Ma=Ga,!0===!!Ma.k)){T=a.ib;break a}if(Qa&&!1===!!Ma.k){T=a.La;break a}if(t().d===Ga){T=WB(a,I,c,d.Ek(I),t().d,g,h,k,l,m,
+n,r,v,x,A);break a}throw new w(Ga);}if(F){var ab=!1,Hb=null,bc=h.U(I);if(bc instanceof L){ab=!0;Hb=bc;var yb=Hb.k;if(yb instanceof L){var tb=yb.k;if(a.F){var eb=ut(Q(),"| ",a.r)+"-\x3e "+tb;ff(gf(),eb+"\n")}T=WB(a,tb,c,d.bc(I),e,g,h,k,l,m,n,r,v,x,A);break a}}if(ab){var kb=Hb.k;if(t().d===kb){var Rb=I;if(a.F){var Gb=ut(Q(),"| ",a.r)+"-\x3e bound "+c.Ig(Rb.Xa);ff(gf(),Gb+"\n")}var vb=c.Ig(I.Xa);if(!k&&(vy(I).b()&&vb.L(!0)||rA(I).b()&&vb.L(!1)||vy(I).b()&&rA(I).b())){var Tb=new vl("?"),Nb=ap();T=new Mu(a,
+Tb,Nb,V(a))}else{var ic=I;vb.b()&&xm("Should not be replacing an invariant type variable by its bound...");var Va=!!vb.o();T=OB(a,Va,c,ic,d.bc(ic),e,g,h,k,l,m,n,r,v,x,A)}break a}}if(t().d===bc){var cb=new GA(!0),zb=m.Hk(I,new U((kc=>()=>{cb.Am=!1;var Vc=V(a);t();var Hc=new L(kc),rc=kc.kg,sd=O().c,Kc=O().c;Vc=new lx(a,kc.Xa,sd,Kc,Hc,rc,!1,Vc);a.F&&(Hc=ut(Q(),"| ",a.r)+("Renewed "+kc+" ~\x3e ")+Vc,ff(gf(),Hc+"\n"));return Vc})(I))),Ub=c.Ig(I.Xa);if(Ub instanceof L){var jb=!!Ub.k;if(n&&!r.L(I)&&!v.rc.L(I)){var db=
+I;if(a.F){var ub=ut(Q(),"| ",a.r)+("Inlining ["+HB(jb)+"] bounds of "+db+" (~\x3e "+zb)+")";ff(gf(),ub+"\n")}if(jb){var Aa=OB(a,!0,c,I,d.bc(I),e,g,h,k,l,m,n,r,v,x,A),va=V(Aa.q);T=dv(Aa,zb,va,!1)}else{var Ra=OB(a,!1,c,I,d.bc(I),e,g,h,k,l,m,n,r,v,x,A),rb=V(Ra.q);T=Pu(Ra,zb,rb,!1)}break a}}if(!cb.Am){if(Ub instanceof L){var xb=!!Ub.k;if(A.U(G(new H,!xb,I)).b()&&I.Sb.b()){var mc=xb?vy(I):rA(I);b:{for(var Ha=mc;!Ha.b();){var Ka=Ha.e();if(Ka instanceof lx)var Oa=h.U(Ka),Na=Oa.b()?!0:!Oa.o().b();else Na=
+!1;if(!Na){var Da=!1;break b}Ha=Ha.f()}Da=!0}if(Da){var ta=I;if(a.F){var Ya=ut(Q(),"| ",a.r)+("NEW SUBS "+ta)+" -\x3e N";ff(gf(),Ya+"\n")}var dc=I,ka=t().d,ya=G(new H,dc,ka);h.$(ya);var Sa=PB(a,xb,mc);T=WB(a,Sa,c,d.bc(I),e,g,h,k,l,m,n,r,v,x,A)}else T=VB(a,zb,Ub,n,r,I,v,c,g,e,x,h,k,l,m,A);break a}}T=VB(a,zb,Ub,n,r,I,v,c,g,e,x,h,k,l,m,A);break a}T=zb;break a}throw new w(bc);}if(b instanceof LA){M=!0;N=b;var xc=N.ic,Sb=N.jc;if(!0===N.tc){var uc=WB(a,xc,c,d,e,g,h,k,l,m,n,r,v,x,A),Lb=WB(a,Sb,c,d,e,g,h,
+k,l,m,n,r,v,x,A),lc=V(uc.q);T=dv(uc,Lb,lc,!1);break a}}if(M){var Xb=N.ic,ec=N.jc;if(!1===N.tc){var Ab=WB(a,Xb,c,d,e,g,h,k,l,m,n,r,v,x,A),Ob=WB(a,ec,c,d,e,g,h,k,l,m,n,r,v,x,A),fb=V(Ab.q);T=Pu(Ab,Ob,fb,!1);break a}}if(b instanceof MA){var Wa=WB(a,b.Fc,new UB(c),g,t().d,g,h,k,l,m,n,r,v,x,A),bb=V(Wa.q);T=NA(Wa,bb,!1)}else{if(b instanceof $y){var Ia=b.Oq,Ua=b.up;if(null!==Ua){var pc=Ua.Ba,sc=WB(a,Ia,c,g,e,g,h,k,l,m,n,r,v,x,A),Ba=ry(lv(),pc,new y(kc=>{var Vc=kc.Va,Hc=kc.Oa;Hc.b()?Hc=R():(Hc=Hc.o(),Hc=new L(WB(a,
+Hc,new UB(c),g,t().d,g,h,k,l,m,n,r,v,x,A)));return new Uw(Vc,Hc,WB(a,kc.ra,c,g,t().d,g,h,k,l,m,n,r,v,x,A),kc.Pd)})),ob=new Qv(a,Ba,V(a));T=new $y(a,sc,ob,V(a));break a}}if(b instanceof ZB){$B(a);t();var nc=b.mc(),Ib=new L(nc);if(!Ib.b()){T=WB(a,Ib.k,c,d,e,g,h,k,l,m,n,r,v,x,A);break a}}if(b instanceof fw)T=new fw(a,b.qb,aC(b,c,new fn((kc,Vc)=>WB(a,Vc,kc,g,t().d,g,h,k,l,m,n,r,v,x,A)),l),b.Xl);else if(b instanceof Tv){var vc=b.Ic,Vb=b.kf;if(Vb.b())T=WB(a,vc,c,g,e,g,h,k,l,m,n,r,v,x,A);else if(Pe(new E(c.ol),
+(t(),new L(!0)))){var fc=WB(a,vc,c,g,e,g,h,k,l,m,n,r,v,x,A);T=bC(fc,Vb)}else{var Bc=WB(a,vc,c,g,e,g,h,k,l,m,n,r,v,x,A);T=iB(Bc,Vb)}}else if(b instanceof cC){var Pb=b.Fg,Jb=b.Sf,gc=c.ol;if(gc.b()){var Cb=cw(a),cc=WB(a,Pb,gA(a).Xu,d,e,g,h,k,l,m,n,r,v,x,A),yc=WB(a,Jb,gA(a).Pj,d,e,g,h,k,l,m,n,r,v,x,A);T=tA(Cb,cc,yc,V(a))}else T=gc.o()?WB(a,Jb,c,d,t().d,g,h,k,l,m,n,r,v,x,A):WB(a,Pb,c,d,t().d,g,h,k,l,m,n,r,v,x,A)}else if(b instanceof Qx){var Mc=b.de,qc=WB(a,b.Re,new dC(c,Mc),d,(t(),new L(Mc)),g,h,k,l,m,
+n,r,v,x,A);if(e instanceof L){var oc=e.k|0;if(a.Wq){var Qc=new Iw(l.S,l.Ec,l.hc,l.Ed,1+oc|0,l.Pc,l.Zc,l.Lb,l.yc,l.tb,l.$a,l.od,l.cb),jc=new Qx(a,Mc,qc);T=TA(jc,Qc);break a}}T=yx(zx(a),Mc,qc)}else if(b instanceof eC){var sb=b.Lj,Gc=b.kj,Wb=kc=>{if(null!==kc){var Vc=kc.j();return G(new H,WB(a,kc.h(),gA(a).Pj,g,t().d,g,h,k,l,m,n,r,v,x,A),WB(a,Vc,gA(a).Jx,g,t().d,g,h,k,l,m,n,r,v,x,A))}throw new w(kc);};if(sb===u())var Cc=u();else{for(var Fc=sb.e(),qd=new z(Wb(Fc),u()),Yb=qd,Nc=sb.f();Nc!==u();){var ad=
+Nc.e(),Uc=new z(Wb(ad),u());Yb=Yb.p=Uc;Nc=Nc.f()}Cc=qd}T=new eC(a,Cc,WB(a,Gc,c,d,t().d,g,h,k,l,m,n,r,v,x,A))}else throw new w(b);}}}finally{a.r=-1+a.r|0}if(dx(new E(C),a.qa)&&a.F){var cd=""+ut(Q(),"| ",a.r)+C.n(T);ff(gf(),cd+"\n")}return T};function fC(a,b,c,d,e,g,h,k){if(null===b)throw le();return b.sb?b.vb:me(b,UA(c,d,!0,new fn((l,m)=>gC(a,l,m,e,h,g,k)),g))}
+var gC=function hC(a,b,c,d,e,g,h){for(;;){var l=!1,m=null,n=uy(c);if(n instanceof lx&&(l=!0,m=n,iC(a),n=m.Sb,!n.b()))return b=n.o(),d=new zB(e),c=m,l=a,a=m,d.en.L(c)||(d.en.$(c),t(),e=hC(l,t().d,b,(t(),new L(a)),e,g,h),wy(a,new L(e))),m;if(l){d=new zB(e);c=m;b=a;a=m;if(!d.en.L(c)){d.en.$(c);n=vy(a);d=((v,x,A,B,C)=>D=>hC(v,(t(),new L(!0)),D,(t(),new L(x)),A,B,C))(b,a,e,g,h);if(n===u())d=u();else{c=n.e();l=c=new z(d(c),u());for(n=n.f();n!==u();){var r=n.e();r=new z(d(r),u());l=l.p=r;n=n.f()}d=c}IA(a,
+d);d=rA(a);e=((v,x,A,B,C)=>D=>hC(v,(t(),new L(!1)),D,(t(),new L(x)),A,B,C))(b,a,e,g,h);if(d===u())e=u();else{g=d.e();h=g=new z(e(g),u());for(b=d.f();b!==u();)d=b.e(),d=new z(e(d),u()),h=h.p=d,b=b.f();e=g}KA(a,e)}return m}m=new $e;if(b instanceof L){n=!!b.k;l=h.U(G(new H,n,c));if(l instanceof L&&(l=l.k,d.b()?r=!0:(r=d.o(),r=dx(new E(r),l)),r)){m=a;m.F&&(m=ut(Q(),"| ",m.r)+("!unskid-1! "+c+" -\x3e ")+l,ff(gf(),m+"\n"));c=l;continue}l=m.sb?m.vb:fC(a,m,c,b,d,g,e,h);l=h.U(G(new H,n,l));if(l instanceof
+L&&(l=l.k,d.b()?n=!0:(n=d.o(),n=dx(new E(n),l)),n)){r=n=a;n.F&&(m=ut(Q(),"| ",n.r)+("!unskid-2! "+(m.sb?m.vb:fC(r,m,c,b,d,g,e,h))+" -\x3e ")+l,ff(gf(),m+"\n"));c=l;continue}return m.sb?m.vb:fC(a,m,c,b,d,g,e,h)}if(t().d===b)return m.sb?m.vb:fC(a,m,c,b,d,g,e,h);throw new w(b);}};function $ba(a,b,c,d,e,g){if(c instanceof zA)return gC(a,b,c,t().d,e,d,g);if(c instanceof BA){CA(a);t();var h=new L(c);if(!h.b())return wB(h.k,b,new fn((k,l)=>gC(a,k,l,t().d,e,d,g)),d)}throw new w(c);}
+function jC(a,b,c){a.F&&(a=ut(Q(),"| ",a.r)+("Nope("+ag(ca(b))+"): "+b+" ~ ")+c,ff(gf(),a+"\n"));return!1}function kC(a,b,c,d,e,g,h){if(null!==b){var k=b.Oa,l=b.ra;if(k instanceof L&&(k=k.k,null!==c)){var m=c.Oa,n=c.ra;if(m instanceof L)return yA(a,k,m.k,d,e)&&yA(a,l,n,d,e)}}return null!==b&&(l=b.Oa,b=b.ra,t().d===l&&null!==c&&(l=c.Oa,c=c.ra,t().d===l))?yA(a,b,c,d,e):jC(a,g,h)}
+var yA=function lC(a,b,c,d,e){for(;;){var h=b,k=c;if((null===d?null===h:mC(d,h))&&(null===e?null===k:mC(e,k))||(null===e?null===h:mC(e,h))&&(null===d?null===k:mC(d,k)))return!0;if(h instanceof lx){var l=h;if(k instanceof lx)return Ot(new E(l),k)||jC(a,b,c)}if(h instanceof MA){var m=h.Fc;if(k instanceof MA){var n=k.Fc;b=m;c=n;continue}}if(h instanceof Mu){var r=h.pd;if(k instanceof Mu)return Pe(new E(r),k.pd)||jC(a,b,c)}if(h instanceof Sv){var v=h.Fd;if(k instanceof Sv)return kC(a,v,k.Fd,d,e,b,c)}if(h instanceof
+zv){var x=h.Yb;if(k instanceof zv){var A=k.Yb,B=x.K();if(Pe(new E(B),A.K())||jC(a,b,c)){if(x===u())var C=u();else{for(var D=x.e(),F=new z(D.j(),u()),I=F,M=x.f();M!==u();){var N=M.e(),P=new z(N.j(),u());I=I.p=P;M=M.f()}C=F}if(A===u())var T=u();else{for(var Y=A.e(),Z=new z(Y.j(),u()),S=Z,ea=A.f();ea!==u();){var ia=ea.e(),X=new z(ia.j(),u());S=S.p=X;ea=ea.f()}T=Z}for(var sa=new Wq(C,C,T),Ja=a,Xa=b,Fa=c,za=sa.ck.m(),Qa=sa.dk.m(),Ma=!1;!Ma&&za.s()&&Qa.s();){var Ga=za.t(),ab=Qa.t();Ma=!kC(Ja,Ga,ab,d,e,
+Xa,Fa)}return!Ma}return!1}}if(h instanceof cv){var Hb=h,bc=Hb.Nb,yb=Hb.ac;if(k instanceof cv){var tb=k,eb=tb.ac;if(lC(a,bc,tb.Nb,d,e)){b=yb;c=eb;continue}else return!1}}if(h instanceof Tv){var kb=h,Rb=kb.Ic,Gb=kb.kf;if(k instanceof Tv){var vb=k,Tb=vb.kf;return lC(a,Rb,vb.Ic,d,e)&&(Pe(new E(Gb),Tb)||jC(a,b,c))}}if(h instanceof nC){var Nb=h.rp;if(k instanceof nC)return Pe(new E(Nb),k.rp)||jC(a,b,c)}if(h instanceof mx){var ic=h.hi;if(k instanceof mx)return Pe(new E(ic),k.hi)||jC(a,b,c)}if(h instanceof
+FA){var Va=h.Eh;if(k instanceof FA)return Pe(new E(Va),k.Eh)||jC(a,b,c)}if(h instanceof cC){var cb=h,zb=cb.Fg,Ub=cb.Sf;if(k instanceof cC){var jb=k,db=jb.Sf;if(lC(a,zb,jb.Fg,d,e)){b=Ub;c=db;continue}else return!1}}if(h instanceof LA){var ub=h,Aa=ub.tc,va=ub.ic,Ra=ub.jc;if(k instanceof LA){var rb=k,xb=rb.ic,mc=rb.jc;if((Pe(new E(Aa),rb.tc)||jC(a,b,c))&&lC(a,va,xb,d,e)){b=Ra;c=mc;continue}else return!1}}if(h instanceof Qv){var Ha=h.Ba;if(k instanceof Qv){var Ka=k.Ba,Oa=Ha.K();if(Pe(new E(Oa),Ka.K())){for(var Na=
+new Wq(Ha,Ha,Ka),Da=a,ta=b,Ya=c,dc=Na.ck.m(),ka=Na.dk.m(),ya=!1;!ya&&dc.s()&&ka.s();){var Sa=dc.t(),xc=ka.t(),Sb=Sa,uc=xc;ya=!((Pe(new E(Sb.h()),uc.h())||jC(Da,ta,Ya))&&kC(Da,Sb.j(),uc.j(),d,e,ta,Ya))}return!ya}return!1}}if(h instanceof $y){var Lb=h,lc=Lb.Oq,Xb=Lb.up;if(k instanceof $y){var ec=k,Ab=ec.up;if(lC(a,lc,ec.Oq,d,e)){b=Xb;c=Ab;continue}else return!1}}if(h instanceof ZB){var Ob=h;$B(a);t();var fb=Ob.mc(),Wa=new L(fb);if(!Wa.b()){b=Wa.k;continue}}if(k instanceof ZB){var bb=k;$B(a);t();var Ia=
+bb.mc(),Ua=new L(Ia);if(!Ua.b()){c=Ua.k;continue}}if(h instanceof fw){var pc=h,sc=pc.qb,Ba=pc.Zb;if(k instanceof fw){var ob=k,nc=ob.Zb;if(Pe(new E(sc),ob.qb)||jC(a,b,c)){for(var Ib=new Wq(Ba,Ba,nc),vc=a,Vb=Ib.ck.m(),fc=Ib.dk.m(),Bc=!1;!Bc&&Vb.s()&&fc.s();){var Pb=Vb.t(),Jb=fc.t();Bc=!lC(vc,Pb,Jb,d,e)}return!Bc}return!1}}return jC(a,b,c)}};function oC(){this.op=null}oC.prototype=new p;oC.prototype.constructor=oC;function pC(){}pC.prototype=oC.prototype;
+function saa(a,b,c,d,e){var g=a.Ui;g.F&&(g=ut(Q(),"| ",g.r)+"\u2b24 Initial: "+b,ff(gf(),g+"\n"));g=a.Ui;g.F&&(g=ut(Q(),"| ",g.r)+" where: "+xx(b),ff(gf(),g+"\n"));b=eA(a.op,b,c,!0,!1,e);g=a.Ui;g.F&&(g=ut(Q(),"| ",g.r)+"\u2b24 Cleaned up: "+b,ff(gf(),g+"\n"));g=a.Ui;g.F&&(g=ut(Q(),"| ",g.r)+" where: "+xx(b),ff(gf(),g+"\n"));c.b()||(g=!!c.o(),b=vA(a.op,b,g,e));g=a.Ui;g.F&&(g=ut(Q(),"| ",g.r)+"\u2b24 Unskid: "+b,ff(gf(),g+"\n"));g=a.Ui;g.F&&(g=ut(Q(),"| ",g.r)+" where: "+xx(b),ff(gf(),g+"\n"));b=kA(a.op,
+b,d,c,e);g=a.Ui;g.F&&(g=ut(Q(),"| ",g.r)+"\u2b24 Type after simplification: "+b,ff(gf(),g+"\n"));g=a.Ui;g.F&&(g=ut(Q(),"| ",g.r)+" where: "+xx(b),ff(gf(),g+"\n"));b=iA(a.op,b,c,e);g=a.Ui;g.F&&(g=ut(Q(),"| ",g.r)+"\u2b24 Normalized: "+b,ff(gf(),g+"\n"));g=a.Ui;g.F&&(g=ut(Q(),"| ",g.r)+" where: "+xx(b),ff(gf(),g+"\n"));b=eA(a.op,b,c,!1,!0,e);g=a.Ui;g.F&&(g=ut(Q(),"| ",g.r)+"\u2b24 Cleaned up: "+b,ff(gf(),g+"\n"));g=a.Ui;g.F&&(g=ut(Q(),"| ",g.r)+" where: "+xx(b),ff(gf(),g+"\n"));c.b()||(g=!!c.o(),b=
+vA(a.op,b,g,e));g=a.Ui;g.F&&(g=ut(Q(),"| ",g.r)+"\u2b24 Unskid: "+b,ff(gf(),g+"\n"));g=a.Ui;g.F&&(g=ut(Q(),"| ",g.r)+" where: "+xx(b),ff(gf(),g+"\n"));b=kA(a.op,b,d,c,e);d=a.Ui;d.F&&(d=ut(Q(),"| ",d.r)+"\u2b24 Resim: "+b,ff(gf(),d+"\n"));d=a.Ui;d.F&&(d=ut(Q(),"| ",d.r)+" where: "+xx(b),ff(gf(),d+"\n"));b=aca(a.op,b,c,e);c=a.Ui;c.F&&(c=ut(Q(),"| ",c.r)+"\u2b24 Factored: "+b,ff(gf(),c+"\n"));a=a.Ui;a.F&&(a=ut(Q(),"| ",a.r)+" where: "+xx(b),ff(gf(),a+"\n"));return b}
+function qC(a,b){this.aO=null;this.bO=b;if(null===a)throw null;this.aO=a}qC.prototype=new p;qC.prototype.constructor=qC;function rC(a,b){var c=a.aO;a=a.bO;b=b.m();return new qC(c,a.bf(new Ef(b,new y(d=>{if(null!==d)return G(new H,d.hb,d.kc);throw new w(d);}))))}qC.prototype.$classData=q({QY:0},!1,"mlscript.Typer$ExpCtx$1",{QY:1,g:1});function sC(a){this.rI=null;if(null===a)throw null;this.rI=a}sC.prototype=new p;sC.prototype.constructor=sC;
+function tC(a,b,c,d){if(c.yc&&kca(b)){c=(new Dx(c.Ec)).wF;c.b()?c=t().d:(c=c.o(),c=uC(c,c,b.x));c=Wk(new vC(a)).Ob(c,new y(()=>{t();return R()}));var e=new wC(a,b,d);Wk(e).Ob(c,new y(()=>{t();return R()}));return xC(yC(a.rI),b,d)}return t().d}sC.prototype.$classData=q({SY:0},!1,"mlscript.Typer$ValidPatVar$",{SY:1,g:1});function zC(a){this.sI=null;if(null===a)throw null;this.sI=a}zC.prototype=new p;zC.prototype.constructor=zC;
+function xC(a,b,c){t();a.sI.uP.L(b.x)&&Lw(a.sI,We(Xe(),"Illegal use of reserved operator: "+b.x),b.A(),c);return new L(b.x)}zC.prototype.$classData=q({VY:0},!1,"mlscript.Typer$ValidVar$",{VY:1,g:1});function AC(){}AC.prototype=new p;AC.prototype.constructor=AC;AC.prototype.$classData=q({XY:0},!1,"mlscript.TyperDatatypes$AssignedVariable$",{XY:1,g:1});function BC(){}BC.prototype=new p;BC.prototype.constructor=BC;BC.prototype.$classData=q({eZ:0},!1,"mlscript.TyperDatatypes$DelayedTypeInfo$",{eZ:1,g:1});
+function CC(){}CC.prototype=new p;CC.prototype.constructor=CC;CC.prototype.$classData=q({rZ:0},!1,"mlscript.TyperDatatypes$OtherTypeLike$",{rZ:1,g:1});function DC(){}DC.prototype=new p;DC.prototype.constructor=DC;DC.prototype.$classData=q({wZ:0},!1,"mlscript.TyperDatatypes$ProxyType$",{wZ:1,g:1});function EC(a){this.PO=null;if(null===a)throw null;this.PO=a}EC.prototype=new p;EC.prototype.constructor=EC;function lca(a,b,c,d){return a.PO.Wq?mca(b,b.Re,ap(),b.de,c,d):t().d}
+EC.prototype.$classData=q({BZ:0},!1,"mlscript.TyperDatatypes$SplittablePolyFun$",{BZ:1,g:1});function FC(a,b){if(null===b)throw null;a.J=b}function GC(){this.J=null}GC.prototype=new p;GC.prototype.constructor=GC;function HC(){}HC.prototype=GC.prototype;function IC(){}IC.prototype=new p;IC.prototype.constructor=IC;IC.prototype.$classData=q({LZ:0},!1,"mlscript.TyperDatatypes$TypeVariable$",{LZ:1,g:1});
+var nca=function JC(a,b,c,d,e,g,h,k){for(;;){var m=c.U(b);if(m instanceof L){if(b=m.k,!d)return b}else{if(t().d===m){var n=!1;m=null;var r=b;if(r instanceof lx){n=!0;m=r;iC(a);var v=m.Sb;if(!v.b())return b=v.o(),e.Se(m,new U(((x,A,B,C,D,F,I,M,N)=>()=>{var P=A.ji;t();var T=new L(A),Y=A.kg,Z=O().c,S=O().c;P=new lx(x,A.Xa,Z,S,T,Y,!1,P);T=G(new H,A,P);B.$(T);t();T=JC(x,C,D,F,B,I,M,N);wy(P,new L(T));return P})(a,m,e,b,c,d,g,h,k)))}if(n&&vy(m).b()&&rA(m).b())return c=G(new H,m,m),e.$(c),m;if(n)return e.Se(m,
+new U(((x,A,B,C,D,F,I,M)=>()=>{var N=A.ji;t();var P=new L(A),T=A.kg,Y=O().c,Z=O().c;N=new lx(x,A.Xa,Y,Z,P,T,!1,N);P=G(new H,A,N);B.$(P);Z=vy(A);P=(ea=>ia=>JC(ea,ia,C,D,B,F,I,M))(x);if(Z===u())P=u();else{T=Z.e();Y=T=new z(P(T),u());for(Z=Z.f();Z!==u();){var S=Z.e();S=new z(P(S),u());Y=Y.p=S;Z=Z.f()}P=T}IA(N,P);Z=rA(A);P=(ea=>ia=>JC(ea,ia,C,D,B,F,I,M))(x);if(Z===u())P=u();else{T=Z.e();Y=T=new z(P(T),u());for(Z=Z.f();Z!==u();)S=Z.e(),S=new z(P(S),u()),Y=Y.p=S,Z=Z.f();P=T}KA(N,P);return N})(a,m,e,c,d,
+g,h,k)));if(r instanceof Qx&&(m=r,m.de<g)){b=ap();b=KC(m,g,b,h,k);continue}return tB(b,new y(((x,A,B,C,D,F,I)=>M=>JC(x,M,A,B,C,D,F,I))(a,c,d,e,g,h,k)))}throw new w(m);}}};function LC(a,b){b=b.m();b=new Ef(b,new y(g=>{for(var h=a.La;!g.b();){var k=g.e(),l=V(h.q);h=Pu(h,k,l,!1);g=g.f()}return h}));for(var c=a.ib;b.s();){var d=b.t(),e=V(c.q);c=dv(c,d,e,!1)}return c}function oca(a){a.Ep=0;a.an=0;a.Gp=0;a.Fp=0;a.qa=new y(()=>"");a.r=0}
+function MC(){this.io=this.ho=this.jo=null;this.Fp=this.Gp=this.an=this.Ep=0;this.qa=null;this.r=0}MC.prototype=new p;MC.prototype.constructor=MC;function NC(){}NC.prototype=MC.prototype;function pca(a){null===a.jo&&null===a.jo&&(a.jo=new OC(a));return a.jo}function Iv(a){null===a.ho&&null===a.ho&&(a.ho=new PC(a));return a.ho}function gA(a){null===a.io&&null===a.io&&(a.io=new QC(a));return a.io}
+function Lx(a,b,c,d){Nx(a,b);a.r=1+a.r|0;try{var e=Es(c)}finally{a.r=-1+a.r|0}dx(new E(d),a.qa)&&a.F&&(a=""+ut(Q(),"| ",a.r)+d.n(e),ff(gf(),a+"\n"));return e}function Nx(a,b){a.F&&(a=""+ut(Q(),"| ",a.r)+Es(b),ff(gf(),a+"\n"))}function HB(a){if(!0===a)return"+";if(!1===a)return"-";throw new w(a);}function dA(a){if(a instanceof L)return HB(!!a.k);if(t().d===a)return"\x3d";throw new w(a);}
+function Yv(a,b){var c=a.Q()+b.Q()|0;b=Lv(Lv(Mv(8<c?c:8),a),b);a=Xu().X();for(b=sl(b).m();b.s();){var d=b.t();c=d.h();var e=a.U(c);if(e instanceof L)e=e.k,d=Nv(e,d.j(),V(e.Va));else{if(R()!==e)throw new w(e);d=d.j()}a.bj(c,d)}b=qp();a=(new Pv(b)).vc(a);Od();return Pd(u(),a)}
+function RC(a,b){op();b=pp(qp(),b);for(var c=null,d=null;a!==u();){var e=a.e();if(null===e)throw new w(e);var g=e.h();e=e.j();var h=b.U(g);h.b()?g=R():(h=h.o(),e=xw(e,h,V(e.Va)),g=new L(G(new H,g,e)));for(g=g.m();g.s();)e=new z(g.t(),u()),null===d?c=e:d.p=e,d=e;a=a.f()}return null===c?u():c}
+function bca(a,b,c,d){if(b instanceof zA)return SC(a,b,c,!0,d);if(b instanceof BA){CA(a);t();var e=new L(b);if(!e.b()){b=e.k;var g=b.xk;e=m=>cz(m,new y(n=>SC(a,n,c,!0,d)),d);if(g===u())e=u();else{var h=g.e(),k=h=new z(e(h),u());for(g=g.f();g!==u();){var l=g.e();l=new z(e(l),u());k=k.p=l;g=g.f()}e=h}b=b.Ul;b.b()?b=R():(b=b.o(),b=new L(SC(a,b,c,!0,d)));return new By(a,e,b)}}throw new w(b);}
+function SC(a,b,c,d,e){var g=Xu().X(),h=Xu().X(),k=c.ie();k=new Ef(k,new y(r=>r.Ea()));if(k.s()){if(!k.s())throw nv("empty.reduceLeft");for(var l=!0,m=null;k.s();){var n=k.t();l?(m=n,l=!1):(m|=0,n|=0,m=m>n?m:n)}k=new L(m)}else k=R();k=(k.b()?a.Gd:k.o())|0;return nca(a,b,c,d,g,k,e,h)}
+function Rv(a,b){tp();var c=a.K();At(0,Pe(new E(c),b.K()));a=new Wq(a,a,b);b=new fn((d,e)=>{d=G(new H,d,e);e=d.y;var g=d.w;if(null!==e){var h=e.h();e=e.j();if(h instanceof L&&(h=h.k,null!==g)){var k=g.h();g=g.j();if(k instanceof L&&Nm(new E(h),k.k))return d=t().d,G(new H,d,Nv(e,g,V(e.Va)))}}g=d.y;h=d.w;if(null!==g&&(e=g.h(),g=g.j(),null!==h))return d=h.h(),h=h.j(),d=e.b()?d:e,G(new H,d,Nv(g,h,V(g.Va)));throw new w(d);});Yq();return Ew(a,b)}
+function TC(a,b){tp();var c=a.K();At(0,Pe(new E(c),b.K()));a=new Wq(a,a,b);b=new fn((d,e)=>{d=G(new H,d,e);e=d.y;var g=d.w;if(null!==e){var h=e.h();e=e.j();if(h instanceof L&&(h=h.k,null!==g)){var k=g.h();g=g.j();if(k instanceof L)return d=Pe(new E(h),k.k)?new L(h):R(),G(new H,d,xw(e,g,V(e.Va)))}}e=d.y;g=d.w;if(null!==e&&(e=e.j(),null!==g))return d=g.j(),g=t().d,G(new H,g,xw(e,d,V(e.Va)));throw new w(d);});Yq();return Ew(a,b)}
+function vB(a,b){var c=tc();try{var d=new y(db=>"yes: "+db);if(a.F){var e=ut(Q(),"| ",a.r);if(b===u())var g=u();else{var h=b.e(),k=new z(ze(h,""," \x26 ",""),u());h=k;for(var l=b.f();l!==u();){var m=l.e(),n=new z(ze(m,""," \x26 ",""),u());h=h.p=n;l=l.f()}g=k}var r=e+"factorize? "+ze(g,""," | ","");ff(gf(),r+"\n")}a.r=1+a.r|0;try{if(0>=b.ab(1))throw Hq(new Iq,c,LC(a,b));var v=new lA;for(e=b;!e.b();){for(var x=e.e();!x.b();){var A=x.e();if(A instanceof lx){g=A;var B=v.U(g);if(B instanceof L)var C=B.k;
+else{if(R()!==B)throw new w(B);C=0}v.bh(g,1+(C|0)|0)}else if(A instanceof Gv){g=A;var D=v.U(g);if(D instanceof L)var F=D.k;else{if(R()!==D)throw new w(D);F=0}v.bh(g,1+(F|0)|0)}else if(A instanceof UC){g=A;var I=v.U(g);if(I instanceof L)var M=I.k;else{if(R()!==I)throw new w(I);M=0}v.bh(g,1+(M|0)|0)}else if(A instanceof VC){g=A;var N=v.U(g);if(N instanceof L)var P=N.k;else{if(R()!==N)throw new w(N);P=0}v.bh(g,1+(P|0)|0)}x=x.f()}e=e.f()}if(a.F){var T=ut(Q(),"| ",a.r)+"Factors "+ze(v,"",", ","");ff(gf(),
+T+"\n")}var Y=Fq();if(v.b())var Z=R();else{if(v.b())throw nv("empty.maxBy");A=A=x=x=null;B=!1;B=!0;for(var S=v.Gn;null!==S;){var ea=G(new H,S.ju,S.Fn),ia=ea.w|0;if(B||0<Y.Da(ia,x))A=ea,x=ia,B=!1;S=S.zm}Z=new L(A)}a:{if(Z instanceof L){var X=Z.k;if(null!==X){var sa=X.h(),Ja=X.Sc();if(1<Ja){Od();var Xa=new fp;Od();for(var Fa=new fp;!b.b();){var za=b.e(),Qa=za.L(sa)?(t(),new fe(za)):(t(),new Ud(za));if(Qa instanceof fe)wp(Xa,Qa.aa);else if(Qa instanceof Ud)wp(Fa,Qa.fa);else throw new w(Qa);b=b.f()}var Ma=
+Xa.ha(),Ga=Fa.ha();if(a.F){var ab=ut(Q(),"| ",a.r)+("Factor "+sa+" -\x3e ")+ze(Ma,"",", ","");ff(gf(),ab+"\n")}var Hb=Ma.K();if(!Pe(new E(Hb),Ja))throw new Yj("assertion failed: "+G(new H,Ma,Ja));Ja=db=>{var ub=db;a:for(;;)if(ub.b()){db=u();break}else{var Aa=ub.e();db=ub.f();if(!0===!!Pe(new E(Aa),sa))ub=db;else for(;;){if(db.b())db=ub;else{Aa=db.e();if(!0!==!!Pe(new E(Aa),sa)){db=db.f();continue}Aa=db;db=new z(ub.e(),u());var va=ub.f();for(ub=db;va!==Aa;){var Ra=new z(va.e(),u());ub=ub.p=Ra;va=va.f()}for(va=
+Aa=Aa.f();!Aa.b();){Ra=Aa.e();if(!0===!!Pe(new E(Ra),sa)){for(;va!==Aa;)Ra=new z(va.e(),u()),ub=ub.p=Ra,va=va.f();va=Aa.f()}Aa=Aa.f()}va.b()||(ub.p=va)}break a}}return db};if(Ma===u())var bc=u();else{var yb=Ma.e(),tb=new z(Ja(yb),u());yb=tb;for(var eb=Ma.f();eb!==u();){var kb=eb.e(),Rb=new z(Ja(kb),u());yb=yb.p=Rb;eb=eb.f()}bc=tb}var Gb=vB(a,bc),vb=V(sa.q),Tb=Pu(sa,Gb,vb,!1);if(0<iv(v,1)){Ma=!1;for(var Nb=new WC(v);!Ma&&Nb.s();){var ic=Nb.gm();Ma=dx(new E(ic.h()),sa)?1<ic.Sc():!1}var Va=Ma}else Va=
+!1;var cb=Va?vB(a,Ga):LC(a,Ga),zb=V(cb.q);var Ub=dv(cb,Tb,zb,!1);break a}}}Ub=LC(a,b)}}finally{a.r=-1+a.r|0}if(dx(new E(d),a.qa)&&a.F){var jb=""+ut(Q(),"| ",a.r)+d.n(Ub);ff(gf(),jb+"\n")}return Ub}catch(db){if(db instanceof Iq){a=db;if(a.Qg===c)return a.Cj();throw a;}throw db;}}function XC(a,b,c,d){lv();return new Qv(a,ry(0,b.Ba,new y(e=>{var g=e.Va,h=e.Oa;if(h.b())h=R();else{h=h.o();if(c.b())var k=R();else k=!!c.o(),k=new L(!k);h=new L(d.ba(k,h))}return new Uw(g,h,d.ba(c,e.ra),e.Pd)})),b.Nj)}
+function qca(a,b,c,d){var e=!1,g=null;if(b instanceof cv){g=b.Nb;e=b.ac;if(c.b())var h=R();else h=!!c.o(),h=new L(!h);return new cv(a,d.ba(h,g),d.ba(c,e),b.ma())}if(b instanceof Jv)return rB(b,c,d);if(b instanceof zv)return g=b.Yb,new zv(a,ry(lv(),g,new y(l=>{var m=l.Va,n=l.Oa;if(n.b())n=R();else{n=n.o();if(c.b())var r=R();else r=!!c.o(),r=new L(!r);n=new L(d.ba(r,n))}return new Uw(m,n,d.ba(c,l.ra),l.Pd)})),b.ma());if(b instanceof Sv){g=b.Fd;e=g.Va;h=g.Oa;if(h.b())h=R();else{h=h.o();if(c.b())var k=
+R();else k=!!c.o(),k=new L(!k);h=new L(d.ba(k,h))}return new Sv(a,new Uw(e,h,d.ba(c,g.ra),g.Pd),b.ma())}if(b instanceof Wv)return sB(b,new y(l=>d.ba(c,l)),new y(l=>{if(c.b())var m=R();else m=!!c.o(),m=new L(!m);return d.ba(m,l)}),new y(l=>d.ba(c,l)),b.Uu);if(b instanceof Tv&&(e=!0,g=b,h=g.Ic,k=g.kf,h instanceof LA&&null!==k&&k.b()))return new Tv(a,tB(h,new y(l=>d.ba(c,l))),k,g.vp);if(e)return e=g.kf,new Tv(a,d.ba(c,g.Ic),e,b.ma());if(b instanceof Mu)return b;throw new w(b);}
+function PB(a,b,c){if(b){for(a=a.ib;!c.b();){b=c.e();var d=V(a.q);a=dv(a,b,d,!1);c=c.f()}return a}for(a=a.La;!c.b();)b=c.e(),d=V(a.q),a=Pu(a,b,d,!1),c=c.f();return a}function YC(a,b){return Pe(new E(b),a.Df)?"^":5<b?"^"+b:ut(Q(),"'",b)}function PC(a){this.fP=null;if(null===a)throw null;this.fP=a}PC.prototype=new p;PC.prototype.constructor=PC;
+function Hv(a,b,c){a:for(var d=ap();;){var e=b;if(e instanceof fw){var g=e;if(PA(g,c)){b=QA(g,c);continue}}if(e instanceof ZB)b=e.mc();else{if(e instanceof lx&&(iC(a.fP),g=e.Sb,!g.b()&&(g=g.o(),!d.L(e)))){d=d.bc(e);b=g;continue}t();a=new L(b);break a}}return a}PC.prototype.$classData=q({QZ:0},!1,"mlscript.TyperHelpers$AliasOf$",{QZ:1,g:1});function ZC(a,b,c){a.ol=c;if(null===b)throw null;a.$m=b;a.gt=0}function $C(){this.ol=null;this.gt=0;this.$m=null}$C.prototype=new p;$C.prototype.constructor=$C;
+function aD(){}aD.prototype=$C.prototype;$C.prototype.u=function(){return this.Bw()};function QC(a){this.iP=this.jP=this.Jx=this.Xu=this.Pj=null;if(null===a)throw null;this.iP=a;t();this.Pj=new bD(this,new L(!0));t();this.Xu=new bD(this,new L(!1));this.Jx=new RB(this.Pj,a.Gd,!1);a=t().d;this.jP=new bD(this,a)}QC.prototype=new p;QC.prototype.constructor=QC;
+function fA(a,b){var c=!1,d=null;if(b instanceof L&&(c=!0,d=b,!0===!!d.k))return a.Pj;if(c&&!1===!!d.k)return a.Xu;if(t().d===b)return a.jP;throw new w(b);}QC.prototype.$classData=q({RZ:0},!1,"mlscript.TyperHelpers$PolMap$",{RZ:1,g:1});
+var sca=function rca(a,b,c,d,e){for(;;){if(a.Yu.Wq){if(b instanceof Qx)return a=b,t(),new L(a);if(b instanceof fw){var h=b;if(!c.L(h.qb)){b=cD(h,d,e);c=h=c.bc(h.qb);continue}}if(b instanceof ZB){b=b.mc();continue}if(b instanceof lx){h=b;iC(a.Yu);var k=h.Sb;if(!k.b()&&(k=k.o(),!c.L(h))){h=c.bc(h);b=k;c=h;continue}}if(b instanceof cv){h=b.Nb;e=rca(a,b.ac,c,d,e);c=new dD(e,new y(l=>null!==l));e=c.lR;c=c.e3;e=e.b()||c.n(e.o())?e:R();if(e.b())return R();e=e.o();if(null!==e)c=e.de,k=e.Re,h.Ea()>c?(c=h.Ea(),
+k=ap(),d=eD(e,c,k,d),a=new Qx(a.Yu,d.de,new cv(a.Yu,h,d.Re,b.Mj))):a=new Qx(a.Yu,c,new cv(a.Yu,h,k,b.Mj));else throw new w(e);return new L(a)}}return t().d}};function OC(a){this.Yu=null;if(null===a)throw null;this.Yu=a}OC.prototype=new p;OC.prototype.constructor=OC;function tca(a,b,c,d){return sca(a,b,ap(),c,d)}OC.prototype.$classData=q({XZ:0},!1,"mlscript.TyperHelpers$PolyFunction$",{XZ:1,g:1});
+function TA(a,b){var c=Xu().X(),d=a.q;d.F&&(d=ut(Q(),"| ",d.r)+("INST ["+a.de+"]   ")+a,ff(gf(),d+"\n"));d=a.q;d.F&&(d=ut(Q(),"| ",d.r)+"  where  "+xx(a),ff(gf(),d+"\n"));c=a.Re.Kc(a.de,!1,b,c);d=a.q;d.F&&(b=ut(Q(),"| ",d.r)+("TO ["+b.da+"] ~\x3e  ")+c,ff(gf(),b+"\n"));a=a.q;a.F&&(a=ut(Q(),"| ",a.r)+"  where  "+xx(c),ff(gf(),a+"\n"));return c}function uca(a,b){var c=Xu().X();return a.Re.Kc(a.de,!0,b,c)}function eD(a,b,c,d){var e=Xu().X();return KC(a,b,c,d,e)}
+function KC(a,b,c,d,e){At(tp(),b>=a.de);if(Pe(new E(b),a.de))return a;var g=a.q,h=a.de,k=a.Re,l=a.q.Df;d=new Iw(d.S,d.Ec,d.hc,d.Ed,1+b|0,d.Pc,d.Zc,d.Lb,d.yc,d.tb,d.$a,d.od,d.cb);return new Qx(g,b,fD(a.q,k,l,d,h,c,e,!1))}
+function mca(a,b,c,d,e,g){for(;;){var h=!1,k=null;if(b instanceof cv){c=b;k=c.Nb;b=c.ac;h=gD(b,d,a.q.Df);g=a.q;g.F&&(g=ut(Q(),"| ",g.r)+"could be distribbed: "+h,ff(gf(),g+"\n"));if(h.b())return t().d;g=gD(k,d,a.q.Df);var l=a.q;l.F&&(l=ut(Q(),"| ",l.r)+"cannot be distribbed: "+g,ff(gf(),l+"\n"));if(h.wy(g).b())return t().d;h=1+d|0;l=new y(n=>n.Xa);var m=Fq();l=vca(g,l,m);m=a;l=l.b()?m.q.Gd:l.o().Xa;h=h>l?h:l;b=new Qx(a.q,d,b);l=a.q;l.F&&(l=ut(Q(),"| ",l.r)+"inner: "+b,ff(gf(),l+"\n"));e=new cv(a.q,
+k,eD(b,h,g,e),c.Mj);c=a.q;c.F&&(c=ut(Q(),"| ",c.r)+"raised: "+e,ff(gf(),c+"\n"));c=a.q;c.F&&(c=ut(Q(),"| ",c.r)+"  where: "+xx(e),ff(gf(),c+"\n"));if(g.b())return t(),new L(e);t();d=new Qx(a.q,d,e);return new L(d)}if(b instanceof fw&&(l=b,!c.L(l.qb))){k=cD(l,e,g);c=c.bc(l.qb);b=k;continue}if(b instanceof ZB)b=k=b.mc();else{if(b instanceof lx&&(h=!0,k=b,iC(a.q),l=k.Sb,!l.b()&&(l=l.o(),!c.L(k)))){c=c.bc(k);b=l;continue}if(h&&k.Xa>d&&!c.L(k)){b=a;h=vy(k);l=a.q.ib;for(a=h;!a.b();)h=l,l=a.e(),m=V(h.q),
+l=dv(h,l,m,!1),a=a.f();h=l;c=c.bc(k);a=b;b=h}else if(b instanceof Qx)k=b,b=k.de,d=d<b?d:b,b=k.Re;else return t().d}}}function hD(a){if(a instanceof lx)return a;xm(a+" was not a type variable")}
+function mC(a,b){if(a instanceof OA)return Pe(new E(a.Hi),b);if(a instanceof lx)return b instanceof lx?Pe(new E(a.sp),b.sp):b instanceof OA&&b.q===a.q?Pe(new E(a),b.Hi):!1;if(null!==a&&Gs(a)){if(b instanceof zA&&b.q===a.q){if(b instanceof OA)return Pe(new E(a),b.Hi);if(b instanceof lx)return!1;if(null!==b&&Gs(b)){if(a.D(b)&&Pe(new E(a.G()),b.G())){a=new iD(a);for(b=new iD(b);a.s()&&b.s();){var c=a.t();if(Nm(new E(c),b.t()))return!1}return!a.s()&&!b.s()}return!1}throw new w(b);}return!1}throw new w(a);
+}function wca(a){return a instanceof lx?xca(a):tB(a,new y(b=>jD(b)))}function jD(a){Pe(new E(a.q.Im),a.pe)||(a.oe=wca(a),a.pe=a.q.Im);return a.oe}
+function tB(a,b){if(a instanceof cC){var c=a.Fg,d=a.Sf;return kD(cw(a.q),b.n(c),b.n(d),V(cw(a.q).Vu))}if(a instanceof cv)return c=a.ac,new cv(a.q,b.n(a.Nb),b.n(c),a.ma());if(a instanceof Jv)return rB(a,t().d,new fn((l,m)=>b.n(m)));if(a instanceof Qv)return c=a.Ba,new Qv(a.q,ry(lv(),c,new y(l=>cB(l,b,b))),a.ma());if(a instanceof zv)return c=a.Yb,new zv(a.q,ry(lv(),c,new y(l=>cB(l,b,b))),a.ma());if(a instanceof Wv)return sB(a,b,b,b,a.Uu);if(a instanceof Sv)return new Sv(a.q,cB(a.Fd,b,b),a.ma());if(a instanceof
+LA)return c=a.jc,new LA(a.q,a.tc,b.n(a.ic),b.n(c),a.ma());if(a instanceof MA)return new MA(a.q,b.n(a.Fc),a.ma());if(a instanceof Tv)return c=a.kf,new Tv(a.q,b.n(a.Ic),c,a.ma());if(a instanceof OA)return new OA(a.q,b.n(a.Hi),a.ma());if(a instanceof $y){c=a.up;d=a.q;var e=b.n(a.Oq),g=a.q;lv();return new $y(d,e,new Qv(g,ry(0,c.Ba,new y(l=>cB(l,b,b))),c.Nj),a.ma())}if(a instanceof ZB&&($B(a.q),t(),c=a.mc(),c=new L(c),!c.b()))return b.n(c.k);if(a instanceof fw){c=a.qb;var h=a.Zb;d=a.q;if(h===u())e=u();
+else for(e=h.e(),g=e=new z(b.n(e),u()),h=h.f();h!==u();){var k=h.e();k=new z(b.n(k),u());g=g.p=k;h=h.f()}return new fw(d,c,e,a.ma())}if(a instanceof Qx)return new Qx(a.q,a.de,b.n(a.Re));if(a instanceof eC){h=a.Lj;c=a.kj;a=a.q;d=l=>{var m=b.n(l.h());l=b.n(l.j());return G(new H,m,l)};if(h===u())d=u();else{e=h.e();g=e=new z(d(e),u());for(h=h.f();h!==u();)k=h.e(),k=new z(d(k),u()),g=g.p=k,h=h.f();d=e}return new eC(a,d,b.n(c))}if(a instanceof lx||Uv(a)||a instanceof FA)return a;throw new w(a);}
+function UA(a,b,c,d,e){var g=!1,h=null,k=!1,l=null,m=!1,n=null;if(a instanceof cC){g=!0;h=a;var r=h.Fg,v=h.Sf;if(c&&!b.b())return b.b()&&xm("Program reached and unexpected state."),b.o()?d.ba((t(),new L(!0)),v):d.ba((t(),new L(!1)),r)}if(g)return c=h.Fg,e=h.Sf,kD(cw(a.q),d.ba((t(),new L(!1)),c),d.ba((t(),new L(!0)),e),V(cw(a.q).Vu));if(a instanceof Qv)return XC(a.q,a,b,d);if(a instanceof Tv&&(g=a.Ic,h=a.kf,c))return a=d.ba(b,g),iB(a,h);if(a instanceof Fv)return qca(a.q,a,b,d);if(a instanceof LA&&
+(k=!0,l=a,g=l.tc,r=l.ic,h=l.jc,c)){if(g)return a=d.ba(b,r),c=d.ba(b,h),e=V(a.q),dv(a,c,e,!1);a=d.ba(b,r);c=d.ba(b,h);e=V(a.q);return Pu(a,c,e,!1)}if(k)return c=l.jc,new LA(a.q,l.tc,d.ba(b,l.ic),d.ba(b,c),a.ma());if(a instanceof MA&&(m=!0,n=a,l=n.Fc,c))return b.b()?c=R():(c=!!b.o(),c=new L(!c)),c=d.ba(c,l),a=a.ma(),NA(c,a,!1);if(m)return c=n.Fc,e=a.q,b.b()?l=R():(l=!!b.o(),l=new L(!l)),new MA(e,d.ba(l,c),a.ma());if(a instanceof OA)return new OA(a.q,d.ba(b,a.Hi),a.ma());if(a instanceof $y)return c=
+a.up,e=a.q,l=d.ba(b,a.Oq),m=a.q,lv(),new $y(e,l,new Qv(m,ry(0,c.Ba,new y(x=>{var A=x.Va,B=x.Oa;if(B.b())B=R();else{B=B.o();if(b.b())var C=R();else C=!!b.o(),C=new L(!C);B=new L(d.ba(C,B))}return new Uw(A,B,d.ba(b,x.ra),x.Pd)})),c.Nj),a.ma());if(a instanceof ZB&&($B(a.q),t(),l=a.mc(),l=new L(l),!l.b()))return d.ba(b,l.k);if(a instanceof fw)return new fw(a.q,a.qb,bw(a,b,d,e),a.ma());if(a instanceof Qx)return e=a.de,l=a.Re,c?yx(zx(a.q),e,d.ba(b,l)):new Qx(a.q,e,d.ba(b,l));if(a instanceof eC){n=a.Lj;
+c=a.kj;a=a.q;e=x=>{var A=d.ba((t(),new L(!0)),x.h());x=d.ba((t(),new L(!1)),x.j());return G(new H,A,x)};if(n===u())e=u();else{l=n.e();m=l=new z(e(l),u());for(n=n.f();n!==u();)k=n.e(),k=new z(e(k),u()),m=m.p=k,n=n.f();e=l}return new eC(a,e,d.ba(b,c))}if(a instanceof lx||Uv(a)||a instanceof FA)return a;throw new w(a);}function lD(a,b){return new Uw(a.q,(t(),new L(a)),a,b)}
+var dv=function yca(a,b,c,d){var g=a.q.La;if(null===g?null===a:mC(g,a))return a;g=a.q.ib;if(null===g?null===a:mC(g,a))return b;g=a.q.La;if(null===g?null===b:mC(g,b))return b;g=a.q.ib;if(null===g?null===b:mC(g,b))return a;if(a instanceof YB&&!0===a.pA)return b;if(a instanceof YB&&!1===a.pA||a instanceof Qv&&b instanceof cv)return a.q.La;if(a instanceof Qv&&(g=a.Ba,b instanceof Qv))return new Qv(a.q,RC(g,b.Ba),c);if(a instanceof zv&&(g=a.Yb,b instanceof zv)){var h=b.Yb,k=jv(g,h);if(Pe(new E(k),0))return new zv(a.q,
+TC(g,h),a.Nq)}return d?(null===b?null===a:mC(b,a))?a:a instanceof MA&&(d=a.Fc,null===b?null===d:mC(b,d))?a.q.La:new LA(a.q,!0,b,a,c):yca(b,a,c,!0)},sA=function zca(a,b,c){if(a instanceof cv){var e=a.Nb,g=a.ac;if(b instanceof cv){var h=b.Nb,k=b.ac;if(a.q.UI)return a=a.q,b=V(e.q),e=dv(e,h,b,!1),h=V(g.q),new cv(a,e,zca(g,k,h),c)}}return Pu(a,b,c,!1)},Pu=function mD(a,b,c,d){a:{var g=a.q.La;if(null===g?null===a:mC(g,a))g=!0;else{if(a instanceof Qv){g=a.Ba;var h=O().c;if(null===h?null===g:h.i(g)){g=!0;
+break a}}g=!1}}if(g)return b;g=a.q.ib;if((null===g?null===a:mC(g,a))||a instanceof Mu&&b instanceof cv)return a.q.ib;if(a instanceof Qv&&(g=a.Ba,b instanceof Qv)){h=b.Ba;a=a.q;b=Su();d=op().ga;b=new Uu(b,d);d=sv();var k=g.Q()+h.Q()|0;h=Lv(Lv(Mv(8<k?k:8),g),h);g=Xu().X();for(h=sl(h).m();h.s();){var l=h.t();k=l.h();var m=g.U(k);if(m instanceof L)m=m.k,l=Nv(m,l.j(),V(m.Va));else{if(R()!==m)throw new w(m);l=l.j()}g.bj(k,l)}h=qp();b=Ov(d,(new Pv(h)).vc(g),b);Od();return new Qv(a,Pd(u(),b),c)}return a instanceof
+zv&&(g=a.Yb,b instanceof zv)?(c=b.Yb,b=jv(g,c),Nm(new E(b),0)?a.q.ib:new zv(a.q,Rv(g,c),a.Nq)):d?(null===b?null===a:mC(b,a))?a:d?a instanceof MA&&(d=a.Fc,null===b?null===d:mC(b,d))?a.q.ib:new LA(a.q,!1,b,a,c):mD(b,a,c,!0):mD(b,a,c,!0)},NA=function nD(a,b,c){var e=!1,g=null;if(a instanceof FA)return new FA(a.q,!a.Eh,V(a.q));if(a instanceof LA){e=!0;g=a;var h=g.ic,k=g.jc;if(!0===g.tc)return a=V(h.q),a=nD(h,a,!1),b=V(k.q),k=nD(k,b,!1),b=V(a.q),Pu(a,k,b,!1)}return e&&(h=g.ic,k=g.jc,!1===g.tc&&c)?(a=V(h.q),
+a=nD(h,a,!1),b=V(k.q),k=nD(k,b,!1),b=V(a.q),dv(a,k,b,!1)):a instanceof MA?a.Fc:new MA(a.q,a,b)};function Aca(a,b,c){var d=Xu().X();return Zu(a,b,c,!0,d)?(d=Xu().X(),Zu(b,a,c,!0,d)):!1}
+var Zu=function oD(a,b,c,d,e){var h=Pe(new E(d),!0)&&!a.q.ZE;a.q.Gp=1+a.q.Gp|0;if(!pD(a)&&(Ot(new E(a),b)||Pe(new E(a),b)))return!0;var k=G(new H,a,b);var l=k.w;if(l instanceof FA&&!1===l.Eh)var m=!0;else{var n=k.y;m=n instanceof FA&&!0===n.Eh?!0:!1}if(m)return!0;var r=k.y;if(r instanceof ZB){$B(a.q);t();var v=r.mc(),x=new L(v);if(!x.b())return oD(x.k,b,c,d,e)}var A=k.w;if(A instanceof ZB){$B(a.q);t();var B=A.mc(),C=new L(B);if(!C.b())return oD(a,C.k,c,d,e)}if((Uv(k.y)&&Uv(k.w)||k.y instanceof lx&&
+k.w instanceof lx)&&Pe(new E(a),b))return!0;var D=k.y,F=k.w;if(D instanceof Vv&&F instanceof Sv)return Fw(D.Zj(),F.Fd,c,e);var I=k.y,M=k.w;if(I instanceof zv){var N=I.Yb;if(M instanceof zv){var P=M.Yb,T=jv(N,P);if(Pe(new E(T),0)){for(var Y=new Wq(N,N,P),Z=Y.ck.m(),S=Y.dk.m(),ea=!1;!ea&&Z.s()&&S.s();){var ia=Z.t(),X=S.t(),sa=G(new H,ia,X);a:{var Ja=sa.y,Xa=sa.w;if(null!==Ja){var Fa=Ja.j();if(null!==Xa){var za=Fw(Fa,Xa.j(),c,e);break a}}throw new w(sa);}ea=!za}return!ea}return!1}}var Qa=k.y;if(Qa instanceof
+Qv){var Ma=Qa.Ba,Ga=O().c;if(null===Ga?null===Ma:Ga.i(Ma))return oD(a.q.La,b,c,d,e)}var ab=k.w;if(ab instanceof Qv){var Hb=ab.Ba,bc=O().c;if(null===bc?null===Hb:bc.i(Hb))return oD(a,a.q.La,c,d,e)}var yb=k.y,tb=k.w;if(yb instanceof Mu){var eb=yb.pd;if(tb instanceof Mu){var kb=tb.pd;return Pe(new E(eb),kb)?!0:yb.Fv().L(kb)}}var Rb=k.y;if(Rb instanceof cC)return oD(Rb.Sf,b,c,d,e);var Gb=k.w;if(Gb instanceof cC)return oD(a,Gb.Fg,c,d,e);var vb=k.y,Tb=k.w;if(vb instanceof cv){var Nb=vb.Nb,ic=vb.ac;if(Tb instanceof
+cv){var Va=Tb.Nb,cb=Tb.ac,zb=Rd=>oD(Va,Nb,c,d,Rd)&&oD(ic,cb,c,d,Rd);if(h)var Ub=e.ry(new y(Rd=>G(new H,Rd.h(),!0))),jb=zb(Ub);else jb=zb(e);return!!jb}}var db=k.y;if(db instanceof LA){var ub=db.ic,Aa=db.jc;if(!0===db.tc)return oD(ub,b,c,d,e)&&oD(Aa,b,c,d,e)}var va=k.w;if(va instanceof LA){var Ra=va.ic,rb=va.jc;if(!1===va.tc)return oD(a,Ra,c,d,e)&&oD(a,rb,c,d,e)}var xb=k.y;if(xb instanceof LA){var mc=xb.ic,Ha=xb.jc;if(!1===xb.tc)return oD(mc,b,c,d,e)||oD(Ha,b,c,d,e)}var Ka=k.w;if(Ka instanceof LA){var Oa=
+Ka.ic,Na=Ka.jc;if(!0===Ka.tc)return oD(a,Oa,c,d,e)||oD(a,Na,c,d,e)}var Da=k.y,ta=k.w;if(Da instanceof Qv){var Ya=Da.Ba;if(ta instanceof Qv){var dc=ta.Ba,ka=Rd=>{for(var Bd=dc;!Bd.b();){var ae=Bd.e();a:{for(var dd=Ya;!dd.b();){var od=dd.e().h();if(Pe(new E(od),ae.h())){dd=new L(dd.e());break a}dd=dd.f()}dd=R()}if(dd.b()||!Fw(dd.o().j(),ae.j(),c,Rd))return!1;Bd=Bd.f()}return!0};if(h)var ya=e.ry(new y(Rd=>G(new H,Rd.h(),!0))),Sa=ka(ya);else Sa=ka(e);return!!Sa}}if(k.w instanceof Tv||(k.y instanceof lx||
+k.w instanceof lx)&&!h)return!1;if((k.y instanceof lx||k.w instanceof lx)&&e.L(G(new H,a,b)))return!!e.n(G(new H,a,b));var xc=k.y;if(xc instanceof lx){e.bh(G(new H,a,b),!1);var Sb=xc.Sb;if(Sb instanceof L)var uc=oD(Sb.k,b,c,d,e);else{if(t().d!==Sb)throw new w(Sb);a:{for(var Lb=rA(xc);!Lb.b();){var lc=Lb.e();if(oD(lc,b,c,d,e)){uc=!0;break a}Lb=Lb.f()}uc=!1}}uc&&e.bh(G(new H,a,b),!0);return uc}var Xb=k.w;if(Xb instanceof lx){e.bh(G(new H,a,b),!1);var ec=Xb.Sb;if(ec instanceof L)var Ab=oD(a,ec.k,c,d,
+e);else{if(t().d!==ec)throw new w(ec);a:{for(var Ob=vy(Xb);!Ob.b();){var fb=Ob.e();if(oD(a,fb,c,d,e)){Ab=!0;break a}Ob=Ob.f()}Ab=!1}}Ab&&e.bh(G(new H,a,b),!0);return Ab}var Wa=k.y;if(Wa instanceof eC){var bb=Wa.Lj,Ia=Wa.kj,Ua=O().c;if(null===Ua?null===bb:Ua.i(bb))return oD(Ia,b,c,d,e)}var pc=k.w;if(pc instanceof eC)return oD(a,pc.kj,c,d,e);var sc=k.w;if(sc instanceof MA){var Ba=sc.Fc,ob=V(a.q),nc=Pu(a,Ba,ob,!1);return oD(nc,a.q.ib,c,d,e)}var Ib=k.y;if(Ib instanceof MA){var vc=Ib.Fc,Vb=a.q.La,fc=V(b.q),
+Bc=dv(b,vc,fc,!1);return oD(Vb,Bc,c,d,e)}var Pb=k.y;if(Pb instanceof fw&&a.q.cn.L(Pb.qb.V)&&PA(Pb,c)){var Jb=QA(Pb,c);return oD(Jb,b,c,d,e)}var gc=k.w;if(gc instanceof fw&&a.q.cn.L(gc.qb.V)&&PA(gc,c)){var Cb=QA(gc,c);return oD(a,Cb,c,d,e)}var cc=k.y;if(cc instanceof fw){var yc=c.tb.U(cc.qb.V);if(yc instanceof L){var Mc=yc.k;if(b instanceof fw&&Pe(new E(b.qb),cc.qb)){for(var qc=dB(Mc),oc=Mc.Xm,Qc=op(),jc=oc.Gb(Qc.ga).j(),sb=qD(new Wq(jc,jc,cc.Zb),b.Zb),Gc=sb.jL.m(),Wb=sb.kL.m(),Cc=sb.lL.m(),Fc=!1;!Fc&&
+Gc.s()&&Wb.s()&&Cc.s();){var qd=Gc.t(),Yb=Wb.t(),Nc=Cc.t(),ad=Yb,Uc=Nc,cd=qc.n(qd);Fc=!((cd.qe||oD(ad,Uc,c,d,e))&&(cd.Qd||oD(Uc,ad,c,d,e)))}return!Fc}if(Ot(new E(Mc.jj),Bp())){var kc=rD(a.q,Mc,V(a.q),c);return oD(kc,b,c,d,e)}return!1}if(t().d===yc)return!1;throw new w(yc);}if(k.w instanceof fw||k.y instanceof Qx||k.w instanceof Qx)return!1;var Vc=k.w;if(Vc instanceof Jv){for(var Hc=Vc.gi;!Hc.b();){var rc=Hc.e();if(!oD(a,rc,c,d,e))return!1;Hc=Hc.f()}return!0}var sd=k.y;if(sd instanceof Jv){for(var Kc=
+sd.gi;!Kc.b();){var Qd=Kc.e();if(oD(Qd,b,c,d,e))return!0;Kc=Kc.f()}return!1}if(k.y instanceof eC||k.y instanceof Tv||k.y instanceof Vv||k.w instanceof Vv||k.y instanceof Gv||k.w instanceof Gv||k.y instanceof cv||k.w instanceof cv||k.y instanceof Qv&&Uv(k.w)||Uv(k.y)&&k.w instanceof Qv)return!1;var Ad=k.w;if(Ad instanceof FA&&!0===Ad.Eh)var kd=!0;else{var Hd=k.y;kd=Hd instanceof FA&&!1===Hd.Eh?!0:!1}if(kd)return!1;throw new w(k);};function JA(a,b){var c=Xu().X();return Zu(a.q.La,a,b,!0,c)}
+function Kv(a,b){var c=a.q.ib,d=Xu().X();return Zu(a,c,b,!0,d)}function iB(a,b){return b.b()?a:a instanceof Tv?new Tv(a.q,a.Ic,a.kf.Ce(b),a.ma()):new Tv(a.q,a,b,V(a.q))}
+var bC=function sD(a,b){if(b.b())return a;var d=!1,e=null,g=!1,h=null;if(a instanceof Tv)return new Tv(a.q,a.Ic,a.kf.Ce(b),a.ma());if(a instanceof cv)return a;if(a instanceof LA){d=!0;e=a;var k=e.ic,l=e.jc;if(!0===e.tc)return a=iB(k,b),b=iB(l,b),h=V(a.q),dv(a,b,h,!1)}if(d&&(d=e.ic,l=e.jc,!1===e.tc))return a=iB(d,b),b=iB(l,b),h=V(a.q),Pu(a,b,h,!1);if(a instanceof Qv){h=a.q;g=a.Ba;a:for(;;)if(g.b()){b=u();break}else if(l=g.e(),e=g.f(),!1===!b.L(l.h()))g=e;else for(;;){if(e.b())b=g;else{l=e.e();if(!1!==
+!b.L(l.h())){e=e.f();continue}l=e;e=new z(g.e(),u());d=g.f();for(g=e;d!==l;)k=new z(d.e(),u()),g=g.p=k,d=d.f();for(d=l=l.f();!l.b();){k=l.e();if(!1===!b.L(k.h())){for(;d!==l;)k=new z(d.e(),u()),g=g.p=k,d=d.f();d=l.f()}l=l.f()}d.b()||(g.p=d);b=e}break a}return new Qv(h,b,a.Nj)}if(a instanceof zv){var m=a.Yb;b=b.Fk(new y(n=>{var r=nB(n);n=m.K();if(r.b())return!1;r=r.o()|0;return r!==n&&!(0>r||r>n)}));if(b.b())return a;a=a.kq();e=a.Ba;a:for(;;)if(e.b()){b=u();break}else if(g=e.e(),h=e.f(),!0===!!b.L(g.h()))e=
+h;else for(;;){if(h.b())b=e;else{g=h.e();if(!0!==!!b.L(g.h())){h=h.f();continue}g=h;h=new z(e.e(),u());l=e.f();for(e=h;l!==g;)d=new z(l.e(),u()),e=e.p=d,l=l.f();for(l=g=g.f();!g.b();){d=g.e();if(!0===!!b.L(d.h())){for(;l!==g;)d=new z(l.e(),u()),e=e.p=d,l=l.f();l=g.f()}g=g.f()}l.b()||(e.p=l);b=h}break a}return new Qv(a.q,b,a.Nj)}if(a instanceof Sv)return a;a instanceof Wv&&no();if(a instanceof MA&&(g=!0,h=a,h.Fc instanceof Mu||h.Fc instanceof cv||h.Fc instanceof Qv))return h;if(g&&(e=h.Fc,e instanceof
+LA||e instanceof FA||e instanceof MA))return a=NA(e,h.rA,!0),sD(a,b);if(a instanceof FA)return a;if(a instanceof OA)return new OA(a.q,sD(a.Hi,b),a.NE);if(a instanceof ZB&&($B(a.q),t(),h=a.mc(),h=new L(h),!h.b()))return sD(h.k,b);if(Uv(a))return a;if(a instanceof cC)return sD(a.Sf,b);if(a instanceof lx||a instanceof MA||a instanceof fw)return new Tv(a.q,a,b,V(a.q));if(a instanceof Qx)return h=a.de,e=a.Re,yx(zx(a.q),h,sD(e,b));if(a instanceof Jv||a instanceof eC)return a;throw new w(a);},tD=function Bca(a,
+b){a=DB(a);return a instanceof fw&&PA(a,b)?(a=QA(a,b),Bca(a,b)):a},wD=function uD(a,b,c,d,e){var h=!1,k=null,l=vD(e)?a:tD(a,d);if(l instanceof FA)return new FA(a.q,!l.Eh,V(a.q));if(l instanceof LA){h=!0;k=l;var m=k.ic,n=k.jc;if(!0===k.tc)return a=uD(m,b,c,d,e),c=uD(n,b,c,d,e),b=V(a.q),Pu(a,c,b,!1)}return h&&(h=k.ic,n=k.jc,!1===k.tc)?(a=uD(h,b,c,d,e),c=uD(n,b,c,d,e),b=V(a.q),dv(a,c,b,!1)):l instanceof MA?(b=b.n(l.Fc),ux(b.q,b,c)):l instanceof fw&&!vD(e)&&PA(l,d)?(a=QA(l,d),uD(a,b,c,d,e)):l instanceof
+Qv||l instanceof cv?a.q.ib:new MA(a.q,b.n(l),c)},Cca=function xD(a,b,c){if(a instanceof MA){var e=a.Fc,g=new y(m=>xD(m,b,c));a=a.ma();return wD(e,g,a,b,c)}if(a instanceof Tv){var h=a.Ic,k=a.kf;if(k.b())return xD(h,b,c);g=!1;e=null;h=vD(c)?DB(h):tD(h,b);k=bC(h,k);if(k instanceof Tv){g=!0;e=k;h=e.Ic;var l=e.kf;if(h instanceof LA)return e=h.jc,new LA(a.q,h.tc,bC(h.ic,l),bC(e,l),h.KE)}return g&&(g=e.Ic,e=e.kf,g instanceof MA)?(g=g.Fc,k=new y(m=>xD(m,b,c)),h=g.ma(),g=wD(g,k,h,b,c),e=bC(g,e),e instanceof
+Tv&&(g=e.Ic,g instanceof MA)?(g=g.Fc,g instanceof lx||g instanceof Mu||g instanceof Qv?e:vD(c)?e:xm(a+"  "+e+"  ("+ca(g)+")")):e):k}return a},DB=function Dca(a){if(a instanceof ZB){$B(a.q);t();var c=a.mc();c=new L(c);if(!c.b())return Dca(c.k)}return a},uy=function Eca(a){return a instanceof OA?Eca(a.Hi):a},Fca=function yD(a){var c=DB(a);return c instanceof Tv?yD(c.Ic):c instanceof Qx?yD(c.Re):c instanceof cC?yD(c.Sf):a},uB=function zD(a,b){var d=!1,e=null;if(a instanceof FA&&b===a.Eh)return O().c;
+if(a instanceof LA){var g=a.ic,h=a.jc;if(b===a.tc)return a=zD(g,b),dl(zD(h,b),a)}if(a instanceof MA&&(d=!0,e=a,h=e.Fc,h instanceof lx&&!b))return a=new UC(a.q,h),b=O().c,new z(a,b);if(d&&(d=e.Fc,d instanceof Gv&&!b))return a=new VC(a.q,d),b=O().c,new z(a,b);if(a instanceof OA)return zD(a.Hi,b);b=O().c;return new z(a,b)};function gD(a,b,c){var d=jA().X(),e=jA().X();Gca(a,a,b,c,e,d);return Aq(Bq(),d)}function AD(a,b){t();return BD(a,new L(!0),a,b)}function CD(a,b){t();return BD(a,new L(!1),a,b)}
+function BD(a,b,c,d){c=SC(a.q,c,nf(),!1,d);b=iA(a.q,c,b,d);return uf(a.q,b,!0,d)}var Gca=function DD(a,b,c,d,e,g){for(;;){if(c<d&&b.Ea()>c)if(b instanceof lx){if(!e.L(b))for(e.$(b),b.Xa>c&&b.Xa<=d&&g.$(b),b=ED(b,!0);!b.b();){var k=b.e();DD(a,k,c,d,e,g);b=b.f()}}else if(b instanceof Qx){k=b.de;d=k<d?k:d;b=b.Re;continue}else for(b=ED(b,!0);!b.b();)k=b.e(),DD(a,k,c,d,e,g),b=b.f();break}};function FD(a,b,c){a.yA=c;if(null===b)throw null;a.Vq=b}function GD(){this.Vq=this.yA=null}GD.prototype=new p;
+GD.prototype.constructor=GD;function HD(){}HD.prototype=GD.prototype;function mA(a,b,c){if(c instanceof zA)a.Tb(b,c);else{if(c instanceof BA){CA(a.Vq);t();var d=new L(c);if(!d.b()){c=d.k;for(d=c.xk;!d.b();){var e=d.e();ID(a,b,e);d=d.f()}c=c.Ul;c.b()||(c=c.o(),a.Tb(b,c));return}}throw new w(c);}}
+function ID(a,b,c){if(c instanceof ax){var d=c.Ql;for(c=c.rk.m();c.s();){var e=c.t();a.Tb(new TB(b),e.hb)}a.Tb(b,d)}else if(c instanceof Yw){var g=c.Ij,h=c.gl,k=c.Ei;d=c.Um;e=c.sk;var l=c.Tm;for(c=c.gh.m();c.s();){var m=c.t();a.Tb(new TB(b),m.hb)}if(!g.b())for(c=g.o();!c.b();)g=c.e(),a.Kp(b,g.j()),c=c.f();if(!h.b())for(c=h.o();!c.b();)h=c.e(),a.Tb(new UB(b),h.j()),c=c.f();for(c=k.ie();c.s();)k=c.t(),ID(a,b,k);a.Tb(new UB(b),d);a.Tb(new UB(b),e);for(c=l.ie();c.s();)d=c.t(),ID(a,b,d)}else if(c instanceof
+Ww){k=c.tk;d=c.co;e=c.uk;l=c.Vm;for(c=c.wk.m();c.s();)h=c.t(),a.Tb(new TB(b),h.hb);for(c=k.ie();c.s();)k=c.t(),ID(a,b,k);a.Tb(new UB(b),d);a.Tb(b,e);for(c=l.ie();c.s();)d=c.t(),ID(a,b,d)}else if(c instanceof Nw){d=c.jl;e=c.hl;k=c.Tl;l=c.Jj;for(c=c.kl.m();c.s();)h=c.t(),a.Tb(new TB(b),h.hb);for(c=k;!c.b();)k=c.e(),a.Kp(b,k.j()),c=c.f();for(c=l.ie();c.s();)l=c.t(),ID(a,b,l);a.Tb(new UB(b),d);a.Tb(new UB(b),e)}else if(c instanceof Vw)a.Kp(b,c.ig);else if(c instanceof bx)a.Tb(b,c.hh);else if(!(c instanceof
+cx))throw new w(c);}
+GD.prototype.Tb=function(a,b){var c=!1,d=null;a:{if(b instanceof lx){c=!0;d=b;iC(this.Vq);var e=d.Sb;if(!e.b()){b=e.o();this.Tb(a,b);break a}}if(c){b=a.Ig(d.Xa);if(Nm(new E(b),(t(),new L(!1))))for(e=vy(d),c=new RB(a,d.Xa,!0);!e.b();){var g=e.e();this.Tb(c,g);e=e.f()}if(Nm(new E(b),(t(),new L(!0))))for(b=rA(d),a=new RB(a,d.Xa,!1);!b.b();)d=b.e(),this.Tb(a,d),b=b.f()}else if(b instanceof cv)d=b.Nb,b=b.ac,this.Tb(new UB(a),d),this.Tb(a,b);else if(b instanceof Jv)for(b=b.gi;!b.b();)d=b.e(),this.Tb(a,
+d),b=b.f();else if(b instanceof LA)d=b.jc,this.Tb(a,b.ic),this.Tb(a,d);else if(b instanceof Qv)for(b=b.Ba,d=op(),b=b.Gb(d.ga).j();!b.b();)d=b.e(),this.Kp(a,d),b=b.f();else if(b instanceof zv)for(b=b.Yb,d=op(),b=b.Gb(d.ga).j();!b.b();)d=b.e(),this.Kp(a,d),b=b.f();else if(b instanceof Sv)this.Kp(a,b.Fd);else if(b instanceof Wv)for(b=b.fo;!b.b();){d=b.e();if(d instanceof fe)this.Tb(a,d.aa);else if(d instanceof Ud)this.Kp(a,d.fa);else throw new w(d);b=b.f()}else if(b instanceof MA)b=b.Fc,this.Tb(new UB(a),
+b);else if(!(b instanceof FA)){if(b instanceof ZB&&($B(this.Vq),t(),d=b.mc(),d=new L(d),!d.b())){this.Tb(a,d.k);break a}if(!(XB(b)||b instanceof YB))if(b instanceof mx)this.Tb(a,b.hi);else if(b instanceof fw)aC(b,a,new fn((h,k)=>{this.Tb(h,k)}),this.yA);else if(b instanceof Tv)this.Tb(a,b.Ic);else if(b instanceof cC)d=b.Fg,b=b.Sf,c=(h,k)=>{this.Tb(h,k)},Nm(new E(a.ol),(t(),new L(!0)))&&(e=gA(a.$m).Xu,c(e,d)),Nm(new E(a.ol),(t(),new L(!1)))&&(a=gA(a.$m).Pj,c(a,b));else if(b instanceof Qx)d=b.Re,this.Tb(new dC(a,
+b.de),d);else if(b instanceof eC){d=b.kj;for(b=b.Lj;!b.b();){e=b.e();if(null!==e)c=e.h(),e=e.j(),this.Tb(gA(this.Vq).Pj,c),this.Tb(gA(this.Vq).Jx,e);else throw new w(e);b=b.f()}this.Tb(a,d)}else throw new w(b);}}};GD.prototype.Kp=function(a,b){var c=b.Oa,d=new UB(a);c.b()||(c=c.o(),this.Tb(d,c));this.Tb(a,b.ra)};function JD(a,b,c){var d=c.Oa;d.b()?d=!1:(d=d.o(),d=Pe(new E(d),c.ra));d?a.Tb(new TB(b),c.ra):GD.prototype.Kp.call(a,b,c)}
+function KD(a,b,c){var d=!1,e=null;if(a instanceof lx){d=!0;e=a;iC(a.q);var g=e.Sb;if(!g.b()){var h=g.o(),k=G(new H,b,h),l=O().c;return new z(k,l)}}if(d){var m=b.Ig(e.Xa);if(Nm(new E(m),(t(),new L(!1)))){var n=vy(e),r=(bd=>Rc=>{var Wc=new RB(b,bd.Xa,!0);return G(new H,Wc,Rc)})(e);if(n===u())var v=u();else{for(var x=n.e(),A=new z(r(x),u()),B=A,C=n.f();C!==u();){var D=C.e(),F=new z(r(D),u());B=B.p=F;C=C.f()}v=A}}else v=O().c;if(Nm(new E(m),(t(),new L(!0)))){var I=rA(e),M=(bd=>Rc=>{var Wc=new RB(b,bd.Xa,
+!1);return G(new H,Wc,Rc)})(e);if(I===u())var N=u();else{for(var P=I.e(),T=new z(M(P),u()),Y=T,Z=I.f();Z!==u();){var S=Z.e(),ea=new z(M(S),u());Y=Y.p=ea;Z=Z.f()}N=T}}else N=O().c;return dl(N,v)}if(a instanceof cv){var ia=a.Nb,X=a.ac,sa=new UB(b),Ja=G(new H,sa,ia),Xa=G(new H,b,X),Fa=O().c;return new z(Ja,new z(Xa,Fa))}if(a instanceof Jv){var za=a.gi;if(za===u())return u();for(var Qa=za.e(),Ma=new z(G(new H,b,Qa),u()),Ga=Ma,ab=za.f();ab!==u();){var Hb=ab.e(),bc=new z(G(new H,b,Hb),u());Ga=Ga.p=bc;ab=
+ab.f()}return Ma}if(a instanceof LA){var yb=a.jc,tb=G(new H,b,a.ic),eb=G(new H,b,yb),kb=O().c;return new z(tb,new z(eb,kb))}if(a instanceof Qv){for(var Rb=a.Ba,Gb=op(),vb=Rb.Gb(Gb.ga).j(),Tb=null,Nb=null;vb!==u();){for(var ic=vb.e(),Va=LD(b,ic).m();Va.s();){var cb=new z(Va.t(),u());null===Nb?Tb=cb:Nb.p=cb;Nb=cb}vb=vb.f()}return null===Tb?u():Tb}if(a instanceof zv){for(var zb=a.Yb,Ub=op(),jb=zb.Gb(Ub.ga).j(),db=null,ub=null;jb!==u();){for(var Aa=jb.e(),va=LD(b,Aa).m();va.s();){var Ra=new z(va.t(),
+u());null===ub?db=Ra:ub.p=Ra;ub=Ra}jb=jb.f()}return null===db?u():db}if(a instanceof Sv)return LD(b,a.Fd);if(a instanceof Wv){for(var rb=a.fo,xb=null,mc=null;rb!==u();){var Ha=rb.e();if(Ha instanceof fe)var Ka=G(new H,b,Ha.aa),Oa=O().c,Na=new z(Ka,Oa);else{if(!(Ha instanceof Ud))throw new w(Ha);Na=LD(b,Ha.fa)}for(var Da=Na.m();Da.s();){var ta=new z(Da.t(),u());null===mc?xb=ta:mc.p=ta;mc=ta}rb=rb.f()}return null===xb?u():xb}if(a instanceof MA){var Ya=a.Fc,dc=new UB(b),ka=G(new H,dc,Ya),ya=O().c;return new z(ka,
+ya)}if(a instanceof FA)return O().c;if(a instanceof ZB){$B(a.q);t();var Sa=a.mc(),xc=new L(Sa);if(!xc.b()){var Sb=G(new H,b,xc.k),uc=O().c;return new z(Sb,uc)}}if(XB(a)||a instanceof YB)return O().c;if(a instanceof mx){var Lb=G(new H,b,a.hi),lc=O().c;return new z(Lb,lc)}if(a instanceof fw)return aC(a,b,new fn((bd,Rc)=>G(new H,bd,Rc)),c);if(a instanceof Tv){var Xb=G(new H,b,a.Ic),ec=O().c;return new z(Xb,ec)}if(a instanceof cC){var Ab=a.Fg,Ob=a.Sf,fb=gA(a.q).Xu,Wa=G(new H,fb,Ab),bb=gA(a.q).Pj,Ia=G(new H,
+bb,Ob),Ua=O().c;return new z(Wa,new z(Ia,Ua))}if(a instanceof Qx){var pc=G(new H,b,a.Re),sc=O().c;return new z(pc,sc)}if(a instanceof eC){for(var Ba=a.kj,ob=a.Lj,nc=null,Ib=null;ob!==u();){for(var vc=ob.e(),Vb=gA(a.q).Pj,fc=G(new H,Vb,vc.h()),Bc=gA(a.q).Jx,Pb=G(new H,Bc,vc.j()),Jb=O().c,gc=new Om(new z(fc,new z(Pb,Jb)));gc.s();){var Cb=new z(gc.t(),u());null===Ib?nc=Cb:Ib.p=Cb;Ib=Cb}ob=ob.f()}var cc=null===nc?u():nc,yc=G(new H,b,Ba),Mc=O().c;return dl(new z(yc,Mc),cc)}if(a instanceof BA){CA(a.q);
+t();var qc=new L(a);if(!qc.b()){for(var oc=qc.k,Qc=oc.xk,jc=null,sb=null;Qc!==u();){var Gc=Qc.e();if(Gc instanceof ax){var Wb=Gc,Cc=Wb.rk,Fc=(bd=>Rc=>{var Wc=new TB(bd);return G(new H,Wc,Rc.hb)})(b);if(Cc===u())var qd=u();else{for(var Yb=Cc.e(),Nc=new z(Fc(Yb),u()),ad=Nc,Uc=Cc.f();Uc!==u();){var cd=Uc.e(),kc=new z(Fc(cd),u());ad=ad.p=kc;Uc=Uc.f()}qd=Nc}var Vc=G(new H,b,Wb.Ql),Hc=O().c,rc=dl(new z(Vc,Hc),qd)}else if(Gc instanceof bx){var sd=Gc,Kc=gA(a.q).Pj,Qd=G(new H,Kc,sd.hh),Ad=O().c;rc=new z(Qd,
+Ad)}else if(Gc instanceof Nw){var kd=Gc,Hd=kd.kl.m(),Rd=new Ef(Hd,new y((bd=>Rc=>{var Wc=new TB(bd);return G(new H,Wc,Rc.hb)})(b)));rc=kv(Rd,new U(((bd,Rc,Wc)=>()=>{var Wd=bd.Jj.ie();return new xo(Wd,new y(zd=>MD(a,zd,Rc,Wc)))})(kd,b,c))).nb(new U(((bd,Rc)=>()=>{t();var Wc=new UB(bd);Wc=G(new H,Wc,Rc.hl);return new L(Wc)})(b,kd))).nb(new U(((bd,Rc)=>()=>{t();var Wc=new UB(bd);Wc=G(new H,Wc,Rc.jl);return new L(Wc)})(b,kd)))}else if(Gc instanceof Yw){var Bd=Gc,ae=Bd.gh.m(),dd=new Ef(ae,new y((bd=>Rc=>
+{var Wc=new TB(bd);return G(new H,Wc,Rc.hb)})(b)));rc=kv(dd,new U((bd=>()=>{for(var Rc=bd.Ij.ha(),Wc=null,Wd=null;Rc!==u();){for(var zd=Rc.e(),Pa=null,Db=null;zd!==u();){var Oc=zd.e();for(Oc=LD(gA(a.q).Pj,Oc.j()).m();Oc.s();){var Tc=new z(Oc.t(),u());null===Db?Pa=Tc:Db.p=Tc;Db=Tc}zd=zd.f()}for(zd=(null===Pa?u():Pa).m();zd.s();)Pa=new z(zd.t(),u()),null===Wd?Wc=Pa:Wd.p=Pa,Wd=Pa;Rc=Rc.f()}return null===Wc?u():Wc})(Bd))).nb(new U((bd=>()=>{for(var Rc=bd.gl.ha(),Wc=null,Wd=null;Rc!==u();){var zd=Rc.e(),
+Pa=Sd=>{var Jc=gA(a.q).Xu;return G(new H,Jc,Sd.j())};if(zd===u())Pa=u();else{var Db=zd.e(),Oc=Db=new z(Pa(Db),u());for(zd=zd.f();zd!==u();){var Tc=zd.e();Tc=new z(Pa(Tc),u());Oc=Oc.p=Tc;zd=zd.f()}Pa=Db}for(Pa=Pa.m();Pa.s();)Db=new z(Pa.t(),u()),null===Wd?Wc=Db:Wd.p=Db,Wd=Db;Rc=Rc.f()}return null===Wc?u():Wc})(Bd))).nb(new U(((bd,Rc,Wc)=>()=>{var Wd=bd.Ei.ie();return new xo(Wd,new y(zd=>MD(a,zd,Rc,Wc)))})(Bd,b,c))).nb(new U(((bd,Rc)=>()=>{t();var Wc=new UB(bd);Wc=G(new H,Wc,Rc.Um);return new L(Wc)})(b,
+Bd))).nb(new U(((bd,Rc)=>()=>{t();var Wc=G(new H,bd,Rc.sk);return new L(Wc)})(b,Bd))).nb(new U(((bd,Rc,Wc)=>()=>{var Wd=bd.Tm.ie();return new xo(Wd,new y(zd=>MD(a,zd,Rc,Wc)))})(Bd,b,c)))}else if(Gc instanceof Ww){var od=Gc,Ta=od.wk.m(),wb=new Ef(Ta,new y((bd=>Rc=>{var Wc=new TB(bd);return G(new H,Wc,Rc.hb)})(b)));rc=kv(wb,new U(((bd,Rc,Wc)=>()=>{var Wd=bd.tk.ie();return new xo(Wd,new y(zd=>MD(a,zd,Rc,Wc)))})(od,b,c))).nb(new U(((bd,Rc)=>()=>{t();var Wc=new UB(bd);Wc=G(new H,Wc,Rc.co);return new L(Wc)})(b,
+od))).nb(new U(((bd,Rc)=>()=>{t();var Wc=G(new H,bd,Rc.uk);return new L(Wc)})(b,od))).nb(new U(((bd,Rc,Wc)=>()=>{var Wd=bd.Vm.ie();return new xo(Wd,new y(zd=>MD(a,zd,Rc,Wc)))})(od,b,c)))}else if(Gc instanceof Vw)rc=LD(b,Gc.ig);else{if(!(Gc instanceof cx))throw new w(Gc);rc=t().d}for(var $a=rc.m();$a.s();){var wa=new z($a.t(),u());null===sb?jc=wa:sb.p=wa;sb=wa}Qc=Qc.f()}var hb=null===jc?u():jc,ra=oc.Ul.ha();if(ra===u())var wc=u();else{for(var ac=ra.e(),Id=new z(G(new H,b,ac),u()),ud=Id,be=ra.f();be!==
+u();){var re=be.e(),pe=new z(G(new H,b,re),u());ud=ud.p=pe;be=be.f()}wc=Id}return dl(wc,hb)}}throw new w(a);}function hA(a,b,c){var d=Xu().X(),e=jA().X();Hca(a,b,!1,a.q.Df,a,!1,d,e,c);a=Su();b=op().ga;a=new Uu(a,b);return Ov(sv(),d,a)}
+var Ica=function ND(a,b){if(b instanceof bx){var d=b.hh,e=O().c;return new z(d,e)}if(b instanceof ax)return d=b.rk.m(),d=new Ef(d,new y(h=>h.hb)),kv(d,new U(()=>{t();return new L(b.Ql)}));if(b instanceof Nw)return d=b.kl.m(),d=new Ef(d,new y(h=>h.hb)),kv(d,new U(()=>{var h=b.Jj.ie();return new xo(h,new y(k=>ND(a,k)))})).nb(new U(()=>{t();return new L(b.hl)})).nb(new U(()=>{t();return new L(b.jl)}));if(b instanceof Yw)return d=b.gh.m(),d=new Ef(d,new y(h=>h.hb)),kv(d,new U(()=>{for(var h=b.Ij.ha(),
+k=null,l=null;h!==u();){for(var m=h.e(),n=null,r=null;m!==u();){var v=m.e(),x=v.j().Oa.ha();v=v.j().ra;var A=O().c;for(x=dl(new z(v,A),x).m();x.s();)v=new z(x.t(),u()),null===r?n=v:r.p=v,r=v;m=m.f()}for(m=(null===n?u():n).m();m.s();)n=new z(m.t(),u()),null===l?k=n:l.p=n,l=n;h=h.f()}return null===k?u():k})).nb(new U(()=>{for(var h=b.gl.ha(),k=null,l=null;h!==u();){var m=h.e();for(m=mv(lv(),m);m.s();){var n=new z(m.t(),u());null===l?k=n:l.p=n;l=n}h=h.f()}return null===k?u():k})).nb(new U(()=>{var h=
+b.Ei.ie();return new xo(h,new y(k=>ND(a,k)))})).nb(new U(()=>{t();return new L(b.Um)})).nb(new U(()=>{t();return new L(b.sk)}));if(b instanceof Ww)return d=b.wk.m(),d=new Ef(d,new y(h=>h.hb)),kv(d,new U(()=>{var h=b.tk.ie();return new xo(h,new y(k=>ND(a,k)))})).nb(new U(()=>{t();return new L(b.co)})).nb(new U(()=>{t();return new L(b.uk)})).nb(new U(()=>{var h=b.Vm.ie();return new xo(h,new y(k=>ND(a,k)))}));if(b instanceof Vw){d=b.ig.Oa.ha();e=b.ig.ra;var g=O().c;return dl(new z(e,g),d)}if(b instanceof
+cx)return O().c;throw new w(b);};
+function ED(a,b){var c=!1,d=null;if(a instanceof lx){c=!0;d=a;iC(a.q);var e=d.Sb;if(!e.b())return a=e.o(),b?(b=O().c,new z(a,b)):O().c}if(c)return b?(a=vy(d),dl(rA(d),a)):O().c;if(a instanceof cv)return b=a.Nb,a=a.ac,d=O().c,new z(b,new z(a,d));if(a instanceof Jv)return a.gi;if(a instanceof LA)return b=a.ic,a=a.jc,d=O().c,new z(b,new z(a,d));if(a instanceof Qv){a=a.Ba;for(d=b=null;a!==u();){e=a.e();c=e.j().Oa.ha();e=e.j().ra;var g=O().c;for(c=dl(new z(e,g),c).m();c.s();)e=new z(c.t(),u()),null===
+d?b=e:d.p=e,d=e;a=a.f()}return null===b?u():b}if(a instanceof zv){a=a.Yb;for(d=b=null;a!==u();){e=a.e();c=e.j().Oa.ha();e=e.j().ra;g=O().c;for(c=dl(new z(e,g),c).m();c.s();)e=new z(c.t(),u()),null===d?b=e:d.p=e,d=e;a=a.f()}return null===b?u():b}if(a instanceof Sv)return b=a.Fd,a=b.Oa.ha(),b=b.ra,d=O().c,un(a,new z(b,d));if(a instanceof MA)return a=a.Fc,b=O().c,new z(a,b);if(a instanceof FA)return O().c;if(a instanceof ZB&&($B(a.q),t(),b=a.mc(),b=new L(b),!b.b()))return a=b.k,b=O().c,new z(a,b);if(XB(a)||
+a instanceof YB)return O().c;if(a instanceof mx)return a=a.hi,b=O().c,new z(a,b);if(a instanceof fw)return a.Zb;if(a instanceof Tv)return a=a.Ic,b=O().c,new z(a,b);if(a instanceof cC)return b=a.Fg,a=a.Sf,d=O().c,new z(b,new z(a,d));if(a instanceof Qx)return a=a.Re,b=O().c,new z(a,b);if(a instanceof eC){b=a.kj;a=a.Lj;for(c=d=null;a!==u();){g=a.e();e=g.h();g=g.j();var h=O().c;for(e=new Om(new z(e,new z(g,h)));e.s();)g=new z(e.t(),u()),null===c?d=g:c.p=g,c=g;a=a.f()}a=null===d?u():d;d=O().c;return dl(new z(b,
+d),a)}if(a instanceof Wv){a=a.fo;for(d=b=null;a!==u();){c=a.e();if(c instanceof fe)c=c.aa,e=O().c,c=new z(c,e);else{if(!(c instanceof Ud))throw new w(c);e=c.fa;c=e.Oa.ha();e=e.ra;g=O().c;c=dl(new z(e,g),c)}for(c=c.m();c.s();)e=new z(c.t(),u()),null===d?b=e:d.p=e,d=e;a=a.f()}return null===b?u():b}if(a instanceof BA&&(CA(a.q),t(),b=new L(a),!b.b())){b=b.k;d=b.xk;for(e=c=null;d!==u();){g=d.e();for(g=Ica(a,g).m();g.s();)h=new z(g.t(),u()),null===e?c=h:e.p=h,e=h;d=d.f()}a=null===c?u():c;return dl(b.Ul.ha(),
+a)}throw new w(a);}function xA(a,b){var c=jA().X(),d=O().c;Jca(new z(a,d),c,b);a=uv();O();b=new y(e=>e.sp);d=Fq();return oA(a,c,new OD(d,b))}
+function xx(a){var b=xA(a,!0).m();b=new iy(b,new y(c=>{if(c.Sb.b()){var d=rA(c);c=vy(c);return!un(d,c).b()}return!0}),!1);b=new Ef(b,new y(c=>{if(null!==c){iC(a.q);var d=c.Sb;if(!d.b())return d=d.o(),"\n\t\t"+c.u()+" :\x3d "+d}d=c.u();if(vy(c).b())var e="";else e=vy(c),e=" :\x3e "+ze(e,""," | ","");rA(c).b()?c="":(c=rA(c),c=" \x3c: "+ze(c,""," \x26 ",""));return"\n\t\t"+d+e+c}));return ze(b,"","","")}
+function LD(a,b){var c=b.Oa;if(c.b())c=R();else{c=c.o();var d=new UB(a);c=new L(G(new H,d,c))}c=c.ha();a=G(new H,a,b.ra);b=O().c;return dl(new z(a,b),c)}function MD(a,b,c,d){if(b instanceof Vw)return c=b.ig,LD(gA(a.q).Pj,c);if(b instanceof bx)return c=G(new H,c,b.hh),d=O().c,new z(c,d);if(b&&b.$classData&&b.$classData.rb.Rs){a=a.q;var e=O().c;b=new By(a,new z(b,e),t().d);return KD(b,c,d)}throw new w(b);}
+var Hca=function PD(a,b,c,d,e,g,h,k,l){for(;;){if(e instanceof lx){if(g&&e.Xa>d){g=a.q;g.F&&(g=ut(Q(),"| ",g.r)+"Quantified! "+e,ff(gf(),g+"\n"));break}var n=b.Ig(e.Xa);c||h.ou(e,new y((A=>B=>{if(B instanceof L&&Nm(new E(B.k),A))return t(),B=t().d,new L(B);t();return new L(A)})(n)));if(n instanceof L){n=!!n.k;var r=G(new H,e,n);k.L(r)?n=!1:(n=G(new H,e,n),k.$(n),n=!0)}else{if(t().d!==n)throw new w(n);n=G(new H,e,!0);k.L(n)?(n=G(new H,e,!1),n=k.L(n)):n=!1;n?n=!1:(n=G(new H,e,!0),k.$(n),n=G(new H,e,
+!1),k.$(n),n=!0)}if(n)for(b=KD(e,b,l);!b.b();)e=b.e(),PD(a,e.h(),c,d,e.j(),g,h,k,l),b=b.f()}else{if(e instanceof ZB&&(n=e,$B(a.q),t(),n=n.mc(),n=new L(n),!n.b())){e=n.k;continue}if(e instanceof Jv)for(e=e.gi;!e.b();)n=e.e(),PD(a,b,c,d,n,g,h,k,l),e=e.f();else{if(e instanceof MA){e=e.Fc;b=new UB(b);continue}if(e instanceof Tv){e=e.Ic;continue}if(e instanceof cC){b=e.Fg;e=e.Sf;PD(a,gA(a.q).Xu,c,d,b,g,h,k,l);b=a;n=gA(a.q).Pj;a=b;b=n;continue}if(e instanceof eC){var v=e;e=v.kj;n=a;r=d;for(v=v.Lj;!v.b();){var x=
+v.e();PD(n,gA(n.q).Pj,!1,r,x.h(),g,h,k,l);PD(n,gA(n.q).Jx,!1,r,x.j(),g,h,k,l);v=v.f()}continue}if(e instanceof LA){n=e.jc;PD(a,b,c,d,e.ic,g,h,k,l);e=n;continue}if(e instanceof Qx){b=new dC(b,e.de);n=e.de;d=d<n?d:n;e=e.Re;continue}b=KD(e,b,l);c=a;for(a=b;!a.b();)b=a.e(),PD(c,b.h(),!1,d,b.j(),g,h,k,l),a=a.f()}}break}};
+function Jca(a,b,c){for(;;){var d=!1,e=null,g=a;if(g instanceof z){d=!0;e=g;var h=e.z;a=e.p;if(h instanceof lx){e=h;b.L(e)||(b.$(e),e=ED(e,c),a=dl(a,e));continue}}if(d){a=e.p;e=ED(e.z,c);a=dl(a,e);continue}b=O().c;if(null===b?null!==g:!b.i(g))throw new w(g);break}}function PA(a,b){a=b.$a.U(a.qb.V);if(a.b())return!0;a=a.o();return dz(a.Qu)?!0:!a.eo.b()}
+function cD(a,b,c){var d=b.$a.U(a.qb.V);if(d instanceof L){if(d=d.k,!dz(d.Qu)&&(Kx(d,c),d.eo.b()))return Ey(a.q)}else if(t().d!==d)throw new w(d);return gB(a,!0,!0,b)}function QA(a,b){At(tp(),PA(a,b));return gB(a,!0,!0,b)}
+function gB(a,b,c,d){var e=d.$a.U(a.qb.V);if(e.b())e=R();else{e=e.o();var g=new $e,h=!1,k=null,l=e.eo;a:{if(l instanceof L&&(h=!0,k=l,l=k.k,l instanceof ax)){tp();e=l.rk.K();up(0,Pe(new E(e),a.Zb.K()));e=a.q;g=l.Ql;c=l.rk;c=new Wq(c,c,a.Zb);l=new fn((m,n)=>{m=new mx(a.q,m.hb,V(a.q));return G(new H,m,n)});Yq();c=Ew(c,l);op();e=SC(e,g,c.Ti(),!1,d);break a}if(h&&(l=k.k,l instanceof Ww)){tp();h=l.wk.K();up(0,Pe(new E(h),a.Zb.K()));h=a.q;k=new vl(l.vk.gb.V);k=Cq(k,a.Xl.Ga);t();h=Jx(h,l,k,new L(a.Zb),d);
+if(null===h)throw new w(h);h=h.h();c=c?(Sw(a.q),l.uk.Kc(l.Hq,!1,d,h)):a.q.La;l=Xx(a.q,l.vk,V(a.q),d);h=V(c.q);c=Pu(c,l,h,!1);e=g.sb?g.vb:QD(a,g,e);g=V(c.q);e=Pu(c,e,g,!1);break a}if(h&&(l=k.k,l instanceof Yw)){tp();h=l.gh.K();up(0,Pe(new E(h),a.Zb.K()));h=a.q;k=new vl(l.Rf.gb.V);k=Cq(k,a.Xl.Ga);t();h=Jx(h,l,k,new L(a.Zb),d);if(null===h)throw new w(h);h=h.h();c=c?(Sw(a.q),l.sk.Kc(l.Sm,!1,d,h)):a.q.La;l=bz(a.q,l.Rf,V(a.q),d);h=V(l.q);c=Pu(l,c,h,!1);e=g.sb?g.vb:QD(a,g,e);g=V(c.q);e=Pu(c,e,g,!1);break a}l=
+!1;c=null;h=e.Ab;if(h instanceof yo&&(l=!0,c=h,Kca(c.pb))){tp();l=c.hg.K();up(0,Pe(new E(l),a.Zb.K()));c=bz(a.q,c,V(a.q),d);e=g.sb?g.vb:QD(a,g,e);g=V(c.q);e=Pu(c,e,g,!1);break a}l&&Ot(new E(c.pb),Fp())?(tp(),l=c.hg.K(),up(0,Pe(new E(l),a.Zb.K())),c=Xx(a.q,c,V(a.q),d),e=g.sb?g.vb:QD(a,g,e),g=V(c.q),e=Pu(c,e,g,!1)):(l&&Ot(new E(c.pb),Ap())&&xm("cannot expand unforced type alias"),e=Ey(a.q))}e=new L(e)}if(e.b()){c=new $e;g=d.tb.n(a.qb.V);tp();e=a.Zb.K();At(0,Pe(new E(e),g.Xm.K()));e=a.q;l=g.jj;if(Ap()===
+l)b=g.Cx;else{if(zp()===l)throw RD("Namespaces are not supported yet.");if(Bp()===l)l=rD(a.q,g,a.Xl,d),h=g.Cx,k=V(l.q),l=Pu(l,h,k,!1),b=c.sb?c.vb:SD(a,c,b,g),c=V(l.q),b=Pu(l,b,c,!1);else{if(Fp()!==l)throw cp()===l&&xm("mixins cannot be used as types"),new w(l);l=TD(a.q,g,a.Xl);h=g.Cx;k=V(l.q);l=Pu(l,h,k,!1);b=c.sb?c.vb:SD(a,c,b,g);c=V(l.q);b=Pu(l,b,c,!1)}}g=g.UN;g=new UD(new Wq(g,g,a.Zb));op();d=SC(e,b,pp(qp(),g),!1,d)}else d=e.o();return d}
+function Lca(a,b){a=b.$a.U(a.qb.V);return a instanceof L?(a=a.k.Ab,a instanceof yo&&a.Pm.b()?!a.Hj.b():!0):!0}
+function gw(a,b){var c=a.MI;if(c.b()){c=!1;var d=null,e=b.tb.U(a.qb.V);a:{if(e instanceof L&&(c=!0,d=e,e=d.k,null!==e&&(Ot(new E(e.jj),Bp())||Ot(new E(e.jj),zp())))){t();b=rD(a.q,e,V(a.q),b);b=new L(b);break a}if(c&&(c=d.k,null!==c&&Ot(new E(c.jj),Fp()))){b=t().d;break a}c=b.$a.U(a.qb.V);if(c instanceof L&&(c=c.k.Ab,c instanceof yo&&(Ot(new E(c.pb),Bp())||Ot(new E(c.pb),zp())))){t();b=bz(a.q,c,V(a.q),b);b=new L(b);break a}b=t().d}a.MI=(t(),new L(b));a=b}else a=c.o();return a}
+function bw(a,b,c,d){var e=d.tb.U(a.qb.V);if(e instanceof L)e=e.k,d=e.Nu,e=e.Xm;else{if(t().d!==e)throw new w(e);e=d.$a.n(a.qb.V);d=t().d;var g=e.Ag();if(g===u())e=u();else{e=g.e();var h=e=new z(G(new H,e.kc,e.hb),u());for(g=g.f();g!==u();){var k=g.e();k=new z(G(new H,k.kc,k.hb),u());h=h.p=k;g=g.f()}}}if(d.b()){g=a.Zb;d=m=>c.ba(t().d,m);if(g===u())return u();e=g.e();h=e=new z(d(e),u());for(g=g.f();g!==u();)k=g.e(),k=new z(d(k),u()),h=h.p=k,g=g.f();return e}var l=d.o();tp();d=jv(e,a.Zb);up(0,Pe(new E(d),
+0));d=new Wq(e,e,a.Zb);e=new fn((m,n)=>{n=G(new H,m,n);var r=n.y;m=n.w;if(null!==r){n=l.n(r.j());if(null!==n&&(r=n.qe,!0===n.Qd&&!0===r))return m=t().d,c.ba(m,new cC(a.q,a.q.ib,a.q.La,V(a.q)));if(null!==n)return r=n.qe,n.Qd?n=b:r?b.b()?n=R():(n=!!b.o(),n=new L(!n)):n=t().d,c.ba(n,m);throw new w(n);}throw new w(n);});Yq();return Ew(d,e)}
+function aC(a,b,c,d){var e=tc();try{var g=d.tb.U(a.qb.V);if(g instanceof L)var h=g.k,k=h.Nu,l=h.Xm;else{if(t().d!==g)throw new w(g);var m=d.$a.Se(a.qb.V,new U(()=>{throw Hq(new Iq,e,O().c);})),n=it().n(VD(m)),r=m.Ag();if(r===u())var v=u();else{var x=r.e(),A=new z(G(new H,x.kc,x.hb),u());d=A;for(var B=r.f();B!==u();){var C=B.e(),D=new z(G(new H,C.kc,C.hb),u());d=d.p=D;B=B.f()}v=A}k=n;l=v}if(k.b()){var F=a.Zb,I=ia=>c.ba(new TB(b),ia);if(F===u())return u();var M=F.e(),N=new z(I(M),u());M=N;for(var P=
+F.f();P!==u();){var T=P.e(),Y=new z(I(T),u());M=M.p=Y;P=P.f()}return N}var Z=k.o();tp();I=jv(l,a.Zb);up(0,Pe(new E(I),0));var S=new Wq(l,l,a.Zb),ea=new fn((ia,X)=>{X=G(new H,ia,X);var sa=X.y;ia=X.w;if(null!==sa){X=Z.n(sa.j());if(null!==X&&(sa=X.qe,!0===X.Qd&&!0===sa))return ia=new TB(b),c.ba(ia,new cC(a.q,a.q.ib,a.q.La,V(a.q)));if(null!==X)return sa=X.qe,c.ba(X.Qd?b:sa?new UB(b):new TB(b),ia);throw new w(X);}throw new w(X);});Yq();return Ew(S,ea)}catch(ia){if(ia instanceof Iq){F=ia;if(F.Qg===e)return F.Cj();
+throw F;}throw ia;}}function QD(a,b,c){if(null===b)throw le();if(b.sb)return b.vb;var d=a.q;c=c.Ag();c=new Wq(c,c,a.Zb);var e=new fn((g,h)=>{var k=G(new H,g,h);h=k.y;g=k.w;if(null!==h){k=h.kc;h=h.Rd;var l=new vl(a.qb.V+"#"+k.V);k=k.A();k=Cq(l,k);l=WD(a.q);h=h.b()?ou().Yl:h.o();g=XD(l,h,g,g,V(a.q));return G(new H,k,g)}throw new w(k);});Yq();c=Ew(c,e);return me(b,new Qv(d,c,V(a.q)))}
+function SD(a,b,c,d){if(null===b)throw le();if(b.sb)return b.vb;if(c){c=xv(a.q);var e=d.Xm,g=m=>{if(null!==m){var n=m.h();m=m.j();var r=dB(d);n=new vl(a.qb.V+"#"+n.V);m=new Uw(a.q,new L(r.n(m).Qd?a.q.ib:m),r.n(m).qe?a.q.La:m,a.Xl);return G(new H,n,m)}throw new w(m);};if(e===u())g=u();else{var h=e.e(),k=h=new z(g(h),u());for(e=e.f();e!==u();){var l=e.e();l=new z(g(l),u());k=k.p=l;e=e.f()}g=h}c=SA(c,g,V(a.q))}else c=a.q.La;return me(b,c)}
+function YD(a){var b=!1,c=Xz(Q(),a.x);if(c instanceof L&&(b=!0,48===Ea(c.k)))return Pe(new E(a.x.length),1);if(b){a=a.x;b=0;for(c=a.length;b<c;){var d=a.charCodeAt(b),e=Pr();if(!(256>d?48<=d&&57>=d:9===ZD(e,d)))return!1;b=1+b|0}return!0}if(t().d===c)return!1;throw new w(c);}function nB(a){return YD(a)?(a=a.x,$D(aE(),a)):t().d}
+function kca(a){var b=Hu(Q(),a.x);Or(Pr(),b)?(b=Hu(Q(),a.x),b=bE(Pr(),b)):b=!1;b?b=!0:(b=Hu(Q(),a.x),b=Pe(new E(hc(b)),hc(95)));b?b=!0:(b=Hu(Q(),a.x),b=Pe(new E(hc(b)),hc(36)));return b&&Nm(new E(a.x),"true")?Nm(new E(a.x),"false"):!1}function cE(a){a.xK(yn(a.mv()))}var Nca=function Mca(a,b){if(a.Ip.L(b))return!0;a=a.cJ;if(a.b())return!1;a=a.o();return Mca(a,b)};
+function dE(a,b){var c=tc();try{if(""===b)return a.bJ.t();eE();var d=String.fromCharCode(39),e=String.fromCharCode(36),g=b.split(d).join(e);if(a.Ip.L(g)?0:!eq().qF.L(g))return g;for(b=1;;){d=""+g+b;if(!a.Ip.L(d))throw Hq(new Iq,c,d);if(2147483647===b)break;b=1+b|0}throw new gm(""===g?"Cannot allocate a runtime name":"Cannot allocate a runtime name starting with '"+g+"'");}catch(h){if(h instanceof Iq){a=h;if(a.Qg===c)return a.Cj();throw a;}throw h;}}
+function zo(a,b,c,d){var e=!1,g=null,h=a.Rx.U(b);a:{if(h instanceof L){e=!0;g=h;var k=g.k;if(k instanceof ko&&k.RP){b=new io(b,k.re,!1,c,!0);break a}}if(e)b=new io(b,g.k.zo(),!0,c,!0);else if(t().d===h)b=new io(b,dE(a,b),!1,c,!0);else throw new w(h);}vp(a,b);d.b()||(d=d.o(),vp(a,new io(d,b.nt,!1,c,!0)));return b}
+function fE(a,b){a.cJ=b;Ty();b=u();a.ko=Uy(b);Ty();b=u();a.Rx=Uy(b);pz();b=u();a.Ip=qz(b);Ty();b=u();a.PA=Uy(b);a.lo=new gE;a.bJ=new xo(new hE(1,1,2147483647,!1),new y(c=>{c|=0;var d=eE().QP;c=Oca(d,c);c=new Ef(c,new y(e=>{var g=ze(e,"","","");return G(new H,e,g)}));c=new iy(c,new y(e=>{if(null!==e)return!Nca(a,e.j());throw new w(e);}),!1);return new Ef(c,new y(e=>{if(null!==e)return e.j();throw new w(e);}))}));return a}function iE(){this.bJ=this.lo=this.PA=this.Ip=this.Rx=this.ko=this.cJ=null}
+iE.prototype=new p;iE.prototype.constructor=iE;function yp(a,b){a.ko.bj(b.xo(),b);a.Rx.bj(b.xo(),b);a.Ip.oh(b.zo())}function vp(a,b){a.Rx.bj(b.xo(),b);a.Ip.oh(b.zo())}function Cm(a,b){var c=a.Rx.U(b);return c.b()?(a=a.cJ,a.b()?R():Cm(a.o(),b)):c}function Taa(a,b,c,d,e){var g=dE(a,b);b=new mn(b,g,c,d,e);yp(a,b);return b}function Saa(a,b,c,d){b=new nn(b,c,d);a.ko.bj(b.er,b)}
+function Im(a,b,c,d,e){var g=!1,h=null,k=a.Rx.U(b);a:{if(k instanceof L&&(g=!0,h=k,k=h.k,k instanceof io&&!k.RA)){g=k.nt;break a}if(g&&(k=h.k,k instanceof ko&&k.RP)){g=k.re;break a}if(g&&(g=h.k,g instanceof go&&!g.DP)){g=g.bF;break a}g=dE(a,b)}b=new ko(b,g,c,d,!1);vp(a,b);e.b()||(e=e.o(),vp(a,new ko(e,g,c,d,!1)));return b}function gp(a,b){b=dE(a,b);t();b=new ko("this",b,new L(!1),!1,!1);Ly(a.PA,b.re,b,!1);vp(a,b);return b.re}
+function lm(a,b){var c=a.PA;a=()=>{throw new gm("qualifier "+b+" not found");};if(ca(c)!==da(Ky))if(c=c.U(b),c instanceof L)a=c.k;else{if(R()!==c)throw new w(c);a=a()}else{var d=My(W(),b);d^=d>>>16|0;c=c.eb.a[d&(-1+c.eb.a.length|0)];c=null===c?null:Ny(c,b,d);a=null===c?a():c.Ah}return a}function Naa(a){var b=a.bJ.t();a.Ip.oh(b);return b}function Uo(a,b){b=dE(a,b);a.Ip.oh(b);return b}
+function wl(a,b){if(aq(Al(),b))var c=b;else if(eq().qF.L(b))c=b+"$";else{eE();c=String.fromCharCode(39);var d=String.fromCharCode(36);c=b.split(c).join(d)}c=dE(a,c);vp(a,new ko(b,c,new L(!1),!1,!1));return c}function Hm(a){var b=fE(new iE,(t(),new L(a)));a=a.PA;for(var c=a.eb.a.length,d=0;d<c;){var e=a.eb.a[d];if(null!==e)for(;;){var g=e.Wk,h=e.Ah;b.Ip.oh(g);Ly(b.PA,g,h,!1);if(null!==e.$d)e=e.$d;else break}d=1+d|0}return b}iE.prototype.$classData=q({w_:0},!1,"mlscript.codegen.Scope",{w_:1,g:1});
+function jE(){this.QP=null;kE=this;t();tp();var a=new Jr("abcdefghijklmnopqrstuvwxyz");this.QP=Pd(u(),a)}jE.prototype=new p;jE.prototype.constructor=jE;jE.prototype.$classData=q({x_:0},!1,"mlscript.codegen.Scope$",{x_:1,g:1});var kE;function eE(){kE||(kE=new jE);return kE}
+function lE(){this.qF=null;mE=this;this.qF=Aq(tp().Iv,J(new K,"break case catch class const continue debugger default delete do else export extends finally for function if import in instanceof new return super switch this throw try typeof var void while with yield enum abstract boolean byte char double final float goto int long native short synchronized throws transient volatile".split(" ")))}lE.prototype=new p;lE.prototype.constructor=lE;
+lE.prototype.$classData=q({A_:0},!1,"mlscript.codegen.Symbol$",{A_:1,g:1});var mE;function eq(){mE||(mE=new lE);return mE}function nE(){this.SP="??"}nE.prototype=new p;nE.prototype.constructor=nE;nE.prototype.$classData=q({G_:0},!1,"mlscript.package$",{G_:1,g:1});var oE;function pE(){oE||(oE=new nE);return oE}function qE(a){a.lf=O().c}function rE(){this.lf=null}rE.prototype=new p;rE.prototype.constructor=rE;function sE(){}sE.prototype=rE.prototype;
+function tE(a){if(a.lf.b())return"";var b=a.lf;a=O().c;if(null===a?null===b:a.i(b))a="";else{if(b===u())a=u();else{a=b.e();var c=a=new z(a.Sj.x,u());for(b=b.f();b!==u();){var d=b.e();d=new z(d.Sj.x,u());c=c.p=d;b=b.f()}}a=ze(a,"(",", ",")")}return" with "+a}var Qca=function Pca(a,b,c,d){return c.L(b)?c:d.Se(b,new U(()=>u())).De(c.bc(b),new fn((g,h)=>Pca(a,h,g,d)))};function uE(){}uE.prototype=new p;uE.prototype.constructor=uE;
+function Rca(a,b){a=b.m();a=new xo(a,new y(e=>{if(null!==e){var g=e.h();e=e.j().m();return new Ef(e,new y(h=>G(new H,h,g)))}throw new w(e);}));for(b=nf();a.s();){var c=a.t();b=G(new H,b,c);a:{c=b.y;var d=b.w;if(null!==d&&(d=new L(d),!d.b())){b=c.IC(d.k.h(),new y((e=>g=>{if(R()===g)return g=O().c,new L(new z(e,g));if(g instanceof L)return new L(new z(e,g.k));throw new w(g);})(d.k.j())));break a}throw new w(b);}}return b}
+function Sca(a,b){var c=b.zr().Ja(new y(d=>{tp();var e=u();e=Qca(a,d,Aq(0,e),b).Ek(d);Od();e=Pd(u(),e);return G(new H,d,e)}));op();return c.Ti()}function vE(a,b,c,d,e){c.n(new U(()=>"\u2022 "+d));b.b()?c.n(new U(()=>"  + \x3cEmpty\x3e")):b.og(new fn((g,h)=>{c.n(new U(()=>"  + "+g+" "+e+" "+(h.b()?"{}":ze(h,"{ ",", "," }"))))}))}uE.prototype.$classData=q({R_:0},!1,"mlscript.ucs.Desugarer$",{R_:1,g:1});var wE;function xE(){wE||(wE=new uE);return wE}function yE(){}yE.prototype=new p;
+yE.prototype.constructor=yE;function zE(){}zE.prototype=yE.prototype;function AE(a,b){if(null===a)throw le();if(a.sb)return a.vb;b=b.ni.m();b=new Ef(b,new y(c=>{if(null!==c){var d=c.Sj,e=c.gr;if(null!==d)return"[binding "+d.x+" \x3d "+Zz(e,!1)+"]"}throw new w(c);}));Od();return me(a,Pd(u(),b))}
+var Tca=function BE(a,b,c,d){for(;;){var g=new $e,h=ut(Q(),"  ",c),k=b;if(k instanceof CE){var l=k,m=l.hr;k=l.Dk;l=l.Fh;for(b=g.sb?g.vb:AE(g,b);!b.b();)g=b.e(),d.$(""+h+g),b=b.f();b=h+("if \u00ab"+Zz(m,!1))+"\u00bb";d.$(b);BE(a,k,1+c|0,d);d.$(h+"else");h=1+c|0;b=l;c=h}else{if(k instanceof DE){l=k;k=l.mo;m=l.mh;l=l.nj;for(b=g.sb?g.vb:AE(g,b);!b.b();)g=b.e(),d.$(""+h+g),b=b.f();b=""+h;var n=k;g=Zz(n.nh,!1);n=n.no;a:if(t().d===n)n="";else{if(n instanceof L){var r=n.k;if(null!==r){n=" as "+r.x;break a}}throw new w(n);
+}d.$(b+("\u00ab"+g+"\u00bb"+n)+" match");b=c;for(m=m.m();m.s();)a:if(n=m.t(),n instanceof EE)g=n.Jp,n=h+"  case "+Zz(n.ir,!1)+" \x3d\x3e",d.$(n),BE(a,g,1+b|0,d);else{if(n instanceof FE&&(g=n,r=g.Tj,g=g.pl,null!==r)){var v=new L(r);if(!v.b()&&(r=v.k.h(),v=v.k.j(),null!==r)){d.$(h+"  case "+r.x+" \x3d\x3e");for(n=v.m();n.s();)b:{if(v=n.t(),null!==v){r=v.h();var x=v.j();if(null!==x){v=x.x;x=GE(k);r=h+"    [pattern "+v+" \x3d "+Zz(x,!1)+"."+r+"]";d.$(r);break b}}throw new w(v);}BE(a,g,2+b|0,d);break a}}throw new w(n);
+}l.b()||(k=l.o(),d.$(h+"  default"),BE(a,k,2+c|0,d))}else if(k instanceof HE){a=k.ot;for(c=g.sb?g.vb:AE(g,b);!c.b();)k=c.e(),d.$(""+h+k),c=c.f();h=h+"\u00ab"+Zz(a,!1)+"\u00bb";d.$(h)}else if(IE()===k){for(a=g.sb?g.vb:AE(g,b);!a.b();)c=a.e(),d.$(""+h+c),a=a.f();d.$(h+"\x3cmissing case\x3e")}else throw new w(k);break}}};
+function JE(a,b){if(null===a)throw le();if(a.sb)return a.vb;b=b.lf;if(b.b())b=Od().jC;else{Od();var c=new fp;Od();for(var d=new fp,e=b.m();e.s();){var g=e.t(),h=g;a:{if(null!==h){var k=h.fr;if(KE()===k){h=!1;break a}}if(null!==h)h=!0;else throw new w(h);}wp(h?c:d,g)}c=G(new H,c.ha(),d.ha());d=c.y;u().i(d)?b=G(new H,u(),b):(d=c.w,b=u().i(d)?G(new H,b,u()):c)}if(null===b)throw new w(b);return me(a,G(new H,b.h(),b.j()))}
+function LE(a,b,c){if(a.sb)a=a.vb;else{if(null===a)throw le();a=a.sb?a.vb:me(a,(b.sb?b.vb:JE(b,c)).h())}return a}function ME(a,b,c){if(a.sb)a=a.vb;else{if(null===a)throw le();a=a.sb?a.vb:me(a,(b.sb?b.vb:JE(b,c)).j())}return a}
+var cF=function Uca(a,b,c){if(null!==b){var e=b.Wi,g=b.mj;if(e instanceof z){b=e.z;var h=new $e,k=new $e,l=new $e;c=Uca(a,new NE(e.p,g),c);if(b instanceof OE)return a=b.$x,g=b.Zx,e=PE(),l=ME(l,h,b),l=new EE(g,QE(c,l)),c=g.A(),l.pt.zc(c),l=RE(e,J(new K,[l])),l=new DE(a,l,t().d),b=LE(k,h,b),QE(l,b);if(b instanceof SE)return a=b.Wx,e=TE(PE()),t(),l=ME(l,h,b),l=QE(c,l),l=new DE(a,e,new L(l)),b=LE(k,h,b),QE(l,b);if(b instanceof UE){a=b.Yx;g=b.Xx;var m=b.WA;e=PE();m=PE().vl(m);g=G(new H,g,m);l=ME(l,h,b);
+l=[VE(new FE(g,QE(c,l)),b.Cv())];l=RE(e,J(new K,l));l=new DE(a,l,t().d);b=LE(k,h,b);return QE(l,b)}if(b instanceof WE)return a=b.ev,m=b.dv,g=b.ay,e=PE(),m=new vl("Tuple#"+m),g=PE().vl(g),g=G(new H,m,g),l=ME(l,h,b),l=[VE(new FE(g,QE(c,l)),b.Cv())],l=RE(e,J(new K,l)),l=new DE(a,l,t().d),b=LE(k,h,b),QE(l,b);if(b instanceof XE)return c=new CE(b.Vx,c,IE()),k=LE(k,h,b),k=QE(c,k),b=ME(l,h,b),QE(k,b);if(b instanceof YE)return a=b.bv,e=b.cv,b.Ux?(ZE||(ZE=new $E),g=ZE):g=aF(),k=LE(k,h,b),k=QE(c,k),c=new bF(g,
+!1,a,e),a=O().c,k=QE(k,new z(c,a)),b=ME(l,h,b),QE(k,b);throw new w(b);}}if(null!==b&&(k=b.Wi,h=b.mj,l=O().c,null===l?null===k:l.i(k)))return b=new HE(c),QE(b,h);throw new w(b);};function dF(){}dF.prototype=new p;dF.prototype.constructor=dF;function eF(a,b){var c=TE(PE());Tca(a,b,0,c);return c.ha()}dF.prototype.$classData=q({X_:0},!1,"mlscript.ucs.MutCaseOf$",{X_:1,g:1});var fF;function gF(){fF||(fF=new dF);return fF}function hF(){this.pt=null}hF.prototype=new p;hF.prototype.constructor=hF;
+function iF(){}iF.prototype=hF.prototype;function VE(a,b){a.pt.zc(b);return a}function jF(){}jF.prototype=new p;jF.prototype.constructor=jF;function kF(){}kF.prototype=jF.prototype;function lF(a,b){for(b=b.m();b.s();){var c=b.t();a.fv.L(c)||(a.fv.$(c),a.ni.$(c))}}function QE(a,b){lF(a,b);return a}
+var mF=function Vca(a,b,c,d){for(;;){var g=b;b=O().c;if(null===b?null===g:b.i(g))return d;if(g instanceof z){var h=g;b=h.z;h=h.p;if(null!==b){g=b.ZA;var k=b.Sj;b=b.gr;if(c.L(k)){b=h;continue}else return new Rl(g,k,b,Vca(a,h,c.bc(k),d))}}throw new w(g);}};function nF(){}nF.prototype=new p;nF.prototype.constructor=nF;function oF(a){var b=t().d;a=new sm(tm().Cg,a);b=G(new H,b,a);a=O().c;return new Gl(new z(b,a))}
+function pF(a,b,c,d,e){return e?(eu(),new Pl(c,fu(0,J(new K,[b,d])))):new Pl(new Pl(c,oF(b)),oF(d))}
+function qF(a,b){var c=!1,d=null;if(b instanceof Pl){c=!0;d=b;var e=d.Za,g=d.Qb;if(e instanceof Pl){var h=e.Za;e=e.Qb;if(h instanceof vl&&"and"===h.x&&e instanceof Gl&&(e=e.Ra,e instanceof z&&(h=e.z,e=e.p,null!==h&&(h=new L(h),!h.b()&&(h=h.k.j(),null!==h))))){h=h.ya;var k=O().c;if((null===k?null===e:k.i(e))&&g instanceof Gl&&(g=g.Ra,g instanceof z&&(e=g.z,g=g.p,null!==e&&(e=new L(e),!e.b()&&(e=e.k.j(),null!==e&&(e=e.ya,k=O().c,null===k?null===g:k.i(g)))))))return a=qF(a,h),Xq(a,e)}}}if(c&&(c=d.Za,
+d=d.Qb,c instanceof vl&&"and"===c.x&&null!==d&&(d=mz(eu(),d),!d.b()&&null!==d.o()&&0===d.o().ab(2))))return b=d.o(),b=eB(b,0),d=d.o(),d=eB(d,1),a=qF(a,b),Xq(a,d);a=O().c;return new z(b,a)}
+function rF(a,b,c){var d=!1,e=null;if(b instanceof Pl){d=!0;e=b;var g=e.Za,h=e.Qb;if(g instanceof Pl){var k=g.Za;g=g.Qb;if(k instanceof vl&&"and"===k.x&&g instanceof Gl){var l=g.Ra;if(l instanceof z&&(g=l.z,l=l.p,null!==g&&(g=new L(g),!g.b()&&(g=g.k.j(),null!==g)))){g=g.ya;var m=O().c;if((null===m?null===l:m.i(l))&&h instanceof Gl&&(l=h.Ra,l instanceof z&&(h=l.z,l=l.p,null!==h&&(h=new L(h),!h.b()&&(h=h.k.j(),null!==h&&(h=h.ya,m=O().c,null===m?null===l:m.i(l))))))){a=rF(a,g,c);if(null!==a&&(b=a.h(),
+e=a.j(),t().d===e))return G(new H,b,(t(),new L(h)));if(null!==a&&(b=a.h(),e=a.j(),e instanceof L))return a=e.k,t(),c=pF(0,a,k,h,c),G(new H,b,new L(c));throw new w(a);}}}}}if(d&&(k=e.Za,e=e.Qb,k instanceof vl&&"and"===k.x&&null!==e&&(e=mz(eu(),e),!e.b()&&null!==e.o()&&0===e.o().ab(2)))){b=e.o();d=eB(b,0);b=e.o();b=eB(b,1);a=rF(a,d,c);if(null!==a&&(e=a.h(),d=a.j(),t().d===d))return G(new H,e,(t(),new L(b)));if(null!==a&&(e=a.h(),d=a.j(),d instanceof L))return a=d.k,t(),c=pF(0,a,k,b,c),G(new H,e,new L(c));
+throw new w(a);}return G(new H,b,t().d)}nF.prototype.$classData=q({j0:0},!1,"mlscript.ucs.helpers$",{j0:1,g:1});var sF;function tF(){sF||(sF=new nF);return sF}q({k0:0},!1,"mlscript.utils.algorithms$",{k0:1,g:1});function uF(){}uF.prototype=new p;uF.prototype.constructor=uF;
+function Wca(a,b,c,d){a=G(new H,b,c);c=a.y;b=a.w;if(c instanceof L&&(c=c.k,b instanceof L))return a=d.ba(c,b.k),it().n(a);d=a.y;if(d instanceof L)return d;d=a.w;if(d instanceof L)return d;d=a.y;b=a.w;if(R()===d&&R()===b)return R();throw new w(a);}function vF(){wF();throw RD("please add this rare case to test files");}function xm(a){wF();var b=new xF;yF(b,"Internal Error: "+a,null,!0);throw b;}uF.prototype.$classData=q({m0:0},!1,"mlscript.utils.package$",{m0:1,g:1});var zF;
+function wF(){zF||(zF=new uF);return zF}function E(a){this.gv=a}E.prototype=new p;E.prototype.constructor=E;function Pe(a,b){a=a.gv;return ml(nl(),a,b)}function Nm(a,b){a=a.gv;return!ml(nl(),a,b)}function Ot(a,b){return Object.is(a.gv,b)}function dx(a,b){return!Object.is(a.gv,b)}function Lf(a,b){a=a.gv;return ml(nl(),a,b)}function Xca(a,b){return!!b.n(a.gv)}function Yca(a,b){return b.qo(new y(c=>Pe(new E(c),a.gv)))}E.prototype.$classData=q({n0:0},!1,"mlscript.utils.package$AnyOps",{n0:1,g:1});
+function AF(){}AF.prototype=new p;AF.prototype.constructor=AF;function BF(a,b){a=b.m();return a.s()?ze(a,"[",", ","]"):""}function CF(a,b){a=b.m();a=new Ef(a,new y(c=>{ve();c=nb(c);var d=ue(ve(),c);c=new DF;for(d=sl(d).m();d.s();){var e=d.t();EF(c,"\t"+e)}return"\n"+ze(c.lk,"","\n","")}));return ze(a,"","","")}AF.prototype.$classData=q({o0:0},!1,"mlscript.utils.package$IterableOps$",{o0:1,g:1});var FF;function GF(){FF||(FF=new AF);return FF}function yt(a){this.mJ=a}yt.prototype=new p;
+yt.prototype.constructor=yt;function HF(a){var b=Zca(),c=a.mJ;a=O().c;for(c=Km(c);!c.b();){var d=c.e();a=a.b()||!b.ba(a.e(),d)?new z(d,a):a;c=c.f()}return a}function Zca(){return new fn((a,b)=>Pe(new E(a),b))}function hba(a){if(a.mJ.b())return t().d;t();a=a.mJ.f();return new L(a)}yt.prototype.$classData=q({p0:0},!1,"mlscript.utils.package$ListHelpers",{p0:1,g:1});function zB(a){this.en=a}zB.prototype=new p;zB.prototype.constructor=zB;
+zB.prototype.$classData=q({q0:0},!1,"mlscript.utils.package$MutSetHelpers",{q0:1,g:1});function Dx(a){this.wF=a}Dx.prototype=new p;Dx.prototype.constructor=Dx;Dx.prototype.$classData=q({r0:0},!1,"mlscript.utils.package$OptionHelpers",{r0:1,g:1});function IF(){}IF.prototype=new p;IF.prototype.constructor=IF;function JF(a,b,c){a=$ca(lv(),b,c);Od();return Pd(u(),a)}function ry(a,b,c){a=KF(lv(),b,c);Od();return Pd(u(),a)}
+function $ca(a,b,c){a=b.m();return new Ef(a,new y(d=>{var e=c.n(d.h());return G(new H,e,d.j())}))}function KF(a,b,c){a=b.m();return new Ef(a,new y(d=>{var e=d.h();d=c.n(d.j());return G(new H,e,d)}))}function dy(a,b){a=b.m();return new Ef(a,new y(c=>c.h()))}function mv(a,b){a=b.m();return new Ef(a,new y(c=>c.j()))}IF.prototype.$classData=q({s0:0},!1,"mlscript.utils.package$PairIterableOps$",{s0:1,g:1});var LF;function lv(){LF||(LF=new IF);return LF}function gq(a){return MF(NF(new OF,a))}
+q({t0:0},!1,"mlscript.utils.package$SetObjectHelpers",{t0:1,g:1});function $v(a,b){return sv().Dv(b).$(a).Kb()}q({u0:0},!1,"mlscript.utils.package$SortedMapObjectHelpers",{u0:1,g:1});function vv(a,b){return uv().GB(b).$(a).Kb()}q({v0:0},!1,"mlscript.utils.package$SortedSetObjectHelpers",{v0:1,g:1});function PF(){}PF.prototype=new p;PF.prototype.constructor=PF;
+function ue(a,b){QF();a=[ce()];a=J(new K,a);a=RF(a);for(var c=b.length,d=0;d<c;){var e=b.charCodeAt(d);if(Pe(new E(hc(e)),hc(10))){var g=ce();ol(a,g)}else g=SF(a).yf,e=String.fromCharCode(e),g.ja=""+g.ja+e;d=1+d|0}b=new DF;for(a=sl(a).m();a.s();)c=a.t().yf.ja,EF(b,c);return b.lk}
+function ada(a){var b=ue(ve(),a);Od();var c=Pd(u(),b);if(c instanceof z){b=c.z;var d=c.p;if(d instanceof z){if(d===u())a=u();else for(c=a=new z("  "+d.z,u()),d=d.p;d!==u();){var e=d.e();e=new z("  "+e,u());c=c.p=e;d=d.f()}return b+"\n"+ze(a,"","\n","")}}return a}function hB(a,b){return""!==b?(a=Hu(Q(),b),TF(Pr(),a)):!1}function UF(a,b){Pe(new E(b.length),0)?a=!0:(a=b.charCodeAt(0),a=!TF(Pr(),a));if(a)return b;Q();a=b.charCodeAt(0);Pr();a=65535&bda(a);return VF(b,a)}
+function WF(a,b,c,d){return 1<c?b+(d?"es":"s"):b}PF.prototype.$classData=q({w0:0},!1,"mlscript.utils.package$StringOps$",{w0:1,g:1});var XF;function ve(){XF||(XF=new PF);return XF}function YF(){this.d=null;ZF=this;O();O();ju();$F||($F=new aG);this.d=R();O();O();O()}YF.prototype=new p;YF.prototype.constructor=YF;function it(){t();return new y(a=>new L(a))}YF.prototype.$classData=q({x0:0},!1,"mlscript.utils.shorthands$",{x0:1,g:1});var ZF;function t(){ZF||(ZF=new YF);return ZF}
+function ma(a,b){this.W=a;this.Y=b}ma.prototype=new p;ma.prototype.constructor=ma;f=ma.prototype;f.i=function(a){return a instanceof ma?this.W===a.W&&this.Y===a.Y:!1};f.B=function(){return this.W^this.Y};f.u=function(){return bG(xa(),this.W,this.Y)};f.jB=function(){return this.W<<24>>24};f.EC=function(){return this.W<<16>>16};f.Zi=function(){return this.W};f.xl=function(){return Za(this)};
+f.pv=function(){xa();var a=this.W,b=this.Y;if(0>b){var c=-a|0;a=0!==a?~b:-b|0}else c=a,a=b;c=4294967296*+(a>>>0)+ +((0===(-2097152&a)||0===(65535&c)?c:32768|-65536&c)>>>0);return Math.fround(0>b?-c:c)};f.Lp=function(){return cG(xa(),this.W,this.Y)};f.sl=function(a){return ua(xa(),this.W,this.Y,a.W,a.Y)};f.$classData=q({B0:0},!1,"org.scalajs.linker.runtime.RuntimeLong",{B0:1,g:1});function dG(a,b,c){return 0===(-2097152&c)?""+(4294967296*c+ +(b>>>0)):eG(a,b,c,1E9,0,2)}
+function fG(a,b,c,d,e){return 0===(-2097152&c)?0===(-2097152&e)?(c=(4294967296*c+ +(b>>>0))/(4294967296*e+ +(d>>>0)),a.Qc=c/4294967296|0,c|0):a.Qc=0:0===e&&0===(d&(-1+d|0))?(d=31-Math.clz32(d)|0,a.Qc=c>>>d|0,b>>>d|0|c<<1<<(31-d|0)):0===d&&0===(e&(-1+e|0))?(b=31-Math.clz32(e)|0,a.Qc=0,c>>>b|0):eG(a,b,c,d,e,0)|0}
+function eG(a,b,c,d,e,g){var h=(0!==e?Math.clz32(e):32+Math.clz32(d)|0)-(0!==c?Math.clz32(c):32+Math.clz32(b)|0)|0,k=h,l=0===(32&k)?d<<k:0,m=0===(32&k)?(d>>>1|0)>>>(31-k|0)|0|e<<k:d<<k;k=b;var n=c;for(b=c=0;0<=h&&0!==(-2097152&n);){var r=k,v=n,x=l,A=m;if(v===A?(-2147483648^r)>=(-2147483648^x):(-2147483648^v)>=(-2147483648^A))r=n,v=m,n=k-l|0,r=(-2147483648^n)>(-2147483648^k)?-1+(r-v|0)|0:r-v|0,k=n,n=r,32>h?c|=1<<h:b|=1<<h;h=-1+h|0;r=m>>>1|0;l=l>>>1|0|m<<31;m=r}h=n;if(h===e?(-2147483648^k)>=(-2147483648^
+d):(-2147483648^h)>=(-2147483648^e))h=4294967296*n+ +(k>>>0),d=4294967296*e+ +(d>>>0),1!==g&&(m=h/d,e=m/4294967296|0,l=c,c=m=l+(m|0)|0,b=(-2147483648^m)<(-2147483648^l)?1+(b+e|0)|0:b+e|0),0!==g&&(d=h%d,k=d|0,n=d/4294967296|0);if(0===g)return a.Qc=b,c;if(1===g)return a.Qc=n,k;a=""+k;return""+(4294967296*b+ +(c>>>0))+"000000000".substring(a.length)+a}function gG(){this.Qc=0}gG.prototype=new p;gG.prototype.constructor=gG;
+function bG(a,b,c){return c===b>>31?""+b:0>c?"-"+dG(a,-b|0,0!==b?~c:-c|0):dG(a,b,c)}function cG(a,b,c){return 0>c?-(4294967296*+((0!==b?~c:-c|0)>>>0)+ +((-b|0)>>>0)):4294967296*c+ +(b>>>0)}function ua(a,b,c,d,e){return c===e?b===d?0:(-2147483648^b)<(-2147483648^d)?-1:1:c<e?-1:1}
+function $h(a,b,c,d,e){if(0===(d|e))throw new qb("/ by zero");if(c===b>>31){if(e===d>>31){if(-2147483648===b&&-1===d)return a.Qc=0,-2147483648;c=pb(b,d);a.Qc=c>>31;return c}return-2147483648===b&&-2147483648===d&&0===e?a.Qc=-1:a.Qc=0}if(0>c){var g=-b|0;b=0!==b?~c:-c|0}else g=b,b=c;if(0>e){var h=-d|0;d=0!==d?~e:-e|0}else h=d,d=e;g=fG(a,g,b,h,d);if(0<=(c^e))return g;c=a.Qc;a.Qc=0!==g?~c:-c|0;return-g|0}
+function Wh(a,b,c,d,e){if(0===(d|e))throw new qb("/ by zero");return 0===c?0===e?(a.Qc=0,0===d?pb(0,0):+(b>>>0)/+(d>>>0)|0):a.Qc=0:fG(a,b,c,d,e)}
+function Ri(a,b,c,d,e){if(0===(d|e))throw new qb("/ by zero");if(c===b>>31){if(e===d>>31)return-1!==d?(c=Bb(b,d),a.Qc=c>>31,c):a.Qc=0;if(-2147483648===b&&-2147483648===d&&0===e)return a.Qc=0;a.Qc=c;return b}if(0>c)var g=-b|0,h=0!==b?~c:-c|0;else g=b,h=c;0>e?(b=-d|0,d=0!==d?~e:-e|0):(b=d,d=e);0===(-2097152&h)?0===(-2097152&d)?(b=(4294967296*h+ +(g>>>0))%(4294967296*d+ +(b>>>0)),a.Qc=b/4294967296|0,b|=0):(a.Qc=h,b=g):0===d&&0===(b&(-1+b|0))?(a.Qc=0,b=g&(-1+b|0)):0===b&&0===(d&(-1+d|0))?(a.Qc=h&(-1+
+d|0),b=g):b=eG(a,g,h,b,d,1)|0;return 0>c?(c=a.Qc,a.Qc=0!==b?~c:-c|0,-b|0):b}gG.prototype.$classData=q({C0:0},!1,"org.scalajs.linker.runtime.RuntimeLong$",{C0:1,g:1});var hG;function xa(){hG||(hG=new gG);return hG}function iG(){this.EK=this.KB=null;jG=this;this.KB=new Xc(0);this.EK=new zc(0)}iG.prototype=new p;iG.prototype.constructor=iG;iG.prototype.$classData=q({X2:0},!1,"scala.Array$EmptyArrays$",{X2:1,g:1});var jG;function kG(){jG||(jG=new iG);return jG}function lG(){}lG.prototype=new p;
+lG.prototype.constructor=lG;function mG(){}mG.prototype=lG.prototype;function dD(a,b){this.lR=null;this.e3=b;if(null===a)throw null;this.lR=a}dD.prototype=new p;dD.prototype.constructor=dD;dD.prototype.$classData=q({d3:0},!1,"scala.Option$WithFilter",{d3:1,g:1});function nG(){this.nR=this.Hv=null;oG=this;this.Hv=new y(()=>pG().Hv);this.nR=new qG}nG.prototype=new p;nG.prototype.constructor=nG;function rG(a,b){return a.Hv===b}nG.prototype.$classData=q({f3:0},!1,"scala.PartialFunction$",{f3:1,g:1});
+var oG;function pG(){oG||(oG=new nG);return oG}function sG(){}sG.prototype=new p;sG.prototype.constructor=sG;function cda(a,b){up(tp(),b);return a}sG.prototype.$classData=q({m3:0},!1,"scala.Predef$Ensuring$",{m3:1,g:1});var tG;function uG(a){this.oR=null;if(null===a)throw null;this.oR=a}uG.prototype=new p;uG.prototype.constructor=uG;function dda(a,b){return eda(Qq(),a.oR.Jv,b)}uG.prototype.$classData=q({t3:0},!1,"scala.StringContext$s$",{t3:1,g:1});function vG(){}vG.prototype=new p;
+vG.prototype.constructor=vG;
+function ns(a,b,c,d){a=0<c?c:0;c=wG(xG(),b);d=d<c?d:c;if(d>a){if(b instanceof zc)return Jj(Pj(),b,a,d);if(b instanceof Xc){Pj();if(a>d)throw Kj(a+" \x3e "+d);d=d-a|0;c=b.a.length-a|0;c=d<c?d:c;d=new Xc(d);b.wa(a,d,0,c);return d}if(b instanceof ed){Pj();if(a>d)throw Kj(a+" \x3e "+d);d=d-a|0;c=b.a.length-a|0;c=d<c?d:c;d=new ed(d);b.wa(a,d,0,c);return d}if(b instanceof Zc){Pj();if(a>d)throw Kj(a+" \x3e "+d);d=d-a|0;c=b.a.length-a|0;c=d<c?d:c;d=new Zc(d);b.wa(a,d,0,c);return d}if(b instanceof $c){Pj();
+if(a>d)throw Kj(a+" \x3e "+d);d=d-a|0;c=b.a.length-a|0;c=d<c?d:c;d=new $c(d);b.wa(a,d,0,c);return d}if(b instanceof Ic){Pj();if(a>d)throw Kj(a+" \x3e "+d);d=d-a|0;c=b.a.length-a|0;c=d<c?d:c;d=new Ic(d);b.wa(a,d,0,c);return d}if(b instanceof Pc){Pj();if(a>d)throw Kj(a+" \x3e "+d);d=d-a|0;c=b.a.length-a|0;c=d<c?d:c;d=new Pc(d);b.wa(a,d,0,c);return d}if(b instanceof Sc){Pj();if(a>d)throw Kj(a+" \x3e "+d);d=d-a|0;c=b.a.length-a|0;c=d<c?d:c;d=new Sc(d);b.wa(a,d,0,c);return d}if(b instanceof Ec){Pj();if(a>
+d)throw Kj(a+" \x3e "+d);d=d-a|0;c=b.a.length-a|0;c=d<c?d:c;d=new Ec(d);b.wa(a,d,0,c);return d}throw new w(b);}return yG(zG(),bg(ca(b))).si(0)}function ls(a,b,c){return ns(ms(),b,c,wG(xG(),b))}
+function AG(a){if(a instanceof zc)return Du(new Eu,a);if(a instanceof Xc)return new BG(a);if(a instanceof ed)return new CG(a);if(a instanceof Zc)return new DG(a);if(a instanceof $c)return new EG(a);if(a instanceof Ic)return new FG(a);if(a instanceof Pc)return new GG(a);if(a instanceof Sc)return new HG(a);if(a instanceof Ec)return new IG(a);if(ph(a))return new JG(a);if(null===a)throw le();throw new w(a);}
+function Tu(a,b){var c=wG(xG(),a);if(1>=c)return KG(xG(),a);if(a instanceof zc)return c=zj(Pj(),a,c),hj(Pj(),c,b),c;if(a instanceof Xc){if(b===Fq())return c=Fj(Pj(),a,c),Ti(Pj(),c),c}else if(a instanceof Zc){if(b===LG())return c=Gj(Pj(),a,c),$i(Pj(),c),c}else if(a instanceof Ic){if(b===MG())return c=Hj(Pj(),a,c),dj(Pj(),c),c}else if(a instanceof Pc){if(b===NG())return c=Dj(Pj(),a,c),fj(Pj(),c),c}else if(a instanceof Sc){if(b===OG())return c=Ej(Pj(),a,c),bj(Pj(),c),c}else if(a instanceof Ec&&b===PG()){c=
+Ij(Pj(),a,c);var d=QG();b=PG();RG(d,c,c.a.length,b);return c}300>c?(c=KG(xG(),a),RG(QG(),c,wG(xG(),c),b)):(SG(),TG(),Zf(da(jd),bg(ca(a)))?d=Yf(da(jd))?UG(a,c):Cj(Pj(),a,c,da(md(jd))):(d=new zc(c),VG(SG(),a,0,d,0,wG(xG(),a))),hj(Pj(),d,b),SG(),b=yG(zG(),bg(ca(a))),a=b.uh(),null!==a&&a===da(pd)?c=WG(c):Zf(a,bg(ca(d)))?Yf(a)?c=UG(d,c):(b=rh(th(),a,0),b=ca(b),c=Cj(Pj(),d,c,b)):(c=b.si(c),VG(SG(),d,0,c,0,wG(xG(),d))));return c}
+function lB(a,b,c){if(null===a)throw le();if(a instanceof zc){for(var d=wG(xG(),a),e=0;e<d;)b=c.ba(b,XG(xG(),a,e)),e=1+e|0;return b}if(a instanceof Xc){d=a.a.length;for(e=0;e<d;)b=c.ba(b,a.a[e]),e=1+e|0;return b}if(a instanceof ed){d=a.a.length;for(e=0;e<d;)b=c.ba(b,a.a[e]),e=1+e|0;return b}if(a instanceof Zc){d=a.a.length;for(e=0;e<d;)b=c.ba(b,a.a[e]),e=1+e|0;return b}if(a instanceof $c){d=a.a.length;for(e=0;e<d;)b=c.ba(b,a.a[e]),e=1+e|0;return b}if(a instanceof Ic){d=a.a.length;for(e=0;e<d;)b=c.ba(b,
+hc(a.a[e])),e=1+e|0;return b}if(a instanceof Pc){d=a.a.length;for(e=0;e<d;)b=c.ba(b,a.a[e]),e=1+e|0;return b}if(a instanceof Sc){d=a.a.length;for(e=0;e<d;)b=c.ba(b,a.a[e]),e=1+e|0;return b}if(a instanceof Ec){d=a.a.length;for(e=0;e<d;)b=c.ba(b,a.a[e]),e=1+e|0;return b}if(ph(a)){d=a.a.length;for(e=0;e<d;)b=c.ba(b,a.a[e]),e=1+e|0;return b}throw new w(a);}vG.prototype.$classData=q({y4:0},!1,"scala.collection.ArrayOps$",{y4:1,g:1});var YG;function ms(){YG||(YG=new vG);return YG}function ZG(){}
+ZG.prototype=new p;ZG.prototype.constructor=ZG;function $G(a,b){a=b+~(b<<9)|0;a^=a>>>14|0;a=a+(a<<4)|0;return a^(a>>>10|0)}ZG.prototype.$classData=q({W4:0},!1,"scala.collection.Hashing$",{W4:1,g:1});var aH;function bH(){aH||(aH=new ZG);return aH}function cH(a,b){for(a=a.m();a.s();)b.n(a.t())}function nw(a,b){var c=!0;for(a=a.m();c&&a.s();)c=!!b.n(a.t());return c}function ey(a,b){var c=!1;for(a=a.m();!c&&a.s();)c=!!b.n(a.t());return c}
+function dH(a,b){for(a=a.m();a.s();){var c=a.t();if(b.n(c))return new L(c)}return R()}function mB(a,b,c){for(a=a.m();a.s();)b=c.ba(b,a.t());return b}function Qu(a,b,c){return a.ad().De(b,new fn((d,e)=>c.ba(e,d)))}function eH(a,b){a=a.m();if(!a.s())throw nv("empty.reduceLeft");for(var c=!0,d=null;a.s();){var e=a.t();c?(d=e,c=!1):d=b.ba(d,e)}return d}function kba(a,b){if(!a.m().s())throw nv("empty.reduceRight");return a.ad().th(new fn((c,d)=>b.ba(d,c)))}
+function Qba(a,b){return a.b()?R():new L(a.th(b))}function hs(a){if(0<=a.Q())return a.Q();a=a.m();for(var b=0;a.s();)b=1+b|0,a.t();return b}function NB(a,b,c,d){a=a.m();var e=c,g=wG(xG(),b)-c|0;for(d=c+(d<g?d:g)|0;e<d&&a.s();)fH(xG(),b,e,a.t()),e=1+e|0;return e-c|0}function fda(a){return a.b()?0:a.th(new fn((b,c)=>(b|0)+(c|0)|0))}function gH(a,b){if(a.b())throw nv("empty.min");return a.th(new fn((c,d)=>b.Kk(c,d)))}function Gq(a,b){return a.b()?R():new L(a.aj(b))}
+function hH(a,b){if(a.b())throw nv("empty.max");return a.th(new fn((c,d)=>b.Jk(c,d)))}function Jq(a,b){return a.b()?R():new L(a.$i(b))}function gda(a,b,c){if(a.b())throw nv("empty.maxBy");var d=new aw(null),e=new aw(null),g=new GA(!0);a.Ca(new y(h=>{var k=b.n(h);if(g.Am||c.Xj(k,d.rc))e.rc=h,d.rc=k,g.Am=!1}));return e.rc}function vca(a,b,c){return a.b()?R():new L(gda(a,b,c))}function ze(a,b,c,d){return a.b()?""+b+d:a.Gh(ce(),b,c,d).yf.ja}
+function iH(a,b,c,d,e){var g=b.yf;0!==c.length&&(g.ja=""+g.ja+c);a=a.m();if(a.s())for(c=a.t(),g.ja=""+g.ja+c;a.s();)g.ja=""+g.ja+d,c=a.t(),g.ja=""+g.ja+c;0!==e.length&&(g.ja=""+g.ja+e);return b}function kB(a,b){if(0<=a.Q())return b=b.si(a.Q()),a.Gc(b,0,2147483647),b;var c=b.uh(),d=c===da(td);b=[];for(a=a.m();a.s();){var e=a.t();b.push(d?Ea(e):null===e?c.qi.jz:e)}return md((c===da(pd)?da(la):c===da(jH)||c===da(kH)?da(jd):c).qi).iz(b)}
+function er(a){var b=u();for(a=a.m();a.s();){var c=a.t();b=new z(c,b)}return b}function lH(a,b){this.v5=a;this.AG=b}lH.prototype=new p;lH.prototype.constructor=lH;lH.prototype.$classData=q({u5:0},!1,"scala.collection.Iterator$ConcatIteratorCell",{u5:1,g:1});function Wq(a,b,c){this.iL=a;this.ck=b;this.dk=c}Wq.prototype=new p;Wq.prototype.constructor=Wq;function qD(a,b){return new mH(a.iL,a.ck,a.dk,b)}function Ew(a,b){b=new nH(a,b);return a.iL.Ub().Ib(b)}
+function Zq(a,b){b=new oH(a,b);return a.iL.Ub().Ib(b)}function pH(a,b){var c=a.ck.m();for(a=a.dk.m();c.s()&&a.s();)b.ba(c.t(),a.t())}function qH(a){var b=a.ck.Q();if(0===b)return 0;a=a.dk.Q();return 0===a?0:b<a?b:a}Wq.prototype.u=function(){return this.ck+".lazyZip("+this.dk+")"};Wq.prototype.$classData=q({z5:0},!1,"scala.collection.LazyZip2",{z5:1,g:1});function mH(a,b,c,d){this.jL=b;this.kL=c;this.lL=d}mH.prototype=new p;mH.prototype.constructor=mH;
+function rH(a,b){var c=a.jL.m(),d=a.kL.m();for(a=a.lL.m();c.s()&&d.s()&&a.s();){var e=c.t(),g=d.t(),h=a.t();(0,b.aM)(e,g,h)}}mH.prototype.u=function(){return this.jL+".lazyZip("+this.kL+").lazyZip("+this.lL+")"};mH.prototype.$classData=q({G5:0},!1,"scala.collection.LazyZip3",{G5:1,g:1});function sH(){}sH.prototype=new p;sH.prototype.constructor=sH;
+function VF(a,b){var c=Cu(a.length);c.ja=""+c.ja+a;a=c.ja;if(0>=a.length)throw b=new tH,yF(b,"String index out of range: 0",null,!0),b;c.ja=""+a.substring(0,0)+hc(b)+a.substring(1);return c.ja}function uH(a,b,c){return 0<=vH(b,c)}function Of(a,b,c,d){a=0<c?c:0;c=b.length;d=d<c?d:c;return a>=d?"":b.substring(a,d)}function ut(a,b,c){if(0>=c)return"";a=Cu(Math.imul(b.length,c));for(var d=0;d<c;)a.ja=""+a.ja+b,d=1+d|0;return a.ja}
+function Nu(a,b){null===b||0===b.length?a=!0:(a=b.charCodeAt(0),a=!bE(Pr(),a));if(a)return b;Q();a=b.charCodeAt(0);Pr();a=65535&hda(a);return VF(b,a)}function zf(a){return"\n"===a.substring(a.length-1|0)?a.substring(0,a.length-1|0):a}function he(a){Q();var b=Cu(a.length);for(a=new wH(a,!1);a.cj<a.Jy;){for(var c=xH(a),d=c.length,e=0;;)if(e<d&&32>=c.charCodeAt(e))e=1+e|0;else break;c=e<d&&124===c.charCodeAt(e)?c.substring(1+e|0):c;b.ja=""+b.ja+c}return b.ja}
+function ida(a,b){a=b.Ja(new y(c=>{Q();return c instanceof yH?c.qT():c})).Bj(TG());return jda(zH(),a)}function Hu(a,b){if(""===b)throw AH("head of empty String");return b.charCodeAt(0)}function Xz(a,b){return""===b?R():new L(hc(b.charCodeAt(0)))}function Iu(a,b){if(""===b)throw AH("last of empty String");return b.charCodeAt(-1+b.length|0)}function ys(a,b,c){Q();a=b.length;return Of(0,b,c<a?c:a,b.length)}function $aa(a,b){Q();a=b.length-2|0;Q();var c=b.length;return Of(0,b,0,a<c?a:c)}
+function kda(a,b,c){a:{Q();a=b.length;for(var d=0;d<a;){if(c.n(hc(b.charCodeAt(d)))){b=d;break a}d=1+d|0}b=-1}return-1!==b}function gca(a,b){a:{for(var c=a.length,d=0;d<c;){var e=a.charCodeAt(d);if(!b.n(hc(e))){b=d;break a}d=1+d|0}b=-1}return-1===b?a:a.substring(0,b)}sH.prototype.$classData=q({k6:0},!1,"scala.collection.StringOps$",{k6:1,g:1});var BH;function Q(){BH||(BH=new sH);return BH}
+function CH(a,b,c,d){for(var e=1;;){if(e===c)return b?-2147483648===a?R():new L(-a|0):new L(a);if(-214748364>a)return R();var g=d.charCodeAt(e);g=DH(Pr(),g,10);if(-1===g||-214748364===a&&9===g)return R();e=1+e|0;a=Math.imul(10,a)-g|0}}function EH(){}EH.prototype=new p;EH.prototype.constructor=EH;function $D(a,b){a=b.length;if(0===a)return R();var c=b.charCodeAt(0),d=DH(Pr(),c,10);return 1===a?-1<d?new L(d):R():-1<d?CH(-d|0,!0,a,b):43===c?CH(0,!0,a,b):45===c?CH(0,!1,a,b):R()}
+EH.prototype.$classData=q({p6:0},!1,"scala.collection.StringParsers$",{p6:1,g:1});var FH;function aE(){FH||(FH=new EH);return FH}function GH(a,b){null===a.Ok&&(a.Ok=new Xc(HH().mC<<1),a.Do=new (md(IH).Ia)(HH().mC));a.vi=1+a.vi|0;var c=a.vi<<1,d=1+(a.vi<<1)|0;a.Do.a[a.vi]=b;a.Ok.a[c]=0;a.Ok.a[d]=b.HB()}function JH(a,b){a.Nc=0;a.wn=0;a.vi=-1;b.nB()&&GH(a,b);b.jy()&&(a.wh=b,a.Nc=0,a.wn=b.uy())}function KH(){this.wn=this.Nc=0;this.wh=null;this.vi=0;this.Do=this.Ok=null}KH.prototype=new p;
+KH.prototype.constructor=KH;function LH(){}LH.prototype=KH.prototype;KH.prototype.s=function(){var a;if(!(a=this.Nc<this.wn))a:{for(;0<=this.vi;){a=this.vi<<1;var b=this.Ok.a[a];if(b<this.Ok.a[1+(this.vi<<1)|0]){var c=this.Ok;c.a[a]=1+c.a[a]|0;a=this.Do.a[this.vi].mB(b);a.nB()&&GH(this,a);if(a.jy()){this.wh=a;this.Nc=0;this.wn=a.uy();a=!0;break a}}else this.vi=-1+this.vi|0}a=!1}return a};function MH(a,b){a.Pk=1+a.Pk|0;a.Xv.a[a.Pk]=b;a.Wv.a[a.Pk]=-1+b.HB()|0}
+function NH(a){for(;0<=a.Pk;){var b=a.Wv.a[a.Pk];a.Wv.a[a.Pk]=-1+b|0;if(0<=b)b=a.Xv.a[a.Pk].mB(b),MH(a,b);else if(b=a.Xv.a[a.Pk],a.Pk=-1+a.Pk|0,b.jy())return a.Ut=b,a.gk=-1+b.uy()|0,!0}return!1}function OH(a,b){a.gk=-1;a.Pk=-1;a.Wv=new Xc(1+HH().mC|0);a.Xv=new (md(IH).Ia)(1+HH().mC|0);MH(a,b);NH(a)}function PH(){this.gk=0;this.Ut=null;this.Pk=0;this.Xv=this.Wv=null}PH.prototype=new p;PH.prototype.constructor=PH;function QH(){}QH.prototype=PH.prototype;
+PH.prototype.s=function(){return 0<=this.gk||NH(this)};function RH(){this.lS=0;SH=this;try{var a=fh(gh(),"scala.collection.immutable.IndexedSeq.defaultApplyPreferredMaxLength","64");var b=TH(UH(),a,10)}catch(c){throw c;}this.lS=b}RH.prototype=new p;RH.prototype.constructor=RH;RH.prototype.$classData=q({f7:0},!1,"scala.collection.immutable.IndexedSeqDefaults$",{f7:1,g:1});var SH;function VH(){this.HL=null}VH.prototype=new p;VH.prototype.constructor=VH;
+function WH(a){a=a.HL;if(null===a)throw XH("uninitialized");return Es(a)}function YH(a,b){if(null!==a.HL)throw XH("already initialized");a.HL=b}VH.prototype.$classData=q({k7:0},!1,"scala.collection.immutable.LazyList$LazyBuilder$DeferredState",{k7:1,g:1});function ZH(){this.Ty=null;$H=this;this.Ty=new aI(0,0,(IB(),new zc(0)),(rl(),new Xc(0)),0,0)}ZH.prototype=new p;ZH.prototype.constructor=ZH;ZH.prototype.$classData=q({P7:0},!1,"scala.collection.immutable.MapNode$",{P7:1,g:1});var $H;
+function bI(){$H||($H=new ZH);return $H}function cI(a,b){var c=new dI;a=b+" is out of bounds (min 0, max "+(-1+wG(xG(),a)|0);yF(c,a,null,!0);return c}function eI(){}eI.prototype=new p;eI.prototype.constructor=eI;function fI(){}fI.prototype=eI.prototype;function gI(a,b){if(0>b)throw cI(a,b);if(b>(-1+a.a.length|0))throw cI(a,b);var c=new Xc(-1+a.a.length|0);a.wa(0,c,0,b);a.wa(1+b|0,c,b,-1+(a.a.length-b|0)|0);return c}
+function hI(a,b,c){if(0>b)throw cI(a,b);if(b>a.a.length)throw cI(a,b);var d=new Xc(1+a.a.length|0);a.wa(0,d,0,b);d.a[b]=c;a.wa(b,d,1+b|0,a.a.length-b|0);return d}var IH=q({lC:0},!1,"scala.collection.immutable.Node",{lC:1,g:1});eI.prototype.$classData=IH;function iI(){this.mC=0;jI=this;this.mC=Eb(+Math.ceil(6.4))}iI.prototype=new p;iI.prototype.constructor=iI;function kI(a,b,c){return 31&(b>>>c|0)}function lI(a,b){return 1<<b}function mI(a,b,c){a=b&(-1+c|0);return nI(UH(),a)}
+function oI(a,b,c,d){return-1===b?c:mI(0,b,d)}iI.prototype.$classData=q({V7:0},!1,"scala.collection.immutable.Node$",{V7:1,g:1});var jI;function HH(){jI||(jI=new iI);return jI}var mda=function lda(a,b,c){for(;;)if(null!==b.sa&&lda(a,b.sa,c),c.n(G(new H,b.Wa,b.Wb)),null!==b.ta)b=b.ta;else break},oda=function nda(a,b,c){for(;;)if(null!==b.sa&&nda(a,b.sa,c),c.n(b.Wa),null!==b.ta)b=b.ta;else break},qda=function pda(a,b,c){for(;;)if(null!==b.sa&&pda(a,b.sa,c),c.ba(b.Wa,b.Wb),null!==b.ta)b=b.ta;else break};
+function pI(a){return null===a?null:qI(a)}function rI(a,b,c,d,e){return new sI(b,c,d,e,1+((null===d?0:2147483647&d.ea)+(null===e?0:2147483647&e.ea)|0)|0|(a?-2147483648:0))}function tI(a,b){if(a.sa===b)return a;if(0<=b.ea){var c=b.sa,d=b.ta;return null!==c&&0<=c.ea?uI(b,qI(c),vI(a,d)):null!==d&&0<=d.ea?uI(d,wI(b,d.sa),vI(a,d.ta)):xI(a,b)}return xI(a,b)}
+function yI(a,b){if(a.ta===b)return a;if(0<=b.ea){var c=b.sa;if(null!==c&&0<=c.ea)return uI(c,wI(a,c.sa),vI(b,c.ta));var d=b.ta;return null!==d&&0<=d.ea?uI(b,wI(a,c),qI(d)):zI(a,b)}return zI(a,b)}
+var rda=function AI(a,b,c,d,e,g){if(null===b)return BI(c,d,null,null);if(Object.is(c,b.Wa))return e?CI(b,d):b;var k=g.Da(c,b.Wa);return 0>k?tI(b,AI(a,b.sa,c,d,e,g)):0<k?yI(b,AI(a,b.ta,c,d,e,g)):e&&!Object.is(d,b.Wb)?CI(b,d):b},sda=function DI(a,b,c,d,e){if(null===b)return BI(d,e,null,null);var h=1+EI(0,b.sa)|0;return c<h?tI(b,DI(a,b.sa,c,d,e)):c>h?yI(b,DI(a,b.ta,c-h|0,d,e)):b},GI=function tda(a,b,c){for(;;){if(null===b||0>=c)return b;if(c>=(2147483647&b.ea))return null;var e=EI(0,b.sa);if(c>e)c=-1+
+(c-e|0)|0,b=b.ta;else{if(c===e)return FI(a,null,b.Wa,b.Wb,b.ta);c=tda(a,b.sa,c);return FI(a,c,b.Wa,b.Wb,b.ta)}}},HI=function uda(a,b,c){for(;;){if(null===b||0>=c)return null;if(c>=(2147483647&b.ea))return b;var e=EI(0,b.sa);if(c<=e)b=b.sa;else return c===(1+e|0)?(a=sda(a,b.sa,c,b.Wa,b.Wb),null===a||0>a.ea||(b=a.sa,null!==b&&0<=b.ea?b=!0:(b=a.ta,b=null!==b&&0<=b.ea),a=b?qI(a):a)):a=FI(a,b.sa,b.Wa,b.Wb,uda(a,b.ta,-1+(c-e|0)|0)),a}},PI=function II(a,b,c,d){if(null===b)return null;var g=d.Da(c,b.Wa);
+if(0>g){a=II(a,b.sa,c,d);if(a===b.sa)return b;c=b.sa;null!==c&&0>c.ea?b=JI(b,a,b.ta):a===b.sa&&0<=b.ea||(c=b.ta,b=new sI(b.Wa,b.Wb,a,b.ta,1+((null===a?0:2147483647&a.ea)+(null===c?0:2147483647&c.ea)|0)|0));return b}if(0<g){a=II(a,b.ta,c,d);if(a===b.ta)return b;c=b.ta;null!==c&&0>c.ea?(c=b.sa,null!==a&&0<=a.ea?b=KI(b,c,qI(a)):null!==c&&0>c.ea?b=LI(b,MI(c),a):(null!==c&&0<=c.ea?(d=c.ta,d=null!==d&&0>d.ea):d=!1,d?b=KI(c.ta,LI(c,MI(c.sa),c.ta.sa),NI(b,c.ta.ta,a)):(OI(),b=void 0))):a===b.ta&&0<=b.ea||
+(c=b.sa,b=new sI(b.Wa,b.Wb,b.sa,a,1+((null===c?0:2147483647&c.ea)+(null===a?0:2147483647&a.ea)|0)|0));return b}return vda(a,b.sa,b.ta)};
+function LI(a,b,c){if(null!==b&&0<=b.ea){if(null!==c&&0<=c.ea)return KI(a,qI(b),qI(c));var d=b.sa;if(null!==d&&0<=d.ea)return uI(b,qI(b.sa),NI(a,b.ta,c));d=b.ta;return null!==d&&0<=d.ea?uI(b.ta,wI(b,b.ta.sa),NI(a,b.ta.ta,c)):NI(a,b,c)}if(null!==c&&0<=c.ea){d=c.ta;if(null!==d&&0<=d.ea)return uI(c,NI(a,b,c.sa),qI(c.ta));d=c.sa;return null!==d&&0<=d.ea?uI(c.sa,NI(a,b,c.sa.sa),NI(c,c.sa.ta,c.ta)):NI(a,b,c)}return NI(a,b,c)}
+function JI(a,b,c){if(null!==b&&0<=b.ea)return KI(a,qI(b),c);if(null!==c&&0>c.ea)return LI(a,b,MI(c));if(null!==c&&0<=c.ea){var d=c.sa;d=null!==d&&0>d.ea}else d=!1;if(d)return KI(c.sa,NI(a,b,c.sa.sa),LI(c,c.sa.ta,MI(c.ta)));OI()}
+var vda=function QI(a,b,c){return null===b?c:null===c?b:0<=b.ea?0<=c.ea?(a=QI(a,b.ta,c.sa),null!==a&&0<=a.ea?uI(a,zI(b,a.sa),xI(c,a.ta)):zI(b,xI(c,a))):zI(b,QI(a,b.ta,c)):0>c.ea?(a=QI(a,b.ta,c.sa),null!==a&&0<=a.ea?uI(a,zI(b,a.sa),xI(c,a.ta)):JI(b,b.sa,xI(c,a))):xI(c,QI(a,b,c.sa))},xda=function wda(a,b,c,d,e,g,h){if((null===b?0:0>b.ea?(-1+g|0)<<1:-1+(g<<1)|0)===(h/2|0)<<1)return BI(c,d,b,e);var l=null!==b&&0>b.ea;a=wda(a,b.ta,c,d,e,l?-1+g|0:g,h);l&&null!==a&&0<=a.ea?(c=a.ta,c=null!==c&&0<=c.ea):c=
+!1;return c?BI(a.Wa,a.Wb,RI(b.Wa,b.Wb,b.sa,a.sa),qI(a.ta)):rI(l,b.Wa,b.Wb,b.sa,a)},zda=function yda(a,b,c,d,e,g,h){if((null===e?0:0>e.ea?(-1+h|0)<<1:-1+(h<<1)|0)===(g/2|0)<<1)return BI(c,d,b,e);var l=null!==e&&0>e.ea;a=yda(a,b,c,d,e.sa,g,l?-1+h|0:h);l&&null!==a&&0<=a.ea?(b=a.sa,b=null!==b&&0<=b.ea):b=!1;return b?BI(a.Wa,a.Wb,qI(a.sa),RI(e.Wa,e.Wb,a.ta,e.ta)):rI(l,e.Wa,e.Wb,a,e.ta)},TI=function SI(a,b,c,d){if(null===b)return new Gp(null,null,null,c);var g=d.Da(c,b.Wa);if(0===g)return new Gp(b.sa,b,
+b.ta,b.Wa);if(0>g){c=SI(a,b.sa,c,d);if(null===c)throw new w(c);d=c.Xi;return new Gp(c.Uj,c.oj,FI(a,c.oi,b.Wa,b.Wb,b.ta),d)}c=SI(a,b.ta,c,d);if(null===c)throw new w(c);d=c.oj;g=c.oi;var h=c.Xi;return new Gp(FI(a,b.sa,b.Wa,b.Wb,c.Uj),d,g,h)},Bda=function Ada(a,b){if(null===b.ta)return new tl(b.sa,b.Wa,b.Wb);var d=Ada(a,b.ta);if(null===d)throw new w(d);var e=d.hb,g=d.Rd;return new tl(FI(a,b.sa,b.Wa,b.Wb,d.kc),e,g)},Cda=function UI(a,b,c,d){if(null===b||b===c)return c;if(null===c)return b;var g=TI(a,
+b,c.Wa,d);if(null===g)throw new w(g);var h=g.oi;b=g.Xi;g=UI(a,g.Uj,c.sa,d);d=UI(a,h,c.ta,d);return FI(a,g,b,c.Wb,d)},XI=function VI(a,b,c,d){if(null===b||null===c)return b;if(b===c)return null;var g=TI(a,b,c.Wa,d);if(null===g)throw new w(g);b=g.oi;g=VI(a,g.Uj,c.sa,d);c=VI(a,b,c.ta,d);return WI(a,g,c)},Dda=function YI(a,b,c,d,e){switch(c){case 0:return null;case 1:return rI(b!==d||1===b,e.t(),null,null,null);default:var h=(-1+c|0)/2|0,k=YI(a,1+b|0,h,d,e),l=e.t();a=YI(a,1+b|0,(-1+c|0)-h|0,d,e);return RI(l,
+null,k,a)}},Eda=function ZI(a,b,c,d,e){switch(c){case 0:return null;case 1:var h=d.t();if(null===h)throw new w(h);return rI(b!==e||1===b,h.h(),h.j(),null,null);default:var k=(-1+c|0)/2|0;h=ZI(a,1+b|0,k,d,e);var l=d.t();if(null===l)throw new w(l);var m=l.h();l=l.j();b=ZI(a,1+b|0,(-1+c|0)-k|0,d,e);return RI(m,l,h,b)}},Fda=function $I(a,b,c){var e=b.Wa,g=b.Wb,h=b.sa,k=b.ta,l=null===h?null:$I(a,h,c),m=!!c.ba(e,g);c=null===k?null:$I(a,k,c);return m?l===h&&c===k?b:FI(a,l,e,g,c):WI(a,l,c)};
+function aJ(a,b){if(null===a)throw le();return a.sb?a.vb:me(a,new bJ(b))}function cJ(a){for(var b=0;;){if(null===a)return 1+b|0;b=0>a.ea?1+b|0:b;a=a.sa}}function dJ(){this.AS=null;eJ=this;this.AS=G(new H,null,null)}dJ.prototype=new p;dJ.prototype.constructor=dJ;function fJ(a,b,c,d){for(;;){if(null===b)return null;a=d.Da(c,b.Wa);if(0>a)b=b.sa;else if(0<a)b=b.ta;else return b}}function EI(a,b){return null===b?0:2147483647&b.ea}function gJ(a,b,c,d,e,g){return pI(rda(a,b,c,d,e,g))}
+function hJ(a,b){if(null===b)throw AH("empty tree");for(a=b;;)if(null!==a.sa)a=a.sa;else break;return a}function iJ(a,b){if(null===b)throw AH("empty tree");for(a=b;;)if(null!==a.ta)a=a.ta;else break;return a}function BI(a,b,c,d){return new sI(a,b,c,d,1+((null===c?0:2147483647&c.ea)+(null===d?0:2147483647&d.ea)|0)|0)}function RI(a,b,c,d){return new sI(a,b,c,d,1+((null===c?0:2147483647&c.ea)+(null===d?0:2147483647&d.ea)|0)|-2147483648)}
+function jJ(a,b,c){var d=32-Math.clz32(c)|0;return Dda(a,1,c,d,b)}function kJ(a,b,c){return null===b?null:pI(Fda(a,b,c))}function Gda(a,b,c){if(null===b)return G(new H,null,null);if(null===b)return a.AS;a=new $e;lJ(a.sb?a.vb:aJ(a,c),b);return G(new H,pI((a.sb?a.vb:aJ(a,c)).$G),pI((a.sb?a.vb:aJ(a,c)).ZG))}function mJ(a,b,c,d){return pI(Cda(a,b,c,d))}
+function FI(a,b,c,d,e){var g=cJ(b),h=cJ(e);return g>h?(a=xda(a,b,c,d,e,g,null===e?0:0>e.ea?(-1+h|0)<<1:-1+(h<<1)|0),null!==a&&0<=a.ea?(b=a.ta,b=null!==b&&0<=b.ea):b=!1,b?qI(a):a):h>g?(a=zda(a,b,c,d,e,null===b?0:0>b.ea?(-1+g|0)<<1:-1+(g<<1)|0,h),null!==a&&0<=a.ea?(b=a.sa,b=null!==b&&0<=b.ea):b=!1,b?qI(a):a):rI(null!==b&&0<=b.ea||null!==e&&0<=e.ea,c,d,b,e)}function WI(a,b,c){if(null===b)return c;if(null===c)return b;b=Bda(a,b);if(null===b)throw new w(b);return FI(a,b.kc,b.hb,b.Rd,c)}
+dJ.prototype.$classData=q({a8:0},!1,"scala.collection.immutable.RedBlackTree$",{a8:1,g:1});var eJ;function nJ(){eJ||(eJ=new dJ);return eJ}function oJ(){this.Uk=null}oJ.prototype=new p;oJ.prototype.constructor=oJ;function pJ(){}pJ.prototype=oJ.prototype;function qJ(a){return null===a?a:0===(2147483647&a.ea)?rJ(sJ(a)):qI(a)}
+function tJ(a,b){if(0<=b.ea){var c=b.sa,d=b.ta;if(nJ(),null!==c&&0<=c.ea)return c=sJ(c),d=uJ(a,d),vJ(b,c,d);if(nJ(),null!==d&&0<=d.ea)return c=d.ta,b=wJ(b,d.sa),a=uJ(a,c),vJ(d,b,a)}a.sa===b?d=a:0===(2147483647&a.ea)?(a.sa=b,d=a):d=new sI(a.Wa,a.Wb,b,a.ta,-2147483648&a.ea);return d}
+function xJ(a,b){if(0<=b.ea){var c=b.sa;if(nJ(),null!==c&&0<=c.ea){var d=wJ(a,c.sa);b=uJ(b,c.ta);return vJ(c,d,b)}d=b.ta;if(nJ(),null!==d&&0<=d.ea)return c=wJ(a,c),d=sJ(d),vJ(b,c,d)}a.ta===b?b=a:0===(2147483647&a.ea)?(a.ta=b,b=a):b=new sI(a.Wa,a.Wb,a.sa,b,-2147483648&a.ea);return b}function sI(a,b,c,d,e){this.Wa=a;this.Wb=b;this.sa=c;this.ta=d;this.ea=e}sI.prototype=new p;sI.prototype.constructor=sI;
+sI.prototype.u=function(){return(0<=this.ea?"RedTree":"BlackTree")+"("+this.Wa+", "+this.Wb+", "+this.sa+", "+this.ta+")"};function rJ(a){if(0===(2147483647&a.ea)){var b=1;null!==a.sa&&(rJ(a.sa),b=b+(2147483647&a.sa.ea)|0);null!==a.ta&&(rJ(a.ta),b=b+(2147483647&a.ta.ea)|0);a.ea|=b}return a}function sJ(a){return 0>a.ea?a:0===(2147483647&a.ea)?(a.ea=-2147483648,a):new sI(a.Wa,a.Wb,a.sa,a.ta,-2147483648)}
+function yJ(a,b){return Object.is(b,a.Wb)?a:0===(2147483647&a.ea)?(a.Wb=b,a):new sI(a.Wa,b,a.sa,a.ta,-2147483648&a.ea)}function vJ(a,b,c){return a.sa===b&&a.ta===c?a:0===(2147483647&a.ea)?(a.sa=b,a.ta=c,a):new sI(a.Wa,a.Wb,b,c,-2147483648&a.ea)}function uJ(a,b){return a.sa===b&&0>a.ea?a:0===(2147483647&a.ea)?(a.ea=-2147483648,a.sa=b,a):new sI(a.Wa,a.Wb,b,a.ta,-2147483648)}
+function wJ(a,b){return a.ta===b&&0>a.ea?a:0===(2147483647&a.ea)?(a.ea=-2147483648,a.ta=b,a):new sI(a.Wa,a.Wb,a.sa,b,-2147483648)}function qI(a){return 0>a.ea?a:new sI(a.Wa,a.Wb,a.sa,a.ta,-2147483648^a.ea)}function MI(a){return 0<=a.ea?a:new sI(a.Wa,a.Wb,a.sa,a.ta,-2147483648^a.ea)}function CI(a,b){return Object.is(b,a.Wb)?a:new sI(a.Wa,b,a.sa,a.ta,a.ea)}
+function xI(a,b){if(b===a.sa)return a;var c=a.ta;return new sI(a.Wa,a.Wb,b,a.ta,-2147483648&a.ea|1+((null===b?0:2147483647&b.ea)+(null===c?0:2147483647&c.ea)|0)|0)}function zI(a,b){if(b===a.ta)return a;var c=a.sa;return new sI(a.Wa,a.Wb,a.sa,b,-2147483648&a.ea|1+((null===c?0:2147483647&c.ea)+(null===b?0:2147483647&b.ea)|0)|0)}function vI(a,b){if(b===a.sa&&0>a.ea)return a;var c=a.ta;return new sI(a.Wa,a.Wb,b,a.ta,1+((null===b?0:2147483647&b.ea)+(null===c?0:2147483647&c.ea)|0)|-2147483648)}
+function wI(a,b){if(b===a.ta&&0>a.ea)return a;var c=a.sa;return new sI(a.Wa,a.Wb,a.sa,b,1+((null===c?0:2147483647&c.ea)+(null===b?0:2147483647&b.ea)|0)|-2147483648)}function uI(a,b,c){return b===a.sa&&c===a.ta?a:new sI(a.Wa,a.Wb,b,c,-2147483648&a.ea|1+((null===b?0:2147483647&b.ea)+(null===c?0:2147483647&c.ea)|0)|0)}function KI(a,b,c){return b===a.sa&&c===a.ta&&0<=a.ea?a:new sI(a.Wa,a.Wb,b,c,1+((null===b?0:2147483647&b.ea)+(null===c?0:2147483647&c.ea)|0)|0)}
+function NI(a,b,c){return b===a.sa&&c===a.ta&&0>a.ea?a:new sI(a.Wa,a.Wb,b,c,1+((null===b?0:2147483647&b.ea)+(null===c?0:2147483647&c.ea)|0)|-2147483648)}var zJ=q({f8:0},!1,"scala.collection.immutable.RedBlackTree$Tree",{f8:1,g:1});sI.prototype.$classData=zJ;function bJ(a){this.h8=a;this.ZG=this.$G=null}bJ.prototype=new p;bJ.prototype.constructor=bJ;
+function lJ(a,b){var c=b.Wa,d=b.Wb,e=b.sa,g=b.ta,h=null,k=null,l=null,m=null;null!==e&&(lJ(a,e),h=a.$G,k=a.ZG);var n=!!a.h8.ba(c,d);null!==g&&(lJ(a,g),l=a.$G,m=a.ZG);h=n?h===e&&l===g?b:FI(nJ(),h,c,d,l):WI(nJ(),h,l);b=n?WI(nJ(),k,m):k===e&&m===g?b:FI(nJ(),k,c,d,m);a.$G=h;a.ZG=b}bJ.prototype.$classData=q({g8:0},!1,"scala.collection.immutable.RedBlackTree$partitioner$1$",{g8:1,g:1});function AJ(){this.mw=null;BJ=this;this.mw=new CJ(0,0,(IB(),new zc(0)),(rl(),new Xc(0)),0,0)}AJ.prototype=new p;
+AJ.prototype.constructor=AJ;AJ.prototype.$classData=q({w8:0},!1,"scala.collection.immutable.SetNode$",{w8:1,g:1});var BJ;function DJ(){BJ||(BJ=new AJ);return BJ}
+var Ida=function Hda(a,b,c,d,e){for(;;){if(1===b){b=c;var h=d,k=e;EJ(a,1,0===h&&k===b.a.length?b:Jj(Pj(),b,h,k))}else{h=Math.imul(5,-1+b|0);var l=1<<h;k=d>>>h|0;h=e>>>h|0;d&=-1+l|0;e&=-1+l|0;if(0===d)if(0===e)e=c,EJ(a,b,0===k&&h===e.a.length?e:Jj(Pj(),e,k,h));else{h>k&&(d=c,EJ(a,b,0===k&&h===d.a.length?d:Jj(Pj(),d,k,h)));h=c.a[h];b=-1+b|0;c=h;d=0;continue}else if(h===k){h=c.a[k];b=-1+b|0;c=h;continue}else if(Hda(a,-1+b|0,c.a[k],d,l),0===e)h>(1+k|0)&&(e=c,k=1+k|0,EJ(a,b,0===k&&h===e.a.length?e:Jj(Pj(),
+e,k,h)));else{h>(1+k|0)&&(d=c,k=1+k|0,EJ(a,b,0===k&&h===d.a.length?d:Jj(Pj(),d,k,h)));h=c.a[h];b=-1+b|0;c=h;d=0;continue}}break}};function EJ(a,b,c){b<=a.Vk?b=11-b|0:(a.Vk=b,b=-1+b|0);a.lb.a[b]=c}
+var Kda=function Jda(a,b){if(null===a.lb.a[-1+b|0])if(b===a.Vk)a.lb.a[-1+b|0]=a.lb.a[11-b|0],a.lb.a[11-b|0]=null;else{Jda(a,1+b|0);var d=a.lb.a[-1+(1+b|0)|0];a.lb.a[-1+b|0]=d.a[0];if(1===d.a.length)a.lb.a[-1+(1+b|0)|0]=null,a.Vk===(1+b|0)&&null===a.lb.a[11-(1+b|0)|0]&&(a.Vk=b);else{var e=d.a.length;a.lb.a[-1+(1+b|0)|0]=Jj(Pj(),d,1,e)}}},Mda=function Lda(a,b){if(null===a.lb.a[11-b|0])if(b===a.Vk)a.lb.a[11-b|0]=a.lb.a[-1+b|0],a.lb.a[-1+b|0]=null;else{Lda(a,1+b|0);var d=a.lb.a[11-(1+b|0)|0];a.lb.a[11-
+b|0]=d.a[-1+d.a.length|0];if(1===d.a.length)a.lb.a[11-(1+b|0)|0]=null,a.Vk===(1+b|0)&&null===a.lb.a[-1+(1+b|0)|0]&&(a.Vk=b);else{var e=-1+d.a.length|0;a.lb.a[11-(1+b|0)|0]=Jj(Pj(),d,0,e)}}};function FJ(a,b){this.lb=null;this.Vk=this.az=this.Ko=0;this.KS=a;this.JS=b;this.lb=new (md(md(jd)).Ia)(11);this.Vk=this.az=this.Ko=0}FJ.prototype=new p;FJ.prototype.constructor=FJ;
+function GJ(a,b,c){var d=Math.imul(c.a.length,1<<Math.imul(5,-1+b|0)),e=a.KS-a.az|0;e=0<e?e:0;var g=a.JS-a.az|0;g=g<d?g:d;g>e&&(Ida(a,b,c,e,g),a.Ko=a.Ko+(g-e|0)|0);a.az=a.az+d|0}
+FJ.prototype.im=function(){if(32>=this.Ko){if(0===this.Ko)return HJ();var a=this.lb.a[0],b=this.lb.a[10];if(null!==a)if(null!==b){var c=a.a.length+b.a.length|0,d=zj(Pj(),a,c);b.wa(0,d,a.a.length,b.a.length);var e=d}else e=a;else if(null!==b)e=b;else{var g=this.lb.a[1];e=null!==g?g.a[0]:this.lb.a[9].a[0]}return new IJ(e)}Kda(this,1);Mda(this,1);var h=this.Vk;if(6>h){var k=this.lb.a[-1+this.Vk|0],l=this.lb.a[11-this.Vk|0];if(null!==k&&null!==l)if(30>=(k.a.length+l.a.length|0)){var m=this.lb,n=this.Vk,
+r=k.a.length+l.a.length|0,v=zj(Pj(),k,r);l.wa(0,v,k.a.length,l.a.length);m.a[-1+n|0]=v;this.lb.a[11-this.Vk|0]=null}else h=1+h|0;else 30<(null!==k?k:l).a.length&&(h=1+h|0)}var x=this.lb.a[0],A=this.lb.a[10],B=x.a.length,C=h;switch(C){case 2:var D=JJ().bd,F=this.lb.a[1];if(null!==F)var I=F;else{var M=this.lb.a[9];I=null!==M?M:D}var N=new KJ(x,B,I,A,this.Ko);break;case 3:var P=JJ().bd,T=this.lb.a[1],Y=null!==T?T:P,Z=JJ().eg,S=this.lb.a[2];if(null!==S)var ea=S;else{var ia=this.lb.a[8];ea=null!==ia?ia:
+Z}var X=ea,sa=JJ().bd,Ja=this.lb.a[9];N=new LJ(x,B,Y,B+(Y.a.length<<5)|0,X,null!==Ja?Ja:sa,A,this.Ko);break;case 4:var Xa=JJ().bd,Fa=this.lb.a[1],za=null!==Fa?Fa:Xa,Qa=JJ().eg,Ma=this.lb.a[2],Ga=null!==Ma?Ma:Qa,ab=JJ().jk,Hb=this.lb.a[3];if(null!==Hb)var bc=Hb;else{var yb=this.lb.a[7];bc=null!==yb?yb:ab}var tb=bc,eb=JJ().eg,kb=this.lb.a[8],Rb=null!==kb?kb:eb,Gb=JJ().bd,vb=this.lb.a[9],Tb=B+(za.a.length<<5)|0;N=new MJ(x,B,za,Tb,Ga,Tb+(Ga.a.length<<10)|0,tb,Rb,null!==vb?vb:Gb,A,this.Ko);break;case 5:var Nb=
+JJ().bd,ic=this.lb.a[1],Va=null!==ic?ic:Nb,cb=JJ().eg,zb=this.lb.a[2],Ub=null!==zb?zb:cb,jb=JJ().jk,db=this.lb.a[3],ub=null!==db?db:jb,Aa=JJ().du,va=this.lb.a[4];if(null!==va)var Ra=va;else{var rb=this.lb.a[6];Ra=null!==rb?rb:Aa}var xb=Ra,mc=JJ().jk,Ha=this.lb.a[7],Ka=null!==Ha?Ha:mc,Oa=JJ().eg,Na=this.lb.a[8],Da=null!==Na?Na:Oa,ta=JJ().bd,Ya=this.lb.a[9],dc=B+(Va.a.length<<5)|0,ka=dc+(Ub.a.length<<10)|0;N=new NJ(x,B,Va,dc,Ub,ka,ub,ka+(ub.a.length<<15)|0,xb,Ka,Da,null!==Ya?Ya:ta,A,this.Ko);break;
+case 6:var ya=JJ().bd,Sa=this.lb.a[1],xc=null!==Sa?Sa:ya,Sb=JJ().eg,uc=this.lb.a[2],Lb=null!==uc?uc:Sb,lc=JJ().jk,Xb=this.lb.a[3],ec=null!==Xb?Xb:lc,Ab=JJ().du,Ob=this.lb.a[4],fb=null!==Ob?Ob:Ab,Wa=JJ().dH,bb=this.lb.a[5];if(null!==bb)var Ia=bb;else{var Ua=this.lb.a[5];Ia=null!==Ua?Ua:Wa}var pc=Ia,sc=JJ().du,Ba=this.lb.a[6],ob=null!==Ba?Ba:sc,nc=JJ().jk,Ib=this.lb.a[7],vc=null!==Ib?Ib:nc,Vb=JJ().eg,fc=this.lb.a[8],Bc=null!==fc?fc:Vb,Pb=JJ().bd,Jb=this.lb.a[9],gc=B+(xc.a.length<<5)|0,Cb=gc+(Lb.a.length<<
+10)|0,cc=Cb+(ec.a.length<<15)|0;N=new OJ(x,B,xc,gc,Lb,Cb,ec,cc,fb,cc+(fb.a.length<<20)|0,pc,ob,vc,Bc,null!==Jb?Jb:Pb,A,this.Ko);break;default:throw new w(C);}return N};FJ.prototype.u=function(){return"VectorSliceBuilder(lo\x3d"+this.KS+", hi\x3d"+this.JS+", len\x3d"+this.Ko+", pos\x3d"+this.az+", maxDim\x3d"+this.Vk+")"};FJ.prototype.$classData=q({Y8:0},!1,"scala.collection.immutable.VectorSliceBuilder",{Y8:1,g:1});
+function PJ(){this.dH=this.du=this.jk=this.eg=this.bd=this.PL=null;QJ=this;this.PL=new zc(0);this.bd=new (md(md(jd)).Ia)(0);this.eg=new (md(md(md(jd))).Ia)(0);this.jk=new (md(md(md(md(jd)))).Ia)(0);this.du=new (md(md(md(md(md(jd))))).Ia)(0);this.dH=new (md(md(md(md(md(md(jd)))))).Ia)(0)}PJ.prototype=new p;PJ.prototype.constructor=PJ;function RJ(a,b,c){a=b.a.length;var d=new zc(1+a|0);b.wa(0,d,0,a);d.a[a]=c;return d}
+function SJ(a,b,c){a=1+b.a.length|0;b=zj(Pj(),b,a);b.a[-1+b.a.length|0]=c;return b}function TJ(a,b,c){a=new zc(1+c.a.length|0);c.wa(0,a,1,c.a.length);a.a[0]=b;return a}function UJ(a,b,c){a=bg(ca(c));var d=1+c.a.length|0;a=rh(th(),a,d);c.wa(0,a,1,c.a.length);a.a[0]=b;return a}function VJ(a,b,c,d){var e=0,g=c.a.length;if(0===b)for(;e<g;)d.n(c.a[e]),e=1+e|0;else for(b=-1+b|0;e<g;)VJ(a,b,c.a[e],d),e=1+e|0}
+function WJ(a,b,c){for(var d=0;d<b.a.length;){var e=b.a[d];a=c.n(e);if(!Object.is(e,a)){e=a;a=new zc(b.a.length);0<d&&b.wa(0,a,0,d);a.a[d]=e;for(d=1+d|0;d<b.a.length;)a.a[d]=c.n(b.a[d]),d=1+d|0;return a}d=1+d|0}return b}function XJ(a,b,c,d){if(1===b)return WJ(0,c,d);for(var e=0;e<c.a.length;){var g=c.a[e],h=XJ(a,-1+b|0,g,d);if(g!==h){g=bg(ca(c));var k=c.a.length;g=rh(th(),g,k);0<e&&c.wa(0,g,0,e);g.a[e]=h;for(h=1+e|0;h<c.a.length;)g.a[h]=XJ(a,-1+b|0,c.a[h],d),h=1+h|0;return g}e=1+e|0}return c}
+function YJ(a,b,c){if(ZJ(c))if(0>=c.$k(32-b.a.length|0))switch(a=c.ka(),a){case 0:return null;case 1:return SJ(0,b,c.e());default:return a=b.a.length+a|0,a=zj(Pj(),b,a),c.Gc(a,b.a.length,2147483647),a}else return null;else return a=c.Q(),0<a&&a<=(32-b.a.length|0)?(a=b.a.length+a|0,a=zj(Pj(),b,a),c.m().Gc(a,b.a.length,2147483647),a):null}PJ.prototype.$classData=q({Z8:0},!1,"scala.collection.immutable.VectorStatics$",{Z8:1,g:1});var QJ;function JJ(){QJ||(QJ=new PJ);return QJ}
+var $J=q({VL:0},!0,"scala.collection.mutable.HashEntry",{VL:1,g:1});function aK(a,b,c,d){this.Wk=a;this.mk=b;this.Ah=c;this.$d=d}aK.prototype=new p;aK.prototype.constructor=aK;function Ny(a,b,c){for(;;){if(c===a.mk&&ml(nl(),b,a.Wk))return a;if(null===a.$d||a.mk>c)return null;a=a.$d}}aK.prototype.Ca=function(a){for(var b=this;;)if(a.n(G(new H,b.Wk,b.Ah)),null!==b.$d)b=b.$d;else break};aK.prototype.og=function(a){for(var b=this;;)if(a.ba(b.Wk,b.Ah),null!==b.$d)b=b.$d;else break};
+aK.prototype.u=function(){return"Node("+this.Wk+", "+this.Ah+", "+this.mk+") -\x3e "+this.$d};var bK=q({M9:0},!1,"scala.collection.mutable.HashMap$Node",{M9:1,g:1});aK.prototype.$classData=bK;function cK(a,b,c){this.xm=a;this.nk=b;this.yg=c}cK.prototype=new p;cK.prototype.constructor=cK;cK.prototype.Ca=function(a){for(var b=this;;)if(a.n(b.xm),null!==b.yg)b=b.yg;else break};cK.prototype.u=function(){return"Node("+this.xm+", "+this.nk+") -\x3e "+this.yg};
+var dK=q({T9:0},!1,"scala.collection.mutable.HashSet$Node",{T9:1,g:1});cK.prototype.$classData=dK;function eK(){}eK.prototype=new p;eK.prototype.constructor=eK;function fK(a,b,c){a=c>>31;var d=b>>31,e=65535&c,g=c>>>16|0,h=65535&b,k=b>>>16|0,l=Math.imul(e,h);h=Math.imul(g,h);var m=Math.imul(e,k);e=l+((h+m|0)<<16)|0;l=(l>>>16|0)+m|0;b=(((Math.imul(c,d)+Math.imul(a,b)|0)+Math.imul(g,k)|0)+(l>>>16|0)|0)+(((65535&l)+h|0)>>>16|0)|0;return $h(xa(),e,b,1E3,0)}
+eK.prototype.$classData=q({V9:0},!1,"scala.collection.mutable.HashTable$",{V9:1,g:1});var gK;function hK(){gK||(gK=new eK);return gK}function iK(){}iK.prototype=new p;iK.prototype.constructor=iK;function jK(a,b){if(b!==a)throw new kK;}iK.prototype.$classData=q({o$:0},!1,"scala.collection.mutable.MutationTracker$",{o$:1,g:1});var lK;function mK(){lK||(lK=new iK)}function nK(a,b,c){for(;;){if(null===a)return null;var d=c.Da(b,a.Oo);if(0>d)a=a.Vc;else if(0<d)a=a.Bc;else return a}}
+function oK(a,b){if(null!==b){var c=b.Bc;b.Bc=c.Vc;null!==c.Vc&&(c.Vc.bb=b);c.bb=b.bb;null===b.bb?a.zi=c:b===b.bb.Vc?b.bb.Vc=c:b.bb.Bc=c;c.Vc=b;b.bb=c}}function pK(a,b){if(null!==b){var c=b.Vc;b.Vc=c.Bc;null!==c.Bc&&(c.Bc.bb=b);c.bb=b.bb;null===b.bb?a.zi=c:b===b.bb.Bc?b.bb.Bc=c:b.bb.Vc=c;c.Bc=b;b.bb=c}}function qK(a,b,c){null===b.bb?a.zi=c:b===b.bb.Vc?b.bb.Vc=c:b.bb.Bc=c;null!==c&&(c.bb=b.bb)}
+var Oda=function Nda(a,b,c){for(;;)if(null!==b.Vc&&Nda(a,b.Vc,c),c.n(G(new H,b.Oo,b.Vr)),null!==b.Bc)b=b.Bc;else break},Qda=function Pda(a,b,c){for(;;){var e=b.Vc;null!==e&&Pda(a,e,c);c.ba(b.Oo,b.Vr);b=b.Bc;if(null===b)break}};function rK(){}rK.prototype=new p;rK.prototype.constructor=rK;function sK(a){return null!==a&&a.Wc}function tK(a){return null===a||!a.Wc}function uK(a){for(;;){if(null===a.Vc)return a;a=a.Vc}}
+function vK(a,b){if(null!==b.Bc)return uK(b.Bc);a=b;for(b=a.bb;null!==b&&a===b.Bc;)a=b,b=b.bb;return b}rK.prototype.$classData=q({t$:0},!1,"scala.collection.mutable.RedBlackTree$",{t$:1,g:1});var wK;function xK(){wK||(wK=new rK);return wK}function yK(a,b,c,d,e,g){this.Oo=a;this.Vr=b;this.Wc=c;this.Vc=d;this.Bc=e;this.bb=g}yK.prototype=new p;yK.prototype.constructor=yK;yK.prototype.u=function(){return"Node("+this.Oo+", "+this.Vr+", "+this.Wc+", "+this.Vc+", "+this.Bc+")"};
+yK.prototype.$classData=q({w$:0},!1,"scala.collection.mutable.RedBlackTree$Node",{w$:1,g:1});function zK(a,b){this.zi=a;this.gz=b}zK.prototype=new p;zK.prototype.constructor=zK;zK.prototype.$classData=q({x$:0},!1,"scala.collection.mutable.RedBlackTree$Tree",{x$:1,g:1});
+function AK(a,b){if(b instanceof ba)return b=Ea(b),a.XJ()&&a.Zi()===b;if(Zb(b))return b|=0,a.WJ()&&a.jB()===b;if($b(b))return b|=0,a.YJ()&&a.EC()===b;if(ha(b))return b|=0,a.MF()&&a.Zi()===b;if(b instanceof ma){var c=Za(b);b=c.W;c=c.Y;a=a.xl();return a.W===b&&a.Y===c}return ja(b)?(b=Math.fround(b),a.pv()===b):"number"===typeof b?(b=+b,a.Lp()===b):!1}
+function BK(){this.wR=this.c=this.xR=this.vR=this.uR=this.tR=null;this.Jt=0;CK=this;DK();this.vR=DK();EK();xe();Rq();this.xR=Od();this.c=u();this.wR=FK();GK();Su();HK||(HK=new IK);JK||(JK=new KK);LK||(LK=new MK)}BK.prototype=new p;BK.prototype.constructor=BK;function Tr(){var a=O();0===(2&a.Jt)<<24>>24&&0===(2&a.Jt)<<24>>24&&(a.uR=NK(),a.Jt=(2|a.Jt)<<24>>24);return a.uR}BK.prototype.$classData=q({T3:0},!1,"scala.package$",{T3:1,g:1});var CK;function O(){CK||(CK=new BK);return CK}function OK(){}
+OK.prototype=new p;OK.prototype.constructor=OK;function ml(a,b,c){if(b===c)c=!0;else if(PK(b))a:if(PK(c))c=QK(0,b,c);else{if(c instanceof ba){if("number"===typeof b){c=+b===Ea(c);break a}if(b instanceof ma){a=Za(b);b=a.Y;c=Ea(c);c=a.W===c&&b===c>>31;break a}}c=null===b?null===c:La(b,c)}else c=b instanceof ba?Rda(b,c):null===b?null===c:La(b,c);return c}
+function QK(a,b,c){if("number"===typeof b)return a=+b,"number"===typeof c?a===+c:c instanceof ma?(b=Za(c),c=b.W,b=b.Y,a===cG(xa(),c,b)):c instanceof yH?c.i(a):!1;if(b instanceof ma){b=Za(b);a=b.W;b=b.Y;if(c instanceof ma){c=Za(c);var d=c.Y;return a===c.W&&b===d}return"number"===typeof c?(c=+c,cG(xa(),a,b)===c):c instanceof yH?c.i(new ma(a,b)):!1}return null===b?null===c:La(b,c)}
+function Rda(a,b){if(b instanceof ba)return Ea(a)===Ea(b);if(PK(b)){if("number"===typeof b)return+b===Ea(a);if(b instanceof ma){b=Za(b);var c=b.Y;a=Ea(a);return b.W===a&&c===a>>31}return null===b?null===a:La(b,a)}return null===a&&null===b}OK.prototype.$classData=q({Y$:0},!1,"scala.runtime.BoxesRunTime$",{Y$:1,g:1});var RK;function nl(){RK||(RK=new OK);return RK}var jH=q({daa:0},!1,"scala.runtime.Null$",{daa:1,g:1});function SK(){}SK.prototype=new p;SK.prototype.constructor=SK;
+SK.prototype.$classData=q({gaa:0},!1,"scala.runtime.RichInt$",{gaa:1,g:1});var TK;function UK(){}UK.prototype=new p;UK.prototype.constructor=UK;function XG(a,b,c){if(b instanceof zc||b instanceof Xc||b instanceof ed||b instanceof Zc||b instanceof $c)return b.a[c];if(b instanceof Ic)return hc(b.a[c]);if(b instanceof Pc||b instanceof Sc||b instanceof Ec)return b.a[c];if(null===b)throw le();throw new w(b);}
+function fH(a,b,c,d){if(b instanceof zc)b.a[c]=d;else if(b instanceof Xc)b.a[c]=d|0;else if(b instanceof ed)b.a[c]=+d;else if(b instanceof Zc)b.a[c]=Za(d);else if(b instanceof $c)b.a[c]=Math.fround(d);else if(b instanceof Ic)b.a[c]=Ea(d);else if(b instanceof Pc)b.a[c]=d|0;else if(b instanceof Sc)b.a[c]=d|0;else if(b instanceof Ec)b.a[c]=!!d;else{if(null===b)throw le();throw new w(b);}}
+function wG(a,b){th();if(b instanceof zc||b instanceof Ec||b instanceof Ic||b instanceof Pc||b instanceof Sc||b instanceof Xc||b instanceof Zc||b instanceof $c||b instanceof ed)a=b.a.length;else throw Kj("argument type mismatch");return a}function KG(a,b){if(b instanceof zc||b instanceof Xc||b instanceof ed||b instanceof Zc||b instanceof $c||b instanceof Ic||b instanceof Pc||b instanceof Sc||b instanceof Ec)return b.ia();if(null===b)throw le();throw new w(b);}
+function VK(a){xG();return ze(new iD(a),a.H()+"(",",",")")}UK.prototype.$classData=q({haa:0},!1,"scala.runtime.ScalaRunTime$",{haa:1,g:1});var WK;function xG(){WK||(WK=new UK);return WK}function XK(){}XK.prototype=new p;XK.prototype.constructor=XK;XK.prototype.C=function(a,b){a=this.Pp(a,b);return-430675100+Math.imul(5,a<<13|a>>>19|0)|0};XK.prototype.Pp=function(a,b){b=Math.imul(-862048943,b);b=Math.imul(461845907,b<<15|b>>>17|0);return a^b};
+XK.prototype.Ma=function(a,b){a^=b;a=Math.imul(-2048144789,a^(a>>>16|0));a=Math.imul(-1028477387,a^(a>>>13|0));return a^(a>>>16|0)};function YK(a,b){a=b.W;b=b.Y;return b===a>>31?a:a^b}function ZK(a,b){a=Eb(b);if(a===b)return a;a=xa();if(-0x7fffffffffffffff>b){a.Qc=-2147483648;var c=0}else if(0x7fffffffffffffff<=b)a.Qc=2147483647,c=-1;else{c=b|0;var d=b/4294967296|0;a.Qc=0>b&&0!==c?-1+d|0:d}a=a.Qc;return cG(xa(),c,a)===b?c^a:ig(mg(),b)}
+function My(a,b){return null===b?0:"number"===typeof b?ZK(0,+b):b instanceof ma?(a=Za(b),YK(0,new ma(a.W,a.Y))):ib(b)}function $K(a,b){throw aL(new bL,""+b);}XK.prototype.$classData=q({kaa:0},!1,"scala.runtime.Statics$",{kaa:1,g:1});var cL;function W(){cL||(cL=new XK);return cL}function dL(){}dL.prototype=new p;dL.prototype.constructor=dL;dL.prototype.$classData=q({laa:0},!1,"scala.runtime.Statics$PFMarker$",{laa:1,g:1});var eL;function fL(){eL||(eL=new dL);return eL}function gL(){}gL.prototype=new p;
+gL.prototype.constructor=gL;function OI(){hL||(hL=new gL);throw iL("Defect: invariance violation");}gL.prototype.$classData=q({i4:0},!1,"scala.sys.package$",{i4:1,g:1});var hL;function yy(){}yy.prototype=new p;yy.prototype.constructor=yy;function Rba(a,b){b.n(a);return a}yy.prototype.$classData=q({j4:0},!1,"scala.util.ChainingOps$",{j4:1,g:1});var xy;function jL(a){this.yR=a}jL.prototype=new p;jL.prototype.constructor=jL;jL.prototype.u=function(){return"DynamicVariable("+this.yR+")"};
+jL.prototype.$classData=q({k4:0},!1,"scala.util.DynamicVariable",{k4:1,g:1});function kL(){}kL.prototype=new p;kL.prototype.constructor=kL;
+function lL(a,b,c,d){c=c-b|0;if(!(2>c)){if(0<d.Da(XG(xG(),a,b),XG(xG(),a,1+b|0))){var e=XG(xG(),a,b);fH(xG(),a,b,XG(xG(),a,1+b|0));fH(xG(),a,1+b|0,e)}for(e=2;e<c;){var g=XG(xG(),a,b+e|0);if(0>d.Da(g,XG(xG(),a,-1+(b+e|0)|0))){for(var h=b,k=-1+(b+e|0)|0;1<(k-h|0);){var l=(h+k|0)>>>1|0;0>d.Da(g,XG(xG(),a,l))?k=l:h=l}h=h+(0>d.Da(g,XG(xG(),a,h))?0:1)|0;for(k=b+e|0;k>h;)fH(xG(),a,k,XG(xG(),a,-1+k|0)),k=-1+k|0;fH(xG(),a,h,g)}e=1+e|0}}}
+function mL(a,b,c,d,e,g,h){if(32>(d-c|0))lL(b,c,d,e);else{var k=(c+d|0)>>>1|0;g=null===g?h.si(k-c|0):g;mL(a,b,c,k,e,g,h);mL(a,b,k,d,e,g,h);nL(b,c,k,d,e,g)}}function nL(a,b,c,d,e,g){if(0<e.Da(XG(xG(),a,-1+c|0),XG(xG(),a,c))){for(var h=b,k=c-b|0,l=0;h<c;)fH(xG(),g,l,XG(xG(),a,h)),h=1+h|0,l=1+l|0;for(l=0;h<d&&l<k;)0>e.Da(XG(xG(),a,h),XG(xG(),g,l))?(fH(xG(),a,b,XG(xG(),a,h)),h=1+h|0):(fH(xG(),a,b,XG(xG(),g,l)),l=1+l|0),b=1+b|0;for(;l<k;)fH(xG(),a,b,XG(xG(),g,l)),l=1+l|0,b=1+b|0}}
+function RG(a,b,c,d){if(b instanceof zc){if(1<wG(xG(),b)&&null===d)throw oL("Ordering");a=Pj();d=null===d?ij():d;var e=jj();if(0>c)throw Kj("fromIndex(0) \x3e toIndex("+c+")");if(16<(c-0|0)){var g=b.a.length,h=ca(b);Vi(a,b,rh(th(),bg(h),g),0,c,d,e)}else Zi(b,0,c,d,e)}else if(b instanceof Xc)if(d===Fq())Ti(Pj(),b);else if(e=rl(),32>(c-0|0))lL(b,0,c,d);else{g=(0+c|0)>>>1|0;h=new Xc(g-0|0);if(32>(g-0|0))lL(b,0,g,d);else{var k=(0+g|0)>>>1|0;mL(a,b,0,k,d,h,e);mL(a,b,k,g,d,h,e);nL(b,0,k,g,d,h)}32>(c-g|
+0)?lL(b,g,c,d):(k=(g+c|0)>>>1|0,mL(a,b,g,k,d,h,e),mL(a,b,k,c,d,h,e),nL(b,g,k,c,d,h));nL(b,0,g,c,d,h)}else if(b instanceof ed)e=pL(),32>(c-0|0)?lL(b,0,c,d):(g=(0+c|0)>>>1|0,h=new ed(g-0|0),32>(g-0|0)?lL(b,0,g,d):(k=(0+g|0)>>>1|0,mL(a,b,0,k,d,h,e),mL(a,b,k,g,d,h,e),nL(b,0,k,g,d,h)),32>(c-g|0)?lL(b,g,c,d):(k=(g+c|0)>>>1|0,mL(a,b,g,k,d,h,e),mL(a,b,k,c,d,h,e),nL(b,g,k,c,d,h)),nL(b,0,g,c,d,h));else if(b instanceof Zc)d===LG()?$i(Pj(),b):(e=qL(),32>(c-0|0)?lL(b,0,c,d):(g=(0+c|0)>>>1|0,h=new Zc(g-0|0),32>
+(g-0|0)?lL(b,0,g,d):(k=(0+g|0)>>>1|0,mL(a,b,0,k,d,h,e),mL(a,b,k,g,d,h,e),nL(b,0,k,g,d,h)),32>(c-g|0)?lL(b,g,c,d):(k=(g+c|0)>>>1|0,mL(a,b,g,k,d,h,e),mL(a,b,k,c,d,h,e),nL(b,g,k,c,d,h)),nL(b,0,g,c,d,h)));else if(b instanceof $c)e=rL(),32>(c-0|0)?lL(b,0,c,d):(g=(0+c|0)>>>1|0,h=new $c(g-0|0),32>(g-0|0)?lL(b,0,g,d):(k=(0+g|0)>>>1|0,mL(a,b,0,k,d,h,e),mL(a,b,k,g,d,h,e),nL(b,0,k,g,d,h)),32>(c-g|0)?lL(b,g,c,d):(k=(g+c|0)>>>1|0,mL(a,b,g,k,d,h,e),mL(a,b,k,c,d,h,e),nL(b,g,k,c,d,h)),nL(b,0,g,c,d,h));else if(b instanceof
+Ic)d===MG()?dj(Pj(),b):(e=Ir(),32>(c-0|0)?lL(b,0,c,d):(g=(0+c|0)>>>1|0,h=new Ic(g-0|0),32>(g-0|0)?lL(b,0,g,d):(k=(0+g|0)>>>1|0,mL(a,b,0,k,d,h,e),mL(a,b,k,g,d,h,e),nL(b,0,k,g,d,h)),32>(c-g|0)?lL(b,g,c,d):(k=(g+c|0)>>>1|0,mL(a,b,g,k,d,h,e),mL(a,b,k,c,d,h,e),nL(b,g,k,c,d,h)),nL(b,0,g,c,d,h)));else if(b instanceof Pc)d===NG()?fj(Pj(),b):(e=sL(),32>(c-0|0)?lL(b,0,c,d):(g=(0+c|0)>>>1|0,h=new Pc(g-0|0),32>(g-0|0)?lL(b,0,g,d):(k=(0+g|0)>>>1|0,mL(a,b,0,k,d,h,e),mL(a,b,k,g,d,h,e),nL(b,0,k,g,d,h)),32>(c-g|0)?
+lL(b,g,c,d):(k=(g+c|0)>>>1|0,mL(a,b,g,k,d,h,e),mL(a,b,k,c,d,h,e),nL(b,g,k,c,d,h)),nL(b,0,g,c,d,h)));else if(b instanceof Sc)d===OG()?bj(Pj(),b):(e=tL(),32>(c-0|0)?lL(b,0,c,d):(g=(0+c|0)>>>1|0,h=new Sc(g-0|0),32>(g-0|0)?lL(b,0,g,d):(k=(0+g|0)>>>1|0,mL(a,b,0,k,d,h,e),mL(a,b,k,g,d,h,e),nL(b,0,k,g,d,h)),32>(c-g|0)?lL(b,g,c,d):(k=(g+c|0)>>>1|0,mL(a,b,g,k,d,h,e),mL(a,b,k,c,d,h,e),nL(b,g,k,c,d,h)),nL(b,0,g,c,d,h)));else if(b instanceof Ec)if(d===PG()){for(d=c=0;c<b.a.length;)b.a[c]||(d=1+d|0),c=1+c|0;for(c=
+0;c<d;)b.a[c]=!1,c=1+c|0;for(;c<b.a.length;)b.a[c]=!0,c=1+c|0}else e=uL(),32>(c-0|0)?lL(b,0,c,d):(g=(0+c|0)>>>1|0,h=new Ec(g-0|0),32>(g-0|0)?lL(b,0,g,d):(k=(0+g|0)>>>1|0,mL(a,b,0,k,d,h,e),mL(a,b,k,g,d,h,e),nL(b,0,k,g,d,h)),32>(c-g|0)?lL(b,g,c,d):(k=(g+c|0)>>>1|0,mL(a,b,g,k,d,h,e),mL(a,b,k,c,d,h,e),nL(b,g,k,c,d,h)),nL(b,0,g,c,d,h));else{if(null===b)throw le();throw new w(b);}}kL.prototype.$classData=q({r4:0},!1,"scala.util.Sorting$",{r4:1,g:1});var vL;function QG(){vL||(vL=new kL);return vL}
+function wL(){}wL.prototype=new p;wL.prototype.constructor=wL;function xL(){}xL.prototype=wL.prototype;wL.prototype.C=function(a,b){a=this.Pp(a,b);return-430675100+Math.imul(5,a<<13|a>>>19|0)|0};wL.prototype.Pp=function(a,b){b=Math.imul(-862048943,b);b=Math.imul(461845907,b<<15|b>>>17|0);return a^b};wL.prototype.Ma=function(a,b){return yL(a^b)};function yL(a){a=Math.imul(-2048144789,a^(a>>>16|0));a=Math.imul(-1028477387,a^(a>>>13|0));return a^(a>>>16|0)}
+function zL(a,b,c){var d=a.C(-889275714,lb("Tuple2"));d=a.C(d,b);d=a.C(d,c);return a.Ma(d,2)}function AL(a){var b=BL(),c=a.G();if(0===c)return lb(a.H());var d=b.C(-889275714,lb(a.H()));for(var e=0;e<c;){var g=a.I(e);d=b.C(d,My(W(),g));e=1+e|0}return b.Ma(d,c)}function CL(a,b,c){var d=0,e=0,g=0,h=1;for(b=b.m();b.s();){var k=b.t();k=My(W(),k);d=d+k|0;e^=k;h=Math.imul(h,1|k);g=1+g|0}c=a.C(c,d);c=a.C(c,e);c=a.Pp(c,h);return a.Ma(c,g)}
+function DL(a,b,c){var d=c;c=wG(xG(),b);switch(c){case 0:return a.Ma(d,0);case 1:return c=d,b=XG(xG(),b,0),a.Ma(a.C(c,My(W(),b)),1);default:var e=XG(xG(),b,0),g=My(W(),e);e=d=a.C(d,g);var h=XG(xG(),b,1);h=My(W(),h);var k=h-g|0;for(g=2;g<c;){d=a.C(d,h);var l=XG(xG(),b,g);l=My(W(),l);if(k!==(l-h|0)){d=a.C(d,l);for(g=1+g|0;g<c;)e=XG(xG(),b,g),d=a.C(d,My(W(),e)),g=1+g|0;return a.Ma(d,c)}h=l;g=1+g|0}return yL(a.C(a.C(e,k),h))}}
+function EL(a,b,c){var d=b.a.length;switch(d){case 0:return a.Ma(c,0);case 1:return a.Ma(a.C(c,b.a[0]?1231:1237),1);default:var e=b.a[0]?1231:1237,g=c=a.C(c,e),h=b.a[1]?1231:1237;e=h-e|0;for(var k=2;k<d;){c=a.C(c,h);var l=b.a[k]?1231:1237;if(e!==(l-h|0)){c=a.C(c,l);for(k=1+k|0;k<d;)c=a.C(c,b.a[k]?1231:1237),k=1+k|0;return a.Ma(c,d)}h=l;k=1+k|0}return yL(a.C(a.C(g,e),h))}}
+function FL(a,b,c){var d=b.a.length;switch(d){case 0:return a.Ma(c,0);case 1:return a.Ma(a.C(c,b.a[0]),1);default:var e=b.a[0],g=c=a.C(c,e),h=b.a[1];e=h-e|0;for(var k=2;k<d;){c=a.C(c,h);var l=b.a[k];if(e!==(l-h|0)){c=a.C(c,l);for(k=1+k|0;k<d;)c=a.C(c,b.a[k]),k=1+k|0;return a.Ma(c,d)}h=l;k=1+k|0}return yL(a.C(a.C(g,e),h))}}
+function GL(a,b,c){var d=b.a.length;switch(d){case 0:return a.Ma(c,0);case 1:return a.Ma(a.C(c,b.a[0]),1);default:var e=b.a[0],g=c=a.C(c,e),h=b.a[1];e=h-e|0;for(var k=2;k<d;){c=a.C(c,h);var l=b.a[k];if(e!==(l-h|0)){c=a.C(c,l);for(k=1+k|0;k<d;)c=a.C(c,b.a[k]),k=1+k|0;return a.Ma(c,d)}h=l;k=1+k|0}return yL(a.C(a.C(g,e),h))}}
+function HL(a,b,c){var d=b.a.length;switch(d){case 0:return a.Ma(c,0);case 1:return b=b.a[0],a.Ma(a.C(c,ZK(W(),b)),1);default:var e=b.a[0],g=ZK(W(),e);e=c=a.C(c,g);var h=b.a[1];h=ZK(W(),h);var k=h-g|0;for(g=2;g<d;){c=a.C(c,h);var l=b.a[g];l=ZK(W(),l);if(k!==(l-h|0)){c=a.C(c,l);for(g=1+g|0;g<d;)e=b.a[g],c=a.C(c,ZK(W(),e)),g=1+g|0;return a.Ma(c,d)}h=l;g=1+g|0}return yL(a.C(a.C(e,k),h))}}
+function IL(a,b,c){var d=c;c=b.a.length;switch(c){case 0:return a.Ma(d,0);case 1:return c=d,b=b.a[0],W(),a.Ma(a.C(c,ZK(0,b)),1);default:var e=b.a[0],g=ZK(W(),e);e=d=a.C(d,g);var h=b.a[1];h=ZK(W(),h);var k=h-g|0;for(g=2;g<c;){d=a.C(d,h);var l=b.a[g];l=ZK(W(),l);if(k!==(l-h|0)){d=a.C(d,l);for(g=1+g|0;g<c;)e=b.a[g],W(),d=a.C(d,ZK(0,e)),g=1+g|0;return a.Ma(d,c)}h=l;g=1+g|0}return yL(a.C(a.C(e,k),h))}}
+function JL(a,b,c){var d=b.a.length;switch(d){case 0:return a.Ma(c,0);case 1:return a.Ma(a.C(c,b.a[0]),1);default:var e=b.a[0],g=c=a.C(c,e),h=b.a[1];e=h-e|0;for(var k=2;k<d;){c=a.C(c,h);var l=b.a[k];if(e!==(l-h|0)){c=a.C(c,l);for(k=1+k|0;k<d;)c=a.C(c,b.a[k]),k=1+k|0;return a.Ma(c,d)}h=l;k=1+k|0}return yL(a.C(a.C(g,e),h))}}
+function KL(a,b,c){var d=b.a.length;switch(d){case 0:return a.Ma(c,0);case 1:return d=b.a[0],b=d.W,d=d.Y,a.Ma(a.C(c,YK(W(),new ma(b,d))),1);default:var e=b.a[0],g=e.W;e=e.Y;e=YK(W(),new ma(g,e));g=c=a.C(c,e);var h=b.a[1],k=h.W;h=h.Y;k=YK(W(),new ma(k,h));h=k-e|0;for(e=2;e<d;){c=a.C(c,k);var l=b.a[e],m=l.W;l=l.Y;m=YK(W(),new ma(m,l));if(h!==(m-k|0)){c=a.C(c,m);for(e=1+e|0;e<d;)k=b.a[e],g=k.W,k=k.Y,c=a.C(c,YK(W(),new ma(g,k))),e=1+e|0;return a.Ma(c,d)}k=m;e=1+e|0}return yL(a.C(a.C(g,h),k))}}
+function LL(a,b,c){var d=b.a.length;switch(d){case 0:return a.Ma(c,0);case 1:return a.Ma(a.C(c,b.a[0]),1);default:var e=b.a[0],g=c=a.C(c,e),h=b.a[1];e=h-e|0;for(var k=2;k<d;){c=a.C(c,h);var l=b.a[k];if(e!==(l-h|0)){c=a.C(c,l);for(k=1+k|0;k<d;)c=a.C(c,b.a[k]),k=1+k|0;return a.Ma(c,d)}h=l;k=1+k|0}return yL(a.C(a.C(g,e),h))}}
+function ML(a,b,c){b=b.a.length;switch(b){case 0:return a.Ma(c,0);case 1:return a.Ma(a.C(c,0),1);default:for(var d=c=a.C(c,0),e=0,g=e,h=2;h<b;){c=a.C(c,e);if(g!==(-e|0)){c=a.C(c,0);for(h=1+h|0;h<b;)c=a.C(c,0),h=1+h|0;return a.Ma(c,b)}e=0;h=1+h|0}return yL(a.C(a.C(d,g),e))}}function NL(){}NL.prototype=new p;NL.prototype.constructor=NL;NL.prototype.$classData=q({v4:0},!1,"scala.util.hashing.package$",{v4:1,g:1});var OL;function PL(){}PL.prototype=new p;PL.prototype.constructor=PL;function QL(){}
+QL.prototype=PL.prototype;function Ke(a,b){this.Lz=this.mE=this.dx=this.lE=this.ex=null;this.hx=!1;this.Fu=null;this.Eu=!1;this.jE=this.kE=null;this.le=this.fx=0;this.gx=this.Ol=null;this.Kz=!1;lt(this,a,b,!0,new y(c=>{throw c;}),!1,t().d,(Vs(),"input"))}Ke.prototype=new ot;Ke.prototype.constructor=Ke;Ke.prototype.nQ=function(a){this.Eu&&(a=Es(a),ff(gf(),a+"\n"))};Ke.prototype.$classData=q({vT:0},!1,"Main$$anon$1",{vT:1,PW:1,g:1});
+function ne(a){this.op=null;this.Ui=a;if(null===a)throw null;this.op=a}ne.prototype=new pC;ne.prototype.constructor=ne;ne.prototype.$classData=q({wT:0},!1,"Main$SimplifyPipeline$1$",{wT:1,Maa:1,g:1});
+function ZD(a,b){0===(4&a.$j)<<24>>24&&0===(4&a.$j)<<24>>24&&(a.tQ=new Xc(new Int32Array([1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,5,1,2,5,1,3,2,1,3,2,1,3,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,
 2,1,3,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,5,2,4,27,4,27,4,27,4,27,4,27,6,1,2,1,2,4,27,1,2,0,4,2,24,0,27,1,24,1,0,1,0,1,2,1,0,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,25,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,28,6,7,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,0,1,0,4,24,0,2,0,24,20,0,26,0,6,20,6,24,6,24,6,24,6,0,5,0,5,24,0,16,0,25,24,26,24,28,6,24,0,24,5,4,5,6,9,24,5,6,5,24,5,6,16,28,6,4,6,28,6,5,9,5,28,5,24,0,16,5,6,5,6,0,5,6,5,0,9,5,6,4,28,24,4,0,5,6,4,6,4,6,4,6,0,24,0,5,6,0,24,0,5,0,5,0,6,0,6,8,5,6,8,6,5,8,6,8,6,8,5,6,5,6,24,9,24,4,5,0,5,0,
 6,8,0,5,0,5,0,5,0,5,0,5,0,5,0,6,5,8,6,0,8,0,8,6,5,0,8,0,5,0,5,6,0,9,5,26,11,28,26,0,6,8,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,6,0,8,6,0,6,0,6,0,6,0,5,0,5,0,9,6,5,6,0,6,8,0,5,0,5,0,5,0,5,0,5,0,5,0,6,5,8,6,0,6,8,0,8,6,0,5,0,5,6,0,9,24,26,0,6,8,0,5,0,5,0,5,0,5,0,5,0,5,0,6,5,8,6,8,6,0,8,0,8,6,0,6,8,0,5,0,5,6,0,9,28,5,11,0,6,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,8,6,8,0,8,0,8,6,0,5,0,8,0,9,11,28,26,28,0,8,0,5,0,5,0,5,0,5,0,5,0,5,6,8,0,6,0,6,0,6,0,5,0,5,6,0,9,0,11,28,0,8,0,5,0,5,0,5,0,5,0,5,0,6,5,8,6,8,0,6,8,
@@ -977,7 +1033,7 @@ function sD(a,b){0===(4&a.Oj)<<24>>24&&0===(4&a.Oj)<<24>>24&&(a.aQ=new zd(new In
 6,8,0,9,0,24,5,4,5,28,5,8,0,5,6,5,6,5,6,5,6,5,6,5,0,5,4,24,5,8,6,8,24,5,4,8,6,0,5,0,5,0,5,0,5,0,5,0,5,8,6,8,6,8,24,8,6,0,9,0,5,0,5,0,5,0,19,18,5,0,5,0,2,0,2,0,5,6,5,25,5,0,5,0,5,0,5,0,5,0,5,27,0,5,21,22,0,5,0,5,0,5,26,28,0,6,24,21,22,24,0,6,0,24,20,23,21,22,21,22,21,22,21,22,21,22,21,22,21,22,21,22,24,21,22,24,23,24,0,24,20,21,22,21,22,21,22,24,25,20,25,0,24,26,24,0,5,0,5,0,16,0,24,26,24,21,22,24,25,24,20,24,9,24,25,24,1,21,24,22,27,23,27,2,21,25,22,25,21,22,24,21,22,24,5,4,5,4,5,0,5,0,5,0,5,0,5,
 0,26,25,27,28,26,0,28,25,28,0,16,28,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,24,0,11,0,28,10,11,28,11,0,28,0,28,6,0,5,0,5,0,5,0,11,0,5,10,5,10,0,5,0,24,5,0,5,24,10,0,1,2,5,0,9,0,5,0,5,0,5,0,5,0,5,0,5,0,24,11,0,5,11,0,24,5,0,24,0,5,0,5,0,5,6,0,6,0,6,5,0,5,0,5,0,6,0,6,11,0,24,0,5,11,24,0,5,0,24,5,0,11,5,0,11,0,5,0,11,0,8,6,8,5,6,24,0,11,9,0,6,8,5,8,6,8,6,24,16,24,0,5,0,9,0,6,5,6,8,6,0,9,24,0,6,8,5,8,6,8,5,24,0,9,0,5,6,8,6,8,6,8,6,0,9,0,5,0,10,0,24,0,5,0,5,0,5,0,5,8,0,6,4,0,5,0,28,0,28,0,28,8,6,28,8,16,6,28,6,
 28,6,28,0,28,6,28,0,28,0,11,0,1,2,1,2,0,2,1,2,1,0,1,0,1,0,1,0,1,0,1,2,0,2,0,2,0,2,1,2,1,0,1,0,1,0,1,0,2,1,0,1,0,1,0,1,0,1,0,2,1,2,1,2,1,2,1,2,1,2,1,2,0,1,25,2,25,2,1,25,2,25,2,1,25,2,25,2,1,25,2,25,2,1,25,2,25,2,1,2,0,9,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,5,0,25,0,28,0,28,0,28,0,28,0,28,0,28,0,11,0,28,0,28,0,28,0,28,0,28,0,28,0,28,0,28,0,28,0,28,0,28,0,28,0,28,0,28,0,28,0,28,0,28,0,28,0,28,0,28,0,28,0,28,
-0,28,0,28,0,28,0,5,0,5,0,5,0,5,0,16,0,16,0,6,0,18,0,18,0])),a.Oj=(4|a.Oj)<<24>>24);var c=a.aQ.a;if(0===(2&a.Oj)<<24>>24&&0===(2&a.Oj)<<24>>24){for(var d=new zd(new Int32Array([257,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,3,2,1,1,1,2,1,3,2,4,1,2,1,3,3,2,1,2,1,1,1,1,1,2,1,1,2,1,1,2,1,3,1,1,1,2,2,1,1,
+0,28,0,28,0,28,0,5,0,5,0,5,0,5,0,16,0,16,0,6,0,18,0,18,0])),a.$j=(4|a.$j)<<24>>24);var c=a.tQ.a;if(0===(2&a.$j)<<24>>24&&0===(2&a.$j)<<24>>24){for(var d=new Xc(new Int32Array([257,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,3,2,1,1,1,2,1,3,2,4,1,2,1,3,3,2,1,2,1,1,1,1,1,2,1,1,2,1,1,2,1,3,1,1,1,2,2,1,1,
 3,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,7,2,1,2,2,1,1,4,1,1,1,1,1,1,1,1,69,1,27,18,4,12,14,5,7,1,1,1,17,112,1,1,1,1,1,1,1,1,2,1,3,1,5,2,1,1,3,1,1,1,2,1,17,1,9,35,1,2,3,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,1,1,1,1,1,2,2,51,48,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,2,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,9,38,2,1,6,1,39,1,1,1,4,1,1,45,1,1,1,2,1,2,1,1,8,27,5,3,2,11,5,1,3,2,1,2,2,11,1,2,2,32,1,10,21,10,4,2,1,99,1,1,7,1,1,6,2,2,1,4,2,10,3,2,1,14,1,1,1,1,30,27,2,89,11,1,14,10,33,9,2,1,3,1,5,22,4,1,9,1,3,1,
 5,2,15,1,25,3,2,1,65,1,1,11,55,27,1,3,1,54,1,1,1,1,3,8,4,1,2,1,7,10,2,2,10,1,1,6,1,7,1,1,2,1,8,2,2,2,22,1,7,1,1,3,4,2,1,1,3,4,2,2,2,2,1,1,8,1,4,2,1,3,2,2,10,2,2,6,1,1,5,2,1,1,6,4,2,2,22,1,7,1,2,1,2,1,2,2,1,1,3,2,4,2,2,3,3,1,7,4,1,1,7,10,2,3,1,11,2,1,1,9,1,3,1,22,1,7,1,2,1,5,2,1,1,3,5,1,2,1,1,2,1,2,1,15,2,2,2,10,1,1,15,1,2,1,8,2,2,2,22,1,7,1,2,1,5,2,1,1,1,1,1,4,2,2,2,2,1,8,1,1,4,2,1,3,2,2,10,1,1,6,10,1,1,1,6,3,3,1,4,3,2,1,1,1,2,3,2,3,3,3,12,4,2,1,2,3,3,1,3,1,2,1,6,1,14,10,3,6,1,1,6,3,1,8,1,3,1,23,
@@ -991,2069 +1047,2113 @@ function sD(a,b){0===(4&a.Oj)<<24>>24&&0===(4&a.Oj)<<24>>24&&(a.aQ=new zd(new In
 2,5,2,1,1,1,24,2,1,2,11,1,2,2,2,1,2,1,1,10,6,2,6,2,6,9,7,1,7,145,35,2,1,2,1,2,1,1,1,2,10,6,11172,12,23,4,49,4,2048,6400,366,2,106,38,7,12,5,5,1,1,10,1,13,1,5,1,1,1,2,1,2,1,108,16,17,363,1,1,16,64,2,54,40,12,1,1,2,16,7,1,1,1,6,7,9,1,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,4,3,3,1,4,1,1,1,1,1,1,1,3,1,1,3,1,1,1,2,4,5,1,135,2,1,1,3,1,3,1,1,1,1,1,1,2,10,2,3,2,26,1,1,1,1,1,1,26,1,1,1,1,1,1,1,1,1,2,10,1,45,2,31,3,6,2,6,2,6,2,3,3,2,1,1,1,2,1,1,4,2,10,3,2,2,12,1,26,1,19,1,2,1,15,2,14,34,123,5,3,4,45,3,9,
 53,4,17,1,5,12,52,45,1,130,29,3,49,47,31,1,4,12,17,1,8,1,53,30,1,1,36,4,8,1,5,42,40,40,78,2,10,854,6,2,1,1,44,1,2,3,1,2,23,1,1,8,160,22,6,3,1,26,5,1,64,56,6,2,64,1,3,1,2,5,4,4,1,3,1,27,4,3,4,1,8,8,9,7,29,2,1,128,54,3,7,22,2,8,19,5,8,128,73,535,31,385,1,1,1,53,15,7,4,20,10,16,2,1,45,3,4,2,2,2,1,4,14,25,7,10,6,3,36,5,1,8,1,10,4,60,2,1,48,3,9,2,4,4,7,10,1190,43,1,1,1,2,6,1,1,8,10,2358,879,145,99,13,4,2956,1071,13265,569,1223,69,11,1,46,16,4,13,16480,2,8190,246,10,39,2,60,2,3,3,6,8,8,2,7,30,4,48,34,66,
 3,1,186,87,9,18,142,26,26,26,7,1,18,26,26,1,1,2,2,1,2,2,2,4,1,8,4,1,1,1,7,1,11,26,26,2,1,4,2,8,1,7,1,26,2,1,4,1,5,1,1,3,7,1,26,26,26,26,26,26,26,26,26,26,26,26,28,2,25,1,25,1,6,25,1,25,1,6,25,1,25,1,6,25,1,25,1,6,25,1,25,1,6,1,1,2,50,5632,4,1,27,1,2,1,1,2,1,1,10,1,4,1,1,1,1,6,1,4,1,1,1,1,1,1,3,1,2,1,1,2,1,1,1,1,1,1,1,1,1,1,2,1,1,2,4,1,7,1,4,1,4,1,1,1,10,1,17,5,3,1,5,1,17,52,2,270,44,4,100,12,15,2,14,2,15,1,15,32,11,5,31,1,60,4,43,75,29,13,43,5,9,7,2,174,33,15,6,1,70,3,20,12,37,1,5,21,17,15,63,1,1,
-1,182,1,4,3,62,2,4,12,24,147,70,4,11,48,70,58,116,2188,42711,41,4149,11,222,16354,542,722403,1,30,96,128,240,65040,65534,2,65534])),e=d.a[0],g=1,h=d.a.length;g!==h;)e=e+d.a[g]|0,d.a[g]=e,g=1+g|0;a.$P=d;a.Oj=(2|a.Oj)<<24>>24}a=a.$P;b=Aj(fk(),a,b);return c[0<=b?1+b|0:-1-b|0]}
-function AL(a){0===(32&a.Oj)<<24>>24&&0===(32&a.Oj)<<24>>24&&(a.cQ=new zd(new Int32Array([1632,1776,1984,2406,2534,2662,2790,2918,3046,3174,3302,3430,3664,3792,3872,4160,4240,6112,6160,6470,6608,6784,6800,6992,7088,7232,7248,42528,43216,43264,43472,43600,44016,65296,66720,69734,69872,69942,70096,71360,120782,120792,120802,120812,120822])),a.Oj=(32|a.Oj)<<24>>24);return a.cQ}function BL(){this.cQ=this.aQ=this.$P=this.bQ=null;this.Oj=0}BL.prototype=new p;BL.prototype.constructor=BL;
-function CL(a,b){if(0<=b&&65536>b)return String.fromCharCode(b);if(0<=b&&1114111>=b)return String.fromCharCode(65535&(-64+(b>>10)|55296),65535&(56320|1023&b));throw DL();}function EL(a,b){return 0>b?0:256>b?FL(a).a[b]:sD(a,b)}
-function lH(a,b,c){if(256>b)a=48<=b&&57>=b?-48+b|0:65<=b&&90>=b?-55+b|0:97<=b&&122>=b?-87+b|0:-1;else if(65313<=b&&65338>=b)a=-65303+b|0;else if(65345<=b&&65370>=b)a=-65335+b|0;else{var d=Aj(fk(),AL(a),b);d=0>d?-2-d|0:d;0>d?a=-1:(a=b-AL(a).a[d]|0,a=9<a?-1:a)}return a<c?a:-1}function Nr(a,b){return 0<=b&&31>=b||127<=b&&159>=b}
-function vD(a,b){return 256>b?170===b||186===b||2===FL(a).a[b]:688<=b&&696>=b||704<=b&&705>=b||736<=b&&740>=b||837===b||890===b||7468<=b&&7530>=b||7544===b||7579<=b&&7615>=b||8305===b||8319===b||8336<=b&&8348>=b||8560<=b&&8575>=b||9424<=b&&9449>=b||11388<=b&&11389>=b||42864===b||43E3<=b&&43001>=b||2===sD(a,b)}function AF(a,b){return 8544<=b&&8559>=b||9398<=b&&9423>=b||1===EL(a,b)}function Zq(a,b){a=EL(a,b);return 1===a||2===a||3===a||4===a||5===a}
-function Pba(a){switch(a){case 8115:case 8131:case 8179:return 9+a|0;default:if(8064<=a&&8111>=a)return 8|a;var b=CL(0,a).toUpperCase();switch(b.length){case 1:return b.charCodeAt(0);case 2:var c=b.charCodeAt(0);b=b.charCodeAt(1);return-671032320===(-67044352&(c<<16|b))?(64+(1023&c)|0)<<10|1023&b:a;default:return a}}}
-function Jba(a){if(304===a)return 105;var b=CL(0,a).toLowerCase();switch(b.length){case 1:return b.charCodeAt(0);case 2:var c=b.charCodeAt(0);b=b.charCodeAt(1);return-671032320===(-67044352&(c<<16|b))?(64+(1023&c)|0)<<10|1023&b:a;default:return a}}
-function FL(a){0===(1&a.Oj)<<24>>24&&0===(1&a.Oj)<<24>>24&&(a.bQ=new zd(new Int32Array([15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,12,24,24,24,26,24,24,24,21,22,24,25,24,20,24,24,9,9,9,9,9,9,9,9,9,9,24,24,25,25,25,24,24,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,21,24,22,27,23,27,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,21,25,22,25,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
-15,12,24,26,26,26,26,28,24,27,28,5,29,25,16,28,27,28,25,11,11,27,2,24,24,27,11,5,30,11,11,11,24,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,25,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,25,2,2,2,2,2,2,2,2])),a.Oj=(1|a.Oj)<<24>>24);return a.bQ}BL.prototype.$classData=q({p0:0},!1,"java.lang.Character$",{p0:1,d:1,l:1});var GL;function $q(){GL||(GL=new BL);return GL}function HL(a){throw new IL('For input string: "'+a+'"');}function JL(){this.dQ=this.eQ=null;this.Vs=0}
-JL.prototype=new p;JL.prototype.constructor=JL;
-function KL(a,b){0===(1&a.Vs)<<24>>24&&0===(1&a.Vs)<<24>>24&&(a.eQ=RegExp("^[\\x00-\\x20]*([+-]?(?:NaN|Infinity|(?:\\d+\\.?\\d*|\\.\\d+)(?:[eE][+-]?\\d+)?)[fFdD]?)[\\x00-\\x20]*$"),a.Vs=(1|a.Vs)<<24>>24);var c=a.eQ.exec(b);if(null!==c)b=+parseFloat(c[1]);else{0===(2&a.Vs)<<24>>24&&0===(2&a.Vs)<<24>>24&&(a.dQ=RegExp("^[\\x00-\\x20]*([+-]?)0[xX]([0-9A-Fa-f]*)\\.?([0-9A-Fa-f]*)[pP]([+-]?\\d+)[fFdD]?[\\x00-\\x20]*$"),a.Vs=(2|a.Vs)<<24>>24);var d=a.dQ.exec(b);null===d&&HL(b);a=d[1];c=d[2];var e=d[3];d=
-d[4];""===c&&""===e&&HL(b);b=LL(0,c,e,d,15);b="-"===a?-b:b}return b}
-function LL(a,b,c,d,e){a=""+b+c;c=-(c.length<<2)|0;for(b=0;;)if(b!==a.length&&48===a.charCodeAt(b))b=1+b|0;else break;a=a.substring(b);if(""===a)return 0;var g=a.length;if(b=g>e){for(var h=!1,k=e;!h&&k!==g;)48!==a.charCodeAt(k)&&(h=!0),k=1+k|0;g=h?"1":"0";g=a.substring(0,e)+g}else g=a;c=c+(b?(a.length-(1+e|0)|0)<<2:0)|0;e=+parseInt(g,16);d=+parseInt(d,10);c=Mc(d)+c|0;a=c/3|0;d=+Math.pow(2,a);c=+Math.pow(2,c-(a<<1)|0);return e*d*d*c}
-function yb(a,b,c){return b!==b?c!==c?0:1:c!==c?-1:b===c?0===b?(a=1/b,a===1/c?0:0>a?-1:1):0:b<c?-1:1}JL.prototype.$classData=q({s0:0},!1,"java.lang.Double$",{s0:1,d:1,l:1});var ML;function Ab(){ML||(ML=new JL);return ML}
-function NL(a,b,c,d,e,g){a=OL(""+a+b);b=BH(CH(),c,10)-b.length|0;var h=Pg(Qg(),g);c=h.W;var k=h.Z;h=k>>20;if(0===h)throw new rk("parseFloatCorrection was given a subnormal mid: "+g);g=1048575&k;g=zi(Zh(),new fb(c,1048576|g));c=-1075+h|0;0<=b?0<=c?(a=Vi(a,aj(Zh().Cp,b)),b=Zi(g,c),a=PL(a,b)):a=PL(Zi(Vi(a,aj(Zh().Cp,b)),-c|0),g):0<=c?(b=-b|0,b=Zi(Vi(g,aj(Zh().Cp,b)),c),a=PL(a,b)):(a=Zi(a,-c|0),b=-b|0,b=Vi(g,aj(Zh().Cp,b)),a=PL(a,b));return 0>a?d:0<a?e:0===(1&Og(Qg(),d))?d:e}
-function QL(){this.gQ=null;this.JJ=!1}QL.prototype=new p;QL.prototype.constructor=QL;
-function RL(a,b){a.JJ||a.JJ||(a.gQ=RegExp("^[\\x00-\\x20]*([+-]?)(?:(NaN)|(Infinity)|(?:((?:(\\d+)(?:\\.(\\d*))?|\\.(\\d+))(?:[eE]([+-]?\\d+))?)|(0[xX](?:([0-9A-Fa-f]+)(?:\\.([0-9A-Fa-f]*))?|\\.([0-9A-Fa-f]+))[pP]([+-]?\\d+)))[fFdD]?)[\\x00-\\x20]*$"),a.JJ=!0);a=a.gQ.exec(b);if(null===a)throw new IL('For input string: "'+b+'"');if(void 0!==a[2])b=NaN;else if(void 0!==a[3])b=Infinity;else if(void 0!==a[4]){b=a[5];var c=a[6],d=a[7],e=a[8];b=void 0!==b?b:"";c=""+(void 0!==c?c:"")+(void 0!==d?d:"");e=
-void 0!==e?e:"0";d=+parseFloat(a[4]);var g=Math.fround(d);if(g===d)b=g;else if(Infinity===g)b=3.4028235677973366E38===d?NL(b,c,e,3.4028234663852886E38,g,3.4028235677973366E38):g;else if(g<d){$g||($g=new Ug);if(g!==g||Infinity===g)var h=g;else-0===g?h=1.401298464324817E-45:(h=Og(Qg(),g),h=0<g?1+h|0:-1+h|0,h=Ng(Qg(),h));var k=(g+h)/2;b=d===k?NL(b,c,e,g,h,k):g}else $g||($g=new Ug),g!==g||-Infinity===g?h=g:0===g?h=-1.401298464324817E-45:(h=Og(Qg(),g),h=0<g?-1+h|0:1+h|0,h=Ng(Qg(),h)),k=(g+h)/2,b=d===k?
-NL(b,c,e,h,g,k):g}else b=a[10],c=a[11],e=a[12],b=void 0!==b?b:"",c=""+(void 0!==c?c:"")+(void 0!==e?e:""),e=a[13],b=LL(Ab(),b,c,e,7),b=Math.fround(b);return"-"===a[1]?Math.fround(-b):b}QL.prototype.$classData=q({u0:0},!1,"java.lang.Float$",{u0:1,d:1,l:1});var SL;function TL(){SL||(SL=new QL);return SL}function UL(a){throw new IL('For input string: "'+a+'"');}function VL(){}VL.prototype=new p;VL.prototype.constructor=VL;
-function BH(a,b,c){a=null===b?0:b.length;(0===a||2>c||36<c)&&UL(b);var d=b.charCodeAt(0),e=45===d,g=e?2147483648:2147483647;d=e||43===d?1:0;d>=b.length&&UL(b);for(var h=0;d!==a;){var k=lH($q(),b.charCodeAt(d),c);h=h*c+k;(-1===k||h>g)&&UL(b);d=1+d|0}return e?-h|0:h|0}function XH(a,b){a=b-(1431655765&b>>1)|0;a=(858993459&a)+(858993459&a>>2)|0;return Math.imul(16843009,252645135&(a+(a>>4)|0))>>24}VL.prototype.$classData=q({x0:0},!1,"java.lang.Integer$",{x0:1,d:1,l:1});var WL;
-function CH(){WL||(WL=new VL);return WL}function XL(a){if(!a.tF){for(var b=[],c=0;2>c;)b.push(null),c=1+c|0;for(;36>=c;){for(var d=rc(2147483647,c),e=c,g=1,h="0";e<=d;)e=Math.imul(e,c),g=1+g|0,h+="0";d=e;e=d>>31;var k=Cb(),l=fi(k,-1,-1,d,e);b.push(new Rg(g,new fb(d,e),h,new fb(l,k.Kc)));c=1+c|0}a.sF=b;a.tF=!0}return a.sF}
-function YL(a,b,c){var d=(a.tF?a.sF:XL(a))[c],e=d.kQ;a=e.W;e=e.Z;d=d.G0;var g=-2147483648^e,h="",k=b.W;for(b=b.Z;;){var l=k,m=-2147483648^b;if(m===g?(-2147483648^l)>=(-2147483648^a):m>g){l=k;m=Cb();b=fi(m,l,b,a,e);l=m.Kc;var n=65535&b;m=b>>>16|0;var r=65535&a,u=a>>>16|0,w=Math.imul(n,r);r=Math.imul(m,r);n=Math.imul(n,u);w=w+((r+n|0)<<16)|0;Math.imul(b,e);Math.imul(l,a);Math.imul(m,u);k=(k-w|0).toString(c);h=""+d.substring(k.length)+k+h;k=b;b=l}else break}return""+k.toString(c)+h}
-function ZL(a){throw new IL('For input string: "'+a+'"');}function $L(a,b,c){for(var d=0;a!==b;){var e=lH($q(),c.charCodeAt(a),10);-1===e&&ZL(c);d=Math.imul(d,10)+e|0;a=1+a|0}return d}function aM(){this.sF=null;this.tF=!1}aM.prototype=new p;aM.prototype.constructor=aM;function bM(a,b,c){return 0!==c?(a=(+(c>>>0)).toString(16),b=(+(b>>>0)).toString(16),a+(""+"00000000".substring(b.length)+b)):(+(b>>>0)).toString(16)}aM.prototype.$classData=q({C0:0},!1,"java.lang.Long$",{C0:1,d:1,l:1});var cM;
-function dM(){cM||(cM=new aM);return cM}function eM(){}eM.prototype=new p;eM.prototype.constructor=eM;function fM(){}fM.prototype=eM.prototype;function yK(a){return a instanceof eM||"number"===typeof a||a instanceof fb}function gM(a,b,c,d,e){this.XA=a;this.uF=b;this.YA=c;this.ZA=d;this.WA=e}gM.prototype=new p;gM.prototype.constructor=gM;gM.prototype.h=function(a){return a instanceof gM?this.YA===a.YA&&this.ZA===a.ZA&&this.WA===a.WA&&this.XA===a.XA&&this.uF===a.uF:!1};
-gM.prototype.u=function(){var a="";"\x3cjscode\x3e"!==this.XA&&(a=""+a+this.XA+".");a=""+a+this.uF;null===this.YA?a+="(Unknown Source)":(a=a+"("+this.YA,0<=this.ZA&&(a=a+":"+this.ZA,0<=this.WA&&(a=a+":"+this.WA)),a+=")");return a};gM.prototype.y=function(){return dc(this.XA)^dc(this.uF)^dc(this.YA)^this.ZA^this.WA};var hM=q({O0:0},!1,"java.lang.StackTraceElement",{O0:1,d:1,l:1});gM.prototype.$classData=hM;function iM(){}iM.prototype=new p;iM.prototype.constructor=iM;
-function tM(a,b,c,d){a=c+d|0;if(0>c||a<c||a>b.a.length)throw b=new bH,fF(b,null,null,!0),b;for(d="";c!==a;)d=""+d+String.fromCharCode(b.a[c]),c=1+c|0;return d}
-function Rba(a,b){var c=new uM,d=vM();c.Vu=null;c.n1=d;c.Zs="";c.PJ=!1;if(c.PJ)throw new wM;for(var e=0,g=0,h=6,k=0;k!==h;){var l="\\u%04X".indexOf("%",k)|0;if(0>l){xM(c,"\\u%04X".substring(k));break}xM(c,"\\u%04X".substring(k,l));var m=1+l|0,n=mk().xQ;n.lastIndex=m;var r=n.exec("\\u%04X");if(null===r||(r.index|0)!==m){var u=m===h?37:"\\u%04X".charCodeAt(m);yM(u)}k=n.lastIndex|0;for(var w="\\u%04X".charCodeAt(-1+k|0),y,B=r[2],D=65<=w&&90>=w?256:0,C=B.length,F=0;F!==C;){var I=B.charCodeAt(F);switch(I){case 45:var K=
-1;break;case 35:K=2;break;case 43:K=4;break;case 32:K=8;break;case 48:K=16;break;case 44:K=32;break;case 40:K=64;break;case 60:K=128;break;default:throw new rk(hd(I));}if(0!==(D&K))throw new zM(String.fromCharCode(I));D|=K;F=1+F|0}y=D;var N=AM(r[3]),P=AM(r[4]);if(-2===N)throw new BM(-2147483648);-2===P&&CM(-2147483648);if(110===w){-1!==P&&CM(P);if(-1!==N)throw new BM(N);0!==y&&DM(y);xM(c,"\n")}else if(37===w){-1!==P&&CM(P);17!==(17&y)&&12!==(12&y)||DM(y);if(0!==(1&y)&&-1===N)throw new EM("%"+r[0]);
-0!==(-2&y)&&FM(37,y,-2);GM(c,y,N,"%")}else{var T=0!==(256&y)?65535&(32+w|0):w,aa=mk().wQ.a[-97+T|0];-1!==aa&&0===(256&y&aa)||yM(w);if(0!==(17&y)&&-1===N)throw new EM("%"+r[0]);17!==(17&y)&&12!==(12&y)||DM(y);-1!==P&&0!==(512&aa)&&CM(P);0!==(y&aa)&&FM(T,y,aa);if(0!==(128&y))var Y=g;else{var S=AM(r[1]);if(-1===S)Y=e=1+e|0;else{if(0>=S)throw new HM(0===S?"Illegal format argument index \x3d 0":"Format argument index: (not representable as int)");Y=S}}if(0>=Y||Y>b.a.length)throw new IM("%"+r[0]);g=Y;var Z=
-b.a[-1+Y|0];if(null===Z&&98!==T&&115!==T)JM(c,vM(),y,N,P,"null");else{var ka=void 0,X=void 0,sa=void 0,Ia=void 0,Za=void 0,Ga=c,xa=Z,Ra=T,Ja=y,La=N,pb=P;switch(Ra){case 98:var Fb=!1===xa||null===xa?"false":"true";JM(Ga,vM(),Ja,La,pb,Fb);break;case 104:var Gb=(+(bc(xa)>>>0)).toString(16);JM(Ga,vM(),Ja,La,pb,Gb);break;case 115:xa&&xa.$classData&&xa.$classData.pb.taa?xa.raa(Ga,(0!==(1&Ja)?1:0)|(0!==(2&Ja)?4:0)|(0!==(256&Ja)?2:0),La,pb):(0!==(2&Ja)&&FM(Ra,Ja,2),JM(Ga,0,Ja,La,pb,""+xa));break;case 99:if(xa instanceof
-fa)var Hb=String.fromCharCode(Eb(xa));else{oa(xa)||KM(Ra,xa);var tb=xa|0;if(!(0<=tb&&1114111>=tb))throw new LM(tb);Hb=65536>tb?String.fromCharCode(tb):String.fromCharCode(-64+(tb>>10)|55296,56320|1023&tb)}JM(Ga,0,Ja,La,-1,Hb);break;case 100:if(oa(xa))var kb=""+(xa|0);else if(xa instanceof fb){var gb=Qb(xa),Vb=gb.W,bb=gb.Z;kb=JF(Cb(),Vb,bb)}else xa instanceof MM||KM(Ra,xa),kb=ei(li(),xa);NM(Ga,Ja,La,kb,"");break;case 111:case 120:var nb=111===Ra,Tb=0===(2&Ja)?"":nb?"0":0!==(256&Ja)?"0X":"0x";if(xa instanceof
-MM){var ub=nb?8:16;vM();var Ub=li(),$a=xa.Ya,cb=xa.ub,Na=xa.Pa,Ca=2>ub||36<ub;if(0===$a)Za="0";else if(1===cb){var Ba=Na.a[-1+cb|0],Oa=0;if(0>$a){var wa=Ba,ea=Oa;Ba=-wa|0;Oa=0!==wa?~ea:-ea|0}var la=dM(),Ka=Ba,Ua=Oa;if(10===ub||2>ub||36<ub)Ia=JF(Cb(),Ka,Ua);else{var ya=new fb(Ka,Ua),ib=ya.W,Lb=ya.Z;if(ib>>31===Lb)Ia=ib.toString(ub);else if(0>Lb){var ec=ya.W,Mb=ya.Z;Ia="-"+YL(la,new fb(-ec|0,0!==ec?~Mb:-Mb|0),ub)}else Ia=YL(la,ya,ub)}Za=Ia}else if(10===ub||Ca)Za=ei(li(),xa);else{var Jb=0;Jb=+Math.log(ub)/
-+Math.log(2);var Kb=0>$a?1:0,eb=OM(xa),Wb=Mh(bi(),eb),mc=1+Mc(Wb/Jb+Kb)|0,ua=null;ua="";var Pa=0;Pa=mc;var xb=0;xb=0;if(16!==ub){var Yb=new zd(cb);Na.va(0,Yb,0,cb);var zb=0;zb=cb;for(var Sb=Ub.ZG.a[ub],Ma=Ub.YG.a[-2+ub|0];;){xb=qi(oi(),Yb,Yb,zb,Ma);for(var Ea=Pa;;){Pa=-1+Pa|0;$q();var ab=Kc(xb,ub);if(2>ub||36<ub||0>ab||ab>=ub)var Db=0;else{var mb=-10+ab|0;Db=65535&(0>mb?48+ab|0:97+mb|0)}ua=""+String.fromCharCode(Db)+ua;xb=rc(xb,ub);if(0===xb||0===Pa)break}for(var vb=(Sb-Ea|0)+Pa|0,Ya=0;Ya<vb&&0<Pa;)Pa=
--1+Pa|0,ua="0"+ua,Ya=1+Ya|0;for(Ya=-1+zb|0;0<Ya&&0===Yb.a[Ya];)Ya=-1+Ya|0;zb=1+Ya|0;if(1===zb&&0===Yb.a[0])break}}else for(var Wa=0;Wa<cb;){for(var rb=Wa,pa=0;8>pa&&0<Pa;)xb=15&Na.a[rb]>>(pa<<2),Pa=-1+Pa|0,ua=""+(+(xb>>>0)).toString(16)+ua,pa=1+pa|0;Wa=1+Wa|0}for(var Fa=0;;)if(48===ua.charCodeAt(Fa))Fa=1+Fa|0;else break;0!==Fa&&(ua=ua.substring(Fa));Za=-1===$a?"-"+ua:ua}NM(Ga,Ja,La,Za,Tb)}else{if(oa(xa))var Ib=xa|0,qb=nb?(+(Ib>>>0)).toString(8):(+(Ib>>>0)).toString(16);else{xa instanceof fb||KM(Ra,
-xa);var Nb=Qb(xa),fc=Nb.W,Ac=Nb.Z;if(nb){dM();var tc=1073741823&fc,vc=1073741823&((fc>>>30|0)+(Ac<<2)|0),sc=Ac>>>28|0;if(0!==sc){var uc=(+(sc>>>0)).toString(8),lc=(+(vc>>>0)).toString(8),Wc="0000000000".substring(lc.length),Cc=(+(tc>>>0)).toString(8);sa=uc+(""+Wc+lc)+(""+"0000000000".substring(Cc.length)+Cc)}else if(0!==vc){var Dc=(+(vc>>>0)).toString(8),Ec=(+(tc>>>0)).toString(8);sa=Dc+(""+"0000000000".substring(Ec.length)+Ec)}else sa=(+(tc>>>0)).toString(8)}else sa=bM(dM(),fc,Ac);qb=sa}0!==(76&
-Ja)&&FM(Ra,Ja,76);PM(Ga,vM(),Ja,La,Tb,QM(Ja,qb))}break;case 101:case 102:case 103:if("number"===typeof xa){var Ic=+xa;if(Ic!==Ic||Infinity===Ic||-Infinity===Ic)RM(Ga,Ja,La,Ic);else{mk();if(0===Ic)X=new pk(0>1/Ic,"0",0);else{var Xc=0>Ic,Sc=""+(Xc?-Ic:Ic),oc=dH(Sc,101),qc=0>oc?0:parseInt(Sc.substring(1+oc|0))|0,Tc=0>oc?Sc.length:oc,Nc=dH(Sc,46);if(0>Nc){var Pc=Sc.substring(0,Tc);X=new pk(Xc,Pc,-qc|0)}else{for(var Oc=""+Sc.substring(0,Nc)+Sc.substring(1+Nc|0,Tc),$c=Oc.length,Lc=0;;)if(Lc<$c&&48===Oc.charCodeAt(Lc))Lc=
-1+Lc|0;else break;var Zb=Oc.substring(Lc);X=new pk(Xc,Zb,(-qc|0)+(Tc-(1+Nc|0)|0)|0)}}SM(Ga,X,Ja,pb,Ra,La)}}else if(xa instanceof Mq){mk();var ed=TM(xa),$b=ei(li(),ed);if("0"===$b)ka=new pk(!1,"0",0);else{var Fc=45===$b.charCodeAt(0),Yc=Fc?$b.substring(1):$b;ka=new pk(Fc,Yc,xa.wb)}SM(Ga,ka,Ja,pb,Ra,La)}else KM(Ra,xa);break;case 97:if("number"===typeof xa){var nc=+xa;if(nc!==nc||Infinity===nc||-Infinity===nc)RM(Ga,Ja,La,nc);else{var Ob=Pg(Qg(),nc),cc=Ob.W,Gc=Ob.Z,Bc=1048575&Gc,qd=2047&(Gc>>>20|0),Gd=
-0===pb?1:12<pb?-1:pb,cd=0>Gc?"-":0!==(4&Ja)?"+":0!==(8&Ja)?" ":"";if(0===qd)if(0===cc&&0===Bc)var rd="0",Id=ca,Ha=0;else if(-1===Gd)rd="0",Id=new fb(cc,Bc),Ha=-1022;else{var jc=-11+(0!==Bc?Math.clz32(Bc):32+Math.clz32(cc)|0)|0;rd="1";Id=new fb(0===(32&jc)?cc<<jc:0,1048575&(0===(32&jc)?(cc>>>1|0)>>>(31-jc|0)|0|Bc<<jc:cc<<jc));Ha=-1022-jc|0}else rd="1",Id=new fb(cc,Bc),Ha=-1023+qd|0;var Rb=rd,Uc=Qb(Id),Rc=Ha|0,Cd=Qb(new fb(Uc.W,Uc.Z)),od=Cd.W,Va=Cd.Z;if(-1===Gd)var wb=od,db=Va;else{var Jc=52-(Gd<<2)|
-0,Vc=0===(32&Jc)?1<<Jc:0,Ta=0===(32&Jc)?0:1<<Jc,kd=-1+Vc|0,ld=-1!==kd?Ta:-1+Ta|0,qe=Vc>>>1|0|Ta<<31,Wd=Ta>>1,Rd=od&~kd,Me=Va&~ld,wc=od&kd,Xb=Va&ld;if(Xb===Wd?(-2147483648^wc)<(-2147483648^qe):Xb<Wd)wb=Rd,db=Me;else if(Xb===Wd?(-2147483648^wc)>(-2147483648^qe):Xb>Wd){var gc=Rd+Vc|0;wb=gc;db=(-2147483648^gc)<(-2147483648^Rd)?1+(Me+Ta|0)|0:Me+Ta|0}else if(0===(Rd&Vc)&&0===(Me&Ta))wb=Rd,db=Me;else{var hc=Rd+Vc|0;wb=hc;db=(-2147483648^hc)<(-2147483648^Rd)?1+(Me+Ta|0)|0:Me+Ta|0}}var gd=bM(dM(),wb,db),kc=
-""+"0000000000000".substring(gd.length)+gd;mk();if(13!==kc.length)throw new rk("padded mantissa does not have the right number of bits");for(var ud=1>Gd?1:Gd,za=kc.length;;)if(za>ud&&48===kc.charCodeAt(-1+za|0))za=-1+za|0;else break;var Qa=kc.substring(0,za),xc=cd+(0!==(256&Ja)?"0X":"0x"),yd=Rb+"."+Qa+"p"+Rc;PM(Ga,vM(),Ja,La,xc,QM(Ja,yd))}}else KM(Ra,xa);break;default:throw new rk("Unknown conversion '"+hd(Ra)+"' was not rejected earlier");}}}}return c.u()}
-iM.prototype.$classData=q({P0:0},!1,"java.lang.String$",{P0:1,d:1,l:1});var UM;function hH(){UM||(UM=new iM);return UM}
-function zca(a,b){VM(a);b(a.u());if(0!==a.Px.a.length)for(var c=0;c<a.Px.a.length;)b("  at "+a.Px.a[c]),c=1+c|0;else b("  \x3cno stack trace available\x3e");for(;;)if(a!==a.vF&&null!==a.vF){var d=VM(a);a=a.vF;c=VM(a);var e=c.a.length,g=d.a.length;b("Caused by: "+a);if(0!==e){for(var h=0;;){if(h<e&&h<g){var k=c.a[-1+(e-h|0)|0],l=d.a[-1+(g-h|0)|0];k=null===k?null===l:k.h(l)}else k=!1;if(k)h=1+h|0;else break}0<h&&(h=-1+h|0);d=e-h|0;for(e=0;e<d;)b("  at "+c.a[e]),e=1+e|0;0<h&&b("  ... "+h+" more")}else b("  \x3cno stack trace available\x3e")}else break}
-function fF(a,b,c,d){a.sQ=b;a.vF=c;(a.tQ=d)&&a.XP()}function rg(a){var b=wh().oQ;zca(a,c=>{Af(b,null===c?"null":c);Af(b,"\n")})}
-function VM(a){if(null===a.Px){if(a.tQ){oh||(oh=new nh);var b=oh;var c=a.rQ;if(c)if(c.arguments&&c.stack)var d=jh(c);else if(c.stack&&c.sourceURL)d=c.stack.replace(lh("\\[native code\\]\\n","m"),"").replace(lh("^(?\x3d\\w+Error\\:).*$\\n","m"),"").replace(lh("^@","gm"),"{anonymous}()@").split("\n");else if(c.stack&&c.number)d=c.stack.replace(lh("^\\s*at\\s+(.*)$","gm"),"$1").replace(lh("^Anonymous function\\s+","gm"),"{anonymous}() ").replace(lh("^([^\\(]+|\\{anonymous\\}\\(\\))\\s+\\((.+)\\)$","gm"),
-"$1@$2").split("\n").slice(1);else if(c.stack&&c.fileName)d=c.stack.replace(lh("(?:\\n@:0)?\\s+$","m"),"").replace(lh("^(?:\\((\\S*)\\))?@","gm"),"{anonymous}($1)@").split("\n");else if(c.message&&c["opera#sourceloc"])if(c.stacktrace)if(-1<c.message.indexOf("\n")&&c.message.split("\n").length>c.stacktrace.split("\n").length)d=mh(c);else{d=lh("Line (\\d+).*script (?:in )?(\\S+)(?:: In function (\\S+))?$","i");c=c.stacktrace.split("\n");var e=[];for(var g=0,h=c.length|0;g<h;){var k=d.exec(c[g]);if(null!==
-k){var l=k[3];e.push((void 0!==l?l:"{anonymous}")+"()@"+k[2]+":"+k[1])}g=2+g|0}d=e}else d=mh(c);else if(c.message&&c.stack&&c.stacktrace)if(0>c.stacktrace.indexOf("called from line")){d=kh("^(.*)@(.+):(\\d+)$");c=c.stacktrace.split("\n");e=[];g=0;for(h=c.length|0;g<h;)k=d.exec(c[g]),null!==k&&(l=k[1],e.push((void 0!==l?l+"()":"global code")+"@"+k[2]+":"+k[3])),g=1+g|0;d=e}else{d=kh("^.*line (\\d+), column (\\d+)(?: in (.+))? in (\\S+):$");c=c.stacktrace.split("\n");e=[];g=0;for(h=c.length|0;g<h;)l=
-d.exec(c[g]),null!==l&&(k=l[4]+":"+l[1]+":"+l[2],l=l[2],l=(void 0!==l?l:"global code").replace(kh("\x3canonymous function: (\\S+)\x3e"),"$1").replace(kh("\x3canonymous function\x3e"),"{anonymous}"),e.push(l+"@"+k)|0),g=2+g|0;d=e}else d=c.stack&&!c.fileName?jh(c):[];else d=[];e=d;g=kh("^([^@]*)@(.*?):([0-9]+)(?::([0-9]+))?$");d=[];for(c=0;c<(e.length|0);){k=e[c];if(""!==k)if(h=g.exec(k),null!==h){k=b;l=h[1];var m=kh("^(?:Object\\.|\\[object Object\\]\\.|Module\\.)?\\$(?:ps?|s|f)_((?:_[^_]|[^_])+)__([^\\.]+)$"),
-n=kh("^(?:Object\\.|\\[object Object\\]\\.|Module\\.)?\\$ct_((?:_[^_]|[^_])+)__([^\\.]*)$"),r=kh("^new (?:Object\\.|\\[object Object\\]\\.|Module\\.)?\\$c_([^\\.]+)$"),u=kh("^(?:Object\\.|\\[object Object\\]\\.|Module\\.)?\\$m_([^\\.]+)$"),w=kh("^(?:Object\\.|\\[object Object\\]\\.|Module\\.)?\\$[bc]_([^\\.]+)(?:\\.prototype)?\\.([^\\.]+)$").exec(l);m=null!==w?w:m.exec(l);null!==m?(k=ah(k,m[1]),l=m[2],0<=l.length&&"init___"===l.substring(0,7)?l="\x3cinit\x3e":(u=l.indexOf("__")|0,l=0>u?l:l.substring(0,
-u)),l=[k,l]):(n=n.exec(l),r=null!==n?n:r.exec(l),null!==r?l=[ah(k,r[1]),"\x3cinit\x3e"]:(u=u.exec(l),l=null!==u?[ah(k,u[1]),"\x3cclinit\x3e"]:["\x3cjscode\x3e",l]));k=l[0];l=l[1];u=h[2];r=parseInt(h[3]);h=h[4];h=void 0!==h?parseInt(h)|0:-1;d.push(new gM(k,l,u,r|0,h))}else d.push(new gM("\x3cjscode\x3e",k,null,-1,-1))|0;c=1+c|0}b=d.length|0;e=new (Nd(hM).Ja)(b);for(c=0;c<b;)e.a[c]=d[c],c=1+c|0;b=e}else b=new (Nd(hM).Ja)(0);a.Px=b}return a.Px}
-class oe extends Error{constructor(){super();this.vF=this.sQ=null;this.tQ=!1;this.Px=this.rQ=null}mj(){return this.sQ}XP(){var a=this instanceof pe?this.Dt:this;this.rQ="[object Error]"===Object.prototype.toString.call(a)?a:void 0===Error.captureStackTrace?Error():(Error.captureStackTrace(this),this)}u(){var a=lb(this),b=this.mj();return null===b?a:a+": "+b}y(){return ac.prototype.y.call(this)}h(a){return ac.prototype.h.call(this,a)}get message(){var a=this.mj();return null===a?"":a}get name(){return lb(this)}toString(){return this.u()}}
-function WM(){this.VL=this.VG=this.UL=this.Qy=this.WG=null;XM=this;YM(0,0);YM(1,0);YM(10,0);this.WG=ZM(28,5);for(var a=this.WG.a.length,b=new zd(a),c=0;c<a;){var d=c;b.a[d]=$M(aN(),aN().WG.a[d]);c=1+c|0}this.Qy=ZM(19,10);a=this.Qy.a.length;b=new zd(a);for(c=0;c<a;)d=c,b.a[d]=$M(aN(),aN().Qy.a[d]),c=1+c|0;a=new (Nd(bN).Ja)(11);for(b=0;11>b;)c=b,a.a[c]=YM(c,0),b=1+b|0;this.UL=a;a=new (Nd(bN).Ja)(11);for(b=0;11>b;)c=b,a.a[c]=YM(0,c),b=1+b|0;this.VG=a;this.VL="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"}
-WM.prototype=new p;WM.prototype.constructor=WM;function cN(a,b,c){0===c?(0<=b.Z?(c=b.Z,c=0===c?-2147483637>(-2147483648^b.W):0>c):c=!1,a=c?a.UL.a[b.W]:dN(b,0)):a=0===b.W&&0===b.Z&&0<=c&&c<a.VG.a.length?a.VG.a[c]:dN(b,c);return a}
-function ZM(a,b){var c=new Ad(a);c.a[0]=new fb(1,0);for(var d=1;d<a;){var e=d,g=c.a[-1+e|0],h=b>>31,k=g.W,l=65535&k,m=k>>>16|0,n=65535&b,r=b>>>16|0,u=Math.imul(l,n);n=Math.imul(m,n);var w=Math.imul(l,r);l=u+((n+w|0)<<16)|0;u=(u>>>16|0)+w|0;g=(((Math.imul(k,h)+Math.imul(g.Z,b)|0)+Math.imul(m,r)|0)+(u>>>16|0)|0)+(((65535&u)+n|0)>>>16|0)|0;c.a[e]=new fb(l,g);d=1+d|0}return c}
-function eN(a,b,c,d){a=0>c?-c|0:c;var e=0===c?0:0>c?-1:1;if(Pi().fM===d)return e;if(Pi().aM===d)return 0;if(Pi().$L===d)return 0<e?e:0;if(Pi().bM===d)return 0>e?e:0;if(Pi().dM===d)return 5<=a?e:0;if(Pi().cM===d)return 5<a?e:0;if(Pi().qC===d)return 5<(a+b|0)?e:0;if(Pi().eM===d){if(0===c)return 0;throw new zc("Rounding necessary");}throw new rk(d);}
-function fN(a,b){a=b.Z;(-1===a?0>(-2147483648^b.W):-1>a)?a=!0:(a=b.Z,a=0===a?-1<(-2147483648^b.W):0<a);if(a)throw new zc("Out of int range: "+b);return b.W}function $M(a,b){b=0>b.Z?new fb(~b.W,~b.Z):b;a=b.W;b=b.Z;return 64-(0!==b?Math.clz32(b):32+Math.clz32(a)|0)|0}function gN(a,b,c){return!hN(0,b,c)}function hN(a,b,c){a=c.a.length;for(var d=0;d!==a;){if(c.a[d]===b)return!0;d=1+d|0}return!1}WM.prototype.$classData=q({iT:0},!1,"java.math.BigDecimal$",{iT:1,d:1,l:1});var XM;
-function aN(){XM||(XM=new WM);return XM}function iN(){this.XG=this.YL=this.oC=this.Dp=this.Cp=this.bw=null;jN=this;this.bw=yi(1,1);this.Cp=yi(1,10);this.Dp=yi(0,0);this.oC=yi(-1,1);this.YL=new (Nd(Ui).Ja)([this.Dp,this.bw,yi(1,2),yi(1,3),yi(1,4),yi(1,5),yi(1,6),yi(1,7),yi(1,8),yi(1,9),this.Cp]);for(var a=new (Nd(Ui).Ja)(32),b=0;32>b;){var c=b,d=Zh();a.a[c]=zi(d,new fb(0===(32&c)?1<<c:0,0===(32&c)?0:1<<c));b=1+b|0}this.XG=a}iN.prototype=new p;iN.prototype.constructor=iN;
-function zi(a,b){if(0>b.Z)return-1!==b.W||-1!==b.Z?(a=b.W,b=b.Z,kN(-1,new fb(-a|0,0!==a?~b:-b|0))):a.oC;var c=b.Z;return(0===c?-2147483638>=(-2147483648^b.W):0>c)?a.YL.a[b.W]:kN(1,b)}iN.prototype.$classData=q({kT:0},!1,"java.math.BigInteger$",{kT:1,d:1,l:1});var jN;function Zh(){jN||(jN=new iN);return jN}
-function lN(){this.eM=this.qC=this.cM=this.dM=this.bM=this.$L=this.aM=this.fM=null;mN=this;this.fM=new nN("UP",0);this.aM=new nN("DOWN",1);this.$L=new nN("CEILING",2);this.bM=new nN("FLOOR",3);this.dM=new nN("HALF_UP",4);this.cM=new nN("HALF_DOWN",5);this.qC=new nN("HALF_EVEN",6);this.eM=new nN("UNNECESSARY",7)}lN.prototype=new p;lN.prototype.constructor=lN;lN.prototype.$classData=q({uT:0},!1,"java.math.RoundingMode$",{uT:1,d:1,l:1});var mN;function Pi(){mN||(mN=new lN);return mN}function oN(){}
-oN.prototype=new p;oN.prototype.constructor=oN;function pN(){}pN.prototype=oN.prototype;oN.prototype.h=function(a){if(a===this)return!0;if(a&&a.$classData&&a.$classData.pb.zQ&&this.ka()===a.ka()){var b=this.lF().Uu();a:{for(;b.s();){var c=b.t(),d=a.nF(c.Nn());c=c.On();if(null===d?null!==c:!Pb(d,c)){a=!0;break a}}a=!1}return!a}return!1};oN.prototype.y=function(){for(var a=this.lF().Uu(),b=0;a.s();){var c=b;b=a.t();c|=0;b=b.y()+c|0}return b|0};
-oN.prototype.u=function(){for(var a="{",b=!0,c=this.lF().Uu();c.s();){var d=c.t();b?b=!1:a+=", ";a=""+a+d.Nn()+"\x3d"+d.On()}return a+"}"};function qN(){}qN.prototype=new p;qN.prototype.constructor=qN;qN.prototype.Fa=function(a,b){return ob(a,b)};qN.prototype.$classData=q({b1:0},!1,"java.util.Arrays$NaturalComparator$",{b1:1,d:1,Si:1});var rN;function yj(){rN||(rN=new qN);return rN}function sN(){}sN.prototype=new tk;sN.prototype.constructor=sN;
-sN.prototype.$classData=q({l1:0},!1,"java.util.Formatter$RootLocaleInfo$",{l1:1,uaa:1,d:1});var tN;function vM(){tN||(tN=new sN);return tN}function uN(){this.$A=this.RJ=0;this.QJ=this.aB=null}uN.prototype=new p;uN.prototype.constructor=uN;function vN(){}vN.prototype=uN.prototype;uN.prototype.s=function(){if(null!==this.aB)return!0;for(;this.$A<this.RJ;){var a=this.QJ.kl.a[this.$A];this.$A=1+this.$A|0;if(null!==a)return this.aB=a,!0}return!1};
-uN.prototype.t=function(){if(!this.s())throw iH("next on empty iterator");var a=this.aB;this.aB=a.Nq;return a};function wN(a,b,c,d,e){this.bB=a;this.Rx=b;this.Wu=c;this.Nq=e}wN.prototype=new p;wN.prototype.constructor=wN;f=wN.prototype;f.Nn=function(){return this.bB};f.On=function(){return this.Wu};f.h=function(a){if(vk(a)){var b=this.bB,c=a.Nn();if(null===b?null===c:Pb(b,c))return b=this.Wu,a=a.On(),null===b?null===a:Pb(b,a)}return!1};
-f.y=function(){var a=this.Rx,b=this.Wu;return a^(a>>>16|0)^(null===b?0:bc(b))};f.u=function(){return this.bB+"\x3d"+this.Wu};var xN=q({q1:0},!1,"java.util.HashMap$Node",{q1:1,d:1,AQ:1});wN.prototype.$classData=xN;function yN(a){this.TJ=null;this.TJ=new zN(a.cB.Yu)}yN.prototype=new p;yN.prototype.constructor=yN;yN.prototype.s=function(){return this.TJ.s()};yN.prototype.t=function(){return new AN(this.TJ.t())};
-yN.prototype.$classData=q({u1:0},!1,"java.util.IdentityHashMap$EntrySet$$anon$2",{u1:1,d:1,K1:1});function AN(a){this.yF=a}AN.prototype=new p;AN.prototype.constructor=AN;f=AN.prototype;f.h=function(a){return vk(a)?Object.is(this.Nn(),a.Nn())?Object.is(this.On(),a.On()):!1:!1};f.Nn=function(){return this.yF.Nn().Sx};f.On=function(){return this.yF.On()};f.y=function(){var a=this.yF.On();return bd(this.yF.Nn().Sx)^bd(a)};f.u=function(){return this.Nn()+"\x3d"+this.On()};
-f.$classData=q({w1:0},!1,"java.util.IdentityHashMap$MapEntry",{w1:1,d:1,AQ:1});function BN(){}BN.prototype=new p;BN.prototype.constructor=BN;BN.prototype.jo=function(a,b,c){a.a[b]=c};BN.prototype.Lj=function(a,b){return a.a[b]};BN.prototype.$classData=q({X1:0},!1,"java.util.internal.GenericArrayOps$ReusableAnyRefArrayOps$",{X1:1,d:1,dB:1});var CN;function zj(){CN||(CN=new BN);return CN}function DN(a){if(null===a.$u)throw FH("No match available");return a.$u}
-function Sp(a,b){this.UJ=a;this.BQ=b;this.CQ=0;this.Zu=this.BQ;this.AF=0;this.$u=null;this.Tx=0}Sp.prototype=new p;Sp.prototype.constructor=Sp;function Rp(a){a.AF=0;a.$u=null;a.Tx=0;a.$u=a.UJ.NQ.exec(a.Zu);return null!==a.$u}function EN(a){var b=a.UJ;var c=a.Zu;var d=b.aK;d.lastIndex=a.AF;c=d.exec(c);b=b.aK.lastIndex|0;a.AF=null!==c?b===(c.index|0)?1+b|0:b:1+a.Zu.length|0;a.$u=c;return null!==c}function FN(a){return(DN(a).index|0)+a.CQ|0}function GN(a){var b=FN(a);a=DN(a)[0];return b+a.length|0}
-Sp.prototype.$classData=q({Z1:0},!1,"java.util.regex.Matcher",{Z1:1,d:1,waa:1});function jl(a,b,c,d,e,g,h){this.NQ=this.aK=null;this.MQ=a;this.k2=d;this.l2=e;this.i2=g;this.j2=h;this.aK=new RegExp(c,this.k2+(this.l2?"gy":"g"));this.NQ=new RegExp("^(?:"+c+")$",d)}jl.prototype=new p;jl.prototype.constructor=jl;jl.prototype.u=function(){return this.MQ};jl.prototype.$classData=q({$1:0},!1,"java.util.regex.Pattern",{$1:1,d:1,l:1});
-var Bca=function Aca(a,b){if(a instanceof Im){var d=a.xr,e=a.zr;return(b?"":"; ")+rz(a.yr,!1)+" \x3d\x3e "+rz(d,!1)+Aca(e,!1)}if(a instanceof Mm)return(b?"":"; ")+"_ \x3d\x3e "+rz(a.qq,!1);if(Nm()===a)return"";throw new x(a);};function rba(a){return!!(a&&a.$classData&&a.$classData.pb.iM)}function HN(a){this.Cb=null;if(null===a)throw null;this.Cb=new IN(a,Wp(),Wp())}HN.prototype=new p;HN.prototype.constructor=HN;HN.prototype.$classData=q({dU:0},!1,"mlscript.ConstraintSolver$Shadows$",{dU:1,d:1,l:1});
-function JN(){this.td=null}JN.prototype=new Cy;JN.prototype.constructor=JN;function KN(){}KN.prototype=JN.prototype;function LN(){}LN.prototype=new p;LN.prototype.constructor=LN;function Kq(a,b,c,d){return new fg(MN(b.e().i(),c),b,d)}LN.prototype.$classData=q({rU:0},!1,"mlscript.ErrorReport$",{rU:1,d:1,l:1});var NN;function Jq(){NN||(NN=new LN);return NN}function ON(){this.Kg=null;PN=this;this.Kg=new jt(!1,!1,!1)}ON.prototype=new p;ON.prototype.constructor=ON;
-ON.prototype.$classData=q({wU:0},!1,"mlscript.FldFlags$",{wU:1,d:1,l:1});var PN;function Ct(){PN||(PN=new ON);return PN}
-function Cca(a){if(a instanceof st){var b=a.Jp,c=k=>{if(k instanceof me)k=k.ia;else{if(!(k instanceof te))throw new x(k);k=k.ca}return k};if(b===v())return v();a=b.e();var d=a=new A(c(a),v());for(b=b.g();b!==v();){var e=b.e();e=new A(c(e),v());d=d.r=e;b=b.g()}return a}if(a instanceof lt)return c=a.Kp,a=a.Lp,d=O().c,new A(c,new A(a,d));if(a instanceof Kt)return c=a.Qt,a=O().c,new A(c,a);if(a instanceof Jt)return c=a.pw,d=a.qw,a=a.ow,b=O().c,new A(c,new A(d,new A(a,b)));if(a instanceof kt)return c=
-a.ro,d=a.so,a=a.to,b=O().c,new A(c,new A(d,new A(a,b)));if(a instanceof Rt){c=a.Rt;a=a.St;for(b=d=null;a!==v();){var g=a.e();e=g.i();g=g.j();var h=O().c;for(e=new lq(new A(e,new A(g,h)));e.s();)g=new A(e.t(),v()),null===b?d=g:b.r=g,b=g;a=a.g()}a=null===d?v():d;return new A(c,a)}throw new x(a);}
-var Dca=function QN(a){if(a instanceof lt){var c=a.Lp;return"("+rz(a.Kp,!1)+") then "+rz(c,!1)}if(a instanceof Kt)return"else "+rz(a.Qt,!1);if(a instanceof st)return a=a.Jp.m(),a=new eg(a,new z(e=>{if(e instanceof me)return e.ia.mr();if(!(e instanceof te))throw new x(e);return QN(e.ca)})),"\u2039"+Qe(a,"","; ","")+"\u203a";if(a instanceof kt){c=a.so;var d=a.to;return rz(a.ro,!1)+" "+rz(c,!1)+" "+QN(d)}if(a instanceof Rt)return c=a.St,a=rz(a.Rt,!1),c=c.m(),c=new eg(c,new z(e=>{if(null!==e){var g=e.j();
-return"\u00b7 "+rz(e.i(),!1)+" "+QN(g)}throw new x(e);})),a+" \u2039"+Qe(c,"","; ","")+"\u203a";if(a instanceof Jt)return c=a.qw,d=a.ow,(a.az?"rec ":"")+"let "+rz(a.pw,!1)+" \x3d "+rz(c,!1)+" in "+QN(d);throw new x(a);};function RN(){this.KC=null;SN=this;this.KC=TN().$s()}RN.prototype=new p;RN.prototype.constructor=RN;
-function TN(){return Wy(Xy(),J(new L,[G(new H,"**",14),G(new H,"*",13),G(new H,"/",13),G(new H,"%",13),G(new H,"+",12),G(new H,"-",12),G(new H,"\x3c\x3c",11),G(new H,"\x3e\x3e",11),G(new H,"\x3e\x3e\x3e",11),G(new H,"\x3c",10),G(new H,"\x3c\x3d",10),G(new H,"\x3e",10),G(new H,"\x3e\x3d",10),G(new H,"in",10),G(new H,"instanceof",10),G(new H,"\x3d\x3d",9),G(new H,"!\x3d",9),G(new H,"\x3d\x3d\x3d",9),G(new H,"!\x3d\x3d",9),G(new H,"\x26",8),G(new H,"^",7),G(new H,"|",6),G(new H,"\x26\x26",5),G(new H,
-"||",4),G(new H,"??",4),G(new H,",",1)]))}RN.prototype.$classData=q({aV:0},!1,"mlscript.JSBinary$",{aV:1,d:1,l:1});var SN;function Zn(){SN||(SN=new RN);return SN}function UN(){this.fz=2}UN.prototype=new p;UN.prototype.constructor=UN;UN.prototype.$classData=q({jV:0},!1,"mlscript.JSCommaExpr$",{jV:1,d:1,l:1});var VN;function Kp(){VN||(VN=new UN);return VN}function WN(){}WN.prototype=new yp;WN.prototype.constructor=WN;function XN(){}XN.prototype=WN.prototype;WN.prototype.DJ=function(){return!1};
-function jn(a){return new so((t(),new M(a)))}function Sy(a,b){return new lo(new vo(a,b))}function Baa(a,b,c){c=c.Ga(new z(d=>{if(null!==d)return new YN(d.i(),d.j());throw new x(d);})).ea();t();return new ZN(a,c,new M(new $N(b)))}function Jp(a,b){return a.ih()<b?Ep(a.xa(),!0):a.xa()}function aO(){}aO.prototype=new p;aO.prototype.constructor=aO;
-function uo(a){var b=g=>{var h=t().f;return G(new H,g,h)};if(a===v())b=v();else{var c=a.e(),d=c=new A(b(c),v());for(a=a.g();a!==v();){var e=a.e();e=new A(b(e),v());d=d.r=e;a=a.g()}b=c}return new oo(b)}aO.prototype.$classData=q({zV:0},!1,"mlscript.JSLetDecl$",{zV:1,d:1,l:1});var bO;function to(){bO||(bO=new aO)}function cO(){}cO.prototype=new p;cO.prototype.constructor=cO;
-function Bp(a,b){a=b.length;for(var c=new jd(a),d=0;d<a;){var e=d,g=b.charCodeAt(d);switch(g){case 34:g='\\"';break;case 92:g="\\\\";break;case 8:g="\\b";break;case 12:g="\\f";break;case 10:g="\\n";break;case 13:g="\\r";break;case 9:g="\\t";break;default:g=0<g&&255>=g&&!Nr($q(),g)?String.fromCharCode(g):Qba(Q(),J(new L,[g]))}c.a[e]=g;d=1+d|0}return Qe(new $t(c),'"',"",'"')}cO.prototype.$classData=q({BV:0},!1,"mlscript.JSLit$",{BV:1,d:1,l:1});var dO;function Cp(){dO||(dO=new cO);return dO}
-function eO(){}eO.prototype=new yp;eO.prototype.constructor=eO;function fO(){}fO.prototype=eO.prototype;function gO(){}gO.prototype=new yp;gO.prototype.constructor=gO;function hO(){}hO.prototype=gO.prototype;
-function ag(){this.gH=this.hH=this.Ur=this.Th=null;this.UM=!0;yD();var a=new CD;zD(a,t().f);t();var b=J(new L,"true false NaN id emptyArray succ error length concat join add sub mul div gt not ne eq sgt slt sge sle typeof toString String negate eq unit log discard".split(" "));for(b=le(v(),b);!b.b();){var c=b.e();hp(a,new Sn(c,c));b=b.g()}b=new bn("anything",O().c,Jl());a.Fn.Vi(b.tq,b);b=new bn("nothing",O().c,Il());a.Fn.Vi(b.tq,b);t();b=J(new L,["int","number","bool","string","unit"]);for(b=le(v(),
-b);!b.b();)c=b.e(),c=new bn(c,O().c,new sp(c)),a.Fn.Vi(c.tq,c),b=b.g();this.Th=a;this.Ur=(Vy(),new Gy);this.hH=Ko(this.Th,"results");this.gH=Ko(this.Th,"prettyPrint");Tn(this.Ur,"prettyPrint",this.gH)}ag.prototype=new Pn;ag.prototype.constructor=ag;
-function $f(a,b){var c=b.zz;je();var d=new Wo;je();for(var e=new Wo,g=c;!g.b();){var h=g.e();if(h&&h.$classData&&h.$classData.pb.If){var k=h;t();var l=new me(k)}else if(h instanceof Kn){var m=h;t();l=new me(m)}else{h instanceof io||Dn("Program reached and unexpected state.");var n=h;t();l=new te(n)}if(l instanceof te)ip(d,l.ca);else if(l instanceof me)ip(e,l.ia);else throw new x(l);g=g.g()}var r=d.ea(),u=e.ea(),w=a.Th,y=O().c,B=xD(w,"TypingUnit");je();var D=new Wo;je();for(var C=new Wo,F=y;!F.b();){var I=
-F.e();a:{if(I instanceof Kn){var K=I,N=K.Sd,P=K.Qb,T=K.qh,aa=K.cd;if(null!==P){var Y=P.w;if(aa instanceof te){var S=aa.ca;if(N.b()||(N.b()?0:N.o())){O();var Z=new rp(!(N.b()||!N.o()),new sp(B),new Wl(Y),T,(O(),new te(S)));var ka=new te(Z);break a}}}}O();ka=new me(I)}if(ka instanceof te)ip(D,ka.ca);else if(ka instanceof me)ip(C,ka.ia);else throw new x(ka);F=F.g()}var X=D.ea(),sa=C.ea();je();var Ia=new Wo;je();for(var Za=new Wo,Ga=sa;!Ga.b();){var xa=Ga.e();a:{if(xa instanceof Kn){var Ra=xa,Ja=Ra.Sd,
-La=Ra.Qb,pb=Ra.qh,Fb=Ra.cd;if(null!==La){var Gb=La.w;if(Fb instanceof me){var Hb=Fb.ia;if(Ja.b()||(Ja.b()?0:Ja.o())){O();var tb=new rp(!(Ja.b()||!Ja.o()),new sp(B),new Wl(Gb),pb,(O(),new me(Hb)));var kb=new te(tb);break a}}}}O();kb=new me(xa)}if(kb instanceof te)ip(Ia,kb.ca);else if(kb instanceof me)ip(Za,kb.ia);else throw new x(kb);Ga=Ga.g()}var gb=Ia.ea(),Vb=Za.ea(),bb=new $m(B,O().c,new En(O().c),X,gb,Vb,O().c,r,t().f);lp(w,bb);var nb=gn(a.Th,"typing_unit",new M(!1),!1,t().f),Tb=a.Th,ub=qo(a,bb,
-t().f,!0,Tb),Ub=new hn(nb.Ze,new Om(new Em(bb.gj))),$a=r;a:for(var cb;;)if($a.b()){cb=v();break}else{var Na=$a.e(),Ca=$a.g();if(!1===!!Na.Vk.b())$a=Ca;else for(var Ba=$a,Oa=Ca;;){if(Oa.b())cb=Ba;else{if(!1!==!!Oa.e().Vk.b()){Oa=Oa.g();continue}for(var wa=Oa,ea=new A(Ba.e(),v()),la=Ba.g(),Ka=ea;la!==wa;){var Ua=new A(la.e(),v());Ka=Ka.r=Ua;la=la.g()}for(var ya=wa.g(),ib=ya;!ya.b();){if(!1===!!ya.e().Vk.b()){for(;ib!==ya;){var Lb=new A(ib.e(),v());Ka=Ka.r=Lb;ib=ib.g()}ib=ya.g()}ya=ya.g()}ib.b()||(Ka.r=
-ib);cb=ea}break a}}if(cb===v())var ec=v();else{for(var Mb=cb.e(),Jb=new A(Po(Mb,nb.Ze),v()),Kb=Jb,eb=cb.g();eb!==v();){var Wb=eb.e(),mc=new A(Po(Wb,nb.Ze),v());Kb=Kb.r=mc;eb=eb.g()}ec=Jb}for(var ua=new Em(a.hH),Pa=v(),xb=Vo(new Wo,Pa),Yb=new hn(a.hH,new Mo(O().c)),zb=new A(ub,new A(Ub,ec)),Sb=u,Ma=null,Ea=null;Sb!==v();){var ab=Sb.e(),Db=!1,mb=null;a:{if(ab instanceof Kn){Db=!0;mb=ab;var vb=mb.Sd,Ya=mb.Qb,Wa=mb.bj,rb=mb.cd;if(null!==Ya){var pa=Ya.w;if(rb instanceof te){var Fa=rb.ca,Ib=!(!vb.b()&&
-!vb.o()),qb=vb.b();if(Wa.b())var Nb=R();else{var fc=Wa.o();Nb=new M(fc.w)}if(Ib){var Ac=qb?R():new M(!0),tc=gn(a.Th,pa,Ac,mo(new no(a,Fa)),t().f),vc=Lm(a,Fa,a.Th),sc=a.Th,uc=tc;sc.Fn.lB(uc.OI);sc.Yo.HF(uc.Ze);var lc=qb?R():new M(!1),Wc=gn(a.Th,pa,lc,mo(new no(a,Fa)),Nb),Cc=vc,Dc=Wc}else{var Ec=Lm(a,Fa,a.Th),Ic=qb?R():new M(!1),Xc=gn(a.Th,pa,Ic,mo(new no(a,Fa)),Nb);Cc=Ec;Dc=Xc}var Sc=Cc,oc=Dc,qc=oc.MI.b()&&!oc.NI?new bo(O().c,(t(),new te(Sc))):Sc;ip(xb,oc.Ze);var Tc=a.Th.Gn,Nc=new hn(oc.Ze,qc),Pc=
-Gm(cm(),ua,"push"),Oc=new Em(oc.Ze),$c=O().c,Lc=new lo(new Rm(Pc,new A(Oc,$c))),Zb=O().c;var ed=Ao(Tc,new A(Nc,new A(Lc,Zb)));break a}}}if(Db){var $b=mb.cd;if(null!==mb.Qb&&$b instanceof me){ed=O().c;break a}}if(ab instanceof xo||ab instanceof yo||ab instanceof zo)throw new Am("Def and TypeDef are not supported in NewDef files.");if(ab instanceof Ln){var Fc=Lm(a,ab,a.Th),Yc=Fc.xa().Hf,nc=Qe(Yc,"","\n","");ip(xb,nc);var Ob=a.Th.Gn,cc=Gm(cm(),ua,"push"),Gc=O().c,Bc=new lo(new Rm(cc,new A(Fc,Gc))),qd=
-O().c;ed=Ao(Ob,new A(Bc,qd))}else throw new x(ab);}for(var Gd=ed.m();Gd.s();){var cd=new A(Gd.t(),v());null===Ea?Ma=cd:Ea.r=cd;Ea=cd}Sb=Sb.g()}var rd=null===Ma?v():Ma,Id=mn(zb,rd),Ha=new A(Yb,Id),jc=Gm(cm(),ua,"map"),Rb=J(new L,[new Em(a.gH)]),Uc=jn(new Rm(jc,(je(),le(v(),Rb)))),Rc=O().c,Cd=new A(Uc,Rc),od=t().f,Va=O().c;t();for(var wb,db=a.Ur,Jc=db.Az,Vc=iO().Db(),Ta=Jc.m();Ta.s();){var kd=Ta.t();if(null===kd)throw new x(kd);var ld=kd.i(),qe=kd.j();if(db.EH.L(ld))var Wd=t().f;else{var Rd=Vy().zN.Y(ld);
-if(Rd instanceof M){var Me=Rd.k;db.EH.eh(ld);t();var wc=Me.LP(qe);Wd=new M(wc)}else{if(t().f!==Rd)throw new x(Rd);Wd=t().f}}Vc.oc(Wd)}wb=Vc.Eb().ea();var Xb=Fl(Fl(Cd,Ha),wb),gc=new H;var hc=(new Sm(od,Va,new me(Xb),O().c)).xa().Hf;if(hc===v())var gd=v();else{for(var kc=hc.e(),ud=new A(kc.u(),v()),za=ud,Qa=hc.g();Qa!==v();){var xc=Qa.e(),yd=new A(xc.u(),v());za=za.r=yd;Qa=Qa.g()}gd=ud}return G(gc,gd,xb.ea())}ag.prototype.$classData=q({OV:0},!1,"mlscript.JSWebBackend",{OV:1,W$:1,d:1});
-function jO(){}jO.prototype=new p;jO.prototype.constructor=jO;function Et(a,b){a=b.m();t();for(b=R();a.s();){var c=b;b=a.t();c.b()?b=b.C():(b=Zs(c.o(),b.C()),b=bt().n(b))}return b}jO.prototype.$classData=q({WV:0},!1,"mlscript.Loc$",{WV:1,d:1,l:1});var kO;function Dt(){kO||(kO=new jO);return kO}function lO(){}lO.prototype=new p;lO.prototype.constructor=lO;function dg(a){Sf();a=a.m();return Tf(0,new ho(a,new z(b=>Hn(b.wo,new mO(b)))),!0,"?")}
-function nO(a,b){a=new oO(b);b=O().c;return new zq(new A(a,b))}function pf(a,b){a=new uq(b);b=O().c;return new zq(new A(a,b))}lO.prototype.$classData=q({YV:0},!1,"mlscript.Message$",{YV:1,d:1,l:1});var pO;function qf(){pO||(pO=new lO);return pO}function Us(a,b,c,d){this.qz=this.ND=this.Hw=this.MD=this.Iw=null;this.Lw=!1;this.Xt=null;this.Wt=!1;this.KD=this.LD=null;this.Rd=this.Jw=0;this.Kw=this.Fl=null;this.pz=!1;this.hN=null;if(null===a)throw null;this.hN=a;xs(this,a.ND,b,a.Lw,a.Xt,a.Wt,c,d)}
-Us.prototype=new As;Us.prototype.constructor=Us;Us.prototype.VP=function(a){Yr(this.hN,new U(()=>"\x3e "+Zr(a)))};Us.prototype.$classData=q({qW:0},!1,"mlscript.NewParser$$anon$1",{qW:1,oW:1,d:1});function Ds(a){this.gk=this.mH=null;if(null===a)throw null;this.gk=a;this.mH=new qO(a,Jf())}Ds.prototype=new p;Ds.prototype.constructor=Ds;
-Ds.prototype.jC=function(){var a;a:for(a=this.gk.Kw;;){var b=!1,c=null,d=ef(this.gk,new ff(269),new gf("go"));if(d instanceof A){b=!0;c=d;var e=c.A;if(null!==e){var g=e.i();e=e.j();if(g instanceof Jr&&(g=g.Ta,a.pm.L(g))){d=this.gk;b=new mf(new nf(J(new L,["Repeated modifier `","`"])));c=[pf(qf(),g)];b=sf(b,J(new L,c));t();b=G(new H,b,new M(e));c=O().c;wf(d,new A(b,c));is(this.gk,new ff(272),new gf("go"));hs(this.gk);continue}}}if(b&&(g=c.A,null!==g&&(e=g.i(),g=g.j(),e instanceof Jr&&"declare"===e.Ta))){is(this.gk,
-new ff(276),new gf("go"));hs(this.gk);d=a;a=a.pm.mm(G(new H,"declare",g));a=new qO(d.$r,a);continue}if(b&&(g=c.A,null!==g&&(e=g.i(),g=g.j(),e instanceof Jr&&"virtual"===e.Ta))){is(this.gk,new ff(280),new gf("go"));hs(this.gk);d=a;a=a.pm.mm(G(new H,"virtual",g));a=new qO(d.$r,a);continue}if(b&&(g=c.A,null!==g&&(e=g.i(),g=g.j(),e instanceof Jr&&"abstract"===e.Ta))){is(this.gk,new ff(284),new gf("go"));hs(this.gk);d=a;a=a.pm.mm(G(new H,"abstract",g));a=new qO(d.$r,a);continue}if(a.pm.b())break a;if(b&&
-(e=c.A,null!==e&&(e=e.i(),e instanceof Jr&&(e=e.Ta,"class"===e||"infce"===e||"trait"===e||"mixin"===e||"type"===e||"namespace"===e||"module"===e||"fun"===e||"val"===e))))break a;if(b&&(b=c.A,null!==b)){c=b.i();b=b.j();d=this.gk;e=new mf(new nf(J(new L,["Unexpected "," token after modifier",""])));c=[pf(qf(),c.yb()),0<a.pm.Pk(1)?pf(qf(),"s"):pf(qf(),"")];c=sf(e,J(new L,c));t();b=G(new H,c,new M(b));c=O().c;wf(d,new A(b,c));break a}a=O().c;(null===a?null===d:a.h(d))&&$n();throw new x(d);}this.gk.Kw=
-a;t();a=G(new H,a,this.gk.Fl);return new M(a)};Ds.prototype.$classData=q({sW:0},!1,"mlscript.NewParser$ModifierSet$",{sW:1,d:1,l:1});function rO(a){this.Rf=null;if(null===a)throw null;this.Rf=a}rO.prototype=new p;rO.prototype.constructor=rO;function sO(a,b){var c=a.Rf,d=a.Rf,e=Mu(),g=mu(),h=ap().wa;e=e.fg(new ou(g,h));a=pu(a.Rf);g=Mu();h=mu();var k=ap().wa;b=new tO(d,b,e,a,g.fg(new ou(h,k)));d=O().c;return new uO(c,new A(b,d))}
-function Eca(a,b){var c=a.Rf;b=b.Ba.m();b=new eg(b,new z(d=>{var e=a.Rf;d=new xv(a.Rf,d.i(),d.j());var g=Mu(),h=mu(),k=ap().wa;g=g.fg(new ou(h,k));h=pu(a.Rf);k=Mu();var l=mu(),m=ap().wa;return new tO(e,d,g,h,k.fg(new ou(l,m)))}));je();return new uO(c,le(v(),b))}function vO(a,b){return b?new uO(a.Rf,O().c):sO(a,Av(a.Rf))}
-function wO(a,b,c,d,e,g,h,k,l){for(;;){var m=!1,n=null,r=d;if(r instanceof Tu){a:{var u=a,w=r,y=id();try{var B=xO(u.Rf),D=Mv(Av(u.Rf),w);if(D.b())throw fq(new gq,y,vO(xO(u.Rf),!0));var C=sO(B,D.o())}catch(Lc){if(Lc instanceof gq){var F=Lc;if(F.Hg===y){C=F.wj();break a}throw F;}throw Lc;}}return C}if(r instanceof Uu){var I=r,K=a.Rf,N=O().c,P=new A(I,N),T=t().f,aa=Ku(),Y=mu(),S=ap().wa;return sO(a,new yv(K,P,T,aa.Ch(new ou(Y,S))))}if(r instanceof dv)return Eca(a,r);if(r instanceof gA)return vO(a,!r.sh);
-if(r instanceof nA){var Z=r,ka=Z.dc,X=Z.nc,sa=wO(a,b,c,Z.cc,e,g,h,k,l),Ia=wO(a,b,c,ka,e,g,h,k,l);if(X){var Za=sa,Ga=X,xa=g,Ra=k,Ja=Ia.Sp;if(Ja===v())var La=v();else{for(var pb=Ja.e(),Fb=new A(yO(Za,pb,Ga,xa,Ra),v()),Gb=Fb,Hb=Ja.g();Hb!==v();){var tb=Hb.e(),kb=new A(yO(Za,tb,Ga,xa,Ra),v());Gb=Gb.r=kb;Hb=Hb.g()}La=Fb}for(var gb=vO(xO(Za.Mw),!1),Vb=La;!Vb.b();){var bb=gb,nb=Vb.e();gb=zO(bb,nb);Vb=Vb.g()}var Tb=gb}else Tb=zO(sa,Ia);return Tb}if(r instanceof oA){var ub=r.xc,Ub=a.Rf,$a=ZA(YA(a.Rf),b,c,
-ub,!e,g,h,k,l).ae;if($a===v())var cb=v();else{for(var Na=$a.e(),Ca=new A(new tO(Na.xb,Na.$f,Na.Sf,Na.Zf,Na.ag),v()),Ba=Ca,Oa=$a.g();Oa!==v();){var wa=Oa.e(),ea=new A(new tO(wa.xb,wa.$f,wa.Sf,wa.Zf,wa.ag),v());Ba=Ba.r=ea;Oa=Oa.g()}cb=Ca}return new uO(Ub,cb)}if(r instanceof Ow){m=!0;n=r;DB(a.Rf);var la=n.Wb;if(!la.b()){var Ka=la.o();if(!PC(h)&&!l.L(n)){var Ua=l.Yb(n),ya=b,ib=c,Lb=Ua;return wO(xO(a.Rf),ya,ib,Ka,e,g,h,k,Lb)}}}if(m){Mu();var ec=n,Mb=mu(),Jb=ap().wa,Kb=void 0,eb=void 0,Wb=Nu(ec,new ou(Mb,
-Jb)),mc=a.Rf,ua=a.Rf;null===ua.Xp&&null===ua.Xp&&(ua.Xp=new AO(ua));eb=ua.Xp;var Pa=eb.OD,xb=Av(eb.OD),Yb=pu(eb.OD),zb=Mu(),Sb=mu(),Ma=ap().wa;Kb=new tO(Pa,xb,Wb,Yb,zb.fg(new ou(Sb,Ma)));var Ea=O().c;return new uO(mc,new A(Kb,Ea))}if(r instanceof sB){var ab=r;tB(a.Rf);t();var Db=ab.gc(),mb=new M(Db);if(!mb.b()){d=mb.k;continue}}if(r instanceof uv){var vb=r,Ya=vb.ob;if(PC(h)&&!a.Rf.Em.L(Ya.X)||!rA(vb,g)){var Wa=a.Rf,rb=a.Rf,pa=a.Rf,Fa=O().c,Ib=t().f;Ku();var qb=G(new H,Ya,vb),Nb=mu(),fc=ap().wa,Ac=
-new yv(pa,Fa,Ib,nv(qb,new ou(Nb,fc))),tc=Mu(),vc=mu(),sc=ap().wa,uc=tc.fg(new ou(vc,sc)),lc=pu(a.Rf),Wc=Mu(),Cc=mu(),Dc=ap().wa,Ec=new tO(rb,Ac,uc,lc,Wc.fg(new ou(Cc,Dc))),Ic=O().c;return new uO(Wa,new A(Ec,Ic))}d=sA(vb,g)}else if(r instanceof wB){var Xc=r,Sc=Xc.vg,oc=Xc.Jf;d=e?oc:Sc}else if(r instanceof px){var qc=r,Tc=qc.ve;b=qc.Ld;d=Tc}else if(r instanceof yB){var Nc=r,Pc=Nc.ej,Oc=g.fa,$c=Fl(c,Nc.Aj);b=Oc;c=$c;d=Pc}else throw new x(r);}}
-rO.prototype.$classData=q({wW:0},!1,"mlscript.NormalForms$CNF$",{wW:1,d:1,l:1});function BO(a){this.Tp=null;if(null===a)throw null;this.Tp=a}BO.prototype=new p;BO.prototype.constructor=BO;BO.prototype.$classData=q({yW:0},!1,"mlscript.NormalForms$Conjunct$",{yW:1,d:1,l:1});
-var Gca=function Fca(a,b,c,d,e,g,h){if(hf(new E(c),d))return wA(d,b,!1,new Um((l,m)=>Fca(a,l,m,d,e,g,h)),e);if(b instanceof M)return CO(a,g,h,c,!!b.k,e,!0,!1);if(t().f===b)return sv(rv(a.qf),CO(a,g,h,c,!1,e,!0,!1),CO(a,g,h,c,!0,e,!0,!1),tv(rv(a.qf)),e);throw new x(b);};function DO(a){this.qf=null;if(null===a)throw null;this.qf=a}DO.prototype=new p;DO.prototype.constructor=DO;
-function EO(a,b,c,d){var e=a.qf,g=Mu(),h=mu(),k=ap().wa;g=g.fg(new ou(h,k));h=Av(a.qf);k=Mu();var l=mu(),m=ap().wa;d=new FO(e,d,g,h,k.fg(new ou(l,m)));e=O().c;return GO(a,b,c,new A(d,e))}function GO(a,b,c,d){a=new HO(a.qf,b,c,d);0===(4&a.qm)<<24>>24&&0===(4&a.qm)<<24>>24&&(a.kN=RA(a)?a.db:a.Ca(),a.qm=(4|a.qm)<<24>>24);c=a.kN;return c<b?new HO(a.hk,c,a.Ff,a.ae):a}function IO(a,b){return b?EO(a,a.qf.md,O().c,pu(a.qf)):new HO(a.qf,a.qf.md,O().c,O().c)}
-function JO(a,b,c,d,e,g,h){return ZA(a,b,c,CO(a,b,c,d,e,g,!1,!0),e,g,!1,!0,h)}function CO(a,b,c,d,e,g,h,k){if(d instanceof qA)return e=CO(a,b,c,d.yi,e,g,h,k),Vw(e.p,e,d.qa());if(d instanceof wB){var l=d.vg,m=d.Jf;e=CO(a,b,c,e?m:l,e,g,h,k);return Vw(e.p,e,d.qa())}l=Wp();h=ZA(a,b,c,d,e,g,h,k,l).nf(!1);t();return wA(h,new M(e),!1,new Um((n,r)=>Gca(a,n,r,d,g,b,c)),g)}
-function ZA(a,b,c,d,e,g,h,k,l){for(;;){var m=!1,n=null,r=e?jba(d,g,h):d;if(r instanceof Tu){var u=r,w=YA(a.qf),y=b,B=c,D=a.qf;t();var C=new M(u),F=Mu(),I=mu(),K=ap().wa,N=F.fg(new ou(I,K)),P=Su(k)?u.Ap():Ou(Pu(a.qf)),T=Ku(),aa=mu(),Y=ap().wa;return EO(w,y,B,new eu(D,C,N,P,T.Ch(new ou(aa,Y))))}if(r instanceof Uu){var S=r,Z=YA(a.qf),ka=b,X=c,sa=a.qf,Ia=t().f;Mu();var Za=mu(),Ga=ap().wa,xa=Nu(S,new ou(Za,Ga)),Ra=Ou(Pu(a.qf)),Ja=Ku(),La=mu(),pb=ap().wa;return EO(Z,ka,X,new eu(sa,Ia,xa,Ra,Ja.Ch(new ou(La,
-pb))))}if(r instanceof dv){var Fb=r,Gb=YA(a.qf),Hb=b,tb=c,kb=a.qf,gb=t().f,Vb=Mu(),bb=mu(),nb=ap().wa,Tb=Vb.fg(new ou(bb,nb)),ub=Ku(),Ub=mu(),$a=ap().wa;return EO(Gb,Hb,tb,new eu(kb,gb,Tb,Fb,ub.Ch(new ou(Ub,$a))))}if(r instanceof gA)return IO(a,!r.sh);if(r instanceof nA){var cb=r,Na=cb.dc,Ca=e,Ba=ZA(a,b,c,cb.cc,e,g,h,k,l),Oa=ZA(a,b,c,Na,e,g,h,k,l),wa=g,ea=k;return cb.nc?KO(Ba,Oa,wa,ea):Hca(Ba,Oa,Ca,wa,ea)}if(r instanceof oA){var la=r.xc,Ka=YA(a.qf),Ua=b,ya=c,ib=wO(xO(a.qf),b,O().c,la,!e,g,h,k,l).Sp;
-if(ib===v())var Lb=v();else{for(var ec=ib.e(),Mb=new A(new FO(ec.bs,ec.cs,ec.ds,ec.es,ec.fs),v()),Jb=Mb,Kb=ib.g();Kb!==v();){var eb=Kb.e(),Wb=new A(new FO(eb.bs,eb.cs,eb.ds,eb.es,eb.fs),v());Jb=Jb.r=Wb;Kb=Kb.g()}Lb=Mb}return GO(Ka,Ua,ya,Lb)}if(r instanceof Ow){m=!0;n=r;DB(a.qf);var mc=n.Wb;if(!mc.b()){var ua=mc.o();if(!PC(h)&&!l.L(n)){var Pa=l.Yb(n),xb=b,Yb=c,zb=Pa;return ZA(YA(a.qf),xb,Yb,ua,e,g,h,k,zb)}}}if(m){var Sb=YA(a.qf),Ma=b,Ea=c,ab=LO(a.qf);Mu();var Db=n,mb=mu(),vb=ap().wa,Ya=ab,Wa=Nu(Db,
-new ou(mb,vb)),rb=Ya.Tp,pa=pu(Ya.Tp),Fa=Av(Ya.Tp),Ib=Mu(),qb=mu(),Nb=ap().wa;var fc=new FO(rb,pa,Wa,Fa,Ib.fg(new ou(qb,Nb)));var Ac=O().c;return GO(Sb,Ma,Ea,new A(fc,Ac))}if(r instanceof sB){var tc=r;tB(a.qf);t();var vc=tc.gc(),sc=new M(vc);if(!sc.b()){d=sc.k;continue}}if(r instanceof uv){var uc=r,lc=uc.ob;if(PC(h)&&!a.qf.Em.L(lc.X)||!rA(uc,g)){var Wc=b,Cc=c,Dc=a.qf,Ec=vv(uc,g),Ic=Mu(),Xc=mu(),Sc=ap().wa,oc=Ic.fg(new ou(Xc,Sc)),qc=Ou(Pu(a.qf)),Tc=Ku(),Nc=[G(new H,lc,uc)],Pc=J(new L,Nc),Oc=mu(),$c=
-ap().wa;return EO(a,Wc,Cc,new eu(Dc,Ec,oc,qc,Tc.eF(Pc,new ou(Oc,$c))))}d=sA(uc,g)}else if(r instanceof wB){var Lc=r,Zb=Lc.vg,ed=Lc.Jf;d=e?ed:Zb}else if(r instanceof px){var $b=r,Fc=$b.ve;b=$b.Ld;d=Fc}else if(r instanceof yB){var Yc=r,nc=Yc.ej;c=Fl(c,Yc.Aj);d=nc}else throw new x(r);}}DO.prototype.$classData=q({AW:0},!1,"mlscript.NormalForms$DNF$",{AW:1,d:1,l:1});function AO(a){this.OD=null;if(null===a)throw null;this.OD=a}AO.prototype=new p;AO.prototype.constructor=AO;
-AO.prototype.$classData=q({CW:0},!1,"mlscript.NormalForms$Disjunct$",{CW:1,d:1,l:1});function Ax(a){if(a instanceof Kn)return"definition";if(a instanceof io)return"type declaration";throw new x(a);}
-function Ica(a){var b=!1,c=null;if(a instanceof Kn){b=!0;c=a;var d=c.Sd,e=c.Qb,g=c.bj;if(t().f===d)return"fun"+(g.b()?"":" ("+g.o().w+")")+" "+e.w}if(b&&(d=c.Sd,e=c.Qb,g=c.bj,d instanceof M&&!1===!!d.k))return"let"+(g.b()?"":" "+g.o().w+")")+" "+e.w;if(b&&(b=c.Sd,d=c.Qb,c=c.bj,b instanceof M&&!0===!!b.k))return"let rec"+(c.b()?"":" "+c.o().w+")")+" "+d.w;if(a instanceof io){d=a.nb;var h=a.bg;g=a.Lg;e=a.xj;b=a.ti;c=d.td;a=a.eb.X;if(h.b())var k="";else{if(h===v())k=v();else{k=h.e();var l=k=new A(k.j().X,
-v());for(h=h.g();h!==v();){var m=h.e();m=new A(m.j().X,v());l=l.r=m;h=h.g()}}k=Qe(k,"\u2039",", ","\u203a")}g.b()?g="":(g=g.o(),g="("+qz(g)+")");e.b()?e="":(e=e.o(),e=": "+MO(e));d=b.b()?"":hf(new E(d),np())?" \x3d ":": ";b=b.m();b=new eg(b,new z(n=>rz(n,!1)));return c+" "+a+k+g+e+d+Qe(b,"",", ","")}throw new x(a);}
-function Jca(a){if(a instanceof io&&et(new E(a.nb),pp())){var b=a.Lg;if(b.b())return R();var c=b.o();b=new Wl("_");a=new em(new Wl("x"),new sp(a.sf.w));var d=c.Ra;c=k=>{if(null!==k){var l=new M(k);if(!l.b()&&(l=l.k.i(),l instanceof M)){var m=l.k;k=t().f;l=Ct().Kg;var n=new Wl("x"),r=new Wl("#"+m.w);m=m.C();l=new ws(l,new nm(n,aq(r,m)));return G(new H,k,l)}}if(null!==k&&(l=new M(k),!l.b()&&(k=l.k.i(),l=l.k.j(),t().f===k&&null!==l&&(m=l.Da,m instanceof Wl))))return k=t().f,l=Ct().Kg,n=new Wl("x"),r=
-new Wl("#"+m.w),m=m.C(),l=new ws(l,new nm(n,aq(r,m))),G(new H,k,l);Dn("Program reached and unexpected state.")};if(d===v())c=v();else{var e=d.e(),g=e=new A(c(e),v());for(d=d.g();d!==v();){var h=d.e();h=new A(c(h),v());g=g.r=h;d=d.g()}c=e}g=new om(!1,b,a,new im(c));b=t().f;a=new Wl("unapply");c=t().f;e=O().c;t();d=t().f;h=new ws(Ct().Kg,new Wl("x"));d=G(new H,d,h);h=O().c;g=new lm(new im(new A(d,h)),g);return new M(new Kn(b,a,c,e,new te(g),t().f,t().f,t().f,t().f,!0))}return t().f}
-function NO(a){this.uN=null;this.qH=!1;this.tN=null;if(null===a)throw null;this.tN=a}NO.prototype=new p;NO.prototype.constructor=NO;NO.prototype.$classData=q({XW:0},!1,"mlscript.NuTypeDefs$RefMap$",{XW:1,d:1,l:1});function OO(a,b,c){if(0<=a.length&&"'"===a.substring(0,1))var d=!0;else d=JD().BP,d=0<=a.length&&a.substring(0,d.length)===d;b=d?"":b;d=c.Y(a);if(d instanceof M)return d=d.k|0,c.Qh(a,1+d|0),""+b+a+d;if(t().f===d)return c.Qh(a,0),""+b+a;throw new x(d);}function PO(){}PO.prototype=new p;
-PO.prototype.constructor=PO;
-function Tf(a,b,c,d){a=b.m();je();a=le(v(),a);for(var e=b=null;a!==v();){for(var g=QO(a.e()).m();g.s();){var h=new A(g.t(),v());null===e?b=h:e.r=h;e=h}a=a.g()}a=null===b?v():b;a=Kl(a);a=ft(a,new z(n=>{var r=n.Go;if(r instanceof te)return t(),n=G(new H,n.Rz,n),new te(n);if(r instanceof me)return r=r.ia,t(),n=G(new H,r,n),new me(n);throw new x(r);}));if(null===a)throw new x(a);g=a.i();b=a.j();je();e=new Wo;je();for(a=new Wo;!g.b();){h=g.e();a:{if(null!==h){var k=h.i(),l=h.j();if(k instanceof M){h=k.k;
-t();h=G(new H,h,l);h=new te(h);break a}}if(null!==h&&(l=h.i(),k=h.j(),t().f===l)){t();h=new me(k);break a}throw new x(h);}if(h instanceof te)ip(e,h.ca);else if(h instanceof me)ip(a,h.ia);else throw new x(h);g=g.g()}e=e.ea();a=a.ea();var m=ru().U();h=mn(b,e);b=n=>{if(null!==n){var r=n.i();n=n.j();Q();r=0<=r.length&&r.substring(0,d.length)===d?r.substring(d.length):r;r=OO(r,d,m);return G(new H,n,r)}throw new x(n);};if(h===v())b=v();else{e=h.e();g=e=new A(b(e),v());for(h=h.g();h!==v();)l=h.e(),l=new A(b(l),
-v()),g=g.r=l,h=h.g();b=e}ap();b=bp(cp(),b);e=m.Pq();O();e=new Gx(new RO(0,new z(n=>{n|=0;var r=n/26|0;t();n=G(new H,String.fromCharCode(65535&(97+(n%26|0)|0))+(hf(new E(r),0)?"":""+r),1+n|0);return new M(n)})),e,!0);e=new eg(e,new z(n=>OO(n,d,m)));return new SO(b.oe(bg(a,e)),!1,0,c,!1)}PO.prototype.$classData=q({DX:0},!1,"mlscript.ShowCtx$",{DX:1,d:1,l:1});var TO;function Sf(){TO||(TO=new PO);return TO}
-function UO(a){var b=!1,c=null;if(a instanceof io){b=!0;c=a;var d=c.nb;mp()===d&&$n()}b&&(d=c.nb,Qo()===d&&$n());if(b){d=c.nb;var e=c.eb,g=c.bg,h=c.Lg,k=c.xj,l=c.ti,m=c.hs,n=c.Uh;if(np()===d){if(!h.b()&&!h.o().Ra.b())throw dk("requirement failed: "+h);a=l.K();if(!hf(new E(a),0))throw dk("requirement failed: "+l);Os(fp(),!k.b());if(!m.b())throw dk("requirement failed: "+m);if(!zf(n).b())throw dk("requirement failed: "+n);a=O().c;if(g===v())c=v();else for(c=g.e(),b=c=new A(c.j(),v()),g=g.g();g!==v();)l=
-g.e(),l=new A(l.j(),v()),b=b.r=l,g=g.g();k.b()&&Dn("Program reached and unexpected state.");d=new yo(d,e,c,k.o(),O().c,O().c,O().c,t().f);e=O().c;return G(new H,a,new A(d,e))}}if(b&&(d=c.nb,e=c.eb,k=c.bg,g=c.Lg,b=c.ti,pp()===d||tp()===d)){c=g.b()?new im(O().c):g.o();g=c.Ra;var r=mE(iE());a=B=>{if(null!==B){var D=B.i(),C=B.j();if(D instanceof M&&(D=D.k,null!==C)){var F=C.vc;C=C.Da;if(null!==F)return B=F.pf,C=VO(C,r),B=new Cn(B?(t(),new M(C)):t().f,C),G(new H,D,B)}}if(null!==B&&(D=B.i(),B=B.j(),t().f===
-D&&null!==B&&(C=B.vc,D=B.Da,null!==C&&(B=C.pf,D instanceof Wl))))return B?(t(),B=Il(),B=new M(B)):B=t().f,B=new Cn(B,Jl()),G(new H,D,B);Dn("Program reached and unexpected state.")};if(g===v())l=v();else for(l=g.e(),m=l=new A(a(l),v()),n=g.g();n!==v();)h=n.e(),h=new A(a(h),v()),m=m.r=h,n=n.g();a=ap();a=l.Gb(a.wa).i();if(b===v())b=v();else{m=b.e();n=m=new A(VO(m,r),v());for(b=b.g();b!==v();)h=b.e(),h=new A(VO(h,r),v()),n=n.r=h,b=b.g();b=m}b=b.we(new En(l),Fn());l=new Wl(e.X);m=e.C();l=aq(l,m);t();m=
-t().f;n=Ct().Kg;h=B=>{if(null!==B){var D=B.i(),C=B.j();if(D instanceof M)return B=D.k,C=new ws(new jt(!1,!1,C.vc.ri),B),G(new H,B,C)}if(null!==B&&(C=B.i(),B=B.j(),t().f===C&&null!==B&&(C=B.Da,C instanceof Wl)))return G(new H,C,B);Dn("Program reached and unexpected state.")};if(g===v())g=v();else{var u=g.e(),w=u=new A(h(u),v());for(g=g.g();g!==v();){var y=g.e();y=new A(h(y),v());w=w.r=y;g=g.g()}g=u}g=new ws(n,new Zl(g));g=G(new H,m,g);m=O().c;c=new lm(c,new mm(l,new im(new A(g,m))));c=new xo(!1,l,
-new te(c),!0);g=r.ea();if(k===v())k=v();else{l=k.e();m=l=new A(l.j(),v());for(k=k.g();k!==v();)n=k.e(),n=new A(n.j(),v()),m=m.r=n,k=k.g();k=l}d=new yo(d,e,k,b,O().c,O().c,a,t().f);e=O().c;return G(new H,g,new A(d,new A(c,e)))}if(Nx(a))return d=O().c,e=O().c,G(new H,d,new A(a,e));throw new x(a);}
-function WO(a){if(a instanceof hm){a=a.Sh;var b=O().c;return new A(a,b)}if(a instanceof Wl)return O().c;if(a instanceof em)return a=a.Ni,b=O().c,new A(a,b);if(a instanceof lm){b=a.Dl;a=a.El;var c=O().c;return new A(b,new A(a,c))}if(a instanceof mm)return b=a.kb,a=a.hc,c=O().c,new A(b,new A(a,c));if(a instanceof im){c=a.Ra;if(c===v())return v();a=c.e();b=a=new A(a.j().Da,v());for(c=c.g();c!==v();){var d=c.e();d=new A(d.j().Da,v());b=b.r=d;c=c.g()}return a}if(a instanceof Zl){c=a.vn;if(c===v())return v();
-a=c.e();b=a=new A(a.j().Da,v());for(c=c.g();c!==v();)d=c.e(),d=new A(d.j().Da,v()),b=b.r=d,c=c.g();return a}if(a instanceof nm)return b=a.Co,a=a.wn,c=O().c,new A(b,new A(a,c));if(a instanceof om)return b=a.Pp,a=a.vo,c=O().c,new A(b,new A(a,c));if(a instanceof pm)return a.Rk;if(a instanceof fm)return O().c;if(a instanceof qm)return b=a.wu,a=a.vu,c=O().c,new A(b,new A(a,c));if(a instanceof rm)return b=a.Fp,a=a.Ep,c=O().c,new A(b,new A(a,c));if(a instanceof xo)return b=a.Gp,a=a.zM,c=O().c,new A(b,new A(a,
-c));if(a instanceof yo){b=a.Hz;c=a.Jz;d=a.Fz;a=a.Iz;var e=O().c;a=Fl(Fl(new A(d,e),a),c);return new A(b,a)}if(a instanceof sm)return b=a.fu,a=a.gu,c=O().c,new A(b,new A(a,c));if(a instanceof tm)return b=a.Qr,a=a.rw.ea(),new A(b,a);if(a instanceof Kn)return b=a.Qb,c=a.qh,d=a.bj.ea(),a=a.pN,e=O().c,a=Fl(Fl(new A(a,e),c),d),new A(b,a);if(a instanceof km)return new A(a.ym,a.ts);if(a instanceof um)return a=a.gs,b=O().c,new A(a,b);if(a instanceof zm)return b=a.cu,a=a.du,c=O().c,new A(b,new A(a,c));if(a instanceof
-wm)return new A(a.tu,a.uu);if(a instanceof vm)return b=a.Pt,a=a.Ir,c=O().c,Fl(new A(a,c),b);if(a instanceof xm)return O().c;if(a instanceof zo)return b=a.Cr,a=a.Br,c=O().c,new A(b,new A(a,c));if(a instanceof ym)return b=a.Ip,a=a.Er,c=O().c,new A(b,new A(a,c));if(a instanceof io){b=a.eb;var g=a.bg;e=a.Lg;c=a.ti;d=a.hs;a=a.Uh;if(g===v())var h=v();else{h=g.e();var k=h=new A(h.j(),v());for(g=g.g();g!==v();){var l=g.e();l=new A(l.j(),v());k=k.r=l;g=g.g()}}e=e.ea();d=d.ea();k=O().c;a=Fl(Fl(Fl(Fl(new A(a,
-k),d),c),e),h);return new A(b,a)}throw new x(a);}
-function lx(a){if(a instanceof zo){var b=a.Br;return"constructor("+qz(a.Cr)+") "+rz(b,!1)}if(a instanceof Ln)return rz(a,!1);if(a instanceof XO){a:{var c=!1;b=null;if(a instanceof xo){c=!0;b=a;var d=b.Gp;if(!0===b.Dr){b="rec def "+rz(d,!1);break a}}if(c&&(c=b.Gp,!1===b.Dr)){b="def "+rz(c,!1);break a}if(a instanceof yo){var e=a.Jz;b=a.Iz;c=a.Gz.td;d=a.Hz.X;if(e.b())var g="";else{if(e===v())g=v();else{g=e.e();var h=g=new A(g.X,v());for(e=e.g();e!==v();){var k=e.e();k=new A(k.X,v());h=h.r=k;e=e.g()}}g=
-Qe(g,"[",", ","]")}b=c+" "+d+g+(b.b()?"":Qe(b,"(",", ",")"))}else throw new x(a);}c=a instanceof yo&&et(new E(a.Gz),np())?" \x3d ":": ";b+=c;if(a instanceof xo)if(a=a.Ot,a instanceof me)a=MO(a.ia);else{if(!(a instanceof te))throw new x(a);a=rz(a.ca,!1)}else if(a instanceof yo)a=MO(a.Fz);else throw new x(a);return b+a}if(a instanceof Rs){b=Ica(a);if(a instanceof Kn)c=a.cd.BJ()?" \x3d ":": ";else{if(!(a instanceof io))throw new x(a);c=" "}b+=c;if(a instanceof Kn)if(a=a.cd,a instanceof me)a=MO(a.ia);
-else{if(!(a instanceof te))throw new x(a);a=rz(a.ca,!1)}else if(a instanceof io)a=YO(a.Uh);else throw new x(a);return b+a}throw new x(a);}function VO(a,b){a=An(a);if(a instanceof te)return b.S(a.ca),Jl();if(a instanceof me)return a.ia;throw new x(a);}
-function Kca(a){if(a instanceof En){var b=a.rs;if(b===v())return v();var c=b.e();a=c=new A(c.i().w,v());for(b=b.g();b!==v();){var d=b.e();d=new A(d.i().w,v());a=a.r=d;b=b.g()}return c}if(a instanceof ZO)return c=a.Tr,a=rn(a.Sr),c=rn(c),mn(a,c);if(a instanceof $O||a instanceof nt||a instanceof aP||a instanceof bP||a instanceof cP||a instanceof dP||a instanceof eP||Jl()===a||Il()===a||a instanceof fP||a instanceof ns||a instanceof gP||a instanceof sp||a instanceof hP||a instanceof iP||a instanceof jP||
-a instanceof mt||a instanceof kP)return O().c;throw new x(a);}
-function Lca(a){if(a instanceof sp){a=a.X;var b=O().c;return new A(a,b)}if(a instanceof gP&&(b=a.dw,null!==b))return a=b.X,b=O().c,new A(a,b);if(a instanceof ZO)return b=a.Tr,a=un(a.Sr),b=un(b),mn(a,b);if(a instanceof $O||a instanceof nt||a instanceof En||a instanceof aP||a instanceof bP||a instanceof cP||a instanceof dP||a instanceof eP||Jl()===a||Il()===a||a instanceof mt||a instanceof fP||a instanceof ns||a instanceof hP||a instanceof iP||a instanceof jP||a instanceof kP)return O().c;throw new x(a);
-}function MO(a){Sf();var b=O().c;b=Tf(0,new A(a,b),!0,"'");return Yf(a,b,0)}function lP(a,b){return b?"("+a+")":a}
-function mP(a,b){if(null!==a){var c=a.Pf,d=a.Jg;if(t().f===c)return Yf(d,b,0)}if(null!==a&&(c=a.Pf,d=a.Jg,c instanceof M&&hf(new E(c.k),d)))return Yf(d,b,0);if(null!==a&&(d=a.Pf,c=a.Jg,d instanceof M&&(d=d.k,Il()===d)))return"out "+Yf(c,b,0);if(null!==a&&(d=a.Pf,c=a.Jg,d instanceof M&&(d=d.k,Jl()===c)))return"in "+Yf(d,b,0);if(null!==a&&(c=a.Pf,d=a.Jg,c instanceof M))return"in "+Yf(c.k,b,0)+" out "+Yf(d,b,0);throw new x(a);}
-function nP(a,b){var c=h=>{var k=h.j().Pf.b()?"":"mut ",l=h.i();l=l.b()?"":l.o().w+": ";return k+l+mP(h.j(),b)};if(a===v())return v();var d=a.e(),e=d=new A(c(d),v());for(a=a.g();a!==v();){var g=a.e();g=new A(c(g),v());e=e.r=g;a=a.g()}return d}
-var Yf=function oP(a,b,c){var e=!1,g=null,h=!1,k=null,l=!1,m=null,n=!1,r=null,u=!1,w=null;if(Jl()===a)return"anything";if(Il()===a)return"nothing";if(a instanceof sp)return a.X;if(a instanceof jP)return"#"+a.Qz;if(a instanceof ns)return b.Eo.n(a);if(a instanceof eP){var y=a.qx;return lP(oP(a.px,b,2)+" with "+oP(y,b,0),1<c)}if(a instanceof nt){e=!0;g=a;var B=g.Jr,D=g.Kr;if(B instanceof aP){var C=B.hu;a:{var F=O().c;if(null===F?null===C:F.h(C))var I="()";else{if(C instanceof A){var K=C.A,N=C.r;if(null!==
-K){var P=new M(K);if(!P.b()){var T=P.k.i(),aa=P.k.j();if(t().f===T&&null!==aa){var Y=aa.Pf,S=aa.Jg;if(t().f===Y)var Z=O().c,ka=(null===Z?null===N:Z.h(N))?!(S instanceof aP):!1;else ka=!1;if(ka){I=oP(S,b,31);break a}}}}}var X=nP(C,b);I=b.Do?Qe(X,"(",", ",")"):Qe(X,"(",", ",",)")}}return lP(I+" -\x3e "+oP(D,b,30),30<c)}}if(e){var sa=g.Jr,Ia=g.Kr;if(b.Do)return lP("(..."+oP(sa,b,0)+") -\x3e "+oP(Ia,b,30),30<c)}if(e){var Za=g.Kr;return lP(oP(g.Jr,b,31)+" -\x3e "+oP(Za,b,30),30<c)}if(a instanceof bP)return"~"+
-oP(a.Gw,b,100);if(a instanceof En){var Ga=a.rs,xa=md=>{var Ue=md.i().w;if(IA(Ne(),Ue)){md=md.j();if(null!==md){var Jd=md.Pf,uf=md.Jg;a:if(t().f===Jd)Jd=!0;else{if(Jd instanceof M&&(Jd=Jd.k,Il()===Jd)){Jd=!0;break a}Jd=!1}if(Jd&&Jl()===uf)return""+Ue}if(null!==md&&(uf=md.Pf,Jd=md.Jg,uf instanceof M&&hf(new E(uf.k),Jd)))return Ue+" \x3d "+oP(Jd,b,0);if(null!==md){Jd=md.Pf;uf=md.Jg;a:if(t().f===Jd)Jd=!0;else{if(Jd instanceof M&&(Jd=Jd.k,Il()===Jd)){Jd=!0;break a}Jd=!1}if(Jd)return Ue+" \x3c: "+oP(uf,
-b,0)}if(null!==md&&(Jd=md.Pf,uf=md.Jg,Jd instanceof M&&(Jd=Jd.k,Jl()===uf)))return Ue+" :\x3e "+oP(Jd,b,0);if(null!==md&&(uf=md.Pf,Jd=md.Jg,uf instanceof M))return Ue+" :\x3e "+oP(uf.k,b,0)+" \x3c: "+oP(Jd,b,0);throw new x(md);}return(md.j().Pf.b()?"":"mut ")+Ue+": "+mP(md.j(),b)};if(Ga===v())var Ra=v();else{for(var Ja=Ga.e(),La=new A(xa(Ja),v()),pb=La,Fb=Ga.g();Fb!==v();){var Gb=Fb.e(),Hb=new A(xa(Gb),v());pb=pb.r=Hb;Fb=Fb.g()}Ra=La}for(var tb=0,kb=Ra;!kb.b();){var gb=tb,Vb=kb.e();tb=(gb|0)+Vb.length|
-0;kb=kb.g()}if(80<(tb|0)){Ne();var bb="{\n"+pP(b),nb=",\n"+pP(b),Tb=Qe(Ra,bb,nb,"");return Iba(Tb)+"\n"+pP(b)+"}"}return Qe(Ra,"{",", ","}")}if(a instanceof iP){var ub=a.cx,Ub=md=>{if(md instanceof te)return"..."+oP(md.ca,b,0);if(md instanceof me)return""+mP(md.ia,b);throw new x(md);};if(ub===v())var $a=v();else{for(var cb=ub.e(),Na=new A(Ub(cb),v()),Ca=Na,Ba=ub.g();Ba!==v();){var Oa=Ba.e(),wa=new A(Ub(Oa),v());Ca=Ca.r=wa;Ba=Ba.g()}$a=Na}return b.Do?Qe($a,"[",", ","]"):Qe($a,"(",", ",")")}if(a instanceof
-aP){var ea=a.hu,la=nP(ea,b);if(b.Do)return Qe(la,"[",", ","]");var Ka=ea.b()?")":",)";return Qe(la,"(",", ",Ka)}a:{if(a instanceof $O){var Ua=a.Cs,ya=a.Ds;if(Ua instanceof sp&&"true"===Ua.X&&ya instanceof sp&&"false"===ya.X){var ib=!0;break a}}if(a instanceof $O){var Lb=a.Cs,ec=a.Ds;if(Lb instanceof sp&&"false"===Lb.X&&ec instanceof sp&&"true"===ec.X){ib=!0;break a}}ib=!1}if(ib){var Mb=new sp("bool");return oP(Mb,b,0)}if(a instanceof Cl){var Jb=a.qo?20:25,Kb=a.qo?" | ":" \x26 ",eb=a.gw?a.hw:qP(a),
-Wb=O().c;if(null===Wb?null===eb:Wb.h(eb)){var mc=a.qo?Il():Jl();return oP(mc,b,c)}if(eb instanceof A){var ua=eb.A,Pa=eb.r,xb=O().c;if(null===xb?null===Pa:xb.h(Pa))return oP(ua,b,c)}var Yb=(a.gw?a.hw:qP(a)).m(),zb=new eg(Yb,new z(md=>oP(md,b,Jb)));if(!zb.s())throw Fu("empty.reduceLeft");for(var Sb=!0,Ma=null;zb.s();){var Ea=zb.t();Sb?(Ma=Ea,Sb=!1):Ma=Ma+Kb+Ea}return lP(Ma,c>Jb)}if(a instanceof dP){h=!0;k=a;var ab=k.pi,Db=k.qi;if(Il()===ab&&Jl()===Db)return"?"}if(h){var mb=k.pi;if(hf(new E(mb),k.qi))return oP(mb,
-b,c)}if(h){var vb=k.pi,Ya=k.qi;if(Il()===vb)return"out "+oP(Ya,b,0)}if(h){var Wa=k.pi,rb=k.qi;if(Jl()===rb)return"in "+oP(Wa,b,0)}if(h){var pa=k.qi;return"in "+oP(k.pi,b,0)+" out "+oP(pa,b,0)}if(a instanceof gP){var Fa=a.ew,Ib=a.dw.X;if(Fa===v())var qb=v();else{for(var Nb=Fa.e(),fc=new A(oP(Nb,b,0),v()),Ac=fc,tc=Fa.g();tc!==v();){var vc=tc.e(),sc=new A(oP(vc,b,0),v());Ac=Ac.r=sc;tc=tc.g()}qb=fc}return""+Ib+Qe(qb,b.eu?"\x3c":"[",", ",b.eu?"\x3e":"]")}if(a instanceof kP){var uc=a.Zw;return oP(a.Yw,
-b,100)+"."+uc.X}if(a instanceof cP){var lc=a.Bz,Wc=oP(a.Ww,b,90);if(lc===v())var Cc=v();else{for(var Dc=lc.e(),Ec=new A("\\"+Dc.w,v()),Ic=Ec,Xc=lc.g();Xc!==v();){var Sc=Xc.e(),oc=new A("\\"+Sc.w,v());Ic=Ic.r=oc;Xc=Xc.g()}Cc=Ec}return""+Wc+Qe(Cc,"","","")}if(a instanceof fP){l=!0;m=a;var qc=m.Xr;if(qc instanceof Do)return qc.Rr.u()}if(l){var Tc=m.Xr;if(Tc instanceof Ho)return Tc.nw.gd.u()}if(l){var Nc=m.Xr;if(Nc instanceof Io)return'"'+Nc.dx+'"'}if(l){var Pc=m.Xr;if(Pc instanceof Jo)return Pc.Es?b.Do?
-"()":"undefined":"null"}if(a instanceof mt){n=!0;r=a;var Oc=r.qs,$c=r.ps,Lc=O().c;if(null===Lc?null===Oc:Lc.h(Oc))return oP($c,b,c)}if(n){var Zb=r.ps,ed=r.qs.m(),$b=new eg(ed,new z(md=>{if(md instanceof me)return oP(md.ia,b,0);if(!(md instanceof te))throw new x(md);return md.ca.X}));return lP(Qe($b,"forall "," ",".")+" "+oP(Zb,b,0),1<c)}if(a instanceof hP){var Fc=a.iw,Yc=a.jw,nc=a.kw;Q();var Ob=oP(Fc,b,0),cc=Zf(Ob),Gc=cH(Q(),cc,10),Bc=Gc?rP(b):rP(rP(b)),qd=pP(b),Gd=md=>{if(null!==md){var Ue=md.i(),
-Jd=md.j();if(null!==Jd){var uf=Jd.pi;Jd=Jd.qi;if(Il()===uf)return"\n"+pP(Bc)+Bc.Eo.n(Ue)+" \x3c: "+oP(Jd,Bc,0)}}if(null!==md&&(Ue=md.i(),Jd=md.j(),null!==Jd&&(uf=Jd.pi,Jd=Jd.qi,Jl()===Jd)))return"\n"+pP(Bc)+Bc.Eo.n(Ue)+" :\x3e "+oP(uf,Bc,0);if(null!==md&&(Ue=md.i(),uf=md.j(),null!==uf&&(Jd=uf.pi,hf(new E(Jd),uf.qi))))return"\n"+pP(Bc)+Bc.Eo.n(Ue)+" :\x3d "+oP(Jd,Bc,0);if(null!==md&&(Ue=md.i(),uf=md.j(),null!==uf))return md=uf.pi,uf=uf.qi,Ue=Bc.Eo.n(Ue),"\n"+pP(Bc)+Ue+" :\x3e "+oP(md,Bc,0)+("\n"+pP(Bc)+
-Hs(Q()," ",Ue.length)+" \x3c: ")+oP(uf,Bc,0);throw new x(md);};if(Yc===v())var cd=v();else{for(var rd=Yc.e(),Id=new A(Gd(rd),v()),Ha=Id,jc=Yc.g();jc!==v();){var Rb=jc.e(),Uc=new A(Gd(Rb),v());Ha=Ha.r=Uc;jc=jc.g()}cd=Id}var Rc=Qe(cd,"","",""),Cd=md=>{if(null!==md){var Ue=md.pi;md=md.qi;return"\n"+pP(Bc)+oP(Ue,Bc,0)+" \x3c: "+oP(md,Bc,0)}throw new x(md);};if(nc===v())var od=v();else{for(var Va=nc.e(),wb=new A(Cd(Va),v()),db=wb,Jc=nc.g();Jc!==v();){var Vc=Jc.e(),Ta=new A(Cd(Vc),v());db=db.r=Ta;Jc=Jc.g()}od=
-wb}return lP(cc+"\n"+qd+(Gc?"":"  ")+"where"+Rc+Qe(od,"","",""),0<c)}if(a instanceof Kn){var kd=a.Sd,ld=a.Qb,qe=a.bj,Wd=a.qh,Rd=a.cd,Me=!1,wc=null;a:{if(kd instanceof M&&(Me=!0,wc=kd,!1===!!wc.k)){var Xb=a.yo?"val":"let";break a}if(Me&&!0===!!wc.k)a.yo&&Dn("Program reached and unexpected state."),Xb="let rec";else if(t().f===kd)Xb="fun";else throw new x(kd);}var gc=qe.b()?"":" ("+qe.o().w+")",hc=ld.w;if(Wd===v())var gd=v();else{for(var kc=Wd.e(),ud=new A(oP(kc,b,0),v()),za=ud,Qa=Wd.g();Qa!==v();){var xc=
-Qa.e(),yd=new A(oP(xc,b,0),v());za=za.r=yd;Qa=Qa.g()}gd=ud}var be=iF(nF(),gd);if(Rd instanceof te)var yc=" \x3d ...";else{if(!(Rd instanceof me))throw new x(Rd);yc=": "+oP(Rd.ia,b,0)}return Xb+gc+" "+hc+be+yc}if(a instanceof sP){var Od=a.ax,sd=a.Dz,he=md=>""+pP(b)+oP(md,b,0)+"\n";if(Od===v())var ue=v();else{for(var sg=Od.e(),Se=new A(he(sg),v()),Kf=Se,$e=Od.g();$e!==v();){var rf=$e.e(),He=new A(he(rf),v());Kf=Kf.r=He;$e=$e.g()}ue=Se}if(sd instanceof M)var Ze=sd.k,jf=""+pP(b)+oP(Ze,b,0)+"\n",tf=O().c,
-Te=new A(jf,tf);else{if(t().f!==sd)throw new x(sd);Te=O().c}var hg=Fl(Te,ue);return Qe(hg,"","","")}if(a instanceof io){u=!0;w=a;var eh=w.nb,fh=w.eb,tg=w.bg,Jg=w.Lg,Gh=w.sm,zg=w.xj,ig=w.ti,qh=w.Pw,gh=w.hs,Wg=w.Uh;if(np()===eh){if(!Jg.b())throw new rk("assertion failed: "+Jg);if(!Gh.b())throw new rk("assertion failed: "+Gh);if(!ig.b())throw new rk("assertion failed: "+ig);if(!qh.b())throw new rk("assertion failed: "+qh);if(!gh.b())throw new rk("assertion failed: "+gh);if(!zf(Wg).b())throw new rk("assertion failed: "+
-Wg);var Uf=fh.X;if(tg===v())var rh=v();else{for(var Rh=tg.e(),Sg=new A(oP(Rh.j(),b,0),v()),Hh=Sg,Xg=tg.g();Xg!==v();){var jg=Xg.e(),Ag=new A(oP(jg.j(),b,0),v());Hh=Hh.r=Ag;Xg=Xg.g()}rh=Sg}var Cf=iF(nF(),rh);zg.b()&&Dn("Program reached and unexpected state.");var Bg=zg.o();return"type "+Uf+Cf+" \x3d "+oP(Bg,b,0)}}if(u){var Lf=w.nb,Df=w.eb,kg=w.bg,df=w.Lg,Kg=w.xj,Mf=w.ti,Vf=w.Pw,Cg=w.hs,Ef=w.Uh,Wf=rP(b),de=w.Vk;if(de.b())var Ee="";else de.o(),Ee="declare ";var Sh=w.rm;if(Sh.b())var hi="";else Sh.o(),
-hi="abstract ";var vi=Lf.td,Lg=Df.X;if(kg===v())var Tg=v();else{for(var cj=kg.e(),Cj=new A(oP(cj.j(),b,0),v()),Dj=Cj,wi=kg.g();wi!==v();){var Ki=wi.e(),Yg=new A(oP(Ki.j(),b,0),v());Dj=Dj.r=Yg;wi=wi.g()}Tg=Cj}var dj=iF(nF(),Tg);a:{if(df instanceof M){var ii=df.k;if(null!==ii){var ji=ii.Ra,Th=md=>{if(null!==md){var Ue=md.i(),Jd=md.j();if(t().f===Ue&&null!==Jd&&(Jd=Jd.Da,Jd instanceof em&&(Ue=Jd.Ni,Jd=Jd.po,Ue instanceof Wl)))return Ue.w+": "+oP(Jd,b,0)}null!==md&&(Ue=md.i(),(t().f===Ue||Ue instanceof
-M)&&Dn("ill-formed type definition parameter"));throw new x(md);};if(ji===v())var Ej=v();else{for(var ej=ji.e(),xd=new A(Th(ej),v()),ke=xd,Ie=ji.g();Ie!==v();){var Qf=Ie.e(),hh=new A(Th(Qf),v());ke=ke.r=hh;Ie=Ie.g()}Ej=xd}var lg="("+Qe(Ej,"",", ","")+")";break a}}lg=""}if(Kg.b())var Uh="";else{var Zg=Kg.o();Uh=": "+oP(Zg,Wf,0)}var Vh=O().c;if(null===Vh?null===Mf:Vh.h(Mf))var fj="";else{var gj=Mf.m(),Li=new eg(gj,new z(md=>rz(md,!1)));fj=" extends "+Qe(Li,"",", ","")}if(zf(Ef).b()&&Vf.b()&&Cg.b())var Mi=
-"";else{if(Vf.b())var hj="";else{var Fj=Vf.o();hj=pP(Wf)+"super: "+oP(Fj,Wf,0)+"\n"}if(Cg.b())var Qj="";else{var Ni=Cg.o();Qj=pP(Wf)+"this: "+oP(Ni,Wf,0)+"\n"}var Gj=Hn(zf(Ef),new tP(a,Wf)),Hj=Qe(Gj,"","",""),lk=new sP(Hn(zf(Ef),new uP(a)),t().f);Mi=" {\n"+hj+Qj+Hj+oP(lk,Wf,0)+pP(b)+"}"}return Ee+hi+vi+" "+Lg+dj+lg+Uh+fj+Mi}throw new x(a);};
-function vP(a){if(a instanceof wP)return O().c;if(a instanceof nt){var b=a.Jr,c=a.Kr,d=O().c;return new A(b,new A(c,d))}if(a instanceof dP){var e=a.pi,g=a.qi,h=O().c;return new A(e,new A(g,h))}if(a instanceof bP){var k=a.Gw,l=O().c;return new A(k,l)}if(a instanceof En){for(var m=a.rs,n=null,r=null;m!==v();){for(var u=m.e(),w=u.j().Pf.ea(),y=u.j().Jg,B=O().c,D=mn(w,new A(y,B)).m();D.s();){var C=new A(D.t(),v());null===r?n=C:r.r=C;r=C}m=m.g()}return null===n?v():n}if(a instanceof aP){for(var F=a.hu,
-I=null,K=null;F!==v();){for(var N=F.e(),P=Mt(Nt(),N.j().Pf),T=N.j().Jg,aa=O().c,Y=P.hl(new A(T,aa)).m();Y.s();){var S=new A(Y.t(),v());null===K?I=S:K.r=S;K=S}F=F.g()}return null===I?v():I}if(a instanceof $O){var Z=a.Cs,ka=a.Ds,X=O().c;return new A(Z,new A(ka,X))}if(a instanceof ZO){var sa=a.Sr,Ia=a.Tr,Za=O().c;return new A(sa,new A(Ia,Za))}if(a instanceof gP)return a.ew;if(a instanceof kP){var Ga=a.Yw,xa=a.Zw,Ra=O().c;return new A(Ga,new A(xa,Ra))}if(a instanceof cP){var Ja=a.Ww,La=O().c;return new A(Ja,
-La)}if(a instanceof eP){var pb=a.px,Fb=a.qx,Gb=O().c;return new A(pb,new A(Fb,Gb))}if(a instanceof mt){var Hb=a.qs,tb=a.ps,kb=qc=>{if(qc instanceof me)qc=qc.ia;else{if(!(qc instanceof te))throw new x(qc);qc=qc.ca}return qc};if(Hb===v())var gb=v();else{for(var Vb=Hb.e(),bb=new A(kb(Vb),v()),nb=bb,Tb=Hb.g();Tb!==v();){var ub=Tb.e(),Ub=new A(kb(ub),v());nb=nb.r=Ub;Tb=Tb.g()}gb=bb}return wq(gb,tb)}if(a instanceof iP){for(var $a=a.cx,cb=null,Na=null;$a!==v();){var Ca=$a.e();if(Ca instanceof te)var Ba=
-Ca.ca,Oa=O().c,wa=new A(Ba,Oa);else{if(!(Ca instanceof me))throw new x(Ca);var ea=Ca.ia,la=ea.Pf.ea(),Ka=ea.Jg,Ua=O().c;wa=mn(la,new A(Ka,Ua))}for(var ya=wa.m();ya.s();){var ib=new A(ya.t(),v());null===Na?cb=ib:Na.r=ib;Na=ib}$a=$a.g()}return null===cb?v():cb}if(a instanceof hP){for(var Lb=a.iw,ec=a.kw,Mb=a.jw,Jb=null,Kb=null;Mb!==v();){for(var eb=Mb.e(),Wb=eb.i(),mc=eb.j(),ua=O().c,Pa=new lq(new A(Wb,new A(mc,ua)));Pa.s();){var xb=new A(Pa.t(),v());null===Kb?Jb=xb:Kb.r=xb;Kb=xb}Mb=Mb.g()}for(var Yb=
-null===Jb?v():Jb,zb=ec,Sb=null,Ma=null;zb!==v();){for(var Ea=zb.e(),ab=Ea.pi,Db=Ea.qi,mb=O().c,vb=new lq(new A(ab,new A(Db,mb)));vb.s();){var Ya=new A(vb.t(),v());null===Ma?Sb=Ya:Ma.r=Ya;Ma=Ya}zb=zb.g()}var Wa=Fl(null===Sb?v():Sb,Yb);return new A(Lb,Wa)}if(a instanceof sP){var rb=a.ax;return Fl(a.Dz.ea(),rb)}if(a instanceof Kn){var pa=a.qh;return Fl(xP(a.cd).ea(),pa)}if(a instanceof io){var Fa=a.bg,Ib=a.Lg,qb=a.xj,Nb=a.Pw,fc=a.hs,Ac=a.Uh;if(Fa===v())var tc=v();else{for(var vc=Fa.e(),sc=new A(vc.j(),
-v()),uc=sc,lc=Fa.g();lc!==v();){var Wc=lc.e(),Cc=new A(Wc.j(),v());uc=uc.r=Cc;lc=lc.g()}tc=sc}var Dc=Hn((Ib.b()?new im(O().c):Ib.o()).Ra,new yP(a)),Ec=qb.ea(),Ic=Nb.ea(),Xc=fc.ea(),Sc=new sP(Hn(zf(Ac),new zP(a)),t().f),oc=O().c;return Fl(Fl(Fl(Fl(Fl(new A(Sc,oc),Xc),Ic),Ec),Dc),tc)}throw new x(a);}
-var Mca=function AP(a,b,c,d){var g=dB(b);if(g instanceof Ow)return fp(),a=c.zg(g.Va),Vp(G(new H,a,g));if(g instanceof nA){var h=g.cc;b=g.dc;if(hf(new E(g.nc),d.nc))return g=AP(a,h,c,d),a=AP(a,b,c,d),g.af(a);fp();a=t().f;return Vp(G(new H,a,g))}fp();g=t().f;return Vp(G(new H,g,b))};function bB(a,b,c,d,e,g){this.Pz=this.Nz=this.Oz=this.ku=this.vs=this.eq=this.nq=this.$z=null;if(null===a)throw null;this.eq=a;this.vs=c;this.ku=d;this.Oz=e;this.Nz=g;this.Pz=b;ZC(this,a,b)}bB.prototype=new aD;
-bB.prototype.constructor=bB;
-bB.prototype.Rb=function(a,b){var c=this.eq.pa,d=this.eq;if(d.D){var e=Hs(Q(),"| ",d.q)+("analyze2["+a+"] ")+b;Af(Bf(),e+"\n")}d.q=1+d.q|0;try{if(b instanceof Ow){var g=a.zg(b.Va);if(g instanceof M){var h=!!g.k;this.vs.eh(G(new H,h,b))&&gB(this.eq,b,a,h,this.Oz,this.Nz,this.Pz,this.vs,this.ku)}else if(t().f===g){if(this.vs.eh(G(new H,!0,b))){var k=this.eq,l=new kB(a,b.Va,!0);gB(k,b,l,!0,this.Oz,this.Nz,this.Pz,this.vs,this.ku)}if(this.vs.eh(G(new H,!1,b))){var m=this.eq,n=new kB(a,b.Va,!1);gB(m,b,
-n,!1,this.Oz,this.Nz,this.Pz,this.vs,this.ku)}}else throw new x(g);}else if(b instanceof nA){var r=Mca(this,b,a,b),u=this.eq;if(u.D){var w=Hs(Q(),"| ",u.q)+"Components "+r;Af(Bf(),w+"\n")}if(this.ku.eh(r))gB(this.eq,b,a,b.nc,this.Oz,this.Nz,this.Pz,this.vs,this.ku);else{var y=this.eq;if(y.D){var B=Hs(Q(),"| ",y.q)+"Found in "+this.ku;Af(Bf(),B+"\n")}}}else $C.prototype.Rb.call(this,a,b);var D=void 0}finally{d.q=-1+d.q|0}Gw(new E(c),d.pa)&&d.D&&(a=""+Hs(Q(),"| ",d.q)+c.n(D),Af(Bf(),a+"\n"))};
-bB.prototype.$classData=q({dY:0},!1,"mlscript.TypeSimplifier$Analyze2$1$",{dY:1,UO:1,d:1});
-function BP(a){this.gx=this.Ll=null;if(null===a)throw null;this.gx=a;var b=t().f,c=ru(),d=a.XO.m();c=c.Ib(new eg(d,new z(m=>{var n=m.i();m=new Sw(this.gx,m.j(),new Wl(m.i()));return G(new H,n,m)})));d=ru().U();var e=a.md;fp();var g=a.xE;if(g===v())var h=v();else{h=g.e();var k=h=new A(G(new H,h.Kl.X,h),v());for(g=g.g();g!==v();){var l=g.e();l=new A(G(new H,l.Kl.X,l),v());k=k.r=l;g=g.g()}}this.Ll=new Uv(a,b,c,d,e,!1,bp(0,h),ru().U(),t().f,ru().U());Hf(this)}BP.prototype=new p;
-BP.prototype.constructor=BP;
-function Hf(a){if(a.gx.Qc){var b=ru(),c=a.gx.$O,d=k=>{var l=new Iw(a.gx,k,Jf(),a.Ll,new z(r=>{Dn(r.Hp)})),m=a.Ll.Xa,n=G(new H,k.eb.X,l);m.S(n);return G(new H,k.eb.X,l)};if(c===v())d=v();else{var e=c.e(),g=e=new A(d(e),v());for(c=c.g();c!==v();){var h=c.e();h=new A(d(h),v());g=g.r=h;c=c.g()}d=e}b=b.Ib(d);b=new Uv(a.Ll.V,a.Ll.Vc,a.Ll.Xa,a.Ll.kd,a.Ll.fa,a.Ll.Ac,a.Ll.vb,b,a.Ll.ud,a.Ll.hb);d=new z(k=>{throw k;});for(e=b.fb.Qd();e.s();)g=e.t(),h=jx(g,d),g=b.Xa,c=h.Sa(),h=new Lw(a.gx,h),c=G(new H,c,h),g.S(c);
-return b}return a.Ll}BP.prototype.$classData=q({lY:0},!1,"mlscript.Typer$Ctx$",{lY:1,d:1,l:1});function CP(){this.Cn=this.Bn=this.Dn=null;this.Vo=this.Wo=this.Dm=this.Uo=0;this.pa=null;this.q=0;this.bl=this.iq=this.mq=this.No=this.Ro=this.So=this.kq=this.Po=this.jq=this.Mo=this.Qo=this.Oo=this.lq=null;this.To=0}CP.prototype=new gC;CP.prototype.constructor=CP;function DP(){}DP.prototype=CP.prototype;function Uw(a){null===a.lq&&null===a.lq&&(a.lq=new EP(a))}
-function $w(a){null===a.Oo&&null===a.Oo&&(a.Oo=new FP(a));return a.Oo}function Nca(a){null===a.Qo&&null===a.Qo&&(a.Qo=new YB(a));return a.Qo}function Ww(a){null===a.Mo&&null===a.Mo&&(a.Mo=new GP(a));return a.Mo}function dA(a){null===a.jq&&null===a.jq&&(a.jq=new WB(a))}function Pu(a){null===a.Po&&null===a.Po&&(a.Po=new HP(a));return a.Po}function tB(a){null===a.kq&&null===a.kq&&(a.kq=new XB(a))}function rv(a){null===a.Ro&&null===a.Ro&&(a.Ro=new IP(a));return a.Ro}
-function pD(a){null===a.No&&null===a.No&&(a.No=new JP(a));return a.No}function KP(a){null===a.mq&&null===a.mq&&(a.mq=new bC(a))}function DB(a){null===a.iq&&null===a.iq&&(a.iq=new VB(a))}function LP(a){a.To=1+a.To|0;return-1+a.To|0}function GP(a){this.RN=null;if(null===a)throw null;this.RN=a}GP.prototype=new p;GP.prototype.constructor=GP;function Xw(a,b,c){return b.b()?c:new yB(a.RN,b,c)}GP.prototype.$classData=q({zY:0},!1,"mlscript.TyperDatatypes$ConstrainedType$",{zY:1,d:1,l:1});
-function JP(a){this.mu=null;if(null===a)throw null;this.mu=a}JP.prototype=new p;JP.prototype.constructor=JP;function qD(a,b,c,d,e){if(null!==b){var g=b.Vd;if(!0===b.wd&&!0===g)return new ww(a.mu,t().f,a.mu.Na,e)}if(null!==b&&(g=b.Vd,!0===b.wd&&!1===g))return new ww(a.mu,t().f,d,e);if(null!==b&&(g=b.Vd,!1===b.wd&&!0===g))return new ww(a.mu,(t(),new M(c)),a.mu.Na,e);if(null!==b&&(g=b.Vd,!1===b.wd&&!1===g))return new ww(a.mu,(t(),new M(c)),d,e);throw new x(b);}
-JP.prototype.$classData=q({HY:0},!1,"mlscript.TyperDatatypes$FieldType$",{HY:1,d:1,l:1});function MP(){this.J=null}MP.prototype=new aC;MP.prototype.constructor=MP;function NP(){}NP.prototype=MP.prototype;function FP(a){this.Uz=null;if(null===a)throw null;this.Uz=a}FP.prototype=new p;FP.prototype.constructor=FP;
-function Zw(a,b,c){for(;;){Os(fp(),b<=a.Uz.tf);if(hf(new E(b),a.Uz.tf)||c.Ca()<=b)return c;var d=CB(c);if(d instanceof px)c=d.Ld,d=d.ve,a=$w(a.Uz),b=b<c?b:c,c=d;else return new px(a.Uz,b,c)}}FP.prototype.$classData=q({QY:0},!1,"mlscript.TyperDatatypes$PolymorphicType$",{QY:1,d:1,l:1});function HP(a){this.Vz=null;if(null===a)throw null;this.Vz=a}HP.prototype=new p;HP.prototype.constructor=HP;function Ou(a){var b=a.Vz,c=O().c;return new dv(b,c,V(a.Vz))}
-function uA(a,b,c){return b.b()?new gA(a.Vz,!1,c):new dv(a.Vz,b,c)}HP.prototype.$classData=q({UY:0},!1,"mlscript.TyperDatatypes$RecordType$",{UY:1,d:1,l:1});function IP(a){this.pu=null;if(null===a)throw null;this.pu=a}IP.prototype=new p;IP.prototype.constructor=IP;function FC(a,b,c,d){for(;;){var e=b,g=c;if(e instanceof wB)b=e.vg,c=g;else if(g instanceof wB)c=g.Jf,b=e;else return new wB(a.pu,b,c,d)}}
-function sv(a,b,c,d,e){if(et(new E(b),c)||hf(new E(b),c))e=!0;else{if(JC(b)||JC(c))g=!1;else{g=ru().U();var g=tu(b,c,e,!0,g)}g?(g=ru().U(),e=tu(c,b,e,!0,g)):e=!1}return e?b:FC(a,b,c,d)}function tv(a){return V(a.pu)}function Vz(a,b,c,d){return et(new E(b),c)||hf(new E(b),c)?b:FC(a,b,c,d)}IP.prototype.$classData=q({bZ:0},!1,"mlscript.TyperDatatypes$TypeBounds$",{bZ:1,d:1,l:1});function OP(){this.p=null}OP.prototype=new p;OP.prototype.constructor=OP;function PP(){}PP.prototype=OP.prototype;
-function QP(a){this.FO=null;if(null===a)throw null;this.FO=a}QP.prototype=new p;QP.prototype.constructor=QP;QP.prototype.u=function(){return"TypeRef"};function RP(a,b,c,d){return new uv(a.FO,b,c,d)}QP.prototype.$classData=q({eZ:0},!1,"mlscript.TyperDatatypes$TypeRef$",{eZ:1,d:1,l:1});function xB(a,b){this.cl=null;this.As=0;this.Yz=this.Cm=null;this.uI=0;if(null===a)throw null;this.Yz=a;this.uI=b;tC(this,a.Cm,a.cl)}xB.prototype=new vC;xB.prototype.constructor=xB;
-xB.prototype.zg=function(a){return a>this.uI?(t(),new M(!0)):this.Yz.zg(a)};xB.prototype.Qq=function(a){return a>this.uI?this:this.Yz.Qq(a)};xB.prototype.$v=function(){return this.Yz+";Q("+this.Yz.As+")"};xB.prototype.$classData=q({nZ:0},!1,"mlscript.TyperHelpers$PolMap$$anon$1",{nZ:1,pE:1,d:1});function mB(a){this.cl=null;this.As=0;this.vI=this.Cm=null;if(null===a)throw null;this.vI=a;tC(this,a.Cm,t().f)}mB.prototype=new vC;mB.prototype.constructor=mB;mB.prototype.zg=function(){return t().f};
-mB.prototype.Qq=function(a){return this.vI.Qq(a)};mB.prototype.$v=function(){return this.vI+";\x3d"};mB.prototype.$classData=q({oZ:0},!1,"mlscript.TyperHelpers$PolMap$$anon$2",{oZ:1,pE:1,d:1});function nB(a){this.cl=null;this.As=0;this.qE=this.Cm=null;if(null===a)throw null;this.qE=a;var b=a.Cm;a=a.cl;a.b()?a=R():(a=!!a.o(),a=new M(!a));tC(this,b,a)}nB.prototype=new vC;nB.prototype.constructor=nB;nB.prototype.zg=function(a){a=this.qE.zg(a);if(a.b())return R();a=!!a.o();return new M(!a)};
-nB.prototype.Qq=function(a){return this.qE.Qq(a)};nB.prototype.$v=function(){return this.qE+";-"};nB.prototype.$classData=q({pZ:0},!1,"mlscript.TyperHelpers$PolMap$$anon$3",{pZ:1,pE:1,d:1});function kB(a,b,c){this.cl=null;this.As=0;this.rE=this.RO=this.Cm=null;this.QO=0;this.Zz=!1;if(null===a)throw null;this.rE=a;this.QO=b;this.Zz=c;tC(this,a.Cm,a.cl);this.RO=this.Qq(b)}kB.prototype=new vC;kB.prototype.constructor=kB;
-kB.prototype.zg=function(a){if(a>=this.QO)return t(),new M(this.Zz);var b=!1,c=null;a=this.RO.zg(a);if(a instanceof M&&(b=!0,c=a,!0===!!c.k))return t(),new M(this.Zz);if(b&&!1===!!c.k)return t(),new M(!this.Zz);if(t().f===a)return t().f;throw new x(a);};kB.prototype.Qq=function(a){return this.rE.Qq(a)};kB.prototype.$v=function(){var a=this.rE;t();return a+";@["+uz(new M(this.Zz))+"]("+this.rE.As+")"};kB.prototype.$classData=q({qZ:0},!1,"mlscript.TyperHelpers$PolMap$$anon$4",{qZ:1,pE:1,d:1});
-function wC(a,b){this.cl=null;this.As=0;this.wI=this.Cm=null;if(null===a)throw null;this.wI=b;tC(this,a.SO,b)}wC.prototype=new vC;wC.prototype.constructor=wC;wC.prototype.zg=function(){return this.wI};wC.prototype.Qq=function(){return this};wC.prototype.$v=function(){return""+uz(this.wI)};wC.prototype.$classData=q({rZ:0},!1,"mlscript.TyperHelpers$PolMap$$anon$5",{rZ:1,pE:1,d:1});
-function YO(a){a=zf(a).m();a=new eg(a,new z(b=>{if(b instanceof Ln)return rz(b,!1);if(b instanceof Rs||b instanceof zo)return lx(b);Dn("Unexpected typing unit entity: "+b)}));return Qe(a,"{","; ","}")}
-function Oca(a){var b=Hn(a.ox,new SP(a)),c=Zp($p(),b),d=a.ox;a=h=>{if(h instanceof ym){var k=h.Ip,l=h.Er;if(c.L(k.w))return new Kn(t().f,k,t().f,O().c,(t(),new te(l)),t().f,t().f,t().f,t().f,!0)}return h};if(d===v())return v();b=d.e();var e=b=new A(a(b),v());for(d=d.g();d!==v();){var g=d.e();g=new A(a(g),v());e=e.r=g;d=d.g()}return b}function TP(){this.En=this.cA=this.bA=this.lP=null;UP=this;this.lP=new VP(!0,!0);this.bA=new VP(!0,!1);this.cA=new VP(!1,!0);this.En=new VP(!1,!1)}TP.prototype=new p;
-TP.prototype.constructor=TP;TP.prototype.$classData=q({BZ:0},!1,"mlscript.VarianceInfo$",{BZ:1,d:1,l:1});var UP;function Tt(){UP||(UP=new TP);return UP}function WP(){}WP.prototype=new p;WP.prototype.constructor=WP;function Hq(a,b,c,d){return new gg(MN(b.e().i(),c),b,d)}WP.prototype.$classData=q({DZ:0},!1,"mlscript.WarningReport$",{DZ:1,d:1,l:1});var XP;function Fq(){XP||(XP=new WP);return XP}function YP(){this.$e=null}YP.prototype=new MD;YP.prototype.constructor=YP;function ZP(){}ZP.prototype=YP.prototype;
-function $P(a){a.Du=Lz().U();a.bi=mE(iE());O()}function aQ(){this.bi=this.Du=null}aQ.prototype=new p;aQ.prototype.constructor=aQ;function bQ(){}bQ.prototype=aQ.prototype;function cQ(a){if(a instanceof aE)return"Consequent";if(bE()===a)return"MissingCase";if(a instanceof WD)return"IfThenElse";if(a instanceof XD)return"Match";throw new x(a);}function dQ(a,b,c,d,e){a.Rl(b,new z(()=>{}),c,d,e)}function eQ(){this.wa=null;fQ=this;this.wa=new gQ}eQ.prototype=new p;eQ.prototype.constructor=eQ;
-eQ.prototype.$classData=q({o2:0},!1,"scala.$less$colon$less$",{o2:1,d:1,l:1});var fQ;function ap(){fQ||(fQ=new eQ);return fQ}function DG(a){a=new (Nd(Xa).Ja)(a);Sj(fk(),a,void 0);return a}function hQ(){}hQ.prototype=new p;hQ.prototype.constructor=hQ;
-function iQ(a,b,c){a=b.Q();if(-1<a){c=c.gi(a);b=b.m();for(var d=0;d<a;)OG(eG(),c,d,b.t()),d=1+d|0;return c}c=c.jh();d=c===ma(Vd);a=[];for(b=b.m();b.s();){var e=b.t();a.push(d?Eb(e):null===e?c.ei.Oy:e)}return Nd((c===ma(Qd)?ma(Xa):c===ma(SG)||c===ma(TG)?ma(Md):c).ei).Ny(a)}function CG(a,b,c,d,e,g){a=ja(b);if(Eg(a)&&Dg(ja(d),a))b.va(c,d,e,g);else for(a=c,c=c+g|0;a<c;)OG(eG(),d,e,EG(eG(),b,a)),a=1+a|0,e=1+e|0}
-function BG(a,b){if(Dh(a))return DG(b);if(a instanceof jd)return Tj(fk(),a,b);if(a instanceof zd)return Yj(fk(),a,b);if(a instanceof Dd){fk();if(0>b)throw new Uj;var c=a.a.length;c=b<c?b:c;b=new Dd(b);a.va(0,b,0,c);return b}if(a instanceof Ad)return Zj(fk(),a,b);if(a instanceof Bd){fk();if(0>b)throw new Uj;c=a.a.length;c=b<c?b:c;b=new Bd(b);a.va(0,b,0,c);return b}if(a instanceof td)return ak(fk(),a,b);if(a instanceof vd)return Wj(fk(),a,b);if(a instanceof wd)return Xj(fk(),a,b);if(a instanceof pd)return bk(fk(),
-a,b);throw new x(a);}function jQ(a,b,c){if(b===c)return!0;if(b.a.length!==c.a.length)return!1;a=b.a.length;for(var d=0;d<a;){if(!Ol(Pl(),b.a[d],c.a[d]))return!1;d=1+d|0}return!0}hQ.prototype.$classData=q({q2:0},!1,"scala.Array$",{q2:1,d:1,l:1});var kQ;function zG(){kQ||(kQ=new hQ);return kQ}function lQ(){this.RQ=null;mQ=this;this.RQ=new TK(wh().pQ);wh()}lQ.prototype=new p;lQ.prototype.constructor=lQ;function Bf(){mQ||(mQ=new lQ);return mQ.RQ.fR}
-lQ.prototype.$classData=q({s2:0},!1,"scala.Console$",{s2:1,d:1,Iaa:1});var mQ;function nQ(){}nQ.prototype=new UF;nQ.prototype.constructor=nQ;function oQ(){}oQ.prototype=nQ.prototype;function Fr(a){return null===a?null:0===a.a.length?(a=pQ(),AG(),a.AL):new qQ(a)}function or(a,b){return null!==b?new rQ(b):null}function sQ(){}sQ.prototype=new p;sQ.prototype.constructor=sQ;function Mt(a,b){if(b.b())return O().cR.U();O();a=b.o();return new tQ(a)}function Rx(a,b,c){return b?new M(Zr(c)):R()}
-sQ.prototype.$classData=q({x2:0},!1,"scala.Option$",{x2:1,d:1,l:1});var uQ;function Nt(){uQ||(uQ=new sQ);return uQ}function xl(a){var b=bt();return b&&b.$classData&&b.$classData.pb.za?new vQ(a,b):new wQ(a,b)}function xQ(a,b,c){return a.Ec(b)?a.n(b):c.n(b)}function as(a){return!!(a&&a.$classData&&a.$classData.pb.F)}function IF(){}IF.prototype=new p;IF.prototype.constructor=IF;IF.prototype.u=function(){return"Some"};IF.prototype.$classData=q({J2:0},!1,"scala.Some$",{J2:1,d:1,l:1});var HF;
-function yQ(){}yQ.prototype=new p;yQ.prototype.constructor=yQ;
-function Mba(a,b,c){var d=0,e=0,g=0,h=0,k=-1+b.K()|0;Rl();if(0>=k)a=new zd(0);else{a=new zd(k);for(var l=0;l<k;)a.a[l]=-1,l=1+l|0}Rl();if(0>=k)l=new zd(0);else{l=new zd(k);for(var m=0;m<k;)l.a[m]=-1,m=1+m|0}m=c.length;var n=new zQ(k);b.ya(new z(N=>{n.Zd=n.Zd+N.length|0}));var r=n.Zd,u=new wd(r),w=new zQ(0),y=new hA(!0);b.ya(new z(N=>{y.ko?y.ko=!1:(u.a[w.Zd]=-1,w.Zd=1+w.Zd|0);for(var P=N.length,T=0;T<P;){var aa=N.charCodeAt(T);u.a[w.Zd]=aa<<16>>16;w.Zd=1+w.Zd|0;T=1+T|0}}));var B=1+r|0;Rl();if(0>=B)var D=
-new zd(0);else{for(var C=new zd(B),F=0;F<B;)C.a[F]=-1,F=1+F|0;D=C}var I=new zQ(0),K=new zQ(0);for(b.ya(new z(N=>{K.Zd<k&&(I.Zd=I.Zd+N.length|0,D.a[I.Zd]=K.Zd,I.Zd=1+I.Zd|0,K.Zd=1+K.Zd|0)}));d<r||e<m;)if(B=D.a[d],-1!==B&&(C=a.a[B],-1===C?C=e:(F=e,C=C<F?C:F),a.a[B]=C,C=l.a[B],-1===C?C=e:(F=e,C=C>F?C:F),l.a[B]=C),d<r?(B=u.a[d],-1===B?(g=d,h=1+e|0,d=1+d|0,B=!0):e<m&&c.charCodeAt(e)===B?(d=1+d|0,e=1+e|0,B=!0):B=!1):B=!1,!B)if(0<h&&h<=m)d=g,e=h;else return R();AQ();b=-1+b.K()|0;if(0>=b)c=new (Nd(na).Ja)(0);
-else{d=new (Nd(na).Ja)(b);for(e=0;e<b;)g=e,d.a[e]=qg(Q(),c,a.a[g],l.a[g]),e=1+e|0;c=d}return new M(BQ(0,c))}
-function sq(a,b){a=dH(b,92);if(-1!==a){var c=a;a=b.length;for(var d=0,e=CQ(new rq);0<=c;){c>d&&DQ(e,b,d,c);d=1+c|0;if(d>=a)throw new EQ(b,c);switch(b.charCodeAt(d)){case 117:c=117;break;case 98:c=8;break;case 116:c=9;break;case 110:c=10;break;case 102:c=12;break;case 114:c=13;break;case 34:c=34;break;case 39:c=39;break;case 92:c=92;break;default:throw new EQ(b,c);}if(117===c)a:for(var g=c=d,h=b.length,k=b;;){if(c>=h)throw new FQ(k,-1+c|0);if(117===k.charCodeAt(c))c=1+c|0;else{b:for(var l=0,m=0;;){if(4<=
-l){c=new GQ(65535&m,(c-g|0)+l|0);break b}if((l+c|0)>=h)throw new FQ(k,c+l|0);var n=k.charCodeAt(l+c|0);n=lH($q(),n,36);if(0<=n&&15>=n)m=(m<<4)+n|0,l=1+l|0;else throw new FQ(k,c+l|0);}break a}}else c=new GQ(c,1);if(null===c)throw new x(c);g=c.dF();d=d+c.Lc()|0;c=String.fromCharCode(g);e.ha=""+e.ha+c;c=d;g=b;h=CL($q(),92);g=g.indexOf(h,d)|0;d=c;c=g}d<a&&DQ(e,b,d,a);b=e.ha}return b}yQ.prototype.$classData=q({L2:0},!1,"scala.StringContext$",{L2:1,d:1,l:1});var HQ;
-function pq(){HQ||(HQ=new yQ);return HQ}q({l4:0},!1,"scala.collection.BuildFromLowPriority2$$anon$11",{l4:1,d:1,dba:1});function IQ(a,b){this.$m=this.Gc=0;this.lh=null;this.ji=0;this.Xn=this.Ck=null;for(rH(this,b.$b);this.s();)b=this.lh.Jb(this.Gc),JQ(a,a.cr,this.lh.uf(this.Gc),this.lh.Kf(this.Gc),b,HG(JG(),b),0),this.Gc=1+this.Gc|0}IQ.prototype=new tH;IQ.prototype.constructor=IQ;IQ.prototype.$classData=q({u6:0},!1,"scala.collection.immutable.HashMapBuilder$$anon$1",{u6:1,tv:1,d:1});
-function KQ(a,b){this.$m=this.Gc=0;this.lh=null;this.ji=0;this.Xn=this.Ck=null;for(rH(this,b.nd);this.s();)b=this.lh.Jb(this.Gc),LQ(a,a.dr,this.lh.Yc(this.Gc),b,HG(JG(),b),0),this.Gc=1+this.Gc|0}KQ.prototype=new tH;KQ.prototype.constructor=KQ;KQ.prototype.$classData=q({y6:0},!1,"scala.collection.immutable.HashSetBuilder$$anon$1",{y6:1,tv:1,d:1});function MQ(){}MQ.prototype=new p;MQ.prototype.constructor=MQ;MQ.prototype.u=function(){return"\x3cfunction1\x3e"};MQ.prototype.n=function(){return this};
-MQ.prototype.$classData=q({O6:0},!1,"scala.collection.immutable.List$$anon$1",{O6:1,d:1,ja:1});function NQ(){}NQ.prototype=new PH;NQ.prototype.constructor=NQ;function OQ(){}OQ.prototype=NQ.prototype;function PQ(a){this.$m=this.Gc=0;this.lh=null;this.ji=0;this.Xn=this.Ck=null;rH(this,a)}PQ.prototype=new tH;PQ.prototype.constructor=PQ;PQ.prototype.$classData=q({k7:0},!1,"scala.collection.immutable.MapNodeRemoveAllSetNodeIterator",{k7:1,tv:1,d:1});function QQ(){}QQ.prototype=new p;
-QQ.prototype.constructor=QQ;function RQ(a,b,c,d,e){throw dk(b+(e?" to ":" until ")+c+" by "+d+": seqs cannot contain more than Int.MaxValue elements.");}function SQ(a){TQ();return iH(a+" on empty Range")}QQ.prototype.$classData=q({r7:0},!1,"scala.collection.immutable.Range$",{r7:1,d:1,l:1});var UQ;function TQ(){UQ||(UQ=new QQ);return UQ}function VQ(){this.Ik=null}VQ.prototype=new ZI;VQ.prototype.constructor=VQ;function WQ(){}WQ.prototype=VQ.prototype;
-function XQ(a,b,c,d){if(null===b)return XI(),new bI(c,d,null,null,0);if(Object.is(c,b.Wa))return hJ(b,d);var e=a.Ik.Fa(c,b.Wa);return 0>e?cJ(b,XQ(a,b.ra,c,d)):0<e?gJ(b,XQ(a,b.sa,c,d)):hJ(b,d)}function YQ(){this.Ik=null}YQ.prototype=new ZI;YQ.prototype.constructor=YQ;function ZQ(){}ZQ.prototype=YQ.prototype;function $Q(a,b,c){if(null===b)return XI(),new bI(c,void 0,null,null,0);if(Object.is(c,b.Wa))return b;var d=a.Ik.Fa(c,b.Wa);return 0>d?cJ(b,$Q(a,b.ra,c)):0<d?gJ(b,$Q(a,b.sa,c)):b}
-function aR(){}aR.prototype=new PH;aR.prototype.constructor=aR;function bR(){}bR.prototype=aR.prototype;function cR(a,b){if(b===a)a.oc(iE().jl(b));else for(b=b.m();b.s();)a.S(b.t());return a}function dR(a,b){var c=dy(W(),b);c=eR(a,c);return fR(a,b,c)}function fR(a,b,c){for(a=a.Qk().a[c];;)if(null!==a?(c=a.fB(),c=!Ol(Pl(),c,b)):c=!1,c)a=a.cv();else break;return a}
-function gR(a,b,c){b.Wx(a.Qk().a[c]);a.Qk().a[c]=b;a.My(1+a.Ft()|0);hR(a,c);if(a.Ft()>a.XS()){b=a.Qk().a.length<<1;c=a.Qk();a.PL(new (Nd(JJ).Ja)(b));iR(a,a.Qk().a.length);for(var d=-1+c.a.length|0;0<=d;){for(var e=c.a[d];null!==e;){var g=e.fB();g=dy(W(),g);g=eR(a,g);var h=e.cv();e.Wx(a.Qk().a[g]);a.Qk().a[g]=e;e=h;hR(a,g)}d=-1+d|0}a.QL(PJ(RJ(),a.$I(),b))}}function jR(a,b,c){var d=dy(W(),b);d=eR(a,d);var e=fR(a,b,d);if(null!==e)return e;b=a.jJ(b,c);gR(a,b,d);return null}
-function kR(a,b){var c=dy(W(),b);c=eR(a,c);return lR(a,b,c)}function lR(a,b,c){var d=a.Qk().a[c];if(null!==d){var e=d.fB();if(Ol(Pl(),e,b))return a.Qk().a[c]=d.cv(),a.My(-1+a.Ft()|0),mR(a,c),d.Wx(null),d;for(e=d.cv();;){if(null!==e){var g=e.fB();g=!Ol(Pl(),g,b)}else g=!1;if(g)d=e,e=e.cv();else break}if(null!==e)return d.Wx(e.cv()),a.My(-1+a.Ft()|0),mR(a,c),e.Wx(null),e}return null}function hR(a,b){null!==a.Ct()&&(a=a.Ct(),b>>=5,a.a[b]=1+a.a[b]|0)}
-function mR(a,b){null!==a.Ct()&&(a=a.Ct(),b>>=5,a.a[b]=-1+a.a[b]|0)}function iR(a,b){if(null!==a.Ct())if(b=1+(b>>5)|0,a.Ct().a.length!==b)a.IL(new zd(b));else{a=a.Ct();fk();b=a.a.length;for(var c=0;c!==b;)a.a[c]=0,c=1+c|0}}function eR(a,b){var c=-1+a.Qk().a.length|0,d=Math.clz32(c);a=a.SS();xL||(xL=new wL);b=Math.imul(-1640532531,b);CH();b=Math.imul(-1640532531,b<<24|16711680&b<<8|65280&(b>>>8|0)|b>>>24|0);return((b>>>a|0|b<<(-a|0))>>>d|0)&c}
-function nR(a){a.JP(750);RJ();a.PL(new (Nd(JJ).Ja)(1<<(-Math.clz32(15)|0)));a.My(0);var b=a.$I();RJ();RJ();a.QL(PJ(0,b,1<<(-Math.clz32(15)|0)));a.IL(null);b=a.RS;var c=-1+a.Qk().a.length|0;c=XH(CH(),c);b.call(a,c)}function oR(a,b){this.FS=null;this.Wv=a;this.jn=b;this.gm=this.Vv=null}oR.prototype=new p;oR.prototype.constructor=oR;oR.prototype.fB=function(){return this.Wv};oR.prototype.Wx=function(a){this.FS=a};oR.prototype.cv=function(){return this.FS};
-oR.prototype.$classData=q({z9:0},!1,"scala.collection.mutable.LinkedHashMap$LinkedEntry",{z9:1,d:1,DL:1});function pR(a){this.MS=null;this.$B=a;this.kr=this.Yv=null}pR.prototype=new p;pR.prototype.constructor=pR;pR.prototype.fB=function(){return this.$B};pR.prototype.Wx=function(a){this.MS=a};pR.prototype.cv=function(){return this.MS};pR.prototype.$classData=q({F9:0},!1,"scala.collection.mutable.LinkedHashSet$Entry",{F9:1,d:1,DL:1});function qR(){this.ay=null;rR=this;this.ay=Ii().ZL}
-qR.prototype=new p;qR.prototype.constructor=qR;
-function sR(a,b){var c=""+a;a=new Mq;Nq(a,Oq(c),c.length);c=b.ur;var d=Pq(a)-c|0;if(!(tR(a)<c||0===c||0>=d))if(64>a.Rh){c=aN().Qy.a[d];var e=c.W,g=c.Z,h=a.wb,k=h>>31,l=d>>31;c=h-d|0;h=(-2147483648^c)>(-2147483648^h)?-1+(k-l|0)|0:k-l|0;d=a.qg;l=d.W;var m=d.Z;k=Cb();d=ki(k,l,m,e,g);k=k.Kc;var n=Cb();l=bj(n,l,m,e,g);m=n.Kc;if(0!==l||0!==m){aN();if(0>m){var r=-l|0;n=0!==l?~m:-m|0}else r=l,n=m;n=new fb(r<<1,r>>>31|0|n<<1);e=new fb(e,g);g=n.Z;r=e.Z;(g===r?(-2147483648^n.W)>(-2147483648^e.W):g>r)?e=1:(g=
-n.Z,r=e.Z,e=(g===r?(-2147483648^n.W)<(-2147483648^e.W):g<r)?-1:0);e=Math.imul(0>m?-1:0===m&&0===l?0:1,5+e|0);e=eN(aN(),1&d,e,b.cw);g=e>>31;e=d+e|0;d=(-2147483648^e)<(-2147483648^d)?1+(k+g|0)|0:k+g|0;0>d?(k=-e|0,g=0!==e?~d:-d|0):(k=e,g=d);k=KF(Cb(),k,g);+Math.log10(k)>=b.ur?(c=-1+c|0,k=-1!==c?h:-1+h|0,h=Cb(),d=ki(h,e,d,10,0),c=new fb(c,k),h=new fb(d,h.Kc)):(c=new fb(c,h),h=new fb(e,d))}else c=new fb(c,h),h=new fb(d,k);c=Qb(c);d=Qb(h);h=Qb(new fb(c.W,c.Z));c=h.W;h=h.Z;k=Qb(new fb(d.W,d.Z));d=k.W;k=
-k.Z;a.wb=fN(aN(),new fb(c,h));a.tr=b.ur;a.qg=new fb(d,k);a.Rh=$M(aN(),new fb(d,k));a.sr=null}else e=$i(pi(),new fb(d,d>>31)),h=uR(TM(a),e),k=a.wb,g=k>>31,l=d>>31,d=k-d|0,k=(-2147483648^d)>(-2147483648^k)?-1+(g-l|0)|0:g-l|0,0!==h.a[1].Ya&&(g=OM(h.a[1]),0!==g.Ya&&(bi(),l=g.ub,m=1+l|0,n=new zd(m),Xh(0,n,g.Pa,l),g=Qh(g.Ya,m,n),Wh(g)),g=PL(g,e),e=vR(h.a[0],0)?1:0,g=Math.imul(h.a[1].Ya,5+g|0),e=eN(aN(),e,g,b.cw),0!==e&&(e=zi(Zh(),new fb(e,e>>31)),g=h.a[0],h.a[0]=xi(Di(),g,e)),e=new Mq,wR(e,h.a[0],0),Pq(e)>
-c&&(h.a[0]=xR(h.a[0],Zh().Cp),d=e=-1+d|0,k=-1!==e?k:-1+k|0)),a.wb=fN(aN(),new fb(d,k)),a.tr=c,yR(a,h.a[0]);return new Qq(a,b)}qR.prototype.$classData=q({Q2:0},!1,"scala.math.BigDecimal$",{Q2:1,d:1,l:1});var rR;function Lq(){rR||(rR=new qR);return rR}function zR(a,b){var c=b-a.by|0,d=a.sK.a[c];null===d&&(d=AR(new BR,null,new fb(b,b>>31)),a.sK.a[c]=d);return d}
-function CR(){this.XQ=this.tK=null;this.nB=this.by=0;this.YQ=this.sK=null;DR=this;this.tK=zi(Zh(),new fb(0,-2147483648));this.XQ=AR(new BR,this.tK,new fb(0,-2147483648));this.by=-1024;this.nB=1024;this.sK=new (Nd(ER).Ja)(1+(this.nB-this.by|0)|0);this.YQ=zi(Zh(),new fb(-1,-1))}CR.prototype=new p;CR.prototype.constructor=CR;function Bq(){var a=jr();return 0>=a.by&&0<=a.nB?zR(a,0):FR(a,new fb(0,0))}
-function FR(a,b){var c=a.by,d=c>>31,e=b.Z;(d===e?(-2147483648^c)<=(-2147483648^b.W):d<e)?(c=a.nB,d=c>>31,e=b.Z,c=e===d?(-2147483648^b.W)<=(-2147483648^c):e<d):c=!1;return c?zR(a,b.W):0===b.W&&-2147483648===b.Z?a.XQ:AR(new BR,null,b)}function wp(a){var b=jr();return GR(b,OL(a))}function ir(a,b,c){return GR(a,HR(new MM,b,c))}
-function GR(a,b){if(63>=Mh(bi(),b)){var c=b.ll(),d=c.W;c=c.Z;var e=a.by,g=e>>31;(g===c?(-2147483648^e)<=(-2147483648^d):g<c)?(e=a.nB,g=e>>31,e=c===g?(-2147483648^d)<=(-2147483648^e):c<g):e=!1;return e?zR(a,d):AR(new BR,b,new fb(d,c))}return AR(new BR,b,new fb(0,-2147483648))}CR.prototype.$classData=q({S2:0},!1,"scala.math.BigInt$",{S2:1,d:1,l:1});var DR;function wK(){DR||(DR=new CR);return DR}function IR(){}IR.prototype=new p;IR.prototype.constructor=IR;
-function fG(a,b){b===ma(Xd)?a=bL():b===ma(Yd)?a=cL():b===ma(Vd)?a=Tq():b===ma(Zd)?a=Rl():b===ma($d)?a=$K():b===ma(ae)?a=aL():b===ma(ce)?a=ZK():b===ma(Td)?a=dL():b===ma(Qd)?a=JR():b===ma(Md)?a=AG():b===ma(TG)?(KR||(KR=new LR),a=KR):b===ma(SG)?(MR||(MR=new NR),a=MR):a=new KA(b);return a}IR.prototype.$classData=q({o3:0},!1,"scala.reflect.ClassTag$",{o3:1,d:1,l:1});var OR;function gG(){OR||(OR=new IR);return OR}function PR(){}PR.prototype=new p;PR.prototype.constructor=PR;function QR(){}
-QR.prototype=PR.prototype;PR.prototype.u=function(){return"\x3cfunction0\x3e"};function RR(){}RR.prototype=new p;RR.prototype.constructor=RR;function SR(){}SR.prototype=RR.prototype;RR.prototype.u=function(){return"\x3cfunction1\x3e"};function TR(){}TR.prototype=new p;TR.prototype.constructor=TR;function UR(){}UR.prototype=TR.prototype;function VR(){}VR.prototype=new p;VR.prototype.constructor=VR;function WR(){}WR.prototype=VR.prototype;VR.prototype.u=function(){return"\x3cfunction2\x3e"};
-function YR(){}YR.prototype=new p;YR.prototype.constructor=YR;function ZR(){}ZR.prototype=YR.prototype;YR.prototype.u=function(){return"\x3cfunction3\x3e"};function $R(){}$R.prototype=new p;$R.prototype.constructor=$R;function aS(){}aS.prototype=$R.prototype;function bS(){}bS.prototype=new p;bS.prototype.constructor=bS;function cS(){}cS.prototype=bS.prototype;function hA(a){this.ko=a}hA.prototype=new p;hA.prototype.constructor=hA;hA.prototype.u=function(){return""+this.ko};
-hA.prototype.$classData=q({r$:0},!1,"scala.runtime.BooleanRef",{r$:1,d:1,l:1});function zQ(a){this.Zd=a}zQ.prototype=new p;zQ.prototype.constructor=zQ;zQ.prototype.u=function(){return""+this.Zd};zQ.prototype.$classData=q({t$:0},!1,"scala.runtime.IntRef",{t$:1,d:1,l:1});function xu(){this.mo=this.lo=!1}xu.prototype=new p;xu.prototype.constructor=xu;function su(a,b){a.mo=b;a.lo=!0;return b}xu.prototype.u=function(){return"LazyBoolean "+(this.lo?"of: "+this.mo:"thunk")};
-xu.prototype.$classData=q({u$:0},!1,"scala.runtime.LazyBoolean",{u$:1,d:1,l:1});function xf(){this.qb=!1;this.sb=null}xf.prototype=new p;xf.prototype.constructor=xf;function Ce(a,b){a.sb=b;a.qb=!0;return b}xf.prototype.u=function(){return"LazyRef "+(this.qb?"of: "+this.sb:"thunk")};xf.prototype.$classData=q({v$:0},!1,"scala.runtime.LazyRef",{v$:1,d:1,l:1});function ov(a){this.Lb=a}ov.prototype=new p;ov.prototype.constructor=ov;ov.prototype.u=function(){return""+this.Lb};
-ov.prototype.$classData=q({z$:0},!1,"scala.runtime.ObjectRef",{z$:1,d:1,l:1});function rK(){}rK.prototype=new p;rK.prototype.constructor=rK;rK.prototype.$classData=q({H3:0},!1,"scala.util.Either$",{H3:1,d:1,l:1});var qK;function tK(){}tK.prototype=new p;tK.prototype.constructor=tK;tK.prototype.u=function(){return"Left"};tK.prototype.$classData=q({J3:0},!1,"scala.util.Left$",{J3:1,d:1,l:1});var sK;function vK(){}vK.prototype=new p;vK.prototype.constructor=vK;vK.prototype.u=function(){return"Right"};
-vK.prototype.$classData=q({L3:0},!1,"scala.util.Right$",{L3:1,d:1,l:1});var uK;function dS(){this.RF=this.qB=this.Sq=this.ig=0;eS=this;this.ig=dc("Seq");this.Sq=dc("Map");this.qB=dc("Set");this.RF=lL(this,O().c,this.Sq)}dS.prototype=new gL;dS.prototype.constructor=dS;function fS(a,b,c){return iL(a,dy(W(),b),dy(W(),c))}
-function gS(a){var b=kL();if(a&&a.$classData&&a.$classData.pb.Zc)a:{var c=b.ig,d=a.K();switch(d){case 0:b=b.La(c,0);break a;case 1:d=c;a=a.ua(0);b=b.La(b.B(d,dy(W(),a)),1);break a;default:var e=a.ua(0),g=dy(W(),e);e=c=b.B(c,g);var h=a.ua(1);h=dy(W(),h);var k=h-g|0;for(g=2;g<d;){c=b.B(c,h);var l=a.ua(g);l=dy(W(),l);if(k!==(l-h|0)){c=b.B(c,l);for(g=1+g|0;g<d;)e=a.ua(g),c=b.B(c,dy(W(),e)),g=1+g|0;b=b.La(c,d);break a}h=l;g=1+g|0}b=hL(b.B(b.B(e,k),h))}}else if(a instanceof hS){d=b.ig;g=0;h=d;c=e=l=k=0;
-for(var m=a;!m.b();){a=m.e();m=m.g();a=dy(W(),a);h=b.B(h,a);switch(k){case 0:c=a;k=1;break;case 1:l=a-e|0;k=2;break;case 2:l!==(a-e|0)&&(k=3)}e=a;g=1+g|0}2===k?(a=l,b=hL(b.B(b.B(b.B(d,c),a),e))):b=b.La(h,g)}else a:if(d=b.ig,a=a.m(),a.s())if(c=a.t(),a.s()){e=a.t();h=dy(W(),c);c=d=b.B(d,h);g=dy(W(),e);h=g-h|0;for(e=2;a.s();){d=b.B(d,g);k=a.t();k=dy(W(),k);if(h!==(k-g|0)){d=b.B(d,k);for(e=1+e|0;a.s();)c=a.t(),d=b.B(d,dy(W(),c)),e=1+e|0;b=b.La(d,e);break a}g=k;e=1+e|0}b=hL(b.B(b.B(c,h),g))}else b=b.La(b.B(d,
-dy(W(),c)),1);else b=b.La(d,0);return b}dS.prototype.$classData=q({O3:0},!1,"scala.util.hashing.MurmurHash3$",{O3:1,cba:1,d:1});var eS;function kL(){eS||(eS=new dS);return eS}function iS(){this.AK=this.yK=this.xK=0;this.zK=1}iS.prototype=new p;iS.prototype.constructor=iS;iS.prototype.u=function(){return"\x3cfunction2\x3e"};iS.prototype.Jx=function(a,b){a=fS(kL(),a,b);this.xK=this.xK+a|0;this.yK^=a;this.zK=Math.imul(this.zK,1|a);this.AK=1+this.AK|0};iS.prototype.aa=function(a,b){this.Jx(a,b)};
-iS.prototype.$classData=q({P3:0},!1,"scala.util.hashing.MurmurHash3$accum$1",{P3:1,d:1,Py:1});function Op(){this.SF=null}Op.prototype=new p;Op.prototype.constructor=Op;Op.prototype.u=function(){return this.SF.MQ};Op.prototype.$classData=q({R3:0},!1,"scala.util.matching.Regex",{R3:1,d:1,l:1});function jS(){this.fQ=null;this.pF=0}jS.prototype=new p;jS.prototype.constructor=jS;function kS(){}kS.prototype=jS.prototype;jS.prototype.u=function(){return this.fQ};
-jS.prototype.h=function(a){return this===a};jS.prototype.y=function(){return bd(this)};jS.prototype.sk=function(a){var b=this.pF;a=a.pF;return b===a?0:b<a?-1:1};function lS(a,b){fF(a,b,null,!0);return a}class mS extends oe{}mS.prototype.$classData=q({qF:0},!1,"java.lang.Error",{qF:1,jc:1,d:1,l:1});class eF extends oe{}eF.prototype.$classData=q({fd:0},!1,"java.lang.Exception",{fd:1,jc:1,d:1,l:1});function nS(){}nS.prototype=new p;nS.prototype.constructor=nS;function oS(){}oS.prototype=nS.prototype;
-nS.prototype.u=function(){for(var a=this.Uu(),b="[",c=!0;a.s();)c?c=!1:b+=", ",b=""+b+a.t();return b+"]"};function zN(a){this.$A=this.RJ=0;this.QJ=this.aB=null;if(null===a)throw null;this.QJ=a;this.RJ=a.kl.a.length}zN.prototype=new vN;zN.prototype.constructor=zN;zN.prototype.$classData=q({r1:0},!1,"java.util.HashMap$NodeIterator",{r1:1,vaa:1,d:1,K1:1});function pS(){this.Ry=null;this.Ty=this.Uy=0;this.Vy=this.Sy=null;this.sn=0}pS.prototype=new p;pS.prototype.constructor=pS;function qS(){}
-f=qS.prototype=pS.prototype;f.Kj=function(){if(this instanceof Im){var a=this.yr;var b=this.xr,c=this.zr,d=O().c;a=new A(a,new A(b,new A(c,d)))}else if(this instanceof Mm)a=this.qq,b=O().c,a=new A(a,b);else if(Nm()===this)a=O().c;else throw new x(this);return a};f.Jm=function(){0===(1&this.sn)<<24>>24&&0===(1&this.sn)<<24>>24&&(this.Ry=Yp(this),this.sn=(1|this.sn)<<24>>24);return this.Ry};f.Rm=function(){return this.Uy};f.Tl=function(a){this.Uy=a};f.Qm=function(){return this.Ty};
-f.Sl=function(a){this.Ty=a};f.Pm=function(){return this.Sy};f.Om=function(a){this.Sy=a};f.C=function(){0===(2&this.sn)<<24>>24&&0===(2&this.sn)<<24>>24&&(this.Vy=bq(this),this.sn=(2|this.sn)<<24>>24);return this.Vy};function rS(){this.Lr=null;this.Nr=this.Or=0;this.Pr=this.Mr=null;this.Uk=0}rS.prototype=new p;rS.prototype.constructor=rS;function sS(){}f=sS.prototype=rS.prototype;f.Kj=function(){return Cca(this)};
-f.Jm=function(){0===(1&this.Uk)<<24>>24&&0===(1&this.Uk)<<24>>24&&(this.Lr=Yp(this),this.Uk=(1|this.Uk)<<24>>24);return this.Lr};f.Rm=function(){return this.Or};f.Tl=function(a){this.Or=a};f.Qm=function(){return this.Nr};f.Sl=function(a){this.Nr=a};f.Pm=function(){return this.Mr};f.Om=function(a){this.Mr=a};f.C=function(){0===(2&this.Uk)<<24>>24&&0===(2&this.Uk)<<24>>24&&(this.Pr=bq(this),this.Uk=(2|this.Uk)<<24>>24);return this.Pr};function tS(){}tS.prototype=new hO;tS.prototype.constructor=tS;
-function uS(){}uS.prototype=tS.prototype;function No(a,b,c){a.Cw=b;a.eH=c;return a}function Oo(){this.eH=this.Cw=null}Oo.prototype=new XN;Oo.prototype.constructor=Oo;function vS(){}vS.prototype=Oo.prototype;Oo.prototype.ih=function(){return 20};Oo.prototype.xa=function(){return Gp(Gp(Gp(Ep(this.Cw.xa(),20>this.Cw.ih()||this.Cw instanceof fo),Hp(Fp(),"[")),this.eH.xa()),Hp(Fp(),"]"))};Oo.prototype.DJ=function(){return this.Cw.DJ()};
-Oo.prototype.$classData=q({VM:0},!1,"mlscript.JSMember",{VM:1,Oi:1,Uc:1,d:1});function JS(){this.Cn=this.Bn=this.Dn=null;this.Vo=this.Wo=this.Dm=this.Uo=0;this.pa=null;this.q=0;this.bl=this.iq=this.mq=this.No=this.Ro=this.So=this.kq=this.Po=this.jq=this.Mo=this.Qo=this.Oo=this.lq=null;this.To=0;this.Up=this.Wp=this.Xp=this.Vp=this.Zp=this.Yp=null}JS.prototype=new DP;JS.prototype.constructor=JS;function KS(){}KS.prototype=JS.prototype;
-function pu(a){null===a.Yp&&null===a.Yp&&(a.Yp=new LS(a));return a.Yp}function Av(a){null===a.Zp&&null===a.Zp&&(a.Zp=new MS(a));return a.Zp}function LO(a){null===a.Vp&&null===a.Vp&&(a.Vp=new BO(a));return a.Vp}function YA(a){null===a.Wp&&null===a.Wp&&(a.Wp=new DO(a));return a.Wp}function xO(a){null===a.Up&&null===a.Up&&(a.Up=new rO(a));return a.Up}function PC(a){return hf(new E(a),!0)}function Su(a){return hf(new E(a),!0)}
-function Ov(a,b,c,d,e){var g=mu(),h=ap().wa;g=new ou(g,h);h=Ku();var k=c.Q()+d.Q()|0;d=Zu(Zu($u(8<k?k:8),c),d);c=ru().U();for(d=Sl(d).m();d.s();){var l=d.t();k=l.i();var m=c.Y(k);if(m instanceof M){m=m.k;var n=l.j();gp(fp(),hf(new E(m.ob),n.ob));fp();l=m.Vb.K();gp(0,hf(new E(l),n.Vb.K()));l=m.ob;m=m.Vb;m=new vq(m,m,n.Vb);n=new Um(((r,u)=>(w,y)=>{if(r){var B=rv(a),D=V(w.p);D=ju(w,y,D,!1);var C=V(w.p);return sv(B,D,zu(w,y,C,!1),tv(rv(a)),u)}B=rv(a);D=V(w.p);D=zu(w,y,D,!1);C=V(w.p);return sv(B,D,ju(w,
-y,C,!1),tv(rv(a)),u)})(b,e));xq();m=Rv(m,n);l=new uv(a,l,m,V(a))}else{if(R()!==m)throw new x(m);l=l.j()}c.Vi(k,l)}b=cp();return bv(h,(new cv(b)).qc(c),g)}class NS extends oe{constructor(a){super();this.KW=a;fF(this,null,null,!0)}}NS.prototype.$classData=q({JW:0},!1,"mlscript.NotAType",{JW:1,jc:1,d:1,l:1});function OS(a,b,c,d){this.sH=this.vN=this.XD=this.nq=this.$z=null;if(null===a)throw null;this.XD=a;this.vN=c;this.sH=d;ZC(this,a.ic,b)}OS.prototype=new aD;OS.prototype.constructor=OS;
-OS.prototype.$o=function(a,b){cD(this,a,b)};
-OS.prototype.Rb=function(a,b){var c=this.XD.ic.pa,d=this.XD.ic;if(d.D){var e=Hs(Q(),"| ",d.q)+("Trav("+a+")("+b)+")";Af(Bf(),e+"\n")}d.q=1+d.q|0;try{if(b instanceof Ow){var g=this.vN,h=a.zg(b.Va);if(g.eh(G(new H,h,b))){var k=this.sH,l=this.sH.yd(b,new U(()=>Tt().lP)),m=!1,n=null,r=a.zg(b.Va);a:{if(r instanceof M&&(m=!0,n=r,!0===!!n.k)){var u=Tt().bA;break a}if(m&&!1===!!n.k)u=Tt().cA;else if(t().f===r)u=Tt().En;else throw new x(r);}k.Qh(b,new VP(l.wd&&u.wd,l.Vd&&u.Vd));$C.prototype.Rb.call(this,a,
-b)}}else if(b instanceof dv){m=this.XD.ic;k=Y=>cH(Q(),Y.i().w,35);var w=b.Ba;a:for(;;)if(w.b()){n=v();break}else{var y=w.e(),B=w.g();if(!0===!!k(y))w=B;else for(l=w,r=B;;){if(r.b())n=l;else{var D=r.e();if(!0!==!!k(D)){r=r.g();continue}D=r;var C=new A(l.e(),v()),F=l.g();for(l=C;F!==D;){var I=new A(F.e(),v());l=l.r=I;F=F.g()}var K=D.g();for(F=K;!K.b();){var N=K.e();if(!0===!!k(N)){for(;F!==K;){var P=new A(F.e(),v());l=l.r=P;F=F.g()}F=K.g()}K=K.g()}F.b()||(l.r=F);n=C}break a}}var T=new dv(m,n,b.Cj);
-$C.prototype.Rb.call(this,a,T)}else $C.prototype.Rb.call(this,a,b);var aa=void 0}finally{d.q=-1+d.q|0}Gw(new E(c),d.pa)&&d.D&&(a=""+Hs(Q(),"| ",d.q)+c.n(aa),Af(Bf(),a+"\n"))};OS.prototype.$classData=q({aX:0},!1,"mlscript.NuTypeDefs$TypedNuCls$Trav$1$",{aX:1,UO:1,d:1,tZ:1});function PS(a,b){if(null===b)throw null;a.ic=b;var c=a.EF().Qd();c=new eg(c,new z(e=>{e=e.Sa();return new Wl(e)}));a.Sw=Zp($p(),c);c=a.or().C();a=Ax(a.or());Uw(b);var d=t().f;Mw(new Nw,b,c,a,d,!0)}
-function cx(){this.ic=this.Sw=null}cx.prototype=new p;cx.prototype.constructor=cx;function QS(){}QS.prototype=cx.prototype;cx.prototype.C=function(){return this.or().C()};cx.prototype.FF=function(){return this.ic};function RS(a,b){a.se=(t(),new M(b));b=b.C();return aq(a,b)}
-var Lt=function SS(a){var c=a.se;if(c instanceof M)return SS(c.k);if(t().f===c){var d=!1,e=null,g=!1,h=!1,k=null;c=!1;var l=null;if(a instanceof hm){d=!0;e=a;var m=e.Sh;if(!0===e.Sk)a:{if(m instanceof im){var n=m.Ra;if(n instanceof A&&n.r instanceof A){m=!0;break a}}if(m instanceof im&&(n=m.Ra,n instanceof A&&(n=n.A,null!==n&&n.i()instanceof M))){m=!0;break a}m=m instanceof pm?!0:!1}else m=!1;if(m)return"record"}if(d)return SS(e.Sh);if(a instanceof pm&&(g=!0,e=a.Rk,e instanceof A&&(d=e.A,e=e.r,d instanceof
-Ln&&(m=O().c,null===m?null===e:m.h(e)))))return SS(d);if(g)return"block of statements";if(a instanceof Do)return"integer literal";if(a instanceof Ho)return"decimal literal";if(a instanceof Io)return"string literal";if(a instanceof Jo)return a.Es?"undefined literal":"null literal";if(a instanceof Wl)return"reference";if(a instanceof em)return"type ascription";if(a instanceof lm)return"lambda expression";if(a instanceof mm&&(h=!0,k=a,g=k.kb,null!==g&&(g=xy(Ay(),g),!g.b()&&(g=g.o().i(),g instanceof Wl&&
-"|"===g.w))))return"type union";if(h&&(g=k.kb,null!==g&&(g=xy(Ay(),g),!g.b()&&(g=g.o().i(),g instanceof Wl&&"\x26"===g.w))))return"type intersection";if(h&&(k=k.kb,null!==k&&!xy(Ay(),k).b())||null!==a&&!xy(Ay(),a).b())return"operator application";if(h)return"application";if(a instanceof Zl)return"record";if(a instanceof nm)return"field selection";if(a instanceof om)return"let binding";if(a instanceof im&&(c=!0,l=a,h=l.Ra,h instanceof A&&(k=h.A,h=h.r,null!==k&&(g=k.i(),k=k.j(),t().f===g&&null!==k&&
-(k=k.Da,g=O().c,null===g?null===h:g.h(h))))))return SS(k);if(c&&(h=l.Ra,h instanceof A&&(l=h.A,h=h.r,null!==l&&(l.i()instanceof M?(l=O().c,l=null===l?null===h:l.h(h)):l=!1,l))))return"binding";if(c)return"tuple";if(a instanceof qm)return"`with` extension";if(a instanceof rm)return"`case` expression";if(a instanceof sm)return"array access";if(a instanceof um)return"new instance";if(a instanceof zm)return"refinement";if(a instanceof tm)return"if-else block";if(a instanceof km)return"type application";
-if(a instanceof wm)return"constraint clause";if(a instanceof vm)return"forall clause";if(a instanceof xm)return"super";if(a instanceof ym)return"assign for ctor";throw new x(a);}throw new x(c);},rz=function TS(a,b){var d=!1,e=null,g=!1,h=null,k=!1,l=null;if(a instanceof hm){d=!0;e=a;var m=e.Sh;if(!0===e.Sk)return"'{' "+TS(m,!1)+" '}'"}if(d&&(d=e.Sh,!1===e.Sk))return"'(' "+TS(d,!1)+" ')'";if(a instanceof pm)return b=a.Rk.m(),b=new eg(b,new z(n=>n.mr())),Qe(b,"{","; ","}");if(a instanceof Do)return a.Rr.u();
-if(a instanceof Ho)return a.nw.gd.u();if(a instanceof Io)return b=a.dx,""+String.fromCharCode(34)+b+'"';if(a instanceof Jo)return a.Es?"undefined":"null";if(a instanceof Wl)return b=a.w,a=a.Fs,a=a.b()?"":"::"+(a.o()|0),b+a;if(a instanceof em)return l=a.po,a=TS(a.Ni,!1)+" : "+MO(l),US(a,b);if(a instanceof lm&&(g=!0,h=a,e=h.Dl,d=h.El,e instanceof im))return a="("+qz(e)+") \x3d\x3e "+TS(d,!1),US(a,b);if(g)return a=h.El,a="(..."+TS(h.Dl,!1)+") \x3d\x3e "+TS(a,!1),US(a,b);if(a instanceof mm&&(k=!0,l=a,
-h=l.kb,g=l.hc,g instanceof im))return a=TS(h,!(h instanceof mm))+"("+qz(g)+")",US(a,b);if(k)return a=l.kb,l=l.hc,a=TS(a,!(a instanceof mm))+"(..."+TS(l,!0)+")",US(a,b);if(a instanceof Zl)return b=a.vn.m(),b=new eg(b,new z(n=>(n.j().vc.pf?"mut ":"")+n.i().w+": "+TS(n.j().Da,!1))),Qe(b,"{",", ","}");if(a instanceof nm)return b=a.wn,"("+TS(a.Co,!1)+")."+TS(b,!1);if(a instanceof om&&(l=a.Wr,k=a.Op,h=a.Pp,g=a.vo,null!==k))return a="let"+(l?" rec":"")+" "+k.w+" \x3d "+TS(h,!1)+" in "+TS(g,!1),US(a,b);if(a instanceof
-im)return"["+qz(a)+"]";if(a instanceof qm)return l=a.vu,a=TS(a.wu,!1)+" with "+TS(l,!1),US(a,b);if(a instanceof rm)return l=a.Ep,a="case "+TS(a.Fp,!1)+" of { "+Bca(l,!0)+" }",US(a,b);if(a instanceof sm)return b=a.gu,"("+TS(a.fu,!1)+")["+TS(b,!1)+"]";if(a instanceof um)return a="new "+TS(a.gs,!1),US(a,b);if(a instanceof tm)return l=a.rw,a=Dca(a.Qr),l.b()?l="":(l=l.o(),l=" else "+TS(l,!1)),US("if "+a+l,b);if(a instanceof km)return l=a.ts,b=TS(a.ym,!1),a=l.m(),a=new eg(a,new z(n=>MO(n))),b+"\u2039"+
-Qe(a,"",", ","")+"\u203a";if(a instanceof wm)return l=a.uu,b=TS(a.tu,!1),a=l.m(),a=new eg(a,new z(n=>n.mr())),b+" where {"+Qe(a,"","; ","")+"}";if(a instanceof vm)return b=a.Ir,"forall "+Qe(a.Pt,"",", ","")+". "+TS(b,!1);if(a instanceof xm)return"super";if(a instanceof ym)return b=a.Er,TS(a.Ip,!1)+" \x3d "+TS(b,!1);if(a instanceof zm)return b=a.du,TS(a.cu,!1)+" "+YO(b);throw new x(a);};
-function VS(a,b){a=An(a);if(a instanceof te)return b.n(a.ca),Il();if(a instanceof me)return a.ia;throw new x(a);}function An(a){try{t();var b=Pca(a),c=a.C(),d=aq(b,c);return new me(d)}catch(e){if(e instanceof NS)return b=e,t(),Jq(),a=sf(new mf(new nf(J(new L,["Not a recognized type"]))),v()),b=b.KW.C(),a=G(new H,a,b),b=O().c,a=Kq(0,new A(a,b),!0,Pr()),new te(a);throw e;}}
-var Pca=function WS(a){var c=!1,d=null,e=!1,g=null;a:{if(a instanceof Wl){c=!0;d=a;var h=d.w;if(0<=h.length&&"`"===h.substring(0,1)){t();var k=qg(Q(),h,1,h.length);var l=new ns(new me(k),t().f);break a}}if(c){var m=d.w;if(0<=m.length&&"'"===m.substring(0,1)){l=new ns((t(),new me(m)),t().f);break a}}if(c)l=new sp(d.w);else if(a instanceof fm)l=new fP(a);else{if(a instanceof mm){e=!0;g=a;var n=g.kb,r=g.hc;if(n instanceof Wl&&"-\x3e"===n.w&&null!==r){var u=Ey(Gt(),r);if(!u.b()&&null!==u.o()&&0===u.o().$a(2)){var w=
-u.o(),y=FA(w,0),B=u.o(),D=FA(B,1);var C=y instanceof im?!0:y instanceof hm&&!1===y.Sk&&y.Sh instanceof im?!0:!1;if(C){l=new nt(WS(y),WS(D));break a}}}}if(e){var F=g.kb,I=g.hc;if(F instanceof Wl&&"-\x3e"===F.w&&null!==I){var K=Ey(Gt(),I);if(!K.b()&&null!==K.o()&&0===K.o().$a(2)){var N=K.o(),P=FA(N,0),T=K.o(),aa=FA(T,1),Y=t().f,S=new Cn(t().f,WS(P)),Z=G(new H,Y,S),ka=O().c;l=new nt(new aP(new A(Z,ka)),WS(aa));break a}}}if(e){var X=g.kb,sa=g.hc;if(X instanceof Wl&&"|"===X.w&&null!==sa){var Ia=Ey(Gt(),
-sa);if(!Ia.b()&&null!==Ia.o()&&0===Ia.o().$a(2)){var Za=Ia.o(),Ga=FA(Za,0),xa=Ia.o(),Ra=FA(xa,1);l=new $O(WS(Ga),WS(Ra));break a}}}if(e){var Ja=g.kb,La=g.hc;if(Ja instanceof Wl&&"\x26"===Ja.w&&null!==La){var pb=Ey(Gt(),La);if(!pb.b()&&null!==pb.o()&&0===pb.o().$a(2)){var Fb=pb.o(),Gb=FA(Fb,0),Hb=pb.o(),tb=FA(Hb,1);l=new ZO(WS(Gb),WS(tb));break a}}}if(e){var kb=g.kb,gb=g.hc;if(kb instanceof Wl&&"\\"===kb.w&&null!==gb){var Vb=Ey(Gt(),gb);if(!Vb.b()&&null!==Vb.o()&&0===Vb.o().$a(2)){var bb=Vb.o(),nb=
-FA(bb,0),Tb=Vb.o(),ub=FA(Tb,1),Ub=WS(nb),$a=new bP(WS(ub));Dt();var cb=O().c,Na=Et(0,new A(kb,new A(ub,cb))),Ca=new ZO(Ub,aq($a,Na)),Ba=jq(g);l=aq(Ca,Ba);break a}}}if(e){var Oa=g.kb,wa=g.hc;if(Oa instanceof Wl&&"~"===Oa.w){l=new bP(WS(wa));break a}}if(a instanceof lm){var ea=a.El;l=new nt(WS(a.Dl),WS(ea))}else{if(e){var la=g.kb,Ka=g.hc;if(null!==Ka){var Ua=Ey(Gt(),Ka);if(!Ua.b()){var ya=Ua.o(),ib=WS(la);if(!(ib instanceof sp))throw new NS(a);var Lb=ya.m(),ec=new eg(Lb,new z(Zb=>WS(Zb)));je();l=new gP(ib,
-le(v(),ec));break a}}}if(a instanceof im){var Mb=a.Ra,Jb=Zb=>{var ed=Zb.i(),$b=Zb.j();a:{if(null!==$b){var Fc=$b.vc;Zb=$b.Da;if(null!==Fc){$b=Fc.pf;Zb=WS(Zb);Zb=new Cn($b?new M(Zb):R(),Zb);break a}}throw new x($b);}return G(new H,ed,Zb)};if(Mb===v())var Kb=v();else{for(var eb=Mb.e(),Wb=new A(Jb(eb),v()),mc=Wb,ua=Mb.g();ua!==v();){var Pa=ua.e(),xb=new A(Jb(Pa),v());mc=mc.r=xb;ua=ua.g()}Kb=Wb}l=new aP(Kb)}else if(a instanceof hm){var Yb=a.Sk,zb=a.Sh;if(zb instanceof Zl){if(!Yb)throw new NS(a);}else if(Yb)throw new NS(a);
-l=WS(zb)}else if(a instanceof km){var Sb=a.ts,Ma=WS(a.ym);if(!(Ma instanceof sp))throw new NS(a);l=new gP(Ma,Sb)}else if(a instanceof Zl){var Ea=a.vn,ab=Zb=>{var ed=Zb.i(),$b=Zb.j();a:{if(null!==$b){var Fc=$b.vc;Zb=$b.Da;if(null!==Fc){$b=Fc.pf;Zb=WS(Zb);Zb=new Cn($b?new M(Zb):R(),Zb);break a}}throw new x($b);}return G(new H,ed,Zb)};if(Ea===v())var Db=v();else{for(var mb=Ea.e(),vb=new A(ab(mb),v()),Ya=vb,Wa=Ea.g();Wa!==v();){var rb=Wa.e(),pa=new A(ab(rb),v());Ya=Ya.r=pa;Wa=Wa.g()}Db=vb}l=new En(Db)}else if(a instanceof
-wm){var Fa=a.uu,Ib=WS(a.tu),qb=O().c,Nb=Zb=>{if(Zb instanceof em){var ed=Zb.po;return new dP(WS(Zb.Ni),ed)}throw new NS(Zb);};if(Fa===v())var fc=v();else{for(var Ac=Fa.e(),tc=new A(Nb(Ac),v()),vc=tc,sc=Fa.g();sc!==v();){var uc=sc.e(),lc=new A(Nb(uc),v());vc=vc.r=lc;sc=sc.g()}fc=tc}l=new hP(Ib,qb,fc)}else if(a instanceof vm){var Wc=a.Pt,Cc=a.Ir,Dc=Zb=>{t();return new me(Zb)};if(Wc===v())var Ec=v();else{for(var Ic=Wc.e(),Xc=new A(Dc(Ic),v()),Sc=Xc,oc=Wc.g();oc!==v();){var qc=oc.e(),Tc=new A(Dc(qc),
-v());Sc=Sc.r=Tc;oc=oc.g()}Ec=Xc}l=new mt(Ec,WS(Cc))}else if(a instanceof nm){var Nc=a.wn,Pc=WS(a.Co),Oc=new sp(Nc.w),$c=Nc.C();l=new kP(Pc,aq(Oc,$c))}else throw new NS(a);}}}var Lc=a.C();return aq(l,Lc)};function US(a,b){return b?"("+a+")":a}function XS(){this.td=null}XS.prototype=new KN;XS.prototype.constructor=XS;function YS(){}YS.prototype=XS.prototype;function ZS(){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0}ZS.prototype=new p;ZS.prototype.constructor=ZS;
-function $S(){}$S.prototype=ZS.prototype;function QO(a){if(0===(1&a.mc)<<24>>24&&0===(1&a.mc)<<24>>24){if(a instanceof ns){var b=O().c;b=new A(a,b)}else{b=vP(a);for(var c=null,d=null;b!==v();){for(var e=QO(b.e()).m();e.s();){var g=new A(e.t(),v());null===d?c=g:d.r=g;d=g}b=b.g()}b=null===c?v():c}a.Xe=b;a.mc=(1|a.mc)<<24>>24}return a.Xe}
-function aT(a){if(0===(2&a.mc)<<24>>24&&0===(2&a.mc)<<24>>24){if(a instanceof ns){fp();var b=Vp(a)}else{var c=vP(a);b=Wp();for(c=jp(c);!c.b();){var d=c.e();b=aT(d).af(b);c=c.g()}}a.Re=b;a.mc=(2|a.mc)<<24>>24}return a.Re}f=ZS.prototype;f.Jm=function(){0===(4&this.mc)<<24>>24&&0===(4&this.mc)<<24>>24&&(this.Se=Yp(this),this.mc=(4|this.mc)<<24>>24);return this.Se};f.Rm=function(){return this.Ve};f.Tl=function(a){this.Ve=a};f.Qm=function(){return this.Ue};f.Sl=function(a){this.Ue=a};f.Pm=function(){return this.Te};
-f.Om=function(a){this.Te=a};f.C=function(){0===(8&this.mc)<<24>>24&&0===(8&this.mc)<<24>>24&&(this.We=bq(this),this.mc=(8|this.mc)<<24>>24);return this.We};function aB(a,b,c,d,e){this.iE=this.IN=this.ju=this.OH=this.nq=this.$z=null;if(null===a)throw null;this.OH=a;this.ju=c;this.IN=d;this.iE=e;ZC(this,a,b)}aB.prototype=new aD;aB.prototype.constructor=aB;aB.prototype.$o=function(a,b){cD(this,a,b)};
-aB.prototype.Rb=function(a,b){var c=this.OH.pa,d=this.OH;if(d.D){var e=Hs(Q(),"| ",d.q)+("analyze1["+a+"] ")+b;Af(Bf(),e+"\n")}d.q=1+d.q|0;try{if(b instanceof Ow){var g=a.zg(b.Va);if(g instanceof M){var h=G(new H,!!g.k,b);this.ju.Qh(h,1+(this.ju.n(h)|0)|0)}else if(t().f===g){this.IN.S(b);var k=G(new H,!0,b);this.ju.Qh(k,1+(this.ju.n(k)|0)|0);var l=G(new H,!1,b);this.ju.Qh(l,1+(this.ju.n(l)|0)|0)}else throw new x(g);var m=b.Wb;if(m instanceof M){var n=m.k,r=new $A(this.iE),u=a.zg(b.Va),w=u.b()?!1:
-u.o(),y=G(new H,b,w);r.Fm.L(y)||(r.Fm.S(y),this.Rb(a,n))}else if(t().f===m){var B=a.zg(b.Va);if(sr(new E(B),(t(),new M(!1)))){var D=new $A(this.iE),C=G(new H,b,!0);if(!D.Fm.L(C)){D.Fm.S(C);var F=ny(b),I=new kB(a,b.Va,!0);for(e=F;!e.b();){var K=e.e();this.Rb(I,K);e=e.g()}}}var N=a.zg(b.Va);if(sr(new E(N),(t(),new M(!0)))){var P=new $A(this.iE),T=G(new H,b,!1);if(!P.Fm.L(T)){P.Fm.S(T);var aa=Tz(b),Y=new kB(a,b.Va,!1);for(a=aa;!a.b();){var S=a.e();this.Rb(Y,S);a=a.g()}}}}else throw new x(m);}else $C.prototype.Rb.call(this,
-a,b);var Z=void 0}finally{d.q=-1+d.q|0}Gw(new E(c),d.pa)&&d.D&&(c=""+Hs(Q(),"| ",d.q)+c.n(Z),Af(Bf(),c+"\n"))};aB.prototype.$classData=q({cY:0},!1,"mlscript.TypeSimplifier$Analyze1$1$",{cY:1,UO:1,d:1,tZ:1});function bT(a){var b=xP(a.Go);return b.b()?a.Rz:b}
-function cT(a,b){a=a.Go;if(a instanceof me)a=G(new H,0,a.ia);else if(a instanceof te)a=G(new H,a.ca|0,"");else throw new x(a);var c=dq(),d=dT();a=new eT(new fT(c,d),a);b=b.Go;if(b instanceof me)b=G(new H,0,b.ia);else if(b instanceof te)b=G(new H,b.ca|0,"");else throw new x(b);return a.gl(b)}function cA(){this.p=null}cA.prototype=new PP;cA.prototype.constructor=cA;function gT(){}gT.prototype=cA.prototype;cA.prototype.ZS=function(){return this};
-var iT=function Qca(a,b){a=G(new H,a,b);b=a.z;var d=a.x;if(qB(b)&&qB(d))return sb(b.Gq().vi,d.Gq().vi);d=a.z;b=a.x;if(d instanceof Pw&&(d=d.Xh,b instanceof Pw))return hT(d,b.Xh);d=a.z;b=a.x;if(d instanceof rB&&(d=d.Am,b instanceof rB))return Qca(d,b.Am);if(qB(a.z)&&(a.x instanceof Pw||a.x instanceof rB))return-1;if((a.z instanceof Pw||a.z instanceof rB)&&qB(a.x))return 1;if(a.z instanceof Pw&&a.x instanceof rB)return-1;if(a.z instanceof rB&&a.x instanceof Pw)return 1;throw new x(a);};
-function hv(a){return!!(a&&a.$classData&&a.$classData.pb.Wz)}function Wn(a,b,c,d,e){this.OI=a;this.Ze=b;this.MI=c;this.NI=d;this.AP=e;this.TE=!1}Wn.prototype=new p;Wn.prototype.constructor=Wn;Wn.prototype.Sn=function(){return this.OI};Wn.prototype.ep=function(){return this.Ze};Wn.prototype.u=function(){return"value "+this.OI};Wn.prototype.$classData=q({YZ:0},!1,"mlscript.codegen.ValueSymbol",{YZ:1,d:1,Gs:1,rq:1});function jT(a,b){a.EP=b;fF(a,null,null,!0);return a}
-function kT(a,b,c){b=G(new H,b,c);c=O().c;jT(a,new A(b,c));return a}class lT extends oe{constructor(){super();this.EP=null}}lT.prototype.$classData=q({k_:0},!1,"mlscript.ucs.DesugaringException",{k_:1,jc:1,d:1,l:1});function mT(){}mT.prototype=new p;mT.prototype.constructor=mT;function nT(){}nT.prototype=mT.prototype;function oT(){this.gv=this.rK=null;pT=this;O();je();this.rK=cp();this.gv=$p()}oT.prototype=new oQ;oT.prototype.constructor=oT;
-function gp(a,b){if(!b)throw new rk("assertion failed");}function Os(a,b){if(!b)throw dk("requirement failed");}function $n(){fp();var a=new qT;fF(a,"an implementation is missing",null,!0);throw a;}oT.prototype.$classData=q({G2:0},!1,"scala.Predef$",{G2:1,zaa:1,Aaa:1,d:1});var pT;function fp(){pT||(pT=new oT);return pT}function Rca(a,b){switch(b){case 0:return a.Jj;case 1:return a.jj;case 2:return a.ci;case 3:return a.Qi;default:throw KK(new LK,b+" is out of bounds (min 0, max 3)");}}
-function Sca(a,b){switch(b){case 0:return a.Gu;case 1:return a.Ks;case 2:return a.zq;case 3:return a.Hu;case 4:return a.Iu;default:throw KK(new LK,b+" is out of bounds (min 0, max 4)");}}function Tca(a,b){switch(b){case 0:return a.Aq;case 1:return a.Bq;case 2:return a.Ls;case 3:return a.Ms;case 4:return a.Ns;case 5:return a.Ju;default:throw KK(new LK,b+" is out of bounds (min 0, max 5)");}}function rT(){sT=this}rT.prototype=new p;rT.prototype.constructor=rT;
-rT.prototype.$classData=q({k4:0},!1,"scala.collection.BuildFrom$",{k4:1,d:1,eba:1,fba:1});var sT;function xq(){sT||(sT=new rT)}function tT(){this.sB=null}tT.prototype=new p;tT.prototype.constructor=tT;function uT(){}uT.prototype=tT.prototype;tT.prototype.U=function(){return this.sB.fg(KH())};tT.prototype.Ib=function(a){return this.sB.Eq(a,KH())};tT.prototype.Db=function(){var a=this.sB,b=KH();return a.Vx(b)};tT.prototype.wh=function(a){var b=this.sB,c=KH();return b.Eq(a,c)};
-function vT(){this.et=null}vT.prototype=new p;vT.prototype.constructor=vT;function wT(){}wT.prototype=vT.prototype;vT.prototype.fg=function(a){return this.et.fg(a)};vT.prototype.Eq=function(a,b){return this.et.Eq(a,b)};vT.prototype.jB=function(a){return this.et.jB(a)};function xT(){this.bm=null}xT.prototype=new p;xT.prototype.constructor=xT;function yT(){}yT.prototype=xT.prototype;xT.prototype.U=function(){return this.bm.U()};xT.prototype.Ib=function(a){return this.bm.Ib(a)};xT.prototype.Db=function(){return this.bm.Db()};
-function zT(a){this.x4=a}zT.prototype=new p;zT.prototype.constructor=zT;zT.prototype.qc=function(a){return this.x4.Ib(a)};zT.prototype.$classData=q({w4:0},!1,"scala.collection.IterableFactory$ToFactory",{w4:1,d:1,BK:1,l:1});function ep(a){a=a.m();return a.s()?new M(a.t()):R()}function AT(a){a=a.m();for(var b=a.t();a.s();)b=a.t();return b}function cs(a){return a.b()?R():new M(a.Fc())}
-function qC(a,b){if(0>b)return 1;var c=a.Q();if(0<=c)return c===b?0:c<b?-1:1;c=0;for(a=a.m();a.s();){if(c===b)return 1;a.t();c=1+c|0}return c-b|0}function Uca(a,b){var c=b.Q();if(0<=c)return a.Pk(c);c=a.Q();if(0<=c)return b=b.Pk(c),-2147483648===b?1:-b|0;a=a.m();for(b=b.m();a.s()&&b.s();)a.t(),b.t();a=a.s();b=b.s();return a===b?0:a?1:-1}function BT(a,b){return a.qc(CT(new DT,a,b))}function ET(a){if(a.b())throw FT();return a.Cc(1)}
-function GT(a,b,c){var d=ru().U();a.ya(new z(h=>{var k=b.n(h);k=d.Ai(k,new U(()=>a.Ob().Db()));h=c.n(h);return k.S(h)}));var e=Jf(),g=new ov(e);d.ya(new z(h=>{if(null!==h)g.Lb=g.Lb.mm(G(new H,h.i(),h.j().Eb()));else throw new x(h);}));return g.Lb}function HT(a,b){return a.Ob().Ib(IT(new JT,a,b))}function KT(a,b){var c=a.Ob();a=$r(b)?new LT(a,b):a.m().mb(new U(()=>b.m()));return c.Ib(a)}
-function MT(a,b){var c=IT(new JT,a,new z(e=>b.n(e).i())),d=IT(new JT,a,new z(e=>b.n(e).j()));return G(new H,a.Ob().Ib(c),a.Ob().Ib(d))}function Vca(a,b){for(var c=!1;!c&&a.s();)c=a.t(),c=Ol(Pl(),c,b);return c}function NT(a,b,c){var d=0<c?c:0;for(a=a.fh(c);a.s();){if(b.n(a.t()))return d;d=1+d|0}return-1}function Cu(a,b){return(new OT(a)).mb(b)}function PT(a,b){return a.fk(0,0<b?b:0)}function QT(a,b,c){b=0<b?b:0;c=0>c?-1:c<=b?0:c-b|0;return 0===c?qq().Oa:new RT(a,b,c)}
-function ST(){this.Oa=null;TT=this;this.Oa=new UT}ST.prototype=new p;ST.prototype.constructor=ST;ST.prototype.Db=function(){return new VT};ST.prototype.U=function(){return this.Oa};ST.prototype.Ib=function(a){return a.m()};ST.prototype.$classData=q({y4:0},!1,"scala.collection.Iterator$",{y4:1,d:1,Uf:1,l:1});var TT;function qq(){TT||(TT=new ST);return TT}function Wca(a){var b=cp();a.ft=b}function WT(){this.ft=null}WT.prototype=new p;WT.prototype.constructor=WT;function XT(){}XT.prototype=WT.prototype;
-WT.prototype.wh=function(a){return this.ft.wh(a)};WT.prototype.Ib=function(a){return this.ft.Ib(a)};WT.prototype.U=function(){return this.ft.U()};WT.prototype.Db=function(){return this.ft.Db()};function cv(a){this.e5=a}cv.prototype=new p;cv.prototype.constructor=cv;cv.prototype.qc=function(a){return this.e5.Ib(a)};cv.prototype.$classData=q({d5:0},!1,"scala.collection.MapFactory$ToFactory",{d5:1,d:1,BK:1,l:1});function YT(){this.ht=null}YT.prototype=new p;YT.prototype.constructor=YT;
-function ZT(){}ZT.prototype=YT.prototype;YT.prototype.eF=function(a,b){return this.ht.eF(a,b)};YT.prototype.Fq=function(a,b){return this.ht.Fq(a,b)};YT.prototype.Ch=function(a){return this.ht.Ch(a)};YT.prototype.bv=function(a){return this.ht.bv(a)};function Lu(a,b){this.w5=a;this.v5=b}Lu.prototype=new p;Lu.prototype.constructor=Lu;Lu.prototype.qc=function(a){return this.w5.Fq(a,this.v5)};Lu.prototype.$classData=q({u5:0},!1,"scala.collection.SortedMapFactory$ToFactory",{u5:1,d:1,BK:1,l:1});
-function $T(){}$T.prototype=new p;$T.prototype.constructor=$T;function aU(a,b){if(b&&b.$classData&&b.$classData.pb.ad)return b;if($r(b))return new bU(new U(()=>b.m()));a=cU(oK(),b);return dU(new eU,a)}$T.prototype.Db=function(){var a=new kF;return new fU(a,new z(b=>aU(gU(),b)))};$T.prototype.U=function(){hU||(hU=new iU);return hU};$T.prototype.Ib=function(a){return aU(0,a)};$T.prototype.$classData=q({M5:0},!1,"scala.collection.View$",{M5:1,d:1,Uf:1,l:1});var jU;
-function gU(){jU||(jU=new $T);return jU}function JH(a,b,c,d,e,g){this.Bb=a;this.kc=b;this.Xd=c;this.Pg=d;this.bd=e;this.ii=g}JH.prototype=new OQ;JH.prototype.constructor=JH;f=JH.prototype;f.ka=function(){return this.bd};f.pc=function(){return this.ii};f.uf=function(a){return this.Xd.a[a<<1]};f.Kf=function(a){return this.Xd.a[1+(a<<1)|0]};f.Ru=function(a){return G(new H,this.Xd.a[a<<1],this.Xd.a[1+(a<<1)|0])};f.Jb=function(a){return this.Pg.a[a]};
-f.gh=function(a){return this.Xd.a[(-1+this.Xd.a.length|0)-a|0]};f.iJ=function(a,b,c,d){var e=UH(pH(),c,d),g=VH(pH(),e);if(0!==(this.Bb&g)){if(b=YH(pH(),this.Bb,e,g),Ol(Pl(),a,this.uf(b)))return this.Kf(b)}else if(0!==(this.kc&g))return this.gh(YH(pH(),this.kc,e,g)).iJ(a,b,c,5+d|0);throw iH("key not found: "+a);};
-f.mF=function(a,b,c,d){var e=UH(pH(),c,d),g=VH(pH(),e);return 0!==(this.Bb&g)?(b=YH(pH(),this.Bb,e,g),c=this.uf(b),Ol(Pl(),a,c)?new M(this.Kf(b)):R()):0!==(this.kc&g)?(e=YH(pH(),this.kc,e,g),this.gh(e).mF(a,b,c,5+d|0)):R()};f.sJ=function(a,b,c,d,e){var g=UH(pH(),c,d),h=VH(pH(),g);return 0!==(this.Bb&h)?(b=YH(pH(),this.Bb,g,h),c=this.uf(b),Ol(Pl(),a,c)?this.Kf(b):Zr(e)):0!==(this.kc&h)?(g=YH(pH(),this.kc,g,h),this.gh(g).sJ(a,b,c,5+d|0,e)):Zr(e)};
-f.fF=function(a,b,c,d){var e=UH(pH(),c,d),g=VH(pH(),e);return 0!==(this.Bb&g)?(c=YH(pH(),this.Bb,e,g),this.Pg.a[c]===b&&Ol(Pl(),a,this.uf(c))):0!==(this.kc&g)&&this.gh(YH(pH(),this.kc,e,g)).fF(a,b,c,5+d|0)};
-function kU(a,b,c,d,e,g,h){var k=UH(pH(),e,g),l=VH(pH(),k);if(0!==(a.Bb&l)){var m=YH(pH(),a.Bb,k,l);k=a.uf(m);var n=a.Jb(m);if(n===d&&Ol(Pl(),k,b))return h?(e=a.Kf(m),Object.is(k,b)&&Object.is(e,c)||(l=a.di(l)<<1,b=a.Xd,e=new jd(b.a.length),b.va(0,e,0,b.a.length),e.a[1+l|0]=c,a=new JH(a.Bb,a.kc,e,a.Pg,a.bd,a.ii)),a):a;m=a.Kf(m);h=HG(JG(),n);c=lU(a,k,m,n,h,b,c,d,e,5+g|0);e=a.di(l);d=e<<1;g=(-2+a.Xd.a.length|0)-a.Ul(l)|0;k=a.Xd;b=new jd(-1+k.a.length|0);k.va(0,b,0,d);k.va(2+d|0,b,d,g-d|0);b.a[g]=c;
-k.va(2+g|0,b,1+g|0,-2+(k.a.length-g|0)|0);e=QH(a.Pg,e);return new JH(a.Bb^l,a.kc|l,b,e,(-1+a.bd|0)+c.ka()|0,(a.ii-h|0)+c.pc()|0)}if(0!==(a.kc&l))return k=YH(pH(),a.kc,k,l),k=a.gh(k),c=k.mC(b,c,d,e,5+g|0,h),c===k?a:mU(a,l,k,c);g=a.di(l);k=g<<1;n=a.Xd;h=new jd(2+n.a.length|0);n.va(0,h,0,k);h.a[k]=b;h.a[1+k|0]=c;n.va(k,h,2+k|0,n.a.length-k|0);c=RH(a.Pg,g,d);return new JH(a.Bb|l,a.kc,h,c,1+a.bd|0,a.ii+e|0)}
-function nU(a,b,c,d,e,g,h){var k=UH(pH(),e,g),l=VH(pH(),k);if(0!==(a.Bb&l)){var m=YH(pH(),a.Bb,k,l);k=a.uf(m);var n=a.Jb(m);if(n===d&&Ol(Pl(),k,b))return d=a.Kf(m),Object.is(k,b)&&Object.is(d,c)||(l=a.di(l)<<1,a.Xd.a[1+l|0]=c),h;var r=a.Kf(m);m=HG(JG(),n);c=lU(a,k,r,n,m,b,c,d,e,5+g|0);oU(a,l,m,c);return h|l}if(0!==(a.kc&l))return k=YH(pH(),a.kc,k,l),r=a.gh(k),k=r.ka(),n=r.pc(),m=h,r instanceof JH&&0!==(l&h)?(nU(r,b,c,d,e,5+g|0,0),h=r):(h=r.mC(b,c,d,e,5+g|0,!0),h!==r&&(m|=l)),a.Xd.a[(-1+a.Xd.a.length|
-0)-a.Ul(l)|0]=h,a.bd=(a.bd-k|0)+h.ka()|0,a.ii=(a.ii-n|0)+h.pc()|0,m;g=a.di(l);k=g<<1;n=a.Xd;m=new jd(2+n.a.length|0);n.va(0,m,0,k);m.a[k]=b;m.a[1+k|0]=c;n.va(k,m,2+k|0,n.a.length-k|0);a.Bb|=l;a.Xd=m;a.Pg=RH(a.Pg,g,d);a.bd=1+a.bd|0;a.ii=a.ii+e|0;return h}
-function pU(a,b,c,d,e){var g=UH(pH(),d,e),h=VH(pH(),g);if(0!==(a.Bb&h)){if(g=YH(pH(),a.Bb,g,h),c=a.uf(g),Ol(Pl(),c,b)){b=a.Bb;2===XH(CH(),b)?(b=a.kc,b=0===XH(CH(),b)):b=!1;if(b)return h=0===e?a.Bb^h:VH(pH(),UH(pH(),d,0)),0===g?new JH(h,0,new jd([a.uf(1),a.Kf(1)]),new zd(new Int32Array([a.Pg.a[1]])),1,HG(JG(),a.Jb(1))):new JH(h,0,new jd([a.uf(0),a.Kf(0)]),new zd(new Int32Array([a.Pg.a[0]])),1,HG(JG(),a.Jb(0)));e=a.di(h);b=e<<1;c=a.Xd;g=new jd(-2+c.a.length|0);c.va(0,g,0,b);c.va(2+b|0,g,b,-2+(c.a.length-
-b|0)|0);e=QH(a.Pg,e);return new JH(a.Bb^h,a.kc,g,e,-1+a.bd|0,a.ii-d|0)}}else if(0!==(a.kc&h)){g=YH(pH(),a.kc,g,h);g=a.gh(g);d=g.PQ(b,c,d,5+e|0);if(d===g)return a;e=d.ka();if(1===e)if(a.bd===g.ka())a=d;else{b=(-1+a.Xd.a.length|0)-a.Ul(h)|0;c=a.di(h);var k=c<<1,l=d.uf(0),m=d.Kf(0),n=a.Xd;e=new jd(1+n.a.length|0);n.va(0,e,0,k);e.a[k]=l;e.a[1+k|0]=m;n.va(k,e,2+k|0,b-k|0);n.va(1+b|0,e,2+b|0,-1+(n.a.length-b|0)|0);b=RH(a.Pg,c,d.Jb(0));a=new JH(a.Bb|h,a.kc^h,e,b,1+(a.bd-g.ka()|0)|0,(a.ii-g.pc()|0)+d.pc()|
-0)}else a=1<e?mU(a,h,g,d):a;return a}return a}function lU(a,b,c,d,e,g,h,k,l,m){if(32<=m)return pK(),b=[G(new H,b,c),G(new H,g,h)],b=J(new L,b),new qU(d,e,rU(0,b));var n=UH(pH(),e,m),r=UH(pH(),l,m),u=e+l|0;if(n!==r)return e=VH(pH(),n)|VH(pH(),r),n<r?new JH(e,0,new jd([b,c,g,h]),new zd(new Int32Array([d,k])),2,u):new JH(e,0,new jd([g,h,b,c]),new zd(new Int32Array([k,d])),2,u);n=VH(pH(),n);d=lU(a,b,c,d,e,g,h,k,l,5+m|0);return new JH(0,n,new jd([d]),SF().mB,d.ka(),d.pc())}f.RA=function(){return 0!==this.kc};
-f.kB=function(){var a=this.kc;return XH(CH(),a)};f.Mx=function(){return 0!==this.Bb};f.Xx=function(){var a=this.Bb;return XH(CH(),a)};f.di=function(a){a=this.Bb&(-1+a|0);return XH(CH(),a)};f.Ul=function(a){a=this.kc&(-1+a|0);return XH(CH(),a)};function mU(a,b,c,d){b=(-1+a.Xd.a.length|0)-a.Ul(b)|0;var e=a.Xd,g=new jd(e.a.length);e.va(0,g,0,e.a.length);g.a[b]=d;return new JH(a.Bb,a.kc,g,a.Pg,(a.bd-c.ka()|0)+d.ka()|0,(a.ii-c.pc()|0)+d.pc()|0)}
-function oU(a,b,c,d){var e=a.di(b),g=e<<1,h=(-2+a.Xd.a.length|0)-a.Ul(b)|0,k=a.Xd,l=new jd(-1+k.a.length|0);k.va(0,l,0,g);k.va(2+g|0,l,g,h-g|0);l.a[h]=d;k.va(2+h|0,l,1+h|0,-2+(k.a.length-h|0)|0);e=QH(a.Pg,e);a.Bb^=b;a.kc|=b;a.Xd=l;a.Pg=e;a.bd=(-1+a.bd|0)+d.ka()|0;a.ii=(a.ii-c|0)+d.pc()|0}f.ya=function(a){var b=this.Bb;b=XH(CH(),b);for(var c=0;c<b;)a.n(this.Ru(c)),c=1+c|0;b=this.kc;b=XH(CH(),b);for(c=0;c<b;)this.gh(c).ya(a),c=1+c|0};
-f.Ag=function(a){var b=this.Bb;b=XH(CH(),b);for(var c=0;c<b;)a.aa(this.uf(c),this.Kf(c)),c=1+c|0;b=this.kc;b=XH(CH(),b);for(c=0;c<b;)this.gh(c).Ag(a),c=1+c|0};f.oJ=function(a){var b=0,c=this.Bb;for(c=XH(CH(),c);b<c;){var d=this.uf(b),e=this.Kf(b);(0,a.JL)(d,e,this.Jb(b));b=1+b|0}b=this.kc;b=XH(CH(),b);for(c=0;c<b;)this.gh(c).oJ(a),c=1+c|0};
-f.h=function(a){if(a instanceof JH){if(this===a)return!0;if(this.ii===a.ii&&this.kc===a.kc&&this.Bb===a.Bb&&this.bd===a.bd){var b=this.Pg,c=a.Pg;b=Jj(fk(),b,c)}else b=!1;if(b){b=this.Xd;a=a.Xd;c=this.Xd.a.length;if(b===a)return!0;for(var d=!0,e=0;d&&e<c;)d=Ol(Pl(),b.a[e],a.a[e]),e=1+e|0;return d}}return!1};f.y=function(){throw Fu("Trie nodes do not support hashing.");};
-function sU(a,b,c){if(b instanceof JH){if(0===a.bd)return b;if(0===b.bd||b===a)return a;if(1===b.bd){var d=b.Jb(0);return kU(a,b.uf(0),b.Kf(0),d,HG(JG(),d),c,!0)}d=!1;var e=a.Bb|b.Bb|a.kc|b.kc,g=VH(pH(),0===e?32:31-Math.clz32(e&(-e|0))|0);e=VH(pH(),31-Math.clz32(e)|0);for(var h=0,k=0,l=0,m=0,n=0,r=0,u=0,w=0,y=0,B=0,D=g,C=0,F=0,I=!1;!I;){if(0!==(D&a.Bb)){if(0!==(D&b.Bb)){var K=a.Jb(C);K===b.Jb(F)&&Ol(Pl(),a.uf(C),b.uf(F))?y|=D:(w|=D,B|=VH(pH(),UH(pH(),HG(JG(),K),c)));F=1+F|0}else 0!==(D&b.kc)?k|=D:
-m|=D;C=1+C|0}else 0!==(D&a.kc)?0!==(D&b.Bb)?(l|=D,F=1+F|0):0!==(D&b.kc)?h|=D:r|=D:0!==(D&b.Bb)?(n|=D,F=1+F|0):0!==(D&b.kc)&&(u|=D);D===e?I=!0:D<<=1}D=m|n|y;B|=h|k|l|r|u;if(D===(n|y)&&B===u)return b;I=XH(CH(),D);C=(I<<1)+XH(CH(),B)|0;F=new jd(C);I=new zd(I);var N=K=0,P=0,T=0,aa=0,Y=0;c=5+c|0;for(var S=0,Z=0,ka=!1;!ka;){if(0!==(g&h)){var X=b.gh(Y),sa=a.gh(aa).QP(X,c);X!==sa&&(d=!0);F.a[-1+(C-Z|0)|0]=sa;Z=1+Z|0;Y=1+Y|0;aa=1+aa|0;K=K+sa.ka()|0;N=N+sa.pc()|0}else if(0!==(g&k)){X=b.gh(Y);sa=a.uf(P);var Ia=
-a.Kf(P),Za=a.Jb(P),Ga=HG(JG(),Za);sa=X.mC(sa,Ia,Za,Ga,c,!1);sa!==X&&(d=!0);F.a[-1+(C-Z|0)|0]=sa;Z=1+Z|0;Y=1+Y|0;P=1+P|0;K=K+sa.ka()|0;N=N+sa.pc()|0}else 0!==(g&l)?(d=!0,X=b.Jb(T),X=a.gh(aa).mC(b.uf(T),b.Kf(T),b.Jb(T),HG(JG(),X),c,!0),F.a[-1+(C-Z|0)|0]=X,Z=1+Z|0,aa=1+aa|0,T=1+T|0,K=K+X.ka()|0,N=N+X.pc()|0):0!==(g&m)?(d=!0,X=a.Pg.a[P],F.a[S<<1]=a.uf(P),F.a[1+(S<<1)|0]=a.Kf(P),I.a[S]=X,S=1+S|0,P=1+P|0,K=1+K|0,N=N+HG(JG(),X)|0):0!==(g&n)?(X=b.Pg.a[T],F.a[S<<1]=b.uf(T),F.a[1+(S<<1)|0]=b.Kf(T),I.a[S]=X,
-S=1+S|0,T=1+T|0,K=1+K|0,N=N+HG(JG(),X)|0):0!==(g&r)?(d=!0,X=a.gh(aa),F.a[-1+(C-Z|0)|0]=X,Z=1+Z|0,aa=1+aa|0,K=K+X.ka()|0,N=N+X.pc()|0):0!==(g&u)?(X=b.gh(Y),F.a[-1+(C-Z|0)|0]=X,Z=1+Z|0,Y=1+Y|0,K=K+X.ka()|0,N=N+X.pc()|0):0!==(g&w)?(d=!0,X=a.Jb(P),sa=b.Jb(T),X=lU(b,a.uf(P),a.Kf(P),X,HG(JG(),X),b.uf(T),b.Kf(T),sa,HG(JG(),sa),c),F.a[-1+(C-Z|0)|0]=X,Z=1+Z|0,P=1+P|0,T=1+T|0,K=K+X.ka()|0,N=N+X.pc()|0):0!==(g&y)&&(X=b.Pg.a[T],F.a[S<<1]=b.uf(T),F.a[1+(S<<1)|0]=b.Kf(T),I.a[S]=X,S=1+S|0,T=1+T|0,K=1+K|0,N=N+HG(JG(),
-X)|0,P=1+P|0);g===e?ka=!0:g<<=1}return d?new JH(D,B,F,I,K,N):b}throw Fu("Cannot concatenate a HashCollisionMapNode with a BitmapIndexedMapNode");}function tU(a){var b=a.Xd.ga(),c=b.a.length,d=a.Bb;for(d=XH(CH(),d)<<1;d<c;)b.a[d]=b.a[d].SP(),d=1+d|0;return new JH(a.Bb,a.kc,b,a.Pg.ga(),a.bd,a.ii)}
-function uU(a,b,c){if(0===a.bd)return a;if(1===a.bd)return!!b.n(a.Ru(0))!==c?a:LH().wy;if(0===a.kc){for(var d=a.Bb,e=0===d?32:31-Math.clz32(d&(-d|0))|0,g=32-Math.clz32(a.Bb)|0,h=d=0,k=0;e<g;){var l=VH(pH(),e);if(0!==(l&a.Bb)){var m=a.Ru(k);!!b.n(m)!==c&&(d|=l,h=h+HG(JG(),a.Jb(k))|0);k=1+k|0}e=1+e|0}if(0===d)return LH().wy;if(d===a.Bb)return a;g=d;g=XH(CH(),g);k=new jd(g<<1);e=new zd(g);l=32-Math.clz32(d)|0;m=d;m=0===m?32:31-Math.clz32(m&(-m|0))|0;for(var n=0;m<l;){var r=VH(pH(),m);0!==(r&d)&&(r=WH(pH(),
-a.Bb,r),k.a[n<<1]=a.Xd.a[r<<1],k.a[1+(n<<1)|0]=a.Xd.a[1+(r<<1)|0],e.a[n]=a.Pg.a[r],n=1+n|0);m=1+m|0}return new JH(d,0,k,e,g,h)}d=a.Bb|a.kc;var u=0===d?32:31-Math.clz32(d&(-d|0))|0,w=32-Math.clz32(d)|0;h=d=0;var y=null;k=g=0;e=null;for(var B=r=n=m=l=0,D=0,C=u;C<w;){var F=VH(pH(),C);if(0!==(F&a.Bb)){var I=a.Ru(B);!!b.n(I)!==c&&(l|=F,d|=F,n=1+n|0,r=r+HG(JG(),a.Jb(B))|0);B=1+B|0}else if(0!==(F&a.kc)){var K=a.gh(D);I=K.YP(b,c);n=n+I.ka()|0;r=r+I.pc()|0;1<I.ka()?(m|=F,K===I?g|=F:(k|=F,null===e&&(e=new vU(16)),
-wU(e,I))):1===I.ka()&&(l|=F,h|=F,null===y&&(y=v(),y=xU(new vU(16),y)),wU(y,I));D=1+D|0}C=1+C|0}if(0===n)return LH().wy;if(n===a.bd)return a;b=l;w=XH(CH(),b);b=m;b=(w<<1)+XH(CH(),b)|0;c=new jd(b);w=new zd(w);B=32-Math.clz32(l|m)|0;for(I=F=C=D=0;u<B;)K=VH(pH(),u),0!==(K&d)?(c.a[F<<1]=a.uf(D),c.a[1+(F<<1)|0]=a.Kf(D),w.a[F]=a.Jb(D),F=1+F|0,D=1+D|0):0!==(K&g)?(c.a[-1+(b-I|0)|0]=a.gh(C),I=1+I|0,C=1+C|0):0!==(K&h)?(K=yU(y),c.a[F<<1]=K.uf(0),c.a[1+(F<<1)|0]=K.Kf(0),w.a[F]=K.Jb(0),F=1+F|0,C=1+C|0):0!==(K&
-k)?(c.a[-1+(b-I|0)|0]=yU(e),I=1+I|0,C=1+C|0):0!==(K&a.Bb)?D=1+D|0:0!==(K&a.kc)&&(C=1+C|0),u=1+u|0;return new JH(l,m,c,w,n,r)}f.YP=function(a,b){return uU(this,a,b)};f.SP=function(){return tU(this)};f.QP=function(a,b){return sU(this,a,b)};f.PQ=function(a,b,c,d){return pU(this,a,b,c,d)};f.mC=function(a,b,c,d,e,g){return kU(this,a,b,c,d,e,g)};f.QA=function(a){return this.gh(a)};f.$classData=q({l6:0},!1,"scala.collection.immutable.BitmapIndexedMapNode",{l6:1,i7:1,NB:1,d:1});
-function zU(a,b,c,d,e,g,h,k,l,m,n,r){if(0===b)return mJ().Lv;if(b===a.Fb)return a;var u=XH(CH(),c),w=u+XH(CH(),d)|0,y=new jd(w);u=new zd(u);for(var B=32-Math.clz32(c|d)|0,D=0,C=0,F=0,I=0;e<B;){var K=VH(pH(),e);0!==(K&g)?(y.a[F]=a.Yc(D),u.a[F]=a.Jb(D),F=1+F|0,D=1+D|0):0!==(K&h)?(y.a[-1+(w-I|0)|0]=a.Dh(C),I=1+I|0,C=1+C|0):0!==(K&k)?(K=yU(l),y.a[F]=K.Yc(0),u.a[F]=K.Jb(0),F=1+F|0,C=1+C|0):0!==(K&m)?(y.a[-1+(w-I|0)|0]=yU(n),I=1+I|0,C=1+C|0):0!==(K&a.bb)?D=1+D|0:0!==(K&a.Pb)&&(C=1+C|0);e=1+e|0}return new lJ(c,
-d,y,u,b,r)}function lJ(a,b,c,d,e,g){this.bb=a;this.Pb=b;this.Nc=c;this.Cd=d;this.Fb=e;this.Ae=g}lJ.prototype=new bR;lJ.prototype.constructor=lJ;f=lJ.prototype;f.ka=function(){return this.Fb};f.pc=function(){return this.Ae};f.Yc=function(a){return this.Nc.a[a]};f.Jb=function(a){return this.Cd.a[a]};f.Dh=function(a){return this.Nc.a[(-1+this.Nc.a.length|0)-a|0]};
-f.Rs=function(a,b,c,d){var e=UH(pH(),c,d),g=VH(pH(),e);return 0!==(this.bb&g)?(c=YH(pH(),this.bb,e,g),this.Cd.a[c]===b&&Ol(Pl(),a,this.Yc(c))):0!==(this.Pb&g)?(e=YH(pH(),this.Pb,e,g),this.Dh(e).Rs(a,b,c,5+d|0)):!1};
-function AU(a,b,c,d,e){var g=UH(pH(),d,e),h=VH(pH(),g);if(0!==(a.bb&h)){g=YH(pH(),a.bb,g,h);var k=a.Yc(g);if(Object.is(k,b))return a;var l=a.Jb(g);g=HG(JG(),l);if(c===l&&Ol(Pl(),k,b))return a;d=BU(a,k,l,g,b,c,d,5+e|0);c=a.di(h);e=(-1+a.Nc.a.length|0)-a.Ul(h)|0;k=a.Nc;b=new jd(k.a.length);k.va(0,b,0,c);k.va(1+c|0,b,c,e-c|0);b.a[e]=d;k.va(1+e|0,b,1+e|0,-1+(k.a.length-e|0)|0);c=QH(a.Cd,c);return new lJ(a.bb^h,a.Pb|h,b,c,(-1+a.Fb|0)+d.ka()|0,(a.Ae-g|0)+d.pc()|0)}if(0!==(a.Pb&h))return g=YH(pH(),a.Pb,
-g,h),g=a.Dh(g),d=g.lC(b,c,d,5+e|0),g===d?a:CU(a,h,g,d);e=a.di(h);k=a.Nc;g=new jd(1+k.a.length|0);k.va(0,g,0,e);g.a[e]=b;k.va(e,g,1+e|0,k.a.length-e|0);b=RH(a.Cd,e,c);return new lJ(a.bb|h,a.Pb,g,b,1+a.Fb|0,a.Ae+d|0)}
-function DU(a,b,c,d,e,g){var h=UH(pH(),d,e),k=VH(pH(),h);if(0!==(a.bb&k)){var l=YH(pH(),a.bb,h,k);h=a.Yc(l);var m=a.Jb(l);if(m===c&&Ol(Pl(),h,b))return g;l=HG(JG(),m);d=BU(a,h,m,l,b,c,d,5+e|0);EU(a,k,l,d);return g|k}if(0!==(a.Pb&k)){h=YH(pH(),a.Pb,h,k);var n=a.Dh(h);h=n.ka();l=n.pc();m=g;n instanceof lJ&&0!==(k&g)?(DU(n,b,c,d,5+e|0,0),g=n):(g=n.lC(b,c,d,5+e|0),g!==n&&(m|=k));a.Nc.a[(-1+a.Nc.a.length|0)-a.Ul(k)|0]=g;a.Fb=(a.Fb-h|0)+g.ka()|0;a.Ae=(a.Ae-l|0)+g.pc()|0;return m}h=a.di(k);l=a.Nc;e=new jd(1+
-l.a.length|0);l.va(0,e,0,h);e.a[h]=b;l.va(h,e,1+h|0,l.a.length-h|0);b=RH(a.Cd,h,c);a.bb|=k;a.Nc=e;a.Cd=b;a.Fb=1+a.Fb|0;a.Ae=a.Ae+d|0;return g}
-function FU(a,b,c,d,e){var g=UH(pH(),d,e),h=VH(pH(),g);if(0!==(a.bb&h)){g=YH(pH(),a.bb,g,h);c=a.Yc(g);if(Ol(Pl(),c,b)){b=a.bb;2===XH(CH(),b)?(b=a.Pb,b=0===XH(CH(),b)):b=!1;if(b)return h=0===e?a.bb^h:VH(pH(),UH(pH(),d,0)),0===g?new lJ(h,0,new jd([a.Yc(1)]),new zd(new Int32Array([a.Cd.a[1]])),-1+a.Fb|0,HG(JG(),a.Cd.a[1])):new lJ(h,0,new jd([a.Yc(0)]),new zd(new Int32Array([a.Cd.a[0]])),-1+a.Fb|0,HG(JG(),a.Cd.a[0]));g=a.di(h);b=a.Nc;e=new jd(-1+b.a.length|0);b.va(0,e,0,g);b.va(1+g|0,e,g,-1+(b.a.length-
-g|0)|0);g=QH(a.Cd,g);return new lJ(a.bb^h,a.Pb,e,g,-1+a.Fb|0,a.Ae-d|0)}return a}if(0!==(a.Pb&h)){g=YH(pH(),a.Pb,g,h);g=a.Dh(g);d=g.JF(b,c,d,5+e|0);if(d===g)return a;e=d.ka();if(1===e){if(a.Fb===g.ka())a=d;else{b=(-1+a.Nc.a.length|0)-a.Ul(h)|0;c=a.di(h);var k=a.Nc;e=new jd(k.a.length);k.va(0,e,0,c);e.a[c]=d.Yc(0);k.va(c,e,1+c|0,b-c|0);k.va(1+b|0,e,1+b|0,-1+(k.a.length-b|0)|0);b=RH(a.Cd,c,d.Jb(0));a=new lJ(a.bb|h,a.Pb^h,e,b,1+(a.Fb-g.ka()|0)|0,(a.Ae-g.pc()|0)+d.pc()|0)}return a}if(1<e)return CU(a,h,
+1,182,1,4,3,62,2,4,12,24,147,70,4,11,48,70,58,116,2188,42711,41,4149,11,222,16354,542,722403,1,30,96,128,240,65040,65534,2,65534])),e=d.a[0],g=1,h=d.a.length;g!==h;)e=e+d.a[g]|0,d.a[g]=e,g=1+g|0;a.sQ=d;a.$j=(2|a.$j)<<24>>24}a=a.sQ;b=kj(Pj(),a,b);return c[0<=b?1+b|0:-1-b|0]}
+function RL(a){0===(32&a.$j)<<24>>24&&0===(32&a.$j)<<24>>24&&(a.vQ=new Xc(new Int32Array([1632,1776,1984,2406,2534,2662,2790,2918,3046,3174,3302,3430,3664,3792,3872,4160,4240,6112,6160,6470,6608,6784,6800,6992,7088,7232,7248,42528,43216,43264,43472,43600,44016,65296,66720,69734,69872,69942,70096,71360,120782,120792,120802,120812,120822])),a.$j=(32|a.$j)<<24>>24);return a.vQ}function SL(){this.vQ=this.tQ=this.sQ=this.uQ=null;this.$j=0}SL.prototype=new p;SL.prototype.constructor=SL;
+function TL(a,b){if(0<=b&&65536>b)return String.fromCharCode(b);if(0<=b&&1114111>=b)return String.fromCharCode(65535&(-64+(b>>10)|55296),65535&(56320|1023&b));throw UL();}function VL(a,b){return 0>b?0:256>b?WL(a).a[b]:ZD(a,b)}
+function DH(a,b,c){if(256>b)a=48<=b&&57>=b?-48+b|0:65<=b&&90>=b?-55+b|0:97<=b&&122>=b?-87+b|0:-1;else if(65313<=b&&65338>=b)a=-65303+b|0;else if(65345<=b&&65370>=b)a=-65335+b|0;else{var d=kj(Pj(),RL(a),b);d=0>d?-2-d|0:d;0>d?a=-1:(a=b-RL(a).a[d]|0,a=9<a?-1:a)}return a<c?a:-1}function us(a,b){return 0<=b&&31>=b||127<=b&&159>=b}
+function bE(a,b){return 256>b?170===b||186===b||2===WL(a).a[b]:688<=b&&696>=b||704<=b&&705>=b||736<=b&&740>=b||837===b||890===b||7468<=b&&7530>=b||7544===b||7579<=b&&7615>=b||8305===b||8319===b||8336<=b&&8348>=b||8560<=b&&8575>=b||9424<=b&&9449>=b||11388<=b&&11389>=b||42864===b||43E3<=b&&43001>=b||2===ZD(a,b)}function TF(a,b){return 8544<=b&&8559>=b||9398<=b&&9423>=b||1===VL(a,b)}function Or(a,b){a=VL(a,b);return 1===a||2===a||3===a||4===a||5===a}
+function hda(a){switch(a){case 8115:case 8131:case 8179:return 9+a|0;default:if(8064<=a&&8111>=a)return 8|a;var b=TL(0,a).toUpperCase();switch(b.length){case 1:return b.charCodeAt(0);case 2:var c=b.charCodeAt(0);b=b.charCodeAt(1);return-671032320===(-67044352&(c<<16|b))?(64+(1023&c)|0)<<10|1023&b:a;default:return a}}}
+function bda(a){if(304===a)return 105;var b=TL(0,a).toLowerCase();switch(b.length){case 1:return b.charCodeAt(0);case 2:var c=b.charCodeAt(0);b=b.charCodeAt(1);return-671032320===(-67044352&(c<<16|b))?(64+(1023&c)|0)<<10|1023&b:a;default:return a}}
+function WL(a){0===(1&a.$j)<<24>>24&&0===(1&a.$j)<<24>>24&&(a.uQ=new Xc(new Int32Array([15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,12,24,24,24,26,24,24,24,21,22,24,25,24,20,24,24,9,9,9,9,9,9,9,9,9,9,24,24,25,25,25,24,24,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,21,24,22,27,23,27,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,21,25,22,25,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
+15,12,24,26,26,26,26,28,24,27,28,5,29,25,16,28,27,28,25,11,11,27,2,24,24,27,11,5,30,11,11,11,24,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,25,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,25,2,2,2,2,2,2,2,2])),a.$j=(1|a.$j)<<24>>24);return a.uQ}SL.prototype.$classData=q({V0:0},!1,"java.lang.Character$",{V0:1,g:1,l:1});var XL;function Pr(){XL||(XL=new SL);return XL}function YL(a){throw new ZL('For input string: "'+a+'"');}function $L(){this.wQ=this.xQ=null;this.Ct=0}
+$L.prototype=new p;$L.prototype.constructor=$L;
+function aM(a,b){0===(1&a.Ct)<<24>>24&&0===(1&a.Ct)<<24>>24&&(a.xQ=RegExp("^[\\x00-\\x20]*([+-]?(?:NaN|Infinity|(?:\\d+\\.?\\d*|\\.\\d+)(?:[eE][+-]?\\d+)?)[fFdD]?)[\\x00-\\x20]*$"),a.Ct=(1|a.Ct)<<24>>24);var c=a.xQ.exec(b);if(null!==c)b=+parseFloat(c[1]);else{0===(2&a.Ct)<<24>>24&&0===(2&a.Ct)<<24>>24&&(a.wQ=RegExp("^[\\x00-\\x20]*([+-]?)0[xX]([0-9A-Fa-f]*)\\.?([0-9A-Fa-f]*)[pP]([+-]?\\d+)[fFdD]?[\\x00-\\x20]*$"),a.Ct=(2|a.Ct)<<24>>24);var d=a.wQ.exec(b);null===d&&YL(b);a=d[1];c=d[2];var e=d[3];d=
+d[4];""===c&&""===e&&YL(b);b=bM(0,c,e,d,15);b="-"===a?-b:b}return b}
+function bM(a,b,c,d,e){a=""+b+c;c=-(c.length<<2)|0;for(b=0;;)if(b!==a.length&&48===a.charCodeAt(b))b=1+b|0;else break;a=a.substring(b);if(""===a)return 0;var g=a.length;if(b=g>e){for(var h=!1,k=e;!h&&k!==g;)48!==a.charCodeAt(k)&&(h=!0),k=1+k|0;g=h?"1":"0";g=a.substring(0,e)+g}else g=a;c=c+(b?(a.length-(1+e|0)|0)<<2:0)|0;e=+parseInt(g,16);d=+parseInt(d,10);c=Eb(d)+c|0;a=c/3|0;d=+Math.pow(2,a);c=+Math.pow(2,c-(a<<1)|0);return e*d*d*c}
+function maa(a,b,c){return b!==b?c!==c?0:1:c!==c?-1:b===c?0===b?(a=1/b,a===1/c?0:0>a?-1:1):0:b<c?-1:1}$L.prototype.$classData=q({Y0:0},!1,"java.lang.Double$",{Y0:1,g:1,l:1});var cM;function qa(){cM||(cM=new $L);return cM}
+function dM(a,b,c,d,e,g){a=eM(""+a+b);b=TH(UH(),c,10)-b.length|0;var h=lg(mg(),g);c=h.W;var k=h.Y;h=k>>20;if(0===h)throw new Yj("parseFloatCorrection was given a subnormal mid: "+g);g=1048575&k;g=ri(Ph(),new ma(c,1048576|g));c=-1075+h|0;0<=b?0<=c?(a=Ki(a,Qi(Ph().mq,b)),b=Oi(g,c),a=fM(a,b)):a=fM(Oi(Ki(a,Qi(Ph().mq,b)),-c|0),g):0<=c?(b=-b|0,b=Oi(Ki(g,Qi(Ph().mq,b)),c),a=fM(a,b)):(a=Oi(a,-c|0),b=-b|0,b=Ki(g,Qi(Ph().mq,b)),a=fM(a,b));return 0>a?d:0<a?e:0===(1&kg(mg(),d))?d:e}
+function gM(){this.zQ=null;this.aK=!1}gM.prototype=new p;gM.prototype.constructor=gM;
+function hM(a,b){a.aK||a.aK||(a.zQ=RegExp("^[\\x00-\\x20]*([+-]?)(?:(NaN)|(Infinity)|(?:((?:(\\d+)(?:\\.(\\d*))?|\\.(\\d+))(?:[eE]([+-]?\\d+))?)|(0[xX](?:([0-9A-Fa-f]+)(?:\\.([0-9A-Fa-f]*))?|\\.([0-9A-Fa-f]+))[pP]([+-]?\\d+)))[fFdD]?)[\\x00-\\x20]*$"),a.aK=!0);a=a.zQ.exec(b);if(null===a)throw new ZL('For input string: "'+b+'"');if(void 0!==a[2])b=NaN;else if(void 0!==a[3])b=Infinity;else if(void 0!==a[4]){b=a[5];var c=a[6],d=a[7],e=a[8];b=void 0!==b?b:"";c=""+(void 0!==c?c:"")+(void 0!==d?d:"");e=
+void 0!==e?e:"0";d=+parseFloat(a[4]);var g=Math.fround(d);if(g===d)b=g;else if(Infinity===g)b=3.4028235677973366E38===d?dM(b,c,e,3.4028234663852886E38,g,3.4028235677973366E38):g;else if(g<d){rg||(rg=new qg);if(g!==g||Infinity===g)var h=g;else-0===g?h=1.401298464324817E-45:(h=kg(mg(),g),h=0<g?1+h|0:-1+h|0,h=jg(mg(),h));var k=(g+h)/2;b=d===k?dM(b,c,e,g,h,k):g}else rg||(rg=new qg),g!==g||-Infinity===g?h=g:0===g?h=-1.401298464324817E-45:(h=kg(mg(),g),h=0<g?-1+h|0:1+h|0,h=jg(mg(),h)),k=(g+h)/2,b=d===k?
+dM(b,c,e,h,g,k):g}else b=a[10],c=a[11],e=a[12],b=void 0!==b?b:"",c=""+(void 0!==c?c:"")+(void 0!==e?e:""),e=a[13],b=bM(qa(),b,c,e,7),b=Math.fround(b);return"-"===a[1]?Math.fround(-b):b}gM.prototype.$classData=q({$0:0},!1,"java.lang.Float$",{$0:1,g:1,l:1});var iM;function jM(){iM||(iM=new gM);return iM}function kM(a){throw new ZL('For input string: "'+a+'"');}function lM(){}lM.prototype=new p;lM.prototype.constructor=lM;
+function TH(a,b,c){a=null===b?0:b.length;(0===a||2>c||36<c)&&kM(b);var d=b.charCodeAt(0),e=45===d,g=e?2147483648:2147483647;d=e||43===d?1:0;d>=b.length&&kM(b);for(var h=0;d!==a;){var k=DH(Pr(),b.charCodeAt(d),c);h=h*c+k;(-1===k||h>g)&&kM(b);d=1+d|0}return e?-h|0:h|0}function nI(a,b){a=b-(1431655765&b>>1)|0;a=(858993459&a)+(858993459&a>>2)|0;return Math.imul(16843009,252645135&(a+(a>>4)|0))>>24}lM.prototype.$classData=q({c1:0},!1,"java.lang.Integer$",{c1:1,g:1,l:1});var mM;
+function UH(){mM||(mM=new lM);return mM}function nM(a){if(!a.RF){for(var b=[],c=0;2>c;)b.push(null),c=1+c|0;for(;36>=c;){for(var d=pb(2147483647,c),e=c,g=1,h="0";e<=d;)e=Math.imul(e,c),g=1+g|0,h+="0";d=e;e=d>>31;var k=xa(),l=Wh(k,-1,-1,d,e);b.push(new pg(g,new ma(d,e),h,new ma(l,k.Qc)));c=1+c|0}a.QF=b;a.RF=!0}return a.QF}
+function oM(a,b,c){var d=(a.RF?a.QF:nM(a))[c],e=d.DQ;a=e.W;e=e.Y;d=d.l1;var g=-2147483648^e,h="",k=b.W;for(b=b.Y;;){var l=k,m=-2147483648^b;if(m===g?(-2147483648^l)>=(-2147483648^a):m>g){l=k;m=xa();b=Wh(m,l,b,a,e);l=m.Qc;var n=65535&b;m=b>>>16|0;var r=65535&a,v=a>>>16|0,x=Math.imul(n,r);r=Math.imul(m,r);n=Math.imul(n,v);x=x+((r+n|0)<<16)|0;Math.imul(b,e);Math.imul(l,a);Math.imul(m,v);k=(k-x|0).toString(c);h=""+d.substring(k.length)+k+h;k=b;b=l}else break}return""+k.toString(c)+h}
+function pM(a){throw new ZL('For input string: "'+a+'"');}function qM(a,b,c){for(var d=0;a!==b;){var e=DH(Pr(),c.charCodeAt(a),10);-1===e&&pM(c);d=Math.imul(d,10)+e|0;a=1+a|0}return d}function rM(){this.QF=null;this.RF=!1}rM.prototype=new p;rM.prototype.constructor=rM;function sM(a,b,c){return 0!==c?(a=(+(c>>>0)).toString(16),b=(+(b>>>0)).toString(16),a+(""+"00000000".substring(b.length)+b)):(+(b>>>0)).toString(16)}rM.prototype.$classData=q({h1:0},!1,"java.lang.Long$",{h1:1,g:1,l:1});var tM;
+function uM(){tM||(tM=new rM);return tM}function vM(){}vM.prototype=new p;vM.prototype.constructor=vM;function wM(){}wM.prototype=vM.prototype;function PK(a){return a instanceof vM||"number"===typeof a||a instanceof ma}function xM(a,b,c,d,e){this.sB=a;this.SF=b;this.tB=c;this.uB=d;this.rB=e}xM.prototype=new p;xM.prototype.constructor=xM;xM.prototype.i=function(a){return a instanceof xM?this.tB===a.tB&&this.uB===a.uB&&this.rB===a.rB&&this.sB===a.sB&&this.SF===a.SF:!1};
+xM.prototype.u=function(){var a="";"\x3cjscode\x3e"!==this.sB&&(a=""+a+this.sB+".");a=""+a+this.SF;null===this.tB?a+="(Unknown Source)":(a=a+"("+this.tB,0<=this.uB&&(a=a+":"+this.uB,0<=this.rB&&(a=a+":"+this.rB)),a+=")");return a};xM.prototype.B=function(){return lb(this.sB)^lb(this.SF)^lb(this.tB)^this.uB^this.rB};var yM=q({t1:0},!1,"java.lang.StackTraceElement",{t1:1,g:1,l:1});xM.prototype.$classData=yM;function zM(){}zM.prototype=new p;zM.prototype.constructor=zM;
+function AM(a,b,c,d){a=c+d|0;if(0>c||a<c||a>b.a.length)throw b=new tH,yF(b,null,null,!0),b;for(d="";c!==a;)d=""+d+String.fromCharCode(b.a[c]),c=1+c|0;return d}
+function jda(a,b){var c=new BM,d=CM();c.wv=null;c.T1=d;c.Gt="";c.gK=!1;if(c.gK)throw new DM;for(var e=0,g=0,h=6,k=0;k!==h;){var l="\\u%04X".indexOf("%",k)|0;if(0>l){EM(c,"\\u%04X".substring(k));break}EM(c,"\\u%04X".substring(k,l));var m=1+l|0,n=Tj().QQ;n.lastIndex=m;var r=n.exec("\\u%04X");if(null===r||(r.index|0)!==m){var v=m===h?37:"\\u%04X".charCodeAt(m);FM(v)}k=n.lastIndex|0;for(var x="\\u%04X".charCodeAt(-1+k|0),A,B=r[2],C=65<=x&&90>=x?256:0,D=B.length,F=0;F!==D;){var I=B.charCodeAt(F);switch(I){case 45:var M=
+1;break;case 35:M=2;break;case 43:M=4;break;case 32:M=8;break;case 48:M=16;break;case 44:M=32;break;case 40:M=64;break;case 60:M=128;break;default:throw new Yj(hc(I));}if(0!==(C&M))throw new GM(String.fromCharCode(I));C|=M;F=1+F|0}A=C;var N=HM(r[3]),P=HM(r[4]);if(-2===N)throw new IM(-2147483648);-2===P&&JM(-2147483648);if(110===x){-1!==P&&JM(P);if(-1!==N)throw new IM(N);0!==A&&KM(A);EM(c,"\n")}else if(37===x){-1!==P&&JM(P);17!==(17&A)&&12!==(12&A)||KM(A);if(0!==(1&A)&&-1===N)throw new LM("%"+r[0]);
+0!==(-2&A)&&MM(37,A,-2);NM(c,A,N,"%")}else{var T=0!==(256&A)?65535&(32+x|0):x,Y=Tj().PQ.a[-97+T|0];-1!==Y&&0===(256&A&Y)||FM(x);if(0!==(17&A)&&-1===N)throw new LM("%"+r[0]);17!==(17&A)&&12!==(12&A)||KM(A);-1!==P&&0!==(512&Y)&&JM(P);0!==(A&Y)&&MM(T,A,Y);if(0!==(128&A))var Z=g;else{var S=HM(r[1]);if(-1===S)Z=e=1+e|0;else{if(0>=S)throw new OM(0===S?"Illegal format argument index \x3d 0":"Format argument index: (not representable as int)");Z=S}}if(0>=Z||Z>b.a.length)throw new PM("%"+r[0]);g=Z;var ea=
+b.a[-1+Z|0];if(null===ea&&98!==T&&115!==T)QM(c,CM(),A,N,P,"null");else{var ia=void 0,X=void 0,sa=void 0,Ja=void 0,Xa=void 0,Fa=c,za=ea,Qa=T,Ma=A,Ga=N,ab=P;switch(Qa){case 98:var Hb=!1===za||null===za?"false":"true";QM(Fa,CM(),Ma,Ga,ab,Hb);break;case 104:var bc=(+(ib(za)>>>0)).toString(16);QM(Fa,CM(),Ma,Ga,ab,bc);break;case 115:za&&za.$classData&&za.$classData.rb.Zaa?za.Xaa(Fa,(0!==(1&Ma)?1:0)|(0!==(2&Ma)?4:0)|(0!==(256&Ma)?2:0),Ga,ab):(0!==(2&Ma)&&MM(Qa,Ma,2),QM(Fa,0,Ma,Ga,ab,""+za));break;case 99:if(za instanceof
+ba)var yb=String.fromCharCode(Ea(za));else{ha(za)||RM(Qa,za);var tb=za|0;if(!(0<=tb&&1114111>=tb))throw new SM(tb);yb=65536>tb?String.fromCharCode(tb):String.fromCharCode(-64+(tb>>10)|55296,56320|1023&tb)}QM(Fa,0,Ma,Ga,-1,yb);break;case 100:if(ha(za))var eb=""+(za|0);else if(za instanceof ma){var kb=Za(za),Rb=kb.W,Gb=kb.Y;eb=bG(xa(),Rb,Gb)}else za instanceof TM||RM(Qa,za),eb=Vh(bi(),za);UM(Fa,Ma,Ga,eb,"");break;case 111:case 120:var vb=111===Qa,Tb=0===(2&Ma)?"":vb?"0":0!==(256&Ma)?"0X":"0x";if(za instanceof
+TM){var Nb=vb?8:16;CM();var ic=bi(),Va=za.Ya,cb=za.wb,zb=za.Qa,Ub=2>Nb||36<Nb;if(0===Va)Xa="0";else if(1===cb){var jb=zb.a[-1+cb|0],db=0;if(0>Va){var ub=jb,Aa=db;jb=-ub|0;db=0!==ub?~Aa:-Aa|0}var va=uM(),Ra=jb,rb=db;if(10===Nb||2>Nb||36<Nb)Ja=bG(xa(),Ra,rb);else{var xb=new ma(Ra,rb),mc=xb.W,Ha=xb.Y;if(mc>>31===Ha)Ja=mc.toString(Nb);else if(0>Ha){var Ka=xb.W,Oa=xb.Y;Ja="-"+oM(va,new ma(-Ka|0,0!==Ka?~Oa:-Oa|0),Nb)}else Ja=oM(va,xb,Nb)}Xa=Ja}else if(10===Nb||Ub)Xa=Vh(bi(),za);else{var Na=0;Na=+Math.log(Nb)/
++Math.log(2);var Da=0>Va?1:0,ta=VM(za),Ya=yh(Sh(),ta),dc=1+Eb(Ya/Na+Da)|0,ka=null;ka="";var ya=0;ya=dc;var Sa=0;Sa=0;if(16!==Nb){var xc=new Xc(cb);zb.wa(0,xc,0,cb);var Sb=0;Sb=cb;for(var uc=ic.uH.a[Nb],Lb=ic.tH.a[-2+Nb|0];;){Sa=gi(ei(),xc,xc,Sb,Lb);for(var lc=ya;;){ya=-1+ya|0;Pr();var Xb=Bb(Sa,Nb);if(2>Nb||36<Nb||0>Xb||Xb>=Nb)var ec=0;else{var Ab=-10+Xb|0;ec=65535&(0>Ab?48+Xb|0:97+Ab|0)}ka=""+String.fromCharCode(ec)+ka;Sa=pb(Sa,Nb);if(0===Sa||0===ya)break}for(var Ob=(uc-lc|0)+ya|0,fb=0;fb<Ob&&0<ya;)ya=
+-1+ya|0,ka="0"+ka,fb=1+fb|0;for(fb=-1+Sb|0;0<fb&&0===xc.a[fb];)fb=-1+fb|0;Sb=1+fb|0;if(1===Sb&&0===xc.a[0])break}}else for(var Wa=0;Wa<cb;){for(var bb=Wa,Ia=0;8>Ia&&0<ya;)Sa=15&zb.a[bb]>>(Ia<<2),ya=-1+ya|0,ka=""+(+(Sa>>>0)).toString(16)+ka,Ia=1+Ia|0;Wa=1+Wa|0}for(var Ua=0;;)if(48===ka.charCodeAt(Ua))Ua=1+Ua|0;else break;0!==Ua&&(ka=ka.substring(Ua));Xa=-1===Va?"-"+ka:ka}UM(Fa,Ma,Ga,Xa,Tb)}else{if(ha(za))var pc=za|0,sc=vb?(+(pc>>>0)).toString(8):(+(pc>>>0)).toString(16);else{za instanceof ma||RM(Qa,
+za);var Ba=Za(za),ob=Ba.W,nc=Ba.Y;if(vb){uM();var Ib=1073741823&ob,vc=1073741823&((ob>>>30|0)+(nc<<2)|0),Vb=nc>>>28|0;if(0!==Vb){var fc=(+(Vb>>>0)).toString(8),Bc=(+(vc>>>0)).toString(8),Pb="0000000000".substring(Bc.length),Jb=(+(Ib>>>0)).toString(8);sa=fc+(""+Pb+Bc)+(""+"0000000000".substring(Jb.length)+Jb)}else if(0!==vc){var gc=(+(vc>>>0)).toString(8),Cb=(+(Ib>>>0)).toString(8);sa=gc+(""+"0000000000".substring(Cb.length)+Cb)}else sa=(+(Ib>>>0)).toString(8)}else sa=sM(uM(),ob,nc);sc=sa}0!==(76&
+Ma)&&MM(Qa,Ma,76);WM(Fa,CM(),Ma,Ga,Tb,XM(Ma,sc))}break;case 101:case 102:case 103:if("number"===typeof za){var cc=+za;if(cc!==cc||Infinity===cc||-Infinity===cc)YM(Fa,Ma,Ga,cc);else{Tj();if(0===cc)X=new Vj(0>1/cc,"0",0);else{var yc=0>cc,Mc=""+(yc?-cc:cc),qc=vH(Mc,101),oc=0>qc?0:parseInt(Mc.substring(1+qc|0))|0,Qc=0>qc?Mc.length:qc,jc=vH(Mc,46);if(0>jc){var sb=Mc.substring(0,Qc);X=new Vj(yc,sb,-oc|0)}else{for(var Gc=""+Mc.substring(0,jc)+Mc.substring(1+jc|0,Qc),Wb=Gc.length,Cc=0;;)if(Cc<Wb&&48===Gc.charCodeAt(Cc))Cc=
+1+Cc|0;else break;var Fc=Gc.substring(Cc);X=new Vj(yc,Fc,(-oc|0)+(Qc-(1+jc|0)|0)|0)}}ZM(Fa,X,Ma,ab,Qa,Ga)}}else if(za instanceof mr){Tj();var qd=$M(za),Yb=Vh(bi(),qd);if("0"===Yb)ia=new Vj(!1,"0",0);else{var Nc=45===Yb.charCodeAt(0),ad=Nc?Yb.substring(1):Yb;ia=new Vj(Nc,ad,za.xb)}ZM(Fa,ia,Ma,ab,Qa,Ga)}else RM(Qa,za);break;case 97:if("number"===typeof za){var Uc=+za;if(Uc!==Uc||Infinity===Uc||-Infinity===Uc)YM(Fa,Ma,Ga,Uc);else{var cd=lg(mg(),Uc),kc=cd.W,Vc=cd.Y,Hc=1048575&Vc,rc=2047&(Vc>>>20|0),sd=
+0===ab?1:12<ab?-1:ab,Kc=0>Vc?"-":0!==(4&Ma)?"+":0!==(8&Ma)?" ":"";if(0===rc)if(0===kc&&0===Hc)var Qd="0",Ad=aa,kd=0;else if(-1===sd)Qd="0",Ad=new ma(kc,Hc),kd=-1022;else{var Hd=-11+(0!==Hc?Math.clz32(Hc):32+Math.clz32(kc)|0)|0;Qd="1";Ad=new ma(0===(32&Hd)?kc<<Hd:0,1048575&(0===(32&Hd)?(kc>>>1|0)>>>(31-Hd|0)|0|Hc<<Hd:kc<<Hd));kd=-1022-Hd|0}else Qd="1",Ad=new ma(kc,Hc),kd=-1023+rc|0;var Rd=Qd,Bd=Za(Ad),ae=kd|0,dd=Za(new ma(Bd.W,Bd.Y)),od=dd.W,Ta=dd.Y;if(-1===sd)var wb=od,$a=Ta;else{var wa=52-(sd<<2)|
+0,hb=0===(32&wa)?1<<wa:0,ra=0===(32&wa)?0:1<<wa,wc=-1+hb|0,ac=-1!==wc?ra:-1+ra|0,Id=hb>>>1|0|ra<<31,ud=ra>>1,be=od&~wc,re=Ta&~ac,pe=od&wc,bd=Ta&ac;if(bd===ud?(-2147483648^pe)<(-2147483648^Id):bd<ud)wb=be,$a=re;else if(bd===ud?(-2147483648^pe)>(-2147483648^Id):bd>ud){var Rc=be+hb|0;wb=Rc;$a=(-2147483648^Rc)<(-2147483648^be)?1+(re+ra|0)|0:re+ra|0}else if(0===(be&hb)&&0===(re&ra))wb=be,$a=re;else{var Wc=be+hb|0;wb=Wc;$a=(-2147483648^Wc)<(-2147483648^be)?1+(re+ra|0)|0:re+ra|0}}var Wd=sM(uM(),wb,$a),zd=
+""+"0000000000000".substring(Wd.length)+Wd;Tj();if(13!==zd.length)throw new Yj("padded mantissa does not have the right number of bits");for(var Pa=1>sd?1:sd,Db=zd.length;;)if(Db>Pa&&48===zd.charCodeAt(-1+Db|0))Db=-1+Db|0;else break;var Oc=zd.substring(0,Db),Tc=Kc+(0!==(256&Ma)?"0X":"0x"),Sd=Rd+"."+Oc+"p"+ae;WM(Fa,CM(),Ma,Ga,Tc,XM(Ma,Sd))}}else RM(Qa,za);break;default:throw new Yj("Unknown conversion '"+hc(Qa)+"' was not rejected earlier");}}}}return c.u()}
+zM.prototype.$classData=q({u1:0},!1,"java.lang.String$",{u1:1,g:1,l:1});var aN;function zH(){aN||(aN=new zM);return aN}
+function Sda(a,b){bN(a);b(a.u());if(0!==a.my.a.length)for(var c=0;c<a.my.a.length;)b("  at "+a.my.a[c]),c=1+c|0;else b("  \x3cno stack trace available\x3e");for(;;)if(a!==a.TF&&null!==a.TF){var d=bN(a);a=a.TF;c=bN(a);var e=c.a.length,g=d.a.length;b("Caused by: "+a);if(0!==e){for(var h=0;;){if(h<e&&h<g){var k=c.a[-1+(e-h|0)|0],l=d.a[-1+(g-h|0)|0];k=null===k?null===l:k.i(l)}else k=!1;if(k)h=1+h|0;else break}0<h&&(h=-1+h|0);d=e-h|0;for(e=0;e<d;)b("  at "+c.a[e]),e=1+e|0;0<h&&b("  ... "+h+" more")}else b("  \x3cno stack trace available\x3e")}else break}
+function yF(a,b,c,d){a.LQ=b;a.TF=c;(a.MQ=d)&&a.pQ()}function vaa(a){var b=ch().HQ;Sda(a,c=>{ff(b,null===c?"null":c);ff(b,"\n")})}
+function bN(a){if(null===a.my){if(a.MQ){Ug||(Ug=new Tg);var b=Ug;var c=a.KQ;if(c)if(c.arguments&&c.stack)var d=Fg(c);else if(c.stack&&c.sourceURL)d=c.stack.replace(Rg("\\[native code\\]\\n","m"),"").replace(Rg("^(?\x3d\\w+Error\\:).*$\\n","m"),"").replace(Rg("^@","gm"),"{anonymous}()@").split("\n");else if(c.stack&&c.number)d=c.stack.replace(Rg("^\\s*at\\s+(.*)$","gm"),"$1").replace(Rg("^Anonymous function\\s+","gm"),"{anonymous}() ").replace(Rg("^([^\\(]+|\\{anonymous\\}\\(\\))\\s+\\((.+)\\)$","gm"),
+"$1@$2").split("\n").slice(1);else if(c.stack&&c.fileName)d=c.stack.replace(Rg("(?:\\n@:0)?\\s+$","m"),"").replace(Rg("^(?:\\((\\S*)\\))?@","gm"),"{anonymous}($1)@").split("\n");else if(c.message&&c["opera#sourceloc"])if(c.stacktrace)if(-1<c.message.indexOf("\n")&&c.message.split("\n").length>c.stacktrace.split("\n").length)d=Sg(c);else{d=Rg("Line (\\d+).*script (?:in )?(\\S+)(?:: In function (\\S+))?$","i");c=c.stacktrace.split("\n");var e=[];for(var g=0,h=c.length|0;g<h;){var k=d.exec(c[g]);if(null!==
+k){var l=k[3];e.push((void 0!==l?l:"{anonymous}")+"()@"+k[2]+":"+k[1])}g=2+g|0}d=e}else d=Sg(c);else if(c.message&&c.stack&&c.stacktrace)if(0>c.stacktrace.indexOf("called from line")){d=Gg("^(.*)@(.+):(\\d+)$");c=c.stacktrace.split("\n");e=[];g=0;for(h=c.length|0;g<h;)k=d.exec(c[g]),null!==k&&(l=k[1],e.push((void 0!==l?l+"()":"global code")+"@"+k[2]+":"+k[3])),g=1+g|0;d=e}else{d=Gg("^.*line (\\d+), column (\\d+)(?: in (.+))? in (\\S+):$");c=c.stacktrace.split("\n");e=[];g=0;for(h=c.length|0;g<h;)l=
+d.exec(c[g]),null!==l&&(k=l[4]+":"+l[1]+":"+l[2],l=l[2],l=(void 0!==l?l:"global code").replace(Gg("\x3canonymous function: (\\S+)\x3e"),"$1").replace(Gg("\x3canonymous function\x3e"),"{anonymous}"),e.push(l+"@"+k)|0),g=2+g|0;d=e}else d=c.stack&&!c.fileName?Fg(c):[];else d=[];e=d;g=Gg("^([^@]*)@(.*?):([0-9]+)(?::([0-9]+))?$");d=[];for(c=0;c<(e.length|0);){k=e[c];if(""!==k)if(h=g.exec(k),null!==h){k=b;l=h[1];var m=Gg("^(?:Object\\.|\\[object Object\\]\\.|Module\\.)?\\$(?:ps?|s|f)_((?:_[^_]|[^_])+)__([^\\.]+)$"),
+n=Gg("^(?:Object\\.|\\[object Object\\]\\.|Module\\.)?\\$ct_((?:_[^_]|[^_])+)__([^\\.]*)$"),r=Gg("^new (?:Object\\.|\\[object Object\\]\\.|Module\\.)?\\$c_([^\\.]+)$"),v=Gg("^(?:Object\\.|\\[object Object\\]\\.|Module\\.)?\\$m_([^\\.]+)$"),x=Gg("^(?:Object\\.|\\[object Object\\]\\.|Module\\.)?\\$[bc]_([^\\.]+)(?:\\.prototype)?\\.([^\\.]+)$").exec(l);m=null!==x?x:m.exec(l);null!==m?(k=sg(k,m[1]),l=m[2],0<=l.length&&"init___"===l.substring(0,7)?l="\x3cinit\x3e":(v=l.indexOf("__")|0,l=0>v?l:l.substring(0,
+v)),l=[k,l]):(n=n.exec(l),r=null!==n?n:r.exec(l),null!==r?l=[sg(k,r[1]),"\x3cinit\x3e"]:(v=v.exec(l),l=null!==v?[sg(k,v[1]),"\x3cclinit\x3e"]:["\x3cjscode\x3e",l]));k=l[0];l=l[1];v=h[2];r=parseInt(h[3]);h=h[4];h=void 0!==h?parseInt(h)|0:-1;d.push(new xM(k,l,v,r|0,h))}else d.push(new xM("\x3cjscode\x3e",k,null,-1,-1))|0;c=1+c|0}b=d.length|0;e=new (md(yM).Ia)(b);for(c=0;c<b;)e.a[c]=d[c],c=1+c|0;b=e}else b=new (md(yM).Ia)(0);a.my=b}return a.my}
+class Vd extends Error{constructor(){super();this.TF=this.LQ=null;this.MQ=!1;this.my=this.KQ=null}qj(){return this.LQ}pQ(){var a=this instanceof $d?this.mu:this;this.KQ="[object Error]"===Object.prototype.toString.call(a)?a:void 0===Error.captureStackTrace?Error():(Error.captureStackTrace(this),this)}u(){var a=na(this),b=this.qj();return null===b?a:a+": "+b}B(){return gb.prototype.B.call(this)}i(a){return gb.prototype.i.call(this,a)}get message(){var a=this.qj();return null===a?"":a}get name(){return na(this)}toString(){return this.u()}}
+function cN(){this.mM=this.qH=this.lM=this.lz=this.rH=null;dN=this;eN(0,0);eN(1,0);eN(10,0);this.rH=fN(28,5);for(var a=this.rH.a.length,b=new Xc(a),c=0;c<a;){var d=c;b.a[d]=gN(hN(),hN().rH.a[d]);c=1+c|0}this.lz=fN(19,10);a=this.lz.a.length;b=new Xc(a);for(c=0;c<a;)d=c,b.a[d]=gN(hN(),hN().lz.a[d]),c=1+c|0;a=new (md(iN).Ia)(11);for(b=0;11>b;)c=b,a.a[c]=eN(c,0),b=1+b|0;this.lM=a;a=new (md(iN).Ia)(11);for(b=0;11>b;)c=b,a.a[c]=eN(0,c),b=1+b|0;this.qH=a;this.mM="0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"}
+cN.prototype=new p;cN.prototype.constructor=cN;function jN(a,b,c){0===c?(0<=b.Y?(c=b.Y,c=0===c?-2147483637>(-2147483648^b.W):0>c):c=!1,a=c?a.lM.a[b.W]:kN(b,0)):a=0===b.W&&0===b.Y&&0<=c&&c<a.qH.a.length?a.qH.a[c]:kN(b,c);return a}
+function fN(a,b){var c=new Zc(a);c.a[0]=new ma(1,0);for(var d=1;d<a;){var e=d,g=c.a[-1+e|0],h=b>>31,k=g.W,l=65535&k,m=k>>>16|0,n=65535&b,r=b>>>16|0,v=Math.imul(l,n);n=Math.imul(m,n);var x=Math.imul(l,r);l=v+((n+x|0)<<16)|0;v=(v>>>16|0)+x|0;g=(((Math.imul(k,h)+Math.imul(g.Y,b)|0)+Math.imul(m,r)|0)+(v>>>16|0)|0)+(((65535&v)+n|0)>>>16|0)|0;c.a[e]=new ma(l,g);d=1+d|0}return c}
+function lN(a,b,c,d){a=0>c?-c|0:c;var e=0===c?0:0>c?-1:1;if(Bi().xM===d)return e;if(Bi().sM===d)return 0;if(Bi().rM===d)return 0<e?e:0;if(Bi().tM===d)return 0>e?e:0;if(Bi().vM===d)return 5<=a?e:0;if(Bi().uM===d)return 5<a?e:0;if(Bi().OC===d)return 5<(a+b|0)?e:0;if(Bi().wM===d){if(0===c)return 0;throw new qb("Rounding necessary");}throw new Yj(d);}
+function mN(a,b){a=b.Y;(-1===a?0>(-2147483648^b.W):-1>a)?a=!0:(a=b.Y,a=0===a?-1<(-2147483648^b.W):0<a);if(a)throw new qb("Out of int range: "+b);return b.W}function gN(a,b){b=0>b.Y?new ma(~b.W,~b.Y):b;a=b.W;b=b.Y;return 64-(0!==b?Math.clz32(b):32+Math.clz32(a)|0)|0}function nN(a,b,c){return!oN(0,b,c)}function oN(a,b,c){a=c.a.length;for(var d=0;d!==a;){if(c.a[d]===b)return!0;d=1+d|0}return!1}cN.prototype.$classData=q({BT:0},!1,"java.math.BigDecimal$",{BT:1,g:1,l:1});var dN;
+function hN(){dN||(dN=new cN);return dN}function pN(){this.sH=this.pM=this.MC=this.nq=this.mq=this.Ew=null;qN=this;this.Ew=qi(1,1);this.mq=qi(1,10);this.nq=qi(0,0);this.MC=qi(-1,1);this.pM=new (md(Ji).Ia)([this.nq,this.Ew,qi(1,2),qi(1,3),qi(1,4),qi(1,5),qi(1,6),qi(1,7),qi(1,8),qi(1,9),this.mq]);for(var a=new (md(Ji).Ia)(32),b=0;32>b;){var c=b,d=Ph();a.a[c]=ri(d,new ma(0===(32&c)?1<<c:0,0===(32&c)?0:1<<c));b=1+b|0}this.sH=a}pN.prototype=new p;pN.prototype.constructor=pN;
+function ri(a,b){if(0>b.Y)return-1!==b.W||-1!==b.Y?(a=b.W,b=b.Y,rN(-1,new ma(-a|0,0!==a?~b:-b|0))):a.MC;var c=b.Y;return(0===c?-2147483638>=(-2147483648^b.W):0>c)?a.pM.a[b.W]:rN(1,b)}pN.prototype.$classData=q({DT:0},!1,"java.math.BigInteger$",{DT:1,g:1,l:1});var qN;function Ph(){qN||(qN=new pN);return qN}
+function sN(){this.wM=this.OC=this.uM=this.vM=this.tM=this.rM=this.sM=this.xM=null;tN=this;this.xM=new uN("UP",0);this.sM=new uN("DOWN",1);this.rM=new uN("CEILING",2);this.tM=new uN("FLOOR",3);this.vM=new uN("HALF_UP",4);this.uM=new uN("HALF_DOWN",5);this.OC=new uN("HALF_EVEN",6);this.wM=new uN("UNNECESSARY",7)}sN.prototype=new p;sN.prototype.constructor=sN;sN.prototype.$classData=q({NT:0},!1,"java.math.RoundingMode$",{NT:1,g:1,l:1});var tN;function Bi(){tN||(tN=new sN);return tN}function vN(){}
+vN.prototype=new p;vN.prototype.constructor=vN;function wN(){}wN.prototype=vN.prototype;vN.prototype.i=function(a){if(a===this)return!0;if(a&&a.$classData&&a.$classData.rb.SQ&&this.ka()===a.ka()){var b=this.JF().vv();a:{for(;b.s();){var c=b.t(),d=a.LF(c.so());c=c.to();if(null===d?null!==c:!La(d,c)){a=!0;break a}}a=!1}return!a}return!1};vN.prototype.B=function(){for(var a=this.JF().vv(),b=0;a.s();){var c=b;b=a.t();c|=0;b=b.B()+c|0}return b|0};
+vN.prototype.u=function(){for(var a="{",b=!0,c=this.JF().vv();c.s();){var d=c.t();b?b=!1:a+=", ";a=""+a+d.so()+"\x3d"+d.to()}return a+"}"};function xN(){}xN.prototype=new p;xN.prototype.constructor=xN;xN.prototype.Da=function(a,b){return oa(a,b)};xN.prototype.$classData=q({H1:0},!1,"java.util.Arrays$NaturalComparator$",{H1:1,g:1,Ji:1});var yN;function ij(){yN||(yN=new xN);return yN}function zN(){}zN.prototype=new ak;zN.prototype.constructor=zN;
+zN.prototype.$classData=q({R1:0},!1,"java.util.Formatter$RootLocaleInfo$",{R1:1,$aa:1,g:1});var AN;function CM(){AN||(AN=new zN);return AN}function BN(){this.vB=this.iK=0;this.hK=this.wB=null}BN.prototype=new p;BN.prototype.constructor=BN;function CN(){}CN.prototype=BN.prototype;BN.prototype.s=function(){if(null!==this.wB)return!0;for(;this.vB<this.iK;){var a=this.hK.wl.a[this.vB];this.vB=1+this.vB|0;if(null!==a)return this.wB=a,!0}return!1};
+BN.prototype.t=function(){if(!this.s())throw AH("next on empty iterator");var a=this.wB;this.wB=a.xr;return a};function DN(a,b,c,d,e){this.xB=a;this.oy=b;this.xv=c;this.xr=e}DN.prototype=new p;DN.prototype.constructor=DN;f=DN.prototype;f.so=function(){return this.xB};f.to=function(){return this.xv};f.i=function(a){if(ck(a)){var b=this.xB,c=a.so();if(null===b?null===c:La(b,c))return b=this.xv,a=a.to(),null===b?null===a:La(b,a)}return!1};
+f.B=function(){var a=this.oy,b=this.xv;return a^(a>>>16|0)^(null===b?0:ib(b))};f.u=function(){return this.xB+"\x3d"+this.xv};var EN=q({W1:0},!1,"java.util.HashMap$Node",{W1:1,g:1,TQ:1});DN.prototype.$classData=EN;function FN(a){this.kK=null;this.kK=new GN(a.yB.zv)}FN.prototype=new p;FN.prototype.constructor=FN;FN.prototype.s=function(){return this.kK.s()};FN.prototype.t=function(){return new HN(this.kK.t())};
+FN.prototype.$classData=q({$1:0},!1,"java.util.IdentityHashMap$EntrySet$$anon$2",{$1:1,g:1,p2:1});function HN(a){this.WF=a}HN.prototype=new p;HN.prototype.constructor=HN;f=HN.prototype;f.i=function(a){return ck(a)?Object.is(this.so(),a.so())?Object.is(this.to(),a.to()):!1:!1};f.so=function(){return this.WF.so().py};f.to=function(){return this.WF.to()};f.B=function(){var a=this.WF.to();return Qb(this.WF.so().py)^Qb(a)};f.u=function(){return this.so()+"\x3d"+this.to()};
+f.$classData=q({b2:0},!1,"java.util.IdentityHashMap$MapEntry",{b2:1,g:1,TQ:1});function IN(){}IN.prototype=new p;IN.prototype.constructor=IN;IN.prototype.Qo=function(a,b,c){a.a[b]=c};IN.prototype.Wj=function(a,b){return a.a[b]};IN.prototype.$classData=q({C2:0},!1,"java.util.internal.GenericArrayOps$ReusableAnyRefArrayOps$",{C2:1,g:1,zB:1});var JN;function jj(){JN||(JN=new IN);return JN}function KN(a){if(null===a.Bv)throw XH("No match available");return a.Bv}
+function cq(a,b){this.lK=a;this.UQ=b;this.VQ=0;this.Av=this.UQ;this.YF=0;this.Bv=null;this.qy=0}cq.prototype=new p;cq.prototype.constructor=cq;function bq(a){a.YF=0;a.Bv=null;a.qy=0;a.Bv=a.lK.fR.exec(a.Av);return null!==a.Bv}function LN(a){var b=a.lK;var c=a.Av;var d=b.sK;d.lastIndex=a.YF;c=d.exec(c);b=b.sK.lastIndex|0;a.YF=null!==c?b===(c.index|0)?1+b|0:b:1+a.Av.length|0;a.Bv=c;return null!==c}function MN(a){return(KN(a).index|0)+a.VQ|0}function NN(a){var b=MN(a);a=KN(a)[0];return b+a.length|0}
+cq.prototype.$classData=q({E2:0},!1,"java.util.regex.Matcher",{E2:1,g:1,bba:1});function Fk(a,b,c,d,e,g,h){this.fR=this.sK=null;this.eR=a;this.Q2=d;this.R2=e;this.O2=g;this.P2=h;this.sK=new RegExp(c,this.Q2+(this.R2?"gy":"g"));this.fR=new RegExp("^(?:"+c+")$",d)}Fk.prototype=new p;Fk.prototype.constructor=Fk;Fk.prototype.u=function(){return this.eR};Fk.prototype.$classData=q({F2:0},!1,"java.util.regex.Pattern",{F2:1,g:1,l:1});
+var Uda=function Tda(a){if(a instanceof um){var c=a.Tn;a=Tda(a.Un);return new z(c,a)}if(a instanceof ym)return c=a.dn,a=O().c,new z(c,a);if(zm()===a)return O().c;throw new w(a);},Wda=function Vda(a,b){if(a instanceof um){var d=a.Tn,e=a.Un;return(b?"":"; ")+Zz(a.Xo,!1)+" \x3d\x3e "+Zz(d,!1)+Vda(e,!1)}if(a instanceof ym)return(b?"":"; ")+"_ \x3d\x3e "+Zz(a.dn,!1);if(zm()===a)return"";throw new w(a);},Yda=function Xda(a,b){if(a instanceof um){var d=a.Xo,e=a.Tn;a=a.Un;return""+ON(b)+aA(d,!1,b)+" \x3d\x3e "+
+aA(e,!1,b)+Xda(a,b)}if(a instanceof ym)return d=a.dn,ON(b)+"_ \x3d\x3e "+aA(d,!1,b);if(zm()===a)return"";throw new w(a);};function Kca(a){return!!(a&&a.$classData&&a.$classData.rb.AM)}function PN(a){this.ob=null;if(null===a)throw null;this.ob=new QN(a,ap(),ap())}PN.prototype=new p;PN.prototype.constructor=PN;PN.prototype.$classData=q({BU:0},!1,"mlscript.ConstraintSolver$Shadows$",{BU:1,g:1,l:1});function RN(){this.ld=null}RN.prototype=new kz;RN.prototype.constructor=RN;function SN(){}
+SN.prototype=RN.prototype;function TN(){}TN.prototype=new p;TN.prototype.constructor=TN;function kr(a,b,c,d){return new Ff(UN(b.e().h(),c),b,d)}TN.prototype.$classData=q({PU:0},!1,"mlscript.ErrorReport$",{PU:1,g:1,l:1});var VN;function jr(){VN||(VN=new TN);return VN}function WN(){this.Cg=null;XN=this;this.Cg=new St(!1,!1,!1)}WN.prototype=new p;WN.prototype.constructor=WN;WN.prototype.$classData=q({UU:0},!1,"mlscript.FldFlags$",{UU:1,g:1,l:1});var XN;function tm(){XN||(XN=new WN);return XN}
+function Zda(a){if(a instanceof $t){var b=a.ap,c=k=>{if(k instanceof Ud)k=k.fa;else{if(!(k instanceof fe))throw new w(k);k=k.aa}return k};if(b===u())return u();a=b.e();var d=a=new z(c(a),u());for(b=b.f();b!==u();){var e=b.e();e=new z(c(e),u());d=d.p=e;b=b.f()}return a}if(a instanceof Ut)return c=a.Km,a=a.Lm,d=O().c,new z(c,new z(a,d));if(a instanceof gu)return c=a.ws,a=O().c,new z(c,a);if(a instanceof Ss)return c=a.xu,d=a.yu,a=a.wu,b=O().c,new z(c,new z(d,new z(a,b)));if(a instanceof Tt)return c=
+a.Wn,d=a.Xn,a=a.Yn,b=O().c,new z(c,new z(d,new z(a,b)));if(a instanceof mu){c=a.xs;a=a.ys;for(b=d=null;a!==u();){var g=a.e();e=g.h();g=g.j();var h=O().c;for(e=new Om(new z(e,new z(g,h)));e.s();)g=new z(e.t(),u()),null===b?d=g:b.p=g,b=g;a=a.f()}a=null===d?u():d;return new z(c,a)}throw new w(a);}
+var $da=function YN(a){if(a instanceof Ut){var c=a.Lm;return"("+Zz(a.Km,!1)+") then "+Zz(c,!1)}if(a instanceof gu)return"else "+Zz(a.ws,!1);if(a instanceof $t)return a=a.ap.m(),a=new Ef(a,new y(e=>{if(e instanceof Ud)return e.fa.Wr();if(!(e instanceof fe))throw new w(e);return YN(e.aa)})),"\u2039"+ze(a,"","; ","")+"\u203a";if(a instanceof Tt){c=a.Xn;var d=a.Yn;return Zz(a.Wn,!1)+" "+Zz(c,!1)+" "+YN(d)}if(a instanceof mu)return c=a.ys,a=Zz(a.xs,!1),c=c.m(),c=new Ef(c,new y(e=>{if(null!==e){var g=e.j();
+return"\u00b7 "+Zz(e.h(),!1)+" "+YN(g)}throw new w(e);})),a+" \u2039"+ze(c,"","; ","")+"\u203a";if(a instanceof Ss)return c=a.yu,d=a.wu,(a.Qw?"rec ":"")+"let "+Zz(a.xu,!1)+" \x3d "+Zz(c,!1)+" in "+YN(d);throw new w(a);},aea=function ZN(a,b){if(a instanceof Ut){var d=a.Km;a=a.Lm;return aA(d,!(d instanceof wm),b)+" then "+aA(a,!1,b)}if(a instanceof gu)return"else "+aA(a.ws,!1,b);if(a instanceof $t){var e=a.ap;a=k=>{if(k instanceof Ud)k=k.fa;else{if(!(k instanceof fe))throw new w(k);k=k.aa}return k};
+if(e===u())a=u();else{d=e.e();var g=d=new z(a(d),u());for(e=e.f();e!==u();){var h=e.e();h=new z(a(h),u());g=g.p=h;e=e.f()}a=d}b=ON(b);return""+ze(a,"",b,"")}if(a instanceof Tt)return d=a.Xn,g=a.Yn,aA(a.Wn,!1,b)+" "+aA(d,!1,b)+" "+ZN(g,b);if(a instanceof mu)return d=a.ys,a=aA(a.xs,!1,b),d=d.m(),d=new Ef(d,new y(k=>{if(null!==k)return"\u00b7 "+k.h()+" "+k.j();throw new w(k);})),b=ON(b),a+" "+ze(d,"",b,"");if(a instanceof Ss)return d=a.yu,g=a.wu,(a.Qw?"rec ":"")+"let "+aA(a.xu,!1,b)+" \x3d "+aA(d,!1,
+b)+" in "+ZN(g,b);throw new w(a);};function $N(){this.gD=null;aO=this;this.gD=bO().Ht()}$N.prototype=new p;$N.prototype.constructor=$N;
+function bO(){return Dz(Ez(),J(new K,[G(new H,"**",14),G(new H,"*",13),G(new H,"/",13),G(new H,"%",13),G(new H,"+",12),G(new H,"-",12),G(new H,"\x3c\x3c",11),G(new H,"\x3e\x3e",11),G(new H,"\x3e\x3e\x3e",11),G(new H,"\x3c",10),G(new H,"\x3c\x3d",10),G(new H,"\x3e",10),G(new H,"\x3e\x3d",10),G(new H,"in",10),G(new H,"instanceof",10),G(new H,"\x3d\x3d",9),G(new H,"!\x3d",9),G(new H,"\x3d\x3d\x3d",9),G(new H,"!\x3d\x3d",9),G(new H,"\x26",8),G(new H,"^",7),G(new H,"|",6),G(new H,"\x26\x26",5),G(new H,
+"||",4),G(new H,"??",4),G(new H,",",1)]))}$N.prototype.$classData=q({AV:0},!1,"mlscript.JSBinary$",{AV:1,g:1,l:1});var aO;function Lm(){aO||(aO=new $N);return aO}function cO(){this.Az=2}cO.prototype=new p;cO.prototype.constructor=cO;cO.prototype.$classData=q({JV:0},!1,"mlscript.JSCommaExpr$",{JV:1,g:1,l:1});var dO;function Vp(){dO||(dO=new cO);return dO}function eO(){}eO.prototype=new Jp;eO.prototype.constructor=eO;function fO(){}fO.prototype=eO.prototype;eO.prototype.VJ=function(){return!1};
+function rn(a){return new Io((t(),new L(a)))}function zz(a,b){return new Bo(new Lo(a,b))}function Tba(a,b,c){c=c.Ja(new y(d=>{if(null!==d)return new gO(d.h(),d.j());throw new w(d);})).ha();t();return new hO(a,c,new L(new iO(b)))}function Up(a,b){return a.sh()<b?Pp(a.xa(),!0):a.xa()}function jO(){}jO.prototype=new p;jO.prototype.constructor=jO;
+function Ko(a){var b=g=>{var h=t().d;return G(new H,g,h)};if(a===u())b=u();else{var c=a.e(),d=c=new z(b(c),u());for(a=a.f();a!==u();){var e=a.e();e=new z(b(e),u());d=d.p=e;a=a.f()}b=c}return new Eo(b)}jO.prototype.$classData=q({ZV:0},!1,"mlscript.JSLetDecl$",{ZV:1,g:1,l:1});var kO;function Jo(){kO||(kO=new jO)}function lO(){}lO.prototype=new p;lO.prototype.constructor=lO;
+function Mp(a,b){a=b.length;for(var c=new zc(a),d=0;d<a;){var e=d,g=b.charCodeAt(d);switch(g){case 34:g='\\"';break;case 92:g="\\\\";break;case 8:g="\\b";break;case 12:g="\\f";break;case 10:g="\\n";break;case 13:g="\\r";break;case 9:g="\\t";break;default:g=0<g&&255>=g&&!us(Pr(),g)?String.fromCharCode(g):ida(Q(),J(new K,[g]))}c.a[e]=g;d=1+d|0}return ze(new Fu(c),'"',"",'"')}lO.prototype.$classData=q({aW:0},!1,"mlscript.JSLit$",{aW:1,g:1,l:1});var mO;function Np(){mO||(mO=new lO);return mO}
+function nO(){}nO.prototype=new Jp;nO.prototype.constructor=nO;function oO(){}oO.prototype=nO.prototype;function pO(){}pO.prototype=new Jp;pO.prototype.constructor=pO;function qO(){}qO.prototype=pO.prototype;
+function Af(){this.CH=this.DH=this.Cs=this.di=null;eE();var a=new iE;fE(a,t().d);t();var b=J(new K,"true false NaN id emptyArray succ error length concat join add sub mul div gt not ne eq sgt slt sge sle typeof toString String negate eq unit log run Const freshName Lam Var App IntLit StrLit DecLit UnitLit Rcd Bra Sel Blk Tup Fld Let Subs With Quoted CaseOf Case Wildcard NoCases discard window".split(" "));for(b=Pd(u(),b);!b.b();){var c=b.e();vp(a,new go(c,c));b=b.f()}b=new nn("anything",O().c,gl());
+a.ko.bj(b.er,b);b=new nn("nothing",O().c,el());a.ko.bj(b.er,b);t();b=J(new K,["int","number","bool","string","unit"]);for(b=Pd(u(),b);!b.b();)c=b.e(),c=new nn(c,O().c,new Ep(c)),a.ko.bj(c.er,c),b=b.f();b=new mn("Annotation","Annotation",O().c,new Tn(O().c),O().c);yp(a,b);this.di=a;this.Cs=(Cz(),new oz);this.DH=Uo(this.di,"results");this.CH=Uo(this.di,"prettyPrint");ho(this.Cs,"prettyPrint",this.CH)}Af.prototype=new eo;Af.prototype.constructor=Af;
+function taa(a,b){var c=b.Xz;Od();var d=new fp;Od();for(var e=new fp,g=c;!g.b();){var h=g.e();if(h&&h.$classData&&h.$classData.rb.ce){var k=h;t();var l=new Ud(k)}else if(h instanceof Zn){var m=h;t();l=new Ud(m)}else{h instanceof yo||xm("Program reached and unexpected state.");var n=h;t();l=new fe(n)}if(l instanceof fe)wp(d,l.aa);else if(l instanceof Ud)wp(e,l.fa);else throw new w(l);g=g.f()}var r=d.ha(),v=e.ha(),x=a.di,A=O().c,B=dE(x,"TypingUnit");Od();var C=new fp;Od();for(var D=new fp,F=A;!F.b();){var I=
+F.e();a:{if(I instanceof Zn){var M=I,N=M.wd,P=M.Rb,T=M.Ch,Y=M.Yc;if(null!==P){var Z=P.x;if(Y instanceof fe){var S=Y.aa;if(N.b()||(N.b()?0:N.o())){O();var ea=new Dp(!(N.b()||!N.o()),new Ep(B),new vl(Z),T,(O(),new fe(S)));var ia=new fe(ea);break a}}}}O();ia=new Ud(I)}if(ia instanceof fe)wp(C,ia.aa);else if(ia instanceof Ud)wp(D,ia.fa);else throw new w(ia);F=F.f()}var X=C.ha(),sa=D.ha();Od();var Ja=new fp;Od();for(var Xa=new fp,Fa=sa;!Fa.b();){var za=Fa.e();a:{if(za instanceof Zn){var Qa=za,Ma=Qa.wd,
+Ga=Qa.Rb,ab=Qa.Ch,Hb=Qa.Yc;if(null!==Ga){var bc=Ga.x;if(Hb instanceof Ud){var yb=Hb.fa;if(Ma.b()||(Ma.b()?0:Ma.o())){O();var tb=new Dp(!(Ma.b()||!Ma.o()),new Ep(B),new vl(bc),ab,(O(),new Ud(yb)));var eb=new fe(tb);break a}}}}O();eb=new Ud(za)}if(eb instanceof fe)wp(Ja,eb.aa);else if(eb instanceof Ud)wp(Xa,eb.fa);else throw new w(eb);Fa=Fa.f()}var kb=Ja.ha(),Rb=Xa.ha(),Gb=new ln(B,O().c,new Tn(O().c),X,kb,Rb,O().c,r,t().d);yp(x,Gb);var vb=Im(a.di,"typing_unit",new L(!1),!1,t().d),Tb=a.di,Nb=Go(a,Gb,
+t().d,!0,Tb),ic=new qn(vb.re,new $m(new km(Gb.lj))),Va=r;a:for(var cb;;)if(Va.b()){cb=u();break}else{var zb=Va.e(),Ub=Va.f();if(!1===!!zb.fl.b())Va=Ub;else for(var jb=Va,db=Ub;;){if(db.b())cb=jb;else{if(!1!==!!db.e().fl.b()){db=db.f();continue}for(var ub=db,Aa=new z(jb.e(),u()),va=jb.f(),Ra=Aa;va!==ub;){var rb=new z(va.e(),u());Ra=Ra.p=rb;va=va.f()}for(var xb=ub.f(),mc=xb;!xb.b();){if(!1===!!xb.e().fl.b()){for(;mc!==xb;){var Ha=new z(mc.e(),u());Ra=Ra.p=Ha;mc=mc.f()}mc=xb.f()}xb=xb.f()}mc.b()||(Ra.p=
+mc);cb=Aa}break a}}if(cb===u())var Ka=u();else{for(var Oa=cb.e(),Na=new z(bp(Oa,vb.re),u()),Da=Na,ta=cb.f();ta!==u();){var Ya=ta.e(),dc=new z(bp(Ya,vb.re),u());Da=Da.p=dc;ta=ta.f()}Ka=Na}for(var ka=new km(a.DH),ya=u(),Sa=ep(new fp,ya),xc=new qn(a.DH,new Wo(O().c)),Sb=new z(Nb,new z(ic,Ka)),uc=v,Lb=null,lc=null;uc!==u();){var Xb=uc.e(),ec=!1,Ab=null;a:{if(Xb instanceof Zn){ec=!0;Ab=Xb;var Ob=Ab.wd,fb=Ab.Rb,Wa=Ab.hj,bb=Ab.Yc;if(null!==fb){var Ia=fb.x;if(bb instanceof fe){var Ua=bb.aa,pc=!(!Ob.b()&&
+!Ob.o()),sc=Ob.b();if(Wa.b())var Ba=R();else{var ob=Wa.o();Ba=new L(ob.x)}if(pc){var nc=sc?R():new L(!0),Ib=Im(a.di,Ia,nc,Co(new Do(a,Ua)),t().d),vc=Zm(a,Ua,a.di),Vb=a.di,fc=Ib;Vb.ko.JB(fc.jJ);Vb.Ip.IB(fc.re);var Bc=sc?R():new L(!1),Pb=Im(a.di,Ia,Bc,Co(new Do(a,Ua)),Ba),Jb=vc,gc=Pb}else{var Cb=Zm(a,Ua,a.di),cc=sc?R():new L(!1),yc=Im(a.di,Ia,cc,Co(new Do(a,Ua)),Ba);Jb=Cb;gc=yc}var Mc=Jb,qc=gc,oc=qc.hJ.b()&&!qc.iJ?new oo(O().c,(t(),new fe(Mc))):Mc;wp(Sa,qc.re);var Qc=a.di.lo,jc=new qn(qc.re,oc),sb=
+om(Al(),ka,"push"),Gc=new km(qc.re),Wb=O().c,Cc=new Bo(new cn(sb,new z(Gc,Wb))),Fc=O().c;var qd=Qo(Qc,new z(jc,new z(Cc,Fc)));break a}}}if(ec){var Yb=Ab.Yc;if(null!==Ab.Rb&&Yb instanceof Ud){qd=O().c;break a}}if(Xb instanceof No||Xb instanceof Oo||Xb instanceof Po)throw new gm("Def and TypeDef are not supported in NewDef files.");if(Xb instanceof Pm){var Nc=Xb,ad=Zm(a,Nc,a.di),Uc=Nc,cd=wf(vf(),O().c,!0,"'");var kc=aA(Uc,!1,cd);wp(Sa,kc);var Vc=a.di.lo,Hc=om(Al(),ka,"push"),rc=O().c,sd=new Bo(new cn(Hc,
+new z(ad,rc))),Kc=O().c;qd=Qo(Vc,new z(sd,Kc))}else throw new w(Xb);}for(var Qd=qd.m();Qd.s();){var Ad=new z(Qd.t(),u());null===lc?Lb=Ad:lc.p=Ad;lc=Ad}uc=uc.f()}var kd=null===Lb?u():Lb,Hd=un(Sb,kd),Rd=new z(xc,Hd),Bd=om(Al(),ka,"map"),ae=J(new K,[new km(a.CH)]),dd=rn(new cn(Bd,(Od(),Pd(u(),ae)))),od=O().c,Ta=new z(dd,od),wb=t().d,$a=O().c;t();for(var wa,hb=a.Cs,ra=hb.Yz,wc=rO().Eb(),ac=ra.m();ac.s();){var Id=ac.t();if(null===Id)throw new w(Id);var ud=Id.h(),be=Id.j();if(hb.aI.L(ud))var re=t().d;else{var pe=
+Cz().PN.U(ud);if(pe instanceof L){var bd=pe.k;hb.aI.oh(ud);t();var Rc=bd.dQ(be);re=new L(Rc)}else{if(t().d!==pe)throw new w(pe);re=t().d}}wc.zc(re)}wa=wc.Kb().ha();var Wc=dl(dl(Ta,Rd),wa),Wd=new H;var zd=(new dn(wb,$a,new Ud(Wc),O().c)).xa().$f;if(zd===u())var Pa=u();else{for(var Db=zd.e(),Oc=new z(Db.u(),u()),Tc=Oc,Sd=zd.f();Sd!==u();){var Jc=Sd.e(),vd=new z(Jc.u(),u());Tc=Tc.p=vd;Sd=Sd.f()}Pa=Oc}return G(Wd,Pa,Sa.ha())}Af.prototype.$classData=q({nW:0},!1,"mlscript.JSWebBackend",{nW:1,Baa:1,g:1});
+function sO(){}sO.prototype=new p;sO.prototype.constructor=sO;function du(a,b){a=b.m();t();for(b=R();a.s();){var c=b;b=a.t();c.b()?b=b.A():(b=Kt(c.o(),b.A()),b=it().n(b))}return b}sO.prototype.$classData=q({wW:0},!1,"mlscript.Loc$",{wW:1,g:1,l:1});var tO;function cu(){tO||(tO=new sO);return tO}function uO(){}uO.prototype=new p;uO.prototype.constructor=uO;function uaa(a){vf();a=a.m();return wf(0,new xo(a,new y(b=>Wn(b.fp,new vO(b)))),!0,"?")}
+function wO(a,b){a=new xO(b);b=O().c;return new $q(new z(a,b))}function We(a,b){a=new Vq(b);b=O().c;return new $q(new z(a,b))}uO.prototype.$classData=q({yW:0},!1,"mlscript.Message$",{yW:1,g:1,l:1});var yO;function Xe(){yO||(yO=new uO);return yO}function Ft(a,b,c,d){this.Lz=this.mE=this.dx=this.lE=this.ex=null;this.hx=!1;this.Fu=null;this.Eu=!1;this.jE=this.kE=null;this.le=this.fx=0;this.gx=this.Ol=null;this.Kz=!1;this.wN=null;if(null===a)throw null;this.wN=a;lt(this,a.mE,b,a.hx,a.Fu,a.Eu,c,d)}
+Ft.prototype=new ot;Ft.prototype.constructor=Ft;Ft.prototype.nQ=function(a){Ds(this.wN,new U(()=>"\x3e "+Es(a)))};Ft.prototype.$classData=q({RW:0},!1,"mlscript.NewParser$$anon$1",{RW:1,PW:1,g:1});function rt(a){this.gj=this.KH=null;if(null===a)throw null;this.gj=a;this.KH=new zO(a,nf())}rt.prototype=new p;rt.prototype.constructor=rt;
+rt.prototype.HC=function(){var a;a:for(a=this.gj.gx;;){var b=!1,c=null,d=Me(this.gj,new Ne(271),new Oe("go"));if(d instanceof z){b=!0;c=d;var e=c.z;if(null!==e){var g=e.h();e=e.j();if(g instanceof as&&(g=g.Na,a.Nl.L(g))){d=this.gj;b=new Te(new Ue(J(new K,["Repeated modifier `","`"])));c=[We(Xe(),g)];b=Ye(b,J(new K,c));t();b=G(new H,b,new L(e));c=O().c;Ze(d,new z(b,c));Ps(this.gj,new Ne(274),new Oe("go"));Os(this.gj);continue}}}if(b&&(g=c.z,null!==g&&(e=g.h(),g=g.j(),e instanceof as&&"declare"===e.Na))){Ps(this.gj,
+new Ne(278),new Oe("go"));Os(this.gj);d=a;a=a.Nl.Pn(G(new H,"declare",g));a=new zO(d.vq,a);continue}if(b&&(g=c.z,null!==g&&(e=g.h(),g=g.j(),e instanceof as&&"virtual"===e.Na))){Ps(this.gj,new Ne(282),new Oe("go"));Os(this.gj);d=a;a=a.Nl.Pn(G(new H,"virtual",g));a=new zO(d.vq,a);continue}if(b&&(g=c.z,null!==g&&(e=g.h(),g=g.j(),e instanceof as&&"mut"===e.Na))){Ps(this.gj,new Ne(286),new Oe("go"));Os(this.gj);d=a;a=a.Nl.Pn(G(new H,"mut",g));a=new zO(d.vq,a);continue}if(b&&(g=c.z,null!==g&&(e=g.h(),g=
+g.j(),e instanceof as&&"abstract"===e.Na))){Ps(this.gj,new Ne(290),new Oe("go"));Os(this.gj);d=a;a=a.Nl.Pn(G(new H,"abstract",g));a=new zO(d.vq,a);continue}if(a.Nl.b())break a;if(b&&(e=c.z,null!==e&&(e=e.h(),e instanceof as&&(e=e.Na,"class"===e||"infce"===e||"trait"===e||"mixin"===e||"type"===e||"namespace"===e||"module"===e||"fun"===e||"val"===e||"let"===e))))break a;if(b&&(b=c.z,null!==b)){c=b.h();b=b.j();d=this.gj;e=new Te(new Ue(J(new K,["Unexpected "," token after modifier",""])));c=[We(Xe(),
+c.jb()),0<a.Nl.$k(1)?We(Xe(),"s"):We(Xe(),"")];c=Ye(e,J(new K,c));t();b=G(new H,c,new L(b));c=O().c;Ze(d,new z(b,c));break a}a=O().c;(null===a?null===d:a.i(d))&&no();throw new w(d);}this.gj.gx=a;t();a=G(new H,a,this.gj.Ol);return new L(a)};rt.prototype.$classData=q({TW:0},!1,"mlscript.NewParser$ModifierSet$",{TW:1,g:1,l:1});function AO(a){this.Zf=null;if(null===a)throw null;this.Zf=a}AO.prototype=new p;AO.prototype.constructor=AO;
+function BO(a,b){var c=a.Zf,d=a.Zf,e=uv(),g=Su(),h=op().ga;e=e.ng(new Uu(g,h));a=Vu(a.Zf);g=uv();h=Su();var k=op().ga;b=new CO(d,b,e,a,g.ng(new Uu(h,k)));d=O().c;return new DO(c,new z(b,d))}function bea(a,b){var c=a.Zf;b=b.Ba.m();b=new Ef(b,new y(d=>{var e=a.Zf;d=new iw(a.Zf,d.h(),d.j());var g=uv(),h=Su(),k=op().ga;g=g.ng(new Uu(h,k));h=Vu(a.Zf);k=uv();var l=Su(),m=op().ga;return new CO(e,d,g,h,k.ng(new Uu(l,m)))}));Od();return new DO(c,Pd(u(),b))}
+function EO(a,b){return b?new DO(a.Zf,O().c):BO(a,lw(a.Zf))}
+function FO(a,b,c,d,e,g,h,k,l){for(;;){var m=!1,n=null,r=d;if(r instanceof Fv){a:{var v=a,x=r,A=tc();try{var B=GO(v.Zf),C=zw(lw(v.Zf),x);if(C.b())throw Hq(new Iq,A,EO(GO(v.Zf),!0));var D=BO(B,C.o())}catch(Cc){if(Cc instanceof Iq){var F=Cc;if(F.Qg===A){D=F.Cj();break a}throw F;}throw Cc;}}return D}if(r instanceof Gv){var I=r,M=a.Zf,N=O().c,P=new z(I,N),T=t().d,Y=sv(),Z=Su(),S=op().ga;return BO(a,new jw(M,P,T,Y.Hd(new Uu(Z,S))))}if(r instanceof Qv)return bea(a,r);if(r instanceof FA)return EO(a,!r.Eh);
+if(r instanceof LA){var ea=r,ia=ea.jc,X=ea.tc,sa=FO(a,b,c,ea.ic,e,g,h,k,l),Ja=FO(a,b,c,ia,e,g,h,k,l);if(X){var Xa=sa,Fa=X,za=g,Qa=k,Ma=Ja.wq;if(Ma===u())var Ga=u();else{for(var ab=Ma.e(),Hb=new z(HO(Xa,ab,Fa,za,Qa),u()),bc=Hb,yb=Ma.f();yb!==u();){var tb=yb.e(),eb=new z(HO(Xa,tb,Fa,za,Qa),u());bc=bc.p=eb;yb=yb.f()}Ga=Hb}for(var kb=EO(GO(Xa.ix),!1),Rb=Ga;!Rb.b();){var Gb=kb,vb=Rb.e();kb=IO(Gb,vb);Rb=Rb.f()}var Tb=kb}else Tb=IO(sa,Ja);return Tb}if(r instanceof MA){var Nb=r.Fc,ic=a.Zf,Va=yB(xB(a.Zf),
+b,c,Nb,!e,g,h,k,l).xe;if(Va===u())var cb=u();else{for(var zb=Va.e(),Ub=new z(new CO(zb.zb,zb.Of,zb.Af,zb.Nf,zb.Pf),u()),jb=Ub,db=Va.f();db!==u();){var ub=db.e(),Aa=new z(new CO(ub.zb,ub.Of,ub.Af,ub.Nf,ub.Pf),u());jb=jb.p=Aa;db=db.f()}cb=Ub}return new DO(ic,cb)}if(r instanceof lx){m=!0;n=r;iC(a.Zf);var va=n.Sb;if(!va.b()){var Ra=va.o();if(!vD(h)&&!l.L(n)){var rb=l.bc(n),xb=b,mc=c,Ha=rb;return FO(GO(a.Zf),xb,mc,Ra,e,g,h,k,Ha)}}}if(m){uv();var Ka=n,Oa=Su(),Na=op().ga,Da=void 0,ta=void 0,Ya=vv(Ka,new Uu(Oa,
+Na)),dc=a.Zf,ka=a.Zf;null===ka.Bq&&null===ka.Bq&&(ka.Bq=new JO(ka));ta=ka.Bq;var ya=ta.oE,Sa=lw(ta.oE),xc=Vu(ta.oE),Sb=uv(),uc=Su(),Lb=op().ga;Da=new CO(ya,Sa,Ya,xc,Sb.ng(new Uu(uc,Lb)));var lc=O().c;return new DO(dc,new z(Da,lc))}if(r instanceof ZB){var Xb=r;$B(a.Zf);t();var ec=Xb.mc(),Ab=new L(ec);if(!Ab.b()){d=Ab.k;continue}}if(r instanceof fw){var Ob=r,fb=Ob.qb;if(vD(h)&&!a.Zf.cn.L(fb.V)||!PA(Ob,g)){var Wa=a.Zf,bb=a.Zf,Ia=a.Zf,Ua=O().c,pc=t().d;sv();var sc=G(new H,fb,Ob),Ba=Su(),ob=op().ga,nc=
+new jw(Ia,Ua,pc,$v(sc,new Uu(Ba,ob))),Ib=uv(),vc=Su(),Vb=op().ga,fc=Ib.ng(new Uu(vc,Vb)),Bc=Vu(a.Zf),Pb=uv(),Jb=Su(),gc=op().ga,Cb=new CO(bb,nc,fc,Bc,Pb.ng(new Uu(Jb,gc))),cc=O().c;return new DO(Wa,new z(Cb,cc))}d=QA(Ob,g)}else if(r instanceof cC){var yc=r,Mc=yc.Fg,qc=yc.Sf;d=e?qc:Mc}else if(r instanceof Qx){var oc=r,Qc=oc.Re;b=oc.de;d=Qc}else if(r instanceof eC){var jc=r,sb=jc.kj,Gc=g.da,Wb=dl(c,jc.Lj);b=Gc;c=Wb;d=sb}else throw new w(r);}}
+AO.prototype.$classData=q({XW:0},!1,"mlscript.NormalForms$CNF$",{XW:1,g:1,l:1});function KO(a){this.xq=this.nE=null;if(null===a)throw null;this.xq=a}KO.prototype=new p;KO.prototype.constructor=KO;function ZA(a){null===a.nE&&null===a.nE&&(a.nE=new LO(a));return a.nE}KO.prototype.$classData=q({ZW:0},!1,"mlscript.NormalForms$Conjunct$",{ZW:1,g:1,l:1});
+var dea=function cea(a,b,c,d,e,g,h){if(Pe(new E(c),d))return UA(d,b,!1,new fn((l,m)=>cea(a,l,m,d,e,g,h)),e);if(b instanceof L)return MO(a,g,h,c,!!b.k,e,!0,!1);if(t().d===b)return dw(cw(a.Bf),MO(a,g,h,c,!1,e,!0,!1),MO(a,g,h,c,!0,e,!0,!1),ew(cw(a.Bf)),e);throw new w(b);};function NO(a){this.Bf=null;if(null===a)throw null;this.Bf=a}NO.prototype=new p;NO.prototype.constructor=NO;
+function OO(a,b,c,d){var e=a.Bf,g=uv(),h=Su(),k=op().ga;g=g.ng(new Uu(h,k));h=lw(a.Bf);k=uv();var l=Su(),m=op().ga;d=new PO(e,d,g,h,k.ng(new Uu(l,m)));e=O().c;return QO(a,b,c,new z(d,e))}function QO(a,b,c,d){a=new RO(a.Bf,b,c,d);0===(4&a.Nm)<<24>>24&&0===(4&a.Nm)<<24>>24&&(a.zN=qB(a)?a.fb:a.Ea(),a.Nm=(4|a.Nm)<<24>>24);c=a.zN;return c<b?new RO(a.Gj,c,a.Qf,a.xe):a}function SO(a,b){return b?OO(a,a.Bf.Gd,O().c,Vu(a.Bf)):new RO(a.Bf,a.Bf.Gd,O().c,O().c)}
+function TO(a,b,c,d,e,g,h){return yB(a,b,c,MO(a,b,c,d,e,g,!1,!0),e,g,!1,!0,h)}function MO(a,b,c,d,e,g,h,k){if(d instanceof OA)return e=MO(a,b,c,d.Hi,e,g,h,k),h=d.ma(),ux(e.q,e,h);if(d instanceof cC){var l=d.Fg,m=d.Sf;e=MO(a,b,c,e?m:l,e,g,h,k);h=d.ma();return ux(e.q,e,h)}l=ap();h=yB(a,b,c,d,e,g,h,k,l).zf(!1);t();return UA(h,new L(e),!1,new fn((n,r)=>dea(a,n,r,d,g,b,c)),g)}
+function yB(a,b,c,d,e,g,h,k,l){for(;;){var m=!1,n=null,r=e?Cca(d,g,h):d;if(r instanceof Fv){var v=r,x=xB(a.Bf),A=b,B=c,C=a.Bf;t();var D=new L(v),F=uv(),I=Su(),M=op().ga,N=F.ng(new Uu(I,M)),P=Ev(k)?v.kq():wv(xv(a.Bf)),T=sv(),Y=Su(),Z=op().ga;return OO(x,A,B,new Ku(C,D,N,P,T.Hd(new Uu(Y,Z))))}if(r instanceof Gv){var S=r,ea=xB(a.Bf),ia=b,X=c,sa=a.Bf,Ja=t().d;uv();var Xa=Su(),Fa=op().ga,za=vv(S,new Uu(Xa,Fa)),Qa=wv(xv(a.Bf)),Ma=sv(),Ga=Su(),ab=op().ga;return OO(ea,ia,X,new Ku(sa,Ja,za,Qa,Ma.Hd(new Uu(Ga,
+ab))))}if(r instanceof Qv){var Hb=r,bc=xB(a.Bf),yb=b,tb=c,eb=a.Bf,kb=t().d,Rb=uv(),Gb=Su(),vb=op().ga,Tb=Rb.ng(new Uu(Gb,vb)),Nb=sv(),ic=Su(),Va=op().ga;return OO(bc,yb,tb,new Ku(eb,kb,Tb,Hb,Nb.Hd(new Uu(ic,Va))))}if(r instanceof FA)return SO(a,!r.Eh);if(r instanceof LA){var cb=r,zb=cb.jc,Ub=e,jb=yB(a,b,c,cb.ic,e,g,h,k,l),db=yB(a,b,c,zb,e,g,h,k,l),ub=g,Aa=k;return cb.tc?UO(jb,db,ub,Aa):eea(jb,db,Ub,ub,Aa)}if(r instanceof MA){var va=r.Fc,Ra=xB(a.Bf),rb=b,xb=c,mc=FO(GO(a.Bf),b,O().c,va,!e,g,h,k,l).wq;
+if(mc===u())var Ha=u();else{for(var Ka=mc.e(),Oa=new z(new PO(Ka.Is,Ka.Js,Ka.Ks,Ka.Ls,Ka.Ms),u()),Na=Oa,Da=mc.f();Da!==u();){var ta=Da.e(),Ya=new z(new PO(ta.Is,ta.Js,ta.Ks,ta.Ls,ta.Ms),u());Na=Na.p=Ya;Da=Da.f()}Ha=Oa}return QO(Ra,rb,xb,Ha)}if(r instanceof lx){m=!0;n=r;iC(a.Bf);var dc=n.Sb;if(!dc.b()){var ka=dc.o();if(!vD(h)&&!l.L(n)){var ya=l.bc(n),Sa=b,xc=c,Sb=ya;return yB(xB(a.Bf),Sa,xc,ka,e,g,h,k,Sb)}}}if(m){var uc=xB(a.Bf),Lb=b,lc=c,Xb=$A(a.Bf);uv();var ec=n,Ab=Su(),Ob=op().ga,fb=Xb,Wa=vv(ec,
+new Uu(Ab,Ob)),bb=fb.xq,Ia=Vu(fb.xq),Ua=lw(fb.xq),pc=uv(),sc=Su(),Ba=op().ga;var ob=new PO(bb,Ia,Wa,Ua,pc.ng(new Uu(sc,Ba)));var nc=O().c;return QO(uc,Lb,lc,new z(ob,nc))}if(r instanceof ZB){var Ib=r;$B(a.Bf);t();var vc=Ib.mc(),Vb=new L(vc);if(!Vb.b()){d=Vb.k;continue}}if(r instanceof fw){var fc=r,Bc=fc.qb;if(vD(h)&&!a.Bf.cn.L(Bc.V)||!PA(fc,g)){var Pb=b,Jb=c,gc=a.Bf,Cb=gw(fc,g),cc=uv(),yc=Su(),Mc=op().ga,qc=cc.ng(new Uu(yc,Mc)),oc=wv(xv(a.Bf)),Qc=sv(),jc=[G(new H,Bc,fc)],sb=J(new K,jc),Gc=Su(),Wb=
+op().ga;return OO(a,Pb,Jb,new Ku(gc,Cb,qc,oc,Qc.CF(sb,new Uu(Gc,Wb))))}d=QA(fc,g)}else if(r instanceof cC){var Cc=r,Fc=Cc.Fg,qd=Cc.Sf;d=e?qd:Fc}else if(r instanceof Qx){var Yb=r,Nc=Yb.Re;b=Yb.de;d=Nc}else if(r instanceof eC){var ad=r,Uc=ad.kj;c=dl(c,ad.Lj);d=Uc}else throw new w(r);}}NO.prototype.$classData=q({bX:0},!1,"mlscript.NormalForms$DNF$",{bX:1,g:1,l:1});function JO(a){this.oE=null;if(null===a)throw null;this.oE=a}JO.prototype=new p;JO.prototype.constructor=JO;
+JO.prototype.$classData=q({dX:0},!1,"mlscript.NormalForms$Disjunct$",{dX:1,g:1,l:1});function cy(a){if(a instanceof Zn)return"definition";if(a instanceof yo)return"type declaration";throw new w(a);}
+function fea(a){var b=!1,c=null;if(a instanceof Zn){b=!0;c=a;var d=c.wd,e=c.Rb,g=c.hj;if(t().d===d)return"fun"+(g.b()?"":" ("+g.o().x+")")+" "+e.x}if(b&&(d=c.wd,e=c.Rb,g=c.hj,d instanceof L&&!1===!!d.k))return"let"+(g.b()?"":" "+g.o().x+")")+" "+e.x;if(b&&(b=c.wd,d=c.Rb,c=c.hj,b instanceof L&&!0===!!b.k))return"let rec"+(c.b()?"":" "+c.o().x+")")+" "+d.x;if(a instanceof yo){d=a.pb;var h=a.hg;g=a.Sg;e=a.Hj;b=a.Di;c=d.ld;a=a.gb.V;if(h.b())var k="";else{if(h===u())k=u();else{k=h.e();var l=k=new z(k.j().V,
+u());for(h=h.f();h!==u();){var m=h.e();m=new z(m.j().V,u());l=l.p=m;h=h.f()}}k=ze(k,"\u2039",", ","\u203a")}g.b()?g="":(g=g.o(),g="("+Yz(g)+")");e.b()?e="":(e=e.o(),e=": "+VO(e,!0));d=b.b()?"":Pe(new E(d),Ap())?" \x3d ":": ";b=b.m();b=new Ef(b,new y(n=>Zz(n,!1)));return c+" "+a+k+g+e+d+ze(b,"",", ","")}throw new w(a);}
+function gea(a){if(a instanceof yo&&Ot(new E(a.pb),Bp())){var b=a.Sg;if(b.b())return R();var c=b.o();b=new vl("_");a=new Cl(new vl("x"),new Ep(a.Cf.x));var d=c.Ra;c=k=>{if(null!==k){var l=new L(k);if(!l.b()&&(l=l.k.h(),l instanceof L)){var m=l.k;k=t().d;l=tm().Cg;var n=new vl("x"),r=new vl("#"+m.x);m=m.A();l=new sm(l,new Ql(n,Cq(r,m)));return G(new H,k,l)}}if(null!==k&&(l=new L(k),!l.b()&&(k=l.k.h(),l=l.k.j(),t().d===k&&null!==l&&(m=l.ya,m instanceof vl))))return k=t().d,l=tm().Cg,n=new vl("x"),r=
+new vl("#"+m.x),m=m.A(),l=new sm(l,new Ql(n,Cq(r,m))),G(new H,k,l);xm("Program reached and unexpected state.")};if(d===u())c=u();else{var e=d.e(),g=e=new z(c(e),u());for(d=d.f();d!==u();){var h=d.e();h=new z(c(h),u());g=g.p=h;d=d.f()}c=e}g=new Rl(!1,b,a,new Gl(c));b=t().d;a=new vl("unapply");c=t().d;e=O().c;t();d=t().d;h=new sm(tm().Cg,new vl("x"));d=G(new H,d,h);h=O().c;g=new Ol(new Gl(new z(d,h)),g);return new L(new Zn(b,a,c,e,new fe(g),t().d,t().d,t().d,t().d,t().d,!0,O().c))}return t().d}
+function WO(a){this.JN=null;this.OH=!1;this.IN=null;if(null===a)throw null;this.IN=a}WO.prototype=new p;WO.prototype.constructor=WO;WO.prototype.$classData=q({yX:0},!1,"mlscript.NuTypeDefs$RefMap$",{yX:1,g:1,l:1});function XO(a,b,c){if(0<=a.length&&"'"===a.substring(0,1))var d=!0;else d=pE().SP,d=0<=a.length&&a.substring(0,d.length)===d;b=d?"":b;d=c.U(a);if(d instanceof L)return d=d.k|0,c.bh(a,1+d|0),""+b+a+d;if(t().d===d)return c.bh(a,0),""+b+a;throw new w(d);}function YO(){}YO.prototype=new p;
+YO.prototype.constructor=YO;
+function wf(a,b,c,d){a=b.m();Od();a=Pd(u(),a);for(var e=b=null;a!==u();){for(var g=ZO(a.e()).m();g.s();){var h=new z(g.t(),u());null===e?b=h:e.p=h;e=h}a=a.f()}a=null===b?u():b;a=hl(a);a=Pt(a,new y(n=>{var r=n.pp;if(r instanceof fe)return t(),n=G(new H,n.oA,n),new fe(n);if(r instanceof Ud)return r=r.fa,t(),n=G(new H,r,n),new Ud(n);throw new w(r);}));if(null===a)throw new w(a);g=a.h();b=a.j();Od();e=new fp;Od();for(a=new fp;!g.b();){h=g.e();a:{if(null!==h){var k=h.h(),l=h.j();if(k instanceof L){h=k.k;
+t();h=G(new H,h,l);h=new fe(h);break a}}if(null!==h&&(l=h.h(),k=h.j(),t().d===l)){t();h=new Ud(k);break a}throw new w(h);}if(h instanceof fe)wp(e,h.aa);else if(h instanceof Ud)wp(a,h.fa);else throw new w(h);g=g.f()}e=e.ha();a=a.ha();var m=Xu().X();h=un(b,e);b=n=>{if(null!==n){var r=n.h();n=n.j();Q();r=0<=r.length&&r.substring(0,d.length)===d?r.substring(d.length):r;r=XO(r,d,m);return G(new H,n,r)}throw new w(n);};if(h===u())b=u();else{e=h.e();g=e=new z(b(e),u());for(h=h.f();h!==u();)l=h.e(),l=new z(b(l),
+u()),g=g.p=l,h=h.f();b=e}e=Su();g=op().ga;e=new Uu(e,g);b=Ov(sv(),b,e);e=m.zr();O();e=new iy(new $O(0,new y(n=>{n|=0;var r=n/26|0;t();n=G(new H,String.fromCharCode(65535&(97+(n%26|0)|0))+(Pe(new E(r),0)?"":""+r),1+n|0);return new L(n)})),e,!0);e=new Ef(e,new y(n=>XO(n,d,m)));a=Bf(a,e);return new aP(b.hy(a),!1,0,c,!1)}YO.prototype.$classData=q({gY:0},!1,"mlscript.ShowCtx$",{gY:1,g:1,l:1});var bP;function vf(){bP||(bP=new YO);return bP}
+function cP(a){var b=!1,c=null;if(a instanceof yo){b=!0;c=a;var d=c.pb;zp()===d&&no()}b&&(d=c.pb,cp()===d&&no());if(b){d=c.pb;var e=c.gb,g=c.hg,h=c.Sg,k=c.Hj,l=c.Di,m=c.Ns,n=c.ei;if(Ap()===d){if(!h.b()&&!h.o().Ra.b())throw Kj("requirement failed: "+h);a=l.K();if(!Pe(new E(a),0))throw Kj("requirement failed: "+l);At(tp(),!k.b());if(!m.b())throw Kj("requirement failed: "+m);if(!ef(n).b())throw Kj("requirement failed: "+n);a=O().c;if(g===u())c=u();else for(c=g.e(),b=c=new z(c.j(),u()),g=g.f();g!==u();)l=
+g.e(),l=new z(l.j(),u()),b=b.p=l,g=g.f();k.b()&&xm("Program reached and unexpected state.");d=new Oo(d,e,c,k.o(),O().c,O().c,O().c,t().d);e=O().c;return G(new H,a,new z(d,e))}}if(b&&(d=c.pb,e=c.gb,k=c.hg,g=c.Sg,b=c.Di,Bp()===d||Fp()===d)){c=g.b()?new Gl(O().c):g.o();g=c.Ra;var r=TE(PE());a=B=>{if(null!==B){var C=B.h(),D=B.j();if(C instanceof L&&(C=C.k,null!==D)){var F=D.yb;D=D.ya;if(null!==F)return B=F.je,D=dP(D,r),B=new Sn(B?(t(),new L(D)):t().d,D),G(new H,C,B)}}if(null!==B&&(C=B.h(),B=B.j(),t().d===
+C&&null!==B&&(D=B.yb,C=B.ya,null!==D&&(B=D.je,C instanceof vl))))return B?(t(),B=el(),B=new L(B)):B=t().d,B=new Sn(B,gl()),G(new H,C,B);xm("Program reached and unexpected state.")};if(g===u())l=u();else for(l=g.e(),m=l=new z(a(l),u()),n=g.f();n!==u();)h=n.e(),h=new z(a(h),u()),m=m.p=h,n=n.f();a=op();a=l.Gb(a.ga).h();if(b===u())b=u();else{m=b.e();n=m=new z(dP(m,r),u());for(b=b.f();b!==u();)h=b.e(),h=new z(dP(h,r),u()),n=n.p=h,b=b.f();b=m}b=b.mf(new Tn(l),Un());l=new vl(e.V);m=e.A();l=Cq(l,m);t();m=
+t().d;n=tm().Cg;h=B=>{if(null!==B){var C=B.h(),D=B.j();if(C instanceof L)return B=C.k,D=new sm(new St(!1,!1,D.yb.Bh),B),G(new H,B,D)}if(null!==B&&(D=B.h(),B=B.j(),t().d===D&&null!==B&&(D=B.ya,D instanceof vl)))return G(new H,D,B);xm("Program reached and unexpected state.")};if(g===u())g=u();else{var v=g.e(),x=v=new z(h(v),u());for(g=g.f();g!==u();){var A=g.e();A=new z(h(A),u());x=x.p=A;g=g.f()}g=v}g=new sm(n,new yl(g));g=G(new H,m,g);m=O().c;c=new Ol(c,new Pl(l,new Gl(new z(g,m))));c=new No(!1,l,
+new fe(c),!0);g=r.ha();if(k===u())k=u();else{l=k.e();m=l=new z(l.j(),u());for(k=k.f();k!==u();)n=k.e(),n=new z(n.j(),u()),m=m.p=n,k=k.f();k=l}d=new Oo(d,e,k,b,O().c,O().c,a,t().d);e=O().c;return G(new H,g,new z(d,new z(c,e)))}if(sy(a))return d=O().c,e=O().c,G(new H,d,new z(a,e));throw new w(a);}
+function eP(a){if(a instanceof Ml){var b=a.gs,c=a.Ml,d=O().c;return new z(b,new z(c,d))}if(a instanceof Fl){var e=a.gg,g=O().c;return new z(e,g)}if(a instanceof vl)return O().c;if(a instanceof Cl){var h=a.ai,k=O().c;return new z(h,k)}if(a instanceof Ol){var l=a.Ej,m=a.Fj,n=O().c;return new z(l,new z(m,n))}if(a instanceof Pl){var r=a.Za,v=a.Qb,x=O().c;return new z(r,new z(v,x))}if(a instanceof Gl){var A=a.Ra;if(A===u())return u();for(var B=A.e(),C=new z(B.j().ya,u()),D=C,F=A.f();F!==u();){var I=F.e(),
+M=new z(I.j().ya,u());D=D.p=M;F=F.f()}return C}if(a instanceof yl){var N=a.ll;if(N===u())return u();for(var P=N.e(),T=new z(P.j().ya,u()),Y=T,Z=N.f();Z!==u();){var S=Z.e(),ea=new z(S.j().ya,u());Y=Y.p=ea;Z=Z.f()}return T}if(a instanceof Ql){var ia=a.Vl,X=a.ml,sa=O().c;return new z(ia,new z(X,sa))}if(a instanceof Rl){var Ja=a.$n,Xa=a.Mm,Fa=O().c;return new z(Ja,new z(Xa,Fa))}if(a instanceof Sl)return a.Dj;if(a instanceof Dl)return O().c;if(a instanceof Tl){var za=a.br,Qa=a.ar,Ma=O().c;return new z(za,
+new z(Qa,Ma))}if(a instanceof Ul){var Ga=a.Sn,ab=a.Hm,Hb=O().c;return new z(Ga,new z(ab,Hb))}if(a instanceof No){var bc=a.oq,yb=a.RM,tb=O().c;return new z(bc,new z(yb,tb))}if(a instanceof Oo){var eb=a.eA,kb=a.gA,Rb=a.cA,Gb=a.fA,vb=O().c,Tb=dl(dl(new z(Rb,vb),Gb),kb);return new z(eb,Tb)}if(a instanceof Vl){var Nb=a.lp,ic=a.mp,Va=O().c;return new z(Nb,new z(ic,Va))}if(a instanceof Wl){var cb=a.Gm,zb=a.Qn,Ub=O().c;return new z(cb,new z(zb,Ub))}if(a instanceof dm){var jb=a.$q,db=a.Zq,ub=O().c;return new z(jb,
+new z(db,ub))}if(a instanceof Xl){var Aa=a.bp,va=a.zs.ha();return new z(Aa,va)}if(a instanceof Zn){var Ra=a.Rb,rb=a.Ch,xb=a.hj.ha(),mc=a.EN,Ha=O().c,Ka=dl(dl(new z(mc,Ha),rb),xb);return new z(Ra,Ka)}if(a instanceof Il)return new z(a.nl,a.np);if(a instanceof Yl){var Oa=a.hp,Na=O().c;return new z(Oa,Na)}if(a instanceof cm){var Da=a.Ys,ta=a.Zs,Ya=O().c;return new z(Da,new z(ta,Ya))}if(a instanceof $l)return new z(a.Yq,a.lt);if(a instanceof Zl){var dc=a.qq,ka=a.$o,ya=O().c;return dl(new z(ka,ya),dc)}if(a instanceof
+Kl){var Sa=a.cp,xc=O().c;return new z(Sa,xc)}if(a instanceof am)return O().c;if(a instanceof Po){var Sb=a.ks,uc=a.js,Lb=O().c;return new z(Sb,new z(uc,Lb))}if(a instanceof bm){var lc=a.Vn,Xb=a.Zo,ec=O().c;return new z(lc,new z(Xb,ec))}if(a instanceof yo){var Ab=a.gb,Ob=a.hg,fb=a.Sg,Wa=a.Di,bb=a.Ns,Ia=a.ei;if(Ob===u())var Ua=u();else{for(var pc=Ob.e(),sc=new z(pc.j(),u()),Ba=sc,ob=Ob.f();ob!==u();){var nc=ob.e(),Ib=new z(nc.j(),u());Ba=Ba.p=Ib;ob=ob.f()}Ua=sc}var vc=fb.ha(),Vb=bb.ha(),fc=O().c,Bc=
+dl(dl(dl(dl(new z(Ia,fc),Vb),Wa),vc),Ua);return new z(Ab,Bc)}if(a instanceof em){var Pb=a.Iq,Jb=O().c;return new z(Pb,Jb)}if(a instanceof fm){var gc=a.jt,Cb=O().c;return new z(gc,Cb)}throw new w(a);}
+function Mx(a){if(a instanceof Po){var b=a.js;return"constructor("+Yz(a.ks)+") "+Zz(b,!1)}if(a instanceof Pm)return Zz(a,!1);if(a instanceof fP){a:{var c=!1;b=null;if(a instanceof No){c=!0;b=a;var d=b.oq;if(!0===b.ls){b="rec def "+Zz(d,!1);break a}}if(c&&(c=b.oq,!1===b.ls)){b="def "+Zz(c,!1);break a}if(a instanceof Oo){var e=a.gA;b=a.fA;c=a.dA.ld;d=a.eA.V;if(e.b())var g="";else{if(e===u())g=u();else{g=e.e();var h=g=new z(g.V,u());for(e=e.f();e!==u();){var k=e.e();k=new z(k.V,u());h=h.p=k;e=e.f()}}g=
+ze(g,"[",", ","]")}b=c+" "+d+g+(b.b()?"":ze(b,"(",", ",")"))}else throw new w(a);}c=a instanceof Oo&&Ot(new E(a.dA),Ap())?" \x3d ":": ";b+=c;if(a instanceof No)if(a=a.vu,a instanceof Ud)a=VO(a.fa,!0);else{if(!(a instanceof fe))throw new w(a);a=Zz(a.aa,!1)}else if(a instanceof Oo)a=VO(a.cA,!0);else throw new w(a);return b+a}if(a instanceof Ct){b=fea(a);if(a instanceof Zn)c=a.Yc.TJ()?" \x3d ":": ";else{if(!(a instanceof yo))throw new w(a);c=" "}b+=c;if(a instanceof Zn)if(a=a.Yc,a instanceof Ud)a=VO(a.fa,
+!0);else{if(!(a instanceof fe))throw new w(a);a=Zz(a.aa,!1)}else if(a instanceof yo)a=gP(a.ei);else throw new w(a);return b+a}throw new w(a);}function dP(a,b){a=Qn(a);if(a instanceof fe)return b.$(a.aa),gl();if(a instanceof Ud)return a.fa;throw new w(a);}
+function hea(a){if(a instanceof Tn){var b=a.Xs;if(b===u())return u();var c=b.e();a=c=new z(c.h().x,u());for(b=b.f();b!==u();){var d=b.e();d=new z(d.h().x,u());a=a.p=d;b=b.f()}return c}if(a instanceof hP)return c=a.Bs,a=yn(a.As),c=yn(c),un(a,c);if(a instanceof iP||a instanceof Wt||a instanceof jP||a instanceof kP||a instanceof lP||a instanceof mP||a instanceof nP||gl()===a||el()===a||a instanceof oP||a instanceof jt||a instanceof pP||a instanceof Ep||a instanceof qP||a instanceof rP||a instanceof sP||
+a instanceof Vt||a instanceof tP)return O().c;throw new w(a);}
+function iea(a){if(a instanceof Ep){a=a.V;var b=O().c;return new z(a,b)}if(a instanceof pP&&(b=a.Gw,null!==b))return a=b.V,b=O().c,new z(a,b);if(a instanceof hP)return b=a.Bs,a=zn(a.As),b=zn(b),un(a,b);if(a instanceof iP||a instanceof Wt||a instanceof Tn||a instanceof jP||a instanceof kP||a instanceof lP||a instanceof mP||a instanceof nP||gl()===a||el()===a||a instanceof Vt||a instanceof oP||a instanceof jt||a instanceof qP||a instanceof rP||a instanceof sP||a instanceof tP)return O().c;throw new w(a);
+}function VO(a,b){vf();var c=O().c;b=wf(0,new z(a,c),b,"'");return yf(a,0,b)}function uP(a,b){return b?"("+a+")":a}
+function vP(a,b){if(null!==a){var c=a.Yf,d=a.Rg;if(t().d===c)return yf(d,0,b)}if(null!==a&&(c=a.Yf,d=a.Rg,c instanceof L&&Pe(new E(c.k),d)))return yf(d,0,b);if(null!==a&&(d=a.Yf,c=a.Rg,d instanceof L&&(d=d.k,el()===d)))return"out "+yf(c,0,b);if(null!==a&&(d=a.Yf,c=a.Rg,d instanceof L&&(d=d.k,gl()===c)))return"in "+yf(d,0,b);if(null!==a&&(c=a.Yf,d=a.Rg,c instanceof L))return"in "+yf(c.k,0,b)+" out "+yf(d,0,b);throw new w(a);}
+function wP(a,b){var c=h=>{var k=h.j().Yf.b()?"":"mut ",l=h.h();l=l.b()?"":l.o().x+": ";return k+l+vP(h.j(),b)};if(a===u())return u();var d=a.e(),e=d=new z(c(d),u());for(a=a.f();a!==u();){var g=a.e();g=new z(c(g),u());e=e.p=g;a=a.f()}return d}
+var yf=function xP(a,b,c){var e=!1,g=null,h=!1,k=null,l=!1,m=null,n=!1,r=null,v=!1,x=null;if(gl()===a)return"anything";if(el()===a)return"nothing";if(a instanceof Ep)return a.V;if(a instanceof sP)return"#"+a.nA;if(a instanceof jt)return HA(c.kp,a);if(a instanceof nP){var A=a.Mx;return uP(xP(a.Lx,2,c)+" with "+xP(A,0,c),1<b)}if(a instanceof Wt){e=!0;g=a;var B=g.ps,C=g.qs;if(B instanceof jP){var D=B.Mu;a:{var F=O().c;if(null===F?null===D:F.i(D))var I="()";else{if(D instanceof z){var M=D.z,N=D.p;if(null!==
+M){var P=new L(M);if(!P.b()){var T=P.k.h(),Y=P.k.j();if(t().d===T&&null!==Y){var Z=Y.Yf,S=Y.Rg;if(t().d===Z)var ea=O().c,ia=(null===ea?null===N:ea.i(N))?!(S instanceof jP):!1;else ia=!1;if(ia){I=xP(S,31,c);break a}}}}}var X=wP(D,c);I=c.fi?ze(X,"(",", ",")"):ze(X,"(",", ",",)")}}return uP(I+" -\x3e "+xP(C,30,c),30<b)}}if(e){var sa=g.ps,Ja=g.qs;if(c.fi)return uP("(..."+xP(sa,0,c)+") -\x3e "+xP(Ja,30,c),30<b)}if(e){var Xa=g.qs;return uP(xP(g.ps,31,c)+" -\x3e "+xP(Xa,30,c),30<b)}if(a instanceof kP)return"~"+
+xP(a.cx,100,c);if(a instanceof Tn){var Fa=a.Xs,za=Ac=>{var Ve=Ac.h().x;if(hB(ve(),Ve)){Ac=Ac.j();if(null!==Ac){var Td=Ac.Yf,lf=Ac.Rg;a:if(t().d===Td)Td=!0;else{if(Td instanceof L&&(Td=Td.k,el()===Td)){Td=!0;break a}Td=!1}if(Td&&gl()===lf)return""+Ve}if(null!==Ac&&(lf=Ac.Yf,Td=Ac.Rg,lf instanceof L&&Pe(new E(lf.k),Td)))return Ve+" \x3d "+xP(Td,0,c);if(null!==Ac){Td=Ac.Yf;lf=Ac.Rg;a:if(t().d===Td)Td=!0;else{if(Td instanceof L&&(Td=Td.k,el()===Td)){Td=!0;break a}Td=!1}if(Td)return Ve+" \x3c: "+xP(lf,
+0,c)}if(null!==Ac&&(Td=Ac.Yf,lf=Ac.Rg,Td instanceof L&&(Td=Td.k,gl()===lf)))return Ve+" :\x3e "+xP(Td,0,c);if(null!==Ac&&(lf=Ac.Yf,Td=Ac.Rg,lf instanceof L))return Ve+" :\x3e "+xP(lf.k,0,c)+" \x3c: "+xP(Td,0,c);throw new w(Ac);}return(Ac.j().Yf.b()?"":"mut ")+Ve+": "+vP(Ac.j(),c)};if(Fa===u())var Qa=u();else{for(var Ma=Fa.e(),Ga=new z(za(Ma),u()),ab=Ga,Hb=Fa.f();Hb!==u();){var bc=Hb.e(),yb=new z(za(bc),u());ab=ab.p=yb;Hb=Hb.f()}Qa=Ga}for(var tb=0,eb=Qa;!eb.b();){var kb=tb,Rb=eb.e();tb=(kb|0)+Rb.length|
+0;eb=eb.f()}if(80<(tb|0)){ve();var Gb="{\n"+yP(c),vb=",\n"+yP(c),Tb=ze(Qa,Gb,vb,"");return ada(Tb)+"\n"+yP(c)+"}"}return ze(Qa,"{",", ","}")}if(a instanceof rP){var Nb=a.Ax,ic=Ac=>{if(Ac instanceof fe)return"..."+xP(Ac.aa,0,c);if(Ac instanceof Ud)return""+vP(Ac.fa,c);throw new w(Ac);};if(Nb===u())var Va=u();else{for(var cb=Nb.e(),zb=new z(ic(cb),u()),Ub=zb,jb=Nb.f();jb!==u();){var db=jb.e(),ub=new z(ic(db),u());Ub=Ub.p=ub;jb=jb.f()}Va=zb}return c.fi?ze(Va,"[",", ","]"):ze(Va,"(",", ",")")}if(a instanceof
+jP){var Aa=a.Mu,va=wP(Aa,c);if(c.fi)return ze(va,"[",", ","]");var Ra=Aa.b()?")":",)";return ze(va,"(",", ",Ra)}a:{if(a instanceof iP){var rb=a.ht,xb=a.it;if(rb instanceof Ep&&"true"===rb.V&&xb instanceof Ep&&"false"===xb.V){var mc=!0;break a}}if(a instanceof iP){var Ha=a.ht,Ka=a.it;if(Ha instanceof Ep&&"false"===Ha.V&&Ka instanceof Ep&&"true"===Ka.V){mc=!0;break a}}mc=!1}if(mc){var Oa=new Ep("bool");return xP(Oa,0,c)}if(a instanceof cl){var Na=a.Yo?20:25,Da=a.Yo?" | ":" \x26 ",ta=a.Jw?a.Kw:zP(a),
+Ya=O().c;if(null===Ya?null===ta:Ya.i(ta)){var dc=a.Yo?el():gl();return xP(dc,b,c)}if(ta instanceof z){var ka=ta.z,ya=ta.p,Sa=O().c;if(null===Sa?null===ya:Sa.i(ya))return xP(ka,b,c)}var xc=(a.Jw?a.Kw:zP(a)).m(),Sb=new Ef(xc,new y(Ac=>xP(Ac,Na,c)));if(!Sb.s())throw nv("empty.reduceLeft");for(var uc=!0,Lb=null;Sb.s();){var lc=Sb.t();uc?(Lb=lc,uc=!1):Lb=Lb+Da+lc}return uP(Lb,b>Na)}if(a instanceof mP){h=!0;k=a;var Xb=k.Bi,ec=k.Ci;if(el()===Xb&&gl()===ec)return"?"}if(h){var Ab=k.Bi;if(Pe(new E(Ab),k.Ci))return xP(Ab,
+b,c)}if(h){var Ob=k.Bi,fb=k.Ci;if(el()===Ob)return"out "+xP(fb,0,c)}if(h){var Wa=k.Bi,bb=k.Ci;if(gl()===bb)return"in "+xP(Wa,0,c)}if(h){var Ia=k.Ci;return"in "+xP(k.Bi,0,c)+" out "+xP(Ia,0,c)}if(a instanceof pP){var Ua=a.Hw,pc=a.Gw.V;if(Ua===u())var sc=u();else{for(var Ba=Ua.e(),ob=new z(xP(Ba,0,c),u()),nc=ob,Ib=Ua.f();Ib!==u();){var vc=Ib.e(),Vb=new z(xP(vc,0,c),u());nc=nc.p=Vb;Ib=Ib.f()}sc=ob}return""+pc+ze(sc,c.Jq?"\x3c":"[",", ",c.Jq?"\x3e":"]")}if(a instanceof tP){var fc=a.wx;return xP(a.vx,
+100,c)+"."+fc.V}if(a instanceof lP){var Bc=a.Zz,Pb=xP(a.tx,90,c);if(Bc===u())var Jb=u();else{for(var gc=Bc.e(),Cb=new z("\\"+gc.x,u()),cc=Cb,yc=Bc.f();yc!==u();){var Mc=yc.e(),qc=new z("\\"+Mc.x,u());cc=cc.p=qc;yc=yc.f()}Jb=Cb}return""+Pb+ze(Jb,"","","")}if(a instanceof oP){l=!0;m=a;var oc=m.Es;if(oc instanceof Em)return oc.rq.u()}if(l){var Qc=m.Es;if(Qc instanceof Fm)return Qc.uu.gd.u()}if(l){var jc=m.Es;if(jc instanceof Dm)return'"'+jc.Lu+'"'}if(l){var sb=m.Es;if(sb instanceof Gm)return sb.Xq?c.fi?
+"()":"undefined":"null"}if(a instanceof Vt){n=!0;r=a;var Gc=r.Ws,Wb=r.Vs,Cc=O().c;if(null===Cc?null===Gc:Cc.i(Gc))return xP(Wb,b,c)}if(n){var Fc=r.Vs,qd=r.Ws.m(),Yb=new Ef(qd,new y(Ac=>{if(Ac instanceof Ud)return xP(Ac.fa,0,c);if(!(Ac instanceof fe))throw new w(Ac);return Ac.aa.V}));return uP(ze(Yb,"forall "," ",".")+" "+xP(Fc,0,c),1<b)}if(a instanceof qP){var Nc=a.Lw,ad=a.Mw,Uc=a.Nw;Q();var cd=xP(Nc,0,c),kc=zf(cd),Vc=uH(Q(),kc,10),Hc=Vc?AP(c):AP(AP(c)),rc=yP(c),sd=Ac=>{if(null!==Ac){var Ve=Ac.h(),
+Td=Ac.j();if(null!==Td){var lf=Td.Bi;Td=Td.Ci;if(el()===lf)return"\n"+yP(Hc)+HA(Hc.kp,Ve)+" \x3c: "+xP(Td,0,Hc)}}if(null!==Ac&&(Ve=Ac.h(),Td=Ac.j(),null!==Td&&(lf=Td.Bi,Td=Td.Ci,gl()===Td)))return"\n"+yP(Hc)+HA(Hc.kp,Ve)+" :\x3e "+xP(lf,0,Hc);if(null!==Ac&&(Ve=Ac.h(),lf=Ac.j(),null!==lf&&(Td=lf.Bi,Pe(new E(Td),lf.Ci))))return"\n"+yP(Hc)+HA(Hc.kp,Ve)+" :\x3d "+xP(Td,0,Hc);if(null!==Ac&&(Ve=Ac.h(),lf=Ac.j(),null!==lf))return Ac=lf.Bi,lf=lf.Ci,Ve=HA(Hc.kp,Ve),"\n"+yP(Hc)+Ve+" :\x3e "+xP(Ac,0,Hc)+("\n"+
+yP(Hc)+ut(Q()," ",Ve.length)+" \x3c: ")+xP(lf,0,Hc);throw new w(Ac);};if(ad===u())var Kc=u();else{for(var Qd=ad.e(),Ad=new z(sd(Qd),u()),kd=Ad,Hd=ad.f();Hd!==u();){var Rd=Hd.e(),Bd=new z(sd(Rd),u());kd=kd.p=Bd;Hd=Hd.f()}Kc=Ad}var ae=ze(Kc,"","",""),dd=Ac=>{if(null!==Ac){var Ve=Ac.Bi;Ac=Ac.Ci;return"\n"+yP(Hc)+xP(Ve,0,Hc)+" \x3c: "+xP(Ac,0,Hc)}throw new w(Ac);};if(Uc===u())var od=u();else{for(var Ta=Uc.e(),wb=new z(dd(Ta),u()),$a=wb,wa=Uc.f();wa!==u();){var hb=wa.e(),ra=new z(dd(hb),u());$a=$a.p=ra;
+wa=wa.f()}od=wb}return uP(kc+"\n"+rc+(Vc?"":"  ")+"where"+ae+ze(od,"","",""),0<b)}if(a instanceof Zn){var wc=a.wd,ac=a.Rb,Id=a.hj,ud=a.Ch,be=a.Yc,re=a.Om.b()?"":"mut ",pe=!1,bd=null;a:{if(wc instanceof L&&(pe=!0,bd=wc,!1===!!bd.k)){var Rc=a.Pl?"val":"let";break a}if(pe&&!0===!!bd.k)a.Pl&&xm("Program reached and unexpected state."),Rc="let rec";else if(t().d===wc)Rc="fun";else throw new w(wc);}var Wc=Id.b()?"":" ("+Id.o().x+")",Wd=ac.x;if(ud===u())var zd=u();else{for(var Pa=ud.e(),Db=new z(xP(Pa,0,
+c),u()),Oc=Db,Tc=ud.f();Tc!==u();){var Sd=Tc.e(),Jc=new z(xP(Sd,0,c),u());Oc=Oc.p=Jc;Tc=Tc.f()}zd=Db}var vd=BF(GF(),zd);if(be instanceof fe)var hd=" \x3d ...";else{if(!(be instanceof Ud))throw new w(be);hd=": "+xP(be.fa,0,c)}return re+Rc+Wc+" "+Wd+vd+hd}if(a instanceof BP){var de=a.yx,ye=a.aA,jf=Ac=>""+yP(c)+xP(Ac,0,c)+"\n";if(de===u())var af=u();else{for(var pf=de.e(),kf=new z(jf(pf),u()),Be=kf,Kd=de.f();Kd!==u();){var ld=Kd.e(),Jd=new z(jf(ld),u());Be=Be.p=Jd;Kd=Kd.f()}af=kf}if(ye instanceof L)var Dd=
+ye.k,Xd=""+yP(c)+xP(Dd,0,c)+"\n",Yc=O().c,Ce=new z(Xd,Yc);else{if(t().d!==ye)throw new w(ye);Ce=O().c}var te=dl(Ce,af);return ze(te,"","","")}if(a instanceof yo){v=!0;x=a;var Ie=x.pb,Jf=x.gb,df=x.hg,vg=x.Sg,wg=x.Qm,xg=x.Hj,eg=x.Di,vh=x.mx,fg=x.Ns,ih=x.ei;if(Ap()===Ie){if(!vg.b())throw new Yj("assertion failed: "+vg);if(!wg.b())throw new Yj("assertion failed: "+wg);if(!eg.b())throw new Yj("assertion failed: "+eg);if(!vh.b())throw new Yj("assertion failed: "+vh);if(!fg.b())throw new Yj("assertion failed: "+
+fg);if(!ef(ih).b())throw new Yj("assertion failed: "+ih);var Ig=Jf.V;if(df===u())var Tf=u();else{for(var Jg=df.e(),jh=new z(xP(Jg.j(),0,c),u()),yg=jh,gg=df.f();gg!==u();){var Cf=gg.e(),Uf=new z(xP(Cf.j(),0,c),u());yg=yg.p=Uf;gg=gg.f()}Tf=jh}var $g=BF(GF(),Tf);xg.b()&&xm("Program reached and unexpected state.");var Ah=xg.o();return"type "+Ig+$g+" \x3d "+xP(Ah,0,c)}}if(v){var Kg=x.pb,Vf=x.gb,hg=x.hg,zg=x.Sg,Lg=x.Hj,Mg=x.Di,Wf=x.mx,Ng=x.Ns,Kf=x.ei,xf=AP(c),Og=x.fl;if(Og.b())var mi="";else Og.o(),mi=
+"declare ";var Ci=x.Pm;if(Ci.b())var Xh="";else Ci.o(),Xh="abstract ";var wh=Kg.ld,Bh=Vf.V;if(hg===u())var ng=u();else{for(var kh=hg.e(),Kh=new z(xP(kh.j(),0,c),u()),ni=Kh,Lh=hg.f();Lh!==u();){var lh=Lh.e(),Ch=new z(xP(lh.j(),0,c),u());ni=ni.p=Ch;Lh=Lh.f()}ng=Kh}var Dh=BF(GF(),ng);a:{if(zg instanceof L){var Yh=zg.k;if(null!==Yh){var ah=Yh.Ra,oi=Ac=>{if(null!==Ac){var Ve=Ac.h(),Td=Ac.j();if(t().d===Ve&&null!==Td&&(Td=Td.ya,Td instanceof Cl&&(Ve=Td.ai,Td=Td.Fm,Ve instanceof vl)))return Ve.x+": "+xP(Td,
+0,c)}null!==Ac&&(Ve=Ac.h(),(t().d===Ve||Ve instanceof L)&&xm("ill-formed type definition parameter"));throw new w(Ac);};if(ah===u())var mj=u();else{for(var wd=ah.e(),ge=new z(oi(wd),u()),De=ge,qf=ah.f();qf!==u();){var og=qf.e(),Xf=new z(oi(og),u());De=De.p=Xf;qf=qf.f()}mj=ge}var mh="("+ze(mj,"",", ","")+")";break a}}mh=""}if(Lg.b())var Ag="";else{var Bg=Lg.o();Ag=": "+xP(Bg,0,xf)}var Eh=O().c;if(null===Eh?null===Mg:Eh.i(Mg))var Pg="";else{var Di=Mg.m(),Mh=new Ef(Di,new y(Ac=>Zz(Ac,!1)));Pg=" extends "+
+ze(Mh,"",", ","")}if(ef(Kf).b()&&Wf.b()&&Ng.b())var pi="";else{if(Wf.b())var Xi="";else{var Qg=Wf.o();Xi=yP(xf)+"super: "+xP(Qg,0,xf)+"\n"}if(Ng.b())var nh="";else{var bh=Ng.o();nh=yP(xf)+"this: "+xP(bh,0,xf)+"\n"}var Mj=Wn(ef(Kf),new CP(a,xf)),Nj=ze(Mj,"","",""),ie=new BP(Wn(ef(Kf),new DP(a)),t().d);pi=" {\n"+Xi+nh+Nj+xP(ie,0,xf)+yP(c)+"}"}return mi+Xh+wh+" "+Bh+Dh+mh+Ag+Pg+pi}throw new w(a);};
+function EP(a){if(a instanceof FP)return O().c;if(a instanceof Wt){var b=a.ps,c=a.qs,d=O().c;return new z(b,new z(c,d))}if(a instanceof mP){var e=a.Bi,g=a.Ci,h=O().c;return new z(e,new z(g,h))}if(a instanceof kP){var k=a.cx,l=O().c;return new z(k,l)}if(a instanceof Tn){for(var m=a.Xs,n=null,r=null;m!==u();){for(var v=m.e(),x=v.j().Yf.ha(),A=v.j().Rg,B=O().c,C=un(x,new z(A,B)).m();C.s();){var D=new z(C.t(),u());null===r?n=D:r.p=D;r=D}m=m.f()}return null===n?u():n}if(a instanceof jP){for(var F=a.Mu,
+I=null,M=null;F!==u();){for(var N=F.e(),P=iu(ju(),N.j().Yf),T=N.j().Rg,Y=O().c,Z=P.tl(new z(T,Y)).m();Z.s();){var S=new z(Z.t(),u());null===M?I=S:M.p=S;M=S}F=F.f()}return null===I?u():I}if(a instanceof iP){var ea=a.ht,ia=a.it,X=O().c;return new z(ea,new z(ia,X))}if(a instanceof hP){var sa=a.As,Ja=a.Bs,Xa=O().c;return new z(sa,new z(Ja,Xa))}if(a instanceof pP)return a.Hw;if(a instanceof tP){var Fa=a.vx,za=a.wx,Qa=O().c;return new z(Fa,new z(za,Qa))}if(a instanceof lP){var Ma=a.tx,Ga=O().c;return new z(Ma,
+Ga)}if(a instanceof nP){var ab=a.Lx,Hb=a.Mx,bc=O().c;return new z(ab,new z(Hb,bc))}if(a instanceof Vt){var yb=a.Ws,tb=a.Vs,eb=oc=>{if(oc instanceof Ud)oc=oc.fa;else{if(!(oc instanceof fe))throw new w(oc);oc=oc.aa}return oc};if(yb===u())var kb=u();else{for(var Rb=yb.e(),Gb=new z(eb(Rb),u()),vb=Gb,Tb=yb.f();Tb!==u();){var Nb=Tb.e(),ic=new z(eb(Nb),u());vb=vb.p=ic;Tb=Tb.f()}kb=Gb}return Xq(kb,tb)}if(a instanceof rP){for(var Va=a.Ax,cb=null,zb=null;Va!==u();){var Ub=Va.e();if(Ub instanceof fe)var jb=
+Ub.aa,db=O().c,ub=new z(jb,db);else{if(!(Ub instanceof Ud))throw new w(Ub);var Aa=Ub.fa,va=Aa.Yf.ha(),Ra=Aa.Rg,rb=O().c;ub=un(va,new z(Ra,rb))}for(var xb=ub.m();xb.s();){var mc=new z(xb.t(),u());null===zb?cb=mc:zb.p=mc;zb=mc}Va=Va.f()}return null===cb?u():cb}if(a instanceof qP){for(var Ha=a.Lw,Ka=a.Nw,Oa=a.Mw,Na=null,Da=null;Oa!==u();){for(var ta=Oa.e(),Ya=ta.h(),dc=ta.j(),ka=O().c,ya=new Om(new z(Ya,new z(dc,ka)));ya.s();){var Sa=new z(ya.t(),u());null===Da?Na=Sa:Da.p=Sa;Da=Sa}Oa=Oa.f()}for(var xc=
+null===Na?u():Na,Sb=Ka,uc=null,Lb=null;Sb!==u();){for(var lc=Sb.e(),Xb=lc.Bi,ec=lc.Ci,Ab=O().c,Ob=new Om(new z(Xb,new z(ec,Ab)));Ob.s();){var fb=new z(Ob.t(),u());null===Lb?uc=fb:Lb.p=fb;Lb=fb}Sb=Sb.f()}var Wa=dl(null===uc?u():uc,xc);return new z(Ha,Wa)}if(a instanceof BP){var bb=a.yx;return dl(a.aA.ha(),bb)}if(a instanceof Zn){var Ia=a.Ch;return dl(GP(a.Yc).ha(),Ia)}if(a instanceof yo){var Ua=a.hg,pc=a.Sg,sc=a.Hj,Ba=a.mx,ob=a.Ns,nc=a.ei;if(Ua===u())var Ib=u();else{for(var vc=Ua.e(),Vb=new z(vc.j(),
+u()),fc=Vb,Bc=Ua.f();Bc!==u();){var Pb=Bc.e(),Jb=new z(Pb.j(),u());fc=fc.p=Jb;Bc=Bc.f()}Ib=Vb}var gc=Wn((pc.b()?new Gl(O().c):pc.o()).Ra,new HP(a)),Cb=sc.ha(),cc=Ba.ha(),yc=ob.ha(),Mc=new BP(Wn(ef(nc),new IP(a)),t().d),qc=O().c;return dl(dl(dl(dl(dl(new z(Mc,qc),yc),cc),Cb),gc),Ib)}throw new w(a);}
+var jea=function JP(a,b,c,d){var g=DB(b);if(g instanceof lx)return tp(),a=c.Ig(g.Xa),gq(G(new H,a,g));if(g instanceof LA){var h=g.ic;b=g.jc;if(Pe(new E(g.tc),d.tc))return g=JP(a,h,c,d),a=JP(a,b,c,d),g.Ce(a);tp();a=t().d;return gq(G(new H,a,g))}tp();g=t().d;return gq(G(new H,g,b))};function BB(a,b,c,d,e,g){this.mA=this.kA=this.lA=this.Pu=this.bt=this.Lq=this.Vq=this.yA=null;if(null===a)throw null;this.Lq=a;this.bt=c;this.Pu=d;this.lA=e;this.kA=g;this.mA=b;FD(this,a,b)}BB.prototype=new HD;
+BB.prototype.constructor=BB;
+BB.prototype.Tb=function(a,b){var c=this.Lq.qa,d=this.Lq;if(d.F){var e=ut(Q(),"| ",d.r)+("analyze2["+a+"] ")+b;ff(gf(),e+"\n")}d.r=1+d.r|0;try{if(b instanceof lx){var g=a.Ig(b.Xa);if(g instanceof L){var h=!!g.k;this.bt.oh(G(new H,h,b))&&LB(this.Lq,b,a,h,this.lA,this.kA,this.mA,this.bt,this.Pu)}else if(t().d===g){if(this.bt.oh(G(new H,!0,b))){var k=this.Lq,l=new RB(a,b.Xa,!0);LB(k,b,l,!0,this.lA,this.kA,this.mA,this.bt,this.Pu)}if(this.bt.oh(G(new H,!1,b))){var m=this.Lq,n=new RB(a,b.Xa,!1);LB(m,b,
+n,!1,this.lA,this.kA,this.mA,this.bt,this.Pu)}}else throw new w(g);}else if(b instanceof LA){var r=jea(this,b,a,b),v=this.Lq;if(v.F){var x=ut(Q(),"| ",v.r)+"Components "+r;ff(gf(),x+"\n")}if(this.Pu.oh(r))LB(this.Lq,b,a,b.tc,this.lA,this.kA,this.mA,this.bt,this.Pu);else{var A=this.Lq;if(A.F){var B=ut(Q(),"| ",A.r)+"Found in "+this.Pu;ff(gf(),B+"\n")}}}else GD.prototype.Tb.call(this,a,b);var C=void 0}finally{d.r=-1+d.r|0}dx(new E(c),d.qa)&&d.F&&(a=""+ut(Q(),"| ",d.r)+c.n(C),ff(gf(),a+"\n"))};
+BB.prototype.$classData=q({HY:0},!1,"mlscript.TypeSimplifier$Analyze2$1$",{HY:1,kP:1,g:1});
+function KP(a){this.Dx=this.Kj=null;if(null===a)throw null;this.Dx=a;var b=t().d,c=Xu(),d=a.nP.m();c=c.Ib(new Ef(d,new y(x=>{var A=x.h();x=new qx(this.Dx,x.j(),new vl(x.h()));return G(new H,A,x)})));d=Xu().X();var e=a.Gd,g=Xu().X(),h=new MB;tp();var k=a.XE;if(k===u())var l=u();else{l=k.e();var m=l=new z(G(new H,l.Wl.V,l),u());for(k=k.f();k!==u();){var n=k.e();n=new z(G(new H,n.Wl.V,n),u());m=m.p=n;k=k.f()}}l=pp(0,l);m=Xu().X();k=t().d;n=Hw();var r=Su(),v=op().ga;this.Kj=new Iw(a,b,c,d,e,g,h,!1,!1,
+l,m,k,n.Hd(new Uu(r,v)));mf(this)}KP.prototype=new p;KP.prototype.constructor=KP;
+function mf(a){if(a.Dx.$c){var b=Xu(),c=a.Dx.qP,d=k=>{var l=new fx(a.Dx,k,nf(),a.Kj,new y(r=>{xm(r.pq)})),m=a.Kj.hc,n=G(new H,k.gb.V,l);m.$(n);return G(new H,k.gb.V,l)};if(c===u())d=u();else{var e=c.e(),g=e=new z(d(e),u());for(c=c.f();c!==u();){var h=c.e();h=new z(d(h),u());g=g.p=h;c=c.f()}d=e}b=b.Ib(d);b=new Iw(a.Kj.S,a.Kj.Ec,a.Kj.hc,a.Kj.Ed,a.Kj.da,a.Kj.Pc,a.Kj.Zc,a.Kj.Lb,a.Kj.yc,a.Kj.tb,b,a.Kj.od,a.Kj.cb);d=new y(k=>{throw k;});for(e=b.$a.ie();e.s();)g=e.t(),h=Kx(g,d),g=b.hc,c=h.Ua(),h=new ix(a.Dx,
+h),c=G(new H,c,h),g.$(c);return b}return a.Kj}KP.prototype.$classData=q({PY:0},!1,"mlscript.Typer$Ctx$",{PY:1,g:1,l:1});function LP(){this.io=this.ho=this.jo=null;this.Fp=this.Gp=this.an=this.Ep=0;this.qa=null;this.r=0;this.zk=this.Pq=this.Uq=this.xp=this.Bp=this.Cp=this.Sq=this.zp=this.Rq=this.wp=this.Ap=this.yp=this.Qq=this.Tq=null;this.Dp=0}LP.prototype=new NC;LP.prototype.constructor=LP;function MP(){}MP.prototype=LP.prototype;function tx(a){null===a.Tq&&null===a.Tq&&(a.Tq=new NP(a))}
+function zx(a){null===a.yp&&null===a.yp&&(a.yp=new OP(a));return a.yp}function kea(a){null===a.Ap&&null===a.Ap&&(a.Ap=new EC(a));return a.Ap}function vx(a){null===a.wp&&null===a.wp&&(a.wp=new PP(a));return a.wp}function CA(a){null===a.Rq&&null===a.Rq&&(a.Rq=new CC(a))}function xv(a){null===a.zp&&null===a.zp&&(a.zp=new QP(a));return a.zp}function $B(a){null===a.Sq&&null===a.Sq&&(a.Sq=new DC(a))}function cw(a){null===a.Bp&&null===a.Bp&&(a.Bp=new RP(a));return a.Bp}
+function WD(a){null===a.xp&&null===a.xp&&(a.xp=new SP(a));return a.xp}function TP(a){null===a.Uq&&null===a.Uq&&(a.Uq=new IC(a))}function iC(a){null===a.Pq&&null===a.Pq&&(a.Pq=new AC(a))}function UP(a){a.Dp=1+a.Dp|0;return-1+a.Dp|0}function PP(a){this.gO=null;if(null===a)throw null;this.gO=a}PP.prototype=new p;PP.prototype.constructor=PP;function wx(a,b,c){return b.b()?c:new eC(a.gO,b,c)}PP.prototype.$classData=q({cZ:0},!1,"mlscript.TyperDatatypes$ConstrainedType$",{cZ:1,g:1,l:1});
+function SP(a){this.Su=null;if(null===a)throw null;this.Su=a}SP.prototype=new p;SP.prototype.constructor=SP;function XD(a,b,c,d,e){if(null!==b){var g=b.qe;if(!0===b.Qd&&!0===g)return new Uw(a.Su,t().d,a.Su.La,e)}if(null!==b&&(g=b.qe,!0===b.Qd&&!1===g))return new Uw(a.Su,t().d,d,e);if(null!==b&&(g=b.qe,!1===b.Qd&&!0===g))return new Uw(a.Su,(t(),new L(c)),a.Su.La,e);if(null!==b&&(g=b.qe,!1===b.Qd&&!1===g))return new Uw(a.Su,(t(),new L(c)),d,e);throw new w(b);}
+SP.prototype.$classData=q({lZ:0},!1,"mlscript.TyperDatatypes$FieldType$",{lZ:1,g:1,l:1});function VP(){this.J=null}VP.prototype=new HC;VP.prototype.constructor=VP;function WP(){}WP.prototype=VP.prototype;function OP(a){this.sA=null;if(null===a)throw null;this.sA=a}OP.prototype=new p;OP.prototype.constructor=OP;
+function yx(a,b,c){for(;;){At(tp(),b<=a.sA.Df);if(Pe(new E(b),a.sA.Df)||c.Ea()<=b)return c;var d=uy(c);if(d instanceof Qx)c=d.de,d=d.Re,a=zx(a.sA),b=b<c?b:c,c=d;else return new Qx(a.sA,b,c)}}OP.prototype.$classData=q({uZ:0},!1,"mlscript.TyperDatatypes$PolymorphicType$",{uZ:1,g:1,l:1});function QP(a){this.tA=null;if(null===a)throw null;this.tA=a}QP.prototype=new p;QP.prototype.constructor=QP;function wv(a){var b=a.tA,c=O().c;return new Qv(b,c,V(a.tA))}
+function SA(a,b,c){return b.b()?new FA(a.tA,!1,c):new Qv(a.tA,b,c)}QP.prototype.$classData=q({yZ:0},!1,"mlscript.TyperDatatypes$RecordType$",{yZ:1,g:1,l:1});function RP(a){this.Vu=null;if(null===a)throw null;this.Vu=a}RP.prototype=new p;RP.prototype.constructor=RP;function kD(a,b,c,d){for(;;){var e=b,g=c;if(e instanceof cC)b=e.Fg,c=g;else if(g instanceof cC)c=g.Sf,b=e;else return new cC(a.Vu,b,c,d)}}
+function dw(a,b,c,d,e){if(Ot(new E(b),c)||Pe(new E(b),c))e=!0;else{if(pD(b)||pD(c))g=!1;else{g=Xu().X();var g=Zu(b,c,e,!0,g)}g?(g=Xu().X(),e=Zu(c,b,e,!0,g)):e=!1}return e?b:kD(a,b,c,d)}function ew(a){return V(a.Vu)}function tA(a,b,c,d){return Ot(new E(b),c)||Pe(new E(b),c)?b:kD(a,b,c,d)}RP.prototype.$classData=q({GZ:0},!1,"mlscript.TyperDatatypes$TypeBounds$",{GZ:1,g:1,l:1});function XP(){this.q=null}XP.prototype=new p;XP.prototype.constructor=XP;function YP(){}YP.prototype=XP.prototype;
+function ZP(a){this.WO=null;if(null===a)throw null;this.WO=a}ZP.prototype=new p;ZP.prototype.constructor=ZP;ZP.prototype.u=function(){return"TypeRef"};function $P(a,b,c,d){return new fw(a.WO,b,c,d)}ZP.prototype.$classData=q({JZ:0},!1,"mlscript.TyperDatatypes$TypeRef$",{JZ:1,g:1,l:1});function dC(a,b){this.ol=null;this.gt=0;this.wA=this.$m=null;this.QI=0;if(null===a)throw null;this.wA=a;this.QI=b;ZC(this,a.$m,a.ol)}dC.prototype=new aD;dC.prototype.constructor=dC;
+dC.prototype.Ig=function(a){return a>this.QI?(t(),new L(!0)):this.wA.Ig(a)};dC.prototype.Ar=function(a){return a>this.QI?this:this.wA.Ar(a)};dC.prototype.Bw=function(){return this.wA+";Q("+this.wA.gt+")"};dC.prototype.$classData=q({SZ:0},!1,"mlscript.TyperHelpers$PolMap$$anon$1",{SZ:1,OE:1,g:1});function TB(a){this.ol=null;this.gt=0;this.RI=this.$m=null;if(null===a)throw null;this.RI=a;ZC(this,a.$m,t().d)}TB.prototype=new aD;TB.prototype.constructor=TB;TB.prototype.Ig=function(){return t().d};
+TB.prototype.Ar=function(a){return this.RI.Ar(a)};TB.prototype.Bw=function(){return this.RI+";\x3d"};TB.prototype.$classData=q({TZ:0},!1,"mlscript.TyperHelpers$PolMap$$anon$2",{TZ:1,OE:1,g:1});function UB(a){this.ol=null;this.gt=0;this.PE=this.$m=null;if(null===a)throw null;this.PE=a;var b=a.$m;a=a.ol;a.b()?a=R():(a=!!a.o(),a=new L(!a));ZC(this,b,a)}UB.prototype=new aD;UB.prototype.constructor=UB;UB.prototype.Ig=function(a){a=this.PE.Ig(a);if(a.b())return R();a=!!a.o();return new L(!a)};
+UB.prototype.Ar=function(a){return this.PE.Ar(a)};UB.prototype.Bw=function(){return this.PE+";-"};UB.prototype.$classData=q({UZ:0},!1,"mlscript.TyperHelpers$PolMap$$anon$3",{UZ:1,OE:1,g:1});function RB(a,b,c){this.ol=null;this.gt=0;this.QE=this.hP=this.$m=null;this.gP=0;this.xA=!1;if(null===a)throw null;this.QE=a;this.gP=b;this.xA=c;ZC(this,a.$m,a.ol);this.hP=this.Ar(b)}RB.prototype=new aD;RB.prototype.constructor=RB;
+RB.prototype.Ig=function(a){if(a>=this.gP)return t(),new L(this.xA);var b=!1,c=null;a=this.hP.Ig(a);if(a instanceof L&&(b=!0,c=a,!0===!!c.k))return t(),new L(this.xA);if(b&&!1===!!c.k)return t(),new L(!this.xA);if(t().d===a)return t().d;throw new w(a);};RB.prototype.Ar=function(a){return this.QE.Ar(a)};RB.prototype.Bw=function(){var a=this.QE;t();return a+";@["+dA(new L(this.xA))+"]("+this.QE.gt+")"};RB.prototype.$classData=q({VZ:0},!1,"mlscript.TyperHelpers$PolMap$$anon$4",{VZ:1,OE:1,g:1});
+function bD(a,b){this.ol=null;this.gt=0;this.SI=this.$m=null;if(null===a)throw null;this.SI=b;ZC(this,a.iP,b)}bD.prototype=new aD;bD.prototype.constructor=bD;bD.prototype.Ig=function(){return this.SI};bD.prototype.Ar=function(){return this};bD.prototype.Bw=function(){return""+dA(this.SI)};bD.prototype.$classData=q({WZ:0},!1,"mlscript.TyperHelpers$PolMap$$anon$5",{WZ:1,OE:1,g:1});
+function gP(a){a=ef(a).m();a=new Ef(a,new y(b=>{if(b instanceof Pm)return Zz(b,!1);if(b instanceof Ct||b instanceof Po)return Mx(b);xm("Unexpected typing unit entity: "+b)}));return ze(a,"{","; ","}")}function lea(a,b){var c=AP(b),d=ef(a);a=k=>k instanceof Pm?aA(k,!1,c):k instanceof Ct?VO(k,c.fi):b.fi?no():k.u();if(d===u())a=u();else{var e=d.e(),g=e=new z(a(e),u());for(d=d.f();d!==u();){var h=d.e();h=new z(a(h),u());g=g.p=h;d=d.f()}a=e}e="{"+ON(c);g=ON(c);d=ON(b)+"}";return ze(a,e,g,d)}
+function mea(a){var b=Wn(a.Kx,new aQ(a)),c=Aq(Bq(),b),d=a.Kx;a=h=>{if(h instanceof bm){var k=h.Vn,l=h.Zo;if(c.L(k.x))return new Zn(t().d,k,t().d,O().c,(t(),new fe(l)),t().d,t().d,t().d,t().d,t().d,!0,O().c)}return h};if(d===u())return u();b=d.e();var e=b=new z(a(b),u());for(d=d.f();d!==u();){var g=d.e();g=new z(a(g),u());e=e.p=g;d=d.f()}return b}function bQ(){this.Yl=this.AA=this.Zu=this.CP=null;cQ=this;this.CP=new dQ(!0,!0);this.Zu=new dQ(!0,!1);this.AA=new dQ(!1,!0);this.Yl=new dQ(!1,!1)}
+bQ.prototype=new p;bQ.prototype.constructor=bQ;bQ.prototype.$classData=q({g_:0},!1,"mlscript.VarianceInfo$",{g_:1,g:1,l:1});var cQ;function ou(){cQ||(cQ=new bQ);return cQ}function eQ(){}eQ.prototype=new p;eQ.prototype.constructor=eQ;function hr(a,b,c,d){return new Gf(UN(b.e().h(),c),b,d)}eQ.prototype.$classData=q({i_:0},!1,"mlscript.WarningReport$",{i_:1,g:1,l:1});var fQ;function fr(){fQ||(fQ=new eQ);return fQ}function gQ(){this.lf=null}gQ.prototype=new sE;gQ.prototype.constructor=gQ;
+function hQ(){}hQ.prototype=gQ.prototype;function iQ(a){a.fv=jA().X();a.ni=TE(PE());O()}function jQ(){this.ni=this.fv=null}jQ.prototype=new p;jQ.prototype.constructor=jQ;function kQ(){}kQ.prototype=jQ.prototype;function lQ(a){if(a instanceof HE)return"Consequent";if(IE()===a)return"MissingCase";if(a instanceof CE)return"IfThenElse";if(a instanceof DE)return"Match";throw new w(a);}function mQ(a,b,c,d,e){a.dm(b,new y(()=>{}),c,d,e)}function nQ(){this.ga=null;oQ=this;this.ga=new pQ}nQ.prototype=new p;
+nQ.prototype.constructor=nQ;nQ.prototype.$classData=q({U2:0},!1,"scala.$less$colon$less$",{U2:1,g:1,l:1});var oQ;function op(){oQ||(oQ=new nQ);return oQ}function WG(a){a=new (md(la).Ia)(a);yj(Pj(),a,void 0);return a}function qQ(){}qQ.prototype=new p;qQ.prototype.constructor=qQ;
+function rQ(a,b,c){a=b.Q();if(-1<a){c=c.si(a);b=b.m();for(var d=0;d<a;)fH(xG(),c,d,b.t()),d=1+d|0;return c}c=c.uh();d=c===da(td);a=[];for(b=b.m();b.s();){var e=b.t();a.push(d?Ea(e):null===e?c.qi.jz:e)}return md((c===da(pd)?da(la):c===da(jH)||c===da(kH)?da(jd):c).qi).iz(a)}function VG(a,b,c,d,e,g){a=ca(b);if($f(a)&&Zf(ca(d),a))b.wa(c,d,e,g);else for(a=c,c=c+g|0;a<c;)fH(xG(),d,e,XG(xG(),b,a)),a=1+a|0,e=1+e|0}
+function UG(a,b){if(ph(a))return WG(b);if(a instanceof zc)return zj(Pj(),a,b);if(a instanceof Xc)return Fj(Pj(),a,b);if(a instanceof ed){Pj();if(0>b)throw new Aj;var c=a.a.length;c=b<c?b:c;b=new ed(b);a.wa(0,b,0,c);return b}if(a instanceof Zc)return Gj(Pj(),a,b);if(a instanceof $c){Pj();if(0>b)throw new Aj;c=a.a.length;c=b<c?b:c;b=new $c(b);a.wa(0,b,0,c);return b}if(a instanceof Ic)return Hj(Pj(),a,b);if(a instanceof Pc)return Dj(Pj(),a,b);if(a instanceof Sc)return Ej(Pj(),a,b);if(a instanceof Ec)return Ij(Pj(),
+a,b);throw new w(a);}function sQ(a,b,c){if(b===c)return!0;if(b.a.length!==c.a.length)return!1;a=b.a.length;for(var d=0;d<a;){if(!ml(nl(),b.a[d],c.a[d]))return!1;d=1+d|0}return!0}qQ.prototype.$classData=q({W2:0},!1,"scala.Array$",{W2:1,g:1,l:1});var tQ;function SG(){tQ||(tQ=new qQ);return tQ}function uQ(){this.jR=null;vQ=this;this.jR=new jL(ch().IQ);ch()}uQ.prototype=new p;uQ.prototype.constructor=uQ;function gf(){vQ||(vQ=new uQ);return vQ.jR.yR}
+uQ.prototype.$classData=q({Y2:0},!1,"scala.Console$",{Y2:1,g:1,nba:1});var vQ;function wQ(){}wQ.prototype=new mG;wQ.prototype.constructor=wQ;function xQ(){}xQ.prototype=wQ.prototype;function ps(a){return null===a?null:0===a.a.length?(a=yQ(),TG(),a.SL):new zQ(a)}function Ur(a,b){return null!==b?new AQ(b):null}function BQ(){}BQ.prototype=new p;BQ.prototype.constructor=BQ;function iu(a,b){if(b.b())return O().vR.X();O();a=b.o();return new CQ(a)}function zy(a,b,c){return b?new L(Es(c)):R()}
+BQ.prototype.$classData=q({c3:0},!1,"scala.Option$",{c3:1,g:1,l:1});var DQ;function ju(){DQ||(DQ=new BQ);return DQ}function Wk(a){var b=it();return b&&b.$classData&&b.$classData.rb.za?new EQ(a,b):new FQ(a,b)}function GQ(a,b,c){return a.Lc(b)?a.n(b):c.n(b)}function Gs(a){return!!(a&&a.$classData&&a.$classData.rb.E)}function aG(){}aG.prototype=new p;aG.prototype.constructor=aG;aG.prototype.u=function(){return"Some"};aG.prototype.$classData=q({o3:0},!1,"scala.Some$",{o3:1,g:1,l:1});var $F;
+function HQ(){}HQ.prototype=new p;HQ.prototype.constructor=HQ;
+function eda(a,b,c){var d=0,e=0,g=0,h=0,k=-1+b.K()|0;rl();if(0>=k)a=new Xc(0);else{a=new Xc(k);for(var l=0;l<k;)a.a[l]=-1,l=1+l|0}rl();if(0>=k)l=new Xc(0);else{l=new Xc(k);for(var m=0;m<k;)l.a[m]=-1,m=1+m|0}m=c.length;var n=new IQ(k);b.Ca(new y(N=>{n.ve=n.ve+N.length|0}));var r=n.ve,v=new Sc(r),x=new IQ(0),A=new GA(!0);b.Ca(new y(N=>{A.Am?A.Am=!1:(v.a[x.ve]=-1,x.ve=1+x.ve|0);for(var P=N.length,T=0;T<P;){var Y=N.charCodeAt(T);v.a[x.ve]=Y<<16>>16;x.ve=1+x.ve|0;T=1+T|0}}));var B=1+r|0;rl();if(0>=B)var C=
+new Xc(0);else{for(var D=new Xc(B),F=0;F<B;)D.a[F]=-1,F=1+F|0;C=D}var I=new IQ(0),M=new IQ(0);for(b.Ca(new y(N=>{M.ve<k&&(I.ve=I.ve+N.length|0,C.a[I.ve]=M.ve,I.ve=1+I.ve|0,M.ve=1+M.ve|0)}));d<r||e<m;)if(B=C.a[d],-1!==B&&(D=a.a[B],-1===D?D=e:(F=e,D=D<F?D:F),a.a[B]=D,D=l.a[B],-1===D?D=e:(F=e,D=D>F?D:F),l.a[B]=D),d<r?(B=v.a[d],-1===B?(g=d,h=1+e|0,d=1+d|0,B=!0):e<m&&c.charCodeAt(e)===B?(d=1+d|0,e=1+e|0,B=!0):B=!1):B=!1,!B)if(0<h&&h<=m)d=g,e=h;else return R();JQ();b=-1+b.K()|0;if(0>=b)c=new (md(fa).Ia)(0);
+else{d=new (md(fa).Ia)(b);for(e=0;e<b;)g=e,d.a[e]=Of(Q(),c,a.a[g],l.a[g]),e=1+e|0;c=d}return new L(KQ(0,c))}
+function Tq(a,b){a=vH(b,92);if(-1!==a){var c=a;a=b.length;for(var d=0,e=LQ(new Sq);0<=c;){c>d&&MQ(e,b,d,c);d=1+c|0;if(d>=a)throw new NQ(b,c);switch(b.charCodeAt(d)){case 117:c=117;break;case 98:c=8;break;case 116:c=9;break;case 110:c=10;break;case 102:c=12;break;case 114:c=13;break;case 34:c=34;break;case 39:c=39;break;case 92:c=92;break;default:throw new NQ(b,c);}if(117===c)a:for(var g=c=d,h=b.length,k=b;;){if(c>=h)throw new OQ(k,-1+c|0);if(117===k.charCodeAt(c))c=1+c|0;else{b:for(var l=0,m=0;;){if(4<=
+l){c=new PQ(65535&m,(c-g|0)+l|0);break b}if((l+c|0)>=h)throw new OQ(k,c+l|0);var n=k.charCodeAt(l+c|0);n=DH(Pr(),n,36);if(0<=n&&15>=n)m=(m<<4)+n|0,l=1+l|0;else throw new OQ(k,c+l|0);}break a}}else c=new PQ(c,1);if(null===c)throw new w(c);g=c.aQ();d=d+c.Sc()|0;c=String.fromCharCode(g);e.ja=""+e.ja+c;c=d;g=b;h=TL(Pr(),92);g=g.indexOf(h,d)|0;d=c;c=g}d<a&&MQ(e,b,d,a);b=e.ja}return b}HQ.prototype.$classData=q({q3:0},!1,"scala.StringContext$",{q3:1,g:1,l:1});var QQ;
+function Qq(){QQ||(QQ=new HQ);return QQ}q({R4:0},!1,"scala.collection.BuildFromLowPriority2$$anon$11",{R4:1,g:1,Jba:1});function RQ(a,b){this.wn=this.Nc=0;this.wh=null;this.vi=0;this.Do=this.Ok=null;for(JH(this,b.dc);this.s();)b=this.wh.Jb(this.Nc),SQ(a,a.Nr,this.wh.Ef(this.Nc),this.wh.Tf(this.Nc),b,$G(bH(),b),0),this.Nc=1+this.Nc|0}RQ.prototype=new LH;RQ.prototype.constructor=RQ;RQ.prototype.$classData=q({$6:0},!1,"scala.collection.immutable.HashMapBuilder$$anon$1",{$6:1,Vv:1,g:1});
+function TQ(a,b){this.wn=this.Nc=0;this.wh=null;this.vi=0;this.Do=this.Ok=null;for(JH(this,b.Id);this.s();)b=this.wh.Jb(this.Nc),UQ(a,a.Or,this.wh.ed(this.Nc),b,$G(bH(),b),0),this.Nc=1+this.Nc|0}TQ.prototype=new LH;TQ.prototype.constructor=TQ;TQ.prototype.$classData=q({d7:0},!1,"scala.collection.immutable.HashSetBuilder$$anon$1",{d7:1,Vv:1,g:1});function VQ(){}VQ.prototype=new p;VQ.prototype.constructor=VQ;VQ.prototype.u=function(){return"\x3cfunction1\x3e"};VQ.prototype.n=function(){return this};
+VQ.prototype.$classData=q({t7:0},!1,"scala.collection.immutable.List$$anon$1",{t7:1,g:1,la:1});function WQ(){}WQ.prototype=new fI;WQ.prototype.constructor=WQ;function XQ(){}XQ.prototype=WQ.prototype;function YQ(a){this.wn=this.Nc=0;this.wh=null;this.vi=0;this.Do=this.Ok=null;JH(this,a)}YQ.prototype=new LH;YQ.prototype.constructor=YQ;YQ.prototype.$classData=q({Q7:0},!1,"scala.collection.immutable.MapNodeRemoveAllSetNodeIterator",{Q7:1,Vv:1,g:1});function ZQ(){}ZQ.prototype=new p;
+ZQ.prototype.constructor=ZQ;function $Q(a,b,c,d,e){throw Kj(b+(e?" to ":" until ")+c+" by "+d+": seqs cannot contain more than Int.MaxValue elements.");}function aR(a){bR();return AH(a+" on empty Range")}ZQ.prototype.$classData=q({X7:0},!1,"scala.collection.immutable.Range$",{X7:1,g:1,l:1});var cR;function bR(){cR||(cR=new ZQ);return cR}function dR(){this.Uk=null}dR.prototype=new pJ;dR.prototype.constructor=dR;function eR(){}eR.prototype=dR.prototype;
+function fR(a,b,c,d){if(null===b)return nJ(),new sI(c,d,null,null,0);if(Object.is(c,b.Wa))return yJ(b,d);var e=a.Uk.Da(c,b.Wa);return 0>e?tJ(b,fR(a,b.sa,c,d)):0<e?xJ(b,fR(a,b.ta,c,d)):yJ(b,d)}function gR(){this.Uk=null}gR.prototype=new pJ;gR.prototype.constructor=gR;function hR(){}hR.prototype=gR.prototype;function iR(a,b,c){if(null===b)return nJ(),new sI(c,void 0,null,null,0);if(Object.is(c,b.Wa))return b;var d=a.Uk.Da(c,b.Wa);return 0>d?tJ(b,iR(a,b.sa,c)):0<d?xJ(b,iR(a,b.ta,c)):b}
+function jR(){}jR.prototype=new fI;jR.prototype.constructor=jR;function kR(){}kR.prototype=jR.prototype;function lR(a,b){if(b===a)a.zc(PE().vl(b));else for(b=b.m();b.s();)a.$(b.t());return a}function mR(a,b){var c=My(W(),b);c=nR(a,c);return oR(a,b,c)}function oR(a,b,c){for(a=a.bl().a[c];;)if(null!==a?(c=a.BB(),c=!ml(nl(),c,b)):c=!1,c)a=a.Ev();else break;return a}
+function pR(a,b,c){b.ty(a.bl().a[c]);a.bl().a[c]=b;a.hz(1+a.nu()|0);qR(a,c);if(a.nu()>a.pT()){b=a.bl().a.length<<1;c=a.bl();a.gM(new (md($J).Ia)(b));rR(a,a.bl().a.length);for(var d=-1+c.a.length|0;0<=d;){for(var e=c.a[d];null!==e;){var g=e.BB();g=My(W(),g);g=nR(a,g);var h=e.Ev();e.ty(a.bl().a[g]);a.bl().a[g]=e;e=h;qR(a,g)}d=-1+d|0}a.hM(fK(hK(),a.sJ(),b))}}function sR(a,b,c){var d=My(W(),b);d=nR(a,d);var e=oR(a,b,d);if(null!==e)return e;b=a.CJ(b,c);pR(a,b,d);return null}
+function tR(a,b){var c=My(W(),b);c=nR(a,c);return uR(a,b,c)}function uR(a,b,c){var d=a.bl().a[c];if(null!==d){var e=d.BB();if(ml(nl(),e,b))return a.bl().a[c]=d.Ev(),a.hz(-1+a.nu()|0),vR(a,c),d.ty(null),d;for(e=d.Ev();;){if(null!==e){var g=e.BB();g=!ml(nl(),g,b)}else g=!1;if(g)d=e,e=e.Ev();else break}if(null!==e)return d.ty(e.Ev()),a.hz(-1+a.nu()|0),vR(a,c),e.ty(null),e}return null}function qR(a,b){null!==a.lu()&&(a=a.lu(),b>>=5,a.a[b]=1+a.a[b]|0)}
+function vR(a,b){null!==a.lu()&&(a=a.lu(),b>>=5,a.a[b]=-1+a.a[b]|0)}function rR(a,b){if(null!==a.lu())if(b=1+(b>>5)|0,a.lu().a.length!==b)a.$L(new Xc(b));else{a=a.lu();Pj();b=a.a.length;for(var c=0;c!==b;)a.a[c]=0,c=1+c|0}}function nR(a,b){var c=-1+a.bl().a.length|0,d=Math.clz32(c);a=a.kT();OL||(OL=new NL);b=Math.imul(-1640532531,b);UH();b=Math.imul(-1640532531,b<<24|16711680&b<<8|65280&(b>>>8|0)|b>>>24|0);return((b>>>a|0|b<<(-a|0))>>>d|0)&c}
+function wR(a){a.bQ(750);hK();a.gM(new (md($J).Ia)(1<<(-Math.clz32(15)|0)));a.hz(0);var b=a.sJ();hK();hK();a.hM(fK(0,b,1<<(-Math.clz32(15)|0)));a.$L(null);b=a.jT;var c=-1+a.bl().a.length|0;c=nI(UH(),c);b.call(a,c)}function xR(a,b){this.YS=null;this.ju=a;this.Fn=b;this.zm=this.ww=null}xR.prototype=new p;xR.prototype.constructor=xR;xR.prototype.BB=function(){return this.ju};xR.prototype.ty=function(a){this.YS=a};xR.prototype.Ev=function(){return this.YS};
+xR.prototype.$classData=q({e$:0},!1,"scala.collection.mutable.LinkedHashMap$LinkedEntry",{e$:1,g:1,VL:1});function yR(a){this.eT=null;this.zw=a;this.Mo=this.yw=null}yR.prototype=new p;yR.prototype.constructor=yR;yR.prototype.BB=function(){return this.zw};yR.prototype.ty=function(a){this.eT=a};yR.prototype.Ev=function(){return this.eT};yR.prototype.$classData=q({k$:0},!1,"scala.collection.mutable.LinkedHashSet$Entry",{k$:1,g:1,VL:1});function zR(){this.xy=null;AR=this;this.xy=Ai().qM}
+zR.prototype=new p;zR.prototype.constructor=zR;
+function BR(a,b){var c=""+a;a=new mr;nr(a,or(c),c.length);c=b.ds;var d=pr(a)-c|0;if(!(CR(a)<c||0===c||0>=d))if(64>a.$h){c=hN().lz.a[d];var e=c.W,g=c.Y,h=a.xb,k=h>>31,l=d>>31;c=h-d|0;h=(-2147483648^c)>(-2147483648^h)?-1+(k-l|0)|0:k-l|0;d=a.Bg;l=d.W;var m=d.Y;k=xa();d=$h(k,l,m,e,g);k=k.Qc;var n=xa();l=Ri(n,l,m,e,g);m=n.Qc;if(0!==l||0!==m){hN();if(0>m){var r=-l|0;n=0!==l?~m:-m|0}else r=l,n=m;n=new ma(r<<1,r>>>31|0|n<<1);e=new ma(e,g);g=n.Y;r=e.Y;(g===r?(-2147483648^n.W)>(-2147483648^e.W):g>r)?e=1:(g=
+n.Y,r=e.Y,e=(g===r?(-2147483648^n.W)<(-2147483648^e.W):g<r)?-1:0);e=Math.imul(0>m?-1:0===m&&0===l?0:1,5+e|0);e=lN(hN(),1&d,e,b.Fw);g=e>>31;e=d+e|0;d=(-2147483648^e)<(-2147483648^d)?1+(k+g|0)|0:k+g|0;0>d?(k=-e|0,g=0!==e?~d:-d|0):(k=e,g=d);k=cG(xa(),k,g);+Math.log10(k)>=b.ds?(c=-1+c|0,k=-1!==c?h:-1+h|0,h=xa(),d=$h(h,e,d,10,0),c=new ma(c,k),h=new ma(d,h.Qc)):(c=new ma(c,h),h=new ma(e,d))}else c=new ma(c,h),h=new ma(d,k);c=Za(c);d=Za(h);h=Za(new ma(c.W,c.Y));c=h.W;h=h.Y;k=Za(new ma(d.W,d.Y));d=k.W;k=
+k.Y;a.xb=mN(hN(),new ma(c,h));a.cs=b.ds;a.Bg=new ma(d,k);a.$h=gN(hN(),new ma(d,k));a.bs=null}else e=Pi(fi(),new ma(d,d>>31)),h=DR($M(a),e),k=a.xb,g=k>>31,l=d>>31,d=k-d|0,k=(-2147483648^d)>(-2147483648^k)?-1+(g-l|0)|0:g-l|0,0!==h.a[1].Ya&&(g=VM(h.a[1]),0!==g.Ya&&(Sh(),l=g.wb,m=1+l|0,n=new Xc(m),Nh(0,n,g.Qa,l),g=Hh(g.Ya,m,n),Ih(g)),g=fM(g,e),e=ER(h.a[0],0)?1:0,g=Math.imul(h.a[1].Ya,5+g|0),e=lN(hN(),e,g,b.Fw),0!==e&&(e=ri(Ph(),new ma(e,e>>31)),g=h.a[0],h.a[0]=li(vi(),g,e)),e=new mr,FR(e,h.a[0],0),pr(e)>
+c&&(h.a[0]=GR(h.a[0],Ph().mq),d=e=-1+d|0,k=-1!==e?k:-1+k|0)),a.xb=mN(hN(),new ma(d,k)),a.cs=c,HR(a,h.a[0]);return new tr(a,b)}zR.prototype.$classData=q({v3:0},!1,"scala.math.BigDecimal$",{v3:1,g:1,l:1});var AR;function lr(){AR||(AR=new zR);return AR}function IR(a,b){var c=b-a.yy|0,d=a.KK.a[c];null===d&&(d=JR(new KR,null,new ma(b,b>>31)),a.KK.a[c]=d);return d}
+function LR(){this.pR=this.LK=null;this.MB=this.yy=0;this.qR=this.KK=null;MR=this;this.LK=ri(Ph(),new ma(0,-2147483648));this.pR=JR(new KR,this.LK,new ma(0,-2147483648));this.yy=-1024;this.MB=1024;this.KK=new (md(NR).Ia)(1+(this.MB-this.yy|0)|0);this.qR=ri(Ph(),new ma(-1,-1))}LR.prototype=new p;LR.prototype.constructor=LR;function br(){var a=Tr();return 0>=a.yy&&0<=a.MB?IR(a,0):OR(a,new ma(0,0))}
+function OR(a,b){var c=a.yy,d=c>>31,e=b.Y;(d===e?(-2147483648^c)<=(-2147483648^b.W):d<e)?(c=a.MB,d=c>>31,e=b.Y,c=e===d?(-2147483648^b.W)<=(-2147483648^c):e<d):c=!1;return c?IR(a,b.W):0===b.W&&-2147483648===b.Y?a.pR:JR(new KR,null,b)}function Hp(a){var b=Tr();return PR(b,eM(a))}function Sr(a,b,c){return PR(a,QR(new TM,b,c))}
+function PR(a,b){if(63>=yh(Sh(),b)){var c=b.xl(),d=c.W;c=c.Y;var e=a.yy,g=e>>31;(g===c?(-2147483648^e)<=(-2147483648^d):g<c)?(e=a.MB,g=e>>31,e=c===g?(-2147483648^d)<=(-2147483648^e):c<g):e=!1;return e?IR(a,d):JR(new KR,b,new ma(d,c))}return JR(new KR,b,new ma(0,-2147483648))}LR.prototype.$classData=q({x3:0},!1,"scala.math.BigInt$",{x3:1,g:1,l:1});var MR;function NK(){MR||(MR=new LR);return MR}function RR(){}RR.prototype=new p;RR.prototype.constructor=RR;
+function yG(a,b){b===da(xd)?a=sL():b===da(Cd)?a=tL():b===da(td)?a=Ir():b===da(Ed)?a=rl():b===da(Fd)?a=qL():b===da(Gd)?a=rL():b===da(Ld)?a=pL():b===da(rd)?a=uL():b===da(pd)?a=SR():b===da(jd)?a=TG():b===da(kH)?(TR||(TR=new UR),a=TR):b===da(jH)?(VR||(VR=new WR),a=VR):a=new jB(b);return a}RR.prototype.$classData=q({U3:0},!1,"scala.reflect.ClassTag$",{U3:1,g:1,l:1});var YR;function zG(){YR||(YR=new RR);return YR}function ZR(){}ZR.prototype=new p;ZR.prototype.constructor=ZR;function aS(){}
+aS.prototype=ZR.prototype;ZR.prototype.u=function(){return"\x3cfunction0\x3e"};function bS(){}bS.prototype=new p;bS.prototype.constructor=bS;function cS(){}cS.prototype=bS.prototype;bS.prototype.u=function(){return"\x3cfunction1\x3e"};function dS(){}dS.prototype=new p;dS.prototype.constructor=dS;function eS(){}eS.prototype=dS.prototype;function fS(){}fS.prototype=new p;fS.prototype.constructor=fS;function gS(){}gS.prototype=fS.prototype;fS.prototype.u=function(){return"\x3cfunction2\x3e"};
+function hS(){}hS.prototype=new p;hS.prototype.constructor=hS;function iS(){}iS.prototype=hS.prototype;hS.prototype.u=function(){return"\x3cfunction3\x3e"};function jS(){}jS.prototype=new p;jS.prototype.constructor=jS;function kS(){}kS.prototype=jS.prototype;function lS(){}lS.prototype=new p;lS.prototype.constructor=lS;function mS(){}mS.prototype=lS.prototype;function GA(a){this.Am=a}GA.prototype=new p;GA.prototype.constructor=GA;GA.prototype.u=function(){return""+this.Am};
+GA.prototype.$classData=q({X$:0},!1,"scala.runtime.BooleanRef",{X$:1,g:1,l:1});function IQ(a){this.ve=a}IQ.prototype=new p;IQ.prototype.constructor=IQ;IQ.prototype.u=function(){return""+this.ve};IQ.prototype.$classData=q({Z$:0},!1,"scala.runtime.IntRef",{Z$:1,g:1,l:1});function bv(){this.So=this.Ro=!1}bv.prototype=new p;bv.prototype.constructor=bv;function Yu(a,b){a.So=b;a.Ro=!0;return b}bv.prototype.u=function(){return"LazyBoolean "+(this.Ro?"of: "+this.So:"thunk")};
+bv.prototype.$classData=q({$$:0},!1,"scala.runtime.LazyBoolean",{$$:1,g:1,l:1});function $e(){this.sb=!1;this.vb=null}$e.prototype=new p;$e.prototype.constructor=$e;function me(a,b){a.vb=b;a.sb=!0;return b}$e.prototype.u=function(){return"LazyRef "+(this.sb?"of: "+this.vb:"thunk")};$e.prototype.$classData=q({aaa:0},!1,"scala.runtime.LazyRef",{aaa:1,g:1,l:1});function aw(a){this.rc=a}aw.prototype=new p;aw.prototype.constructor=aw;aw.prototype.u=function(){return""+this.rc};
+aw.prototype.$classData=q({eaa:0},!1,"scala.runtime.ObjectRef",{eaa:1,g:1,l:1});function IK(){}IK.prototype=new p;IK.prototype.constructor=IK;IK.prototype.$classData=q({m4:0},!1,"scala.util.Either$",{m4:1,g:1,l:1});var HK;function KK(){}KK.prototype=new p;KK.prototype.constructor=KK;KK.prototype.u=function(){return"Left"};KK.prototype.$classData=q({o4:0},!1,"scala.util.Left$",{o4:1,g:1,l:1});var JK;function MK(){}MK.prototype=new p;MK.prototype.constructor=MK;MK.prototype.u=function(){return"Right"};
+MK.prototype.$classData=q({q4:0},!1,"scala.util.Right$",{q4:1,g:1,l:1});var LK;function nS(){this.mG=this.PB=this.Cr=this.rg=0;oS=this;this.rg=lb("Seq");this.Cr=lb("Map");this.PB=lb("Set");this.mG=CL(this,O().c,this.Cr)}nS.prototype=new xL;nS.prototype.constructor=nS;function pS(a,b,c){return zL(a,My(W(),b),My(W(),c))}
+function qS(a){var b=BL();if(a&&a.$classData&&a.$classData.rb.hd)a:{var c=b.rg,d=a.K();switch(d){case 0:b=b.Ma(c,0);break a;case 1:d=c;a=a.va(0);b=b.Ma(b.C(d,My(W(),a)),1);break a;default:var e=a.va(0),g=My(W(),e);e=c=b.C(c,g);var h=a.va(1);h=My(W(),h);var k=h-g|0;for(g=2;g<d;){c=b.C(c,h);var l=a.va(g);l=My(W(),l);if(k!==(l-h|0)){c=b.C(c,l);for(g=1+g|0;g<d;)e=a.va(g),c=b.C(c,My(W(),e)),g=1+g|0;b=b.Ma(c,d);break a}h=l;g=1+g|0}b=yL(b.C(b.C(e,k),h))}}else if(a instanceof rS){d=b.rg;g=0;h=d;c=e=l=k=0;
+for(var m=a;!m.b();){a=m.e();m=m.f();a=My(W(),a);h=b.C(h,a);switch(k){case 0:c=a;k=1;break;case 1:l=a-e|0;k=2;break;case 2:l!==(a-e|0)&&(k=3)}e=a;g=1+g|0}2===k?(a=l,b=yL(b.C(b.C(b.C(d,c),a),e))):b=b.Ma(h,g)}else a:if(d=b.rg,a=a.m(),a.s())if(c=a.t(),a.s()){e=a.t();h=My(W(),c);c=d=b.C(d,h);g=My(W(),e);h=g-h|0;for(e=2;a.s();){d=b.C(d,g);k=a.t();k=My(W(),k);if(h!==(k-g|0)){d=b.C(d,k);for(e=1+e|0;a.s();)c=a.t(),d=b.C(d,My(W(),c)),e=1+e|0;b=b.Ma(d,e);break a}g=k;e=1+e|0}b=yL(b.C(b.C(c,h),g))}else b=b.Ma(b.C(d,
+My(W(),c)),1);else b=b.Ma(d,0);return b}nS.prototype.$classData=q({t4:0},!1,"scala.util.hashing.MurmurHash3$",{t4:1,Iba:1,g:1});var oS;function BL(){oS||(oS=new nS);return oS}function sS(){this.SK=this.QK=this.PK=0;this.RK=1}sS.prototype=new p;sS.prototype.constructor=sS;sS.prototype.u=function(){return"\x3cfunction2\x3e"};sS.prototype.ey=function(a,b){a=pS(BL(),a,b);this.PK=this.PK+a|0;this.QK^=a;this.RK=Math.imul(this.RK,1|a);this.SK=1+this.SK|0};sS.prototype.ba=function(a,b){this.ey(a,b)};
+sS.prototype.$classData=q({u4:0},!1,"scala.util.hashing.MurmurHash3$accum$1",{u4:1,g:1,kz:1});function Zp(){this.nG=null}Zp.prototype=new p;Zp.prototype.constructor=Zp;Zp.prototype.u=function(){return this.nG.eR};Zp.prototype.$classData=q({w4:0},!1,"scala.util.matching.Regex",{w4:1,g:1,l:1});function tS(){this.yQ=null;this.NF=0}tS.prototype=new p;tS.prototype.constructor=tS;function uS(){}uS.prototype=tS.prototype;tS.prototype.u=function(){return this.yQ};
+tS.prototype.i=function(a){return this===a};tS.prototype.B=function(){return Qb(this)};tS.prototype.sl=function(a){var b=this.NF;a=a.NF;return b===a?0:b<a?-1:1};function vS(a,b){yF(a,b,null,!0);return a}class wS extends Vd{}wS.prototype.$classData=q({OF:0},!1,"java.lang.Error",{OF:1,pc:1,g:1,l:1});class xF extends Vd{}xF.prototype.$classData=q({qd:0},!1,"java.lang.Exception",{qd:1,pc:1,g:1,l:1});function xS(){}xS.prototype=new p;xS.prototype.constructor=xS;function yS(){}yS.prototype=xS.prototype;
+xS.prototype.u=function(){for(var a=this.vv(),b="[",c=!0;a.s();)c?c=!1:b+=", ",b=""+b+a.t();return b+"]"};function GN(a){this.vB=this.iK=0;this.hK=this.wB=null;if(null===a)throw null;this.hK=a;this.iK=a.wl.a.length}GN.prototype=new CN;GN.prototype.constructor=GN;GN.prototype.$classData=q({X1:0},!1,"java.util.HashMap$NodeIterator",{X1:1,aba:1,g:1,p2:1});function zS(){this.mz=null;this.oz=this.pz=0;this.qz=this.nz=null;this.Rn=0}zS.prototype=new p;zS.prototype.constructor=zS;function AS(){}
+f=AS.prototype=zS.prototype;f.Vj=function(){if(this instanceof um){var a=this.Xo;var b=this.Tn,c=this.Un,d=O().c;a=new z(a,new z(b,new z(c,d)))}else if(this instanceof ym)a=this.dn,b=O().c,a=new z(a,b);else if(zm()===this)a=O().c;else throw new w(this);return a};f.jn=function(){0===(1&this.Rn)<<24>>24&&0===(1&this.Rn)<<24>>24&&(this.mz=zq(this),this.Rn=(1|this.Rn)<<24>>24);return this.mz};f.rn=function(){return this.pz};f.fm=function(a){this.pz=a};f.qn=function(){return this.oz};
+f.em=function(a){this.oz=a};f.pn=function(){return this.nz};f.on=function(a){this.nz=a};f.A=function(){0===(2&this.Rn)<<24>>24&&0===(2&this.Rn)<<24>>24&&(this.qz=Dq(this),this.Rn=(2|this.Rn)<<24>>24);return this.qz};function BS(){this.rs=null;this.ts=this.us=0;this.vs=this.ss=null;this.dl=0}BS.prototype=new p;BS.prototype.constructor=BS;function CS(){}f=CS.prototype=BS.prototype;f.Vj=function(){return Zda(this)};
+f.jn=function(){0===(1&this.dl)<<24>>24&&0===(1&this.dl)<<24>>24&&(this.rs=zq(this),this.dl=(1|this.dl)<<24>>24);return this.rs};f.rn=function(){return this.us};f.fm=function(a){this.us=a};f.qn=function(){return this.ts};f.em=function(a){this.ts=a};f.pn=function(){return this.ss};f.on=function(a){this.ss=a};f.A=function(){0===(2&this.dl)<<24>>24&&0===(2&this.dl)<<24>>24&&(this.vs=Dq(this),this.dl=(2|this.dl)<<24>>24);return this.vs};function DS(){}DS.prototype=new qO;DS.prototype.constructor=DS;
+function ES(){}ES.prototype=DS.prototype;function Xo(a,b,c){a.Bu=b;a.AH=c;return a}function Yo(){this.AH=this.Bu=null}Yo.prototype=new fO;Yo.prototype.constructor=Yo;function FS(){}FS.prototype=Yo.prototype;Yo.prototype.sh=function(){return 20};Yo.prototype.xa=function(){return Rp(Rp(Rp(Pp(this.Bu.xa(),20>this.Bu.sh()||this.Bu instanceof vo||this.Bu instanceof $m),Sp(Qp(),"[")),this.AH.xa()),Sp(Qp(),"]"))};Yo.prototype.VJ=function(){return this.Bu.VJ()};
+Yo.prototype.$classData=q({lN:0},!1,"mlscript.JSMember",{lN:1,Vi:1,Xc:1,g:1});function GS(){this.io=this.ho=this.jo=null;this.Fp=this.Gp=this.an=this.Ep=0;this.qa=null;this.r=0;this.zk=this.Pq=this.Uq=this.xp=this.Bp=this.Cp=this.Sq=this.zp=this.Rq=this.wp=this.Ap=this.yp=this.Qq=this.Tq=null;this.Dp=0;this.yq=this.Aq=this.Bq=this.zq=this.Dq=this.Cq=null}GS.prototype=new MP;GS.prototype.constructor=GS;function HS(){}HS.prototype=GS.prototype;
+function Vu(a){null===a.Cq&&null===a.Cq&&(a.Cq=new IS(a));return a.Cq}function lw(a){null===a.Dq&&null===a.Dq&&(a.Dq=new JS(a));return a.Dq}function $A(a){null===a.zq&&null===a.zq&&(a.zq=new KO(a));return a.zq}function xB(a){null===a.Aq&&null===a.Aq&&(a.Aq=new NO(a));return a.Aq}function GO(a){null===a.yq&&null===a.yq&&(a.yq=new AO(a));return a.yq}function vD(a){return Pe(new E(a),!0)}function Ev(a){return Pe(new E(a),!0)}
+function Bw(a,b,c,d,e){var g=Su(),h=op().ga;g=new Uu(g,h);h=sv();var k=c.Q()+d.Q()|0;d=Lv(Lv(Mv(8<k?k:8),c),d);c=Xu().X();for(d=sl(d).m();d.s();){var l=d.t();k=l.h();var m=c.U(k);if(m instanceof L){m=m.k;var n=l.j();up(tp(),Pe(new E(m.qb),n.qb));tp();l=m.Zb.K();up(0,Pe(new E(l),n.Zb.K()));l=m.qb;m=m.Zb;m=new Wq(m,m,n.Zb);n=new fn(((r,v)=>(x,A)=>{if(r){var B=cw(a),C=V(x.q);C=Pu(x,A,C,!1);var D=V(x.q);return dw(B,C,dv(x,A,D,!1),ew(cw(a)),v)}B=cw(a);C=V(x.q);C=dv(x,A,C,!1);D=V(x.q);return dw(B,C,Pu(x,
+A,D,!1),ew(cw(a)),v)})(b,e));Yq();m=Ew(m,n);l=new fw(a,l,m,V(a))}else{if(R()!==m)throw new w(m);l=l.j()}c.bj(k,l)}b=qp();return Ov(h,(new Pv(b)).vc(c),g)}class KS extends Vd{constructor(a){super();this.lX=a;yF(this,null,null,!0)}}KS.prototype.$classData=q({kX:0},!1,"mlscript.NotAType",{kX:1,pc:1,g:1,l:1});function LS(a,b,c,d){this.QH=this.KN=this.vE=this.Vq=this.yA=null;if(null===a)throw null;this.vE=a;this.KN=c;this.QH=d;FD(this,a.nc,b)}LS.prototype=new HD;LS.prototype.constructor=LS;
+LS.prototype.Kp=function(a,b){JD(this,a,b)};
+LS.prototype.Tb=function(a,b){var c=this.vE.nc.qa,d=this.vE.nc;if(d.F){var e=ut(Q(),"| ",d.r)+("Trav("+a+")("+b)+")";ff(gf(),e+"\n")}d.r=1+d.r|0;try{if(b instanceof lx){var g=this.KN,h=a.Ig(b.Xa);if(g.oh(G(new H,h,b))){var k=this.QH,l=this.QH.Se(b,new U(()=>ou().CP)),m=!1,n=null,r=a.Ig(b.Xa);a:{if(r instanceof L&&(m=!0,n=r,!0===!!n.k)){var v=ou().Zu;break a}if(m&&!1===!!n.k)v=ou().AA;else if(t().d===r)v=ou().Yl;else throw new w(r);}k.bh(b,new dQ(l.Qd&&v.Qd,l.qe&&v.qe));GD.prototype.Tb.call(this,a,
+b)}}else if(b instanceof Qv){m=this.vE.nc;k=Z=>uH(Q(),Z.h().x,35);var x=b.Ba;a:for(;;)if(x.b()){n=u();break}else{var A=x.e(),B=x.f();if(!0===!!k(A))x=B;else for(l=x,r=B;;){if(r.b())n=l;else{var C=r.e();if(!0!==!!k(C)){r=r.f();continue}C=r;var D=new z(l.e(),u()),F=l.f();for(l=D;F!==C;){var I=new z(F.e(),u());l=l.p=I;F=F.f()}var M=C.f();for(F=M;!M.b();){var N=M.e();if(!0===!!k(N)){for(;F!==M;){var P=new z(F.e(),u());l=l.p=P;F=F.f()}F=M.f()}M=M.f()}F.b()||(l.p=F);n=D}break a}}var T=new Qv(m,n,b.Nj);
+GD.prototype.Tb.call(this,a,T)}else GD.prototype.Tb.call(this,a,b);var Y=void 0}finally{d.r=-1+d.r|0}dx(new E(c),d.qa)&&d.F&&(a=""+ut(Q(),"| ",d.r)+c.n(Y),ff(gf(),a+"\n"))};LS.prototype.$classData=q({CX:0},!1,"mlscript.NuTypeDefs$TypedNuCls$Trav$1$",{CX:1,kP:1,g:1,YZ:1});function MS(a,b){if(null===b)throw null;a.nc=b;var c=a.aG().ie();c=new Ef(c,new y(e=>{e=e.Ua();return new vl(e)}));a.px=Aq(Bq(),c);c=a.Yr().A();a=cy(a.Yr());tx(b);var d=t().d;jx(new kx,b,c,a,d,!0)}
+function Cx(){this.nc=this.px=null}Cx.prototype=new p;Cx.prototype.constructor=Cx;function NS(){}NS.prototype=Cx.prototype;Cx.prototype.A=function(){return this.Yr().A()};Cx.prototype.bG=function(){return this.nc};function OS(a,b){a.nd=(t(),new L(b));b=b.A();return Cq(a,b)}
+var hu=function PS(a){var c=a.nd;if(c instanceof L)return PS(c.k);if(t().d===c){var d=!1,e=null,g=!1,h=null,k=!1,l=!1,m=null;c=!1;var n=null;if(a instanceof Ml){d=!0;e=a;var r=e.Ml;if(r instanceof Ml)return PS(r.Ml)}if(d)return"annotated "+PS(e.Ml);if(a instanceof Fl){g=!0;h=a;d=h.gg;if(!0===h.bi)a:{if(d instanceof Gl&&(e=d.Ra,e instanceof z&&e.p instanceof z)){d=!0;break a}if(d instanceof Gl&&(e=d.Ra,e instanceof z&&(e=e.z,null!==e&&e.h()instanceof L))){d=!0;break a}d=d instanceof Sl?!0:!1}else d=
+!1;if(d)return"record"}if(g)return PS(h.gg);if(a instanceof Sl&&(k=!0,h=a.Dj,h instanceof z&&(g=h.z,h=h.p,g instanceof Pm&&(d=O().c,null===d?null===h:d.i(h)))))return PS(g);if(k)return"block of statements";if(a instanceof Em)return"integer literal";if(a instanceof Fm)return"decimal literal";if(a instanceof Dm)return"string literal";if(a instanceof Gm)return a.Xq?"undefined literal":"null literal";if(a instanceof vl)return"reference";if(a instanceof Cl)return"type ascription";if(a instanceof Ol)return"lambda expression";
+if(a instanceof Pl&&(l=!0,m=a,k=m.Za,null!==k&&(k=fz(iz(),k),!k.b()&&(k=k.o().h(),k instanceof vl&&"|"===k.x))))return"type union";if(l&&(k=m.Za,null!==k&&(k=fz(iz(),k),!k.b()&&(k=k.o().h(),k instanceof vl&&"\x26"===k.x))))return"type intersection";if(l&&(m=m.Za,null!==m&&!fz(iz(),m).b())||null!==a&&!fz(iz(),a).b())return"operator application";if(l)return"application";if(a instanceof yl)return"record";if(a instanceof Ql)return"field selection";if(a instanceof Rl)return"let binding";if(a instanceof
+Gl&&(c=!0,n=a,l=n.Ra,l instanceof z&&(m=l.z,l=l.p,null!==m&&(k=m.h(),m=m.j(),t().d===k&&null!==m&&(m=m.ya,k=O().c,null===k?null===l:k.i(l))))))return PS(m);if(c&&(l=n.Ra,l instanceof z&&(n=l.z,l=l.p,null!==n&&(n.h()instanceof L?(n=O().c,n=null===n?null===l:n.i(l)):n=!1,n))))return"binding";if(c)return"tuple";if(a instanceof Tl)return"`with` extension";if(a instanceof Ul)return"`case` expression";if(a instanceof Vl)return"array access";if(a instanceof Wl)return"assignment";if(a instanceof dm)return"while loop";
+if(a instanceof Yl)return"new instance";if(a instanceof cm)return"refinement";if(a instanceof Xl)return"if-else block";if(a instanceof Il)return"type application";if(a instanceof $l)return"constraint clause";if(a instanceof Zl)return"forall clause";if(a instanceof Kl)return"explicit instantiation";if(a instanceof am)return"super";if(a instanceof bm)return"assign for ctor";if(a instanceof em)return"quasiquote";if(a instanceof fm)return"unquote";throw new w(a);}throw new w(c);},Zz=function QS(a,b){var d=
+!1,e=null,g=!1,h=null,k=!1,l=null;if(a instanceof Ml)return l=a.Ml,""+RS("@"+QS(a.gs,!1)+" ",b)+QS(l,!1);if(a instanceof Fl){d=!0;e=a;var m=e.gg;if(!0===e.bi)return"'{' "+QS(m,!1)+" '}'"}if(d&&(d=e.gg,!1===e.bi))return"'(' "+QS(d,!1)+" ')'";if(a instanceof Sl)return b=a.Dj.m(),b=new Ef(b,new y(n=>n.Wr())),ze(b,"{","; ","}");if(a instanceof Em)return a.rq.u();if(a instanceof Fm)return a.uu.gd.u();if(a instanceof Dm)return b=a.Lu,""+String.fromCharCode(34)+b+'"';if(a instanceof Gm)return a.Xq?"undefined":
+"null";if(a instanceof vl)return b=a.x,a=a.kt,a=a.b()?"":"::"+(a.o()|0),b+a;if(a instanceof Cl)return l=a.Fm,a=QS(a.ai,!1)+" : "+VO(l,!0),RS(a,b);if(a instanceof Ol&&(g=!0,h=a,e=h.Ej,d=h.Fj,e instanceof Gl))return a="("+Yz(e)+") \x3d\x3e "+QS(d,!1),RS(a,b);if(g)return a=h.Fj,a="(..."+QS(h.Ej,!1)+") \x3d\x3e "+QS(a,!1),RS(a,b);if(a instanceof Pl&&(k=!0,l=a,h=l.Za,g=l.Qb,g instanceof Gl))return a=QS(h,!(h instanceof Pl))+"("+Yz(g)+")",RS(a,b);if(k)return a=l.Za,l=l.Qb,a=QS(a,!(a instanceof Pl))+"(..."+
+QS(l,!0)+")",RS(a,b);if(a instanceof yl)return b=a.ll.m(),b=new Ef(b,new y(n=>(n.j().yb.je?"mut ":"")+n.h().x+": "+QS(n.j().ya,!1))),ze(b,"{",", ","}");if(a instanceof Ql)return b=a.ml,"("+QS(a.Vl,!1)+")."+QS(b,!1);if(a instanceof Rl&&(l=a.ep,k=a.Zn,h=a.$n,g=a.Mm,null!==k))return a="let"+(l?" rec":"")+" "+k.x+" \x3d "+QS(h,!1)+" in "+QS(g,!1),RS(a,b);if(a instanceof Gl)return"["+Yz(a)+"]";if(a instanceof Tl)return l=a.ar,a=QS(a.br,!1)+" with "+QS(l,!1),RS(a,b);if(a instanceof Ul)return l=a.Hm,a="case "+
+QS(a.Sn,!1)+" of { "+Wda(l,!0)+" }",RS(a,b);if(a instanceof Vl)return b=a.mp,"("+QS(a.lp,!1)+")["+QS(b,!1)+"]";if(a instanceof Wl)return l=a.Qn,a=QS(a.Gm,!1)+" \x3c- "+QS(l,!1),RS(a,b);if(a instanceof dm)return l=a.Zq,a="while "+QS(a.$q,!1)+" do "+QS(l,!1),RS(a,b);if(a instanceof Yl)return a="new "+QS(a.hp,!1),RS(a,b);if(a instanceof Xl)return l=a.zs,a=$da(a.bp),l.b()?l="":(l=l.o(),l=" else "+QS(l,!1)),RS("if "+a+l,b);if(a instanceof Il)return l=a.np,b=QS(a.nl,!1),a=l.m(),a=new Ef(a,new y(n=>VO(n,
+!0))),b+"\u2039"+ze(a,"",", ","")+"\u203a";if(a instanceof $l)return l=a.lt,b=QS(a.Yq,!1),a=l.m(),a=new Ef(a,new y(n=>n.Wr())),b+" where {"+ze(a,"","; ","")+"}";if(a instanceof Zl)return b=a.$o,"forall "+ze(a.qq,"",", ","")+". "+QS(b,!1);if(a instanceof Kl)return QS(a.cp,!0)+"!";if(a instanceof am)return"super";if(a instanceof bm)return b=a.Zo,QS(a.Vn,!1)+" \x3d "+QS(b,!1);if(a instanceof em)return'code"'+QS(a.Iq,!1)+'"';if(a instanceof fm)return"${"+QS(a.jt,!1)+"}";if(a instanceof cm)return b=a.Zs,
+QS(a.Ys,!1)+" "+gP(b);throw new w(a);},aA=function SS(a,b,c){var e=!1,g=null,h=!1,k=null,l=!1,m=null;if(a instanceof Ml)return m=a.Ml,TS("@"+a.gs.u()+" "+SS(m,!1,c),b);if(a instanceof Fl){e=!0;g=a;var n=g.gg;if(!0===g.bi)return SS(n,!1,c)}if(e&&(e=g.gg,!1===g.bi))return"("+SS(e,!1,c)+")";if(a instanceof Sl){l=a.Dj;var r=AP(c);b=x=>x instanceof Pm?SS(x,!1,r):x instanceof Ct?VO(x,r.fi):c.fi?no():x.u();if(l===u())b=u();else{a=l.e();m=a=new z(b(a),u());for(l=l.f();l!==u();)k=l.e(),k=new z(b(k),u()),m=
+m.p=k,l=l.f();b=a}a="{"+ON(r);m=ON(r);l=yP(c)+"\n}";return ze(b,a,m,l)}if(a instanceof Em)return a.rq.u();if(a instanceof Fm)return a.uu.gd.u();if(a instanceof Dm)return b=a.Lu,""+String.fromCharCode(34)+b+'"';if(a instanceof Gm)return b=a.Xq,c.fi?"()":b?"undefined":"null";if(a instanceof vl)return a.x;if(a instanceof Cl)return a=a.ai+" : "+VO(a.Fm,c.fi),TS(a,b);if(a instanceof Ol&&(h=!0,k=a,g=k.Ej,e=k.Fj,g instanceof Gl))return a="("+$z(g,c)+") \x3d\x3e "+SS(e,!1,c),TS(a,b);if(h)return a=k.Fj,a=
+"(..."+SS(k.Ej,!1,c)+") \x3d\x3e "+SS(a,!1,c),TS(a,b);if(a instanceof Pl&&(l=!0,m=a,k=m.Za,h=m.Qb,h instanceof Gl))return a=SS(k,!(k instanceof Pl),c)+"("+$z(h,c)+")",TS(a,b);if(l)return a=m.Za,m=m.Qb,a=SS(a,!(a instanceof Pl),c)+"(..."+SS(m,!0,c)+")",TS(a,b);if(a instanceof yl){var v=AP(c);b=a.ll.m();b=new Ef(b,new y(x=>(x.j().yb.je?"mut ":"")+x.h().x+": "+SS(x.j().ya,!1,v)));a="{"+ON(v);m=","+ON(v);l=ON(c)+"}";return ze(b,a,m,l)}if(a instanceof Ql)return b=a.Vl,a=a.ml,SS(b,!(b instanceof wm),c)+
+"."+a;if(a instanceof Rl)return m=a.$n,l=a.Mm,a="let"+(a.ep?" rec":"")+" "+SS(a.Zn,!1,c)+" \x3d "+SS(m,!1,c)+" in "+SS(l,!1,c),TS(a,b);if(a instanceof Gl)return"["+$z(a,c)+"]";if(a instanceof Tl)return m=a.ar,a=SS(a.br,!1,c)+" with "+SS(m,!1,c),TS(a,b);if(a instanceof Ul)return m=a.Hm,a="case "+SS(a.Sn,!1,c)+" of {"+Yda(m,AP(c))+ON(c)+"}",TS(a,b);if(a instanceof Vl)return b=a.mp,"("+SS(a.lp,!1,c)+")["+SS(b,!1,c)+"]";if(a instanceof Wl)return m=a.Qn,a=SS(a.Gm,!1,c)+" \x3c- "+SS(m,!1,c),TS(a,b);if(a instanceof
+dm)return m=a.Zq,a="while "+SS(a.$q,!1,c)+" do "+SS(m,!1,c),TS(a,b);if(a instanceof Yl)return a="new "+SS(a.hp,!1,c),TS(a,b);if(a instanceof Xl)return m=a.zs,a=aea(a.bp,AP(c)),m.b()?m="":(m=m.o(),m=" else "+SS(m,!1,AP(c))),TS("if "+a+m,b);if(a instanceof Il){k=a.np;b=SS(a.nl,!1,c);a=c.Jq?"\x3c":"[";if(k===u())m=u();else for(m=k.e(),l=m=new z(VO(m,c.fi),u()),k=k.f();k!==u();)h=k.e(),h=new z(VO(h,c.fi),u()),l=l.p=h,k=k.f();return""+b+a+ze(m,"",", ","")+(c.Jq?"\x3e":"]")}if(a instanceof $l)return b=
+a.lt,a=SS(a.Yq,!1,c),b=new Sl(b),a+" where "+SS(b,!1,AP(c));if(a instanceof Zl){l=a.qq;b=a.$o;if(l===u())a=u();else for(a=l.e(),m=a=new z(VO(a,c.fi),u()),l=l.f();l!==u();)k=l.e(),k=new z(VO(k,c.fi),u()),m=m.p=k,l=l.f();return"forall "+ze(a,"",", ","")+". "+SS(b,!1,c)}if(a instanceof Kl)return SS(a.cp,!0,c)+"!";if(a instanceof am)return"super";if(a instanceof bm)return b=a.Zo,SS(a.Vn,!1,c)+" \x3d "+SS(b,!1,c);if(a instanceof cm)return b=a.Zs,SS(a.Ys,!1,c)+" { "+lea(b,c)+" }";if(a instanceof em)return'code"'+
+SS(a.Iq,!1,c)+'"';if(a instanceof fm)return"${"+SS(a.jt,!1,c)+"}";throw new w(a);};function nx(a,b){a=Qn(a);if(a instanceof fe)return b.n(a.aa),el();if(a instanceof Ud)return a.fa;throw new w(a);}function Qn(a){try{t();var b=nea(a),c=a.A(),d=Cq(b,c);return new Ud(d)}catch(e){if(e instanceof KS)return b=e,t(),jr(),a=Ye(new Te(new Ue(J(new K,["Not a recognized type"]))),u()),b=b.lX.A(),a=G(new H,a,b),b=O().c,a=kr(0,new z(a,b),!0,ws()),new fe(a);throw e;}}
+var nea=function US(a){var c=!1,d=null,e=!1,g=null;a:{if(a instanceof vl){c=!0;d=a;var h=d.x;if(0<=h.length&&"`"===h.substring(0,1)){t();var k=Of(Q(),h,1,h.length);var l=new jt(new Ud(k),t().d);break a}}if(c){var m=d.x;if(0<=m.length&&"'"===m.substring(0,1)){l=new jt((t(),new Ud(m)),t().d);break a}}if(c)l=new Ep(d.x);else if(a instanceof Dl)l=new oP(a);else{if(a instanceof Pl){e=!0;g=a;var n=g.Za,r=g.Qb;if(n instanceof vl&&"-\x3e"===n.x&&null!==r){var v=mz(eu(),r);if(!v.b()&&null!==v.o()&&0===v.o().ab(2)){var x=
+v.o(),A=eB(x,0),B=v.o(),C=eB(B,1);var D=A instanceof Gl?!0:A instanceof Fl&&!1===A.bi&&A.gg instanceof Gl?!0:!1;if(D){l=new Wt(US(A),US(C));break a}}}}if(e){var F=g.Za,I=g.Qb;if(F instanceof vl&&"-\x3e"===F.x&&null!==I){var M=mz(eu(),I);if(!M.b()&&null!==M.o()&&0===M.o().ab(2)){var N=M.o(),P=eB(N,0),T=M.o(),Y=eB(T,1),Z=t().d,S=new Sn(t().d,US(P)),ea=G(new H,Z,S),ia=O().c;l=new Wt(new jP(new z(ea,ia)),US(Y));break a}}}if(e){var X=g.Za,sa=g.Qb;if(X instanceof vl&&"|"===X.x&&null!==sa){var Ja=mz(eu(),
+sa);if(!Ja.b()&&null!==Ja.o()&&0===Ja.o().ab(2)){var Xa=Ja.o(),Fa=eB(Xa,0),za=Ja.o(),Qa=eB(za,1);l=new iP(US(Fa),US(Qa));break a}}}if(e){var Ma=g.Za,Ga=g.Qb;if(Ma instanceof vl&&"\x26"===Ma.x&&null!==Ga){var ab=mz(eu(),Ga);if(!ab.b()&&null!==ab.o()&&0===ab.o().ab(2)){var Hb=ab.o(),bc=eB(Hb,0),yb=ab.o(),tb=eB(yb,1);l=new hP(US(bc),US(tb));break a}}}if(e){var eb=g.Za,kb=g.Qb;if(eb instanceof vl&&"\\"===eb.x&&null!==kb){var Rb=mz(eu(),kb);if(!Rb.b()&&null!==Rb.o()&&0===Rb.o().ab(2)){var Gb=Rb.o(),vb=
+eB(Gb,0),Tb=Rb.o(),Nb=eB(Tb,1),ic=US(vb),Va=new kP(US(Nb));cu();var cb=O().c,zb=du(0,new z(eb,new z(Nb,cb))),Ub=new hP(ic,Cq(Va,zb)),jb=Lq(g);l=Cq(Ub,jb);break a}}}if(e){var db=g.Za,ub=g.Qb;if(db instanceof vl&&"~"===db.x){l=new kP(US(ub));break a}}if(a instanceof Ol){var Aa=a.Fj;l=new Wt(US(a.Ej),US(Aa))}else{if(e){var va=g.Za,Ra=g.Qb;if(null!==Ra){var rb=mz(eu(),Ra);if(!rb.b()){var xb=rb.o(),mc=US(va);if(!(mc instanceof Ep))throw new KS(a);var Ha=xb.m(),Ka=new Ef(Ha,new y(Fc=>US(Fc)));Od();l=new pP(mc,
+Pd(u(),Ka));break a}}}if(a instanceof Gl){var Oa=a.Ra,Na=Fc=>{var qd=Fc.h(),Yb=Fc.j();a:{if(null!==Yb){var Nc=Yb.yb;Fc=Yb.ya;if(null!==Nc){Yb=Nc.je;Fc=US(Fc);Fc=new Sn(Yb?new L(Fc):R(),Fc);break a}}throw new w(Yb);}return G(new H,qd,Fc)};if(Oa===u())var Da=u();else{for(var ta=Oa.e(),Ya=new z(Na(ta),u()),dc=Ya,ka=Oa.f();ka!==u();){var ya=ka.e(),Sa=new z(Na(ya),u());dc=dc.p=Sa;ka=ka.f()}Da=Ya}l=new jP(Da)}else if(a instanceof Fl){var xc=a.bi,Sb=a.gg;if(Sb instanceof yl){if(!xc)throw new KS(a);}else if(xc)throw new KS(a);
+l=US(Sb)}else if(a instanceof Il){var uc=a.np,Lb=US(a.nl);if(!(Lb instanceof Ep))throw new KS(a);l=new pP(Lb,uc)}else if(a instanceof yl){var lc=a.ll,Xb=Fc=>{var qd=Fc.h(),Yb=Fc.j();a:{if(null!==Yb){var Nc=Yb.yb;Fc=Yb.ya;if(null!==Nc){Yb=Nc.je;Fc=US(Fc);Fc=new Sn(Yb?new L(Fc):R(),Fc);break a}}throw new w(Yb);}return G(new H,qd,Fc)};if(lc===u())var ec=u();else{for(var Ab=lc.e(),Ob=new z(Xb(Ab),u()),fb=Ob,Wa=lc.f();Wa!==u();){var bb=Wa.e(),Ia=new z(Xb(bb),u());fb=fb.p=Ia;Wa=Wa.f()}ec=Ob}l=new Tn(ec)}else if(a instanceof
+$l){var Ua=a.lt,pc=US(a.Yq),sc=O().c,Ba=Fc=>{if(Fc instanceof Cl){var qd=Fc.Fm;return new mP(US(Fc.ai),qd)}throw new KS(Fc);};if(Ua===u())var ob=u();else{for(var nc=Ua.e(),Ib=new z(Ba(nc),u()),vc=Ib,Vb=Ua.f();Vb!==u();){var fc=Vb.e(),Bc=new z(Ba(fc),u());vc=vc.p=Bc;Vb=Vb.f()}ob=Ib}l=new qP(pc,sc,ob)}else if(a instanceof Zl){var Pb=a.qq,Jb=a.$o,gc=Fc=>{t();return new Ud(Fc)};if(Pb===u())var Cb=u();else{for(var cc=Pb.e(),yc=new z(gc(cc),u()),Mc=yc,qc=Pb.f();qc!==u();){var oc=qc.e(),Qc=new z(gc(oc),
+u());Mc=Mc.p=Qc;qc=qc.f()}Cb=yc}l=new Vt(Cb,US(Jb))}else if(a instanceof Ql){var jc=a.ml,sb=US(a.Vl),Gc=new Ep(jc.x),Wb=jc.A();l=new tP(sb,Cq(Gc,Wb))}else throw new KS(a);}}}var Cc=a.A();return Cq(l,Cc)},oea=function VS(a){if(a instanceof Ol)return!0;if(a instanceof Fl){var c=a.gg;if(!1===a.bi)return VS(c)}if(a instanceof $l)return VS(a.Yq);if(a instanceof Ul){for(a=Uda(a.Hm);!a.b();){c=a.e();if(!VS(c))return!1;a=a.f()}return!0}return!1};function RS(a,b){return b?"("+a+")":a}
+function TS(a,b){return b?"("+a+")":a}function WS(){this.ld=null}WS.prototype=new SN;WS.prototype.constructor=WS;function XS(){}XS.prototype=WS.prototype;function YS(){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0}YS.prototype=new p;YS.prototype.constructor=YS;function ZS(){}ZS.prototype=YS.prototype;
+function ZO(a){if(0===(1&a.sc)<<24>>24&&0===(1&a.sc)<<24>>24){if(a instanceof jt){var b=O().c;b=new z(a,b)}else{b=EP(a);for(var c=null,d=null;b!==u();){for(var e=ZO(b.e()).m();e.s();){var g=new z(e.t(),u());null===d?c=g:d.p=g;d=g}b=b.f()}b=null===c?u():c}a.jf=b;a.sc=(1|a.sc)<<24>>24}return a.jf}
+function $S(a){if(0===(2&a.sc)<<24>>24&&0===(2&a.sc)<<24>>24){if(a instanceof jt){tp();var b=gq(a)}else{var c=EP(a);b=ap();for(c=Km(c);!c.b();){var d=c.e();b=$S(d).Ce(b);c=c.f()}}a.cf=b;a.sc=(2|a.sc)<<24>>24}return a.cf}f=YS.prototype;f.jn=function(){0===(4&this.sc)<<24>>24&&0===(4&this.sc)<<24>>24&&(this.df=zq(this),this.sc=(4|this.sc)<<24>>24);return this.df};f.rn=function(){return this.gf};f.fm=function(a){this.gf=a};f.qn=function(){return this.ff};f.em=function(a){this.ff=a};f.pn=function(){return this.ef};
+f.on=function(a){this.ef=a};f.A=function(){0===(8&this.sc)<<24>>24&&0===(8&this.sc)<<24>>24&&(this.hf=Dq(this),this.sc=(8|this.sc)<<24>>24);return this.hf};function AB(a,b,c,d,e){this.HE=this.YN=this.Ou=this.kI=this.Vq=this.yA=null;if(null===a)throw null;this.kI=a;this.Ou=c;this.YN=d;this.HE=e;FD(this,a,b)}AB.prototype=new HD;AB.prototype.constructor=AB;AB.prototype.Kp=function(a,b){JD(this,a,b)};
+AB.prototype.Tb=function(a,b){var c=this.kI.qa,d=this.kI;if(d.F){var e=ut(Q(),"| ",d.r)+("analyze1["+a+"] ")+b;ff(gf(),e+"\n")}d.r=1+d.r|0;try{if(b instanceof lx){var g=a.Ig(b.Xa);if(g instanceof L){var h=G(new H,!!g.k,b);this.Ou.bh(h,1+(this.Ou.n(h)|0)|0)}else if(t().d===g){this.YN.$(b);var k=G(new H,!0,b);this.Ou.bh(k,1+(this.Ou.n(k)|0)|0);var l=G(new H,!1,b);this.Ou.bh(l,1+(this.Ou.n(l)|0)|0)}else throw new w(g);var m=b.Sb;if(m instanceof L){var n=m.k,r=new zB(this.HE),v=a.Ig(b.Xa),x=v.b()?!1:
+v.o(),A=G(new H,b,x);r.en.L(A)||(r.en.$(A),this.Tb(a,n))}else if(t().d===m){var B=a.Ig(b.Xa);if(Nm(new E(B),(t(),new L(!1)))){var C=new zB(this.HE),D=G(new H,b,!0);if(!C.en.L(D)){C.en.$(D);var F=vy(b),I=new RB(a,b.Xa,!0);for(e=F;!e.b();){var M=e.e();this.Tb(I,M);e=e.f()}}}var N=a.Ig(b.Xa);if(Nm(new E(N),(t(),new L(!0)))){var P=new zB(this.HE),T=G(new H,b,!1);if(!P.en.L(T)){P.en.$(T);var Y=rA(b),Z=new RB(a,b.Xa,!1);for(a=Y;!a.b();){var S=a.e();this.Tb(Z,S);a=a.f()}}}}else throw new w(m);}else GD.prototype.Tb.call(this,
+a,b);var ea=void 0}finally{d.r=-1+d.r|0}dx(new E(c),d.qa)&&d.F&&(c=""+ut(Q(),"| ",d.r)+c.n(ea),ff(gf(),c+"\n"))};AB.prototype.$classData=q({GY:0},!1,"mlscript.TypeSimplifier$Analyze1$1$",{GY:1,kP:1,g:1,YZ:1});function aT(a){var b=GP(a.pp);return b.b()?a.oA:b}
+function bT(a,b){a=a.pp;if(a instanceof Ud)a=G(new H,0,a.fa);else if(a instanceof fe)a=G(new H,a.aa|0,"");else throw new w(a);var c=Fq(),d=cT();a=new dT(new eT(c,d),a);b=b.pp;if(b instanceof Ud)b=G(new H,0,b.fa);else if(b instanceof fe)b=G(new H,b.aa|0,"");else throw new w(b);return a.$l(b)}function BA(){this.q=null}BA.prototype=new YP;BA.prototype.constructor=BA;function fT(){}fT.prototype=BA.prototype;BA.prototype.rT=function(){return this};
+var uw=function pea(a,b){a=G(new H,a,b);b=a.y;var d=a.w;if(XB(b)&&XB(d))return pa(b.rr().Dh,d.rr().Dh);d=a.y;b=a.w;if(d instanceof mx&&(d=d.hi,b instanceof mx))return gT(d,b.hi);d=a.y;b=a.w;if(d instanceof YB&&(d=d.Ym,b instanceof YB))return pea(d,b.Ym);if(XB(a.y)&&(a.w instanceof mx||a.w instanceof YB))return-1;if((a.y instanceof mx||a.y instanceof YB)&&XB(a.w))return 1;if(a.y instanceof mx&&a.w instanceof YB)return-1;if(a.y instanceof YB&&a.w instanceof mx)return 1;throw new w(a);};
+function Uv(a){return!!(a&&a.$classData&&a.$classData.rb.uA)}function ko(a,b,c,d,e){this.jJ=a;this.re=b;this.hJ=c;this.iJ=d;this.RP=e;this.sF=!1}ko.prototype=new p;ko.prototype.constructor=ko;ko.prototype.xo=function(){return this.jJ};ko.prototype.zo=function(){return this.re};ko.prototype.u=function(){return"value "+this.jJ};ko.prototype.$classData=q({F_:0},!1,"mlscript.codegen.ValueSymbol",{F_:1,g:1,mt:1,cr:1});function hT(a,b){a.VP=b;yF(a,null,null,!0);return a}
+function iT(a,b,c){b=G(new H,b,c);c=O().c;hT(a,new z(b,c));return a}class jT extends Vd{constructor(){super();this.VP=null}}jT.prototype.$classData=q({S_:0},!1,"mlscript.ucs.DesugaringException",{S_:1,pc:1,g:1,l:1});function kT(){}kT.prototype=new p;kT.prototype.constructor=kT;function lT(){}lT.prototype=kT.prototype;function mT(){this.Iv=this.JK=null;nT=this;O();Od();this.JK=qp();this.Iv=Bq()}mT.prototype=new xQ;mT.prototype.constructor=mT;
+function up(a,b){if(!b)throw new Yj("assertion failed");}function At(a,b){if(!b)throw Kj("requirement failed");}function no(){tp();var a=new oT;yF(a,"an implementation is missing",null,!0);throw a;}mT.prototype.$classData=q({l3:0},!1,"scala.Predef$",{l3:1,eba:1,fba:1,g:1});var nT;function tp(){nT||(nT=new mT);return nT}function qea(a,b){switch(b){case 0:return a.Uj;case 1:return a.oj;case 2:return a.oi;case 3:return a.Xi;default:throw aL(new bL,b+" is out of bounds (min 0, max 3)");}}
+function rea(a,b){switch(b){case 0:return a.hv;case 1:return a.qt;case 2:return a.kr;case 3:return a.iv;case 4:return a.jv;default:throw aL(new bL,b+" is out of bounds (min 0, max 4)");}}function sea(a,b){switch(b){case 0:return a.lr;case 1:return a.mr;case 2:return a.rt;case 3:return a.st;case 4:return a.tt;case 5:return a.kv;default:throw aL(new bL,b+" is out of bounds (min 0, max 5)");}}function pT(){qT=this}pT.prototype=new p;pT.prototype.constructor=pT;
+pT.prototype.$classData=q({Q4:0},!1,"scala.collection.BuildFrom$",{Q4:1,g:1,Kba:1,Lba:1});var qT;function Yq(){qT||(qT=new pT)}function rT(){this.RB=null}rT.prototype=new p;rT.prototype.constructor=rT;function sT(){}sT.prototype=rT.prototype;rT.prototype.X=function(){return this.RB.ng(IB())};rT.prototype.Ib=function(a){return this.RB.pr(a,IB())};rT.prototype.Eb=function(){var a=this.RB,b=IB();return a.sy(b)};rT.prototype.Hh=function(a){var b=this.RB,c=IB();return b.pr(a,c)};
+function tT(){this.Mt=null}tT.prototype=new p;tT.prototype.constructor=tT;function uT(){}uT.prototype=tT.prototype;tT.prototype.ng=function(a){return this.Mt.ng(a)};tT.prototype.pr=function(a,b){return this.Mt.pr(a,b)};tT.prototype.GB=function(a){return this.Mt.GB(a)};function vT(){this.sm=null}vT.prototype=new p;vT.prototype.constructor=vT;function wT(){}wT.prototype=vT.prototype;vT.prototype.X=function(){return this.sm.X()};vT.prototype.Ib=function(a){return this.sm.Ib(a)};vT.prototype.Eb=function(){return this.sm.Eb()};
+function xT(a){this.c5=a}xT.prototype=new p;xT.prototype.constructor=xT;xT.prototype.vc=function(a){return this.c5.Ib(a)};xT.prototype.$classData=q({b5:0},!1,"scala.collection.IterableFactory$ToFactory",{b5:1,g:1,TK:1,l:1});function sp(a){a=a.m();return a.s()?new L(a.t()):R()}function yT(a){a=a.m();for(var b=a.t();a.s();)b=a.t();return b}function Is(a){return a.b()?R():new L(a.Mc())}
+function iv(a,b){if(0>b)return 1;var c=a.Q();if(0<=c)return c===b?0:c<b?-1:1;c=0;for(a=a.m();a.s();){if(c===b)return 1;a.t();c=1+c|0}return c-b|0}function hv(a,b){var c=b.Q();if(0<=c)return a.$k(c);c=a.Q();if(0<=c)return b=b.$k(c),-2147483648===b?1:-b|0;a=a.m();for(b=b.m();a.s()&&b.s();)a.t(),b.t();a=a.s();b=b.s();return a===b?0:a?1:-1}function zT(a,b){return a.vc(AT(new BT,a,b))}function CT(a){if(a.b())throw DT();return a.Jc(1)}
+function ET(a,b,c){var d=Xu().X();a.Ca(new y(h=>{var k=b.n(h);k=d.Hk(k,new U(()=>a.Ub().Eb()));h=c.n(h);return k.$(h)}));var e=nf(),g=new aw(e);d.Ca(new y(h=>{if(null!==h)g.rc=g.rc.Pn(G(new H,h.h(),h.j().Kb()));else throw new w(h);}));return g.rc}function FT(a,b){return a.Ub().Ib(GT(new HT,a,b))}function IT(a,b){var c=a.Ub();a=Fs(b)?new JT(a,b):a.m().nb(new U(()=>b.m()));return c.Ib(a)}
+function KT(a,b){var c=GT(new HT,a,new y(e=>b.n(e).h())),d=GT(new HT,a,new y(e=>b.n(e).j()));return G(new H,a.Ub().Ib(c),a.Ub().Ib(d))}function tea(a,b){for(var c=!1;!c&&a.s();)c=a.t(),c=ml(nl(),c,b);return c}function LT(a,b,c){var d=0<c?c:0;for(a=a.ph(c);a.s();){if(b.n(a.t()))return d;d=1+d|0}return-1}function kv(a,b){return(new MT(a)).nb(b)}function NT(a,b){return a.qk(0,0<b?b:0)}function OT(a,b,c){b=0<b?b:0;c=0>c?-1:c<=b?0:c-b|0;return 0===c?Rq().Pa:new PT(a,b,c)}
+function QT(){this.Pa=null;RT=this;this.Pa=new ST}QT.prototype=new p;QT.prototype.constructor=QT;QT.prototype.Eb=function(){return new TT};QT.prototype.X=function(){return this.Pa};QT.prototype.Ib=function(a){return a.m()};QT.prototype.$classData=q({d5:0},!1,"scala.collection.Iterator$",{d5:1,g:1,bg:1,l:1});var RT;function Rq(){RT||(RT=new QT);return RT}function uea(a){var b=qp();a.Nt=b}function UT(){this.Nt=null}UT.prototype=new p;UT.prototype.constructor=UT;function VT(){}VT.prototype=UT.prototype;
+UT.prototype.Hh=function(a){return this.Nt.Hh(a)};UT.prototype.Ib=function(a){return this.Nt.Ib(a)};UT.prototype.X=function(){return this.Nt.X()};UT.prototype.Eb=function(){return this.Nt.Eb()};function Pv(a){this.K5=a}Pv.prototype=new p;Pv.prototype.constructor=Pv;Pv.prototype.vc=function(a){return this.K5.Ib(a)};Pv.prototype.$classData=q({J5:0},!1,"scala.collection.MapFactory$ToFactory",{J5:1,g:1,TK:1,l:1});function WT(){this.Pt=null}WT.prototype=new p;WT.prototype.constructor=WT;
+function XT(){}XT.prototype=WT.prototype;WT.prototype.CF=function(a,b){return this.Pt.CF(a,b)};WT.prototype.qr=function(a,b){return this.Pt.qr(a,b)};WT.prototype.Hd=function(a){return this.Pt.Hd(a)};WT.prototype.Dv=function(a){return this.Pt.Dv(a)};function tv(a,b){this.b6=a;this.a6=b}tv.prototype=new p;tv.prototype.constructor=tv;tv.prototype.vc=function(a){return this.b6.qr(a,this.a6)};tv.prototype.$classData=q({$5:0},!1,"scala.collection.SortedMapFactory$ToFactory",{$5:1,g:1,TK:1,l:1});
+function YT(){}YT.prototype=new p;YT.prototype.constructor=YT;function ZT(a,b){if(b&&b.$classData&&b.$classData.rb.jd)return b;if(Fs(b))return new $T(new U(()=>b.m()));a=aU(FK(),b);return bU(new cU,a)}YT.prototype.Eb=function(){var a=new DF;return new dU(a,new y(b=>ZT(eU(),b)))};YT.prototype.X=function(){fU||(fU=new gU);return fU};YT.prototype.Ib=function(a){return ZT(0,a)};YT.prototype.$classData=q({r6:0},!1,"scala.collection.View$",{r6:1,g:1,bg:1,l:1});var hU;
+function eU(){hU||(hU=new YT);return hU}function aI(a,b,c,d,e,g){this.Db=a;this.qc=b;this.te=c;this.Vg=d;this.kd=e;this.ui=g}aI.prototype=new XQ;aI.prototype.constructor=aI;f=aI.prototype;f.ka=function(){return this.kd};f.uc=function(){return this.ui};f.Ef=function(a){return this.te.a[a<<1]};f.Tf=function(a){return this.te.a[1+(a<<1)|0]};f.rv=function(a){return G(new H,this.te.a[a<<1],this.te.a[1+(a<<1)|0])};f.Jb=function(a){return this.Vg.a[a]};
+f.qh=function(a){return this.te.a[(-1+this.te.a.length|0)-a|0]};f.BJ=function(a,b,c,d){var e=kI(HH(),c,d),g=lI(HH(),e);if(0!==(this.Db&g)){if(b=oI(HH(),this.Db,e,g),ml(nl(),a,this.Ef(b)))return this.Tf(b)}else if(0!==(this.qc&g))return this.qh(oI(HH(),this.qc,e,g)).BJ(a,b,c,5+d|0);throw AH("key not found: "+a);};
+f.KF=function(a,b,c,d){var e=kI(HH(),c,d),g=lI(HH(),e);return 0!==(this.Db&g)?(b=oI(HH(),this.Db,e,g),c=this.Ef(b),ml(nl(),a,c)?new L(this.Tf(b)):R()):0!==(this.qc&g)?(e=oI(HH(),this.qc,e,g),this.qh(e).KF(a,b,c,5+d|0)):R()};f.KJ=function(a,b,c,d,e){var g=kI(HH(),c,d),h=lI(HH(),g);return 0!==(this.Db&h)?(b=oI(HH(),this.Db,g,h),c=this.Ef(b),ml(nl(),a,c)?this.Tf(b):Es(e)):0!==(this.qc&h)?(g=oI(HH(),this.qc,g,h),this.qh(g).KJ(a,b,c,5+d|0,e)):Es(e)};
+f.DF=function(a,b,c,d){var e=kI(HH(),c,d),g=lI(HH(),e);return 0!==(this.Db&g)?(c=oI(HH(),this.Db,e,g),this.Vg.a[c]===b&&ml(nl(),a,this.Ef(c))):0!==(this.qc&g)&&this.qh(oI(HH(),this.qc,e,g)).DF(a,b,c,5+d|0)};
+function iU(a,b,c,d,e,g,h){var k=kI(HH(),e,g),l=lI(HH(),k);if(0!==(a.Db&l)){var m=oI(HH(),a.Db,k,l);k=a.Ef(m);var n=a.Jb(m);if(n===d&&ml(nl(),k,b))return h?(e=a.Tf(m),Object.is(k,b)&&Object.is(e,c)||(l=a.pi(l)<<1,b=a.te,e=new zc(b.a.length),b.wa(0,e,0,b.a.length),e.a[1+l|0]=c,a=new aI(a.Db,a.qc,e,a.Vg,a.kd,a.ui)),a):a;m=a.Tf(m);h=$G(bH(),n);c=jU(a,k,m,n,h,b,c,d,e,5+g|0);e=a.pi(l);d=e<<1;g=(-2+a.te.a.length|0)-a.hm(l)|0;k=a.te;b=new zc(-1+k.a.length|0);k.wa(0,b,0,d);k.wa(2+d|0,b,d,g-d|0);b.a[g]=c;
+k.wa(2+g|0,b,1+g|0,-2+(k.a.length-g|0)|0);e=gI(a.Vg,e);return new aI(a.Db^l,a.qc|l,b,e,(-1+a.kd|0)+c.ka()|0,(a.ui-h|0)+c.uc()|0)}if(0!==(a.qc&l))return k=oI(HH(),a.qc,k,l),k=a.qh(k),c=k.KC(b,c,d,e,5+g|0,h),c===k?a:kU(a,l,k,c);g=a.pi(l);k=g<<1;n=a.te;h=new zc(2+n.a.length|0);n.wa(0,h,0,k);h.a[k]=b;h.a[1+k|0]=c;n.wa(k,h,2+k|0,n.a.length-k|0);c=hI(a.Vg,g,d);return new aI(a.Db|l,a.qc,h,c,1+a.kd|0,a.ui+e|0)}
+function lU(a,b,c,d,e,g,h){var k=kI(HH(),e,g),l=lI(HH(),k);if(0!==(a.Db&l)){var m=oI(HH(),a.Db,k,l);k=a.Ef(m);var n=a.Jb(m);if(n===d&&ml(nl(),k,b))return d=a.Tf(m),Object.is(k,b)&&Object.is(d,c)||(l=a.pi(l)<<1,a.te.a[1+l|0]=c),h;var r=a.Tf(m);m=$G(bH(),n);c=jU(a,k,r,n,m,b,c,d,e,5+g|0);mU(a,l,m,c);return h|l}if(0!==(a.qc&l))return k=oI(HH(),a.qc,k,l),r=a.qh(k),k=r.ka(),n=r.uc(),m=h,r instanceof aI&&0!==(l&h)?(lU(r,b,c,d,e,5+g|0,0),h=r):(h=r.KC(b,c,d,e,5+g|0,!0),h!==r&&(m|=l)),a.te.a[(-1+a.te.a.length|
+0)-a.hm(l)|0]=h,a.kd=(a.kd-k|0)+h.ka()|0,a.ui=(a.ui-n|0)+h.uc()|0,m;g=a.pi(l);k=g<<1;n=a.te;m=new zc(2+n.a.length|0);n.wa(0,m,0,k);m.a[k]=b;m.a[1+k|0]=c;n.wa(k,m,2+k|0,n.a.length-k|0);a.Db|=l;a.te=m;a.Vg=hI(a.Vg,g,d);a.kd=1+a.kd|0;a.ui=a.ui+e|0;return h}
+function nU(a,b,c,d,e){var g=kI(HH(),d,e),h=lI(HH(),g);if(0!==(a.Db&h)){if(g=oI(HH(),a.Db,g,h),c=a.Ef(g),ml(nl(),c,b)){b=a.Db;2===nI(UH(),b)?(b=a.qc,b=0===nI(UH(),b)):b=!1;if(b)return h=0===e?a.Db^h:lI(HH(),kI(HH(),d,0)),0===g?new aI(h,0,new zc([a.Ef(1),a.Tf(1)]),new Xc(new Int32Array([a.Vg.a[1]])),1,$G(bH(),a.Jb(1))):new aI(h,0,new zc([a.Ef(0),a.Tf(0)]),new Xc(new Int32Array([a.Vg.a[0]])),1,$G(bH(),a.Jb(0)));e=a.pi(h);b=e<<1;c=a.te;g=new zc(-2+c.a.length|0);c.wa(0,g,0,b);c.wa(2+b|0,g,b,-2+(c.a.length-
+b|0)|0);e=gI(a.Vg,e);return new aI(a.Db^h,a.qc,g,e,-1+a.kd|0,a.ui-d|0)}}else if(0!==(a.qc&h)){g=oI(HH(),a.qc,g,h);g=a.qh(g);d=g.hR(b,c,d,5+e|0);if(d===g)return a;e=d.ka();if(1===e)if(a.kd===g.ka())a=d;else{b=(-1+a.te.a.length|0)-a.hm(h)|0;c=a.pi(h);var k=c<<1,l=d.Ef(0),m=d.Tf(0),n=a.te;e=new zc(1+n.a.length|0);n.wa(0,e,0,k);e.a[k]=l;e.a[1+k|0]=m;n.wa(k,e,2+k|0,b-k|0);n.wa(1+b|0,e,2+b|0,-1+(n.a.length-b|0)|0);b=hI(a.Vg,c,d.Jb(0));a=new aI(a.Db|h,a.qc^h,e,b,1+(a.kd-g.ka()|0)|0,(a.ui-g.uc()|0)+d.uc()|
+0)}else a=1<e?kU(a,h,g,d):a;return a}return a}function jU(a,b,c,d,e,g,h,k,l,m){if(32<=m)return GK(),b=[G(new H,b,c),G(new H,g,h)],b=J(new K,b),new oU(d,e,pU(0,b));var n=kI(HH(),e,m),r=kI(HH(),l,m),v=e+l|0;if(n!==r)return e=lI(HH(),n)|lI(HH(),r),n<r?new aI(e,0,new zc([b,c,g,h]),new Xc(new Int32Array([d,k])),2,v):new aI(e,0,new zc([g,h,b,c]),new Xc(new Int32Array([k,d])),2,v);n=lI(HH(),n);d=jU(a,b,c,d,e,g,h,k,l,5+m|0);return new aI(0,n,new zc([d]),kG().KB,d.ka(),d.uc())}f.nB=function(){return 0!==this.qc};
+f.HB=function(){var a=this.qc;return nI(UH(),a)};f.jy=function(){return 0!==this.Db};f.uy=function(){var a=this.Db;return nI(UH(),a)};f.pi=function(a){a=this.Db&(-1+a|0);return nI(UH(),a)};f.hm=function(a){a=this.qc&(-1+a|0);return nI(UH(),a)};function kU(a,b,c,d){b=(-1+a.te.a.length|0)-a.hm(b)|0;var e=a.te,g=new zc(e.a.length);e.wa(0,g,0,e.a.length);g.a[b]=d;return new aI(a.Db,a.qc,g,a.Vg,(a.kd-c.ka()|0)+d.ka()|0,(a.ui-c.uc()|0)+d.uc()|0)}
+function mU(a,b,c,d){var e=a.pi(b),g=e<<1,h=(-2+a.te.a.length|0)-a.hm(b)|0,k=a.te,l=new zc(-1+k.a.length|0);k.wa(0,l,0,g);k.wa(2+g|0,l,g,h-g|0);l.a[h]=d;k.wa(2+h|0,l,1+h|0,-2+(k.a.length-h|0)|0);e=gI(a.Vg,e);a.Db^=b;a.qc|=b;a.te=l;a.Vg=e;a.kd=(-1+a.kd|0)+d.ka()|0;a.ui=(a.ui-c|0)+d.uc()|0}f.Ca=function(a){var b=this.Db;b=nI(UH(),b);for(var c=0;c<b;)a.n(this.rv(c)),c=1+c|0;b=this.qc;b=nI(UH(),b);for(c=0;c<b;)this.qh(c).Ca(a),c=1+c|0};
+f.og=function(a){var b=this.Db;b=nI(UH(),b);for(var c=0;c<b;)a.ba(this.Ef(c),this.Tf(c)),c=1+c|0;b=this.qc;b=nI(UH(),b);for(c=0;c<b;)this.qh(c).og(a),c=1+c|0};f.GJ=function(a){var b=0,c=this.Db;for(c=nI(UH(),c);b<c;){var d=this.Ef(b),e=this.Tf(b);(0,a.aM)(d,e,this.Jb(b));b=1+b|0}b=this.qc;b=nI(UH(),b);for(c=0;c<b;)this.qh(c).GJ(a),c=1+c|0};
+f.i=function(a){if(a instanceof aI){if(this===a)return!0;if(this.ui===a.ui&&this.qc===a.qc&&this.Db===a.Db&&this.kd===a.kd){var b=this.Vg,c=a.Vg;b=qj(Pj(),b,c)}else b=!1;if(b){b=this.te;a=a.te;c=this.te.a.length;if(b===a)return!0;for(var d=!0,e=0;d&&e<c;)d=ml(nl(),b.a[e],a.a[e]),e=1+e|0;return d}}return!1};f.B=function(){throw nv("Trie nodes do not support hashing.");};
+function qU(a,b,c){if(b instanceof aI){if(0===a.kd)return b;if(0===b.kd||b===a)return a;if(1===b.kd){var d=b.Jb(0);return iU(a,b.Ef(0),b.Tf(0),d,$G(bH(),d),c,!0)}d=!1;var e=a.Db|b.Db|a.qc|b.qc,g=lI(HH(),0===e?32:31-Math.clz32(e&(-e|0))|0);e=lI(HH(),31-Math.clz32(e)|0);for(var h=0,k=0,l=0,m=0,n=0,r=0,v=0,x=0,A=0,B=0,C=g,D=0,F=0,I=!1;!I;){if(0!==(C&a.Db)){if(0!==(C&b.Db)){var M=a.Jb(D);M===b.Jb(F)&&ml(nl(),a.Ef(D),b.Ef(F))?A|=C:(x|=C,B|=lI(HH(),kI(HH(),$G(bH(),M),c)));F=1+F|0}else 0!==(C&b.qc)?k|=C:
+m|=C;D=1+D|0}else 0!==(C&a.qc)?0!==(C&b.Db)?(l|=C,F=1+F|0):0!==(C&b.qc)?h|=C:r|=C:0!==(C&b.Db)?(n|=C,F=1+F|0):0!==(C&b.qc)&&(v|=C);C===e?I=!0:C<<=1}C=m|n|A;B|=h|k|l|r|v;if(C===(n|A)&&B===v)return b;I=nI(UH(),C);D=(I<<1)+nI(UH(),B)|0;F=new zc(D);I=new Xc(I);var N=M=0,P=0,T=0,Y=0,Z=0;c=5+c|0;for(var S=0,ea=0,ia=!1;!ia;){if(0!==(g&h)){var X=b.qh(Z),sa=a.qh(Y).iQ(X,c);X!==sa&&(d=!0);F.a[-1+(D-ea|0)|0]=sa;ea=1+ea|0;Z=1+Z|0;Y=1+Y|0;M=M+sa.ka()|0;N=N+sa.uc()|0}else if(0!==(g&k)){X=b.qh(Z);sa=a.Ef(P);var Ja=
+a.Tf(P),Xa=a.Jb(P),Fa=$G(bH(),Xa);sa=X.KC(sa,Ja,Xa,Fa,c,!1);sa!==X&&(d=!0);F.a[-1+(D-ea|0)|0]=sa;ea=1+ea|0;Z=1+Z|0;P=1+P|0;M=M+sa.ka()|0;N=N+sa.uc()|0}else 0!==(g&l)?(d=!0,X=b.Jb(T),X=a.qh(Y).KC(b.Ef(T),b.Tf(T),b.Jb(T),$G(bH(),X),c,!0),F.a[-1+(D-ea|0)|0]=X,ea=1+ea|0,Y=1+Y|0,T=1+T|0,M=M+X.ka()|0,N=N+X.uc()|0):0!==(g&m)?(d=!0,X=a.Vg.a[P],F.a[S<<1]=a.Ef(P),F.a[1+(S<<1)|0]=a.Tf(P),I.a[S]=X,S=1+S|0,P=1+P|0,M=1+M|0,N=N+$G(bH(),X)|0):0!==(g&n)?(X=b.Vg.a[T],F.a[S<<1]=b.Ef(T),F.a[1+(S<<1)|0]=b.Tf(T),I.a[S]=
+X,S=1+S|0,T=1+T|0,M=1+M|0,N=N+$G(bH(),X)|0):0!==(g&r)?(d=!0,X=a.qh(Y),F.a[-1+(D-ea|0)|0]=X,ea=1+ea|0,Y=1+Y|0,M=M+X.ka()|0,N=N+X.uc()|0):0!==(g&v)?(X=b.qh(Z),F.a[-1+(D-ea|0)|0]=X,ea=1+ea|0,Z=1+Z|0,M=M+X.ka()|0,N=N+X.uc()|0):0!==(g&x)?(d=!0,X=a.Jb(P),sa=b.Jb(T),X=jU(b,a.Ef(P),a.Tf(P),X,$G(bH(),X),b.Ef(T),b.Tf(T),sa,$G(bH(),sa),c),F.a[-1+(D-ea|0)|0]=X,ea=1+ea|0,P=1+P|0,T=1+T|0,M=M+X.ka()|0,N=N+X.uc()|0):0!==(g&A)&&(X=b.Vg.a[T],F.a[S<<1]=b.Ef(T),F.a[1+(S<<1)|0]=b.Tf(T),I.a[S]=X,S=1+S|0,T=1+T|0,M=1+M|
+0,N=N+$G(bH(),X)|0,P=1+P|0);g===e?ia=!0:g<<=1}return d?new aI(C,B,F,I,M,N):b}throw nv("Cannot concatenate a HashCollisionMapNode with a BitmapIndexedMapNode");}function rU(a){var b=a.te.ia(),c=b.a.length,d=a.Db;for(d=nI(UH(),d)<<1;d<c;)b.a[d]=b.a[d].kQ(),d=1+d|0;return new aI(a.Db,a.qc,b,a.Vg.ia(),a.kd,a.ui)}
+function sU(a,b,c){if(0===a.kd)return a;if(1===a.kd)return!!b.n(a.rv(0))!==c?a:bI().Ty;if(0===a.qc){for(var d=a.Db,e=0===d?32:31-Math.clz32(d&(-d|0))|0,g=32-Math.clz32(a.Db)|0,h=d=0,k=0;e<g;){var l=lI(HH(),e);if(0!==(l&a.Db)){var m=a.rv(k);!!b.n(m)!==c&&(d|=l,h=h+$G(bH(),a.Jb(k))|0);k=1+k|0}e=1+e|0}if(0===d)return bI().Ty;if(d===a.Db)return a;g=d;g=nI(UH(),g);k=new zc(g<<1);e=new Xc(g);l=32-Math.clz32(d)|0;m=d;m=0===m?32:31-Math.clz32(m&(-m|0))|0;for(var n=0;m<l;){var r=lI(HH(),m);0!==(r&d)&&(r=mI(HH(),
+a.Db,r),k.a[n<<1]=a.te.a[r<<1],k.a[1+(n<<1)|0]=a.te.a[1+(r<<1)|0],e.a[n]=a.Vg.a[r],n=1+n|0);m=1+m|0}return new aI(d,0,k,e,g,h)}d=a.Db|a.qc;var v=0===d?32:31-Math.clz32(d&(-d|0))|0,x=32-Math.clz32(d)|0;h=d=0;var A=null;k=g=0;e=null;for(var B=r=n=m=l=0,C=0,D=v;D<x;){var F=lI(HH(),D);if(0!==(F&a.Db)){var I=a.rv(B);!!b.n(I)!==c&&(l|=F,d|=F,n=1+n|0,r=r+$G(bH(),a.Jb(B))|0);B=1+B|0}else if(0!==(F&a.qc)){var M=a.qh(C);I=M.qQ(b,c);n=n+I.ka()|0;r=r+I.uc()|0;1<I.ka()?(m|=F,M===I?g|=F:(k|=F,null===e&&(e=new tU(16)),
+uU(e,I))):1===I.ka()&&(l|=F,h|=F,null===A&&(A=u(),A=vU(new tU(16),A)),uU(A,I));C=1+C|0}D=1+D|0}if(0===n)return bI().Ty;if(n===a.kd)return a;b=l;x=nI(UH(),b);b=m;b=(x<<1)+nI(UH(),b)|0;c=new zc(b);x=new Xc(x);B=32-Math.clz32(l|m)|0;for(I=F=D=C=0;v<B;)M=lI(HH(),v),0!==(M&d)?(c.a[F<<1]=a.Ef(C),c.a[1+(F<<1)|0]=a.Tf(C),x.a[F]=a.Jb(C),F=1+F|0,C=1+C|0):0!==(M&g)?(c.a[-1+(b-I|0)|0]=a.qh(D),I=1+I|0,D=1+D|0):0!==(M&h)?(M=wU(A),c.a[F<<1]=M.Ef(0),c.a[1+(F<<1)|0]=M.Tf(0),x.a[F]=M.Jb(0),F=1+F|0,D=1+D|0):0!==(M&
+k)?(c.a[-1+(b-I|0)|0]=wU(e),I=1+I|0,D=1+D|0):0!==(M&a.Db)?C=1+C|0:0!==(M&a.qc)&&(D=1+D|0),v=1+v|0;return new aI(l,m,c,x,n,r)}f.qQ=function(a,b){return sU(this,a,b)};f.kQ=function(){return rU(this)};f.iQ=function(a,b){return qU(this,a,b)};f.hR=function(a,b,c,d){return nU(this,a,b,c,d)};f.KC=function(a,b,c,d,e,g){return iU(this,a,b,c,d,e,g)};f.mB=function(a){return this.qh(a)};f.$classData=q({R6:0},!1,"scala.collection.immutable.BitmapIndexedMapNode",{R6:1,O7:1,lC:1,g:1});
+function xU(a,b,c,d,e,g,h,k,l,m,n,r){if(0===b)return DJ().mw;if(b===a.Fb)return a;var v=nI(UH(),c),x=v+nI(UH(),d)|0,A=new zc(x);v=new Xc(v);for(var B=32-Math.clz32(c|d)|0,C=0,D=0,F=0,I=0;e<B;){var M=lI(HH(),e);0!==(M&g)?(A.a[F]=a.ed(C),v.a[F]=a.Jb(C),F=1+F|0,C=1+C|0):0!==(M&h)?(A.a[-1+(x-I|0)|0]=a.Nh(D),I=1+I|0,D=1+D|0):0!==(M&k)?(M=wU(l),A.a[F]=M.ed(0),v.a[F]=M.Jb(0),F=1+F|0,D=1+D|0):0!==(M&m)?(A.a[-1+(x-I|0)|0]=wU(n),I=1+I|0,D=1+D|0):0!==(M&a.db)?C=1+C|0:0!==(M&a.Pb)&&(D=1+D|0);e=1+e|0}return new CJ(c,
+d,A,v,b,r)}function CJ(a,b,c,d,e,g){this.db=a;this.Pb=b;this.Uc=c;this.Ud=d;this.Fb=e;this.Ve=g}CJ.prototype=new kR;CJ.prototype.constructor=CJ;f=CJ.prototype;f.ka=function(){return this.Fb};f.uc=function(){return this.Ve};f.ed=function(a){return this.Uc.a[a]};f.Jb=function(a){return this.Ud.a[a]};f.Nh=function(a){return this.Uc.a[(-1+this.Uc.a.length|0)-a|0]};
+f.yt=function(a,b,c,d){var e=kI(HH(),c,d),g=lI(HH(),e);return 0!==(this.db&g)?(c=oI(HH(),this.db,e,g),this.Ud.a[c]===b&&ml(nl(),a,this.ed(c))):0!==(this.Pb&g)?(e=oI(HH(),this.Pb,e,g),this.Nh(e).yt(a,b,c,5+d|0)):!1};
+function yU(a,b,c,d,e){var g=kI(HH(),d,e),h=lI(HH(),g);if(0!==(a.db&h)){g=oI(HH(),a.db,g,h);var k=a.ed(g);if(Object.is(k,b))return a;var l=a.Jb(g);g=$G(bH(),l);if(c===l&&ml(nl(),k,b))return a;d=zU(a,k,l,g,b,c,d,5+e|0);c=a.pi(h);e=(-1+a.Uc.a.length|0)-a.hm(h)|0;k=a.Uc;b=new zc(k.a.length);k.wa(0,b,0,c);k.wa(1+c|0,b,c,e-c|0);b.a[e]=d;k.wa(1+e|0,b,1+e|0,-1+(k.a.length-e|0)|0);c=gI(a.Ud,c);return new CJ(a.db^h,a.Pb|h,b,c,(-1+a.Fb|0)+d.ka()|0,(a.Ve-g|0)+d.uc()|0)}if(0!==(a.Pb&h))return g=oI(HH(),a.Pb,
+g,h),g=a.Nh(g),d=g.JC(b,c,d,5+e|0),g===d?a:AU(a,h,g,d);e=a.pi(h);k=a.Uc;g=new zc(1+k.a.length|0);k.wa(0,g,0,e);g.a[e]=b;k.wa(e,g,1+e|0,k.a.length-e|0);b=hI(a.Ud,e,c);return new CJ(a.db|h,a.Pb,g,b,1+a.Fb|0,a.Ve+d|0)}
+function BU(a,b,c,d,e,g){var h=kI(HH(),d,e),k=lI(HH(),h);if(0!==(a.db&k)){var l=oI(HH(),a.db,h,k);h=a.ed(l);var m=a.Jb(l);if(m===c&&ml(nl(),h,b))return g;l=$G(bH(),m);d=zU(a,h,m,l,b,c,d,5+e|0);CU(a,k,l,d);return g|k}if(0!==(a.Pb&k)){h=oI(HH(),a.Pb,h,k);var n=a.Nh(h);h=n.ka();l=n.uc();m=g;n instanceof CJ&&0!==(k&g)?(BU(n,b,c,d,5+e|0,0),g=n):(g=n.JC(b,c,d,5+e|0),g!==n&&(m|=k));a.Uc.a[(-1+a.Uc.a.length|0)-a.hm(k)|0]=g;a.Fb=(a.Fb-h|0)+g.ka()|0;a.Ve=(a.Ve-l|0)+g.uc()|0;return m}h=a.pi(k);l=a.Uc;e=new zc(1+
+l.a.length|0);l.wa(0,e,0,h);e.a[h]=b;l.wa(h,e,1+h|0,l.a.length-h|0);b=hI(a.Ud,h,c);a.db|=k;a.Uc=e;a.Ud=b;a.Fb=1+a.Fb|0;a.Ve=a.Ve+d|0;return g}
+function DU(a,b,c,d,e){var g=kI(HH(),d,e),h=lI(HH(),g);if(0!==(a.db&h)){g=oI(HH(),a.db,g,h);c=a.ed(g);if(ml(nl(),c,b)){b=a.db;2===nI(UH(),b)?(b=a.Pb,b=0===nI(UH(),b)):b=!1;if(b)return h=0===e?a.db^h:lI(HH(),kI(HH(),d,0)),0===g?new CJ(h,0,new zc([a.ed(1)]),new Xc(new Int32Array([a.Ud.a[1]])),-1+a.Fb|0,$G(bH(),a.Ud.a[1])):new CJ(h,0,new zc([a.ed(0)]),new Xc(new Int32Array([a.Ud.a[0]])),-1+a.Fb|0,$G(bH(),a.Ud.a[0]));g=a.pi(h);b=a.Uc;e=new zc(-1+b.a.length|0);b.wa(0,e,0,g);b.wa(1+g|0,e,g,-1+(b.a.length-
+g|0)|0);g=gI(a.Ud,g);return new CJ(a.db^h,a.Pb,e,g,-1+a.Fb|0,a.Ve-d|0)}return a}if(0!==(a.Pb&h)){g=oI(HH(),a.Pb,g,h);g=a.Nh(g);d=g.eG(b,c,d,5+e|0);if(d===g)return a;e=d.ka();if(1===e){if(a.Fb===g.ka())a=d;else{b=(-1+a.Uc.a.length|0)-a.hm(h)|0;c=a.pi(h);var k=a.Uc;e=new zc(k.a.length);k.wa(0,e,0,c);e.a[c]=d.ed(0);k.wa(c,e,1+c|0,b-c|0);k.wa(1+b|0,e,1+b|0,-1+(k.a.length-b|0)|0);b=hI(a.Ud,c,d.Jb(0));a=new CJ(a.db|h,a.Pb^h,e,b,1+(a.Fb-g.ka()|0)|0,(a.Ve-g.uc()|0)+d.uc()|0)}return a}if(1<e)return AU(a,h,
 g,d)}return a}
-function GU(a,b,c,d){var e=UH(pH(),d,0),g=VH(pH(),e);if(0!==(a.bb&g))e=YH(pH(),a.bb,e,g),c=a.Yc(e),Ol(Pl(),c,b)&&(b=a.bb,2===XH(CH(),b)?(b=a.Pb,b=0===XH(CH(),b)):b=!1,b?(g^=a.bb,0===e?(d=new jd([a.Yc(1)]),e=new zd(new Int32Array([a.Cd.a[1]])),b=HG(JG(),a.Jb(1)),a.Nc=d,a.Cd=e,a.Ae=b):(d=new jd([a.Yc(0)]),e=new zd(new Int32Array([a.Cd.a[0]])),b=HG(JG(),a.Jb(0)),a.Nc=d,a.Cd=e,a.Ae=b),a.bb=g,a.Pb=0,a.Fb=1):(b=a.di(g),c=a.Nc,e=new jd(-1+c.a.length|0),c.va(0,e,0,b),c.va(1+b|0,e,b,-1+(c.a.length-b|0)|0),
-b=QH(a.Cd,b),a.bb^=g,a.Nc=e,a.Cd=b,a.Fb=-1+a.Fb|0,a.Ae=a.Ae-d|0));else if(0!==(a.Pb&g)&&(e=YH(pH(),a.Pb,e,g),e=a.Dh(e),d=e.JF(b,c,d,5),d!==e))if(1===d.Fb)if(b=a.bb,0===XH(CH(),b)?(b=a.Pb,b=1===XH(CH(),b)):b=!1,b)a.bb=d.bb,a.Pb=d.Pb,a.Nc=d.Nc,a.Cd=d.Cd,a.Fb=d.Fb,a.Ae=d.Ae;else{b=(-1+a.Nc.a.length|0)-a.Ul(g)|0;c=a.di(g);var h=d.Yc(0);a.Nc.va(c,a.Nc,1+c|0,b-c|0);a.Nc.a[c]=h;b=RH(a.Cd,c,d.Jb(0));a.bb|=g;a.Pb^=g;a.Cd=b;a.Fb=1+(a.Fb-e.ka()|0)|0;a.Ae=(a.Ae-e.pc()|0)+d.pc()|0}else a.Nc.a[(-1+a.Nc.a.length|
-0)-a.Ul(g)|0]=d,a.Fb=-1+a.Fb|0,a.Ae=(a.Ae-e.pc()|0)+d.Ae|0}function BU(a,b,c,d,e,g,h,k){if(32<=k)return pK(),new HU(c,d,rU(0,J(new L,[b,e])));var l=UH(pH(),d,k),m=UH(pH(),h,k);if(l!==m)return a=VH(pH(),l)|VH(pH(),m),d=d+h|0,l<m?new lJ(a,0,new jd([b,e]),new zd(new Int32Array([c,g])),2,d):new lJ(a,0,new jd([e,b]),new zd(new Int32Array([g,c])),2,d);l=VH(pH(),l);b=BU(a,b,c,d,e,g,h,5+k|0);return new lJ(0,l,new jd([b]),SF().mB,b.ka(),b.pc())}f.Mx=function(){return 0!==this.bb};
-f.Xx=function(){var a=this.bb;return XH(CH(),a)};f.RA=function(){return 0!==this.Pb};f.kB=function(){var a=this.Pb;return XH(CH(),a)};f.di=function(a){a=this.bb&(-1+a|0);return XH(CH(),a)};f.Ul=function(a){a=this.Pb&(-1+a|0);return XH(CH(),a)};function CU(a,b,c,d){b=(-1+a.Nc.a.length|0)-a.Ul(b)|0;var e=a.Nc,g=new jd(e.a.length);e.va(0,g,0,e.a.length);g.a[b]=d;return new lJ(a.bb,a.Pb,g,a.Cd,(a.Fb-c.ka()|0)+d.ka()|0,(a.Ae-c.pc()|0)+d.pc()|0)}
-function EU(a,b,c,d){var e=a.di(b),g=(-1+a.Nc.a.length|0)-a.Ul(b)|0;a.Nc.va(1+e|0,a.Nc,e,g-e|0);a.Nc.a[g]=d;a.bb^=b;a.Pb|=b;a.Cd=QH(a.Cd,e);a.Fb=(-1+a.Fb|0)+d.ka()|0;a.Ae=(a.Ae-c|0)+d.pc()|0}f.ya=function(a){var b=this.bb;b=XH(CH(),b);for(var c=0;c<b;)a.n(this.Yc(c)),c=1+c|0;b=this.Pb;b=XH(CH(),b);for(c=0;c<b;)this.Dh(c).ya(a),c=1+c|0};
-function IU(a,b,c){if(0===a.Fb)return a;if(1===a.Fb)return!!b.n(a.Yc(0))!==c?a:mJ().Lv;if(0===a.Pb){for(var d=a.bb,e=0===d?32:31-Math.clz32(d&(-d|0))|0,g=32-Math.clz32(a.bb)|0,h=d=0,k=0;e<g;){var l=VH(pH(),e);if(0!==(l&a.bb)){var m=a.Yc(k);!!b.n(m)!==c&&(d|=l,h=h+HG(JG(),a.Jb(k))|0);k=1+k|0}e=1+e|0}if(0===d)return mJ().Lv;if(d===a.bb)return a;b=d;b=XH(CH(),b);c=new jd(b);g=new zd(b);k=32-Math.clz32(d)|0;e=d;e=0===e?32:31-Math.clz32(e&(-e|0))|0;for(l=0;e<k;)m=VH(pH(),e),0!==(m&d)&&(m=WH(pH(),a.bb,
-m),c.a[l]=a.Nc.a[m],g.a[l]=a.Cd.a[m],l=1+l|0),e=1+e|0;return new lJ(d,0,c,g,b,h)}h=a.bb|a.Pb;d=0===h?32:31-Math.clz32(h&(-h|0))|0;h=32-Math.clz32(h)|0;k=g=0;e=null;m=l=0;for(var n=null,r=0,u=0,w=0,y=0,B=0,D=0,C=d;C<h;){var F=VH(pH(),C);if(0!==(F&a.bb)){var I=a.Yc(B);!!b.n(I)!==c&&(r|=F,g|=F,w=1+w|0,y=y+HG(JG(),a.Jb(B))|0);B=1+B|0}else if(0!==(F&a.Pb)){I=a.Dh(D);var K=I.lJ(b,c);w=w+K.ka()|0;y=y+K.pc()|0;1<K.ka()?(u|=F,I===K?l|=F:(m|=F,null===n&&(n=new vU(16)),wU(n,K))):1===K.ka()&&(r|=F,k|=F,null===
-e&&(e=new vU(16)),wU(e,K));D=1+D|0}C=1+C|0}return zU(a,w,r,u,d,g,l,k,e,m,n,y)}
-function JU(a,b,c){if(b instanceof lJ){if(0===a.Fb)return a;if(1===a.Fb){var d=a.Jb(0);return b.Rs(a.Yc(0),d,HG(JG(),d),c)?mJ().Lv:a}var e=a.bb|a.Pb;d=0===e?32:31-Math.clz32(e&(-e|0))|0;e=32-Math.clz32(e)|0;for(var g=0,h=0,k=null,l=0,m=0,n=null,r=0,u=0,w=0,y=0,B=0,D=0,C=d;C<e;){var F=VH(pH(),C);if(0!==(F&a.bb)){var I=a.Yc(B),K=a.Jb(B),N=HG(JG(),K);b.Rs(I,K,N,c)||(r|=F,g|=F,w=1+w|0,y=y+N|0);B=1+B|0}else if(0!==(F&a.Pb)){I=a.Dh(D);if(0!==(F&b.bb)){N=WH(pH(),b.bb,F);K=b.Yc(N);N=b.Jb(N);var P=HG(JG(),
-N);K=I.JF(K,N,P,5+c|0)}else K=0!==(F&b.Pb)?I.UP(b.Dh(WH(pH(),b.Pb,F)),5+c|0):I;w=w+K.ka()|0;y=y+K.pc()|0;1<K.ka()?(u|=F,I===K?l|=F:(m|=F,null===n&&(n=new vU(16)),wU(n,K))):1===K.ka()&&(r|=F,h|=F,null===k&&(k=new vU(16)),wU(k,K));D=1+D|0}C=1+C|0}return zU(a,w,r,u,d,g,l,h,k,m,n,y)}if(b instanceof HU)throw SK("BitmapIndexedSetNode diff HashCollisionSetNode");throw new x(b);}
-f.h=function(a){if(a instanceof lJ){if(this===a)return!0;if(this.Ae===a.Ae&&this.Pb===a.Pb&&this.bb===a.bb&&this.Fb===a.Fb){var b=this.Cd,c=a.Cd;b=Jj(fk(),b,c)}else b=!1;if(b){b=this.Nc;a=a.Nc;c=this.Nc.a.length;if(b===a)return!0;for(var d=!0,e=0;d&&e<c;)d=Ol(Pl(),b.a[e],a.a[e]),e=1+e|0;return d}}return!1};f.y=function(){throw Fu("Trie nodes do not support hashing.");};
-function KU(a){var b=a.Nc.ga(),c=b.a.length,d=a.bb;for(d=XH(CH(),d);d<c;)b.a[d]=b.a[d].TP(),d=1+d|0;return new lJ(a.bb,a.Pb,b,a.Cd.ga(),a.Fb,a.Ae)}
-function LU(a,b,c){if(b instanceof lJ){if(0===a.Fb)return b;if(0===b.Fb||b===a)return a;if(1===b.Fb){var d=b.Jb(0);return AU(a,b.Yc(0),d,HG(JG(),d),c)}d=!1;var e=a.bb|b.bb|a.Pb|b.Pb,g=VH(pH(),0===e?32:31-Math.clz32(e&(-e|0))|0);e=VH(pH(),31-Math.clz32(e)|0);for(var h=0,k=0,l=0,m=0,n=0,r=0,u=0,w=0,y=0,B=0,D=g,C=0,F=0,I=!1;!I;)0!==(D&a.bb)?(0!==(D&b.bb)?(a.Jb(C)===b.Jb(F)&&Ol(Pl(),a.Yc(C),b.Yc(F))?y|=D:(w|=D,B|=VH(pH(),UH(pH(),HG(JG(),a.Jb(C)),c))),F=1+F|0):0!==(D&b.Pb)?k|=D:m|=D,C=1+C|0):0!==(D&a.Pb)?
-0!==(D&b.bb)?(l|=D,F=1+F|0):0!==(D&b.Pb)?h|=D:r|=D:0!==(D&b.bb)?(n|=D,F=1+F|0):0!==(D&b.Pb)&&(u|=D),D===e?I=!0:D<<=1;D=m|n|y;B|=h|k|l|r|u;if(D===(m|y)&&B===r)return a;I=XH(CH(),D);C=I+XH(CH(),B)|0;F=new jd(C);I=new zd(I);var K=0,N=0,P=0,T=0,aa=0,Y=0;c=5+c|0;for(var S=0,Z=0,ka=!1;!ka;){if(0!==(g&h)){var X=a.Dh(aa),sa=X.RP(b.Dh(Y),c);X!==sa&&(d=!0);F.a[-1+(C-Z|0)|0]=sa;Z=1+Z|0;Y=1+Y|0;aa=1+aa|0;K=K+sa.ka()|0;N=N+sa.pc()|0}else if(0!==(g&k)){d=!0;X=b.Dh(Y);sa=a.Yc(P);var Ia=a.Jb(P),Za=HG(JG(),Ia);X=
-X.lC(sa,Ia,Za,c);F.a[-1+(C-Z|0)|0]=X;Z=1+Z|0;Y=1+Y|0;P=1+P|0;K=K+X.ka()|0;N=N+X.pc()|0}else 0!==(g&l)?(sa=b.Jb(T),X=a.Dh(aa),sa=X.lC(b.Yc(T),b.Jb(T),HG(JG(),sa),c),sa!==X&&(d=!0),F.a[-1+(C-Z|0)|0]=sa,Z=1+Z|0,aa=1+aa|0,T=1+T|0,K=K+sa.ka()|0,N=N+sa.pc()|0):0!==(g&m)?(X=a.Cd.a[P],F.a[S]=a.Yc(P),I.a[S]=X,S=1+S|0,P=1+P|0,K=1+K|0,N=N+HG(JG(),X)|0):0!==(g&n)?(d=!0,X=b.Cd.a[T],F.a[S]=b.Yc(T),I.a[S]=X,S=1+S|0,T=1+T|0,K=1+K|0,N=N+HG(JG(),X)|0):0!==(g&r)?(X=a.Dh(aa),F.a[-1+(C-Z|0)|0]=X,Z=1+Z|0,aa=1+aa|0,K=K+
-X.ka()|0,N=N+X.pc()|0):0!==(g&u)?(d=!0,X=b.Dh(Y),F.a[-1+(C-Z|0)|0]=X,Z=1+Z|0,Y=1+Y|0,K=K+X.ka()|0,N=N+X.pc()|0):0!==(g&w)?(d=!0,X=a.Jb(P),sa=b.Jb(T),X=BU(b,a.Yc(P),X,HG(JG(),X),b.Yc(T),sa,HG(JG(),sa),c),F.a[-1+(C-Z|0)|0]=X,Z=1+Z|0,P=1+P|0,T=1+T|0,K=K+X.ka()|0,N=N+X.pc()|0):0!==(g&y)&&(X=b.Cd.a[T],F.a[S]=b.Yc(T),I.a[S]=X,S=1+S|0,T=1+T|0,K=1+K|0,N=N+HG(JG(),X)|0,P=1+P|0);g===e?ka=!0:g<<=1}return d?new lJ(D,B,F,I,K,N):a}throw Fu("Cannot concatenate a HashCollisionSetNode with a BitmapIndexedSetNode");
-}f.nJ=function(a){var b=this.bb;b=XH(CH(),b);for(var c=0;c<b;)a.aa(this.Yc(c),this.Jb(c)),c=1+c|0;b=this.Pb;b=XH(CH(),b);for(c=0;c<b;)this.Dh(c).nJ(a),c=1+c|0};f.RP=function(a,b){return LU(this,a,b)};f.TP=function(){return KU(this)};f.UP=function(a,b){return JU(this,a,b)};f.lJ=function(a,b){return IU(this,a,b)};f.JF=function(a,b,c,d){return FU(this,a,b,c,d)};f.lC=function(a,b,c,d){return AU(this,a,b,c,d)};f.QA=function(a){return this.Dh(a)};
-f.$classData=q({m6:0},!1,"scala.collection.immutable.BitmapIndexedSetNode",{m6:1,Q7:1,NB:1,d:1});function qU(a,b,c){this.sy=a;this.Yn=b;this.bf=c;Os(fp(),2<=this.bf.K())}qU.prototype=new OQ;qU.prototype.constructor=qU;function MU(a,b){a=a.bf.m();for(var c=0;a.s();){if(Ol(Pl(),a.t().i(),b))return c;c=1+c|0}return-1}f=qU.prototype;f.ka=function(){return this.bf.K()};f.iJ=function(a,b,c,d){a=this.mF(a,b,c,d);if(a.b())throw NU();return a.o()};
-f.mF=function(a,b,c){return this.Yn===c?(a=MU(this,a),0<=a?new M(this.bf.ua(a).j()):R()):R()};f.sJ=function(a,b,c,d,e){return this.Yn===c?(a=MU(this,a),-1===a?Zr(e):this.bf.ua(a).j()):Zr(e)};f.fF=function(a,b,c){return this.Yn===c&&0<=MU(this,a)};f.mC=function(a,b,c,d,e,g){e=MU(this,a);return 0<=e?g?Object.is(this.bf.ua(e).j(),b)?this:new qU(c,d,this.bf.qr(e,G(new H,a,b))):this:new qU(c,d,this.bf.Im(G(new H,a,b)))};
-f.PQ=function(a,b,c,d){if(this.fF(a,b,c,d)){d=OU(this.bf,new z(g=>Ol(Pl(),g.i(),a)),!0);if(1===d.K()){var e=d.ua(0);if(null===e)throw new x(e);d=e.i();e=e.j();return new JH(VH(pH(),UH(pH(),c,0)),0,new jd([d,e]),new zd(new Int32Array([b])),1,c)}return new qU(b,c,d)}return this};f.RA=function(){return!1};f.kB=function(){return 0};f.gh=function(){throw KK(new LK,"No sub-nodes present in hash-collision leaf node.");};f.Mx=function(){return!0};f.Xx=function(){return this.bf.K()};f.uf=function(a){return this.bf.ua(a).i()};
-f.Kf=function(a){return this.bf.ua(a).j()};f.Ru=function(a){return this.bf.ua(a)};f.Jb=function(){return this.sy};f.ya=function(a){this.bf.ya(a)};f.Ag=function(a){this.bf.ya(new z(b=>{if(null!==b)return a.aa(b.i(),b.j());throw new x(b);}))};f.oJ=function(a){for(var b=this.bf.m();b.s();){var c=b.t();(0,a.JL)(c.i(),c.j(),this.sy)}};
-f.h=function(a){if(a instanceof qU){if(this===a)return!0;if(this.Yn===a.Yn&&this.bf.K()===a.bf.K()){for(var b=this.bf.m();b.s();){var c=b.t();if(null===c)throw new x(c);var d=c.j();c=MU(a,c.i());if(0>c||!Ol(Pl(),d,a.bf.ua(c).j()))return!1}return!0}}return!1};
-f.YP=function(a,b){a=OU(this.bf,a,b);b=a.K();if(0===b)return LH().wy;if(1===b){b=a.e();if(null===b)throw new x(b);a=b.i();b=b.j();return new JH(VH(pH(),UH(pH(),this.Yn,0)),0,new jd([a,b]),new zd(new Int32Array([this.sy])),1,this.Yn)}return b===this.bf.K()?this:new qU(this.sy,this.Yn,a)};f.y=function(){throw Fu("Trie nodes do not support hashing.");};f.pc=function(){return Math.imul(this.bf.K(),this.Yn)};f.SP=function(){return new qU(this.sy,this.Yn,this.bf)};
-f.QP=function(a){if(a instanceof qU)if(a===this)a=this;else{for(var b=null,c=this.bf.m();c.s();){var d=c.t();0>MU(a,d.i())&&(null===b&&(b=new PU,QU(b,a.bf)),RU(b,d))}a=null===b?a:new qU(this.sy,this.Yn,b.Vl())}else{if(a instanceof JH)throw Fu("Cannot concatenate a HashCollisionMapNode with a BitmapIndexedMapNode");throw new x(a);}return a};f.QA=function(a){return this.gh(a)};f.$classData=q({n6:0},!1,"scala.collection.immutable.HashCollisionMapNode",{n6:1,i7:1,NB:1,d:1});
-function HU(a,b,c){this.wv=a;this.lp=b;this.Bg=c;Os(fp(),2<=this.Bg.K())}HU.prototype=new bR;HU.prototype.constructor=HU;f=HU.prototype;f.Rs=function(a,b,c){return this.lp===c?SU(this.Bg,a):!1};f.lC=function(a,b,c,d){return this.Rs(a,b,c,d)?this:new HU(b,c,this.Bg.Im(a))};f.JF=function(a,b,c,d){return this.Rs(a,b,c,d)?(d=OU(this.Bg,new z(e=>Ol(Pl(),e,a)),!0),1===d.K()?new lJ(VH(pH(),UH(pH(),c,0)),0,new jd([d.ua(0)]),new zd(new Int32Array([b])),1,c):new HU(b,c,d)):this};f.RA=function(){return!1};
-f.kB=function(){return 0};f.Dh=function(){throw KK(new LK,"No sub-nodes present in hash-collision leaf node.");};f.Mx=function(){return!0};f.Xx=function(){return this.Bg.K()};f.Yc=function(a){return this.Bg.ua(a)};f.Jb=function(){return this.wv};f.ka=function(){return this.Bg.K()};f.ya=function(a){for(var b=this.Bg.m();b.s();)a.n(b.t())};f.pc=function(){return Math.imul(this.Bg.K(),this.lp)};
-f.lJ=function(a,b){a=OU(this.Bg,a,b);b=a.K();return 0===b?mJ().Lv:1===b?new lJ(VH(pH(),UH(pH(),this.lp,0)),0,new jd([a.e()]),new zd(new Int32Array([this.wv])),1,this.lp):a.K()===this.Bg.K()?this:new HU(this.wv,this.lp,a)};f.UP=function(a,b){return this.lJ(new z(c=>a.Rs(c,this.wv,this.lp,b)),!0)};f.h=function(a){if(a instanceof HU){if(this===a)return!0;if(this.lp===a.lp&&this.Bg.K()===a.Bg.K()){a=a.Bg;for(var b=!0,c=this.Bg.m();b&&c.s();)b=c.t(),b=SU(a,b);return b}}return!1};
-f.y=function(){throw Fu("Trie nodes do not support hashing.");};f.RP=function(a){if(a instanceof HU){if(a===this)return this;var b=null;for(a=a.Bg.m();a.s();){var c=a.t();SU(this.Bg,c)||(null===b&&(b=new PU,QU(b,this.Bg)),RU(b,c))}return null===b?this:new HU(this.wv,this.lp,b.Vl())}if(a instanceof lJ)throw Fu("Cannot concatenate a HashCollisionSetNode with a BitmapIndexedSetNode");throw new x(a);};f.nJ=function(a){for(var b=this.Bg.m();b.s();){var c=b.t();a.aa(c,this.wv)}};
-f.TP=function(){return new HU(this.wv,this.lp,this.Bg)};f.QA=function(a){return this.Dh(a)};f.$classData=q({o6:0},!1,"scala.collection.immutable.HashCollisionSetNode",{o6:1,Q7:1,NB:1,d:1});function TU(){this.br=null;UU=this;var a=LH();this.br=new VU(a.wy)}TU.prototype=new p;TU.prototype.constructor=TU;f=TU.prototype;f.wh=function(a){return Wy(0,a)};function Wy(a,b){return b instanceof VU?b:WU(XU(new YU,b))}f.Db=function(){return new YU};f.Ib=function(a){return Wy(0,a)};f.U=function(){return this.br};
-f.$classData=q({q6:0},!1,"scala.collection.immutable.HashMap$",{q6:1,d:1,hy:1,l:1});var UU;function Xy(){UU||(UU=new TU);return UU}function ZU(){this.Zn=null;$U=this;var a=mJ();this.Zn=new aV(a.Lv)}ZU.prototype=new p;ZU.prototype.constructor=ZU;function bV(a,b){return b instanceof aV?b:0===b.Q()?a.Zn:cV(dV(new eV,b))}ZU.prototype.Db=function(){return new eV};ZU.prototype.Ib=function(a){return bV(this,a)};ZU.prototype.U=function(){return this.Zn};
-ZU.prototype.$classData=q({w6:0},!1,"scala.collection.immutable.HashSet$",{w6:1,d:1,Uf:1,l:1});var $U;function fV(){$U||($U=new ZU);return $U}function gV(a,b){this.J6=a;this.K6=b}gV.prototype=new p;gV.prototype.constructor=gV;gV.prototype.e=function(){return this.J6};gV.prototype.Cf=function(){return this.K6};gV.prototype.$classData=q({I6:0},!1,"scala.collection.immutable.LazyList$State$Cons",{I6:1,d:1,H6:1,l:1});function hV(){}hV.prototype=new p;hV.prototype.constructor=hV;
-hV.prototype.tJ=function(){throw iH("head of empty lazy list");};hV.prototype.Cf=function(){throw Fu("tail of empty lazy list");};hV.prototype.e=function(){this.tJ()};hV.prototype.$classData=q({L6:0},!1,"scala.collection.immutable.LazyList$State$Empty$",{L6:1,d:1,H6:1,l:1});var iV;function jV(){iV||(iV=new hV);return iV}function kV(){}kV.prototype=new p;kV.prototype.constructor=kV;f=kV.prototype;f.wh=function(a){return bp(0,a)};
-function bp(a,b){IJ(b)&&b.b()?a=Jf():lV(b)?a=b:(a=mV(new nV,b),a=a.vy?WU(a.ot):a.rp);return a}f.Db=function(){return new nV};f.Ib=function(a){return bp(0,a)};f.U=function(){return Jf()};f.$classData=q({P6:0},!1,"scala.collection.immutable.Map$",{P6:1,d:1,hy:1,l:1});var oV;function cp(){oV||(oV=new kV);return oV}function pV(){}pV.prototype=new p;pV.prototype.constructor=pV;
-function Zp(a,b){return b&&b.$classData&&b.$classData.pb.wL?tF(qV(new vF,b)):0===b.Q()?Wp():b&&b.$classData&&b.$classData.pb.tp?b:tF(qV(new vF,b))}pV.prototype.Db=function(){return new vF};pV.prototype.Ib=function(a){return Zp(0,a)};pV.prototype.U=function(){return Wp()};pV.prototype.$classData=q({E7:0},!1,"scala.collection.immutable.Set$",{E7:1,d:1,Uf:1,l:1});var rV;function $p(){rV||(rV=new pV);return rV}function sV(){}sV.prototype=new p;sV.prototype.constructor=sV;f=sV.prototype;
-f.eF=function(a,b){return tV(0,a,b)};function tV(a,b,c){if(b instanceof uV&&(a=b.Be,null===c?null===a:c.h(a)))return b;if(b&&b.$classData&&b.$classData.pb.zB&&(a=b.Wd(),null===c?null===a:c.h(a))){a=new uV;var d=XI(),e=b.m();b=b.ka();var g=32-Math.clz32(b)|0;b=lca(d,1,b,e,g);return vV(a,b,c)}a=null;for(b=b.m();b.s();){e=b.t();if(null===e)throw new x(e);d=e.i();e=e.j();a=QI(XI(),a,d,e,!0,c)}return vV(new uV,a,c)}f.bv=function(a){return new wV(a)};f.Fq=function(a,b){return tV(0,a,b)};f.Ch=function(a){return xV(a)};
-f.$classData=q({b8:0},!1,"scala.collection.immutable.TreeMap$",{b8:1,d:1,fL:1,l:1});var yV;function zV(){yV||(yV=new sV);return yV}function AV(a){this.FG=this.By=null;if(null===a)throw null;this.FG=a;this.By=null}AV.prototype=new WR;AV.prototype.constructor=AV;AV.prototype.Jx=function(a,b){this.By=XQ(this.FG,this.By,a,b)};AV.prototype.aa=function(a,b){this.Jx(a,b)};AV.prototype.$classData=q({e8:0},!1,"scala.collection.immutable.TreeMap$TreeMapBuilder$adder$",{e8:1,SG:1,d:1,Py:1});
-function BV(a){this.nS=this.HG=null;if(null===a)throw null;this.nS=a;this.HG=a.xf}BV.prototype=new SR;BV.prototype.constructor=BV;BV.prototype.n=function(a){var b=XI();this.HG=ZH(yI(b,this.HG,a,this.nS.Ce))};BV.prototype.$classData=q({i8:0},!1,"scala.collection.immutable.TreeSet$sub$1$",{i8:1,ML:1,d:1,ja:1});function CV(){}CV.prototype=new p;CV.prototype.constructor=CV;f=CV.prototype;f.wh=function(a){return ly(a)};function ly(a){var b=a.Q();return DV(EV(new FV,0<b?Mc((1+b|0)/.75):16,.75),a)}
-f.Db=function(){return new GV(16,.75)};f.Ib=function(a){return ly(a)};f.U=function(){return HV()};f.$classData=q({$8:0},!1,"scala.collection.mutable.HashMap$",{$8:1,d:1,hy:1,l:1});var IV;function ky(){IV||(IV=new CV);return IV}function JV(){}JV.prototype=new p;JV.prototype.constructor=JV;function Iy(a){var b=a.Q();return KV(LV(new MV,0<b?Mc((1+b|0)/.75):16,.75),a)}JV.prototype.Db=function(){return new NV(16,.75)};JV.prototype.U=function(){return Gn()};JV.prototype.Ib=function(a){return Iy(a)};
-JV.prototype.$classData=q({i9:0},!1,"scala.collection.mutable.HashSet$",{i9:1,d:1,Uf:1,l:1});var OV;function Hy(){OV||(OV=new JV);return OV}function PV(){}PV.prototype=new p;PV.prototype.constructor=PV;f=PV.prototype;f.wh=function(a){return QV(a)};function QV(a){if(a instanceof Nz)return a;var b=new Nz;return cR(b,a)}f.Db=function(){return RV(new SV,new Nz)};f.Ib=function(a){return QV(a)};f.U=function(){return new Nz};
-f.$classData=q({u9:0},!1,"scala.collection.mutable.LinkedHashMap$",{u9:1,d:1,hy:1,l:1});var TV;function UV(a){this.zS=0;this.CS=null;this.ES=this.DS=0;this.BS=null;this.AS=0;this.Hy=null;if(null===a)throw null;this.Hy=a;nR(this)}UV.prototype=new p;UV.prototype.constructor=UV;f=UV.prototype;f.$I=function(){return this.zS};f.JP=function(a){this.zS=a};f.Qk=function(){return this.CS};f.PL=function(a){this.CS=a};f.Ft=function(){return this.DS};f.My=function(a){this.DS=a};f.XS=function(){return this.ES};
-f.QL=function(a){this.ES=a};f.Ct=function(){return this.BS};f.IL=function(a){this.BS=a};f.SS=function(){return this.AS};f.RS=function(a){this.AS=a};f.jJ=function(a,b){a=new oR(a,b);null===this.Hy.kn?this.Hy.kn=a:(this.Hy.Xv.gm=a,a.Vv=this.Hy.Xv);return this.Hy.Xv=a};f.$classData=q({v9:0},!1,"scala.collection.mutable.LinkedHashMap$$anon$1",{v9:1,d:1,o9:1,q9:1});function VV(){}VV.prototype=new p;VV.prototype.constructor=VV;VV.prototype.Db=function(){return RV(new SV,new WV)};
-VV.prototype.Ib=function(a){if(!(a instanceof WV)){var b=new WV;a=cR(b,a)}return a};VV.prototype.U=function(){return new WV};VV.prototype.$classData=q({C9:0},!1,"scala.collection.mutable.LinkedHashSet$",{C9:1,d:1,Uf:1,l:1});var XV;function YV(){XV||(XV=new VV);return XV}function ZV(a){this.GS=0;this.JS=null;this.LS=this.KS=0;this.IS=null;this.HS=0;this.Iy=null;if(null===a)throw null;this.Iy=a;nR(this)}ZV.prototype=new p;ZV.prototype.constructor=ZV;f=ZV.prototype;f.$I=function(){return this.GS};
-f.JP=function(a){this.GS=a};f.Qk=function(){return this.JS};f.PL=function(a){this.JS=a};f.Ft=function(){return this.KS};f.My=function(a){this.KS=a};f.XS=function(){return this.LS};f.QL=function(a){this.LS=a};f.Ct=function(){return this.IS};f.IL=function(a){this.IS=a};f.SS=function(){return this.HS};f.RS=function(a){this.HS=a};f.jJ=function(a){a=new pR(a);null===this.Iy.Jy?this.Iy.Jy=a:(this.Iy.aC.kr=a,a.Yv=this.Iy.aC);return this.Iy.aC=a};
-f.$classData=q({D9:0},!1,"scala.collection.mutable.LinkedHashSet$$anon$1",{D9:1,d:1,o9:1,q9:1});function $V(){}$V.prototype=new p;$V.prototype.constructor=$V;f=$V.prototype;f.eF=function(a,b){return aW(0,a,b)};function aW(a,b,c){a=bW(c);return cR(a,b)}f.bv=function(a){return RV(new SV,bW(a))};f.Ch=function(a){return bW(a)};f.Fq=function(a,b){return aW(0,a,b)};f.$classData=q({e$:0},!1,"scala.collection.mutable.TreeMap$",{e$:1,d:1,fL:1,l:1});var cW;function dW(){cW||(cW=new $V);return cW}
-function eT(a,b){this.X2=a;this.Y2=b}eT.prototype=new p;eT.prototype.constructor=eT;eT.prototype.sk=function(a){return this.gl(a)};eT.prototype.gl=function(a){return this.X2.Fa(this.Y2,a)};eT.prototype.$classData=q({W2:0},!1,"scala.math.Ordered$$anon$1",{W2:1,d:1,Wi:1,xe:1});function eW(){}eW.prototype=new p;eW.prototype.constructor=eW;eW.prototype.$classData=q({Z2:0},!1,"scala.math.Ordering$",{Z2:1,d:1,Kaa:1,l:1});var fW;function mu(){fW||(fW=new eW);return fW}function gH(){}gH.prototype=new fM;
-gH.prototype.constructor=gH;function gW(){}gW.prototype=gH.prototype;function hW(){}hW.prototype=new p;hW.prototype.constructor=hW;function iW(){}iW.prototype=hW.prototype;hW.prototype.u=function(){return"\x3cfunction1\x3e"};hW.prototype.n=function(a){return this.Nb(a,XF().VQ)};var TG=q({x$:0},!1,"scala.runtime.Nothing$",{x$:1,jc:1,d:1,l:1});function U(a){this.j$=a}U.prototype=new QR;U.prototype.constructor=U;function Zr(a){return(0,a.j$)()}
-U.prototype.$classData=q({i$:0},!1,"scala.scalajs.runtime.AnonFunction0",{i$:1,rba:1,d:1,I$:1});function z(a){this.l$=a}z.prototype=new SR;z.prototype.constructor=z;z.prototype.n=function(a){return(0,this.l$)(a)};z.prototype.$classData=q({k$:0},!1,"scala.scalajs.runtime.AnonFunction1",{k$:1,ML:1,d:1,ja:1});function Um(a){this.n$=a}Um.prototype=new WR;Um.prototype.constructor=Um;Um.prototype.aa=function(a,b){return(0,this.n$)(a,b)};
-Um.prototype.$classData=q({m$:0},!1,"scala.scalajs.runtime.AnonFunction2",{m$:1,SG:1,d:1,Py:1});function jW(a){this.JL=a}jW.prototype=new ZR;jW.prototype.constructor=jW;jW.prototype.$classData=q({o$:0},!1,"scala.scalajs.runtime.AnonFunction3",{o$:1,tba:1,d:1,K$:1});class Xca extends oe{}function kW(){}kW.prototype=new p;kW.prototype.constructor=kW;function lW(){}lW.prototype=kW.prototype;class rk extends mS{constructor(a){super();fF(this,""+a,a instanceof oe?a:null,!0)}}
-rk.prototype.$classData=q({k0:0},!1,"java.lang.AssertionError",{k0:1,qF:1,jc:1,d:1,l:1});var Sa=q({m0:0},!1,"java.lang.Boolean",{m0:1,d:1,l:1,xe:1,Xs:1},a=>"boolean"===typeof a),jb=q({o0:0},!1,"java.lang.Character",{o0:1,d:1,l:1,xe:1,Xs:1},a=>a instanceof fa);function SK(a){var b=new mW;fF(b,a,null,!0);return b}class mW extends eF{}mW.prototype.$classData=q({ye:0},!1,"java.lang.RuntimeException",{ye:1,fd:1,jc:1,d:1,l:1});function nW(){this.Ox=null}nW.prototype=new p;nW.prototype.constructor=nW;
-function oW(a,b){a=a.Ox;a.ha=""+a.ha+b}function pW(a,b){a=a.Ox;b=String.fromCharCode(b);a.ha=""+a.ha+b}nW.prototype.NL=function(a,b){return this.Ox.ha.substring(a,b)};nW.prototype.u=function(){return this.Ox.ha};nW.prototype.bJ=function(a){var b=this.Ox;b.ha=""+b.ha+a};nW.prototype.$classData=q({Q0:0},!1,"java.lang.StringBuffer",{Q0:1,d:1,HJ:1,ZP:1,l:1});function CQ(a){a.ha="";return a}function tq(a,b){CQ(a);if(null===b)throw ze();a.ha=b;return a}
-function Xt(a){var b=new rq;CQ(b);if(0>a)throw new Uj;return b}function rq(){this.ha=null}rq.prototype=new p;rq.prototype.constructor=rq;function DQ(a,b,c,d){b=null===b?"null":b;c="string"===typeof b?b.substring(c,d):b.NL(c,d);a.ha=""+a.ha+c}function qW(a,b){b=tM(hH(),b,0,b.a.length);a.ha=""+a.ha+b}f=rq.prototype;f.u=function(){return this.ha};f.K=function(){return this.ha.length};f.NL=function(a,b){return this.ha.substring(a,b)};f.bJ=function(a){this.ha=""+this.ha+a};
-f.$classData=q({R0:0},!1,"java.lang.StringBuilder",{R0:1,d:1,HJ:1,ZP:1,l:1});function rW(a){return 0===a.Rh?(a=a.qg,!(-1===a.W&&-1===a.Z)):!1}function sW(a,b){var c=a.wb,d=c>>31,e=-c|0;c=0!==c?~d:-d|0;var g=tR(a);d=g>>31;g=e+g|0;e=(-2147483648^g)<(-2147483648^e)?1+(c+d|0)|0:c+d|0;if(0===e?-2147483629<(-2147483648^g):0<e)throw new zc("Rounding necessary");a=tW(a);if(Mh(bi(),a)<b)return a.ll();throw new zc("Rounding necessary");}
-function tR(a){return 0<a.tr?a.tr:1+Mc(.3010299956639812*(-1+a.Rh|0))|0}function yR(a,b){a.sr=b;a.Rh=Mh(bi(),b);64>a.Rh&&(a.qg=b.ll())}function uW(a){a.Ht=null;a.Bp=0;a.Rh=0;a.qg=ca;a.wb=0;a.tr=0}function dN(a,b){var c=new Mq;uW(c);c.qg=a;c.wb=b;c.Rh=$M(aN(),a);return c}function YM(a,b){var c=new Mq;uW(c);c.qg=new fb(a,a>>31);c.wb=b;aN();a=32-Math.clz32(0>a?~a:a)|0;c.Rh=a;return c}
-function Nq(a,b,c){uW(a);var d=-1+(0+c|0)|0;if(null===b)throw YK("in \x3d\x3d null");if(d>=b.a.length||0>=c||0>d)throw new IL("Bad offset/length: offset\x3d0 len\x3d"+c+" in.length\x3d"+b.a.length);var e=0;if(0<=d&&43===b.a[0]){if(e=1+e|0,e<d&&hN(aN(),b.a[e],new td(new Uint16Array([43,45]))))throw new IL("For input string: "+b.u());}else{c=e<=d&&45===b.a[e];var g=(1+e|0)<d&&hN(aN(),b.a[1+e|0],new td(new Uint16Array([43,45])));if(c&&g)throw new IL("For input string: "+b.u());}var h=e;for(c=!1;e<=d&&
-gN(aN(),b.a[e],new td(new Uint16Array([46,101,69])));)c||48===b.a[e]||(c=!0),e=1+e|0;g=e-h|0;g=tM(hH(),b,h,g);h=e-h|0;if(e<=d&&46===b.a[e]){for(var k=e=1+e|0;e<=d&&gN(aN(),b.a[e],new td(new Uint16Array([101,69])));)c||48===b.a[e]||(c=!0),e=1+e|0;a.wb=e-k|0;c=a.wb;hH();c=""+g+tM(0,b,k,c);g=h+a.wb|0}else a.wb=0,c=g,g=h;g|=0;if(e<=d&&hN(aN(),b.a[e],new td(new Uint16Array([101,69])))&&(e=1+e|0,h=(1+e|0)<=d&&45!==b.a[1+e|0],e=e<=d&&43===b.a[e]&&h?1+e|0:e,d=(1+d|0)-e|0,e=tM(hH(),b,e,d),b=a.wb,d=b>>31,h=
-BH(CH(),e,10),e=h>>31,h=b-h|0,a.wb=h,k=a.wb,h!==k||((-2147483648^h)>(-2147483648^b)?-1+(d-e|0)|0:d-e|0)!==k>>31))throw new IL("Scale out of range");if(19>g){e=dM();""===c&&ZL(c);d=0;b=!1;switch(c.charCodeAt(0)){case 43:d=1;break;case 45:d=1,b=!0}g=c.length;if(d>=g)ZL(c),e=void 0;else{h=(e.tF?e.sF:XL(e))[10];for(k=h.E0;;){if(e=d<g){e=$q();var l=c.charCodeAt(d);e=256>l?48===l:0<=Aj(fk(),AL(e),l)}if(e)d=1+d|0;else break}(g-d|0)>Math.imul(3,k)&&ZL(c);e=1+Kc(-1+(g-d|0)|0,k)|0;l=d+e|0;var m=$L(d,l,c);if(l===
-g)e=new fb(m,0);else{e=h.kQ;d=e.W;e=e.Z;k=l+k|0;var n=65535&m,r=m>>>16|0,u=65535&d,w=d>>>16|0,y=Math.imul(n,u);u=Math.imul(r,u);var B=Math.imul(n,w);n=y+((u+B|0)<<16)|0;y=(y>>>16|0)+B|0;m=((Math.imul(m,e)+Math.imul(r,w)|0)+(y>>>16|0)|0)+(((65535&y)+u|0)>>>16|0)|0;l=$L(l,k,c);l=n+l|0;m=(-2147483648^l)<(-2147483648^n)?1+m|0:m;k===g?e=new fb(l,m):(n=h.F0,h=n.W,n=n.Z,g=$L(k,g,c),(m===n?(-2147483648^l)>(-2147483648^h):m>n)&&ZL(c),n=65535&l,h=l>>>16|0,w=65535&d,k=d>>>16|0,r=Math.imul(n,w),w=Math.imul(h,
-w),y=Math.imul(n,k),n=r+((w+y|0)<<16)|0,r=(r>>>16|0)+y|0,e=(((Math.imul(l,e)+Math.imul(m,d)|0)+Math.imul(h,k)|0)+(r>>>16|0)|0)+(((65535&r)+w|0)>>>16|0)|0,d=n+g|0,e=(-2147483648^d)<(-2147483648^n)?1+e|0:e,-2147483648===(-2147483648^e)&&(-2147483648^d)<(-2147483648^g)&&ZL(c),e=new fb(d,e))}}d=e.W;e=e.Z;b?(b=-d|0,d=0!==d?~e:-e|0,(0===d?0!==b:0<d)&&ZL(c),c=new fb(b,d)):(0>e&&ZL(c),c=new fb(d,e));a.qg=c;a.Rh=$M(aN(),a.qg)}else yR(a,OL(c))}
-function wR(a,b,c){uW(a);if(null===b)throw YK("unscaledVal \x3d\x3d null");a.wb=c;yR(a,b);return a}function Mq(){this.Ht=null;this.Bp=0;this.sr=null;this.Rh=0;this.qg=ca;this.tr=this.wb=0}Mq.prototype=new fM;Mq.prototype.constructor=Mq;function vW(a){if(64>a.Rh){if(0>a.qg.Z)return-1;a=a.qg;var b=a.Z;return(0===b?0!==a.W:0<b)?1:0}return TM(a).Ya}
-function Pq(a){if(0===a.tr){if(0===a.Rh)var b=1;else if(64>a.Rh){var c=a.qg;if(0===c.W&&-2147483648===c.Z)b=19;else{fk();b=aN().Qy;if(0>c.Z){var d=c.W;c=c.Z;d=new fb(-d|0,0!==d?~c:-c|0)}else d=c;b:{c=0;for(var e=b.a.length;;){if(c===e){b=-1-c|0;break b}var g=(c+e|0)>>>1|0,h=b.a[g],k=Qb(new fb(h.W,h.Z));h=k.W;k=k.Z;h=Bb(Cb(),d.W,d.Z,h,k);if(0>h)e=g;else{if(0===h){b=g;break b}c=1+g|0}}}b=0>b?-1-b|0:1+b|0}}else b=1+Mc(.3010299956639812*(-1+a.Rh|0))|0,d=TM(a),c=pi(),b=0!==xR(d,$i(c,new fb(b,b>>31))).Ya?
-1+b|0:b;a.tr=b}return a.tr}function wW(a){if(rW(a))return a;var b=-1+pi().wr.a.length|0,c=1,d=TM(a),e=a=a.wb;for(a>>=31;;){if(vR(d,0))c=e,b=d,c=new fb(c,a);else{var g=xW(d,pi().wr.a[c]);if(0===g.XL.Ya){d=g.WL;var h=c;g=h>>31;var k=a;a=e-h|0;e=(-2147483648^a)>(-2147483648^e)?-1+(k-g|0)|0:k-g|0;c=c<b?1+c|0:c;g=e;e=a;a=g;continue}if(1!==c){c=1;continue}c=e;b=d;c=new fb(c,a)}break}c=Qb(c);d=Qb(new fb(c.W,c.Z));c=d.W;d=d.Z;return wR(new Mq,b,fN(aN(),new fb(c,d)))}
-function yW(a,b){var c=vW(a),d=vW(b);if(c===d){if(a.wb===b.wb&&64>a.Rh&&64>b.Rh){d=a.qg;c=b.qg;var e=d.Z,g=c.Z;if(e===g?(-2147483648^d.W)<(-2147483648^c.W):e<g)return-1;a=a.qg;b=b.qg;d=a.Z;c=b.Z;return(d===c?(-2147483648^a.W)>(-2147483648^b.W):d>c)?1:0}e=a.wb;g=e>>31;d=b.wb;var h=d>>31;d=e-d|0;e=(-2147483648^d)>(-2147483648^e)?-1+(g-h|0)|0:g-h|0;g=tR(a)-tR(b)|0;h=g>>31;var k=1+d|0,l=0===k?1+e|0:e;if(h===l?(-2147483648^g)>(-2147483648^k):h>l)return c;h=g>>31;k=-1+d|0;l=-1!==k?e:-1+e|0;if(h===l?(-2147483648^
-g)<(-2147483648^k):h<l)return-c|0;a=TM(a);b=TM(b);if(0>e)c=pi(),a=Vi(a,$i(c,new fb(-d|0,0!==d?~e:-e|0)));else if(0===e?0!==d:0<e)b=Vi(b,$i(pi(),new fb(d,e)));return PL(a,b)}return c<d?-1:1}f=Mq.prototype;f.h=function(a){if(a instanceof Mq&&a.wb===this.wb){if(64>this.Rh){a=a.qg;var b=this.qg;return a.W===b.W&&a.Z===b.Z}return this.sr.h(a.sr)}return!1};
-f.y=function(){if(0===this.Bp)if(64>this.Rh){this.Bp=this.qg.W;var a=this.qg.Z;this.Bp=Math.imul(33,this.Bp)+a|0;this.Bp=Math.imul(17,this.Bp)+this.wb|0}else this.Bp=Math.imul(17,this.sr.y())+this.wb|0;return this.Bp};
-f.u=function(){if(null!==this.Ht)return this.Ht;if(32>this.Rh)return this.Ht=gi(li(),this.qg,this.wb);var a=TM(this);a=ei(li(),a);if(0===this.wb)return a;var b=0>TM(this).Ya?2:1,c=a.length,d=this.wb,e=d>>31,g=-d|0;e=0!==d?~e:-e|0;var h=c>>31;d=g+c|0;e=(-2147483648^d)<(-2147483648^g)?1+(e+h|0)|0:e+h|0;h=b>>31;g=d-b|0;d=(-2147483648^g)>(-2147483648^d)?-1+(e-h|0)|0:e-h|0;0<this.wb&&(-1===d?2147483642<=(-2147483648^g):-1<d)?0<=d?(aN(),b=c-this.wb|0,aN(),a=a.substring(0,b)+"."+a.substring(b)):(aN(),aN(),
-c=-1+b|0,aN(),a=a.substring(0,c)+"0."+a.substring(c),b=1+b|0,c=aN().VL,g=-1-g|0,aN(),c=c.substring(0,g),a=""+a.substring(0,b)+c+a.substring(b)):(a=(1<=(c-b|0)?(aN(),aN(),a.substring(0,b)+"."+a.substring(b)):a)+"E",a=((0===d?0!==g:0<d)?a+"+":a)+JF(Cb(),g,d));return this.Ht=a};function zW(a){if(0===a.wb||rW(a))return TM(a);if(0>a.wb){var b=TM(a),c=pi();a=a.wb;var d=a>>31;return Vi(b,$i(c,new fb(-a|0,0!==a?~d:-d|0)))}b=TM(a);c=pi();a=a.wb;return xR(b,$i(c,new fb(a,a>>31)))}
-function tW(a){if(0===a.wb||rW(a))return TM(a);if(0>a.wb){var b=TM(a),c=pi();a=a.wb;var d=a>>31;return Vi(b,$i(c,new fb(-a|0,0!==a?~d:-d|0)))}if(a.wb>tR(a)||a.wb>AW(TM(a)))throw new zc("Rounding necessary");b=TM(a);c=pi();a=a.wb;a=uR(b,$i(c,new fb(a,a>>31)));if(0!==a.a[1].Ya)throw new zc("Rounding necessary");return a.a[0]}f.ll=function(){return-64>=this.wb||this.wb>tR(this)?ca:zW(this).ll()};f.Ri=function(){return-32>=this.wb||this.wb>tR(this)?0:zW(this).Ri()};
-f.Pu=function(){return RL(TL(),TM(this)+"e"+(-this.wb|0))};f.ap=function(){return KL(Ab(),TM(this)+"e"+(-this.wb|0))};function TM(a){null===a.sr&&(a.sr=zi(Zh(),a.qg));return a.sr}f.sk=function(a){return yW(this,a)};var bN=q({hT:0},!1,"java.math.BigDecimal",{hT:1,Kq:1,d:1,l:1,xe:1});Mq.prototype.$classData=bN;function BW(a){a.pC=-2;a.It=0}
-function HR(a,b,c){BW(a);Zh();if(null===b)throw ze();if(2>c||36<c)throw new IL("Radix out of range");if(""===b)throw new IL("Zero length BigInteger");if(""===b||"+"===b||"-"===b)throw new IL("Zero length BigInteger");var d=b.length;if(45===b.charCodeAt(0))var e=-1,g=1,h=-1+d|0;else 43===b.charCodeAt(0)?(g=e=1,h=-1+d|0):(e=1,g=0,h=d);e|=0;var k=g|0;g=h|0;for(h=k;h<d;){var l=b.charCodeAt(h);if(43===l||45===l)throw new IL("Illegal embedded sign character");h=1+h|0}h=li().ZG.a[c];l=rc(g,h);var m=Kc(g,
-h);0!==m&&(l=1+l|0);g=new zd(l);l=li().YG.a[-2+c|0];var n=0;for(m=k+(0===m?h:m)|0;k<d;){var r=BH(CH(),b.substring(k,m),c);pi();k=Qi(g,g,n,l);Di();var u=g,w=n,y=r;for(r=0;0!==y&&r<w;){var B=y;y=B+u.a[r]|0;B=(-2147483648^y)<(-2147483648^B)?1:0;u.a[r]=y;y=B;r=1+r|0}k=k+y|0;g.a[n]=k;n=1+n|0;k=m;m=k+h|0}a.Ya=e;a.ub=n;a.Pa=g;Wh(a);return a}function OL(a){var b=new MM;HR(b,a,10);return b}function yi(a,b){var c=new MM;BW(c);c.Ya=a;c.ub=1;c.Pa=new zd(new Int32Array([b]));return c}
-function Qh(a,b,c){var d=new MM;BW(d);d.Ya=a;d.ub=b;d.Pa=c;return d}function kN(a,b){var c=new MM;BW(c);c.Ya=a;a=b.Z;0===a?(c.ub=1,c.Pa=new zd(new Int32Array([b.W]))):(c.ub=2,c.Pa=new zd(new Int32Array([b.W,a])));return c}function MM(){this.Pa=null;this.It=this.pC=this.Ya=this.ub=0}MM.prototype=new fM;MM.prototype.constructor=MM;function OM(a){return 0>a.Ya?Qh(1,a.ub,a.Pa):a}function PL(a,b){return a.Ya>b.Ya?1:a.Ya<b.Ya?-1:a.ub>b.ub?a.Ya:a.ub<b.ub?-b.Ya|0:Math.imul(a.Ya,Ai(Di(),a.Pa,b.Pa,a.ub))}
-function xR(a,b){if(0===b.Ya)throw new zc("BigInteger divide by zero");var c=b.Ya;if(1===b.ub&&1===b.Pa.a[0])return 0<b.Ya?a:Ci(a);var d=a.Ya,e=a.ub,g=b.ub;if(2===(e+g|0))return a=a.Pa.a[0],b=b.Pa.a[0],e=Cb(),b=ki(e,a,0,b,0),a=e.Kc,d!==c&&(c=b,d=a,b=-c|0,a=0!==c?~d:-d|0),zi(Zh(),new fb(b,a));var h=e!==g?e>g?1:-1:Ai(Di(),a.Pa,b.Pa,e);if(0===h)return d===c?Zh().bw:Zh().oC;if(-1===h)return Zh().Dp;h=1+(e-g|0)|0;var k=new zd(h);c=d===c?1:-1;1===g?qi(oi(),k,a.Pa,e,b.Pa.a[0]):ni(oi(),k,h,a.Pa,e,b.Pa,g);
-c=Qh(c,h,k);Wh(c);return c}function uR(a,b){a=xW(a,b);return new (Nd(Ui).Ja)([a.WL,a.XL])}
-function xW(a,b){var c=b.Ya;if(0===c)throw new zc("BigInteger divide by zero");var d=b.ub;b=b.Pa;if(1===d){oi();b=b.a[0];var e=a.Pa,g=a.ub;d=a.Ya;1===g?(e=e.a[0],a=0===b?rc(0,0):+(e>>>0)/+(b>>>0)|0,g=0,b=0===b?Kc(0,0):+(e>>>0)%+(b>>>0)|0,e=0,d!==c&&(c=a,a=-c|0,g=0!==c?~g:-g|0),0>d&&(c=b,d=e,b=-c|0,e=0!==c?~d:-d|0),c=new Kh(zi(Zh(),new fb(a,g)),zi(Zh(),new fb(b,e)))):(c=d===c?1:-1,a=new zd(g),b=qi(0,a,e,g,b),b=new zd(new Int32Array([b])),c=Qh(c,g,a),d=Qh(d,1,b),Wh(c),Wh(d),c=new Kh(c,d));return c}g=
-a.Pa;e=a.ub;if(0>(e!==d?e>d?1:-1:Ai(Di(),g,b,e)))return new Kh(Zh().Dp,a);a=a.Ya;var h=1+(e-d|0)|0;c=a===c?1:-1;var k=new zd(h);b=ni(oi(),k,h,g,e,b,d);c=Qh(c,h,k);d=Qh(a,d,b);Wh(c);Wh(d);return new Kh(c,d)}f=MM.prototype;f.h=function(a){if(a instanceof MM){var b;if(b=this.Ya===a.Ya&&this.ub===a.ub)a:{for(b=0;b!==this.ub;){if(this.Pa.a[b]!==a.Pa.a[b]){b=!1;break a}b=1+b|0}b=!0}a=b}else a=!1;return a};
-function AW(a){if(0===a.Ya)return-1;var b=Nh(a);a=a.Pa.a[b];return(b<<5)+(0===a?32:31-Math.clz32(a&(-a|0))|0)|0}f.y=function(){if(0===this.It){for(var a=this.ub,b=0;b<a;){var c=b;this.It=Math.imul(33,this.It)+this.Pa.a[c]|0;b=1+b|0}this.It=Math.imul(this.It,this.Ya)}return this.It};f.Ri=function(){return Math.imul(this.Ya,this.Pa.a[0])};
-f.ll=function(){if(1<this.ub)var a=this.Pa.a[0],b=this.Pa.a[1];else a=this.Pa.a[0],b=0;var c=this.Ya,d=c>>31,e=65535&c,g=c>>>16|0,h=65535&a,k=a>>>16|0,l=Math.imul(e,h);h=Math.imul(g,h);var m=Math.imul(e,k);e=l+((h+m|0)<<16)|0;l=(l>>>16|0)+m|0;b=(((Math.imul(c,b)+Math.imul(d,a)|0)+Math.imul(g,k)|0)+(l>>>16|0)|0)+(((65535&l)+h|0)>>>16|0)|0;return new fb(e,b)};function Vi(a,b){return 0===b.Ya||0===a.Ya?Zh().Dp:Xi(pi(),a,b)}function Ci(a){return 0===a.Ya?a:Qh(-a.Ya|0,a.ub,a.Pa)}
-function aj(a,b){if(0>b)throw new zc("Negative exponent");if(0===b)return Zh().bw;if(1===b||a.h(Zh().bw)||a.h(Zh().Dp))return a;if(vR(a,0)){pi();for(var c=Zh().bw,d=a;1<b;)a=0!==(1&b)?Vi(c,d):c,1===d.ub?d=Vi(d,d):(c=new zd(d.ub<<1),c=Wi(d.Pa,d.ub,c),d=new MM,BW(d),0===c.a.length?(d.Ya=0,d.ub=1,d.Pa=new zd(new Int32Array([0]))):(d.Ya=1,d.ub=c.a.length,d.Pa=c,Wh(d))),b>>=1,c=a;return Vi(c,d)}for(c=1;!vR(a,c);)c=1+c|0;d=Zh();var e=Math.imul(c,b);if(e<d.XG.a.length)d=d.XG.a[e];else{d=e>>5;e&=31;var g=
-new zd(1+d|0);g.a[d]=1<<e;d=Qh(1,1+d|0,g)}return Vi(d,aj(Yi(a,c),b))}function Zi(a,b){return 0===b||0===a.Ya?a:0<b?Oh(bi(),a,b):Yh(bi(),a,-b|0)}function Yi(a,b){return 0===b||0===a.Ya?a:0<b?Yh(bi(),a,b):Oh(bi(),a,-b|0)}function vR(a,b){var c=b>>5;if(0===b)return 0!==(1&a.Pa.a[0]);if(0>b)throw new zc("Negative bit address");if(c>=a.ub)return 0>a.Ya;if(0>a.Ya&&c<Nh(a))return!1;var d=a.Pa.a[c];0>a.Ya&&(d=Nh(a)===c?-d|0:~d);return 0!==(d&1<<(31&b))}f.u=function(){return ei(li(),this)};
-function Wh(a){for(;;){if(0<a.ub&&(a.ub=-1+a.ub|0,0===a.Pa.a[a.ub]))continue;break}0===a.Pa.a[a.ub]&&(a.Ya=0);a.ub=1+a.ub|0}function Nh(a){if(-2===a.pC){if(0===a.Ya)var b=-1;else for(b=0;0===a.Pa.a[b];)b=1+b|0;a.pC=b}return a.pC}f.sk=function(a){return PL(this,a)};var Ui=q({jT:0},!1,"java.math.BigInteger",{jT:1,Kq:1,d:1,l:1,xe:1});MM.prototype.$classData=Ui;function nN(a,b){this.fQ=a;this.pF=b}nN.prototype=new kS;nN.prototype.constructor=nN;
-nN.prototype.$classData=q({tT:0},!1,"java.math.RoundingMode",{tT:1,saa:1,d:1,xe:1,l:1});function xM(a,b){null===a.Vu?a.Zs=""+a.Zs+b:CW(a,[b])}function DW(a,b,c){null===a.Vu?a.Zs=""+a.Zs+b+c:CW(a,[b,c])}function EW(a,b,c,d){null===a.Vu?a.Zs=a.Zs+(""+b+c)+d:CW(a,[b,c,d])}function CW(a,b){try{for(var c=b.length|0,d=0;d!==c;)a.Vu.bJ(b[d]),d=1+d|0}catch(e){throw e;}}function AM(a){return void 0!==a?(a=+parseInt(a,10),2147483647>=a?Mc(a):-2):-1}
-function FW(a){return(0!==(1&a)?"-":"")+(0!==(2&a)?"#":"")+(0!==(4&a)?"+":"")+(0!==(8&a)?" ":"")+(0!==(16&a)?"0":"")+(0!==(32&a)?",":"")+(0!==(64&a)?"(":"")+(0!==(128&a)?"\x3c":"")}function GW(a,b,c){var d=qk(a,1+b|0);a=d.Ys?"-":"";var e=d.Mq,g=-1+e.length|0,h=b-g|0;b=e.substring(0,1);e=""+e.substring(1)+ik(mk(),h);d=g-d.Lq|0;g=""+(0>d?-d|0:d);return a+(""!==e||c?b+"."+e:b)+"e"+(0>d?"-":"+")+(1===g.length?"0"+g:g)}
-function HW(a,b,c){var d=nk(a,(a.Mq.length+b|0)-a.Lq|0);mk();if(!("0"===d.Mq||d.Lq<=b))throw new rk("roundAtPos returned a non-zero value with a scale too large");d="0"===d.Mq||d.Lq===b?d:new pk(a.Ys,""+d.Mq+ik(mk(),b-d.Lq|0),b);a=d.Ys?"-":"";d=d.Mq;var e=d.length,g=1+b|0;d=e>=g?d:""+ik(mk(),g-e|0)+d;e=d.length-b|0;a+=d.substring(0,e);return 0!==b||c?a+"."+d.substring(e):a}function JM(a,b,c,d,e,g){b=0>e||e>=g.length?g:g.substring(0,e);b=0!==(256&c)?b.toUpperCase():b;GM(a,c,d,b)}
-function RM(a,b,c,d){GM(a,b,c,QM(b,d!==d?"NaN":0<d?0!==(4&b)?"+Infinity":0!==(8&b)?" Infinity":"Infinity":0!==(64&b)?"(Infinity)":"-Infinity"))}
-function NM(a,b,c,d,e){if(d.length>=c&&0===(110&b))b=QM(b,d),xM(a,b);else if(0===(126&b))GM(a,b,c,QM(b,d));else{if(45!==d.charCodeAt(0))var g=0!==(4&b)?"+":0!==(8&b)?" ":"";else 0!==(64&b)?(d=d.substring(1)+")",g="("):(d=d.substring(1),g="-");e=""+g+e;if(0!==(32&b)){var h=d.length;for(g=0;;){if(g!==h){var k=d.charCodeAt(g);k=48<=k&&57>=k}else k=!1;if(k)g=1+g|0;else break}g=-3+g|0;if(!(0>=g)){for(h=d.substring(g);3<g;)k=-3+g|0,h=d.substring(k,g)+","+h,g=k;d=d.substring(0,g)+","+h}}d=QM(b,d);PM(a,0,
-b,c,e,d)}}function QM(a,b){return 0!==(256&a)?b.toUpperCase():b}function GM(a,b,c,d){var e=d.length;e>=c?xM(a,d):0!==(1&b)?DW(a,d,IW(" ",c-e|0)):DW(a,IW(" ",c-e|0),d)}function PM(a,b,c,d,e,g){b=e.length+g.length|0;b>=d?DW(a,e,g):0!==(16&c)?EW(a,e,IW("0",d-b|0),g):0!==(1&c)?EW(a,e,g,IW(" ",d-b|0)):EW(a,IW(" ",d-b|0),e,g)}function IW(a,b){for(var c="",d=0;d!==b;)c=""+c+a,d=1+d|0;return c}function yM(a){throw new JW(String.fromCharCode(a));}function CM(a){throw new KW(a);}
-function SM(a,b,c,d,e,g){var h=0!==(2&c);d=0<=d?d:6;switch(e){case 101:h=GW(b,d,h);break;case 102:h=HW(b,d,h);break;default:e=0===d?1:d,b=qk(b,e),d=(-1+b.Mq.length|0)-b.Lq|0,-4<=d&&d<e?(e=-1+(e-d|0)|0,h=HW(b,0>e?0:e,h)):h=GW(b,-1+e|0,h)}NM(a,c,g,h,"")}function uM(){this.Zs=this.n1=this.Vu=null;this.PJ=!1}uM.prototype=new p;uM.prototype.constructor=uM;uM.prototype.u=function(){if(this.PJ)throw new wM;return null===this.Vu?this.Zs:this.Vu.u()};function DM(a){throw new LW(FW(a));}
-function FM(a,b,c){throw new MW(FW(b&c),a);}function KM(a,b){throw new NW(a,ja(b));}uM.prototype.$classData=q({i1:0},!1,"java.util.Formatter",{i1:1,d:1,fT:1,l0:1,gT:1});function OW(){}OW.prototype=new p;OW.prototype.constructor=OW;OW.prototype.Fa=function(a,b){return(a|0)-(b|0)|0};OW.prototype.jo=function(a,b,c){a.a[b]=c|0};OW.prototype.Lj=function(a,b){return a.a[b]};OW.prototype.$classData=q({T1:0},!1,"java.util.internal.GenericArrayOps$ByteArrayOps$",{T1:1,d:1,dB:1,zF:1,Si:1});var PW;
-function wj(){PW||(PW=new OW);return PW}function QW(){}QW.prototype=new p;QW.prototype.constructor=QW;QW.prototype.Fa=function(a,b){return Eb(a)-Eb(b)|0};QW.prototype.jo=function(a,b,c){a.a[b]=Eb(c)};QW.prototype.Lj=function(a,b){return hd(a.a[b])};QW.prototype.$classData=q({U1:0},!1,"java.util.internal.GenericArrayOps$CharArrayOps$",{U1:1,d:1,dB:1,zF:1,Si:1});var RW;function uj(){RW||(RW=new QW);return RW}function SW(){}SW.prototype=new p;SW.prototype.constructor=SW;
-SW.prototype.Fa=function(a,b){a|=0;b|=0;return a===b?0:a<b?-1:1};SW.prototype.jo=function(a,b,c){a.a[b]=c|0};SW.prototype.Lj=function(a,b){return a.a[b]};SW.prototype.$classData=q({V1:0},!1,"java.util.internal.GenericArrayOps$IntArrayOps$",{V1:1,d:1,dB:1,zF:1,Si:1});var TW;function kj(){TW||(TW=new SW);return TW}function UW(){}UW.prototype=new p;UW.prototype.constructor=UW;UW.prototype.Fa=function(a,b){var c=Qb(a);a=c.W;c=c.Z;var d=Qb(b);b=d.W;d=d.Z;return Bb(Cb(),a,c,b,d)};
-UW.prototype.jo=function(a,b,c){c=Qb(c);a.a[b]=new fb(c.W,c.Z)};UW.prototype.Lj=function(a,b){return a.a[b]};UW.prototype.$classData=q({W1:0},!1,"java.util.internal.GenericArrayOps$LongArrayOps$",{W1:1,d:1,dB:1,zF:1,Si:1});var VW;function qj(){VW||(VW=new UW);return VW}function WW(){}WW.prototype=new p;WW.prototype.constructor=WW;WW.prototype.Fa=function(a,b){return(a|0)-(b|0)|0};WW.prototype.jo=function(a,b,c){a.a[b]=c|0};WW.prototype.Lj=function(a,b){return a.a[b]};
-WW.prototype.$classData=q({Y1:0},!1,"java.util.internal.GenericArrayOps$ShortArrayOps$",{Y1:1,d:1,dB:1,zF:1,Si:1});var XW;function sj(){XW||(XW=new WW);return XW}function Yca(a,b,c){Jq();var d=new mf(new nf(J(new L,[""," `","` does not contain member `","`"])));qf();Q();var e=b.Kb.zd().td;e=pf(0,hu(0,e));qf();b=[e,pf(0,b.Kb.sf.w),pf(qf(),c.w)];d=sf(d,J(new L,b));c=c.C();c=G(new H,d,c);d=O().c;return Kq(0,new A(c,d),a.Qc,Qt())}
-var Zca=function YW(a,b,c,d,e,g,h,k,l){for(;;){if(b.Ca()<=c)return b;var n=!1,r=null,u=b;if(u instanceof wB)r=u,b=r.vg,r=r.Jf,d?(b=r,d=!0):d=!1;else{if(u instanceof yu)return b=u,r=b.Xb,new yu(a,YW(a,b.Mb,c,!d,e,g,h,k,l),YW(a,r,c,d,e,g,h,k,l),b.Bj);if(u instanceof nA)return b=u,r=b.dc,new nA(a,b.nc,YW(a,b.cc,c,d,e,g,h,k,l),YW(a,r,c,d,e,g,h,k,l),b.lE);if(u instanceof dv)return b=u,r=b.Ba,u=a,Du(),new dv(u,Mx(0,r,new z(((D,C,F,I,K,N,P,T)=>aa=>{var Y=aa.Ua,S=aa.Ma;S.b()?S=R():(S=S.o(),S=new M(YW(D,S,
-C,!F,I,K,N,P,T)));return new ww(Y,S,YW(D,aa.oa,C,F,I,K,N,P,T),aa.vd)})(a,c,d,e,g,h,k,l))),b.Cj);if(u instanceof Ru)return b=u,r=b.Ub,u=a,Du(),new Ru(u,Mx(0,r,new z(((D,C,F,I,K,N,P,T)=>aa=>{var Y=aa.Ua,S=aa.Ma;S.b()?S=R():(S=S.o(),S=new M(YW(D,S,C,!F,I,K,N,P,T)));return new ww(Y,S,YW(D,aa.oa,C,F,I,K,N,P,T),aa.vd)})(a,c,d,e,g,h,k,l))),b.gq);if(u instanceof fv){b=u;r=b.ld;n=u=a;var w=d,y=r.Ua,B=r.Ma;B.b()?n=R():(B=B.o(),n=new M(YW(n,B,c,!w,e,g,h,k,l)));return new fv(u,new ww(y,n,YW(a,r.oa,c,d,e,g,h,
-k,l),r.vd),b.ix)}if(u instanceof gv)return b=u,r=b.Ye,new gv(a,YW(a,b.Bc,c,d,e,g,h,k,l),r,b.Lo);if(u instanceof Ow&&(n=!0,r=u,DB(a),w=r.Wb,!w.b()))return d=w.o(),b=G(new H,r,!0),h.yd(b,new U(((D,C,F,I,K,N,P,T,aa)=>()=>{var Y=C.Zh;t();var S=new M(C),Z=C.dg,ka=O().c,X=O().c;Y=new Ow(D,C.Va,ka,X,S,Z,!1,Y);S=G(new H,C,!0);S=G(new H,S,Y);F.S(S);Z=YW(D,I,K,!0,N,P,F,T,aa);S=YW(D,I,K,!1,N,P,F,T,aa);hf(new E(Z),S)?jA(Y,(t(),new M(Z))):(gp(fp(),ny(Y).b()),gp(fp(),Tz(Y).b()),ka=O().c,kA(Y,new A(Z,ka)),Z=O().c,
-mA(Y,new A(S,Z)));return Y})(a,r,h,d,c,e,g,k,l)));if(n&&r.Va>e){d=!h.L(G(new H,r,!1));b=r;if(!d)throw new rk("assertion failed: "+G(new H,b,h));if(ny(r).b()&&Tz(r).b())return r;d=G(new H,r,!0);return h.yd(d,new U(((D,C,F,I,K,N,P,T)=>()=>{var aa=C.Zh;t();var Y=new M(C),S=C.dg,Z=O().c,ka=O().c;aa=new Ow(D,C.Va,Z,ka,Y,S,!1,aa);Y=G(new H,C,!0);Y=G(new H,Y,aa);F.S(Y);ka=ny(C);Y=(sa=>Ia=>YW(sa,Ia,I,!0,K,N,F,P,T))(D);if(ka===v())Y=v();else{S=ka.e();Z=S=new A(Y(S),v());for(ka=ka.g();ka!==v();){var X=ka.e();
-X=new A(Y(X),v());Z=Z.r=X;ka=ka.g()}Y=S}kA(aa,Y);ka=Tz(C);Y=(sa=>Ia=>YW(sa,Ia,I,!1,K,N,F,P,T))(D);if(ka===v())Y=v();else{S=ka.e();Z=S=new A(Y(S),v());for(ka=ka.g();ka!==v();)X=ka.e(),X=new A(Y(X),v()),Z=Z.r=X,ka=ka.g();Y=S}mA(aa,Y);return aa})(a,r,h,c,e,g,k,l)))}if(u instanceof jv)return b=u,TA(b,new z(((D,C,F,I,K,N,P,T)=>aa=>YW(D,aa,C,F,I,K,N,P,T))(a,c,d,e,g,h,k,l)),new z(((D,C,F,I,K,N,P,T)=>aa=>YW(D,aa,C,!F,I,K,N,P,T))(a,c,d,e,g,h,k,l)),new z(((D,C,F,I,K,N,P,T)=>aa=>YW(D,aa,C,F,I,K,N,P,T))(a,c,
-d,e,g,h,k,l)),b.ou);if(n)return b=G(new H,r,d),h.yd(b,new U(((D,C,F,I,K,N,P,T,aa)=>()=>{var Y=C.Zh;t();var S=new M(C),Z=C.dg,ka=O().c,X=O().c;Y=new Ow(D,F,ka,X,S,Z,!1,Y);S=G(new H,C,K);S=G(new H,S,Y);I.S(S);if(K){S=Tz(C);mA(C,new A(Y,S));X=ny(C);S=(Ia=>Za=>YW(Ia,Za,F,K,N,P,I,T,aa))(D);if(X===v())S=v();else{Z=X.e();ka=Z=new A(S(Z),v());for(X=X.g();X!==v();){var sa=X.e();sa=new A(S(sa),v());ka=ka.r=sa;X=X.g()}S=Z}kA(Y,S)}else{S=ny(C);kA(C,new A(Y,S));X=Tz(C);S=(Ia=>Za=>YW(Ia,Za,F,K,N,P,I,T,aa))(D);
-if(X===v())S=v();else{Z=X.e();ka=Z=new A(S(Z),v());for(X=X.g();X!==v();)sa=X.e(),sa=new A(S(sa),v()),ka=ka.r=sa,X=X.g();S=Z}mA(Y,S)}return Y})(a,r,c,h,d,e,g,k,l)));if(u instanceof oA)return b=u,new oA(a,YW(a,b.xc,c,d,e,g,h,k,l),b.Tz);if(u instanceof gA)return u;if(u instanceof qA)return b=u,new qA(a,YW(a,b.yi,c,d,e,g,h,k,l),b.oE);if(u instanceof sB&&(r=u,tB(a),t(),r=r.gc(),r=new M(r),!r.b())){b=r.k;continue}if(u instanceof Pw){r=u;n=r.Xh;if(r.nu>e){if(n=YW(a,n,c,d,e,g,h,k,l),n instanceof Ow)return new Pw(a,
-n,r.xs)}else if(r.nu>c)return new rB(a,!d,r,Mw(new Nw,r.xs.qu,r.xs.Ia,"extruded type variable reference",r.xs.An,r.xs.Bm),l);Dn("Program reached and unexpected state.")}if(u instanceof gu||u instanceof IB||u instanceof rB)return b;if(u instanceof uv)return b=u,r=b.ob,u=a,t(),new uv(u,r,qv(b,new M(d),new Um(((D,C,F,I,K,N,P)=>(T,aa)=>{T=G(new H,T,aa);aa=T.z;var Y=T.x;if(t().f===aa)return sv(rv(D),YW(D,Y,C,!1,F,I,K,N,P),YW(D,Y,C,!0,F,I,K,N,P),tv(rv(D)),I);aa=T.z;Y=T.x;if(aa instanceof M)return YW(D,
-Y,C,!!aa.k,F,I,K,N,P);throw new x(T);})(a,c,e,g,h,k,l)),g),b.Ml);if(u instanceof px)return b=u,r=b.Ld,new px(a,r,YW(a,b.ve,c,d,e<r?e:r,g,h,k,l));if(u instanceof yB){b=u;y=b.Aj;b=b.ej;r=a;u=((D,C,F,I,K,N,P)=>T=>{if(null!==T){var aa=T.j();T=YW(D,T.i(),C,!0,F,I,K,N,P);aa=YW(D,aa,C,!1,F,I,K,N,P);return G(new H,T,aa)}throw new x(T);})(a,c,e,g,h,k,l);if(y===v())u=v();else{n=y.e();w=n=new A(u(n),v());for(y=y.g();y!==v();)B=y.e(),B=new A(u(B),v()),w=w.r=B,y=y.g();u=n}return new yB(r,u,YW(a,b,c,d,e,g,h,k,
-l))}if(u instanceof Xu)return ZW(u,new z(((D,C,F,I,K,N,P,T)=>aa=>YW(D,aa,C,!F,I,K,N,P,T))(a,c,d,e,g,h,k,l)),new z(((D,C,F,I,K,N,P,T)=>aa=>YW(D,aa,C,F,I,K,N,P,T))(a,c,d,e,g,h,k,l)));throw new x(u);}}};
-function $W(a,b,c,d,e){var g=!1,h=null,k=b.Y(c.w);if(k instanceof M&&(g=!0,h=k,b=h.k,b instanceof Ew))return t(),e=b.no(),a=V(a),a=new ww(e.p,R(),e,a),new M(a);if(g&&(b=h.k,b instanceof xw))return d||b.tn||(d=new mf(new nf(J(new L,["Parameter '","' cannot tbe accessed as a field"]))),g=[pf(qf(),b.cj.Sa())],d=sf(d,J(new L,g)),c=c.C(),c=G(new H,d,c),d=sf(new mf(new nf(J(new L,["Either make the parameter a `val` or access it through destructuring"]))),v()),g=b.cj.C(),d=G(new H,d,g),g=O().c,yx(a,new A(c,
-new A(d,g)),e)),t(),new M(b.cg);if(g)return d=h.k,t(),b=new mf(new nf(J(new L,["Access to "," member not yet supported"]))),d=[pf(qf(),d.zd().td)],e=Xv(a,sf(b,J(new L,d)),c.C(),e),a=V(a),a=new ww(e.p,R(),e,a),new M(a);if(t().f===k)return t().f;throw new x(k);}
-function $ca(a){if(0>=a.$a(15))return a;var b=Ks(a,15),c=sf(new mf(new nf(J(new L,["......"]))),v()),d=t().f;c=G(new H,c,d);d=sf(new mf(new nf(J(new L,["......"]))),v());var e=t().f;d=G(new H,d,e);a=Eq(a).m().qn(15);je();a=jp(le(v(),a));return Fl(new A(c,new A(d,a)),b)}function aX(a,b,c){var d=new mf(new nf(J(new L,["Subtyping constraint of the form `"," \x3c: ","`"])));a=[nO(qf(),UC(a,b)),nO(qf(),WC(c,b))];return sf(d,J(new L,a))}
-function bX(a,b,c,d,e,g,h,k,l,m,n){var r=(g.ne-g.Hd|0)&(-1+g.ac.a.length|0);0<(250===r?0:250>r?-1:1)?(b=new mf(new nf(J(new L,[""," exceeded recursion depth limit (",")"]))),c=[aX(d,c,e),pf(qf(),"250")],b=sf(b,J(new L,c)),h=G(new H,b,h.Ia),a.aA?a.AE?(je(),b=le(v(),g),b=cX(oF(new Ms(b)),new z(u=>{if(null!==u){var w=u.i();u=u.j();var y=new mf(new nf(J(new L,["while constraining:  ",""]))),B=[pf(qf(),""+w)];y=sf(y,J(new L,B));w=G(new H,y,w.qa().Ia);y=new mf(new nf(J(new L,["                       \x3c!\x3c  ",
-""])));B=[pf(qf(),""+u)];y=sf(y,J(new L,B));u=G(new H,y,u.qa().Ia);y=O().c;return new A(w,new A(u,y))}throw new x(u);}))):(je(),b=le(v(),g),b=$ca(ht(oF(new Ms(b)),new z(u=>{var w=new mf(new nf(J(new L,["while constraining:  ",""])));u=[pf(qf(),u.i()+"  \x3c!\x3c  "+u.j())];w=sf(w,J(new L,u));u=t().f;return G(new H,w,u)})))):(b=sf(new mf(new nf(J(new L,["Note: use flag `:ex` to see internal error info."]))),v()),g=t().f,b=G(new H,b,g),g=O().c,b=new A(b,g)),yx(a,new A(h,b),k),Zr(l)):0>=m.Zd?(g=new mf(new nf(J(new L,
-[""," took too many steps and ran out of fuel (",")"]))),c=[aX(d,c,e),pf(qf(),""+n)],g=sf(g,J(new L,c)),h=G(new H,g,h.Ia),a.aA?(g=ht(b.i(),new z(u=>{var w=new mf(new nf(J(new L,[" + ",""]))),y=[pf(qf(),""+u)];w=sf(w,J(new L,y));return G(new H,w,u.qa().Ia)})),b=Fl(ht(b.j(),new z(u=>{var w=new mf(new nf(J(new L,[" - ",""]))),y=[pf(qf(),""+u)];w=sf(w,J(new L,y));return G(new H,w,u.qa().Ia)})),g)):(b=sf(new mf(new nf(J(new L,["Note: use flag `:ex` to see internal error info."]))),v()),g=t().f,b=G(new H,
-b,g),g=O().c,b=new A(b,g)),yx(a,new A(h,b),k),Zr(l)):m.Zd=-1+m.Zd|0}function dX(a,b,c,d){b=d+"."+b;a.D&&(a=Hs(Q(),"| ",a.q)+b,Af(Bf(),a+"\n"));c.n(b)}
-function eX(a,b,c,d,e,g,h,k,l,m,n,r,u,w,y){c=c.hb;var B=a.pa;if(a.D){var D=Hs(Q(),"| ",a.q)+"UNSTASHING...";Af(Bf(),D+"\n")}a.q=1+a.q|0;try{c.ya(new z(F=>{if(null!==F){var I=F.i();F=F.j();if(a.D){var K=Hs(Q(),"| ",a.q)+("where("+I+") ")+Yw(I);Af(Bf(),K+"\n")}for(F=F.m();F.s();)a:{if(K=F.t(),null!==K){var N=K.j();if(!0===K.Xc()){a.D&&(K=Hs(Q(),"| ",a.q)+("UNSTASH "+N+" \x3c: "+I+" where ")+Yw(N),Af(Bf(),K+"\n"));fX(a,N,I,!1,g,d,e,b,h,k,l,m,n,g,r,u,w,y,h);break a}}if(null!==K&&(N=K.j(),!1===K.Xc())){a.D&&
-(K=Hs(Q(),"| ",a.q)+("UNSTASH "+I+" \x3c: "+N+" where ")+Yw(N),Af(Bf(),K+"\n"));fX(a,I,N,!1,g,d,e,b,h,k,l,m,n,g,r,u,w,y,h);break a}throw new x(K);}}else throw new x(F);}));c.eg();var C=void 0}finally{a.q=-1+a.q|0}Gw(new E(B),a.pa)&&a.D&&(C=""+Hs(Q(),"| ",a.q)+B.n(C),Af(Bf(),C+"\n"))}
-function gX(a,b,c,d,e,g,h,k,l,m,n,r,u,w,y,B,D){var C=a.tf,F=O().c;YA(a);YA(a);YA(a);var I=Wp();b=JO(YA(a),C,F,b,!0,g,I);C=a.tf;F=O().c;YA(a);YA(a);YA(a);I=Wp();var K=JO(YA(a),C,F,c,!1,g,I);if(RA(K)){c=1+g.fa|0;C=ru().U();var N=new Uv(g.V,g.Vc,g.Xa,g.kd,c,g.Ac,g.vb,g.fb,g.ud,C),P=ru().U();c=a.tf;C=qF(Du(),K.Ff,new z(S=>S.Dc(K.db,!0,N,P)));var T=K.ae;if(T===v())F=v();else for(F=T.e(),I=F=new A(hX(F,K.db,!0,N,P),v()),T=T.g();T!==v();){var aa=T.e();aa=new A(hX(aa,K.db,!0,N,P),v());I=I.r=aa;T=T.g()}c=
-new HO(a,c,C,F);a.D&&(C=Hs(Q(),"| ",a.q)+("DNF BUMP TO LEVEL "+N.fa+"  --\x3e  ")+c,Af(Bf(),C+"\n"));iX(a,b,c,d,e,N,h,k,r,u,n,l,w,y,B,D,m);eX(a,g,N,d,e,k,m,n,r,u,l,w,y,B,D);a=N.hb;gp(fp(),g.V.$h||N.hb.b());if(!a.b()){d=g.V.pa;e=g.V;e.D&&(h=Hs(Q(),"| ",e.q)+"UNSTASHING... (out)",Af(Bf(),h+"\n"));e.q=1+e.q|0;try{a.ya(new z(((S,Z)=>ka=>{if(null!==ka){var X=ka.i();for(ka=ka.j().m();ka.s();){var sa=ka.t();a:{if(null!==sa){var Ia=sa.j();if(!0===sa.Xc()){sa=dw(S.V).Cb;ew(S.V,Ia,X,k,l,Z,sa);break a}}if(null!==
-sa&&(Ia=sa.j(),!1===sa.Xc())){sa=dw(S.V).Cb;ew(S.V,X,Ia,k,l,Z,sa);break a}throw new x(sa);}}}else throw new x(ka);})(g,g)));a.eg();var Y=void 0}finally{e.q=-1+e.q|0}Gw(new E(d),e.pa)&&e.D&&(g=""+Hs(Q(),"| ",e.q)+d.n(Y),Af(Bf(),g+"\n"))}}else iX(a,b,K,d,e,g,h,k,r,u,n,l,w,y,B,D,m)}
-function ada(a,b,c,d,e,g,h,k,l,m,n,r,u,w,y,B,D,C,F,I){var K=id();try{var N=ep(b);if(N instanceof M){var P=N.k,T=c.nf(!1),aa=(new FO(a,d,b.tk(P),e,g)).nf(!1),Y=V(aa.p),S=pA(aa,Y,!1),Z=V(T.p);fX(a,P,zu(T,S,Z,!1),!0,h,k,l,m,n,r,u,w,y,h,B,D,C,F,I)}else if(t().f===N){var ka=g.m(),X=new eg(ka,new z(rb=>{var pa=a.tf,Fa=O().c;YA(a);YA(a);var Ib=Wp();return JO(YA(a),pa,Fa,rb,!0,m,Ib)})),sa=a.tf,Ia=O().c,Za=e.nf(!1);YA(a);YA(a);for(var Ga=Wp(),xa=KO(c,JO(YA(a),sa,Ia,Za,!1,m,Ga),m,!0);X.s();){c=xa;var Ra=X.t();
-xa=KO(c,Ra,m,!0)}X=xa;if(a.D){var Ja=Hs(Q(),"| ",a.q)+("Consider "+d+" \x3c: ")+X;Af(Bf(),Ja+"\n")}Ja=!1;xa=null;if(d instanceof eu){Ja=!0;xa=d;var La=xa.lc,pb=xa.Jd,Fb=xa.be,Gb=xa.rf;if(La instanceof M){var Hb=La.k;if(Hb instanceof gv){var tb=Hb.Bc,kb=Hb.Ye;if(tb instanceof oA){var gb=tb.xc;if(gb instanceof Ow){var Vb=X.nf(!1),bb=(new eu(a,t().f,pb,Fb,Gb)).nf(!1),nb=V(bb.p),Tb=pA(bb,nb,!1),ub=V(Vb.p),Ub=zu(Vb,Tb,ub,!1),$a=JA(Ub,kb),cb=V($a.p);fX(a,pA($a,cb,!1),gb,!0,h,k,l,m,n,r,u,w,y,h,B,D,C,F,I);
-return}}}}}if(Ja){var Na=xa.lc,Ca=xa.Jd,Ba=xa.be,Oa=xa.rf;if(Na instanceof M){var wa=Na.k;if(wa instanceof gv){var ea=wa.Bc,la=wa.Ye;gp(fp(),ea instanceof Ow);var Ka=X.nf(!1),Ua=(new eu(a,t().f,Ca,Ba,Oa)).nf(!1),ya=V(Ua.p),ib=pA(Ua,ya,!1),Lb=V(Ka.p),ec=zu(Ka,ib,Lb,!1);fX(a,ea,JA(ec,la),!0,h,k,l,m,n,r,u,w,y,h,B,D,C,F,I);return}}}La=rb=>{if(et(new E(rb.$f),Av(a))&&rb.ag.b()&&rb.Sf.b()&&Bv(d,rb.Zf,m))throw a.D&&(rb=Hs(Q(),"| ",a.q)+("OK  "+d+" \x3c: ")+rb,Af(Bf(),rb+"\n")),new jX(K);if(Cx(b,rb.Sf)?0:
-!wv(d,rb.Zf,!1,m,!1).b()){rb=rb.$f;if(d instanceof eu){var pa=d.Jd;if(rb instanceof yv){a:{for(var Fa=rb.bc;!Fa.b();){var Ib=Fa.e();if(Ib instanceof IB&&pa.L(Ib)){pa=!0;break a}Fa=Fa.g()}pa=!1}if(pa)return!1}}return d instanceof eu&&(pa=d.lc,pa instanceof M&&(pa=pa.k,pa instanceof gu&&rb instanceof yv))?!rb.bc.L(pa):!0}return!1};var Mb=X.ae;a:for(var Jb;;)if(Mb.b()){Jb=v();break}else{var Kb=Mb.e(),eb=Mb.g();if(!1===!!La(Kb))Mb=eb;else for(;;){if(eb.b())Jb=Mb;else{var Wb=eb.e();if(!1!==!!La(Wb)){eb=
-eb.g();continue}Wb=eb;var mc=new A(Mb.e(),v()),ua=Mb.g();for(eb=mc;ua!==Wb;){var Pa=new A(ua.e(),v());eb=eb.r=Pa;ua=ua.g()}var xb=Wb.g();for(ua=xb;!xb.b();){var Yb=xb.e();if(!1===!!La(Yb)){for(;ua!==xb;){var zb=new A(ua.e(),v());eb=eb.r=zb;ua=ua.g()}ua=xb.g()}xb=xb.g()}ua.b()||(eb.r=ua);Jb=mc}break a}}if(a.D){var Sb=Hs(Q(),"| ",a.q)+"Possible: "+Jb;Af(Bf(),Sb+"\n")}var Ma=O().c;if(Jb===v())var Ea=v();else{var ab=Jb.e(),Db=new A(ab.nf(!1),v());mc=Db;for(var mb=Jb.g();mb!==v();){var vb=mb.e(),Ya=new A(vb.nf(!1),
-v());mc=mc.r=Ya;mb=mb.g()}Ea=Db}var Wa=Av(a);kX(a,Ma,d,Ea,Wa,k,l,n,m,"Case",u,w,r,y,h,B,D,C,F,I)}else throw new x(N);}catch(rb){if(rb instanceof gq){if(h=rb,h.Hg!==K)throw h;}else throw rb;}}
-function iX(a,b,c,d,e,g,h,k,l,m,n,r,u,w,y,B,D){var C=a.pa;if(a.D){var F=Hs(Q(),"| ",a.q)+(g.fa+". ARGH  "+b+"  \x3c!  ")+c;Af(Bf(),F+"\n")}a.q=1+a.q|0;try{a.Dm=1+a.Dm|0;bX(a,d,g,l,m,n,r,k,u,w,y);Os(fp(),!RA(c));c.Ff.b()||$n();var I=bda(b,g);if(null===I)throw new x(I);var K=I.i(),N=I.j(),P=a.pa;if(a.D){var T=Hs(Q(),"| ",a.q)+"DNF DISCHARGE CONSTRAINTS";Af(Bf(),T+"\n")}a.q=1+a.q|0;try{for(b=K;!b.b();){var aa=b.e();fX(a,aa.i(),aa.j(),!1,k,d,e,g,h,n,l,m,r,k,u,w,y,B,D);b=b.g()}var Y=void 0}finally{a.q=
--1+a.q|0}if(Gw(new E(P),a.pa)&&a.D){var S=""+Hs(Q(),"| ",a.q)+P.n(Y);Af(Bf(),S+"\n")}for(;!N.b();){var Z=N.e();if(null!==Z)ada(a,Z.ag,c,Z.Zf,Z.$f,Z.Sf,k,d,e,g,h,n,l,m,r,u,w,y,B,D);else throw new x(Z);N=N.g()}var ka=void 0}finally{a.q=-1+a.q|0}Gw(new E(C),a.pa)&&a.D&&(a=""+Hs(Q(),"| ",a.q)+C.n(ka),Af(Bf(),a+"\n"))}function kX(a,b,c,d,e,g,h,k,l,m,n,r,u,w,y,B,D,C,F,I){a.Dm=1+a.Dm|0;bX(a,g,l,n,r,u,w,y,B,D,C);cda(a,b,c,d,e,g,h,l,k,m,y,w,u,n,r,B,D,C,F,I)}
-function dda(a,b,c,d){a=a.m().mb(new U(()=>b.iC()));a=new eg(a,new z(e=>{var g=V(e.p);return pA(e,g,!1)}));return Cu(a,new U(()=>c.m())).mb(new U(()=>d.iC()))}function eda(a,b,c,d,e){b=dda(b,c,d,e);if(b.s()){if(!b.s())throw Fu("empty.reduceLeft");c=!0;for(d=null;b.s();)if(e=b.t(),c)d=e,c=!1;else{var g=V(d.p);d=zu(d,e,g,!1)}b=new M(d)}else b=R();return b.b()?a.tb:b.o()}
-function fda(a,b,c,d){return a.m().mb(new U(()=>b.iC())).mb(new U(()=>{var e=c.m().mb(new U(()=>d.iC()));return new eg(e,new z(g=>{var h=V(g.p);return pA(g,h,!1)}))}))}function gda(a,b,c,d,e){b=fda(c,d,b,e);if(b.s()){if(!b.s())throw Fu("empty.reduceLeft");c=!0;for(d=null;b.s();)if(e=b.t(),c)d=e,c=!1;else{var g=V(d.p);d=ju(d,e,g,!1)}b=new M(d)}else b=R();return b.b()?a.Na:b.o()}
-function cda(a,b,c,d,e,g,h,k,l,m,n,r,u,w,y,B,D,C,F,I){var K=id();try{kx(a,new U(()=>k.fa+". A  "+c+"  %  "+b+"  \x3c!  "+d+"  %  "+e),new U(()=>{var P=G(new H,b,d);a:{var T=P.z;if(T instanceof A){var aa=T.A,Y=T.r;if(aa instanceof Ow){fX(a,aa,eda(a,Y,c,d,e),Dv(c)&&Y.il(new z(kf=>lA(kf,k))),n,g,h,k,l,u,w,y,r,n,B,D,C,F,I);break a}}var S=P.x;if(S instanceof A){var Z=S.A,ka=S.r;if(Z instanceof Ow){fX(a,gda(a,ka,b,c,e),Z,Tv(e)&&ka.il(new z(kf=>Yu(kf,k))),n,g,h,k,l,u,w,y,r,n,B,D,C,F,I);break a}}var X=P.z;
-if(X instanceof A){var sa=X.A,Ia=X.r;if(sa instanceof wB){kX(a,new A(sa.Jf,Ia),c,d,e,g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break a}}var Za=P.x;if(Za instanceof A){var Ga=Za.A,xa=Za.r;if(Ga instanceof wB){kX(a,b,c,new A(Ga.vg,xa),e,g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break a}}var Ra=P.z;if(Ra instanceof A){var Ja=Ra.A,La=Ra.r;if(Ja instanceof nA){var pb=Ja.cc,Fb=Ja.dc;if(!0===Ja.nc){dX(a,"1",new z(kf=>{kX(a,new A(pb,La),c,d,e,g,h,l,k,kf,w,y,u,r,n,B,D,C,F,I)}),m);dX(a,"2",new z(kf=>{kX(a,new A(Fb,La),c,d,e,g,h,
-l,k,kf,w,y,u,r,n,B,D,C,F,I)}),m);break a}}}var Gb=P.x;if(Gb instanceof A){var Hb=Gb.A,tb=Gb.r;if(Hb instanceof nA){var kb=Hb.cc,gb=Hb.dc;if(!1===Hb.nc){dX(a,"1",new z(kf=>{kX(a,b,c,new A(kb,tb),e,g,h,l,k,kf,w,y,u,r,n,B,D,C,F,I)}),m);dX(a,"2",new z(kf=>{kX(a,b,c,new A(gb,tb),e,g,h,l,k,kf,w,y,u,r,n,B,D,C,F,I)}),m);break a}}}var Vb=P.x;if(Vb instanceof A){var bb=Vb.A,nb=Vb.r;if(bb instanceof nA){var Tb=bb.cc,ub=bb.dc;if(!0===bb.nc){kX(a,b,c,new A(Tb,new A(ub,nb)),e,g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break a}}}var Ub=
-P.z;if(Ub instanceof A){var $a=Ub.A,cb=Ub.r;if($a instanceof nA){var Na=$a.cc,Ca=$a.dc;if(!1===$a.nc){kX(a,new A(Na,new A(Ca,cb)),c,d,e,g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break a}}}var Ba=P.z;if(Ba instanceof A){var Oa=Ba.A,wa=Ba.r;if(Oa instanceof sB){tB(a);t();var ea=Oa.gc(),la=new M(ea);if(!la.b()){kX(a,new A(la.k,wa),c,d,e,g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break a}}}var Ka=P.x;if(Ka instanceof A){var Ua=Ka.A,ya=Ka.r;if(Ua instanceof sB){tB(a);t();var ib=Ua.gc(),Lb=new M(ib);if(!Lb.b()){kX(a,b,c,new A(Lb.k,
-ya),e,g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break a}}}var ec=P.z;if(ec instanceof A){var Mb=ec.A,Jb=ec.r;if(Mb instanceof oA){kX(a,Jb,c,new A(Mb.xc,d),e,g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break a}}var Kb=P.x;if(Kb instanceof A){var eb=Kb.A,Wb=Kb.r;if(eb instanceof oA){kX(a,new A(eb.xc,b),c,Wb,e,g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break a}}var mc=P.z;if(mc instanceof A){var ua=mc.A;if(ua instanceof gA&&!0===ua.sh)break a}var Pa=P.x;if(Pa instanceof A){var xb=Pa.A;if(xb instanceof gA&&!1===xb.sh)break a}var Yb=P.z,
-zb=P.x;if(Yb instanceof A){var Sb=Yb.A,Ma=Yb.r;if(Sb instanceof gA&&!1===Sb.sh){kX(a,Ma,c,zb,e,g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break a}}var Ea=P.z,ab=P.x;if(ab instanceof A){var Db=ab.A,mb=ab.r;if(Db instanceof gA&&!0===Db.sh){kX(a,Ea,c,mb,e,g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break a}}var vb=P.z,Ya=P.x;if(vb instanceof A){var Wa=vb.A,rb=vb.r;if(Wa instanceof uv){var pa=mv(c,Wa,!0,k,!1),Fa=new U(()=>{throw new jX(K,(mx(a,new U(()=>"OK  "+c+" \x26 "+Wa+"  \x3d:\x3d  "+a.tb)),void 0));});kX(a,rb,pa.b()?Zr(Fa):
-pa.o(),Ya,e,g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break a}}var Ib=P.z,qb=P.x;if(qb instanceof A){var Nb=qb.A,fc=qb.r;if(Nb instanceof uv){var Ac=Jv(e,Nb,!1,k),tc=new U(()=>{throw new jX(K,(mx(a,new U(()=>"OK  "+e+" \x26 "+Nb+"  \x3d:\x3d  "+a.Na)),void 0));});kX(a,Ib,c,fc,Ac.b()?Zr(tc):Ac.o(),g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break a}}var vc=P.z,sc=P.x;if(vc instanceof A){var uc=vc.A,lc=vc.r;if(uc instanceof lX){var Wc=Qu(c,uc,!0,k,!0),Cc=new U(()=>{throw new jX(K,(mx(a,new U(()=>"OK  "+c+" \x26 "+uc+"  \x3d:\x3d  "+
-a.tb)),void 0));});kX(a,lc,Wc.b()?Zr(Cc):Wc.o(),sc,e,g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break a}}var Dc=P.z,Ec=P.x;if(Ec instanceof A){var Ic=Ec.A,Xc=Ec.r;if(Ic instanceof lX){var Sc=Mv(e,Ic),oc=new U(()=>{throw new jX(K,(mx(a,new U(()=>"OK  "+e+" | "+Ic+"  \x3d:\x3d  "+a.Na)),void 0));});kX(a,Dc,c,Xc,Sc.b()?Zr(oc):Sc.o(),g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break a}}var qc=P.z,Tc=P.x;if(qc instanceof A){var Nc=qc.A,Pc=qc.r;if(Nc instanceof dv){kX(a,Pc,kv(c,Nc),Tc,e,g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break a}}var Oc=
-P.x;if(Oc instanceof A){var $c=Oc.A;if($c instanceof dv){var Lc=$c.Ba,Zb=O().c;if(null===Zb?null===Lc:Zb.h(Lc))break a}}var ed=P.z,$b=P.x;if($b instanceof A){var Fc=$b.A,Yc=$b.r;if(Fc instanceof dv){var nc=Fc.Ba;if(nc instanceof A){var Ob=nc.A,cc=nc.r,Gc=O().c;if(null===Gc?null===cc:Gc.h(cc)){var Bc=Nv(e,Ob),qd=new U(()=>{throw new jX(K,(mx(a,new U(()=>"OK  "+e+" | "+Ob+"  \x3d:\x3d  "+a.Na)),void 0));});kX(a,ed,c,Yc,Bc.b()?Zr(qd):Bc.o(),g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break a}}}}var Gd=P.z,cd=P.x;
-if(cd instanceof A){var rd=cd.A,Id=cd.r;if(rd instanceof dv){var Ha=hda(rd);kX(a,Gd,c,new A(Ha,Id),e,g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break a}}var jc=P.x;if(jc instanceof A&&jc.A instanceof px)var Rb=!0;else{var Uc=P.z;Rb=Uc instanceof A&&Uc.A instanceof px?!0:!1}Rb&&Dn("Program reached and unexpected state.");var Rc=P.x;if(Rc instanceof A&&Rc.A instanceof yB)var Cd=!0;else{var od=P.z;Cd=od instanceof A&&od.A instanceof yB?!0:!1}Cd&&Dn("Program reached and unexpected state.");var Va=P.z,wb=P.x,db=O().c;
-if(null===db?null===Va:db.h(Va))var Jc=O().c,Vc=null===Jc?null===wb:Jc.h(wb);else Vc=!1;if(Vc){var Ta=G(new H,c,e);b:{var kd=Ta.z,ld=Ta.x;if(kd instanceof eu){var qe=kd.lc;if(qe instanceof M){var Wd=qe.k;if(Wd instanceof gv){var Rd=Wd.Bc;if(Av(a)===ld){fX(a,Rd,a.tb,!0,n,g,h,k,l,u,w,y,r,n,B,D,C,F,I);break b}}}}c:{var Me=Ta.z;if(pu(a)===Me)var wc=!0;else{var Xb=Ta.z;if(Xb instanceof eu){var gc=Xb.lc,hc=Xb.Jd,gd=Xb.be,kc=Xb.rf;if(t().f===gc&&null!==hc&&hc.b()&&null!==gd){var ud=gd.Ba,za=O().c;if((null===
-za?null===ud:za.h(ud))&&null!==kc&&kc.b()){wc=!0;break c}}}wc=!1}}if(wc)mX(a,t().f,g,k,r,n);else{var Qa=Ta.z,xc=Ta.x;if(Qa instanceof eu){var yd=Qa.Jd;if(xc instanceof yv){var be=xc.bc;if(Cx(yd,new z(kf=>be.L(kf))))break b}}var yc=Ta.z;if(yc instanceof eu){var Od=yc.lc,sd=yc.Jd,he=yc.be,ue=yc.rf;if(!ue.b()){var sg=new iu(ue),Se=new eg(sg,new z(kf=>xC(kf,k,n)));je();var Kf=le(v(),Se),$e=Ku(),rf=mu(),He=ap().wa;kX(a,Kf,new eu(a,Od,sd,he,$e.Ch(new ou(rf,He))),O().c,e,g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break b}}var Ze=
-Ta.x;if(Ze instanceof yv){var jf=Ze.bc,tf=Ze.lb,Te=Ze.Ic;if(!Te.b()){var hg=O().c,eh=new iu(Te),fh=new eg(eh,new z(kf=>xC(kf,k,n)));je();var tg=le(v(),fh),Jg=Ku(),Gh=mu(),zg=ap().wa;kX(a,hg,c,tg,new yv(a,jf,tf,Jg.Ch(new ou(Gh,zg))),g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break b}}var ig=Ta.x;if(ig instanceof yv){var qh=ig.bc,gh=ig.lb,Wg=ig.Ic;if(gh instanceof M){var Uf=gh.k;if(Uf instanceof te){var rh=Uf.ca;if(rh instanceof Xu){for(var Rh=new z(kf=>{var Mk=O().c,nj=O().c;t();t();kX(a,Mk,c,nj,new yv(a,qh,new M(new te(kf)),
-Wg),g,h,l,k,m,w,y,u,r,n,B,D,C,F,I)}),Sg=rh.Wh;!Sg.b();)Rh.n(Sg.e()),Sg=Sg.g();break b}}}}var Hh=Ta.z;Hh instanceof eu&&(Hh.rf.b()||Dn("Program reached and unexpected state."));var Xg=Ta.x;Xg instanceof yv&&(Xg.Ic.b()||Dn("Program reached and unexpected state."));c:{var jg=Ta.x;if(Av(a)===jg)var Ag=!0;else{var Cf=Ta.x;if(Cf instanceof yv){var Bg=Cf.bc,Lf=Cf.lb,Df=O().c;if((null===Df?null===Bg:Df.h(Bg))&&t().f===Lf){Ag=!0;break c}}Ag=!1}}if(Ag)mX(a,t().f,g,k,r,n);else{var kg=Ta.z,df=Ta.x;if(kg instanceof
-eu){var Kg=kg.lc;if(Kg instanceof M){var Mf=Kg.k;if(Mf instanceof yu&&df instanceof yv){var Vf=df.lb;if(Vf instanceof M){var Cg=Vf.k;if(Cg instanceof te){var Ef=Cg.ca;if(Ef instanceof yu){fX(a,Mf,Ef,!0,n,g,h,k,l,u,w,y,r,n,B,D,C,F,I);break b}}}}}}var Wf=Ta.z,de=Ta.x;if(Wf instanceof eu){var Ee=Wf.lc,Sh=Wf.Jd,hi=Wf.be,vi=Wf.rf;if(Ee instanceof M&&Ee.k instanceof yu&&de instanceof yv){kX(a,O().c,new eu(a,t().f,Sh,hi,vi),O().c,e,g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break b}}var Lg=Ta.z,Tg=Ta.x;if(Lg instanceof
-eu){var cj=Lg.lc;if(cj instanceof M&&cj.k instanceof gu&&Tg instanceof yv&&Fba(new E(a.VO),Tg.bc)){mx(a,new U(()=>"OK ~ magic Eql ~"));break b}}var Cj=Ta.z,Dj=Ta.x;if(Cj instanceof eu){var wi=Cj.lc;if(wi instanceof M){var Ki=wi.k;if(Ki instanceof gu){var Yg=Ki.ed;if(Yg instanceof fm&&Dj instanceof yv){var dj=Dj.lb;if(dj instanceof M){var ii=dj.k;if(ii instanceof me){var ji=ii.ia;if(null!==ji){var Th=ji.pe,Ej=ji.qe;if(null!==Th&&"Eql#A"===Th.w){if(Yg instanceof Do||Yg instanceof Ho){var ej=Ej.Ma,xd=
-new U(()=>a.Na);fX(a,ej.b()?Zr(xd):ej.o(),a.pk,!1,n,g,h,k,l,u,w,y,r,n,B,D,C,F,I)}else if(Yg instanceof Io){var ke=Ej.Ma,Ie=new U(()=>a.Na);fX(a,ke.b()?Zr(Ie):ke.o(),a.Fj,!1,n,g,h,k,l,u,w,y,r,n,B,D,C,F,I)}else if(Yg instanceof Jo)mX(a,t().f,g,k,r,n);else throw new x(Yg);break b}}}}}}}}var Qf=Ta.z,hh=Ta.x;if(Qf instanceof eu){var lg=Qf.lc,Uh=Qf.Jd,Zg=Qf.be;if(lg instanceof M){var Vh=lg.k;if(Vh instanceof gu){var fj=Vh.ed;if(fj instanceof Wl){var gj=fj.w;if(hh instanceof yv){var Li=hh.lb;if(Li instanceof
-M){var Mi=Li.k;if(Mi instanceof me){var hj=Mi.ia;if(null!==hj){var Fj=hj.pe,Qj=hj.qe;if(k.fb.L(gj)){if(a.Qc&&sr(new E(gj),"Eql")&&"Eql#A"===Fj.w){var Ni=k.fb.n(gj);if(Rw(Ni).b()&&!a.Em.L(gj)){var Gj=new mf(new nf(J(new L,[""," '","' does not support equality comparison because it does not have a parameter list"])));qf();Q();var Hj=Ni.Kb.zd().td,lk=pf(0,hu(0,Hj));qf();var md=[lk,pf(0,Ni.Kb.sf.w)];Xv(a,sf(Gj,J(new L,md)),r.Ia,n)}for(var Ue=Rw(Ni),Jd=new U(()=>O().c),uf=Ue.b()?Zr(Jd):Ue.o(),Dl=new z(kf=>
-{var Mk=new U(()=>c.nf(!0));t();var nj=new M(gj),Yo=Zg.Ba;ap();var CE=bp(cp(),Yo);nj=nX(a,Mk,nj,new z(IS=>CE.Y(IS)),Uh,kf.i(),k,n);Mk=Qj.Ma;Yo=new U(()=>{Dn("Program reached and unexpected state.")});Mk=Mk.b()?Zr(Yo):Mk.o();kf=kf.i();Yo=new sp("Eql");nj=nj.oa;var HS=O().c;nj=new uv(a,Yo,new A(nj,HS),V(a));Yo=V(a);nj=new ww(nj.p,R(),nj,Yo);kf=G(new H,kf,nj);nj=O().c;fX(a,Mk,new dv(a,new A(kf,nj),V(a)),!1,n,g,h,k,l,u,w,y,r,n,B,D,C,F,I)}),gl=uf;!gl.b();)Dl.n(gl.e()),gl=gl.g()}else{var am=new U(()=>c.nf(!0));
-t();var xk=new M(gj),Ae=Zg.Ba;ap();var Ff=bp(cp(),Ae),vf=nX(a,am,xk,new z(kf=>Ff.Y(kf)),Uh,Fj,k,n);fX(a,vf.oa,Qj.oa,!1,n,g,h,k,l,u,w,y,r,n,B,D,C,F,I);oX(a,Qj,vf,n,g,h,k,l,u,r,n,w,y,B,D,C,F,I)}break b}}}}}}}}}var Xf=Ta.z,Ij=Ta.x;if(Xf instanceof eu){var Rj=Xf.lc,hl=Xf.Jd,El=Xf.be,on=Xf.rf;if(Rj instanceof M){var Oi=Rj.k;if(Oi instanceof gu&&Ij instanceof yv){var ee=Ij.bc,Re=Ij.lb,Ji=Ij.Ic;mx(a,new U(()=>"class checking "+Oi+" "+ee));ee.Ln(new z(kf=>hf(new E(kf.Pn()),Oi.ed)?!0:(Xf.RD?Xf.QD:zv(Xf)).L(kf.Pn())))?
-mx(a,new U(()=>"OK  "+Oi+"  \x3c:  "+Qe(ee,""," | ",""))):kX(a,O().c,new eu(a,t().f,hl,El,on),O().c,new yv(a,O().c,Re,Ji),g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);void 0;break b}}}var jk=Ta.z,Vg=Ta.x;if(jk instanceof eu&&Vg instanceof xv){var kk=O().c,eo=O().c,dr=O().c;t();t();var Ud=new M(new me(Vg)),ne=Ku(),Fe=mu(),Bk=ap().wa;kX(a,kk,jk,eo,new yv(a,dr,Ud,ne.Ch(new ou(Fe,Bk))),g,h,l,k,m,w,y,u,r,n,B,D,C,F,I)}else{var sn=Ta.z,Hc=Ta.x;if(sn instanceof eu){var Sd=sn.lc,Hd=sn.Jd,Be=sn.be;if(t().f===Sd&&Hc instanceof
-yv){var mj=Hc.lb;if(mj instanceof M){var bm=mj.k;if(bm instanceof me){var Km=bm.ia;if(null!==Km){var tn=Km.pe,ut=Km.qe;if(a.Qc){var pE=new U(()=>c.nf(!0)),qE=t().f,vt=Be.Ba;ap();var zz=bp(cp(),vt),gw=nX(a,pE,qE,new z(kf=>zz.Y(kf)),Hd,tn,k,n);fX(a,gw.oa,ut.oa,!1,n,g,h,k,l,u,w,y,r,n,B,D,C,F,I);oX(a,ut,gw,n,g,h,k,l,u,r,n,w,y,B,D,C,F,I);break b}}}}}}var qs=Ta.z,er=Ta.x;if(qs instanceof eu){var hw=qs.lc,iw=qs.be;if(er instanceof yv){var rE=er.bc,wt=er.lb,xt=er.Ic;if(wt instanceof M){var Az=wt.k;if(Az instanceof
-me){var jw=Az.ia;if(null!==jw){var kw=jw.pe,lw=jw.qe,rs=pX(iw.Ba,new z(kf=>hf(new E(kf.i()),kw)));if(rs instanceof M){var ss=rs.k;oX(a,lw,ss.j(),n,g,h,k,l,u,r,n,w,y,B,D,C,F,I);fX(a,ss.j().oa,lw.oa,!1,n,g,h,k,l,u,w,y,r,n,B,D,C,F,I)}else if(t().f===rs)c:{if(hw instanceof M){var ts=hw.k;if(ts instanceof gv){var Bz=ts.Bc;if(ts.Ye.L(kw)){var sE=new yv(a,rE,t().f,xt);fX(a,Bz,sE.nf(!1),!0,n,g,h,k,l,u,w,y,r,n,B,D,C,F,I)}else fX(a,Bz,e.nf(!1),!0,n,g,h,k,l,u,w,y,r,n,B,D,C,F,I);break c}}mX(a,t().f,g,k,r,n)}else throw new x(rs);
-break b}}}}}var mw=Ta.z,yt=Ta.x;if(mw instanceof eu){var tE=mw.lc,nw=mw.Jd;if(t().f===tE&&yt instanceof yv){var ow=yt.bc,fr=yt.lb;if(t().f===fr){mx(a,new U(()=>"Tag checking "+nw+" "+ow));ow.Ln(new z(kf=>{var Mk=nw.m();Mk=new ho(Mk,new z(nj=>{if(nj instanceof IB){var Yo=nj.Io;nj=nj.nI;nj=ht((je(),le(v(),nj)),new z(CE=>new Wl(CE.X)));return new A(Yo,nj)}return O().c}));return Vca(Mk,kf.Pn())}))?mx(a,new U(()=>"OK "+nw+" \x3c: "+ow)):mX(a,t().f,g,k,r,n);void 0;break b}}}var Cz=Ta.z,Dz=Ta.x;if(Cz instanceof
-eu){var uE=Cz.lc;if(t().f===uE&&Dz instanceof yv){var us=Dz.lb;if(us instanceof M){var vs=us.k;if(vs instanceof te&&(vs.ca instanceof yu||vs.ca instanceof iv)){mX(a,t().f,g,k,r,n);break b}}}}var zt=Ta.z,pw=Ta.x;if(zt instanceof eu){var qw=zt.lc;if(qw instanceof M){var At=qw.k;if(At instanceof Ru&&pw instanceof yv){var Ez=pw.lb;if(Ez instanceof M){var Xo=Ez.k;if(Xo instanceof te){var gr=Xo.ca;if(gr instanceof Ru){var Fz=At.Ub.K();if(hf(new E(Fz),gr.Ub.K())){var Gz=At.Ub,rw=ap(),Hz=Gz.Gb(rw.wa).j(),
-vE=gr.Ub,Iz=ap(),Jz=vE.Gb(Iz.wa).j();YG(new vq(Hz,Hz,Jz),new Um((kf,Mk)=>{fX(a,kf.oa,Mk.oa,!1,n,g,h,k,l,u,w,y,r,n,B,D,C,F,I);oX(a,Mk,kf,n,g,h,k,l,u,r,n,w,y,B,D,C,F,I)}));break b}}}}}}}var vn=Ta.z,hr=Ta.x;if(vn instanceof eu){var sw=vn.lc;if(sw instanceof M){var tw=sw.k;if(tw instanceof iv&&hr instanceof yv){var wE=hr.lb;if(wE instanceof M){var jM=wE.k;if(jM instanceof te){var xE=jM.ca;if(xE instanceof fv){oX(a,xE.ld,tw.Mj(),n,g,h,k,l,u,r,n,w,y,B,D,C,F,I);fX(a,tw.Mj().oa,xE.ld.oa,!1,n,g,h,k,l,u,w,
-y,r,n,B,D,C,F,I);break b}}}}}}var kM=Ta.z;if(kM instanceof eu){var lM=kM.lc;if(lM instanceof M&&lM.k instanceof iv){mX(a,t().f,g,k,r,n);break b}}var uw=Ta.z;if(uw instanceof eu){var mM=uw.lc,xS=uw.Jd,yS=uw.be,zS=uw.rf;if(mM instanceof M){var nM=mM.k;if(nM instanceof Xu){var AS=O().c;t();var BS=qX(nM);kX(a,AS,new eu(a,new M(BS),xS,yS,zS),O().c,e,g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break b}}}var oM=Ta.z,yE=Ta.x;if(oM instanceof eu){var pM=oM.lc;if(pM instanceof M){var qM=pM.k;if(qM instanceof gv){var CS=
-qM.Bc;if(yE instanceof yv){var zE=yE.lb;var rM=t().f===zE?!0:zE instanceof M&&zE.k instanceof te?!0:!1;if(rM){fX(a,CS,e.nf(!1),!0,n,g,h,k,l,u,w,y,r,n,B,D,C,F,I);break b}}}}}var AE=Ta.x;if(AE instanceof yv){var DS=AE.bc,vw=AE.lb;if(vw instanceof M){var BE=vw.k;if(BE instanceof te){var sM=BE.ca;if(sM instanceof gv){var ES=sM.Bc,FS=ht(DS,new z(kf=>{var Mk=V(kf.p);return pA(kf,Mk,!1)})),GS=O().c;kX(a,FS,c,new A(ES,GS),Av(a),g,h,l,k,m,w,y,u,r,n,B,D,C,F,I);break b}}}}throw new x(Ta);}}}}}else throw new x(P);
-}}),a.pa)}catch(P){if(P instanceof gq){var N=P;if(N.Hg!==K)throw N;}else throw P;}}
-function oX(a,b,c,d,e,g,h,k,l,m,n,r,u,w,y,B,D,C){var F=G(new H,b.Ma,c.Ma);a:{var I=F.z,K=F.x;if(I instanceof M&&(I=I.k,K instanceof M)){fX(a,I,K.k,!1,d,e,g,h,k,l,r,u,m,n,w,y,B,D,C);break a}d=F.z;g=F.x;if(d instanceof M&&(d=d.k,R()===g)){b.vd.Ia.b()||c.vd.Ia.b()?mX(a,t().f,e,h,m,n):(t(),F=sf(new mf(new nf(J(new L,["is not mutable"]))),v()),F=new M(F),e=c.oa,c=Vw(e.p,e,c.vd),b=Vw(d.p,d,b.vd),e=O().c,b=new A(c,new A(b,e)),c=V(a),c=Vw(d.p,d,c),e=O().c,mX(a,F,G(new H,b,new A(c,e)),h,m,n));break a}a=F.z;
-h=F.x;R()===a&&h instanceof M?a=!0:(a=F.z,h=F.x,a=R()===a&&R()===h?!0:!1);if(!a)throw new x(F);}}
-function rX(a,b,c,d,e,g,h,k,l,m,n,r,u,w,y,B,D,C,F,I,K){var N=Zz(b,!0),P=ru().U();sX||(sX=new tX);var T=sX;var aa=mu(),Y=ap().wa;b=Zca(a,b,c,d,e,m,P,T.Ch(new ou(aa,Y)),g);N=Zz(b,!0).Zx(N);if(!N.b()){d=a.pa;a.D&&(e=Hs(Q(),"| ",a.q)+"RECONSTRAINING TVs",Af(Bf(),e+"\n"));a.q=1+a.q|0;try{N.ya(new z(Z=>{a:{if(null!==Z&&(DB(a),!Z.Wb.b()))break a;if(Z.Va>c)for(var ka=ny(Z);!ka.b();){for(var X=ka.e(),sa=Tz(Z);!sa.b();){var Ia=sa.e();fX(a,X,Ia,!1,h,k,l,m,n,r,u,w,y,B,D,C,F,I,K);sa=sa.g()}ka=ka.g()}}}));var S=
-void 0}finally{a.q=-1+a.q|0}Gw(new E(d),a.pa)&&a.D&&(S=""+Hs(Q(),"| ",a.q)+d.n(S),Af(Bf(),S+"\n"))}return b}
-function fX(a,b,c,d,e,g,h,k,l,m,n,r,u,w,y,B,D,C,F){a.Uo=1+a.Uo|0;var I=G(new H,b,c);ida(m,I);bX(a,g,k,n,r,m,u,w,y,B,D);if(d){I=g.i().Og();var K=new z(P=>et(new E(P),b));I=!I.b()&&K.n(I.o())?g.i():new A(b,g.i());K=g.j().Og();var N=new z(P=>et(new E(P),c));K=!K.b()&&N.n(K.o())?g.j():new A(c,g.j());I=G(new H,I,K)}else I=O().c,I=new A(b,I),K=O().c,I=G(new H,I,new A(c,K));g=d||h.b()?h:new A(g,h);d||(d=Wp(),l=new IN(l.tC,d,l.Nt));jda(a,b,c,e,I,g,k,l,C,u,m,n,r,w,y,B,D,F);yU(m)}
-function jda(a,b,c,d,e,g,h,k,l,m,n,r,u,w,y,B,D,C){var F=id();try{kx(a,new U(()=>h.fa+". C "+b+" \x3c! "+c+"    ("+k.ka()+")"),new U(()=>{var K=ru().U();if(tu(b,c,h,!1,K))mx(a,new U(()=>"Already a subtype by \x3c:\x3c"));else{var N=G(new H,b,c);if(N.z instanceof qA||N.x instanceof qA)K=k;else{if(!a.zE&&l.L(N))throw new jX(F,(mx(a,new U(()=>"Cached!")),void 0));K=EC(b);var P=EC(c);P=G(new H,K,P);if(k.Mt.L(N))throw new jX(F,(mx(a,new U(()=>"Spurious cycle involving "+N)),void 0));if(!a.ZO&&k.Nt.L(P)&&
-!k.Mt.L(P)){mx(a,new U(()=>"SHADOWING DETECTED!"));K=new uX(a);if(!pr(new qr(K),N).L(!0)){K=new mf(new nf(J(new L,["Cyclic-looking constraint while typing ","; a type annotation may be required"])));var T=[pf(qf(),m.th)];K=sf(K,J(new L,T));K=G(new H,K,m.Ia);if(a.aA){T=sf(new mf(new nf(J(new L,["\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014 Additional debugging info: \u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014"]))),v());var aa=t().f;T=G(new H,T,aa);aa=new mf(new nf(J(new L,["this constraint:  ",
-"  \x3c:  ","    ","  ",""])));var Y=[pf(qf(),b.u()),pf(qf(),c.u()),pf(qf(),Fg(ja(b))),pf(qf(),Fg(ja(c)))];aa=sf(aa,J(new L,Y));Y=t().f;aa=G(new H,aa,Y);Y=new mf(new nf(J(new L,[" ... looks like:  ","  \x3c:  ",""])));P=[pf(qf(),pc(P.z)),pf(qf(),pc(P.x))];P=sf(Y,J(new L,P));Y=t().f;P=G(new H,P,Y);Y=O().c;P=new A(T,new A(aa,new A(P,Y)))}else P=sf(new mf(new nf(J(new L,["Note: use flag `:ex` to see internal error info."]))),v()),T=t().f,P=G(new H,P,T),T=O().c,P=new A(P,T);yx(a,new A(K,P),d)}throw new jX(F);
-}a.zE||l.S(N);K=k.Mt.Yb(N).Yb(P);K=new IN(a,K,k.Nt.Yb(P))}(new z(S=>{a:{var Z=N.z;if(!(Z instanceof gA&&!0===Z.sh)){var ka=N.x;b:if(ka instanceof gA&&!1===ka.sh)var X=!0;else{if(ka instanceof dv){var sa=ka.Ba,Ia=O().c;if(null===Ia?null===sa:Ia.h(sa)){X=!0;break b}}X=!1}if(!X){var Za=N.z;if(Za instanceof wB)fX(a,Za.Jf,c,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);else{var Ga=N.x;if(Ga instanceof wB)fX(a,b,Ga.vg,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);else{var xa=N.z;if(xa instanceof qA)fX(a,xa.yi,c,!0,d,e,g,h,S,n,
-r,u,m,w,y,B,D,l,C);else{var Ra=N.x;if(Ra instanceof qA)fX(a,b,Ra.yi,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);else if(!(hv(N.z)&&hv(N.x)&&hf(new E(b),c))){var Ja=N.z,La=N.x;if(Ja instanceof oA){var pb=Ja.xc;if(La instanceof oA){fX(a,La.xc,pb,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);break a}}var Fb=N.z,Gb=N.x;if(Fb instanceof gu){var Hb=Fb.ed;if(Hb instanceof Wl){var tb=Hb.w;if(Gb instanceof dv&&a.Qc&&IA(Ne(),tb)){h.fb.n(tb);for(var kb=new z(xd=>{a:{if(null!==xd){var ke=xd.i(),Ie=xd.j();if(null!==ke&&"Eql#A"===ke.w){ke=
-G(new H,ke,Ie);xd=O().c;gX(a,b,new dv(a,new A(ke,xd),V(a)),e,g,h,S,w,m,C,n,r,u,y,B,D,l);break a}}if(null!==xd){ke=xd.i();xd=xd.j();Ie=new U(()=>b);t();var Qf=new M(tb),hh=new z(()=>t().f),lg=Mu(),Uh=mu(),Zg=ap().wa;ke=nX(a,Ie,Qf,hh,lg.fg(new ou(Uh,Zg)),ke,h,d);fX(a,ke.oa,xd.oa,!1,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);oX(a,xd,ke,d,e,g,h,S,n,m,w,r,u,y,B,D,l,C)}else throw new x(xd);}}),gb=Gb.Ba;!gb.b();)kb.n(gb.e()),gb=gb.g();break a}}}var Vb=N.z,bb=N.x;if(Vb instanceof yu){var nb=Vb.Mb,Tb=Vb.Xb;if(bb instanceof
-yu){var ub=bb.Xb;fX(a,bb.Mb,nb,!1,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);fX(a,Tb,ub,!1,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);break a}}var Ub=N.z,$a=N.x;if(!(Ub instanceof gu&&hv($a)&&Ub.dv().L($a.Pn()))){var cb=N.z,Na=N.x;if(cb instanceof Ow){DB(a);var Ca=cb.Wb;if(!Ca.b()){var Ba=Ca.o();fX(a,Ba,Na,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);break a}}var Oa=N.z,wa=N.x;if(wa instanceof Ow){DB(a);var ea=wa.Wb;if(!ea.b()){var la=ea.o();fX(a,Oa,la,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);break a}}var Ka=N.z,Ua=N.x;if(Ka instanceof Ow&&
-Ua.Ca()<=Ka.Va){mx(a,new U(()=>"NEW "+Ka+" UB ("+Ua.Ca()+")"));var ya=e.i(),ib=Fl(jp(e.j()),ya).we(Ua,new Um((xd,ke)=>et(new E(xd.qa()),V(a))?ke:Vw(a,ke,xd.qa()))),Lb=Tz(Ka);mA(Ka,new A(ib,Lb));for(var ec=ny(Ka),Mb=new z(xd=>{fX(a,xd,Ua,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C)}),Jb=ec;!Jb.b();)Mb.n(Jb.e()),Jb=Jb.g()}else{var Kb=N.z,eb=N.x;if(eb instanceof Ow&&Kb.Ca()<=eb.Va){mx(a,new U(()=>"NEW "+eb+" LB ("+Kb.Ca()+")"));var Wb=e.i(),mc=Fl(jp(e.j()),Wb),ua=AA(mc,Kb,new Um((xd,ke)=>et(new E(ke.qa()),V(a))?
-xd:Vw(a,xd,ke.qa()))),Pa=ny(eb);kA(eb,new A(ua,Pa));for(var xb=Tz(eb),Yb=new z(xd=>{fX(a,Kb,xd,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C)}),zb=xb;!zb.b();)Yb.n(zb.e()),zb=zb.g()}else{var Sb=N.z,Ma=N.x;if(Sb instanceof Ow)if(mx(a,new U(()=>"wrong level: "+Ma.Ca())),a.$h&&Ma.Ca()<=h.fa){mx(a,new U(()=>"STASHING "+Sb+" bound in extr ctx"));var Ea=h.hb.Ai(Sb,new U(()=>mE(iE()))),ab=G(new H,!1,Ma);Ea.S(ab);var Db=G(new H,Sb,Ma);l.im(Db)}else{var mb=Sb.Va,vb=a.tf,Ya=e.i(),Wa=ap(),rb=g.Gb(Wa.wa).i(),pa=ap(),Fa=Fl(g.Gb(pa.wa).j(),
-rb),Ib=rX(a,Ma,mb,!1,vb,new A(Ya,Fa),d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);mx(a,new U(()=>"EXTR RHS  ~\x3e  "+Ib+"  to "+Sb.Va));mx(a,new U(()=>" where "+Yw(Ib)));fX(a,Sb,Ib,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C)}else{var qb=N.z,Nb=N.x;if(Nb instanceof Ow)if(mx(a,new U(()=>"wrong level: "+qb.Ca())),a.$h&&qb.Ca()<=h.fa){mx(a,new U(()=>"STASHING "+Nb+" bound in extr ctx"));var fc=h.hb.Ai(Nb,new U(()=>mE(iE()))),Ac=G(new H,!0,qb);fc.S(Ac);var tc=G(new H,qb,Nb);l.im(tc)}else{var vc=Nb.Va,sc=a.tf,uc=e.j(),lc=ap(),
-Wc=g.Gb(lc.wa).j(),Cc=ap(),Dc=Fl(g.Gb(Cc.wa).i(),Wc),Ec=rX(a,qb,vc,!0,sc,new A(uc,Dc),d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);mx(a,new U(()=>"EXTR LHS  ~\x3e  "+Ec+"  to "+Nb.Va));mx(a,new U(()=>" where "+Yw(Ec)));fX(a,Ec,Nb,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C)}else{var Ic=N.z,Xc=N.x;if(Ic instanceof Ru){var Sc=Ic.Ub;if(Xc instanceof Ru){var oc=Xc.Ub,qc=Sc.K();if(hf(new E(qc),oc.K())){YG(new vq(Sc,Sc,oc),new Um((xd,ke)=>{var Ie=G(new H,xd,ke);a:{ke=Ie.z;var Qf=Ie.x;if(null!==ke&&(xd=ke.i(),ke=ke.j(),null!==Qf)){var hh=
-Qf.i();Ie=Qf.j();Qf=new z(lg=>{var Uh=new z(Zg=>{if(sr(new E(lg),Zg)){var Vh=new mf(new nf(J(new L,["Wrong tuple field name: found '","' instead of '","'"])));Zg=[pf(qf(),lg.w),pf(qf(),Zg.w)];return Xv(a,sf(Vh,J(new L,Zg)),b.qa().Ia,d)}});hh.b()||Uh.n(hh.o())});xd.b()||Qf.n(xd.o());oX(a,Ie,ke,d,e,g,h,S,n,m,w,r,u,y,B,D,l,C);fX(a,ke.oa,Ie.oa,!1,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);break a}throw new x(Ie);}}));break a}}}var Tc=N.z,Nc=N.x;if(Tc instanceof iv&&Nc instanceof fv)oX(a,Nc.ld,Tc.Mj(),d,e,g,h,S,n,
-m,w,r,u,y,B,D,l,C),fX(a,Tc.Mj().oa,Nc.ld.oa,!1,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);else{var Pc=N.z;if(Pc instanceof nA){var Oc=Pc.cc,$c=Pc.dc;if(!0===Pc.nc){fX(a,Oc,c,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);fX(a,$c,c,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);break a}}var Lc=N.x;if(Lc instanceof nA){var Zb=Lc.cc,ed=Lc.dc;if(!1===Lc.nc){fX(a,b,Zb,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);fX(a,b,ed,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);break a}}var $b=N.z;if($b instanceof sB){tB(a);t();var Fc=$b.gc(),Yc=new M(Fc);if(!Yc.b()){fX(a,
-Yc.k,c,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);break a}}var nc=N.x;if(nc instanceof sB){tB(a);t();var Ob=nc.gc(),cc=new M(Ob);if(!cc.b()){fX(a,b,cc.k,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);break a}}var Gc=N.x;if(Gc instanceof Ru){var Bc=Gc.Ub;if(Bc instanceof A){var qd=Bc.r,Gd=O().c;null===Gd||Gd.h(qd)}}var cd=N.z,rd=N.x;if(cd instanceof gu){var Id=cd.ed,Ha=a.qk;if((null===Ha?null===Id:Ha.h(Id))&&rd instanceof yu){var jc=rd.Xb;fX(a,rd.Mb,cd,!1,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);fX(a,cd,jc,!1,d,e,g,h,S,n,r,u,m,w,
-y,B,D,l,C);break a}}var Rb=N.z,Uc=N.x;if(Rb instanceof yu){var Rc=Rb.Mb,Cd=Rb.Xb;if(Uc instanceof gu){var od=Uc.ed,Va=a.qk;if(null===Va?null===od:Va.h(od)){fX(a,Uc,Rc,!1,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);fX(a,Cd,Uc,!1,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);break a}}}var wb=N.z,db=N.x;if(wb instanceof dv){var Jc=wb.Ba;if(db instanceof dv){for(var Vc=new z(xd=>{if(null!==xd){var ke=xd.i(),Ie=xd.j();xd=pX(Jc,new z(lg=>hf(new E(lg.i()),ke)));var Qf=new U(()=>{mX(a,t().f,e,h,m,w)}),hh=new z(lg=>{if(null!==lg)lg=
-lg.j(),oX(a,Ie,lg,d,e,g,h,S,n,m,w,r,u,y,B,D,l,C),fX(a,lg.oa,Ie.oa,!1,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);else throw new x(lg);});xd.b()?Zr(Qf):hh.n(xd.o())}else throw new x(xd);}),Ta=db.Ba;!Ta.b();)Vc.n(Ta.e()),Ta=Ta.g();break a}}var kd=N.z;if(kd instanceof Ru&&N.x instanceof dv)fX(a,kd.Ap(),c,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);else{var ld=N.z,qe=N.x;if(ld instanceof gu){var Wd=ld.ed,Rd=a.qk;if((null===Rd?null===Wd:Rd.h(Wd))&&qe instanceof dv){for(var Me=new z(xd=>{fX(a,ld,xd.j().oa,!1,d,e,g,h,S,n,r,u,
-m,w,y,B,D,l,C)}),wc=qe.Ba;!wc.b();)Me.n(wc.e()),wc=wc.g();break a}}if(N.x instanceof dv)gX(a,b,c,e,g,h,S,w,m,C,n,r,u,y,B,D,l);else{var Xb=N.z,gc=N.x;if(Xb instanceof dv){var hc=Xb.Ba;if(gc instanceof gu){var gd=gc.ed,kc=a.qk;if(null===kc?null===gd:kc.h(gd)){for(var ud=new z(xd=>{fX(a,xd.j().oa,gc,!1,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C)}),za=hc;!za.b();)ud.n(za.e()),za=za.g();break a}}}var Qa=N.z,xc=N.x;if(Qa instanceof uv&&xc instanceof uv&&sr(new E(Qa.ob.X),"Array")&&sr(new E(xc.ob.X),"Eql"))if(hf(new E(Qa.ob),
-xc.ob)){fp();var yd=pv(Qa.Vb,xc.Vb);gp(0,hf(new E(yd),0));var be=h.vb.Y(Qa.ob.X);if(be instanceof M){var yc=be.k,Od=EA(yc),sd=yc.zm,he=ap(),ue=sd.Gb(he.wa).j();$G(KC(new vq(ue,ue,Qa.Vb),xc.Vb),new jW((xd,ke,Ie)=>{xd=Od.n(xd);xd.Vd||fX(a,ke,Ie,!1,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);xd.wd||fX(a,Ie,ke,!1,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C)}))}else if(t().f===be){var sg=h.fb.Y(Qa.ob.X);if(sg instanceof M){var Se=sg.k,Kf=ht(Se.pg(),new z(xd=>xd.gb));$G(KC(new vq(Kf,Kf,Qa.Vb),xc.Vb),new jW((xd,ke,Ie)=>{xd=oD(Se).Y(xd);
-xd=xd.b()?Tt().En:xd.o();xd.Vd||fX(a,ke,Ie,!1,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);xd.wd||fX(a,Ie,ke,!1,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C)}))}else if(t().f===sg)$n();else throw new x(sg);}else throw new x(be);}else if(sba(Qa,h))fX(a,xC(Qa,h,d),xC(xc,h,d),!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);else{var $e=G(new H,vv(Qa,h),vv(xc,h));b:{var rf=$e.z,He=$e.x;if(rf instanceof M){var Ze=rf.k;if(He instanceof M){var jf=He.k,tf=ru().U();if(!tu(Ze,jf,h,!0,tf)){mX(a,t().f,e,h,m,w);break b}}}fX(a,xC(Qa,h,d),xC(xc,h,d),!0,d,
-e,g,h,S,n,r,u,m,w,y,B,D,l,C)}}else{var Te=N.z;if(Te instanceof uv)fX(a,xC(Te,h,d),c,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);else{var hg=N.z,eh=N.x;if(hg instanceof gu){var fh=hg.ed,tg=a.qk;if((null===tg?null===fh:tg.h(fh))&&eh instanceof uv)break a}var Jg=N.x;if(Jg instanceof uv)fX(a,b,xC(Jg,h,d),!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);else{var Gh=N.z;if(Gh instanceof gu){var zg=Gh.ed,ig=a.qk;if(null===ig?null===zg:ig.h(zg))break a}var qh=N.x;if(qh instanceof gu){var gh=qh.ed,Wg=a.qk;if(null===Wg?null===gh:Wg.h(gh))break a}var Uf=
-N.x;if(Uf instanceof gv){var rh=Uf.Bc;fX(a,JA(b,Uf.Ye),rh,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C)}else{var Rh=N.x;if(Rh instanceof oA){var Sg=Rh.xc;if(Sg instanceof gv){var Hh=Sg.Bc;fX(a,new gv(a,b,Sg.Ye,Sg.Lo),new oA(a,Hh,Rh.Tz),!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);break a}}var Xg=N.x;if(Xg instanceof px)qx(h,new z(xd=>{var ke=cba(Xg,xd);mx(a,new U(()=>"BUMP TO LEVEL "+xd.fa+"  --\x3e  "+ke));mx(a,new U(()=>"where "+Yw(ke)));fX(a,b,ke,!0,d,e,g,xd,S,n,r,u,m,w,y,B,D,l,C);eX(a,h,xd,e,g,w,C,n,r,u,m,y,B,D,l)}),
-d,m);else{var jg=N.z;if(null!==jg){var Ag=Vu(Wu(a),jg,h);if(!Ag.b()){var Cf=Ag.k;if(Cf instanceof px){var Bg=Cf.Ld,Lf=Cf.ve;if(Lf.Ca()<=Bg){fX(a,Lf,c,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);break a}}}}var Df=N.x;if(null!==Df){var kg=bba(Yaa(a),Df,h,d);if(!kg.b()){var df=kg.o();if(a.oq){mx(a,new U(()=>"DISTRIB-R  ~\x3e  "+df));fX(a,b,df,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);break a}}}var Kg=N.z;if(null!==Kg){var Mf=Vu(Wu(a),Kg,h);if(!Mf.b()){var Vf=Mf.k;if(Vf instanceof px){var Cg=Vf.Ld,Ef=Vf.ve;if(null!==Ef){var Wf=
-Vu(Wu(a),Ef,h);if(!Wf.b()){var de=Wf.k;if(de instanceof yu){var Ee=de.Mb,Sh=de.Xb;if(a.oq&&Ee.Ca()<=Cg&&Sh.Ca()>Cg){var hi=new yu(a,Ee,new px(a,Cg,Sh),c.qa());mx(a,new U(()=>"DISTRIB-L  ~\x3e  "+hi));fX(a,hi,c,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);break a}}}}}}}var vi=N.z;if(vi instanceof px){var Lg=Uaa(Nca(a),vi,h,d);if(!Lg.b()){var Tg=Lg.o();if(a.oq){mx(a,new U(()=>"DISTRIB-L'  ~\x3e  "+Tg));fX(a,Tg,c,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);break a}}}var cj=N.z;if(cj instanceof px){if(g.b())var Cj=O().c,
-Dj=O().c,wi=G(new H,Cj,Dj),Ki=O().c,Yg=new A(wi,Ki);else Yg=g;(new z(xd=>{fX(a,vA(cj,h),c,!0,d,e,xd,h,S,n,r,u,m,w,y,B,D,l,C)})).n(Yg)}else{var dj=N.z;if(dj instanceof yB){var ii=dj.Aj,ji=dj.ej;kx(a,new U(()=>"DISCHARGE CONSTRAINTS"),new U(()=>{for(var xd=new z(Ie=>{if(null!==Ie)fX(a,Ie.i(),Ie.j(),!1,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C);else throw new x(Ie);}),ke=ii;!ke.b();)xd.n(ke.e()),ke=ke.g()}),a.pa);fX(a,ji,c,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C)}else{N.x instanceof yB&&$n();var Th=N.x;if(Th instanceof
-nA&&!0===Th.nc)gX(a,b,c,e,g,h,S,w,m,C,n,r,u,y,B,D,l);else{var Ej=N.z;if(Ej instanceof nA&&!1===Ej.nc)gX(a,b,c,e,g,h,S,w,m,C,n,r,u,y,B,D,l);else{var ej=N.z;ej instanceof Xu?fX(a,qX(ej),c,!0,d,e,g,h,S,n,r,u,m,w,y,B,D,l,C):N.z instanceof oA||N.z instanceof gv||N.x instanceof oA||N.x instanceof gv?gX(a,b,c,e,g,h,S,w,m,C,n,r,u,y,B,D,l):(N.z instanceof gu||N.z instanceof IB)&&N.x instanceof IB?gX(a,b,c,e,g,h,S,w,m,C,n,r,u,y,B,D,l):mX(a,t().f,e,h,m,w)}}}}}}}}}}}}}}}}}}}}}}}}})).n(K)}}),a.pa)}catch(K){if(K instanceof
-gq){var I=K;if(I.Hg!==F)throw I;}else throw K;}}function vX(a,b){var c=new mf(new nf(J(new L,["does not match type `","`"])));a=[nO(qf(),WC(a,b))];return sf(c,J(new L,a))}function wX(a){var b=new mf(new nf(J(new L,["does not have field '","'"])));a=[pf(qf(),a)];return sf(b,J(new L,a))}function xX(a,b){if(!a.b()){var c=a.o();b.S(c)}return a}
-function yX(a){if(a.Bm)return sf(new mf(new nf(J(new L,["type"]))),v());var b=new mf(new nf(J(new L,[""," of type"])));a=[pf(qf(),a.th)];return sf(b,J(new L,a))}var lda=function kda(a,b,c,d){if(b instanceof A){var g=b.r;b=b.A.m();b=new eg(b,new z(h=>h.qa()));b=new ex(b,new zX(a,c,d));je();b=le(v(),b);return Fl(kda(a,g,c,d),b)}a=O().c;if(null===a?null===b:a.h(b))return O().c;throw new x(b);};
-function mda(a,b){var c=Lz().U(),d=Lz().U(),e=k=>{k=k.j();if(k.b())return!1;k=k.o();return d.L(k)};b=lda(a,b,c,d);a:for(;;)if(b.b()){e=v();break}else if(c=b.e(),a=b.g(),!0===!!e(c))b=a;else for(;;){if(a.b())e=b;else{c=a.e();if(!0!==!!e(c)){a=a.g();continue}c=a;a=new A(b.e(),v());var g=b.g();for(b=a;g!==c;){var h=new A(g.e(),v());b=b.r=h;g=g.g()}for(g=c=c.g();!c.b();){h=c.e();if(!0===!!e(h)){for(;g!==c;)h=new A(g.e(),v()),b=b.r=h,g=g.g();g=c.g()}c=c.g()}g.b()||(b.r=g);e=a}break a}return e}
-function AX(a,b,c,d,e){var g=a.Ia;if(g instanceof M&&(g=g.k,!b.Ia.L(g)&&!c.L(g))){var h=new mf(new nf(J(new L,["Note: constraint arises from ",":"]))),k=[pf(qf(),a.th)];h=sf(h,J(new L,k));a=xX(a.Ia,c);a=G(new H,h,a);h=d.Ia;a:{if(h instanceof M&&(h=h.k,sr(new E(h),g)&&!b.Ia.L(h)&&!e.Ia.L(h)&&!c.L(h))){b=new mf(new nf(J(new L,["from ",":"])));e=[pf(qf(),d.th)];b=sf(b,J(new L,e));c=xX(d.Ia,c);c=G(new H,b,c);d=O().c;c=new A(c,d);break a}c=O().c}return new A(a,c)}return O().c}
-function mX(a,b,c,d,e,g){var h=id();try{var k=c.i().e(),l=c.j().e();mx(a,new U(()=>"CONSTRAINT FAILURE: "+k+" \x3c: "+l));var m=c.i(),n=c.j(),r=m.m(),u=new Gx(r,new z(ua=>ua.qa().mx),!0),w=LG(u,new z(ua=>!ua.qa().Ia.b())),y=new z(ua=>ua.qa()),B=w.b()?R():new M(y.n(w.o())),D=new U(()=>k.qa()),C=B.b()?Zr(D):B.o(),F=n.m(),I=new Gx(F,new z(ua=>ua.qa().mx),!0),K=LG(I,new z(ua=>!ua.qa().Ia.b())),N=new z(ua=>ua.qa()),P=K.b()?R():new M(N.n(K.o())),T=new U(()=>l.qa()),aa=P.b()?Zr(T):P.o(),Y=Eq(n).m(),S=new Gx(Y,
-new z(ua=>ua.qa().mx),!0),Z=LG(S,new z(ua=>!ua.qa().Ia.b())),ka=new z(ua=>ua.qa()),X=Z.b()?R():new M(ka.n(Z.o())),sa=new U(()=>l.qa()),Ia=X.b()?Zr(sa):X.o(),Za=Hn(m,new BX(a,C,e)).Og(),Ga=Lz().U(),xa=Mt(Nt(),m.Og()),Ra=cs(n),Ja=xa.hl(Ra).m(),La=new eg(Ja,new z(ua=>ua.qa())),pb=new ex(La,new CX(a));je();var Fb=le(v(),pb),Gb=Ix(Fb,new z(ua=>ua.j().Ia)),Hb=mba(k),tb=new U(()=>{var ua=G(new H,Hb,CB(l));if(ua.z instanceof rB||ua.x instanceof rB){var Pa=ua.z,xb=ua.x;if(Pa instanceof rB&&xb instanceof rB){t();
-var Yb=new M(Pa);t();var zb=new vp(Pa,Yb,new M(xb),mn(Pa.nE,xb.nE))}else{var Sb=ua.z;if(Sb instanceof rB)zb=new vp(Sb,(t(),new M(Sb)),t().f,Sb.nE);else{var Ma=ua.x;Ma instanceof rB?zb=new vp(Ma,t().f,(t(),new M(Ma)),Ma.nE):Dn("Program reached and unexpected state.")}}if(null!==zb)var Ea=new vp(zb.Jj,zb.jj,zb.ci,zb.Qi);else throw new x(zb);var ab=Ea.Jj,Db=Ea.jj,mb=Ea.ci,vb=mda(a,Ea.Qi),Ya=xX(C.Ia,Ga),Wa=new U(()=>xX(ab.Am.xs.Ia,Ga)),rb=Ya.b()?Zr(Wa):Ya,pa=new U(()=>xX(ab.Am.Xh.Zh.Ia,Ga)),Fa=rb.b()?
-Zr(pa):rb,Ib=new mf(new nf(J(new L,["Type error in ",""]))),qb=[pf(qf(),e.th)],Nb=sf(Ib,J(new L,qb)),fc=xX(e.Ia,Ga),Ac=G(new H,Nb,fc),tc=new mf(new nf(J(new L,["type variable `","` leaks out of its scope"]))),vc=[nO(qf(),UC(ab.Am,d))],sc=sf(tc,J(new L,vc)),uc=G(new H,sc,Fa);if(mb instanceof M){var lc=mb.k,Wc=xX(aa.Ia,Ga),Cc=new U(()=>xX(lc.Am.xs.Ia,Ga)),Dc=Wc.b()?Zr(Cc):Wc,Ec=new U(()=>xX(lc.Am.Xh.Zh.Ia,Ga)),Ic=Dc.b()?Zr(Ec):Dc;if(!Db.b()&&sr(new E(Ic),Fa))var Xc=new mf(new nf(J(new L,["back into type variable `",
-"`"]))),Sc=[nO(qf(),WC(lc.Am,d))],oc=sf(Xc,J(new L,Sc)),qc=G(new H,oc,Ic),Tc=O().c,Nc=new A(qc,Tc);else Nc=O().c}else if(t().f===mb){var Pc=new mf(new nf(J(new L,["into "," `","`"]))),Oc=[yX(aa),nO(qf(),WC(l,d))],$c=sf(Pc,J(new L,Oc)),Lc=xX(aa.Ia,Ga),Zb=G(new H,$c,Lc),ed=O().c;Nc=new A(Zb,ed)}else throw new x(mb);if(vb.b())nc=O().c;else var $b=sf(new mf(new nf(J(new L,["adding a type annotation to any of the following terms may help resolve the problem"]))),v()),Fc=t().f,Yc=G(new H,$b,Fc),nc=new A(Yc,
-vb);var Ob=Ia.Ia;a:{if(Ob instanceof M){var cc=Ob.k;if(!(aa.Ia.L(cc)||e.Ia.L(cc)||C.Ia.L(cc)||Ga.L(cc))){var Gc=new mf(new nf(J(new L,["Note: constraint arises from ",":"]))),Bc=[pf(qf(),Ia.th)],qd=sf(Gc,J(new L,Bc)),Gd=xX(Ia.Ia,Ga),cd=G(new H,qd,Gd),rd=O().c;var Id=new A(cd,rd);break a}}Id=O().c}var Ha=Fl(Fl(Id,nc),Nc),jc=new A(Ac,new A(uc,Ha));throw new jX(h,g.n(Kq(Jq(),Fl(AX(aa,e,Ga,Ia,C),jc),a.Qc,Qt())));}if(ua.z instanceof Ow||ua.z instanceof sB)return vX(l,d);var Rb=ua.z,Uc=ua.x;if(Rb instanceof
-dv){var Rc=Rb.Ba;if(Uc instanceof dv){var Cd=ht(Uc.Ba,new z(Te=>Te.i())),od=Zp($p(),Cd),Va=ht(Rc,new z(Te=>Te.i())),wb=Zp($p(),Va),db=od.Zx(wb),Jc=ep(db),Vc=new U(()=>vX(l,d)),Ta=new z(Te=>wX(Te.w));return Jc.b()?Zr(Vc):Ta.n(Jc.o())}}var kd=ua.x;if(qB(kd)&&kd.Gq()instanceof Wl){var ld=new mf(new nf(J(new L,["is not an instance of type `","`"])));if(a.Em.L(kd.Gq().vi))var qe=pf(qf(),kd.Gq().vi);else qf(),Q(),qe=pf(0,hu(0,kd.Gq().vi));return sf(ld,J(new L,[qe]))}var Wd=ua.x;if(Wd instanceof uv){var Rd=
-new mf(new nf(J(new L,["is not an instance of `","`"]))),Me=[nO(qf(),WC(Wd,d))];return sf(Rd,J(new L,Me))}var wc=ua.z,Xb=ua.x;if(Xb instanceof Ru){var gc=Xb.Ub;if(!(wc instanceof Ru)){var hc=new mf(new nf(J(new L,["is not a ","-element tuple"])));qf();var gd=gc.K(),kc=[pf(0,""+gd)];return sf(hc,J(new L,kc))}}var ud=ua.z;if(ua.x instanceof yu&&!(ud instanceof yu))return sf(new mf(new nf(J(new L,["is not a function"]))),v());var za=ua.z,Qa=ua.x;if(Qa instanceof dv){var xc=Qa.Ba;if(xc instanceof A){var yd=
-xc.A,be=xc.r;if(null!==yd){var yc=yd.i(),Od=O().c;if((null===Od?null===be:Od.h(be))&&!(za instanceof dv))return wX(yc.w)}}}var sd=ua.z,he=ua.x;if(he instanceof dv){var ue=he.Ba;if(ue instanceof A&&pr(new qr(new DX(a)),Hb).L(!0)&&!(sd instanceof dv)){var sg=new mf(new nf(J(new L,["is not a record (expected a record with field",": ",")"]))),Se=0<ue.$a(1)?pf(qf(),"s"):pf(qf(),"");qf();var Kf=ht(ue,new z(Te=>Te.i().w)),$e=[Se,pf(0,Qe(Kf,"",", ",""))];return sf(sg,J(new L,$e))}}var rf=ua.x;if(rf instanceof
-dv){var He=rf.Ba;if(He instanceof A){var Ze=new mf(new nf(J(new L,["does not have all required fields ",""])));qf();var jf=ht(He,new z(Te=>"'"+Te.i().w+"'")),tf=[pf(0,Qe(jf,"",", ",""))];return sf(Ze,J(new L,tf))}}return vX(l,d)}),kb=b.b()?Zr(tb):b.o(),gb=new mf(new nf(J(new L,["Type mismatch in ",":"]))),Vb=[pf(qf(),e.th)],bb=sf(gb,J(new L,Vb)),nb=xX(e.Ia,Ga),Tb=G(new H,bb,nb),ub=new mf(new nf(J(new L,[""," `","` ",""]))),Ub=[yX(C),nO(qf(),UC(k,d)),kb],$a=sf(ub,J(new L,Ub)),cb=hf(new E(C.Ia),e.Ia)?
-t().f:xX(C.Ia,Ga),Na=G(new H,$a,cb),Ca=O().c,Ba=new A(Tb,new A(Na,Ca)),Oa=new z(ua=>{var Pa=new mf(new nf(J(new L,[" with expected type `","`"]))),xb=[nO(qf(),WC(l,d))];xb=sf(Pa,J(new L,xb));Pa=new mf(new nf(J(new L,["but it flows into ","",""])));xb=[pf(qf(),ua.qa().th),xb];Pa=sf(Pa,J(new L,xb));ua=xX(ua.qa().Ia,Ga);ua=G(new H,Pa,ua);Pa=O().c;return new A(ua,Pa)}),wa=(Za.b()?R():new M(Oa.n(Za.o()))).ea(),ea=ap().wa,la=EX(wa,ea),Ka=AX(aa,e,Ga,Ia,C),Ua=Hn(Gb,new FX(a,Ga,new hA(!0)));if(a.aA)var ya=
-sf(new mf(new nf(J(new L,["\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d Additional explanations below \x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d"]))),v()),ib=t().f,Lb=G(new H,ya,ib),ec=cX(m,new z(ua=>{if(a.D){var Pa=new mf(new nf(J(new L,["[info] LHS \x3e\x3e "," : ",""]))),xb=[pf(qf(),ua.qa().u()),nO(qf(),UC(ua,d))];Pa=sf(Pa,J(new L,xb));ua=G(new H,Pa,ua.qa().Ia);Pa=O().c;return new A(ua,Pa)}Pa=new mf(new nf(J(new L,["[info] flowing from "," `","`"])));xb=[yX(ua.qa()),nO(qf(),UC(ua,d))];Pa=sf(Pa,J(new L,xb));
-ua=G(new H,Pa,ua.qa().Ia);Pa=O().c;return new A(ua,Pa)})),Mb=Fl(cX(jp(n),new z(ua=>{if(a.D){var Pa=new mf(new nf(J(new L,["[info] RHS \x3c\x3c "," : ",""]))),xb=[pf(qf(),ua.qa().u()),nO(qf(),WC(ua,d))];Pa=sf(Pa,J(new L,xb));ua=G(new H,Pa,ua.qa().Ia);Pa=O().c;return new A(ua,Pa)}Pa=new mf(new nf(J(new L,["[info] flowing into "," `","`"])));xb=[yX(ua.qa()),nO(qf(),WC(ua,d))];Pa=sf(Pa,J(new L,xb));ua=G(new H,Pa,ua.qa().Ia);Pa=O().c;return new A(ua,Pa)})),ec),Jb=new A(Lb,Mb);else Jb=O().c;t();var Kb=
-J(new L,[Ba,la,Ka,Ua,Jb]),eb=le(v(),Kb),Wb=ap().wa,mc=EX(eb,Wb);g.n(Kq(Jq(),mc,a.Qc,Qt()))}catch(ua){if(ua instanceof gq){if(b=ua,b.Hg!==h)throw b;}else throw ua;}}
-var AC=function GX(a,b,c,d,e,g,h,k){Os(fp(),c>=d.fa);if(b.Ca()<=e)return b;var m=!1,n=null,r=!1,u=null;if(b instanceof Ow&&(m=!0,n=b,g.L(n)))return n;if(m){DB(a);var w=n.Wb;if(!w.b()){var y=w.o();return h.yd(n,new U((Ta=>()=>{var kd=Ta.Zh;t();var ld=new M(Ta),qe=Ta.dg,Wd=O().c,Rd=O().c;kd=new Ow(a,Ta.Va>c?Ta.Va:d.fa,Wd,Rd,ld,qe,!1,kd);ld=G(new H,Ta,kd);h.S(ld);ld=GX(a,y,c,d,e,g,h,k);jA(kd,(t(),new M(ld)));return kd})(n)))}}if(m){var B=!1,D=h.Y(n);if(D instanceof M)return D.k;if(R()===D&&(B=!0,k&&
-n.Va<=c)){var C=V(a);t();var F=new M(n),I=n.dg,K=O().c,N=O().c,P=new Pw(a,new Ow(a,d.fa,K,N,F,I,!1,C),n.Zh),T=n;if(a.D){var aa=Hs(Q(),"| ",a.q)+("New skolem: "+T+" ~\x3e ")+P;Af(Bf(),aa+"\n")}if(ny(n).b()?!Tz(n).b():1){var Y=n.Zh;t();var S=new M(n),Z=n.dg,ka=O().c,X=O().c,sa=new Ow(a,d.fa,ka,X,S,Z,!1,Y),Ia=G(new H,n,sa);h.S(Ia);var Za=ny(sa),Ga=Tz(n);if(Ga===v())var xa=v();else{for(var Ra=Ga.e(),Ja=new A(GX(a,Ra,c,d,e,g,h,k),v()),La=Ja,pb=Ga.g();pb!==v();){var Fb=pb.e(),Gb=new A(GX(a,Fb,c,d,e,g,h,
-k),v());La=La.r=Gb;pb=pb.g()}xa=Ja}for(var Hb=P,tb=xa;!tb.b();){var kb=Hb,gb=tb.e(),Vb=kb,bb=gb,nb=V(Vb.p);Hb=ju(Vb,bb,nb,!1);tb=tb.g()}kA(sa,new A(Hb,Za));if(a.D){var Tb=Hs(Q(),"| ",a.q)+(sa+" :\x3e ")+ny(sa);Af(Bf(),Tb+"\n")}var ub=Tz(sa),Ub=ny(n);if(Ub===v())var $a=v();else{for(var cb=Ub.e(),Na=new A(GX(a,cb,c,d,e,g,h,k),v()),Ca=Na,Ba=Ub.g();Ba!==v();){var Oa=Ba.e(),wa=new A(GX(a,Oa,c,d,e,g,h,k),v());Ca=Ca.r=wa;Ba=Ba.g()}$a=Na}for(var ea=P,la=$a;!la.b();){var Ka=ea,Ua=la.e(),ya=Ka,ib=Ua,Lb=V(ya.p);
-ea=zu(ya,ib,Lb,!1);la=la.g()}mA(sa,new A(ea,ub));if(a.D){var ec=Hs(Q(),"| ",a.q)+(sa+" \x3c: ")+Tz(sa);Af(Bf(),ec+"\n")}return sa}var Mb=G(new H,n,P);h.S(Mb);return P}if(B){var Jb=n.Zh;t();var Kb=new M(n),eb=n.dg,Wb=O().c,mc=O().c;if(n.Va>c)var ua=n.Va;else{if(!(d.fa<=c))throw new rk("assertion failed: this condition should be false for the result to be correct");ua=d.fa}var Pa=new Ow(a,ua,Wb,mc,Kb,eb,!1,Jb),xb=G(new H,n,Pa);h.S(xb);for(var Yb=ny(n),zb=null,Sb=null,Ma=Yb,Ea=Yb,ab;;)if(Ea.b()){null===
-zb?ab=Ma:(Sb.r=Ma,ab=zb);break}else{var Db=Ea.e(),mb=GX(a,Db,c,d,e,g,h,k);if(mb===Db)Ea=Ea.g();else{for(var vb=Ma,Ya=zb,Wa=Sb;vb!==Ea;){var rb=new A(vb.e(),v());null===Ya&&(Ya=rb);null!==Wa&&(Wa.r=rb);Wa=rb;vb=vb.g()}var pa=new A(mb,v());null===Ya&&(Ya=pa);null!==Wa&&(Wa.r=pa);Wa=pa;var Fa=Ea.g(),Ib=Wa;zb=Ya;Sb=Ib;Ea=Ma=Fa}}kA(Pa,ab);for(var qb=Tz(n),Nb=null,fc=null,Ac=qb,tc=qb,vc;;)if(tc.b()){null===Nb?vc=Ac:(fc.r=Ac,vc=Nb);break}else{var sc=tc.e(),uc=GX(a,sc,c,d,e,g,h,k);if(uc===sc)tc=tc.g();else{for(var lc=
-Ac,Wc=Nb,Cc=fc;lc!==tc;){var Dc=new A(lc.e(),v());null===Wc&&(Wc=Dc);null!==Cc&&(Cc.r=Dc);Cc=Dc;lc=lc.g()}var Ec=new A(uc,v());null===Wc&&(Wc=Ec);null!==Cc&&(Cc.r=Ec);Cc=Ec;var Ic=tc.g(),Xc=Cc;Nb=Wc;fc=Xc;tc=Ac=Ic}}mA(Pa,vc);return Pa}throw new x(D);}if(b instanceof wB){var Sc=b.Jf;return new wB(a,GX(a,b.vg,c,d,e,g,h,k),GX(a,Sc,c,d,e,g,h,k),b.CO)}if(b instanceof yu){var oc=b.Xb;return new yu(a,GX(a,b.Mb,c,d,e,g,h,k),GX(a,oc,c,d,e,g,h,k),b.Bj)}if(b instanceof nA){var qc=b.dc;return new nA(a,b.nc,GX(a,
-b.cc,c,d,e,g,h,k),GX(a,qc,c,d,e,g,h,k),b.lE)}if(b instanceof dv){var Tc=b.Ba;return new dv(a,Mx(Du(),Tc,new z(Ta=>{var kd=Ta.Ua,ld=Ta.Ma;ld.b()?ld=R():(ld=ld.o(),ld=new M(GX(a,ld,c,d,e,g,h,k)));return new ww(kd,ld,GX(a,Ta.oa,c,d,e,g,h,k),Ta.vd)})),b.Cj)}if(b instanceof Ru){var Nc=b.Ub;return new Ru(a,Mx(Du(),Nc,new z(Ta=>{var kd=Ta.Ua,ld=Ta.Ma;ld.b()?ld=R():(ld=ld.o(),ld=new M(GX(a,ld,c,d,e,g,h,k)));return new ww(kd,ld,GX(a,Ta.oa,c,d,e,g,h,k),Ta.vd)})),b.gq)}if(b instanceof fv){var Pc=b.ld,Oc=Pc.Ua,
-$c=Pc.Ma;if($c.b())var Lc=R();else{var Zb=$c.o();Lc=new M(GX(a,Zb,c,d,e,g,h,k))}return new fv(a,new ww(Oc,Lc,GX(a,Pc.oa,c,d,e,g,h,k),Pc.vd),b.ix)}if(b instanceof jv)return TA(b,new z(Ta=>GX(a,Ta,c,d,e,g,h,k)),new z(Ta=>GX(a,Ta,c,d,e,g,h,k)),new z(Ta=>GX(a,Ta,c,d,e,g,h,k)),b.ou);if(b instanceof oA)return new oA(a,GX(a,b.xc,c,d,e,g,h,k),b.Tz);if(b instanceof gA)return b;if(b instanceof qA)return new qA(a,GX(a,b.yi,c,d,e,g,h,k),b.oE);if(b instanceof sB){tB(a);t();var ed=b.gc(),$b=new M(ed);if(!$b.b())return GX(a,
-$b.k,c,d,e,g,h,k)}if(b instanceof Pw){var Fc=b.Xh;if(b.nu>e&&b.nu<=c)return GX(a,Fc,c,d,e,g,h,k)}if(b instanceof gu||b instanceof IB||b instanceof Pw||b instanceof rB)return b;if(b instanceof gv){var Yc=b.Ye;return new gv(a,GX(a,b.Bc,c,d,e,g,h,k),Yc,b.Lo)}if(b instanceof uv){var nc=b.ob,Ob=b.Vb;if(Ob===v())var cc=v();else{for(var Gc=Ob.e(),Bc=new A(GX(a,Gc,c,d,e,g,h,k),v()),qd=Bc,Gd=Ob.g();Gd!==v();){var cd=Gd.e(),rd=new A(GX(a,cd,c,d,e,g,h,k),v());qd=qd.r=rd;Gd=Gd.g()}cc=Bc}return new uv(a,nc,cc,
-b.Ml)}if(b instanceof px&&(r=!0,u=b,u.Ca()<=e))return u;if(r){var Id=u.Ld,Ha=u.ve;if(d.fa>Id){var jc=dC(u,d.fa,g,d,h);return GX(a,jc,c,d,e,g,h,k)}return new px(a,Id,GX(a,Ha,c<Id?c:Id,d,e,g,h,k))}if(b instanceof yB){var Rb=b.Aj,Uc=b.ej,Rc=Ta=>{var kd=GX(a,Ta.i(),c,d,e,g,h,k);Ta=GX(a,Ta.j(),c,d,e,g,h,k);return G(new H,kd,Ta)};if(Rb===v())var Cd=v();else{for(var od=Rb.e(),Va=new A(Rc(od),v()),wb=Va,db=Rb.g();db!==v();){var Jc=db.e(),Vc=new A(Rc(Jc),v());wb=wb.r=Vc;db=db.g()}Cd=Va}return new yB(a,Cd,
-GX(a,Uc,c,d,e,g,h,k))}if(b instanceof Xu)return ZW(b,new z(Ta=>GX(a,Ta,c,d,e,g,h,k)),new z(Ta=>GX(a,Ta,c,d,e,g,h,k)));throw new x(b);};function HX(){this.Cn=this.Bn=this.Dn=null;this.Vo=this.Wo=this.Dm=this.Uo=0;this.pa=null;this.q=0;this.bl=this.iq=this.mq=this.No=this.Ro=this.So=this.kq=this.Po=this.jq=this.Mo=this.Qo=this.Oo=this.lq=null;this.To=0;this.Ar=this.Up=this.Wp=this.Xp=this.Vp=this.Zp=this.Yp=null;this.nm=this.mw=0}HX.prototype=new KS;HX.prototype.constructor=HX;function IX(){}
-IX.prototype=HX.prototype;function dw(a){null===a.Ar&&null===a.Ar&&(a.Ar=new HN(a));return a.Ar}function nda(a,b,c,d,e){b=d.fb.yd(b,new U(()=>{$n()}));if(!b.ws&&(e=jx(b,e),e instanceof Aw)){e=e.ui.Y(c.w);if(e instanceof M)return a=e.k,t(),new me(a);if(t().f===e)return t(),a=Yca(a,b,c),new te(a);throw new x(e);}$n()}
-function nX(a,b,c,d,e,g,h,k){var l=a.pa;if(a.D){var m=Hs(Q(),"| ",a.q)+("Looking up field "+g.w+" in "+c+" \x26 "+e)+" \x26 {...}";Af(Bf(),m+"\n")}a.q=1+a.q|0;try{var n=g.w;if(0<=n.length&&"#"===n.substring(0,1))var r=g.w,u=new Wl(qg(Q(),r,1,r.length)),w=g.C(),y=aq(u,w),B=!0;else y=g,B=!1;g=y;B=!!B;var D=d.n(g),C=t().f,F=new ov(C);if(c.b())var I=R();else{var K=c.o();I=JX(a,h.fb.n(K),g,B,k,F,d,h)}var N=Hn((je(),le(v(),e)),new KX(a,h,g,B,k,F,d)),P=ap().wa,T=EX(N,P),aa=D.ea(),Y=I.ea(),S=Fl(Fl(T,Y),aa);
-if(a.D){var Z=Hs(Q(),"| ",a.q)+("  \x26 "+D)+"  (from refinement)";Af(Bf(),Z+"\n")}if(S instanceof A){for(var ka=S.A,X=jp(S.r);!X.b();){var sa=X.e();ka=av(sa,ka,V(sa.Ua));X=X.g()}var Ia=ka}else{var Za=O().c;if(null===Za?null===S:Za.h(S)){var Ga=F.Lb;if(Ga instanceof M){var xa=LX(a,Ga.k,k),Ra=V(a);Ia=new ww(xa.p,R(),xa,Ra)}else if(t().f===Ga){var Ja=new mf(new nf(J(new L,["Type `","` does not contain member `","`"])));qf();var La=Zr(b),pb=[nO(0,UC(La,h)),pf(qf(),g.w)],Fb=sf(Ja,J(new L,pb)),Gb=g.C(),
-Hb=G(new H,Fb,Gb),tb=O().c,kb=yx(a,new A(Hb,tb),k),gb=V(a);Ia=new ww(kb.p,R(),kb,gb)}else throw new x(Ga);}else throw new x(S);}}finally{a.q=-1+a.q|0}Gw(new E(l),a.pa)&&a.D&&(a=""+Hs(Q(),"| ",a.q)+l.n(Ia),Af(Bf(),a+"\n"));return Ia}function ew(a,b,c,d,e,g,h){var k=id();try{a.nm=1+a.nm|0,MX(a,b,c,d,e,g,h)}catch(l){if(l instanceof gq){if(a=l,a.Hg!==k)throw a;}else throw l;}}
-function MX(a,b,c,d,e,g,h){var k=id();try{var l=Lz().U(),m=a.mw,n=new zQ(m),r=new NX(16);mx(a,new U(()=>"CONSTRAIN "+b+" \x3c! "+c));mx(a,new U(()=>{var B=new yu(a,b,c,V(a));return"  where "+Yw(B)}));var u=new U(()=>{throw new jX(k);}),w=O().c,y=O().c;fX(a,b,c,!0,d,G(new H,w,y),O().c,g,h,r,b,c,e,d,u,n,m,l,h)}catch(B){if(B instanceof gq){if(d=B,d.Hg!==k)throw d;}else throw B;}}
-function oda(a,b,c,d,e,g){var h=id();try{mx(a,new U(()=>"CHECKING SUBSUMPTION..."));var k=new zQ(0);ew(a,b,c,new z(l=>{k.Zd=1+k.Zd|0;if(3<k.Zd)throw new jX(h);hf(new E(k.Zd),1)&&e.n(l)}),g,d,dw(a).Cb)}catch(l){if(l instanceof gq){if(a=l,a.Hg!==h)throw a;}else throw l;}}function Xv(a,b,c,d){b=G(new H,b,c);c=O().c;return yx(a,new A(b,c),d)}function yx(a,b,c){return LX(a,Kq(Jq(),b,a.Qc,Qt()),c)}function LX(a,b,c){c.n(b);return Wx(a)}function Wx(a){var b=a.qk,c=Wp();return new gu(a,b,c,V(a))}
-function OX(a,b,c,d){b=G(new H,b,c);c=O().c;zx(a,new A(b,c),d)}function zx(a,b,c){c.n(Hq(Fq(),b,a.Qc,Qt()))}
-function PX(a,b,c,d,e,g,h){var k=a.pa;if(a.D){var l=Hs(Q(),"| ",a.q)+(g.fa+". U "+b+" \x3d! ")+c;Af(Bf(),l+"\n")}a.q=1+a.q|0;try{l=c;for(var m=!1;;){if(JC(b)||!hf(new E(b),l)){var n=b;c=l;if(n instanceof Ow&&c.Ca()<=n.Va){var r=n.Wb;if(r instanceof M)PX(a,r.k,c,d,e,g,h);else if(t().f===r){r=a;if(r.D){var u=Hs(Q(),"| ",r.q)+(n+" :\x3d ")+c;Af(Bf(),u+"\n")}var w=ny(n),y=Tz(n);jA(n,(t(),new M(c)));for(u=a;!w.b();){var B=w.e();MX(u,B,c,d,e,g,h);w=w.g()}for(B=a;!y.b();){var D=y.e();MX(B,c,D,d,e,g,h);y=
-y.g()}}else throw new x(r);}else if(m)ew(a,b,l,d,e,g,h),ew(a,l,b,d,e,g,h);else{c=b;b=l;l=c;m=!0;continue}}break}var C=void 0}finally{a.q=-1+a.q|0}Gw(new E(k),a.pa)&&a.D&&(a=""+Hs(Q(),"| ",a.q)+k.n(C),Af(Bf(),a+"\n"))}
-function JX(a,b,c,d,e,g,h,k){var l=!1;if(b.yn.b()){0===(65536&b.Ka)&&0===(65536&b.Ka)&&(b.hO=taa(b),b.Ka|=65536);var m=b.hO.Y(c)}else m=t().f;a:if(m instanceof M)g=m.k,Dx(b).L(c)&&!d&&(d=new mf(new nf(J(new L,["Parameter '","' cannot tbe accessed as a field"]))),l=[pf(qf(),c.w)],d=sf(d,J(new L,l)),l=c.C(),d=G(new H,d,l),l=O().c,yx(a,new A(d,l),e)),t(),e=new M(g);else{if(t().f===m&&(l=!0,b.ws)){bx(b).L(c)&&(t(),Jq(),e=sf(new mf(new nf(J(new L,["Indirectly-recursive member should have a type signature"]))),
-v()),d=c.C(),e=G(new H,e,d),d=O().c,e=Kq(0,new A(e,d),a.Qc,Qt()),g.Lb=new M(e));e=t().f;break a}if(l)g=jx(b,e),g instanceof Aw?e=$W(a,g.nC(),c,d,e):g instanceof yw?e=$W(a,g.nC(),c,d,e):g instanceof Zv?e=$W(a,g.nC(),c,d,e):(g instanceof Fw||$n(),e=t().f);else throw new x(m);}a.D&&(g=Hs(Q(),"| ",a.q),d=b.Kb.sf.w,l=c.w,e.b()?m="":(m=e.o().oa,m=Yw(m)),Af(Bf(),g+("Lookup "+d+"."+l+" : "+e+" where ")+m+"\n"));if(e.b())h=R();else{e=e.o();g=ru().U();dw(a);for(d=b.pg();!d.b();){var n=d.e();if(null!==n){l=
-n.gb;var r=n.xd;m=!1;var u=null;n=h.n(new Wl(b.Kb.sf.w+"#"+n.ec.X));a:{if(n instanceof M){m=!0;u=n;var w=u.k,y=new E(r);t();var B=Tt().bA;if(hf(y,new M(B))){m=w.oa;break a}}if(m&&(w=u.k,r=new E(r),t(),y=Tt().cA,hf(r,new M(y)))){m=w.Ma;m=m.b()?a.tb:m.o();break a}if(m)m=u.k,u=rv(a),n=m.Ma,m=sv(u,n.b()?a.tb:n.o(),m.oa,tv(rv(a)),k);else if(t().f===n){m=ny(l);u=new Pw(a,l,V(a));for(u=new rB(a,!0,u,V(a),O().c);!m.b();)n=m.e(),r=V(u.p),u=zu(u,n,r,!1),m=m.g();m=u;u=Tz(l);n=new Pw(a,l,V(a));for(n=new rB(a,
-!1,n,V(a),O().c);!u.b();)r=u.e(),w=V(n.p),n=ju(n,r,w,!1),u=u.g();m=new wB(a,m,n,l.Zh)}else throw new x(n);}l=G(new H,l,m);g.S(l)}else throw new x(n);d=d.g()}h=new M(QX(e,b.kx,!1,k,g))}a.D&&(a=Hs(Q(),"| ",a.q),k=b.kx,b=b.Kb.sf.w,c=c.w,h.b()?e=R():(e=h.o().oa,e=new M(Yw(e))),Af(Bf(),a+("Fresh["+k+"] "+b+"."+c+" : "+h+" where ")+e+"\n"));return h}function IN(a,b,c){this.tC=null;this.Mt=b;this.Nt=c;if(null===a)throw null;this.tC=a}IN.prototype=new p;IN.prototype.constructor=IN;f=IN.prototype;
-f.ka=function(){return this.Mt.ka()+this.Nt.ka()|0};f.H=function(){return"Shadows"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Mt;case 1:return this.Nt;default:return JK(W(),a)}};f.E=function(a){return a instanceof IN};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof IN&&a.tC===this.tC){var b=this.Mt,c=a.Mt;if(null===b?null===c:b.h(c))return b=this.Nt,a=a.Nt,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({cU:0},!1,"mlscript.ConstraintSolver$Shadows",{cU:1,d:1,F:1,v:1,l:1});class cg extends eF{constructor(){super();this.Hp=null}}function RX(){}RX.prototype=new WR;RX.prototype.constructor=RX;RX.prototype.u=function(){return"Inter"};RX.prototype.aa=function(a,b){return new ZO(a,b)};RX.prototype.$classData=q({KU:0},!1,"mlscript.Inter$",{KU:1,SG:1,d:1,Py:1,l:1});var SX;function Fn(){SX||(SX=new RX);return SX}function $o(a,b,c){this.Tt=b;this.uo=c;if(null===a)throw null;}$o.prototype=new p;
-$o.prototype.constructor=$o;f=$o.prototype;f.H=function(){return"QualifierPack"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Tt;case 1:return this.uo;default:return JK(W(),a)}};f.E=function(a){return a instanceof $o};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){return this===a?!0:a instanceof $o?this.Tt===a.Tt?this.uo===a.uo:!1:!1};f.$classData=q({WU:0},!1,"mlscript.JSBackend$QualifierPack$1",{WU:1,d:1,F:1,v:1,l:1});
-function yn(a){this.JC=null;if(null===a)throw null;this.JC=a}yn.prototype=new WR;yn.prototype.constructor=yn;yn.prototype.u=function(){return"QualifierPack"};yn.prototype.aa=function(a,b){return new $o(this.JC,a,b)};yn.prototype.$classData=q({XU:0},!1,"mlscript.JSBackend$QualifierPack$2$",{XU:1,SG:1,d:1,Py:1,l:1});function $N(a){this.XC=a}$N.prototype=new p;$N.prototype.constructor=$N;f=$N.prototype;
-f.xa=function(){for(var a=Hp(Fp(),"default:"),b=this.XC,c=Fp().ce;!b.b();){var d=b.e();c=az(c,cz(d.xa()));b=b.g()}return az(a,c)};f.H=function(){return"JSDefaultCase"};f.G=function(){return 1};f.I=function(a){return 0===a?this.XC:JK(W(),a)};f.E=function(a){return a instanceof $N};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof $N){var b=this.XC;a=a.XC;return null===b?null===a:b.h(a)}return!1};
-f.$classData=q({lV:0},!1,"mlscript.JSDefaultCase",{lV:1,d:1,F:1,v:1,l:1});function Pp(a,b){this.eH=this.Cw=null;this.dH=a;this.YC=b;No(this,a,b)}Pp.prototype=new vS;Pp.prototype.constructor=Pp;Pp.prototype.xa=function(){var a=Ep(this.dH.xa(),20>this.dH.ih()||this.dH instanceof fo);Fp();var b=cm().cH;if(Rp(new Sp(b.SF,pc(this.YC.Np))))b="."+this.YC.Np;else if(b=this.YC.Np,b=tD(uD(),b),b instanceof M)b="["+(b.k|0)+"]";else{if(t().f!==b)throw new x(b);b="["+Bp(Cp(),this.YC.Np)+"]"}return Gp(a,Hp(0,b))};
-Pp.prototype.$classData=q({oV:0},!1,"mlscript.JSField",{oV:1,VM:1,Oi:1,Uc:1,d:1});function YN(a,b){this.wD=a;this.vD=b}YN.prototype=new p;YN.prototype.constructor=YN;f=YN.prototype;f.xa=function(){for(var a=Gp(Gp(Hp(Fp(),"case "),this.wD.xa()),Hp(Fp(),": ")),b=this.vD,c=Fp().ce;!b.b();){var d=b.e();c=az(c,cz(d.xa()));b=b.g()}return az(a,c)};f.H=function(){return"JSSwitchCase"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.wD;case 1:return this.vD;default:return JK(W(),a)}};
-f.E=function(a){return a instanceof YN};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof YN){var b=this.wD,c=a.wD;if(null===b?null===c:b.h(c))return b=this.vD,a=a.vD,null===b?null===a:b.h(a)}return!1};f.$classData=q({IV:0},!1,"mlscript.JSSwitchCase",{IV:1,d:1,F:1,v:1,l:1});function iq(a,b,c){this.Yg=a;this.Xg=b;this.Wg=c;gp(fp(),0<=a);gp(fp(),b>=a)}iq.prototype=new p;iq.prototype.constructor=iq;
-function jy(a,b){return hf(new E(b.Wg),a.Wg)?b.Yg>=a.Yg&&b.Xg<=a.Xg:!1}function TX(a,b){return hf(new E(b.Wg),a.Wg)?b.Yg>=a.Yg&&b.Yg<=a.Xg||b.Xg<=a.Xg&&b.Xg>=a.Yg:!1}function Rr(a,b){Os(fp(),et(new E(a.Wg),b.Wg));var c=a.Yg,d=b.Yg,e=a.Xg;b=b.Xg;return new iq(c<d?c:d,e>b?e:b,a.Wg)}function Zs(a,b){if(b.b())return a;b=b.o();return Rr(a,b)}function Or(a){return new iq(a.Yg,a.Yg,a.Wg)}f=iq.prototype;f.H=function(){return"Loc"};f.G=function(){return 3};
-f.I=function(a){switch(a){case 0:return this.Yg;case 1:return this.Xg;case 2:return this.Wg;default:return JK(W(),a)}};f.E=function(a){return a instanceof iq};f.y=function(){var a=dc("Loc");a=W().B(-889275714,a);var b=this.Yg;a=W().B(a,b);b=this.Xg;a=W().B(a,b);b=this.Wg;b=dy(W(),b);a=W().B(a,b);return W().La(a,3)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof iq&&this.Yg===a.Yg&&this.Xg===a.Xg){var b=this.Wg;a=a.Wg;return null===b?null===a:b.h(a)}return!1};
-f.$classData=q({VV:0},!1,"mlscript.Loc",{VV:1,d:1,F:1,v:1,l:1});function zq(a){this.wo=a}zq.prototype=new p;zq.prototype.constructor=zq;function MN(a,b){b=Tf(Sf(),Hn(a.wo,new mO(a)),b,"'");return og(a,b)}function og(a,b){var c=a.wo;a=h=>{if(h instanceof oO)return Yf(h.Ew,b,0);if(h instanceof uq)return h.oz;throw new x(h);};if(c===v())a=v();else{var d=c.e(),e=d=new A(a(d),v());for(c=c.g();c!==v();){var g=c.e();g=new A(a(g),v());e=e.r=g;c=c.g()}a=d}return Qe(a,"","","")}f=zq.prototype;
-f.mr=function(){var a=this.wo.m();a=new eg(a,new z(b=>{if(b instanceof oO)return""+b.Ew;if(b instanceof uq)return b.oz;throw new x(b);}));return Qe(a,"","","")};function UX(a,b){return new zq(mn(a.wo,b.wo))}f.H=function(){return"Message"};f.G=function(){return 1};f.I=function(a){return 0===a?this.wo:JK(W(),a)};f.E=function(a){return a instanceof zq};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof zq){var b=this.wo;a=a.wo;return null===b?null===a:b.h(a)}return!1};f.$classData=q({XV:0},!1,"mlscript.Message",{XV:1,d:1,F:1,v:1,l:1});function qO(a,b){this.$r=null;this.pm=b;if(null===a)throw null;this.$r=a}qO.prototype=new p;qO.prototype.constructor=qO;function $s(a,b){var c=a.pm.Y(b);b=a.pm.rj(b);a=new qO(a.$r,b);return G(new H,c,a)}
-function at(a){a.pm.Ag(new Um((b,c)=>{var d=a.$r,e=new mf(new nf(J(new L,["Unrecognized modifier `","` in this position"])));b=[pf(qf(),b)];e=sf(e,J(new L,b));t();c=G(new H,e,new M(c));e=O().c;wf(d,new A(c,e))}))}f=qO.prototype;f.H=function(){return"ModifierSet"};f.G=function(){return 1};f.I=function(a){return 0===a?this.pm:JK(W(),a)};f.E=function(a){return a instanceof qO};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof qO&&a.$r===this.$r){var b=this.pm;a=a.pm;return null===b?null===a:b.h(a)}return!1};f.$classData=q({rW:0},!1,"mlscript.NewParser$ModifierSet",{rW:1,d:1,F:1,v:1,l:1});function uO(a,b){this.Mw=null;this.Sp=b;if(null===a)throw null;this.Mw=a}uO.prototype=new p;uO.prototype.constructor=uO;function zO(a,b){for(b=b.Sp;!b.b();){var c=b.e();a=new uO(a.Mw,new A(c,a.Sp));b=b.g()}return a}
-function yO(a,b,c,d,e){var g=a.Mw;a=a.Sp;for(var h=null,k=null;a!==v();){a:{var l=a.e(),m=b,n=c,r=d,u=e,w=id();try{t();var y=l.bs,B=Lv(l.es,m.es,n,r);if(B.b())throw fq(new gq,w,t().f);var D=B.o(),C=l.fs.af(m.fs),F=wv(l.cs,m.cs,n,r,u);if(F.b())throw fq(new gq,w,t().f);var I=F.o(),K=new tO(y,D,C,I,l.ds.af(m.ds));var N=new M(K)}catch(P){if(P instanceof gq){N=P;if(N.Hg===w){N=N.wj();break a}throw N;}throw P;}}for(w=N.m();w.s();)l=new A(w.t(),v()),null===k?h=l:k.r=l,k=l;a=a.g()}return new uO(g,null===
-h?v():h)}f=uO.prototype;f.u=function(){return"CNF("+Qe(this.Sp,""," \x26 ","")+")"};f.H=function(){return"CNF"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Sp:JK(W(),a)};f.E=function(a){return a instanceof uO};f.y=function(){return jL(this)};f.h=function(a){if(this===a)return!0;if(a instanceof uO&&a.Mw===this.Mw){var b=this.Sp;a=a.Sp;return null===b?null===a:b.h(a)}return!1};f.$classData=q({vW:0},!1,"mlscript.NormalForms$CNF",{vW:1,d:1,F:1,v:1,l:1});
-function VX(a,b){var c=a.ae.m();c=new eg(c,new z(e=>e.rb(b,Lz().U())));var d=dq();c=hq(c,d);return(c.b()?a.hk.md:c.o())|0}
-function WX(a,b,c){var d=ru().U();if(XX(a)<=b.db&&XX(b)<=a.db){c=a.db;var e=b.db;return new YX(c<e?c:e,a.ae,b.ae,a.Ff,b.Ff)}if(VX(a,b.db)<=a.db&&XX(a)<=b.db)return new YX(b.db,a.ae,b.ae,a.Ff,b.Ff);if(VX(b,a.db)<=b.db&&XX(b)<=a.db)return new YX(a.db,a.ae,b.ae,a.Ff,b.Ff);if(b.db>a.db){var g=new Uv(c.V,c.Vc,c.Xa,c.kd,1+b.db|0,c.Ac,c.vb,c.fb,c.ud,c.hb);fp();c=a.db;e=b.db;gp(0,hf(new E(c>e?c:e),b.db));c=a.db;e=b.db;var h=a.ae;if(h===v())var k=v();else{k=h.e();var l=k=new A(hX(k,a.db,!1,g,d),v());for(h=
-h.g();h!==v();){var m=h.e();m=new A(hX(m,a.db,!1,g,d),v());l=l.r=m;h=h.g()}}l=b.ae;Du();h=qF(Du(),a.Ff,new z(u=>u.Dc(a.db,!1,g,d)));return new YX(c>e?c:e,k,l,Mx(0,h,new z(u=>u.Dc(a.db,!1,g,d))),b.Ff)}if(a.db>b.db){var n=new Uv(c.V,c.Vc,c.Xa,c.kd,1+a.db|0,c.Ac,c.vb,c.fb,c.ud,c.hb);fp();c=a.db;e=b.db;gp(0,hf(new E(c>e?c:e),a.db));c=a.db;e=b.db;k=a.ae;m=b.ae;if(m===v())l=v();else for(l=m.e(),h=l=new A(hX(l,b.db,!1,n,d),v()),m=m.g();m!==v();){var r=m.e();r=new A(hX(r,b.db,!1,n,d),v());h=h.r=r;m=m.g()}h=
-a.Ff;Du();b=qF(Du(),b.Ff,new z(u=>u.Dc(a.db,!1,n,d)));return new YX(c>e?c:e,k,l,h,Mx(0,b,new z(u=>u.Dc(a.db,!1,n,d))))}aG||(aG=new $F);return Kba(new YX(a.db,a.ae,b.ae,a.Ff,b.Ff),hf(new E(b.db),a.db))}function HO(a,b,c,d){this.qm=this.kN=this.lN=this.mN=0;this.hk=null;this.db=b;this.Ff=c;this.ae=d;if(null===a)throw null;this.hk=a;if(!(b<=a.tf))throw new rk("assertion failed: "+this.db);}HO.prototype=new p;HO.prototype.constructor=HO;
-function XX(a){0===(1&a.qm)<<24>>24&&0===(1&a.qm)<<24>>24&&(a.mN=VX(a,a.db),a.qm=(1|a.qm)<<24>>24);return a.mN}f=HO.prototype;
-f.nf=function(a){var b=Ww(this.hk),c=this.Ff;if(this.ae.b())var d=this.hk.tb;else{if(a){d=this.ae;var e=mu(),g=ap().wa,h=Fv(d,new ou(e,g))}else h=this.ae;d=$w(this.hk);e=this.db;if(h===v())a=v();else{g=h.e();var k=g=new A(g.nf(a),v());for(h=h.g();h!==v();){var l=h.e();l=new A(l.nf(a),v());k=k.r=l;h=h.g()}a=g}for(g=this.hk.tb;!a.b();)k=a.e(),h=V(g.p),g=zu(g,k,h,!1),a=a.g();d=Zw(d,e,g)}return Xw(b,c,d)};
-f.Ca=function(){if(0===(2&this.qm)<<24>>24&&0===(2&this.qm)<<24>>24){var a=this.ae,b=dq();if(a.b())b=R();else{if(a.b())throw Fu("empty.maxBy");var c=null;var d=null;var e;for(e=!0;!a.b();){var g=a.e(),h=g.Ca();if(e||0<b.Fa(h,c))d=g,c=h,e=!1;a=a.g()}b=new M(d)}this.lN=b.b()?this.hk.md:b.o().Ca();this.qm=(2|this.qm)<<24>>24}return this.lN};function RA(a){return a.Ca()>a.db}
-function bda(a,b){if(RA(a)){var c=ru().U(),d=a.Ff,e=l=>{if(null!==l){var m=l.j();return G(new H,l.i().Dc(a.db,!1,b,c),m.Dc(a.db,!1,b,c))}throw new x(l);};if(d===v())e=v();else{var g=d.e(),h=g=new A(e(g),v());for(d=d.g();d!==v();){var k=d.e();k=new A(e(k),v());h=h.r=k;d=d.g()}e=g}d=a.ae;if(d===v())g=v();else for(g=d.e(),h=g=new A(hX(g,a.db,!1,b,c),v()),d=d.g();d!==v();)k=d.e(),k=new A(hX(k,a.db,!1,b,c),v()),h=h.r=k,d=d.g();return G(new H,e,g)}return G(new H,a.Ff,a.ae)}
-function Hca(a,b,c,d,e){b=WX(a,b,d);if(null===b)throw new x(b);var g=b.Gu|0,h=b.Ks,k=b.zq,l=b.Hu,m=b.Iu;b=w=>{var y=new HO(a.hk,g,Fl(m,l),h),B=y.hk,D=y.db,C=y.Ff;y=y.ae;for(var F=null,I=null;y!==v();){a:{var K=y.e(),N=w,P=c,T=d,aa=e,Y=id();try{if(K.Zf.aw(N.$f,T))var S=t().f;else{t();var Z=LO(K.xb),ka=wv(K.Zf,N.Zf,P,T,aa);if(ka.b())throw fq(new gq,Y,t().f);var X=ka.o(),sa=K.ag.af(N.ag),Ia=Lv(K.$f,N.$f,P,T);if(Ia.b())throw fq(new gq,Y,t().f);var Za=Ia.o(),Ga=void 0,xa=Z,Ra=X,Ja=sa,La=Za,pb=K.Sf.af(N.Sf);
-K=P;var Fb=xa.Tp;if(La instanceof xv)var Gb=new xv(xa.Tp,La.pe,La.qe);else if(La instanceof yv){var Hb=La.lb,tb=La.Ic,kb=xa.Tp,gb=La.bc;b:for(;;)if(gb.b()){Ga=v();break}else{var Vb=gb.e(),bb=gb.g();if(!1===!Qu(Ra,Vb,K,T,aa).b())gb=bb;else for(xa=gb,La=bb;;){if(La.b())Ga=xa;else{var nb=La.e();if(!1!==!Qu(Ra,nb,K,T,aa).b()){La=La.g();continue}var Tb=new A(xa.e(),v()),ub=xa.g();for(xa=Tb;ub!==La;){var Ub=new A(ub.e(),v());xa=xa.r=Ub;ub=ub.g()}var $a=La.g();for(La=$a;!$a.b();){var cb=$a.e();if(!1===!Qu(Ra,
-cb,K,T,aa).b()){for(;La!==$a;){var Na=new A(La.e(),v());xa=xa.r=Na;La=La.g()}La=$a.g()}$a=$a.g()}La.b()||(xa.r=La);Ga=Tb}break b}}if(Hb.b())var Ca=!0;else{var Ba=Hb.o();if(Ba instanceof te)Ca=!Qu(Ra,Ba.ca,K,T,aa).b();else{if(!(Ba instanceof me))throw new x(Ba);Ca=!0}}Gb=new yv(kb,Ga,Ca?Hb:R(),tb)}else if(Av(xa.Tp)===La)Gb=Av(xa.Tp);else throw new x(La);var Oa=new FO(Fb,Ra,Ja,Gb,pb);S=new M(Oa)}}catch(wa){if(wa instanceof gq){S=wa;if(S.Hg===Y){S=S.wj();break a}throw S;}throw wa;}}for(Y=S.m();Y.s();)Ga=
-new A(Y.t(),v()),null===I?F=Ga:I.r=Ga,I=Ga;y=y.g()}return new HO(B,D,C,null===F?v():F)};if(k===v())b=v();else{var n=k.e(),r=n=new A(b(n),v());for(k=k.g();k!==v();){var u=k.e();u=new A(b(u),v());r=r.r=u;k=k.g()}b=n}for(n=IO(YA(a.hk),!1);!b.b();)r=b.e(),n=KO(n,r,d,e),b=b.g();return n}
-function KO(a,b,c,d){var e=WX(a,b,c);if(null===e)throw new x(e);var g=e.Ks;b=e.zq;e=new HO(a.hk,e.Gu|0,Fl(e.Iu,e.Hu),g);for(a=b;!a.b();){var h=e,k=a.e(),l=c,m=d;b=h.hk;e=h.db;g=h.Ff;a:{var n=h.ae;for(h=O().c;;)if(n instanceof A){var r=n.A;n=n.r;if(ZX(r,k,l)){h=jp(h);h=Fl(new A(k,n),h);break a}if(ZX(k,r,l)){h=jp(h);h=Fl(new A(r,n),h);break a}var u=pda(r,k,l,m);if(u instanceof M){k=u.k;h=jp(h);h=Fl(new A(k,n),h);break a}if(R()===u)h=new A(r,h);else throw new x(u);}else{l=O().c;if(null===l?null===n:
-l.h(n)){h=jp(new A(k,h));break a}throw new x(n);}}e=new HO(b,e,g,h);a=a.g()}return e}f.u=function(){var a=this.db,b=Qe(this.ae,""," | ",""),c=this.Ff.b()?"":"{"+Qe(this.Ff,"",", ","")+"}";return"DNF("+a+", "+b+")"+c};f.H=function(){return"DNF"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.db;case 1:return this.Ff;case 2:return this.ae;default:return JK(W(),a)}};f.E=function(a){return a instanceof HO};
-f.y=function(){var a=dc("DNF");a=W().B(-889275714,a);var b=this.db;a=W().B(a,b);b=this.Ff;b=dy(W(),b);a=W().B(a,b);b=this.ae;b=dy(W(),b);a=W().B(a,b);return W().La(a,3)};f.h=function(a){if(this===a)return!0;if(a instanceof HO&&a.hk===this.hk){if(this.db===a.db){var b=this.Ff,c=a.Ff;b=null===b?null===c:b.h(c)}else b=!1;if(b)return b=this.ae,a=a.ae,null===b?null===a:b.h(a)}return!1};f.$classData=q({zW:0},!1,"mlscript.NormalForms$DNF",{zW:1,d:1,F:1,v:1,l:1});
-function tO(a,b,c,d,e){this.bs=null;this.es=b;this.fs=c;this.cs=d;this.ds=e;if(null===a)throw null;this.bs=a}tO.prototype=new p;tO.prototype.constructor=tO;f=tO.prototype;
-f.u=function(){O();var a=new $X(J(new L,[this.es]));a=Vq(new Wq,a);a=new Gx(a,new z(b=>sr(new E(b),Av(this.bs))),!1);a=Cu(a,new U(()=>this.fs)).mb(new U(()=>{O();var b=new $X(J(new L,[this.cs]));b=Vq(new Wq,b);b=new Gx(b,new z(c=>sr(new E(c),pu(this.bs))),!1);b=Cu(b,new U(()=>this.ds));return new eg(b,new z(c=>"~"+c))}));return Qe(a,"","\u2228","")};f.H=function(){return"Disjunct"};f.G=function(){return 4};
-f.I=function(a){switch(a){case 0:return this.es;case 1:return this.fs;case 2:return this.cs;case 3:return this.ds;default:return JK(W(),a)}};f.E=function(a){return a instanceof tO};f.y=function(){return jL(this)};f.h=function(a){if(this===a)return!0;if(a instanceof tO&&a.bs===this.bs){var b=this.es,c=a.es;(null===b?null===c:b.h(c))?(b=this.fs,c=a.fs,b=null===b?null===c:b.h(c)):b=!1;if(b&&(b=this.cs,c=a.cs,null===b?null===c:b.h(c)))return b=this.ds,a=a.ds,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({BW:0},!1,"mlscript.NormalForms$Disjunct",{BW:1,d:1,F:1,v:1,l:1});function sy(a,b,c,d,e,g,h,k){this.uz=null;this.$p=b;this.js=c;this.Zt=d;this.Yt=e;this.ls=g;this.ks=h;this.tm=k;if(null===a)throw null;this.uz=a}sy.prototype=new p;sy.prototype.constructor=sy;f=sy.prototype;f.H=function(){return"Pack"};f.G=function(){return 7};
-f.I=function(a){switch(a){case 0:return this.$p;case 1:return this.js;case 2:return this.Zt;case 3:return this.Yt;case 4:return this.ls;case 5:return this.ks;case 6:return this.tm;default:return JK(W(),a)}};f.E=function(a){return a instanceof sy};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof sy){var b=this.$p,c=a.$p;(null===b?null===c:HB(b,c))?(b=this.js,c=a.js,b=null===b?null===c:b.h(c)):b=!1;b?(b=this.Zt,c=a.Zt,(null===b?null===c:b.h(c))?(b=this.Yt,c=a.Yt,b=null===b?null===c:b.h(c)):b=!1):b=!1;if(b&&(b=this.ls,c=a.ls,(null===b?null===c:b.h(c))?(b=this.ks,c=a.ks,b=null===b?null===c:b.h(c)):b=!1,b))return b=this.tm,a=a.tm,null===b?null===a:HB(b,a)}return!1};
-f.$classData=q({TW:0},!1,"mlscript.NuTypeDefs$DelayedTypeInfoImpl$Pack$1",{TW:1,d:1,F:1,v:1,l:1});function oy(a){this.rN=null;if(null===a)throw null;this.rN=a}oy.prototype=new cS;oy.prototype.constructor=oy;oy.prototype.u=function(){return"Pack"};function waa(a,b,c,d,e,g,h,k){return new sy(a.rN,b,c,d,e,g,h,k)}oy.prototype.$classData=q({UW:0},!1,"mlscript.NuTypeDefs$DelayedTypeInfoImpl$Pack$2$",{UW:1,vba:1,d:1,M$:1,l:1});
-function aY(a,b,c){this.rH=null;this.WD=b;this.wz=c;if(null===a)throw null;this.rH=a}aY.prototype=new p;aY.prototype.constructor=aY;f=aY.prototype;f.H=function(){return"RefMap"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.WD;case 1:return this.wz;default:return JK(W(),a)}};f.E=function(a){return a instanceof aY};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof aY&&a.rH===this.rH){var b=this.WD,c=a.WD;if(null===b?null===c:b.h(c))return b=this.wz,a=a.wz,null===b?null===a:b.h(a)}return!1};f.$classData=q({WW:0},!1,"mlscript.NuTypeDefs$RefMap",{WW:1,d:1,F:1,v:1,l:1});function Xe(a,b,c){this.yz=a;this.Uw=b;this.os=c}Xe.prototype=new p;Xe.prototype.constructor=Xe;f=Xe.prototype;f.u=function(){return this.yz+":+"+this.Uw};f.H=function(){return"Origin"};f.G=function(){return 3};
-f.I=function(a){switch(a){case 0:return this.yz;case 1:return this.Uw;case 2:return this.os;default:return JK(W(),a)}};f.E=function(a){return a instanceof Xe};f.y=function(){var a=dc("Origin");a=W().B(-889275714,a);var b=this.yz;b=dy(W(),b);a=W().B(a,b);b=this.Uw;a=W().B(a,b);b=this.os;b=dy(W(),b);a=W().B(a,b);return W().La(a,3)};f.h=function(a){return this===a?!0:a instanceof Xe?this.Uw===a.Uw?this.yz===a.yz?this.os===a.os:!1:!1:!1};f.$classData=q({jX:0},!1,"mlscript.Origin",{jX:1,d:1,F:1,v:1,l:1});
-function SO(a,b,c,d,e){this.AN=null;this.FH=!1;this.Eo=a;this.Cz=b;this.$w=c;this.Do=d;this.eu=e}SO.prototype=new p;SO.prototype.constructor=SO;function pP(a){a.FH||a.FH||(a.AN=Hs(Q(),"  ",a.$w),a.FH=!0);return a.AN}function rP(a){return new SO(a.Eo,a.Cz,1+a.$w|0,a.Do,a.eu)}f=SO.prototype;f.H=function(){return"ShowCtx"};f.G=function(){return 5};
-f.I=function(a){switch(a){case 0:return this.Eo;case 1:return this.Cz;case 2:return this.$w;case 3:return this.Do;case 4:return this.eu;default:return JK(W(),a)}};f.E=function(a){return a instanceof SO};f.y=function(){var a=dc("ShowCtx");a=W().B(-889275714,a);var b=this.Eo;b=dy(W(),b);a=W().B(a,b);b=this.Cz?1231:1237;a=W().B(a,b);b=this.$w;a=W().B(a,b);b=this.Do?1231:1237;a=W().B(a,b);b=this.eu?1231:1237;a=W().B(a,b);return W().La(a,5)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof SO&&this.Cz===a.Cz&&this.$w===a.$w&&this.Do===a.Do&&this.eu===a.eu){var b=this.Eo;a=a.Eo;return null===b?null===a:b.h(a)}return!1};f.$classData=q({CX:0},!1,"mlscript.ShowCtx",{CX:1,d:1,F:1,v:1,l:1});
-function bY(a,b,c,d,e,g,h,k,l,m,n){this.gE=this.iu=this.EN=this.FN=null;this.dj=b;this.Kl=c;this.zm=d;this.fx=e;this.LH=g;this.MH=h;this.ex=k;this.hE=l;this.us=m;this.KH=n;if(null===a)throw null;this.gE=a;a=ap();d=d.Gb(a.wa);a:{if(null!==d&&(a=d.i(),b=d.j(),null!==a&&null!==b)){d=G(new H,a,b);break a}throw new x(d);}this.FN=d;this.EN=this.FN.j();this.iu=t().f}bY.prototype=new p;bY.prototype.constructor=bY;
-function cY(a,b,c){var d=a.ex.Ga(new z(e=>new sp(e.X)));a=a.ex.m();a=new Gx(a,c,!0);a=new ho(a,new z(e=>{var g=b.vb.Y(e.X);return g.b()?Wp():cY(g.o(),b,c.Yb(e))}));return d.af(a)}function EA(a){a=a.iu;if(a.b()){a=Jf();var b=Tt().En;a=dY(a,b)}else a=a.o();return a}f=bY.prototype;f.H=function(){return"TypeDef"};f.G=function(){return 10};
-f.I=function(a){switch(a){case 0:return this.dj;case 1:return this.Kl;case 2:return this.zm;case 3:return this.fx;case 4:return this.LH;case 5:return this.MH;case 6:return this.ex;case 7:return this.hE;case 8:return this.us;case 9:return this.KH;default:return JK(W(),a)}};f.E=function(a){return a instanceof bY};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof bY&&a.gE===this.gE){if(this.dj===a.dj){var b=this.Kl,c=a.Kl;b=null===b?null===c:b.h(c)}else b=!1;b?(b=this.zm,c=a.zm,(null===b?null===c:b.h(c))?(b=this.fx,c=a.fx,(null===b?null===c:HB(b,c))?(b=this.LH,c=a.LH,b=null===b?null===c:b.h(c)):b=!1):b=!1):b=!1;if(b&&(b=this.MH,c=a.MH,(null===b?null===c:b.h(c))?(b=this.ex,c=a.ex,(null===b?null===c:b.h(c))?(b=this.hE,c=a.hE,b=null===b?null===c:b.h(c)):b=!1):b=!1,b&&(b=this.us,c=a.us,null===b?null===c:b.h(c))))return b=
-this.KH,a=a.KH,null===b?null===a:b.h(a)}return!1};f.$classData=q({SX:0},!1,"mlscript.TypeDefs$TypeDef",{SX:1,d:1,F:1,v:1,l:1});function eY(a){if(null===a)throw null;}eY.prototype=new UR;eY.prototype.constructor=eY;eY.prototype.u=function(){return"TypeDef"};eY.prototype.$classData=q({TX:0},!1,"mlscript.TypeDefs$TypeDef$",{TX:1,sba:1,d:1,J$:1,l:1});function fY(){}fY.prototype=new SR;fY.prototype.constructor=fY;fY.prototype.u=function(){return"TypeName"};fY.prototype.n=function(a){return new sp(a)};
-fY.prototype.$classData=q({$X:0},!1,"mlscript.TypeName$",{$X:1,ML:1,d:1,ja:1,l:1});var gY,rda=function qda(a,b){var d=a.kd.Y(b);return d.b()?(a=(new dx(a.Vc)).XE,a.b()?b=t().f:(a=a.o(),b=qda(a,b)),b):d};function Uv(a,b,c,d,e,g,h,k,l,m){this.V=this.KN=null;this.Vc=b;this.Xa=c;this.kd=d;this.fa=e;this.Ac=g;this.vb=h;this.fb=k;this.ud=l;this.hb=m;if(null===a)throw null;this.V=a;this.KN=ru().U()}Uv.prototype=new p;Uv.prototype.constructor=Uv;
-function Vv(a,b){for(b=b.m();b.s();){var c=b.t();a.Xa.S(c)}}function PB(a,b){var c=a.Xa.Y(b);return c.b()?(a=(new dx(a.Vc)).XE,a.b()?t().f:PB(a.o(),b)):c}function hY(a,b,c){t();b=G(new H,b,c);return rda(a,new me(b))}function Of(a){var b=new M(a),c=ru().U(),d=ru().U();return new Uv(a.V,b,c,d,a.fa,a.Ac,a.vb,a.fb,a.ud,a.hb)}
-function qx(a,b,c,d){var e=1+a.fa|0,g=ru().U();g=new Uv(a.V,a.Vc,a.Xa,a.kd,e,a.Ac,a.vb,a.fb,a.ud,g);b=b.n(g);e=g.hb;gp(fp(),a.V.$h||g.hb.b());if(!e.b()){g=a.V.pa;var h=a.V;if(h.D){var k=Hs(Q(),"| ",h.q)+"UNSTASHING... (out)";Af(Bf(),k+"\n")}h.q=1+h.q|0;try{e.ya(new z(m=>{if(null!==m){var n=m.i();for(m=m.j().m();m.s();){var r=m.t();a:{if(null!==r){var u=r.j();if(!0===r.Xc()){r=dw(a.V).Cb;ew(a.V,u,n,c,d,a,r);break a}}if(null!==r&&(u=r.j(),!1===r.Xc())){r=dw(a.V).Cb;ew(a.V,n,u,c,d,a,r);break a}throw new x(r);
-}}}else throw new x(m);}));e.eg();var l=void 0}finally{h.q=-1+h.q|0}Gw(new E(g),h.pa)&&h.D&&(l=""+Hs(Q(),"| ",h.q)+g.n(l),Af(Bf(),l+"\n"))}return b}
-function ox(a,b,c,d){var e=1+a.fa|0,g=ru().U();e=new Uv(a.V,a.Vc,a.Xa,a.kd,e,a.Ac,a.vb,a.fb,a.ud,g);b=b.n(e);gp(fp(),a.V.$h||e.hb.b());ru().U();g=Ww(a.V);var h=e.hb.m();h=new ho(h,new z(m=>{if(null!==m){var n=m.i();m=m.j().m();return new eg(m,new z(r=>{if(null!==r){var u=r.Xc();r=r.j();gp(fp(),r.Ca()>a.fa);return u?G(new H,r,n):G(new H,n,r)}throw new x(r);}))}throw new x(m);}));je();b=Xw(g,le(v(),h),b);g=a.V;g.D&&(g=Hs(Q(),"| ",g.q)+("Inferred poly constr: "+b+"  \u2014\u2014 where ")+Yw(b),Af(Bf(),
-g+"\n"));a.V.D&&sr(new E(b),b)&&(g=a.V,g.D&&(g=Hs(Q(),"| ",g.q)+("Refreshed:            "+b+"  \u2014\u2014 where ")+Yw(b),Af(Bf(),g+"\n")));b=Zw($w(a.V),a.fa,b);e.hb.eg();g=e.hb;gp(fp(),a.V.$h||e.hb.b());if(!g.b()){e=a.V.pa;h=a.V;if(h.D){var k=Hs(Q(),"| ",h.q)+"UNSTASHING... (out)";Af(Bf(),k+"\n")}h.q=1+h.q|0;try{g.ya(new z(m=>{if(null!==m){var n=m.i();for(m=m.j().m();m.s();){var r=m.t();a:{if(null!==r){var u=r.j();if(!0===r.Xc()){r=dw(a.V).Cb;ew(a.V,u,n,c,d,a,r);break a}}if(null!==r&&(u=r.j(),!1===
-r.Xc())){r=dw(a.V).Cb;ew(a.V,n,u,c,d,a,r);break a}throw new x(r);}}}else throw new x(m);}));g.eg();var l=void 0}finally{h.q=-1+h.q|0}Gw(new E(e),h.pa)&&h.D&&(l=""+Hs(Q(),"| ",h.q)+e.n(l),Af(Bf(),l+"\n"))}return b}function iY(a,b){return a.KN.Ai(b,new U(()=>{var c=a.vb.Y(b);return c.b()?Wp():cY(c.o(),a,Wp())}))}f=Uv.prototype;f.H=function(){return"Ctx"};f.G=function(){return 9};
-f.I=function(a){switch(a){case 0:return this.Vc;case 1:return this.Xa;case 2:return this.kd;case 3:return this.fa;case 4:return this.Ac;case 5:return this.vb;case 6:return this.fb;case 7:return this.ud;case 8:return this.hb;default:return JK(W(),a)}};f.E=function(a){return a instanceof Uv};
-f.y=function(){var a=dc("Ctx");a=W().B(-889275714,a);var b=this.Vc;b=dy(W(),b);a=W().B(a,b);b=this.Xa;b=dy(W(),b);a=W().B(a,b);b=this.kd;b=dy(W(),b);a=W().B(a,b);b=this.fa;a=W().B(a,b);b=this.Ac?1231:1237;a=W().B(a,b);b=this.vb;b=dy(W(),b);a=W().B(a,b);b=this.fb;b=dy(W(),b);a=W().B(a,b);b=this.ud;b=dy(W(),b);a=W().B(a,b);b=this.hb;b=dy(W(),b);a=W().B(a,b);return W().La(a,9)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Uv&&a.V===this.V){if(this.fa===a.fa&&this.Ac===a.Ac){var b=this.Vc,c=a.Vc;(null===b?null===c:b.h(c))?(b=this.Xa,c=a.Xa,(null===b?null===c:b.h(c))?(b=this.kd,c=a.kd,b=null===b?null===c:b.h(c)):b=!1):b=!1}else b=!1;if(b&&(b=this.vb,c=a.vb,(null===b?null===c:b.h(c))?(b=this.fb,c=a.fb,b=null===b?null===c:b.h(c)):b=!1,b&&(b=this.ud,c=a.ud,null===b?null===c:b.h(c))))return b=this.hb,a=a.hb,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({kY:0},!1,"mlscript.Typer$Ctx",{kY:1,d:1,F:1,v:1,l:1});
-function Iw(a,b,c,d,e){this.J=null;this.ws=!1;this.yn=null;this.kx=0;this.dO=this.bh=this.bO=this.lu=null;this.mE=!1;this.jO=null;this.$H=!1;this.YN=this.aO=this.hO=this.TN=this.eO=this.WN=this.kO=this.VN=this.lO=this.$N=this.cO=this.iO=this.ZN=this.UN=this.gO=this.fO=this.XN=null;this.Ka=0;this.Kb=b;this.BY=c;this.Kd=d;this.ue=e;ZB(this,a);this.ws=!1;this.yn=t().f;this.kx=this.Kd.fa;this.lu=this.Kb.zd();this.bO=this.Kb.sf.w;a=this.J;b=this.Kb.C();this.bh=Mw(new Nw,a,b,Ax(this.Kb),(Uw(this.J),t().f),
-(Uw(this.J),!1));a=this.J;a.D&&(a=Hs(Q(),"| ",a.q)+(this.Kd.fa+". Created lazy type info for ")+this.Kb,Af(Bf(),a+"\n"));this.$H=this.mE=!1}Iw.prototype=new NP;Iw.prototype.constructor=Iw;f=Iw.prototype;f.u=function(){var a=this.Kb.sf.w;if(this.ws)var b="\x3ccomputing\x3e";else b=this.yn,b=b.b()?"\x3cuncomputed\x3e":b.o().u();return a+" ~\x3e "+b};f.zd=function(){return this.lu};
-function Yv(a){if(0===(1&a.Ka)&&0===(1&a.Ka)){var b=a.Kb;if(b instanceof io){b=b.ti;for(var c=null,d=null;b!==v();){var e=b.e(),g=!1,h=null;b:if(e instanceof Wl)h=e,t(),h=new vp(h,h,O().c,O().c),h=new M(h);else{if(e instanceof mm){g=!0;h=e;var k=h.kb,l=h.hc;if(k instanceof Wl&&l instanceof im){e=l.Ra;t();h=new vp(h,k,O().c,e);h=new M(h);break b}}if(e instanceof km&&(k=e,l=k.ym,k=k.ts,l instanceof Wl)){h=l;t();h=new vp(h,h,k,O().c);h=new M(h);break b}if(g&&(l=h.kb,g=h.hc,l instanceof km&&(k=l.ym,l=
-l.ts,k instanceof Wl&&g instanceof im))){e=g.Ra;t();h=new M(new vp(h,k,l,e));break b}Xv(a.J,sf(new mf(new nf(J(new L,["Unsupported parent specification"]))),v()),e.C(),a.ue);h=t().f}for(h=h.m();h.s();)e=new A(h.t(),v()),null===d?c=e:d.r=e,d=e;b=b.g()}b=null===c?v():c;for(d=c=null;b!==v();){k=b.e();b:{if(null!==k&&(h=k.Jj,e=k.jj,g=k.ci,l=k.Qi,null!==e)){k=e.w;var m=!1,n=PB(a.Kd,k);if(n instanceof M){m=!0;var r=n;r=r.k;if(r instanceof MP){k=r;t();h=new M(new YX(h,e,k,g,l));break b}}if(m){Xv(a.J,sf(new mf(new nf(J(new L,
-["Cannot inherit from this"]))),v()),h.C(),a.ue);h=t().f;break b}if(t().f===n){e=a.J;g=new mf(new nf(J(new L,["Could not find definition `","`"])));l=[pf(qf(),k)];Xv(e,sf(g,J(new L,l)),h.C(),a.ue);h=t().f;break b}throw new x(n);}throw new x(k);}for(h=h.m();h.s();)e=new A(h.t(),v()),null===d?c=e:d.r=e,d=e;b=b.g()}b=null===c?v():c}else b=O().c;a.dO=b;a.Ka|=1}return a.dO}function hx(a){0===(2&a.Ka)&&0===(2&a.Ka)&&(a.jO=gaa(a),a.Ka|=2);return a.jO}
-function Jw(a){if(0===(4&a.Ka)&&0===(4&a.Ka)){if(a.$H)var b=Wp();else{a.$H=!0;b=Yv(a);var c=Wp();b=haa(a,b,c)}a.XN=b;a.Ka|=4}return a.XN}f.pg=function(){0===(8&this.Ka)&&0===(8&this.Ka)&&(this.fO=iaa(this),this.Ka|=8);return this.fO};function rx(a){0===(16&a.Ka)&&0===(16&a.Ka)&&(a.gO=jaa(a),a.Ka|=16);return a.gO}function oD(a){0===(32&a.Ka)&&0===(32&a.Ka)&&(a.UN=kaa(a),a.Ka|=32);return a.UN}function $v(a){0===(64&a.Ka)&&0===(64&a.Ka)&&(a.ZN=a.BY.oe(rx(a)),a.Ka|=64);return a.ZN}
-function Rw(a){0===(128&a.Ka)&&0===(128&a.Ka)&&(a.iO=laa(a),a.Ka|=128);return a.iO}function Wv(a){0===(256&a.Ka)&&0===(256&a.Ka)&&(a.cO=maa(a),a.Ka|=256);return a.cO}function jY(a){0===(512&a.Ka)&&0===(512&a.Ka)&&(a.$N=naa(a),a.Ka|=512);return a.$N}function ax(a){0===(1024&a.Ka)&&0===(1024&a.Ka)&&(a.lO=jY(a).i(),a.Ka|=1024);return a.lO}function paa(a){0===(2048&a.Ka)&&0===(2048&a.Ka)&&(a.VN=jY(a).j(),a.Ka|=2048);return a.VN}
-function wx(a){0===(4096&a.Ka)&&0===(4096&a.Ka)&&(a.kO=oaa(a),a.Ka|=4096);return a.kO}function gx(a){0===(8192&a.Ka)&&0===(8192&a.Ka)&&(a.WN=qaa(a),a.Ka|=8192);return a.WN}function Dx(a){0===(16384&a.Ka)&&0===(16384&a.Ka)&&(a.eO=raa(a),a.Ka|=16384);return a.eO}function bx(a){0===(32768&a.Ka)&&0===(32768&a.Ka)&&(a.TN=saa(a),a.Ka|=32768);return a.TN}
-function sx(a){if(0===(131072&a.Ka)&&0===(131072&a.Ka)){var b,c=b=a.J,d=a.Kb.C(),e=Ax(a.Kb);t();c=Mw(new Nw,c,d,e,new M(a.Kb.sf.w),a.Kb instanceof io);d=t().f;t();e=new M(a.Kb.sf.w);var g=O().c,h=O().c;b=new Ow(b,1+a.kx|0,g,h,d,e,!1,c);a.aO=b;a.Ka|=131072}return a.aO}function tx(a){if(0===(262144&a.Ka)&&0===(262144&a.Ka)){var b=a.J;var c=V(a.J),d=t().f;t();var e=BF(Ne(),a.Kb.sf.w);e=new M(e);var g=O().c,h=O().c;b=new Ow(b,1+a.Kd.fa|0,g,h,d,e,!1,c);a.YN=b;a.Ka|=262144}return a.YN}
-f.NP=function(a){return jx(this,a)};f.$classData=q({AY:0},!1,"mlscript.TyperDatatypes$DelayedTypeInfo",{AY:1,JY:1,DO:1,d:1,Z$:1});function ww(a,b,c,d){this.Ua=null;this.Ma=b;this.oa=c;this.vd=d;if(null===a)throw null;this.Ua=a}ww.prototype=new p;ww.prototype.constructor=ww;f=ww.prototype;f.Ca=function(){var a=this.Ma;a.b()?a=R():(a=a.o(),a=new M(a.Ca()));a=(a.b()?this.oa.Ca():a.o())|0;var b=this.oa.Ca();return a>b?a:b};
-f.rb=function(a,b){var c=this.Ma;c=c.b()?this.Ua.md:c.o().rb(a,b);a=this.oa.rb(a,b);return c>a?c:a};function Sv(a,b,c,d){var e=b.Ma;e=e.b()?a.Ua.tb:e.o();var g=a.Ma;g=g.b()?a.Ua.tb:g.o();return tu(e,g,c,!0,d)?tu(a.oa,b.oa,c,!0,d):!1}function av(a,b,c){var d=a.Ua,e=a.Ma;if(e.b())e=b.Ma;else{e=e.o();var g=b.Ma;if(!g.b()){g=g.o();var h=V(e.p);e=zu(e,g,h,!1)}e=new M(e)}g=a.oa;b=b.oa;a=V(a.oa.p);return new ww(d,e,ju(g,b,a,!1),c)}
-function Kv(a,b,c){var d=a.Ua,e=a.Ma;if(e.b())e=R();else{e=e.o();var g=b.Ma;if(g.b())e=R();else{g=g.o();var h=V(e.p);e=new M(ju(e,g,h,!1))}}g=a.oa;b=b.oa;a=V(a.oa.p);return new ww(d,e,zu(g,b,a,!1),c)}function DA(a,b,c){var d=a.Ma;return new ww(a.Ua,d.b()?R():new M(b.n(d.o())),c.n(a.oa),a.vd)}function QX(a,b,c,d,e){var g=a.Ua,h=a.Ma;h.b()?h=R():(h=h.o(),h=new M(h.Dc(b,c,d,e)));return new ww(g,h,a.oa.Dc(b,c,d,e),a.vd)}
-f.u=function(){var a=this.Ma;if(a.b())return""+this.oa;a=a.o();return"mut "+(hf(new E(a),this.Ua.tb)?"":a)+".."+this.oa};f.H=function(){return"FieldType"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Ma;case 1:return this.oa;default:return JK(W(),a)}};f.E=function(a){return a instanceof ww};f.y=function(){return jL(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof ww&&a.Ua===this.Ua){var b=this.Ma,c=a.Ma;if(null===b?null===c:b.h(c))return b=this.oa,a=a.oa,null===b?null===a:HB(b,a)}return!1};f.$classData=q({GY:0},!1,"mlscript.TyperDatatypes$FieldType",{GY:1,d:1,F:1,v:1,l:1});function kY(a){a=a.iK().m();a=new eg(a,new z(b=>new Wl(b.X)));return Zp($p(),a)}function lY(a){var b=a.Gq().vi;a=a.iK().Ga(new z(c=>c.X));return"#"+(b+("\x3c"+Qe(a,"",",",""))+"\x3e")}
-function qB(a){return!!(a&&a.$classData&&a.$classData.pb.tO)}function mY(a,b){if(null===b)throw null;a.p=b;a.fe=a.p.nm;a.Ud=-1+a.fe|0;a.Td=a;b.Vo=1+b.Vo|0}function aA(){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0}aA.prototype=new PP;aA.prototype.constructor=aA;function nY(){}nY.prototype=aA.prototype;aA.prototype.h=function(a){return HB(this,a)};
-aA.prototype.y=function(){if(0===(1&this.Wc)<<24>>24&&0===(1&this.Wc)<<24>>24){if(this instanceof Ow)var a=this.Jo;else if(this instanceof qA)a=this.yi.y();else if(null!==this&&as(this))a=jL(this);else throw new x(this);this.de=a;this.Wc=(1|this.Wc)<<24>>24}return this.de};function JC(a){if(0===(2&a.Wc)<<24>>24&&0===(2&a.Wc)<<24>>24){a:if(a instanceof wB)var b=!0;else{for(b=YC(a,!1);!b.b();){if(JC(b.e())){b=!0;break a}b=b.g()}b=!1}a.ee=b;a.Wc=(2|a.Wc)<<24>>24}return a.ee}
-aA.prototype.Dc=function(a,b,c,d){var e=this.p,g=this.p.tf,h=Wp();return AC(e,this,g,c,a,h,d,b)};aA.prototype.ZS=function(){return CB(this)};function Mw(a,b,c,d,e,g){a.Ia=c;a.th=d;a.An=e;a.Bm=g;if(null===b)throw null;a.qu=b;a.mx=!e.b();return a}function Nw(){this.An=this.th=this.Ia=null;this.mx=this.Bm=!1;this.qu=null}Nw.prototype=new p;Nw.prototype.constructor=Nw;function oY(){}f=oY.prototype=Nw.prototype;
-f.u=function(){var a=this.mx?"o: ":"",b=this.Ia;b.b()?b=this.th:(b=b.o(),b=this.th+":"+b);return a+"\u2039"+b+"\u203a"};f.H=function(){return"TypeProvenance"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.Ia;case 1:return this.th;case 2:return this.An;case 3:return this.Bm;default:return JK(W(),a)}};f.E=function(a){return a instanceof Nw};
-f.y=function(){var a=dc("TypeProvenance");a=W().B(-889275714,a);var b=this.Ia;b=dy(W(),b);a=W().B(a,b);b=this.th;b=dy(W(),b);a=W().B(a,b);b=this.An;b=dy(W(),b);a=W().B(a,b);b=this.Bm?1231:1237;a=W().B(a,b);return W().La(a,4)};f.h=function(a){if(this===a)return!0;if(a instanceof Nw&&a.qu===this.qu){if(this.Bm===a.Bm){var b=this.Ia,c=a.Ia;b=null===b?null===c:b.h(c)}else b=!1;if(b&&this.th===a.th)return b=this.An,a=a.An,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({EO:0},!1,"mlscript.TyperDatatypes$TypeProvenance",{EO:1,d:1,F:1,v:1,l:1});function EP(a){if(null===a)throw null;}EP.prototype=new aS;EP.prototype.constructor=EP;EP.prototype.u=function(){return"TypeProvenance"};EP.prototype.$classData=q({cZ:0},!1,"mlscript.TyperDatatypes$TypeProvenance$",{cZ:1,uba:1,d:1,L$:1,l:1});function VP(a,b){this.wd=a;this.Vd=b}VP.prototype=new p;VP.prototype.constructor=VP;f=VP.prototype;f.u=function(){return this.$v()};
-f.$v=function(){var a=this.Vd;if(!0===this.wd&&!0===a)return"\u00b1";a=this.Vd;if(!1===this.wd&&!0===a)return"-";a=this.Vd;if(!0===this.wd&&!1===a)return"+";a=this.Vd;if(!1===this.wd&&!1===a)return"\x3d";throw new x(this);};f.H=function(){return"VarianceInfo"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.wd;case 1:return this.Vd;default:return JK(W(),a)}};f.E=function(a){return a instanceof VP};
-f.y=function(){var a=dc("VarianceInfo");a=W().B(-889275714,a);var b=this.wd?1231:1237;a=W().B(a,b);b=this.Vd?1231:1237;a=W().B(a,b);return W().La(a,2)};f.h=function(a){return this===a?!0:a instanceof VP?this.wd===a.wd&&this.Vd===a.Vd:!1};f.$classData=q({AZ:0},!1,"mlscript.VarianceInfo",{AZ:1,d:1,F:1,v:1,l:1});function AD(){this.uA=null;Hy();var a=v();this.uA=Iy(a)}AD.prototype=new p;AD.prototype.constructor=AD;
-function kn(a){if(a.uA.b())return t().f;to();var b=a.uA;je();b=uo(le(v(),b));a.uA.eg();t();return new M(b)}function Ao(a,b){a=kn(a);if(a instanceof M)return new A(a.k,b);if(t().f===a)return b;throw new x(a);}function co(a,b){a=kn(a);if(a instanceof M){a=a.k;t();b=jn(b);var c=O().c;return new me(new A(a,new A(b,c)))}if(t().f===a)return t(),new te(b);throw new x(a);}f=AD.prototype;f.H=function(){return"TemporaryVariableEmitter"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};
-f.E=function(a){return a instanceof AD};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){return a instanceof AD};f.$classData=q({UZ:0},!1,"mlscript.codegen.TemporaryVariableEmitter",{UZ:1,d:1,F:1,v:1,l:1});function gE(a,b){this.Pi=a;this.hj=b}gE.prototype=new p;gE.prototype.constructor=gE;f=gE.prototype;
-f.u=function(){var a=Qe(this.Pi,""," and ",""),b=this.hj.b()?"":" ",c=this.hj,d=O().c;if(null===d?null===c:d.h(c))d="";else{if(c===v())d=v();else{d=c.e();var e=d=new A(d.Hj.w,v());for(c=c.g();c!==v();){var g=c.e();g=new A(g.Hj.w,v());e=e.r=g;c=c.g()}}d=Qe(d,"(",", ",")")}return a+b+d};
-function pY(a,b){var c=a.Pi;a=a.hj;if(null===b)throw new x(b);var d=b.Pi;b=b.hj;var e=O().c;if(null===e?null===d:e.h(d))return new gE(c,Fl(b,a));if(d instanceof A)return e=d.A,e.$e=Fl(e.$e,a),new gE(Fl(d,c),b);throw new x(d);}function qY(a,b){var c=O().c;if(null===c?null===b:c.h(b))return a;if(b instanceof A)return c=b.A,c.$e=Fl(c.$e,a.hj),new gE(Fl(b,a.Pi),O().c);throw new x(b);}
-function sda(a,b){a:for(var c=O().c,d=a.Pi,e=R();;){var g=!1,h=null,k=O().c;if(null===k?null===d:k.h(d)){b=e;break a}if(d instanceof A){g=!0;h=d;var l=h.A;k=h.r;if(l instanceof hE){h=l;if(hf(new E(h.Ex),b)){t();b=new M(new Ul(c,h,k));break a}c=wq(c,h);d=k;continue}}if(g&&(l=h.A,k=h.r,l instanceof nE)){h=l;if(hf(new E(h.Cx),b)){t();b=new M(new Ul(c,h,k));break a}c=wq(c,h);d=k;continue}if(g&&(l=h.A,k=h.r,l instanceof lE)){h=l;hf(new E(h.Ax),b)?(g=c,e.b()&&(t(),e=new M(new Ul(g,h,k))),d=k):(c=wq(c,h),
-d=k);continue}if(g)g=h.r,c=wq(c,h.A),d=g;else throw new x(d);}if(b.b())return R();b=b.o();if(null!==b)a=G(new H,b.gb,new gE(Fl(b.xd,b.ec),a.hj));else throw new x(b);return new M(a)}function rY(a,b){var c=a.Pi,d=O().c;if(null===d?null===c:d.h(c))return c=O().c,b=b.ea(),new gE(c,Fl(a.hj,b));if(c instanceof A)return c=c.A,d=c.$e,c.$e=Fl(b.ea(),d),a;throw new x(c);}f.H=function(){return"Conjunction"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.Pi;case 1:return this.hj;default:return JK(W(),a)}};f.E=function(a){return a instanceof gE};f.y=function(){return jL(this)};f.h=function(a){if(this===a)return!0;if(a instanceof gE){var b=this.Pi,c=a.Pi;if(null===b?null===c:b.h(c))return b=this.hj,a=a.hj,null===b?null===a:b.h(a)}return!1};f.$classData=q({i_:0},!1,"mlscript.ucs.Conjunction",{i_:1,d:1,F:1,v:1,l:1});function JE(a,b,c,d){this.uq=a;this.BA=b;this.Hj=c;this.vq=d}JE.prototype=new p;
-JE.prototype.constructor=JE;f=JE.prototype;f.H=function(){return"LetBinding"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.uq;case 1:return this.BA;case 2:return this.Hj;case 3:return this.vq;default:return JK(W(),a)}};f.E=function(a){return a instanceof JE};
-f.y=function(){var a=dc("LetBinding");a=W().B(-889275714,a);var b=this.uq;b=dy(W(),b);a=W().B(a,b);b=this.BA?1231:1237;a=W().B(a,b);b=this.Hj;b=dy(W(),b);a=W().B(a,b);b=this.vq;b=dy(W(),b);a=W().B(a,b);return W().La(a,4)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof JE&&this.BA===a.BA&&this.uq===a.uq){var b=this.Hj,c=a.Hj;if(null===b?null===c:b.h(c))return b=this.vq,a=a.vq,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({l_:0},!1,"mlscript.ucs.LetBinding",{l_:1,d:1,F:1,v:1,l:1});class sY extends mS{constructor(a){super();fF(this,a,null,!0)}}sY.prototype.$classData=q({B_:0},!1,"mlscript.ucs.PartialTermError",{B_:1,qF:1,jc:1,d:1,l:1});function tY(a,b,c){this.In=a;this.dh=b;this.IP=c}tY.prototype=new p;tY.prototype.constructor=tY;function $D(a){var b=a.In;b.b()?(a=a.dh,a instanceof uY||Dn("`term` must be a `SimpleTerm` when `local` is empty")):a=b.o();return a}
-function vY(a){var b=a.In;if(b.b())return R();b=b.o();return new M(new JE(IE(),!1,b,a.dh))}f=tY.prototype;f.u=function(){var a=this.In;a:if(t().f===a)a="";else{if(a instanceof M){var b=a.k;if(null!==b){a=b.w+" @ ";break a}}throw new x(a);}return a+""+rz(this.dh,!1)};f.H=function(){return"Scrutinee"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.In;case 1:return this.dh;default:return JK(W(),a)}};f.E=function(a){return a instanceof tY};f.y=function(){return jL(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof tY){var b=this.In,c=a.In;if(null===b?null===c:b.h(c))return b=this.dh,a=a.dh,null===b?null===a:b.h(a)}return!1};f.$classData=q({C_:0},!1,"mlscript.ucs.Scrutinee",{C_:1,d:1,F:1,v:1,l:1});q({F_:0},!1,"mlscript.utils.algorithms$CyclicGraphError",{F_:1,fd:1,jc:1,d:1,l:1});function wY(){}wY.prototype=new nT;wY.prototype.constructor=wY;function xY(){}xY.prototype=wY.prototype;function kD(a){var b=new qT;fF(b,a,null,!0);return b}class qT extends mS{}
-qT.prototype.$classData=q({v2:0},!1,"scala.NotImplementedError",{v2:1,qF:1,jc:1,d:1,l:1});function YF(){}YF.prototype=new p;YF.prototype.constructor=YF;f=YF.prototype;f.Nb=function(a,b){return xQ(this,a,b)};f.u=function(){return"\x3cfunction1\x3e"};f.Ec=function(){return!1};f.hJ=function(a){throw new x(a);};f.n=function(a){this.hJ(a)};f.$classData=q({B2:0},!1,"scala.PartialFunction$$anon$1",{B2:1,d:1,za:1,ja:1,l:1});function wQ(a,b){this.oK=a;this.UQ=b}wQ.prototype=new p;
-wQ.prototype.constructor=wQ;f=wQ.prototype;f.u=function(){return"\x3cfunction1\x3e"};f.Ec=function(a){return this.oK.Ec(a)};f.n=function(a){return this.UQ.n(this.oK.n(a))};f.Nb=function(a,b){var c=this.oK.Nb(a,XF().fv);return ZF(XF(),c)?b.n(a):this.UQ.n(c)};f.$classData=q({C2:0},!1,"scala.PartialFunction$AndThen",{C2:1,d:1,za:1,ja:1,l:1});function vQ(a,b){this.qK=a;this.pK=b}vQ.prototype=new p;vQ.prototype.constructor=vQ;f=vQ.prototype;f.u=function(){return"\x3cfunction1\x3e"};
-f.Ec=function(a){a=this.qK.Nb(a,XF().fv);return!ZF(XF(),a)&&this.pK.Ec(a)};f.n=function(a){return this.pK.n(this.qK.n(a))};f.Nb=function(a,b){var c=this.qK.Nb(a,XF().fv);return ZF(XF(),c)?b.n(a):this.pK.Nb(c,new z(()=>b.n(a)))};f.$classData=q({D2:0},!1,"scala.PartialFunction$Combined",{D2:1,d:1,za:1,ja:1,l:1});function qr(a){this.F2=a}qr.prototype=new SR;qr.prototype.constructor=qr;function pr(a,b){a=a.F2.Nb(b,XF().fv);return ZF(XF(),a)?R():new M(a)}qr.prototype.n=function(a){return pr(this,a)};
-qr.prototype.$classData=q({E2:0},!1,"scala.PartialFunction$Lifted",{E2:1,ML:1,d:1,ja:1,l:1});function nf(a){this.LF=null;this.hv=a}nf.prototype=new p;nf.prototype.constructor=nf;function tda(){var a=new nf(J(new L,["",".",""]));null===a.LF&&null===a.LF&&(a.LF=new bG(a));return a.LF}f=nf.prototype;f.H=function(){return"StringContext"};f.G=function(){return 1};f.I=function(a){return 0===a?this.hv:JK(W(),a)};f.E=function(a){return a instanceof nf};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof nf){var b=this.hv;a=a.hv;return null===b?null===a:b.h(a)}return!1};f.$classData=q({K2:0},!1,"scala.StringContext",{K2:1,d:1,F:1,v:1,l:1});function yY(){}yY.prototype=new p;yY.prototype.constructor=yY;function zY(){}f=zY.prototype=yY.prototype;f.m=function(){return this};f.b=function(){return!this.s()};f.mb=function(a){return Cu(this,a)};f.qn=function(a){return PT(this,a)};f.fh=function(a){return this.fk(a,-1)};
-f.fk=function(a,b){return QT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.ya=function(a){KG(this,a)};f.ge=function(a,b){return NA(this,a,b)};f.Bi=function(a){return MG(this,a)};f.yc=function(a,b,c){return NG(this,a,b,c)};f.Ui=function(a){return PG(this,a)};f.Ti=function(a){return QG(this,a)};f.vh=function(a,b,c,d){return RG(this,a,b,c,d)};f.ea=function(){je();return le(v(),this)};f.Li=function(){return bp(cp(),this)};f.vj=function(a){return LA(this,a)};f.Rc=function(){return Eq(this)};
-f.Q=function(){return-1};f.Ga=function(a){return new eg(this,a)};function AY(){this.bm=null;this.bm=BY()}AY.prototype=new yT;AY.prototype.constructor=AY;AY.prototype.$classData=q({u4:0},!1,"scala.collection.Iterable$",{u4:1,UF:1,d:1,Uf:1,l:1});var CY;function mK(){CY||(CY=new AY);return CY}function DY(){this.CR=this.BR=this.ft=null;Wca(this);EY=this;this.BR=id();this.CR=new U(()=>FY().BR)}DY.prototype=new XT;DY.prototype.constructor=DY;
-DY.prototype.$classData=q({b5:0},!1,"scala.collection.Map$",{b5:1,c5:1,d:1,hy:1,l:1});var EY;function FY(){EY||(EY=new DY);return EY}function GY(){this.FR=null;HY=this;this.FR=new IY}GY.prototype=new p;GY.prototype.constructor=GY;f=GY.prototype;f.Db=function(){var a=new GV(16,.75);return new fU(a,new z(b=>new Iu(b)))};f.wh=function(a){return(a=(ap(),bp(cp(),a)))&&a.$classData&&a.$classData.pb.XK?a:new Iu(a)};f.Ib=function(a){return aU(gU(),a)};f.U=function(){return this.FR};
-f.$classData=q({i5:0},!1,"scala.collection.MapView$",{i5:1,d:1,hba:1,hy:1,l:1});var HY;function JY(){this.rl=null}JY.prototype=new p;JY.prototype.constructor=JY;function KY(){}KY.prototype=JY.prototype;function kE(a,b){return a.rl.wh(b)}function mE(a){return a.rl.U()}f=JY.prototype;f.jl=function(a){return this.rl.Ib(a)};f.Db=function(){return this.rl.Db()};f.Ib=function(a){return this.jl(a)};f.U=function(){return mE(this)};f.wh=function(a){return kE(this,a)};
-function Kl(a){return a.zi(new z(b=>b))}function LY(a,b){return a.qc(new MY(a,b))}function uda(a,b){return a.Rn(new z(c=>Ol(Pl(),b,c)),0)}function SU(a,b){return a.Ln(new z(c=>Ol(Pl(),c,b)))}function vba(a,b){return 0>b||b>a.K()?qq().Oa:new NY(a,b)}function Fv(a,b){var c=a.K(),d=a.hi();if(1===c)c=a.e(),d.S(c);else if(1<c){d.Pd(c);var e=new jd(c);a.yc(e,0,2147483647);xj(fk(),e,b);for(a=0;a<c;)d.S(e.a[a]),a=1+a|0}return d.Eb()}function OY(a,b,c){return a.Ph(new PY(c,b))}
-function QY(a){return 0===a.$a(0)}function RY(a,b){var c=a.Q();if(-1!==c){var d=b.Q();c=-1!==d&&c!==d}else c=!1;if(c)return!1;a:{a=a.m();for(b=b.m();a.s()&&b.s();)if(!Ol(Pl(),a.t(),b.t())){b=!1;break a}b=a.s()===b.s()}return b}function SY(){this.bm=null;this.bm=$p()}SY.prototype=new yT;SY.prototype.constructor=SY;SY.prototype.$classData=q({r5:0},!1,"scala.collection.Set$",{r5:1,UF:1,d:1,Uf:1,l:1});var TY;function UY(){TY||(TY=new SY);return TY}
-function VY(a,b){var c=a.Ob().Db(),d=a.Ob().Db();a.ya(new z(e=>{e=b.n(e);c.S(e.i());return d.S(e.j())}));return G(new H,c.Eb(),d.Eb())}function WY(a,b){var c=a.Ob().Db();for(a=a.m();a.s();){var d=b.n(a.t());c.S(d)}return c.Eb()}function EX(a,b){var c=a.Ob().Db();for(a=a.m();a.s();){var d=b.n(a.t());c.oc(d)}return c.Eb()}function bg(a,b){var c=a.Ob().Db();a=a.m();for(b=b.m();a.s()&&b.s();){var d=G(new H,a.t(),b.t());c.S(d)}return c.Eb()}
-function mg(a){var b=a.Ob().Db(),c=0;for(a=a.m();a.s();){var d=G(new H,a.t(),c);b.S(d);c=1+c|0}return b.Eb()}function XY(a,b){var c=a.hi();for(a=a.m();a.s();){var d=a.t();!1!==!!b.n(d)&&c.S(d)}return c.Eb()}function ft(a,b){var c=a.Ob().Db(),d=a.Ob().Db();a.ya(new z(e=>{e=b.n(e);if(e instanceof te)return c.S(e.ca);if(e instanceof me)return d.S(e.ia);throw new x(e);}));return G(new H,c.Eb(),d.Eb())}
-function YY(a,b){var c=a.hi();if(0<=b){var d=-b|0,e=a.Q();-1!==e&&c.Pd(e+d|0)}b=a.m().fh(b);for(a=a.m();b.s();)d=a.t(),c.S(d),b.t();return c.Eb()}function vda(a,b,c){a=a.Db();a.Pd(b);for(var d=0;d<b;){var e=Zr(c);a.S(e);d=1+d|0}return a.Eb()}function ZY(a){this.oL=!1;this.BG=0;this.SR=this.xv=null;if(null===a)throw null;this.SR=a;this.oL=!1;this.BG=0;this.xv=a.$b}ZY.prototype=new WR;ZY.prototype.constructor=ZY;f=ZY.prototype;f.u=function(){return"\x3cfunction1\x3e"};
-f.Jx=function(a,b){var c=dy(W(),a),d=HG(JG(),c);this.oL?this.BG=nU(this.xv,a,b,c,d,0,this.BG):(this.xv=kU(this.xv,a,b,c,d,0,!0),this.xv!==this.SR.$b&&(this.oL=!0,this.BG=VH(pH(),UH(pH(),d,0))))};f.aa=function(a,b){this.Jx(a,b)};f.n=function(a){this.Jx(a.i(),a.j())};f.$classData=q({s6:0},!1,"scala.collection.immutable.HashMap$accum$1",{s6:1,SG:1,d:1,Py:1,ja:1});function $Y(){this.bm=null;this.bm=je()}$Y.prototype=new yT;$Y.prototype.constructor=$Y;
-$Y.prototype.Ib=function(a){return IJ(a)?a:xT.prototype.Ib.call(this,a)};$Y.prototype.$classData=q({B6:0},!1,"scala.collection.immutable.Iterable$",{B6:1,UF:1,d:1,Uf:1,l:1});var aZ;function BY(){aZ||(aZ=new $Y);return aZ}function bZ(){this.uy=null;cZ=this;this.uy=dZ(new eZ(new U(()=>jV())))}bZ.prototype=new p;bZ.prototype.constructor=bZ;f=bZ.prototype;f.wh=function(a){return cU(this,a)};
-function wda(a,b,c){var d=new ov(b),e=new zQ(c);return new eZ(new U(()=>{for(var g=d.Lb,h=e.Zd;0<h&&!g.b();)g=fZ(g).Cf(),d.Lb=g,h=-1+h|0,e.Zd=h;return fZ(g)}))}function cU(a,b){return b instanceof eZ?b:0===b.Q()?a.uy:new eZ(new U(()=>gZ(oK(),b.m())))}function hZ(a,b,c){return b.s()?(a=b.t(),new gV(a,new eZ(new U(()=>hZ(oK(),b,c))))):Zr(c)}function gZ(a,b){return b.s()?(a=b.t(),new gV(a,new eZ(new U(()=>gZ(oK(),b))))):jV()}
-function iZ(a,b,c){return new eZ(new U(()=>{oK();var d=iZ(oK(),b+c|0,c);return new gV(b,d)}))}f.Db=function(){return new jZ};f.U=function(){return this.uy};f.Ib=function(a){return cU(this,a)};f.$classData=q({D6:0},!1,"scala.collection.immutable.LazyList$",{D6:1,d:1,Bk:1,Uf:1,l:1});var cZ;function oK(){cZ||(cZ=new bZ);return cZ}function kZ(){this.ht=null;this.ht=zV()}kZ.prototype=new ZT;kZ.prototype.constructor=kZ;
-function bv(a,b,c){if(b&&b.$classData&&b.$classData.pb.mS){O();var d=b.Wd();if(null===c?null===d:c.h(d))return b}return YT.prototype.Fq.call(a,b,c)}kZ.prototype.Fq=function(a,b){return bv(this,a,b)};kZ.prototype.$classData=q({T7:0},!1,"scala.collection.immutable.SortedMap$",{T7:1,t5:1,d:1,fL:1,l:1});var lZ;function Ku(){lZ||(lZ=new kZ);return lZ}function mZ(a){this.Ik=a.Be;this.ut=a.od}mZ.prototype=new WQ;mZ.prototype.constructor=mZ;mZ.prototype.u=function(){return"\x3cfunction1\x3e"};
-mZ.prototype.n=function(a){this.ut=XQ(this,this.ut,a.i(),a.j())};mZ.prototype.$classData=q({c8:0},!1,"scala.collection.immutable.TreeMap$Adder",{c8:1,z7:1,fS:1,d:1,ja:1});function nZ(){}nZ.prototype=new p;nZ.prototype.constructor=nZ;
-function oZ(a,b,c){if(b instanceof pZ&&(a=b.Ce,null===c?null===a:c.h(a)))return b;if(b&&b.$classData&&b.$classData.pb.tG&&(a=b.Wd(),null===c?null===a:c.h(a)))return qZ(new pZ,TI(XI(),b.m(),b.ka()),c);if(b instanceof rZ&&(c===dq()?a=!0:(a=dq(),a=c===a.oB),a))return c===dq()===0<b.fc?a=b.m():(a=new $X(b),a=sZ(new tZ,a)),b=TI(XI(),a,b.K()),qZ(new pZ,b,c);a=null;for(b=b.m();b.s();)a=QI(XI(),a,b.t(),null,!1,c);return qZ(new pZ,a,c)}nZ.prototype.jB=function(a){return new uZ(a)};
-nZ.prototype.Eq=function(a,b){return oZ(0,a,b)};nZ.prototype.fg=function(a){return vZ(a)};nZ.prototype.$classData=q({g8:0},!1,"scala.collection.immutable.TreeSet$",{g8:1,d:1,LR:1,TF:1,l:1});var wZ;function xZ(){wZ||(wZ=new nZ);return wZ}function yZ(){zZ=this}yZ.prototype=new p;yZ.prototype.constructor=yZ;function AZ(a,b){a=a.Db();var c=b.Q();0<=c&&a.Pd(c);a.oc(b);return a.Eb()}yZ.prototype.Db=function(){var a=re();return new fU(a,new z(b=>new Uq(b)))};yZ.prototype.qc=function(a){return AZ(this,a)};
-yZ.prototype.$classData=q({v8:0},!1,"scala.collection.immutable.WrappedString$",{v8:1,d:1,jba:1,BK:1,l:1});var zZ;function BZ(){zZ||(zZ=new yZ);return zZ}function fU(a,b){this.vS=this.UB=null;if(null===a)throw null;this.UB=a;this.vS=b}fU.prototype=new p;fU.prototype.constructor=fU;f=fU.prototype;f.Pd=function(a){this.UB.Pd(a)};f.Eb=function(){return this.vS.n(this.UB.Eb())};f.oc=function(a){this.UB.oc(a);return this};f.S=function(a){this.UB.S(a);return this};
-f.$classData=q({Q8:0},!1,"scala.collection.mutable.Builder$$anon$1",{Q8:1,d:1,og:1,lf:1,kf:1});function RV(a,b){a.ak=b;return a}function SV(){this.ak=null}SV.prototype=new p;SV.prototype.constructor=SV;function CZ(){}f=CZ.prototype=SV.prototype;f.Pd=function(){};function lF(a,b){a.ak.S(b);return a}function DZ(a,b){a.ak.oc(b);return a}f.oc=function(a){return DZ(this,a)};f.S=function(a){return lF(this,a)};f.Eb=function(){return this.ak};
-f.$classData=q({VB:0},!1,"scala.collection.mutable.GrowableBuilder",{VB:1,d:1,og:1,lf:1,kf:1});function EZ(){this.bm=null;this.bm=xF()}EZ.prototype=new yT;EZ.prototype.constructor=EZ;EZ.prototype.$classData=q({s9:0},!1,"scala.collection.mutable.Iterable$",{s9:1,UF:1,d:1,Uf:1,l:1});var FZ;function iO(){FZ||(FZ=new EZ);return FZ}function GZ(){this.ft=null;this.ft=ky()}GZ.prototype=new XT;GZ.prototype.constructor=GZ;
-GZ.prototype.$classData=q({I9:0},!1,"scala.collection.mutable.Map$",{I9:1,c5:1,d:1,hy:1,l:1});var HZ;function ru(){HZ||(HZ=new GZ);return HZ}function IZ(){this.bm=null;this.bm=Hy()}IZ.prototype=new yT;IZ.prototype.constructor=IZ;IZ.prototype.$classData=q({V9:0},!1,"scala.collection.mutable.Set$",{V9:1,UF:1,d:1,Uf:1,l:1});var JZ;function Lz(){JZ||(JZ=new IZ);return JZ}function tX(){this.ht=null;this.ht=dW()}tX.prototype=new ZT;tX.prototype.constructor=tX;
-tX.prototype.$classData=q({Y9:0},!1,"scala.collection.mutable.SortedMap$",{Y9:1,t5:1,d:1,fL:1,l:1});var sX;function fq(a,b,c){a.Hg=b;a.US=c;fF(a,null,null,!1);return a}class gq extends Xca{constructor(){super();this.US=this.Hg=null}wj(){return this.US}XP(){}}gq.prototype.$classData=q({TS:0},!1,"scala.runtime.NonLocalReturnControl",{TS:1,N3:1,jc:1,d:1,l:1});function KZ(){}KZ.prototype=new p;KZ.prototype.constructor=KZ;function LZ(){}LZ.prototype=KZ.prototype;
-function xP(a){return a instanceof me?new M(a.ia):R()}function MZ(){}MZ.prototype=new lW;MZ.prototype.constructor=MZ;function NZ(){}NZ.prototype=MZ.prototype;class zc extends mW{constructor(a){super();fF(this,a,null,!0)}}zc.prototype.$classData=q({i0:0},!1,"java.lang.ArithmeticException",{i0:1,ye:1,fd:1,jc:1,d:1,l:1});var qa=q({n0:0},!1,"java.lang.Byte",{n0:1,Kq:1,d:1,l:1,xe:1,Xs:1},a=>dd(a));function dk(a){var b=new OZ;fF(b,a,null,!0);return b}
-function DL(){var a=new OZ;fF(a,null,null,!0);return a}class OZ extends mW{}OZ.prototype.$classData=q({Pj:0},!1,"java.lang.IllegalArgumentException",{Pj:1,ye:1,fd:1,jc:1,d:1,l:1});function FH(a){var b=new PZ;fF(b,a,null,!0);return b}class PZ extends mW{}PZ.prototype.$classData=q({jQ:0},!1,"java.lang.IllegalStateException",{jQ:1,ye:1,fd:1,jc:1,d:1,l:1});function KK(a,b){fF(a,b,null,!0);return a}class LK extends mW{}
-LK.prototype.$classData=q({NJ:0},!1,"java.lang.IndexOutOfBoundsException",{NJ:1,ye:1,fd:1,jc:1,d:1,l:1});class Uj extends mW{constructor(){super();fF(this,null,null,!0)}}Uj.prototype.$classData=q({I0:0},!1,"java.lang.NegativeArraySizeException",{I0:1,ye:1,fd:1,jc:1,d:1,l:1});function YK(a){var b=new QZ;fF(b,a,null,!0);return b}function ze(){var a=new QZ;fF(a,null,null,!0);return a}class QZ extends mW{}QZ.prototype.$classData=q({J0:0},!1,"java.lang.NullPointerException",{J0:1,ye:1,fd:1,jc:1,d:1,l:1});
-var ra=q({L0:0},!1,"java.lang.Short",{L0:1,Kq:1,d:1,l:1,xe:1,Xs:1},a=>fd(a));function FT(){var a=new RZ;fF(a,null,null,!0);return a}function Fu(a){var b=new RZ;fF(b,a,null,!0);return b}class RZ extends mW{}RZ.prototype.$classData=q({V0:0},!1,"java.lang.UnsupportedOperationException",{V0:1,ye:1,fd:1,jc:1,d:1,l:1});function SZ(){}SZ.prototype=new oS;SZ.prototype.constructor=SZ;function TZ(){}TZ.prototype=SZ.prototype;
-SZ.prototype.h=function(a){if(a===this)a=!0;else if(a&&a.$classData&&a.$classData.pb.vQ){var b;if(b=a.ka()===this.ka()){a=a.Uu();a:{for(;a.s();)if(b=a.t(),!this.L(b)){a=!0;break a}a=!1}b=!a}a=b}else a=!1;return a};SZ.prototype.y=function(){for(var a=this.Uu(),b=0;a.s();){var c=b;b=a.t();c|=0;b=bc(b)+c|0}return b|0};class UJ extends mW{constructor(){super();fF(this,"mutation occurred during iteration",null,!0)}}
-UJ.prototype.$classData=q({c1:0},!1,"java.util.ConcurrentModificationException",{c1:1,ye:1,fd:1,jc:1,d:1,l:1});function UZ(a,b){if(null===b)var c=0;else c=bc(b),c^=c>>>16|0;a=VZ(a,b,c,c&(-1+a.kl.a.length|0));return null===a?null:a.Wu}
-function WZ(a,b){this.kl=null;this.Xu=this.SJ=0;this.yQ=b;if(0>a)throw dk("initialCapacity \x3c 0");if(0>=b)throw dk("loadFactor \x3c\x3d 0.0");a=-1+a|0;a=4<a?a:4;a=(-2147483648>>Math.clz32(a)&a)<<1;this.kl=new (Nd(xN).Ja)(1073741824>a?a:1073741824);this.SJ=Mc(this.kl.a.length*this.yQ);this.Xu=0}WZ.prototype=new pN;WZ.prototype.constructor=WZ;f=WZ.prototype;f.ka=function(){return this.Xu};f.nF=function(a){return UZ(this,a)};
-f.gF=function(a){if(null===a)var b=0;else b=bc(a),b^=b>>>16|0;return null!==VZ(this,a,b,b&(-1+this.kl.a.length|0))};f.lF=function(){return new XZ(this)};function VZ(a,b,c,d){for(a=a.kl.a[d];;){if(null===a)return null;c===a.Rx?(d=a.bB,d=null===b?null===d:Pb(b,d)):d=!1;if(d)return a;if(c<a.Rx)return null;a=a.Nq}}f.$classData=q({o1:0},!1,"java.util.HashMap",{o1:1,Z0:1,d:1,zQ:1,l:1,vf:1});function xda(){var a=new YZ,b=new WZ(16,.75);a.Yu=b;return a}function YZ(){this.Yu=null}YZ.prototype=new pN;
-YZ.prototype.constructor=YZ;f=YZ.prototype;f.gF=function(a){return this.Yu.gF(new uk(a))};f.nF=function(a){return UZ(this.Yu,new uk(a))};f.ka=function(){return this.Yu.Xu};f.lF=function(){return new ZZ(this)};f.$classData=q({s1:0},!1,"java.util.IdentityHashMap",{s1:1,Z0:1,d:1,zQ:1,l:1,vf:1});function iH(a){var b=new $Z;fF(b,a,null,!0);return b}function NU(){var a=new $Z;fF(a,null,null,!0);return a}class $Z extends mW{}
-$Z.prototype.$classData=q({P1:0},!1,"java.util.NoSuchElementException",{P1:1,ye:1,fd:1,jc:1,d:1,l:1});function a_(){this.td="block"}a_.prototype=new Cy;a_.prototype.constructor=a_;f=a_.prototype;f.H=function(){return"Block"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof a_};f.y=function(){return 64279661};f.u=function(){return"Block"};f.$classData=q({BT:0},!1,"mlscript.Block$",{BT:1,Vw:1,d:1,F:1,v:1,l:1});var b_;
-function c_(){b_||(b_=new a_);return b_}function yl(){}yl.prototype=new iW;yl.prototype.constructor=yl;function yda(a,b){switch(a){case 40:return O(),a=ll(),new te(a);case 41:return O(),a=ll(),new me(a);case 123:return O(),a=ml(),new te(a);case 125:return O(),a=ml(),new me(a);case 91:return O(),a=nl(),new te(a);case 93:return O(),a=nl(),new me(a);case 8249:return O(),a=ol(),new te(a);case 8250:return O(),a=ol(),new me(a);default:return b.n(hd(a))}}
-function zda(a){switch(a){case 40:return!0;case 41:return!0;case 123:return!0;case 125:return!0;case 91:return!0;case 93:return!0;case 8249:return!0;case 8250:return!0;default:return!1}}yl.prototype.Ec=function(a){return zda(Eb(a))};yl.prototype.Nb=function(a,b){return yda(Eb(a),b)};yl.prototype.$classData=q({GT:0},!1,"mlscript.BracketKind$$anonfun$unapply$1",{GT:1,Bf:1,d:1,ja:1,za:1,l:1});function d_(){this.Lt=null;this.aj=this.Kt=this.Jt=0}d_.prototype=new sl;d_.prototype.constructor=d_;f=d_.prototype;
-f.H=function(){return"Angle"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof d_};f.y=function(){return 63408307};f.u=function(){return"Angle"};f.$classData=q({HT:0},!1,"mlscript.BracketKind$Angle$",{HT:1,rC:1,d:1,F:1,v:1,l:1});var e_;function ol(){e_||(e_=new d_);return e_}function f_(){this.Lt=null;this.aj=this.Kt=this.Jt=0}f_.prototype=new sl;f_.prototype.constructor=f_;f=f_.prototype;f.H=function(){return"Curly"};f.G=function(){return 0};
-f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof f_};f.y=function(){return 65474477};f.u=function(){return"Curly"};f.$classData=q({IT:0},!1,"mlscript.BracketKind$Curly$",{IT:1,rC:1,d:1,F:1,v:1,l:1});var g_;function ml(){g_||(g_=new f_);return g_}function h_(){this.Lt=null;this.aj=this.Kt=this.Jt=0}h_.prototype=new sl;h_.prototype.constructor=h_;f=h_.prototype;f.H=function(){return"Indent"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};
-f.E=function(a){return a instanceof h_};f.y=function(){return-2100372276};f.u=function(){return"Indent"};f.$classData=q({JT:0},!1,"mlscript.BracketKind$Indent$",{JT:1,rC:1,d:1,F:1,v:1,l:1});var i_;function pl(){i_||(i_=new h_);return i_}function j_(){this.Lt=null;this.aj=this.Kt=this.Jt=0}j_.prototype=new sl;j_.prototype.constructor=j_;f=j_.prototype;f.H=function(){return"Round"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof j_};f.y=function(){return 79151470};
-f.u=function(){return"Round"};f.$classData=q({KT:0},!1,"mlscript.BracketKind$Round$",{KT:1,rC:1,d:1,F:1,v:1,l:1});var k_;function ll(){k_||(k_=new j_);return k_}function l_(){this.Lt=null;this.aj=this.Kt=this.Jt=0}l_.prototype=new sl;l_.prototype.constructor=l_;f=l_.prototype;f.H=function(){return"Square"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof l_};f.y=function(){return-1810807491};f.u=function(){return"Square"};
-f.$classData=q({LT:0},!1,"mlscript.BracketKind$Square$",{LT:1,rC:1,d:1,F:1,v:1,l:1});var m_;function nl(){m_||(m_=new l_);return m_}function wr(a){this.fw=a}wr.prototype=new oz;wr.prototype.constructor=wr;f=wr.prototype;f.H=function(){return"CLOSE_BRACKET"};f.G=function(){return 1};f.I=function(a){return 0===a?this.fw:JK(W(),a)};f.E=function(a){return a instanceof wr};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){return this===a?!0:a instanceof wr?this.fw===a.fw:!1};f.$classData=q({MT:0},!1,"mlscript.CLOSE_BRACKET",{MT:1,al:1,d:1,F:1,v:1,l:1});function uX(a){this.Wy=null;if(null===a)throw null;this.Wy=a}uX.prototype=new iW;uX.prototype.constructor=uX;f=uX.prototype;
-f.Cq=function(a,b){a:{if(null!==a){var c=a.i();if(c instanceof gu){c=c.ed;var d=this.Wy.qk;if(null===d?null===c:d.h(c)){c=!0;break a}}}if(null!==a&&(c=a.j(),c instanceof gu&&(c=c.ed,d=this.Wy.qk,null===d?null===c:d.h(c)))){c=!0;break a}c=!1}return c?!0:b.n(a)};f.Hq=function(a){if(null!==a){var b=a.i();if(b instanceof gu){b=b.ed;var c=this.Wy.qk;if(null===c?null===b:c.h(b))return!0}}return null!==a&&(a=a.j(),a instanceof gu&&(a=a.ed,b=this.Wy.qk,null===b?null===a:b.h(a)))?!0:!1};f.Ec=function(a){return this.Hq(a)};
-f.Nb=function(a,b){return this.Cq(a,b)};f.$classData=q({VT:0},!1,"mlscript.ConstraintSolver$$anonfun$$nestedInanonfun$constrainImpl$100$1",{VT:1,Bf:1,d:1,ja:1,za:1,l:1});function KX(a,b,c,d,e,g,h){this.lM=this.$G=this.jM=null;this.kM=!1;this.oM=this.mM=this.nM=null;if(null===a)throw null;this.jM=a;this.$G=b;this.lM=c;this.kM=d;this.nM=e;this.mM=g;this.oM=h}KX.prototype=new iW;KX.prototype.constructor=KX;f=KX.prototype;
-f.dJ=function(a,b){return a instanceof IB?JX(this.jM,this.$G.fb.n(a.Io.w),this.lM,this.kM,this.nM,this.mM,this.oM,this.$G):b.n(a)};f.xJ=function(a){return a instanceof IB};f.Ec=function(a){return this.xJ(a)};f.Nb=function(a,b){return this.dJ(a,b)};f.$classData=q({WT:0},!1,"mlscript.ConstraintSolver$$anonfun$1",{WT:1,Bf:1,d:1,ja:1,za:1,l:1});function BX(a,b,c){this.pM=b;this.qM=c}BX.prototype=new iW;BX.prototype.constructor=BX;f=BX.prototype;
-f.eJ=function(a,b){if(sr(new E(a.qa().Ia),this.pM.Ia)){var c=a.qa().Ia;if(c.b())c=!1;else{c=c.o();var d=this.qM.Ia;d.b()?c=!0:(d=d.o(),c=TX(c,d)||jy(d,c))}}else c=!1;return c?a:b.n(a)};f.yJ=function(a){if(sr(new E(a.qa().Ia),this.pM.Ia)){a=a.qa().Ia;if(a.b())return!1;a=a.o();var b=this.qM.Ia;if(b.b())return!0;b=b.o();return TX(a,b)||jy(b,a)}return!1};f.Ec=function(a){return this.yJ(a)};f.Nb=function(a,b){return this.eJ(a,b)};
-f.$classData=q({XT:0},!1,"mlscript.ConstraintSolver$$anonfun$2",{XT:1,Bf:1,d:1,ja:1,za:1,l:1});function CX(){}CX.prototype=new iW;CX.prototype.constructor=CX;f=CX.prototype;f.fJ=function(a,b){if(null!==a){var c=a.Ia,d=a.An;if(d instanceof M&&(d=d.k,!c.b()))return G(new H,d,a)}return b.n(a)};f.zJ=function(a){if(null!==a){var b=a.Ia;if(a.An instanceof M&&!b.b())return!0}return!1};f.Ec=function(a){return this.zJ(a)};f.Nb=function(a,b){return this.fJ(a,b)};
-f.$classData=q({YT:0},!1,"mlscript.ConstraintSolver$$anonfun$3",{YT:1,Bf:1,d:1,ja:1,za:1,l:1});function zX(a,b,c){this.lw=b;this.$T=c}zX.prototype=new iW;zX.prototype.constructor=zX;f=zX.prototype;
-f.fJ=function(a,b){if(null!==a){var c=a.Ia,d=a.th;if(c instanceof M){var e=c.k;if(this.lw.L(e)||a.Bm)h=!1;else{var g=!1;for(h=this.lw.m();!g&&h.s();)g=h.t(),g=jy(e,g);var h=!g}if(h)return this.lw.ya(new z(k=>{if(jy(k,e))return this.$T.S(k)})),this.lw.eh(e),a=new mf(new nf(J(new L,["\u2022 this ",":"]))),d=[pf(qf(),d)],d=sf(a,J(new L,d)),G(new H,d,c)}}return b.n(a)};
-f.zJ=function(a){if(null!==a){var b=a.Ia;if(b instanceof M){b=b.k;if(this.lw.L(b)||a.Bm)b=!1;else{var c=!1;for(a=this.lw.m();!c&&a.s();)c=a.t(),c=jy(b,c);b=!c}if(b)return!0}}return!1};f.Ec=function(a){return this.zJ(a)};f.Nb=function(a,b){return this.fJ(a,b)};f.$classData=q({ZT:0},!1,"mlscript.ConstraintSolver$$anonfun$4",{ZT:1,Bf:1,d:1,ja:1,za:1,l:1});function FX(a,b,c){this.sM=b;this.rM=c}FX.prototype=new iW;FX.prototype.constructor=FX;f=FX.prototype;
-f.Cq=function(a,b){if(null!==a){var c=a.i(),d=a.j(),e=d.Ia;e.b()?e=!1:(e=e.o(),e=!this.sM.L(e));if(e)return this.rM.ko?(a=new mf(new nf(J(new L,["Note: "," ",""]))),c=[pf(qf(),d.th),pf(qf(),c)],c=sf(a,J(new L,c))):(a=new mf(new nf(J(new L,["      "," ",""]))),c=[pf(qf(),d.th),pf(qf(),c)],c=sf(a,J(new L,c))),this.rM.ko=!1,c=sf(new mf(new nf(J(new L,[""," is defined at:"]))),J(new L,[c])),G(new H,c,d.Ia)}return b.n(a)};
-f.Hq=function(a){return null!==a&&(a=a.j().Ia,a.b()?a=!1:(a=a.o(),a=!this.sM.L(a)),a)?!0:!1};f.Ec=function(a){return this.Hq(a)};f.Nb=function(a,b){return this.Cq(a,b)};f.$classData=q({aU:0},!1,"mlscript.ConstraintSolver$$anonfun$5",{aU:1,Bf:1,d:1,ja:1,za:1,l:1});function DX(){}DX.prototype=new iW;DX.prototype.constructor=DX;f=DX.prototype;f.eJ=function(a,b){return a instanceof yu||a instanceof dv||hv(a)||a instanceof Ru||a instanceof uv||a instanceof gA||b.n(a)};
-f.yJ=function(a){return a instanceof yu||a instanceof dv||hv(a)||a instanceof Ru||a instanceof uv||a instanceof gA};f.Ec=function(a){return this.yJ(a)};f.Nb=function(a,b){return this.eJ(a,b)};f.$classData=q({bU:0},!1,"mlscript.ConstraintSolver$$anonfun$lhsIsPlain$1$1",{bU:1,Bf:1,d:1,ja:1,za:1,l:1});function n_(){}n_.prototype=new oz;n_.prototype.constructor=n_;f=n_.prototype;f.H=function(){return"DEINDENT"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};
-f.E=function(a){return a instanceof n_};f.y=function(){return 1524287597};f.u=function(){return"DEINDENT"};f.$classData=q({fU:0},!1,"mlscript.DEINDENT$",{fU:1,al:1,d:1,F:1,v:1,l:1});var o_;function Hr(){o_||(o_=new n_);return o_}function Nx(a){return!!(a&&a.$classData&&a.$classData.pb.Ie)}function p_(){}p_.prototype=new Ml;p_.prototype.constructor=p_;f=p_.prototype;f.H=function(){return"Lexing"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof p_};
-f.y=function(){return-2022196861};f.u=function(){return"Lexing"};f.$classData=q({lU:0},!1,"mlscript.Diagnostic$Lexing$",{lU:1,AM:1,d:1,F:1,v:1,l:1});var q_;function Iq(){q_||(q_=new p_);return q_}function r_(){}r_.prototype=new Ml;r_.prototype.constructor=r_;f=r_.prototype;f.H=function(){return"Parsing"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof r_};f.y=function(){return 871689872};f.u=function(){return"Parsing"};
-f.$classData=q({mU:0},!1,"mlscript.Diagnostic$Parsing$",{mU:1,AM:1,d:1,F:1,v:1,l:1});var s_;function Pr(){s_||(s_=new r_);return s_}function t_(){}t_.prototype=new Ml;t_.prototype.constructor=t_;f=t_.prototype;f.H=function(){return"Typing"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof t_};f.y=function(){return-1774931561};f.u=function(){return"Typing"};f.$classData=q({nU:0},!1,"mlscript.Diagnostic$Typing$",{nU:1,AM:1,d:1,F:1,v:1,l:1});var u_;
-function Qt(){u_||(u_=new t_);return u_}function v_(){}v_.prototype=new oz;v_.prototype.constructor=v_;f=v_.prototype;f.H=function(){return"INDENT"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof v_};f.y=function(){return-2130910036};f.u=function(){return"INDENT"};f.$classData=q({AU:0},!1,"mlscript.INDENT$",{AU:1,al:1,d:1,F:1,v:1,l:1});var w_;function Ar(){w_||(w_=new v_);return w_}function In(a,b,c){this.RU=b;this.SU=c}In.prototype=new iW;
-In.prototype.constructor=In;f=In.prototype;f.kj=function(a,b){if(a instanceof Kn){var c=a.Sd,d=a.Qb,e=a.qh,g=a.cd;if(g instanceof te&&(g=g.ca,c.b()||(c.b()?0:c.o())))return this.RU.eh(d.w),new rp(!(c.b()||!c.o()),new sp(this.SU),d,e,(O(),new te(g)))}return b.n(a)};f.nj=function(a){if(a instanceof Kn){var b=a.Sd;if(a.cd instanceof te&&(b.b()||(b.b()?0:b.o())))return!0}return!1};f.Ec=function(a){return this.nj(a)};f.Nb=function(a,b){return this.kj(a,b)};
-f.$classData=q({QU:0},!1,"mlscript.JSBackend$$anonfun$1",{QU:1,Bf:1,d:1,ja:1,za:1,l:1});function Jn(a,b,c){this.RM=b;this.UU=c}Jn.prototype=new iW;Jn.prototype.constructor=Jn;f=Jn.prototype;f.kj=function(a,b){if(a instanceof Kn){var c=a.Sd,d=a.Qb,e=a.qh,g=a.cd;if(g instanceof me&&(g=g.ia,a.yo&&!this.RM.L(d.w)))return new rp(!(c.b()||!c.o()),new sp(this.UU),d,e,(O(),new me(g)))}return b.n(a)};f.nj=function(a){if(a instanceof Kn){var b=a.Qb;if(a.cd instanceof me&&a.yo&&!this.RM.L(b.w))return!0}return!1};
-f.Ec=function(a){return this.nj(a)};f.Nb=function(a,b){return this.kj(a,b)};f.$classData=q({TU:0},!1,"mlscript.JSBackend$$anonfun$2",{TU:1,Bf:1,d:1,ja:1,za:1,l:1});function Mn(){}Mn.prototype=new iW;Mn.prototype.constructor=Mn;f=Mn.prototype;f.kj=function(a,b){return a instanceof io?a:b.n(a)};f.nj=function(a){return a instanceof io};f.Ec=function(a){return this.nj(a)};f.Nb=function(a,b){return this.kj(a,b)};f.$classData=q({VU:0},!1,"mlscript.JSBackend$$anonfun$3",{VU:1,Bf:1,d:1,ja:1,za:1,l:1});
-function Ry(a,b){this.OC=a;this.NC=b}Ry.prototype=new yp;Ry.prototype.constructor=Ry;f=Ry.prototype;f.xa=function(){for(var a=Hp(Fp()," catch ("+this.OC.Np+") "),b=this.NC,c=Fp().ce;!b.b();){var d=b.e();c=az(c,d.xa());b=b.g()}return Gp(a,gz(c))};f.H=function(){return"JSCatchClause"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.OC;case 1:return this.NC;default:return JK(W(),a)}};f.E=function(a){return a instanceof Ry};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Ry){var b=this.OC,c=a.OC;if(null===b?null===c:b.h(c))return b=this.NC,a=a.NC,null===b?null===a:b.h(a)}return!1};f.$classData=q({bV:0},!1,"mlscript.JSCatchClause",{bV:1,Uc:1,d:1,F:1,v:1,l:1});function mO(){}mO.prototype=new iW;mO.prototype.constructor=mO;mO.prototype.Ec=function(a){return a instanceof oO};mO.prototype.Nb=function(a,b){return a instanceof oO?a.Ew:b.n(a)};
-mO.prototype.$classData=q({ZV:0},!1,"mlscript.Message$$anonfun$typeBits$1",{ZV:1,Bf:1,d:1,ja:1,za:1,l:1});function oO(a){this.Ew=a}oO.prototype=new oq;oO.prototype.constructor=oO;f=oO.prototype;f.H=function(){return"Code"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Ew:JK(W(),a)};f.E=function(a){return a instanceof oO};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof oO){var b=this.Ew;a=a.Ew;return null===b?null===a:b.h(a)}return!1};f.$classData=q({aW:0},!1,"mlscript.Message$Code",{aW:1,$V:1,d:1,F:1,v:1,l:1});function uq(a){this.oz=a}uq.prototype=new oq;uq.prototype.constructor=uq;f=uq.prototype;f.H=function(){return"Text"};f.G=function(){return 1};f.I=function(a){return 0===a?this.oz:JK(W(),a)};f.E=function(a){return a instanceof uq};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){return this===a?!0:a instanceof uq?this.oz===a.oz:!1};f.$classData=q({cW:0},!1,"mlscript.Message$Text",{cW:1,$V:1,d:1,F:1,v:1,l:1});function rp(a,b,c,d,e){this.ZM=this.YM=this.XM=null;this.aN=this.bN=0;this.cN=this.$M=null;this.Yr=0;this.ID=a;this.HD=b;this.Qp=c;this.JD=d;this.Fw=e;mq(this);if(e instanceof me)a=e.ia;else{if(!(e instanceof te))throw new x(e);a=e.ca}a=this.XM=a;b=O().c;this.YM=new A(c,new A(a,b))}rp.prototype=new p;rp.prototype.constructor=rp;f=rp.prototype;
-f.Jm=function(){0===(1&this.Yr)<<24>>24&&0===(1&this.Yr)<<24>>24&&(this.ZM=Yp(this),this.Yr=(1|this.Yr)<<24>>24);return this.ZM};f.Rm=function(){return this.bN};f.Tl=function(a){this.bN=a};f.Qm=function(){return this.aN};f.Sl=function(a){this.aN=a};f.Pm=function(){return this.$M};f.Om=function(a){this.$M=a};f.C=function(){0===(2&this.Yr)<<24>>24&&0===(2&this.Yr)<<24>>24&&(this.cN=bq(this),this.Yr=(2|this.Yr)<<24>>24);return this.cN};f.Kj=function(){return this.YM};f.H=function(){return"MethodDef"};
-f.G=function(){return 5};f.I=function(a){switch(a){case 0:return this.ID;case 1:return this.HD;case 2:return this.Qp;case 3:return this.JD;case 4:return this.Fw;default:return JK(W(),a)}};f.E=function(a){return a instanceof rp};f.y=function(){var a=dc("MethodDef");a=W().B(-889275714,a);var b=this.ID?1231:1237;a=W().B(a,b);b=this.HD;b=dy(W(),b);a=W().B(a,b);b=this.Qp;b=dy(W(),b);a=W().B(a,b);b=this.JD;b=dy(W(),b);a=W().B(a,b);b=this.Fw;b=dy(W(),b);a=W().B(a,b);return W().La(a,5)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof rp){if(this.ID===a.ID){var b=this.HD,c=a.HD;b=null===b?null===c:b.h(c)}else b=!1;if(b&&(b=this.Qp,c=a.Qp,null===b?null===c:b.h(c))&&(b=this.JD,c=a.JD,null===b?null===c:b.h(c)))return b=this.Fw,a=a.Fw,null===b?null===a:b.h(a)}return!1};f.$classData=q({dW:0},!1,"mlscript.MethodDef",{dW:1,d:1,Za:1,F:1,v:1,l:1});
-function zv(a){if(!a.RD){var b=a.Jd.m(),c=a.lc;a:{if(c instanceof M&&(c=c.k,c instanceof gu)){c=c.dv().Yb(c.ed);break a}c=Wp()}for(;b.s();){var d=b.t();if(d instanceof IB){var e=d.dv();c=c.af(e).Yb(d.Io)}}a.QD=c;a.RD=!0}return a.QD}function eu(a,b,c,d,e){this.PD=null;this.rz=!1;this.QD=this.Ea=null;this.RD=!1;this.lc=b;this.Jd=c;this.be=d;this.rf=e;if(null===a)throw null;this.Ea=a}eu.prototype=new Bu;eu.prototype.constructor=eu;f=eu.prototype;
-f.u=function(){var a=this.lc;a=a.b()?"":a.o();var b=this.be,c=this.Jd.m().mb(new U(()=>new iu(this.rf)));c=new eg(c,new z(d=>"\u2227"+d));return""+a+b+Qe(c,"","","")};f.H=function(){return"LhsRefined"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.lc;case 1:return this.Jd;case 2:return this.be;case 3:return this.rf;default:return JK(W(),a)}};f.E=function(a){return a instanceof eu};f.y=function(){return jL(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof eu&&a.Ea===this.Ea){var b=this.lc,c=a.lc;(null===b?null===c:b.h(c))?(b=this.Jd,c=a.Jd,b=null===b?null===c:b.h(c)):b=!1;if(b&&(b=this.be,c=a.be,null===b?null===c:HB(b,c)))return b=this.rf,a=a.rf,null===b?null===a:b.h(a)}return!1};f.$classData=q({EW:0},!1,"mlscript.NormalForms$LhsRefined",{EW:1,DW:1,d:1,F:1,v:1,l:1});function LS(a){this.PD=null;this.rz=!1;this.Ea=null;if(null===a)throw null;this.Ea=a}LS.prototype=new Bu;LS.prototype.constructor=LS;
-f=LS.prototype;f.u=function(){return"\u22a4"};f.H=function(){return"LhsTop"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof LS};f.y=function(){return-2019595394};f.$classData=q({FW:0},!1,"mlscript.NormalForms$LhsTop$",{FW:1,DW:1,d:1,F:1,v:1,l:1});function yv(a,b,c,d){this.sz=null;this.Nw=!1;this.Aa=null;this.bc=b;this.lb=c;this.Ic=d;Gv(this,a)}yv.prototype=new Iv;yv.prototype.constructor=yv;
-function Ada(a,b,c,d,e){var g=a.Aa,h=a.bc,k=a.lb;if(k.b())k=R();else{k=k.o();if(k instanceof te)k=k.ca,t(),k=k.Qu(b,c,d,e),k=new te(k);else if(k instanceof me)k=k.ia,t(),k=x_(k,b,c,d,e),k=new me(k);else throw new x(k);k=new M(k)}a=new Hu(new Iu(a.Ic),new z(r=>Ju(r,b,c,d,e)));var l=Ku(),m=mu(),n=ap().wa;return new yv(g,h,k,(new Lu(l,new ou(m,n))).qc(a))}f=yv.prototype;
-f.u=function(){var a=Qe(this.bc,"","|",""),b=this.lb;if(b.b())b="";else{b=b.o();if(b instanceof me)b=""+b.ia;else{if(!(b instanceof te))throw new x(b);b=""+b.ca}b="|"+b}var c=new iu(this.Ic);c=new eg(c,new z(d=>"|"+d));return a+b+Qe(c,"","","")};f.H=function(){return"RhsBases"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.bc;case 1:return this.lb;case 2:return this.Ic;default:return JK(W(),a)}};f.E=function(a){return a instanceof yv};f.y=function(){return jL(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof yv&&a.Aa===this.Aa){var b=this.bc,c=a.bc;(null===b?null===c:b.h(c))?(b=this.lb,c=a.lb,b=null===b?null===c:b.h(c)):b=!1;if(b)return b=this.Ic,a=a.Ic,null===b?null===a:b.h(a)}return!1};f.pJ=function(a,b,c,d){return Ada(this,a,b,c,d)};f.$classData=q({GW:0},!1,"mlscript.NormalForms$RhsBases",{GW:1,nN:1,d:1,F:1,v:1,l:1});function MS(a){this.sz=null;this.Nw=!1;this.Aa=null;Gv(this,a)}MS.prototype=new Iv;MS.prototype.constructor=MS;f=MS.prototype;
-f.u=function(){return"\u22a5"};f.H=function(){return"RhsBot"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof MS};f.y=function(){return-1847837782};f.pJ=function(){return this};f.$classData=q({HW:0},!1,"mlscript.NormalForms$RhsBot$",{HW:1,nN:1,d:1,F:1,v:1,l:1});function xv(a,b,c){this.sz=null;this.Nw=!1;this.Aa=null;this.pe=b;this.qe=c;Gv(this,a)}xv.prototype=new Iv;xv.prototype.constructor=xv;
-function x_(a,b,c,d,e){var g=a.Aa,h=a.pe,k=a.qe,l=k.Ua,m=k.Ma;if(m.b())m=R();else{m=m.o();var n=a.Aa,r=a.Aa.tf,u=Wp();m=new M(AC(n,m,r,d,b,u,e,c))}n=k.oa;r=a.Aa;a=a.Aa.tf;u=Wp();return new xv(g,h,new ww(l,m,AC(r,n,a,d,b,u,e,c),k.vd))}f=xv.prototype;f.u=function(){return"{"+this.pe+":"+this.qe+"}"};f.H=function(){return"RhsField"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.pe;case 1:return this.qe;default:return JK(W(),a)}};f.E=function(a){return a instanceof xv};f.y=function(){return jL(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof xv&&a.Aa===this.Aa){var b=this.pe,c=a.pe;if(null===b?null===c:b.h(c))return b=this.qe,a=a.qe,null===b?null===a:b.h(a)}return!1};f.pJ=function(a,b,c,d){return x_(this,a,b,c,d)};f.$classData=q({IW:0},!1,"mlscript.NormalForms$RhsField",{IW:1,nN:1,d:1,F:1,v:1,l:1});
-var Cda=function Bda(a,b,c){if(b instanceof nm){var e=b.Co,g=b.wn;if(e instanceof Wl&&"this"===e.w)return c.eh(G(new H,g,(t(),new M(e)))),t().f}if(b instanceof Wl)return"this"===b.w?(t(),new M(b)):(c.eh(G(new H,b,t().f)),t().f);if(b instanceof y_)return t().f;if(b instanceof Ln||b&&b.$classData&&b.$classData.pb.re||b instanceof Rs||b instanceof rS||b instanceof pS||b instanceof Ss){b=b.Kj();for(e=t().f;!b.b();)g=e,e=b.e(),e=g.b()?Bda(a,e,c):g,b=b.g();return e}throw new x(b);};
-function Dda(a,b,c,d,e,g,h){for(;;)if(b instanceof A){var k=b.A;b=b.r;if(k instanceof Rs)var l=t().f;else if(k instanceof Ln){var m=k;l=cw(a,m,c,d,e,!0);if(!(g||b.b()&&h))if(m instanceof fm||m instanceof lm)OX(a,pf(qf(),"Pure expression does nothing in statement position."),m.C(),d);else{k=Vw(a,l,Mw(new Nw,a,jq(m),"expression in statement position",(Uw(a),t().f),(Uw(a),!1)));var n=a.Bs,r=new z(((w,y)=>B=>{Fq();var D=sf(new mf(new nf(J(new L,["Expression in statement position should have type `()`."]))),
-v()),C=t().f;D=G(new H,D,C);C=sf(new mf(new nf(J(new L,["Use a comma expression `... , ()` to explicitly discard non-unit values, making your intent clearer."]))),v());var F=t().f;C=G(new H,C,F);y.n(Hq(0,new A(D,new A(C,B.Os())),w.Qc,Qt()))})(a,d));m=Mw(new Nw,a,m.C(),Lt(m),(Uw(a),t().f),(Uw(a),!1));var u=dw(a).Cb;ew(a,k,n,r,m,c,u)}t();l=new M(l)}else Nx(k)?(l=k,k=a,n=new mf(new nf(J(new L,["Illegal position for this "," statement."]))),r=[pf(qf(),l.yb())],Xv(k,sf(n,J(new L,r)),l.C(),d),l=t().f):
-Dn("Program reached and unexpected state.");k=O().c;if(null===k?null===b:k.h(b))return l}else{a=O().c;if(null===a?null===b:a.h(b))return t().f;throw new x(b);}}function z_(){this.Cn=this.Bn=this.Dn=null;this.Vo=this.Wo=this.Dm=this.Uo=0;this.pa=null;this.q=0;this.bl=this.iq=this.mq=this.No=this.Ro=this.So=this.kq=this.Po=this.jq=this.Mo=this.Qo=this.Oo=this.lq=null;this.To=0;this.Ar=this.Up=this.Wp=this.Xp=this.Vp=this.Zp=this.Yp=null;this.nm=this.mw=0;this.bu=null}z_.prototype=new IX;
-z_.prototype.constructor=z_;function A_(){}A_.prototype=z_.prototype;
-function Vx(a,b,c,d,e,g,h,k,l,m){if(et(new E(d.nb),mp())&&h.b()){if(g.b())return e=d.eb,g=O().c,new uv(a,e,g,V(a));c=$w(a);d=d.eb;if(g===v())g=v();else{m=g.e();h=m=new A(m.gb,v());for(g=g.g();g!==v();)k=g.e(),k=new A(k.gb,v()),h=h.r=k,g=g.g();g=m}return Zw(c,e,new uv(a,d,g,V(a)))}if(et(new E(d.nb),pp())||et(new E(d.nb),mp())){et(new E(d.nb),mp())&&Xv(a,sf(new mf(new nf(J(new L,["Parameterized modules are not yet supported"]))),v()),c,m);a.D&&(l=Hs(Q(),"| ",a.q)+("params: "+h+" ")+k,Af(Bf(),l+"\n"));
-if(!b)if(h.b()){if(k.b())return e=new mf(new nf(J(new L,["Class "," cannot be instantiated as it exposes no constructor"]))),g=[pf(qf(),d.eb.X)],Xv(a,sf(e,J(new L,g)),c,m);b=new mf(new nf(J(new L,["Construction of unparameterized class "," should use the `new` keyword"])));l=[pf(qf(),d.eb.X)];Xv(a,sf(b,J(new L,l)),c,m)}else k.b()||Xv(a,sf(new mf(new nf(J(new L,["Construction of class with auxiliary constructor should use the `new` keyword"]))),v()),c,m);if(k instanceof M)c=k.k,m=Mx(Du(),c,new z(n=>
-{var r=V(a);return new ww(n.p,R(),n,r)}));else{if(t().f!==k)throw new x(k);m=h.b()?O().c:h.o()}c=$w(a);m=qF(Du(),m,bt());m=new Ru(a,m,V(a));d=d.eb;if(g===v())g=v();else{h=g.e();k=h=new A(h.gb,v());for(g=g.g();g!==v();)b=g.e(),b=new A(b.gb,v()),k=k.r=b,g=g.g();g=h}g=new uv(a,d,g,V(a));return Zw(c,e,new yu(a,m,g,V(a)))}return Wx(a)}function my(a,b){Hy();var c=v();c=Iy(c);return new aY(a,Cda(a,b,c),Zp($p(),c))}
-function Nf(a,b,c,d,e,g){var h=a.pa;if(a.D){var k=Hs(Q(),"| ",a.q)+(d.fa+". Typing ")+b;Af(Bf(),k+"\n")}a.q=1+a.q|0;try{for(var l=c.b(),m=zf(b);!m.b();){var n=m.e();if(n instanceof Kn){k=n;if(k.Sd.b())if(c.b())u=!1;else var r=c.o().DF(),u=et(new E(r),c_());else u=!1;u&&Xv(a,sf(new mf(new nf(J(new L,["Cannot use `val` or `fun` in local block; use `let` instead."]))),v()),k.C(),e)}m=m.g()}var w=ru().U(),y=zf(b);je();var B=new Wo;je();var D=new Wo;for(b=y;!b.b();){var C=b.e();if(C instanceof Rs){m=C;
-t();var F=new te(m)}else t(),F=new me(C);if(F instanceof te)ip(B,F.ca);else if(F instanceof me)ip(D,F.ia);else throw new x(F);b=b.g()}var I=B.ea(),K=D.ea(),N=ru().U();B=la=>{if(la instanceof Kn){var Ka=la.Qb;if(la.cd instanceof me)return N.Gt(Ka.w,new z(Ua=>{if(Ua instanceof M)return Ua=Ua.k,Xv(a,pf(qf(),"A type signature for '"+Ka.w+"' was already given"),la.C(),e),t(),new M(Ua);if(t().f===Ua)return t(),new M(la);throw new x(Ua);})),!1}return!0};a:for(var P;;)if(I.b()){P=v();break}else{var T=I.e(),
-aa=I.g();if(!1===!!B(T))I=aa;else for(T=I;;){if(aa.b())P=T;else{var Y=aa.e();if(!1!==!!B(Y)){aa=aa.g();continue}Y=aa;var S=new A(T.e(),v()),Z=T.g();for(aa=S;Z!==Y;){var ka=new A(Z.e(),v());aa=aa.r=ka;Z=Z.g()}var X=Y.g();for(Z=X;!X.b();){var sa=X.e();if(!1===!!B(sa)){for(;Z!==X;){var Ia=new A(Z.e(),v());aa=aa.r=Ia;Z=Z.g()}Z=X.g()}X=X.g()}Z.b()||(aa.r=Z);P=S}break a}}var Za=l?N.Ux(new z(la=>{if(null!==la){la=la.j();var Ka=new Iw(a,la,g,d,e),Ua=la.bj;Ua.b()||(Ua=Ua.o().w,Ua=G(new H,Ua,Ka),d.Xa.S(Ua));
-return G(new H,la.sf.w,Ka)}throw new x(la);})):O().c;S=la=>{if(null!==la){if(la instanceof Kn){gp(fp(),la.VD.b());var Ka=N.Y(la.Qb.w);if(Ka instanceof M){Ka=Ka.k;var Ua=la.Sd,ya=la.Qb,ib=la.bj,Lb=la.qh,ec=la.cd,Mb=la.tz,Jb=la.Ow;t();var Kb=new Kn(Ua,ya,ib,Lb,ec,Mb,Jb,new M(Ka),c,la.yo)}else Kb=new Kn(la.Sd,la.Qb,la.bj,la.qh,la.cd,la.tz,la.Ow,la.VD,c,la.yo)}else{if(!(la instanceof io))throw new x(la);Eba(new E(la.eb.X),a.cP)&&(Ka=new mf(new nf(J(new L,["Type name '","' is reserved"]))),Ua=[pf(qf(),
-la.eb.X)],Xv(a,sf(Ka,J(new L,Ua)),la.C(),e));Kb=la}var eb=new Iw(a,Kb,g,d,e);if(Kb instanceof io)la=d.fb,Ka=G(new H,Kb.eb.X,eb),la.S(Ka);else if(Kb instanceof Kn)la=Kb.bj,la.b()||(la=la.o().w,la=G(new H,la,eb),d.Xa.S(la));else throw new x(Kb);w.Gt(Kb.sf.w,new z(Wb=>{if(Wb instanceof M){if(!(Kb instanceof Kn&&Kb.Sd instanceof M)){Wb=new mf(new nf(J(new L,["Refininition of '","'"])));var mc=[pf(qf(),Kb.sf.w)];Xv(a,sf(Wb,J(new L,mc)),Kb.C(),e)}t();return new M(eb)}if(t().f===Wb)return t(),new M(eb);
-throw new x(Wb);}));return G(new H,Kb.sf.w,eb)}throw new x(la);};if(P===v())var Ga=v();else{var xa=P.e(),Ra=new A(S(xa),v());xa=Ra;for(var Ja=P.g();Ja!==v();){var La=Ja.e(),pb=new A(S(La),v());xa=xa.r=pb;Ja=Ja.g()}Ga=Ra}Vv(d,Ga);Vv(d,Za);var Fb=Mx(Du(),Za,new z(la=>{var Ka=!1,Ua=null;la=jx(la,e);if(la instanceof Ew&&(Ka=!0,Ua=la,!Ua.jd.tz.b()))return a.Na;if(Ka)return Ua.no();Dn("Program reached and unexpected state.")}));ap();var Gb=bp(cp(),Fb);Du();var Hb=mn(Ga,Za),tb=Mx(0,Hb,new z(la=>{la=jx(la,
-e);if(la instanceof Ew){var Ka=Gb.Y(la.Sa());if(Ka instanceof M){Ka=Ka.k;var Ua=la.jd.C();Ua=Mw(new Nw,a,Ua,Ax(la.jd),(Uw(a),t().f),(Uw(a),!1));oda(a,la.no(),Ka,d,e,Ua)}else Ka=la.Sa(),Ua=new Sw(a,la.no(),la.jd.Qb),Ka=G(new H,Ka,Ua),d.Xa.S(Ka),Ka=la.jd.bj,Ka.b()?Ka=R():(Ka=Ka.o(),Ka=new M(Ka.w)),Ka.b()||(Ka=Ka.o(),Ua=new Sw(a,la.no(),la.jd.Qb),Ka=G(new H,Ka,Ua),d.Xa.S(Ka))}return new Lw(a,la)}));Vv(d,tb);if(c.b())var kb=R();else{var gb=c.o();kb=new M(gb.DF())}b:if(t().f===kb)var Vb=!0;else{if(kb instanceof
-M){var bb=kb.k;if(c_()===bb||Kw()===bb){Vb=!0;break b}}Vb=!1}if(Vb)var nb=!0;else if(kb instanceof M&&kb.k instanceof XS)nb=!1;else throw new x(kb);var Tb=new z(la=>": "+la);if(a.D){var ub=Hs(Q(),"| ",a.q)+"Typing unit statements";Af(Bf(),ub+"\n")}a.q=1+a.q|0;try{var Ub=Dda(a,K,d,e,g,l,nb)}finally{a.q=-1+a.q|0}if(Gw(new E(Tb),a.pa)&&a.D){var $a=""+Hs(Q(),"| ",a.q)+Tb.n(Ub);Af(Bf(),$a+"\n")}if(tb===v())var cb=v();else{var Na=tb.e(),Ca=new A(Na.j().rh,v());l=Ca;for(var Ba=tb.g();Ba!==v();){var Oa=Ba.e(),
-wa=new A(Oa.j().rh,v());l=l.r=wa;Ba=Ba.g()}cb=Ca}var ea=new Tx(a,cb,Ub)}finally{a.q=-1+a.q|0}Gw(new E(h),a.pa)&&a.D&&(h=""+Hs(Q(),"| ",a.q)+h.n(ea),Af(Bf(),h+"\n"));return ea}
-function ix(a,b,c,d,e){var g=ru().U(),h=c.w;c=b.pg();if(d.b()){var k=b.pg();b=n=>{if(null!==n){n=n.gb;var r=n.Zh;t();var u=new M(n),w=n.dg,y=O().c,B=O().c;return new Ow(a,n.Va,y,B,u,w,!1,r)}throw new x(n);};if(k===v())b=v();else{d=k.e();var l=d=new A(b(d),v());for(k=k.g();k!==v();){var m=k.e();m=new A(b(m),v());l=l.r=m;k=k.g()}b=d}}else b=d.o();c=new vq(c,c,b);b=new Um((n,r)=>{n=G(new H,n,r);var u=n.z;r=n.x;if(null!==u){n=u.ec;u=u.gb;if(r instanceof Ow){if(a.D){var w=Hs(Q(),"| ",a.q)+("Passing "+
-n.X+" :: "+u+" \x3c\x3d\x3c ")+r;Af(Bf(),w+"\n")}}else{a.D&&(w=Hs(Q(),"| ",a.q)+("Assigning "+n.X+" :: "+u+" :\x3d "+r+" where ")+Yw(r),Af(Bf(),w+"\n"));w=u.Zh;t();var y=new M(u),B=u.dg,D=ny(u),C=Tz(u),F=r.Ca();w=new Ow(a,F,D,C,y,B,!1,w);a.D&&(y=Hs(Q(),"| ",a.q)+("Set "+w+" ~\x3e ")+u,Af(Bf(),y+"\n"));gp(fp(),w.Wb.b());if(!ny(w).b())throw new rk("assertion failed: "+ny(w));if(!Tz(w).b())throw new rk("assertion failed: "+Tz(w));jA(w,(t(),new M(r)));r=w}u=G(new H,u,r);g.S(u);u=h+"#"+n.X;t();n=new xw(a,
-n,new ww(a,new M(r),r,V(a)),!0,e.fa);return G(new H,u,n)}throw new x(n);});xq();c=Rv(c,b);ap();c=bp(cp(),c);return G(new H,g,c)}function fx(){}fx.prototype=new iW;fx.prototype.constructor=fx;f=fx.prototype;f.kj=function(a,b){return a instanceof Kn?a.Qb:b.n(a)};f.nj=function(a){return a instanceof Kn};f.Ec=function(a){return this.nj(a)};f.Nb=function(a,b){return this.kj(a,b)};
-f.$classData=q({QW:0},!1,"mlscript.NuTypeDefs$DelayedTypeInfoImpl$$anonfun$$nestedInanonfun$allFields$4$1",{QW:1,Bf:1,d:1,ja:1,za:1,l:1});function Tw(){}Tw.prototype=new iW;Tw.prototype.constructor=Tw;f=Tw.prototype;f.kj=function(a,b){if(a instanceof Kn){var c=a.Sd,d=a.cd;c=t().f===c?!0:c instanceof M&&!1===!!c.k?!0:!1;if(c&&d instanceof te)return a}return b.n(a)};f.nj=function(a){if(a instanceof Kn){var b=a.Sd;a=a.cd;b=t().f===b?!0:b instanceof M&&!1===!!b.k?!0:!1;if(b&&a instanceof te)return!0}return!1};
-f.Ec=function(a){return this.nj(a)};f.Nb=function(a,b){return this.kj(a,b)};f.$classData=q({RW:0},!1,"mlscript.NuTypeDefs$DelayedTypeInfoImpl$$anonfun$2",{RW:1,Bf:1,d:1,ja:1,za:1,l:1});function qy(a){this.qN=null;if(null===a)throw null;this.qN=a}qy.prototype=new iW;qy.prototype.constructor=qy;qy.prototype.Ec=function(a){return a instanceof xw||a instanceof Ew};
-qy.prototype.Nb=function(a,b){if(a instanceof xw)b=a.cj.pr(),a=G(new H,b,a.cg);else if(a instanceof Ew){b=a.Vh;a=a.jd.Qb;var c=V(this.qN.J);b=new ww(b.p,R(),b,c);a=G(new H,a,b)}else a=b.n(a);return a};qy.prototype.$classData=q({SW:0},!1,"mlscript.NuTypeDefs$DelayedTypeInfoImpl$$anonfun$3",{SW:1,Bf:1,d:1,ja:1,za:1,l:1});function B_(){}B_.prototype=new iW;B_.prototype.constructor=B_;B_.prototype.Ec=function(a){return null!==a&&a.xd instanceof M?!0:!1};
-B_.prototype.Nb=function(a,b){a:{if(null!==a){var c=a.gb,d=a.xd;if(d instanceof M){a=G(new H,c,d.k);break a}}a=b.n(a)}return a};B_.prototype.$classData=q({$W:0},!1,"mlscript.NuTypeDefs$TypedNuCls$$anonfun$1",{$W:1,Bf:1,d:1,ja:1,za:1,l:1});function vr(a){this.Tw=a}vr.prototype=new oz;vr.prototype.constructor=vr;f=vr.prototype;f.H=function(){return"OPEN_BRACKET"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Tw:JK(W(),a)};f.E=function(a){return a instanceof vr};f.y=function(){return jL(this)};
-f.u=function(){return EK(this)};f.h=function(a){return this===a?!0:a instanceof vr?this.Tw===a.Tw:!1};f.$classData=q({gX:0},!1,"mlscript.OPEN_BRACKET",{gX:1,al:1,d:1,F:1,v:1,l:1});function yy(){}yy.prototype=new iW;yy.prototype.constructor=yy;f=yy.prototype;f.cJ=function(a,b){if(a instanceof mm){var c=a.kb,d=a.hc,e=c.C();if(e.b())e=!1;else{e=e.o();var g=d.C();g.b()?e=!1:(g=g.o(),e=e.Yg>g.Yg)}if(e)return G(new H,c,d)}return b.n(a)};
-f.wJ=function(a){if(a instanceof mm){var b=a.hc;a=a.kb.C();a.b()?b=!1:(a=a.o(),b=b.C(),b.b()?b=!1:(b=b.o(),b=a.Yg>b.Yg));if(b)return!0}return!1};f.Ec=function(a){return this.wJ(a)};f.Nb=function(a,b){return this.cJ(a,b)};f.$classData=q({iX:0},!1,"mlscript.OpApp$$anonfun$unapply$1",{iX:1,Bf:1,d:1,ja:1,za:1,l:1});function yf(a){this.xN=null;this.DH=!1;this.zz=a}yf.prototype=new p;yf.prototype.constructor=yf;f=yf.prototype;
-f.Nu=function(){if(!this.DH&&!this.DH){for(var a=mE(iE()),b=this.zz,c=null,d=null;b!==v();){var e=b.e().Nu();if(null===e)throw new x(e);var g=e.j();a.oc(e.i());for(e=g.m();e.s();)g=new A(e.t(),v()),null===d?c=g:d.r=g,d=g;b=b.g()}d=null===c?v():c;je();b=new Wo;je();for(c=new Wo;!d.b();){e=d.e();if(e instanceof yo)t(),e=new te(e);else if(e&&e.$classData&&e.$classData.pb.If)t(),e=new me(e);else{if(!(e instanceof Kn))throw e instanceof zo&&Dn("Program reached and unexpected state."),new x(e);var h=e;
-e=h.Sd;g=h.Qb;h=h.cd;t();e=new xo(!(!e.b()&&!e.o()),g,h,e.b());e=new me(e)}if(e instanceof te)ip(b,e.ca);else if(e instanceof me)ip(c,e.ia);else throw new x(e);d=d.g()}b=G(new H,b.ea(),c.ea());a=a.ea();this.xN=G(new H,a,b);this.DH=!0}return this.xN};f.H=function(){return"Pgrm"};f.G=function(){return 1};f.I=function(a){return 0===a?this.zz:JK(W(),a)};f.E=function(a){return a instanceof yf};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof yf){var b=this.zz;a=a.zz;return null===b?null===a:b.h(a)}return!1};f.$classData=q({lX:0},!1,"mlscript.Pgrm",{lX:1,d:1,$$:1,F:1,v:1,l:1});function Uy(a,b){this.aE=a;this.$D=b}Uy.prototype=new Zy;Uy.prototype.constructor=Uy;f=Uy.prototype;f.Sa=function(){return this.aE};f.LP=function(a){return this.$D.n(a)};f.H=function(){return"BuiltinFunc"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.aE;case 1:return this.$D;default:return JK(W(),a)}};f.E=function(a){return a instanceof Uy};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Uy&&this.aE===a.aE){var b=this.$D;a=a.$D;return null===b?null===a:b.h(a)}return!1};f.$classData=q({qX:0},!1,"mlscript.Polyfill$BuiltinFunc",{qX:1,rX:1,d:1,F:1,v:1,l:1});function Py(a,b){this.cE=a;this.bE=b}Py.prototype=new Zy;
-Py.prototype.constructor=Py;f=Py.prototype;f.Sa=function(){return this.cE};f.LP=function(a){return this.bE.n(a)};f.H=function(){return"RuntimeHelper"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.cE;case 1:return this.bE;default:return JK(W(),a)}};f.E=function(a){return a instanceof Py};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Py&&this.cE===a.cE){var b=this.bE;a=a.bE;return null===b?null===a:b.h(a)}return!1};
-f.$classData=q({sX:0},!1,"mlscript.Polyfill$RuntimeHelper",{sX:1,rX:1,d:1,F:1,v:1,l:1});function y_(){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0}y_.prototype=new $S;y_.prototype.constructor=y_;function C_(){}C_.prototype=y_.prototype;y_.prototype.Kj=function(){return vP(this)};function rn(a){0===(1&a.te)<<24>>24&&0===(1&a.te)<<24>>24&&(a.tg=Kca(a),a.te=(1|a.te)<<24>>24);return a.tg}
-function un(a){0===(2&a.te)<<24>>24&&0===(2&a.te)<<24>>24&&(a.ug=Lca(a),a.te=(2|a.te)<<24>>24);return a.ug}function yP(){}yP.prototype=new iW;yP.prototype.constructor=yP;f=yP.prototype;f.Cq=function(a,b){if(null!==a){var c=a.j();if(null!==c&&(c=c.Da,c instanceof em))return c.po}return b.n(a)};f.Hq=function(a){return null!==a&&(a=a.j(),null!==a&&a.Da instanceof em)?!0:!1};f.Ec=function(a){return this.Hq(a)};f.Nb=function(a,b){return this.Cq(a,b)};
-f.$classData=q({VX:0},!1,"mlscript.TypeLikeImpl$$anonfun$1",{VX:1,Bf:1,d:1,ja:1,za:1,l:1});function zP(){}zP.prototype=new iW;zP.prototype.constructor=zP;f=zP.prototype;f.kj=function(a,b){return a instanceof Rs?a:b.n(a)};f.nj=function(a){return a instanceof Rs};f.Ec=function(a){return this.nj(a)};f.Nb=function(a,b){return this.kj(a,b)};f.$classData=q({WX:0},!1,"mlscript.TypeLikeImpl$$anonfun$2",{WX:1,Bf:1,d:1,ja:1,za:1,l:1});function tP(a,b){this.GN=b}tP.prototype=new iW;
-tP.prototype.constructor=tP;f=tP.prototype;
-f.kj=function(a,b){if(a instanceof zo){b=a.Cr;a=pP(this.GN);var c=b.Ra;b=h=>{if(null!==h){var k=new M(h);if(!k.b()&&(h=k.k.i(),k=k.k.j(),t().f===h&&null!==k)){h=k.vc;k=k.Da;var l=Ct().Kg;if((null===l?null===h:l.h(h))&&k instanceof em&&(h=k.Ni,k=k.po,h instanceof Wl))return h.w+": "+Yf(k,this.GN,0)}}Dn("ill-formed constructor parameter")};if(c===v())b=v();else{var d=c.e(),e=d=new A(b(d),v());for(c=c.g();c!==v();){var g=c.e();g=new A(b(g),v());e=e.r=g;c=c.g()}b=d}return a+"constructor("+Qe(b,"",", ",
-"")+")\n"}return b.n(a)};f.nj=function(a){return a instanceof zo};f.Ec=function(a){return this.nj(a)};f.Nb=function(a,b){return this.kj(a,b)};f.$classData=q({XX:0},!1,"mlscript.TypeLikeImpl$$anonfun$showIn$38",{XX:1,Bf:1,d:1,ja:1,za:1,l:1});function uP(){}uP.prototype=new iW;uP.prototype.constructor=uP;f=uP.prototype;f.kj=function(a,b){return a instanceof Rs?a:b.n(a)};f.nj=function(a){return a instanceof Rs};f.Ec=function(a){return this.nj(a)};f.Nb=function(a,b){return this.kj(a,b)};
-f.$classData=q({YX:0},!1,"mlscript.TypeLikeImpl$$anonfun$showIn$39",{YX:1,Bf:1,d:1,ja:1,za:1,l:1});function CA(){}CA.prototype=new iW;CA.prototype.constructor=CA;f=CA.prototype;f.dJ=function(a,b){if(a instanceof IB){var c=a.Io;if(null!==c)return a=c.w,hu(Q(),a)}return b.n(a)};f.xJ=function(a){return a instanceof IB&&null!==a.Io?!0:!1};f.Ec=function(a){return this.xJ(a)};f.Nb=function(a,b){return this.dJ(a,b)};f.$classData=q({aY:0},!1,"mlscript.TypeSimplifier$$anonfun$1",{aY:1,Bf:1,d:1,ja:1,za:1,l:1});
-function Yz(a){this.Mz=null;if(null===a)throw null;this.Mz=a}Yz.prototype=new iW;Yz.prototype.constructor=Yz;f=Yz.prototype;
-f.Cq=function(a,b){if(null!==a){var c=a.i(),d=a.j();if(null!==c){DB(this.Mz);var e=c.Wb;if(!e.b()&&(e=e.o(),d instanceof M)){if(d.k)return a=G(new H,!0,e),G(new H,a,c);a=G(new H,!1,e);return G(new H,a,c)}}}if(null!==a&&(c=a.i(),d=a.j(),d instanceof M)){if(d.k){a=ny(c);for(b=this.Mz.tb;!a.b();)d=a.e(),e=V(b.p),b=zu(b,d,e,!1),a=a.g();a=G(new H,!0,b);return G(new H,a,c)}a=Tz(c);for(b=this.Mz.Na;!a.b();)d=a.e(),e=V(b.p),b=Uz(b,d,e),a=a.g();a=G(new H,!1,b);return G(new H,a,c)}return b.n(a)};
-f.Hq=function(a){if(null!==a){var b=a.i(),c=a.j();if(null!==b&&(DB(this.Mz),!b.Wb.b()&&c instanceof M))return!0}return null!==a&&a.j()instanceof M?!0:!1};f.Ec=function(a){return this.Hq(a)};f.Nb=function(a,b){return this.Cq(a,b)};f.$classData=q({bY:0},!1,"mlscript.TypeSimplifier$$anonfun$2",{bY:1,Bf:1,d:1,ja:1,za:1,l:1});function D_(a,b){this.JN=b}D_.prototype=new iW;D_.prototype.constructor=D_;D_.prototype.Ec=function(a){return a instanceof Sw};
-D_.prototype.Nb=function(a,b){a instanceof Sw?(b=a.zs,a=a.Xz,gp(fp(),!this.JN.Fs.b()),this.JN.Fs=a.Fs,a=b):a=b.n(a);return a};D_.prototype.$classData=q({hY:0},!1,"mlscript.Typer$$anonfun$$nestedInanonfun$typeTerm$2$1",{hY:1,Bf:1,d:1,ja:1,za:1,l:1});function E_(){}E_.prototype=new iW;E_.prototype.constructor=E_;f=E_.prototype;f.cJ=function(a,b){if(a instanceof Wl)return a;if(a instanceof em){var c=a.Ni;if(c instanceof Wl)return c}return b.n(a)};
-f.wJ=function(a){return a instanceof Wl||a instanceof em&&a.Ni instanceof Wl?!0:!1};f.Ec=function(a){return this.wJ(a)};f.Nb=function(a,b){return this.cJ(a,b)};f.$classData=q({iY:0},!1,"mlscript.Typer$$anonfun$1",{iY:1,Bf:1,d:1,ja:1,za:1,l:1});function F_(a,b,c,d,e,g){this.RH=this.SH=this.PH=null;this.UH=!1;this.QH=this.TH=null;if(null===a)throw null;this.PH=a;this.SH=b;this.RH=c;this.UH=d;this.TH=e;this.QH=g}F_.prototype=new iW;F_.prototype.constructor=F_;f=F_.prototype;
-f.Cq=function(a,b){if(null!==a){var c=a.j();if(c instanceof Ew)return G_(this.PH,c,this.SH,this.RH,this.UH,this.TH,this.QH)}return null!==a&&(c=a.j(),c instanceof cx)?G_(this.PH,c,this.SH,this.RH,this.UH,this.TH,this.QH):b.n(a)};f.Hq=function(a){return null!==a&&a.j()instanceof Ew||null!==a&&a.j()instanceof cx?!0:!1};f.Ec=function(a){return this.Hq(a)};f.Nb=function(a,b){return this.Cq(a,b)};f.$classData=q({jY:0},!1,"mlscript.Typer$$anonfun$mkTypingUnit$1$1",{jY:1,Bf:1,d:1,ja:1,za:1,l:1});
-function H_(a){this.An=this.th=this.Ia=null;this.mx=this.Bm=!1;this.qu=null;Mw(this,a,t().f,"expression",(Uw(a),t().f),(Uw(a),!1))}H_.prototype=new oY;H_.prototype.constructor=H_;H_.prototype.u=function(){return"[NO PROV]"};H_.prototype.$classData=q({nY:0},!1,"mlscript.Typer$NoProv$",{nY:1,EO:1,d:1,F:1,v:1,l:1});function QB(){}QB.prototype=new iW;QB.prototype.constructor=QB;f=QB.prototype;f.gJ=function(a,b){if(a instanceof M){var c=a.k;if(c instanceof Sw&&(c=c.zs,null!==c))return dB(c)}return b.n(a)};
-f.AJ=function(a){return a instanceof M&&(a=a.k,a instanceof Sw&&null!==a.zs)?!0:!1};f.Ec=function(a){return this.AJ(a)};f.Nb=function(a,b){return this.gJ(a,b)};f.$classData=q({pY:0},!1,"mlscript.Typer$ValidPatVar$$anonfun$unapply$3",{pY:1,Bf:1,d:1,ja:1,za:1,l:1});function RB(a,b,c){this.ON=this.hx=this.NN=null;if(null===a)throw null;this.NN=a;this.hx=b;this.ON=c}RB.prototype=new iW;RB.prototype.constructor=RB;f=RB.prototype;
-f.gJ=function(a,b){if(a instanceof M){var c=a.k;if(c instanceof gu&&(c=c.ed,c instanceof Wl&&this.hx.w===c.w)){a=this.NN.VH;b=new mf(new nf(J(new L,["Variable name '","' already names a symbol in scope. "])));c=[pf(qf(),this.hx.w)];OX(a,UX(UX(sf(b,J(new L,c)),pf(qf(),"If you want to refer to that symbol, you can use `scope."+this.hx.w+"`; ")),pf(qf(),"if not, give your future readers a break and use another name :^)")),this.hx.C(),this.ON);return}}return b.n(a)};
-f.AJ=function(a){return a instanceof M&&(a=a.k,a instanceof gu&&(a=a.ed,a instanceof Wl&&this.hx.w===a.w))?!0:!1};f.Ec=function(a){return this.AJ(a)};f.Nb=function(a,b){return this.gJ(a,b)};f.$classData=q({qY:0},!1,"mlscript.Typer$ValidPatVar$$anonfun$unapply$4",{qY:1,Bf:1,d:1,ja:1,za:1,l:1});function lX(){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0}lX.prototype=new nY;lX.prototype.constructor=lX;function I_(){}I_.prototype=lX.prototype;
-function sB(){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0}sB.prototype=new nY;sB.prototype.constructor=sB;function J_(){}J_.prototype=sB.prototype;sB.prototype.Ca=function(){return this.gc().Ca()};sB.prototype.rb=function(a,b){return this.gc().rb(a,b)};sB.prototype.u=function(){return"["+this.gc()+"]"};function Sw(a,b,c){this.J=null;this.zs=b;this.Xz=c;ZB(this,a)}Sw.prototype=new aC;Sw.prototype.constructor=Sw;f=Sw.prototype;f.H=function(){return"VarSymbol"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.zs;case 1:return this.Xz;default:return JK(W(),a)}};f.E=function(a){return a instanceof Sw};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Sw&&a.J===this.J){var b=this.zs,c=a.zs;if(null===b?null===c:HB(b,c))return b=this.Xz,a=a.Xz,null===b?null===a:b.h(a)}return!1};f.$classData=q({hZ:0},!1,"mlscript.TyperDatatypes$VarSymbol",{hZ:1,DO:1,d:1,F:1,v:1,l:1});function SP(){}SP.prototype=new iW;
-SP.prototype.constructor=SP;f=SP.prototype;f.kj=function(a,b){return a instanceof Kn&&a.cd.TA()?a.Qb.w:b.n(a)};f.nj=function(a){return a instanceof Kn&&a.cd.TA()?!0:!1};f.Ec=function(a){return this.nj(a)};f.Nb=function(a,b){return this.kj(a,b)};f.$classData=q({vZ:0},!1,"mlscript.TypingUnitImpl$$anonfun$3",{vZ:1,Bf:1,d:1,ja:1,za:1,l:1});function FE(a,b,c,d){this.$e=null;this.zu=a;this.Au=b;this.yx=c;this.a_=d;KD(this)}FE.prototype=new MD;FE.prototype.constructor=FE;f=FE.prototype;f.av=function(){return this.a_};
-f.u=function(){return"\u00ab"+this.zu+" \x3d "+this.Au+"\u00bb"+ND(this)};f.H=function(){return"Binding"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.zu;case 1:return this.Au;case 2:return this.yx;default:return JK(W(),a)}};f.E=function(a){return a instanceof FE};f.y=function(){var a=dc("Binding");a=W().B(-889275714,a);var b=this.zu;b=dy(W(),b);a=W().B(a,b);b=this.Au;b=dy(W(),b);a=W().B(a,b);b=this.yx?1231:1237;a=W().B(a,b);return W().La(a,3)};
-f.h=function(a){if(this===a)return!0;if(a instanceof FE&&this.yx===a.yx){var b=this.zu,c=a.zu;if(null===b?null===c:b.h(c))return b=this.Au,a=a.Au,null===b?null===a:b.h(a)}return!1};f.$classData=q({$Z:0},!1,"mlscript.ucs.Clause$Binding",{$Z:1,xA:1,d:1,F:1,v:1,l:1});function EE(a,b){this.$e=null;this.zx=a;this.c_=b;KD(this)}EE.prototype=new MD;EE.prototype.constructor=EE;f=EE.prototype;f.av=function(){return this.c_};f.u=function(){return"\u00ab"+this.zx+"\u00bb"+ND(this)};f.H=function(){return"BooleanTest"};
-f.G=function(){return 1};f.I=function(a){return 0===a?this.zx:JK(W(),a)};f.E=function(a){return a instanceof EE};f.y=function(){return jL(this)};f.h=function(a){if(this===a)return!0;if(a instanceof EE){var b=this.zx;a=a.zx;return null===b?null===a:b.h(a)}return!1};f.$classData=q({b_:0},!1,"mlscript.ucs.Clause$BooleanTest",{b_:1,xA:1,d:1,F:1,v:1,l:1});function DE(a,b,c,d){this.$e=null;this.Cu=a;this.Bu=b;this.Fx=c;this.DP=d;KD(this)}DE.prototype=new MD;DE.prototype.constructor=DE;f=DE.prototype;
-f.av=function(){return this.DP};f.u=function(){return"\u00ab"+this.Cu+" is Tuple#"+this.Bu+"\u00bb"+ND(this)};f.H=function(){return"MatchTuple"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.Cu;case 1:return this.Bu;case 2:return this.Fx;default:return JK(W(),a)}};f.E=function(a){return a instanceof DE};
-f.y=function(){var a=dc("MatchTuple");a=W().B(-889275714,a);var b=this.Cu;b=dy(W(),b);a=W().B(a,b);b=this.Bu;a=W().B(a,b);b=this.Fx;b=dy(W(),b);a=W().B(a,b);return W().La(a,3)};f.h=function(a){if(this===a)return!0;if(a instanceof DE&&this.Bu===a.Bu){var b=this.Cu,c=a.Cu;if(null===b?null===c:b.h(c))return b=this.Fx,a=a.Fx,null===b?null===a:b.h(a)}return!1};f.$classData=q({h_:0},!1,"mlscript.ucs.Clause$MatchTuple",{h_:1,xA:1,d:1,F:1,v:1,l:1});function HE(){}HE.prototype=new TD;
-HE.prototype.constructor=HE;f=HE.prototype;f.u=function(){return"pattern destruction"};f.H=function(){return"FieldExtraction"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof HE};f.y=function(){return 1536009313};f.$classData=q({m_:0},!1,"mlscript.ucs.LetBinding$Kind$FieldExtraction$",{m_:1,FP:1,d:1,F:1,v:1,l:1});var GE;function K_(){}K_.prototype=new TD;K_.prototype.constructor=K_;f=K_.prototype;f.u=function(){return"interleaved let"};f.H=function(){return"InterleavedLet"};
-f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof K_};f.y=function(){return 1258608914};f.$classData=q({n_:0},!1,"mlscript.ucs.LetBinding$Kind$InterleavedLet$",{n_:1,FP:1,d:1,F:1,v:1,l:1});var L_;function dE(){L_||(L_=new K_);return L_}function M_(){}M_.prototype=new TD;M_.prototype.constructor=M_;f=M_.prototype;f.u=function(){return"scrutinee alias"};f.H=function(){return"ScrutineeAlias"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};
-f.E=function(a){return a instanceof M_};f.y=function(){return-1538996278};f.$classData=q({o_:0},!1,"mlscript.ucs.LetBinding$Kind$ScrutineeAlias$",{o_:1,FP:1,d:1,F:1,v:1,l:1});var N_;function IE(){N_||(N_=new M_);return N_}function ZD(a,b){this.Js=null;this.Ij=a;this.dl=b;this.Js=Lz().U()}ZD.prototype=new QE;ZD.prototype.constructor=ZD;f=ZD.prototype;f.Qs=function(){return this.dl};f.WP=function(){var a=this.Ij.j().ga();return oE(new ZD(G(new H,this.Ij.Mu(),a),this.dl.Dq()),this.Js)};
-f.hF=function(a,b){var c=!1,d=null;if(a instanceof fm)return!1;if(a instanceof Wl){c=!0;d=a;var e=d.w;if("true"===e||"false"===e)return!1}if(c&&d.w===this.Ij.i().w)return!0;if(c){a=b.Y(d.w);if(a instanceof M)return a.k.L(this.Ij.i().w);if(R()===a)return!1;throw new x(a);}throw new x(a);};function O_(a,b){var c=a.Ij.j();b=b.m();b=new Gx(b,new z(d=>!a.Ij.j().L(d)),!1);c.oc(b)}f.H=function(){return"Constructor"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.Ij;case 1:return this.dl;default:return JK(W(),a)}};f.E=function(a){return a instanceof ZD};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof ZD){var b=this.Ij,c=a.Ij;if(null===b?null===c:b.h(c))return b=this.dl,a=a.dl,null===b?null===a:b.h(a)}return!1};f.$classData=q({w_:0},!1,"mlscript.ucs.MutCaseOf$MutCase$Constructor",{w_:1,v_:1,d:1,F:1,v:1,l:1});
-function YD(a,b){this.Js=null;this.xq=a;this.Zo=b;this.Js=Lz().U()}YD.prototype=new QE;YD.prototype.constructor=YD;f=YD.prototype;f.Qs=function(){return this.Zo};f.WP=function(){return oE(new YD(this.xq,this.Zo.Dq()),this.Js)};f.hF=function(a){var b=a instanceof fm?!0:a instanceof Wl&&"true"===a.w?!0:a instanceof Wl&&"false"===a.w?!0:!1;if(b)return hf(new E(a),this.xq);if(a instanceof Wl)return!1;throw new x(a);};f.H=function(){return"Literal"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.xq;case 1:return this.Zo;default:return JK(W(),a)}};f.E=function(a){return a instanceof YD};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof YD){var b=this.xq,c=a.xq;if(null===b?null===c:b.h(c))return b=this.Zo,a=a.Zo,null===b?null===a:b.h(a)}return!1};f.$classData=q({x_:0},!1,"mlscript.ucs.MutCaseOf$MutCase$Literal",{x_:1,v_:1,d:1,F:1,v:1,l:1});function P_(){Q_=this;O()}P_.prototype=new SE;
-P_.prototype.constructor=P_;f=P_.prototype;f.Jn=function(a){var b=O().c;return new R_(a,new A(a,b))};f.H=function(){return"Empty"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof P_};f.y=function(){return 67081517};f.u=function(){return"Empty"};f.$classData=q({y_:0},!1,"mlscript.ucs.PartialTerm$Empty$",{y_:1,HP:1,d:1,F:1,v:1,l:1});var Q_;function S_(){Q_||(Q_=new P_);return Q_}function T_(a,b,c){this.VE=a;this.WE=b;this.CA=c}T_.prototype=new SE;
-T_.prototype.constructor=T_;f=T_.prototype;f.Jn=function(a,b){var c=ZE(aF(),a,b);if(null===c)throw new x(c);a=c.i();c=c.j();a=XE(aF(),this.VE,this.WE,a,b);if(t().f===c)return new R_(a,this.CA);if(c instanceof M)return c=c.k,b=XE(aF(),a,new Wl("and"),c,b),new R_(b,new A(c,this.CA));throw new x(c);};f.H=function(){return"Half"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.VE;case 1:return this.WE;case 2:return this.CA;default:return JK(W(),a)}};
-f.E=function(a){return a instanceof T_};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof T_){var b=this.VE,c=a.VE;if(null===b?null===c:b.h(c))if(b=this.WE,c=a.WE,null===b?null===c:b.h(c))return b=this.CA,a=a.CA,null===b?null===a:b.h(a)}return!1};f.$classData=q({z_:0},!1,"mlscript.ucs.PartialTerm$Half",{z_:1,HP:1,d:1,F:1,v:1,l:1});function R_(a,b){this.yq=a;this.DA=b}R_.prototype=new SE;R_.prototype.constructor=R_;f=R_.prototype;
-f.Jn=function(a){throw new sY("expect an operator but term "+a+" was given");};function U_(a,b){return new T_(a.yq,b,new A(b,a.DA))}f.H=function(){return"Total"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.yq;case 1:return this.DA;default:return JK(W(),a)}};f.E=function(a){return a instanceof R_};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof R_){var b=this.yq,c=a.yq;if(null===b?null===c:b.h(c))return b=this.DA,a=a.DA,null===b?null===a:b.h(a)}return!1};f.$classData=q({A_:0},!1,"mlscript.ucs.PartialTerm$Total",{A_:1,HP:1,d:1,F:1,v:1,l:1});function gQ(){}gQ.prototype=new xY;gQ.prototype.constructor=gQ;gQ.prototype.n=function(a){return a};gQ.prototype.u=function(){return"generalized constraint"};
-gQ.prototype.$classData=q({p2:0},!1,"scala.$less$colon$less$$anon$1",{p2:1,xaa:1,yaa:1,d:1,ja:1,l:1});class x extends mW{constructor(a){super();this.SQ=null;this.nK=!1;this.KF=a;fF(this,null,null,!0)}mj(){if(!this.nK&&!this.nK){if(null===this.KF)var a="null";else try{a=pc(this.KF)+" (of class "+lb(this.KF)+")"}catch(b){a="an instance of class "+lb(this.KF)}this.SQ=a;this.nK=!0}return this.SQ}}x.prototype.$classData=q({t2:0},!1,"scala.MatchError",{t2:1,ye:1,fd:1,jc:1,d:1,l:1});function V_(){}
-V_.prototype=new p;V_.prototype.constructor=V_;function W_(){}f=W_.prototype=V_.prototype;f.b=function(){return this===R()};f.Q=function(){return this.b()?0:1};f.L=function(a){return!this.b()&&Ol(Pl(),this.o(),a)};f.m=function(){if(this.b())return qq().Oa;qq();var a=this.o();return new X_(a)};f.ea=function(){if(this.b()){O();var a=v();return le(v(),a)}return new A(this.o(),O().c)};function G(a,b,c){a.z=b;a.x=c;return a}function H(){this.x=this.z=null}H.prototype=new p;H.prototype.constructor=H;
-function Y_(){}f=Y_.prototype=H.prototype;f.G=function(){return 2};f.I=function(a){a:switch(a){case 0:a=this.i();break a;case 1:a=this.j();break a;default:throw KK(new LK,a+" is out of bounds (min 0, max 1)");}return a};f.i=function(){return this.z};f.j=function(){return this.x};f.u=function(){return"("+this.i()+","+this.j()+")"};f.Et=function(){return G(new H,this.j(),this.i())};f.Mu=function(){return this.i()};f.H=function(){return"Tuple2"};f.E=function(a){return a instanceof H};f.y=function(){return jL(this)};
-f.h=function(a){return this===a?!0:a instanceof H?Ol(Pl(),this.i(),a.i())&&Ol(Pl(),this.j(),a.j()):!1};f.Xc=function(){return!!this.i()};f.dF=function(){return Eb(this.i())};f.Gx=function(){return this.i()|0};f.Hx=function(){return!!this.j()};f.YI=function(){return Eb(this.j())};f.Lc=function(){return this.j()|0};f.$classData=q({Fu:0},!1,"scala.Tuple2",{Fu:1,d:1,$x:1,F:1,v:1,l:1});function Ul(a,b,c){this.ec=a;this.gb=b;this.xd=c}Ul.prototype=new p;Ul.prototype.constructor=Ul;f=Ul.prototype;f.G=function(){return 3};
-f.I=function(a){a:switch(a){case 0:a=this.ec;break a;case 1:a=this.gb;break a;case 2:a=this.xd;break a;default:throw KK(new LK,a+" is out of bounds (min 0, max 2)");}return a};f.u=function(){return"("+this.ec+","+this.gb+","+this.xd+")"};f.H=function(){return"Tuple3"};f.E=function(a){return a instanceof Ul};f.y=function(){return jL(this)};f.h=function(a){return this===a?!0:a instanceof Ul?Ol(Pl(),this.ec,a.ec)&&Ol(Pl(),this.gb,a.gb)&&Ol(Pl(),this.xd,a.xd):!1};
-f.$classData=q({d0:0},!1,"scala.Tuple3",{d0:1,d:1,Caa:1,F:1,v:1,l:1});function vp(a,b,c,d){this.Jj=a;this.jj=b;this.ci=c;this.Qi=d}vp.prototype=new p;vp.prototype.constructor=vp;f=vp.prototype;f.G=function(){return 4};f.I=function(a){return Rca(this,a)};f.u=function(){return"("+this.Jj+","+this.jj+","+this.ci+","+this.Qi+")"};f.H=function(){return"Tuple4"};f.E=function(a){return a instanceof vp};f.y=function(){return jL(this)};
-f.h=function(a){return this===a?!0:a instanceof vp?Ol(Pl(),this.Jj,a.Jj)&&Ol(Pl(),this.jj,a.jj)&&Ol(Pl(),this.ci,a.ci)&&Ol(Pl(),this.Qi,a.Qi):!1};f.$classData=q({e0:0},!1,"scala.Tuple4",{e0:1,d:1,Daa:1,F:1,v:1,l:1});function YX(a,b,c,d,e){this.Gu=a;this.Ks=b;this.zq=c;this.Hu=d;this.Iu=e}YX.prototype=new p;YX.prototype.constructor=YX;f=YX.prototype;f.G=function(){return 5};f.I=function(a){return Sca(this,a)};f.u=function(){return"("+this.Gu+","+this.Ks+","+this.zq+","+this.Hu+","+this.Iu+")"};
-f.H=function(){return"Tuple5"};f.E=function(a){return a instanceof YX};f.y=function(){return jL(this)};f.h=function(a){return this===a?!0:a instanceof YX?Ol(Pl(),this.Gu,a.Gu)&&Ol(Pl(),this.Ks,a.Ks)&&Ol(Pl(),this.zq,a.zq)&&Ol(Pl(),this.Hu,a.Hu)&&Ol(Pl(),this.Iu,a.Iu):!1};f.$classData=q({f0:0},!1,"scala.Tuple5",{f0:1,d:1,Eaa:1,F:1,v:1,l:1});function Nn(a,b,c,d,e,g){this.Aq=a;this.Bq=b;this.Ls=c;this.Ms=d;this.Ns=e;this.Ju=g}Nn.prototype=new p;Nn.prototype.constructor=Nn;f=Nn.prototype;f.G=function(){return 6};
-f.I=function(a){return Tca(this,a)};f.u=function(){return"("+this.Aq+","+this.Bq+","+this.Ls+","+this.Ms+","+this.Ns+","+this.Ju+")"};f.H=function(){return"Tuple6"};f.E=function(a){return a instanceof Nn};f.y=function(){return jL(this)};f.h=function(a){return this===a?!0:a instanceof Nn?Ol(Pl(),this.Aq,a.Aq)&&Ol(Pl(),this.Bq,a.Bq)&&Ol(Pl(),this.Ls,a.Ls)&&Ol(Pl(),this.Ms,a.Ms)&&Ol(Pl(),this.Ns,a.Ns)&&Ol(Pl(),this.Ju,a.Ju):!1};f.$classData=q({g0:0},!1,"scala.Tuple6",{g0:1,d:1,Faa:1,F:1,v:1,l:1});
-function Z_(a){this.sB=a}Z_.prototype=new uT;Z_.prototype.constructor=Z_;Z_.prototype.$classData=q({o4:0},!1,"scala.collection.ClassTagSeqFactory$AnySeqDelegate",{o4:1,gba:1,d:1,Uf:1,l:1,Bk:1});function $_(){this.rl=null;this.rl=Pe()}$_.prototype=new KY;$_.prototype.constructor=$_;$_.prototype.$classData=q({r4:0},!1,"scala.collection.IndexedSeq$",{r4:1,jG:1,d:1,Bk:1,Uf:1,l:1});var a0;function b0(a,b,c){for(a=a.Ad();a.s();)b=c.aa(a.t(),b);return b}
-function c0(a,b){return a.Ob().Ib(d0(new e0,b,a))}function f0(a,b){return a.qc(g0(new h0,a,b))}function i0(a,b){return a.Ob().Ib(j0(new k0,a,b))}function zF(a){return a.ua(-1+a.K()|0)}function l0(a){return Qe(a,a.xh()+"(",", ",")")}function $r(a){return!!(a&&a.$classData&&a.$classData.pb.la)}function ho(a,b){this.cy=null;this.jv=0;this.nR=this.FK=null;if(null===a)throw null;this.FK=a;this.nR=b;this.cy=qq().Oa;this.jv=-1}ho.prototype=new zY;ho.prototype.constructor=ho;
-ho.prototype.s=function(){if(-1===this.jv){for(;!this.cy.s();){if(!this.FK.s())return this.jv=0,this.cy=qq().Oa,!1;this.cy=null;this.cy=this.nR.n(this.FK.t()).m();this.jv=-1}this.jv=1;return!0}return 1===this.jv};ho.prototype.t=function(){this.s()&&(this.jv=-1);return this.cy.t()};ho.prototype.$classData=q({z4:0},!1,"scala.collection.Iterator$$anon$10",{z4:1,Qa:1,d:1,Ha:1,M:1,N:1});function yr(a,b){this.GK=null;this.B4=b;this.VF=!1;this.HK=a}yr.prototype=new zY;yr.prototype.constructor=yr;
-yr.prototype.s=function(){return this.VF?!0:this.HK.s()?(this.GK=this.HK.t(),this.B4.n(this.GK)?this.VF=!0:this.HK=qq().Oa,this.VF):!1};yr.prototype.t=function(){return this.s()?(this.VF=!1,this.GK):qq().Oa.t()};yr.prototype.$classData=q({A4:0},!1,"scala.collection.Iterator$$anon$11",{A4:1,Qa:1,d:1,Ha:1,M:1,N:1});function m0(a,b){this.WF=this.XF=null;if(null===a)throw null;this.WF=a;this.XF=b.m()}m0.prototype=new zY;m0.prototype.constructor=m0;f=m0.prototype;
-f.Q=function(){var a=this.WF.Q(),b=this.XF.Q();return a<b?a:b};f.s=function(){return this.WF.s()&&this.XF.s()};f.Sm=function(){return G(new H,this.WF.t(),this.XF.t())};f.t=function(){return this.Sm()};f.$classData=q({C4:0},!1,"scala.collection.Iterator$$anon$14",{C4:1,Qa:1,d:1,Ha:1,M:1,N:1});function ko(a){this.ZF=0;this.YF=null;if(null===a)throw null;this.YF=a;this.ZF=0}ko.prototype=new zY;ko.prototype.constructor=ko;f=ko.prototype;f.Q=function(){return this.YF.Q()};f.s=function(){return this.YF.s()};
-f.Sm=function(){var a=G(new H,this.YF.t(),this.ZF);this.ZF=1+this.ZF|0;return a};f.t=function(){return this.Sm()};f.$classData=q({D4:0},!1,"scala.collection.Iterator$$anon$16",{D4:1,Qa:1,d:1,Ha:1,M:1,N:1});function UT(){}UT.prototype=new zY;UT.prototype.constructor=UT;f=UT.prototype;f.s=function(){return!1};f.Q=function(){return 0};f.fk=function(){return this};f.t=function(){throw iH("next on empty iterator");};
-f.$classData=q({E4:0},!1,"scala.collection.Iterator$$anon$19",{E4:1,Qa:1,d:1,Ha:1,M:1,N:1});function X_(a){this.G4=a;this.$F=!1}X_.prototype=new zY;X_.prototype.constructor=X_;X_.prototype.s=function(){return!this.$F};X_.prototype.t=function(){if(this.$F)return qq().Oa.t();this.$F=!0;return this.G4};X_.prototype.fk=function(a,b){return this.$F||0<a||0===b?qq().Oa:this};X_.prototype.$classData=q({F4:0},!1,"scala.collection.Iterator$$anon$20",{F4:1,Qa:1,d:1,Ha:1,M:1,N:1});function n0(a){this.J4=a}
-n0.prototype=new zY;n0.prototype.constructor=n0;n0.prototype.s=function(){return!0};n0.prototype.t=function(){return Zr(this.J4)};n0.prototype.$classData=q({I4:0},!1,"scala.collection.Iterator$$anon$27",{I4:1,Qa:1,d:1,Ha:1,M:1,N:1});function Gx(a,b,c){this.aG=null;this.bG=!1;this.pR=this.tB=null;this.oR=!1;if(null===a)throw null;this.tB=a;this.pR=b;this.oR=c;this.bG=!1}Gx.prototype=new zY;Gx.prototype.constructor=Gx;
-Gx.prototype.s=function(){if(!this.bG){if(!this.tB.s())return!1;for(this.aG=this.tB.t();!!this.pR.n(this.aG)===this.oR;){if(!this.tB.s())return!1;this.aG=this.tB.t()}this.bG=!0}return!0};Gx.prototype.t=function(){return this.s()?(this.bG=!1,this.aG):qq().Oa.t()};Gx.prototype.$classData=q({K4:0},!1,"scala.collection.Iterator$$anon$6",{K4:1,Qa:1,d:1,Ha:1,M:1,N:1});
-function Fx(a,b){this.uR=null;this.cG=!1;this.sR=this.JK=this.tR=null;if(null===a)throw null;this.JK=a;this.sR=b;this.uR=Gn();this.cG=!1}Fx.prototype=new zY;Fx.prototype.constructor=Fx;Fx.prototype.s=function(){for(;;){if(this.cG)return!0;if(this.JK.s()){var a=this.JK.t();if(this.uR.eh(this.sR.n(a)))return this.tR=a,this.cG=!0}else return!1}};Fx.prototype.t=function(){return this.s()?(this.cG=!1,this.tR):qq().Oa.t()};
-Fx.prototype.$classData=q({M4:0},!1,"scala.collection.Iterator$$anon$8",{M4:1,Qa:1,d:1,Ha:1,M:1,N:1});function eg(a,b){this.vR=this.dG=null;if(null===a)throw null;this.dG=a;this.vR=b}eg.prototype=new zY;eg.prototype.constructor=eg;eg.prototype.Q=function(){return this.dG.Q()};eg.prototype.s=function(){return this.dG.s()};eg.prototype.t=function(){return this.vR.n(this.dG.t())};eg.prototype.$classData=q({N4:0},!1,"scala.collection.Iterator$$anon$9",{N4:1,Qa:1,d:1,Ha:1,M:1,N:1});
-function OT(a){this.cm=a;this.gp=this.Vn=null;this.kv=!1}OT.prototype=new zY;OT.prototype.constructor=OT;
-OT.prototype.s=function(){if(this.kv)return!0;if(null!==this.cm){if(this.cm.s())return this.kv=!0;a:for(;;){if(null===this.Vn){this.gp=this.cm=null;var a=!1;break a}this.cm=Zr(this.Vn.Q4).m();this.gp===this.Vn&&(this.gp=this.gp.eG);for(this.Vn=this.Vn.eG;this.cm instanceof OT;)a=this.cm,this.cm=a.cm,this.kv=a.kv,null!==a.Vn&&(null===this.gp&&(this.gp=a.gp),a.gp.eG=this.Vn,this.Vn=a.Vn);if(this.kv){a=!0;break a}if(null!==this.cm&&this.cm.s()){a=this.kv=!0;break a}}return a}return!1};
-OT.prototype.t=function(){return this.s()?(this.kv=!1,this.cm.t()):qq().Oa.t()};OT.prototype.mb=function(a){a=new UG(a,null);null===this.Vn?this.Vn=a:this.gp.eG=a;this.gp=a;null===this.cm&&(this.cm=qq().Oa);return this};OT.prototype.$classData=q({O4:0},!1,"scala.collection.Iterator$ConcatIterator",{O4:1,Qa:1,d:1,Ha:1,M:1,N:1});function o0(a){for(;0<a.lv;)a.ey.s()?(a.ey.t(),a.lv=-1+a.lv|0):a.lv=0}function p0(a,b){if(0>a.Wn)return-1;a=a.Wn-b|0;return 0>a?0:a}
-function RT(a,b,c){this.ey=a;this.Wn=c;this.lv=b}RT.prototype=new zY;RT.prototype.constructor=RT;f=RT.prototype;f.Q=function(){var a=this.ey.Q();if(0>a)return-1;a=a-this.lv|0;a=0>a?0:a;if(0>this.Wn)return a;var b=this.Wn;return b<a?b:a};f.s=function(){o0(this);return 0!==this.Wn&&this.ey.s()};f.t=function(){o0(this);return 0<this.Wn?(this.Wn=-1+this.Wn|0,this.ey.t()):0>this.Wn?this.ey.t():qq().Oa.t()};
-f.fk=function(a,b){a=0<a?a:0;if(0>b)b=p0(this,a);else if(b<=a)b=0;else if(0>this.Wn)b=b-a|0;else{var c=p0(this,a);b=b-a|0;b=c<b?c:b}if(0===b)return qq().Oa;this.lv=this.lv+a|0;this.Wn=b;return this};f.$classData=q({R4:0},!1,"scala.collection.Iterator$SliceIterator",{R4:1,Qa:1,d:1,Ha:1,M:1,N:1});function RO(a,b){this.T4=b;this.KK=a;this.uB=null}RO.prototype=new zY;RO.prototype.constructor=RO;
-RO.prototype.s=function(){if(null===this.uB){var a=this.T4.n(this.KK);if(null===a)throw YK("null during unfold");this.uB=a;this.KK=null}return!this.uB.b()};RO.prototype.t=function(){if(this.s()){var a=this.uB.o();if(null===a)throw new x(a);var b=a.i();this.KK=a.j();this.uB=null;return b}return qq().Oa.t()};RO.prototype.$classData=q({S4:0},!1,"scala.collection.Iterator$UnfoldIterator",{S4:1,Qa:1,d:1,Ha:1,M:1,N:1});
-function q0(a){this.wR=this.MK=this.LK=null;if(null===a)throw null;this.wR=a;this.LK=a.fy.Sj.m();this.MK=a.fy.Tj.m()}q0.prototype=new zY;q0.prototype.constructor=q0;q0.prototype.s=function(){return this.LK.s()&&this.MK.s()};q0.prototype.t=function(){return this.wR.xR.aa(this.LK.t(),this.MK.t())};q0.prototype.$classData=q({W4:0},!1,"scala.collection.LazyZip2$$anon$1$$anon$2",{W4:1,Qa:1,d:1,Ha:1,M:1,N:1});
-function r0(a){for(;!a.fG.s()&&a.NK.s()&&a.OK.s();)a.fG=a.yR.zR.aa(a.NK.t(),a.OK.t()).m();return a.fG}function s0(a){this.yR=this.fG=this.OK=this.NK=null;if(null===a)throw null;this.yR=a;this.NK=a.mv.Sj.m();this.OK=a.mv.Tj.m();this.fG=qq().Oa}s0.prototype=new zY;s0.prototype.constructor=s0;s0.prototype.s=function(){return r0(this).s()};s0.prototype.t=function(){return r0(this).t()};s0.prototype.$classData=q({Y4:0},!1,"scala.collection.LazyZip2$$anon$3$$anon$4",{Y4:1,Qa:1,d:1,Ha:1,M:1,N:1});
-function t0(a){this.QK=this.PK=null;this.PK=a.gy.Sj.m();this.QK=a.gy.Tj.m()}t0.prototype=new zY;t0.prototype.constructor=t0;t0.prototype.s=function(){return this.PK.s()&&this.QK.s()};t0.prototype.Sm=function(){return G(new H,this.PK.t(),this.QK.t())};t0.prototype.t=function(){return this.Sm()};t0.prototype.$classData=q({$4:0},!1,"scala.collection.LazyZip2$$anon$7$$anon$8",{$4:1,Qa:1,d:1,Ha:1,M:1,N:1});
-function pv(a,b){var c=b.Q();if(0<=c)return a.$a(c);if(b&&b.$classData&&b.$classData.pb.gG){for(;;)if(a.b()?0:!b.b())a=a.g(),b=b.g();else break;a=!a.b();b=!b.b();return a===b?0:a?1:-1}for(b=b.m();;)if(!a.b()&&b.s())a=a.g(),b.t();else break;a=!a.b();b=b.s();return a===b?0:a?1:-1}function u0(a,b){return 0<=b&&0<a.$a(b)}function FA(a,b){if(0>b)throw KK(new LK,""+b);a=a.Cc(b);if(a.b())throw KK(new LK,""+b);return a.e()}function AA(a,b,c){for(;!a.b();)b=c.aa(b,a.e()),a=a.g();return b}
-function v0(a,b){if(b&&b.$classData&&b.$classData.pb.gG)a:for(;;){if(a===b){a=!0;break a}if((a.b()?0:!b.b())&&Ol(Pl(),a.e(),b.e()))a=a.g(),b=b.g();else{a=a.b()&&b.b();break a}}else a=RY(a,b);return a}function w0(a,b,c){var d=0<c?c:0;for(a=a.Cc(c);!a.b();){if(b.n(a.e()))return d;d=1+d|0;a=a.g()}return-1}function x0(a){this.WK=null;this.WK=a.m()}x0.prototype=new zY;x0.prototype.constructor=x0;x0.prototype.s=function(){return this.WK.s()};x0.prototype.t=function(){return this.WK.t().i()};
-x0.prototype.$classData=q({g5:0},!1,"scala.collection.MapOps$$anon$2",{g5:1,Qa:1,d:1,Ha:1,M:1,N:1});function iu(a){this.gt=null;this.gt=a.m()}iu.prototype=new zY;iu.prototype.constructor=iu;iu.prototype.s=function(){return this.gt.s()};iu.prototype.t=function(){return this.gt.t().j()};iu.prototype.$classData=q({h5:0},!1,"scala.collection.MapOps$$anon$3",{h5:1,Qa:1,d:1,Ha:1,M:1,N:1});
-function Eda(a){ky();var b=v(),c=ly(b);b=a.ZK;b=(b&&b.$classData&&b.$classData.pb.tc?b:b.hC()).Ga(new z(n=>{if(ja(c)!==ma(by)){var r=c.Y(n);if(r instanceof M)r=r.k;else if(R()===r)r=c.Of,cy(c,n,r,!1);else throw new x(r);}else{r=dy(W(),n);r^=r>>>16|0;var u=r&(-1+c.cb.a.length|0),w=c.cb.a[u];w=null===w?null:ey(w,n,r);if(null!==w)r=w.ph;else{w=c.cb;var y=c.Of;(1+c.Of|0)>=c.At&&fy(c,c.cb.a.length<<1);gy(c,n,y,!1,r,w===c.cb?u:r&(-1+c.cb.a.length|0));r=y}}return G(new H,n,r)}));var d=new z(n=>n.Lc()),e=
-dq();b=OY(b,d,e);d=ap();d=b.Gb(d.wa);if(null===d)throw new x(d);b=d.i();d=d.j();var g=new zd(c.Of);d.ya(new z(n=>{n|=0;g.a[n]=1+g.a[n]|0}));d=new zd(g.a.length);e=0;e=a.o5;var h=d.a.length;a=-1+h|0;if(!(0>=h))for(h=0;;){var k=h,l=e,m=g.a[k];d.a[k]=l<m?l:m;e=e-d.a[k]|0;if(h===a)break;h=1+h|0}a0||(a0=new $_);return new Ul((new zT(a0)).qc(b),g,d)}
-function NY(a,b){this.HR=this.em=this.lG=this.GR=this.mG=null;this.kG=!1;this.ZK=null;this.o5=b;if(null===a)throw null;this.ZK=a;a=Eda(this);if(null===a)throw new x(a);this.mG=new Ul(a.ec,a.gb,a.xd);this.GR=this.mG.ec;this.lG=this.mG.gb;this.em=this.mG.xd;a=this.lG;Rl();for(var c=b=0,d=new zd(1+a.a.length|0);c<a.a.length;)d.a[c]=b|0,b=(b|0)+a.a[c]|0,c=1+c|0;d.a[c]=b|0;this.HR=d;this.kG=!0}NY.prototype=new zY;NY.prototype.constructor=NY;NY.prototype.s=function(){return this.kG};
-NY.prototype.t=function(){this.kG||qq().Oa.t();var a=this.ZK.hi(),b=this.em.a.length,c=-1+b|0;if(!(0>=b))for(b=0;;){var d=b,e=this.em.a[d],g=-1+e|0;if(!(0>=e))for(e=0;;){var h=this.GR.ua(this.HR.a[d]+e|0);a.S(h);if(e===g)break;e=1+e|0}if(b===c)break;b=1+b|0}a=a.Eb();for(b=-1+this.em.a.length|0;0<=b&&this.em.a[b]===this.lG.a[b];)b=-1+b|0;c=this.em;b=-1+b|0;a:{d=-1+c.a.length|0;for(b=b<d?b:d;0<=b;){if(0<c.a[b])break a;b=-1+b|0}b=-1}if(0>b)this.kG=!1;else{c=1;for(d=1+b|0;d<this.em.a.length;)c=c+this.em.a[d]|
-0,d=1+d|0;d=b;this.em.a[d]=-1+this.em.a[d]|0;d=1+b|0;g=this.em.a.length;b=-1+g|0;if(!(d>=g))for(;;){g=d;e=c;h=this.lG.a[g];this.em.a[g]=e<h?e:h;c=c-this.em.a[g]|0;if(d===b)break;d=1+d|0}}return a};NY.prototype.$classData=q({n5:0},!1,"scala.collection.SeqOps$CombinationsItr",{n5:1,Qa:1,d:1,Ha:1,M:1,N:1});function y0(a,b){var c=$r(b)?new LT(a,b):a.m().mb(new U(()=>b.m()));return a.qc(c)}function z0(){this.et=null}z0.prototype=new wT;z0.prototype.constructor=z0;function A0(){}A0.prototype=z0.prototype;
-function lq(a){this.uG=a}lq.prototype=new zY;lq.prototype.constructor=lq;lq.prototype.s=function(){return!this.uG.b()};lq.prototype.t=function(){var a=this.uG.e();this.uG=this.uG.g();return a};lq.prototype.$classData=q({C5:0},!1,"scala.collection.StrictOptimizedLinearSeqOps$$anon$1",{C5:1,Qa:1,d:1,Ha:1,M:1,N:1});function eH(a,b){this.wG=a;this.H5=b;this.my=a.length;this.Xi=0}eH.prototype=new zY;eH.prototype.constructor=eH;eH.prototype.s=function(){return this.Xi<this.my};
-function fH(a){if(a.Xi>=a.my)a=qq().Oa.t();else{for(var b=a.Xi;;){if(a.Xi<a.my){var c=a.wG.charCodeAt(a.Xi);c=!(13===c||10===c)}else c=!1;if(c)a.Xi=1+a.Xi|0;else break}c=a.Xi;if(a.Xi<a.my){var d=a.wG.charCodeAt(a.Xi);a.Xi=1+a.Xi|0;if(a.Xi<a.my){var e=a.wG.charCodeAt(a.Xi);d=13===d&&10===e}else d=!1;d&&(a.Xi=1+a.Xi|0);a.H5||(c=a.Xi)}a=a.wG.substring(b,c)}return a}eH.prototype.t=function(){return fH(this)};
-eH.prototype.$classData=q({G5:0},!1,"scala.collection.StringOps$$anon$1",{G5:1,Qa:1,d:1,Ha:1,M:1,N:1});function zr(a){this.J5=a;this.xG=-1+a.length|0}zr.prototype=new zY;zr.prototype.constructor=zr;zr.prototype.s=function(){return 0<=this.xG};zr.prototype.t=function(){try{var a=this.J5.charCodeAt(this.xG);this.xG=-1+this.xG|0;var b=a}catch(c){if(c instanceof LK)b=Eb(qq().Oa.t());else throw c;}return hd(b)};
-zr.prototype.$classData=q({I5:0},!1,"scala.collection.StringOps$ReverseIterator",{I5:1,Qa:1,d:1,Ha:1,M:1,N:1});function B0(a,b){this.AB=null;this.BB=a;this.lL=b;this.qv=-1;this.jp=0}B0.prototype=new zY;B0.prototype.constructor=B0;B0.prototype.Q=function(){return this.qv};B0.prototype.s=function(){if(null===this.AB){var a=this.lL;for(this.AB=$u(256>a?a:256);this.jp<this.lL&&this.BB.s();)Ql(this.AB,this.BB.t()),this.jp=1+this.jp|0;this.BB.s()||(this.qv=0);this.jp=0}return 0!==this.qv};
-B0.prototype.t=function(){if(this.s()){var a=this.AB.ua(this.jp);-1===this.qv?(C0(this.AB,this.jp,this.BB.t()),this.BB.s()||(this.qv=0)):this.qv=-1+this.qv|0;this.jp=1+this.jp|0;this.jp===this.lL&&(this.jp=0);return a}return qq().Oa.t()};B0.prototype.$classData=q({S5:0},!1,"scala.collection.View$DropRightIterator",{S5:1,Qa:1,d:1,Ha:1,M:1,N:1});function D0(a){null!==a.IB&&(a.cr=tU(a.cr));a.IB=null}function YU(){this.cr=this.IB=null;this.cr=new JH(0,0,SF().mK,SF().mB,0,0)}YU.prototype=new p;
-YU.prototype.constructor=YU;f=YU.prototype;f.Pd=function(){};
-function JQ(a,b,c,d,e,g,h){if(b instanceof JH){var k=UH(pH(),g,h),l=VH(pH(),k);if(0!==(b.Bb&l)){var m=YH(pH(),b.Bb,k,l);a=b.uf(m);k=b.Jb(m);if(k===e&&Ol(Pl(),a,c))b.Xd.a[1+(m<<1)|0]=d;else{var n=b.Kf(m);m=HG(JG(),k);e=lU(b,a,n,k,m,c,d,e,g,5+h|0);oU(b,l,m,e)}}else if(0!==(b.kc&l))l=YH(pH(),b.kc,k,l),l=b.gh(l),k=l.ka(),m=l.pc(),JQ(a,l,c,d,e,g,5+h|0),b.bd=b.bd+(l.ka()-k|0)|0,b.ii=b.ii+(l.pc()-m|0)|0;else{h=b.di(l);k=h<<1;m=b.Xd;a=new jd(2+m.a.length|0);m.va(0,a,0,k);a.a[k]=c;a.a[1+k|0]=d;m.va(k,a,2+
-k|0,m.a.length-k|0);c=b.Pg;if(0>h)throw E0();if(h>c.a.length)throw E0();d=new zd(1+c.a.length|0);c.va(0,d,0,h);d.a[h]=e;c.va(h,d,1+h|0,c.a.length-h|0);b.Bb|=l;b.Xd=a;b.Pg=d;b.bd=1+b.bd|0;b.ii=b.ii+g|0}}else if(b instanceof qU)e=MU(b,c),b.bf=0>e?b.bf.Im(G(new H,c,d)):b.bf.qr(e,G(new H,c,d));else throw new x(b);}function WU(a){if(0===a.cr.bd)return Xy().br;null===a.IB&&(a.IB=new VU(a.cr));return a.IB}
-function F0(a,b){D0(a);var c=b.i();c=dy(W(),c);var d=HG(JG(),c);JQ(a,a.cr,b.i(),b.j(),c,d,0);return a}function G0(a,b,c){D0(a);var d=dy(W(),b);JQ(a,a.cr,b,c,d,HG(JG(),d),0);return a}function XU(a,b){D0(a);if(b instanceof VU)new IQ(a,b);else if(b instanceof FV)for(b=H0(b);b.s();){var c=b.t(),d=c.bk;d^=d>>>16|0;var e=HG(JG(),d);JQ(a,a.cr,c.Kk,c.ph,d,e,0)}else if(lV(b))b.Ag(new Um((g,h)=>G0(a,g,h)));else for(b=b.m();b.s();)F0(a,b.t());return a}f.oc=function(a){return XU(this,a)};
-f.S=function(a){return F0(this,a)};f.Eb=function(){return WU(this)};f.$classData=q({t6:0},!1,"scala.collection.immutable.HashMapBuilder",{t6:1,d:1,io:1,og:1,lf:1,kf:1});function eV(){this.dr=this.yv=null;this.dr=new lJ(0,0,SF().mK,SF().mB,0,0)}eV.prototype=new p;eV.prototype.constructor=eV;f=eV.prototype;f.Pd=function(){};
-function LQ(a,b,c,d,e,g){if(b instanceof lJ){var h=UH(pH(),e,g),k=VH(pH(),h);if(0!==(b.bb&k)){h=YH(pH(),b.bb,h,k);a=b.Yc(h);var l=b.Jb(h);l===d&&Ol(Pl(),a,c)?(d=b.di(k),b.Nc.a[d]=a):(h=HG(JG(),l),d=BU(b,a,l,h,c,d,e,5+g|0),EU(b,k,h,d))}else if(0!==(b.Pb&k))k=YH(pH(),b.Pb,h,k),k=b.Dh(k),h=k.ka(),l=k.pc(),LQ(a,k,c,d,e,5+g|0),b.Fb=b.Fb+(k.ka()-h|0)|0,b.Ae=b.Ae+(k.pc()-l|0)|0;else{g=b.di(k);h=b.Nc;a=new jd(1+h.a.length|0);h.va(0,a,0,g);a.a[g]=c;h.va(g,a,1+g|0,h.a.length-g|0);c=b.Cd;if(0>g)throw E0();if(g>
-c.a.length)throw E0();h=new zd(1+c.a.length|0);c.va(0,h,0,g);h.a[g]=d;c.va(g,h,1+g|0,c.a.length-g|0);b.bb|=k;b.Nc=a;b.Cd=h;b.Fb=1+b.Fb|0;b.Ae=b.Ae+e|0}}else if(b instanceof HU)d=uda(b.Bg,c),b.Bg=0>d?b.Bg.Im(c):b.Bg.qr(d,c);else throw new x(b);}function cV(a){if(0===a.dr.Fb)return fV().Zn;null===a.yv&&(a.yv=new aV(a.dr));return a.yv}function I0(a,b){null!==a.yv&&(a.dr=KU(a.dr));a.yv=null;var c=dy(W(),b),d=HG(JG(),c);LQ(a,a.dr,b,c,d,0);return a}
-function dV(a,b){null!==a.yv&&(a.dr=KU(a.dr));a.yv=null;if(b instanceof aV)new KQ(a,b);else for(b=b.m();b.s();)I0(a,b.t());return a}f.oc=function(a){return dV(this,a)};f.S=function(a){return I0(this,a)};f.Eb=function(){return cV(this)};f.$classData=q({x6:0},!1,"scala.collection.immutable.HashSetBuilder",{x6:1,d:1,io:1,og:1,lf:1,kf:1});function J0(){this.rl=null;this.rl=pK()}J0.prototype=new KY;J0.prototype.constructor=J0;function Oe(a,b){return K0(b)?b:JY.prototype.jl.call(a,b)}
-J0.prototype.Ib=function(a){return Oe(this,a)};J0.prototype.jl=function(a){return Oe(this,a)};J0.prototype.$classData=q({z6:0},!1,"scala.collection.immutable.IndexedSeq$",{z6:1,jG:1,d:1,Bk:1,Uf:1,l:1});var L0;function Pe(){L0||(L0=new J0);return L0}function jZ(){this.UR=this.ty=null;this.eg()}jZ.prototype=new p;jZ.prototype.constructor=jZ;f=jZ.prototype;f.Pd=function(){};f.eg=function(){var a=new DH;oK();this.UR=new eZ(new U(()=>EH(a)));this.ty=a};
-function Fda(a){GH(a.ty,new U(()=>jV()));return a.UR}function Gda(a,b){var c=new DH;GH(a.ty,new U(()=>{oK();oK();return new gV(b,new eZ(new U(()=>EH(c))))}));a.ty=c;return a}function Hda(a,b){if(0!==b.Q()){var c=new DH;GH(a.ty,new U(()=>hZ(oK(),b.m(),new U(()=>EH(c)))));a.ty=c}return a}f.oc=function(a){return Hda(this,a)};f.S=function(a){return Gda(this,a)};f.Eb=function(){return Fda(this)};f.$classData=q({E6:0},!1,"scala.collection.immutable.LazyList$LazyBuilder",{E6:1,d:1,io:1,og:1,lf:1,kf:1});
-function M0(a){this.JB=a}M0.prototype=new zY;M0.prototype.constructor=M0;M0.prototype.s=function(){return!this.JB.b()};M0.prototype.t=function(){if(this.JB.b())return qq().Oa.t();var a=fZ(this.JB).e();this.JB=fZ(this.JB).Cf();return a};M0.prototype.$classData=q({G6:0},!1,"scala.collection.immutable.LazyList$LazyIterator",{G6:1,Qa:1,d:1,Ha:1,M:1,N:1});function N0(){this.KB=this.LB=null;O0=this;this.LB=G(new H,v(),v());this.KB=new MQ}N0.prototype=new p;N0.prototype.constructor=N0;f=N0.prototype;
-f.wh=function(a){return le(v(),a)};f.Db=function(){return new Wo};f.U=function(){return v()};f.Ib=function(a){return le(v(),a)};f.$classData=q({N6:0},!1,"scala.collection.immutable.List$",{N6:1,d:1,it:1,Bk:1,Uf:1,l:1});var O0;function je(){O0||(O0=new N0);return O0}function P0(a,b){if(null===b)throw null;a.nt=b;a.np=0}function Q0(){this.np=0;this.nt=null}Q0.prototype=new zY;Q0.prototype.constructor=Q0;function R0(){}R0.prototype=Q0.prototype;Q0.prototype.s=function(){return 2>this.np};
-Q0.prototype.t=function(){switch(this.np){case 0:var a=this.qj(this.nt.Xj,this.nt.an);break;case 1:a=this.qj(this.nt.Yj,this.nt.bn);break;default:a=qq().Oa.t()}this.np=1+this.np|0;return a};Q0.prototype.fh=function(a){this.np=this.np+a|0;return this};function S0(a,b){if(null===b)throw null;a.op=b;a.pp=0}function T0(){this.pp=0;this.op=null}T0.prototype=new zY;T0.prototype.constructor=T0;function U0(){}U0.prototype=T0.prototype;T0.prototype.s=function(){return 3>this.pp};
-T0.prototype.t=function(){switch(this.pp){case 0:var a=this.qj(this.op.Yi,this.op.vl);break;case 1:a=this.qj(this.op.Ei,this.op.Ek);break;case 2:a=this.qj(this.op.Fi,this.op.Fk);break;default:a=qq().Oa.t()}this.pp=1+this.pp|0;return a};T0.prototype.fh=function(a){this.pp=this.pp+a|0;return this};function V0(a,b){if(null===b)throw null;a.cn=b;a.qp=0}function W0(){this.qp=0;this.cn=null}W0.prototype=new zY;W0.prototype.constructor=W0;function X0(){}X0.prototype=W0.prototype;
-W0.prototype.s=function(){return 4>this.qp};W0.prototype.t=function(){switch(this.qp){case 0:var a=this.qj(this.cn.Jh,this.cn.tj);break;case 1:a=this.qj(this.cn.mh,this.cn.Zi);break;case 2:a=this.qj(this.cn.Qg,this.cn.Gi);break;case 3:a=this.qj(this.cn.Rg,this.cn.Hi);break;default:a=qq().Oa.t()}this.qp=1+this.qp|0;return a};W0.prototype.fh=function(a){this.qp=this.qp+a|0;return this};function nV(){this.rp=null;this.vy=!1;this.ot=null;this.rp=Jf();this.vy=!1}nV.prototype=new p;
-nV.prototype.constructor=nV;f=nV.prototype;f.Pd=function(){};function mV(a,b){return a.vy?(XU(a.ot,b),a):cR(a,b)}f.oc=function(a){return mV(this,a)};f.S=function(a){var b=a.i();a=a.j();if(this.vy)G0(this.ot,b,a);else if(4>this.rp.ka())this.rp=this.rp.lm(b,a);else if(this.rp.L(b))this.rp=this.rp.lm(b,a);else{this.vy=!0;null===this.ot&&(this.ot=new YU);var c=this.rp;G0(G0(G0(G0(this.ot,c.Jh,c.tj),c.mh,c.Zi),c.Qg,c.Gi),c.Rg,c.Hi);G0(this.ot,b,a)}return this};
-f.Eb=function(){return this.vy?WU(this.ot):this.rp};f.$classData=q({d7:0},!1,"scala.collection.immutable.MapBuilderImpl",{d7:1,d:1,io:1,og:1,lf:1,kf:1});function Y0(a){this.$m=this.Gc=0;this.lh=null;this.ji=0;this.Xn=this.Ck=null;rH(this,a)}Y0.prototype=new tH;Y0.prototype.constructor=Y0;f=Y0.prototype;f.m=function(){return this};f.b=function(){return!this.s()};f.mb=function(a){return Cu(this,a)};f.qn=function(a){return PT(this,a)};f.fh=function(a){return QT(this,a,-1)};
-f.fk=function(a,b){return QT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.ya=function(a){KG(this,a)};f.ge=function(a,b){return NA(this,a,b)};f.Bi=function(a){return MG(this,a)};f.yc=function(a,b,c){return NG(this,a,b,c)};f.Ui=function(a){return PG(this,a)};f.Ti=function(a){return QG(this,a)};f.vh=function(a,b,c,d){return RG(this,a,b,c,d)};f.ea=function(){je();return le(v(),this)};f.Li=function(){return bp(cp(),this)};f.vj=function(a){return LA(this,a)};f.Rc=function(){return Eq(this)};
-f.Q=function(){return-1};f.t=function(){if(!this.s())throw NU();var a=this.lh.uf(this.Gc);this.Gc=1+this.Gc|0;return a};f.Ga=function(a){return new eg(this,a)};f.$classData=q({e7:0},!1,"scala.collection.immutable.MapKeyIterator",{e7:1,tv:1,d:1,Ha:1,M:1,N:1});function Z0(a){this.Wj=0;this.mt=null;this.Dk=0;this.vv=this.uv=null;this.tL=0;this.bS=null;wH(this,a);this.tL=0}Z0.prototype=new yH;Z0.prototype.constructor=Z0;f=Z0.prototype;f.m=function(){return this};f.b=function(){return!this.s()};
-f.mb=function(a){return Cu(this,a)};f.qn=function(a){return PT(this,a)};f.fh=function(a){return QT(this,a,-1)};f.fk=function(a,b){return QT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.ya=function(a){KG(this,a)};f.ge=function(a,b){return NA(this,a,b)};f.Bi=function(a){return MG(this,a)};f.yc=function(a,b,c){return NG(this,a,b,c)};f.Ui=function(a){return PG(this,a)};f.Ti=function(a){return QG(this,a)};f.vh=function(a,b,c,d){return RG(this,a,b,c,d)};f.ea=function(){je();return le(v(),this)};
-f.Li=function(){return bp(cp(),this)};f.vj=function(a){return LA(this,a)};f.Rc=function(){return Eq(this)};f.Q=function(){return-1};f.y=function(){var a=kL(),b=this.bS;return iL(a,this.tL,dy(W(),b))};f.Ga=function(a){return new eg(this,a)};f.t=function(){if(!this.s())throw NU();this.tL=this.mt.Jb(this.Wj);this.bS=this.mt.Kf(this.Wj);this.Wj=-1+this.Wj|0;return this};f.$classData=q({f7:0},!1,"scala.collection.immutable.MapKeyValueTupleHashIterator",{f7:1,RR:1,d:1,Ha:1,M:1,N:1});
-function $0(a){this.$m=this.Gc=0;this.lh=null;this.ji=0;this.Xn=this.Ck=null;rH(this,a)}$0.prototype=new tH;$0.prototype.constructor=$0;f=$0.prototype;f.m=function(){return this};f.b=function(){return!this.s()};f.mb=function(a){return Cu(this,a)};f.qn=function(a){return PT(this,a)};f.fh=function(a){return QT(this,a,-1)};f.fk=function(a,b){return QT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.ya=function(a){KG(this,a)};f.ge=function(a,b){return NA(this,a,b)};
-f.Bi=function(a){return MG(this,a)};f.yc=function(a,b,c){return NG(this,a,b,c)};f.Ui=function(a){return PG(this,a)};f.Ti=function(a){return QG(this,a)};f.vh=function(a,b,c,d){return RG(this,a,b,c,d)};f.ea=function(){je();return le(v(),this)};f.Li=function(){return bp(cp(),this)};f.vj=function(a){return LA(this,a)};f.Rc=function(){return Eq(this)};f.Q=function(){return-1};f.Sm=function(){if(!this.s())throw NU();var a=this.lh.Ru(this.Gc);this.Gc=1+this.Gc|0;return a};
-f.Ga=function(a){return new eg(this,a)};f.t=function(){return this.Sm()};f.$classData=q({g7:0},!1,"scala.collection.immutable.MapKeyValueTupleIterator",{g7:1,tv:1,d:1,Ha:1,M:1,N:1});function a1(a){this.Wj=0;this.mt=null;this.Dk=0;this.vv=this.uv=null;wH(this,a)}a1.prototype=new yH;a1.prototype.constructor=a1;f=a1.prototype;f.m=function(){return this};f.b=function(){return!this.s()};f.mb=function(a){return Cu(this,a)};f.qn=function(a){return PT(this,a)};f.fh=function(a){return QT(this,a,-1)};
-f.fk=function(a,b){return QT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.ya=function(a){KG(this,a)};f.ge=function(a,b){return NA(this,a,b)};f.Bi=function(a){return MG(this,a)};f.yc=function(a,b,c){return NG(this,a,b,c)};f.Ui=function(a){return PG(this,a)};f.Ti=function(a){return QG(this,a)};f.vh=function(a,b,c,d){return RG(this,a,b,c,d)};f.ea=function(){je();return le(v(),this)};f.Li=function(){return bp(cp(),this)};f.vj=function(a){return LA(this,a)};f.Rc=function(){return Eq(this)};
-f.Q=function(){return-1};f.Sm=function(){if(!this.s())throw NU();var a=this.mt.Ru(this.Wj);this.Wj=-1+this.Wj|0;return a};f.Ga=function(a){return new eg(this,a)};f.t=function(){return this.Sm()};f.$classData=q({h7:0},!1,"scala.collection.immutable.MapKeyValueTupleReverseIterator",{h7:1,RR:1,d:1,Ha:1,M:1,N:1});function b1(a){this.$m=this.Gc=0;this.lh=null;this.ji=0;this.Xn=this.Ck=null;rH(this,a)}b1.prototype=new tH;b1.prototype.constructor=b1;f=b1.prototype;f.m=function(){return this};f.b=function(){return!this.s()};
-f.mb=function(a){return Cu(this,a)};f.qn=function(a){return PT(this,a)};f.fh=function(a){return QT(this,a,-1)};f.fk=function(a,b){return QT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.ya=function(a){KG(this,a)};f.ge=function(a,b){return NA(this,a,b)};f.Bi=function(a){return MG(this,a)};f.yc=function(a,b,c){return NG(this,a,b,c)};f.Ui=function(a){return PG(this,a)};f.Ti=function(a){return QG(this,a)};f.vh=function(a,b,c,d){return RG(this,a,b,c,d)};f.ea=function(){je();return le(v(),this)};
-f.Li=function(){return bp(cp(),this)};f.vj=function(a){return LA(this,a)};f.Rc=function(){return Eq(this)};f.Q=function(){return-1};f.t=function(){if(!this.s())throw NU();var a=this.lh.Kf(this.Gc);this.Gc=1+this.Gc|0;return a};f.Ga=function(a){return new eg(this,a)};f.$classData=q({l7:0},!1,"scala.collection.immutable.MapValueIterator",{l7:1,tv:1,d:1,Ha:1,M:1,N:1});
-function c1(a){a.li<=a.Cg&&qq().Oa.t();a.Dv=1+a.Dv|0;for(var b=a.dS.oo(a.Dv);0===b.a.length;)a.Dv=1+a.Dv|0,b=a.dS.oo(a.Dv);a.CG=a.qt;var c=a.n7/2|0,d=a.Dv-c|0;a.Cv=(1+c|0)-(0>d?-d|0:d)|0;c=a.Cv;switch(c){case 1:a.$n=b;break;case 2:a.zv=b;break;case 3:a.Av=b;break;case 4:a.Bv=b;break;case 5:a.xy=b;break;case 6:a.uL=b;break;default:throw new x(c);}a.qt=a.CG+Math.imul(b.a.length,1<<Math.imul(5,-1+a.Cv|0))|0;a.qt>a.en&&(a.qt=a.en);1<a.Cv&&(a.MB=-1+(1<<Math.imul(5,a.Cv))|0)}
-function d1(a){var b=(a.Cg-a.li|0)+a.en|0;b===a.qt&&c1(a);if(1<a.Cv){b=b-a.CG|0;var c=a.MB^b;1024>c?a.$n=a.zv.a[31&(b>>>5|0)]:(32768>c?a.zv=a.Av.a[31&(b>>>10|0)]:(1048576>c?a.Av=a.Bv.a[31&(b>>>15|0)]:(33554432>c?a.Bv=a.xy.a[31&(b>>>20|0)]:(a.xy=a.uL.a[b>>>25|0],a.Bv=a.xy.a[0]),a.Av=a.Bv.a[0]),a.zv=a.Av.a[0]),a.$n=a.zv.a[0]);a.MB=b}a.li=a.li-a.Cg|0;b=a.$n.a.length;c=a.li;a.sp=b<c?b:c;a.Cg=0}
-function e1(a,b,c){this.uL=this.xy=this.Bv=this.Av=this.zv=null;this.dS=a;this.en=b;this.n7=c;this.$n=a.R;this.sp=this.$n.a.length;this.MB=this.Cg=0;this.li=this.en;this.Dv=0;this.Cv=1;this.CG=0;this.qt=this.sp}e1.prototype=new p;e1.prototype.constructor=e1;f=e1.prototype;f.m=function(){return this};f.b=function(){return this.li<=this.Cg};f.mb=function(a){return Cu(this,a)};f.fk=function(a,b){return QT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.ya=function(a){KG(this,a)};
-f.ge=function(a,b){return NA(this,a,b)};f.Bi=function(a){return MG(this,a)};f.Ui=function(a){return PG(this,a)};f.Ti=function(a){return QG(this,a)};f.vh=function(a,b,c,d){return RG(this,a,b,c,d)};f.ea=function(){je();return le(v(),this)};f.Li=function(){return bp(cp(),this)};f.vj=function(a){return LA(this,a)};f.Rc=function(){return Eq(this)};f.Q=function(){return this.li-this.Cg|0};f.s=function(){return this.li>this.Cg};
-f.t=function(){this.Cg===this.sp&&d1(this);var a=this.$n.a[this.Cg];this.Cg=1+this.Cg|0;return a};
-f.fh=function(a){if(0<a){a=((this.Cg-this.li|0)+this.en|0)+a|0;var b=this.en;a=a<b?a:b;if(a===this.en)this.sp=this.li=this.Cg=0;else{for(;a>=this.qt;)c1(this);b=a-this.CG|0;if(1<this.Cv){var c=this.MB^b;1024>c||(32768>c||(1048576>c||(33554432>c||(this.xy=this.uL.a[b>>>25|0]),this.Bv=this.xy.a[31&(b>>>20|0)]),this.Av=this.Bv.a[31&(b>>>15|0)]),this.zv=this.Av.a[31&(b>>>10|0)]);this.$n=this.zv.a[31&(b>>>5|0)];this.MB=b}this.sp=this.$n.a.length;this.Cg=31&b;this.li=this.Cg+(this.en-a|0)|0;this.sp>this.li&&
-(this.sp=this.li)}}return this};f.qn=function(a){a<(this.li-this.Cg|0)&&(a=(this.li-this.Cg|0)-(0>a?0:a)|0,this.en=this.en-a|0,this.li=this.li-a|0,this.li<this.sp&&(this.sp=this.li),this.en<this.qt&&(this.qt=this.en));return this};
-f.yc=function(a,b,c){var d=dG(eG(),a),e=this.li-this.Cg|0;c=c<e?c:e;d=d-b|0;d=c<d?c:d;d=0<d?d:0;c=0;for(e=a instanceof jd;c<d;){this.Cg===this.sp&&d1(this);var g=d-c|0,h=this.$n.a.length-this.Cg|0;g=g<h?g:h;e?this.$n.va(this.Cg,a,b+c|0,g):CG(zG(),this.$n,this.Cg,a,b+c|0,g);this.Cg=this.Cg+g|0;c=c+g|0}return d};f.Ga=function(a){return new eg(this,a)};f.$classData=q({m7:0},!1,"scala.collection.immutable.NewVectorIterator",{m7:1,d:1,Ha:1,M:1,N:1,vf:1});
-function f1(a,b,c,d){a.Ay=b;a.Gv=d;null===b?d=null:(d=-2+((32-Math.clz32(1+(2147483647&b.da)|0)|0)<<1)|0,d=new (Nd(iJ).Ja)(d));a.fn=d;a.Ed=0;if(c.b())b=g1(a,b);else if(b=c.o(),null===a.Ay)b=null;else a:for(c=a.Ay;;){if(null===c){if(0===a.Ed){b=null;break a}a.Ed=-1+a.Ed|0;b=a.fn.a[a.Ed];break a}a.Gv.Qj(b,c.Wa)?(a.fn.a[a.Ed]=c,a.Ed=1+a.Ed|0,c=c.ra):c=c.sa}a.zc=b}function h1(){this.fn=this.Gv=this.Ay=null;this.Ed=0;this.zc=null}h1.prototype=new zY;h1.prototype.constructor=h1;function i1(){}
-i1.prototype=h1.prototype;h1.prototype.s=function(){return null!==this.zc};h1.prototype.t=function(){var a=this.zc;return null!==a?(this.zc=g1(this,a.sa),this.gK(a)):qq().Oa.t()};function g1(a,b){for(;;){if(null===b){if(0===a.Ed)return null;a.Ed=-1+a.Ed|0;return a.fn.a[a.Ed]}if(null===b.ra)return b;a.fn.a[a.Ed]=b;a.Ed=1+a.Ed|0;b=b.ra}}function j1(){this.rl=null;this.rl=je()}j1.prototype=new KY;j1.prototype.constructor=j1;
-function k1(a,b){return b&&b.$classData&&b.$classData.pb.Dg?b:JY.prototype.jl.call(a,b)}j1.prototype.Ib=function(a){return k1(this,a)};j1.prototype.jl=function(a){return k1(this,a)};j1.prototype.$classData=q({D7:0},!1,"scala.collection.immutable.Seq$",{D7:1,jG:1,d:1,Bk:1,Uf:1,l:1});var l1;function nK(){l1||(l1=new j1);return l1}function vF(){this.Jv=null;this.QB=!1;this.Kv=null;this.Jv=Wp();this.QB=!1}vF.prototype=new p;vF.prototype.constructor=vF;f=vF.prototype;f.Pd=function(){};
-function tF(a){return a.QB?cV(a.Kv):a.Jv}function uF(a,b){if(a.QB)I0(a.Kv,b);else if(4>a.Jv.ka())a.Jv=a.Jv.Yb(b);else if(!a.Jv.L(b)){a.QB=!0;null===a.Kv&&(a.Kv=new eV);var c=a.Jv;a.Kv.S(c.ao).S(c.up).S(c.vp).S(c.wp);I0(a.Kv,b)}return a}function qV(a,b){return a.QB?(dV(a.Kv,b),a):cR(a,b)}f.oc=function(a){return qV(this,a)};f.S=function(a){return uF(this,a)};f.Eb=function(){return tF(this)};f.$classData=q({N7:0},!1,"scala.collection.immutable.SetBuilderImpl",{N7:1,d:1,io:1,og:1,lf:1,kf:1});
-function m1(a){this.$m=this.Gc=0;this.lh=null;this.ji=0;this.Xn=this.Ck=null;this.vL=0;rH(this,a);this.vL=0}m1.prototype=new tH;m1.prototype.constructor=m1;f=m1.prototype;f.m=function(){return this};f.b=function(){return!this.s()};f.mb=function(a){return Cu(this,a)};f.qn=function(a){return PT(this,a)};f.fh=function(a){return QT(this,a,-1)};f.fk=function(a,b){return QT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.ya=function(a){KG(this,a)};f.ge=function(a,b){return NA(this,a,b)};
-f.Bi=function(a){return MG(this,a)};f.yc=function(a,b,c){return NG(this,a,b,c)};f.Ui=function(a){return PG(this,a)};f.Ti=function(a){return QG(this,a)};f.vh=function(a,b,c,d){return RG(this,a,b,c,d)};f.ea=function(){je();return le(v(),this)};f.Li=function(){return bp(cp(),this)};f.vj=function(a){return LA(this,a)};f.Rc=function(){return Eq(this)};f.Q=function(){return-1};f.y=function(){return this.vL};f.t=function(){if(!this.s())throw NU();this.vL=this.lh.Jb(this.Gc);this.Gc=1+this.Gc|0;return this};
-f.Ga=function(a){return new eg(this,a)};f.$classData=q({O7:0},!1,"scala.collection.immutable.SetHashIterator",{O7:1,tv:1,d:1,Ha:1,M:1,N:1});function n1(a){this.$m=this.Gc=0;this.lh=null;this.ji=0;this.Xn=this.Ck=null;rH(this,a)}n1.prototype=new tH;n1.prototype.constructor=n1;f=n1.prototype;f.m=function(){return this};f.b=function(){return!this.s()};f.mb=function(a){return Cu(this,a)};f.qn=function(a){return PT(this,a)};f.fh=function(a){return QT(this,a,-1)};f.fk=function(a,b){return QT(this,a,b)};
-f.u=function(){return"\x3citerator\x3e"};f.ya=function(a){KG(this,a)};f.ge=function(a,b){return NA(this,a,b)};f.Bi=function(a){return MG(this,a)};f.yc=function(a,b,c){return NG(this,a,b,c)};f.Ui=function(a){return PG(this,a)};f.Ti=function(a){return QG(this,a)};f.vh=function(a,b,c,d){return RG(this,a,b,c,d)};f.ea=function(){je();return le(v(),this)};f.Li=function(){return bp(cp(),this)};f.vj=function(a){return LA(this,a)};f.Rc=function(){return Eq(this)};f.Q=function(){return-1};
-f.t=function(){if(!this.s())throw NU();var a=this.lh.Yc(this.Gc);this.Gc=1+this.Gc|0;return a};f.Ga=function(a){return new eg(this,a)};f.$classData=q({P7:0},!1,"scala.collection.immutable.SetIterator",{P7:1,tv:1,d:1,Ha:1,M:1,N:1});function o1(a){this.Wj=0;this.mt=null;this.Dk=0;this.vv=this.uv=null;wH(this,a)}o1.prototype=new yH;o1.prototype.constructor=o1;f=o1.prototype;f.m=function(){return this};f.b=function(){return!this.s()};f.mb=function(a){return Cu(this,a)};
-f.qn=function(a){return PT(this,a)};f.fh=function(a){return QT(this,a,-1)};f.fk=function(a,b){return QT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.ya=function(a){KG(this,a)};f.ge=function(a,b){return NA(this,a,b)};f.Bi=function(a){return MG(this,a)};f.yc=function(a,b,c){return NG(this,a,b,c)};f.Ui=function(a){return PG(this,a)};f.Ti=function(a){return QG(this,a)};f.vh=function(a,b,c,d){return RG(this,a,b,c,d)};f.ea=function(){je();return le(v(),this)};f.Li=function(){return bp(cp(),this)};
-f.vj=function(a){return LA(this,a)};f.Rc=function(){return Eq(this)};f.Q=function(){return-1};f.t=function(){if(!this.s())throw NU();var a=this.mt.Yc(this.Wj);this.Wj=-1+this.Wj|0;return a};f.Ga=function(a){return new eg(this,a)};f.$classData=q({S7:0},!1,"scala.collection.immutable.SetReverseIterator",{S7:1,RR:1,d:1,Ha:1,M:1,N:1});
-function p1(){this.oS=0;this.pS=null;q1=this;try{var a=zh(Ah(),"scala.collection.immutable.Vector.defaultApplyPreferredMaxLength","250");var b=BH(CH(),a,10)}catch(c){throw c;}this.oS=b;this.pS=new e1(qJ(),0,0)}p1.prototype=new p;p1.prototype.constructor=p1;f=p1.prototype;f.wh=function(a){return rU(0,a)};
-function rU(a,b){if(b instanceof r1)return b;a=b.Q();if(0===a)return qJ();if(0<a&&32>=a){a:{if(b instanceof $t){var c=b.Tf().jh();if(null!==c&&c===ma(Md)){b=b.Zm;break a}}IJ(b)?(a=new jd(a),b.yc(a,0,2147483647),b=a):(a=new jd(a),b.m().yc(a,0,2147483647),b=a)}return new rJ(b)}return QU(new PU,b).Vl()}f.Db=function(){return new PU};f.Ib=function(a){return rU(0,a)};f.U=function(){return qJ()};f.$classData=q({j8:0},!1,"scala.collection.immutable.Vector$",{j8:1,d:1,it:1,Bk:1,Uf:1,l:1});var q1;
-function pK(){q1||(q1=new p1);return q1}function s1(a,b){var c=b.a.length;if(0<c){32===a.Gd&&t1(a);var d=32-a.Gd|0;d=d<c?d:c;c=c-d|0;b.va(0,a.Ge,a.Gd,d);a.Gd=a.Gd+d|0;0<c&&(t1(a),b.va(d,a.Ge,0,c),a.Gd=a.Gd+c|0)}}function Ida(a,b){for(var c=b.rn(),d=0;d<c;){var e=b.oo(d),g=c/2|0,h=d-g|0;g=(1+g|0)-(0>h?-h|0:h)|0;1===g?s1(a,e):EJ(sJ(),-2+g|0,e,new z(k=>{s1(a,k)}));d=1+d|0}return a}
-function t1(a){var b=32+a.mi|0,c=b^a.mi;a.mi=b;a.Gd=0;if(1024>c)1===a.ng&&(a.id=new (Nd(Nd(Md)).Ja)(32),a.id.a[0]=a.Ge,a.ng=1+a.ng|0),a.Ge=new jd(32),a.id.a[31&(b>>>5|0)]=a.Ge;else if(32768>c)2===a.ng&&(a.Yd=new (Nd(Nd(Nd(Md))).Ja)(32),a.Yd.a[0]=a.id,a.ng=1+a.ng|0),a.Ge=new jd(32),a.id=new (Nd(Nd(Md)).Ja)(32),a.id.a[31&(b>>>5|0)]=a.Ge,a.Yd.a[31&(b>>>10|0)]=a.id;else if(1048576>c)3===a.ng&&(a.zf=new (Nd(Nd(Nd(Nd(Md)))).Ja)(32),a.zf.a[0]=a.Yd,a.ng=1+a.ng|0),a.Ge=new jd(32),a.id=new (Nd(Nd(Md)).Ja)(32),
-a.Yd=new (Nd(Nd(Nd(Md))).Ja)(32),a.id.a[31&(b>>>5|0)]=a.Ge,a.Yd.a[31&(b>>>10|0)]=a.id,a.zf.a[31&(b>>>15|0)]=a.Yd;else if(33554432>c)4===a.ng&&(a.Gg=new (Nd(Nd(Nd(Nd(Nd(Md))))).Ja)(32),a.Gg.a[0]=a.zf,a.ng=1+a.ng|0),a.Ge=new jd(32),a.id=new (Nd(Nd(Md)).Ja)(32),a.Yd=new (Nd(Nd(Nd(Md))).Ja)(32),a.zf=new (Nd(Nd(Nd(Nd(Md)))).Ja)(32),a.id.a[31&(b>>>5|0)]=a.Ge,a.Yd.a[31&(b>>>10|0)]=a.id,a.zf.a[31&(b>>>15|0)]=a.Yd,a.Gg.a[31&(b>>>20|0)]=a.zf;else if(1073741824>c)5===a.ng&&(a.Ki=new (Nd(Nd(Nd(Nd(Nd(Nd(Md)))))).Ja)(64),
-a.Ki.a[0]=a.Gg,a.ng=1+a.ng|0),a.Ge=new jd(32),a.id=new (Nd(Nd(Md)).Ja)(32),a.Yd=new (Nd(Nd(Nd(Md))).Ja)(32),a.zf=new (Nd(Nd(Nd(Nd(Md)))).Ja)(32),a.Gg=new (Nd(Nd(Nd(Nd(Nd(Md))))).Ja)(32),a.id.a[31&(b>>>5|0)]=a.Ge,a.Yd.a[31&(b>>>10|0)]=a.id,a.zf.a[31&(b>>>15|0)]=a.Yd,a.Gg.a[31&(b>>>20|0)]=a.zf,a.Ki.a[31&(b>>>25|0)]=a.Gg;else throw dk("advance1("+b+", "+c+"): a1\x3d"+a.Ge+", a2\x3d"+a.id+", a3\x3d"+a.Yd+", a4\x3d"+a.zf+", a5\x3d"+a.Gg+", a6\x3d"+a.Ki+", depth\x3d"+a.ng);}
-function PU(){this.Ge=this.id=this.Yd=this.zf=this.Gg=this.Ki=null;this.ng=this.wl=this.mi=this.Gd=0;this.Ge=new jd(32);this.wl=this.mi=this.Gd=0;this.ng=1}PU.prototype=new p;PU.prototype.constructor=PU;f=PU.prototype;f.Pd=function(){};function Jda(a,b){a.ng=1;var c=b.a.length;a.Gd=31&c;a.mi=c-a.Gd|0;a.Ge=32===b.a.length?b:ck(fk(),b,0,32);0===a.Gd&&0<a.mi&&(a.Gd=32,a.mi=-32+a.mi|0)}
-function u1(a,b){var c=b.rn();switch(c){case 0:break;case 1:a.ng=1;c=b.R.a.length;a.Gd=31&c;a.mi=c-a.Gd|0;b=b.R;a.Ge=32===b.a.length?b:ck(fk(),b,0,32);break;case 3:c=b.nh;var d=b.$;a.Ge=32===d.a.length?d:ck(fk(),d,0,32);a.ng=2;a.wl=32-b.Ji|0;d=b.ba+a.wl|0;a.Gd=31&d;a.mi=d-a.Gd|0;a.id=new (Nd(Nd(Md)).Ja)(32);a.id.a[0]=b.R;c.va(0,a.id,1,c.a.length);a.id.a[1+c.a.length|0]=a.Ge;break;case 5:c=b.Vf;d=b.kg;var e=b.$;a.Ge=32===e.a.length?e:ck(fk(),e,0,32);a.ng=3;a.wl=1024-b.oh|0;e=b.ba+a.wl|0;a.Gd=31&e;
-a.mi=e-a.Gd|0;a.Yd=new (Nd(Nd(Nd(Md))).Ja)(32);a.Yd.a[0]=DJ(sJ(),b.R,b.Mh);c.va(0,a.Yd,1,c.a.length);a.id=Tj(fk(),d,32);a.Yd.a[1+c.a.length|0]=a.id;a.id.a[d.a.length]=a.Ge;break;case 7:c=b.De;d=b.df;e=b.cf;var g=b.$;a.Ge=32===g.a.length?g:ck(fk(),g,0,32);a.ng=4;a.wl=32768-b.Wf|0;g=b.ba+a.wl|0;a.Gd=31&g;a.mi=g-a.Gd|0;a.zf=new (Nd(Nd(Nd(Nd(Md)))).Ja)(32);a.zf.a[0]=DJ(sJ(),DJ(sJ(),b.R,b.lg),b.mg);c.va(0,a.zf,1,c.a.length);a.Yd=Tj(fk(),d,32);a.id=Tj(fk(),e,32);a.zf.a[1+c.a.length|0]=a.Yd;a.Yd.a[d.a.length]=
-a.id;a.id.a[e.a.length]=a.Ge;break;case 9:c=b.Fd;d=b.Od;e=b.Nd;g=b.Md;var h=b.$;a.Ge=32===h.a.length?h:ck(fk(),h,0,32);a.ng=5;a.wl=1048576-b.Ee|0;h=b.ba+a.wl|0;a.Gd=31&h;a.mi=h-a.Gd|0;a.Gg=new (Nd(Nd(Nd(Nd(Nd(Md))))).Ja)(32);a.Gg.a[0]=DJ(sJ(),DJ(sJ(),DJ(sJ(),b.R,b.ef),b.ff),b.gf);c.va(0,a.Gg,1,c.a.length);a.zf=Tj(fk(),d,32);a.Yd=Tj(fk(),e,32);a.id=Tj(fk(),g,32);a.Gg.a[1+c.a.length|0]=a.zf;a.zf.a[d.a.length]=a.Yd;a.Yd.a[e.a.length]=a.id;a.id.a[g.a.length]=a.Ge;break;case 11:c=b.hd;d=b.sd;e=b.rd;g=
-b.qd;h=b.pd;var k=b.$;a.Ge=32===k.a.length?k:ck(fk(),k,0,32);a.ng=6;a.wl=33554432-b.ie|0;k=b.ba+a.wl|0;a.Gd=31&k;a.mi=k-a.Gd|0;a.Ki=new (Nd(Nd(Nd(Nd(Nd(Nd(Md)))))).Ja)(32);a.Ki.a[0]=DJ(sJ(),DJ(sJ(),DJ(sJ(),DJ(sJ(),b.R,b.je),b.ke),b.le),b.me);c.va(0,a.Ki,1,c.a.length);a.Gg=Tj(fk(),d,32);a.zf=Tj(fk(),e,32);a.Yd=Tj(fk(),g,32);a.id=Tj(fk(),h,32);a.Ki.a[1+c.a.length|0]=a.Gg;a.Gg.a[d.a.length]=a.zf;a.zf.a[e.a.length]=a.Yd;a.Yd.a[g.a.length]=a.id;a.id.a[h.a.length]=a.Ge;break;default:throw new x(c);}0===
-a.Gd&&0<a.mi&&(a.Gd=32,a.mi=-32+a.mi|0);return a}function RU(a,b){32===a.Gd&&t1(a);a.Ge.a[a.Gd]=b;a.Gd=1+a.Gd|0;return a}function QU(a,b){return b instanceof r1?0===a.Gd&&0===a.mi?u1(a,b):Ida(a,b):cR(a,b)}
-f.Vl=function(){var a=this.Gd+this.mi|0,b=a-this.wl|0;if(0===b)return pK(),qJ();if(32>=a){if(32===b)return new rJ(this.Ge);var c=this.Ge;return new rJ(Tj(fk(),c,b))}if(1024>=a){var d=31&(-1+a|0),e=(-1+a|0)>>>5|0,g=this.id,h=ck(fk(),g,1,e),k=this.id.a[0],l=this.id.a[e],m=1+d|0,n=l.a.length===m?l:Tj(fk(),l,m);return new tJ(k,32-this.wl|0,h,n,b)}if(32768>=a){var r=31&(-1+a|0),u=31&((-1+a|0)>>>5|0),w=(-1+a|0)>>>10|0,y=this.Yd,B=ck(fk(),y,1,w),D=this.Yd.a[0],C=D.a.length,F=ck(fk(),D,1,C),I=this.Yd.a[0].a[0],
-K=this.Yd.a[w],N=Tj(fk(),K,u),P=this.Yd.a[w].a[u],T=1+r|0,aa=P.a.length===T?P:Tj(fk(),P,T),Y=I.a.length;return new uJ(I,Y,F,Y+(F.a.length<<5)|0,B,N,aa,b)}if(1048576>=a){var S=31&(-1+a|0),Z=31&((-1+a|0)>>>5|0),ka=31&((-1+a|0)>>>10|0),X=(-1+a|0)>>>15|0,sa=this.zf,Ia=ck(fk(),sa,1,X),Za=this.zf.a[0],Ga=Za.a.length,xa=ck(fk(),Za,1,Ga),Ra=this.zf.a[0].a[0],Ja=Ra.a.length,La=ck(fk(),Ra,1,Ja),pb=this.zf.a[0].a[0].a[0],Fb=this.zf.a[X],Gb=Tj(fk(),Fb,ka),Hb=this.zf.a[X].a[ka],tb=Tj(fk(),Hb,Z),kb=this.zf.a[X].a[ka].a[Z],
-gb=1+S|0,Vb=kb.a.length===gb?kb:Tj(fk(),kb,gb),bb=pb.a.length,nb=bb+(La.a.length<<5)|0;return new vJ(pb,bb,La,nb,xa,nb+(xa.a.length<<10)|0,Ia,Gb,tb,Vb,b)}if(33554432>=a){var Tb=31&(-1+a|0),ub=31&((-1+a|0)>>>5|0),Ub=31&((-1+a|0)>>>10|0),$a=31&((-1+a|0)>>>15|0),cb=(-1+a|0)>>>20|0,Na=this.Gg,Ca=ck(fk(),Na,1,cb),Ba=this.Gg.a[0],Oa=Ba.a.length,wa=ck(fk(),Ba,1,Oa),ea=this.Gg.a[0].a[0],la=ea.a.length,Ka=ck(fk(),ea,1,la),Ua=this.Gg.a[0].a[0].a[0],ya=Ua.a.length,ib=ck(fk(),Ua,1,ya),Lb=this.Gg.a[0].a[0].a[0].a[0],
-ec=this.Gg.a[cb],Mb=Tj(fk(),ec,$a),Jb=this.Gg.a[cb].a[$a],Kb=Tj(fk(),Jb,Ub),eb=this.Gg.a[cb].a[$a].a[Ub],Wb=Tj(fk(),eb,ub),mc=this.Gg.a[cb].a[$a].a[Ub].a[ub],ua=1+Tb|0,Pa=mc.a.length===ua?mc:Tj(fk(),mc,ua),xb=Lb.a.length,Yb=xb+(ib.a.length<<5)|0,zb=Yb+(Ka.a.length<<10)|0;return new wJ(Lb,xb,ib,Yb,Ka,zb,wa,zb+(wa.a.length<<15)|0,Ca,Mb,Kb,Wb,Pa,b)}var Sb=31&(-1+a|0),Ma=31&((-1+a|0)>>>5|0),Ea=31&((-1+a|0)>>>10|0),ab=31&((-1+a|0)>>>15|0),Db=31&((-1+a|0)>>>20|0),mb=(-1+a|0)>>>25|0,vb=this.Ki,Ya=ck(fk(),
-vb,1,mb),Wa=this.Ki.a[0],rb=Wa.a.length,pa=ck(fk(),Wa,1,rb),Fa=this.Ki.a[0].a[0],Ib=Fa.a.length,qb=ck(fk(),Fa,1,Ib),Nb=this.Ki.a[0].a[0].a[0],fc=Nb.a.length,Ac=ck(fk(),Nb,1,fc),tc=this.Ki.a[0].a[0].a[0].a[0],vc=tc.a.length,sc=ck(fk(),tc,1,vc),uc=this.Ki.a[0].a[0].a[0].a[0].a[0],lc=this.Ki.a[mb],Wc=Tj(fk(),lc,Db),Cc=this.Ki.a[mb].a[Db],Dc=Tj(fk(),Cc,ab),Ec=this.Ki.a[mb].a[Db].a[ab],Ic=Tj(fk(),Ec,Ea),Xc=this.Ki.a[mb].a[Db].a[ab].a[Ea],Sc=Tj(fk(),Xc,Ma),oc=this.Ki.a[mb].a[Db].a[ab].a[Ea].a[Ma],qc=1+
-Sb|0,Tc=oc.a.length===qc?oc:Tj(fk(),oc,qc),Nc=uc.a.length,Pc=Nc+(sc.a.length<<5)|0,Oc=Pc+(Ac.a.length<<10)|0,$c=Oc+(qb.a.length<<15)|0;return new xJ(uc,Nc,sc,Pc,Ac,Oc,qb,$c,pa,$c+(pa.a.length<<20)|0,Ya,Wc,Dc,Ic,Sc,Tc,b)};f.u=function(){return"VectorBuilder(len1\x3d"+this.Gd+", lenRest\x3d"+this.mi+", offset\x3d"+this.wl+", depth\x3d"+this.ng+")"};f.Eb=function(){return this.Vl()};f.oc=function(a){return QU(this,a)};f.S=function(a){return RU(this,a)};
-f.$classData=q({r8:0},!1,"scala.collection.immutable.VectorBuilder",{r8:1,d:1,io:1,og:1,lf:1,kf:1});function v1(){}v1.prototype=new p;v1.prototype.constructor=v1;f=v1.prototype;f.wh=function(a){return yF(a)};function yF(a){var b=a.Q();if(0<=b){var c=new jd(16<b?b:16);$r(a)?a.yc(c,0,2147483647):a.m().yc(c,0,2147483647);return w1(new x1,c,b)}return Zu(Nl(),a)}f.Db=function(){return new kF};f.U=function(){return Nl()};f.Ib=function(a){return yF(a)};
-f.$classData=q({y8:0},!1,"scala.collection.mutable.ArrayBuffer$",{y8:1,d:1,it:1,Bk:1,Uf:1,l:1});var y1;function xF(){y1||(y1=new v1);return y1}function kF(){this.ak=null;RV(this,Nl())}kF.prototype=new CZ;kF.prototype.constructor=kF;kF.prototype.Pd=function(a){z1(this.ak,a)};kF.prototype.$classData=q({z8:0},!1,"scala.collection.mutable.ArrayBuffer$$anon$1",{z8:1,VB:1,d:1,og:1,lf:1,kf:1});function A1(){}A1.prototype=new p;A1.prototype.constructor=A1;f=A1.prototype;f.wh=function(a){return B1(a)};
-function B1(a){var b=a.Q();if(0<=b){var c=C1(0,b);$r(a)?a.yc(c,0,2147483647):a.m().yc(c,0,2147483647);return D1(new E1,c,0,b)}return xU(F1(),a)}f.Db=function(){return new G1};function C1(a,b){if(!(0<=b))throw dk("requirement failed: Non-negative array size required");a=(-2147483648>>>Math.clz32(b)|0)<<1;if(!(0<=a))throw dk("requirement failed: ArrayDeque too big - cannot allocate ArrayDeque of length "+b);return new jd(16<a?a:16)}f.U=function(){return F1()};f.Ib=function(a){return B1(a)};
-f.$classData=q({C8:0},!1,"scala.collection.mutable.ArrayDeque$",{C8:1,d:1,it:1,Bk:1,Uf:1,l:1});var H1;function I1(){H1||(H1=new A1);return H1}function G1(){this.ak=null;RV(this,F1())}G1.prototype=new CZ;G1.prototype.constructor=G1;G1.prototype.Pd=function(a){var b=this.ak;a>((b.ne-b.Hd|0)&(-1+b.ac.a.length|0))&&a>=b.ac.a.length&&J1(b,a)};G1.prototype.$classData=q({D8:0},!1,"scala.collection.mutable.ArrayDeque$$anon$1",{D8:1,VB:1,d:1,og:1,lf:1,kf:1});function K1(){this.rl=null;this.rl=L1()}
-K1.prototype=new KY;K1.prototype.constructor=K1;K1.prototype.$classData=q({P8:0},!1,"scala.collection.mutable.Buffer$",{P8:1,jG:1,d:1,Bk:1,Uf:1,l:1});var M1;function iE(){M1||(M1=new K1);return M1}function GV(a,b){this.ak=null;RV(this,EV(new FV,a,b))}GV.prototype=new CZ;GV.prototype.constructor=GV;GV.prototype.Pd=function(a){this.ak.Pd(a)};GV.prototype.$classData=q({f9:0},!1,"scala.collection.mutable.HashMap$$anon$6",{f9:1,VB:1,d:1,og:1,lf:1,kf:1});
-function N1(a,b){if(null===b)throw null;a.Tv=b;a.xp=0;a.fo=null;a.Uv=b.cb.a.length}function O1(){this.xp=0;this.fo=null;this.Uv=0;this.Tv=null}O1.prototype=new zY;O1.prototype.constructor=O1;function P1(){}P1.prototype=O1.prototype;O1.prototype.s=function(){if(null!==this.fo)return!0;for(;this.xp<this.Uv;){var a=this.Tv.cb.a[this.xp];this.xp=1+this.xp|0;if(null!==a)return this.fo=a,!0}return!1};O1.prototype.t=function(){if(this.s()){var a=this.PA(this.fo);this.fo=this.fo.Id;return a}return qq().Oa.t()};
-function NV(a,b){this.ak=null;RV(this,LV(new MV,a,b))}NV.prototype=new CZ;NV.prototype.constructor=NV;NV.prototype.Pd=function(a){this.ak.Pd(a)};NV.prototype.$classData=q({m9:0},!1,"scala.collection.mutable.HashSet$$anon$4",{m9:1,VB:1,d:1,og:1,lf:1,kf:1});function Q1(a,b){if(null===b)throw null;a.WB=b;a.Bt=0;a.jr=null;a.XB=b.Af.a.length}function R1(){this.Bt=0;this.jr=null;this.XB=0;this.WB=null}R1.prototype=new zY;R1.prototype.constructor=R1;function S1(){}S1.prototype=R1.prototype;
-R1.prototype.s=function(){if(null!==this.jr)return!0;for(;this.Bt<this.XB;){var a=this.WB.Af.a[this.Bt];this.Bt=1+this.Bt|0;if(null!==a)return this.jr=a,!0}return!1};R1.prototype.t=function(){if(this.s()){var a=this.kJ(this.jr);this.jr=this.jr.He;return a}return qq().Oa.t()};function T1(){this.YB=null}T1.prototype=new p;T1.prototype.constructor=T1;function U1(){}U1.prototype=T1.prototype;T1.prototype.Pd=function(){};T1.prototype.oc=function(a){return cR(this,a)};T1.prototype.Eb=function(){return this.YB};
-function V1(){this.rl=null;this.rl=xF()}V1.prototype=new KY;V1.prototype.constructor=V1;V1.prototype.$classData=q({r9:0},!1,"scala.collection.mutable.IndexedSeq$",{r9:1,jG:1,d:1,Bk:1,Uf:1,l:1});var W1;function Qz(a){this.ZB=a.kn}Qz.prototype=new zY;Qz.prototype.constructor=Qz;Qz.prototype.s=function(){return null!==this.ZB};Qz.prototype.Sm=function(){if(this.s()){var a=G(new H,this.ZB.Wv,this.ZB.jn);this.ZB=this.ZB.gm;return a}return qq().Oa.t()};Qz.prototype.t=function(){return this.Sm()};
-Qz.prototype.$classData=q({w9:0},!1,"scala.collection.mutable.LinkedHashMap$$anon$2",{w9:1,Qa:1,d:1,Ha:1,M:1,N:1});function X1(a){this.OG=a.kn}X1.prototype=new zY;X1.prototype.constructor=X1;X1.prototype.s=function(){return null!==this.OG};X1.prototype.t=function(){if(this.s()){var a=this.OG.Wv;this.OG=this.OG.gm;return a}return qq().Oa.t()};X1.prototype.$classData=q({x9:0},!1,"scala.collection.mutable.LinkedHashMap$$anon$3",{x9:1,Qa:1,d:1,Ha:1,M:1,N:1});function Y1(a){this.PG=a.kn}Y1.prototype=new zY;
-Y1.prototype.constructor=Y1;Y1.prototype.s=function(){return null!==this.PG};Y1.prototype.t=function(){if(this.s()){var a=this.PG.jn;this.PG=this.PG.gm;return a}return qq().Oa.t()};Y1.prototype.$classData=q({y9:0},!1,"scala.collection.mutable.LinkedHashMap$$anon$4",{y9:1,Qa:1,d:1,Ha:1,M:1,N:1});function Z1(a){this.QG=a.Jy}Z1.prototype=new zY;Z1.prototype.constructor=Z1;Z1.prototype.s=function(){return null!==this.QG};Z1.prototype.t=function(){if(this.s()){var a=this.QG.$B;this.QG=this.QG.kr;return a}return qq().Oa.t()};
-Z1.prototype.$classData=q({E9:0},!1,"scala.collection.mutable.LinkedHashSet$$anon$2",{E9:1,Qa:1,d:1,Ha:1,M:1,N:1});function $1(){}$1.prototype=new p;$1.prototype.constructor=$1;f=$1.prototype;f.wh=function(a){return Vo(new Wo,a)};f.Db=function(){return RV(new SV,new Wo)};f.U=function(){return new Wo};f.Ib=function(a){return Vo(new Wo,a)};f.$classData=q({H9:0},!1,"scala.collection.mutable.ListBuffer$",{H9:1,d:1,it:1,Bk:1,Uf:1,l:1});var a2;function b2(){a2||(a2=new $1);return a2}
-function c2(a,b){this.OS=0;this.PS=a;this.L9=b;this.OS=Zr(b)|0}c2.prototype=new zY;c2.prototype.constructor=c2;c2.prototype.s=function(){WJ();var a=this.OS,b=Zr(this.L9)|0;TJ(a,b);return this.PS.s()};c2.prototype.t=function(){return this.PS.t()};c2.prototype.$classData=q({K9:0},!1,"scala.collection.mutable.MutationTracker$CheckedIterator",{K9:1,Qa:1,d:1,Ha:1,M:1,N:1});function d2(){}d2.prototype=new p;d2.prototype.constructor=d2;f=d2.prototype;f.wh=function(a){return xU(new vU(16),a)};
-f.Db=function(){return RV(new SV,new vU(16))};f.U=function(){return new vU(16)};f.Ib=function(a){return xU(new vU(16),a)};f.$classData=q({N9:0},!1,"scala.collection.mutable.Queue$",{N9:1,d:1,it:1,Bk:1,Uf:1,l:1});var e2;function f2(){e2||(e2=new d2);return e2}function g2(a){!a.Ky.b()&&null!==a.yp&&0<=a.fC.Fa(a.yp.ho,a.Ky.o())&&(a.yp=null)}
-function h2(a,b,c,d,e){a.Ky=d;a.fC=e;if(R()===c)gK(),e=b.ni,e=null===e?null:dK(e);else{if(!(c instanceof M))throw new x(c);c=c.k;gK();d=b.ni;if(null===d)e=null;else{b=null;for(var g=1;null!==d&&0!==g;)b=d,g=e.Fa(c,d.ho),d=0>g?d.Oc:d.uc;e=0>=g?b:eK(0,b)}}a.yp=e;g2(a)}function i2(){this.yp=this.fC=this.Ky=null}i2.prototype=new zY;i2.prototype.constructor=i2;function j2(){}j2.prototype=i2.prototype;i2.prototype.s=function(){return null!==this.yp};
-i2.prototype.t=function(){var a=this.yp;if(null===a)throw iH("next on empty iterator");this.yp=eK(gK(),a);g2(this);return this.hK(a)};function k2(){}k2.prototype=new p;k2.prototype.constructor=k2;f=k2.prototype;f.wh=function(a){return xU(new NX(16),a)};f.Db=function(){return RV(new SV,new NX(16))};f.U=function(){return new NX(16)};f.Ib=function(a){return xU(new NX(16),a)};f.$classData=q({b$:0},!1,"scala.collection.mutable.Stack$",{b$:1,d:1,it:1,Bk:1,Uf:1,l:1});var l2;
-function m2(){l2||(l2=new k2);return l2}function n2(a,b,c){return 0===a.Fa(b,c)}function o2(a,b,c){return a.xk(b,c)?b:c}function p2(a,b,c){return a.Qj(b,c)?b:c}function q2(a,b){return b instanceof r2?(b=b.Vm,null!==b&&b.h(a)):!1}var Lda=function Kda(a,b){return Eg(b)?"Array["+Kda(a,Gg(b))+"]":b.ei.name};class jX extends gq{constructor(a){super();fq(this,a,void 0)}wj(){}}jX.prototype.$classData=q({w$:0},!1,"scala.runtime.NonLocalReturnControl$mcV$sp",{w$:1,TS:1,N3:1,jc:1,d:1,l:1});
-function DC(a){this.VS=0;this.E$=a;this.TG=0;this.VS=a.G()}DC.prototype=new zY;DC.prototype.constructor=DC;DC.prototype.s=function(){return this.TG<this.VS};DC.prototype.t=function(){var a=this.E$.I(this.TG);this.TG=1+this.TG|0;return a};DC.prototype.$classData=q({D$:0},!1,"scala.runtime.ScalaRunTime$$anon$1",{D$:1,Qa:1,d:1,Ha:1,M:1,N:1});function s2(){}s2.prototype=new p;s2.prototype.constructor=s2;f=s2.prototype;f.wh=function(a){return t2(a)};f.Db=function(){return u2()};
-function t2(a){var b=u2();return cR(b,a).Eb()}f.Ib=function(a){return t2(a)};f.U=function(){return u2()};f.$classData=q({h$:0},!1,"scala.scalajs.js.WrappedArray$",{h$:1,d:1,it:1,Bk:1,Uf:1,l:1});var v2;function L1(){v2||(v2=new s2);return v2}function w2(){}w2.prototype=new p;w2.prototype.constructor=w2;f=w2.prototype;f.wh=function(a){return x2(this,a)};function x2(a,b){return a.Db().oc(b).Eb()}f.Db=function(){return new fU(ge(new ie,[]),new z(a=>J(new L,a.nr)))};f.Ib=function(a){return x2(this,a)};
-f.U=function(){var a=new L;J(a,[]);return a};f.$classData=q({q$:0},!1,"scala.scalajs.runtime.WrappedVarArgs$",{q$:1,d:1,it:1,Bk:1,Uf:1,l:1});var y2;function z2(){y2||(y2=new w2);return y2}function te(a){this.ca=a}te.prototype=new LZ;te.prototype.constructor=te;f=te.prototype;f.BJ=function(){return!0};f.TA=function(){return!1};f.H=function(){return"Left"};f.G=function(){return 1};f.I=function(a){return 0===a?this.ca:JK(W(),a)};f.E=function(a){return a instanceof te};f.y=function(){return jL(this)};
-f.u=function(){return EK(this)};f.h=function(a){return this===a?!0:a instanceof te?Ol(Pl(),this.ca,a.ca):!1};f.$classData=q({I3:0},!1,"scala.util.Left",{I3:1,G3:1,d:1,F:1,v:1,l:1});function me(a){this.ia=a}me.prototype=new LZ;me.prototype.constructor=me;f=me.prototype;f.BJ=function(){return!1};f.TA=function(){return!0};f.H=function(){return"Right"};f.G=function(){return 1};f.I=function(a){return 0===a?this.ia:JK(W(),a)};f.E=function(a){return a instanceof me};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){return this===a?!0:a instanceof me?Ol(Pl(),this.ia,a.ia):!1};f.$classData=q({K3:0},!1,"scala.util.Right",{K3:1,G3:1,d:1,F:1,v:1,l:1});function ff(a){this.Nl=a}ff.prototype=new zL;ff.prototype.constructor=ff;f=ff.prototype;f.H=function(){return"Line"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Nl:JK(W(),a)};f.E=function(a){return a instanceof ff};f.y=function(){var a=dc("Line");a=W().B(-889275714,a);var b=this.Nl;a=W().B(a,b);return W().La(a,1)};f.u=function(){return EK(this)};
-f.h=function(a){return this===a?!0:a instanceof ff?this.Nl===a.Nl:!1};f.$classData=q({S_:0},!1,"sourcecode.Line",{S_:1,U_:1,d:1,F:1,v:1,l:1});function gf(a){this.Gm=a}gf.prototype=new zL;gf.prototype.constructor=gf;f=gf.prototype;f.H=function(){return"Name"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Gm:JK(W(),a)};f.E=function(a){return a instanceof gf};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){return this===a?!0:a instanceof gf?this.Gm===a.Gm:!1};f.$classData=q({T_:0},!1,"sourcecode.Name",{T_:1,U_:1,d:1,F:1,v:1,l:1});function E0(){var a=new NH;fF(a,null,null,!0);return a}class NH extends LK{}NH.prototype.$classData=q({j0:0},!1,"java.lang.ArrayIndexOutOfBoundsException",{j0:1,NJ:1,ye:1,fd:1,jc:1,d:1,l:1});function ic(a){return Mg(Qg(),a)}
-var Da=q({r0:0},!1,"java.lang.Double",{r0:1,Kq:1,d:1,l:1,xe:1,Xs:1,wF:1},a=>"number"===typeof a),Aa=q({t0:0},!1,"java.lang.Float",{t0:1,Kq:1,d:1,l:1,xe:1,Xs:1,wF:1},a=>va(a)),ta=q({w0:0},!1,"java.lang.Integer",{w0:1,Kq:1,d:1,l:1,xe:1,Xs:1,wF:1},a=>oa(a)),hb=q({B0:0},!1,"java.lang.Long",{B0:1,Kq:1,d:1,l:1,xe:1,Xs:1,wF:1},a=>a instanceof fb);class IL extends OZ{constructor(a){super();fF(this,a,null,!0)}}
-IL.prototype.$classData=q({K0:0},!1,"java.lang.NumberFormatException",{K0:1,Pj:1,ye:1,fd:1,jc:1,d:1,l:1});function Ak(a,b){return a.codePointAt(b)|0}function dc(a){for(var b=0,c=1,d=-1+a.length|0;0<=d;)b=b+Math.imul(a.charCodeAt(d),c)|0,c=Math.imul(31,c),d=-1+d|0;return b}function sb(a,b){for(var c=a.length,d=b.length,e=c<d?c:d,g=0;g!==e;){var h=g;h=a.charCodeAt(g)-b.charCodeAt(h)|0;if(0!==h)return h;g=1+g|0}return c-d|0}
-function A2(a,b,c,d){if(b>a.length||0>b||0>b)throw a=new bH,fF(a,"Index out of Bound",null,!0),a;d=d-0|0;for(var e=0;e<b;)c.a[e+d|0]=a.charCodeAt(e),e=1+e|0}function dH(a,b){b=CL($q(),b);return a.indexOf(b)|0}
-function xe(a,b,c){b=fl(b);a=new Sp(b,a);a.CQ=0;a.Zu=a.BQ;a.AF=0;a.$u=null;a.Tx=0;b=new nW;for(b.Ox=CQ(new rq);EN(a);){var d=a,e=b,g=c,h=d.Zu,k=d.Tx,l=FN(d);oW(e,h.substring(k,l));h=g.length;for(k=0;k<h;)switch(l=g.charCodeAt(k),l){case 36:for(l=k=1+k|0;;){if(k<h){var m=g.charCodeAt(k);m=48<=m&&57>=m}else m=!1;if(m)k=1+k|0;else break}CH();l=g.substring(l,k);m=BH(0,l,10);l=d;var n=DN(l);l=l.UJ;if(0>m||m>l.i2)throw KK(new LK,""+m);l=n[l.j2[m]|0];l=void 0!==l?l:null;null!==l&&oW(e,l);break;case 92:k=
-1+k|0;k<h&&pW(e,g.charCodeAt(k));k=1+k|0;break;default:pW(e,l),k=1+k|0}d.Tx=GN(d)}oW(b,a.Zu.substring(a.Tx));a.Tx=a.Zu.length;return b.u()}
-function B2(a,b){b=fl(b);if(""===a)b=new (Nd(na).Ja)([""]);else{var c=new Sp(b,a);b=[];for(var d=0;2147483646>(b.length|0)&&EN(c);){if(0!==GN(c)){var e=FN(c);b.push(a.substring(d,e))}d=GN(c)}b.push(a.substring(d));for(c=b.length|0;;)if(0!==c?(a=b[-1+c|0],a=null!==a&&Pb(a,"")):a=!1,a)c=-1+c|0;else break;a=new (Nd(na).Ja)(c);for(d=0;d<c;)e=d,a.a[e]=b[e],d=1+d|0;b=a}return b}function Oq(a){for(var b=a.length,c=new td(b),d=0;d<b;)c.a[d]=a.charCodeAt(d),d=1+d|0;return c}
-var na=q({X_:0},!1,"java.lang.String",{X_:1,d:1,l:1,xe:1,HJ:1,Xs:1,wF:1},a=>"string"===typeof a);class bH extends LK{}bH.prototype.$classData=q({S0:0},!1,"java.lang.StringIndexOutOfBoundsException",{S0:1,NJ:1,ye:1,fd:1,jc:1,d:1,l:1});class wM extends PZ{constructor(){super();fF(this,null,null,!0)}}wM.prototype.$classData=q({m1:0},!1,"java.util.FormatterClosedException",{m1:1,jQ:1,ye:1,fd:1,jc:1,d:1,l:1});function XZ(a){this.xF=null;if(null===a)throw null;this.xF=a}XZ.prototype=new TZ;
-XZ.prototype.constructor=XZ;XZ.prototype.Uu=function(){return new zN(this.xF)};XZ.prototype.ka=function(){return this.xF.Xu};XZ.prototype.L=function(a){if(vk(a)){var b=this.xF,c=a.Nn();if(null===c)var d=0;else d=bc(c),d^=d>>>16|0;b=VZ(b,c,d,d&(-1+b.kl.a.length|0));if(null!==b)return b=b.Wu,a=a.On(),null===b?null===a:Pb(b,a)}return!1};XZ.prototype.$classData=q({p1:0},!1,"java.util.HashMap$EntrySet",{p1:1,$0:1,Y0:1,d:1,vQ:1,y0:1,Q1:1});function ZZ(a){this.cB=null;if(null===a)throw null;this.cB=a}
-ZZ.prototype=new TZ;ZZ.prototype.constructor=ZZ;ZZ.prototype.Uu=function(){return new yN(this)};ZZ.prototype.ka=function(){return this.cB.Yu.Xu};ZZ.prototype.L=function(a){if(vk(a)){var b=a.Nn();if(this.cB.gF(b))return b=this.cB.nF(b),Object.is(b,a.On())}return!1};ZZ.prototype.$classData=q({t1:0},!1,"java.util.IdentityHashMap$EntrySet",{t1:1,$0:1,Y0:1,d:1,vQ:1,y0:1,Q1:1});class C2 extends OZ{}
-class yk extends OZ{constructor(a,b,c){super();this.f2=a;this.h2=b;this.g2=c;fF(this,null,null,!0)}mj(){var a=this.g2,b=this.h2,c=this.f2+(0>a?"":" near index "+a)+"\n"+b;if(0<=a&&null!==b&&a<b.length){if(0>a)throw DL();a=" ".repeat(a);c=c+"\n"+a+"^"}return c}}yk.prototype.$classData=q({e2:0},!1,"java.util.regex.PatternSyntaxException",{e2:1,Pj:1,ye:1,fd:1,jc:1,d:1,l:1});function Qr(a,b,c){this.Tc=a;this.$d=b;this.Ig=c}Qr.prototype=new oz;Qr.prototype.constructor=Qr;f=Qr.prototype;f.H=function(){return"BRACKETS"};
-f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Tc;case 1:return this.$d;default:return JK(W(),a)}};f.E=function(a){return a instanceof Qr};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Qr&&this.Tc===a.Tc){var b=this.$d;a=a.$d;return null===b?null===a:b.h(a)}return!1};f.$classData=q({zT:0},!1,"mlscript.BRACKETS",{zT:1,al:1,d:1,xn:1,F:1,v:1,l:1});function D2(){}D2.prototype=new oz;
-D2.prototype.constructor=D2;f=D2.prototype;f.H=function(){return"COMMA"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof D2};f.y=function(){return 64305845};f.u=function(){return"COMMA"};f.$classData=q({NT:0},!1,"mlscript.COMMA$",{NT:1,al:1,d:1,xn:1,F:1,v:1,l:1});var E2;function mr(){E2||(E2=new D2);return E2}function tr(a){this.sC=a}tr.prototype=new oz;tr.prototype.constructor=tr;f=tr.prototype;f.H=function(){return"COMMENT"};f.G=function(){return 1};
-f.I=function(a){return 0===a?this.sC:JK(W(),a)};f.E=function(a){return a instanceof tr};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){return this===a?!0:a instanceof tr?this.sC===a.sC:!1};f.$classData=q({OT:0},!1,"mlscript.COMMENT",{OT:1,al:1,d:1,xn:1,F:1,v:1,l:1});function F2(){}F2.prototype=new oz;F2.prototype.constructor=F2;f=F2.prototype;f.H=function(){return"ERROR"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};
-f.E=function(a){return a instanceof F2};f.y=function(){return 66247144};f.u=function(){return"ERROR"};f.$classData=q({oU:0},!1,"mlscript.ERROR$",{oU:1,al:1,d:1,xn:1,F:1,v:1,l:1});var G2;function Mr(){G2||(G2=new F2);return G2}function Cn(a,b){this.CM=null;this.EM=this.FM=0;this.GM=this.DM=null;this.Fr=0;this.Pf=a;this.Jg=b;mq(this)}Cn.prototype=new p;Cn.prototype.constructor=Cn;f=Cn.prototype;f.Kj=function(){var a=this.Pf.ea(),b=this.Jg,c=O().c;return Fl(new A(b,c),a)};
-f.Jm=function(){0===(1&this.Fr)<<24>>24&&0===(1&this.Fr)<<24>>24&&(this.CM=Yp(this),this.Fr=(1|this.Fr)<<24>>24);return this.CM};f.Rm=function(){return this.FM};f.Tl=function(a){this.FM=a};f.Qm=function(){return this.EM};f.Sl=function(a){this.EM=a};f.Pm=function(){return this.DM};f.Om=function(a){this.DM=a};f.C=function(){0===(2&this.Fr)<<24>>24&&0===(2&this.Fr)<<24>>24&&(this.GM=bq(this),this.Fr=(2|this.Fr)<<24>>24);return this.GM};f.H=function(){return"Field"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.Pf;case 1:return this.Jg;default:return JK(W(),a)}};f.E=function(a){return a instanceof Cn};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Cn){var b=this.Pf,c=a.Pf;if(null===b?null===c:b.h(c))return b=this.Jg,a=a.Jg,null===b?null===a:b.h(a)}return!1};f.$classData=q({tU:0},!1,"mlscript.Field",{tU:1,d:1,T$:1,Za:1,F:1,v:1,l:1});
-function ws(a,b){this.MM=null;this.OM=this.PM=0;this.QM=this.NM=null;this.Hr=0;this.vc=a;this.Da=b;mq(this)}ws.prototype=new p;ws.prototype.constructor=ws;f=ws.prototype;f.Kj=function(){var a=this.Da,b=O().c;return new A(a,b)};f.Jm=function(){0===(1&this.Hr)<<24>>24&&0===(1&this.Hr)<<24>>24&&(this.MM=Yp(this),this.Hr=(1|this.Hr)<<24>>24);return this.MM};f.Rm=function(){return this.PM};f.Tl=function(a){this.PM=a};f.Qm=function(){return this.OM};f.Sl=function(a){this.OM=a};f.Pm=function(){return this.NM};
-f.Om=function(a){this.NM=a};f.C=function(){0===(2&this.Hr)<<24>>24&&0===(2&this.Hr)<<24>>24&&(this.QM=bq(this),this.Hr=(2|this.Hr)<<24>>24);return this.QM};f.H=function(){return"Fld"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.vc;case 1:return this.Da;default:return JK(W(),a)}};f.E=function(a){return a instanceof ws};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof ws){var b=this.vc,c=a.vc;if(null===b?null===c:b.h(c))return b=this.Da,a=a.Da,null===b?null===a:b.h(a)}return!1};f.$classData=q({uU:0},!1,"mlscript.Fld",{uU:1,d:1,V$:1,Za:1,F:1,v:1,l:1});function jt(a,b,c){this.HM=null;this.JM=this.KM=0;this.LM=this.IM=null;this.Gr=0;this.pf=a;this.si=b;this.ri=c;mq(this)}jt.prototype=new p;jt.prototype.constructor=jt;f=jt.prototype;f.Kj=function(){return O().c};
-f.u=function(){if(null===this)throw new x(this);var a=(this.pf?"m":"")+(this.si?"s":"")+(this.ri?"g":"");return""===a?"_":a};f.Jm=function(){0===(1&this.Gr)<<24>>24&&0===(1&this.Gr)<<24>>24&&(this.HM=Yp(this),this.Gr=(1|this.Gr)<<24>>24);return this.HM};f.Rm=function(){return this.KM};f.Tl=function(a){this.KM=a};f.Qm=function(){return this.JM};f.Sl=function(a){this.JM=a};f.Pm=function(){return this.IM};f.Om=function(a){this.IM=a};
-f.C=function(){0===(2&this.Gr)<<24>>24&&0===(2&this.Gr)<<24>>24&&(this.LM=bq(this),this.Gr=(2|this.Gr)<<24>>24);return this.LM};f.H=function(){return"FldFlags"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.pf;case 1:return this.si;case 2:return this.ri;default:return JK(W(),a)}};f.E=function(a){return a instanceof jt};
-f.y=function(){var a=dc("FldFlags");a=W().B(-889275714,a);var b=this.pf?1231:1237;a=W().B(a,b);b=this.si?1231:1237;a=W().B(a,b);b=this.ri?1231:1237;a=W().B(a,b);return W().La(a,3)};f.h=function(a){return this===a?!0:a instanceof jt?this.pf===a.pf&&this.si===a.si&&this.ri===a.ri:!1};f.$classData=q({vU:0},!1,"mlscript.FldFlags",{vU:1,d:1,U$:1,Za:1,F:1,v:1,l:1});function Kr(a,b){this.Df=a;this.Qf=b}Kr.prototype=new oz;Kr.prototype.constructor=Kr;f=Kr.prototype;f.H=function(){return"IDENT"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.Df;case 1:return this.Qf;default:return JK(W(),a)}};f.E=function(a){return a instanceof Kr};f.y=function(){var a=dc("IDENT");a=W().B(-889275714,a);var b=this.Df;b=dy(W(),b);a=W().B(a,b);b=this.Qf?1231:1237;a=W().B(a,b);return W().La(a,2)};f.u=function(){return EK(this)};f.h=function(a){return this===a?!0:a instanceof Kr?this.Qf===a.Qf&&this.Df===a.Df:!1};f.$classData=q({zU:0},!1,"mlscript.IDENT",{zU:1,al:1,d:1,xn:1,F:1,v:1,l:1});
-function Mo(a){this.FC=a}Mo.prototype=new XN;Mo.prototype.constructor=Mo;f=Mo.prototype;f.ih=function(){return 22};f.xa=function(){Fp();var a=this.FC;if(a===v())var b=v();else{b=a.e();var c=b=new A(Jp(b,Kp().fz),v());for(a=a.g();a!==v();){var d=a.e();d=new A(Jp(d,Kp().fz),v());c=c.r=d;a=a.g()}}return mz(b)};f.H=function(){return"JSArray"};f.G=function(){return 1};f.I=function(a){return 0===a?this.FC:JK(W(),a)};f.E=function(a){return a instanceof Mo};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Mo){var b=this.FC;a=a.FC;return null===b?null===a:b.h(a)}return!1};f.$classData=q({LU:0},!1,"mlscript.JSArray",{LU:1,Oi:1,Uc:1,d:1,F:1,v:1,l:1});function jm(a){this.EC=a}jm.prototype=new fO;jm.prototype.constructor=jm;f=jm.prototype;f.xa=function(){Fp();var a=this.EC;if(a===v())var b=v();else{b=a.e();var c=b=new A(b.xa(),v());for(a=a.g();a!==v();){var d=a.e();d=new A(d.xa(),v());c=c.r=d;a=a.g()}}return mz(b)};f.H=function(){return"JSArrayPattern"};
-f.G=function(){return 1};f.I=function(a){return 0===a?this.EC:JK(W(),a)};f.E=function(a){return a instanceof jm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof jm){var b=this.EC;a=a.EC;return null===b?null===a:b.h(a)}return!1};f.$classData=q({MU:0},!1,"mlscript.JSArrayPattern",{MU:1,fH:1,Uc:1,d:1,F:1,v:1,l:1});function bo(a,b){this.bz=a;this.GC=b}bo.prototype=new XN;bo.prototype.constructor=bo;f=bo.prototype;f.ih=function(){return 2};
-f.xa=function(){var a=Gp(Ep(mg(this.bz).ge(Fp().ce,new Um((g,h)=>{var k=G(new H,g,h);g=k.z;h=k.x;if(null!==h)return k=h.i(),h=h.Lc(),Gp(Gp(g,k instanceof gm?Hp(Fp(),"_"+h):k.xa()),hf(new E(h),-1+this.bz.K()|0)?Fp().ce:Hp(Fp(),", "));throw new x(k);})),!0),Fp().CN),b=!1,c=null,d=this.GC;a:{if(d instanceof te){b=!0;c=d;var e=c.ca;if(e instanceof fo){b=Ep(e.xa(),!0);break a}}if(b)b=Jp(c.ca,2);else if(d instanceof me){d=d.ia;Fp();if(d===v())b=v();else for(b=d.e(),c=b=new A(b.xa(),v()),d=d.g();d!==v();)e=
-d.e(),e=new A(e.xa(),v()),c=c.r=e,d=d.g();b=gz(kz(b))}else throw new x(d);}return Gp(a,b)};f.H=function(){return"JSArrowFn"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.bz;case 1:return this.GC;default:return JK(W(),a)}};f.E=function(a){return a instanceof bo};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof bo){var b=this.bz,c=a.bz;if(null===b?null===c:b.h(c))return b=this.GC,a=a.GC,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({NU:0},!1,"mlscript.JSArrowFn",{NU:1,Oi:1,Uc:1,d:1,F:1,v:1,l:1});function vo(a,b){this.HC=a;this.IC=b}vo.prototype=new XN;vo.prototype.constructor=vo;f=vo.prototype;f.ih=function(){return 3};f.xa=function(){return Gp(Gp(Jp(this.HC,3),Hp(Fp()," \x3d ")),Jp(this.IC,3))};f.H=function(){return"JSAssignExpr"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.HC;case 1:return this.IC;default:return JK(W(),a)}};f.E=function(a){return a instanceof vo};f.y=function(){return jL(this)};
-f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof vo){var b=this.HC,c=a.HC;if(null===b?null===c:b.h(c))return b=this.IC,a=a.IC,null===b?null===a:b.h(a)}return!1};f.$classData=q({OU:0},!1,"mlscript.JSAssignExpr",{OU:1,Oi:1,Uc:1,d:1,F:1,v:1,l:1});function Vm(a,b,c){this.sw=a;this.LC=b;this.MC=c}Vm.prototype=new XN;Vm.prototype.constructor=Vm;f=Vm.prototype;
-f.ih=function(){var a=TN(Zn()).Y(this.sw);if(a instanceof M)return a.k|0;if(R()===a)throw lS(new mS,"Unknown binary operator: "+this.sw);throw new x(a);};f.xa=function(){return Gp(Gp(Jp(this.LC,this.ih()),Hp(Fp()," "+this.sw+" ")),Jp(this.MC,this.ih()))};f.H=function(){return"JSBinary"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.sw;case 1:return this.LC;case 2:return this.MC;default:return JK(W(),a)}};f.E=function(a){return a instanceof Vm};f.y=function(){return jL(this)};
-f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Vm&&this.sw===a.sw){var b=this.LC,c=a.LC;if(null===b?null===c:b.h(c))return b=this.MC,a=a.MC,null===b?null===a:b.h(a)}return!1};f.$classData=q({$U:0},!1,"mlscript.JSBinary",{$U:1,Oi:1,Uc:1,d:1,F:1,v:1,l:1});q({cV:0},!1,"mlscript.JSClassDecl",{cV:1,Cl:1,Uc:1,d:1,F:1,v:1,l:1});function wo(a){this.PC=a}wo.prototype=new XN;wo.prototype.constructor=wo;f=wo.prototype;f.ih=function(){return 22};f.xa=function(){return this.PC.xa()};
-f.H=function(){return"JSClassExpr"};f.G=function(){return 1};f.I=function(a){return 0===a?this.PC:JK(W(),a)};f.E=function(a){return a instanceof wo};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof wo){var b=this.PC;a=a.PC;return null===b?null===a:b.h(a)}return!1};f.$classData=q({dV:0},!1,"mlscript.JSClassExpr",{dV:1,Oi:1,Uc:1,d:1,F:1,v:1,l:1});
-function kp(a,b,c,d,e,g,h,k,l,m,n,r,u,w){this.Vr=a;this.Ut=b;this.tw=c;this.yw=d;this.uw=e;this.Aw=g;this.Mp=h;this.ez=k;this.xw=l;this.vw=m;this.ww=n;this.dz=r;this.cz=u;this.zw=w;bV(fV(),b)}kp.prototype=new hO;kp.prototype.constructor=kp;f=kp.prototype;
-f.xa=function(){var a=new Wo,b=this.Mp.m();b=new ko(b);var c=this.ez;b=ku(b,c instanceof M?"..."+c.k:"",new Um((k,l)=>""===l?""+k.i():k.i()+", "+l));for(c=this.dz;!c.b();){var d="  #"+c.e()+";";ip(a,d);c=c.g()}for(c=Kl(this.yw);!c.b();)d="  #"+c.e()+";",ip(a,d),c=c.g();for(c=Kl(this.tw);!c.b();)d=c.e(),this.yw.L(d)||ip(a,"  #"+d+";"),ip(a,"  get "+d+"() { return this.#"+d+"; }"),c=c.g();ip(a,"  constructor("+b+") {");if(!this.uw.b()){b=this.Aw.m();b=new ko(b);for(c="";b.s();)d=c,c=b.Sm(),c=hf(new E(c.Lc()),
--1+this.Aw.K()|0)?""+d+c.i().xa():""+d+c.i().xa()+", ";ip(a,"    super("+c+");")}for(b=this.vw;!b.b();)c="    "+b.e()+".implement(this);",ip(a,c),b=b.g();if(!this.cz){b=this.Ut.K();if(!hf(new E(b),this.Mp.K()))throw new rk("assertion failed: fields and ctorParams have different size in class "+this.Vr+".");b=this.Ut;c=new vq(b,b,this.Mp);b=c.Sj.m();for(c=c.Tj.m();b.s()&&c.s();){d=b.t();var e=c.t();ip(a,"    this.#"+d+" \x3d "+e+";")}}for(b=this.ww;!b.b();){c=cz(cz(b.e().xa())).Hf;c=Qe(c,"","\n","");
-var g=B2(c,"\n");c=(k=>l=>ip(k,l))(a);d=g.a.length;e=0;if(null!==g)for(;e<d;)c(g.a[e]),e=1+e|0;else if(g instanceof zd)for(;e<d;)c(g.a[e]),e=1+e|0;else if(g instanceof Dd)for(;e<d;)c(g.a[e]),e=1+e|0;else if(g instanceof Ad)for(;e<d;){var h=g.a[e];c(new fb(h.W,h.Z));e=1+e|0}else if(g instanceof Bd)for(;e<d;)c(g.a[e]),e=1+e|0;else if(g instanceof td)for(;e<d;)c(hd(g.a[e])),e=1+e|0;else if(g instanceof vd)for(;e<d;)c(g.a[e]),e=1+e|0;else if(g instanceof wd)for(;e<d;)c(g.a[e]),e=1+e|0;else if(g instanceof
-pd)for(;e<d;)c(g.a[e]),e=1+e|0;else throw new x(g);b=b.g()}ip(a,"  }");a=jz(Fp(),a.ea());b=this.xw;for(c=Fp().ce;!b.b();)d=b.e(),c=az(c,cz(d.xa())),b=b.g();b=c;c=this.zw;for(d=Fp().ce;!c.b();)e=c.e(),d=az(az(d,Hp(Fp(),"static")),cz(e.xa())),c=c.g();c=d;d=Hp(Fp(),"}");e=this.uw;if(e instanceof M)return e=e.k,az(az(az(az(Gp(Gp(Hp(Fp(),"class "+this.Vr+" extends "),e.xa()),Hp(Fp()," {")),a),b),c),d);if(R()===e){if(this.Ut.b()&&this.xw.b()&&this.vw.b()&&this.tw.b()&&this.ww.b()&&this.zw.b())return Hp(Fp(),
-"class "+this.Vr+" {}");Fp();e="class "+this.Vr+" {";g=O().c;return az(az(az(az(jz(0,new A(e,g)),a),b),c),d)}throw new x(e);};f.H=function(){return"JSClassNewDecl"};f.G=function(){return 14};
-f.I=function(a){switch(a){case 0:return this.Vr;case 1:return this.Ut;case 2:return this.tw;case 3:return this.yw;case 4:return this.uw;case 5:return this.Aw;case 6:return this.Mp;case 7:return this.ez;case 8:return this.xw;case 9:return this.vw;case 10:return this.ww;case 11:return this.dz;case 12:return this.cz;case 13:return this.zw;default:return JK(W(),a)}};f.E=function(a){return a instanceof kp};
-f.y=function(){var a=dc("JSClassNewDecl");a=W().B(-889275714,a);var b=this.Vr;b=dy(W(),b);a=W().B(a,b);b=this.Ut;b=dy(W(),b);a=W().B(a,b);b=this.tw;b=dy(W(),b);a=W().B(a,b);b=this.yw;b=dy(W(),b);a=W().B(a,b);b=this.uw;b=dy(W(),b);a=W().B(a,b);b=this.Aw;b=dy(W(),b);a=W().B(a,b);b=this.Mp;b=dy(W(),b);a=W().B(a,b);b=this.ez;b=dy(W(),b);a=W().B(a,b);b=this.xw;b=dy(W(),b);a=W().B(a,b);b=this.vw;b=dy(W(),b);a=W().B(a,b);b=this.ww;b=dy(W(),b);a=W().B(a,b);b=this.dz;b=dy(W(),b);a=W().B(a,b);b=this.cz?1231:
-1237;a=W().B(a,b);b=this.zw;b=dy(W(),b);a=W().B(a,b);return W().La(a,14)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof kp){if(this.cz===a.cz)if(this.Vr===a.Vr){var b=this.Ut,c=a.Ut;b=null===b?null===c:b.h(c)}else b=!1;else b=!1;b?(b=this.tw,c=a.tw,(null===b?null===c:b.h(c))?(b=this.yw,c=a.yw,b=null===b?null===c:b.h(c)):b=!1,b?(b=this.uw,c=a.uw,(null===b?null===c:b.h(c))?(b=this.Aw,c=a.Aw,b=null===b?null===c:b.h(c)):b=!1):b=!1):b=!1;if(b&&(b=this.Mp,c=a.Mp,(null===b?null===c:b.h(c))?(b=this.ez,c=a.ez,(null===b?null===c:b.h(c))?(b=this.xw,c=a.xw,b=null===b?null===
-c:b.h(c)):b=!1):b=!1,b&&(b=this.vw,c=a.vw,(null===b?null===c:b.h(c))?(b=this.ww,c=a.ww,b=null===b?null===c:b.h(c)):b=!1,b&&(b=this.dz,c=a.dz,null===b?null===c:b.h(c)))))return b=this.zw,a=a.zw,null===b?null===a:b.h(a)}return!1};f.$classData=q({hV:0},!1,"mlscript.JSClassNewDecl",{hV:1,Cl:1,Uc:1,d:1,F:1,v:1,l:1});function Bo(a){this.VC=a}Bo.prototype=new XN;Bo.prototype.constructor=Bo;f=Bo.prototype;f.ih=function(){return 1};
-f.xa=function(){var a=Fp(),b=this.VC;if(b===v())var c=v();else{c=b.e();var d=c=new A(c.xa(),v());for(b=b.g();b!==v();){var e=b.e();e=new A(e.xa(),v());d=d.r=e;b=b.g()}}d=Fp();return Caa(a,c,d.BN)};f.H=function(){return"JSCommaExpr"};f.G=function(){return 1};f.I=function(a){return 0===a?this.VC:JK(W(),a)};f.E=function(a){return a instanceof Bo};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Bo){var b=this.VC;a=a.VC;return null===b?null===a:b.h(a)}return!1};f.$classData=q({iV:0},!1,"mlscript.JSCommaExpr",{iV:1,Oi:1,Uc:1,d:1,F:1,v:1,l:1});function hn(a,b){this.WC=a;this.Bw=b}hn.prototype=new hO;hn.prototype.constructor=hn;f=hn.prototype;f.xa=function(){var a=Hp(Fp(),"const "+this.WC+" \x3d "),b=this.Bw instanceof Bo?Ep(this.Bw.xa(),!0):this.Bw.xa();return Gp(Gp(a,b),Fp().bx)};f.H=function(){return"JSConstDecl"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.WC;case 1:return this.Bw;default:return JK(W(),a)}};f.E=function(a){return a instanceof hn};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof hn&&this.WC===a.WC){var b=this.Bw;a=a.Bw;return null===b?null===a:b.h(a)}return!1};f.$classData=q({kV:0},!1,"mlscript.JSConstDecl",{kV:1,Cl:1,Uc:1,d:1,F:1,v:1,l:1});function lo(a){this.gz=a}lo.prototype=new hO;lo.prototype.constructor=lo;f=lo.prototype;
-f.xa=function(){return Gp(Ep(this.gz.xa(),this.gz instanceof fo),Fp().bx)};f.H=function(){return"JSExprStmt"};f.G=function(){return 1};f.I=function(a){return 0===a?this.gz:JK(W(),a)};f.E=function(a){return a instanceof lo};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof lo){var b=this.gz;a=a.gz;return null===b?null===a:b.h(a)}return!1};f.$classData=q({nV:0},!1,"mlscript.JSExprStmt",{nV:1,Cl:1,Uc:1,d:1,F:1,v:1,l:1});
-function Ty(a,b,c){this.aD=a;this.$C=b;this.ZC=c}Ty.prototype=new hO;Ty.prototype.constructor=Ty;f=Ty.prototype;f.xa=function(){for(var a=Gp(Gp(Gp(Gp(Hp(Fp(),"for (const "),this.aD.xa()),Hp(Fp()," in ")),this.$C.xa()),Hp(Fp(),")")),b=this.ZC,c=Fp().ce;!b.b();){var d=b.e();c=az(c,d.xa());b=b.g()}return Gp(a,gz(c))};f.H=function(){return"JSForInStmt"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.aD;case 1:return this.$C;case 2:return this.ZC;default:return JK(W(),a)}};
-f.E=function(a){return a instanceof Ty};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Ty){var b=this.aD,c=a.aD;if(null===b?null===c:b.h(c))if(b=this.$C,c=a.$C,null===b?null===c:b.h(c))return b=this.ZC,a=a.ZC,null===b?null===a:b.h(a)}return!1};f.$classData=q({qV:0},!1,"mlscript.JSForInStmt",{qV:1,Cl:1,Uc:1,d:1,F:1,v:1,l:1});function Ky(a,b,c){this.cD=a;this.dD=b;this.bD=c}Ky.prototype=new hO;Ky.prototype.constructor=Ky;f=Ky.prototype;
-f.xa=function(){for(var a=Gp(Gp(Hp(Fp(),"function "+this.cD),Dp(Ap(),this.dD)),Fp().Ez),b=this.bD,c=Fp().ce;!b.b();){var d=b.e();c=az(c,d.xa());b=b.g()}return Gp(a,gz(c))};f.H=function(){return"JSFuncDecl"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.cD;case 1:return this.dD;case 2:return this.bD;default:return JK(W(),a)}};f.E=function(a){return a instanceof Ky};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Ky&&this.cD===a.cD){var b=this.dD,c=a.dD;if(null===b?null===c:b.h(c))return b=this.bD,a=a.bD,null===b?null===a:b.h(a)}return!1};f.$classData=q({rV:0},!1,"mlscript.JSFuncDecl",{rV:1,Cl:1,Uc:1,d:1,F:1,v:1,l:1});function go(a,b,c){this.fD=a;this.gD=b;this.eD=c}go.prototype=new XN;go.prototype.constructor=go;f=go.prototype;f.ih=function(){return 22};
-f.xa=function(){Fp();var a=this.fD;a=Gp(Gp(Hp(0,"function "+(a.b()?"":a.o())),Dp(Ap(),this.gD)),Fp().Ez);Fp();var b=this.eD;if(b===v())var c=v();else{c=b.e();var d=c=new A(c.xa(),v());for(b=b.g();b!==v();){var e=b.e();e=new A(e.xa(),v());d=d.r=e;b=b.g()}}return Gp(a,gz(kz(c)))};f.H=function(){return"JSFuncExpr"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.fD;case 1:return this.gD;case 2:return this.eD;default:return JK(W(),a)}};f.E=function(a){return a instanceof go};
-f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof go){var b=this.fD,c=a.fD;if(null===b?null===c:b.h(c))if(b=this.gD,c=a.gD,null===b?null===c:b.h(c))return b=this.eD,a=a.eD,null===b?null===a:b.h(a)}return!1};f.$classData=q({sV:0},!1,"mlscript.JSFuncExpr",{sV:1,Oi:1,Uc:1,d:1,F:1,v:1,l:1});function Em(a){this.Np=a}Em.prototype=new XN;Em.prototype.constructor=Em;f=Em.prototype;f.ih=function(){return 22};
-f.xa=function(){return Hp(Fp(),this.Np)};f.H=function(){return"JSIdent"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Np:JK(W(),a)};f.E=function(a){return a instanceof Em};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){return this===a?!0:a instanceof Em?this.Np===a.Np:!1};f.$classData=q({tV:0},!1,"mlscript.JSIdent",{tV:1,Oi:1,Uc:1,d:1,F:1,v:1,l:1});function To(a,b,c){this.iD=a;this.hD=b;this.hz=c}To.prototype=new hO;To.prototype.constructor=To;f=To.prototype;
-f.xa=function(){var a=Hp(Fp(),"if ");a:{var b=this.iD.xa();switch(b.Hf.K()){case 0:var c=b;break a;case 1:var d=b.Hf;if(d===v())c=v();else for(c=d.e(),b=c=new A(ez(c),v()),d=d.g();d!==v();){var e=d.e();e=new A(ez(e),v());b=b.r=e;d=d.g()}c=new $y(c);break a;default:c=new bz("(",0);e=b.Hf;if(e===v())b=v();else for(b=e.e(),d=b=new A(dz(b),v()),e=e.g();e!==v();){var g=e.e();g=new A(dz(g),v());d=d.r=g;e=e.g()}t();d=J(new L,[new bz(")",0)]);b=Fl(le(v(),d),b);c=new $y(new A(c,b))}}a=Gp(Gp(a,c),Fp().Ez);
-c=this.hD;for(b=Fp().ce;!c.b();)d=c.e(),b=az(b,d.xa()),c=c.g();a=Gp(a,gz(b));c=this.hz;b=O().c;if(null===b?null===c:b.h(c))c=Fp().ce;else{c=Hp(Fp()," else ");b=this.hz;for(d=Fp().ce;!b.b();)e=b.e(),d=az(d,e.xa()),b=b.g();c=Gp(c,gz(d))}return Gp(a,c)};f.H=function(){return"JSIfStmt"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.iD;case 1:return this.hD;case 2:return this.hz;default:return JK(W(),a)}};f.E=function(a){return a instanceof To};f.y=function(){return jL(this)};
-f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof To){var b=this.iD,c=a.iD;if(null===b?null===c:b.h(c))if(b=this.hD,c=a.hD,null===b?null===c:b.h(c))return b=this.hz,a=a.hz,null===b?null===a:b.h(a)}return!1};f.$classData=q({uV:0},!1,"mlscript.JSIfStmt",{uV:1,Cl:1,Uc:1,d:1,F:1,v:1,l:1});function Sm(a,b,c,d){this.jD=a;this.kz=b;this.jz=c;this.iz=d}Sm.prototype=new XN;Sm.prototype.constructor=Sm;f=Sm.prototype;f.ih=function(){return 22};
-f.xa=function(){var a=this.jD;if(R()===a){a=Hp(Fp(),Dp(Ap(),this.kz)+" \x3d\x3e ");var b=!1,c=null,d=this.jz;a:{if(d instanceof te){b=!0;c=d;var e=c.ca;if(e instanceof fo){b=Ep(e.xa(),!0);break a}}if(b)b=Jp(c.ca,2);else if(d instanceof me){b=d.ia;for(c=Fp().ce;!b.b();)d=b.e(),c=az(c,d.xa()),b=b.g();b=gz(c)}else throw new x(d);}return Gp(Ep(Gp(a,b),!0),Ip(Ap(),this.iz))}if(a instanceof M){a=a.k;a=Hp(Fp(),"function "+a+Dp(Ap(),this.kz)+" ");b=this.jz;if(b instanceof te)b=jn(b.ca).xa();else{if(!(b instanceof
-me))throw new x(b);b=b.ia;for(c=Fp().ce;!b.b();)d=b.e(),c=az(c,d.xa()),b=b.g();b=c}return Gp(Ep(Gp(a,gz(b)),!0),Ip(Ap(),this.iz))}throw new x(a);};f.H=function(){return"JSImmEvalFn"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.jD;case 1:return this.kz;case 2:return this.jz;case 3:return this.iz;default:return JK(W(),a)}};f.E=function(a){return a instanceof Sm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Sm){var b=this.jD,c=a.jD;(null===b?null===c:b.h(c))?(b=this.kz,c=a.kz,b=null===b?null===c:b.h(c)):b=!1;if(b&&(b=this.jz,c=a.jz,null===b?null===c:b.h(c)))return b=this.iz,a=a.iz,null===b?null===a:b.h(a)}return!1};f.$classData=q({vV:0},!1,"mlscript.JSImmEvalFn",{vV:1,Oi:1,Uc:1,d:1,F:1,v:1,l:1});function Zm(a,b){this.kD=a;this.lD=b}Zm.prototype=new XN;Zm.prototype.constructor=Zm;f=Zm.prototype;f.ih=function(){return 12};
-f.xa=function(){return Gp(Gp(this.kD.xa(),Hp(Fp()," instanceof ")),this.lD.xa())};f.H=function(){return"JSInstanceOf"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.kD;case 1:return this.lD;default:return JK(W(),a)}};f.E=function(a){return a instanceof Zm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Zm){var b=this.kD,c=a.kD;if(null===b?null===c:b.h(c))return b=this.lD,a=a.lD,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({wV:0},!1,"mlscript.JSInstanceOf",{wV:1,Oi:1,Uc:1,d:1,F:1,v:1,l:1});function Rm(a,b){this.mD=a;this.lz=b}Rm.prototype=new XN;Rm.prototype.constructor=Rm;f=Rm.prototype;f.ih=function(){return 20};f.xa=function(){var a=Jp(this.mD,20),b=mg(this.lz).ge(Fp().ce,new Um((c,d)=>{var e=G(new H,c,d);c=e.z;d=e.x;if(null!==d)return e=d.Lc(),Gp(Gp(c,Jp(d.i(),Kp().fz)),hf(new E(e),-1+this.lz.K()|0)?Fp().ce:Hp(Fp(),", "));throw new x(e);}));return Gp(a,Ep(b,!0))};f.H=function(){return"JSInvoke"};
-f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.mD;case 1:return this.lz;default:return JK(W(),a)}};f.E=function(a){return a instanceof Rm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Rm){var b=this.mD,c=a.mD;if(null===b?null===c:b.h(c))return b=this.lz,a=a.lz,null===b?null===a:b.h(a)}return!1};f.$classData=q({xV:0},!1,"mlscript.JSInvoke",{xV:1,Oi:1,Uc:1,d:1,F:1,v:1,l:1});function oo(a){this.mz=a}
-oo.prototype=new hO;oo.prototype.constructor=oo;f=oo.prototype;f.xa=function(){return Gp(Gp(Hp(Fp(),"let "),mg(this.mz).ge(Fp().ce,new Um((a,b)=>{var c=G(new H,a,b);a=c.z;b=c.x;if(null!==b){c=b.i();b=b.Lc();a:{if(null!==c){var d=c.i(),e=c.j();if(t().f===e){c=Hp(Fp(),d);break a}}if(null!==c&&(d=c.i(),e=c.j(),e instanceof M)){c=e.k;c=Gp(Gp(Hp(Fp(),d),Hp(Fp()," \x3d ")),c.xa());break a}throw new x(c);}return Gp(Gp(a,c),hf(new E(b),-1+this.mz.K()|0)?Fp().ce:Hp(Fp(),", "))}throw new x(c);}))),Fp().bx)};
-f.H=function(){return"JSLetDecl"};f.G=function(){return 1};f.I=function(a){return 0===a?this.mz:JK(W(),a)};f.E=function(a){return a instanceof oo};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof oo){var b=this.mz;a=a.mz;return null===b?null===a:b.h(a)}return!1};f.$classData=q({yV:0},!1,"mlscript.JSLetDecl",{yV:1,Cl:1,Uc:1,d:1,F:1,v:1,l:1});function Wm(a){this.nD=a}Wm.prototype=new XN;Wm.prototype.constructor=Wm;f=Wm.prototype;
-f.ih=function(){return 22};f.xa=function(){return Hp(Fp(),this.nD)};f.H=function(){return"JSLit"};f.G=function(){return 1};f.I=function(a){return 0===a?this.nD:JK(W(),a)};f.E=function(a){return a instanceof Wm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){return this===a?!0:a instanceof Wm?this.nD===a.nD:!1};f.$classData=q({AV:0},!1,"mlscript.JSLit",{AV:1,Oi:1,Uc:1,d:1,F:1,v:1,l:1});function Yl(a){this.oD=a}Yl.prototype=new fO;Yl.prototype.constructor=Yl;f=Yl.prototype;
-f.xa=function(){return Hp(Fp(),this.oD)};f.H=function(){return"JSNamePattern"};f.G=function(){return 1};f.I=function(a){return 0===a?this.oD:JK(W(),a)};f.E=function(a){return a instanceof Yl};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){return this===a?!0:a instanceof Yl?this.oD===a.oD:!1};f.$classData=q({CV:0},!1,"mlscript.JSNamePattern",{CV:1,fH:1,Uc:1,d:1,F:1,v:1,l:1});function Om(a){this.pD=a}Om.prototype=new XN;Om.prototype.constructor=Om;f=Om.prototype;
-f.ih=function(){return 21};f.xa=function(){return Gp(Hp(Fp(),"new "),this.pD.xa())};f.H=function(){return"JSNew"};f.G=function(){return 1};f.I=function(a){return 0===a?this.pD:JK(W(),a)};f.E=function(a){return a instanceof Om};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Om){var b=this.pD;a=a.pD;return null===b?null===a:b.h(a)}return!1};f.$classData=q({DV:0},!1,"mlscript.JSNew",{DV:1,Oi:1,Uc:1,d:1,F:1,v:1,l:1});
-function dm(a){this.qD=a}dm.prototype=new fO;dm.prototype.constructor=dm;f=dm.prototype;
-f.xa=function(){Fp();var a=this.qD,b=g=>{if(null!==g){var h=new M(g);if(!h.b()){var k=h.k.i();h=h.k.j();if(h instanceof M&&h.k instanceof gm)return Hp(Fp(),k)}}if(null!==g&&(h=new M(g),!h.b()&&(k=h.k.i(),h=h.k.j(),h instanceof M)))return g=h.k,Gp(Hp(Fp(),k+": "),g.xa());if(null!==g&&(h=new M(g),!h.b()&&(k=h.k.i(),h=h.k.j(),t().f===h)))return Hp(Fp(),k);throw new x(g);};if(a===v())b=v();else{var c=a.e(),d=c=new A(b(c),v());for(a=a.g();a!==v();){var e=a.e();e=new A(b(e),v());d=d.r=e;a=a.g()}b=c}return lz(b)};
-f.H=function(){return"JSObjectPattern"};f.G=function(){return 1};f.I=function(a){return 0===a?this.qD:JK(W(),a)};f.E=function(a){return a instanceof dm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof dm){var b=this.qD;a=a.qD;return null===b?null===a:b.h(a)}return!1};f.$classData=q({EV:0},!1,"mlscript.JSObjectPattern",{EV:1,fH:1,Uc:1,d:1,F:1,v:1,l:1});function Lo(a){this.rD=a}Lo.prototype=new XN;Lo.prototype.constructor=Lo;f=Lo.prototype;
-f.ih=function(){return 0};f.xa=function(){return Jp(this.rD,0)};f.H=function(){return"JSParenthesis"};f.G=function(){return 1};f.I=function(a){return 0===a?this.rD:JK(W(),a)};f.E=function(a){return a instanceof Lo};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Lo){var b=this.rD;a=a.rD;return null===b?null===a:b.h(a)}return!1};f.$classData=q({FV:0},!1,"mlscript.JSParenthesis",{FV:1,Oi:1,Uc:1,d:1,F:1,v:1,l:1});
-function fo(a,b){this.sD=a;this.tD=b}fo.prototype=new XN;fo.prototype.constructor=fo;f=fo.prototype;f.ih=function(){return 22};
-f.xa=function(){Fp();var a=this.sD,b=g=>{if(null!==g){var h=g.i();g=g.j();return Gp(Hp(Fp(),$l(cm(),h)+": "),Jp(g,Kp().fz))}throw new x(g);};if(a===v())b=v();else{var c=a.e(),d=c=new A(b(c),v());for(a=a.g();a!==v();){var e=a.e();e=new A(b(e),v());d=d.r=e;a=a.g()}b=c}a=this.tD;if(a===v())c=v();else for(c=a.e(),d=c=new A(c.xa(),v()),a=a.g();a!==v();)e=a.e(),e=new A(e.xa(),v()),d=d.r=e,a=a.g();return lz(mn(b,c))};f.H=function(){return"JSRecord"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.sD;case 1:return this.tD;default:return JK(W(),a)}};f.E=function(a){return a instanceof fo};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof fo){var b=this.sD,c=a.sD;if(null===b?null===c:b.h(c))return b=this.tD,a=a.tD,null===b?null===a:b.h(a)}return!1};f.$classData=q({GV:0},!1,"mlscript.JSRecord",{GV:1,Oi:1,Uc:1,d:1,F:1,v:1,l:1});function so(a){this.uD=a}so.prototype=new hO;
-so.prototype.constructor=so;f=so.prototype;f.xa=function(){var a=this.uD;if(a instanceof M)a=a.k,a=Gp(Hp(Fp(),"return "),fz(a.xa()));else{if(R()!==a)throw new x(a);a=Hp(Fp(),"return")}return Gp(a,Fp().bx)};f.H=function(){return"JSReturnStmt"};f.G=function(){return 1};f.I=function(a){return 0===a?this.uD:JK(W(),a)};f.E=function(a){return a instanceof so};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof so){var b=this.uD;a=a.uD;return null===b?null===a:b.h(a)}return!1};f.$classData=q({HV:0},!1,"mlscript.JSReturnStmt",{HV:1,Cl:1,Uc:1,d:1,F:1,v:1,l:1});function ZN(a,b,c){this.zD=a;this.xD=b;this.yD=c}ZN.prototype=new hO;ZN.prototype.constructor=ZN;f=ZN.prototype;
-f.xa=function(){for(var a=Gp(Gp(Hp(Fp(),"switch ("),this.zD.xa()),Hp(Fp(),") {")),b=this.xD,c=Fp().ce;!b.b();){var d=b.e();c=az(c,cz(d.xa()));b=b.g()}a=az(a,c);b=this.yD;if(b instanceof M)b=az(cz(b.k.xa()),Hp(Fp(),"}"));else{if(t().f!==b)throw new x(b);b=Hp(Fp(),"}")}return az(a,b)};f.H=function(){return"JSSwitchStmt"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.zD;case 1:return this.xD;case 2:return this.yD;default:return JK(W(),a)}};f.E=function(a){return a instanceof ZN};
-f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof ZN){var b=this.zD,c=a.zD;if(null===b?null===c:b.h(c))if(b=this.xD,c=a.xD,null===b?null===c:b.h(c))return b=this.yD,a=a.yD,null===b?null===a:b.h(a)}return!1};f.$classData=q({JV:0},!1,"mlscript.JSSwitchStmt",{JV:1,Cl:1,Uc:1,d:1,F:1,v:1,l:1});function cn(a,b,c){this.CD=a;this.BD=b;this.AD=c}cn.prototype=new XN;cn.prototype.constructor=cn;f=cn.prototype;f.ih=function(){return 4};
-f.xa=function(){return Gp(Gp(Gp(Gp(Jp(this.CD,4),Hp(Fp()," ? ")),Jp(this.BD,4)),Hp(Fp()," : ")),Jp(this.AD,4))};f.H=function(){return"JSTenary"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.CD;case 1:return this.BD;case 2:return this.AD;default:return JK(W(),a)}};f.E=function(a){return a instanceof cn};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof cn){var b=this.CD,c=a.CD;if(null===b?null===c:b.h(c))if(b=this.BD,c=a.BD,null===b?null===c:b.h(c))return b=this.AD,a=a.AD,null===b?null===a:b.h(a)}return!1};f.$classData=q({KV:0},!1,"mlscript.JSTenary",{KV:1,Oi:1,Uc:1,d:1,F:1,v:1,l:1});function Qm(a){this.DD=a}Qm.prototype=new hO;Qm.prototype.constructor=Qm;f=Qm.prototype;f.xa=function(){return Gp(Gp(Hp(Fp(),"throw "),fz(this.DD.xa())),Fp().bx)};f.H=function(){return"JSThrowStmt"};f.G=function(){return 1};
-f.I=function(a){return 0===a?this.DD:JK(W(),a)};f.E=function(a){return a instanceof Qm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Qm){var b=this.DD;a=a.DD;return null===b?null===a:b.h(a)}return!1};f.$classData=q({LV:0},!1,"mlscript.JSThrowStmt",{LV:1,Cl:1,Uc:1,d:1,F:1,v:1,l:1});function Qy(a,b){this.ED=a;this.FD=b}Qy.prototype=new hO;Qy.prototype.constructor=Qy;f=Qy.prototype;
-f.xa=function(){for(var a=Hp(Fp(),"try "),b=this.ED,c=Fp().ce;!b.b();){var d=b.e();c=az(c,d.xa());b=b.g()}return Gp(Gp(a,gz(c)),this.FD.xa())};f.H=function(){return"JSTryStmt"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.ED;case 1:return this.FD;default:return JK(W(),a)}};f.E=function(a){return a instanceof Qy};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Qy){var b=this.ED,c=a.ED;if(null===b?null===c:b.h(c))return b=this.FD,a=a.FD,null===b?null===a:b.h(a)}return!1};f.$classData=q({MV:0},!1,"mlscript.JSTryStmt",{MV:1,Cl:1,Uc:1,d:1,F:1,v:1,l:1});function My(a,b){this.nz=a;this.GD=b}My.prototype=new XN;My.prototype.constructor=My;f=My.prototype;f.ih=function(){return 15};f.xa=function(){return Gp("typeof"===this.nz?Hp(Fp(),"typeof "):Hp(Fp(),this.nz),Jp(this.GD,15))};f.H=function(){return"JSUnary"};
-f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.nz;case 1:return this.GD;default:return JK(W(),a)}};f.E=function(a){return a instanceof My};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof My&&this.nz===a.nz){var b=this.GD;a=a.GD;return null===b?null===a:b.h(a)}return!1};f.$classData=q({NV:0},!1,"mlscript.JSUnary",{NV:1,Oi:1,Uc:1,d:1,F:1,v:1,l:1});function gm(){}gm.prototype=new fO;gm.prototype.constructor=gm;
-f=gm.prototype;f.xa=function(){return Fp().ce};f.H=function(){return"JSWildcardPattern"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof gm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){return a instanceof gm};f.$classData=q({PV:0},!1,"mlscript.JSWildcardPattern",{PV:1,fH:1,Uc:1,d:1,F:1,v:1,l:1});function Jr(a){this.Ta=a}Jr.prototype=new oz;Jr.prototype.constructor=Jr;f=Jr.prototype;f.H=function(){return"KEYWORD"};
-f.G=function(){return 1};f.I=function(a){return 0===a?this.Ta:JK(W(),a)};f.E=function(a){return a instanceof Jr};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){return this===a?!0:a instanceof Jr?this.Ta===a.Ta:!1};f.$classData=q({QV:0},!1,"mlscript.KEYWORD",{QV:1,al:1,d:1,xn:1,F:1,v:1,l:1});function rr(a){this.Dw=a}rr.prototype=new oz;rr.prototype.constructor=rr;f=rr.prototype;f.H=function(){return"LITVAL"};f.G=function(){return 1};
-f.I=function(a){return 0===a?this.Dw:JK(W(),a)};f.E=function(a){return a instanceof rr};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof rr){var b=this.Dw;a=a.Dw;return null===b?null===a:b.h(a)}return!1};f.$classData=q({RV:0},!1,"mlscript.LITVAL",{RV:1,al:1,d:1,xn:1,F:1,v:1,l:1});function H2(){}H2.prototype=new oz;H2.prototype.constructor=H2;f=H2.prototype;f.H=function(){return"NEWLINE"};f.G=function(){return 0};
-f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof H2};f.y=function(){return-1731062412};f.u=function(){return"NEWLINE"};f.$classData=q({gW:0},!1,"mlscript.NEWLINE$",{gW:1,al:1,d:1,xn:1,F:1,v:1,l:1});var I2;function Gr(){I2||(I2=new H2);return I2}
-function Mda(a){if(0===(2&a.as)<<24>>24){O();var b=new $X(J(new L,[a.Zf]));b=Vq(new Wq,b);b=new Gx(b,new z(c=>sr(new E(c),pu(a.xb))),!1);b=Cu(b,new U(()=>a.ag)).mb(new U(()=>{O();var c=new $X(J(new L,[a.$f]));c=Vq(new Wq,c);c=new Gx(c,new z(d=>sr(new E(d),Av(a.xb))),!1);c=Cu(c,new U(()=>a.Sf));return new eg(c,new z(d=>"~("+d+")"))}));a.pH=Qe(b,"","\u2227","");a.as=(2|a.as)<<24>>24}return a.pH}function J2(a){return 0===(2&a.as)<<24>>24?Mda(a):a.pH}
-function FO(a,b,c,d,e){this.jN=0;this.pH=null;this.as=0;this.xb=null;this.Zf=b;this.ag=c;this.$f=d;this.Sf=e;if(null===a)throw null;this.xb=a}FO.prototype=new p;FO.prototype.constructor=FO;f=FO.prototype;f.sk=function(a){return K2(this,a)};function K2(a,b){a=J2(a);b=J2(b);return sb(a,b)}
-f.nf=function(a){var b=new z(h=>h.nf(a));if(a){Cr();Cr();var c=this.ag;if(0<=c.Q()){var d=c.Q();d=new (Nd(L2).Ja)(d);c.yc(d,0,2147483647);c=d}else{d=null;d=[];for(c=c.m();c.s();){var e=c.t();d.push(null===e?null:e)}c=new (Nd(L2).Ja)(d)}d=mu();e=ap().wa;c=nu(c,new ou(d,e));c=hG(c)}else c=this.ag.m();c=c.mb(new U(()=>{O();var h=b.n(this.$f),k=V(h.p);h=[pA(h,k,!1)];h=J(new L,h);h=new $X(h);return Vq(new Wq,h)})).mb(new U(()=>{if(a){Cr();Cr();var h=this.Sf;if(0<=h.Q()){var k=h.Q();k=new (Nd(L2).Ja)(k);
-h.yc(k,0,2147483647);h=k}else{k=null;k=[];for(h=h.m();h.s();){var l=h.t();k.push(null===l?null:l)}h=new (Nd(L2).Ja)(k)}k=mu();l=ap().wa;h=nu(h,new ou(k,l));h=hG(h)}else h=this.Sf;return h.Ga(new z(m=>{var n=V(m.p);return pA(m,n,!1)}))}));for(d=this.Zf.nf(a);c.s();){e=c.t();var g=V(d.p);d=ju(d,e,g,!1)}return d};
-function Oaa(a,b,c){Cr();Cr();var d=a.ag;if(0<=d.Q()){var e=d.Q();e=new (Nd(L2).Ja)(e);d.yc(e,0,2147483647);d=e}else{e=null;e=[];for(d=d.m();d.s();){var g=d.t();e.push(null===g?null:g)}d=new (Nd(L2).Ja)(e)}e=mu();g=ap().wa;d=nu(d,new ou(e,g));d=hG(d).mb(new U(()=>{O();var h=c.n(a.$f),k=V(h.p);h=[pA(h,k,!1)];h=J(new L,h);h=new $X(h);return Vq(new Wq,h)})).mb(new U(()=>{Cr();Cr();var h=a.Sf;if(0<=h.Q()){var k=h.Q();k=new (Nd(L2).Ja)(k);h.yc(k,0,2147483647);h=k}else{k=null;k=[];for(h=h.m();h.s();){var l=
-h.t();k.push(null===l?null:l)}h=new (Nd(L2).Ja)(k)}k=mu();l=ap().wa;h=nu(h,new ou(k,l));return hG(h).Ga(new z(m=>{var n=V(m.p);return pA(m,n,!1)}))}));for(b=b.n(a.Zf);d.s();)e=d.t(),g=V(b.p),b=ju(b,e,g,!1);return b}f.Ca=function(){0===(1&this.as)<<24>>24&&0===(1&this.as)<<24>>24&&(this.jN=this.rb(this.xb.tf,Lz().U()),this.as=(1|this.as)<<24>>24);return this.jN};
-f.rb=function(a,b){var c=this.ag.m().mb(new U(()=>this.Sf));c=new eg(c,new z(e=>e.rb(a,b)));c=Cu(c,new U(()=>{O();var e=[this.Zf.rb(a,b),this.$f.gc().rb(a,b)];e=J(new L,e);e=new $X(e);return Vq(new Wq,e)}));var d=dq();return QG(c,d)|0};
-function hX(a,b,c,d,e){var g=a.ag;g=iE().jl(g);g=ft(g,new z(u=>{u=u.Dc(b,c,d,e);if(u instanceof Ow)return t(),new te(u);if(u instanceof Uu)return t(),new me(u);Dn("Program reached and unexpected state.")}));if(null===g)throw new x(g);var h=g.i(),k=g.j();g=a.Sf;g=iE().jl(g);var l=ft(g,new z(u=>{u=u.Dc(b,c,d,e);if(u instanceof Ow)return t(),new te(u);if(u instanceof Uu)return t(),new me(u);Dn("Program reached and unexpected state.")}));if(null===l)throw new x(l);g=l.i();var m=l.j();l=a.xb;var n=baa(a.Zf,
-b,c,d,e);for(k=k.m();k.s();){var r=k.t();n=caa(n,r)}k=n;n=mu();r=ap().wa;n=new ou(n,r);h=Rz(Mu(),h,n);n=a.$f.pJ(b,c,d,e);for(a=m.m();a.s();)m=n,n=a.t(),n=faa(m,n);a=n;m=mu();n=ap().wa;m=new ou(m,n);return new FO(l,k,h,a,Rz(Mu(),g,m))}function ZX(a,b,c){return Cv(b.ag,a.ag)&&Bv(a.Zf,b.Zf,c)&&b.$f.aw(a.$f,c)?Cv(b.Sf,a.Sf):!1}
-function pda(a,b,c,d){var e=id();try{if(ZX(a,b,c))return t(),new M(b);if(ZX(b,a,c))return t(),new M(a);var g=a.Zf,h=a.ag,k=a.$f,l=a.Sf;if(pu(a.xb)===g&&null!==b){var m=b.Zf,n=b.ag,r=b.$f,u=b.Sf;if(pu(a.xb)===m&&hf(new E(h),n)&&hf(new E(l),u)){t();var w=a.xb,y=pu(a.xb),B=eaa(k,r,c);if(B.b())throw fq(new gq,e,t().f);var D=new FO(w,y,h,B.o(),l);return new M(D)}}var C=a.Zf,F=a.ag,I=a.$f,K=a.Sf;if(C instanceof eu){var N=C.lc,P=C.Jd,T=C.be,aa=C.rf;if(null!==b){var Y=b.Zf,S=b.ag,Z=b.$f,ka=b.Sf;if(Y instanceof
-eu){var X=Y.Jd,sa=Y.be,Ia=Y.rf;if(hf(new E(N),Y.lc)&&hf(new E(P),X)&&hf(new E(F),S)&&hf(new E(I),Z)&&hf(new E(K),ka))var Za=aa.eB(),Ga=hf(new E(Za),Ia.eB());else Ga=!1;if(Ga){var xa=Ov(a.xb,!0,aa,Ia,c),Ra=a.xb,Ja=kC(T.Ba,sa.Ba),La=new dv(Ra,Ja,V(a.xb));t();var pb=new FO(a.xb,new eu(a.xb,N,P,La,xa),F,I,K);return new M(pb)}}}}var Fb=a.Zf,Gb=a.ag,Hb=a.$f,tb=a.Sf;if(Fb instanceof eu){var kb=Fb.lc,gb=Fb.Jd,Vb=Fb.be,bb=Fb.rf;if(null!==b){var nb=b.Zf,Tb=b.ag,ub=b.$f,Ub=b.Sf;if(nb instanceof eu){var $a=nb.lc,
-cb=nb.be,Na=nb.rf;if(hf(new E(gb),nb.Jd)&&hf(new E(Gb),Tb)&&hf(new E(Hb),ub)&&hf(new E(tb),Ub)&&hf(new E(bb),Na)){var Ca=a.xb;if(Su(d))var Ba=Vb.Ba;else{if(kb.b())var Oa=R();else{var wa=kb.o();Oa=new M(wa.Ap().Ba)}if(Oa.b())Ba=Vb.Ba;else{var ea=Oa.o();Ba=lv(Vb.Ba,ea)}}if(Su(d))var la=cb.Ba;else{if($a.b())var Ka=R();else{var Ua=$a.o();Ka=new M(Ua.Ap().Ba)}if(Ka.b())la=cb.Ba;else{var ya=Ka.o();la=lv(cb.Ba,ya)}}var ib=kC(Ba,la),Lb=new dv(Ca,ib,V(a.xb));if(kb instanceof M){var ec=kb.k;if(ec instanceof
-yu){var Mb=ec.Mb,Jb=ec.Xb;if($a instanceof M){var Kb=$a.k;if(Kb instanceof yu){var eb=Kb.Mb,Wb=Kb.Xb;t();var mc=a.xb,ua=a.xb;t();var Pa=a.xb,xb=V(Mb.p),Yb=ju(Mb,eb,xb,!1),zb=V(Jb.p),Sb=zu(Jb,Wb,zb,!1),Ma=new yu(Pa,Yb,Sb,V(a.xb)),Ea=new FO(mc,new eu(ua,new M(Ma),gb,Lb,bb),Gb,Av(a.xb),tb);return new M(Ea)}}}}if(kb instanceof M){var ab=kb.k;if(ab instanceof Ru){var Db=ab.Ub;if($a instanceof M){var mb=$a.k;if(mb instanceof Ru){var vb=mb.Ub,Ya=Db.K();if(sr(new E(Ya),vb.K())){t();var Wa=a.xb,rb=a.xb;t();
-var pa=a.xb,Fa=ab.Mj(),Ib=mb.Mj(),qb=ab.Mj().Ua,Nb=Kv(Fa,Ib,V(qb)),fc=new fv(pa,Nb,V(a.xb)),Ac=new FO(Wa,new eu(rb,new M(fc),gb,Lb,bb),Gb,Av(a.xb),tb);return new M(Ac)}t();var tc=a.xb,vc=a.xb;t();var sc=a.xb,uc=mC(Db,vb),lc=new Ru(sc,uc,V(a.xb)),Wc=new FO(tc,new eu(vc,new M(lc),gb,Lb,bb),Gb,Av(a.xb),tb);return new M(Wc)}}}}if(kb instanceof M){var Cc=kb.k;if(Cc instanceof Ru&&$a instanceof M){var Dc=$a.k;if(Dc instanceof fv){var Ec=Dc.ld;t();var Ic=a.xb,Xc=a.xb;t();var Sc=a.xb,oc=Cc.Mj(),qc=Cc.Mj().Ua,
-Tc=Kv(oc,Ec,V(qc)),Nc=new fv(Sc,Tc,V(a.xb)),Pc=new FO(Ic,new eu(Xc,new M(Nc),gb,Lb,bb),Gb,Av(a.xb),tb);return new M(Pc)}}}if(kb instanceof M){var Oc=kb.k;if(Oc instanceof fv){var $c=Oc.ld;if($a instanceof M){var Lc=$a.k;if(Lc instanceof Ru){t();var Zb=a.xb,ed=a.xb;t();var $b=a.xb,Fc=Lc.Mj(),Yc=Lc.Mj().Ua,nc=Kv(Fc,$c,V(Yc)),Ob=new fv($b,nc,V(a.xb)),cc=new FO(Zb,new eu(ed,new M(Ob),gb,Lb,bb),Gb,Av(a.xb),tb);return new M(cc)}}}}if(kb instanceof M){var Gc=kb.k;if(Gc instanceof fv){var Bc=Gc.ld;if($a instanceof
-M){var qd=$a.k;if(qd instanceof fv){var Gd=qd.ld;t();var cd=a.xb,rd=a.xb;t();var Id=a.xb,Ha=Kv(Bc,Gd,V(Bc.Ua)),jc=new fv(Id,Ha,V(a.xb)),Rb=new FO(cd,new eu(rd,new M(jc),gb,Lb,bb),Gb,Av(a.xb),tb);return new M(Rb)}}}}var Uc=t().f===kb&&t().f===$a?!0:kb instanceof M&&kb.k instanceof yu&&$a instanceof M&&$a.k instanceof iv?!0:kb instanceof M&&kb.k instanceof iv&&$a instanceof M&&$a.k instanceof yu?!0:!1;if(Uc){t();var Rc=new FO(a.xb,new eu(a.xb,t().f,gb,Lb,bb),Gb,Av(a.xb),tb);return new M(Rc)}}}}}return t().f}catch(od){if(od instanceof
-gq){var Cd=od;if(Cd.Hg===e)return Cd.wj();throw Cd;}throw od;}}f.u=function(){return J2(this)};f.H=function(){return"Conjunct"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.Zf;case 1:return this.ag;case 2:return this.$f;case 3:return this.Sf;default:return JK(W(),a)}};f.E=function(a){return a instanceof FO};f.y=function(){return jL(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof FO&&a.xb===this.xb){var b=this.Zf,c=a.Zf;(null===b?null===c:b.h(c))?(b=this.ag,c=a.ag,b=null===b?null===c:b.h(c)):b=!1;if(b&&(b=this.$f,c=a.$f,null===b?null===c:b.h(c)))return b=this.Sf,a=a.Sf,null===b?null===a:b.h(a)}return!1};f.gl=function(a){return K2(this,a)};f.$classData=q({xW:0},!1,"mlscript.NormalForms$Conjunct",{xW:1,d:1,Wi:1,xe:1,F:1,v:1,l:1});
-function wP(){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0}wP.prototype=new C_;wP.prototype.constructor=wP;function M2(){}M2.prototype=wP.prototype;function Lr(a){this.Xw=a}Lr.prototype=new oz;Lr.prototype.constructor=Lr;f=Lr.prototype;f.H=function(){return"SELECT"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Xw:JK(W(),a)};f.E=function(a){return a instanceof Lr};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){return this===a?!0:a instanceof Lr?this.Xw===a.Xw:!1};f.$classData=q({xX:0},!1,"mlscript.SELECT",{xX:1,al:1,d:1,xn:1,F:1,v:1,l:1});function N2(){}N2.prototype=new oz;N2.prototype.constructor=N2;f=N2.prototype;f.H=function(){return"SEMI"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof N2};f.y=function(){return 2541422};f.u=function(){return"SEMI"};f.$classData=q({yX:0},!1,"mlscript.SEMI$",{yX:1,al:1,d:1,xn:1,F:1,v:1,l:1});var O2;
-function nr(){O2||(O2=new N2);return O2}function P2(){}P2.prototype=new oz;P2.prototype.constructor=P2;f=P2.prototype;f.H=function(){return"SPACE"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof P2};f.y=function(){return 79100134};f.u=function(){return"SPACE"};f.$classData=q({zX:0},!1,"mlscript.SPACE$",{zX:1,al:1,d:1,xn:1,F:1,v:1,l:1});var Q2;function lf(){Q2||(Q2=new P2);return Q2}
-function R2(){this.Cn=this.Bn=this.Dn=null;this.Vo=this.Wo=this.Dm=this.Uo=0;this.pa=null;this.q=0;this.bl=this.iq=this.mq=this.No=this.Ro=this.So=this.kq=this.Po=this.jq=this.Mo=this.Qo=this.Oo=this.lq=null;this.To=0;this.Ar=this.Up=this.Wp=this.Xp=this.Vp=this.Zp=this.Yp=null;this.nm=this.mw=0;this.Lz=this.Kz=this.bu=null}R2.prototype=new A_;R2.prototype.constructor=R2;function S2(){}S2.prototype=R2.prototype;function T2(a){null===a.Kz&&null===a.Kz&&(a.Kz=new eY(a))}
-function Nda(a){null===a.Lz&&null===a.Lz&&(a.Lz=new sz(a))}function ty(a,b,c,d){if(!et(new E(b.nb),pp())&&!et(new E(b.nb),mp()))throw dk("requirement failed: "+b.nb);var e=new Wl(b.eb.X);if(a.Qc&&sr(new E(b.eb.X),"Object")){fp();var g=Vp(new sp("Object"));b=d.fb.Y(b.eb.X);b.b()?b=R():(b=b.o(),b=new M(Jw(b)));b=b.b()?Wp():b.o();g=g.af(b)}else g=iY(d,b.eb.X);return new gu(a,e,g,c)}
-function LC(a,b,c,d){if(!et(new E(b.dj),pp())&&!et(new E(b.dj),mp()))throw dk("requirement failed: "+b.dj);return new gu(a,new Wl(b.Kl.X),iY(d,b.Kl.X),c)}function mD(a,b,c){Os(fp(),et(new E(b.dj),tp()));return new IB(a,new Wl(b.Kl.X),Wp(),c)}function ux(a,b,c,d){Os(fp(),et(new E(b.nb),tp()));var e=new Wl(b.eb.X);b=d.fb.Y(b.eb.X);b.b()?b=R():(b=b.o(),b=new M(Jw(b)));return new IB(a,e,b.b()?Wp():b.o(),c)}
-function GA(a,b,c,d){if(b instanceof uv)return GA(a,HA(b,c,!1,d),c,d);if(b instanceof nA){var e=b.cc,g=b.dc;if(!1===b.nc){b=GA(a,e,c,d);a=GA(a,g,c,d);c=b.Q()+a.Q()|0;c=Zu(Zu($u(8<c?c:8),b),a);a=ru().U();for(c=Sl(c).m();c.s();){g=c.t();d=g.i();b=a.Y(d);if(b instanceof M)b=b.k,g=av(b,g.j(),V(b.Ua));else{if(R()!==b)throw new x(b);g=g.j()}a.Vi(d,g)}c=cp();return(new cv(c)).qc(a)}}if(b instanceof dv)return a=b.Ba,ap(),bp(cp(),a);if(b instanceof sB)return GA(a,b.gc(),c,d);if(b instanceof gv){var h=b.Ye;
-return GA(a,b.Bc,c,d).uk(new z(k=>h.L(k.i())))}if(b instanceof wB)return GA(a,b.Jf,c,d);if(hv(b)||b instanceof yu||b instanceof iv||b instanceof Ow||b instanceof oA||b instanceof gA||b instanceof nA||b instanceof jv||b instanceof yB||b instanceof px||b instanceof Xu)return Jf();throw new x(b);}function Tu(){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0}Tu.prototype=new I_;Tu.prototype.constructor=Tu;function U2(){}U2.prototype=Tu.prototype;Tu.prototype.Ap=function(){return Ou(Pu(this.p))};
-Tu.prototype.Dc=function(a,b,c,d){return this.Ts(a,b,c,d)};function Lw(a,b){this.J=null;this.rh=b;ZB(this,a);b.Sa()}Lw.prototype=new NP;Lw.prototype.constructor=Lw;f=Lw.prototype;f.NP=function(){return this.rh};f.zd=function(){return this.rh.zd()};f.H=function(){return"CompletedTypeInfo"};f.G=function(){return 1};f.I=function(a){return 0===a?this.rh:JK(W(),a)};f.E=function(a){return a instanceof Lw};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Lw&&a.J===this.J){var b=this.rh;a=a.rh;return null===b?null===a:b.h(a)}return!1};f.$classData=q({wY:0},!1,"mlscript.TyperDatatypes$CompletedTypeInfo",{wY:1,JY:1,DO:1,d:1,F:1,v:1,l:1});function Ss(a){this.gP=this.fP=this.eP=null;this.iP=this.jP=0;this.kP=this.hP=null;this.Gj=0;this.ox=a;mq(this)}Ss.prototype=new p;Ss.prototype.constructor=Ss;f=Ss.prototype;
-f.Kj=function(){0===(1&this.Gj)<<24>>24&&0===(1&this.Gj)<<24>>24&&(this.eP=this.ox,this.Gj=(1|this.Gj)<<24>>24);return this.eP};function zf(a){0===(2&a.Gj)<<24>>24&&0===(2&a.Gj)<<24>>24&&(a.fP=Oca(a),a.Gj=(2|a.Gj)<<24>>24);return a.fP}f.Jm=function(){0===(4&this.Gj)<<24>>24&&0===(4&this.Gj)<<24>>24&&(this.gP=Yp(this),this.Gj=(4|this.Gj)<<24>>24);return this.gP};f.Rm=function(){return this.jP};f.Tl=function(a){this.jP=a};f.Qm=function(){return this.iP};f.Sl=function(a){this.iP=a};f.Pm=function(){return this.hP};
-f.Om=function(a){this.hP=a};f.C=function(){0===(8&this.Gj)<<24>>24&&0===(8&this.Gj)<<24>>24&&(this.kP=bq(this),this.Gj=(8|this.Gj)<<24>>24);return this.kP};f.H=function(){return"TypingUnit"};f.G=function(){return 1};f.I=function(a){return 0===a?this.ox:JK(W(),a)};f.E=function(a){return a instanceof Ss};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Ss){var b=this.ox;a=a.ox;return null===b?null===a:b.h(a)}return!1};
-f.$classData=q({uZ:0},!1,"mlscript.TypingUnit",{uZ:1,d:1,naa:1,Za:1,F:1,v:1,l:1});function V2(){this.td="value"}V2.prototype=new KN;V2.prototype.constructor=V2;f=V2.prototype;f.H=function(){return"Val"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof V2};f.y=function(){return 85761};f.u=function(){return"Val"};f.$classData=q({yZ:0},!1,"mlscript.Val$",{yZ:1,Xy:1,Vw:1,d:1,F:1,v:1,l:1});var W2;function Kw(){W2||(W2=new V2);return W2}
-function Sn(a,b){this.dA=a;this.rx=b;this.CE=a;this.mP=!1}Sn.prototype=new p;Sn.prototype.constructor=Sn;f=Sn.prototype;f.Sn=function(){return this.dA};f.ep=function(){return this.CE};f.u=function(){return"function "+this.dA};f.H=function(){return"BuiltinSymbol"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.dA;case 1:return this.rx;default:return JK(W(),a)}};f.E=function(a){return a instanceof Sn};f.y=function(){return jL(this)};
-f.h=function(a){return this===a?!0:a instanceof Sn?this.dA===a.dA&&this.rx===a.rx:!1};f.$classData=q({IZ:0},!1,"mlscript.codegen.BuiltinSymbol",{IZ:1,d:1,Gs:1,rq:1,F:1,v:1,l:1});class Am extends eF{constructor(a){super();this.DI=a;fF(this,a,null,!0)}H(){return"CodeGenError"}G(){return 1}I(a){return 0===a?this.DI:JK(W(),a)}E(a){return a instanceof Am}y(){return jL(this)}h(a){return this===a?!0:a instanceof Am?this.DI===a.DI:!1}}
-Am.prototype.$classData=q({KZ:0},!1,"mlscript.codegen.CodeGenError",{KZ:1,fd:1,jc:1,d:1,l:1,F:1,v:1});function Xn(a,b,c,d,e){this.sq=a;this.sx=b;this.tx=c;this.gA=d;this.hA=e;this.xP=!1}Xn.prototype=new p;Xn.prototype.constructor=Xn;f=Xn.prototype;f.u=function(){return"new class member "+this.sq};f.Sn=function(){return this.sq};f.ep=function(){return this.sq};f.H=function(){return"NewClassMemberSymbol"};f.G=function(){return 5};
-f.I=function(a){switch(a){case 0:return this.sq;case 1:return this.sx;case 2:return this.tx;case 3:return this.gA;case 4:return this.hA;default:return JK(W(),a)}};f.E=function(a){return a instanceof Xn};f.y=function(){var a=dc("NewClassMemberSymbol");a=W().B(-889275714,a);var b=this.sq;b=dy(W(),b);a=W().B(a,b);b=this.sx;b=dy(W(),b);a=W().B(a,b);b=this.tx?1231:1237;a=W().B(a,b);b=this.gA?1231:1237;a=W().B(a,b);b=this.hA;b=dy(W(),b);a=W().B(a,b);return W().La(a,5)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Xn&&this.tx===a.tx&&this.gA===a.gA&&this.sq===a.sq){var b=this.sx,c=a.sx;if(null===b?null===c:b.h(c))return b=this.hA,a=a.hA,null===b?null===a:b.h(a)}return!1};f.$classData=q({NZ:0},!1,"mlscript.codegen.NewClassMemberSymbol",{NZ:1,d:1,Gs:1,rq:1,F:1,v:1,l:1});function Un(a,b,c,d,e){this.yu=a;this.Hs=b;this.tA=c;this.sA=d;this.SZ=e}Un.prototype=new p;Un.prototype.constructor=Un;f=Un.prototype;f.Sn=function(){return this.yu};f.ep=function(){return this.Hs};
-f.u=function(){return"value "+this.yu};f.H=function(){return"StubValueSymbol"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.yu;case 1:return this.Hs;case 2:return this.tA;case 3:return this.sA;default:return JK(W(),a)}};f.E=function(a){return a instanceof Un};
-f.y=function(){var a=dc("StubValueSymbol");a=W().B(-889275714,a);var b=this.yu;b=dy(W(),b);a=W().B(a,b);b=this.Hs;b=dy(W(),b);a=W().B(a,b);b=this.tA?1231:1237;a=W().B(a,b);b=this.sA;b=dy(W(),b);a=W().B(a,b);return W().La(a,4)};f.h=function(a){if(this===a)return!0;if(a instanceof Un&&this.tA===a.tA&&this.yu===a.yu&&this.Hs===a.Hs){var b=this.sA;a=a.sA;return null===b?null===a:b.h(a)}return!1};f.$classData=q({RZ:0},!1,"mlscript.codegen.StubValueSymbol",{RZ:1,d:1,Gs:1,rq:1,F:1,v:1,l:1});
-function bn(a,b,c){this.tq=a;this.KI=b;this.SE=c}bn.prototype=new p;bn.prototype.constructor=bn;f=bn.prototype;f.Sn=function(){return this.tq};f.Lu=function(){return this.SE};f.u=function(){return"type "+this.tq};f.H=function(){return"TypeAliasSymbol"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.tq;case 1:return this.KI;case 2:return this.SE;default:return JK(W(),a)}};f.E=function(a){return a instanceof bn};f.y=function(){return jL(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof bn){if(this.tq===a.tq){var b=this.KI,c=a.KI;b=null===b?null===c:b.h(c)}else b=!1;if(b)return b=this.SE,a=a.SE,null===b?null===a:b.h(a)}return!1};f.$classData=q({WZ:0},!1,"mlscript.codegen.TypeAliasSymbol",{WZ:1,d:1,wA:1,rq:1,F:1,v:1,l:1});
-class Vn extends eF{constructor(a){super();this.LI=a;var b=Nl();for(a=new M(a);;){var c=a;if(c instanceof M)a=c.k,Ql(b,a.yu),a=a.sA,c=!0;else if(R()===c)c=!1;else throw new x(c);if(!c)break}a=Qe(b,"",", ","");c=a.lastIndexOf(", ")|0;a=-1<c?a.substring(0,c)+" and "+a.substring(2+c|0):a;b=b.Tg;fF(this,a+" "+(0<(1===b?0:1>b?-1:1)?"are":"is")+" not implemented",null,!0)}H(){return"UnimplementedError"}G(){return 1}I(a){return 0===a?this.LI:JK(W(),a)}E(a){return a instanceof Vn}y(){return jL(this)}h(a){if(this===
-a)return!0;if(a instanceof Vn){var b=this.LI;a=a.LI;return null===b?null===a:b.h(a)}return!1}}Vn.prototype.$classData=q({XZ:0},!1,"mlscript.codegen.UnimplementedError",{XZ:1,fd:1,jc:1,d:1,l:1,F:1,v:1});function lE(a,b){this.$e=null;this.Ax=a;this.e_=b;KD(this)}lE.prototype=new ZP;lE.prototype.constructor=lE;f=lE.prototype;f.av=function(){return this.e_};f.u=function(){return"\u00ab"+this.Ax+" is any"+ND(this)};f.H=function(){return"MatchAny"};f.G=function(){return 1};
-f.I=function(a){return 0===a?this.Ax:JK(W(),a)};f.E=function(a){return a instanceof lE};f.y=function(){return jL(this)};f.h=function(a){if(this===a)return!0;if(a instanceof lE){var b=this.Ax;a=a.Ax;return null===b?null===a:b.h(a)}return!1};f.$classData=q({d_:0},!1,"mlscript.ucs.Clause$MatchAny",{d_:1,GP:1,xA:1,d:1,F:1,v:1,l:1});function nE(a,b,c,d){this.$e=null;this.Cx=a;this.Bx=b;this.yA=c;this.UE=d;KD(this)}nE.prototype=new ZP;nE.prototype.constructor=nE;f=nE.prototype;f.av=function(){return this.UE};
-f.u=function(){return"\u00ab"+this.Cx+" is "+this.Bx+"\u00bb"+ND(this)};f.H=function(){return"MatchClass"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.Cx;case 1:return this.Bx;case 2:return this.yA;default:return JK(W(),a)}};f.E=function(a){return a instanceof nE};f.y=function(){return jL(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof nE){var b=this.Cx,c=a.Cx;if(null===b?null===c:b.h(c))if(b=this.Bx,c=a.Bx,null===b?null===c:b.h(c))return b=this.yA,a=a.yA,null===b?null===a:b.h(a)}return!1};f.$classData=q({f_:0},!1,"mlscript.ucs.Clause$MatchClass",{f_:1,GP:1,xA:1,d:1,F:1,v:1,l:1});function hE(a,b,c){this.$e=null;this.Ex=a;this.Dx=b;this.CP=c;KD(this)}hE.prototype=new ZP;hE.prototype.constructor=hE;f=hE.prototype;f.av=function(){return this.CP};
-f.u=function(){return"\u00ab"+this.Ex+" is "+this.Dx+ND(this)};f.H=function(){return"MatchLiteral"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Ex;case 1:return this.Dx;default:return JK(W(),a)}};f.E=function(a){return a instanceof hE};f.y=function(){return jL(this)};f.h=function(a){if(this===a)return!0;if(a instanceof hE){var b=this.Ex,c=a.Ex;if(null===b?null===c:b.h(c))return b=this.Dx,a=a.Dx,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({g_:0},!1,"mlscript.ucs.Clause$MatchLiteral",{g_:1,GP:1,xA:1,d:1,F:1,v:1,l:1});function aE(a){this.bi=this.Du=null;this.Is=a;$P(this)}aE.prototype=new bQ;aE.prototype.constructor=aE;f=aE.prototype;f.yb=function(){return"Consequent("+rz(this.Is,!1)+")"};f.Ss=function(){};f.Dq=function(){var a=new aE(this.Is);return jE(a,this.bi)};f.Us=function(){return!0};f.Nx=function(){return!0};
-f.Rl=function(a,b){var c=new Wo,d=pf(qf(),"Found a duplicated branch"),e=t().f;d=G(new H,d,e);ip(c,d);d=pf(qf(),"This branch");a:{if(null!==a&&(e=new M(a),!e.b())){var g=e.k.j();if(null!==e.k.i())break a}throw new x(a);}a=g.C();a=G(new H,d,a);ip(c,a);a=pf(qf(),"is subsumed by the branch here.");d=this.Is.C();a=G(new H,a,d);ip(c,a);b.n(Hq(Fq(),c.ea(),!0,Qt()))};f.cp=function(){return 0};f.H=function(){return"Consequent"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Is:JK(W(),a)};
-f.E=function(a){return a instanceof aE};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof aE){var b=this.Is;a=a.Is;return null===b?null===a:b.h(a)}return!1};f.$classData=q({q_:0},!1,"mlscript.ucs.MutCaseOf$Consequent",{q_:1,PI:1,d:1,QI:1,F:1,v:1,l:1});function WD(a,b,c){this.bi=this.Du=null;this.wq=a;this.rk=b;this.uh=c;$P(this)}WD.prototype=new bQ;WD.prototype.constructor=WD;f=WD.prototype;
-f.yb=function(){return"IfThenElse("+rz(this.wq,!1)+", whenTrue \x3d "+cQ(this.rk)+", whenFalse \x3d "+cQ(this.uh)+")"};f.Dq=function(){var a=new WD(this.wq,this.rk.Dq(),this.uh.Dq());return jE(a,this.bi)};f.Ss=function(a){this.rk.Ss(a);hf(new E(this.uh),bE())?this.uh=a:this.uh.Ss(a)};f.Us=function(){return this.rk.Us()&&this.uh.Us()};f.Nx=function(a,b){return this.rk.Nx(a,b)&&this.uh.Nx(a,b)};
-f.Rl=function(a,b,c,d,e){if(null!==a){var g=new M(a);if(!g.b()){var h=g.k.i();g=g.k.j();if(null!==h){var k=h.Pi;h=h.hj;var l=O().c;if(null===l?null===k:l.h(k)){a=this.cp(h,g,b,c,d,e);hf(new E(a),0)&&(Fq(),a=sf(new mf(new nf(J(new L,["Found a redundant else branch"]))),v()),c=g.C(),a=G(new H,a,c),c=O().c,b.n(Hq(0,new A(a,c),!0,Qt())));return}}}}if(null!==a&&(g=new M(a),!g.b()&&(h=g.k.i(),g=g.k.j(),null!==h&&(k=h.Pi,h=h.hj,k instanceof A&&(l=k.A,k=k.r,l instanceof EE&&hf(new E(l.zx),this.wq)))))){TE(this.rk,
-l.$e);this.rk.Rl(G(new H,new gE(k,h),g),b,c,d,e);return}if(null!==a&&(g=new M(a),!g.b()&&(g=g.k.i(),null!==g&&(g=g.Pi,g instanceof A)))){g=g.A;dQ(this.rk,a,c,d,e);k=this.uh;k instanceof aE?(Fq(),a=pf(qf(),"duplicated else in the if-then-else"),c=t().f,a=G(new H,a,c),c=O().c,b.n(Hq(0,new A(a,c),!0,Qt()))):bE()===k?(b=OE(),this.uh=KE(b,a.i(),a.j()),TE(this.uh,g.$e)):this.uh.Rl(a,b,c,d,e);return}throw new x(a);};
-f.cp=function(a,b,c,d,e,g){var h=this.rk.cp(a,b,c,d,e,g),k=this.uh;if(k instanceof aE)a=0;else if(bE()===k)b=new aE(b),this.uh=jE(b,a),a=1;else{if(!(k instanceof WD||k instanceof XD))throw new x(k);a=this.uh.cp(a,b,c,d,e,g)}return h+a|0};f.H=function(){return"IfThenElse"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.wq;case 1:return this.rk;case 2:return this.uh;default:return JK(W(),a)}};f.E=function(a){return a instanceof WD};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof WD){var b=this.wq,c=a.wq;if(null===b?null===c:b.h(c))if(b=this.rk,c=a.rk,null===b?null===c:b.h(c))return b=this.uh,a=a.uh,null===b?null===a:b.h(a)}return!1};f.$classData=q({r_:0},!1,"mlscript.ucs.MutCaseOf$IfThenElse",{r_:1,PI:1,d:1,QI:1,F:1,v:1,l:1});function XD(a,b,c){this.bi=this.Du=null;this.Hn=a;this.ch=b;this.ij=c;$P(this)}XD.prototype=new bQ;XD.prototype.constructor=XD;f=XD.prototype;
-f.yb=function(){var a=this.ch.K(),b=this.Hn,c=DF(Ne(),"branch",a,!0),d=this.ij;d=d.b()?"no wildcard":"wildcard \x3d "+cQ(d.o());return"Match("+b+", "+a+" "+c+", "+d+")"};f.Dq=function(){var a=this.Hn,b=this.ch.Ga(new z(d=>d.WP())),c=this.ij;c.b()?c=R():(c=c.o(),c=new M(c.Dq()));a=new XD(a,b,c);return jE(a,this.bi)};f.Ss=function(a){for(var b=this.ch.m();b.s();)b.t().Qs().Ss(a);b=this.ij;b.b()||b.o().Ss(a)};
-f.Us=function(){for(var a=!0,b=this.ch.m();a&&b.s();)a=b.t().Qs().Us();return a?(a=this.ij,a.b()?!0:a.o().Us()):!1};
-f.Nx=function(a,b){a=b.Y(a.n(this.Hn));if(R()===a)$n();else{if(a instanceof M)return a=a.k.oj(),!(new Gx(a,new z(c=>{if(c instanceof te){c=c.ca|0;for(var d=this.ch.m(),e=!1;!e&&d.s();)a:if(e=d.t(),e instanceof YD)e=!1;else{if(e instanceof ZD){var g=e.Ij;if(null!==g&&(g=new M(g),!g.b()&&(g=g.k.i(),null!==g))){e=g.w==="Tuple#"+c;break a}}throw new x(e);}return e}if(c instanceof me){c=c.ia;d=this.ch.m();for(e=!1;!e&&d.s();)a:if(e=d.t(),e instanceof YD)e=hf(new E(c),e.xq);else{if(e instanceof ZD&&(g=
-e.Ij,null!==g&&(g=new M(g),!g.b()))){e=hf(new E(c),g.k.i());break a}throw new x(e);}return e}throw new x(c);}),!0)).s();throw new x(a);}};
-f.Rl=function(a,b,c,d,e){var g=Lc=>{if(Lc instanceof FE){var Zb=Lc.zu,ed=Lc.Au;if(!1===Lc.yx){var $b=!1;for(Lc=this.bi.m();!$b&&Lc.s();){var Fc=Lc.t();a:{if(null!==Fc){$b=Fc.uq;var Yc=Fc.Hj;Fc=Fc.vq;if(IE()===$b){$b=hf(new E(Yc),Zb)&&hf(new E(Fc),ed);break a}}$b=!1}}Zb=$b}else Zb=!1;if(Zb)return!1}return!0},h=a.i().Pi;a:for(var k;;)if(h.b()){k=v();break}else{var l=h.e(),m=h.g();if(!1===!!g(l))h=m;else for(var n=h,r=m;;){if(r.b())k=n;else{var u=r.e();if(!1!==!!g(u)){r=r.g();continue}for(var w=r,y=
-new A(n.e(),v()),B=n.g(),D=y;B!==w;){var C=new A(B.e(),v());D=D.r=C;B=B.g()}for(var F=w.g(),I=F;!F.b();){var K=F.e();if(!1===!!g(K)){for(;I!==F;){var N=new A(I.e(),v());D=D.r=N;I=I.g()}I=F.g()}F=F.g()}I.b()||(D.r=I);k=y}break a}}var P=G(new H,new gE(k,a.i().hj),a.j()),T=!1,aa=null,Y=sda(P.z,this.Hn);a:if(t().f===Y)b:{var S=new M(P);if(!S.b()){var Z=S.k.i(),ka=S.k.j();if(null!==Z){var X=Z.Pi,sa=Z.hj;if(X instanceof A){var Ia=X.A,Za=X.r;if(Ia instanceof DE){var Ga=Ia.Bu,xa=Ia.Fx;if(hf(new E(Ia.Cu),
-this.Hn)){var Ra=new Wl("Tuple#"+Ga);c:{for(var Ja=this.ch.m();Ja.s();){var La=Ja.t();if(La.hF(Ra,e)){var pb=new M(La);break c}}pb=R()}c:{var Fb=t().f;var Gb=null!==Fb&&Fb===pb?!0:pb instanceof M&&pb.k instanceof YD?!0:!1;if(Gb){var Hb=OE(),tb=KE(Hb,new gE(Za,sa),ka);TE(tb,Ia.$e);var kb=this.ch,gb=iE().jl(xa),Vb=oE(new ZD(G(new H,Ra,gb),tb),Ia.DP);kb.S(Vb)}else{if(pb instanceof M){var bb=pb.k;if(bb instanceof ZD){TE(bb.dl,Ia.$e);O_(bb,xa);bb.dl.Rl(G(new H,new gE(Za,sa),ka),b,c,d,e);break c}}throw new x(pb);
-}}break b}}}}}var nb=new M(P);if(!nb.b()){var Tb=nb.k.i(),ub=nb.k.j();if(null!==Tb){var Ub=Tb.Pi,$a=Tb.hj,cb=O().c;if(null===cb?null===Ub:cb.h(Ub)){var Na=this.cp($a,ub,b,c,d,e);if(hf(new E(Na),0)){Fq();var Ca=sf(new mf(new nf(J(new L,["Found a redundant else branch"]))),v()),Ba=ub.C(),Oa=G(new H,Ca,Ba),wa=O().c;b.n(Hq(0,new A(Oa,wa),!0,Qt()))}break b}}}var ea=new M(P);if(ea.b())throw new x(P);for(var la=ea.k.i(),Ka=ea.k.j(),Ua=this.ch.m();Ua.s();)dQ(Ua.t().Qs(),G(new H,la,Ka),c,d,e);var ya=this.ij;
-if(t().f===ya){t();var ib=OE(),Lb=KE(ib,la,Ka);this.ij=new M(Lb)}else if(ya instanceof M)ya.k.Rl(G(new H,la,Ka),b,c,d,e);else throw new x(ya);}else{if(Y instanceof M){T=!0;aa=Y;var ec=aa.k;if(null!==ec){var Mb=new M(ec);if(!Mb.b()){var Jb=Mb.k.i(),Kb=Mb.k.j();if(Jb instanceof nE){var eb=Jb.Bx,Wb=Jb.yA,mc=this.ch.m(),ua=new Gx(mc,new z(Lc=>Lc.hF(eb,e)),!1);if(ua.s())for(;ua.s();){var Pa=ua.t();b:if(!(Pa instanceof YD)){if(Pa instanceof ZD){var xb=Pa,Yb=xb.Ij;if(null!==Yb){var zb=new M(Yb);if(!zb.b()){var Sb=
-zb.k.i();if(null!==Sb){Sb.w===eb.w?(TE(xb.dl,Jb.$e),O_(xb,Wb),xb.dl.Rl(G(new H,Kb,P.x),b,c,d,e)):(TE(xb.dl,Jb.$e),O_(xb,Wb),xb.dl.Rl(P,b,c,d,e));break b}}}}throw new x(Pa);}}else{var Ma=this.ij;b:{if(Ma instanceof M){var Ea=Ma.k;if(!Ea.Us()){var ab=Ea.Dq(),Db=OE();ab.Ss(KE(Db,Kb,P.x));TE(ab,Jb.$e);var mb=this.ch,vb=iE().jl(Wb),Ya=oE(new ZD(G(new H,eb,vb),ab),Jb.UE);mb.S(Ya);break b}}if(Ma instanceof M||R()===Ma){var Wa=OE(),rb=KE(Wa,Kb,P.x);TE(rb,Jb.$e);var pa=this.ch,Fa=iE().jl(Wb),Ib=oE(new ZD(G(new H,
-eb,Fa),rb),Jb.UE);pa.S(Ib)}else throw new x(Ma);}}break a}}}}if(T){var qb=aa.k;if(null!==qb){var Nb=new M(qb);if(!Nb.b()){var fc=Nb.k.i(),Ac=Nb.k.j();if(fc instanceof hE){var tc=fc.Dx;b:{for(var vc=this.ch.m();vc.s();){var sc=vc.t();if(sc.hF(tc,e)){var uc=new M(sc);break b}}uc=R()}b:{var lc=t().f;var Wc=null!==lc&&lc===uc?!0:uc instanceof M&&uc.k instanceof ZD?!0:!1;if(Wc){var Cc=OE(),Dc=KE(Cc,Ac,P.x);TE(Dc,fc.$e);var Ec=this.ch,Ic=oE(new YD(tc,Dc),fc.CP);Ec.S(Ic)}else{if(uc instanceof M){var Xc=
-uc.k;if(Xc instanceof YD){TE(Xc.Zo,fc.$e);Xc.Zo.Rl(G(new H,Ac,P.x),b,c,d,e);break b}}throw new x(uc);}}break a}}}}if(T){var Sc=aa.k;if(null!==Sc){var oc=new M(Sc);if(!oc.b()){var qc=oc.k.j();if(oc.k.i()instanceof lE){for(var Tc=this.ch.m(),Nc=new Gx(Tc,new z(Lc=>Lc.Qs().Nx(c,d)),!0);Nc.s();)dQ(Nc.t().Qs(),G(new H,qc,P.x),c,d,e);var Pc=this.ij;if(t().f===Pc){t();var Oc=OE(),$c=KE(Oc,qc,P.x);this.ij=new M($c)}else if(Pc instanceof M)Pc.k.Rl(G(new H,qc,P.x),b,c,d,e);else throw new x(Pc);break a}}}}throw new x(Y);
-}};f.cp=function(a,b,c,d,e,g){var h=this.ch.m();h=new eg(h,new z(l=>{if(l instanceof ZD)return l.dl.cp(a,b,c,d,e,g);if(l instanceof YD)return l.Zo.cp(a,b,c,d,e,g);throw new x(l);}));X2||(X2=new Y2);h=Nba(h);var k=this.ij;if(t().f===k)t(),k=new aE(b),k=jE(k,a),this.ij=new M(k),k=1;else{if(!(k instanceof M))throw new x(k);k=k.k.cp(a,b,c,d,e,g)}return(h|0)+k|0};f.H=function(){return"Match"};f.G=function(){return 3};
-f.I=function(a){switch(a){case 0:return this.Hn;case 1:return this.ch;case 2:return this.ij;default:return JK(W(),a)}};f.E=function(a){return a instanceof XD};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof XD){var b=this.Hn,c=a.Hn;if(null===b?null===c:b.h(c))if(b=this.ch,c=a.ch,null===b?null===c:Z2(b,c))return b=this.ij,a=a.ij,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({t_:0},!1,"mlscript.ucs.MutCaseOf$Match",{t_:1,PI:1,d:1,QI:1,F:1,v:1,l:1});function $2(){this.bi=this.Du=null;$P(this)}$2.prototype=new bQ;$2.prototype.constructor=$2;f=$2.prototype;f.yb=function(){return"MissingCase"};f.Ss=function(){};f.Us=function(){return!1};f.Nx=function(){return!1};f.Rl=function(){Dn("`MissingCase` is a placeholder and cannot be merged")};f.cp=function(){return 0};f.H=function(){return"MissingCase"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};
-f.E=function(a){return a instanceof $2};f.y=function(){return-1279461994};f.u=function(){return"MissingCase"};f.Dq=function(){return bE()};f.$classData=q({u_:0},!1,"mlscript.ucs.MutCaseOf$MissingCase$",{u_:1,PI:1,d:1,QI:1,F:1,v:1,l:1});var a3;function bE(){a3||(a3=new $2);return a3}function b3(){}b3.prototype=new W_;b3.prototype.constructor=b3;f=b3.prototype;f.H=function(){return"None"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof b3};f.y=function(){return 2433880};
-f.u=function(){return"None"};f.o=function(){throw iH("None.get");};f.$classData=q({u2:0},!1,"scala.None$",{u2:1,w2:1,d:1,M:1,F:1,v:1,l:1});var c3;function R(){c3||(c3=new b3);return c3}function M(a){this.k=a}M.prototype=new W_;M.prototype.constructor=M;f=M.prototype;f.o=function(){return this.k};f.H=function(){return"Some"};f.G=function(){return 1};f.I=function(a){return 0===a?this.k:JK(W(),a)};f.E=function(a){return a instanceof M};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){return this===a?!0:a instanceof M?Ol(Pl(),this.k,a.k):!1};f.$classData=q({I2:0},!1,"scala.Some",{I2:1,w2:1,d:1,M:1,F:1,v:1,l:1});class EQ extends OZ{constructor(a,b){super();Os(fp(),0<=b&&b<a.length);var c=b===(-1+a.length|0)?"at terminal":"'\\"+hd(a.charCodeAt(1+b|0))+"' not one of [\\b, \\t, \\n, \\f, \\r, \\\\, \\\", \\', \\uxxxx] at";fF(this,"invalid escape "+c+" index "+b+' in "'+a+'". Use \\\\ for literal \\.',null,!0)}}
-EQ.prototype.$classData=q({M2:0},!1,"scala.StringContext$InvalidEscapeException",{M2:1,Pj:1,ye:1,fd:1,jc:1,d:1,l:1});class FQ extends OZ{constructor(a,b){super();fF(this,"invalid unicode escape at index "+b+" of "+a,null,!0)}}FQ.prototype.$classData=q({N2:0},!1,"scala.StringContext$InvalidUnicodeEscapeException",{N2:1,Pj:1,ye:1,fd:1,jc:1,d:1,l:1});function ql(a,b){this.x=this.z=null;this.YE=a;this.SI=b;G(this,null,null)}ql.prototype=new Y_;ql.prototype.constructor=ql;f=ql.prototype;f.dF=function(){return this.YE};
-f.YI=function(){return this.SI};f.Et=function(){return new ql(this.SI,this.YE)};f.Mu=function(){return hd(this.YE)};f.j=function(){return hd(this.SI)};f.i=function(){return hd(this.YE)};f.$classData=q({Y_:0},!1,"scala.Tuple2$mcCC$sp",{Y_:1,Fu:1,d:1,$x:1,F:1,v:1,l:1});function GQ(a,b){this.x=this.z=null;this.ZE=a;this.TI=b;G(this,null,null)}GQ.prototype=new Y_;GQ.prototype.constructor=GQ;f=GQ.prototype;f.dF=function(){return this.ZE};f.Lc=function(){return this.TI};
-f.Et=function(){return new d3(this.TI,this.ZE)};f.Mu=function(){return hd(this.ZE)};f.j=function(){return this.TI};f.i=function(){return hd(this.ZE)};f.$classData=q({Z_:0},!1,"scala.Tuple2$mcCI$sp",{Z_:1,Fu:1,d:1,$x:1,F:1,v:1,l:1});function d3(a,b){this.x=this.z=null;this.$E=a;this.UI=b;G(this,null,null)}d3.prototype=new Y_;d3.prototype.constructor=d3;f=d3.prototype;f.Gx=function(){return this.$E};f.YI=function(){return this.UI};f.Et=function(){return new GQ(this.UI,this.$E)};f.Mu=function(){return this.$E};
-f.j=function(){return hd(this.UI)};f.i=function(){return this.$E};f.$classData=q({$_:0},!1,"scala.Tuple2$mcIC$sp",{$_:1,Fu:1,d:1,$x:1,F:1,v:1,l:1});function qt(a,b){this.x=this.z=null;this.bF=a;this.WI=b;G(this,null,null)}qt.prototype=new Y_;qt.prototype.constructor=qt;f=qt.prototype;f.Gx=function(){return this.bF};f.Hx=function(){return this.WI};f.Et=function(){return new e3(this.WI,this.bF)};f.Mu=function(){return this.bF};f.j=function(){return this.WI};f.i=function(){return this.bF};
-f.$classData=q({b0:0},!1,"scala.Tuple2$mcIZ$sp",{b0:1,Fu:1,d:1,$x:1,F:1,v:1,l:1});function e3(a,b){this.x=this.z=null;this.cF=a;this.XI=b;G(this,null,null)}e3.prototype=new Y_;e3.prototype.constructor=e3;f=e3.prototype;f.Xc=function(){return this.cF};f.Lc=function(){return this.XI};f.Et=function(){return new qt(this.XI,this.cF)};f.Mu=function(){return this.cF};f.j=function(){return this.XI};f.i=function(){return this.cF};
-f.$classData=q({c0:0},!1,"scala.Tuple2$mcZI$sp",{c0:1,Fu:1,d:1,$x:1,F:1,v:1,l:1});function f3(){}f3.prototype=new p;f3.prototype.constructor=f3;function g3(){}f=g3.prototype=f3.prototype;f.Ob=function(){return mK()};f.xh=function(){return this.Hc()};f.Hc=function(){return"Iterable"};f.u=function(){return l0(this)};f.vk=function(a){return this.Ob().Ib(a)};f.hi=function(){return this.Ob().Db()};f.e=function(){return this.m().t()};f.Fc=function(){return AT(this)};f.Pk=function(a){return qC(this,a)};
-f.uk=function(a){return this.qc(new h3(this,a,!1))};f.jK=function(a){var b=new h3(this,a,!0);return G(new H,this.qc(new h3(this,a,!1)),this.qc(b))};f.Cc=function(a){return BT(this,a)};f.zb=function(a){return this.qc(i3(new j3,this,a))};f.g=function(){return ET(this)};f.uJ=function(){if(this.b())throw FT();return this.zb(1)};f.Ga=function(a){return HT(this,a)};f.hl=function(a){return KT(this,a)};f.Gb=function(a){return MT(this,a)};f.ya=function(a){KG(this,a)};f.il=function(a){return Cv(this,a)};
-f.Ln=function(a){return Cx(this,a)};f.ge=function(a,b){return NA(this,a,b)};f.we=function(a,b){return ku(this,a,b)};f.Bi=function(a){return MG(this,a)};f.b=function(){return!this.m().s()};f.ka=function(){return xr(this)};f.yc=function(a,b,c){return NG(this,a,b,c)};f.Ui=function(a){return PG(this,a)};f.Ti=function(a){return QG(this,a)};f.vh=function(a,b,c,d){return RG(this,a,b,c,d)};f.ea=function(){je();return le(v(),this)};f.Li=function(){return bp(cp(),this)};f.hC=function(){return k1(nK(),this)};
-f.vj=function(a){return LA(this,a)};f.Rc=function(){return Eq(this)};f.Q=function(){return-1};f.qc=function(a){return this.vk(a)};function Yt(a,b){a.Xm=b;a.rc=0;a.ql=dG(eG(),a.Xm);return a}function Zt(){this.Xm=null;this.ql=this.rc=0}Zt.prototype=new zY;Zt.prototype.constructor=Zt;function k3(){}f=k3.prototype=Zt.prototype;f.Q=function(){return this.ql-this.rc|0};f.s=function(){return this.rc<this.ql};
-f.t=function(){try{var a=EG(eG(),this.Xm,this.rc);this.rc=1+this.rc|0;return a}catch(b){if(b instanceof NH)return qq().Oa.t();throw b;}};f.fh=function(a){if(0<a){a=this.rc+a|0;if(0>a)a=this.ql;else{var b=this.ql;a=b<a?b:a}this.rc=a}return this};f.$classData=q({fp:0},!1,"scala.collection.ArrayOps$ArrayIterator",{fp:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});function Vq(a,b){a.CK=b;a.Uq=0;a.Rj=b.K();return a}function Wq(){this.CK=null;this.Rj=this.Uq=0}Wq.prototype=new zY;Wq.prototype.constructor=Wq;
-function l3(){}f=l3.prototype=Wq.prototype;f.Q=function(){return this.Rj};f.s=function(){return 0<this.Rj};f.t=function(){if(0<this.Rj){var a=this.CK.ua(this.Uq);this.Uq=1+this.Uq|0;this.Rj=-1+this.Rj|0;return a}return qq().Oa.t()};f.fh=function(a){0<a&&(this.Uq=this.Uq+a|0,a=this.Rj-a|0,this.Rj=0>a?0:a);return this};f.fk=function(a,b){a=0>a?0:a>this.Rj?this.Rj:a;b=(0>b?0:b>this.Rj?this.Rj:b)-a|0;this.Rj=0>b?0:b;this.Uq=this.Uq+a|0;return this};
-f.$classData=q({jR:0},!1,"scala.collection.IndexedSeqView$IndexedSeqViewIterator",{jR:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});function sZ(a,b){a.DK=b;a.sj=b.K();a.iv=-1+a.sj|0;return a}function tZ(){this.DK=null;this.iv=this.sj=0}tZ.prototype=new zY;tZ.prototype.constructor=tZ;function m3(){}m3.prototype=tZ.prototype;tZ.prototype.s=function(){return 0<this.sj};tZ.prototype.t=function(){if(0<this.sj){var a=this.DK.ua(this.iv);this.iv=-1+this.iv|0;this.sj=-1+this.sj|0;return a}return qq().Oa.t()};
-tZ.prototype.fk=function(a,b){0<this.sj&&(this.sj<=a?this.sj=0:0>=a?0<=b&&b<this.sj&&(this.sj=b):(this.iv=this.iv-a|0,this.sj=0<=b&&b<this.sj?b<=a?0:b-a|0:this.sj-a|0));return this};tZ.prototype.$classData=q({kR:0},!1,"scala.collection.IndexedSeqView$IndexedSeqViewReverseIterator",{kR:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});function VT(){this.YB=null;this.YB=qq().Oa}VT.prototype=new U1;VT.prototype.constructor=VT;function Oda(a,b){a.YB=a.YB.mb(new U(()=>{qq();return new X_(b)}));return a}
-VT.prototype.S=function(a){return Oda(this,a)};VT.prototype.$classData=q({H4:0},!1,"scala.collection.Iterator$$anon$21",{H4:1,pba:1,d:1,io:1,og:1,lf:1,kf:1});function ex(a,b){this.qR=null;this.dy=0;this.rR=this.IK=null;if(null===a)throw null;this.IK=a;this.rR=b;this.dy=0}ex.prototype=new zY;ex.prototype.constructor=ex;f=ex.prototype;f.u=function(){return"\x3cfunction1\x3e"};f.n=function(){return PK()};
-f.s=function(){for(var a=PK();0===this.dy;)if(this.IK.s()){var b=this.IK.t();b=this.rR.Nb(b,this);a!==b&&(this.qR=b,this.dy=1)}else this.dy=-1;return 1===this.dy};f.t=function(){return this.s()?(this.dy=0,this.qR):qq().Oa.t()};f.$classData=q({L4:0},!1,"scala.collection.Iterator$$anon$7",{L4:1,Qa:1,d:1,Ha:1,M:1,N:1,ja:1});function n3(a,b,c){a=a.Y(b);if(a instanceof M)return a.k;if(R()===a)return Zr(c);throw new x(a);}
-function iA(a,b){var c=a.Y(b);if(R()===c)return a.kF(b);if(c instanceof M)return c.k;throw new x(c);}function o3(a,b,c){return a.yd(b,new U(()=>c.n(b)))}function p3(a){throw iH("key not found: "+a);}function q3(a,b){var c=a.pj();a=$r(b)?new LT(a,b):a.m().mb(new U(()=>b.m()));return c.Ib(a)}function r3(a,b,c,d,e){a=a.m();a=new eg(a,new z(g=>{if(null!==g)return g.i()+" -\x3e "+g.j();throw new x(g);}));return RG(a,b,c,d,e)}function s3(){this.et=null;this.et=Mu()}s3.prototype=new A0;
-s3.prototype.constructor=s3;s3.prototype.$classData=q({z5:0},!1,"scala.collection.SortedSet$",{z5:1,s5:1,p4:1,d:1,TF:1,l:1,LR:1});var t3;function u3(a,b){var c=a.hi(),d=Gn();for(a=a.m();a.s();){var e=a.t();d.eh(b.n(e))&&c.S(e)}return c.Eb()}function v3(a,b){var c=a.yk().Db();0<=a.Q()&&c.Pd(1+a.K()|0);c.S(b);c.oc(a);return c.Eb()}function wq(a,b){var c=a.yk().Db();0<=a.Q()&&c.Pd(1+a.K()|0);c.oc(a);c.S(b);return c.Eb()}function w3(a,b){var c=a.yk().Db();c.oc(a);c.oc(b);return c.Eb()}
-function x3(){this.nL=this.QR=null;this.mL=!1;y3=this;this.nL=new Z_(this)}x3.prototype=new p;x3.prototype.constructor=x3;function z3(a,b){return a instanceof A3?a:BQ(0,iQ(zG(),a,b))}f=x3.prototype;f.Vx=function(a){var b=new kF;return new fU(b,new z(c=>BQ(AQ(),LA(c,a))))};
-function BQ(a,b){if(null===b)return null;if(b instanceof jd)return new $t(b);if(b instanceof zd)return new B3(b);if(b instanceof Dd)return new C3(b);if(b instanceof Ad)return new D3(b);if(b instanceof Bd)return new E3(b);if(b instanceof td)return new F3(b);if(b instanceof vd)return new G3(b);if(b instanceof wd)return new H3(b);if(b instanceof pd)return new I3(b);if(Dh(b))return new J3(b);throw new x(b);}f.jB=function(a){return this.Vx(a)};f.Eq=function(a,b){return z3(a,b)};
-f.fg=function(){this.mL||this.mL||(this.QR=new $t(new jd(0)),this.mL=!0);return this.QR};f.$classData=q({a6:0},!1,"scala.collection.immutable.ArraySeq$",{a6:1,d:1,A5:1,n4:1,m4:1,TF:1,l:1});var y3;function AQ(){y3||(y3=new x3);return y3}function IJ(a){return!!(a&&a.$classData&&a.$classData.pb.sc)}function K3(a){this.np=0;this.nt=null;P0(this,a)}K3.prototype=new R0;K3.prototype.constructor=K3;K3.prototype.qj=function(a,b){return G(new H,a,b)};
-K3.prototype.$classData=q({T6:0},!1,"scala.collection.immutable.Map$Map2$$anon$1",{T6:1,YR:1,Qa:1,d:1,Ha:1,M:1,N:1});function L3(a){this.np=0;this.nt=null;P0(this,a)}L3.prototype=new R0;L3.prototype.constructor=L3;L3.prototype.qj=function(a){return a};L3.prototype.$classData=q({U6:0},!1,"scala.collection.immutable.Map$Map2$$anon$2",{U6:1,YR:1,Qa:1,d:1,Ha:1,M:1,N:1});function M3(a){this.np=0;this.nt=null;P0(this,a)}M3.prototype=new R0;M3.prototype.constructor=M3;M3.prototype.qj=function(a,b){return b};
-M3.prototype.$classData=q({V6:0},!1,"scala.collection.immutable.Map$Map2$$anon$3",{V6:1,YR:1,Qa:1,d:1,Ha:1,M:1,N:1});function N3(a){this.pp=0;this.op=null;S0(this,a)}N3.prototype=new U0;N3.prototype.constructor=N3;N3.prototype.qj=function(a,b){return G(new H,a,b)};N3.prototype.$classData=q({X6:0},!1,"scala.collection.immutable.Map$Map3$$anon$4",{X6:1,ZR:1,Qa:1,d:1,Ha:1,M:1,N:1});function O3(a){this.pp=0;this.op=null;S0(this,a)}O3.prototype=new U0;O3.prototype.constructor=O3;O3.prototype.qj=function(a){return a};
-O3.prototype.$classData=q({Y6:0},!1,"scala.collection.immutable.Map$Map3$$anon$5",{Y6:1,ZR:1,Qa:1,d:1,Ha:1,M:1,N:1});function P3(a){this.pp=0;this.op=null;S0(this,a)}P3.prototype=new U0;P3.prototype.constructor=P3;P3.prototype.qj=function(a,b){return b};P3.prototype.$classData=q({Z6:0},!1,"scala.collection.immutable.Map$Map3$$anon$6",{Z6:1,ZR:1,Qa:1,d:1,Ha:1,M:1,N:1});function Q3(a){this.qp=0;this.cn=null;V0(this,a)}Q3.prototype=new X0;Q3.prototype.constructor=Q3;
-Q3.prototype.qj=function(a,b){return G(new H,a,b)};Q3.prototype.$classData=q({a7:0},!1,"scala.collection.immutable.Map$Map4$$anon$7",{a7:1,$R:1,Qa:1,d:1,Ha:1,M:1,N:1});function R3(a){this.qp=0;this.cn=null;V0(this,a)}R3.prototype=new X0;R3.prototype.constructor=R3;R3.prototype.qj=function(a){return a};R3.prototype.$classData=q({b7:0},!1,"scala.collection.immutable.Map$Map4$$anon$8",{b7:1,$R:1,Qa:1,d:1,Ha:1,M:1,N:1});function S3(a){this.qp=0;this.cn=null;V0(this,a)}S3.prototype=new X0;
-S3.prototype.constructor=S3;S3.prototype.qj=function(a,b){return b};S3.prototype.$classData=q({c7:0},!1,"scala.collection.immutable.Map$Map4$$anon$9",{c7:1,$R:1,Qa:1,d:1,Ha:1,M:1,N:1});function BD(a,b,c,d){this.PB=b;this.zy=c;this.Ev=!d;this.yy=a}BD.prototype=new zY;BD.prototype.constructor=BD;f=BD.prototype;f.Q=function(){return this.Ev?1+rc(this.zy-this.yy|0,this.PB)|0:0};f.s=function(){return this.Ev};function T3(a){a.Ev||qq().Oa.t();var b=a.yy;a.Ev=b!==a.zy;a.yy=b+a.PB|0;return b}
-f.fh=function(a){if(0<a){var b=this.yy,c=b>>31;a=Math.imul(this.PB,a);var d=a>>31;a=b+a|0;b=(-2147483648^a)<(-2147483648^b)?1+(c+d|0)|0:c+d|0;0<this.PB?(c=this.zy,d=c>>31,this.yy=(d===b?(-2147483648^c)<(-2147483648^a):d<b)?c:a,c=this.zy,d=c>>31,this.Ev=b===d?(-2147483648^a)<=(-2147483648^c):b<d):0>this.PB&&(c=this.zy,d=c>>31,this.yy=(d===b?(-2147483648^c)>(-2147483648^a):d>b)?c:a,c=this.zy,d=c>>31,this.Ev=b===d?(-2147483648^a)>=(-2147483648^c):b>d)}return this};f.t=function(){return T3(this)};
-f.$classData=q({u7:0},!1,"scala.collection.immutable.RangeIterator",{u7:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});function U3(a,b,c){this.fn=this.Gv=this.Ay=null;this.Ed=0;this.zc=null;f1(this,a,b,c)}U3.prototype=new i1;U3.prototype.constructor=U3;U3.prototype.gK=function(a){return G(new H,a.Wa,a.Tb)};U3.prototype.$classData=q({w7:0},!1,"scala.collection.immutable.RedBlackTree$EntriesIterator",{w7:1,gS:1,Qa:1,d:1,Ha:1,M:1,N:1});
-function V3(a,b){this.fn=this.Gv=this.Ay=null;this.Ed=0;this.zc=null;f1(this,a,R(),b)}V3.prototype=new i1;V3.prototype.constructor=V3;V3.prototype.gK=function(){$n()};V3.prototype.$classData=q({x7:0},!1,"scala.collection.immutable.RedBlackTree$EqualsIterator",{x7:1,gS:1,Qa:1,d:1,Ha:1,M:1,N:1});function W3(a,b,c){this.fn=this.Gv=this.Ay=null;this.Ed=0;this.zc=null;f1(this,a,b,c)}W3.prototype=new i1;W3.prototype.constructor=W3;W3.prototype.gK=function(a){return a.Wa};
-W3.prototype.$classData=q({y7:0},!1,"scala.collection.immutable.RedBlackTree$KeysIterator",{y7:1,gS:1,Qa:1,d:1,Ha:1,M:1,N:1});function X3(){this.gn=this.bo=0}X3.prototype=new zY;X3.prototype.constructor=X3;function Y3(){}Y3.prototype=X3.prototype;X3.prototype.Q=function(){return this.gn};X3.prototype.s=function(){return 0<this.gn};X3.prototype.t=function(){if(this.s()){var a=this.ua(this.bo);this.bo=1+this.bo|0;this.gn=-1+this.gn|0;return a}return qq().Oa.t()};
-X3.prototype.fh=function(a){0<a&&(this.bo=this.bo+a|0,a=this.gn-a|0,this.gn=0>a?0:a);return this};function Z3(){this.et=null;this.et=xZ()}Z3.prototype=new A0;Z3.prototype.constructor=Z3;function Rz(a,b,c){if(b&&b.$classData&&b.$classData.pb.wL){O();var d=b.Wd();if(null===c?null===d:c.h(d))return b}return vT.prototype.Eq.call(a,b,c)}Z3.prototype.Eq=function(a,b){return Rz(this,a,b)};Z3.prototype.$classData=q({X7:0},!1,"scala.collection.immutable.SortedSet$",{X7:1,s5:1,p4:1,d:1,TF:1,l:1,LR:1});var $3;
-function Mu(){$3||($3=new Z3);return $3}function a4(){}a4.prototype=new p;a4.prototype.constructor=a4;function b4(){}b4.prototype=a4.prototype;a4.prototype.Pd=function(){};function c4(){this.AL=this.BL=null;d4=this;this.BL=new Z_(this);this.AL=new qQ(new jd(0))}c4.prototype=new p;c4.prototype.constructor=c4;f=c4.prototype;f.Vx=function(a){a=new e4(a.jh());return new fU(a,new z(b=>f4(pQ(),b)))};
-function f4(a,b){if(null===b)return null;if(b instanceof jd)return new qQ(b);if(b instanceof zd)return new g4(b);if(b instanceof Dd)return new h4(b);if(b instanceof Ad)return new i4(b);if(b instanceof Bd)return new j4(b);if(b instanceof td)return new rQ(b);if(b instanceof vd)return new k4(b);if(b instanceof wd)return new l4(b);if(b instanceof pd)return new m4(b);if(Dh(b))return new n4(b);throw new x(b);}f.jB=function(a){return this.Vx(a)};f.Eq=function(a,b){return f4(0,iQ(zG(),a,b))};f.fg=function(){return this.AL};
-f.$classData=q({E8:0},!1,"scala.collection.mutable.ArraySeq$",{E8:1,d:1,A5:1,n4:1,m4:1,TF:1,l:1});var d4;function pQ(){d4||(d4=new c4);return d4}function o4(a){this.xp=0;this.fo=null;this.Uv=0;this.Tv=null;N1(this,a)}o4.prototype=new P1;o4.prototype.constructor=o4;o4.prototype.PA=function(a){return G(new H,a.Kk,a.ph)};o4.prototype.$classData=q({a9:0},!1,"scala.collection.mutable.HashMap$$anon$1",{a9:1,KG:1,Qa:1,d:1,Ha:1,M:1,N:1});
-function p4(a){this.xp=0;this.fo=null;this.Uv=0;this.Tv=null;N1(this,a)}p4.prototype=new P1;p4.prototype.constructor=p4;p4.prototype.PA=function(a){return a.Kk};p4.prototype.$classData=q({b9:0},!1,"scala.collection.mutable.HashMap$$anon$2",{b9:1,KG:1,Qa:1,d:1,Ha:1,M:1,N:1});function q4(a){this.xp=0;this.fo=null;this.Uv=0;this.Tv=null;N1(this,a)}q4.prototype=new P1;q4.prototype.constructor=q4;q4.prototype.PA=function(a){return a.ph};
-q4.prototype.$classData=q({c9:0},!1,"scala.collection.mutable.HashMap$$anon$3",{c9:1,KG:1,Qa:1,d:1,Ha:1,M:1,N:1});function r4(a){this.xp=0;this.fo=null;this.Uv=0;this.Tv=null;N1(this,a)}r4.prototype=new P1;r4.prototype.constructor=r4;r4.prototype.PA=function(a){return a};r4.prototype.$classData=q({d9:0},!1,"scala.collection.mutable.HashMap$$anon$4",{d9:1,KG:1,Qa:1,d:1,Ha:1,M:1,N:1});
-function s4(a){this.xp=0;this.fo=null;this.Uv=0;this.Tv=null;this.EL=0;if(null===a)throw null;N1(this,a);this.EL=0}s4.prototype=new P1;s4.prototype.constructor=s4;s4.prototype.y=function(){return this.EL};s4.prototype.PA=function(a){var b=kL(),c=a.bk;a=a.ph;this.EL=fS(b,c^(c>>>16|0),dy(W(),a));return this};s4.prototype.$classData=q({e9:0},!1,"scala.collection.mutable.HashMap$$anon$5",{e9:1,KG:1,Qa:1,d:1,Ha:1,M:1,N:1});function t4(a){this.Bt=0;this.jr=null;this.XB=0;this.WB=null;Q1(this,a)}
-t4.prototype=new S1;t4.prototype.constructor=t4;t4.prototype.kJ=function(a){return a.Lk};t4.prototype.$classData=q({j9:0},!1,"scala.collection.mutable.HashSet$$anon$1",{j9:1,yS:1,Qa:1,d:1,Ha:1,M:1,N:1});function u4(a){this.Bt=0;this.jr=null;this.XB=0;this.WB=null;Q1(this,a)}u4.prototype=new S1;u4.prototype.constructor=u4;u4.prototype.kJ=function(a){return a};u4.prototype.$classData=q({k9:0},!1,"scala.collection.mutable.HashSet$$anon$2",{k9:1,yS:1,Qa:1,d:1,Ha:1,M:1,N:1});
-function v4(a){this.Bt=0;this.jr=null;this.XB=0;this.WB=null;this.FL=0;if(null===a)throw null;Q1(this,a);this.FL=0}v4.prototype=new S1;v4.prototype.constructor=v4;v4.prototype.y=function(){return this.FL};v4.prototype.kJ=function(a){this.FL=w4(a.ck);return this};v4.prototype.$classData=q({l9:0},!1,"scala.collection.mutable.HashSet$$anon$3",{l9:1,yS:1,Qa:1,d:1,Ha:1,M:1,N:1});function x4(a,b,c,d){this.yp=this.fC=this.Ky=null;h2(this,a,b,c,d)}x4.prototype=new j2;x4.prototype.constructor=x4;
-x4.prototype.hK=function(a){return G(new H,a.ho,a.lr)};x4.prototype.$classData=q({P9:0},!1,"scala.collection.mutable.RedBlackTree$EntriesIterator",{P9:1,QS:1,Qa:1,d:1,Ha:1,M:1,N:1});function y4(a,b,c,d){this.yp=this.fC=this.Ky=null;h2(this,a,b,c,d)}y4.prototype=new j2;y4.prototype.constructor=y4;y4.prototype.hK=function(a){return a.ho};y4.prototype.$classData=q({Q9:0},!1,"scala.collection.mutable.RedBlackTree$KeysIterator",{Q9:1,QS:1,Qa:1,d:1,Ha:1,M:1,N:1});
-function z4(a,b,c,d){this.yp=this.fC=this.Ky=null;h2(this,a,b,c,d)}z4.prototype=new j2;z4.prototype.constructor=z4;z4.prototype.hK=function(a){return a.lr};z4.prototype.$classData=q({T9:0},!1,"scala.collection.mutable.RedBlackTree$ValuesIterator",{T9:1,QS:1,Qa:1,d:1,Ha:1,M:1,N:1});function ou(a,b){this.U2=b}ou.prototype=new p;ou.prototype.constructor=ou;f=ou.prototype;f.Qj=function(a,b){return 0>=this.Fa(a,b)};f.xk=function(a,b){return 0<=this.Fa(a,b)};f.wk=function(a,b){return 0<this.Fa(a,b)};
-f.lj=function(a,b){return n2(this,a,b)};f.nl=function(a,b){return o2(this,a,b)};f.ol=function(a,b){return p2(this,a,b)};f.Nj=function(a){return q2(this,a)};f.Fa=function(a,b){return ob(this.U2.n(a),b)};f.$classData=q({T2:0},!1,"scala.math.LowPriorityOrderingImplicits$$anon$2",{T2:1,d:1,Um:1,Si:1,Wm:1,Tm:1,l:1});function PY(a,b){this.uK=this.ZQ=null;if(null===a)throw null;this.ZQ=a;this.uK=b}PY.prototype=new p;PY.prototype.constructor=PY;f=PY.prototype;f.Qj=function(a,b){return 0>=this.Fa(a,b)};
-f.xk=function(a,b){return 0<=this.Fa(a,b)};f.wk=function(a,b){return 0<this.Fa(a,b)};f.lj=function(a,b){return n2(this,a,b)};f.nl=function(a,b){return o2(this,a,b)};f.ol=function(a,b){return p2(this,a,b)};f.Nj=function(a){return q2(this,a)};f.Fa=function(a,b){return this.ZQ.Fa(this.uK.n(a),this.uK.n(b))};f.$classData=q({$2:0},!1,"scala.math.Ordering$$anon$1",{$2:1,d:1,Um:1,Si:1,Wm:1,Tm:1,l:1});function hD(a,b){this.NF=a;this.at=b}hD.prototype=new p;hD.prototype.constructor=hD;f=hD.prototype;
-f.lj=function(a,b){return n2(this,a,b)};f.nl=function(a,b){return o2(this,a,b)};f.ol=function(a,b){return p2(this,a,b)};f.Nj=function(a){return q2(this,a)};f.Fa=function(a,b){return this.NF.Fa(this.at.n(a),this.at.n(b))};f.wk=function(a,b){return this.NF.wk(this.at.n(a),this.at.n(b))};f.xk=function(a,b){return this.NF.xk(this.at.n(a),this.at.n(b))};f.Qj=function(a,b){return this.NF.Qj(this.at.n(a),this.at.n(b))};
-f.$classData=q({a3:0},!1,"scala.math.Ordering$$anon$5",{a3:1,d:1,Um:1,Si:1,Wm:1,Tm:1,l:1});function r2(a){this.Vm=a}r2.prototype=new p;r2.prototype.constructor=r2;f=r2.prototype;f.Nj=function(a){var b=this.Vm;return null===a?null===b:a.h(b)};f.Fa=function(a,b){return this.Vm.Fa(b,a)};f.Qj=function(a,b){return this.Vm.Qj(b,a)};f.xk=function(a,b){return this.Vm.xk(b,a)};f.wk=function(a,b){return this.Vm.wk(b,a)};f.lj=function(a,b){return this.Vm.lj(b,a)};f.nl=function(a,b){return this.Vm.ol(a,b)};
-f.ol=function(a,b){return this.Vm.nl(a,b)};f.h=function(a){if(null!==a&&this===a)return!0;if(a instanceof r2){var b=this.Vm;a=a.Vm;return null===b?null===a:b.h(a)}return!1};f.y=function(){return Math.imul(41,this.Vm.y())};f.$classData=q({h3:0},!1,"scala.math.Ordering$Reverse",{h3:1,d:1,Um:1,Si:1,Wm:1,Tm:1,l:1});function fT(a,b){this.OF=a;this.PF=b}fT.prototype=new p;fT.prototype.constructor=fT;f=fT.prototype;f.Qj=function(a,b){return 0>=this.Fa(a,b)};f.xk=function(a,b){return 0<=this.Fa(a,b)};
-f.wk=function(a,b){return 0<this.Fa(a,b)};f.lj=function(a,b){return n2(this,a,b)};f.nl=function(a,b){return o2(this,a,b)};f.ol=function(a,b){return p2(this,a,b)};f.Nj=function(a){return q2(this,a)};f.h=function(a){if(null!==a&&this===a)return!0;if(a instanceof fT){var b=this.OF,c=a.OF;if(null===b?null===c:b.h(c))return b=this.PF,a=a.PF,null===b?null===a:b.h(a)}return!1};
-f.y=function(){var a=this.OF,b=this.PF,c=kL();var d=c.B(-889275714,dc("Tuple2"));for(var e=0;2>e;){var g=e;switch(g){case 0:g=a;break;case 1:g=b;break;default:throw KK(new LK,g+" is out of bounds (min 0, max 1)");}d=c.B(d,dy(W(),g));e=1+e|0}return c.La(d,2)};f.Fa=function(a,b){var c=this.OF.Fa(a.i(),b.i());return 0!==c?c:this.PF.Fa(a.j(),b.j())};f.$classData=q({k3:0},!1,"scala.math.Ordering$Tuple2Ordering",{k3:1,d:1,Um:1,Si:1,Wm:1,Tm:1,l:1});function KA(a){this.QF=a}KA.prototype=new p;
-KA.prototype.constructor=KA;f=KA.prototype;f.E=function(a){return!!(a&&a.$classData&&a.$classData.pb.zk)};f.h=function(a){if(a&&a.$classData&&a.$classData.pb.zk){var b=this.jh();a=a.jh();b=b===a}else b=!1;return b};f.y=function(){var a=this.QF;return dy(W(),a)};f.u=function(){return Lda(this,this.QF)};f.jh=function(){return this.QF};f.gi=function(a){var b=this.QF;return Fh(Jh(),b,a)};f.$classData=q({p3:0},!1,"scala.reflect.ClassTag$GenericClassTag",{p3:1,d:1,zk:1,Xl:1,Zl:1,l:1,v:1});
-function A4(){}A4.prototype=new NZ;A4.prototype.constructor=A4;function B4(){}B4.prototype=A4.prototype;A4.prototype.bJ=function(a){a=null===a?"null":pc(a);Af(this,null===a?"null":a)};class zM extends C2{constructor(a){super();this.e1=a;fF(this,null,null,!0);if(null===a)throw ze();}mj(){return"Flags \x3d '"+this.e1+"'"}}zM.prototype.$classData=q({d1:0},!1,"java.util.DuplicateFormatFlagsException",{d1:1,bp:1,Pj:1,ye:1,fd:1,jc:1,d:1,l:1});
-class MW extends C2{constructor(a,b){super();this.h1=a;this.g1=b;fF(this,null,null,!0);if(null===a)throw ze();}mj(){return"Conversion \x3d "+hd(this.g1)+", Flags \x3d "+this.h1}}MW.prototype.$classData=q({f1:0},!1,"java.util.FormatFlagsConversionMismatchException",{f1:1,bp:1,Pj:1,ye:1,fd:1,jc:1,d:1,l:1});class HM extends C2{constructor(a){super();this.y1=a;fF(this,null,null,!0)}mj(){return this.y1}}
-HM.prototype.$classData=q({x1:0},!1,"java.util.IllegalFormatArgumentIndexException",{x1:1,bp:1,Pj:1,ye:1,fd:1,jc:1,d:1,l:1});class LM extends C2{constructor(a){super();this.A1=a;fF(this,null,null,!0)}mj(){return"Code point \x3d 0x"+(+(this.A1>>>0)).toString(16)}}LM.prototype.$classData=q({z1:0},!1,"java.util.IllegalFormatCodePointException",{z1:1,bp:1,Pj:1,ye:1,fd:1,jc:1,d:1,l:1});
-class NW extends C2{constructor(a,b){super();this.D1=a;this.C1=b;fF(this,null,null,!0);if(null===b)throw ze();}mj(){return String.fromCharCode(this.D1)+" !\x3d "+this.C1.ei.name}}NW.prototype.$classData=q({B1:0},!1,"java.util.IllegalFormatConversionException",{B1:1,bp:1,Pj:1,ye:1,fd:1,jc:1,d:1,l:1});class LW extends C2{constructor(a){super();this.F1=a;fF(this,null,null,!0);if(null===a)throw ze();}mj(){return"Flags \x3d '"+this.F1+"'"}}
-LW.prototype.$classData=q({E1:0},!1,"java.util.IllegalFormatFlagsException",{E1:1,bp:1,Pj:1,ye:1,fd:1,jc:1,d:1,l:1});class KW extends C2{constructor(a){super();this.H1=a;fF(this,null,null,!0)}mj(){return""+this.H1}}KW.prototype.$classData=q({G1:0},!1,"java.util.IllegalFormatPrecisionException",{G1:1,bp:1,Pj:1,ye:1,fd:1,jc:1,d:1,l:1});class BM extends C2{constructor(a){super();this.J1=a;fF(this,null,null,!0)}mj(){return""+this.J1}}
-BM.prototype.$classData=q({I1:0},!1,"java.util.IllegalFormatWidthException",{I1:1,bp:1,Pj:1,ye:1,fd:1,jc:1,d:1,l:1});class IM extends C2{constructor(a){super();this.M1=a;fF(this,null,null,!0);if(null===a)throw ze();}mj(){return"Format specifier '"+this.M1+"'"}}IM.prototype.$classData=q({L1:0},!1,"java.util.MissingFormatArgumentException",{L1:1,bp:1,Pj:1,ye:1,fd:1,jc:1,d:1,l:1});
-class EM extends C2{constructor(a){super();this.O1=a;fF(this,null,null,!0);if(null===a)throw ze();}mj(){return this.O1}}EM.prototype.$classData=q({N1:0},!1,"java.util.MissingFormatWidthException",{N1:1,bp:1,Pj:1,ye:1,fd:1,jc:1,d:1,l:1});class JW extends C2{constructor(a){super();this.S1=a;fF(this,null,null,!0);if(null===a)throw ze();}mj(){return"Conversion \x3d '"+this.S1+"'"}}JW.prototype.$classData=q({R1:0},!1,"java.util.UnknownFormatConversionException",{R1:1,bp:1,Pj:1,ye:1,fd:1,jc:1,d:1,l:1});
-function C4(){this.td="type alias"}C4.prototype=new YS;C4.prototype.constructor=C4;f=C4.prototype;f.H=function(){return"Als"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof C4};f.y=function(){return 65928};f.u=function(){return"Als"};f.$classData=q({vT:0},!1,"mlscript.Als$",{vT:1,fE:1,Xy:1,Vw:1,d:1,F:1,v:1,l:1});var D4;function np(){D4||(D4=new C4);return D4}
-function Im(a,b,c){this.Ry=null;this.Ty=this.Uy=0;this.Vy=this.Sy=null;this.sn=0;this.yr=a;this.xr=b;this.zr=c;mq(this)}Im.prototype=new qS;Im.prototype.constructor=Im;f=Im.prototype;f.H=function(){return"Case"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.yr;case 1:return this.xr;case 2:return this.zr;default:return JK(W(),a)}};f.E=function(a){return a instanceof Im};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Im){var b=this.yr,c=a.yr;if(null===b?null===c:b.h(c))if(b=this.xr,c=a.xr,null===b?null===c:b.h(c))return b=this.zr,a=a.zr,null===b?null===a:b.h(a)}return!1};f.$classData=q({PT:0},!1,"mlscript.Case",{PT:1,gM:1,d:1,hM:1,Za:1,F:1,v:1,l:1});function qP(a){a.gw||(a.hw=Hl(a),a.gw=!0);return a.hw}
-function Cl(){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.qo=!1;this.hw=null;this.gw=!1}Cl.prototype=new C_;Cl.prototype.constructor=Cl;function E4(){}E4.prototype=Cl.prototype;function XO(){this.vC=this.uC=null;this.xC=this.yC=0;this.zC=this.wC=null;this.Tk=0}XO.prototype=new p;XO.prototype.constructor=XO;function F4(){}f=F4.prototype=XO.prototype;
-f.yb=function(){if(this instanceof xo)var a="definition";else if(this instanceof yo)a="type declaration";else throw new x(this);return a};f.Kj=function(){return WO(this)};f.mr=function(){return lx(this)};f.Nu=function(){0===(1&this.Tk)<<24>>24&&0===(1&this.Tk)<<24>>24&&(this.uC=UO(this),this.Tk=(1|this.Tk)<<24>>24);return this.uC};f.Jm=function(){0===(2&this.Tk)<<24>>24&&0===(2&this.Tk)<<24>>24&&(this.vC=Yp(this),this.Tk=(2|this.Tk)<<24>>24);return this.vC};f.Rm=function(){return this.yC};
-f.Tl=function(a){this.yC=a};f.Qm=function(){return this.xC};f.Sl=function(a){this.xC=a};f.Pm=function(){return this.wC};f.Om=function(a){this.wC=a};f.C=function(){0===(4&this.Tk)<<24>>24&&0===(4&this.Tk)<<24>>24&&(this.zC=bq(this),this.Tk=(4|this.Tk)<<24>>24);return this.zC};
-class fg extends cg{constructor(a,b,c){super();this.BC=b;this.aH=c;this.Hp=a;fF(this,a,null,!0)}Os(){return this.BC}H(){return"ErrorReport"}G(){return 3}I(a){switch(a){case 0:return this.Hp;case 1:return this.BC;case 2:return this.aH;default:return JK(W(),a)}}E(a){return a instanceof fg}y(){return jL(this)}h(a){if(this===a)return!0;if(a instanceof fg&&this.Hp===a.Hp){var b=this.BC,c=a.BC;return(null===b?null===c:b.h(c))?this.aH===a.aH:!1}return!1}}
-fg.prototype.$classData=q({qU:0},!1,"mlscript.ErrorReport",{qU:1,kU:1,fd:1,jc:1,d:1,l:1,F:1,v:1});function st(a){this.Lr=null;this.Nr=this.Or=0;this.Pr=this.Mr=null;this.Uk=0;this.Jp=a;mq(this)}st.prototype=new sS;st.prototype.constructor=st;f=st.prototype;f.H=function(){return"IfBlock"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Jp:JK(W(),a)};f.E=function(a){return a instanceof st};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof st){var b=this.Jp;a=a.Jp;return null===b?null===a:b.h(a)}return!1};f.$classData=q({CU:0},!1,"mlscript.IfBlock",{CU:1,Zy:1,d:1,$y:1,Za:1,F:1,v:1,l:1});function Kt(a){this.Lr=null;this.Nr=this.Or=0;this.Pr=this.Mr=null;this.Uk=0;this.Qt=a;mq(this)}Kt.prototype=new sS;Kt.prototype.constructor=Kt;f=Kt.prototype;f.H=function(){return"IfElse"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Qt:JK(W(),a)};
-f.E=function(a){return a instanceof Kt};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Kt){var b=this.Qt;a=a.Qt;return null===b?null===a:b.h(a)}return!1};f.$classData=q({DU:0},!1,"mlscript.IfElse",{DU:1,Zy:1,d:1,$y:1,Za:1,F:1,v:1,l:1});function Jt(a,b,c,d){this.Lr=null;this.Nr=this.Or=0;this.Pr=this.Mr=null;this.Uk=0;this.az=a;this.pw=b;this.qw=c;this.ow=d;mq(this)}Jt.prototype=new sS;Jt.prototype.constructor=Jt;f=Jt.prototype;
-f.H=function(){return"IfLet"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.az;case 1:return this.pw;case 2:return this.qw;case 3:return this.ow;default:return JK(W(),a)}};f.E=function(a){return a instanceof Jt};f.y=function(){var a=dc("IfLet");a=W().B(-889275714,a);var b=this.az?1231:1237;a=W().B(a,b);b=this.pw;b=dy(W(),b);a=W().B(a,b);b=this.qw;b=dy(W(),b);a=W().B(a,b);b=this.ow;b=dy(W(),b);a=W().B(a,b);return W().La(a,4)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Jt){if(this.az===a.az){var b=this.pw,c=a.pw;b=null===b?null===c:b.h(c)}else b=!1;if(b&&(b=this.qw,c=a.qw,null===b?null===c:b.h(c)))return b=this.ow,a=a.ow,null===b?null===a:b.h(a)}return!1};f.$classData=q({EU:0},!1,"mlscript.IfLet",{EU:1,Zy:1,d:1,$y:1,Za:1,F:1,v:1,l:1});function kt(a,b,c){this.Lr=null;this.Nr=this.Or=0;this.Pr=this.Mr=null;this.Uk=0;this.ro=a;this.so=b;this.to=c;mq(this)}kt.prototype=new sS;kt.prototype.constructor=kt;f=kt.prototype;
-f.H=function(){return"IfOpApp"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.ro;case 1:return this.so;case 2:return this.to;default:return JK(W(),a)}};f.E=function(a){return a instanceof kt};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof kt){var b=this.ro,c=a.ro;if(null===b?null===c:b.h(c))if(b=this.so,c=a.so,null===b?null===c:b.h(c))return b=this.to,a=a.to,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({FU:0},!1,"mlscript.IfOpApp",{FU:1,Zy:1,d:1,$y:1,Za:1,F:1,v:1,l:1});function Rt(a,b){this.Lr=null;this.Nr=this.Or=0;this.Pr=this.Mr=null;this.Uk=0;this.Rt=a;this.St=b;mq(this)}Rt.prototype=new sS;Rt.prototype.constructor=Rt;f=Rt.prototype;f.H=function(){return"IfOpsApp"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Rt;case 1:return this.St;default:return JK(W(),a)}};f.E=function(a){return a instanceof Rt};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Rt){var b=this.Rt,c=a.Rt;if(null===b?null===c:b.h(c))return b=this.St,a=a.St,null===b?null===a:b.h(a)}return!1};f.$classData=q({GU:0},!1,"mlscript.IfOpsApp",{GU:1,Zy:1,d:1,$y:1,Za:1,F:1,v:1,l:1});function lt(a,b){this.Lr=null;this.Nr=this.Or=0;this.Pr=this.Mr=null;this.Uk=0;this.Kp=a;this.Lp=b;mq(this)}lt.prototype=new sS;lt.prototype.constructor=lt;f=lt.prototype;f.H=function(){return"IfThen"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.Kp;case 1:return this.Lp;default:return JK(W(),a)}};f.E=function(a){return a instanceof lt};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof lt){var b=this.Kp,c=a.Kp;if(null===b?null===c:b.h(c))return b=this.Lp,a=a.Lp,null===b?null===a:b.h(a)}return!1};f.$classData=q({HU:0},!1,"mlscript.IfThen",{HU:1,Zy:1,d:1,$y:1,Za:1,F:1,v:1,l:1});function pn(a,b){this.RC=a;this.QC=b}pn.prototype=new uS;
-pn.prototype.constructor=pn;f=pn.prototype;f.xa=function(){var a=Hp(Fp(),"get "+$l(cm(),this.RC)+"() "),b=this.QC;if(b instanceof te)b=b.ca,b=(new so((t(),new M(b)))).xa();else{if(!(b instanceof me))throw new x(b);b=b.ia;for(var c=Fp().ce;!b.b();){var d=b.e();c=az(c,d.xa());b=b.g()}b=c}return Gp(a,gz(b))};f.H=function(){return"JSClassGetter"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.RC;case 1:return this.QC;default:return JK(W(),a)}};
-f.E=function(a){return a instanceof pn};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof pn&&this.RC===a.RC){var b=this.QC;a=a.QC;return null===b?null===a:b.h(a)}return!1};f.$classData=q({eV:0},!1,"mlscript.JSClassGetter",{eV:1,fV:1,Cl:1,Uc:1,d:1,F:1,v:1,l:1});function nn(a,b,c){this.TC=a;this.UC=b;this.SC=c}nn.prototype=new uS;nn.prototype.constructor=nn;f=nn.prototype;
-f.xa=function(){var a=Gp(Gp(Hp(Fp(),$l(cm(),this.TC)),Dp(Ap(),this.UC)),Fp().Ez),b=this.SC;if(b instanceof te)b=b.ca,b=(new so((t(),new M(b)))).xa();else{if(!(b instanceof me))throw new x(b);b=b.ia;for(var c=Fp().ce;!b.b();){var d=b.e();c=az(c,d.xa());b=b.g()}b=c}return Gp(a,gz(b))};f.H=function(){return"JSClassMethod"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.TC;case 1:return this.UC;case 2:return this.SC;default:return JK(W(),a)}};
-f.E=function(a){return a instanceof nn};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof nn&&this.TC===a.TC){var b=this.UC,c=a.UC;if(null===b?null===c:b.h(c))return b=this.SC,a=a.SC,null===b?null===a:b.h(a)}return!1};f.$classData=q({gV:0},!1,"mlscript.JSClassMethod",{gV:1,fV:1,Cl:1,Uc:1,d:1,F:1,v:1,l:1});function G4(){this.td="mixin"}G4.prototype=new YS;G4.prototype.constructor=G4;f=G4.prototype;f.H=function(){return"Mxn"};f.G=function(){return 0};
-f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof G4};f.y=function(){return 77827};f.u=function(){return"Mxn"};f.$classData=q({fW:0},!1,"mlscript.Mxn$",{fW:1,fE:1,Xy:1,Vw:1,d:1,F:1,v:1,l:1});var H4;function Qo(){H4||(H4=new G4);return H4}function I4(){this.Ry=null;this.Ty=this.Uy=0;this.Vy=this.Sy=null;this.sn=0;mq(this)}I4.prototype=new qS;I4.prototype.constructor=I4;f=I4.prototype;f.H=function(){return"NoCases"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};
-f.E=function(a){return a instanceof I4};f.y=function(){return-546441758};f.u=function(){return"NoCases"};f.$classData=q({uW:0},!1,"mlscript.NoCases$",{uW:1,gM:1,d:1,hM:1,Za:1,F:1,v:1,l:1});var J4;function Nm(){J4||(J4=new I4);return J4}function K4(a){mq(a);if(a instanceof io)var b=a.eb.pr();else{if(!(a instanceof Kn))throw new x(a);b=a.Qb}a.sf=b}function Rs(){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.SD=this.TD=this.sf=null;this.xo=0}Rs.prototype=new $S;
-Rs.prototype.constructor=Rs;function L4(){}L4.prototype=Rs.prototype;Rs.prototype.yb=function(){return Ax(this)};Rs.prototype.Kj=function(){return WO(this)};Rs.prototype.mr=function(){return lx(this)};function qp(a){0===(1&a.xo)<<24>>24&&0===(1&a.xo)<<24>>24&&(a.TD=Jca(a),a.xo=(1|a.xo)<<24>>24);return a.TD}Rs.prototype.Nu=function(){0===(2&this.xo)<<24>>24&&0===(2&this.xo)<<24>>24&&(this.SD=UO(this),this.xo=(2|this.xo)<<24>>24);return this.SD};
-function Dw(a,b,c,d,e){this.ic=this.Sw=null;this.au=b;this.Hl=c;this.ik=d;this.Gl=e;PS(this,a,np())}Dw.prototype=new QS;Dw.prototype.constructor=Dw;f=Dw.prototype;f.Ca=function(){return this.au};f.or=function(){return this.Hl};f.pg=function(){return this.ik};f.zd=function(){return this.Hl.nb};f.Sa=function(){return this.Hl.eb.X};f.GF=function(){return this.Hl.eb};f.EF=function(){return Jf()};f.Iq=function(){return!this.Hl.xj.b()};f.Jq=function(){return!0};
-function Pda(a,b,c,d,e){var g=new Uv(d.V,d.Vc,d.Xa,d.kd,1+d.fa|0,d.Ac,d.vb,d.fb,d.ud,d.hb),h=a.ic;d=d.fa;var k=a.Hl,l=a.ik,m=w=>{var y=w.ec,B=w.gb.Dc(b,c,g,e);return new Ul(y,CC(B),w.xd)};if(l===v())m=v();else{var n=l.e(),r=n=new A(m(n),v());for(l=l.g();l!==v();){var u=l.e();u=new A(m(u),v());r=r.r=u;l=l.g()}m=n}return new Dw(h,d,k,m,a.Gl.Dc(b,c,g,e))}
-function Qda(a,b,c){var d=a.ic,e=a.au,g=a.Hl,h=a.ik,k=r=>{var u=r.ec,w=c.aa(t().f,r.gb);return new Ul(u,CC(w),r.xd)};if(h===v())k=v();else{var l=h.e(),m=l=new A(k(l),v());for(h=h.g();h!==v();){var n=h.e();n=new A(k(n),v());m=m.r=n;h=h.g()}k=l}return new Dw(d,e,g,k,c.aa(b,a.Gl))}
-function Rda(a,b,c){var d=a.ic,e=a.au,g=a.Hl,h=a.ik,k=r=>{var u=r.ec,w=c.aa(new mB(b),r.gb);return new Ul(u,CC(w),r.xd)};if(h===v())k=v();else{var l=h.e(),m=l=new A(k(l),v());for(h=h.g();h!==v();){var n=h.e();n=new A(k(n),v());m=m.r=n;h=h.g()}k=l}return new Dw(d,e,g,k,c.aa(b,a.Gl))}f.H=function(){return"TypedNuAls"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.au;case 1:return this.Hl;case 2:return this.ik;case 3:return this.Gl;default:return JK(W(),a)}};
-f.E=function(a){return a instanceof Dw};f.y=function(){var a=dc("TypedNuAls");a=W().B(-889275714,a);var b=this.au;a=W().B(a,b);b=this.Hl;b=dy(W(),b);a=W().B(a,b);b=this.ik;b=dy(W(),b);a=W().B(a,b);b=this.Gl;b=dy(W(),b);a=W().B(a,b);return W().La(a,4)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Dw&&a.ic===this.ic){if(this.au===a.au){var b=this.Hl,c=a.Hl;b=null===b?null===c:b.h(c)}else b=!1;if(b&&(b=this.ik,c=a.ik,null===b?null===c:b.h(c)))return b=this.Gl,a=a.Gl,null===b?null===a:HB(b,a)}return!1};f.Ql=function(a,b){return Rda(this,a,b)};f.ml=function(a,b,c){return Qda(this,a,c)};f.Mn=function(a,b,c,d){return Pda(this,a,b,c,d)};f.$classData=q({YW:0},!1,"mlscript.NuTypeDefs$TypedNuAls",{YW:1,BH:1,d:1,ms:1,Qw:1,F:1,v:1,l:1});
-function Tx(a,b,c){this.p=null;this.ok=b;this.Jl=c;if(null===a)throw null;this.p=a}Tx.prototype=new gT;Tx.prototype.constructor=Tx;function Maa(a,b,c){var d=a.p,e=a.ok;if(e===v())c=v();else{var g=e.e(),h=g=new A(uy(g,b,c),v());for(e=e.g();e!==v();){var k=e.e();k=new A(uy(k,b,c),v());h=h.r=k;e=e.g()}c=g}a=a.Jl;return new Tx(d,c,a.b()?R():new M(b.n(a.o())))}
-function XA(a,b,c,d){var e=a.p,g=a.ok;if(g===v())d=v();else{var h=g.e(),k=h=new A(h.ml(b,!0,c,d),v());for(g=g.g();g!==v();){var l=g.e();l=new A(l.ml(b,!0,c,d),v());k=k.r=l;g=g.g()}d=h}a=a.Jl;a.b()?b=R():(a=a.o(),b=new M(c.aa(b,a)));return new Tx(e,d,b)}
-function Raa(a,b,c,d){var e=a.p,g=a.ok;if(g===v())d=v();else{var h=g.e(),k=h=new A(h.Ql(b,c,d),v());for(g=g.g();g!==v();){var l=g.e();l=new A(l.Ql(b,c,d),v());k=k.r=l;g=g.g()}d=h}a=a.Jl;a.b()?b=R():(a=a.o(),b=new M(c.aa(b,a)));return new Tx(e,d,b)}f=Tx.prototype;f.u=function(){var a=wq(this.ok,this.Jl);return"TypedTypingUnit("+jF(nF(),a)+")"};f.H=function(){return"TypedTypingUnit"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.ok;case 1:return this.Jl;default:return JK(W(),a)}};f.E=function(a){return a instanceof Tx};f.y=function(){return jL(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Tx&&a.p===this.p){var b=this.ok,c=a.ok;if(null===b?null===c:b.h(c))return b=this.Jl,a=a.Jl,null===b?null===a:b.h(a)}return!1};f.$classData=q({fX:0},!1,"mlscript.NuTypeDefs$TypedTypingUnit",{fX:1,jaa:1,wg:1,d:1,xg:1,F:1,v:1,l:1});
-function Pv(){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0}Pv.prototype=new U2;Pv.prototype.constructor=Pv;function M4(){}M4.prototype=Pv.prototype;
-class gg extends cg{constructor(a,b,c){super();this.BE=b;this.CI=c;this.Hp=a;fF(this,a,null,!0)}Os(){return this.BE}H(){return"WarningReport"}G(){return 3}I(a){switch(a){case 0:return this.Hp;case 1:return this.BE;case 2:return this.CI;default:return JK(W(),a)}}E(a){return a instanceof gg}y(){return jL(this)}h(a){if(this===a)return!0;if(a instanceof gg&&this.Hp===a.Hp){var b=this.BE,c=a.BE;return(null===b?null===c:b.h(c))?this.CI===a.CI:!1}return!1}}
-gg.prototype.$classData=q({CZ:0},!1,"mlscript.WarningReport",{CZ:1,kU:1,fd:1,jc:1,d:1,l:1,F:1,v:1});function Mm(a){this.Ry=null;this.Ty=this.Uy=0;this.Vy=this.Sy=null;this.sn=0;this.qq=a;mq(this)}Mm.prototype=new qS;Mm.prototype.constructor=Mm;f=Mm.prototype;f.H=function(){return"Wildcard"};f.G=function(){return 1};f.I=function(a){return 0===a?this.qq:JK(W(),a)};f.E=function(a){return a instanceof Mm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Mm){var b=this.qq;a=a.qq;return null===b?null===a:b.h(a)}return!1};f.$classData=q({FZ:0},!1,"mlscript.Wildcard",{FZ:1,gM:1,d:1,hM:1,Za:1,F:1,v:1,l:1});function an(a,b,c,d,e){this.vA=a;this.xx=b;this.JI=c;this.wx=d;this.II=e}an.prototype=new p;an.prototype.constructor=an;f=an.prototype;f.Sn=function(){return this.vA};f.ep=function(){return this.xx};f.Lu=function(){return this.wx};f.u=function(){return"trait "+this.vA};f.H=function(){return"TraitSymbol"};
-f.G=function(){return 5};f.I=function(a){switch(a){case 0:return this.vA;case 1:return this.xx;case 2:return this.JI;case 3:return this.wx;case 4:return this.II;default:return JK(W(),a)}};f.E=function(a){return a instanceof an};f.y=function(){return jL(this)};f.h=function(a){if(this===a)return!0;if(a instanceof an&&this.vA===a.vA&&this.xx===a.xx){var b=this.JI,c=a.JI;if(null===b?null===c:b.h(c))if(b=this.wx,c=a.wx,null===b?null===c:b.h(c))return b=this.II,a=a.II,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({VZ:0},!1,"mlscript.codegen.TraitSymbol",{VZ:1,d:1,wA:1,rq:1,Gs:1,F:1,v:1,l:1});function N4(a,b){a.Hb&&mx(a,b)}function Sda(a,b,c,d){a.Hb?kx(a,b,c,d):Zr(c)}function O4(a){var b="tmp"+a.zA;a.zA=1+a.zA|0;return b}function P4(a,b){for(var c=O4(a);b.Xa.L(c);)c=O4(a);return c}function Q4(a,b,c,d,e){e.Ai(R4(a,b,d),new U(()=>ru().U()))}function Tda(a,b,c,d,e,g){g.Ai(R4(a,b,e),new U(()=>ru().U())).Ai((t(),new te(c)),new U(()=>mE(iE()))).oc(d)}
-function S4(a,b,c,d,e,g){g.Ai(R4(a,b,e),new U(()=>ru().U())).Ai((t(),new me(c)),new U(()=>mE(iE()))).oc(d)}
-function T4(a,b,c,d,e,g){var h=mE(iE());c=c.m();d=new m0(c,d);d=new ho(d,new z(k=>{if(null!==k){var l=k.i(),m=k.j();if(l instanceof Wl&&"_"===l.w)return t(),k=new Wl("_"),k=G(new H,m,k),new M(k)}if(null!==k&&(m=k.i(),l=k.j(),m instanceof Wl)){var n=m.w;n=pz(Q(),n);n.b()?n=!1:(n=n.o(),n=Eb(n),n=vD($q(),n));if(n)return t(),k=G(new H,l,m),new M(k)}if(null!==k){var r=k.i();m=k.j();if(null!==r)return k=g.Ai($D(b),new U(()=>ru().U())).Ai(m,new U(()=>{var u=new Wl(P4(a,e));return RS(u,r)})),l=G(new H,k,
-r),h.S(l),t(),k=G(new H,m,k),new M(k)}throw new x(k);}));je();d=le(v(),d);return G(new H,h.ea(),d)}function U4(a,b,c,d,e,g,h){c=c.m();c=new ho(c,new z(k=>{if(null!==k){var l=k.j();k=V4(a,k.i(),b.IP,d);var m=O().c;return W4(a,k,l,!1,d,e,g,h,m)}throw new x(k);}));je();return le(v(),c)}
-function V4(a,b,c,d){var e=()=>{if(b instanceof Wl){if(a.Hb&&a.D){var l=Hs(Q(),"| ",a.q)+"The scrutinee does not need an alias.";Af(Bf(),l+"\n")}return new tY(t().f,b,c)}if(a.AA.gF(b))l=a.AA.nF(b);else{l=new Wl(P4(a,d));l=RS(l,b);var m=a.AA.Yu,n=new uk(b),r=bd(n.Sx);b:{var u=r^(r>>>16|0);r=1+m.Xu|0;if(r>=m.SJ){var w=m.kl,y=w.a.length,B=y<<1,D=new (Nd(xN).Ja)(B);m.kl=D;m.SJ=Mc(B*m.yQ);for(B=0;B<y;){for(var C=null,F=null,I=w.a[B];null!==I;)0===(I.Rx&y)?(null===C?D.a[B]=I:C.Nq=I,C=I):(null===F?D.a[y+
-B|0]=I:F.Nq=I,F=I),I=I.Nq;null!==C&&(C.Nq=null);null!==F&&(F.Nq=null);B=1+B|0}}w=u&(-1+m.kl.a.length|0);y=m.kl.a[w];if(null===y)m.kl.a[w]=new wN(n,u,l,null,null);else{for(D=null;null!==y&&y.Rx<=u;){y.Rx===u?(D=y.bB,D=null===n?null===D:Pb(n,D)):D=!1;if(D){y.Wu=l;break b}D=y;y=y.Nq}n=new wN(n,u,l,D,y);null===D?m.kl.a[w]=n:D.Nq=n;null!==y}m.Xu=r}}a.Hb&&a.D&&(m=Hs(Q(),"| ",a.q)+"The scrutinee needs an alias: "+l,Af(Bf(),m+"\n"));return new tY((t(),new M(l)),b,c)},g=a.pa;if(a.Hb){if(a.D){var h=Hs(Q(),
-"| ",a.q)+("Making a scrutinee for `"+b)+"`";Af(Bf(),h+"\n")}a.q=1+a.q|0;try{var k=e()}finally{a.q=-1+a.q|0}Gw(new E(g),a.pa)&&a.D&&(e=""+Hs(Q(),"| ",a.q)+g.n(k),Af(Bf(),e+"\n"))}else k=e();return k}
-function W4(a,b,c,d,e,g,h,k,l){return kx(a,new U(()=>"[Desugarer.destructPattern] scrutinee \x3d "+b.dh+"; pattern \x3d "+c),new U(()=>{var m=!1,n=null,r=!1,u=null;if(c instanceof Wl&&(m=!0,n=c,"_"===n.w&&d)){Q4(a,b,Mt(Nt(),n.C()),e,h);var w=new lE(b,n.C().ea()),y=O().c;return new A(w,y)}if(m&&"_"===n.w)return O().c;if(m&&("true"===n.w||"false"===n.w)){S4(a,b,n,Mt(Nt(),n.C()),e,h);var B=n,D=b.dh.C().ea(),C=new hE(b,B,Fl(n.C().ea(),D));C.$e=vY(b).ea();N4(a,new U(()=>"Add bindings to the clause: "+
-vY(b)));var F=O().c;return new A(C,F)}if(c instanceof fm){S4(a,b,c,Mt(Nt(),c.C()),e,h);var I=b.dh.C().ea(),K=new hE(b,c,Fl(c.C().ea(),I));K.$e=vY(b).ea();N4(a,new U(()=>"Add bindings to the clause: "+vY(b)));var N=O().c;return new A(K,N)}if(m){var P=n.w,T=pz(Q(),P),aa=new z(Ob=>{Ob=Eb(Ob);return vD($q(),Ob)});if(!T.b()&&aa.n(T.o())){var Y=b.dh.C().ea(),S=Fl(n.C().ea(),Y);if(d){Q4(a,b,Mt(Nt(),n.C()),e,h);var Z=new lE(b,S),ka=new FE(n,$D(b),!d,S),X=O().c;return new A(Z,new A(ka,X))}var sa=new FE(n,
-b.dh,!d,S),Ia=O().c;return new A(sa,Ia)}}if(m){var Za=n.w,Ga=!1,xa=null,Ra=e.vb.Y(Za),Ja=new U(()=>PB(e,Za)),La=Ra.b()?Zr(Ja):Ra;a:{if(La instanceof M){Ga=!0;xa=La;var pb=xa.k;if(pb instanceof MP&&pb.J===a){var Fb=pb.zd();if(et(new E(Fb),pp()))var Gb=!0;else{var Hb=pb.zd();Gb=et(new E(Hb),mp())}if(Gb)break a}}if(Ga){var tb=xa.k;if(tb instanceof MP&&tb.J===a){var kb=tb.zd();if(et(new E(kb),tp())){var gb=new mf(new nf(J(new L,["Cannot match on trait `","`"]))),Vb=[pf(qf(),Za)];throw kT(new lT,sf(gb,
-J(new L,Vb)),n.C());}}}if(!(Ga&&xa.k instanceof bY&&xa.k.gE===a)){var bb=new mf(new nf(J(new L,["Cannot find constructor `","` in scope"]))),nb=[pf(qf(),Za)];throw kT(new lT,sf(bb,J(new L,nb)),n.C());}}N4(a,new U((Ob=>()=>"Build a Clause.MatchClass from "+b+" where pattern is "+Ob)(n)));S4(a,b,n,Mt(Nt(),n.C()),e,h);var Tb=new nE(b,n,O().c,X4()),ub=O().c;return new A(Tb,ub)}if(c instanceof mm){r=!0;u=c;var Ub=u.kb,$a=u.hc;if(Ub instanceof Wl){var cb=Ub.w;if($a instanceof im){var Na=$a.Ra,Ca=e.vb.Y(cb),
-Ba=new z(Ob=>G(new H,Ob.dj,Ob.us)),Oa=Ca.b()?R():new M(Ba.n(Ca.o())),wa=new U(()=>{var Ob=!1,cc=null,Gc=PB(e,cb);if(Gc instanceof M&&(Ob=!0,cc=Gc,Gc=cc.k,Gc instanceof Iw)){var Bc=Gc.Kb.zd();if(et(new E(Bc),pp()))return t(),Ob=Gc.Kb.zd(),cc=Rw(Gc),Gc=new U(()=>O().c),Ob=G(new H,Ob,ht(cc.b()?Zr(Gc):cc.o(),new z(qd=>qd.i().w))),new M(Ob)}if(Ob&&(Ob=cc.k,Ob instanceof Lw&&(Ob=Ob.rh,Ob instanceof Aw)))return t(),cc=Ob.yj,Gc=new U(()=>O().c),Ob=G(new H,Ob.Gf.nb,ht(cc.b()?Zr(Gc):cc.o(),new z(qd=>qd.i().w))),
-new M(Ob);Ob=new mf(new nf(J(new L,["Illegal pattern `","`"])));cc=[pf(qf(),cb)];throw kT(new lT,sf(Ob,J(new L,cc)),Ub.C());}),ea=Oa.b()?Zr(wa):Oa;if(t().f===ea){var la=new mf(new nf(J(new L,["Cannot find class `","` in scope"]))),Ka=[pf(qf(),cb)];throw kT(new lT,sf(la,J(new L,Ka)),Ub.C());}if(ea instanceof M){var Ua=ea.k;if(null!==Ua){var ya=Ua.i(),ib=Ua.j(),Lb=Na.K();if(hf(new E(Lb),ib.K())){var ec=Na.m(),Mb=T4(a,b,new eg(ec,new z(Ob=>Ob.j().Da)),ib,e,k);if(null!==Mb)var Jb=G(new H,Mb.i(),Mb.j());
-else throw new x(Mb);var Kb=Jb.i(),eb=Jb.j();S4(a,b,Ub,Mt(Nt(),u.C()),e,h);var Wb=c.C().ea(),mc=new nE(b,Ub,eb,Fl(X4(),Wb));N4(a,new U(()=>"Build a Clause.MatchClass from "+b+" where pattern is "+c));N4(a,new U(()=>"Fragments: "+l));N4(a,new U(()=>"The locations of the clause: "+mc.UE));var ua=U4(a,b,Kb,e,g,h,k);return new A(mc,ua)}var Pa=ib.K();Na.K();var xb=new mf(new nf(J(new L,"; ; expects ; ; but found ; ;".split(";")))),Yb=pf(qf(),ya.td),zb=pf(qf(),cb),Sb=pf(qf(),""+Pa),Ma=pf(qf(),DF(Ne(),"parameter",
-Pa,!1));qf();var Ea=Na.K(),ab=[Yb,zb,Sb,Ma,pf(0,""+Ea),pf(qf(),DF(Ne(),"parameter",Pa,!1))];throw kT(new lT,sf(xb,J(new L,ab)),u.C());}}throw new x(ea);}}}if(r){var Db=u.kb,mb=u.hc;if(Db instanceof mm){var vb=Db.kb,Ya=Db.hc;if(vb instanceof Wl){var Wa=vb.w;if(Ya instanceof im){var rb=Ya.Ra;if(rb instanceof A){var pa=rb.A,Fa=rb.r;if(null!==pa){var Ib=new M(pa);if(!Ib.b()){var qb=Ib.k.j();if(null!==qb){var Nb=qb.Da,fc=O().c;if((null===fc?null===Fa:fc.h(Fa))&&mb instanceof im){var Ac=mb.Ra;if(Ac instanceof
-A){var tc=Ac.A,vc=Ac.r;if(null!==tc){var sc=new M(tc);if(!sc.b()){var uc=sc.k.j();if(null!==uc){var lc=uc.Da,Wc=O().c;if(null===Wc?null===vc:Wc.h(vc)){var Cc=!1,Dc=null,Ec=e.vb.Y(Wa);if(t().f===Ec){var Ic=new mf(new nf(J(new L,["Cannot find operator `","` in the context"]))),Xc=[pf(qf(),Wa)];throw kT(new lT,sf(Ic,J(new L,Xc)),vb.C());}if(Ec instanceof M){Cc=!0;Dc=Ec;var Sc=Dc.k,oc=Sc.us.K();if(hf(new E(oc),2)){var qc=O().c,Tc=T4(a,b,new A(Nb,new A(lc,qc)),Sc.us,e,k);if(null!==Tc)var Nc=G(new H,Tc.i(),
-Tc.j());else throw new x(Tc);var Pc=Nc.i(),Oc=Nc.j();S4(a,b,vb,Mt(Nt(),u.C()),e,h);var $c=new nE(b,vb,Oc,X4());N4(a,new U(()=>"Build a Clause.MatchClass from "+b+" where operator is "+vb));var Lc=U4(a,b,Pc,e,g,h,k);return new A($c,Lc)}}if(Cc){var Zb=Dc.k;Zb.us.K();var ed=Zb.us.K(),$b=new mf(new nf(J(new L,[""," `","` expects "," "," but found two parameters"]))),Fc=[pf(qf(),Zb.dj.td),pf(qf(),Wa),pf(qf(),""+ed),pf(qf(),DF(Ne(),"parameter",ed,!1))];throw kT(new lT,sf($b,J(new L,Fc)),u.C());}throw new x(Ec);
-}}}}}}}}}}}}}}if(c instanceof hm){var Yc=c.Sh;if(Yc instanceof im)return Y4(a,Yc,b,e,k,g,h)}if(c instanceof im)return Y4(a,c,b,e,k,g,h);var nc=new nf(J(new L,["illegal pattern"]));throw kT(new lT,sf(new mf(nc),v()),c.C());}),new z(m=>"[Desugarer.destructPattern] Result: "+Qe(m,"",", ","")))}function X4(){return mE(iE()).ea()}
-var Vda=function Uda(a,b,c){var e=()=>{var l=b.rw;if(l instanceof M){var m=l.k;if(m instanceof tm)return Uda(a,m,new A(b.Qr,c))}if(c.b())return G(new H,b.Qr,l);m=Eq(new A(b.Qr,c)).m();m=new ho(m,new z(n=>{if(n instanceof st)return n.Jp;O();t();return new tQ(new te(n))}));je();m=le(v(),m);return G(new H,new st(m),l)},g=new z(l=>"[unfoldNestedIf] ("+Fg(ja(l.i()))+", "+l.j()+")");if(a.Hb){if(a.D){var h=Hs(Q(),"| ",a.q)+"[unfoldNestedIf]";Af(Bf(),h+"\n")}a.q=1+a.q|0;try{var k=e()}finally{a.q=-1+a.q|0}Gw(new E(g),
-a.pa)&&a.D&&(e=""+Hs(Q(),"| ",a.q)+g.n(k),Af(Bf(),e+"\n"))}else k=e();return k};
-function Wda(a,b,c,d,e,g){var h=()=>{var n=ru().U(),r=mE(iE()),u=mE(iE());Z4(a,b,S_(),new gE(O().c,O().c),u,r,d,e,g,n);c.b()||(n=c.o(),u=new gE(O().c,O().c),n=G(new H,u,n),r.S(n));a.Hb&&a.D&&(n=Hs(Q(),"| ",a.q)+"Decision paths:",Af(Bf(),n+"\n"));for(n=r.m();n.s();){var w=n.t();a:{if(null!==w&&(u=new M(w),!u.b())){w=u.k.i();u=u.k.j();a.Hb&&a.D&&(u=Hs(Q(),"| ",a.q)+("+ "+w+" \x3d\x3e ")+u,Af(Bf(),u+"\n"));break a}throw new x(w);}}return r.ea()},k=new z(n=>{var r=n.K();n=n.K();return"[desugarIf] produces "+
-r+" "+DF(Ne(),"path",n,!1)});if(a.Hb){if(a.D){var l=Hs(Q(),"| ",a.q)+"[desugarIf] with fallback "+c;Af(Bf(),l+"\n")}a.q=1+a.q|0;try{var m=h()}finally{a.q=-1+a.q|0}Gw(new E(k),a.pa)&&a.D&&(h=""+Hs(Q(),"| ",a.q)+k.n(m),Af(Bf(),h+"\n"))}else m=h();return m}
-function R4(a,b,c){var d=()=>{var k=b.dh;if(k instanceof Wl){var l=k.w;if(a.Hb&&a.D){var m=Hs(Q(),"| ",a.q)+"The original scrutinee is an reference.";Af(Bf(),m+"\n")}l=c.Xa.Y(l);if(l instanceof M&&(m=l.k,m instanceof Sw))return l=m.Xz.Fs,l.b()?(t(),k=new te(k.w)):(k=l.o()|0,t(),k=new me(k)),k;if(l instanceof M||t().f===l)return t(),new te(k.w);throw new x(l);}a.Hb&&a.D&&(k=Hs(Q(),"| ",a.q)+"The scrutinee was localized because it might be effectful.",Af(Bf(),k+"\n"));k=b.In;if(t().f===k)throw lS(new mS,
-"check your `makeScrutinee`");if(k instanceof M)return k=k.k,t(),new te(k.w);throw new x(k);},e=a.pa;if(a.Hb){if(a.D){var g=Hs(Q(),"| ",a.q)+"[getScrutineeKey] "+b;Af(Bf(),g+"\n")}a.q=1+a.q|0;try{var h=d()}finally{a.q=-1+a.q|0}Gw(new E(e),a.pa)&&a.D&&(d=""+Hs(Q(),"| ",a.q)+e.n(h),Af(Bf(),d+"\n"))}else h=d();return h}
-var Xda=function $4(a,b,c,d,e,g,h){Sda(a,new U(()=>"[checkExhaustive] "+b.yb()),new U(()=>{if(!(b instanceof aE)){if(bE()===b){var l=!1,m=null;if(c instanceof M){l=!0;m=c;var n=m.k;if(n instanceof WD){var r=n.wq;if(hf(new E(n.uh),b))throw l=new mf(new nf(J(new L,["The case when this is false is not handled: ",""]))),m=[pf(qf(),rz(r,!1))],kT(new lT,sf(l,J(new L,m)),r.C());Dn("`MissingCase` are not supposed to be the true branch of `IfThenElse`")}}l&&m.k instanceof XD&&Dn("`MissingCase` are not supposed to be a case of `Match`");
-a:if(c instanceof M&&c.k instanceof aE)r=!0;else{if(c instanceof M&&(r=c.k,bE()===r)){r=!0;break a}r=t().f===c?!0:!1}r&&Dn("Program reached and unexpected state.");throw new x(c);}if(b instanceof WD)r=b.rk,$4(a,b.uh,(t(),new M(b)),d,e,g,h),$4(a,r,(t(),new M(b)),d,e,g,h);else if(b instanceof XD){var u=b.Hn;r=b.ch;l=b.ij;m=!1;n=null;var w=g.Y(R4(a,u,d));a:{t().f===w&&Dn("unreachable case: unknown scrutinee "+u.dh);if(w instanceof M&&(m=!0,n=w,!l.b())){N4(a,new U(()=>"The match has a default branch. So, it is always safe."));
-break a}if(m){m=n.k;N4(a,new U(()=>"The exhaustiveness map is"));g.Ag(new Um((D,C)=>{N4(a,new U(()=>{var F=C.oj();return"- "+D+" -\x3e "+Qe(F,"",", ","")}))}));N4(a,new U(()=>"The scrutinee key is "+R4(a,u,d)));N4(a,new U(()=>"Pattern map of the scrutinee:"));m.b()?N4(a,new U(()=>"\x3cEmpty\x3e")):m.Ag(new Um((D,C)=>{N4(a,new U(()=>"- "+D+" \x3d\x3e "+C))}));fp();n=r.m();var y=Zp(0,new ho(n,new z(D=>{if(D instanceof YD)return O().c;if(D instanceof ZD){var C=D.Ij;if(null!==C&&(C=new M(C),!C.b()&&(C=
-C.k.i(),null!==C))){D=h.Y(C.w);C=new U(()=>O().c);var F=new z(I=>I);return D.b()?Zr(C):F.n(D.o())}}throw new x(D);})));N4(a,new U(()=>"The match can cover following classes"));N4(a,new U(()=>Qe(y,"{",", ","}")));n=r.m();m=m.IF(new eg(n,new z(D=>{if(D instanceof YD)return D=D.xq,t(),new me(D);if(D instanceof ZD){var C=D.Ij;if(null!==C&&(C=new M(C),!C.b())){D=C.k.i();fp();Q();C=D.w;Q();C=B2(C,"\\"+hd(35));C=Fr(C);je();C=le(v(),C);if(C instanceof A){var F=C.r;if("Tuple"===C.A&&F instanceof A){C=F.A;
-F=F.r;var I=O().c;if(null===I?null===F:I.h(F)){C=tD(uD(),C);if(t().f===C)return t(),new me(D);if(C instanceof M)return D=C.k|0,t(),new te(D);throw new x(C);}}}t();return new me(D)}}throw new x(D);}))).uk(new z(D=>{if(null!==D){var C=new M(D);if(!C.b()&&(C=C.k.i(),C instanceof me&&(C=C.ia,C instanceof Wl)))return!y.L(C.w)}if(null!==D&&(C=new M(D),!C.b()&&C.k.i()instanceof te)||null!==D&&(C=new M(D),!C.b()&&C.k.i()instanceof me))return!0;throw new x(D);}));N4(a,new U(()=>"Missing cases"));m.Ag(new Um((D,
-C)=>{N4(a,new U(()=>"- "+D+" -\x3e "+C))}));if(m.b())break a;else{var B=m.ka();r=sf(new mf(new nf(J(new L,["The match is not exhaustive."]))),v());r=G(new H,r,u.IP);l=new mf(new nf(J(new L,["The scrutinee at this position misses "," ","."])));n=[pf(qf(),""+B),pf(qf(),DF(Ne(),"case",B,!1))];l=sf(l,J(new L,n));n=u.dh.C();l=G(new H,l,n);m=m.m();m=new ko(m);m=new ho(m,new z(D=>{if(null!==D){var C=D.i(),F=D.Lc();if(null!==C){D=C.i();C=C.j();if(D instanceof te)D=(D.ca|0)+"-ary tuple";else if(D instanceof
-me)D=rz(D.ia,!1);else throw new x(D);var I="[Missing Case "+(1+F|0)+"/"+B+"]";F=new mf(new nf(J(new L,[""," `","`"])));D=[pf(qf(),I),pf(qf(),D)];F=sf(F,J(new L,D));D=t().f;F=G(new H,F,D);C=C.m();C=new ko(C);C=new eg(C,new z(K=>{if(null!==K){var N=K.i();K=hf(new E(K.Lc()),0)?sf(new mf(new nf(J(new L,["It first appears here."]))),v()):sf(new mf(new nf(J(new L,["And here."]))),v());t();return G(new H,K,new M(N))}throw new x(K);}));je();C=le(v(),C);return new A(F,C)}}throw new x(D);}));je();m=le(v(),
-m);l=new A(l,m);throw jT(new lT,new A(r,l));}}throw new x(w);}m=new z(D=>{$4(a,D,(t(),new M(b)),d,e,g,h)});l.b()||m.n(l.o());KG(r,new z(D=>{$4(a,D.Qs(),(t(),new M(b)),d,e,g,h)}))}else throw new x(b);}}),new z(()=>"[checkExhaustive] "+b.yb()))};
-function Yda(a,b,c){var d=()=>{fp();var k=b.bi.m();k=a5(a,b,Zp(0,new eg(k,new z(r=>r.Hj))),c);var l=aF(),m=b.bi.ea(),n=Wp();return UE(l,m,n,k)},e=new z(()=>"[constructTerm]");if(a.Hb){if(a.D){var g=Hs(Q(),"| ",a.q)+"[constructTerm]";Af(Bf(),g+"\n")}a.q=1+a.q|0;try{var h=d()}finally{a.q=-1+a.q|0}Gw(new E(e),a.pa)&&a.D&&(d=""+Hs(Q(),"| ",a.q)+e.n(h),Af(Bf(),d+"\n"))}else h=d();return h}
-function Zda(a,b,c,d,e,g){var h=()=>{var n=O().c;if(null===n?null===b:n.h(b))return bE();if(b instanceof A){var r=b.A;n=b.r;if(null!==r){var u=new M(r);if(!u.b()){r=u.k.i();u=u.k.j();var w=OE(),y=KE(w,r,u);r=()=>{for(var C=ME(OE(),y);!C.b();){var F=C.e();a.Hb&&a.D&&(F=""+Hs(Q(),"| ",a.q)+F,Af(Bf(),F+"\n"));C=C.g()}};u=a.pa;if(a.Hb){a.D&&(w=Hs(Q(),"| ",a.q)+"*** Initial tree ***",Af(Bf(),w+"\n"));a.q=1+a.q|0;try{var B=r()}finally{a.q=-1+a.q|0}Gw(new E(u),a.pa)&&a.D&&(B=""+Hs(Q(),"| ",a.q)+u.n(B),Af(Bf(),
-B+"\n"))}else r();for(;!n.b();){B=n.e();y.Rl(B,c,d,e,g);a.Hb&&a.D&&(B=Hs(Q(),"| ",a.q)+("*** Merging `"+B.i()+" \x3d\x3e "+B.j())+"` ***",Af(Bf(),B+"\n"));B=(C=>()=>{for(var F=ME(OE(),C);!F.b();){var I=F.e();a.Hb&&a.D&&(I=""+Hs(Q(),"| ",a.q)+I,Af(Bf(),I+"\n"));F=F.g()}})(y);r=a.pa;if(a.Hb){a.D&&(u=Hs(Q(),"| ",a.q)+"*** Updated tree ***",Af(Bf(),u+"\n"));a.q=1+a.q|0;try{var D=B()}finally{a.q=-1+a.q|0}Gw(new E(r),a.pa)&&a.D&&(B=""+Hs(Q(),"| ",a.q)+r.n(D),Af(Bf(),B+"\n"))}else B();n=n.g()}return y}}}throw new x(b);
-},k=new z(()=>"[buildCaseTree]");if(a.Hb){if(a.D){var l=Hs(Q(),"| ",a.q)+"[buildCaseTree]";Af(Bf(),l+"\n")}a.q=1+a.q|0;try{var m=h()}finally{a.q=-1+a.q|0}Gw(new E(k),a.pa)&&a.D&&(h=""+Hs(Q(),"| ",a.q)+k.n(m),Af(Bf(),h+"\n"))}else m=h();return m}
-function $da(a,b){var c=()=>{var h=b.vb.m();h=new Gx(h,new z(k=>!k.j().hE.b()),!1);h=new eg(h,new z(k=>{if(null!==k){var l=k.i();k=k.j().ex.m();k=new eg(k,new z(m=>m.X));je();k=le(v(),k);return G(new H,l,k)}throw new x(k);}));h=bp(fp().rK,h);return zba(RD(),h)},d=new z(()=>"[getClassHierarchy]");if(a.Hb){if(a.D){var e=Hs(Q(),"| ",a.q)+"[getClassHierarchy]";Af(Bf(),e+"\n")}a.q=1+a.q|0;try{var g=c()}finally{a.q=-1+a.q|0}Gw(new E(d),a.pa)&&a.D&&(a=""+Hs(Q(),"| ",a.q)+d.n(g),Af(Bf(),a+"\n"))}else g=c();
-return g}function Y4(a,b,c,d,e,g,h){var k=b.Ra.m();k=new eg(k,new z(u=>u.j().Da));var l=b.Ra.K(),m=1>l;if(m)var n=0;else{var r=l>>31;n=-1+l|0;r=-1!==n?r:-1+r|0;n=1+n|0;r=0===n?1+r|0:r;n=(0===r?-1<(-2147483648^n):0<r)?-1:n}0>n&&RQ(TQ(),1,l,1,!0);n=Pe().Db();for(l=new BD(1,1,l,m);l.Ev;)m="_"+T3(l),n.S(m);l=n.Eb();je();l=T4(a,c,k,le(v(),l),d,e);if(null===l)throw new x(l);k=l.i();l=l.j();Tda(a,c,b.Ra.K(),Mt(Nt(),b.C()),d,h);b=new DE(c,b.Ra.K(),l,X4());a=U4(a,c,k,d,g,h,e);return new A(b,a)}
-function b5(a,b,c,d,e,g){for(var h=null,k=null;b!==v();){var l=b.e(),m=!1,n=null;a:{if(l instanceof mm){m=!0;n=l;var r=n.kb,u=n.hc;if(r instanceof mm){var w=r;r=w.kb;w=w.hc;if(r instanceof Wl&&"is"===r.w&&w instanceof im&&(r=w.Ra,r instanceof A&&(w=r,r=w.A,w=w.r,null!==r&&(r=new M(r),!r.b()&&(r=r.k.j(),null!==r))))){r=r.Da;var y=O().c;if((null===y?null===w:y.h(w))&&u instanceof im&&(u=u.Ra,u instanceof A&&(w=u.A,u=u.r,null!==w&&(w=new M(w),!w.b()&&(w=w.k.j(),null!==w&&(w=w.Da,y=O().c,(null===y?null===
-u:y.h(u))&&!a.Qc)))))){n=n.C();n=V4(a,r,n,c);l=O().c;n=W4(a,n,w,!0,c,d,e,g,l);break a}}}}if(m&&(m=n.kb,u=n.hc,m instanceof Wl&&"is"===m.w&&null!==u&&(m=Ey(Gt(),u),!m.b()&&null!==m.o()&&0===m.o().$a(2)))){l=m.o();l=FA(l,0);m=m.o();m=FA(m,1);n=n.C();n=V4(a,l,n,c);l=O().c;n=W4(a,n,m,!0,c,d,e,g,l);break a}n=new EE(l,X4());O();n=new tQ(n)}for(n=n.m();n.s();)l=new A(n.t(),v()),null===k?h=l:k.r=l,k=l;b=b.g()}return null===h?v():h}
-var aea=function c5(a,b,c,d,e,g,h,k,l,m,n){var u=()=>{var D=!1,C=null,F=!1,I=null;a:{if(c instanceof te){D=!0;C=c;var K=C.ca;if(K instanceof Kt){F=G(new H,e,K.Qt);h.S(F);break a}}if(D){var N=C.ca;if(N instanceof lt&&(K=N.Kp,N=N.Lp,K instanceof Wl&&"_"===K.w)){F=G(new H,e,N);h.S(F);break a}}if(D&&(K=C.ca,K instanceof lt)){I=K.Kp;F=K.Lp;D=ZE(aF(),I,a.Qc);if(null===D)throw new x(D);I=D.j();D=d.Jn(D.i(),a.Qc).yq;C=O().c;D=W4(a,b,D,!0,k,l,m,n,C);D=pY(e,rY(new gE(D,O().c),g));a.Hb&&a.D&&(C=Hs(Q(),"| ",
-a.q)+"Result: "+Qe(D.Pi,"",", ",""),Af(Bf(),C+"\n"));if(t().f===I)F=G(new H,D,F),h.S(F);else if(I instanceof M)Z4(a,new lt(I.k,F),S_(),D,g,h,k,l,m,n);else throw new x(I);break a}if(D&&(K=C.ca,K instanceof kt)){N=K.ro;var P=K.so;K=K.to;if(null!==P&&"and"===P.w){I=ZE(aF(),N,a.Qc);if(null===I)throw new x(I);F=I.i();I=I.j();D=O().c;F=W4(a,b,F,!0,k,l,m,n,D);I.b()?I=O().c:(I=I.o(),I=YE(aF(),I),O(),I=b5(a,I,k,l,m,n));F=pY(e,rY(new gE(Fl(I,F),O().c),g));Z4(a,K,S_(),F,g,h,k,l,m,n);break a}}if(D&&(K=C.ca,K instanceof
-kt)){D=K.ro;I=K.so;F=K.to;D=ZE(aF(),D,a.Qc);b:{if(null!==D&&(C=D.i(),K=D.j(),K instanceof M)){I=K.k;D=O().c;D=W4(a,b,C,!0,k,l,m,n,D);I=YE(aF(),I);O();I=b5(a,I,k,l,m,n);I=pY(e,rY(new gE(Fl(I,D),O().c),g));Z4(a,F,S_(),I,g,h,k,l,m,n);break b}if(null!==D&&(C=D.i(),K=D.j(),t().f===K)){F=(t(),new te(F));I=U_(d.Jn(C,a.Qc),I);c5(a,b,F,I,e,g,h,k,l,m,n);break b}throw new x(D);}break a}if(D&&(K=C.ca,K instanceof Rt)){I=K.Rt;F=K.St;I=ZE(aF(),I,a.Qc);b:{if(null!==I&&(D=I.i(),C=I.j(),t().f===C)){for(I=d.Jn(D,a.Qc);!F.b();){C=
-F.e();c:{if(null!==C&&(D=new M(C),!D.b())){C=D.k.i();D=D.k.j();c5(a,b,(t(),new te(D)),U_(I,C),e,g,h,k,l,m,n);break c}throw new x(C);}F=F.g()}break b}if(null!==I&&(D=I.i(),C=I.j(),C instanceof M)){I=C.k;D=d.Jn(D,a.Qc).yq;C=O().c;D=W4(a,b,D,!0,k,l,m,n,C);I=YE(aF(),I);C=I.uJ();O();C=b5(a,C,k,l,m,n);for(D=pY(e,rY(new gE(Fl(C,D),O().c),g));!F.b();){C=F.e();c:{if(null!==C&&(K=new M(C),!K.b())){C=K.k.j();K=I.Fc();N=O().c;Z4(a,C,new R_(K,new A(K,N)),D,g,h,k,l,m,n);break c}throw new x(C);}F=F.g()}break b}throw new x(I);
-}break a}if(D&&(K=C.ca,K instanceof st)){for(F=K.Jp;!F.b();)I=F.e(),c5(a,b,I,d,e,g,h,k,l,m,n),F=F.g();break a}D&&C.ca instanceof Jt&&cF();if(c instanceof me&&(F=!0,I=c,K=I.ia,K instanceof Kn&&(C=K.Sd,D=K.Qb,K=K.cd,C instanceof M&&(C=!!C.k,K instanceof te)))){F=K.ca;F=new JE(dE(),C,D,F);g.S(F);break a}if(F)throw F=I.ia,I=new mf(new nf(J(new L,["Illegal interleaved statement ",""]))),D=[pf(qf(),F.u())],kT(new lT,sf(I,J(new L,D)),F.C());throw new x(c);}},w=new z(()=>"[desugarMatchBranch]");if(a.Hb){if(a.D){var y=
-Hs(Q(),"| ",a.q)+"[desugarMatchBranch]";Af(Bf(),y+"\n")}a.q=1+a.q|0;try{var B=u()}finally{a.q=-1+a.q|0}Gw(new E(w),a.pa)&&a.D&&(u=""+Hs(Q(),"| ",a.q)+w.n(B),Af(Bf(),u+"\n"))}else u()},Z4=function d5(a,b,c,d,e,g,h,k,l,m){var r=()=>{var B=!1,D=null,C=!1,F=null;a:if(b instanceof Rt)for(C=b.St,F=c.Jn(b.Rt,a.Qc);!C.b();){D=C.e();b:{if(null!==D&&(B=new M(D),!B.b())){d5(a,B.k.j(),U_(F,B.k.i()),d,e,g,h,k,l,m);break b}throw new x(D);}C=C.g()}else{if(b instanceof lt){B=!0;D=b;var I=D.Kp,K=D.Lp;if(I instanceof
-Wl&&"_"===I.w){F=G(new H,d,K);g.S(F);break a}}if(B)F=D.Lp,C=c.Jn(D.Kp,a.Qc),D=YE(aF(),C.yq),Fl(C.DA,D),C=b5(a,D,h,k,l,m),C=rY(qY(d,C),e),F=G(new H,C,F),g.S(F);else{if(b instanceof kt&&(C=!0,F=b,B=F.ro,D=F.so,I=F.to,null!==D&&"is"===D.w&&I instanceof st)){F=I.Jp;C=c.Jn(B,a.Qc).yq;B=C.C();D=D.C();b:{if(B instanceof M&&(B=B.k,D instanceof M)){D=D.k;t();D=Rr(B,D);D=new M(D);break b}D=t().f}C=V4(a,C,D,h);D=C.In;if(D instanceof M)D=d;else{if(t().f!==D)throw new x(D);D=d}for(B=e.ga();!F.b();)I=F.e(),aea(a,
-C,I,S_(),D,B,g,h,k,l,m),F=F.g();break a}if(C&&(B=F.ro,I=F.so,D=F.to,null!==I&&"and"===I.w)){F=c.Jn(B,a.Qc).yq;C=O().c;F=new A(F,C);O();F=qY(d,b5(a,F,h,k,l,m));d5(a,D,S_(),F,e,g,h,k,l,m);break a}if(C)C=F.to,D=F.so,F=U_(c.Jn(F.ro,a.Qc),D),d5(a,C,F,d,e,g,h,k,l,m);else if(b instanceof Jt&&cF(),b instanceof Kt)F=b.Qt,C=rY(d,e),F=G(new H,C,F),g.S(F);else if(b instanceof st)for(F=b.Jp;!F.b();){C=F.e();D=!1;b:if(C instanceof te)d5(a,C.ca,c,d,e,g,h,k,l,m);else{if(C instanceof me&&(D=!0,B=C,B=B.ia,B instanceof
-Kn&&(K=B,I=K.Sd,B=K.Qb,K=K.cd,I instanceof M&&(I=!!I.k,K instanceof te)))){C=K.ca;a.Hb&&a.D&&(D=Hs(Q(),"| ",a.q)+"Found interleaved binding "+B.w,Af(Bf(),D+"\n"));C=new JE(dE(),I,B,C);e.S(C);break b}if(D)throw lS(new mS,"unexpected statements at desugarIfBody");throw new x(C);}F=F.g()}else throw new x(b);}}},u=new z(()=>"[desugarIfBody]");if(a.Hb){if(a.D){var w=Hs(Q(),"| ",a.q)+"[desugarIfBody]";Af(Bf(),w+"\n")}a.q=1+a.q|0;try{var y=r()}finally{a.q=-1+a.q|0}Gw(new E(u),a.pa)&&a.D&&(r=""+Hs(Q(),"| ",
-a.q)+u.n(y),Af(Bf(),r+"\n"))}else r()},f5=function e5(a,b,c,d,e,g){var k=!1,l=null;if(b instanceof A){k=!0;l=b;var m=l.A,n=l.r;if(m instanceof ZD){var r=m.Ij;m=m.dl;if(null!==r&&(r=new M(r),!r.b())){b=r.k.i();l=r.k.j();a.Hb&&a.D&&(k=Hs(Q(),"| ",a.q),r=l.m(),r=new eg(r,new z(C=>C.i()+" -\x3e "+C.j())),k=k+("\u2022 Constructor pattern: "+b+"("+Qe(r,"",", ",""))+")",Af(Bf(),k+"\n"));k=l.m();k=new eg(k,new z(C=>C.j()));m=a5(a,m,c.af(k),g);r=!1;var u=null;k=PB(g,b.w);a:{if(k instanceof M){r=!0;u=k;var w=
-u.k;if(w instanceof Lw&&(w=w.rh,w instanceof cx)){k=qp(w.or());break a}}if(r&&(r=u.k,r instanceof Iw)){k=qp(r.Kb);break a}r=k instanceof M&&k.k instanceof MP?!0:k instanceof M&&k.k instanceof Sw?!0:t().f===k?!0:!1;if(r)k=t().f;else throw new x(k);}a:{if($D(d)instanceof Wl&&k instanceof M&&(k=k.k,!l.b())){u=HV();r=new Wo;for(w=l.m();w.s();){var y=w.t();b:{if(null!==y){var B=new M(y);if(!B.b()){var D=B.k.i();B=B.k.j();if(null!==B){y=B.w;B=u.Y(D);B instanceof M?ip(r,G(new H,B.k,y)):u.Vi(D,y);break b}}}throw new x(y);
-}}u=t().f;l=new ws(Ct().Kg,new im(l.zi(new z(C=>C.i())).Ga(new z(C=>{if(null!==C){var F=new M(C);if(!F.b()&&(F=F.k.j(),null!==F)){F=F.w;if("_"===F)return C=t().f,F=new ws(Ct().Kg,new Wl(P4(a,g))),G(new H,C,F);C=t().f;F=new ws(Ct().Kg,new Wl(F));return G(new H,C,F)}}throw new x(C);})).ea()));l=G(new H,u,l);u=O().c;l=new im(new A(l,u));r=r.ea();for(r=jp(r);!r.b();)u=r.e(),m=new om(!1,new Wl(u.j()),new Wl(u.i()),m),r=r.g();l=new lm(l,m);m=t().f;r=Ct().Kg;k=new nm(b,new Wl(k.sf.w));u=t().f;w=new ws(Ct().Kg,
-$D(d));u=G(new H,u,w);w=O().c;k=new ws(r,new mm(k,new im(new A(u,w))));m=G(new H,m,k);k=O().c;l=new mm(l,new im(new A(m,k)));break a}l=l.uk(new z(C=>sr(new E(C.j().w),"_"))).ea();l=bea(a,$D(d),l,m,d,g)}return new Im(b,l,e5(a,n,c,d,e,g))}}}if(k&&(m=l.A,n=l.r,m instanceof YD))return b=m.xq,l=m.Zo,a.Hb&&a.D&&(m=Hs(Q(),"| ",a.q)+"\u2022 Literal pattern: "+b,Af(Bf(),m+"\n")),new Im(b,a5(a,l,c,g),e5(a,n,c,d,e,g));d=O().c;if(null===d?null===b:d.h(b)){if(R()===e)return a.Hb&&a.D&&(c=Hs(Q(),"| ",a.q)+"\u2022 No wildcard branch",
-Af(Bf(),c+"\n")),Nm();if(e instanceof M)return e=e.k,a.Hb&&a.D&&(d=Hs(Q(),"| ",a.q)+"\u2022 Wildcard branch",Af(Bf(),d+"\n")),new Mm(a5(a,e,c,g));throw new x(e);}throw new x(b);},a5=function g5(a,b,c,d){var g=()=>{if(b instanceof aE){var m=b.Is,n=aF(),r=b.bi.ea();return UE(n,r,c,m)}if(b instanceof XD){m=b.Hn;var u=b.ch,w=b.ij;a.Hb&&a.D&&(n=Hs(Q(),"| ",a.q)+"\u2022 Owned let bindings",Af(Bf(),n+"\n"));n=b.bi.m();n=new Gx(n,new z(F=>hf(new E(F.uq),dE())),!0);je();n=le(v(),n);if(n.b()){if(a.Hb&&a.D){var y=
-Hs(Q(),"| ",a.q)+"  * \x3cNo bindings\x3e";Af(Bf(),y+"\n")}}else for(y=n;!y.b();){var B=y.e();if(null!==B){var D=B.uq,C=B.Hj;B=B.vq;a.Hb&&a.D&&(D=Hs(Q(),"| ",a.q)+("  * ("+D+") "+C+" \x3d ")+B,Af(Bf(),D+"\n"))}else throw new x(B);y=y.g()}y=u.m();y=new eg(y,new z(F=>F.Qs()));y=Cu(y,new U(()=>w));y=new ho(y,new z(F=>F.bi));y=new Gx(y,new z(F=>hf(new E(F.uq),dE())),!1);je();y=le(v(),y);a.Hb&&a.D&&(D=Hs(Q(),"| ",a.q)+"\u2022 Collect interleaved let bindings from case branches",Af(Bf(),D+"\n"));if(y.b())a.Hb&&
-a.D&&(D=Hs(Q(),"| ",a.q)+"  * \x3cNo interleaved bindings\x3e",Af(Bf(),D+"\n"));else for(D=y;!D.b();){B=D.e();if(null!==B)C=B.Hj,B=B.vq,a.Hb&&a.D&&(C=Hs(Q(),"| ",a.q)+("  * "+C+" \x3d ")+B,Af(Bf(),C+"\n"));else throw new x(B);D=D.g()}if(u.b()){if(R()===w)throw a.Hb&&a.D&&(n=Hs(Q(),"| ",a.q)+"\u2022 The match has neither branches nor default case",Af(Bf(),n+"\n")),n=new nf(J(new L,["found an empty match"])),kT(new lT,sf(new mf(n),v()),m.dh.C());if(!(w instanceof M))throw new x(w);r=w.k;a.Hb&&a.D&&
-(u=Hs(Q(),"| ",a.q)+"\u2022 Degenerated case: the match only has a wildcard",Af(Bf(),u+"\n"));r=g5(a,r,c,d);u=m.In;if(t().f!==u){if(!(u instanceof M))throw new x(u);r=new om(!1,u.k,m.dh,r)}}else{a.Hb&&a.D&&(D=Hs(Q(),"| ",a.q)+"\u2022 The match has some case branches",Af(Bf(),D+"\n"));D=new z(()=>"\u2022 End for each");if(a.Hb){a.D&&(C=Hs(Q(),"| ",a.q)+"\u2022 For each case branch",Af(Bf(),C+"\n"));a.q=1+a.q|0;try{r=f5(a,u.ea(),c,m,w,d)}finally{a.q=-1+a.q|0}Gw(new E(D),a.pa)&&a.D&&(u=""+Hs(Q(),"| ",
-a.q)+D.n(r),Af(Bf(),u+"\n"))}else r=f5(a,u.ea(),c,m,w,d);u=m.In;if(t().f===u)r=new rm(m.dh,r);else{if(!(u instanceof M))throw new x(u);u=u.k;r=new om(!1,u,m.dh,new rm(u,r))}}m=aF();u=aF();r=UE(u,y,c,r);return UE(m,n,c,r)}if(bE()===b)throw m=new nf(J(new L,["missing a default branch"])),kT(new lT,sf(new mf(m),v()),t().f);if(b instanceof WD)return m=b.wq,n=b.rk,y=b.uh,r=aF(),u=y.bi.ea(),D=y.bi.m(),D=new eg(D,new z(F=>F.Hj)),y=g5(a,y,c.af(D),d),r=UE(r,u,c,y),u=aF(),y=n.bi.ea(),D=n.bi.m(),D=new eg(D,
-new z(F=>F.Hj)),n=g5(a,n,c.af(D),d),n=UE(u,y,c,n),r=new Mm(r),n=new Im(new Wl("true"),n,r),new rm(m,n);throw new x(b);},h=a.pa;if(a.Hb){if(a.D){var k=Hs(Q(),"| ",a.q)+("[rec] "+b.yb()+" -| {"+Qe(c,"",", ",""))+"}";Af(Bf(),k+"\n")}a.q=1+a.q|0;try{var l=g()}finally{a.q=-1+a.q|0}Gw(new E(h),a.pa)&&a.D&&(g=""+Hs(Q(),"| ",a.q)+h.n(l),Af(Bf(),g+"\n"))}else l=g();return l},bea=function h5(a,b,c,d,e,g){var k=O().c;if(null===k?null===c:k.h(c))return d;if(c instanceof A){var l=c.A;k=c.r;if(null!==l&&(l=new M(l),
-!l.b())){var m=l.k.i();l=l.k.j();if(null!==l){c=l.w;var n=e.dh;if(n instanceof Wl&&c===n.w)return b=new Wl(P4(a,g)),c=$D(e),m=new nm(b,new Wl(m)),new om(!1,b,c,new om(!1,l,RS(m,e.dh),h5(a,b,k,d,e,g)));m=new nm(b,new Wl(m));return new om(!1,l,RS(m,e.dh),h5(a,b,k,d,e,g))}}}throw new x(c);};
-function i5(){this.Cn=this.Bn=this.Dn=null;this.Vo=this.Wo=this.Dm=this.Uo=0;this.pa=null;this.q=0;this.bl=this.iq=this.mq=this.No=this.Ro=this.So=this.kq=this.Po=this.jq=this.Mo=this.Qo=this.Oo=this.lq=null;this.To=0;this.Ar=this.Up=this.Wp=this.Xp=this.Vp=this.Zp=this.Yp=null;this.nm=this.mw=0;this.Lz=this.Kz=this.bu=null;this.Hb=!1;this.zA=0;this.AA=null}i5.prototype=new S2;i5.prototype.constructor=i5;function j5(){}j5.prototype=i5.prototype;
-function cea(a,b,c,d){var e=()=>{var l=$da(a,c);PD(RD(),l,new z(y=>{N4(a,y)}),"Super-class map","\x3c:");var m=yba(RD(),l);PD(RD(),m,new z(y=>{N4(a,y)}),"Sub-class map",":\x3e");var n=Vda(a,b,O().c);if(null===n)throw new x(n);var r=n.i(),u=n.j();n=ru().U();if(a.Hb&&a.D){var w=Hs(Q(),"| ",a.q)+"### Desugar the UCS to decision paths ###";Af(Bf(),w+"\n")}r=Wda(a,r,u,c,d,n);a.Hb&&a.D&&(u=Hs(Q(),"| ",a.q)+"Exhaustiveness map",Af(Bf(),u+"\n"));n.b()?a.Hb&&a.D&&(u=Hs(Q(),"| ",a.q)+"  * \x3cNo entries\x3e",
-Af(Bf(),u+"\n")):n.Ag(new Um((y,B)=>{a.Hb&&a.D&&(y=Hs(Q(),"| ",a.q)+"  * Patterns of "+y,Af(Bf(),y+"\n"));B.b()?a.Hb&&a.D&&(B=Hs(Q(),"| ",a.q)+"    + \x3cNo patterns\x3e",Af(Bf(),B+"\n")):B.Ag(new Um((D,C)=>{if(D instanceof te)D="()^"+(D.ca|0);else{if(!(D instanceof me))throw new x(D);D=rz(D.ia,!1)}C=Qe(C,"[",", ","]");a.Hb&&a.D&&(C=Hs(Q(),"| ",a.q)+("    + "+D+" -\x3e ")+C,Af(Bf(),C+"\n"))}))}));a.Hb&&a.D&&(u=Hs(Q(),"| ",a.q)+"### Build a case tree from decision paths ###",Af(Bf(),u+"\n"));fp();
-n=n.m();n=bp(0,new eg(n,new z(y=>{if(null!==y){var B=y.i();y=y.j();y=bp(fp().rK,y);return G(new H,B,y)}throw new x(y);})));l=Zda(a,r,d,new z(y=>R4(a,y,c)),n,l);a.Hb&&a.D&&(r=Hs(Q(),"| ",a.q)+"### Checking exhaustiveness of the case tree ###",Af(Bf(),r+"\n"));Xda(a,l,t().f,c,d,n,m);a.Hb&&a.D&&(m=Hs(Q(),"| ",a.q)+"### Construct a term from the case tree ###",Af(Bf(),m+"\n"));m=Yda(a,l,c);a.D&&(l=Hs(Q(),"| ",a.q)+"Desugared term: "+rz(m,!1),Af(Bf(),l+"\n"));b.dd=(t(),new M(m));return m},g=a.pa;if(a.Hb){if(a.D){var h=
-Hs(Q(),"| ",a.q)+"[desugarIf]";Af(Bf(),h+"\n")}a.q=1+a.q|0;try{var k=e()}finally{a.q=-1+a.q|0}Gw(new E(g),a.pa)&&a.D&&(e=""+Hs(Q(),"| ",a.q)+g.n(k),Af(Bf(),e+"\n"))}else k=e();return k}function au(a,b){this.x=this.z=null;this.aF=a;this.VI=b;G(this,null,null)}au.prototype=new Y_;au.prototype.constructor=au;f=au.prototype;f.Gx=function(){return this.aF};f.Lc=function(){return this.VI};f.Et=function(){return new au(this.VI,this.aF)};f.Mu=function(){return this.aF};f.j=function(){return this.VI};
-f.i=function(){return this.aF};f.$classData=q({a0:0},!1,"scala.Tuple2$mcII$sp",{a0:1,Fu:1,d:1,$x:1,F:1,v:1,l:1,Baa:1});function nG(a){this.Xm=null;this.ql=this.rc=0;this.V3=a;Yt(this,a)}nG.prototype=new k3;nG.prototype.constructor=nG;nG.prototype.t=function(){try{var a=this.V3.a[this.rc];this.rc=1+this.rc|0;var b=a}catch(c){if(c instanceof NH)b=qq().Oa.t()|0;else throw c;}return b};
-nG.prototype.$classData=q({U3:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcB$sp",{U3:1,fp:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});function mG(a){this.Xm=null;this.ql=this.rc=0;this.X3=a;Yt(this,a)}mG.prototype=new k3;mG.prototype.constructor=mG;mG.prototype.t=function(){try{var a=this.X3.a[this.rc];this.rc=1+this.rc|0;var b=a}catch(c){if(c instanceof NH)b=Eb(qq().Oa.t());else throw c;}return hd(b)};
-mG.prototype.$classData=q({W3:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcC$sp",{W3:1,fp:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});function jG(a){this.Xm=null;this.ql=this.rc=0;this.Z3=a;Yt(this,a)}jG.prototype=new k3;jG.prototype.constructor=jG;jG.prototype.t=function(){try{var a=this.Z3.a[this.rc];this.rc=1+this.rc|0;var b=a}catch(c){if(c instanceof NH)b=+qq().Oa.t();else throw c;}return b};
-jG.prototype.$classData=q({Y3:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcD$sp",{Y3:1,fp:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});function lG(a){this.Xm=null;this.ql=this.rc=0;this.a4=a;Yt(this,a)}lG.prototype=new k3;lG.prototype.constructor=lG;lG.prototype.t=function(){try{var a=this.a4.a[this.rc];this.rc=1+this.rc|0;var b=a}catch(c){if(c instanceof NH)b=Math.fround(qq().Oa.t());else throw c;}return b};
-lG.prototype.$classData=q({$3:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcF$sp",{$3:1,fp:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});function iG(a){this.Xm=null;this.ql=this.rc=0;this.c4=a;Yt(this,a)}iG.prototype=new k3;iG.prototype.constructor=iG;iG.prototype.t=function(){try{var a=this.c4.a[this.rc];this.rc=1+this.rc|0;var b=a}catch(c){if(c instanceof NH)b=qq().Oa.t()|0;else throw c;}return b};
-iG.prototype.$classData=q({b4:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcI$sp",{b4:1,fp:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});function kG(a){this.Xm=null;this.ql=this.rc=0;this.e4=a;Yt(this,a)}kG.prototype=new k3;kG.prototype.constructor=kG;kG.prototype.t=function(){try{var a=this.e4.a[this.rc],b=a.W,c=a.Z;this.rc=1+this.rc|0;var d=new fb(b,c)}catch(e){if(e instanceof NH)d=Qb(qq().Oa.t());else throw e;}return d};
-kG.prototype.$classData=q({d4:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcJ$sp",{d4:1,fp:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});function oG(a){this.Xm=null;this.ql=this.rc=0;this.g4=a;Yt(this,a)}oG.prototype=new k3;oG.prototype.constructor=oG;oG.prototype.t=function(){try{var a=this.g4.a[this.rc];this.rc=1+this.rc|0;var b=a}catch(c){if(c instanceof NH)b=qq().Oa.t()|0;else throw c;}return b};
-oG.prototype.$classData=q({f4:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcS$sp",{f4:1,fp:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});function qG(a){this.Xm=null;this.ql=this.rc=0;Yt(this,a)}qG.prototype=new k3;qG.prototype.constructor=qG;qG.prototype.t=function(){try{this.rc=1+this.rc|0}catch(a){if(a instanceof NH)qq().Oa.t();else throw a;}};qG.prototype.$classData=q({h4:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcV$sp",{h4:1,fp:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});
-function pG(a){this.Xm=null;this.ql=this.rc=0;this.j4=a;Yt(this,a)}pG.prototype=new k3;pG.prototype.constructor=pG;pG.prototype.t=function(){try{var a=this.j4.a[this.rc];this.rc=1+this.rc|0;var b=a}catch(c){if(c instanceof NH)b=!!qq().Oa.t();else throw c;}return b};pG.prototype.$classData=q({i4:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcZ$sp",{i4:1,fp:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});function tQ(a){this.EK=a}tQ.prototype=new g3;tQ.prototype.constructor=tQ;f=tQ.prototype;f.m=function(){qq();return new X_(this.EK)};
-f.Q=function(){return 1};f.e=function(){return this.EK};f.Fc=function(){return this.EK};f.zb=function(a){return 0<a?mK().U():this};f.Cc=function(a){return 0<a?mK().U():this};f.$classData=q({v4:0},!1,"scala.collection.Iterable$$anon$1",{v4:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1});function k5(a,b){if(a.b())throw Fu("empty.min");var c=a.Wd();return(null===b?null===c:b.h(c))?a.e():b.Nj(a.Wd())?a.Fc():PG(a,b)}
-function l5(a,b){if(a.b())throw Fu("empty.max");var c=a.Wd();return(null===b?null===c:b.h(c))?a.Fc():b.Nj(a.Wd())?a.e():QG(a,b)}function m5(a){return a.xh()+"(\x3cnot computed\x3e)"}function n5(a,b){for(b=b.m();b.s();){var c=b.t();a=a.rj(c)}return a}function o5(a,b,c){var d=a.Y(b);c=c.n(d);d=G(new H,d,c);c=d.z;var e=d.x;if(R()===c&&R()===e)return a;c=d.x;if(d.z instanceof M&&R()===c)return a.rj(b);c=d.x;if(c instanceof M)return a.lm(b,c.k);throw new x(d);}
-function p5(a){this.gn=this.bo=0;this.iS=null;if(null===a)throw null;this.iS=a;this.bo=0;this.gn=2}p5.prototype=new Y3;p5.prototype.constructor=p5;p5.prototype.ua=function(a){a:{var b=this.iS;switch(a){case 0:a=b.rt;break a;case 1:a=b.Iv;break a;default:throw new x(a);}}return a};p5.prototype.$classData=q({I7:0},!1,"scala.collection.immutable.Set$Set2$$anon$1",{I7:1,lS:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});
-function q5(a){this.gn=this.bo=0;this.jS=null;if(null===a)throw null;this.jS=a;this.bo=0;this.gn=3}q5.prototype=new Y3;q5.prototype.constructor=q5;q5.prototype.ua=function(a){a:{var b=this.jS;switch(a){case 0:a=b.fr;break a;case 1:a=b.st;break a;case 2:a=b.tt;break a;default:throw new x(a);}}return a};q5.prototype.$classData=q({K7:0},!1,"scala.collection.immutable.Set$Set3$$anon$2",{K7:1,lS:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});
-function r5(a){this.gn=this.bo=0;this.kS=null;if(null===a)throw null;this.kS=a;this.bo=0;this.gn=4}r5.prototype=new Y3;r5.prototype.constructor=r5;r5.prototype.ua=function(a){return dea(this.kS,a)};r5.prototype.$classData=q({M7:0},!1,"scala.collection.immutable.Set$Set4$$anon$3",{M7:1,lS:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});function wV(a){this.GG=null;this.Ik=a;this.vt=null}wV.prototype=new WQ;wV.prototype.constructor=wV;f=wV.prototype;f.Pd=function(){};f.Eb=function(){return vV(new uV,$I(this.vt),this.Ik)};
-f.oc=function(a){a:{if(a instanceof uV){var b=a.Be,c=this.Ik;if(null===b?null===c:b.h(c)){this.vt=null===this.vt?a.od:WI(XI(),$I(this.vt),a.od,this.Ik);break a}}a&&a.$classData&&a.$classData.pb.Ak?(null===this.GG&&null===this.GG&&(this.GG=new AV(this)),b=this.GG,b.By=b.FG.vt,a.Ag(b),b.FG.vt=b.By,b.By=null):cR(this,a)}return this};f.S=function(a){this.vt=XQ(this,this.vt,a.i(),a.j());return this};
-f.$classData=q({d8:0},!1,"scala.collection.immutable.TreeMap$TreeMapBuilder",{d8:1,z7:1,fS:1,d:1,io:1,og:1,lf:1,kf:1});function uZ(a){this.Ik=a;this.hr=null}uZ.prototype=new ZQ;uZ.prototype.constructor=uZ;f=uZ.prototype;f.Pd=function(){};f.Eb=function(){return qZ(new pZ,$I(this.hr),this.Ik)};
-f.oc=function(a){a:{if(a instanceof pZ){var b=a.Ce,c=this.Ik;if(null===b?null===c:b.h(c)){this.hr=null===this.hr?a.xf:WI(XI(),$I(this.hr),a.xf,this.Ik);break a}}if(a instanceof uV&&(b=a.Be,c=this.Ik,null===b?null===c:b.h(c))){this.hr=null===this.hr?a.od:WI(XI(),$I(this.hr),a.od,this.Ik);break a}cR(this,a)}return this};f.S=function(a){this.hr=$Q(this,this.hr,a);return this};f.$classData=q({h8:0},!1,"scala.collection.immutable.TreeSet$TreeSetBuilder",{h8:1,lba:1,fS:1,d:1,io:1,og:1,lf:1,kf:1});
-function e4(a){this.tS=!1;this.yL=null;this.SB=a;this.tS=a===ma(Vd);this.yL=[]}e4.prototype=new b4;e4.prototype.constructor=e4;function s5(a,b){a.yL.push(a.tS?Eb(b):null===b?a.SB.ei.Oy:b);return a}f=e4.prototype;f.Eb=function(){return Nd((this.SB===ma(Qd)?ma(Xa):this.SB===ma(SG)||this.SB===ma(TG)?ma(Md):this.SB).ei).Ny(this.yL)};f.u=function(){return"ArrayBuilder.generic"};f.oc=function(a){for(a=a.m();a.s();){var b=a.t();s5(this,b)}return this};f.S=function(a){return s5(this,a)};
-f.$classData=q({B8:0},!1,"scala.collection.mutable.ArrayBuilder$generic",{B8:1,oba:1,d:1,io:1,og:1,lf:1,kf:1,l:1});
-function t5(a,b,c,d){var e=1+dG(eG(),b)|0;if(0>c||c>=e)throw KK(new LK,c+" is out of bounds (min 0, max "+(-1+e|0)+")");e=(a.ne-a.Hd|0)&(-1+a.ac.a.length|0)|0;var g=dG(eG(),b)-c|0;e=e<g?e:g;d=d<e?d:e;if(0<d){e=(a.ne-a.Hd|0)&(-1+a.ac.a.length|0);if(0>=e)throw KK(new LK,"0 is out of bounds (min 0, max "+(-1+e|0)+")");e=(a.Hd+0|0)&(-1+a.ac.a.length|0);g=a.ac.a.length-e|0;g=d<g?d:g;CG(zG(),a.ac,e,b,c,g);d=d-g|0;0<d&&CG(zG(),a.ac,0,b,c+g|0,d)}return b}
-function u5(a,b){this.CK=null;this.wS=this.Rj=this.Uq=0;this.S8=b;Vq(this,a);this.wS=Zr(b)|0}u5.prototype=new l3;u5.prototype.constructor=u5;u5.prototype.s=function(){WJ();var a=this.wS,b=Zr(this.S8)|0;TJ(a,b);return 0<this.Rj};u5.prototype.$classData=q({R8:0},!1,"scala.collection.mutable.CheckedIndexedSeqView$CheckedIterator",{R8:1,jR:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});function v5(a,b){this.DK=null;this.xS=this.iv=this.sj=0;this.U8=b;sZ(this,a);this.xS=Zr(b)|0}v5.prototype=new m3;
-v5.prototype.constructor=v5;v5.prototype.s=function(){WJ();var a=this.xS,b=Zr(this.U8)|0;TJ(a,b);return 0<this.sj};v5.prototype.$classData=q({T8:0},!1,"scala.collection.mutable.CheckedIndexedSeqView$CheckedReverseIterator",{T8:1,kR:1,Qa:1,d:1,Ha:1,M:1,N:1,l:1});function w5(){}w5.prototype=new p;w5.prototype.constructor=w5;f=w5.prototype;f.Qj=function(a,b){return 0>=this.Fa(a,b)};f.xk=function(a,b){return 0<=this.Fa(a,b)};f.wk=function(a,b){return 0<this.Fa(a,b)};
-f.lj=function(a,b){return n2(this,a,b)};f.nl=function(a,b){return o2(this,a,b)};f.ol=function(a,b){return p2(this,a,b)};f.Nj=function(a){return q2(this,a)};f.Fa=function(a,b){a=!!a;return a===!!b?0:a?1:-1};f.$classData=q({b3:0},!1,"scala.math.Ordering$Boolean$",{b3:1,d:1,Naa:1,Um:1,Si:1,Wm:1,Tm:1,l:1});var x5;function wG(){x5||(x5=new w5);return x5}function y5(){}y5.prototype=new p;y5.prototype.constructor=y5;f=y5.prototype;f.Qj=function(a,b){return 0>=this.Fa(a,b)};
-f.xk=function(a,b){return 0<=this.Fa(a,b)};f.wk=function(a,b){return 0<this.Fa(a,b)};f.lj=function(a,b){return n2(this,a,b)};f.nl=function(a,b){return o2(this,a,b)};f.ol=function(a,b){return p2(this,a,b)};f.Nj=function(a){return q2(this,a)};f.Fa=function(a,b){return(a|0)-(b|0)|0};f.$classData=q({c3:0},!1,"scala.math.Ordering$Byte$",{c3:1,d:1,Oaa:1,Um:1,Si:1,Wm:1,Tm:1,l:1});var z5;function uG(){z5||(z5=new y5);return z5}function A5(){}A5.prototype=new p;A5.prototype.constructor=A5;f=A5.prototype;
-f.Qj=function(a,b){return 0>=this.Fa(a,b)};f.xk=function(a,b){return 0<=this.Fa(a,b)};f.wk=function(a,b){return 0<this.Fa(a,b)};f.lj=function(a,b){return n2(this,a,b)};f.nl=function(a,b){return o2(this,a,b)};f.ol=function(a,b){return p2(this,a,b)};f.Nj=function(a){return q2(this,a)};f.Fa=function(a,b){return Eb(a)-Eb(b)|0};f.$classData=q({d3:0},!1,"scala.math.Ordering$Char$",{d3:1,d:1,Qaa:1,Um:1,Si:1,Wm:1,Tm:1,l:1});var B5;function tG(){B5||(B5=new A5);return B5}function C5(){}C5.prototype=new p;
-C5.prototype.constructor=C5;f=C5.prototype;f.Qj=function(a,b){return 0>=this.Fa(a,b)};f.xk=function(a,b){return 0<=this.Fa(a,b)};f.wk=function(a,b){return 0<this.Fa(a,b)};f.lj=function(a,b){return n2(this,a,b)};f.nl=function(a,b){return o2(this,a,b)};f.ol=function(a,b){return p2(this,a,b)};f.Nj=function(a){return q2(this,a)};f.Fa=function(a,b){var c=Qb(a);a=c.W;c=c.Z;var d=Qb(b);b=d.W;d=d.Z;return Bb(Cb(),a,c,b,d)};
-f.$classData=q({g3:0},!1,"scala.math.Ordering$Long$",{g3:1,d:1,Raa:1,Um:1,Si:1,Wm:1,Tm:1,l:1});var D5;function sG(){D5||(D5=new C5);return D5}function E5(){}E5.prototype=new p;E5.prototype.constructor=E5;f=E5.prototype;f.Qj=function(a,b){return 0>=this.Fa(a,b)};f.xk=function(a,b){return 0<=this.Fa(a,b)};f.wk=function(a,b){return 0<this.Fa(a,b)};f.lj=function(a,b){return n2(this,a,b)};f.nl=function(a,b){return o2(this,a,b)};f.ol=function(a,b){return p2(this,a,b)};f.Nj=function(a){return q2(this,a)};
-f.Fa=function(a,b){return(a|0)-(b|0)|0};f.$classData=q({i3:0},!1,"scala.math.Ordering$Short$",{i3:1,d:1,Saa:1,Um:1,Si:1,Wm:1,Tm:1,l:1});var F5;function vG(){F5||(F5=new E5);return F5}function G5(){}G5.prototype=new p;G5.prototype.constructor=G5;f=G5.prototype;f.Qj=function(a,b){return 0>=this.Fa(a,b)};f.xk=function(a,b){return 0<=this.Fa(a,b)};f.wk=function(a,b){return 0<this.Fa(a,b)};f.lj=function(a,b){return n2(this,a,b)};f.nl=function(a,b){return o2(this,a,b)};
-f.ol=function(a,b){return p2(this,a,b)};f.Nj=function(a){return q2(this,a)};f.Fa=function(a,b){return sb(a,b)};f.$classData=q({j3:0},!1,"scala.math.Ordering$String$",{j3:1,d:1,Taa:1,Um:1,Si:1,Wm:1,Tm:1,l:1});var H5;function dT(){H5||(H5=new G5);return H5}function I5(){this.Ci=null;this.wf=0}I5.prototype=new p;I5.prototype.constructor=I5;function J5(){}J5.prototype=I5.prototype;I5.prototype.u=function(){return this.Ci};I5.prototype.E=function(a){return a instanceof I5};
-I5.prototype.h=function(a){return this===a};I5.prototype.y=function(){return this.wf};function K5(){}K5.prototype=new p;K5.prototype.constructor=K5;function L5(){}L5.prototype=K5.prototype;K5.prototype.E=function(a){return!!(a&&a.$classData&&a.$classData.pb.Yl)};
-class pe extends mW{constructor(a){super();this.Dt=a;fF(this,null,null,!0)}mj(){return pc(this.Dt)}H(){return"JavaScriptException"}G(){return 1}I(a){return 0===a?this.Dt:JK(W(),a)}E(a){return a instanceof pe}y(){return jL(this)}h(a){if(this===a)return!0;if(a instanceof pe){var b=this.Dt;a=a.Dt;return Ol(Pl(),b,a)}return!1}}pe.prototype.$classData=q({f$:0},!1,"scala.scalajs.js.JavaScriptException",{f$:1,ye:1,fd:1,jc:1,d:1,l:1,F:1,v:1});function vh(a){this.A0=a;this.rF=""}vh.prototype=new B4;
-vh.prototype.constructor=vh;function Af(a,b){for(;""!==b;){var c=b.indexOf("\n")|0;if(0>c)a.rF=""+a.rF+b,b="";else{var d=""+a.rF+b.substring(0,c);"undefined"!==typeof console&&(a.A0&&console.error?console.error(d):console.log(d));a.rF="";b=b.substring(1+c|0)}}}vh.prototype.$classData=q({z0:0},!1,"java.lang.JSConsoleBasedPrintStream",{z0:1,P$:1,N$:1,O$:1,d:1,fT:1,l0:1,gT:1,ZP:1});function xw(a,b,c,d,e){this.$t=null;this.cj=b;this.cg=c;this.tn=d;this.vz=e;if(null===a)throw null;this.$t=a}
-xw.prototype=new p;xw.prototype.constructor=xw;f=xw.prototype;f.Jq=function(){return this.tn};f.Ca=function(){return this.vz};f.Sa=function(){return this.cj.Sa()};f.zd=function(){return this.cj instanceof sp?np():Kw()};f.C=function(){return this.cj.C()};f.Iq=function(){return!0};f.no=function(){return this.cg.oa};f.H=function(){return"NuParam"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.cj;case 1:return this.cg;case 2:return this.tn;default:return JK(W(),a)}};
-f.E=function(a){return a instanceof xw};f.y=function(){var a=dc("NuParam");a=W().B(-889275714,a);var b=this.cj;b=dy(W(),b);a=W().B(a,b);b=this.cg;b=dy(W(),b);a=W().B(a,b);b=this.tn?1231:1237;a=W().B(a,b);return W().La(a,3)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof xw&&a.$t===this.$t){if(this.tn===a.tn){var b=this.cj,c=a.cj;b=null===b?null===c:b.h(c)}else b=!1;if(b)return b=this.cg,a=a.cg,null===b?null===a:b.h(a)}return!1};f.FF=function(){return this.$t};
-f.Ql=function(a,b){var c=this.$t,d=this.cj,e=this.cg,g=e.Ua,h=e.Ma;h.b()?h=R():(h=h.o(),h=new M(b.aa(new nB(a),h)));return new xw(c,d,new ww(g,h,b.aa(a,e.oa),e.vd),this.tn,this.vz)};f.ml=function(a,b,c){b=this.$t;var d=this.cj,e=this.cg,g=e.Ua,h=e.Ma;if(h.b())h=R();else{h=h.o();if(a.b())var k=R();else k=!!a.o(),k=new M(!k);h=new M(c.aa(k,h))}return new xw(b,d,new ww(g,h,c.aa(a,e.oa),e.vd),this.tn,this.vz)};f.Mn=function(a,b,c,d){return new xw(this.$t,this.cj,QX(this.cg,a,b,c,d),this.tn,c.fa)};
-f.$classData=q({VW:0},!1,"mlscript.NuTypeDefs$NuParam",{VW:1,d:1,Qw:1,ZD:1,ms:1,DN:1,F:1,v:1,l:1});function eea(a){if(!a.uH){var b=a.ui,c=a.Zg,d=k=>{if(null!==k){var l=k.ec,m=k.gb;if(null!==l){k=a.Gf.eb.X+"#"+l.X;var n=a.ic,r=a.ic;t();l=new xw(n,l,new ww(r,new M(m),m,V(a.ic)),!0,a.um);return G(new H,k,l)}}throw new x(k);};if(c===v())d=v();else{var e=c.e(),g=e=new A(d(e),v());for(c=c.g();c!==v();){var h=c.e();h=new A(d(h),v());g=g.r=h;c=c.g()}d=e}a.vH=b.oe(d).oe(a.vm);a.uH=!0}return a.vH}
-function Aw(a,b,c,d,e,g,h,k,l,m,n){this.tH=this.vH=this.ic=this.Sw=null;this.uH=!1;this.um=b;this.Gf=c;this.Zg=d;this.yj=e;this.Wk=g;this.ui=h;this.wm=k;this.jk=l;this.zo=m;this.vm=n;PS(this,a,pp());this.tH=t().f}Aw.prototype=new QS;Aw.prototype.constructor=Aw;f=Aw.prototype;f.Ca=function(){return this.um};f.or=function(){return this.Gf};f.pg=function(){return this.Zg};f.EF=function(){return this.ui};f.zd=function(){return this.Gf.nb};f.GF=function(){return this.Gf.eb};f.Sa=function(){return this.Gf.eb.X};
-f.Iq=function(){return!0};f.Jq=function(){return!0};f.nC=function(){return this.uH?this.vH:eea(this)};
-function Sx(a,b){var c=a.tH;if(c instanceof M)return c.k;if(t().f===c){c=a.ic;var d=new z(r=>"\x3d "+r);if(c.D){var e=Hs(Q(),"| ",c.q)+"Computing variances of "+a.Gf.eb.X;Af(Bf(),e+"\n")}c.q=1+c.q|0;try{var g=new xf;Nda(a.ic);var h=ru().U(),k=Lz().U();a.ui.Ag(new Um((r,u)=>{if(!(u instanceof xw&&u.cj instanceof sp)){r=bD;if(g.qb)var w=g.sb;else{if(null===g)throw ze();w=g.qb?g.sb:Ce(g,new OS(a,b,k,h))}r(w,xz(a.ic).Ej,u)}}));var l=a.Zg.m(),m=h.oe(new ex(l,new B_(a)));a.tH=(t(),new M(m));var n=m}finally{c.q=
--1+c.q|0}Gw(new E(d),c.pa)&&c.D&&(l=""+Hs(Q(),"| ",c.q)+d.n(n),Af(Bf(),l+"\n"));return n}throw new x(c);}function tA(a,b,c){return Sx(a,c).yd(b,new U(()=>Tt().En))}
-function Bw(a,b,c,d,e){var g=new Uv(d.V,d.Vc,d.Xa,d.kd,1+d.fa|0,d.Ac,d.vb,d.fb,d.ud,d.hb),h=a.ic;d=d.fa;var k=a.Gf,l=a.Zg,m=B=>{var D=B.ec,C=B.gb.Dc(b,c,g,e);return new Ul(D,CC(C),B.xd)};if(l===v())m=v();else{var n=l.e(),r=n=new A(m(n),v());for(l=l.g();l!==v();){var u=l.e();u=new A(m(u),v());r=r.r=u;l=l.g()}m=n}n=a.yj;n.b()?n=R():(n=n.o(),n=new M(Mx(Du(),n,new z(B=>QX(B,b,c,g,e)))));r=a.Wk;r.b()?r=R():(r=r.o(),r=new M(Mx(Du(),r,new z(B=>B.Dc(b,c,g,e)))));l=rF(Du(),a.ui,new z(B=>B.Mn(b,c,g,e)));ap();
-l=bp(cp(),l);u=a.wm.Dc(b,c,g,e);var w=a.jk.Dc(b,c,g,e),y=a.zo;a=rF(Du(),a.vm,new z(B=>B.Mn(b,c,g,e)));ap();return new Aw(h,d,k,m,n,r,l,u,w,y,bp(cp(),a))}
-function fea(a,b,c,d,e){var g=a.ic,h=a.um,k=a.Gf,l=a.Zg,m=B=>{var D=B.ec,C=d.aa(t().f,B.gb);return new Ul(D,CC(C),B.xd)};if(l===v())m=v();else{var n=l.e(),r=n=new A(m(n),v());for(l=l.g();l!==v();){var u=l.e();u=new A(m(u),v());r=r.r=u;l=l.g()}m=n}n=a.yj;n.b()?n=R():(n=n.o(),n=new M(Mx(Du(),n,new z(B=>{var D=B.Ua,C=B.Ma;if(C.b())C=R();else{C=C.o();if(b.b())var F=R();else F=!!b.o(),F=new M(!F);C=new M(d.aa(F,C))}return new ww(D,C,d.aa(b,B.oa),B.vd)}))));r=a.Wk;r.b()?r=R():(r=r.o(),r=new M(Mx(Du(),r,
-new z(B=>{if(b.b())var D=R();else D=!!b.o(),D=new M(!D);return d.aa(D,B)}))));l=rF(Du(),a.ui,new z(B=>B.ml(b,c,d,e)));ap();l=bp(cp(),l);b.b()?u=R():(u=!!b.o(),u=new M(!u));u=d.aa(u,a.wm);var w=d.aa(b,a.jk),y=a.zo;a=rF(Du(),a.vm,new z(B=>B.ml(b,c,d,e)));ap();return new Aw(g,h,k,m,n,r,l,u,w,y,bp(cp(),a))}
-function gea(a,b,c,d){var e=a.ic,g=a.um,h=a.Gf,k=a.Zg,l=y=>{var B=y.ec,D=c.aa(new mB(b),y.gb);return new Ul(B,CC(D),y.xd)};if(k===v())l=v();else{var m=k.e(),n=m=new A(l(m),v());for(k=k.g();k!==v();){var r=k.e();r=new A(l(r),v());n=n.r=r;k=k.g()}l=m}m=a.yj;m.b()?m=R():(m=m.o(),m=new M(Mx(Du(),m,new z(y=>{var B=y.Ua,D=y.Ma;D.b()?D=R():(D=D.o(),D=new M(c.aa(new nB(b),D)));return new ww(B,D,c.aa(b,y.oa),y.vd)}))));n=a.Wk;n.b()?n=R():(n=n.o(),n=new M(Mx(Du(),n,new z(y=>c.aa(new nB(b),y)))));k=rF(Du(),
-a.ui,new z(y=>y.Ql(b,c,d)));ap();k=bp(cp(),k);r=c.aa(new nB(b),a.wm);var u=c.aa(b,a.jk),w=a.zo;a=rF(Du(),a.vm,new z(y=>y.Ql(b,c,d)));ap();return new Aw(e,g,h,l,m,n,k,r,u,w,bp(cp(),a))}f.u=function(){var a=this.ui;return"TypedNuCls("+this.um+", "+this.Gf.eb+",\n\t"+this.Zg+",\n\t"+this.yj+",\n\tthis: "+this.wm+", "+jF(nF(),a)+",\n\t: "+this.jk+", "+this.zo+", "+this.vm+")"};f.H=function(){return"TypedNuCls"};f.G=function(){return 10};
-f.I=function(a){switch(a){case 0:return this.um;case 1:return this.Gf;case 2:return this.Zg;case 3:return this.yj;case 4:return this.Wk;case 5:return this.ui;case 6:return this.wm;case 7:return this.jk;case 8:return this.zo;case 9:return this.vm;default:return JK(W(),a)}};f.E=function(a){return a instanceof Aw};
-f.y=function(){var a=dc("TypedNuCls");a=W().B(-889275714,a);var b=this.um;a=W().B(a,b);b=this.Gf;b=dy(W(),b);a=W().B(a,b);b=this.Zg;b=dy(W(),b);a=W().B(a,b);b=this.yj;b=dy(W(),b);a=W().B(a,b);b=this.Wk;b=dy(W(),b);a=W().B(a,b);b=this.ui;b=dy(W(),b);a=W().B(a,b);b=this.wm;b=dy(W(),b);a=W().B(a,b);b=this.jk;b=dy(W(),b);a=W().B(a,b);b=this.zo;b=dy(W(),b);a=W().B(a,b);b=this.vm;b=dy(W(),b);a=W().B(a,b);return W().La(a,10)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Aw&&a.ic===this.ic){if(this.um===a.um){var b=this.Gf,c=a.Gf;b=null===b?null===c:b.h(c)}else b=!1;b?(b=this.Zg,c=a.Zg,(null===b?null===c:b.h(c))?(b=this.yj,c=a.yj,(null===b?null===c:b.h(c))?(b=this.Wk,c=a.Wk,b=null===b?null===c:b.h(c)):b=!1):b=!1):b=!1;if(b&&(b=this.ui,c=a.ui,(null===b?null===c:b.h(c))?(b=this.wm,c=a.wm,(null===b?null===c:HB(b,c))?(b=this.jk,c=a.jk,b=null===b?null===c:HB(b,c)):b=!1):b=!1,b&&(b=this.zo,c=a.zo,null===b?null===c:b.h(c))))return b=
-this.vm,a=a.vm,null===b?null===a:b.h(a)}return!1};f.Ql=function(a,b,c){return gea(this,a,b,c)};f.ml=function(a,b,c,d){return fea(this,a,b,c,d)};f.Mn=function(a,b,c,d){return Bw(this,a,b,c,d)};f.$classData=q({ZW:0},!1,"mlscript.NuTypeDefs$TypedNuCls",{ZW:1,BH:1,d:1,ms:1,Qw:1,sN:1,F:1,v:1,l:1});function Fw(a,b){this.Rw=null;this.YD=b;if(null===a)throw null;this.Rw=a}Fw.prototype=new p;Fw.prototype.constructor=Fw;f=Fw.prototype;f.Ca=function(){return this.Rw.md};f.zd=function(){return Kw()};f.C=function(){return t().f};
-f.Sa=function(){return this.YD.sf.w};f.Iq=function(){return!0};f.Jq=function(){return!0};f.no=function(){return Wx(this.Rw)};f.H=function(){return"TypedNuDummy"};f.G=function(){return 1};f.I=function(a){return 0===a?this.YD:JK(W(),a)};f.E=function(a){return a instanceof Fw};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Fw&&a.Rw===this.Rw){var b=this.YD;a=a.YD;return null===b?null===a:b.h(a)}return!1};f.FF=function(){return this.Rw};
-f.Ql=function(){return this};f.ml=function(){return this};f.Mn=function(){return this};f.$classData=q({bX:0},!1,"mlscript.NuTypeDefs$TypedNuDummy",{bX:1,d:1,ms:1,Qw:1,ZD:1,DN:1,F:1,v:1,l:1});function Ew(a,b,c,d,e){this.wN=null;this.wH=!1;this.Ao=null;this.Bo=b;this.jd=c;this.Vh=d;this.ns=e;if(null===a)throw null;this.Ao=a}Ew.prototype=new p;Ew.prototype.constructor=Ew;f=Ew.prototype;f.Ca=function(){return this.Bo};f.Iq=function(){return this.ns};f.zd=function(){return Kw()};f.Sa=function(){return this.jd.Qb.w};
-f.C=function(){return this.jd.C()};f.Jq=function(){return!0};f.no=function(){this.wH||this.wH||(this.wN=Zw($w(this.Ao),this.Bo,this.Vh),this.wH=!0);return this.wN};function $x(a){var b=a.jd.cd;b instanceof te?a=my(a.Ao,b.ca):(a=a.Ao,null===a.bu&&null===a.bu&&(a.bu=new NO(a)),a=a.bu,a.qH||a.qH||(a.uN=new aY(a.tN,t().f,Wp()),a.qH=!0),a=a.uN);return a}f.H=function(){return"TypedNuFun"};f.G=function(){return 3};
-f.I=function(a){switch(a){case 0:return this.Bo;case 1:return this.jd;case 2:return this.Vh;default:return JK(W(),a)}};f.E=function(a){return a instanceof Ew};f.y=function(){var a=dc("TypedNuFun");a=W().B(-889275714,a);var b=this.Bo;a=W().B(a,b);b=this.jd;b=dy(W(),b);a=W().B(a,b);b=this.Vh;b=dy(W(),b);a=W().B(a,b);return W().La(a,3)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Ew&&a.Ao===this.Ao){if(this.Bo===a.Bo){var b=this.jd,c=a.jd;b=null===b?null===c:b.h(c)}else b=!1;if(b)return b=this.Vh,a=a.Vh,null===b?null===a:HB(b,a)}return!1};f.FF=function(){return this.Ao};f.Ql=function(a,b){return new Ew(this.Ao,this.Bo,this.jd,b.aa(a,this.Vh),this.ns)};f.ml=function(a,b,c){return new Ew(this.Ao,this.Bo,this.jd,c.aa(a,this.Vh),this.ns)};
-f.Mn=function(a,b,c,d){var e=new Uv(c.V,c.Vc,c.Xa,c.kd,1+c.fa|0,c.Ac,c.vb,c.fb,c.ud,c.hb);return new Ew(this.Ao,c.fa,this.jd,this.Vh.Dc(a,b,e,d),this.ns)};f.$classData=q({cX:0},!1,"mlscript.NuTypeDefs$TypedNuFun",{cX:1,d:1,ms:1,Qw:1,ZD:1,DN:1,F:1,v:1,l:1});
-function hea(a){if(!a.xH){var b=a.zj,c=a.$k,d=k=>{if(null!==k){var l=k.ec,m=k.gb;if(null!==l){k=a.Yk.eb.X+"#"+l.X;var n=a.ic,r=a.ic;t();l=new xw(n,l,new ww(r,new M(m),m,V(a.ic)),!1,a.aq);return G(new H,k,l)}}throw new x(k);};if(c===v())d=v();else{var e=c.e(),g=e=new A(d(e),v());for(c=c.g();c!==v();){var h=c.e();h=new A(d(h),v());g=g.r=h;c=c.g()}d=e}a.yH=b.oe(d);a.xH=!0}return a.yH}
-function Zv(a,b,c,d,e,g,h,k){this.yH=this.ic=this.Sw=null;this.xH=!1;this.aq=b;this.Yk=c;this.Zk=d;this.Xk=e;this.$k=g;this.Il=h;this.zj=k;PS(this,a,Qo())}Zv.prototype=new QS;Zv.prototype.constructor=Zv;f=Zv.prototype;f.Ca=function(){return this.aq};f.or=function(){return this.Yk};f.pg=function(){return this.$k};f.EF=function(){return this.zj};f.zd=function(){return this.Yk.nb};f.GF=function(){return this.Yk.eb};f.Sa=function(){return this.Yk.eb.X};f.Iq=function(){return!0};f.Jq=function(){return!0};
-f.nC=function(){return this.xH?this.yH:hea(this)};
-function bw(a,b,c,d,e){var g=new Uv(d.V,d.Vc,d.Xa,d.kd,1+d.fa|0,d.Ac,d.vb,d.fb,d.ud,d.hb),h=a.ic;d=d.fa;var k=a.Yk,l=a.Zk.Dc(b,c,g,e),m=a.Xk.Dc(b,c,g,e),n=a.$k,r=B=>{var D=B.ec,C=B.gb.Dc(b,c,g,e);return new Ul(D,CC(C),B.xd)};if(n===v())r=v();else{var u=n.e(),w=u=new A(r(u),v());for(n=n.g();n!==v();){var y=n.e();y=new A(r(y),v());w=w.r=y;n=n.g()}r=u}u=Mx(Du(),a.Il,new z(B=>QX(B,b,c,g,e)));a=rF(Du(),a.zj,new z(B=>B.Mn(b,c,g,e)));ap();return new Zv(h,d,k,l,m,r,u,bp(cp(),a))}
-function iea(a,b,c,d,e){var g=a.ic,h=a.aq,k=a.Yk;if(b.b())var l=R();else l=!!b.o(),l=new M(!l);l=d.aa(l,a.Zk);if(b.b())var m=R();else m=!!b.o(),m=new M(!m);m=d.aa(m,a.Xk);var n=a.$k,r=B=>{var D=B.ec,C=d.aa(t().f,B.gb);return new Ul(D,CC(C),B.xd)};if(n===v())r=v();else{var u=n.e(),w=u=new A(r(u),v());for(n=n.g();n!==v();){var y=n.e();y=new A(r(y),v());w=w.r=y;n=n.g()}r=u}u=Mx(Du(),a.Il,new z(B=>{var D=B.Ua,C=B.Ma;if(C.b())C=R();else{C=C.o();if(b.b())var F=R();else F=!!b.o(),F=new M(!F);C=new M(d.aa(F,
-C))}return new ww(D,C,d.aa(b,B.oa),B.vd)}));a=rF(Du(),a.zj,new z(B=>B.ml(b,c,d,e)));ap();return new Zv(g,h,k,l,m,r,u,bp(cp(),a))}
-function jea(a,b,c,d){var e=a.ic,g=a.aq,h=a.Yk,k=c.aa(new nB(b),a.Zk),l=c.aa(new nB(b),a.Xk),m=a.$k,n=y=>{var B=y.ec,D=c.aa(new mB(b),y.gb);return new Ul(B,CC(D),y.xd)};if(m===v())n=v();else{var r=m.e(),u=r=new A(n(r),v());for(m=m.g();m!==v();){var w=m.e();w=new A(n(w),v());u=u.r=w;m=m.g()}n=r}r=Mx(Du(),a.Il,new z(y=>{var B=y.Ua,D=y.Ma;D.b()?D=R():(D=D.o(),D=new M(c.aa(new nB(b),D)));return new ww(B,D,c.aa(b,y.oa),y.vd)}));a=rF(Du(),a.zj,new z(y=>y.Ql(b,c,d)));ap();return new Zv(e,g,h,k,l,n,r,bp(cp(),
-a))}f.u=function(){var a=this.zj;return"TypedNuMxn("+this.aq+", "+this.Yk.eb+",\n\tthis: "+this.Zk+",\n\tsuper: "+this.Xk+",\n\ttparams: "+this.$k+",\n\tparams: "+this.Il+",\n\tmembers: "+jF(nF(),a)+"\n)"};f.H=function(){return"TypedNuMxn"};f.G=function(){return 7};f.I=function(a){switch(a){case 0:return this.aq;case 1:return this.Yk;case 2:return this.Zk;case 3:return this.Xk;case 4:return this.$k;case 5:return this.Il;case 6:return this.zj;default:return JK(W(),a)}};
-f.E=function(a){return a instanceof Zv};f.y=function(){var a=dc("TypedNuMxn");a=W().B(-889275714,a);var b=this.aq;a=W().B(a,b);b=this.Yk;b=dy(W(),b);a=W().B(a,b);b=this.Zk;b=dy(W(),b);a=W().B(a,b);b=this.Xk;b=dy(W(),b);a=W().B(a,b);b=this.$k;b=dy(W(),b);a=W().B(a,b);b=this.Il;b=dy(W(),b);a=W().B(a,b);b=this.zj;b=dy(W(),b);a=W().B(a,b);return W().La(a,7)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Zv&&a.ic===this.ic){if(this.aq===a.aq){var b=this.Yk,c=a.Yk;b=null===b?null===c:b.h(c)}else b=!1;b?(b=this.Zk,c=a.Zk,(null===b?null===c:HB(b,c))?(b=this.Xk,c=a.Xk,b=null===b?null===c:HB(b,c)):b=!1):b=!1;if(b&&(b=this.$k,c=a.$k,(null===b?null===c:b.h(c))?(b=this.Il,c=a.Il,b=null===b?null===c:b.h(c)):b=!1,b))return b=this.zj,a=a.zj,null===b?null===a:b.h(a)}return!1};f.Ql=function(a,b,c){return jea(this,a,b,c)};
-f.ml=function(a,b,c,d){return iea(this,a,b,c,d)};f.Mn=function(a,b,c,d){return bw(this,a,b,c,d)};f.$classData=q({dX:0},!1,"mlscript.NuTypeDefs$TypedNuMxn",{dX:1,BH:1,d:1,ms:1,Qw:1,sN:1,F:1,v:1,l:1});
-function kea(a){if(!a.zH){var b=a.kk,c=a.nk,d=k=>{if(null!==k){var l=k.ec,m=k.gb;if(null!==l){k=a.mk.eb.X+"#"+l.X;var n=a.ic,r=a.ic;t();l=new xw(n,l,new ww(r,new M(m),m,V(a.ic)),!0,a.cq);return G(new H,k,l)}}throw new x(k);};if(c===v())d=v();else{var e=c.e(),g=e=new A(d(e),v());for(c=c.g();c!==v();){var h=c.e();h=new A(d(h),v());g=g.r=h;c=c.g()}d=e}a.AH=b.oe(d).oe(a.xm);a.zH=!0}return a.AH}
-function yw(a,b,c,d,e,g,h,k,l){this.AH=this.ic=this.Sw=null;this.zH=!1;this.cq=b;this.mk=c;this.nk=d;this.kk=e;this.un=g;this.lk=h;this.bq=k;this.xm=l;PS(this,a,tp())}yw.prototype=new QS;yw.prototype.constructor=yw;f=yw.prototype;f.Ca=function(){return this.cq};f.or=function(){return this.mk};f.pg=function(){return this.nk};f.EF=function(){return this.kk};f.zd=function(){return this.mk.nb};f.GF=function(){return this.mk.eb};f.Sa=function(){return this.mk.eb.X};f.Iq=function(){return!0};f.Jq=function(){return!0};
-f.nC=function(){return this.zH?this.AH:kea(this)};
-function zw(a,b,c,d,e){var g=new Uv(d.V,d.Vc,d.Xa,d.kd,1+d.fa|0,d.Ac,d.vb,d.fb,d.ud,d.hb),h=a.ic;d=d.fa;var k=a.mk,l=a.nk,m=w=>{var y=w.ec,B=w.gb.Dc(b,c,g,e);return new Ul(y,CC(B),w.xd)};if(l===v())m=v();else{var n=l.e(),r=n=new A(m(n),v());for(l=l.g();l!==v();){var u=l.e();u=new A(m(u),v());r=r.r=u;l=l.g()}m=n}n=rF(Du(),a.kk,new z(w=>w.Mn(b,c,g,e)));ap();n=bp(cp(),n);r=a.un.Dc(b,c,g,e);l=a.lk.Dc(b,c,g,e);u=a.bq;a=rF(Du(),a.xm,new z(w=>w.Mn(b,c,g,e)));ap();return new yw(h,d,k,m,n,r,l,u,bp(cp(),a))}
-function lea(a,b,c,d,e){var g=a.ic,h=a.cq,k=a.mk,l=a.nk,m=w=>{var y=w.ec,B=d.aa(t().f,w.gb);return new Ul(y,CC(B),w.xd)};if(l===v())m=v();else{var n=l.e(),r=n=new A(m(n),v());for(l=l.g();l!==v();){var u=l.e();u=new A(m(u),v());r=r.r=u;l=l.g()}m=n}n=rF(Du(),a.kk,new z(w=>w.ml(b,c,d,e)));ap();n=bp(cp(),n);b.b()?r=R():(r=!!b.o(),r=new M(!r));r=d.aa(r,a.un);l=d.aa(b,a.lk);u=a.bq;a=rF(Du(),a.xm,new z(w=>w.ml(b,c,d,e)));ap();return new yw(g,h,k,m,n,r,l,u,bp(cp(),a))}
-function mea(a,b,c,d){var e=a.ic,g=a.cq,h=a.mk,k=a.nk,l=u=>{var w=u.ec,y=c.aa(new mB(b),u.gb);return new Ul(w,CC(y),u.xd)};if(k===v())l=v();else{var m=k.e(),n=m=new A(l(m),v());for(k=k.g();k!==v();){var r=k.e();r=new A(l(r),v());n=n.r=r;k=k.g()}l=m}m=rF(Du(),a.kk,new z(u=>u.Ql(b,c,d)));ap();m=bp(cp(),m);n=c.aa(new nB(b),a.un);k=c.aa(b,a.lk);r=a.bq;a=rF(Du(),a.xm,new z(u=>u.Ql(b,c,d)));ap();return new yw(e,g,h,l,m,n,k,r,bp(cp(),a))}f.H=function(){return"TypedNuTrt"};f.G=function(){return 8};
-f.I=function(a){switch(a){case 0:return this.cq;case 1:return this.mk;case 2:return this.nk;case 3:return this.kk;case 4:return this.un;case 5:return this.lk;case 6:return this.bq;case 7:return this.xm;default:return JK(W(),a)}};f.E=function(a){return a instanceof yw};
-f.y=function(){var a=dc("TypedNuTrt");a=W().B(-889275714,a);var b=this.cq;a=W().B(a,b);b=this.mk;b=dy(W(),b);a=W().B(a,b);b=this.nk;b=dy(W(),b);a=W().B(a,b);b=this.kk;b=dy(W(),b);a=W().B(a,b);b=this.un;b=dy(W(),b);a=W().B(a,b);b=this.lk;b=dy(W(),b);a=W().B(a,b);b=this.bq;b=dy(W(),b);a=W().B(a,b);b=this.xm;b=dy(W(),b);a=W().B(a,b);return W().La(a,8)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof yw&&a.ic===this.ic){if(this.cq===a.cq){var b=this.mk,c=a.mk;b=null===b?null===c:b.h(c)}else b=!1;b?(b=this.nk,c=a.nk,(null===b?null===c:b.h(c))?(b=this.kk,c=a.kk,b=null===b?null===c:b.h(c)):b=!1):b=!1;if(b&&(b=this.un,c=a.un,(null===b?null===c:HB(b,c))?(b=this.lk,c=a.lk,b=null===b?null===c:HB(b,c)):b=!1,b&&(b=this.bq,c=a.bq,null===b?null===c:b.h(c))))return b=this.xm,a=a.xm,null===b?null===a:b.h(a)}return!1};
-f.Ql=function(a,b,c){return mea(this,a,b,c)};f.ml=function(a,b,c,d){return lea(this,a,b,c,d)};f.Mn=function(a,b,c,d){return zw(this,a,b,c,d)};f.$classData=q({eX:0},!1,"mlscript.NuTypeDefs$TypedNuTrt",{eX:1,BH:1,d:1,ms:1,Qw:1,sN:1,F:1,v:1,l:1});function sP(a,b){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ax=a;this.Dz=b;mq(this)}sP.prototype=new $S;sP.prototype.constructor=sP;f=sP.prototype;f.Kj=function(){return this.ax};f.H=function(){return"Signature"};
-f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.ax;case 1:return this.Dz;default:return JK(W(),a)}};f.E=function(a){return a instanceof sP};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof sP){var b=this.ax,c=a.ax;if(null===b?null===c:b.h(c))return b=this.Dz,a=a.Dz,null===b?null===a:b.h(a)}return!1};f.$classData=q({EX:0},!1,"mlscript.Signature",{EX:1,$g:1,d:1,ah:1,Za:1,baa:1,F:1,v:1,l:1});
-function M5(a){mq(a);a.dd=t().f;a.se=t().f}function Ln(){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0}Ln.prototype=new p;Ln.prototype.constructor=Ln;function N5(){}f=N5.prototype=Ln.prototype;f.yb=function(){return Lt(this)};f.mr=function(){return rz(this,!1)};f.Kj=function(){return WO(this)};f.Nu=function(){0===(1&this.Jc)<<24>>24&&0===(1&this.Jc)<<24>>24&&(this.Le=UO(this),this.Jc=(1|this.Jc)<<24>>24);return this.Le};
-f.Jm=function(){0===(2&this.Jc)<<24>>24&&0===(2&this.Jc)<<24>>24&&(this.Me=Yp(this),this.Jc=(2|this.Jc)<<24>>24);return this.Me};f.Rm=function(){return this.Pe};f.Tl=function(a){this.Pe=a};f.Qm=function(){return this.Oe};f.Sl=function(a){this.Oe=a};f.Pm=function(){return this.Ne};f.Om=function(a){this.Ne=a};f.C=function(){0===(4&this.Jc)<<24>>24&&0===(4&this.Jc)<<24>>24&&(this.Qe=bq(this),this.Jc=(4|this.Jc)<<24>>24);return this.Qe};function O5(){this.td="trait"}O5.prototype=new YS;
-O5.prototype.constructor=O5;f=O5.prototype;f.H=function(){return"Trt"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof O5};f.y=function(){return 84374};f.u=function(){return"Trt"};f.$classData=q({NX:0},!1,"mlscript.Trt$",{NX:1,fE:1,Xy:1,Vw:1,d:1,CH:1,F:1,v:1,l:1});var P5;function tp(){P5||(P5=new O5);return P5}function iv(){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0}iv.prototype=new M4;iv.prototype.constructor=iv;
-function Q5(){}Q5.prototype=iv.prototype;function nA(a,b,c,d,e){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0;this.nc=b;this.cc=c;this.dc=d;this.lE=e;mY(this,a)}nA.prototype=new nY;nA.prototype.constructor=nA;f=nA.prototype;f.qa=function(){return this.lE};f.Ca=function(){var a=this.cc.Ca(),b=this.dc.Ca();return a>b?a:b};f.rb=function(a,b){var c=this.cc.rb(a,b);a=this.dc.rb(a,b);return c>a?c:a};f.u=function(){return"("+this.cc+" "+(this.nc?"|":"\x26")+" "+this.dc+")"};
-f.H=function(){return"ComposedType"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.nc;case 1:return this.cc;case 2:return this.dc;default:return JK(W(),a)}};f.E=function(a){return a instanceof nA};f.$classData=q({xY:0},!1,"mlscript.TyperDatatypes$ComposedType",{xY:1,Mg:1,wg:1,d:1,xg:1,Ng:1,F:1,v:1,l:1});function nea(a){if(!a.YH){var b=YC(a,!1).m();b=new eg(b,new z(d=>d.Ca()));var c=dq();a.ZH=QG(b,c)|0;a.YH=!0}return a.ZH}
-function yB(a,b,c){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.ZH=this.Wc=0;this.SN=null;this.YH=!1;this.Aj=b;this.ej=c;mY(this,a);this.SN=c.qa()}yB.prototype=new nY;yB.prototype.constructor=yB;f=yB.prototype;f.qa=function(){return this.SN};f.Ca=function(){return this.YH?this.ZH:nea(this)};f.rb=function(a,b){var c=YC(this,!1).m();c=new eg(c,new z(e=>e.rb(a,b)));var d=dq();return QG(c,d)|0};
-f.u=function(){var a=this.ej,b=this.Aj,c=h=>{if(null!==h)return h.i()+" \x3c: "+h.j();throw new x(h);};if(b===v())c=v();else{var d=b.e(),e=d=new A(c(d),v());for(b=b.g();b!==v();){var g=b.e();g=new A(c(g),v());e=e.r=g;b=b.g()}c=d}return"{"+a+" where: "+Qe(c,"",", ","")+"}"};f.H=function(){return"ConstrainedType"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Aj;case 1:return this.ej;default:return JK(W(),a)}};f.E=function(a){return a instanceof yB};
-f.$classData=q({yY:0},!1,"mlscript.TyperDatatypes$ConstrainedType",{yY:1,Mg:1,wg:1,d:1,xg:1,Ng:1,F:1,v:1,l:1});function gA(a,b,c){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0;this.sh=b;this.DY=c;mY(this,a)}gA.prototype=new nY;gA.prototype.constructor=gA;f=gA.prototype;f.qa=function(){return this.DY};f.Ca=function(){return this.p.md};f.rb=function(){return this.p.md};f.u=function(){return this.sh?"\u22a5":"\u22a4"};f.H=function(){return"ExtrType"};f.G=function(){return 1};
-f.I=function(a){return 0===a?this.sh:JK(W(),a)};f.E=function(a){return a instanceof gA};f.$classData=q({CY:0},!1,"mlscript.TyperDatatypes$ExtrType",{CY:1,Mg:1,wg:1,d:1,xg:1,Ng:1,F:1,v:1,l:1});function oA(a,b,c){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0;this.xc=b;this.Tz=c;mY(this,a)}oA.prototype=new nY;oA.prototype.constructor=oA;f=oA.prototype;f.qa=function(){return this.Tz};f.Ca=function(){return this.xc.Ca()};f.rb=function(a,b){return this.xc.rb(a,b)};
-f.u=function(){return"~("+this.xc+")"};f.H=function(){return"NegType"};f.G=function(){return 1};f.I=function(a){return 0===a?this.xc:JK(W(),a)};f.E=function(a){return a instanceof oA};f.$classData=q({LY:0},!1,"mlscript.TyperDatatypes$NegType",{LY:1,Mg:1,wg:1,d:1,xg:1,Ng:1,F:1,v:1,l:1});function dv(a,b,c){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.xO=this.Wc=0;this.jI=!1;this.Ba=b;this.Cj=c;mY(this,a)}dv.prototype=new nY;dv.prototype.constructor=dv;f=dv.prototype;f.qa=function(){return this.Cj};
-f.Ca=function(){this.jI||this.jI||(this.xO=this.rb(this.p.tf,Lz().U()),this.jI=!0);return this.xO};f.rb=function(a,b){var c=this.Ba.m();c=new eg(c,new z(e=>e.j().rb(a,b)));var d=dq();c=hq(c,d);return(c.b()?this.p.md:c.o())|0};function Gu(a,b,c,d,e){return rC(a.p,a,t().f,new Um((g,h)=>h.Dc(b,c,d,e)))}
-function hda(a){var b=a.Ba,c=h=>{var k=a.p,l=O().c;return new dv(k,new A(h,l),a.Cj)};if(b===v())c=v();else{var d=b.e(),e=d=new A(c(d),v());for(b=b.g();b!==v();){var g=b.e();g=new A(c(g),v());e=e.r=g;b=b.g()}c=d}for(d=a.p.Na;!c.b();)e=c.e(),d=new nA(a.p,!1,d,e,V(a.p)),c=c.g();return d}function fu(a){var b=a.p,c=a.Ba,d=new z(h=>h.i()),e=mu(),g=ap().wa;return new dv(b,OY(c,d,new ou(e,g)),a.Cj)}
-f.u=function(){var a=this.Ba;if(a===v())var b=v();else{b=a.e();var c=b=new A(b.i().w+": "+b.j(),v());for(a=a.g();a!==v();){var d=a.e();d=new A(d.i().w+": "+d.j(),v());c=c.r=d;a=a.g()}}return"{"+Qe(b,"",", ","")+"}"};f.H=function(){return"RecordType"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Ba:JK(W(),a)};f.E=function(a){return a instanceof dv};f.Dc=function(a,b,c,d){return Gu(this,a,b,c,d)};
-f.$classData=q({TY:0},!1,"mlscript.TyperDatatypes$RecordType",{TY:1,Mg:1,wg:1,d:1,xg:1,Ng:1,F:1,v:1,l:1});function wB(a,b,c,d){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0;this.vg=b;this.Jf=c;this.CO=d;mY(this,a)}wB.prototype=new nY;wB.prototype.constructor=wB;f=wB.prototype;f.qa=function(){return this.CO};f.Ca=function(){var a=this.vg.Ca(),b=this.Jf.Ca();return a>b?a:b};f.rb=function(a,b){var c=this.vg.rb(a,b);a=this.Jf.rb(a,b);return c>a?c:a};
-f.u=function(){return this.vg+".."+this.Jf};f.H=function(){return"TypeBounds"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.vg;case 1:return this.Jf;default:return JK(W(),a)}};f.E=function(a){return a instanceof wB};f.$classData=q({aZ:0},!1,"mlscript.TyperDatatypes$TypeBounds",{aZ:1,Mg:1,wg:1,d:1,xg:1,Ng:1,F:1,v:1,l:1});
-function wn(a,b,c,d,e,g,h,k,l){this.qP=null;this.oP=!1;this.pP=this.rP=this.nP=null;this.Xo=a;this.EI=b;this.DE=c;this.FE=d;this.IE=e;this.EE=g;this.HE=h;this.GE=k;this.eA=l;wD(this);this.qP=O().c;this.oP=!0;this.nP=t().f;this.rP=t().f}wn.prototype=new p;wn.prototype.constructor=wn;f=wn.prototype;f.eK=function(){return this.pP};f.fK=function(a){this.pP=a};f.Sa=function(){return this.Xo};f.Lu=function(){return this.DE};f.hB=function(){return this.FE};f.HL=function(){return this.IE};f.jF=function(){return this.EE};
-f.Yx=function(){return this.HE};f.iB=function(){return this.GE};f.kK=function(){return this.eA};f.u=function(){return"mixin "+this.Xo};f.Sn=function(){return this.Xo};f.ep=function(){return this.Xo};f.UG=function(){return this.qP};f.CJ=function(){return this.oP};f.iF=function(){return this.nP};f.RL=function(){return this.rP};f.H=function(){return"MixinSymbol"};f.G=function(){return 9};
-f.I=function(a){switch(a){case 0:return this.Xo;case 1:return this.EI;case 2:return this.DE;case 3:return this.FE;case 4:return this.IE;case 5:return this.EE;case 6:return this.HE;case 7:return this.GE;case 8:return this.eA;default:return JK(W(),a)}};f.E=function(a){return a instanceof wn};f.y=function(){return jL(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof wn){if(this.Xo===a.Xo){var b=this.EI,c=a.EI;b=null===b?null===c:b.h(c)}else b=!1;b?(b=this.DE,c=a.DE,(null===b?null===c:b.h(c))?(b=this.FE,c=a.FE,b=null===b?null===c:b.h(c)):b=!1):b=!1;if(b&&(b=this.IE,c=a.IE,(null===b?null===c:b.h(c))?(b=this.EE,c=a.EE,b=null===b?null===c:b.h(c)):b=!1,b&&(b=this.HE,c=a.HE,null===b?null===c:b.h(c)))&&(b=this.GE,c=a.GE,null===b?null===c:b.h(c)))return b=this.eA,a=a.eA,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({LZ:0},!1,"mlscript.codegen.MixinSymbol",{LZ:1,d:1,wA:1,rq:1,Gs:1,QE:1,F:1,v:1,l:1});function $m(a,b,c,d,e,g,h,k,l){this.tP=!1;this.uP=this.wP=this.vP=this.sP=null;this.gj=a;this.FI=b;this.JE=c;this.LE=d;this.NE=e;this.KE=g;this.OE=h;this.ME=k;this.fA=l;wD(this);this.tP=!1;this.sP=t().f;this.vP=O().c;this.wP=t().f}$m.prototype=new p;$m.prototype.constructor=$m;f=$m.prototype;f.eK=function(){return this.uP};f.fK=function(a){this.uP=a};f.Sa=function(){return this.gj};f.Lu=function(){return this.JE};
-f.hB=function(){return this.LE};f.HL=function(){return this.NE};f.jF=function(){return this.KE};f.UG=function(){return this.OE};f.iB=function(){return this.ME};f.kK=function(){return this.fA};f.u=function(){return"module "+this.gj};f.Sn=function(){return this.gj};f.ep=function(){return this.gj};f.CJ=function(){return this.tP};f.iF=function(){return this.sP};f.Yx=function(){return this.vP};f.RL=function(){return this.wP};f.H=function(){return"ModuleSymbol"};f.G=function(){return 9};
-f.I=function(a){switch(a){case 0:return this.gj;case 1:return this.FI;case 2:return this.JE;case 3:return this.LE;case 4:return this.NE;case 5:return this.KE;case 6:return this.OE;case 7:return this.ME;case 8:return this.fA;default:return JK(W(),a)}};f.E=function(a){return a instanceof $m};f.y=function(){return jL(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof $m){if(this.gj===a.gj){var b=this.FI,c=a.FI;b=null===b?null===c:b.h(c)}else b=!1;b?(b=this.JE,c=a.JE,(null===b?null===c:b.h(c))?(b=this.LE,c=a.LE,b=null===b?null===c:b.h(c)):b=!1):b=!1;if(b&&(b=this.NE,c=a.NE,(null===b?null===c:b.h(c))?(b=this.KE,c=a.KE,b=null===b?null===c:b.h(c)):b=!1,b&&(b=this.OE,c=a.OE,null===b?null===c:b.h(c)))&&(b=this.ME,c=a.ME,null===b?null===c:b.h(c)))return b=this.fA,a=a.fA,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({MZ:0},!1,"mlscript.codegen.ModuleSymbol",{MZ:1,d:1,wA:1,rq:1,Gs:1,QE:1,F:1,v:1,l:1});function Ym(a,b,c,d,e,g,h,k,l,m,n,r,u){this.yP=null;this.ai=a;this.PE=b;this.kA=c;this.iA=d;this.lA=e;this.qA=g;this.oA=h;this.jA=k;this.pA=l;this.nA=m;this.mA=n;this.ux=r;this.xu=u;wD(this)}Ym.prototype=new p;Ym.prototype.constructor=Ym;f=Ym.prototype;f.eK=function(){return this.yP};f.fK=function(a){this.yP=a};f.Sa=function(){return this.ai};f.iF=function(){return this.kA};f.Lu=function(){return this.iA};
-f.hB=function(){return this.lA};f.RL=function(){return this.qA};f.HL=function(){return this.oA};f.jF=function(){return this.jA};f.UG=function(){return this.pA};f.Yx=function(){return this.nA};f.iB=function(){return this.mA};f.kK=function(){return this.ux};f.CJ=function(){return this.xu};f.u=function(){return"new class "+this.ai};f.Sn=function(){return this.ai};f.ep=function(){return this.ai};f.H=function(){return"NewClassSymbol"};f.G=function(){return 13};
-f.I=function(a){switch(a){case 0:return this.ai;case 1:return this.PE;case 2:return this.kA;case 3:return this.iA;case 4:return this.lA;case 5:return this.qA;case 6:return this.oA;case 7:return this.jA;case 8:return this.pA;case 9:return this.nA;case 10:return this.mA;case 11:return this.ux;case 12:return this.xu;default:return JK(W(),a)}};f.E=function(a){return a instanceof Ym};
-f.y=function(){var a=dc("NewClassSymbol");a=W().B(-889275714,a);var b=this.ai;b=dy(W(),b);a=W().B(a,b);b=this.PE;b=dy(W(),b);a=W().B(a,b);b=this.kA;b=dy(W(),b);a=W().B(a,b);b=this.iA;b=dy(W(),b);a=W().B(a,b);b=this.lA;b=dy(W(),b);a=W().B(a,b);b=this.qA;b=dy(W(),b);a=W().B(a,b);b=this.oA;b=dy(W(),b);a=W().B(a,b);b=this.jA;b=dy(W(),b);a=W().B(a,b);b=this.pA;b=dy(W(),b);a=W().B(a,b);b=this.nA;b=dy(W(),b);a=W().B(a,b);b=this.mA;b=dy(W(),b);a=W().B(a,b);b=this.ux;b=dy(W(),b);a=W().B(a,b);b=this.xu?1231:
-1237;a=W().B(a,b);return W().La(a,13)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Ym){if(this.xu===a.xu)if(this.ai===a.ai){var b=this.PE,c=a.PE;b=null===b?null===c:b.h(c)}else b=!1;else b=!1;b?(b=this.kA,c=a.kA,(null===b?null===c:b.h(c))?(b=this.iA,c=a.iA,(null===b?null===c:b.h(c))?(b=this.lA,c=a.lA,b=null===b?null===c:b.h(c)):b=!1):b=!1):b=!1;if(b&&(b=this.qA,c=a.qA,(null===b?null===c:b.h(c))?(b=this.oA,c=a.oA,(null===b?null===c:b.h(c))?(b=this.jA,c=a.jA,b=null===b?null===c:b.h(c)):b=!1):b=!1,b&&(b=this.pA,c=a.pA,(null===b?
-null===c:b.h(c))?(b=this.nA,c=a.nA,b=null===b?null===c:b.h(c)):b=!1,b&&(b=this.mA,c=a.mA,null===b?null===c:b.h(c)))))return b=this.ux,a=a.ux,null===b?null===a:b.h(a)}return!1};f.$classData=q({OZ:0},!1,"mlscript.codegen.NewClassSymbol",{OZ:1,d:1,wA:1,rq:1,Gs:1,QE:1,F:1,v:1,l:1});function R5(a,b){for(;;){if(0>=a||b.b())return b;a=-1+a|0;b=b.g()}}function gt(a,b){for(;;)if(!a.b()&&b.n(a.e()))a=a.g();else break;return a}
-function S5(a,b){var c=a.pj().Db();for(a=a.m();a.s();){var d=b.n(a.t());c.S(d)}return c.Eb()}function T5(a,b){var c=a.pj().Db();c.oc(a);c.oc(b);return c.Eb()}function Ix(a,b){if(0>=a.$a(1))return a;for(var c=a.hi(),d=Gn(),e=a.m(),g=!1;e.s();){var h=e.t();d.eh(b.n(h))?c.S(h):g=!0}return g?c.Eb():a}function Qq(a,b){this.MF=0;this.gd=a;if(null===a)throw dk("null value for BigDecimal");if(null===b)throw dk("null MathContext for BigDecimal");this.MF=1565550863}Qq.prototype=new gW;
-Qq.prototype.constructor=Qq;f=Qq.prototype;f.sk=function(a){return yW(this.gd,a.gd)};
-f.y=function(){if(1565550863===this.MF){if(this.Tu()&&4934>(Pq(this.gd)-this.gd.wb|0))var a=U5(new BR,zW(this.gd)).y();else{a=this.gd.ap();if(Infinity!==a&&-Infinity!==a){var b=Lq();a=V5(this,sR(a,b.ay))}else a=!1;if(a)a=this.gd.ap(),a=IK(W(),a);else{a=wW(this.gd);b=kL();var c=b.dp,d;var e=d=a.wb,g=e>>31,h=d>>31;d=e-d|0;g=(-2147483648^d)>(-2147483648^e)?-1+(g-h|0)|0:g-h|0;64>a.Rh?(e=a.qg,0===e.W&&0===e.Z?(e=aN(),d=new fb(d,g),g=d.W,d=d.W===g&&d.Z===g>>31?cN(e,ca,d.W):0<=d.Z?YM(0,2147483647):YM(0,
--2147483648)):d=cN(aN(),a.qg,fN(aN(),new fb(d,g)))):d=wR(new Mq,TM(a),fN(aN(),new fb(d,g)));a=c.call(b,zW(d).y(),a.wb)}}this.MF=a}return this.MF};
-f.h=function(a){if(a instanceof Qq)return V5(this,a);if(a instanceof BR){var b=W5(a),c=Pq(this.gd);if(b>3.3219280948873626*(-2+(c-this.gd.wb|0)|0)){if(this.Tu())try{var d=new M(U5(new BR,tW(this.gd)))}catch(e){if(e instanceof zc)d=R();else throw e;}else d=R();if(d.b())return!1;b=d.o();return X5(a,b)}return!1}return"number"===typeof a?(b=+a,Infinity!==b&&-Infinity!==b&&(a=this.gd.ap(),Infinity!==a&&-Infinity!==a&&a===b)?(b=Lq(),V5(this,sR(a,b.ay))):!1):va(a)?(b=Math.fround(a),Infinity!==b&&-Infinity!==
-b&&(a=this.gd.Pu(),Infinity!==a&&-Infinity!==a&&a===b)?(b=Lq(),V5(this,sR(a,b.ay))):!1):this.UA()&&jK(this,a)};f.EJ=function(){try{return sW(this.gd,8),!0}catch(a){if(a instanceof zc)return!1;throw a;}};f.GJ=function(){try{return sW(this.gd,16),!0}catch(a){if(a instanceof zc)return!1;throw a;}};f.FJ=function(){return this.oF()&&0<=sW(this.gd,32).W&&65535>=sW(this.gd,32).W};f.oF=function(){try{return sW(this.gd,32),!0}catch(a){if(a instanceof zc)return!1;throw a;}};
-f.UA=function(){try{return sW(this.gd,64),!0}catch(a){if(a instanceof zc)return!1;throw a;}};f.Tu=function(){return 0>=this.gd.wb?!0:0>=wW(this.gd).wb};function V5(a,b){return 0===yW(a.gd,b.gd)}f.MA=function(){return this.gd.Ri()<<24>>24};f.gC=function(){return this.gd.Ri()<<16>>16};f.Ri=function(){return this.gd.Ri()};f.ll=function(){return this.gd.ll()};f.Pu=function(){return this.gd.Pu()};f.ap=function(){return this.gd.ap()};f.u=function(){return this.gd.u()};
-f.gl=function(a){return yW(this.gd,a.gd)};f.YS=function(){return this.gd};f.$classData=q({P2:0},!1,"scala.math.BigDecimal",{P2:1,l3:1,Kq:1,d:1,l:1,m3:1,$Q:1,Wi:1,xe:1});function Y5(a){a=a.Lf;return!(0===a.W&&-2147483648===a.Z)}function Z5(a){a=Yi($5(a),2147483647);return 0!==a.Ya&&!a.h(wK().YQ)}function AR(a,b,c){a.Wl=b;a.Lf=c;return a}function U5(a,b){AR(a,b,63>=Mh(bi(),b)?b.ll():new fb(0,-2147483648));return a}function BR(){this.Wl=null;this.Lf=ca}BR.prototype=new gW;BR.prototype.constructor=BR;
-f=BR.prototype;f.sk=function(a){return a6(this,a)};function $5(a){var b=a.Wl;if(null!==b)return b;var c=a.Lf;b=c.W;c=c.Z;b=zi(Zh(),new fb(b,c));return a.Wl=b}f.y=function(){if(this.UA()){var a=this.ll(),b=a.W;a=a.Z;return(-1===a?0<=(-2147483648^b):-1<a)&&(0===a?-1>=(-2147483648^b):0>a)?b:HK(W(),new fb(b,a))}b=$5(this);return dy(W(),b)};
-f.h=function(a){if(a instanceof BR)return X5(this,a);if(a instanceof Qq)return a.h(this);if("number"===typeof a){a=+a;var b=W5(this);if(53>=b)b=!0;else{var c=b6(this);b=1024>=b&&c>=(-53+b|0)&&1024>c}return(b?!Z5(this):!1)&&this.ap()===a}return va(a)?(a=Math.fround(a),b=W5(this),24>=b?b=!0:(c=b6(this),b=128>=b&&c>=(-24+b|0)&&128>c),b&&!Z5(this)?(b=$5(this),RL(TL(),ei(li(),b))===a):!1):this.UA()&&jK(this,a)};
-f.EJ=function(){var a=this.Lf,b=a.Z;return(-1===b?2147483520<=(-2147483648^a.W):-1<b)?(a=this.Lf,b=a.Z,0===b?-2147483521>=(-2147483648^a.W):0>b):!1};f.GJ=function(){var a=this.Lf,b=a.Z;return(-1===b?2147450880<=(-2147483648^a.W):-1<b)?(a=this.Lf,b=a.Z,0===b?-2147450881>=(-2147483648^a.W):0>b):!1};f.FJ=function(){if(0<=this.Lf.Z){var a=this.Lf,b=a.Z;return 0===b?-2147418113>=(-2147483648^a.W):0>b}return!1};
-f.oF=function(){var a=this.Lf,b=a.Z;return(-1===b?0<=(-2147483648^a.W):-1<b)?(a=this.Lf,b=a.Z,0===b?-1>=(-2147483648^a.W):0>b):!1};f.UA=function(){return Y5(this)||zK(Pl(),this.Wl,wK().tK)};f.Tu=function(){return!0};function X5(a,b){return Y5(a)?Y5(b)?(a=a.Lf,b=b.Lf,a.W===b.W&&a.Z===b.Z):!1:!Y5(b)&&zK(Pl(),a.Wl,b.Wl)}function a6(a,b){if(Y5(a)){if(Y5(b)){var c=a.Lf;a=c.W;c=c.Z;var d=b.Lf;b=d.W;d=d.Z;return Bb(Cb(),a,c,b,d)}return-b.Wl.Ya|0}return Y5(b)?a.Wl.Ya:PL(a.Wl,b.Wl)}
-function Ot(a){if(Y5(a)){var b=wK(),c=a.Lf;a=c.W;c=c.Z;return FR(b,new fb(-a|0,0!==a?~c:-c|0))}return GR(wK(),Ci($5(a)))}function b6(a){if(Y5(a)){var b=a.Lf;if(0===b.W&&0===b.Z)return-1;b=a.Lf;a=b.W;b=b.Z;return 0!==a?0===a?32:31-Math.clz32(a&(-a|0))|0:32+(0===b?32:31-Math.clz32(b&(-b|0))|0)|0}return AW($5(a))}
-function W5(a){if(Y5(a)){if(0>a.Lf.Z){a=a.Lf;var b=a.Z;a=1+a.W|0;var c=0===a?1+b|0:b;b=-a|0;a=0!==a?~c:-c|0;return 64-(0!==a?Math.clz32(a):32+Math.clz32(b)|0)|0}b=a.Lf;a=b.W;b=b.Z;return 64-(0!==b?Math.clz32(b):32+Math.clz32(a)|0)|0}a=a.Wl;return Mh(bi(),a)}f.MA=function(){return this.Ri()<<24>>24};f.gC=function(){return this.Ri()<<16>>16};f.Ri=function(){return Y5(this)?this.Lf.W:$5(this).Ri()};f.ll=function(){return Y5(this)?this.Lf:this.Wl.ll()};
-f.Pu=function(){var a=$5(this);return RL(TL(),ei(li(),a))};f.ap=function(){if(this.UA())if(-2097152<=this.Lf.Z){var a=this.Lf,b=a.Z;a=2097152===b?0===a.W:2097152>b}else a=!1;else a=!1;if(a)return a=this.Lf,KF(Cb(),a.W,a.Z);a=$5(this);return KL(Ab(),ei(li(),a))};f.u=function(){if(Y5(this)){var a=this.Lf;return JF(Cb(),a.W,a.Z)}a=this.Wl;return ei(li(),a)};f.gl=function(a){return a6(this,a)};f.YS=function(){return $5(this)};
-var ER=q({R2:0},!1,"scala.math.BigInt",{R2:1,l3:1,Kq:1,d:1,l:1,m3:1,$Q:1,Wi:1,xe:1});BR.prototype.$classData=ER;function c6(){this.oB=null;d6=this;this.oB=new r2(this)}c6.prototype=new p;c6.prototype.constructor=c6;f=c6.prototype;f.Nj=function(a){return a===this.oB};f.Qj=function(a,b){return 0>=this.Fa(a,b)};f.xk=function(a,b){return 0<=this.Fa(a,b)};f.wk=function(a,b){return 0<this.Fa(a,b)};f.lj=function(a,b){return n2(this,a,b)};f.nl=function(a,b){return o2(this,a,b)};
-f.ol=function(a,b){return p2(this,a,b)};f.Fa=function(a,b){a|=0;b|=0;return a===b?0:a<b?-1:1};f.$classData=q({e3:0},!1,"scala.math.Ordering$Int$",{e3:1,d:1,f3:1,Um:1,Si:1,Wm:1,Tm:1,l:1,Paa:1});var d6;function dq(){d6||(d6=new c6);return d6}function e6(){this.Ci=null;this.wf=0}e6.prototype=new J5;e6.prototype.constructor=e6;function f6(){}f6.prototype=e6.prototype;e6.prototype.jh=function(){return ma(Td)};e6.prototype.gi=function(a){return new pd(a)};function g6(){this.Ci=null;this.wf=0}
-g6.prototype=new J5;g6.prototype.constructor=g6;function h6(){}h6.prototype=g6.prototype;g6.prototype.jh=function(){return ma(Xd)};g6.prototype.gi=function(a){return new vd(a)};function i6(){this.Ci=null;this.wf=0}i6.prototype=new J5;i6.prototype.constructor=i6;function j6(){}j6.prototype=i6.prototype;i6.prototype.jh=function(){return ma(Vd)};i6.prototype.gi=function(a){return new td(a)};function k6(){this.Ci=null;this.wf=0}k6.prototype=new J5;k6.prototype.constructor=k6;function l6(){}
-l6.prototype=k6.prototype;k6.prototype.jh=function(){return ma(ce)};k6.prototype.gi=function(a){return new Dd(a)};function m6(){this.Ci=null;this.wf=0}m6.prototype=new J5;m6.prototype.constructor=m6;function n6(){}n6.prototype=m6.prototype;m6.prototype.jh=function(){return ma(ae)};m6.prototype.gi=function(a){return new Bd(a)};function o6(){this.Ci=null;this.wf=0}o6.prototype=new J5;o6.prototype.constructor=o6;function p6(){}p6.prototype=o6.prototype;o6.prototype.jh=function(){return ma(Zd)};
-o6.prototype.gi=function(a){return new zd(a)};function q6(){this.Ci=null;this.wf=0}q6.prototype=new J5;q6.prototype.constructor=q6;function r6(){}r6.prototype=q6.prototype;q6.prototype.jh=function(){return ma($d)};q6.prototype.gi=function(a){return new Ad(a)};function s6(){this.pB=null;this.Rq=0}s6.prototype=new L5;s6.prototype.constructor=s6;function t6(){}t6.prototype=s6.prototype;s6.prototype.u=function(){return this.pB};s6.prototype.h=function(a){return this===a};s6.prototype.y=function(){return this.Rq};
-function u6(){this.Ci=null;this.wf=0}u6.prototype=new J5;u6.prototype.constructor=u6;function v6(){}v6.prototype=u6.prototype;u6.prototype.jh=function(){return ma(Yd)};u6.prototype.gi=function(a){return new wd(a)};function w6(){this.Ci=null;this.wf=0}w6.prototype=new J5;w6.prototype.constructor=w6;function x6(){}x6.prototype=w6.prototype;w6.prototype.jh=function(){return ma(Qd)};w6.prototype.gi=function(a){return new (Nd(Xa).Ja)(a)};
-function dP(a,b){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.pi=a;this.qi=b;mq(this)}dP.prototype=new C_;dP.prototype.constructor=dP;f=dP.prototype;f.H=function(){return"Bounds"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.pi;case 1:return this.qi;default:return JK(W(),a)}};f.E=function(a){return a instanceof dP};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof dP){var b=this.pi,c=a.pi;if(null===b?null===c:b.h(c))return b=this.qi,a=a.qi,null===b?null===a:b.h(a)}return!1};f.$classData=q({DT:0},!1,"mlscript.Bounds",{DT:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,F:1,v:1,l:1});function y6(){this.td="class"}y6.prototype=new YS;y6.prototype.constructor=y6;f=y6.prototype;f.H=function(){return"Cls"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof y6};f.y=function(){return 67850};
-f.u=function(){return"Cls"};f.$classData=q({RT:0},!1,"mlscript.Cls$",{RT:1,fE:1,Xy:1,Vw:1,d:1,iM:1,CH:1,F:1,v:1,l:1});var z6;function pp(){z6||(z6=new y6);return z6}function hP(a,b,c){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.iw=a;this.jw=b;this.kw=c;mq(this)}hP.prototype=new C_;hP.prototype.constructor=hP;f=hP.prototype;f.H=function(){return"Constrained"};f.G=function(){return 3};
-f.I=function(a){switch(a){case 0:return this.iw;case 1:return this.jw;case 2:return this.kw;default:return JK(W(),a)}};f.E=function(a){return a instanceof hP};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof hP){var b=this.iw,c=a.iw;if(null===b?null===c:b.h(c))if(b=this.jw,c=a.jw,null===b?null===c:b.h(c))return b=this.kw,a=a.kw,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({UT:0},!1,"mlscript.Constrained",{UT:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,F:1,v:1,l:1});function nt(a,b){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.Jr=a;this.Kr=b;mq(this)}nt.prototype=new C_;nt.prototype.constructor=nt;f=nt.prototype;f.H=function(){return"Function"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Jr;case 1:return this.Kr;default:return JK(W(),a)}};
-f.E=function(a){return a instanceof nt};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof nt){var b=this.Jr,c=a.Jr;if(null===b?null===c:b.h(c))return b=this.Kr,a=a.Kr,null===b?null===a:b.h(a)}return!1};f.$classData=q({yU:0},!1,"mlscript.Function",{yU:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,F:1,v:1,l:1});function A6(){this.td="module"}A6.prototype=new YS;A6.prototype.constructor=A6;f=A6.prototype;f.H=function(){return"Mod"};f.G=function(){return 0};
-f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof A6};f.y=function(){return 77538};f.u=function(){return"Mod"};f.$classData=q({eW:0},!1,"mlscript.Mod$",{eW:1,fE:1,Xy:1,Vw:1,d:1,iM:1,CH:1,F:1,v:1,l:1});var B6;function mp(){B6||(B6=new A6);return B6}function bP(a){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.Gw=a;mq(this)}bP.prototype=new C_;bP.prototype.constructor=bP;f=bP.prototype;f.H=function(){return"Neg"};
-f.G=function(){return 1};f.I=function(a){return 0===a?this.Gw:JK(W(),a)};f.E=function(a){return a instanceof bP};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof bP){var b=this.Gw;a=a.Gw;return null===b?null===a:b.h(a)}return!1};f.$classData=q({jW:0},!1,"mlscript.Neg",{jW:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,F:1,v:1,l:1});
-function En(a){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.rs=a;mq(this)}En.prototype=new C_;En.prototype.constructor=En;f=En.prototype;f.H=function(){return"Record"};f.G=function(){return 1};f.I=function(a){return 0===a?this.rs:JK(W(),a)};f.E=function(a){return a instanceof En};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof En){var b=this.rs;a=a.rs;return null===b?null===a:b.h(a)}return!1};f.$classData=q({uX:0},!1,"mlscript.Record",{uX:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,F:1,v:1,l:1});function cP(a,b){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.Ww=a;this.Bz=b;mq(this)}cP.prototype=new C_;cP.prototype.constructor=cP;f=cP.prototype;f.H=function(){return"Rem"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.Ww;case 1:return this.Bz;default:return JK(W(),a)}};f.E=function(a){return a instanceof cP};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof cP){var b=this.Ww,c=a.Ww;if(null===b?null===c:b.h(c))return b=this.Bz,a=a.Bz,null===b?null===a:b.h(a)}return!1};f.$classData=q({vX:0},!1,"mlscript.Rem",{vX:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,F:1,v:1,l:1});
-function kP(a,b){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.Yw=a;this.Zw=b;mq(this)}kP.prototype=new C_;kP.prototype.constructor=kP;f=kP.prototype;f.H=function(){return"Selection"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Yw;case 1:return this.Zw;default:return JK(W(),a)}};f.E=function(a){return a instanceof kP};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof kP){var b=this.Yw,c=a.Yw;if(null===b?null===c:b.h(c))return b=this.Zw,a=a.Zw,null===b?null===a:b.h(a)}return!1};f.$classData=q({BX:0},!1,"mlscript.Selection",{BX:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,F:1,v:1,l:1});function iP(a){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.cx=a;mq(this)}iP.prototype=new C_;iP.prototype.constructor=iP;f=iP.prototype;f.H=function(){return"Splice"};
-f.G=function(){return 1};f.I=function(a){return 0===a?this.cx:JK(W(),a)};f.E=function(a){return a instanceof iP};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof iP){var b=this.cx;a=a.cx;return null===b?null===a:b.h(a)}return!1};f.$classData=q({IX:0},!1,"mlscript.Splice",{IX:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,F:1,v:1,l:1});
-function aP(a){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.hu=a;mq(this)}aP.prototype=new C_;aP.prototype.constructor=aP;f=aP.prototype;f.H=function(){return"Tuple"};f.G=function(){return 1};f.I=function(a){return 0===a?this.hu:JK(W(),a)};f.E=function(a){return a instanceof aP};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof aP){var b=this.hu;a=a.hu;return null===b?null===a:b.h(a)}return!1};f.$classData=q({PX:0},!1,"mlscript.Tuple",{PX:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,F:1,v:1,l:1});function C6(a){fp();return Vp(a)}function D6(a,b,c,d,e){if(pp()!==b&&mp()!==b&&np()!==b&&tp()!==b){var g=new mf(new nf(J(new L,[""," "," cannot be used as a type"])));b=[pf(qf(),b.td),pf(qf(),c)];Xv(a,sf(g,J(new L,b)),d,e)}}
-function E6(a,b,c,d,e,g){d=d.Y(c);d.b()&&(d=e.vb.Y(c),d.b()?d=R():(d=d.o(),d=new M(G(new H,d.dj,d.zm.K()))));if(d.b())if(e=PB(e,c),e.b())e=R();else a:{if(d=e.o(),d instanceof Lw&&(e=d.rh,e instanceof cx)){D6(a,e.or().nb,e.GF().X,b,g);t();d=e.or().nb;e=e.pg();e=G(new H,d,e.K());e=new M(e);break a}if(d instanceof Iw){e=d.Kb.zd();D6(a,e,d.Kb.sf.w,b,g);var h=!1;e=null;d=d.Kb;if(d instanceof io){h=!0;e=d;var k=e.nb,l=e.bg;if(pp()===k||mp()===k||np()===k||tp()===k){t();e=G(new H,k,l.K());e=new M(e);break a}}if(h&&
-(h=e.nb,e=e.bg,Qo()===h)){t();e=G(new H,h,e.K());e=new M(e);break a}if(d instanceof Kn){e=t().f;break a}throw new x(d);}e=t().f}else e=d;if(e.b())return O(),new te(new U(()=>Xv(a,pf(qf(),"type identifier not found: "+c),b,g)));O();e=e.o();return new me(e)}
-function oea(a,b,c,d,e,g,h){var k=NC(b,c);k instanceof uv&&Dn("Program reached and unexpected state.");if(k instanceof gu&&(k=k.ed,k instanceof Wl)){h=!1;b=null;k=nda(a,k.w,d.pr(),c,e);if(k instanceof me){h=!0;b=k;var l=b.ia;if(l instanceof Aw)return l.Zg.b()||$n(),e=l.Gf,d=g.C(),Uw(a),g=t().f,ty(a,e,Mw(new Nw,a,d,"type selection",g,!0),c)}if(h&&(c=b.ia,c instanceof Dw))return c.ik.b()||$n(),c.Gl;if(h)return g=b.ia,c=new mf(new nf(J(new L,["Illegal selection of "," member in type position"]))),g=
-[pf(qf(),g.zd().td)],Xv(a,sf(c,J(new L,g)),d.C(),e);if(k instanceof te)return LX(a,k.ca,e);throw new x(k);}d=new mf(new nf(J(new L,["Illegal prefix of type selection: ",""])));c=[nO(qf(),UC(b,c))];return Xv(a,sf(d,J(new L,c)),h.C(),e)}
-var pea=function F6(a,b,c,d,e,g,h,k,l,m,n){return kx(a,new U(()=>c.fa+". type "+nO(qf(),b).mr()),new U(()=>{var u=!1,w=null,y=!1,B=null;if(Jl()===b){var D=b.C(),C=t().f;return new gA(a,!1,Mw(new Nw,a,D,"top type",C,!0))}if(Il()===b){var F=b.C(),I=t().f;return new gA(a,!0,Mw(new Nw,a,F,"bottom type",I,!0))}if(b instanceof dP){u=!0;w=b;var K=w.pi,N=w.qi;if(Il()===K&&Jl()===N){var P=b.C(),T=t().f,aa=Mw(new Nw,a,P,"type wildcard",T,!0);return new wB(a,new gA(a,!0,aa),new gA(a,!1,aa),aa)}}if(u){var Y=
-w.qi,S=F6(a,w.pi,c,d,e,g,h,k,l,m,n),Z=F6(a,Y,c,d,e,g,h,k,l,m,n),ka=b.C(),X=t().f,sa=Mw(new Nw,a,ka,"type bounds",X,!0),Ia=dw(a).Cb;ew(a,S,Z,e,sa,c,Ia);return new wB(a,S,Z,sa)}if(b instanceof aP){var Za=b.hu,Ga=Mx(Du(),Za,new z(Va=>{var wb=Va.Pf,db=new z(Jc=>F6(a,Jc,c,d,e,g,h,k,l,m,n));return new ww(a,wb.b()?R():new M(db.n(wb.o())),F6(a,Va.Jg,c,d,e,g,h,k,l,m,n),Mw(new Nw,a,Va.C(),"tuple field",(Uw(a),t().f),(Uw(a),!1)))})),xa=b.C(),Ra=t().f;return new Ru(a,Ga,Mw(new Nw,a,xa,"tuple type",Ra,!0))}if(b instanceof
-iP){var Ja=ht(b.cx,new z(Va=>{if(Va instanceof te){Va=F6(a,Va.ca,c,d,e,g,h,k,l,m,n);var wb=Va.qa(),db=t().f,Jc=t().f,Vc=O().c,Ta=O().c;wb=new Ow(a,c.fa,Vc,Ta,db,Jc,!1,wb);db=Va.qa();wb=new fv(a,new ww(wb.p,R(),wb,db),Va.qa());db=Va.qa();Jc=dw(a).Cb;ew(a,Va,wb,e,db,c,Jc);t();return new te(Va)}if(Va instanceof me)return Va=Va.ia,t(),wb=Va.Pf,db=new z(kd=>F6(a,kd,c,d,e,g,h,k,l,m,n)),Va=new ww(a,wb.b()?R():new M(db.n(wb.o())),F6(a,Va.Jg,c,d,e,g,h,k,l,m,n),Mw(new Nw,a,Va.C(),"splice field",(Uw(a),t().f),
-(Uw(a),!1))),new me(Va);throw new x(Va);})),La=b.C(),pb=t().f;return new jv(a,Ja,Mw(new Nw,a,La,"splice type",pb,!0))}if(b instanceof ZO){var Fb=b.Sr,Gb=b.Tr;if(g)var Hb=new z(Va=>{var wb=F6(a,Fb,c,d,e,g,h,k,l,m,n),db=F6(a,Gb,c,d,e,g,h,k,l,m,n);return ju(wb,db,Va,!1)});else{var tb=F6(a,Fb,c,d,e,g,h,k,l,m,n),kb=F6(a,Gb,c,d,e,g,h,k,l,m,n);Hb=new z(Va=>new nA(a,!1,tb,kb,Va))}var gb=b.C(),Vb=t().f;return Hb.n(Mw(new Nw,a,gb,"intersection type",Vb,!0))}if(b instanceof $O){var bb=b.Cs,nb=b.Ds;if(g)var Tb=
-new z(Va=>{var wb=F6(a,bb,c,d,e,g,h,k,l,m,n),db=F6(a,nb,c,d,e,g,h,k,l,m,n);return zu(wb,db,Va,!1)});else{var ub=F6(a,bb,c,d,e,g,h,k,l,m,n),Ub=F6(a,nb,c,d,e,g,h,k,l,m,n);Tb=new z(Va=>new nA(a,!0,ub,Ub,Va))}var $a=b.C(),cb=t().f;return Tb.n(Mw(new Nw,a,$a,"union type",cb,!0))}if(b instanceof bP){var Na=F6(a,b.Gw,c,d,e,g,h,k,l,m,n),Ca=b.C(),Ba=t().f;return new oA(a,Na,Mw(new Nw,a,Ca,"type negation",Ba,!0))}if(b instanceof En){var Oa=b.rs,wa=b.C(),ea=t().f,la=Mw(new Nw,a,wa,"record type",ea,!0);GT(Oa,
-new z(Va=>Va.i().w),new z(Va=>Va.i())).ya(new z(Va=>{if(null!==Va&&(Va=new M(Va),!Va.b())){var wb=Va.k.i();Va=Va.k.j();if(0<Va.$a(1)){var db=new mf(new nf(J(new L,["Multiple declarations of field name "," in ",""])));wb=[pf(qf(),wb),pf(qf(),la.th)];wb=sf(db,J(new L,wb));db=b.C();wb=G(new H,wb,db);Va=ht(Va,new z(Jc=>{var Vc=sf(new mf(new nf(J(new L,["Declared at"]))),v());Jc=Jc.C();return G(new H,Vc,Jc)}));return yx(a,new A(wb,Va),e)}}}));return uA(Pu(a),ht(Oa,new z(Va=>{IA(Ne(),Va.i().w)&&Xv(a,sf(new mf(new nf(J(new L,
-["Field identifiers must start with a small letter"]))),v()),Va.i().C(),e);var wb=Va.i(),db=Va.j().Pf,Jc=new z(ld=>F6(a,ld,c,d,e,g,h,k,l,m,n));db=db.b()?R():new M(Jc.n(db.o()));Jc=F6(a,Va.j().Jg,c,d,e,g,h,k,l,m,n);var Vc=Va.i(),Ta=new Wl(""),kd=Va.j().C();Vc=new mm(Vc,aq(Ta,kd));Vc=jq(Vc);Va=new ww(a,db,Jc,Mw(new Nw,a,Vc,(Va.j().Pf.b()?"":"mutable ")+"record field",(Uw(a),t().f),(Uw(a),!1)));return G(new H,wb,Va)})),la)}if(b instanceof nt){var Ka=b.Kr,Ua=F6(a,b.Jr,c,d,e,g,h,k,l,m,n),ya=F6(a,Ka,c,
-d,e,g,h,k,l,m,n),ib=b.C(),Lb=t().f;return new yu(a,Ua,ya,Mw(new Nw,a,ib,"function type",Lb,!0))}if(b instanceof eP){var ec=b.qx,Mb=F6(a,b.px,c,d,e,g,h,k,l,m,n),Jb=ht(ec.rs,new z(Va=>{if(null!==Va){var wb=Va.i(),db=Va.j();Va=db.Pf;var Jc=new z(Ta=>F6(a,Ta,c,d,e,g,h,k,l,m,n));Va=Va.b()?R():new M(Jc.n(Va.o()));Jc=F6(a,db.Jg,c,d,e,g,h,k,l,m,n);var Vc=new Wl("");db=db.C();db=new mm(wb,aq(Vc,db));db=jq(db);Vc=t().f;Va=new ww(a,Va,Jc,Mw(new Nw,a,db,"extension field",Vc,!0));return G(new H,wb,Va)}throw new x(Va);
-})),Kb=ec.C(),eb=t().f,Wb=new dv(a,Jb,Mw(new Nw,a,Kb,"extension record",eb,!0)),mc=b.C(),ua=t().f;return new ry(a,Mb,Wb,Mw(new Nw,a,mc,"extension type",ua,!0))}if(b instanceof fP){var Pa=b.Xr,xb=a.Qc?Xp(Pa):Up(Pa),Yb=b.C(),zb=t().f;return new gu(a,Pa,xb,Mw(new Nw,a,Yb,"literal type",zb,!0))}if(b instanceof sp&&(y=!0,B=b,"this"===B.X)){var Sb=!1,Ma=null,Ea=c.Xa.Y("this");Ea instanceof M&&(Sb=!0,Ma=Ea,Ma.k instanceof MP&&Dn("Program reached and unexpected state."));if(Sb){var ab=Ma.k;if(ab instanceof
-Sw){var Db=ab.zs;if(null!==Db)return Db}}if(t().f===Ea){var mb=sf(new mf(new nf(J(new L,["undeclared `this`"]))),v()),vb=b.C(),Ya=G(new H,mb,vb),Wa=O().c;return yx(a,new A(Ya,Wa),e)}throw new x(Ea);}if(b instanceof jP){var rb=b.Qz;return F6(a,new sp(BF(Ne(),rb)),c,d,e,g,h,k,l,m,n)}if(y){var pa=B.X,Fa=b.C(),Ib=t().f,qb=Mw(new Nw,a,Fa,"type reference",Ib,!0);return h.yd(pa,new U((Va=>()=>{var wb=E6(a,Fa,pa,m,n,e);if(wb instanceof me){var db=wb.ia;if(null!==db){db=db.Lc();if(hf(new E(db),0))return new uv(a,
-Va,O().c,qb);var Jc=c.fb.Y(pa);if(Jc instanceof M){var Vc=!1,Ta=null;Jc=Jc.k.Kb;if(Jc instanceof io&&(Vc=!0,Ta=Jc,Jc=Ta.nb,pp()===Jc||mp()===Jc))return wb=c.fb.n(pa).Kb,db=t().f,ty(a,wb,Mw(new Nw,a,Fa,"class tag",db,!0),c);if(Vc&&(Jc=Ta.nb,tp()===Jc))return wb=c.fb.n(pa).Kb,db=t().f,ux(a,wb,Mw(new Nw,a,Fa,"class tag",db,!0),c);if(Vc&&(Vc=Ta.nb,np()===Vc))return wb=O().eR,new uv(a,Va,vda(wb,db,new U(()=>{var kd=V(a),ld=t().f,qe=t().f,Wd=O().c,Rd=O().c;return new Ow(a,c.fa,Wd,Rd,ld,qe,!1,kd)})),qb);
-Dn("Program reached and unexpected state.")}else return wb=new mf(new nf(J(new L,["Type "," takes parameters"]))),db=[pf(qf(),pa)],Xv(a,sf(wb,J(new L,db)),Fa,e)}}if(wb instanceof te){wb=wb.ca;""===pa?db=!0:(db=cu(Q(),pa),db=!vD($q(),db));if(!db&&(db=G(new H,E6(a,Fa,hu(Q(),pa),m,n,e),c.vb.Y(hu(Q(),pa))),Vc=db.z,db=db.x,Vc instanceof me&&(Vc=Vc.ia,null!==Vc&&(Vc=Vc.i(),db instanceof M)))){wb=db.k;if(pp()===Vc)return db=t().f,LC(a,wb,Mw(new Nw,a,Fa,"class tag",db,!0),c);if(tp()===Vc)return db=t().f,
-mD(a,wb,Mw(new Nw,a,Fa,"trait tag",db,!0));if(np()===Vc)return wb=new mf(new nf(J(new L,["Type alias "," cannot be used as a type tag"]))),db=[pf(qf(),hu(Q(),pa))],Xv(a,sf(wb,J(new L,db)),Fa,e);if(mp()===Vc)return wb=new mf(new nf(J(new L,["Module "," cannot be used as a type tag"]))),db=[pf(qf(),hu(Q(),pa))],Xv(a,sf(wb,J(new L,db)),Fa,e);if(Qo()===Vc)return wb=new mf(new nf(J(new L,["Mixin "," cannot be used as a type tag"]))),db=[pf(qf(),hu(Q(),pa))],Xv(a,sf(wb,J(new L,db)),Fa,e);throw new x(Vc);
-}return Zr(wb)}throw new x(wb);})(B)))}if(b instanceof ns){var Nb=xP(b.Go),fc=new z(Va=>h.Y(Va)),Ac=Nb.b()?R():fc.n(Nb.o()),tc=new U(()=>{var Va=d.yd(b,new U(()=>k.Ai(b,new U(()=>{var Jc=V(a),Vc=t().f,Ta=bT(b),kd=new z(qe=>Sba(Q(),qe,new z(Wd=>sr(new E(hd(Eb(Wd))),hd(39)))));Ta=Ta.b()||kd.n(Ta.o())?Ta:R();kd=O().c;var ld=O().c;return new Ow(a,l,kd,ld,Vc,Ta,!1,Jc)})))),wb=b.C(),db=t().f;wb=Mw(new Nw,a,wb,"type variable",db,!0);return Vw(Va.p,Va,wb)});return Ac.b()?Zr(tc):Ac.o()}if(b instanceof gP){var vc=
-b.dw,sc=b.ew,uc=b.C(),lc=t().f,Wc=Mw(new Nw,a,uc,"applied type reference",lc,!0),Cc=E6(a,b.C(),vc.X,m,n,e);if(Cc instanceof me){var Dc=Cc.ia;if(null!==Dc){var Ec=Dc.Lc(),Ic=sc.K();if(hf(new E(Ic),Ec))var Xc=ht(sc,new z(Va=>F6(a,Va,c,d,e,g,h,k,l,m,n)));else{var Sc=new mf(new nf(J(new L,["Wrong number of type arguments \u2013 expected ",", found ",""]))),oc=pf(qf(),""+Ec);qf();var qc=sc.K(),Tc=[oc,pf(0,""+qc)];Xv(a,sf(Sc,J(new L,Tc)),b.C(),e);var Nc=sc.m(),Pc=new eg(Nc,new z(Va=>F6(a,Va,c,d,e,g,h,k,
-l,m,n))),Oc=Cu(Pc,new U(()=>{O();return new n0(new U(()=>{var Va=V(a),wb=t().f,db=t().f,Jc=O().c,Vc=O().c;return new Ow(a,c.fa,Jc,Vc,wb,db,!1,Va)}))})).qn(Ec);je();Xc=le(v(),Oc)}return new uv(a,vc,Xc,Wc)}}if(Cc instanceof te)return Zr(Cc.ca);throw new x(Cc);}if(b instanceof kP){var $c=b.Yw,Lc=b.Zw,Zb=F6(a,$c,c,d,e,g,h,k,l,m,n);return oea(a,Zb,c,Lc,e,b,$c)}if(b instanceof cP){var ed=b.Bz,$b=F6(a,b.Ww,c,d,e,g,h,k,l,m,n),Fc=mu(),Yc=ap().wa,nc=new ou(Fc,Yc),Ob=Rz(Mu(),ed,nc),cc=b.C(),Gc=t().f;return new gv(a,
-$b,Ob,Mw(new Nw,a,cc,"field removal type",Gc,!0))}if(b instanceof hP){var Bc=b.iw,qd=b.jw,Gd=b.kw;if(Bc instanceof y_)var cd=Bc;else Dn("Program reached and unexpected state.");for(var rd=F6(a,cd,c,d,e,g,h,k,l,m,n),Id=new z(Va=>{a:{if(null!==Va){var wb=Va.i(),db=Va.j();if(null!==db){var Jc=db.pi;db=db.qi;Va=F6(a,Jc,c,d,e,g,h,k,l,m,n);var Vc=d.n(wb);Jc=Mw(new Nw,a,Jc.C(),"lower bound specifiation",(Uw(a),t().f),(Uw(a),!1));var Ta=dw(a).Cb;ew(a,Va,Vc,e,Jc,c,Ta);wb=d.n(wb);Va=F6(a,db,c,d,e,g,h,k,l,m,
-n);db=Mw(new Nw,a,db.C(),"upper bound specifiation",(Uw(a),t().f),(Uw(a),!1));Vc=dw(a).Cb;ew(a,wb,Va,e,db,c,Vc);break a}}throw new x(Va);}}),Ha=qd;!Ha.b();)Id.n(Ha.e()),Ha=Ha.g();for(var jc=new z(Va=>{if(null!==Va){var wb=Va.pi,db=Va.qi;Va=F6(a,wb,c,d,e,g,h,k,l,m,n);var Jc=F6(a,db,c,d,e,g,h,k,l,m,n);wb=Mw(new Nw,a,Dba(dF(),wb.C(),db.C(),new Um((Vc,Ta)=>Rr(Vc,Ta))),"constraint specifiation",(Uw(a),t().f),(Uw(a),!1));db=dw(a).Cb;ew(a,Va,Jc,e,wb,c,db)}else throw new x(Va);}),Rb=Gd;!Rb.b();)jc.n(Rb.e()),
-Rb=Rb.g();return rd}if(b instanceof mt){var Uc=b.qs,Rc=b.ps,Cd=Mw(new Nw,a,Rc.C(),"polymorphic type",(Uw(a),t().f),(Uw(a),!1)),od=new z(Va=>{var wb=new ov(d);ht(Uc,new z(db=>{if(db instanceof te)Dn("Program reached and unexpected state.");else{if(db instanceof me){db=db.ia;var Jc=db.C(),Vc=bT(db);Jc=Mw(new Nw,a,Jc,"quantified type variable",Vc,!0);Vc=t().f;var Ta=bT(db),kd=O().c,ld=O().c;Jc=new Ow(a,Va.fa,kd,ld,Vc,Ta,!1,Jc);wb.Lb=wb.Lb.mm(G(new H,db,Jc));return Jc}throw new x(db);}}));return F6(a,
-Rc,Va,wb.Lb,e,g,h,k,l,m,n)});dw(c.V);return ox(c,od,e,Cd)}throw new x(b);}),new z(u=>"\x3d\x3e "+u))};function G6(a,b,c,d,e,g,h){var k=id();try{var l=new zQ(0),m=new z(r=>{if(r instanceof fg){if(hf(new E(l.Zd),0)){var u=Wx(a),w=new z(()=>{}),y=V(a),B=dw(a).Cb;ew(a,u,d,w,y,e,B);g.n(r)}else if(3<=l.Zd)throw fq(new gq,k,d);l.Zd=1+l.Zd|0}else g.n(r)}),n=dw(a).Cb;ew(a,b,c,m,h,e,n);return d}catch(r){if(r instanceof gq){b=r;if(b.Hg===k)return b.wj();throw b;}throw r;}}
-function H6(a,b,c,d){if(!b.aJ().b()){var e=new mf(new nf(J(new L,["Class "," is abstract and cannot be instantiated"])));b=[pf(qf(),b.sf.w)];Xv(a,sf(e,J(new L,b)),c.C(),d)}}
-function I6(a,b,c,d,e,g){if(a.D){var h=""+Hs(Q(),"| ",a.q)+G(new H,b,c.fb.Y(b));Af(Bf(),h+"\n")}c=c.fb.Y(b);if(t().f===c)return g=new mf(new nf(J(new L,["Type `","` cannot be used in `new` expression"]))),b=[pf(qf(),b)],Xv(a,sf(g,J(new L,b)),d.C(),e);if(c instanceof M){b=c.k;if(null!==b&&!et(new E(b.lu),pp()))return d=new mf(new nf(J(new L,[""," "," cannot be used in `new` expression"]))),qf(),Q(),b=[pf(0,hu(0,b.lu.td)),pf(qf(),b.bO)],Xv(a,sf(d,J(new L,b)),g.Ia,e);if(null!==b)return h=b.Kb,h.aJ().b()||
-(c=new mf(new nf(J(new L,["Class "," is abstract and cannot be instantiated"]))),h=[pf(qf(),h.sf.w)],Xv(a,sf(c,J(new L,h)),d.C(),e)),Ux(b,!0,g.Ia,e);throw new x(b);}throw new x(c);}
-var qea=function J6(a,b,c){b=CB(b);if(b instanceof px){var e=b.ve;if(null!==e&&(e=Vu(Wu(a),e,c),!e.b()&&(e=e.k,e instanceof yu)))return O(),a=J(new L,[e]),le(v(),a)}if(b instanceof yu)return O(),a=J(new L,[b]),le(v(),a);if(b instanceof Ow){var g=ny(b);if(g===v())a=v();else{b=g.e();e=b=new A(J6(a,b,c),v());for(g=g.g();g!==v();){var h=g.e();h=new A(J6(a,h,c),v());e=e.r=h;g=g.g()}a=b}c=ap().wa;return EX(a,c)}return b instanceof nA&&(g=b.cc,e=b.dc,hf(new E(b.nc),!1))?(b=J6(a,g,c),a=J6(a,e,c),mn(b,a)):
+function EU(a,b,c,d){var e=kI(HH(),d,0),g=lI(HH(),e);if(0!==(a.db&g))e=oI(HH(),a.db,e,g),c=a.ed(e),ml(nl(),c,b)&&(b=a.db,2===nI(UH(),b)?(b=a.Pb,b=0===nI(UH(),b)):b=!1,b?(g^=a.db,0===e?(d=new zc([a.ed(1)]),e=new Xc(new Int32Array([a.Ud.a[1]])),b=$G(bH(),a.Jb(1)),a.Uc=d,a.Ud=e,a.Ve=b):(d=new zc([a.ed(0)]),e=new Xc(new Int32Array([a.Ud.a[0]])),b=$G(bH(),a.Jb(0)),a.Uc=d,a.Ud=e,a.Ve=b),a.db=g,a.Pb=0,a.Fb=1):(b=a.pi(g),c=a.Uc,e=new zc(-1+c.a.length|0),c.wa(0,e,0,b),c.wa(1+b|0,e,b,-1+(c.a.length-b|0)|0),
+b=gI(a.Ud,b),a.db^=g,a.Uc=e,a.Ud=b,a.Fb=-1+a.Fb|0,a.Ve=a.Ve-d|0));else if(0!==(a.Pb&g)&&(e=oI(HH(),a.Pb,e,g),e=a.Nh(e),d=e.eG(b,c,d,5),d!==e))if(1===d.Fb)if(b=a.db,0===nI(UH(),b)?(b=a.Pb,b=1===nI(UH(),b)):b=!1,b)a.db=d.db,a.Pb=d.Pb,a.Uc=d.Uc,a.Ud=d.Ud,a.Fb=d.Fb,a.Ve=d.Ve;else{b=(-1+a.Uc.a.length|0)-a.hm(g)|0;c=a.pi(g);var h=d.ed(0);a.Uc.wa(c,a.Uc,1+c|0,b-c|0);a.Uc.a[c]=h;b=hI(a.Ud,c,d.Jb(0));a.db|=g;a.Pb^=g;a.Ud=b;a.Fb=1+(a.Fb-e.ka()|0)|0;a.Ve=(a.Ve-e.uc()|0)+d.uc()|0}else a.Uc.a[(-1+a.Uc.a.length|
+0)-a.hm(g)|0]=d,a.Fb=-1+a.Fb|0,a.Ve=(a.Ve-e.uc()|0)+d.Ve|0}function zU(a,b,c,d,e,g,h,k){if(32<=k)return GK(),new FU(c,d,pU(0,J(new K,[b,e])));var l=kI(HH(),d,k),m=kI(HH(),h,k);if(l!==m)return a=lI(HH(),l)|lI(HH(),m),d=d+h|0,l<m?new CJ(a,0,new zc([b,e]),new Xc(new Int32Array([c,g])),2,d):new CJ(a,0,new zc([e,b]),new Xc(new Int32Array([g,c])),2,d);l=lI(HH(),l);b=zU(a,b,c,d,e,g,h,5+k|0);return new CJ(0,l,new zc([b]),kG().KB,b.ka(),b.uc())}f.jy=function(){return 0!==this.db};
+f.uy=function(){var a=this.db;return nI(UH(),a)};f.nB=function(){return 0!==this.Pb};f.HB=function(){var a=this.Pb;return nI(UH(),a)};f.pi=function(a){a=this.db&(-1+a|0);return nI(UH(),a)};f.hm=function(a){a=this.Pb&(-1+a|0);return nI(UH(),a)};function AU(a,b,c,d){b=(-1+a.Uc.a.length|0)-a.hm(b)|0;var e=a.Uc,g=new zc(e.a.length);e.wa(0,g,0,e.a.length);g.a[b]=d;return new CJ(a.db,a.Pb,g,a.Ud,(a.Fb-c.ka()|0)+d.ka()|0,(a.Ve-c.uc()|0)+d.uc()|0)}
+function CU(a,b,c,d){var e=a.pi(b),g=(-1+a.Uc.a.length|0)-a.hm(b)|0;a.Uc.wa(1+e|0,a.Uc,e,g-e|0);a.Uc.a[g]=d;a.db^=b;a.Pb|=b;a.Ud=gI(a.Ud,e);a.Fb=(-1+a.Fb|0)+d.ka()|0;a.Ve=(a.Ve-c|0)+d.uc()|0}f.Ca=function(a){var b=this.db;b=nI(UH(),b);for(var c=0;c<b;)a.n(this.ed(c)),c=1+c|0;b=this.Pb;b=nI(UH(),b);for(c=0;c<b;)this.Nh(c).Ca(a),c=1+c|0};
+function GU(a,b,c){if(0===a.Fb)return a;if(1===a.Fb)return!!b.n(a.ed(0))!==c?a:DJ().mw;if(0===a.Pb){for(var d=a.db,e=0===d?32:31-Math.clz32(d&(-d|0))|0,g=32-Math.clz32(a.db)|0,h=d=0,k=0;e<g;){var l=lI(HH(),e);if(0!==(l&a.db)){var m=a.ed(k);!!b.n(m)!==c&&(d|=l,h=h+$G(bH(),a.Jb(k))|0);k=1+k|0}e=1+e|0}if(0===d)return DJ().mw;if(d===a.db)return a;b=d;b=nI(UH(),b);c=new zc(b);g=new Xc(b);k=32-Math.clz32(d)|0;e=d;e=0===e?32:31-Math.clz32(e&(-e|0))|0;for(l=0;e<k;)m=lI(HH(),e),0!==(m&d)&&(m=mI(HH(),a.db,
+m),c.a[l]=a.Uc.a[m],g.a[l]=a.Ud.a[m],l=1+l|0),e=1+e|0;return new CJ(d,0,c,g,b,h)}h=a.db|a.Pb;d=0===h?32:31-Math.clz32(h&(-h|0))|0;h=32-Math.clz32(h)|0;k=g=0;e=null;m=l=0;for(var n=null,r=0,v=0,x=0,A=0,B=0,C=0,D=d;D<h;){var F=lI(HH(),D);if(0!==(F&a.db)){var I=a.ed(B);!!b.n(I)!==c&&(r|=F,g|=F,x=1+x|0,A=A+$G(bH(),a.Jb(B))|0);B=1+B|0}else if(0!==(F&a.Pb)){I=a.Nh(C);var M=I.EJ(b,c);x=x+M.ka()|0;A=A+M.uc()|0;1<M.ka()?(v|=F,I===M?l|=F:(m|=F,null===n&&(n=new tU(16)),uU(n,M))):1===M.ka()&&(r|=F,k|=F,null===
+e&&(e=new tU(16)),uU(e,M));C=1+C|0}D=1+D|0}return xU(a,x,r,v,d,g,l,k,e,m,n,A)}
+function HU(a,b,c){if(b instanceof CJ){if(0===a.Fb)return a;if(1===a.Fb){var d=a.Jb(0);return b.yt(a.ed(0),d,$G(bH(),d),c)?DJ().mw:a}var e=a.db|a.Pb;d=0===e?32:31-Math.clz32(e&(-e|0))|0;e=32-Math.clz32(e)|0;for(var g=0,h=0,k=null,l=0,m=0,n=null,r=0,v=0,x=0,A=0,B=0,C=0,D=d;D<e;){var F=lI(HH(),D);if(0!==(F&a.db)){var I=a.ed(B),M=a.Jb(B),N=$G(bH(),M);b.yt(I,M,N,c)||(r|=F,g|=F,x=1+x|0,A=A+N|0);B=1+B|0}else if(0!==(F&a.Pb)){I=a.Nh(C);if(0!==(F&b.db)){N=mI(HH(),b.db,F);M=b.ed(N);N=b.Jb(N);var P=$G(bH(),
+N);M=I.eG(M,N,P,5+c|0)}else M=0!==(F&b.Pb)?I.mQ(b.Nh(mI(HH(),b.Pb,F)),5+c|0):I;x=x+M.ka()|0;A=A+M.uc()|0;1<M.ka()?(v|=F,I===M?l|=F:(m|=F,null===n&&(n=new tU(16)),uU(n,M))):1===M.ka()&&(r|=F,h|=F,null===k&&(k=new tU(16)),uU(k,M));C=1+C|0}D=1+D|0}return xU(a,x,r,v,d,g,l,h,k,m,n,A)}if(b instanceof FU)throw iL("BitmapIndexedSetNode diff HashCollisionSetNode");throw new w(b);}
+f.i=function(a){if(a instanceof CJ){if(this===a)return!0;if(this.Ve===a.Ve&&this.Pb===a.Pb&&this.db===a.db&&this.Fb===a.Fb){var b=this.Ud,c=a.Ud;b=qj(Pj(),b,c)}else b=!1;if(b){b=this.Uc;a=a.Uc;c=this.Uc.a.length;if(b===a)return!0;for(var d=!0,e=0;d&&e<c;)d=ml(nl(),b.a[e],a.a[e]),e=1+e|0;return d}}return!1};f.B=function(){throw nv("Trie nodes do not support hashing.");};
+function IU(a){var b=a.Uc.ia(),c=b.a.length,d=a.db;for(d=nI(UH(),d);d<c;)b.a[d]=b.a[d].lQ(),d=1+d|0;return new CJ(a.db,a.Pb,b,a.Ud.ia(),a.Fb,a.Ve)}
+function JU(a,b,c){if(b instanceof CJ){if(0===a.Fb)return b;if(0===b.Fb||b===a)return a;if(1===b.Fb){var d=b.Jb(0);return yU(a,b.ed(0),d,$G(bH(),d),c)}d=!1;var e=a.db|b.db|a.Pb|b.Pb,g=lI(HH(),0===e?32:31-Math.clz32(e&(-e|0))|0);e=lI(HH(),31-Math.clz32(e)|0);for(var h=0,k=0,l=0,m=0,n=0,r=0,v=0,x=0,A=0,B=0,C=g,D=0,F=0,I=!1;!I;)0!==(C&a.db)?(0!==(C&b.db)?(a.Jb(D)===b.Jb(F)&&ml(nl(),a.ed(D),b.ed(F))?A|=C:(x|=C,B|=lI(HH(),kI(HH(),$G(bH(),a.Jb(D)),c))),F=1+F|0):0!==(C&b.Pb)?k|=C:m|=C,D=1+D|0):0!==(C&a.Pb)?
+0!==(C&b.db)?(l|=C,F=1+F|0):0!==(C&b.Pb)?h|=C:r|=C:0!==(C&b.db)?(n|=C,F=1+F|0):0!==(C&b.Pb)&&(v|=C),C===e?I=!0:C<<=1;C=m|n|A;B|=h|k|l|r|v;if(C===(m|A)&&B===r)return a;I=nI(UH(),C);D=I+nI(UH(),B)|0;F=new zc(D);I=new Xc(I);var M=0,N=0,P=0,T=0,Y=0,Z=0;c=5+c|0;for(var S=0,ea=0,ia=!1;!ia;){if(0!==(g&h)){var X=a.Nh(Y),sa=X.jQ(b.Nh(Z),c);X!==sa&&(d=!0);F.a[-1+(D-ea|0)|0]=sa;ea=1+ea|0;Z=1+Z|0;Y=1+Y|0;M=M+sa.ka()|0;N=N+sa.uc()|0}else if(0!==(g&k)){d=!0;X=b.Nh(Z);sa=a.ed(P);var Ja=a.Jb(P),Xa=$G(bH(),Ja);X=
+X.JC(sa,Ja,Xa,c);F.a[-1+(D-ea|0)|0]=X;ea=1+ea|0;Z=1+Z|0;P=1+P|0;M=M+X.ka()|0;N=N+X.uc()|0}else 0!==(g&l)?(sa=b.Jb(T),X=a.Nh(Y),sa=X.JC(b.ed(T),b.Jb(T),$G(bH(),sa),c),sa!==X&&(d=!0),F.a[-1+(D-ea|0)|0]=sa,ea=1+ea|0,Y=1+Y|0,T=1+T|0,M=M+sa.ka()|0,N=N+sa.uc()|0):0!==(g&m)?(X=a.Ud.a[P],F.a[S]=a.ed(P),I.a[S]=X,S=1+S|0,P=1+P|0,M=1+M|0,N=N+$G(bH(),X)|0):0!==(g&n)?(d=!0,X=b.Ud.a[T],F.a[S]=b.ed(T),I.a[S]=X,S=1+S|0,T=1+T|0,M=1+M|0,N=N+$G(bH(),X)|0):0!==(g&r)?(X=a.Nh(Y),F.a[-1+(D-ea|0)|0]=X,ea=1+ea|0,Y=1+Y|0,
+M=M+X.ka()|0,N=N+X.uc()|0):0!==(g&v)?(d=!0,X=b.Nh(Z),F.a[-1+(D-ea|0)|0]=X,ea=1+ea|0,Z=1+Z|0,M=M+X.ka()|0,N=N+X.uc()|0):0!==(g&x)?(d=!0,X=a.Jb(P),sa=b.Jb(T),X=zU(b,a.ed(P),X,$G(bH(),X),b.ed(T),sa,$G(bH(),sa),c),F.a[-1+(D-ea|0)|0]=X,ea=1+ea|0,P=1+P|0,T=1+T|0,M=M+X.ka()|0,N=N+X.uc()|0):0!==(g&A)&&(X=b.Ud.a[T],F.a[S]=b.ed(T),I.a[S]=X,S=1+S|0,T=1+T|0,M=1+M|0,N=N+$G(bH(),X)|0,P=1+P|0);g===e?ia=!0:g<<=1}return d?new CJ(C,B,F,I,M,N):a}throw nv("Cannot concatenate a HashCollisionSetNode with a BitmapIndexedSetNode");
+}f.FJ=function(a){var b=this.db;b=nI(UH(),b);for(var c=0;c<b;)a.ba(this.ed(c),this.Jb(c)),c=1+c|0;b=this.Pb;b=nI(UH(),b);for(c=0;c<b;)this.Nh(c).FJ(a),c=1+c|0};f.jQ=function(a,b){return JU(this,a,b)};f.lQ=function(){return IU(this)};f.mQ=function(a,b){return HU(this,a,b)};f.EJ=function(a,b){return GU(this,a,b)};f.eG=function(a,b,c,d){return DU(this,a,b,c,d)};f.JC=function(a,b,c,d){return yU(this,a,b,c,d)};f.mB=function(a){return this.Nh(a)};
+f.$classData=q({S6:0},!1,"scala.collection.immutable.BitmapIndexedSetNode",{S6:1,v8:1,lC:1,g:1});function oU(a,b,c){this.Py=a;this.Eo=b;this.of=c;At(tp(),2<=this.of.K())}oU.prototype=new XQ;oU.prototype.constructor=oU;function KU(a,b){a=a.of.m();for(var c=0;a.s();){if(ml(nl(),a.t().h(),b))return c;c=1+c|0}return-1}f=oU.prototype;f.ka=function(){return this.of.K()};f.BJ=function(a,b,c,d){a=this.KF(a,b,c,d);if(a.b())throw LU();return a.o()};
+f.KF=function(a,b,c){return this.Eo===c?(a=KU(this,a),0<=a?new L(this.of.va(a).j()):R()):R()};f.KJ=function(a,b,c,d,e){return this.Eo===c?(a=KU(this,a),-1===a?Es(e):this.of.va(a).j()):Es(e)};f.DF=function(a,b,c){return this.Eo===c&&0<=KU(this,a)};f.KC=function(a,b,c,d,e,g){e=KU(this,a);return 0<=e?g?Object.is(this.of.va(e).j(),b)?this:new oU(c,d,this.of.$r(e,G(new H,a,b))):this:new oU(c,d,this.of.hn(G(new H,a,b)))};
+f.hR=function(a,b,c,d){if(this.DF(a,b,c,d)){d=MU(this.of,new y(g=>ml(nl(),g.h(),a)),!0);if(1===d.K()){var e=d.va(0);if(null===e)throw new w(e);d=e.h();e=e.j();return new aI(lI(HH(),kI(HH(),c,0)),0,new zc([d,e]),new Xc(new Int32Array([b])),1,c)}return new oU(b,c,d)}return this};f.nB=function(){return!1};f.HB=function(){return 0};f.qh=function(){throw aL(new bL,"No sub-nodes present in hash-collision leaf node.");};f.jy=function(){return!0};f.uy=function(){return this.of.K()};f.Ef=function(a){return this.of.va(a).h()};
+f.Tf=function(a){return this.of.va(a).j()};f.rv=function(a){return this.of.va(a)};f.Jb=function(){return this.Py};f.Ca=function(a){this.of.Ca(a)};f.og=function(a){this.of.Ca(new y(b=>{if(null!==b)return a.ba(b.h(),b.j());throw new w(b);}))};f.GJ=function(a){for(var b=this.of.m();b.s();){var c=b.t();(0,a.aM)(c.h(),c.j(),this.Py)}};
+f.i=function(a){if(a instanceof oU){if(this===a)return!0;if(this.Eo===a.Eo&&this.of.K()===a.of.K()){for(var b=this.of.m();b.s();){var c=b.t();if(null===c)throw new w(c);var d=c.j();c=KU(a,c.h());if(0>c||!ml(nl(),d,a.of.va(c).j()))return!1}return!0}}return!1};
+f.qQ=function(a,b){a=MU(this.of,a,b);b=a.K();if(0===b)return bI().Ty;if(1===b){b=a.e();if(null===b)throw new w(b);a=b.h();b=b.j();return new aI(lI(HH(),kI(HH(),this.Eo,0)),0,new zc([a,b]),new Xc(new Int32Array([this.Py])),1,this.Eo)}return b===this.of.K()?this:new oU(this.Py,this.Eo,a)};f.B=function(){throw nv("Trie nodes do not support hashing.");};f.uc=function(){return Math.imul(this.of.K(),this.Eo)};f.kQ=function(){return new oU(this.Py,this.Eo,this.of)};
+f.iQ=function(a){if(a instanceof oU)if(a===this)a=this;else{for(var b=null,c=this.of.m();c.s();){var d=c.t();0>KU(a,d.h())&&(null===b&&(b=new NU,OU(b,a.of)),PU(b,d))}a=null===b?a:new oU(this.Py,this.Eo,b.im())}else{if(a instanceof aI)throw nv("Cannot concatenate a HashCollisionMapNode with a BitmapIndexedMapNode");throw new w(a);}return a};f.mB=function(a){return this.qh(a)};f.$classData=q({T6:0},!1,"scala.collection.immutable.HashCollisionMapNode",{T6:1,O7:1,lC:1,g:1});
+function FU(a,b,c){this.Yv=a;this.Wp=b;this.Kg=c;At(tp(),2<=this.Kg.K())}FU.prototype=new kR;FU.prototype.constructor=FU;f=FU.prototype;f.yt=function(a,b,c){return this.Wp===c?QU(this.Kg,a):!1};f.JC=function(a,b,c,d){return this.yt(a,b,c,d)?this:new FU(b,c,this.Kg.hn(a))};f.eG=function(a,b,c,d){return this.yt(a,b,c,d)?(d=MU(this.Kg,new y(e=>ml(nl(),e,a)),!0),1===d.K()?new CJ(lI(HH(),kI(HH(),c,0)),0,new zc([d.va(0)]),new Xc(new Int32Array([b])),1,c):new FU(b,c,d)):this};f.nB=function(){return!1};
+f.HB=function(){return 0};f.Nh=function(){throw aL(new bL,"No sub-nodes present in hash-collision leaf node.");};f.jy=function(){return!0};f.uy=function(){return this.Kg.K()};f.ed=function(a){return this.Kg.va(a)};f.Jb=function(){return this.Yv};f.ka=function(){return this.Kg.K()};f.Ca=function(a){for(var b=this.Kg.m();b.s();)a.n(b.t())};f.uc=function(){return Math.imul(this.Kg.K(),this.Wp)};
+f.EJ=function(a,b){a=MU(this.Kg,a,b);b=a.K();return 0===b?DJ().mw:1===b?new CJ(lI(HH(),kI(HH(),this.Wp,0)),0,new zc([a.e()]),new Xc(new Int32Array([this.Yv])),1,this.Wp):a.K()===this.Kg.K()?this:new FU(this.Yv,this.Wp,a)};f.mQ=function(a,b){return this.EJ(new y(c=>a.yt(c,this.Yv,this.Wp,b)),!0)};f.i=function(a){if(a instanceof FU){if(this===a)return!0;if(this.Wp===a.Wp&&this.Kg.K()===a.Kg.K()){a=a.Kg;for(var b=!0,c=this.Kg.m();b&&c.s();)b=c.t(),b=QU(a,b);return b}}return!1};
+f.B=function(){throw nv("Trie nodes do not support hashing.");};f.jQ=function(a){if(a instanceof FU){if(a===this)return this;var b=null;for(a=a.Kg.m();a.s();){var c=a.t();QU(this.Kg,c)||(null===b&&(b=new NU,OU(b,this.Kg)),PU(b,c))}return null===b?this:new FU(this.Yv,this.Wp,b.im())}if(a instanceof CJ)throw nv("Cannot concatenate a HashCollisionSetNode with a BitmapIndexedSetNode");throw new w(a);};f.FJ=function(a){for(var b=this.Kg.m();b.s();){var c=b.t();a.ba(c,this.Yv)}};
+f.lQ=function(){return new FU(this.Yv,this.Wp,this.Kg)};f.mB=function(a){return this.Nh(a)};f.$classData=q({U6:0},!1,"scala.collection.immutable.HashCollisionSetNode",{U6:1,v8:1,lC:1,g:1});function RU(){this.Mr=null;SU=this;var a=bI();this.Mr=new TU(a.Ty)}RU.prototype=new p;RU.prototype.constructor=RU;f=RU.prototype;f.Hh=function(a){return Dz(0,a)};function Dz(a,b){return b instanceof TU?b:UU(VU(new WU,b))}f.Eb=function(){return new WU};f.Ib=function(a){return Dz(0,a)};f.X=function(){return this.Mr};
+f.$classData=q({W6:0},!1,"scala.collection.immutable.HashMap$",{W6:1,g:1,Ey:1,l:1});var SU;function Ez(){SU||(SU=new RU);return SU}function XU(){this.Fo=null;YU=this;var a=DJ();this.Fo=new ZU(a.mw)}XU.prototype=new p;XU.prototype.constructor=XU;function $U(a,b){return b instanceof ZU?b:0===b.Q()?a.Fo:aV(bV(new cV,b))}XU.prototype.Eb=function(){return new cV};XU.prototype.Ib=function(a){return $U(this,a)};XU.prototype.X=function(){return this.Fo};
+XU.prototype.$classData=q({b7:0},!1,"scala.collection.immutable.HashSet$",{b7:1,g:1,bg:1,l:1});var YU;function dV(){YU||(YU=new XU);return YU}function eV(a,b){this.o7=a;this.p7=b}eV.prototype=new p;eV.prototype.constructor=eV;eV.prototype.e=function(){return this.o7};eV.prototype.Lf=function(){return this.p7};eV.prototype.$classData=q({n7:0},!1,"scala.collection.immutable.LazyList$State$Cons",{n7:1,g:1,m7:1,l:1});function fV(){}fV.prototype=new p;fV.prototype.constructor=fV;
+fV.prototype.LJ=function(){throw AH("head of empty lazy list");};fV.prototype.Lf=function(){throw nv("tail of empty lazy list");};fV.prototype.e=function(){this.LJ()};fV.prototype.$classData=q({q7:0},!1,"scala.collection.immutable.LazyList$State$Empty$",{q7:1,g:1,m7:1,l:1});var gV;function hV(){gV||(gV=new fV);return gV}function iV(){}iV.prototype=new p;iV.prototype.constructor=iV;f=iV.prototype;f.Hh=function(a){return pp(0,a)};
+function pp(a,b){ZJ(b)&&b.b()?a=nf():jV(b)?a=b:(a=kV(new lV,b),a=a.Sy?UU(a.Wt):a.bq);return a}f.Eb=function(){return new lV};f.Ib=function(a){return pp(0,a)};f.X=function(){return nf()};f.$classData=q({u7:0},!1,"scala.collection.immutable.Map$",{u7:1,g:1,Ey:1,l:1});var mV;function qp(){mV||(mV=new iV);return mV}function nV(){}nV.prototype=new p;nV.prototype.constructor=nV;
+function Aq(a,b){return b&&b.$classData&&b.$classData.rb.OL?MF(oV(new OF,b)):0===b.Q()?ap():b&&b.$classData&&b.$classData.rb.dq?b:MF(oV(new OF,b))}nV.prototype.Eb=function(){return new OF};nV.prototype.Ib=function(a){return Aq(0,a)};nV.prototype.X=function(){return ap()};nV.prototype.$classData=q({j8:0},!1,"scala.collection.immutable.Set$",{j8:1,g:1,bg:1,l:1});var pV;function Bq(){pV||(pV=new nV);return pV}function qV(){}qV.prototype=new p;qV.prototype.constructor=qV;f=qV.prototype;
+f.CF=function(a,b){return rV(0,a,b)};function rV(a,b,c){if(b instanceof sV&&(a=b.We,null===c?null===a:c.i(a)))return b;if(b&&b.$classData&&b.$classData.rb.YB&&(a=b.se(),null===c?null===a:c.i(a))){a=new sV;var d=nJ(),e=b.m();b=b.ka();var g=32-Math.clz32(b)|0;b=Eda(d,1,b,e,g);return tV(a,b,c)}a=null;for(b=b.m();b.s();){e=b.t();if(null===e)throw new w(e);d=e.h();e=e.j();a=gJ(nJ(),a,d,e,!0,c)}return tV(new sV,a,c)}f.Dv=function(a){return new uV(a)};f.qr=function(a,b){return rV(0,a,b)};f.Hd=function(a){return vV(a)};
+f.$classData=q({H8:0},!1,"scala.collection.immutable.TreeMap$",{H8:1,g:1,xL:1,l:1});var wV;function xV(){wV||(wV=new qV);return wV}function yV(a){this.aH=this.Yy=null;if(null===a)throw null;this.aH=a;this.Yy=null}yV.prototype=new gS;yV.prototype.constructor=yV;yV.prototype.ey=function(a,b){this.Yy=fR(this.aH,this.Yy,a,b)};yV.prototype.ba=function(a,b){this.ey(a,b)};yV.prototype.$classData=q({K8:0},!1,"scala.collection.immutable.TreeMap$TreeMapBuilder$adder$",{K8:1,nH:1,g:1,kz:1});
+function zV(a){this.GS=this.cH=null;if(null===a)throw null;this.GS=a;this.cH=a.Hf}zV.prototype=new cS;zV.prototype.constructor=zV;zV.prototype.n=function(a){var b=nJ();this.cH=pI(PI(b,this.cH,a,this.GS.Xe))};zV.prototype.$classData=q({O8:0},!1,"scala.collection.immutable.TreeSet$sub$1$",{O8:1,dM:1,g:1,la:1});function AV(){}AV.prototype=new p;AV.prototype.constructor=AV;f=AV.prototype;f.Hh=function(a){return Uy(a)};function Uy(a){var b=a.Q();return BV(CV(new DV,0<b?Eb((1+b|0)/.75):16,.75),a)}
+f.Eb=function(){return new EV(16,.75)};f.Ib=function(a){return Uy(a)};f.X=function(){return FV()};f.$classData=q({F9:0},!1,"scala.collection.mutable.HashMap$",{F9:1,g:1,Ey:1,l:1});var GV;function Ty(){GV||(GV=new AV);return GV}function HV(){}HV.prototype=new p;HV.prototype.constructor=HV;function qz(a){var b=a.Q();return IV(JV(new KV,0<b?Eb((1+b|0)/.75):16,.75),a)}HV.prototype.Eb=function(){return new LV(16,.75)};HV.prototype.X=function(){return Vn()};HV.prototype.Ib=function(a){return qz(a)};
+HV.prototype.$classData=q({O9:0},!1,"scala.collection.mutable.HashSet$",{O9:1,g:1,bg:1,l:1});var MV;function pz(){MV||(MV=new HV);return MV}function NV(){}NV.prototype=new p;NV.prototype.constructor=NV;f=NV.prototype;f.Hh=function(a){return OV(a)};function OV(a){if(a instanceof lA)return a;var b=new lA;return lR(b,a)}f.Eb=function(){return PV(new QV,new lA)};f.Ib=function(a){return OV(a)};f.X=function(){return new lA};
+f.$classData=q({$9:0},!1,"scala.collection.mutable.LinkedHashMap$",{$9:1,g:1,Ey:1,l:1});var RV;function SV(a){this.SS=0;this.VS=null;this.XS=this.WS=0;this.US=null;this.TS=0;this.dz=null;if(null===a)throw null;this.dz=a;wR(this)}SV.prototype=new p;SV.prototype.constructor=SV;f=SV.prototype;f.sJ=function(){return this.SS};f.bQ=function(a){this.SS=a};f.bl=function(){return this.VS};f.gM=function(a){this.VS=a};f.nu=function(){return this.WS};f.hz=function(a){this.WS=a};f.pT=function(){return this.XS};
+f.hM=function(a){this.XS=a};f.lu=function(){return this.US};f.$L=function(a){this.US=a};f.kT=function(){return this.TS};f.jT=function(a){this.TS=a};f.CJ=function(a,b){a=new xR(a,b);null===this.dz.Gn?this.dz.Gn=a:(this.dz.xw.zm=a,a.ww=this.dz.xw);return this.dz.xw=a};f.$classData=q({a$:0},!1,"scala.collection.mutable.LinkedHashMap$$anon$1",{a$:1,g:1,U9:1,W9:1});function TV(){}TV.prototype=new p;TV.prototype.constructor=TV;function JB(a,b){if(b instanceof MB)return b;a=new MB;return lR(a,b)}
+TV.prototype.Eb=function(){return PV(new QV,new MB)};TV.prototype.Ib=function(a){return JB(0,a)};TV.prototype.X=function(){return new MB};TV.prototype.$classData=q({h$:0},!1,"scala.collection.mutable.LinkedHashSet$",{h$:1,g:1,bg:1,l:1});var UV;function KB(){UV||(UV=new TV);return UV}function VV(a){this.ZS=0;this.bT=null;this.dT=this.cT=0;this.aT=null;this.$S=0;this.ez=null;if(null===a)throw null;this.ez=a;wR(this)}VV.prototype=new p;VV.prototype.constructor=VV;f=VV.prototype;f.sJ=function(){return this.ZS};
+f.bQ=function(a){this.ZS=a};f.bl=function(){return this.bT};f.gM=function(a){this.bT=a};f.nu=function(){return this.cT};f.hz=function(a){this.cT=a};f.pT=function(){return this.dT};f.hM=function(a){this.dT=a};f.lu=function(){return this.aT};f.$L=function(a){this.aT=a};f.kT=function(){return this.$S};f.jT=function(a){this.$S=a};f.CJ=function(a){a=new yR(a);null===this.ez.ku?this.ez.ku=a:(this.ez.yC.Mo=a,a.yw=this.ez.yC);return this.ez.yC=a};
+f.$classData=q({i$:0},!1,"scala.collection.mutable.LinkedHashSet$$anon$1",{i$:1,g:1,U9:1,W9:1});function WV(){}WV.prototype=new p;WV.prototype.constructor=WV;f=WV.prototype;f.CF=function(a,b){return XV(0,a,b)};function XV(a,b,c){a=YV(c);return lR(a,b)}f.Dv=function(a){return PV(new QV,YV(a))};f.Hd=function(a){return YV(a)};f.qr=function(a,b){return XV(0,a,b)};f.$classData=q({K$:0},!1,"scala.collection.mutable.TreeMap$",{K$:1,g:1,xL:1,l:1});var ZV;function $V(){ZV||(ZV=new WV);return ZV}
+function dT(a,b){this.C3=a;this.D3=b}dT.prototype=new p;dT.prototype.constructor=dT;dT.prototype.sl=function(a){return this.$l(a)};dT.prototype.$l=function(a){return this.C3.Da(this.D3,a)};dT.prototype.$classData=q({B3:0},!1,"scala.math.Ordered$$anon$1",{B3:1,g:1,yj:1,nf:1});function aW(){}aW.prototype=new p;aW.prototype.constructor=aW;aW.prototype.$classData=q({E3:0},!1,"scala.math.Ordering$",{E3:1,g:1,pba:1,l:1});var bW;function Su(){bW||(bW=new aW);return bW}function yH(){}yH.prototype=new wM;
+yH.prototype.constructor=yH;function cW(){}cW.prototype=yH.prototype;function dW(){}dW.prototype=new p;dW.prototype.constructor=dW;function eW(){}eW.prototype=dW.prototype;dW.prototype.u=function(){return"\x3cfunction1\x3e"};dW.prototype.n=function(a){return this.Ob(a,pG().nR)};var kH=q({caa:0},!1,"scala.runtime.Nothing$",{caa:1,pc:1,g:1,l:1});function U(a){this.P$=a}U.prototype=new aS;U.prototype.constructor=U;function Es(a){return(0,a.P$)()}
+U.prototype.$classData=q({O$:0},!1,"scala.scalajs.runtime.AnonFunction0",{O$:1,Xba:1,g:1,naa:1});function y(a){this.R$=a}y.prototype=new cS;y.prototype.constructor=y;y.prototype.n=function(a){return(0,this.R$)(a)};y.prototype.$classData=q({Q$:0},!1,"scala.scalajs.runtime.AnonFunction1",{Q$:1,dM:1,g:1,la:1});function fn(a){this.T$=a}fn.prototype=new gS;fn.prototype.constructor=fn;fn.prototype.ba=function(a,b){return(0,this.T$)(a,b)};
+fn.prototype.$classData=q({S$:0},!1,"scala.scalajs.runtime.AnonFunction2",{S$:1,nH:1,g:1,kz:1});function fW(a){this.aM=a}fW.prototype=new iS;fW.prototype.constructor=fW;fW.prototype.$classData=q({U$:0},!1,"scala.scalajs.runtime.AnonFunction3",{U$:1,Zba:1,g:1,paa:1});class vea extends Vd{}function gW(){}gW.prototype=new p;gW.prototype.constructor=gW;function hW(){}hW.prototype=gW.prototype;class Yj extends wS{constructor(a){super();yF(this,""+a,a instanceof Vd?a:null,!0)}}
+Yj.prototype.$classData=q({Q0:0},!1,"java.lang.AssertionError",{Q0:1,OF:1,pc:1,g:1,l:1});var jaa=q({S0:0},!1,"java.lang.Boolean",{S0:1,g:1,l:1,nf:1,Et:1},a=>"boolean"===typeof a),laa=q({U0:0},!1,"java.lang.Character",{U0:1,g:1,l:1,nf:1,Et:1},a=>a instanceof ba);function iL(a){var b=new iW;yF(b,a,null,!0);return b}class iW extends xF{}iW.prototype.$classData=q({Te:0},!1,"java.lang.RuntimeException",{Te:1,qd:1,pc:1,g:1,l:1});function jW(){this.ly=null}jW.prototype=new p;jW.prototype.constructor=jW;
+function kW(a,b){a=a.ly;a.ja=""+a.ja+b}function lW(a,b){a=a.ly;b=String.fromCharCode(b);a.ja=""+a.ja+b}jW.prototype.eM=function(a,b){return this.ly.ja.substring(a,b)};jW.prototype.u=function(){return this.ly.ja};jW.prototype.uJ=function(a){var b=this.ly;b.ja=""+b.ja+a};jW.prototype.$classData=q({v1:0},!1,"java.lang.StringBuffer",{v1:1,g:1,ZJ:1,rQ:1,l:1});function LQ(a){a.ja="";return a}function Uq(a,b){LQ(a);if(null===b)throw le();a.ja=b;return a}
+function Cu(a){var b=new Sq;LQ(b);if(0>a)throw new Aj;return b}function Sq(){this.ja=null}Sq.prototype=new p;Sq.prototype.constructor=Sq;function MQ(a,b,c,d){b=null===b?"null":b;c="string"===typeof b?b.substring(c,d):b.eM(c,d);a.ja=""+a.ja+c}function mW(a,b){b=AM(zH(),b,0,b.a.length);a.ja=""+a.ja+b}f=Sq.prototype;f.u=function(){return this.ja};f.K=function(){return this.ja.length};f.eM=function(a,b){return this.ja.substring(a,b)};f.uJ=function(a){this.ja=""+this.ja+a};
+f.$classData=q({w1:0},!1,"java.lang.StringBuilder",{w1:1,g:1,ZJ:1,rQ:1,l:1});function nW(a){return 0===a.$h?(a=a.Bg,!(-1===a.W&&-1===a.Y)):!1}function oW(a,b){var c=a.xb,d=c>>31,e=-c|0;c=0!==c?~d:-d|0;var g=CR(a);d=g>>31;g=e+g|0;e=(-2147483648^g)<(-2147483648^e)?1+(c+d|0)|0:c+d|0;if(0===e?-2147483629<(-2147483648^g):0<e)throw new qb("Rounding necessary");a=pW(a);if(yh(Sh(),a)<b)return a.xl();throw new qb("Rounding necessary");}
+function CR(a){return 0<a.cs?a.cs:1+Eb(.3010299956639812*(-1+a.$h|0))|0}function HR(a,b){a.bs=b;a.$h=yh(Sh(),b);64>a.$h&&(a.Bg=b.xl())}function qW(a){a.pu=null;a.lq=0;a.$h=0;a.Bg=aa;a.xb=0;a.cs=0}function kN(a,b){var c=new mr;qW(c);c.Bg=a;c.xb=b;c.$h=gN(hN(),a);return c}function eN(a,b){var c=new mr;qW(c);c.Bg=new ma(a,a>>31);c.xb=b;hN();a=32-Math.clz32(0>a?~a:a)|0;c.$h=a;return c}
+function nr(a,b,c){qW(a);var d=-1+(0+c|0)|0;if(null===b)throw oL("in \x3d\x3d null");if(d>=b.a.length||0>=c||0>d)throw new ZL("Bad offset/length: offset\x3d0 len\x3d"+c+" in.length\x3d"+b.a.length);var e=0;if(0<=d&&43===b.a[0]){if(e=1+e|0,e<d&&oN(hN(),b.a[e],new Ic(new Uint16Array([43,45]))))throw new ZL("For input string: "+b.u());}else{c=e<=d&&45===b.a[e];var g=(1+e|0)<d&&oN(hN(),b.a[1+e|0],new Ic(new Uint16Array([43,45])));if(c&&g)throw new ZL("For input string: "+b.u());}var h=e;for(c=!1;e<=d&&
+nN(hN(),b.a[e],new Ic(new Uint16Array([46,101,69])));)c||48===b.a[e]||(c=!0),e=1+e|0;g=e-h|0;g=AM(zH(),b,h,g);h=e-h|0;if(e<=d&&46===b.a[e]){for(var k=e=1+e|0;e<=d&&nN(hN(),b.a[e],new Ic(new Uint16Array([101,69])));)c||48===b.a[e]||(c=!0),e=1+e|0;a.xb=e-k|0;c=a.xb;zH();c=""+g+AM(0,b,k,c);g=h+a.xb|0}else a.xb=0,c=g,g=h;g|=0;if(e<=d&&oN(hN(),b.a[e],new Ic(new Uint16Array([101,69])))&&(e=1+e|0,h=(1+e|0)<=d&&45!==b.a[1+e|0],e=e<=d&&43===b.a[e]&&h?1+e|0:e,d=(1+d|0)-e|0,e=AM(zH(),b,e,d),b=a.xb,d=b>>31,h=
+TH(UH(),e,10),e=h>>31,h=b-h|0,a.xb=h,k=a.xb,h!==k||((-2147483648^h)>(-2147483648^b)?-1+(d-e|0)|0:d-e|0)!==k>>31))throw new ZL("Scale out of range");if(19>g){e=uM();""===c&&pM(c);d=0;b=!1;switch(c.charCodeAt(0)){case 43:d=1;break;case 45:d=1,b=!0}g=c.length;if(d>=g)pM(c),e=void 0;else{h=(e.RF?e.QF:nM(e))[10];for(k=h.j1;;){if(e=d<g){e=Pr();var l=c.charCodeAt(d);e=256>l?48===l:0<=kj(Pj(),RL(e),l)}if(e)d=1+d|0;else break}(g-d|0)>Math.imul(3,k)&&pM(c);e=1+Bb(-1+(g-d|0)|0,k)|0;l=d+e|0;var m=qM(d,l,c);if(l===
+g)e=new ma(m,0);else{e=h.DQ;d=e.W;e=e.Y;k=l+k|0;var n=65535&m,r=m>>>16|0,v=65535&d,x=d>>>16|0,A=Math.imul(n,v);v=Math.imul(r,v);var B=Math.imul(n,x);n=A+((v+B|0)<<16)|0;A=(A>>>16|0)+B|0;m=((Math.imul(m,e)+Math.imul(r,x)|0)+(A>>>16|0)|0)+(((65535&A)+v|0)>>>16|0)|0;l=qM(l,k,c);l=n+l|0;m=(-2147483648^l)<(-2147483648^n)?1+m|0:m;k===g?e=new ma(l,m):(n=h.k1,h=n.W,n=n.Y,g=qM(k,g,c),(m===n?(-2147483648^l)>(-2147483648^h):m>n)&&pM(c),n=65535&l,h=l>>>16|0,x=65535&d,k=d>>>16|0,r=Math.imul(n,x),x=Math.imul(h,
+x),A=Math.imul(n,k),n=r+((x+A|0)<<16)|0,r=(r>>>16|0)+A|0,e=(((Math.imul(l,e)+Math.imul(m,d)|0)+Math.imul(h,k)|0)+(r>>>16|0)|0)+(((65535&r)+x|0)>>>16|0)|0,d=n+g|0,e=(-2147483648^d)<(-2147483648^n)?1+e|0:e,-2147483648===(-2147483648^e)&&(-2147483648^d)<(-2147483648^g)&&pM(c),e=new ma(d,e))}}d=e.W;e=e.Y;b?(b=-d|0,d=0!==d?~e:-e|0,(0===d?0!==b:0<d)&&pM(c),c=new ma(b,d)):(0>e&&pM(c),c=new ma(d,e));a.Bg=c;a.$h=gN(hN(),a.Bg)}else HR(a,eM(c))}
+function FR(a,b,c){qW(a);if(null===b)throw oL("unscaledVal \x3d\x3d null");a.xb=c;HR(a,b);return a}function mr(){this.pu=null;this.lq=0;this.bs=null;this.$h=0;this.Bg=aa;this.cs=this.xb=0}mr.prototype=new wM;mr.prototype.constructor=mr;function rW(a){if(64>a.$h){if(0>a.Bg.Y)return-1;a=a.Bg;var b=a.Y;return(0===b?0!==a.W:0<b)?1:0}return $M(a).Ya}
+function pr(a){if(0===a.cs){if(0===a.$h)var b=1;else if(64>a.$h){var c=a.Bg;if(0===c.W&&-2147483648===c.Y)b=19;else{Pj();b=hN().lz;if(0>c.Y){var d=c.W;c=c.Y;d=new ma(-d|0,0!==d?~c:-c|0)}else d=c;b:{c=0;for(var e=b.a.length;;){if(c===e){b=-1-c|0;break b}var g=(c+e|0)>>>1|0,h=b.a[g],k=Za(new ma(h.W,h.Y));h=k.W;k=k.Y;h=ua(xa(),d.W,d.Y,h,k);if(0>h)e=g;else{if(0===h){b=g;break b}c=1+g|0}}}b=0>b?-1-b|0:1+b|0}}else b=1+Eb(.3010299956639812*(-1+a.$h|0))|0,d=$M(a),c=fi(),b=0!==GR(d,Pi(c,new ma(b,b>>31))).Ya?
+1+b|0:b;a.cs=b}return a.cs}function sW(a){if(nW(a))return a;var b=-1+fi().fs.a.length|0,c=1,d=$M(a),e=a=a.xb;for(a>>=31;;){if(ER(d,0))c=e,b=d,c=new ma(c,a);else{var g=tW(d,fi().fs.a[c]);if(0===g.oM.Ya){d=g.nM;var h=c;g=h>>31;var k=a;a=e-h|0;e=(-2147483648^a)>(-2147483648^e)?-1+(k-g|0)|0:k-g|0;c=c<b?1+c|0:c;g=e;e=a;a=g;continue}if(1!==c){c=1;continue}c=e;b=d;c=new ma(c,a)}break}c=Za(c);d=Za(new ma(c.W,c.Y));c=d.W;d=d.Y;return FR(new mr,b,mN(hN(),new ma(c,d)))}
+function uW(a,b){var c=rW(a),d=rW(b);if(c===d){if(a.xb===b.xb&&64>a.$h&&64>b.$h){d=a.Bg;c=b.Bg;var e=d.Y,g=c.Y;if(e===g?(-2147483648^d.W)<(-2147483648^c.W):e<g)return-1;a=a.Bg;b=b.Bg;d=a.Y;c=b.Y;return(d===c?(-2147483648^a.W)>(-2147483648^b.W):d>c)?1:0}e=a.xb;g=e>>31;d=b.xb;var h=d>>31;d=e-d|0;e=(-2147483648^d)>(-2147483648^e)?-1+(g-h|0)|0:g-h|0;g=CR(a)-CR(b)|0;h=g>>31;var k=1+d|0,l=0===k?1+e|0:e;if(h===l?(-2147483648^g)>(-2147483648^k):h>l)return c;h=g>>31;k=-1+d|0;l=-1!==k?e:-1+e|0;if(h===l?(-2147483648^
+g)<(-2147483648^k):h<l)return-c|0;a=$M(a);b=$M(b);if(0>e)c=fi(),a=Ki(a,Pi(c,new ma(-d|0,0!==d?~e:-e|0)));else if(0===e?0!==d:0<e)b=Ki(b,Pi(fi(),new ma(d,e)));return fM(a,b)}return c<d?-1:1}f=mr.prototype;f.i=function(a){if(a instanceof mr&&a.xb===this.xb){if(64>this.$h){a=a.Bg;var b=this.Bg;return a.W===b.W&&a.Y===b.Y}return this.bs.i(a.bs)}return!1};
+f.B=function(){if(0===this.lq)if(64>this.$h){this.lq=this.Bg.W;var a=this.Bg.Y;this.lq=Math.imul(33,this.lq)+a|0;this.lq=Math.imul(17,this.lq)+this.xb|0}else this.lq=Math.imul(17,this.bs.B())+this.xb|0;return this.lq};
+f.u=function(){if(null!==this.pu)return this.pu;if(32>this.$h)return this.pu=waa(bi(),this.Bg,this.xb);var a=$M(this);a=Vh(bi(),a);if(0===this.xb)return a;var b=0>$M(this).Ya?2:1,c=a.length,d=this.xb,e=d>>31,g=-d|0;e=0!==d?~e:-e|0;var h=c>>31;d=g+c|0;e=(-2147483648^d)<(-2147483648^g)?1+(e+h|0)|0:e+h|0;h=b>>31;g=d-b|0;d=(-2147483648^g)>(-2147483648^d)?-1+(e-h|0)|0:e-h|0;0<this.xb&&(-1===d?2147483642<=(-2147483648^g):-1<d)?0<=d?(hN(),b=c-this.xb|0,hN(),a=a.substring(0,b)+"."+a.substring(b)):(hN(),hN(),
+c=-1+b|0,hN(),a=a.substring(0,c)+"0."+a.substring(c),b=1+b|0,c=hN().mM,g=-1-g|0,hN(),c=c.substring(0,g),a=""+a.substring(0,b)+c+a.substring(b)):(a=(1<=(c-b|0)?(hN(),hN(),a.substring(0,b)+"."+a.substring(b)):a)+"E",a=((0===d?0!==g:0<d)?a+"+":a)+bG(xa(),g,d));return this.pu=a};function vW(a){if(0===a.xb||nW(a))return $M(a);if(0>a.xb){var b=$M(a),c=fi();a=a.xb;var d=a>>31;return Ki(b,Pi(c,new ma(-a|0,0!==a?~d:-d|0)))}b=$M(a);c=fi();a=a.xb;return GR(b,Pi(c,new ma(a,a>>31)))}
+function pW(a){if(0===a.xb||nW(a))return $M(a);if(0>a.xb){var b=$M(a),c=fi();a=a.xb;var d=a>>31;return Ki(b,Pi(c,new ma(-a|0,0!==a?~d:-d|0)))}if(a.xb>CR(a)||a.xb>wW($M(a)))throw new qb("Rounding necessary");b=$M(a);c=fi();a=a.xb;a=DR(b,Pi(c,new ma(a,a>>31)));if(0!==a.a[1].Ya)throw new qb("Rounding necessary");return a.a[0]}f.xl=function(){return-64>=this.xb||this.xb>CR(this)?aa:vW(this).xl()};f.Zi=function(){return-32>=this.xb||this.xb>CR(this)?0:vW(this).Zi()};
+f.pv=function(){return hM(jM(),$M(this)+"e"+(-this.xb|0))};f.Lp=function(){return aM(qa(),$M(this)+"e"+(-this.xb|0))};function $M(a){null===a.bs&&(a.bs=ri(Ph(),a.Bg));return a.bs}f.sl=function(a){return uW(this,a)};var iN=q({AT:0},!1,"java.math.BigDecimal",{AT:1,ur:1,g:1,l:1,nf:1});mr.prototype.$classData=iN;function xW(a){a.NC=-2;a.qu=0}
+function QR(a,b,c){xW(a);Ph();if(null===b)throw le();if(2>c||36<c)throw new ZL("Radix out of range");if(""===b)throw new ZL("Zero length BigInteger");if(""===b||"+"===b||"-"===b)throw new ZL("Zero length BigInteger");var d=b.length;if(45===b.charCodeAt(0))var e=-1,g=1,h=-1+d|0;else 43===b.charCodeAt(0)?(g=e=1,h=-1+d|0):(e=1,g=0,h=d);e|=0;var k=g|0;g=h|0;for(h=k;h<d;){var l=b.charCodeAt(h);if(43===l||45===l)throw new ZL("Illegal embedded sign character");h=1+h|0}h=bi().uH.a[c];l=pb(g,h);var m=Bb(g,
+h);0!==m&&(l=1+l|0);g=new Xc(l);l=bi().tH.a[-2+c|0];var n=0;for(m=k+(0===m?h:m)|0;k<d;){var r=TH(UH(),b.substring(k,m),c);fi();k=Fi(g,g,n,l);vi();var v=g,x=n,A=r;for(r=0;0!==A&&r<x;){var B=A;A=B+v.a[r]|0;B=(-2147483648^A)<(-2147483648^B)?1:0;v.a[r]=A;A=B;r=1+r|0}k=k+A|0;g.a[n]=k;n=1+n|0;k=m;m=k+h|0}a.Ya=e;a.wb=n;a.Qa=g;Ih(a);return a}function eM(a){var b=new TM;QR(b,a,10);return b}function qi(a,b){var c=new TM;xW(c);c.Ya=a;c.wb=1;c.Qa=new Xc(new Int32Array([b]));return c}
+function Hh(a,b,c){var d=new TM;xW(d);d.Ya=a;d.wb=b;d.Qa=c;return d}function rN(a,b){var c=new TM;xW(c);c.Ya=a;a=b.Y;0===a?(c.wb=1,c.Qa=new Xc(new Int32Array([b.W]))):(c.wb=2,c.Qa=new Xc(new Int32Array([b.W,a])));return c}function TM(){this.Qa=null;this.qu=this.NC=this.Ya=this.wb=0}TM.prototype=new wM;TM.prototype.constructor=TM;function VM(a){return 0>a.Ya?Hh(1,a.wb,a.Qa):a}function fM(a,b){return a.Ya>b.Ya?1:a.Ya<b.Ya?-1:a.wb>b.wb?a.Ya:a.wb<b.wb?-b.Ya|0:Math.imul(a.Ya,si(vi(),a.Qa,b.Qa,a.wb))}
+function GR(a,b){if(0===b.Ya)throw new qb("BigInteger divide by zero");var c=b.Ya;if(1===b.wb&&1===b.Qa.a[0])return 0<b.Ya?a:ui(a);var d=a.Ya,e=a.wb,g=b.wb;if(2===(e+g|0))return a=a.Qa.a[0],b=b.Qa.a[0],e=xa(),b=$h(e,a,0,b,0),a=e.Qc,d!==c&&(c=b,d=a,b=-c|0,a=0!==c?~d:-d|0),ri(Ph(),new ma(b,a));var h=e!==g?e>g?1:-1:si(vi(),a.Qa,b.Qa,e);if(0===h)return d===c?Ph().Ew:Ph().MC;if(-1===h)return Ph().nq;h=1+(e-g|0)|0;var k=new Xc(h);c=d===c?1:-1;1===g?gi(ei(),k,a.Qa,e,b.Qa.a[0]):di(ei(),k,h,a.Qa,e,b.Qa,g);
+c=Hh(c,h,k);Ih(c);return c}function DR(a,b){a=tW(a,b);return new (md(Ji).Ia)([a.nM,a.oM])}
+function tW(a,b){var c=b.Ya;if(0===c)throw new qb("BigInteger divide by zero");var d=b.wb;b=b.Qa;if(1===d){ei();b=b.a[0];var e=a.Qa,g=a.wb;d=a.Ya;1===g?(e=e.a[0],a=0===b?pb(0,0):+(e>>>0)/+(b>>>0)|0,g=0,b=0===b?Bb(0,0):+(e>>>0)%+(b>>>0)|0,e=0,d!==c&&(c=a,a=-c|0,g=0!==c?~g:-g|0),0>d&&(c=b,d=e,b=-c|0,e=0!==c?~d:-d|0),c=new uh(ri(Ph(),new ma(a,g)),ri(Ph(),new ma(b,e)))):(c=d===c?1:-1,a=new Xc(g),b=gi(0,a,e,g,b),b=new Xc(new Int32Array([b])),c=Hh(c,g,a),d=Hh(d,1,b),Ih(c),Ih(d),c=new uh(c,d));return c}g=
+a.Qa;e=a.wb;if(0>(e!==d?e>d?1:-1:si(vi(),g,b,e)))return new uh(Ph().nq,a);a=a.Ya;var h=1+(e-d|0)|0;c=a===c?1:-1;var k=new Xc(h);b=di(ei(),k,h,g,e,b,d);c=Hh(c,h,k);d=Hh(a,d,b);Ih(c);Ih(d);return new uh(c,d)}f=TM.prototype;f.i=function(a){if(a instanceof TM){var b;if(b=this.Ya===a.Ya&&this.wb===a.wb)a:{for(b=0;b!==this.wb;){if(this.Qa.a[b]!==a.Qa.a[b]){b=!1;break a}b=1+b|0}b=!0}a=b}else a=!1;return a};
+function wW(a){if(0===a.Ya)return-1;var b=zh(a);a=a.Qa.a[b];return(b<<5)+(0===a?32:31-Math.clz32(a&(-a|0))|0)|0}f.B=function(){if(0===this.qu){for(var a=this.wb,b=0;b<a;){var c=b;this.qu=Math.imul(33,this.qu)+this.Qa.a[c]|0;b=1+b|0}this.qu=Math.imul(this.qu,this.Ya)}return this.qu};f.Zi=function(){return Math.imul(this.Ya,this.Qa.a[0])};
+f.xl=function(){if(1<this.wb)var a=this.Qa.a[0],b=this.Qa.a[1];else a=this.Qa.a[0],b=0;var c=this.Ya,d=c>>31,e=65535&c,g=c>>>16|0,h=65535&a,k=a>>>16|0,l=Math.imul(e,h);h=Math.imul(g,h);var m=Math.imul(e,k);e=l+((h+m|0)<<16)|0;l=(l>>>16|0)+m|0;b=(((Math.imul(c,b)+Math.imul(d,a)|0)+Math.imul(g,k)|0)+(l>>>16|0)|0)+(((65535&l)+h|0)>>>16|0)|0;return new ma(e,b)};function Ki(a,b){return 0===b.Ya||0===a.Ya?Ph().nq:Mi(fi(),a,b)}function ui(a){return 0===a.Ya?a:Hh(-a.Ya|0,a.wb,a.Qa)}
+function Qi(a,b){if(0>b)throw new qb("Negative exponent");if(0===b)return Ph().Ew;if(1===b||a.i(Ph().Ew)||a.i(Ph().nq))return a;if(ER(a,0)){fi();for(var c=Ph().Ew,d=a;1<b;)a=0!==(1&b)?Ki(c,d):c,1===d.wb?d=Ki(d,d):(c=new Xc(d.wb<<1),c=Li(d.Qa,d.wb,c),d=new TM,xW(d),0===c.a.length?(d.Ya=0,d.wb=1,d.Qa=new Xc(new Int32Array([0]))):(d.Ya=1,d.wb=c.a.length,d.Qa=c,Ih(d))),b>>=1,c=a;return Ki(c,d)}for(c=1;!ER(a,c);)c=1+c|0;d=Ph();var e=Math.imul(c,b);if(e<d.sH.a.length)d=d.sH.a[e];else{d=e>>5;e&=31;var g=
+new Xc(1+d|0);g.a[d]=1<<e;d=Hh(1,1+d|0,g)}return Ki(d,Qi(Ni(a,c),b))}function Oi(a,b){return 0===b||0===a.Ya?a:0<b?Fh(Sh(),a,b):Oh(Sh(),a,-b|0)}function Ni(a,b){return 0===b||0===a.Ya?a:0<b?Oh(Sh(),a,b):Fh(Sh(),a,-b|0)}function ER(a,b){var c=b>>5;if(0===b)return 0!==(1&a.Qa.a[0]);if(0>b)throw new qb("Negative bit address");if(c>=a.wb)return 0>a.Ya;if(0>a.Ya&&c<zh(a))return!1;var d=a.Qa.a[c];0>a.Ya&&(d=zh(a)===c?-d|0:~d);return 0!==(d&1<<(31&b))}f.u=function(){return Vh(bi(),this)};
+function Ih(a){for(;;){if(0<a.wb&&(a.wb=-1+a.wb|0,0===a.Qa.a[a.wb]))continue;break}0===a.Qa.a[a.wb]&&(a.Ya=0);a.wb=1+a.wb|0}function zh(a){if(-2===a.NC){if(0===a.Ya)var b=-1;else for(b=0;0===a.Qa.a[b];)b=1+b|0;a.NC=b}return a.NC}f.sl=function(a){return fM(this,a)};var Ji=q({CT:0},!1,"java.math.BigInteger",{CT:1,ur:1,g:1,l:1,nf:1});TM.prototype.$classData=Ji;function uN(a,b){this.yQ=a;this.NF=b}uN.prototype=new uS;uN.prototype.constructor=uN;
+uN.prototype.$classData=q({MT:0},!1,"java.math.RoundingMode",{MT:1,Yaa:1,g:1,nf:1,l:1});function EM(a,b){null===a.wv?a.Gt=""+a.Gt+b:yW(a,[b])}function zW(a,b,c){null===a.wv?a.Gt=""+a.Gt+b+c:yW(a,[b,c])}function AW(a,b,c,d){null===a.wv?a.Gt=a.Gt+(""+b+c)+d:yW(a,[b,c,d])}function yW(a,b){try{for(var c=b.length|0,d=0;d!==c;)a.wv.uJ(b[d]),d=1+d|0}catch(e){throw e;}}function HM(a){return void 0!==a?(a=+parseInt(a,10),2147483647>=a?Eb(a):-2):-1}
+function BW(a){return(0!==(1&a)?"-":"")+(0!==(2&a)?"#":"")+(0!==(4&a)?"+":"")+(0!==(8&a)?" ":"")+(0!==(16&a)?"0":"")+(0!==(32&a)?",":"")+(0!==(64&a)?"(":"")+(0!==(128&a)?"\x3c":"")}function CW(a,b,c){var d=Wj(a,1+b|0);a=d.Ft?"-":"";var e=d.wr,g=-1+e.length|0,h=b-g|0;b=e.substring(0,1);e=""+e.substring(1)+Sj(Tj(),h);d=g-d.vr|0;g=""+(0>d?-d|0:d);return a+(""!==e||c?b+"."+e:b)+"e"+(0>d?"-":"+")+(1===g.length?"0"+g:g)}
+function DW(a,b,c){var d=Uj(a,(a.wr.length+b|0)-a.vr|0);Tj();if(!("0"===d.wr||d.vr<=b))throw new Yj("roundAtPos returned a non-zero value with a scale too large");d="0"===d.wr||d.vr===b?d:new Vj(a.Ft,""+d.wr+Sj(Tj(),b-d.vr|0),b);a=d.Ft?"-":"";d=d.wr;var e=d.length,g=1+b|0;d=e>=g?d:""+Sj(Tj(),g-e|0)+d;e=d.length-b|0;a+=d.substring(0,e);return 0!==b||c?a+"."+d.substring(e):a}function QM(a,b,c,d,e,g){b=0>e||e>=g.length?g:g.substring(0,e);b=0!==(256&c)?b.toUpperCase():b;NM(a,c,d,b)}
+function YM(a,b,c,d){NM(a,b,c,XM(b,d!==d?"NaN":0<d?0!==(4&b)?"+Infinity":0!==(8&b)?" Infinity":"Infinity":0!==(64&b)?"(Infinity)":"-Infinity"))}
+function UM(a,b,c,d,e){if(d.length>=c&&0===(110&b))b=XM(b,d),EM(a,b);else if(0===(126&b))NM(a,b,c,XM(b,d));else{if(45!==d.charCodeAt(0))var g=0!==(4&b)?"+":0!==(8&b)?" ":"";else 0!==(64&b)?(d=d.substring(1)+")",g="("):(d=d.substring(1),g="-");e=""+g+e;if(0!==(32&b)){var h=d.length;for(g=0;;){if(g!==h){var k=d.charCodeAt(g);k=48<=k&&57>=k}else k=!1;if(k)g=1+g|0;else break}g=-3+g|0;if(!(0>=g)){for(h=d.substring(g);3<g;)k=-3+g|0,h=d.substring(k,g)+","+h,g=k;d=d.substring(0,g)+","+h}}d=XM(b,d);WM(a,0,
+b,c,e,d)}}function XM(a,b){return 0!==(256&a)?b.toUpperCase():b}function NM(a,b,c,d){var e=d.length;e>=c?EM(a,d):0!==(1&b)?zW(a,d,EW(" ",c-e|0)):zW(a,EW(" ",c-e|0),d)}function WM(a,b,c,d,e,g){b=e.length+g.length|0;b>=d?zW(a,e,g):0!==(16&c)?AW(a,e,EW("0",d-b|0),g):0!==(1&c)?AW(a,e,g,EW(" ",d-b|0)):AW(a,EW(" ",d-b|0),e,g)}function EW(a,b){for(var c="",d=0;d!==b;)c=""+c+a,d=1+d|0;return c}function FM(a){throw new FW(String.fromCharCode(a));}function JM(a){throw new GW(a);}
+function ZM(a,b,c,d,e,g){var h=0!==(2&c);d=0<=d?d:6;switch(e){case 101:h=CW(b,d,h);break;case 102:h=DW(b,d,h);break;default:e=0===d?1:d,b=Wj(b,e),d=(-1+b.wr.length|0)-b.vr|0,-4<=d&&d<e?(e=-1+(e-d|0)|0,h=DW(b,0>e?0:e,h)):h=CW(b,-1+e|0,h)}UM(a,c,g,h,"")}function BM(){this.Gt=this.T1=this.wv=null;this.gK=!1}BM.prototype=new p;BM.prototype.constructor=BM;BM.prototype.u=function(){if(this.gK)throw new DM;return null===this.wv?this.Gt:this.wv.u()};function KM(a){throw new HW(BW(a));}
+function MM(a,b,c){throw new IW(BW(b&c),a);}function RM(a,b){throw new JW(a,ca(b));}BM.prototype.$classData=q({O1:0},!1,"java.util.Formatter",{O1:1,g:1,yT:1,R0:1,zT:1});function KW(){}KW.prototype=new p;KW.prototype.constructor=KW;KW.prototype.Da=function(a,b){return(a|0)-(b|0)|0};KW.prototype.Qo=function(a,b,c){a.a[b]=c|0};KW.prototype.Wj=function(a,b){return a.a[b]};KW.prototype.$classData=q({y2:0},!1,"java.util.internal.GenericArrayOps$ByteArrayOps$",{y2:1,g:1,zB:1,XF:1,Ji:1});var LW;
+function gj(){LW||(LW=new KW);return LW}function MW(){}MW.prototype=new p;MW.prototype.constructor=MW;MW.prototype.Da=function(a,b){return Ea(a)-Ea(b)|0};MW.prototype.Qo=function(a,b,c){a.a[b]=Ea(c)};MW.prototype.Wj=function(a,b){return hc(a.a[b])};MW.prototype.$classData=q({z2:0},!1,"java.util.internal.GenericArrayOps$CharArrayOps$",{z2:1,g:1,zB:1,XF:1,Ji:1});var NW;function ej(){NW||(NW=new MW);return NW}function OW(){}OW.prototype=new p;OW.prototype.constructor=OW;
+OW.prototype.Da=function(a,b){a|=0;b|=0;return a===b?0:a<b?-1:1};OW.prototype.Qo=function(a,b,c){a.a[b]=c|0};OW.prototype.Wj=function(a,b){return a.a[b]};OW.prototype.$classData=q({A2:0},!1,"java.util.internal.GenericArrayOps$IntArrayOps$",{A2:1,g:1,zB:1,XF:1,Ji:1});var PW;function Ui(){PW||(PW=new OW);return PW}function QW(){}QW.prototype=new p;QW.prototype.constructor=QW;QW.prototype.Da=function(a,b){var c=Za(a);a=c.W;c=c.Y;var d=Za(b);b=d.W;d=d.Y;return ua(xa(),a,c,b,d)};
+QW.prototype.Qo=function(a,b,c){c=Za(c);a.a[b]=new ma(c.W,c.Y)};QW.prototype.Wj=function(a,b){return a.a[b]};QW.prototype.$classData=q({B2:0},!1,"java.util.internal.GenericArrayOps$LongArrayOps$",{B2:1,g:1,zB:1,XF:1,Ji:1});var RW;function aj(){RW||(RW=new QW);return RW}function SW(){}SW.prototype=new p;SW.prototype.constructor=SW;SW.prototype.Da=function(a,b){return(a|0)-(b|0)|0};SW.prototype.Qo=function(a,b,c){a.a[b]=c|0};SW.prototype.Wj=function(a,b){return a.a[b]};
+SW.prototype.$classData=q({D2:0},!1,"java.util.internal.GenericArrayOps$ShortArrayOps$",{D2:1,g:1,zB:1,XF:1,Ji:1});var TW;function cj(){TW||(TW=new SW);return TW}function wea(a,b,c){jr();var d=new Te(new Ue(J(new K,[""," `","` does not contain member `","`"])));Xe();Q();var e=b.Ab.fd().ld;e=We(0,Nu(0,e));Xe();b=[e,We(0,b.Ab.Cf.x),We(Xe(),c.x)];d=Ye(d,J(new K,b));c=c.A();c=G(new H,d,c);d=O().c;return kr(0,new z(c,d),a.$c,lu())}
+var xea=function UW(a,b,c,d,e,g,h,k,l){for(;;){if(b.Ea()<=c)return b;var n=!1,r=null,v=b;if(v instanceof cC)r=v,b=r.Fg,r=r.Sf,d?(b=r,d=!0):d=!1;else{if(v instanceof cv)return b=v,r=b.ac,new cv(a,UW(a,b.Nb,c,!d,e,g,h,k,l),UW(a,r,c,d,e,g,h,k,l),b.Mj);if(v instanceof LA)return b=v,r=b.jc,new LA(a,b.tc,UW(a,b.ic,c,d,e,g,h,k,l),UW(a,r,c,d,e,g,h,k,l),b.KE);if(v instanceof Qv)return b=v,r=b.Ba,v=a,lv(),new Qv(v,ry(0,r,new y(((C,D,F,I,M,N,P,T)=>Y=>{var Z=Y.Va,S=Y.Oa;S.b()?S=R():(S=S.o(),S=new L(UW(C,S,D,
+!F,I,M,N,P,T)));return new Uw(Z,S,UW(C,Y.ra,D,F,I,M,N,P,T),Y.Pd)})(a,c,d,e,g,h,k,l))),b.Nj);if(v instanceof zv)return b=v,r=b.Yb,v=a,lv(),new zv(v,ry(0,r,new y(((C,D,F,I,M,N,P,T)=>Y=>{var Z=Y.Va,S=Y.Oa;S.b()?S=R():(S=S.o(),S=new L(UW(C,S,D,!F,I,M,N,P,T)));return new Uw(Z,S,UW(C,Y.ra,D,F,I,M,N,P,T),Y.Pd)})(a,c,d,e,g,h,k,l))),b.Nq);if(v instanceof Sv){b=v;r=b.Fd;n=v=a;var x=d,A=r.Va,B=r.Oa;B.b()?n=R():(B=B.o(),n=new L(UW(n,B,c,!x,e,g,h,k,l)));return new Sv(v,new Uw(A,n,UW(a,r.ra,c,d,e,g,h,k,l),r.Pd),
+b.Fx)}if(v instanceof Tv)return b=v,r=b.kf,new Tv(a,UW(a,b.Ic,c,d,e,g,h,k,l),r,b.vp);if(v instanceof lx&&(n=!0,r=v,iC(a),x=r.Sb,!x.b()))return d=x.o(),b=G(new H,r,!0),h.Se(b,new U(((C,D,F,I,M,N,P,T,Y)=>()=>{var Z=D.ji;t();var S=new L(D),ea=D.kg,ia=O().c,X=O().c;Z=new lx(C,F,ia,X,S,ea,!1,Z);S=G(new H,D,!0);S=G(new H,S,Z);I.$(S);ea=UW(C,M,F,!0,N,P,I,T,Y);S=UW(C,M,F,!1,N,P,I,T,Y);Pe(new E(ea),S)?wy(Z,(t(),new L(ea))):(up(tp(),vy(Z).b()),up(tp(),rA(Z).b()),ia=O().c,IA(Z,new z(ea,ia)),ea=O().c,KA(Z,new z(S,
+ea)));return Z})(a,r,c,h,d,e,g,k,l)));if(n&&r.Xa>e){d=!h.L(G(new H,r,!1));b=r;if(!d)throw new Yj("assertion failed: "+G(new H,b,h));if(vy(r).b()&&rA(r).b())return r;d=G(new H,r,!0);return h.Se(d,new U(((C,D,F,I,M,N,P,T)=>()=>{var Y=D.ji;t();var Z=new L(D),S=D.kg,ea=O().c,ia=O().c;Y=new lx(C,D.Xa,ea,ia,Z,S,!1,Y);Z=G(new H,D,!0);Z=G(new H,Z,Y);F.$(Z);ia=vy(D);Z=(sa=>Ja=>UW(sa,Ja,I,!0,M,N,F,P,T))(C);if(ia===u())Z=u();else{S=ia.e();ea=S=new z(Z(S),u());for(ia=ia.f();ia!==u();){var X=ia.e();X=new z(Z(X),
+u());ea=ea.p=X;ia=ia.f()}Z=S}IA(Y,Z);ia=rA(D);Z=(sa=>Ja=>UW(sa,Ja,I,!1,M,N,F,P,T))(C);if(ia===u())Z=u();else{S=ia.e();ea=S=new z(Z(S),u());for(ia=ia.f();ia!==u();)X=ia.e(),X=new z(Z(X),u()),ea=ea.p=X,ia=ia.f();Z=S}KA(Y,Z);return Y})(a,r,h,c,e,g,k,l)))}if(v instanceof Wv)return b=v,sB(b,new y(((C,D,F,I,M,N,P,T)=>Y=>UW(C,Y,D,F,I,M,N,P,T))(a,c,d,e,g,h,k,l)),new y(((C,D,F,I,M,N,P,T)=>Y=>UW(C,Y,D,!F,I,M,N,P,T))(a,c,d,e,g,h,k,l)),new y(((C,D,F,I,M,N,P,T)=>Y=>UW(C,Y,D,F,I,M,N,P,T))(a,c,d,e,g,h,k,l)),b.Uu);
+if(n)return b=G(new H,r,d),h.Se(b,new U(((C,D,F,I,M,N,P,T,Y)=>()=>{var Z=D.ji;t();var S=new L(D),ea=D.kg,ia=O().c,X=O().c;Z=new lx(C,F,ia,X,S,ea,!1,Z);S=G(new H,D,M);S=G(new H,S,Z);I.$(S);if(M){S=rA(D);KA(D,new z(Z,S));X=vy(D);S=(Ja=>Xa=>UW(Ja,Xa,F,M,N,P,I,T,Y))(C);if(X===u())S=u();else{ea=X.e();ia=ea=new z(S(ea),u());for(X=X.f();X!==u();){var sa=X.e();sa=new z(S(sa),u());ia=ia.p=sa;X=X.f()}S=ea}IA(Z,S)}else{S=vy(D);IA(D,new z(Z,S));X=rA(D);S=(Ja=>Xa=>UW(Ja,Xa,F,M,N,P,I,T,Y))(C);if(X===u())S=u();
+else{ea=X.e();ia=ea=new z(S(ea),u());for(X=X.f();X!==u();)sa=X.e(),sa=new z(S(sa),u()),ia=ia.p=sa,X=X.f();S=ea}KA(Z,S)}return Z})(a,r,c,h,d,e,g,k,l)));if(v instanceof MA)return b=v,new MA(a,UW(a,b.Fc,c,!d,e,g,h,k,l),b.rA);if(v instanceof FA)return v;if(v instanceof OA)return b=v,new OA(a,UW(a,b.Hi,c,d,e,g,h,k,l),b.NE);if(v instanceof ZB&&(r=v,$B(a),t(),r=r.mc(),r=new L(r),!r.b())){b=r.k;continue}if(v instanceof mx){r=v;n=r.hi;if(r.Tu>e){if(n=UW(a,n,c,d,e,g,h,k,l),n instanceof lx)return new mx(a,n,
+r.et)}else if(r.Tu>c)return new YB(a,!d,r,jx(new kx,r.et.Wu,r.et.Ga,"extruded type variable reference",r.et.go,r.et.Zm),l);xm("Program reached and unexpected state.")}if(v instanceof Mu||v instanceof nC||v instanceof YB)return b;if(v instanceof fw)return b=v,r=b.qb,v=a,t(),new fw(v,r,bw(b,new L(d),new fn(((C,D,F,I,M,N,P)=>(T,Y)=>{T=G(new H,T,Y);Y=T.y;var Z=T.w;if(t().d===Y)return dw(cw(C),UW(C,Z,D,!1,F,I,M,N,P),UW(C,Z,D,!0,F,I,M,N,P),ew(cw(C)),I);Y=T.y;Z=T.w;if(Y instanceof L)return UW(C,Z,D,!!Y.k,
+F,I,M,N,P);throw new w(T);})(a,c,e,g,h,k,l)),g),b.Xl);if(v instanceof Qx)return b=v,r=b.de,new Qx(a,r,UW(a,b.Re,c,d,e<r?e:r,g,h,k,l));if(v instanceof eC){b=v;A=b.Lj;b=b.kj;r=a;v=((C,D,F,I,M,N,P)=>T=>{if(null!==T){var Y=T.j();T=UW(C,T.h(),D,!0,F,I,M,N,P);Y=UW(C,Y,D,!1,F,I,M,N,P);return G(new H,T,Y)}throw new w(T);})(a,c,e,g,h,k,l);if(A===u())v=u();else{n=A.e();x=n=new z(v(n),u());for(A=A.f();A!==u();)B=A.e(),B=new z(v(B),u()),x=x.p=B,A=A.f();v=n}return new eC(r,v,UW(a,b,c,d,e,g,h,k,l))}if(v instanceof
+Jv)return VW(v,new y(((C,D,F,I,M,N,P,T)=>Y=>UW(C,Y,D,!F,I,M,N,P,T))(a,c,d,e,g,h,k,l)),new y(((C,D,F,I,M,N,P,T)=>Y=>UW(C,Y,D,F,I,M,N,P,T))(a,c,d,e,g,h,k,l)));throw new w(v);}}};
+function WW(a,b,c,d,e){var g=!1,h=null,k=b.U(c.x);if(k instanceof L&&(g=!0,h=k,b=h.k,b instanceof bx))return rx(b.Mb)&&(e=new Te(new Ue(J(new K,["Let binding '","' cannot tbe accessed as a field"]))),g=[We(Xe(),b.Ua())],e=Ye(e,J(new K,g)),c=c.A(),c=G(new H,e,c),e=Ye(new Te(new Ue(J(new K,["Use a `val` declaration to make it a field"]))),u()),g=b.Mb.A(),e=G(new H,e,g),g=O().c,ay(a,new z(c,new z(e,g)),d)),d=b.Nn(),t(),b.Mb.Om.b()?(a=b.ma(),a=new Uw(d.q,R(),d,a)):a=new Uw(a,(t(),new L(d)),d,b.ma()),
+new L(a);if(g&&(b=h.k,b instanceof Vw))return e||b.bo||(e=new Te(new Ue(J(new K,["Parameter '","' cannot be accessed as a field"]))),g=[We(Xe(),b.ij.Ua())],e=Ye(e,J(new K,g)),c=c.A(),c=G(new H,e,c),e=Ye(new Te(new Ue(J(new K,["Either make the parameter a `val` or access it through destructuring"]))),u()),g=b.ij.A(),e=G(new H,e,g),g=O().c,ay(a,new z(c,new z(e,g)),d)),t(),new L(b.ig);if(g)return e=h.k,t(),b=new Te(new Ue(J(new K,["Access to "," member not yet supported"]))),e=[We(Xe(),e.fd().ld)],d=
+Lw(a,Ye(b,J(new K,e)),c.A(),d),a=V(a),a=new Uw(d.q,R(),d,a),new L(a);if(t().d===k)return t().d;throw new w(k);}function yea(a){if(0>=a.ab(15))return a;var b=xt(a,15),c=Ye(new Te(new Ue(J(new K,["......"]))),u()),d=t().d;c=G(new H,c,d);d=Ye(new Te(new Ue(J(new K,["......"]))),u());var e=t().d;d=G(new H,d,e);a=er(a).m().Mn(15);Od();a=Km(Pd(u(),a));return dl(new z(c,new z(d,a)),b)}
+function XW(a,b,c){var d=new Te(new Ue(J(new K,["Subtyping constraint of the form `"," \x3c: ","`"])));a=[wO(Xe(),AD(a,b)),wO(Xe(),CD(c,b))];return Ye(d,J(new K,a))}
+function YW(a,b,c,d,e,g,h,k,l,m,n){var r=(g.Ke-g.Zd|0)&(-1+g.ec.a.length|0);0<(250===r?0:250>r?-1:1)?(b=new Te(new Ue(J(new K,[""," exceeded recursion depth limit (",")"]))),c=[XW(d,c,e),We(Xe(),"250")],b=Ye(b,J(new K,c)),h=G(new H,b,h.Ga),a.zA?a.$E?(Od(),b=Pd(u(),g),b=ZW(HF(new yt(b)),new y(v=>{if(null!==v){var x=v.h();v=v.j();var A=new Te(new Ue(J(new K,["while constraining:  ",""]))),B=[We(Xe(),""+x)];A=Ye(A,J(new K,B));x=x.ma().Ga;x=G(new H,A,x);A=new Te(new Ue(J(new K,["                       \x3c!\x3c  ",
+""])));B=[We(Xe(),""+v)];A=Ye(A,J(new K,B));v=v.ma().Ga;v=G(new H,A,v);A=O().c;return new z(x,new z(v,A))}throw new w(v);}))):(Od(),b=Pd(u(),g),b=yea(Qt(HF(new yt(b)),new y(v=>{var x=new Te(new Ue(J(new K,["while constraining:  ",""])));v=[We(Xe(),v.h()+"  \x3c!\x3c  "+v.j())];x=Ye(x,J(new K,v));v=t().d;return G(new H,x,v)})))):(b=Ye(new Te(new Ue(J(new K,["Note: use flag `:ex` to see internal error info."]))),u()),g=t().d,b=G(new H,b,g),g=O().c,b=new z(b,g)),ay(a,new z(h,b),k),Es(l)):0>=m.ve?(g=
+new Te(new Ue(J(new K,[""," took too many steps and ran out of fuel (",")"]))),c=[XW(d,c,e),We(Xe(),""+n)],g=Ye(g,J(new K,c)),h=G(new H,g,h.Ga),a.zA?(g=Qt(b.h(),new y(v=>{var x=new Te(new Ue(J(new K,[" + ",""]))),A=[We(Xe(),""+v)];x=Ye(x,J(new K,A));v=v.ma().Ga;return G(new H,x,v)})),b=dl(Qt(b.j(),new y(v=>{var x=new Te(new Ue(J(new K,[" - ",""]))),A=[We(Xe(),""+v)];x=Ye(x,J(new K,A));v=v.ma().Ga;return G(new H,x,v)})),g)):(b=Ye(new Te(new Ue(J(new K,["Note: use flag `:ex` to see internal error info."]))),
+u()),g=t().d,b=G(new H,b,g),g=O().c,b=new z(b,g)),ay(a,new z(h,b),k),Es(l)):m.ve=-1+m.ve|0}function $W(a,b,c,d){b=d+"."+b;a.F&&(a=ut(Q(),"| ",a.r)+b,ff(gf(),a+"\n"));c.n(b)}
+function aX(a,b,c,d,e,g,h,k,l,m,n,r,v,x,A){c=c.cb;var B=a.qa;if(a.F){var C=ut(Q(),"| ",a.r)+"UNSTASHING...";ff(gf(),C+"\n")}a.r=1+a.r|0;try{c.Ca(new y(F=>{if(null!==F){var I=F.h();F=F.j();if(a.F){var M=ut(Q(),"| ",a.r)+("where("+I+") ")+xx(I);ff(gf(),M+"\n")}for(F=F.m();F.s();)a:{if(M=F.t(),null!==M){var N=M.j();if(!0===M.Rc()){a.F&&(M=ut(Q(),"| ",a.r)+("UNSTASH "+N+" \x3c: "+I+" where ")+xx(N),ff(gf(),M+"\n"));bX(a,N,I,!1,g,d,e,b,h,k,l,m,n,g,r,v,x,A,h);break a}}if(null!==M&&(N=M.j(),!1===M.Rc())){a.F&&
+(M=ut(Q(),"| ",a.r)+("UNSTASH "+I+" \x3c: "+N+" where ")+xx(N),ff(gf(),M+"\n"));bX(a,I,N,!1,g,d,e,b,h,k,l,m,n,g,r,v,x,A,h);break a}throw new w(M);}}else throw new w(F);}));c.mg();var D=void 0}finally{a.r=-1+a.r|0}dx(new E(B),a.qa)&&a.F&&(D=""+ut(Q(),"| ",a.r)+B.n(D),ff(gf(),D+"\n"))}
+function cX(a,b,c,d,e,g,h,k,l,m,n,r,v,x,A,B,C){var D=a.Df,F=O().c;xB(a);xB(a);xB(a);var I=ap();b=TO(xB(a),D,F,b,!0,g,I);D=a.Df;F=O().c;xB(a);xB(a);xB(a);I=ap();var M=TO(xB(a),D,F,c,!1,g,I);if(qB(M)){c=1+g.da|0;D=Hw();F=Su();I=op().ga;D=D.Hd(new Uu(F,I));var N=new Iw(g.S,g.Ec,g.hc,g.Ed,c,g.Pc,g.Zc,g.Lb,g.yc,g.tb,g.$a,g.od,D),P=Xu().X();c=a.Df;D=JF(lv(),M.Qf,new y(S=>S.Kc(M.fb,!0,N,P)));var T=M.xe;if(T===u())F=u();else for(F=T.e(),I=F=new z(dX(F,M.fb,!0,N,P),u()),T=T.f();T!==u();){var Y=T.e();Y=new z(dX(Y,
+M.fb,!0,N,P),u());I=I.p=Y;T=T.f()}c=new RO(a,c,D,F);a.F&&(D=ut(Q(),"| ",a.r)+("DNF BUMP TO LEVEL "+N.da+"  --\x3e  ")+c,ff(gf(),D+"\n"));eX(a,b,c,d,e,N,h,k,r,v,n,l,x,A,B,C,m);aX(a,g,N,d,e,k,m,n,r,v,l,x,A,B,C);a=N.cb;up(tp(),g.S.li||N.cb.b());if(!a.b()){d=g.S.qa;e=g.S;e.F&&(h=ut(Q(),"| ",e.r)+"UNSTASHING... (out)",ff(gf(),h+"\n"));e.r=1+e.r|0;try{a.Ca(new y(((S,ea)=>ia=>{if(null!==ia){var X=ia.h();for(ia=ia.j().m();ia.s();){var sa=ia.t();a:{if(null!==sa){var Ja=sa.j();if(!0===sa.Rc()){sa=Sw(S.S).ob;
+Tw(S.S,Ja,X,k,l,ea,sa);break a}}if(null!==sa&&(Ja=sa.j(),!1===sa.Rc())){sa=Sw(S.S).ob;Tw(S.S,X,Ja,k,l,ea,sa);break a}throw new w(sa);}}}else throw new w(ia);})(g,g)));a.mg();var Z=void 0}finally{e.r=-1+e.r|0}dx(new E(d),e.qa)&&e.F&&(g=""+ut(Q(),"| ",e.r)+d.n(Z),ff(gf(),g+"\n"))}}else eX(a,b,M,d,e,g,h,k,r,v,n,l,x,A,B,C,m)}
+function zea(a,b,c,d,e,g,h,k,l,m,n,r,v,x,A,B,C,D,F,I){var M=tc();try{var N=sp(b);if(N instanceof L){var P=N.k,T=c.zf(!1),Y=(new PO(a,d,b.Ek(P),e,g)).zf(!1),Z=V(Y.q),S=NA(Y,Z,!1),ea=V(T.q);bX(a,P,dv(T,S,ea,!1),!0,h,k,l,m,n,r,v,x,A,h,B,C,D,F,I)}else if(t().d===N){var ia=g.m(),X=new Ef(ia,new y(bb=>{var Ia=a.Df,Ua=O().c;xB(a);xB(a);var pc=ap();return TO(xB(a),Ia,Ua,bb,!0,m,pc)})),sa=a.Df,Ja=O().c,Xa=e.zf(!1);xB(a);xB(a);for(var Fa=ap(),za=UO(c,TO(xB(a),sa,Ja,Xa,!1,m,Fa),m,!0);X.s();){c=za;var Qa=X.t();
+za=UO(c,Qa,m,!0)}X=za;if(a.F){var Ma=ut(Q(),"| ",a.r)+("Consider "+d+" \x3c: ")+X;ff(gf(),Ma+"\n")}Ma=!1;za=null;if(d instanceof Ku){Ma=!0;za=d;var Ga=za.fc,ab=za.vd,Hb=za.be,bc=za.Me;if(Ga instanceof L){var yb=Ga.k;if(yb instanceof Tv){var tb=yb.Ic,eb=yb.kf;if(tb instanceof MA){var kb=tb.Fc;if(kb instanceof lx){var Rb=X.zf(!1),Gb=(new Ku(a,t().d,ab,Hb,bc)).zf(!1),vb=V(Gb.q),Tb=NA(Gb,vb,!1),Nb=V(Rb.q),ic=dv(Rb,Tb,Nb,!1),Va=iB(ic,eb),cb=V(Va.q);bX(a,NA(Va,cb,!1),kb,!0,h,k,l,m,n,r,v,x,A,h,B,C,D,F,I);
+return}}}}}if(Ma){var zb=za.fc,Ub=za.vd,jb=za.be,db=za.Me;if(zb instanceof L){var ub=zb.k;if(ub instanceof Tv){var Aa=ub.Ic,va=ub.kf;up(tp(),Aa instanceof lx);var Ra=X.zf(!1),rb=(new Ku(a,t().d,Ub,jb,db)).zf(!1),xb=V(rb.q),mc=NA(rb,xb,!1),Ha=V(Ra.q),Ka=dv(Ra,mc,Ha,!1);bX(a,Aa,iB(Ka,va),!0,h,k,l,m,n,r,v,x,A,h,B,C,D,F,I);return}}}Ga=bb=>{if(Ot(new E(bb.Of),lw(a))&&bb.Pf.b()&&bb.Af.b()&&mw(d,bb.Nf,m))throw a.F&&(bb=ut(Q(),"| ",a.r)+("OK  "+d+" \x3c: ")+bb,ff(gf(),bb+"\n")),new fX(M);if(ey(b,bb.Af)?0:
+!hw(d,bb.Nf,!1,m,!1).b()){bb=bb.Of;if(d instanceof Ku){var Ia=d.vd;if(bb instanceof jw){a:{for(var Ua=bb.Xb;!Ua.b();){var pc=Ua.e();if(pc instanceof nC&&Ia.L(pc)){Ia=!0;break a}Ua=Ua.f()}Ia=!1}if(Ia)return!1}}return d instanceof Ku&&(Ia=d.fc,Ia instanceof L&&(Ia=Ia.k,Ia instanceof Mu&&bb instanceof jw))?!bb.Xb.L(Ia):!0}return!1};var Oa=X.xe;a:for(var Na;;)if(Oa.b()){Na=u();break}else{var Da=Oa.e(),ta=Oa.f();if(!1===!!Ga(Da))Oa=ta;else for(;;){if(ta.b())Na=Oa;else{var Ya=ta.e();if(!1!==!!Ga(Ya)){ta=
+ta.f();continue}Ya=ta;var dc=new z(Oa.e(),u()),ka=Oa.f();for(ta=dc;ka!==Ya;){var ya=new z(ka.e(),u());ta=ta.p=ya;ka=ka.f()}var Sa=Ya.f();for(ka=Sa;!Sa.b();){var xc=Sa.e();if(!1===!!Ga(xc)){for(;ka!==Sa;){var Sb=new z(ka.e(),u());ta=ta.p=Sb;ka=ka.f()}ka=Sa.f()}Sa=Sa.f()}ka.b()||(ta.p=ka);Na=dc}break a}}if(a.F){var uc=ut(Q(),"| ",a.r)+"Possible: "+Na;ff(gf(),uc+"\n")}var Lb=O().c;if(Na===u())var lc=u();else{var Xb=Na.e(),ec=new z(Xb.zf(!1),u());dc=ec;for(var Ab=Na.f();Ab!==u();){var Ob=Ab.e(),fb=new z(Ob.zf(!1),
+u());dc=dc.p=fb;Ab=Ab.f()}lc=ec}var Wa=lw(a);gX(a,Lb,d,lc,Wa,k,l,n,m,"Case",v,x,r,A,h,B,C,D,F,I)}else throw new w(N);}catch(bb){if(bb instanceof Iq){if(h=bb,h.Qg!==M)throw h;}else throw bb;}}
+function eX(a,b,c,d,e,g,h,k,l,m,n,r,v,x,A,B,C){var D=a.qa;if(a.F){var F=ut(Q(),"| ",a.r)+(g.da+". ARGH  "+b+"  \x3c!  ")+c;ff(gf(),F+"\n")}a.r=1+a.r|0;try{a.an=1+a.an|0;YW(a,d,g,l,m,n,r,k,v,x,A);At(tp(),!qB(c));c.Qf.b()||no();var I=Aea(b,g);if(null===I)throw new w(I);var M=I.h(),N=I.j(),P=a.qa;if(a.F){var T=ut(Q(),"| ",a.r)+"DNF DISCHARGE CONSTRAINTS";ff(gf(),T+"\n")}a.r=1+a.r|0;try{for(b=M;!b.b();){var Y=b.e();bX(a,Y.h(),Y.j(),!1,k,d,e,g,h,n,l,m,r,k,v,x,A,B,C);b=b.f()}var Z=void 0}finally{a.r=-1+
+a.r|0}if(dx(new E(P),a.qa)&&a.F){var S=""+ut(Q(),"| ",a.r)+P.n(Z);ff(gf(),S+"\n")}for(;!N.b();){var ea=N.e();if(null!==ea)zea(a,ea.Pf,c,ea.Nf,ea.Of,ea.Af,k,d,e,g,h,n,l,m,r,v,x,A,B,C);else throw new w(ea);N=N.f()}var ia=void 0}finally{a.r=-1+a.r|0}dx(new E(D),a.qa)&&a.F&&(a=""+ut(Q(),"| ",a.r)+D.n(ia),ff(gf(),a+"\n"))}function gX(a,b,c,d,e,g,h,k,l,m,n,r,v,x,A,B,C,D,F,I){a.an=1+a.an|0;YW(a,g,l,n,r,v,x,A,B,C,D);Bea(a,b,c,d,e,g,h,l,k,m,A,x,v,n,r,B,C,D,F,I)}
+function Cea(a,b,c,d){a=a.m().nb(new U(()=>b.GC()));a=new Ef(a,new y(e=>{var g=V(e.q);return NA(e,g,!1)}));return kv(a,new U(()=>c.m())).nb(new U(()=>d.GC()))}function Dea(a,b,c,d,e){b=Cea(b,c,d,e);if(b.s()){if(!b.s())throw nv("empty.reduceLeft");c=!0;for(d=null;b.s();)if(e=b.t(),c)d=e,c=!1;else{var g=V(d.q);d=dv(d,e,g,!1)}b=new L(d)}else b=R();return b.b()?a.ib:b.o()}
+function Eea(a,b,c,d){return a.m().nb(new U(()=>b.GC())).nb(new U(()=>{var e=c.m().nb(new U(()=>d.GC()));return new Ef(e,new y(g=>{var h=V(g.q);return NA(g,h,!1)}))}))}function Fea(a,b,c,d,e){b=Eea(c,d,b,e);if(b.s()){if(!b.s())throw nv("empty.reduceLeft");c=!0;for(d=null;b.s();)if(e=b.t(),c)d=e,c=!1;else{var g=V(d.q);d=Pu(d,e,g,!1)}b=new L(d)}else b=R();return b.b()?a.La:b.o()}
+function Bea(a,b,c,d,e,g,h,k,l,m,n,r,v,x,A,B,C,D,F,I){var M=tc();try{Lx(a,new U(()=>k.da+". A  "+c+"  %  "+b+"  \x3c!  "+d+"  %  "+e),new U(()=>{var P=G(new H,b,d);a:{var T=P.y;if(T instanceof z){var Y=T.z,Z=T.p;if(Y instanceof lx){bX(a,Y,Dea(a,Z,c,d,e),ow(c)&&Z.ul(new y(Re=>JA(Re,k))),n,g,h,k,l,v,x,A,r,n,B,C,D,F,I);break a}}var S=P.w;if(S instanceof z){var ea=S.z,ia=S.p;if(ea instanceof lx){bX(a,Fea(a,ia,b,c,e),ea,Gw(e)&&ia.ul(new y(Re=>Kv(Re,k))),n,g,h,k,l,v,x,A,r,n,B,C,D,F,I);break a}}var X=P.y;
+if(X instanceof z){var sa=X.z,Ja=X.p;if(sa instanceof cC){gX(a,new z(sa.Sf,Ja),c,d,e,g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break a}}var Xa=P.w;if(Xa instanceof z){var Fa=Xa.z,za=Xa.p;if(Fa instanceof cC){gX(a,b,c,new z(Fa.Fg,za),e,g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break a}}var Qa=P.y;if(Qa instanceof z){var Ma=Qa.z,Ga=Qa.p;if(Ma instanceof LA){var ab=Ma.ic,Hb=Ma.jc;if(!0===Ma.tc){$W(a,"1",new y(Re=>{gX(a,new z(ab,Ga),c,d,e,g,h,l,k,Re,x,A,v,r,n,B,C,D,F,I)}),m);$W(a,"2",new y(Re=>{gX(a,new z(Hb,Ga),c,d,e,g,h,
+l,k,Re,x,A,v,r,n,B,C,D,F,I)}),m);break a}}}var bc=P.w;if(bc instanceof z){var yb=bc.z,tb=bc.p;if(yb instanceof LA){var eb=yb.ic,kb=yb.jc;if(!1===yb.tc){$W(a,"1",new y(Re=>{gX(a,b,c,new z(eb,tb),e,g,h,l,k,Re,x,A,v,r,n,B,C,D,F,I)}),m);$W(a,"2",new y(Re=>{gX(a,b,c,new z(kb,tb),e,g,h,l,k,Re,x,A,v,r,n,B,C,D,F,I)}),m);break a}}}var Rb=P.w;if(Rb instanceof z){var Gb=Rb.z,vb=Rb.p;if(Gb instanceof LA){var Tb=Gb.ic,Nb=Gb.jc;if(!0===Gb.tc){gX(a,b,c,new z(Tb,new z(Nb,vb)),e,g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break a}}}var ic=
+P.y;if(ic instanceof z){var Va=ic.z,cb=ic.p;if(Va instanceof LA){var zb=Va.ic,Ub=Va.jc;if(!1===Va.tc){gX(a,new z(zb,new z(Ub,cb)),c,d,e,g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break a}}}var jb=P.y;if(jb instanceof z){var db=jb.z,ub=jb.p;if(db instanceof ZB){$B(a);t();var Aa=db.mc(),va=new L(Aa);if(!va.b()){gX(a,new z(va.k,ub),c,d,e,g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break a}}}var Ra=P.w;if(Ra instanceof z){var rb=Ra.z,xb=Ra.p;if(rb instanceof ZB){$B(a);t();var mc=rb.mc(),Ha=new L(mc);if(!Ha.b()){gX(a,b,c,new z(Ha.k,
+xb),e,g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break a}}}var Ka=P.y;if(Ka instanceof z){var Oa=Ka.z,Na=Ka.p;if(Oa instanceof MA){gX(a,Na,c,new z(Oa.Fc,d),e,g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break a}}var Da=P.w;if(Da instanceof z){var ta=Da.z,Ya=Da.p;if(ta instanceof MA){gX(a,new z(ta.Fc,b),c,Ya,e,g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break a}}var dc=P.y;if(dc instanceof z){var ka=dc.z;if(ka instanceof FA&&!0===ka.Eh)break a}var ya=P.w;if(ya instanceof z){var Sa=ya.z;if(Sa instanceof FA&&!1===Sa.Eh)break a}var xc=P.y,
+Sb=P.w;if(xc instanceof z){var uc=xc.z,Lb=xc.p;if(uc instanceof FA&&!1===uc.Eh){gX(a,Lb,c,Sb,e,g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break a}}var lc=P.y,Xb=P.w;if(Xb instanceof z){var ec=Xb.z,Ab=Xb.p;if(ec instanceof FA&&!0===ec.Eh){gX(a,lc,c,Ab,e,g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break a}}var Ob=P.y,fb=P.w;if(Ob instanceof z){var Wa=Ob.z,bb=Ob.p;if(Wa instanceof fw){var Ia=Zv(c,Wa,!0,k,!1),Ua=new U(()=>{throw new fX(M,(Nx(a,new U(()=>"OK  "+c+" \x26 "+Wa+"  \x3d:\x3d  "+a.ib)),void 0));});gX(a,bb,Ia.b()?Es(Ua):
+Ia.o(),fb,e,g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break a}}var pc=P.y,sc=P.w;if(sc instanceof z){var Ba=sc.z,ob=sc.p;if(Ba instanceof fw){var nc=ww(e,Ba,!1,k),Ib=new U(()=>{throw new fX(M,(Nx(a,new U(()=>"OK  "+e+" \x26 "+Ba+"  \x3d:\x3d  "+a.La)),void 0));});gX(a,pc,c,ob,nc.b()?Es(Ib):nc.o(),g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break a}}var vc=P.y,Vb=P.w;if(vc instanceof z){var fc=vc.z,Bc=vc.p;if(fc instanceof hX){var Pb=yv(c,fc,!0,k,!0),Jb=new U(()=>{throw new fX(M,(Nx(a,new U(()=>"OK  "+c+" \x26 "+fc+"  \x3d:\x3d  "+
+a.ib)),void 0));});gX(a,Bc,Pb.b()?Es(Jb):Pb.o(),Vb,e,g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break a}}var gc=P.y,Cb=P.w;if(Cb instanceof z){var cc=Cb.z,yc=Cb.p;if(cc instanceof hX){var Mc=zw(e,cc),qc=new U(()=>{throw new fX(M,(Nx(a,new U(()=>"OK  "+e+" | "+cc+"  \x3d:\x3d  "+a.La)),void 0));});gX(a,gc,c,yc,Mc.b()?Es(qc):Mc.o(),g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break a}}var oc=P.y,Qc=P.w;if(oc instanceof z){var jc=oc.z,sb=oc.p;if(jc instanceof Qv){gX(a,sb,Xv(c,jc),Qc,e,g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break a}}var Gc=
+P.w;if(Gc instanceof z){var Wb=Gc.z;if(Wb instanceof Qv){var Cc=Wb.Ba,Fc=O().c;if(null===Fc?null===Cc:Fc.i(Cc))break a}}var qd=P.y,Yb=P.w;if(Yb instanceof z){var Nc=Yb.z,ad=Yb.p;if(Nc instanceof Qv){var Uc=Nc.Ba;if(Uc instanceof z){var cd=Uc.z,kc=Uc.p,Vc=O().c;if(null===Vc?null===kc:Vc.i(kc)){var Hc=Aw(e,cd),rc=new U(()=>{throw new fX(M,(Nx(a,new U(()=>"OK  "+e+" | "+cd+"  \x3d:\x3d  "+a.La)),void 0));});gX(a,qd,c,ad,Hc.b()?Es(rc):Hc.o(),g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break a}}}}var sd=P.y,Kc=P.w;
+if(Kc instanceof z){var Qd=Kc.z,Ad=Kc.p;if(Qd instanceof Qv){var kd=Gea(Qd);gX(a,sd,c,new z(kd,Ad),e,g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break a}}var Hd=P.w;if(Hd instanceof z&&Hd.z instanceof Qx)var Rd=!0;else{var Bd=P.y;Rd=Bd instanceof z&&Bd.z instanceof Qx?!0:!1}Rd&&xm("Program reached and unexpected state.");var ae=P.w;if(ae instanceof z&&ae.z instanceof eC)var dd=!0;else{var od=P.y;dd=od instanceof z&&od.z instanceof eC?!0:!1}dd&&xm("Program reached and unexpected state.");var Ta=P.y,wb=P.w,$a=O().c;
+if(null===$a?null===Ta:$a.i(Ta))var wa=O().c,hb=null===wa?null===wb:wa.i(wb);else hb=!1;if(hb){var ra=G(new H,c,e);b:{var wc=ra.y,ac=ra.w;if(wc instanceof Ku){var Id=wc.fc;if(Id instanceof L){var ud=Id.k;if(ud instanceof Tv){var be=ud.Ic;if(lw(a)===ac){bX(a,be,a.ib,!0,n,g,h,k,l,v,x,A,r,n,B,C,D,F,I);break b}}}}c:{var re=ra.y;if(Vu(a)===re)var pe=!0;else{var bd=ra.y;if(bd instanceof Ku){var Rc=bd.fc,Wc=bd.vd,Wd=bd.be,zd=bd.Me;if(t().d===Rc&&null!==Wc&&Wc.b()&&null!==Wd){var Pa=Wd.Ba,Db=O().c;if((null===
+Db?null===Pa:Db.i(Pa))&&null!==zd&&zd.b()){pe=!0;break c}}}pe=!1}}if(pe)iX(a,t().d,g,k,r,n);else{var Oc=ra.y,Tc=ra.w;if(Oc instanceof Ku){var Sd=Oc.vd;if(Tc instanceof jw){var Jc=Tc.Xb;if(ey(Sd,new y(Re=>Jc.L(Re))))break b}}var vd=ra.y;if(vd instanceof Ku){var hd=vd.fc,de=vd.vd,ye=vd.be,jf=vd.Me;if(!jf.b()){var af=new Ou(jf),pf=new Ef(af,new y(Re=>cD(Re,k,n)));Od();var kf=Pd(u(),pf),Be=sv(),Kd=Su(),ld=op().ga;gX(a,kf,new Ku(a,hd,de,ye,Be.Hd(new Uu(Kd,ld))),O().c,e,g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break b}}var Jd=
+ra.w;if(Jd instanceof jw){var Dd=Jd.Xb,Xd=Jd.mb,Yc=Jd.Dc;if(!Yc.b()){var Ce=O().c,te=new Ou(Yc),Ie=new Ef(te,new y(Re=>cD(Re,k,n)));Od();var Jf=Pd(u(),Ie),df=sv(),vg=Su(),wg=op().ga;gX(a,Ce,c,Jf,new jw(a,Dd,Xd,df.Hd(new Uu(vg,wg))),g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break b}}var xg=ra.w;if(xg instanceof jw){var eg=xg.Xb,vh=xg.mb,fg=xg.Dc;if(vh instanceof L){var ih=vh.k;if(ih instanceof fe){var Ig=ih.aa;if(Ig instanceof Jv){for(var Tf=new y(Re=>{var rj=O().c,ai=O().c;t();t();gX(a,rj,c,ai,new jw(a,eg,new L(new fe(Re)),
+fg),g,h,l,k,m,x,A,v,r,n,B,C,D,F,I)}),Jg=Ig.gi;!Jg.b();)Tf.n(Jg.e()),Jg=Jg.f();break b}}}}var jh=ra.y;jh instanceof Ku&&(jh.Me.b()||xm("Program reached and unexpected state."));var yg=ra.w;yg instanceof jw&&(yg.Dc.b()||xm("Program reached and unexpected state."));c:{var gg=ra.w;if(lw(a)===gg)var Cf=!0;else{var Uf=ra.w;if(Uf instanceof jw){var $g=Uf.Xb,Ah=Uf.mb,Kg=O().c;if((null===Kg?null===$g:Kg.i($g))&&t().d===Ah){Cf=!0;break c}}Cf=!1}}if(Cf)iX(a,t().d,g,k,r,n);else{var Vf=ra.y,hg=ra.w;if(Vf instanceof
+Ku){var zg=Vf.fc;if(zg instanceof L){var Lg=zg.k;if(Lg instanceof cv&&hg instanceof jw){var Mg=hg.mb;if(Mg instanceof L){var Wf=Mg.k;if(Wf instanceof fe){var Ng=Wf.aa;if(Ng instanceof cv){bX(a,Lg,Ng,!0,n,g,h,k,l,v,x,A,r,n,B,C,D,F,I);break b}}}}}}var Kf=ra.y,xf=ra.w;if(Kf instanceof Ku){var Og=Kf.fc,mi=Kf.vd,Ci=Kf.be,Xh=Kf.Me;if(Og instanceof L&&Og.k instanceof cv&&xf instanceof jw){gX(a,O().c,new Ku(a,t().d,mi,Ci,Xh),O().c,e,g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break b}}var wh=ra.y,Bh=ra.w;if(wh instanceof
+Ku){var ng=wh.fc;if(ng instanceof L&&ng.k instanceof Mu&&Bh instanceof jw&&Yca(new E(a.lP),Bh.Xb)){Nx(a,new U(()=>"OK ~ magic Eql ~"));break b}}var kh=ra.y,Kh=ra.w;if(kh instanceof Ku){var ni=kh.fc;if(ni instanceof L){var Lh=ni.k;if(Lh instanceof Mu){var lh=Lh.pd;if(lh instanceof Dl&&Kh instanceof jw){var Ch=Kh.mb;if(Ch instanceof L){var Dh=Ch.k;if(Dh instanceof Ud){var Yh=Dh.fa;if(null!==Yh){var ah=Yh.me,oi=Yh.Ne;if(null!==ah&&"Eql#A"===ah.x){if(lh instanceof Em||lh instanceof Fm){var mj=oi.Oa,wd=
+new U(()=>a.La);bX(a,mj.b()?Es(wd):mj.o(),a.Ak,!1,n,g,h,k,l,v,x,A,r,n,B,C,D,F,I)}else if(lh instanceof Dm){var ge=oi.Oa,De=new U(()=>a.La);bX(a,ge.b()?Es(De):ge.o(),a.Qj,!1,n,g,h,k,l,v,x,A,r,n,B,C,D,F,I)}else if(lh instanceof Gm)iX(a,t().d,g,k,r,n);else throw new w(lh);break b}}}}}}}}var qf=ra.y,og=ra.w;if(qf instanceof Ku){var Xf=qf.fc,mh=qf.vd,Ag=qf.be;if(Xf instanceof L){var Bg=Xf.k;if(Bg instanceof Mu){var Eh=Bg.pd;if(Eh instanceof vl){var Pg=Eh.x;if(og instanceof jw){var Di=og.mb;if(Di instanceof
+L){var Mh=Di.k;if(Mh instanceof Ud){var pi=Mh.fa;if(null!==pi){var Xi=pi.me,Qg=pi.Ne;if(k.$a.L(Pg)){if(a.$c&&Nm(new E(Pg),"Eql")&&"Eql#A"===Xi.x){var nh=k.$a.n(Pg);if(px(nh).b()&&!a.cn.L(Pg)){var bh=new Te(new Ue(J(new K,[""," '","' does not support equality comparison because it does not have a parameter list"])));Xe();Q();var Mj=nh.Ab.fd().ld,Nj=We(0,Nu(0,Mj));Xe();var ie=[Nj,We(0,nh.Ab.Cf.x)];Lw(a,Ye(bh,J(new K,ie)),r.Ga,n)}for(var Ac=px(nh),Ve=new U(()=>O().c),Td=Ac.b()?Es(Ve):Ac.o(),lf=new y(Re=>
+{var rj=new U(()=>c.zf(!0));t();var ai=new L(Pg),rm=Ag.Ba;op();var Nn=pp(qp(),rm);ai=jX(a,rj,ai,new y(Au=>Nn.U(Au)),mh,Re.h(),k,n);rj=Qg.Oa;rm=new U(()=>{xm("Program reached and unexpected state.")});rj=rj.b()?Es(rm):rj.o();Re=Re.h();rm=new Ep("Eql");ai=ai.ra;var zu=O().c;ai=new fw(a,rm,new z(ai,zu),V(a));rm=V(a);ai=new Uw(ai.q,R(),ai,rm);Re=G(new H,Re,ai);ai=O().c;bX(a,rj,new Qv(a,new z(Re,ai),V(a)),!1,n,g,h,k,l,v,x,A,r,n,B,C,D,F,I)}),Yi=Td;!Yi.b();)lf.n(Yi.e()),Yi=Yi.f()}else{var Jl=new U(()=>c.zf(!0));
+t();var ll=new L(Pg),Bj=Ag.Ba;op();var $k=pp(qp(),Bj),Zh=jX(a,Jl,ll,new y(Re=>$k.U(Re)),mh,Xi,k,n);bX(a,Zh.ra,Qg.ra,!1,n,g,h,k,l,v,x,A,r,n,B,C,D,F,I);kX(a,Qg,Zh,n,g,h,k,l,v,r,n,x,A,B,C,D,F,I)}break b}}}}}}}}}var Ei=ra.y,Yd=ra.w;if(Ei instanceof Ku){var bf=Ei.fc,rf=Ei.vd,Cg=Ei.be,nj=Ei.Me;if(bf instanceof L){var Jh=bf.k;if(Jh instanceof Mu&&Yd instanceof jw){var If=Yd.Xb,Hg=Yd.mb,He=Yd.Dc;Nx(a,new U(()=>"class checking "+Jh+" "+If));If.qo(new y(Re=>Pe(new E(Re.uo()),Jh.pd)?!0:(Ei.rE?Ei.qE:kw(Ei)).L(Re.uo())))?
+Nx(a,new U(()=>"OK  "+Jh+"  \x3c:  "+ze(If,""," | ",""))):gX(a,O().c,new Ku(a,t().d,rf,Cg,nj),O().c,new jw(a,O().c,Hg,He),g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);void 0;break b}}}var lj=ra.y,Wi=ra.w;if(lj instanceof Ku&&Wi instanceof iw){var Oj=O().c,mo=O().c,mm=O().c;t();t();var nm=new L(new Ud(Wi)),dq=sv(),Zd=Su(),sf=op().ga;gX(a,Oj,lj,mo,new jw(a,mm,nm,dq.Hd(new Uu(Zd,sf))),g,h,l,k,m,x,A,v,r,n,B,C,D,F,I)}else{var oj=ra.y,al=ra.w;if(oj instanceof Ku){var Ll=oj.fc,Qm=oj.vd,Rm=oj.be;if(t().d===Ll&&al instanceof
+jw){var hq=al.mb;if(hq instanceof L){var Bn=hq.k;if(Bn instanceof Ud){var hp=Bn.fa;if(null!==hp){var ru=hp.me,qr=hp.Ne;if(a.$c){var Xs=new U(()=>c.zf(!0)),rr=t().d,iq=Rm.Ba;op();var qo=pp(qp(),iq),qm=jX(a,Xs,rr,new y(Re=>qo.U(Re)),Qm,ru,k,n);bX(a,qm.ra,qr.ra,!1,n,g,h,k,l,v,x,A,r,n,B,C,D,F,I);kX(a,qr,qm,n,g,h,k,l,v,r,n,x,A,B,C,D,F,I);break b}}}}}}var jq=ra.y,pl=ra.w;if(jq instanceof Ku){var ro=jq.fc,Cn=jq.be;if(pl instanceof jw){var ip=pl.Xb,so=pl.mb,Dn=pl.Dc;if(so instanceof L){var sr=so.k;if(sr instanceof
+Ud){var kq=sr.fa;if(null!==kq){var ql=kq.me,Ys=kq.Ne,Sm=lX(Cn.Ba,new y(Re=>Pe(new E(Re.h()),ql)));if(Sm instanceof L){var Nl=Sm.k;kX(a,Ys,Nl.j(),n,g,h,k,l,v,r,n,x,A,B,C,D,F,I);bX(a,Nl.j().ra,Ys.ra,!1,n,g,h,k,l,v,x,A,r,n,B,C,D,F,I)}else if(t().d===Sm)c:{if(ro instanceof L){var jp=ro.k;if(jp instanceof Tv){var lq=jp.Ic;if(jp.kf.L(ql)){var mq=new jw(a,ip,t().d,Dn);bX(a,lq,mq.zf(!1),!0,n,g,h,k,l,v,x,A,r,n,B,C,D,F,I)}else bX(a,lq,e.zf(!1),!0,n,g,h,k,l,v,x,A,r,n,B,C,D,F,I);break c}}iX(a,t().d,g,k,r,n)}else throw new w(Sm);
+break b}}}}}var Tm=ra.y,En=ra.w;if(Tm instanceof Ku){var to=Tm.fc,Fn=Tm.vd;if(t().d===to&&En instanceof jw){var nq=En.Xb,Um=En.mb;if(t().d===Um){Nx(a,new U(()=>"Tag checking "+Fn+" "+nq));nq.qo(new y(Re=>{var rj=Fn.m();rj=new xo(rj,new y(ai=>{if(ai instanceof nC){var rm=ai.rp;ai=ai.JI;ai=Qt((Od(),Pd(u(),ai)),new y(Nn=>new vl(Nn.V)));return new z(rm,ai)}return O().c}));return tea(rj,Re.uo())}))?Nx(a,new U(()=>"OK "+Fn+" \x3c: "+nq)):iX(a,t().d,g,k,r,n);void 0;break b}}}var kp=ra.y,oq=ra.w;if(kp instanceof
+Ku){var su=kp.fc;if(t().d===su&&oq instanceof jw){var Gn=oq.mb;if(Gn instanceof L){var ur=Gn.k;if(ur instanceof fe&&(ur.aa instanceof cv||ur.aa instanceof Vv)){iX(a,t().d,g,k,r,n);break b}}}}var In=ra.y,Zs=ra.w;if(In instanceof Ku){var $s=In.fc;if($s instanceof L){var pq=$s.k;if(pq instanceof zv&&Zs instanceof jw){var vr=Zs.mb;if(vr instanceof L){var Vm=vr.k;if(Vm instanceof fe){var Jn=Vm.aa;if(Jn instanceof zv){var wr=pq.Yb.K();if(Pe(new E(wr),Jn.Yb.K())){var at=pq.Yb,xr=op(),lp=at.Gb(xr.ga).j(),
+Kn=Jn.Yb,qq=op(),yr=Kn.Gb(qq.ga).j();pH(new Wq(lp,lp,yr),new fn((Re,rj)=>{bX(a,Re.ra,rj.ra,!1,n,g,h,k,l,v,x,A,r,n,B,C,D,F,I);kX(a,rj,Re,n,g,h,k,l,v,r,n,x,A,B,C,D,F,I)}));break b}}}}}}}var rq=ra.y,sq=ra.w;if(rq instanceof Ku){var bt=rq.fc;if(bt instanceof L){var tq=bt.k;if(tq instanceof Vv&&sq instanceof jw){var zr=sq.mb;if(zr instanceof L){var ct=zr.k;if(ct instanceof fe){var Ar=ct.aa;if(Ar instanceof Sv){kX(a,Ar.Fd,tq.Zj(),n,g,h,k,l,v,r,n,x,A,B,C,D,F,I);bX(a,tq.Zj().ra,Ar.Fd.ra,!1,n,g,h,k,l,v,x,
+A,r,n,B,C,D,F,I);break b}}}}}}var uq=ra.y;if(uq instanceof Ku){var Br=uq.fc;if(Br instanceof L&&Br.k instanceof Vv){iX(a,t().d,g,k,r,n);break b}}var Ln=ra.y;if(Ln instanceof Ku){var vq=Ln.fc,Cr=Ln.vd,tu=Ln.be,uu=Ln.Me;if(vq instanceof L){var dt=vq.k;if(dt instanceof Jv){var vu=O().c;t();var Dr=mX(dt);gX(a,vu,new Ku(a,new L(Dr),Cr,tu,uu),O().c,e,g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break b}}}var uo=ra.y,Er=ra.w;if(uo instanceof Ku){var et=uo.fc;if(et instanceof L){var ft=et.k;if(ft instanceof Tv){var gt=
+ft.Ic;if(Er instanceof jw){var Wm=Er.mb;var Fr=t().d===Wm?!0:Wm instanceof L&&Wm.k instanceof fe?!0:!1;if(Fr){bX(a,gt,e.zf(!1),!0,n,g,h,k,l,v,x,A,r,n,B,C,D,F,I);break b}}}}}var mp=ra.w;if(mp instanceof jw){var wu=mp.Xb,ht=mp.mb;if(ht instanceof L){var wq=ht.k;if(wq instanceof fe){var xq=wq.aa;if(xq instanceof Tv){var Gr=xq.Ic,xu=Qt(wu,new y(Re=>{var rj=V(Re.q);return NA(Re,rj,!1)})),yu=O().c;gX(a,xu,c,new z(Gr,yu),lw(a),g,h,l,k,m,x,A,v,r,n,B,C,D,F,I);break b}}}}throw new w(ra);}}}}}else throw new w(P);
+}}),a.qa)}catch(P){if(P instanceof Iq){var N=P;if(N.Qg!==M)throw N;}else throw P;}}
+function kX(a,b,c,d,e,g,h,k,l,m,n,r,v,x,A,B,C,D){var F=G(new H,b.Oa,c.Oa);a:{var I=F.y,M=F.w;if(I instanceof L&&(I=I.k,M instanceof L)){bX(a,I,M.k,!1,d,e,g,h,k,l,r,v,m,n,x,A,B,C,D);break a}d=F.y;e=F.w;if(d instanceof L&&(d=d.k,R()===e)){Nx(a,new U(()=>"RHS not mutable! in "+b+" \x3c- "+c));b.Pd.Ga.b()||c.Pd.Ga.b()?(t(),F=Ye(new Te(new Ue(J(new K,["cannot be reassigned"]))),u()),F=new L(F)):(t(),F=Ye(new Te(new Ue(J(new K,["is not mutable"]))),u()),F=new L(F));e=c.ra;e=ux(e.q,e,c.Pd);g=ux(d.q,d,b.Pd);
+k=O().c;e=new z(e,new z(g,k));g=V(a);d=ux(d.q,d,g);g=O().c;iX(a,F,G(new H,e,new z(d,g)),h,m,n);break a}a=F.y;h=F.w;R()===a&&h instanceof L?a=!0:(a=F.y,h=F.w,a=R()===a&&R()===h?!0:!1);if(!a)throw new w(F);}}
+function nX(a,b,c,d,e,g,h,k,l,m,n,r,v,x,A,B,C,D,F,I,M){var N=xA(b,!0),P=Xu().X(),T=Hw(),Y=Su(),Z=op().ga;b=xea(a,b,c,d,e,m,P,T.Hd(new Uu(Y,Z)),g);N=xA(b,!0).wy(N);if(!N.b()){d=a.qa;a.F&&(e=ut(Q(),"| ",a.r)+"RECONSTRAINING TVs",ff(gf(),e+"\n"));a.r=1+a.r|0;try{N.Ca(new y(ea=>{a:{if(null!==ea&&(iC(a),!ea.Sb.b())){a.F&&(ea=ut(Q(),"| ",a.r)+"No need to reconstrain assigned "+ea,ff(gf(),ea+"\n"));break a}if(a.F){var ia=ut(Q(),"| ",a.r)+"Reconstraining "+ea;ff(gf(),ia+"\n")}if(ea.Xa>c)for(ia=vy(ea);!ia.b();){for(var X=
+ia.e(),sa=rA(ea);!sa.b();){var Ja=sa.e();bX(a,X,Ja,!1,h,k,l,m,n,r,v,x,A,B,C,D,F,I,M);sa=sa.f()}ia=ia.f()}}}));var S=void 0}finally{a.r=-1+a.r|0}dx(new E(d),a.qa)&&a.F&&(S=""+ut(Q(),"| ",a.r)+d.n(S),ff(gf(),S+"\n"))}return b}
+function bX(a,b,c,d,e,g,h,k,l,m,n,r,v,x,A,B,C,D,F){a.Ep=1+a.Ep|0;var I=G(new H,b,c);Hea(m,I);YW(a,g,k,n,r,m,v,x,A,B,C);if(d){I=g.h().Jg();var M=new y(P=>Ot(new E(P),b));I=!I.b()&&M.n(I.o())?g.h():new z(b,g.h());M=g.j().Jg();var N=new y(P=>Ot(new E(P),c));M=!M.b()&&N.n(M.o())?g.j():new z(c,g.j());I=G(new H,I,M)}else I=O().c,I=new z(b,I),M=O().c,I=G(new H,I,new z(c,M));g=d||h.b()?h:new z(g,h);d||(d=ap(),l=new QN(l.QC,d,l.tu));Iea(a,b,c,e,I,g,k,l,D,v,m,n,r,x,A,B,C,F);wU(m)}
+function Iea(a,b,c,d,e,g,h,k,l,m,n,r,v,x,A,B,C,D){var F=tc();try{Lx(a,new U(()=>h.da+". C "+b+" \x3c! "+c+"    ("+k.ka()+")"),new U(()=>{var M=Xu().X();if(Zu(b,c,h,!1,M))Nx(a,new U(()=>"Already a subtype by \x3c:\x3c"));else{var N=G(new H,b,c);if(N.y instanceof OA||N.w instanceof OA)M=k;else{if(!a.ZE&&l.L(N))throw new fX(F,(Nx(a,new U(()=>"Cached!")),void 0));M=jD(b);var P=jD(c);P=G(new H,M,P);if(k.su.L(N))throw new fX(F,(Nx(a,new U(()=>"Spurious cycle involving "+N)),void 0));if(!a.pP&&k.tu.L(P)&&
+!k.su.L(P)){Nx(a,new U(()=>"SHADOWING DETECTED!"));M=new oX(a);if(!Vr(new Wr(M),N).L(!0)){M=new Te(new Ue(J(new K,["Cyclic-looking constraint while typing ","; a type annotation may be required"])));var T=[We(Xe(),m.lh)];M=Ye(M,J(new K,T));M=G(new H,M,m.Ga);if(a.zA){T=Ye(new Te(new Ue(J(new K,["\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014 Additional debugging info: \u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014"]))),u());var Y=t().d;T=G(new H,T,Y);Y=new Te(new Ue(J(new K,["this constraint:  ",
+"  \x3c:  ","    ","  ",""])));var Z=[We(Xe(),b.u()),We(Xe(),c.u()),We(Xe(),ag(ca(b))),We(Xe(),ag(ca(c)))];Y=Ye(Y,J(new K,Z));Z=t().d;Y=G(new H,Y,Z);Z=new Te(new Ue(J(new K,[" ... looks like:  ","  \x3c:  ",""])));P=[We(Xe(),nb(P.y)),We(Xe(),nb(P.w))];P=Ye(Z,J(new K,P));Z=t().d;P=G(new H,P,Z);Z=O().c;P=new z(T,new z(Y,new z(P,Z)))}else P=Ye(new Te(new Ue(J(new K,["Note: use flag `:ex` to see internal error info."]))),u()),T=t().d,P=G(new H,P,T),T=O().c,P=new z(P,T);ay(a,new z(M,P),d)}throw new fX(F);
+}a.ZE||l.$(N);M=k.su.bc(N).bc(P);M=new QN(a,M,k.tu.bc(P))}(new y(S=>{a:{var ea=N.y;if(!(ea instanceof FA&&!0===ea.Eh)){var ia=N.w;b:if(ia instanceof FA&&!1===ia.Eh)var X=!0;else{if(ia instanceof Qv){var sa=ia.Ba,Ja=O().c;if(null===Ja?null===sa:Ja.i(sa)){X=!0;break b}}X=!1}if(!X){var Xa=N.y;if(Xa instanceof cC)bX(a,Xa.Sf,c,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);else{var Fa=N.w;if(Fa instanceof cC)bX(a,b,Fa.Fg,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);else{var za=N.y;if(za instanceof OA)bX(a,za.Hi,c,!0,d,e,g,h,
+S,n,r,v,m,x,A,B,C,l,D);else{var Qa=N.w;if(Qa instanceof OA)bX(a,b,Qa.Hi,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);else if(!(Uv(N.y)&&Uv(N.w)&&Pe(new E(b),c))){var Ma=N.y,Ga=N.w;if(Ma instanceof MA){var ab=Ma.Fc;if(Ga instanceof MA){bX(a,Ga.Fc,ab,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);break a}}var Hb=N.y,bc=N.w;if(Hb instanceof Mu){var yb=Hb.pd;if(yb instanceof vl){var tb=yb.x;if(bc instanceof Qv&&a.$c&&hB(ve(),tb)){h.$a.n(tb);for(var eb=new y(wd=>{a:{if(null!==wd){var ge=wd.h(),De=wd.j();if(null!==ge&&"Eql#A"===
+ge.x){ge=G(new H,ge,De);wd=O().c;cX(a,b,new Qv(a,new z(ge,wd),V(a)),e,g,h,S,x,m,D,n,r,v,A,B,C,l);break a}}if(null!==wd){ge=wd.h();wd=wd.j();De=new U(()=>b);t();var qf=new L(tb),og=new y(()=>t().d),Xf=uv(),mh=Su(),Ag=op().ga;ge=jX(a,De,qf,og,Xf.ng(new Uu(mh,Ag)),ge,h,d);bX(a,ge.ra,wd.ra,!1,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);kX(a,wd,ge,d,e,g,h,S,n,m,x,r,v,A,B,C,l,D)}else throw new w(wd);}}),kb=bc.Ba;!kb.b();)eb.n(kb.e()),kb=kb.f();break a}}}var Rb=N.y,Gb=N.w;if(Rb instanceof cv){var vb=Rb.Nb,Tb=Rb.ac;if(Gb instanceof
+cv){var Nb=Gb.ac;bX(a,Gb.Nb,vb,!1,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);bX(a,Tb,Nb,!1,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);break a}}var ic=N.y,Va=N.w;if(!(ic instanceof Mu&&Uv(Va)&&ic.Fv().L(Va.uo()))){var cb=N.y,zb=N.w;if(cb instanceof lx){iC(a);var Ub=cb.Sb;if(!Ub.b()){var jb=Ub.o();bX(a,jb,zb,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);break a}}var db=N.y,ub=N.w;if(ub instanceof lx){iC(a);var Aa=ub.Sb;if(!Aa.b()){var va=Aa.o();bX(a,db,va,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);break a}}var Ra=N.y,rb=N.w;if(Ra instanceof lx&&
+rb.Ea()<=Ra.Xa){Nx(a,new U(()=>"NEW "+Ra+" UB ("+rb.Ea()+")"));var xb=e.h(),mc=dl(Km(e.j()),xb).mf(rb,new fn((wd,ge)=>{var De=wd.ma();return Ot(new E(De),V(a))?ge:ux(a,ge,wd.ma())})),Ha=rA(Ra);KA(Ra,new z(mc,Ha));for(var Ka=vy(Ra),Oa=new y(wd=>{bX(a,wd,rb,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D)}),Na=Ka;!Na.b();)Oa.n(Na.e()),Na=Na.f()}else{var Da=N.y,ta=N.w;if(ta instanceof lx&&Da.Ea()<=ta.Xa){Nx(a,new U(()=>"NEW "+ta+" LB ("+Da.Ea()+")"));var Ya=e.h(),dc=dl(Km(e.j()),Ya),ka=YA(dc,Da,new fn((wd,ge)=>{var De=
+ge.ma();return Ot(new E(De),V(a))?wd:ux(a,wd,ge.ma())})),ya=vy(ta);IA(ta,new z(ka,ya));for(var Sa=rA(ta),xc=new y(wd=>{bX(a,Da,wd,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D)}),Sb=Sa;!Sb.b();)xc.n(Sb.e()),Sb=Sb.f()}else{var uc=N.y,Lb=N.w;if(uc instanceof lx)if(Nx(a,new U(()=>"wrong level: "+Lb.Ea())),a.li&&Lb.Ea()<=h.da){Nx(a,new U(()=>"STASHING "+uc+" bound in extr ctx"));var lc=pX(h.cb,uc,new U(()=>TE(PE()))),Xb=G(new H,!1,Lb);lc.$(Xb);var ec=G(new H,uc,Lb);l.Bm(ec)}else{var Ab=uc.Xa,Ob=a.Df,fb=e.h(),Wa=op(),
+bb=g.Gb(Wa.ga).h(),Ia=op(),Ua=dl(g.Gb(Ia.ga).j(),bb),pc=nX(a,Lb,Ab,!1,Ob,new z(fb,Ua),d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);Nx(a,new U(()=>"EXTR RHS  ~\x3e  "+pc+"  to "+uc.Xa));Nx(a,new U(()=>" where "+xx(pc)));bX(a,uc,pc,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D)}else{var sc=N.y,Ba=N.w;if(Ba instanceof lx)if(Nx(a,new U(()=>"wrong level: "+sc.Ea())),a.li&&sc.Ea()<=h.da){Nx(a,new U(()=>"STASHING "+Ba+" bound in extr ctx"));var ob=pX(h.cb,Ba,new U(()=>TE(PE()))),nc=G(new H,!0,sc);ob.$(nc);var Ib=G(new H,sc,Ba);l.Bm(Ib)}else{var vc=
+Ba.Xa,Vb=a.Df,fc=e.j(),Bc=op(),Pb=g.Gb(Bc.ga).j(),Jb=op(),gc=dl(g.Gb(Jb.ga).h(),Pb),Cb=nX(a,sc,vc,!0,Vb,new z(fc,gc),d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);Nx(a,new U(()=>"EXTR LHS  ~\x3e  "+Cb+"  to "+Ba.Xa));Nx(a,new U(()=>" where "+xx(Cb)));bX(a,Cb,Ba,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D)}else{var cc=N.y,yc=N.w;if(cc instanceof zv){var Mc=cc.Yb;if(yc instanceof zv){var qc=yc.Yb,oc=Mc.K();if(Pe(new E(oc),qc.K())){pH(new Wq(Mc,Mc,qc),new fn((wd,ge)=>{var De=G(new H,wd,ge);a:{ge=De.y;var qf=De.w;if(null!==ge&&
+(wd=ge.h(),ge=ge.j(),null!==qf)){var og=qf.h();De=qf.j();qf=new y(Xf=>{var mh=new y(Ag=>{if(Nm(new E(Xf),Ag)){var Bg=new Te(new Ue(J(new K,["Wrong tuple field name: found '","' instead of '","'"])));Ag=[We(Xe(),Xf.x),We(Xe(),Ag.x)];return Lw(a,Ye(Bg,J(new K,Ag)),b.ma().Ga,d)}});og.b()||mh.n(og.o())});wd.b()||qf.n(wd.o());kX(a,De,ge,d,e,g,h,S,n,m,x,r,v,A,B,C,l,D);bX(a,ge.ra,De.ra,!1,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);break a}throw new w(De);}}));break a}}}var Qc=N.y,jc=N.w;if(Qc instanceof Vv&&jc instanceof
+Sv)kX(a,jc.Fd,Qc.Zj(),d,e,g,h,S,n,m,x,r,v,A,B,C,l,D),bX(a,Qc.Zj().ra,jc.Fd.ra,!1,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);else{var sb=N.y;if(sb instanceof LA){var Gc=sb.ic,Wb=sb.jc;if(!0===sb.tc){bX(a,Gc,c,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);bX(a,Wb,c,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);break a}}var Cc=N.w;if(Cc instanceof LA){var Fc=Cc.ic,qd=Cc.jc;if(!1===Cc.tc){bX(a,b,Fc,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);bX(a,b,qd,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);break a}}var Yb=N.y;if(Yb instanceof ZB){$B(a);t();var Nc=Yb.mc(),
+ad=new L(Nc);if(!ad.b()){bX(a,ad.k,c,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);break a}}var Uc=N.w;if(Uc instanceof ZB){$B(a);t();var cd=Uc.mc(),kc=new L(cd);if(!kc.b()){bX(a,b,kc.k,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);break a}}var Vc=N.w;if(Vc instanceof zv){var Hc=Vc.Yb;if(Hc instanceof z){var rc=Hc.p,sd=O().c;null===sd||sd.i(rc)}}var Kc=N.y,Qd=N.w;if(Kc instanceof Mu){var Ad=Kc.pd,kd=a.Bk;if((null===kd?null===Ad:kd.i(Ad))&&Qd instanceof cv){var Hd=Qd.ac;bX(a,Qd.Nb,Kc,!1,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);bX(a,
+Kc,Hd,!1,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);break a}}var Rd=N.y,Bd=N.w;if(Rd instanceof cv){var ae=Rd.Nb,dd=Rd.ac;if(Bd instanceof Mu){var od=Bd.pd,Ta=a.Bk;if(null===Ta?null===od:Ta.i(od)){bX(a,Bd,ae,!1,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);bX(a,dd,Bd,!1,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);break a}}}var wb=N.y,$a=N.w;if(wb instanceof Qv){var wa=wb.Ba;if($a instanceof Qv){for(var hb=new y(wd=>{if(null!==wd){var ge=wd.h(),De=wd.j();wd=lX(wa,new y(Xf=>Pe(new E(Xf.h()),ge)));var qf=new U(()=>{iX(a,t().d,e,h,m,x)}),og=
+new y(Xf=>{if(null!==Xf)Xf=Xf.j(),kX(a,De,Xf,d,e,g,h,S,n,m,x,r,v,A,B,C,l,D),bX(a,Xf.ra,De.ra,!1,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);else throw new w(Xf);});wd.b()?Es(qf):og.n(wd.o())}else throw new w(wd);}),ra=$a.Ba;!ra.b();)hb.n(ra.e()),ra=ra.f();break a}}var wc=N.y;if(wc instanceof zv&&N.w instanceof Qv)bX(a,wc.kq(),c,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);else{var ac=N.y,Id=N.w;if(ac instanceof Mu){var ud=ac.pd,be=a.Bk;if((null===be?null===ud:be.i(ud))&&Id instanceof Qv){for(var re=new y(wd=>{bX(a,ac,wd.j().ra,
+!1,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D)}),pe=Id.Ba;!pe.b();)re.n(pe.e()),pe=pe.f();break a}}if(N.w instanceof Qv)cX(a,b,c,e,g,h,S,x,m,D,n,r,v,A,B,C,l);else{var bd=N.y,Rc=N.w;if(bd instanceof Qv){var Wc=bd.Ba;if(Rc instanceof Mu){var Wd=Rc.pd,zd=a.Bk;if(null===zd?null===Wd:zd.i(Wd)){for(var Pa=new y(wd=>{bX(a,wd.j().ra,Rc,!1,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D)}),Db=Wc;!Db.b();)Pa.n(Db.e()),Db=Db.f();break a}}}var Oc=N.y,Tc=N.w;if(Oc instanceof fw&&Tc instanceof fw&&Nm(new E(Oc.qb.V),"Array")&&Nm(new E(Tc.qb.V),
+"Eql"))if(Pe(new E(Oc.qb),Tc.qb)){tp();var Sd=jv(Oc.Zb,Tc.Zb);up(0,Pe(new E(Sd),0));var Jc=h.tb.U(Oc.qb.V);if(Jc instanceof L){var vd=Jc.k,hd=dB(vd),de=vd.Xm,ye=op(),jf=de.Gb(ye.ga).j();rH(qD(new Wq(jf,jf,Oc.Zb),Tc.Zb),new fW((wd,ge,De)=>{wd=hd.n(wd);wd.qe||bX(a,ge,De,!1,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);wd.Qd||bX(a,De,ge,!1,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D)}))}else if(t().d===Jc){var af=h.$a.U(Oc.qb.V);if(af instanceof L){var pf=af.k,kf=Qt(pf.Ag(),new y(wd=>wd.hb));rH(qD(new Wq(kf,kf,Oc.Zb),Tc.Zb),new fW((wd,
+ge,De)=>{wd=VD(pf).U(wd);wd=wd.b()?ou().Yl:wd.o();wd.qe||bX(a,ge,De,!1,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);wd.Qd||bX(a,De,ge,!1,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D)}))}else if(t().d===af)no();else throw new w(af);}else throw new w(Jc);}else if(Lca(Oc,h))bX(a,cD(Oc,h,d),cD(Tc,h,d),!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);else{var Be=G(new H,gw(Oc,h),gw(Tc,h));b:{var Kd=Be.y,ld=Be.w;if(Kd instanceof L){var Jd=Kd.k;if(ld instanceof L){var Dd=ld.k,Xd=Xu().X();if(!Zu(Jd,Dd,h,!0,Xd)){iX(a,t().d,e,h,m,x);break b}}}bX(a,cD(Oc,
+h,d),cD(Tc,h,d),!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D)}}else{var Yc=N.y;if(Yc instanceof fw)bX(a,cD(Yc,h,d),c,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);else{var Ce=N.y,te=N.w;if(Ce instanceof Mu){var Ie=Ce.pd,Jf=a.Bk;if((null===Jf?null===Ie:Jf.i(Ie))&&te instanceof fw)break a}var df=N.w;if(df instanceof fw)bX(a,b,cD(df,h,d),!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);else{var vg=N.y;if(vg instanceof Mu){var wg=vg.pd,xg=a.Bk;if(null===xg?null===wg:xg.i(wg))break a}var eg=N.w;if(eg instanceof Mu){var vh=eg.pd,fg=a.Bk;if(null===
+fg?null===vh:fg.i(vh))break a}var ih=N.w;if(ih instanceof Tv){var Ig=ih.Ic;bX(a,iB(b,ih.kf),Ig,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D)}else{var Tf=N.w;if(Tf instanceof MA){var Jg=Tf.Fc;if(Jg instanceof Tv){var jh=Jg.Ic;bX(a,new Tv(a,b,Jg.kf,Jg.vp),new MA(a,jh,Tf.rA),!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);break a}}var yg=N.w;if(yg instanceof Qx)Sx(h,new y(wd=>{var ge=uca(yg,wd);Nx(a,new U(()=>"BUMP TO LEVEL "+wd.da+"  --\x3e  "+ge));Nx(a,new U(()=>"where "+xx(ge)));bX(a,b,ge,!0,d,e,g,wd,S,n,r,v,m,x,A,B,C,l,D);
+aX(a,h,wd,e,g,x,D,n,r,v,m,A,B,C,l)}),d,m);else{var gg=N.y;if(null!==gg){var Cf=Hv(Iv(a),gg,h);if(!Cf.b()){var Uf=Cf.k;if(Uf instanceof Qx){var $g=Uf.de,Ah=Uf.Re;if(Ah.Ea()<=$g){bX(a,Ah,c,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);break a}}}}var Kg=N.w;if(null!==Kg){var Vf=tca(pca(a),Kg,h,d);if(!Vf.b()){var hg=Vf.o();if(a.Wq){Nx(a,new U(()=>"DISTRIB-R  ~\x3e  "+hg));bX(a,b,hg,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);break a}}}var zg=N.y;if(null!==zg){var Lg=Hv(Iv(a),zg,h);if(!Lg.b()){var Mg=Lg.k;if(Mg instanceof Qx){var Wf=
+Mg.de,Ng=Mg.Re;if(null!==Ng){var Kf=Hv(Iv(a),Ng,h);if(!Kf.b()){var xf=Kf.k;if(xf instanceof cv){var Og=xf.Nb,mi=xf.ac;if(a.Wq&&Og.Ea()<=Wf&&mi.Ea()>Wf){var Ci=new cv(a,Og,new Qx(a,Wf,mi),c.ma());Nx(a,new U(()=>"DISTRIB-L  ~\x3e  "+Ci));bX(a,Ci,c,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);break a}}}}}}}var Xh=N.y;if(Xh instanceof Qx){var wh=lca(kea(a),Xh,h,d);if(!wh.b()){var Bh=wh.o();if(a.Wq){Nx(a,new U(()=>"DISTRIB-L'  ~\x3e  "+Bh));bX(a,Bh,c,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);break a}}}var ng=N.y;if(ng instanceof
+Qx){if(g.b())var kh=O().c,Kh=O().c,ni=G(new H,kh,Kh),Lh=O().c,lh=new z(ni,Lh);else lh=g;(new y(wd=>{bX(a,TA(ng,h),c,!0,d,e,wd,h,S,n,r,v,m,x,A,B,C,l,D)})).n(lh)}else{var Ch=N.y;if(Ch instanceof eC){var Dh=Ch.Lj,Yh=Ch.kj;Lx(a,new U(()=>"DISCHARGE CONSTRAINTS"),new U(()=>{for(var wd=new y(De=>{if(null!==De)bX(a,De.h(),De.j(),!1,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D);else throw new w(De);}),ge=Dh;!ge.b();)wd.n(ge.e()),ge=ge.f()}),a.qa);bX(a,Yh,c,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D)}else{N.w instanceof eC&&no();
+var ah=N.w;if(ah instanceof LA&&!0===ah.tc)cX(a,b,c,e,g,h,S,x,m,D,n,r,v,A,B,C,l);else{var oi=N.y;if(oi instanceof LA&&!1===oi.tc)cX(a,b,c,e,g,h,S,x,m,D,n,r,v,A,B,C,l);else{var mj=N.y;mj instanceof Jv?bX(a,mX(mj),c,!0,d,e,g,h,S,n,r,v,m,x,A,B,C,l,D):N.y instanceof MA||N.y instanceof Tv||N.w instanceof MA||N.w instanceof Tv?cX(a,b,c,e,g,h,S,x,m,D,n,r,v,A,B,C,l):(N.y instanceof Mu||N.y instanceof nC)&&N.w instanceof nC?cX(a,b,c,e,g,h,S,x,m,D,n,r,v,A,B,C,l):iX(a,t().d,e,h,m,x)}}}}}}}}}}}}}}}}}}}}}}}}})).n(M)}}),
+a.qa)}catch(M){if(M instanceof Iq){var I=M;if(I.Qg!==F)throw I;}else throw M;}}function qX(a,b){var c=new Te(new Ue(J(new K,["does not match type `","`"])));a=[wO(Xe(),CD(a,b))];return Ye(c,J(new K,a))}function rX(a){var b=new Te(new Ue(J(new K,["does not have field '","'"])));a=[We(Xe(),a)];return Ye(b,J(new K,a))}function sX(a,b){if(!a.b()){var c=a.o();b.$(c)}return a}
+function tX(a){if(a.Zm)return Ye(new Te(new Ue(J(new K,["type"]))),u());var b=new Te(new Ue(J(new K,[""," of type"])));a=[We(Xe(),a.lh)];return Ye(b,J(new K,a))}var Kea=function Jea(a,b,c,d){if(b instanceof z){var g=b.p;b=b.z.m();b=new Ef(b,new y(h=>h.ma()));b=new Ex(b,new uX(a,c,d));Od();b=Pd(u(),b);return dl(Jea(a,g,c,d),b)}a=O().c;if(null===a?null===b:a.i(b))return O().c;throw new w(b);};
+function Lea(a,b){var c=jA().X(),d=jA().X(),e=k=>{k=k.j();if(k.b())return!1;k=k.o();return d.L(k)};b=Kea(a,b,c,d);a:for(;;)if(b.b()){e=u();break}else if(c=b.e(),a=b.f(),!0===!!e(c))b=a;else for(;;){if(a.b())e=b;else{c=a.e();if(!0!==!!e(c)){a=a.f();continue}c=a;a=new z(b.e(),u());var g=b.f();for(b=a;g!==c;){var h=new z(g.e(),u());b=b.p=h;g=g.f()}for(g=c=c.f();!c.b();){h=c.e();if(!0===!!e(h)){for(;g!==c;)h=new z(g.e(),u()),b=b.p=h,g=g.f();g=c.f()}c=c.f()}g.b()||(b.p=g);e=a}break a}return e}
+function vX(a,b,c,d,e){var g=a.Ga;if(g instanceof L&&(g=g.k,!b.Ga.L(g)&&!c.L(g))){var h=new Te(new Ue(J(new K,["Note: constraint arises from ",":"]))),k=[We(Xe(),a.lh)];h=Ye(h,J(new K,k));a=sX(a.Ga,c);a=G(new H,h,a);h=d.Ga;a:{if(h instanceof L&&(h=h.k,Nm(new E(h),g)&&!b.Ga.L(h)&&!e.Ga.L(h)&&!c.L(h))){b=new Te(new Ue(J(new K,["from ",":"])));e=[We(Xe(),d.lh)];b=Ye(b,J(new K,e));c=sX(d.Ga,c);c=G(new H,b,c);d=O().c;c=new z(c,d);break a}c=O().c}return new z(a,c)}return O().c}
+function iX(a,b,c,d,e,g){var h=tc();try{var k=c.h().e(),l=c.j().e();Nx(a,new U(()=>"CONSTRAINT FAILURE: "+k+" \x3c: "+l));var m=c.h(),n=c.j(),r=m.m(),v=new iy(r,new y(ka=>ka.ma().Ix),!0),x=dH(v,new y(ka=>!ka.ma().Ga.b())),A=new y(ka=>ka.ma()),B=x.b()?R():new L(A.n(x.o())),C=new U(()=>k.ma()),D=B.b()?Es(C):B.o(),F=n.m(),I=new iy(F,new y(ka=>ka.ma().Ix),!0),M=dH(I,new y(ka=>!ka.ma().Ga.b())),N=new y(ka=>ka.ma()),P=M.b()?R():new L(N.n(M.o())),T=new U(()=>l.ma()),Y=P.b()?Es(T):P.o(),Z=er(n).m(),S=new iy(Z,
+new y(ka=>ka.ma().Ix),!0),ea=dH(S,new y(ka=>!ka.ma().Ga.b())),ia=new y(ka=>ka.ma()),X=ea.b()?R():new L(ia.n(ea.o())),sa=new U(()=>l.ma()),Ja=X.b()?Es(sa):X.o(),Xa=Wn(m,new wX(a,D,e)).Jg(),Fa=jA().X(),za=iu(ju(),m.Jg()),Qa=Is(n),Ma=za.tl(Qa).m(),Ga=new Ef(Ma,new y(ka=>ka.ma())),ab=new Ex(Ga,new xX(a));Od();var Hb=Pd(u(),ab),bc=ky(Hb,new y(ka=>ka.j().Ga)),yb=Fca(k),tb=new U(()=>{var ka=G(new H,yb,uy(l));if(ka.y instanceof YB||ka.w instanceof YB){var ya=ka.y,Sa=ka.w;if(ya instanceof YB&&Sa instanceof
+YB){t();var xc=new L(ya);t();var Sb=new Gp(ya,xc,new L(Sa),un(ya.ME,Sa.ME))}else{var uc=ka.y;if(uc instanceof YB)Sb=new Gp(uc,(t(),new L(uc)),t().d,uc.ME);else{var Lb=ka.w;Lb instanceof YB?Sb=new Gp(Lb,t().d,(t(),new L(Lb)),Lb.ME):xm("Program reached and unexpected state.")}}if(null!==Sb)var lc=new Gp(Sb.Uj,Sb.oj,Sb.oi,Sb.Xi);else throw new w(Sb);var Xb=lc.Uj,ec=lc.oj,Ab=lc.oi,Ob=Lea(a,lc.Xi),fb=sX(D.Ga,Fa),Wa=new U(()=>sX(Xb.Ym.et.Ga,Fa)),bb=fb.b()?Es(Wa):fb,Ia=new U(()=>sX(Xb.Ym.hi.ji.Ga,Fa)),Ua=
+bb.b()?Es(Ia):bb,pc=new Te(new Ue(J(new K,["Type error in ",""]))),sc=[We(Xe(),e.lh)],Ba=Ye(pc,J(new K,sc)),ob=sX(e.Ga,Fa),nc=G(new H,Ba,ob),Ib=new Te(new Ue(J(new K,["type variable `","` leaks out of its scope"]))),vc=[wO(Xe(),AD(Xb.Ym,d))],Vb=Ye(Ib,J(new K,vc)),fc=G(new H,Vb,Ua);if(Ab instanceof L){var Bc=Ab.k,Pb=sX(Y.Ga,Fa),Jb=new U(()=>sX(Bc.Ym.et.Ga,Fa)),gc=Pb.b()?Es(Jb):Pb,Cb=new U(()=>sX(Bc.Ym.hi.ji.Ga,Fa)),cc=gc.b()?Es(Cb):gc;if(!ec.b()&&Nm(new E(cc),Ua))var yc=new Te(new Ue(J(new K,["back into type variable `",
+"`"]))),Mc=[wO(Xe(),CD(Bc.Ym,d))],qc=Ye(yc,J(new K,Mc)),oc=G(new H,qc,cc),Qc=O().c,jc=new z(oc,Qc);else jc=O().c}else if(t().d===Ab){var sb=new Te(new Ue(J(new K,["into "," `","`"]))),Gc=[tX(Y),wO(Xe(),CD(l,d))],Wb=Ye(sb,J(new K,Gc)),Cc=sX(Y.Ga,Fa),Fc=G(new H,Wb,Cc),qd=O().c;jc=new z(Fc,qd)}else throw new w(Ab);if(Ob.b())Uc=O().c;else var Yb=Ye(new Te(new Ue(J(new K,["adding a type annotation to any of the following terms may help resolve the problem"]))),u()),Nc=t().d,ad=G(new H,Yb,Nc),Uc=new z(ad,
+Ob);var cd=Ja.Ga;a:{if(cd instanceof L){var kc=cd.k;if(!(Y.Ga.L(kc)||e.Ga.L(kc)||D.Ga.L(kc)||Fa.L(kc))){var Vc=new Te(new Ue(J(new K,["Note: constraint arises from ",":"]))),Hc=[We(Xe(),Ja.lh)],rc=Ye(Vc,J(new K,Hc)),sd=sX(Ja.Ga,Fa),Kc=G(new H,rc,sd),Qd=O().c;var Ad=new z(Kc,Qd);break a}}Ad=O().c}var kd=dl(dl(Ad,Uc),jc),Hd=new z(nc,new z(fc,kd));throw new fX(h,g.n(kr(jr(),dl(vX(Y,e,Fa,Ja,D),Hd),a.$c,lu())));}if(ka.y instanceof lx||ka.y instanceof ZB)return qX(l,d);var Rd=ka.y,Bd=ka.w;if(Rd instanceof
+Qv){var ae=Rd.Ba;if(Bd instanceof Qv){var dd=Qt(Bd.Ba,new y(Yc=>Yc.h())),od=Aq(Bq(),dd),Ta=Qt(ae,new y(Yc=>Yc.h())),wb=Aq(Bq(),Ta),$a=od.wy(wb),wa=sp($a),hb=new U(()=>qX(l,d)),ra=new y(Yc=>rX(Yc.x));return wa.b()?Es(hb):ra.n(wa.o())}}var wc=ka.w;if(XB(wc)&&wc.rr()instanceof vl){var ac=new Te(new Ue(J(new K,["is not an instance of type `","`"])));if(a.cn.L(wc.rr().Dh))var Id=We(Xe(),wc.rr().Dh);else Xe(),Q(),Id=We(0,Nu(0,wc.rr().Dh));return Ye(ac,J(new K,[Id]))}var ud=ka.w;if(ud instanceof fw){var be=
+new Te(new Ue(J(new K,["is not an instance of `","`"]))),re=[wO(Xe(),CD(ud,d))];return Ye(be,J(new K,re))}var pe=ka.y,bd=ka.w;if(bd instanceof zv){var Rc=bd.Yb;if(!(pe instanceof zv)){var Wc=new Te(new Ue(J(new K,["is not a ","-element tuple"])));Xe();var Wd=Rc.K(),zd=[We(0,""+Wd)];return Ye(Wc,J(new K,zd))}}var Pa=ka.y;if(ka.w instanceof cv&&!(Pa instanceof cv))return Ye(new Te(new Ue(J(new K,["is not a function"]))),u());var Db=ka.y,Oc=ka.w;if(Oc instanceof Qv){var Tc=Oc.Ba;if(Tc instanceof z){var Sd=
+Tc.z,Jc=Tc.p;if(null!==Sd){var vd=Sd.h(),hd=O().c;if((null===hd?null===Jc:hd.i(Jc))&&!(Db instanceof Qv))return rX(vd.x)}}}var de=ka.y,ye=ka.w;if(ye instanceof Qv){var jf=ye.Ba;if(jf instanceof z&&Vr(new Wr(new yX(a)),yb).L(!0)&&!(de instanceof Qv)){var af=new Te(new Ue(J(new K,["is not a record (expected a record with field",": ",")"]))),pf=0<jf.ab(1)?We(Xe(),"s"):We(Xe(),"");Xe();var kf=Qt(jf,new y(Yc=>Yc.h().x)),Be=[pf,We(0,ze(kf,"",", ",""))];return Ye(af,J(new K,Be))}}var Kd=ka.w;if(Kd instanceof
+Qv){var ld=Kd.Ba;if(ld instanceof z){var Jd=new Te(new Ue(J(new K,["does not have all required fields ",""])));Xe();var Dd=Qt(ld,new y(Yc=>"'"+Yc.h().x+"'")),Xd=[We(0,ze(Dd,"",", ",""))];return Ye(Jd,J(new K,Xd))}}return qX(l,d)}),eb=b.b()?Es(tb):b.o(),kb=new Te(new Ue(J(new K,["Type mismatch in ",":"]))),Rb=[We(Xe(),e.lh)],Gb=Ye(kb,J(new K,Rb)),vb=sX(e.Ga,Fa),Tb=G(new H,Gb,vb),Nb=new Te(new Ue(J(new K,[""," `","` ",""]))),ic=[tX(D),wO(Xe(),AD(k,d)),eb],Va=Ye(Nb,J(new K,ic)),cb=Pe(new E(D.Ga),e.Ga)?
+t().d:sX(D.Ga,Fa),zb=G(new H,Va,cb),Ub=O().c,jb=new z(Tb,new z(zb,Ub)),db=new y(ka=>{var ya=new Te(new Ue(J(new K,[" with expected type `","`"]))),Sa=[wO(Xe(),CD(l,d))];Sa=Ye(ya,J(new K,Sa));ya=new Te(new Ue(J(new K,["but it flows into ","",""])));Sa=[We(Xe(),ka.ma().lh),Sa];ya=Ye(ya,J(new K,Sa));ka=sX(ka.ma().Ga,Fa);ka=G(new H,ya,ka);ya=O().c;return new z(ka,ya)}),ub=(Xa.b()?R():new L(db.n(Xa.o()))).ha(),Aa=op().ga,va=zX(ub,Aa),Ra=vX(Y,e,Fa,Ja,D),rb=Wn(bc,new AX(a,Fa,new GA(!0)));if(a.zA)var xb=
+Ye(new Te(new Ue(J(new K,["\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d Additional explanations below \x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d\x3d"]))),u()),mc=t().d,Ha=G(new H,xb,mc),Ka=ZW(m,new y(ka=>{if(a.F){var ya=new Te(new Ue(J(new K,["[info] LHS \x3e\x3e "," : ",""]))),Sa=[We(Xe(),ka.ma().u()),wO(Xe(),AD(ka,d))];ya=Ye(ya,J(new K,Sa));ka=ka.ma().Ga;ka=G(new H,ya,ka);ya=O().c;return new z(ka,ya)}ya=new Te(new Ue(J(new K,["[info] flowing from "," `","`"])));Sa=[tX(ka.ma()),wO(Xe(),AD(ka,d))];ya=Ye(ya,J(new K,
+Sa));ka=ka.ma().Ga;ka=G(new H,ya,ka);ya=O().c;return new z(ka,ya)})),Oa=dl(ZW(Km(n),new y(ka=>{if(a.F){var ya=new Te(new Ue(J(new K,["[info] RHS \x3c\x3c "," : ",""]))),Sa=[We(Xe(),ka.ma().u()),wO(Xe(),CD(ka,d))];ya=Ye(ya,J(new K,Sa));ka=ka.ma().Ga;ka=G(new H,ya,ka);ya=O().c;return new z(ka,ya)}ya=new Te(new Ue(J(new K,["[info] flowing into "," `","`"])));Sa=[tX(ka.ma()),wO(Xe(),CD(ka,d))];ya=Ye(ya,J(new K,Sa));ka=ka.ma().Ga;ka=G(new H,ya,ka);ya=O().c;return new z(ka,ya)})),Ka),Na=new z(Ha,Oa);else Na=
+O().c;t();var Da=J(new K,[jb,va,Ra,rb,Na]),ta=Pd(u(),Da),Ya=op().ga,dc=zX(ta,Ya);g.n(kr(jr(),dc,a.$c,lu()))}catch(ka){if(ka instanceof Iq){if(b=ka,b.Qg!==h)throw b;}else throw ka;}}
+var fD=function BX(a,b,c,d,e,g,h,k){At(tp(),c>=d.da);if(b.Ea()<=e)return b;var m=!1,n=null,r=!1,v=null;if(b instanceof lx&&(m=!0,n=b,g.L(n)))return n;if(m){iC(a);var x=n.Sb;if(!x.b()){var A=x.o();return h.Se(n,new U((ra=>()=>{var wc=ra.ji;t();var ac=new L(ra),Id=ra.kg,ud=O().c,be=O().c;wc=new lx(a,ra.Xa>c?ra.Xa:d.da,ud,be,ac,Id,!1,wc);ac=G(new H,ra,wc);h.$(ac);ac=BX(a,A,c,d,e,g,h,k);wy(wc,(t(),new L(ac)));return wc})(n)))}}if(m){var B=!1,C=h.U(n);if(C instanceof L)return C.k;if(R()===C&&(B=!0,k&&
+n.Xa<=c)){var D=V(a);t();var F=new L(n),I=n.kg,M=O().c,N=O().c,P=new mx(a,new lx(a,d.da,M,N,F,I,!1,D),n.ji),T=n;if(a.F){var Y=ut(Q(),"| ",a.r)+("New skolem: "+T+" ~\x3e ")+P;ff(gf(),Y+"\n")}if(vy(n).b()?!rA(n).b():1){var Z=n.ji;t();var S=new L(n),ea=n.kg,ia=O().c,X=O().c,sa=new lx(a,d.da,ia,X,S,ea,!1,Z),Ja=G(new H,n,sa);h.$(Ja);var Xa=vy(sa),Fa=rA(n);if(Fa===u())var za=u();else{for(var Qa=Fa.e(),Ma=new z(BX(a,Qa,c,d,e,g,h,k),u()),Ga=Ma,ab=Fa.f();ab!==u();){var Hb=ab.e(),bc=new z(BX(a,Hb,c,d,e,g,h,
+k),u());Ga=Ga.p=bc;ab=ab.f()}za=Ma}for(var yb=P,tb=za;!tb.b();){var eb=yb,kb=tb.e(),Rb=eb,Gb=kb,vb=V(Rb.q);yb=Pu(Rb,Gb,vb,!1);tb=tb.f()}IA(sa,new z(yb,Xa));if(a.F){var Tb=ut(Q(),"| ",a.r)+(sa+" :\x3e ")+vy(sa);ff(gf(),Tb+"\n")}var Nb=rA(sa),ic=vy(n);if(ic===u())var Va=u();else{for(var cb=ic.e(),zb=new z(BX(a,cb,c,d,e,g,h,k),u()),Ub=zb,jb=ic.f();jb!==u();){var db=jb.e(),ub=new z(BX(a,db,c,d,e,g,h,k),u());Ub=Ub.p=ub;jb=jb.f()}Va=zb}for(var Aa=P,va=Va;!va.b();){var Ra=Aa,rb=va.e(),xb=Ra,mc=rb,Ha=V(xb.q);
+Aa=dv(xb,mc,Ha,!1);va=va.f()}KA(sa,new z(Aa,Nb));if(a.F){var Ka=ut(Q(),"| ",a.r)+(sa+" \x3c: ")+rA(sa);ff(gf(),Ka+"\n")}return sa}var Oa=G(new H,n,P);h.$(Oa);return P}if(B){var Na=n.ji;t();var Da=new L(n),ta=n.kg,Ya=O().c,dc=O().c;if(n.Xa>c)var ka=n.Xa;else{if(!(d.da<=c))throw new Yj("assertion failed: this condition should be false for the result to be correct");ka=d.da}var ya=new lx(a,ka,Ya,dc,Da,ta,!1,Na),Sa=G(new H,n,ya);h.$(Sa);for(var xc=vy(n),Sb=null,uc=null,Lb=xc,lc=xc,Xb;;)if(lc.b()){null===
+Sb?Xb=Lb:(uc.p=Lb,Xb=Sb);break}else{var ec=lc.e(),Ab=BX(a,ec,c,d,e,g,h,k);if(Ab===ec)lc=lc.f();else{for(var Ob=Lb,fb=Sb,Wa=uc;Ob!==lc;){var bb=new z(Ob.e(),u());null===fb&&(fb=bb);null!==Wa&&(Wa.p=bb);Wa=bb;Ob=Ob.f()}var Ia=new z(Ab,u());null===fb&&(fb=Ia);null!==Wa&&(Wa.p=Ia);Wa=Ia;var Ua=lc.f(),pc=Wa;Sb=fb;uc=pc;lc=Lb=Ua}}IA(ya,Xb);for(var sc=rA(n),Ba=null,ob=null,nc=sc,Ib=sc,vc;;)if(Ib.b()){null===Ba?vc=nc:(ob.p=nc,vc=Ba);break}else{var Vb=Ib.e(),fc=BX(a,Vb,c,d,e,g,h,k);if(fc===Vb)Ib=Ib.f();else{for(var Bc=
+nc,Pb=Ba,Jb=ob;Bc!==Ib;){var gc=new z(Bc.e(),u());null===Pb&&(Pb=gc);null!==Jb&&(Jb.p=gc);Jb=gc;Bc=Bc.f()}var Cb=new z(fc,u());null===Pb&&(Pb=Cb);null!==Jb&&(Jb.p=Cb);Jb=Cb;var cc=Ib.f(),yc=Jb;Ba=Pb;ob=yc;Ib=nc=cc}}KA(ya,vc);return ya}throw new w(C);}if(b instanceof cC){var Mc=b.Sf;return new cC(a,BX(a,b.Fg,c,d,e,g,h,k),BX(a,Mc,c,d,e,g,h,k),b.TO)}if(b instanceof cv){var qc=b.ac;return new cv(a,BX(a,b.Nb,c,d,e,g,h,k),BX(a,qc,c,d,e,g,h,k),b.Mj)}if(b instanceof LA){var oc=b.jc;return new LA(a,b.tc,BX(a,
+b.ic,c,d,e,g,h,k),BX(a,oc,c,d,e,g,h,k),b.KE)}if(b instanceof Qv){var Qc=b.Ba;return new Qv(a,ry(lv(),Qc,new y(ra=>{var wc=ra.Va,ac=ra.Oa;ac.b()?ac=R():(ac=ac.o(),ac=new L(BX(a,ac,c,d,e,g,h,k)));return new Uw(wc,ac,BX(a,ra.ra,c,d,e,g,h,k),ra.Pd)})),b.Nj)}if(b instanceof zv){var jc=b.Yb;return new zv(a,ry(lv(),jc,new y(ra=>{var wc=ra.Va,ac=ra.Oa;ac.b()?ac=R():(ac=ac.o(),ac=new L(BX(a,ac,c,d,e,g,h,k)));return new Uw(wc,ac,BX(a,ra.ra,c,d,e,g,h,k),ra.Pd)})),b.Nq)}if(b instanceof Sv){var sb=b.Fd,Gc=sb.Va,
+Wb=sb.Oa;if(Wb.b())var Cc=R();else{var Fc=Wb.o();Cc=new L(BX(a,Fc,c,d,e,g,h,k))}return new Sv(a,new Uw(Gc,Cc,BX(a,sb.ra,c,d,e,g,h,k),sb.Pd),b.Fx)}if(b instanceof Wv)return sB(b,new y(ra=>BX(a,ra,c,d,e,g,h,k)),new y(ra=>BX(a,ra,c,d,e,g,h,k)),new y(ra=>BX(a,ra,c,d,e,g,h,k)),b.Uu);if(b instanceof MA)return new MA(a,BX(a,b.Fc,c,d,e,g,h,k),b.rA);if(b instanceof FA)return b;if(b instanceof OA)return new OA(a,BX(a,b.Hi,c,d,e,g,h,k),b.NE);if(b instanceof ZB){$B(a);t();var qd=b.mc(),Yb=new L(qd);if(!Yb.b())return BX(a,
+Yb.k,c,d,e,g,h,k)}if(b instanceof mx){var Nc=b.hi;if(b.Tu>e&&b.Tu<=c)return BX(a,Nc,c,d,e,g,h,k)}if(b instanceof Mu||b instanceof nC||b instanceof mx||b instanceof YB)return b;if(b instanceof Tv){var ad=b.kf;return new Tv(a,BX(a,b.Ic,c,d,e,g,h,k),ad,b.vp)}if(b instanceof fw){var Uc=b.qb,cd=b.Zb;if(cd===u())var kc=u();else{for(var Vc=cd.e(),Hc=new z(BX(a,Vc,c,d,e,g,h,k),u()),rc=Hc,sd=cd.f();sd!==u();){var Kc=sd.e(),Qd=new z(BX(a,Kc,c,d,e,g,h,k),u());rc=rc.p=Qd;sd=sd.f()}kc=Hc}return new fw(a,Uc,kc,
+b.Xl)}if(b instanceof Qx&&(r=!0,v=b,v.Ea()<=e))return v;if(r){var Ad=v.de,kd=v.Re;if(d.da>Ad){var Hd=KC(v,d.da,g,d,h);return BX(a,Hd,c,d,e,g,h,k)}return new Qx(a,Ad,BX(a,kd,c<Ad?c:Ad,d,e,g,h,k))}if(b instanceof eC){var Rd=b.Lj,Bd=b.kj,ae=ra=>{var wc=BX(a,ra.h(),c,d,e,g,h,k);ra=BX(a,ra.j(),c,d,e,g,h,k);return G(new H,wc,ra)};if(Rd===u())var dd=u();else{for(var od=Rd.e(),Ta=new z(ae(od),u()),wb=Ta,$a=Rd.f();$a!==u();){var wa=$a.e(),hb=new z(ae(wa),u());wb=wb.p=hb;$a=$a.f()}dd=Ta}return new eC(a,dd,
+BX(a,Bd,c,d,e,g,h,k))}if(b instanceof Jv)return VW(b,new y(ra=>BX(a,ra,c,d,e,g,h,k)),new y(ra=>BX(a,ra,c,d,e,g,h,k)));throw new w(b);};function CX(){this.io=this.ho=this.jo=null;this.Fp=this.Gp=this.an=this.Ep=0;this.qa=null;this.r=0;this.zk=this.Pq=this.Uq=this.xp=this.Bp=this.Cp=this.Sq=this.zp=this.Rq=this.wp=this.Ap=this.yp=this.Qq=this.Tq=null;this.Dp=0;this.hs=this.yq=this.Aq=this.Bq=this.zq=this.Dq=this.Cq=null;this.Im=this.Pw=0}CX.prototype=new HS;CX.prototype.constructor=CX;
+function DX(){}DX.prototype=CX.prototype;function Sw(a){null===a.hs&&null===a.hs&&(a.hs=new PN(a));return a.hs}function Mea(a,b,c,d,e){b=d.$a.Se(b,new U(()=>{no()}));if(!b.ct&&(e=Kx(b,e),e instanceof Yw)){e=e.Ei.U(c.x);if(e instanceof L)return a=e.k,t(),new Ud(a);if(t().d===e)return t(),a=wea(a,b,c),new fe(a);throw new w(e);}no()}
+function jX(a,b,c,d,e,g,h,k){var l=a.qa;if(a.F){var m=ut(Q(),"| ",a.r)+("Looking up field "+g.x+" in "+c+" \x26 "+e)+" \x26 {...}";ff(gf(),m+"\n")}a.r=1+a.r|0;try{var n=g.x;if(0<=n.length&&"#"===n.substring(0,1))var r=g.x,v=new vl(Of(Q(),r,1,r.length)),x=g.A(),A=Cq(v,x),B=!0;else A=g,B=!1;g=A;B=!!B;var C=d.n(g),D=t().d,F=new aw(D);if(c.b())var I=R();else{var M=c.o();I=EX(a,h.$a.n(M),g,B,k,F,d,h)}var N=Wn((Od(),Pd(u(),e)),new FX(a,h,g,B,k,F,d)),P=op().ga,T=zX(N,P),Y=C.ha(),Z=I.ha(),S=dl(dl(T,Z),Y);
+if(a.F){var ea=ut(Q(),"| ",a.r)+("  \x26 "+C)+"  (from refinement)";ff(gf(),ea+"\n")}if(S instanceof z){for(var ia=S.z,X=Km(S.p);!X.b();){var sa=X.e();ia=Nv(sa,ia,V(sa.Va));X=X.f()}var Ja=ia}else{var Xa=O().c;if(null===Xa?null===S:Xa.i(S)){var Fa=F.rc;if(Fa instanceof L){var za=GX(a,Fa.k,k),Qa=V(a);Ja=lD(za,Qa)}else if(t().d===Fa){var Ma=new Te(new Ue(J(new K,["Type `","` does not contain member `","`"])));Xe();var Ga=Es(b),ab=[wO(0,AD(Ga,h)),We(Xe(),g.x)],Hb=Ye(Ma,J(new K,ab)),bc=g.A(),yb=G(new H,
+Hb,bc),tb=O().c,eb=ay(a,new z(yb,tb),k),kb=V(a);Ja=lD(eb,kb)}else throw new w(Fa);}else throw new w(S);}}finally{a.r=-1+a.r|0}dx(new E(l),a.qa)&&a.F&&(a=""+ut(Q(),"| ",a.r)+l.n(Ja),ff(gf(),a+"\n"));return Ja}function Tw(a,b,c,d,e,g,h){var k=tc();try{a.Im=1+a.Im|0,HX(a,b,c,d,e,g,h)}catch(l){if(l instanceof Iq){if(a=l,a.Qg!==k)throw a;}else throw l;}}
+function HX(a,b,c,d,e,g,h){var k=tc();try{var l=jA().X(),m=a.Pw,n=new IQ(m),r=new IX(16);Nx(a,new U(()=>"CONSTRAIN "+b+" \x3c! "+c));Nx(a,new U(()=>{var B=new cv(a,b,c,V(a));return"  where "+xx(B)}));var v=new U(()=>{throw new fX(k);}),x=O().c,A=O().c;bX(a,b,c,!0,d,G(new H,x,A),O().c,g,h,r,b,c,e,d,v,n,m,l,h)}catch(B){if(B instanceof Iq){if(d=B,d.Qg!==k)throw d;}else throw B;}}
+function Nea(a,b,c,d,e,g){var h=tc();try{Nx(a,new U(()=>"CHECKING SUBSUMPTION..."));var k=new IQ(0);Tw(a,b,c,new y(l=>{k.ve=1+k.ve|0;if(3<k.ve)throw new fX(h);Pe(new E(k.ve),1)&&e.n(l)}),g,d,Sw(a).ob)}catch(l){if(l instanceof Iq){if(a=l,a.Qg!==h)throw a;}else throw l;}}function Lw(a,b,c,d){b=G(new H,b,c);c=O().c;return ay(a,new z(b,c),d)}function ay(a,b,c){return GX(a,kr(jr(),b,a.$c,lu()),c)}function GX(a,b,c){c.n(b);return Ey(a)}function Ey(a){var b=a.Bk,c=ap();return new Mu(a,b,c,V(a))}
+function JX(a,b,c,d){b=G(new H,b,c);c=O().c;by(a,new z(b,c),d)}function by(a,b,c){c.n(hr(fr(),b,a.$c,lu()))}
+function KX(a,b,c,d,e,g,h){var k=a.qa;if(a.F){var l=ut(Q(),"| ",a.r)+(g.da+". U "+b+" \x3d! ")+c;ff(gf(),l+"\n")}a.r=1+a.r|0;try{l=c;for(var m=!1;;){if(pD(b)||!Pe(new E(b),l)){var n=b;c=l;if(n instanceof lx&&c.Ea()<=n.Xa){var r=n.Sb;if(r instanceof L)KX(a,r.k,c,d,e,g,h);else if(t().d===r){r=a;if(r.F){var v=ut(Q(),"| ",r.r)+(n+" :\x3d ")+c;ff(gf(),v+"\n")}var x=vy(n),A=rA(n);wy(n,(t(),new L(c)));for(v=a;!x.b();){var B=x.e();HX(v,B,c,d,e,g,h);x=x.f()}for(B=a;!A.b();){var C=A.e();HX(B,c,C,d,e,g,h);A=
+A.f()}}else throw new w(r);}else if(m)Tw(a,b,l,d,e,g,h),Tw(a,l,b,d,e,g,h);else{c=b;b=l;l=c;m=!0;continue}}break}var D=void 0}finally{a.r=-1+a.r|0}dx(new E(k),a.qa)&&a.F&&(a=""+ut(Q(),"| ",a.r)+k.n(D),ff(gf(),a+"\n"))}
+function EX(a,b,c,d,e,g,h,k){var l=!1;if(b.eo.b()){0===(65536&b.Ha)&&0===(65536&b.Ha)&&(b.yO=Jba(b),b.Ha|=65536);var m=b.yO.U(c)}else m=t().d;a:if(m instanceof L)g=m.k,fy(b).L(c)&&!d&&(d=new Te(new Ue(J(new K,["Parameter '","' cannot be accessed as a field"]))),l=[We(Xe(),c.x)],d=Ye(d,J(new K,l)),l=c.A(),d=G(new H,d,l),l=O().c,ay(a,new z(d,l),e)),t(),e=new L(g);else{if(t().d===m&&(l=!0,b.ct)){Bx(b).L(c)&&(t(),jr(),e=Ye(new Te(new Ue(J(new K,["Indirectly-recursive member should have a type signature"]))),
+u()),d=c.A(),e=G(new H,e,d),d=O().c,e=kr(0,new z(e,d),a.$c,lu()),g.rc=new L(e));e=t().d;break a}if(l)g=Kx(b,e),g instanceof Yw?e=WW(a,g.LC(),c,e,d):g instanceof Ww?e=WW(a,g.LC(),c,e,d):g instanceof Nw?e=WW(a,g.LC(),c,e,d):(g instanceof cx||no(),e=t().d);else throw new w(m);}a.F&&(g=ut(Q(),"| ",a.r),d=b.Ab.Cf.x,l=c.x,e.b()?m="":(m=e.o().ra,m=xx(m)),ff(gf(),g+("Lookup "+d+"."+l+" : "+e+" where ")+m+"\n"));if(e.b())h=R();else{e=e.o();g=Xu().X();Sw(a);for(d=b.Ag();!d.b();){var n=d.e();if(null!==n){l=
+n.hb;var r=n.Rd;m=!1;var v=null;n=h.n(new vl(b.Ab.Cf.x+"#"+n.kc.V));a:{if(n instanceof L){m=!0;v=n;var x=v.k,A=new E(r);t();var B=ou().Zu;if(Pe(A,new L(B))){m=x.ra;break a}}if(m&&(x=v.k,r=new E(r),t(),A=ou().AA,Pe(r,new L(A)))){m=x.Oa;m=m.b()?a.ib:m.o();break a}if(m)m=v.k,v=cw(a),n=m.Oa,m=dw(v,n.b()?a.ib:n.o(),m.ra,ew(cw(a)),k);else if(t().d===n){m=vy(l);v=new mx(a,l,V(a));for(v=new YB(a,!0,v,V(a),O().c);!m.b();)n=m.e(),r=V(v.q),v=dv(v,n,r,!1),m=m.f();m=v;v=rA(l);n=new mx(a,l,V(a));for(n=new YB(a,
+!1,n,V(a),O().c);!v.b();)r=v.e(),x=V(n.q),n=Pu(n,r,x,!1),v=v.f();m=new cC(a,m,n,l.ji)}else throw new w(n);}l=G(new H,l,m);g.$(l)}else throw new w(n);d=d.f()}h=new L(LX(e,b.Ru,!1,k,g))}a.F&&(a=ut(Q(),"| ",a.r),k=b.Ru,b=b.Ab.Cf.x,c=c.x,h.b()?e=R():(e=h.o().ra,e=new L(xx(e))),ff(gf(),a+("Fresh["+k+"] "+b+"."+c+" : "+h+" where ")+e+"\n"));return h}function QN(a,b,c){this.QC=null;this.su=b;this.tu=c;if(null===a)throw null;this.QC=a}QN.prototype=new p;QN.prototype.constructor=QN;f=QN.prototype;
+f.ka=function(){return this.su.ka()+this.tu.ka()|0};f.H=function(){return"Shadows"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.su;case 1:return this.tu;default:return $K(W(),a)}};f.D=function(a){return a instanceof QN};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof QN&&a.QC===this.QC){var b=this.su,c=a.su;if(null===b?null===c:b.i(c))return b=this.tu,a=a.tu,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({AU:0},!1,"mlscript.ConstraintSolver$Shadows",{AU:1,g:1,E:1,v:1,l:1});class Df extends xF{constructor(){super();this.pq=null}}function MX(){}MX.prototype=new gS;MX.prototype.constructor=MX;MX.prototype.u=function(){return"Inter"};MX.prototype.ba=function(a,b){return new hP(a,b)};MX.prototype.$classData=q({iV:0},!1,"mlscript.Inter$",{iV:1,nH:1,g:1,kz:1,l:1});var NX;function Un(){NX||(NX=new MX);return NX}function np(a,b,c){this.zu=b;this.dp=c;if(null===a)throw null;}np.prototype=new p;
+np.prototype.constructor=np;f=np.prototype;f.H=function(){return"QualifierPack"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.zu;case 1:return this.dp;default:return $K(W(),a)}};f.D=function(a){return a instanceof np};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){return this===a?!0:a instanceof np?this.zu===a.zu?this.dp===a.dp:!1:!1};f.$classData=q({vV:0},!1,"mlscript.JSBackend$QualifierPack$1",{vV:1,g:1,E:1,v:1,l:1});
+function On(a){this.fD=null;if(null===a)throw null;this.fD=a}On.prototype=new gS;On.prototype.constructor=On;On.prototype.u=function(){return"QualifierPack"};On.prototype.ba=function(a,b){return new np(this.fD,a,b)};On.prototype.$classData=q({wV:0},!1,"mlscript.JSBackend$QualifierPack$2$",{wV:1,nH:1,g:1,kz:1,l:1});function iO(a){this.tD=a}iO.prototype=new p;iO.prototype.constructor=iO;f=iO.prototype;
+f.xa=function(){for(var a=Sp(Qp(),"default:"),b=this.tD,c=Qp().ye;!b.b();){var d=b.e();c=Iz(c,Kz(d.xa()));b=b.f()}return Iz(a,c)};f.H=function(){return"JSDefaultCase"};f.G=function(){return 1};f.I=function(a){return 0===a?this.tD:$K(W(),a)};f.D=function(a){return a instanceof iO};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof iO){var b=this.tD;a=a.tD;return null===b?null===a:b.i(a)}return!1};
+f.$classData=q({LV:0},!1,"mlscript.JSDefaultCase",{LV:1,g:1,E:1,v:1,l:1});function $p(a,b){this.AH=this.Bu=null;this.uD=a;this.vD=b;Xo(this,a,b)}$p.prototype=new FS;$p.prototype.constructor=$p;
+$p.prototype.xa=function(){var a=Pp(this.uD.xa(),20>this.uD.sh()||this.uD instanceof vo||this.uD instanceof $m);Qp();var b=Al().zH;if(bq(new cq(b.nG,nb(this.vD.tq))))b="."+this.vD.tq;else if(b=this.vD.tq,b=$D(aE(),b),b instanceof L)b="["+(b.k|0)+"]";else{if(t().d!==b)throw new w(b);b="["+Mp(Np(),this.vD.tq)+"]"}return Rp(a,Sp(0,b))};$p.prototype.$classData=q({OV:0},!1,"mlscript.JSField",{OV:1,lN:1,Vi:1,Xc:1,g:1});function gO(a,b){this.UD=a;this.TD=b}gO.prototype=new p;gO.prototype.constructor=gO;
+f=gO.prototype;f.xa=function(){for(var a=Rp(Rp(Sp(Qp(),"case "),this.UD.xa()),Sp(Qp(),": ")),b=this.TD,c=Qp().ye;!b.b();){var d=b.e();c=Iz(c,Kz(d.xa()));b=b.f()}return Iz(a,c)};f.H=function(){return"JSSwitchCase"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.UD;case 1:return this.TD;default:return $K(W(),a)}};f.D=function(a){return a instanceof gO};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof gO){var b=this.UD,c=a.UD;if(null===b?null===c:b.i(c))return b=this.TD,a=a.TD,null===b?null===a:b.i(a)}return!1};f.$classData=q({hW:0},!1,"mlscript.JSSwitchCase",{hW:1,g:1,E:1,v:1,l:1});function Kq(a,b,c){this.fh=a;this.eh=b;this.dh=c;up(tp(),0<=a);up(tp(),b>=a)}Kq.prototype=new p;Kq.prototype.constructor=Kq;function Sy(a,b){return Pe(new E(b.dh),a.dh)?b.fh>=a.fh&&b.eh<=a.eh:!1}
+function OX(a,b){return Pe(new E(b.dh),a.dh)?b.fh>=a.fh&&b.fh<=a.eh||b.eh<=a.eh&&b.eh>=a.fh:!1}function xs(a,b){At(tp(),Ot(new E(a.dh),b.dh));var c=a.fh,d=b.fh,e=a.eh;b=b.eh;return new Kq(c<d?c:d,e>b?e:b,a.dh)}function Kt(a,b){if(b.b())return a;b=b.o();return xs(a,b)}function vs(a){return new Kq(a.fh,a.fh,a.dh)}f=Kq.prototype;f.H=function(){return"Loc"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.fh;case 1:return this.eh;case 2:return this.dh;default:return $K(W(),a)}};
+f.D=function(a){return a instanceof Kq};f.B=function(){var a=lb("Loc");a=W().C(-889275714,a);var b=this.fh;a=W().C(a,b);b=this.eh;a=W().C(a,b);b=this.dh;b=My(W(),b);a=W().C(a,b);return W().Ma(a,3)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Kq&&this.fh===a.fh&&this.eh===a.eh){var b=this.dh;a=a.dh;return null===b?null===a:b.i(a)}return!1};f.$classData=q({vW:0},!1,"mlscript.Loc",{vW:1,g:1,E:1,v:1,l:1});function $q(a){this.fp=a}$q.prototype=new p;
+$q.prototype.constructor=$q;function UN(a,b){b=wf(vf(),Wn(a.fp,new vO(a)),b,"'");return Mf(a,b)}function Mf(a,b){var c=a.fp;a=h=>{if(h instanceof xO)return yf(h.ax,0,b);if(h instanceof Vq)return h.Jz;throw new w(h);};if(c===u())a=u();else{var d=c.e(),e=d=new z(a(d),u());for(c=c.f();c!==u();){var g=c.e();g=new z(a(g),u());e=e.p=g;c=c.f()}a=d}return ze(a,"","","")}f=$q.prototype;
+f.Wr=function(){var a=this.fp.m();a=new Ef(a,new y(b=>{if(b instanceof xO)return""+b.ax;if(b instanceof Vq)return b.Jz;throw new w(b);}));return ze(a,"","","")};function PX(a,b){return new $q(un(a.fp,b.fp))}f.H=function(){return"Message"};f.G=function(){return 1};f.I=function(a){return 0===a?this.fp:$K(W(),a)};f.D=function(a){return a instanceof $q};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof $q){var b=this.fp;a=a.fp;return null===b?null===a:b.i(a)}return!1};f.$classData=q({xW:0},!1,"mlscript.Message",{xW:1,g:1,E:1,v:1,l:1});function zO(a,b){this.vq=null;this.Nl=b;if(null===a)throw null;this.vq=a}zO.prototype=new p;zO.prototype.constructor=zO;function Lt(a,b){var c=a.Nl.U(b);b=a.Nl.xj(b);a=new zO(a.vq,b);return G(new H,c,a)}
+function Mt(a){a.Nl.og(new fn((b,c)=>{var d=a.vq,e=new Te(new Ue(J(new K,["Unrecognized modifier `","` in this position"])));b=[We(Xe(),b)];e=Ye(e,J(new K,b));t();c=G(new H,e,new L(c));e=O().c;Ze(d,new z(c,e))}))}f=zO.prototype;f.H=function(){return"ModifierSet"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Nl:$K(W(),a)};f.D=function(a){return a instanceof zO};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof zO&&a.vq===this.vq){var b=this.Nl;a=a.Nl;return null===b?null===a:b.i(a)}return!1};f.$classData=q({SW:0},!1,"mlscript.NewParser$ModifierSet",{SW:1,g:1,E:1,v:1,l:1});function DO(a,b){this.ix=null;this.wq=b;if(null===a)throw null;this.ix=a}DO.prototype=new p;DO.prototype.constructor=DO;function IO(a,b){for(b=b.wq;!b.b();){var c=b.e();a=new DO(a.ix,new z(c,a.wq));b=b.f()}return a}
+function HO(a,b,c,d,e){var g=a.ix;a=a.wq;for(var h=null,k=null;a!==u();){a:{var l=a.e(),m=b,n=c,r=d,v=e,x=tc();try{t();var A=l.Is,B=yw(l.Ls,m.Ls,n,r);if(B.b())throw Hq(new Iq,x,t().d);var C=B.o(),D=l.Ms.Ce(m.Ms),F=hw(l.Js,m.Js,n,r,v);if(F.b())throw Hq(new Iq,x,t().d);var I=F.o(),M=new CO(A,C,D,I,l.Ks.Ce(m.Ks));var N=new L(M)}catch(P){if(P instanceof Iq){N=P;if(N.Qg===x){N=N.Cj();break a}throw N;}throw P;}}for(x=N.m();x.s();)l=new z(x.t(),u()),null===k?h=l:k.p=l,k=l;a=a.f()}return new DO(g,null===
+h?u():h)}f=DO.prototype;f.u=function(){return"CNF("+ze(this.wq,""," \x26 ","")+")"};f.H=function(){return"CNF"};f.G=function(){return 1};f.I=function(a){return 0===a?this.wq:$K(W(),a)};f.D=function(a){return a instanceof DO};f.B=function(){return AL(this)};f.i=function(a){if(this===a)return!0;if(a instanceof DO&&a.ix===this.ix){var b=this.wq;a=a.wq;return null===b?null===a:b.i(a)}return!1};f.$classData=q({WW:0},!1,"mlscript.NormalForms$CNF",{WW:1,g:1,E:1,v:1,l:1});
+function Oea(a){if(0===(2&a.Hs)<<24>>24){O();var b=new QX(J(new K,[a.Nf]));b=Kr(new Lr,b);b=new iy(b,new y(c=>Nm(new E(c),Vu(a.zb))),!1);b=kv(b,new U(()=>a.Pf)).nb(new U(()=>{O();var c=new QX(J(new K,[a.Of]));c=Kr(new Lr,c);c=new iy(c,new y(d=>Nm(new E(d),lw(a.zb))),!1);c=kv(c,new U(()=>a.Af));return new Ef(c,new y(d=>"~("+d+")"))}));a.NH=ze(b,"","\u2227","");a.Hs=(2|a.Hs)<<24>>24}return a.NH}
+function PO(a,b,c,d,e){this.yN=0;this.NH=null;this.Hs=0;this.zb=null;this.Nf=b;this.Pf=c;this.Of=d;this.Af=e;if(null===a)throw null;this.zb=a}PO.prototype=new p;PO.prototype.constructor=PO;function Pea(a,b){var c=oba(a.Nf,b.Nf);if(Nm(new E(c),0))return c;c=tba(a.Of,b.Of);if(Nm(new E(c),0))return c;c=-hv(a.Pf,b.Pf)|0;return Nm(new E(c),0)?c:c=-hv(a.Af,b.Af)|0}f=PO.prototype;
+f.zf=function(a){var b=new y(h=>h.zf(a));if(a){ms();ms();var c=this.Pf;if(0<=c.Q()){var d=c.Q();d=new (md(RX).Ia)(d);c.Gc(d,0,2147483647);c=d}else{d=null;d=[];for(c=c.m();c.s();){var e=c.t();d.push(null===e?null:e)}c=new (md(RX).Ia)(d)}d=Su();e=op().ga;c=Tu(c,new Uu(d,e));c=AG(c)}else c=this.Pf.m();c=c.nb(new U(()=>{O();var h=b.n(this.Of),k=V(h.q);h=[NA(h,k,!1)];h=J(new K,h);h=new QX(h);return Kr(new Lr,h)})).nb(new U(()=>{if(a){ms();ms();var h=this.Af;if(0<=h.Q()){var k=h.Q();k=new (md(RX).Ia)(k);
+h.Gc(k,0,2147483647);h=k}else{k=null;k=[];for(h=h.m();h.s();){var l=h.t();k.push(null===l?null:l)}h=new (md(RX).Ia)(k)}k=Su();l=op().ga;h=Tu(h,new Uu(k,l));h=AG(h)}else h=this.Af;return h.Ja(new y(m=>{var n=V(m.q);return NA(m,n,!1)}))}));for(d=this.Nf.zf(a);c.s();){e=c.t();var g=V(d.q);d=Pu(d,e,g,!1)}return d};
+function fca(a,b,c){ms();ms();var d=a.Pf;if(0<=d.Q()){var e=d.Q();e=new (md(RX).Ia)(e);d.Gc(e,0,2147483647);d=e}else{e=null;e=[];for(d=d.m();d.s();){var g=d.t();e.push(null===g?null:g)}d=new (md(RX).Ia)(e)}e=Su();g=op().ga;d=Tu(d,new Uu(e,g));d=AG(d).nb(new U(()=>{O();var h=c.n(a.Of),k=V(h.q);h=[NA(h,k,!1)];h=J(new K,h);h=new QX(h);return Kr(new Lr,h)})).nb(new U(()=>{ms();ms();var h=a.Af;if(0<=h.Q()){var k=h.Q();k=new (md(RX).Ia)(k);h.Gc(k,0,2147483647);h=k}else{k=null;k=[];for(h=h.m();h.s();){var l=
+h.t();k.push(null===l?null:l)}h=new (md(RX).Ia)(k)}k=Su();l=op().ga;h=Tu(h,new Uu(k,l));return AG(h).Ja(new y(m=>{var n=V(m.q);return NA(m,n,!1)}))}));for(b=b.n(a.Nf);d.s();)e=d.t(),g=V(b.q),b=Pu(b,e,g,!1);return b}f.Ea=function(){0===(1&this.Hs)<<24>>24&&0===(1&this.Hs)<<24>>24&&(this.yN=this.ub(this.zb.Df,jA().X()),this.Hs=(1|this.Hs)<<24>>24);return this.yN};
+f.ub=function(a,b){var c=this.Pf.m().nb(new U(()=>this.Af));c=new Ef(c,new y(e=>e.ub(a,b)));c=kv(c,new U(()=>{O();var e=[this.Nf.ub(a,b),this.Of.mc().ub(a,b)];e=J(new K,e);e=new QX(e);return Kr(new Lr,e)}));var d=Fq();return hH(c,d)|0};
+function dX(a,b,c,d,e){var g=a.Pf;g=PE().vl(g);g=Pt(g,new y(v=>{v=v.Kc(b,c,d,e);if(v instanceof lx)return t(),new fe(v);if(v instanceof Gv)return t(),new Ud(v);xm("Program reached and unexpected state.")}));if(null===g)throw new w(g);var h=g.h(),k=g.j();g=a.Af;g=PE().vl(g);var l=Pt(g,new y(v=>{v=v.Kc(b,c,d,e);if(v instanceof lx)return t(),new fe(v);if(v instanceof Gv)return t(),new Ud(v);xm("Program reached and unexpected state.")}));if(null===l)throw new w(l);g=l.h();var m=l.j();l=a.zb;var n=qba(a.Nf,
+b,c,d,e);for(k=k.m();k.s();){var r=k.t();n=rba(n,r)}k=n;n=Su();r=op().ga;n=new Uu(n,r);h=oA(uv(),h,n);n=a.Of.HJ(b,c,d,e);for(a=m.m();a.s();)m=n,n=a.t(),n=vba(m,n);a=n;m=Su();n=op().ga;m=new Uu(m,n);return new PO(l,k,h,a,oA(uv(),g,m))}function SX(a,b,c){return nw(b.Pf,a.Pf)&&mw(a.Nf,b.Nf,c)&&b.Of.Dw(a.Of,c)?nw(b.Af,a.Af):!1}
+function Qea(a,b,c,d){var e=tc();try{if(SX(a,b,c))return t(),new L(b);if(SX(b,a,c))return t(),new L(a);var g=a.Nf,h=a.Pf,k=a.Of,l=a.Af;if(Vu(a.zb)===g&&null!==b){var m=b.Nf,n=b.Pf,r=b.Of,v=b.Af;if(Vu(a.zb)===m&&Pe(new E(h),n)&&Pe(new E(l),v)){t();var x=a.zb,A=Vu(a.zb),B=uba(k,r,c);if(B.b())throw Hq(new Iq,e,t().d);var C=new PO(x,A,h,B.o(),l);return new L(C)}}var D=a.Nf,F=a.Pf,I=a.Of,M=a.Af;if(D instanceof Ku){var N=D.fc,P=D.vd,T=D.be,Y=D.Me;if(null!==b){var Z=b.Nf,S=b.Pf,ea=b.Of,ia=b.Af;if(Z instanceof
+Ku){var X=Z.vd,sa=Z.be,Ja=Z.Me;if(Pe(new E(N),Z.fc)&&Pe(new E(P),X)&&Pe(new E(F),S)&&Pe(new E(I),ea)&&Pe(new E(M),ia))var Xa=Y.AB(),Fa=Pe(new E(Xa),Ja.AB());else Fa=!1;if(Fa){var za=Bw(a.zb,!0,Y,Ja,c),Qa=a.zb,Ma=RC(T.Ba,sa.Ba),Ga=new Qv(Qa,Ma,V(a.zb));t();var ab=new PO(a.zb,new Ku(a.zb,N,P,Ga,za),F,I,M);return new L(ab)}}}}var Hb=a.Nf,bc=a.Pf,yb=a.Of,tb=a.Af;if(Hb instanceof Ku){var eb=Hb.fc,kb=Hb.vd,Rb=Hb.be,Gb=Hb.Me;if(null!==b){var vb=b.Nf,Tb=b.Pf,Nb=b.Of,ic=b.Af;if(vb instanceof Ku){var Va=vb.fc,
+cb=vb.be,zb=vb.Me;if(Pe(new E(kb),vb.vd)&&Pe(new E(bc),Tb)&&Pe(new E(yb),Nb)&&Pe(new E(tb),ic)&&Pe(new E(Gb),zb)){var Ub=a.zb;if(Ev(d))var jb=Rb.Ba;else{if(eb.b())var db=R();else{var ub=eb.o();db=new L(ub.kq().Ba)}if(db.b())jb=Rb.Ba;else{var Aa=db.o();jb=Yv(Rb.Ba,Aa)}}if(Ev(d))var va=cb.Ba;else{if(Va.b())var Ra=R();else{var rb=Va.o();Ra=new L(rb.kq().Ba)}if(Ra.b())va=cb.Ba;else{var xb=Ra.o();va=Yv(cb.Ba,xb)}}var mc=RC(jb,va),Ha=new Qv(Ub,mc,V(a.zb));if(eb instanceof L){var Ka=eb.k;if(Ka instanceof
+cv){var Oa=Ka.Nb,Na=Ka.ac;if(Va instanceof L){var Da=Va.k;if(Da instanceof cv){var ta=Da.Nb,Ya=Da.ac;t();var dc=a.zb,ka=a.zb;t();var ya=a.zb,Sa=V(Oa.q),xc=Pu(Oa,ta,Sa,!1),Sb=V(Na.q),uc=dv(Na,Ya,Sb,!1),Lb=new cv(ya,xc,uc,V(a.zb)),lc=new PO(dc,new Ku(ka,new L(Lb),kb,Ha,Gb),bc,lw(a.zb),tb);return new L(lc)}}}}if(eb instanceof L){var Xb=eb.k;if(Xb instanceof zv){var ec=Xb.Yb;if(Va instanceof L){var Ab=Va.k;if(Ab instanceof zv){var Ob=Ab.Yb,fb=ec.K();if(Nm(new E(fb),Ob.K())){t();var Wa=a.zb,bb=a.zb;t();
+var Ia=a.zb,Ua=Xb.Zj(),pc=Ab.Zj(),sc=Xb.Zj().Va,Ba=xw(Ua,pc,V(sc)),ob=new Sv(Ia,Ba,V(a.zb)),nc=new PO(Wa,new Ku(bb,new L(ob),kb,Ha,Gb),bc,lw(a.zb),tb);return new L(nc)}t();var Ib=a.zb,vc=a.zb;t();var Vb=a.zb,fc=TC(ec,Ob),Bc=new zv(Vb,fc,V(a.zb)),Pb=new PO(Ib,new Ku(vc,new L(Bc),kb,Ha,Gb),bc,lw(a.zb),tb);return new L(Pb)}}}}if(eb instanceof L){var Jb=eb.k;if(Jb instanceof zv&&Va instanceof L){var gc=Va.k;if(gc instanceof Sv){var Cb=gc.Fd;t();var cc=a.zb,yc=a.zb;t();var Mc=a.zb,qc=Jb.Zj(),oc=Jb.Zj().Va,
+Qc=xw(qc,Cb,V(oc)),jc=new Sv(Mc,Qc,V(a.zb)),sb=new PO(cc,new Ku(yc,new L(jc),kb,Ha,Gb),bc,lw(a.zb),tb);return new L(sb)}}}if(eb instanceof L){var Gc=eb.k;if(Gc instanceof Sv){var Wb=Gc.Fd;if(Va instanceof L){var Cc=Va.k;if(Cc instanceof zv){t();var Fc=a.zb,qd=a.zb;t();var Yb=a.zb,Nc=Cc.Zj(),ad=Cc.Zj().Va,Uc=xw(Nc,Wb,V(ad)),cd=new Sv(Yb,Uc,V(a.zb)),kc=new PO(Fc,new Ku(qd,new L(cd),kb,Ha,Gb),bc,lw(a.zb),tb);return new L(kc)}}}}if(eb instanceof L){var Vc=eb.k;if(Vc instanceof Sv){var Hc=Vc.Fd;if(Va instanceof
+L){var rc=Va.k;if(rc instanceof Sv){var sd=rc.Fd;t();var Kc=a.zb,Qd=a.zb;t();var Ad=a.zb,kd=xw(Hc,sd,V(Hc.Va)),Hd=new Sv(Ad,kd,V(a.zb)),Rd=new PO(Kc,new Ku(Qd,new L(Hd),kb,Ha,Gb),bc,lw(a.zb),tb);return new L(Rd)}}}}var Bd=t().d===eb&&t().d===Va?!0:eb instanceof L&&eb.k instanceof cv&&Va instanceof L&&Va.k instanceof Vv?!0:eb instanceof L&&eb.k instanceof Vv&&Va instanceof L&&Va.k instanceof cv?!0:!1;if(Bd){t();var ae=new PO(a.zb,new Ku(a.zb,t().d,kb,Ha,Gb),bc,lw(a.zb),tb);return new L(ae)}}}}}return t().d}catch(od){if(od instanceof
+Iq){var dd=od;if(dd.Qg===e)return dd.Cj();throw dd;}throw od;}}f.u=function(){return 0===(2&this.Hs)<<24>>24?Oea(this):this.NH};f.H=function(){return"Conjunct"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.Nf;case 1:return this.Pf;case 2:return this.Of;case 3:return this.Af;default:return $K(W(),a)}};f.D=function(a){return a instanceof PO};f.B=function(){return AL(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof PO&&a.zb===this.zb){var b=this.Nf,c=a.Nf;(null===b?null===c:b.i(c))?(b=this.Pf,c=a.Pf,b=null===b?null===c:b.i(c)):b=!1;if(b&&(b=this.Of,c=a.Of,null===b?null===c:b.i(c)))return b=this.Af,a=a.Af,null===b?null===a:b.i(a)}return!1};f.$classData=q({YW:0},!1,"mlscript.NormalForms$Conjunct",{YW:1,g:1,E:1,v:1,l:1});function TX(a,b){var c=a.xe.m();c=new Ef(c,new y(e=>e.ub(b,jA().X())));var d=Fq();c=Jq(c,d);return(c.b()?a.Gj.Gd:c.o())|0}
+function UX(a,b,c){var d=Xu().X();if(VX(a)<=b.fb&&VX(b)<=a.fb){c=a.fb;var e=b.fb;return new WX(c<e?c:e,a.xe,b.xe,a.Qf,b.Qf)}if(TX(a,b.fb)<=a.fb&&VX(a)<=b.fb)return new WX(b.fb,a.xe,b.xe,a.Qf,b.Qf);if(TX(b,a.fb)<=b.fb&&VX(b)<=a.fb)return new WX(a.fb,a.xe,b.xe,a.Qf,b.Qf);if(b.fb>a.fb){var g=new Iw(c.S,c.Ec,c.hc,c.Ed,1+b.fb|0,c.Pc,c.Zc,c.Lb,c.yc,c.tb,c.$a,c.od,c.cb);tp();c=a.fb;e=b.fb;up(0,Pe(new E(c>e?c:e),b.fb));c=a.fb;e=b.fb;var h=a.xe;if(h===u())var k=u();else{k=h.e();var l=k=new z(dX(k,a.fb,!1,
+g,d),u());for(h=h.f();h!==u();){var m=h.e();m=new z(dX(m,a.fb,!1,g,d),u());l=l.p=m;h=h.f()}}l=b.xe;lv();h=JF(lv(),a.Qf,new y(v=>v.Kc(a.fb,!1,g,d)));return new WX(c>e?c:e,k,l,ry(0,h,new y(v=>v.Kc(a.fb,!1,g,d))),b.Qf)}if(a.fb>b.fb){var n=new Iw(c.S,c.Ec,c.hc,c.Ed,1+a.fb|0,c.Pc,c.Zc,c.Lb,c.yc,c.tb,c.$a,c.od,c.cb);tp();c=a.fb;e=b.fb;up(0,Pe(new E(c>e?c:e),a.fb));c=a.fb;e=b.fb;k=a.xe;m=b.xe;if(m===u())l=u();else for(l=m.e(),h=l=new z(dX(l,b.fb,!1,n,d),u()),m=m.f();m!==u();){var r=m.e();r=new z(dX(r,b.fb,
+!1,n,d),u());h=h.p=r;m=m.f()}h=a.Qf;lv();b=JF(lv(),b.Qf,new y(v=>v.Kc(a.fb,!1,n,d)));return new WX(c>e?c:e,k,l,h,ry(0,b,new y(v=>v.Kc(a.fb,!1,n,d))))}tG||(tG=new sG);return cda(new WX(a.fb,a.xe,b.xe,a.Qf,b.Qf),Pe(new E(b.fb),a.fb))}function RO(a,b,c,d){this.Nm=this.zN=this.AN=this.BN=0;this.Gj=null;this.fb=b;this.Qf=c;this.xe=d;if(null===a)throw null;this.Gj=a;if(!(b<=a.Df))throw new Yj("assertion failed: "+this.fb);}RO.prototype=new p;RO.prototype.constructor=RO;
+function VX(a){0===(1&a.Nm)<<24>>24&&0===(1&a.Nm)<<24>>24&&(a.BN=TX(a,a.fb),a.Nm=(1|a.Nm)<<24>>24);return a.BN}f=RO.prototype;
+f.zf=function(a){var b=vx(this.Gj),c=this.Qf;if(this.xe.b())var d=this.Gj.ib;else{if(a){d=this.xe;var e=ZA($A(this.Gj)),g=qw(d,e)}else g=this.xe;d=zx(this.Gj);e=this.fb;if(g===u())a=u();else{var h=g.e(),k=h=new z(h.zf(a),u());for(g=g.f();g!==u();){var l=g.e();l=new z(l.zf(a),u());k=k.p=l;g=g.f()}a=h}for(h=this.Gj.ib;!a.b();)k=a.e(),g=V(h.q),h=dv(h,k,g,!1),a=a.f();d=yx(d,e,h)}return wx(b,c,d)};
+f.Ea=function(){if(0===(2&this.Nm)<<24>>24&&0===(2&this.Nm)<<24>>24){var a=this.xe,b=Fq();if(a.b())b=R();else{if(a.b())throw nv("empty.maxBy");var c=null;var d=null;var e;for(e=!0;!a.b();){var g=a.e(),h=g.Ea();if(e||0<b.Da(h,c))d=g,c=h,e=!1;a=a.f()}b=new L(d)}this.AN=b.b()?this.Gj.Gd:b.o().Ea();this.Nm=(2|this.Nm)<<24>>24}return this.AN};function qB(a){return a.Ea()>a.fb}
+function Aea(a,b){if(qB(a)){var c=Xu().X(),d=a.Qf,e=l=>{if(null!==l){var m=l.j();return G(new H,l.h().Kc(a.fb,!1,b,c),m.Kc(a.fb,!1,b,c))}throw new w(l);};if(d===u())e=u();else{var g=d.e(),h=g=new z(e(g),u());for(d=d.f();d!==u();){var k=d.e();k=new z(e(k),u());h=h.p=k;d=d.f()}e=g}d=a.xe;if(d===u())g=u();else for(g=d.e(),h=g=new z(dX(g,a.fb,!1,b,c),u()),d=d.f();d!==u();)k=d.e(),k=new z(dX(k,a.fb,!1,b,c),u()),h=h.p=k,d=d.f();return G(new H,e,g)}return G(new H,a.Qf,a.xe)}
+function eea(a,b,c,d,e){b=UX(a,b,d);if(null===b)throw new w(b);var g=b.hv|0,h=b.qt,k=b.kr,l=b.iv,m=b.jv;b=x=>{var A=new RO(a.Gj,g,dl(m,l),h),B=A.Gj,C=A.fb,D=A.Qf;A=A.xe;for(var F=null,I=null;A!==u();){a:{var M=A.e(),N=x,P=c,T=d,Y=e,Z=tc();try{if(M.Nf.Dw(N.Of,T))var S=t().d;else{t();var ea=$A(M.zb),ia=hw(M.Nf,N.Nf,P,T,Y);if(ia.b())throw Hq(new Iq,Z,t().d);var X=ia.o(),sa=M.Pf.Ce(N.Pf),Ja=yw(M.Of,N.Of,P,T);if(Ja.b())throw Hq(new Iq,Z,t().d);var Xa=Ja.o(),Fa=void 0,za=ea,Qa=X,Ma=sa,Ga=Xa,ab=M.Af.Ce(N.Af);
+M=P;var Hb=za.xq;if(Ga instanceof iw)var bc=new iw(za.xq,Ga.me,Ga.Ne);else if(Ga instanceof jw){var yb=Ga.mb,tb=Ga.Dc,eb=za.xq,kb=Ga.Xb;b:for(;;)if(kb.b()){Fa=u();break}else{var Rb=kb.e(),Gb=kb.f();if(!1===!yv(Qa,Rb,M,T,Y).b())kb=Gb;else for(za=kb,Ga=Gb;;){if(Ga.b())Fa=za;else{var vb=Ga.e();if(!1!==!yv(Qa,vb,M,T,Y).b()){Ga=Ga.f();continue}var Tb=new z(za.e(),u()),Nb=za.f();for(za=Tb;Nb!==Ga;){var ic=new z(Nb.e(),u());za=za.p=ic;Nb=Nb.f()}var Va=Ga.f();for(Ga=Va;!Va.b();){var cb=Va.e();if(!1===!yv(Qa,
+cb,M,T,Y).b()){for(;Ga!==Va;){var zb=new z(Ga.e(),u());za=za.p=zb;Ga=Ga.f()}Ga=Va.f()}Va=Va.f()}Ga.b()||(za.p=Ga);Fa=Tb}break b}}if(yb.b())var Ub=!0;else{var jb=yb.o();if(jb instanceof fe)Ub=!yv(Qa,jb.aa,M,T,Y).b();else{if(!(jb instanceof Ud))throw new w(jb);Ub=!0}}bc=new jw(eb,Fa,Ub?yb:R(),tb)}else if(lw(za.xq)===Ga)bc=lw(za.xq);else throw new w(Ga);var db=new PO(Hb,Qa,Ma,bc,ab);S=new L(db)}}catch(ub){if(ub instanceof Iq){S=ub;if(S.Qg===Z){S=S.Cj();break a}throw S;}throw ub;}}for(Z=S.m();Z.s();)Fa=
+new z(Z.t(),u()),null===I?F=Fa:I.p=Fa,I=Fa;A=A.f()}return new RO(B,C,D,null===F?u():F)};if(k===u())b=u();else{var n=k.e(),r=n=new z(b(n),u());for(k=k.f();k!==u();){var v=k.e();v=new z(b(v),u());r=r.p=v;k=k.f()}b=n}for(n=SO(xB(a.Gj),!1);!b.b();)r=b.e(),n=UO(n,r,d,e),b=b.f();return n}
+function UO(a,b,c,d){var e=UX(a,b,c);if(null===e)throw new w(e);var g=e.qt;b=e.kr;e=new RO(a.Gj,e.hv|0,dl(e.jv,e.iv),g);for(a=b;!a.b();){var h=e,k=a.e(),l=c,m=d;b=h.Gj;e=h.fb;g=h.Qf;a:{var n=h.xe;for(h=O().c;;)if(n instanceof z){var r=n.z;n=n.p;if(SX(r,k,l)){h=Km(h);h=dl(new z(k,n),h);break a}if(SX(k,r,l)){h=Km(h);h=dl(new z(r,n),h);break a}var v=Qea(r,k,l,m);if(v instanceof L){k=v.k;h=Km(h);h=dl(new z(k,n),h);break a}if(R()===v)h=new z(r,h);else throw new w(v);}else{l=O().c;if(null===l?null===n:
+l.i(n)){h=Km(new z(k,h));break a}throw new w(n);}}e=new RO(b,e,g,h);a=a.f()}return e}f.u=function(){var a=this.fb,b=ze(this.xe,""," | ",""),c=this.Qf.b()?"":"{"+ze(this.Qf,"",", ","")+"}";return"DNF("+a+", "+b+")"+c};f.H=function(){return"DNF"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.fb;case 1:return this.Qf;case 2:return this.xe;default:return $K(W(),a)}};f.D=function(a){return a instanceof RO};
+f.B=function(){var a=lb("DNF");a=W().C(-889275714,a);var b=this.fb;a=W().C(a,b);b=this.Qf;b=My(W(),b);a=W().C(a,b);b=this.xe;b=My(W(),b);a=W().C(a,b);return W().Ma(a,3)};f.i=function(a){if(this===a)return!0;if(a instanceof RO&&a.Gj===this.Gj){if(this.fb===a.fb){var b=this.Qf,c=a.Qf;b=null===b?null===c:b.i(c)}else b=!1;if(b)return b=this.xe,a=a.xe,null===b?null===a:b.i(a)}return!1};f.$classData=q({aX:0},!1,"mlscript.NormalForms$DNF",{aX:1,g:1,E:1,v:1,l:1});
+function CO(a,b,c,d,e){this.Is=null;this.Ls=b;this.Ms=c;this.Js=d;this.Ks=e;if(null===a)throw null;this.Is=a}CO.prototype=new p;CO.prototype.constructor=CO;f=CO.prototype;
+f.u=function(){O();var a=new QX(J(new K,[this.Ls]));a=Kr(new Lr,a);a=new iy(a,new y(b=>Nm(new E(b),lw(this.Is))),!1);a=kv(a,new U(()=>this.Ms)).nb(new U(()=>{O();var b=new QX(J(new K,[this.Js]));b=Kr(new Lr,b);b=new iy(b,new y(c=>Nm(new E(c),Vu(this.Is))),!1);b=kv(b,new U(()=>this.Ks));return new Ef(b,new y(c=>"~"+c))}));return ze(a,"","\u2228","")};f.H=function(){return"Disjunct"};f.G=function(){return 4};
+f.I=function(a){switch(a){case 0:return this.Ls;case 1:return this.Ms;case 2:return this.Js;case 3:return this.Ks;default:return $K(W(),a)}};f.D=function(a){return a instanceof CO};f.B=function(){return AL(this)};f.i=function(a){if(this===a)return!0;if(a instanceof CO&&a.Is===this.Is){var b=this.Ls,c=a.Ls;(null===b?null===c:b.i(c))?(b=this.Ms,c=a.Ms,b=null===b?null===c:b.i(c)):b=!1;if(b&&(b=this.Js,c=a.Js,null===b?null===c:b.i(c)))return b=this.Ks,a=a.Ks,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({cX:0},!1,"mlscript.NormalForms$Disjunct",{cX:1,g:1,E:1,v:1,l:1});function az(a,b,c,d,e,g,h,k){this.Sz=null;this.Eq=b;this.Os=c;this.Hu=d;this.Gu=e;this.Qs=g;this.Ps=h;this.Rm=k;if(null===a)throw null;this.Sz=a}az.prototype=new p;az.prototype.constructor=az;f=az.prototype;f.H=function(){return"Pack"};f.G=function(){return 7};
+f.I=function(a){switch(a){case 0:return this.Eq;case 1:return this.Os;case 2:return this.Hu;case 3:return this.Gu;case 4:return this.Qs;case 5:return this.Ps;case 6:return this.Rm;default:return $K(W(),a)}};f.D=function(a){return a instanceof az};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof az){var b=this.Eq,c=a.Eq;(null===b?null===c:mC(b,c))?(b=this.Os,c=a.Os,b=null===b?null===c:b.i(c)):b=!1;b?(b=this.Hu,c=a.Hu,(null===b?null===c:b.i(c))?(b=this.Gu,c=a.Gu,b=null===b?null===c:b.i(c)):b=!1):b=!1;if(b&&(b=this.Qs,c=a.Qs,(null===b?null===c:b.i(c))?(b=this.Ps,c=a.Ps,b=null===b?null===c:b.i(c)):b=!1,b))return b=this.Rm,a=a.Rm,null===b?null===a:mC(b,a)}return!1};
+f.$classData=q({uX:0},!1,"mlscript.NuTypeDefs$DelayedTypeInfoImpl$Pack$1",{uX:1,g:1,E:1,v:1,l:1});function Xy(a){this.GN=null;if(null===a)throw null;this.GN=a}Xy.prototype=new mS;Xy.prototype.constructor=Xy;Xy.prototype.u=function(){return"Pack"};function Nba(a,b,c,d,e,g,h,k){return new az(a.GN,b,c,d,e,g,h,k)}Xy.prototype.$classData=q({vX:0},!1,"mlscript.NuTypeDefs$DelayedTypeInfoImpl$Pack$2$",{vX:1,aca:1,g:1,raa:1,l:1});
+function XX(a,b,c){this.PH=null;this.uE=b;this.Uz=c;if(null===a)throw null;this.PH=a}XX.prototype=new p;XX.prototype.constructor=XX;f=XX.prototype;f.H=function(){return"RefMap"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.uE;case 1:return this.Uz;default:return $K(W(),a)}};f.D=function(a){return a instanceof XX};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof XX&&a.PH===this.PH){var b=this.uE,c=a.uE;if(null===b?null===c:b.i(c))return b=this.Uz,a=a.Uz,null===b?null===a:b.i(a)}return!1};f.$classData=q({xX:0},!1,"mlscript.NuTypeDefs$RefMap",{xX:1,g:1,E:1,v:1,l:1});function Ge(a,b,c){this.Wz=a;this.rx=b;this.Us=c}Ge.prototype=new p;Ge.prototype.constructor=Ge;f=Ge.prototype;f.u=function(){return this.Wz+":+"+this.rx};f.H=function(){return"Origin"};f.G=function(){return 3};
+f.I=function(a){switch(a){case 0:return this.Wz;case 1:return this.rx;case 2:return this.Us;default:return $K(W(),a)}};f.D=function(a){return a instanceof Ge};f.B=function(){var a=lb("Origin");a=W().C(-889275714,a);var b=this.Wz;b=My(W(),b);a=W().C(a,b);b=this.rx;a=W().C(a,b);b=this.Us;b=My(W(),b);a=W().C(a,b);return W().Ma(a,3)};f.i=function(a){return this===a?!0:a instanceof Ge?this.rx===a.rx?this.Wz===a.Wz?this.Us===a.Us:!1:!1:!1};f.$classData=q({LX:0},!1,"mlscript.Origin",{LX:1,g:1,E:1,v:1,l:1});
+function aP(a,b,c,d,e){this.QN=null;this.bI=!1;this.kp=a;this.$z=b;this.xx=c;this.fi=d;this.Jq=e}aP.prototype=new p;aP.prototype.constructor=aP;function yP(a){a.bI||a.bI||(a.QN=ut(Q(),"  ",a.xx),a.bI=!0);return a.QN}function ON(a){return"\n"+yP(a)}function AP(a){return new aP(a.kp,a.$z,1+a.xx|0,a.fi,a.Jq)}f=aP.prototype;f.H=function(){return"ShowCtx"};f.G=function(){return 5};
+f.I=function(a){switch(a){case 0:return this.kp;case 1:return this.$z;case 2:return this.xx;case 3:return this.fi;case 4:return this.Jq;default:return $K(W(),a)}};f.D=function(a){return a instanceof aP};f.B=function(){var a=lb("ShowCtx");a=W().C(-889275714,a);var b=this.kp;b=My(W(),b);a=W().C(a,b);b=this.$z?1231:1237;a=W().C(a,b);b=this.xx;a=W().C(a,b);b=this.fi?1231:1237;a=W().C(a,b);b=this.Jq?1231:1237;a=W().C(a,b);return W().Ma(a,5)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof aP&&this.$z===a.$z&&this.xx===a.xx&&this.fi===a.fi&&this.Jq===a.Jq){var b=this.kp;a=a.kp;return null===b?null===a:b.i(a)}return!1};f.$classData=q({fY:0},!1,"mlscript.ShowCtx",{fY:1,g:1,E:1,v:1,l:1});
+function YX(a,b,c,d,e,g,h,k,l,m,n){this.FE=this.Nu=this.UN=this.VN=null;this.jj=b;this.Wl=c;this.Xm=d;this.Cx=e;this.hI=g;this.iI=h;this.Bx=k;this.GE=l;this.at=m;this.gI=n;if(null===a)throw null;this.FE=a;a=op();d=d.Gb(a.ga);a:{if(null!==d&&(a=d.h(),b=d.j(),null!==a&&null!==b)){d=G(new H,a,b);break a}throw new w(d);}this.VN=d;this.UN=this.VN.j();this.Nu=t().d}YX.prototype=new p;YX.prototype.constructor=YX;
+function ZX(a,b,c){var d=a.Bx.Ja(new y(e=>new Ep(e.V)));a=a.Bx.m();a=new iy(a,c,!0);a=new xo(a,new y(e=>{var g=b.tb.U(e.V);return g.b()?ap():ZX(g.o(),b,c.bc(e))}));return d.Ce(a)}function dB(a){a=a.Nu;if(a.b()){a=nf();var b=ou().Yl;a=$X(a,b)}else a=a.o();return a}f=YX.prototype;f.H=function(){return"TypeDef"};f.G=function(){return 10};
+f.I=function(a){switch(a){case 0:return this.jj;case 1:return this.Wl;case 2:return this.Xm;case 3:return this.Cx;case 4:return this.hI;case 5:return this.iI;case 6:return this.Bx;case 7:return this.GE;case 8:return this.at;case 9:return this.gI;default:return $K(W(),a)}};f.D=function(a){return a instanceof YX};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof YX&&a.FE===this.FE){if(this.jj===a.jj){var b=this.Wl,c=a.Wl;b=null===b?null===c:b.i(c)}else b=!1;b?(b=this.Xm,c=a.Xm,(null===b?null===c:b.i(c))?(b=this.Cx,c=a.Cx,(null===b?null===c:mC(b,c))?(b=this.hI,c=a.hI,b=null===b?null===c:b.i(c)):b=!1):b=!1):b=!1;if(b&&(b=this.iI,c=a.iI,(null===b?null===c:b.i(c))?(b=this.Bx,c=a.Bx,(null===b?null===c:b.i(c))?(b=this.GE,c=a.GE,b=null===b?null===c:b.i(c)):b=!1):b=!1,b&&(b=this.at,c=a.at,null===b?null===c:b.i(c))))return b=
+this.gI,a=a.gI,null===b?null===a:b.i(a)}return!1};f.$classData=q({vY:0},!1,"mlscript.TypeDefs$TypeDef",{vY:1,g:1,E:1,v:1,l:1});function aY(a){if(null===a)throw null;}aY.prototype=new eS;aY.prototype.constructor=aY;aY.prototype.u=function(){return"TypeDef"};aY.prototype.$classData=q({wY:0},!1,"mlscript.TypeDefs$TypeDef$",{wY:1,Yba:1,g:1,oaa:1,l:1});function bY(){}bY.prototype=new cS;bY.prototype.constructor=bY;bY.prototype.u=function(){return"TypeName"};bY.prototype.n=function(a){return new Ep(a)};
+bY.prototype.$classData=q({DY:0},!1,"mlscript.TypeName$",{DY:1,dM:1,g:1,la:1,l:1});
+var cY,Sea=function Rea(a,b){var d=a.Ed.U(b);return d.b()?(a=(new Dx(a.Ec)).wF,a.b()?b=t().d:(a=a.o(),b=Rea(a,b)),b):d},uC=function dY(a,b,c){for(;;){if(Pe(new E(a.Lb),b.Lb)){var e=b.hc.U(c);if(e.b()){e=b.Ec;if(e.b())return R();e=e.o();return dY(a,e,c)}return e}if(a.Lb)if(e=b.Ec,e instanceof L)b=e.k;else return b.hc.U(c);else{e=b.hc.U(c);if(e instanceof L&&(e=e.k,e instanceof qx)){e=e.tp;var g=eY(b,c);if(g instanceof L){b=g.k;t();var h=g=a.S,k=new Ep("Var"),l=O().c;a=new qx(g,new fw(h,k,new z(e,new z(b,
+l)),V(a.S)),new vl(c));return new L(a)}e=b.Ec;if(e.b())return R();e=e.o();return dY(a,e,c)}e=b.Ec;if(e.b())return R();e=e.o();return dY(a,e,c)}}};function Iw(a,b,c,d,e,g,h,k,l,m,n,r,v){this.S=this.$N=null;this.Ec=b;this.hc=c;this.Ed=d;this.da=e;this.Pc=g;this.Zc=h;this.Lb=k;this.yc=l;this.tb=m;this.$a=n;this.od=r;this.cb=v;if(null===a)throw null;this.S=a;this.$N=Xu().X()}Iw.prototype=new p;Iw.prototype.constructor=Iw;
+function Wx(a,b){a.hc.$(b);if(a.Lb){var c=a.S,d=a.S,e=V(a.S),g=t().d;t();var h=new L(b.h()),k=O().c,l=O().c;c=new mx(c,new lx(d,a.da,k,l,g,h,!1,e),V(a.S));d=a.S;d.F&&(d=ut(Q(),"| ",d.r)+("Create skolem tag "+c+" for "+b.j())+" in quasiquote.",ff(gf(),d+"\n"));a=a.Pc;b=G(new H,b.h(),c);a.$(b)}}function Jw(a,b){for(b=b.m();b.s();){var c=b.t();Wx(a,c)}}function eY(a,b){var c=a.Pc.U(b);return c.b()?(a=(new Dx(a.Ec)).wF,a.b()?t().d:eY(a.o(),b)):c}
+function Tea(a,b){for(a=a.Pc.m();a.s();){var c=a.t(),d=c;c=d.j();d=V(d.j().q);b=dv(c,b,d,!1)}return b}function fY(a){var b=a.S.ib;for(a=new qA(a.Zc);a.s();){var c=a.t(),d=V(b.q);b=dv(b,c,d,!1)}return b}function gY(a,b){var c=a.S;c.F&&(c=ut(Q(),"| ",c.r)+"Capture free variable type "+b,ff(gf(),c+"\n"));FB(a.Zc,b)}function hY(a,b,c){t();b=G(new H,b,c);return Sea(a,new Ud(b))}
+function tf(a){up(tp(),!a.Lb);var b=new L(a),c=Xu().X(),d=Xu().X();return new Iw(a.S,b,c,d,a.da,a.Pc,a.Zc,a.Lb,a.yc,a.tb,a.$a,a.od,a.cb)}function iY(a){var b=new L(a),c=Xu().X(),d=Xu().X(),e=1+a.da|0,g=Xu().X(),h=new MB;return new Iw(a.S,b,c,d,e,g,h,!0,a.yc,a.tb,a.$a,a.od,a.cb)}function Uea(a){var b=new L(a),c=Xu().X(),d=Xu().X();return new Iw(a.S,b,c,d,a.da,a.Pc,a.Zc,!1,a.yc,a.tb,a.$a,a.od,a.cb)}
+function Sx(a,b,c,d){var e=1+a.da|0,g=Hw(),h=Su(),k=op().ga;g=g.Hd(new Uu(h,k));g=new Iw(a.S,a.Ec,a.hc,a.Ed,e,a.Pc,a.Zc,a.Lb,a.yc,a.tb,a.$a,a.od,g);b=b.n(g);e=g.cb;up(tp(),a.S.li||g.cb.b());if(!e.b()){g=a.S.qa;h=a.S;h.F&&(k=ut(Q(),"| ",h.r)+"UNSTASHING... (out)",ff(gf(),k+"\n"));h.r=1+h.r|0;try{e.Ca(new y(m=>{if(null!==m){var n=m.h();for(m=m.j().m();m.s();){var r=m.t();a:{if(null!==r){var v=r.j();if(!0===r.Rc()){r=Sw(a.S).ob;Tw(a.S,v,n,c,d,a,r);break a}}if(null!==r&&(v=r.j(),!1===r.Rc())){r=Sw(a.S).ob;
+Tw(a.S,n,v,c,d,a,r);break a}throw new w(r);}}}else throw new w(m);}));e.mg();var l=void 0}finally{h.r=-1+h.r|0}dx(new E(g),h.qa)&&h.F&&(l=""+ut(Q(),"| ",h.r)+g.n(l),ff(gf(),l+"\n"))}return b}
+function Px(a,b,c,d){var e=1+a.da|0,g=Hw(),h=Su(),k=op().ga;g=g.Hd(new Uu(h,k));e=new Iw(a.S,a.Ec,a.hc,a.Ed,e,a.Pc,a.Zc,a.Lb,a.yc,a.tb,a.$a,a.od,g);b=b.n(e);up(tp(),a.S.li||e.cb.b());Xu().X();g=vx(a.S);h=e.cb.m();h=new xo(h,new y(m=>{if(null!==m){var n=m.h();m=m.j().m();return new Ef(m,new y(r=>{if(null!==r){var v=r.Rc();r=r.j();up(tp(),r.Ea()>a.da);return v?G(new H,r,n):G(new H,n,r)}throw new w(r);}))}throw new w(m);}));Od();b=wx(g,Pd(u(),h),b);g=a.S;g.F&&(g=ut(Q(),"| ",g.r)+("Inferred poly constr: "+
+b+"  \u2014\u2014 where ")+xx(b),ff(gf(),g+"\n"));a.S.F&&Nm(new E(b),b)&&(g=a.S,g.F&&(g=ut(Q(),"| ",g.r)+("Refreshed:            "+b+"  \u2014\u2014 where ")+xx(b),ff(gf(),g+"\n")));b=yx(zx(a.S),a.da,b);e.cb.mg();g=e.cb;up(tp(),a.S.li||e.cb.b());if(!g.b()){e=a.S.qa;h=a.S;h.F&&(k=ut(Q(),"| ",h.r)+"UNSTASHING... (out)",ff(gf(),k+"\n"));h.r=1+h.r|0;try{g.Ca(new y(m=>{if(null!==m){var n=m.h();for(m=m.j().m();m.s();){var r=m.t();a:{if(null!==r){var v=r.j();if(!0===r.Rc()){r=Sw(a.S).ob;Tw(a.S,v,n,c,d,a,
+r);break a}}if(null!==r&&(v=r.j(),!1===r.Rc())){r=Sw(a.S).ob;Tw(a.S,n,v,c,d,a,r);break a}throw new w(r);}}}else throw new w(m);}));g.mg();var l=void 0}finally{h.r=-1+h.r|0}dx(new E(e),h.qa)&&h.F&&(l=""+ut(Q(),"| ",h.r)+e.n(l),ff(gf(),l+"\n"))}return b}function jY(a,b){return a.$N.Hk(b,new U(()=>{var c=a.tb.U(b);return c.b()?ap():ZX(c.o(),a,ap())}))}f=Iw.prototype;f.H=function(){return"Ctx"};f.G=function(){return 12};
+f.I=function(a){switch(a){case 0:return this.Ec;case 1:return this.hc;case 2:return this.Ed;case 3:return this.da;case 4:return this.Pc;case 5:return this.Zc;case 6:return this.Lb;case 7:return this.yc;case 8:return this.tb;case 9:return this.$a;case 10:return this.od;case 11:return this.cb;default:return $K(W(),a)}};f.D=function(a){return a instanceof Iw};
+f.B=function(){var a=lb("Ctx");a=W().C(-889275714,a);var b=this.Ec;b=My(W(),b);a=W().C(a,b);b=this.hc;b=My(W(),b);a=W().C(a,b);b=this.Ed;b=My(W(),b);a=W().C(a,b);b=this.da;a=W().C(a,b);b=this.Pc;b=My(W(),b);a=W().C(a,b);b=this.Zc;b=My(W(),b);a=W().C(a,b);b=this.Lb?1231:1237;a=W().C(a,b);b=this.yc?1231:1237;a=W().C(a,b);b=this.tb;b=My(W(),b);a=W().C(a,b);b=this.$a;b=My(W(),b);a=W().C(a,b);b=this.od;b=My(W(),b);a=W().C(a,b);b=this.cb;b=My(W(),b);a=W().C(a,b);return W().Ma(a,12)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Iw&&a.S===this.S){if(this.da===a.da&&this.Lb===a.Lb&&this.yc===a.yc){var b=this.Ec,c=a.Ec;(null===b?null===c:b.i(c))?(b=this.hc,c=a.hc,(null===b?null===c:b.i(c))?(b=this.Ed,c=a.Ed,b=null===b?null===c:b.i(c)):b=!1):b=!1}else b=!1;if(b&&(b=this.Pc,c=a.Pc,(null===b?null===c:b.i(c))?(b=this.Zc,c=a.Zc,(null===b?null===c:kY(b,c))?(b=this.tb,c=a.tb,b=null===b?null===c:b.i(c)):b=!1):b=!1,b&&(b=this.$a,c=a.$a,(null===b?null===c:b.i(c))?(b=this.od,c=a.od,
+b=null===b?null===c:b.i(c)):b=!1,b)))return b=this.cb,a=a.cb,null===b?null===a:lY(b,a)}return!1};f.$classData=q({OY:0},!1,"mlscript.Typer$Ctx",{OY:1,g:1,E:1,v:1,l:1});
+function fx(a,b,c,d,e){this.J=null;this.ct=!1;this.eo=null;this.Ru=0;this.uO=this.dt=this.jg=this.sO=this.Qu=null;this.LE=!1;this.AO=null;this.wI=!1;this.yO=this.iO=this.vO=this.lO=this.BO=this.kO=this.CO=this.qO=this.tO=this.zO=this.pO=this.jO=this.xO=this.wO=this.mO=null;this.nO=!1;this.oO=this.rO=null;this.Ha=0;this.Ab=b;this.fZ=c;this.cd=d;this.ne=e;FC(this,a);this.ct=!1;this.eo=t().d;this.Ru=this.cd.da;this.Qu=this.Ab.fd();this.sO=this.Ab.Cf.x;a=this.J;b=this.Ab.A();this.jg=jx(new kx,a,b,cy(this.Ab),
+(tx(this.J),t().d),(tx(this.J),!1));this.dt=nf();a=this.J;a.F&&(a=ut(Q(),"| ",a.r)+(this.cd.da+". Created lazy type info for ")+this.Ab,ff(gf(),a+"\n"));this.wI=this.LE=!1}fx.prototype=new WP;fx.prototype.constructor=fx;f=fx.prototype;f.u=function(){var a=this.Ab.Cf.x;if(this.ct)var b="\x3ccomputing\x3e";else b=this.eo,b=b.b()?"\x3cuncomputed\x3e":b.o().u();return a+" ~\x3e "+b};f.fd=function(){return this.Qu};
+function Mw(a){if(0===(1&a.Ha)&&0===(1&a.Ha)){var b=a.Ab;if(b instanceof yo){b=b.Di;for(var c=null,d=null;b!==u();){var e=b.e(),g=!1,h=null;b:if(e instanceof vl)h=e,t(),h=new Gp(h,h,O().c,O().c),h=new L(h);else{if(e instanceof Pl){g=!0;h=e;var k=h.Za,l=h.Qb;if(k instanceof vl&&l instanceof Gl){e=l.Ra;t();h=new Gp(h,k,O().c,e);h=new L(h);break b}}if(e instanceof Il&&(k=e,l=k.nl,k=k.np,l instanceof vl)){h=l;t();h=new Gp(h,h,k,O().c);h=new L(h);break b}if(g&&(l=h.Za,g=h.Qb,l instanceof Il&&(k=l.nl,l=
+l.np,k instanceof vl&&g instanceof Gl))){e=g.Ra;t();h=new L(new Gp(h,k,l,e));break b}Lw(a.J,Ye(new Te(new Ue(J(new K,["Unsupported parent specification"]))),u()),e.A(),a.ne);h=t().d}for(h=h.m();h.s();)e=new z(h.t(),u()),null===d?c=e:d.p=e,d=e;b=b.f()}b=null===c?u():c;for(d=c=null;b!==u();){k=b.e();b:{if(null!==k&&(h=k.Uj,e=k.oj,g=k.oi,l=k.Xi,null!==e)){k=e.x;var m=!1,n=a.cd;n=uC(n,n,k);if(n instanceof L){m=!0;var r=n;r=r.k;if(r instanceof VP){k=r;t();h=new L(new WX(h,e,k,g,l));break b}}if(m){Lw(a.J,
+Ye(new Te(new Ue(J(new K,["Cannot inherit from this"]))),u()),h.A(),a.ne);h=t().d;break b}if(t().d===n){e=a.J;g=new Te(new Ue(J(new K,["Could not find definition `","`"])));l=[We(Xe(),k)];Lw(e,Ye(g,J(new K,l)),h.A(),a.ne);h=t().d;break b}throw new w(n);}throw new w(k);}for(h=h.m();h.s();)e=new z(h.t(),u()),null===d?c=e:d.p=e,d=e;b=b.f()}b=null===c?u():c}else b=O().c;a.uO=b;a.Ha|=1}return a.uO}function Hx(a){0===(2&a.Ha)&&0===(2&a.Ha)&&(a.AO=wba(a),a.Ha|=2);return a.AO}
+function gx(a){if(0===(4&a.Ha)&&0===(4&a.Ha)){if(a.wI)var b=ap();else{a.wI=!0;b=Mw(a);var c=ap();b=xba(a,b,c)}a.mO=b;a.Ha|=4}return a.mO}f.Ag=function(){0===(8&this.Ha)&&0===(8&this.Ha)&&(this.wO=yba(this),this.Ha|=8);return this.wO};function Tx(a){0===(16&a.Ha)&&0===(16&a.Ha)&&(a.xO=zba(a),a.Ha|=16);return a.xO}function VD(a){0===(32&a.Ha)&&0===(32&a.Ha)&&(a.jO=Aba(a),a.Ha|=32);return a.jO}function Ow(a){0===(64&a.Ha)&&0===(64&a.Ha)&&(a.pO=a.fZ.bf(Tx(a)),a.Ha|=64);return a.pO}
+function px(a){0===(128&a.Ha)&&0===(128&a.Ha)&&(a.zO=Bba(a),a.Ha|=128);return a.zO}function Kw(a){0===(256&a.Ha)&&0===(256&a.Ha)&&(a.tO=Cba(a),a.Ha|=256);return a.tO}function mY(a){0===(512&a.Ha)&&0===(512&a.Ha)&&(a.qO=Dba(a),a.Ha|=512);return a.qO}function Ax(a){0===(1024&a.Ha)&&0===(1024&a.Ha)&&(a.CO=mY(a).h(),a.Ha|=1024);return a.CO}function Fba(a){0===(2048&a.Ha)&&0===(2048&a.Ha)&&(a.kO=mY(a).j(),a.Ha|=2048);return a.kO}
+function Zx(a){0===(4096&a.Ha)&&0===(4096&a.Ha)&&(a.BO=Eba(a),a.Ha|=4096);return a.BO}function Gx(a){0===(8192&a.Ha)&&0===(8192&a.Ha)&&(a.lO=Gba(a),a.Ha|=8192);return a.lO}function fy(a){0===(16384&a.Ha)&&0===(16384&a.Ha)&&(a.vO=Hba(a),a.Ha|=16384);return a.vO}function Bx(a){0===(32768&a.Ha)&&0===(32768&a.Ha)&&(a.iO=Iba(a),a.Ha|=32768);return a.iO}function Rx(a){0===(131072&a.Ha)&&0===(131072&a.Ha)&&(a.nO=Kba(a),a.Ha|=131072);return a.nO}
+function Ux(a){if(0===(262144&a.Ha)&&0===(262144&a.Ha)){var b;if(a.Ab instanceof Zn){var c=b=a.J,d=a.Ab.A(),e=cy(a.Ab);t();c=jx(new kx,c,d,e,new L(a.Ab.Cf.x),a.Ab instanceof yo);d=t().d;t();e=new L(a.Ab.Cf.x);var g=O().c,h=O().c,k=Rx(a)?1+a.Ru|0:a.Ru;b=new lx(b,k,g,h,d,e,!1,c)}else xm("Not supposed to use mutRecTV for "+a.Ab.fd()),b=void 0;a.rO=b;a.Ha|=262144}return a.rO}
+function Vx(a){if(0===(524288&a.Ha)&&0===(524288&a.Ha)){var b=a.J;var c=V(a.J),d=t().d;t();var e=UF(ve(),a.Ab.Cf.x);e=new L(e);var g=O().c,h=O().c;b=new lx(b,1+a.cd.da|0,g,h,d,e,!1,c);a.oO=b;a.Ha|=524288}return a.oO}f.fQ=function(a){return Kx(this,a)};f.$classData=q({dZ:0},!1,"mlscript.TyperDatatypes$DelayedTypeInfo",{dZ:1,nZ:1,UO:1,g:1,Eaa:1});function Uw(a,b,c,d){this.Va=null;this.Oa=b;this.ra=c;this.Pd=d;if(null===a)throw null;this.Va=a}Uw.prototype=new p;Uw.prototype.constructor=Uw;f=Uw.prototype;
+f.Ea=function(){var a=this.Oa;a.b()?a=R():(a=a.o(),a=new L(a.Ea()));a=(a.b()?this.ra.Ea():a.o())|0;var b=this.ra.Ea();return a>b?a:b};f.ub=function(a,b){var c=this.Oa;c=c.b()?this.Va.Gd:c.o().ub(a,b);a=this.ra.ub(a,b);return c>a?c:a};function Fw(a,b,c,d){var e=b.Oa;e=e.b()?a.Va.ib:e.o();var g=a.Oa;g=g.b()?a.Va.ib:g.o();return Zu(e,g,c,!0,d)?Zu(a.ra,b.ra,c,!0,d):!1}
+function Nv(a,b,c){var d=a.Va,e=a.Oa;if(e.b())e=b.Oa;else{e=e.o();var g=b.Oa;if(!g.b()){g=g.o();var h=V(e.q);e=dv(e,g,h,!1)}e=new L(e)}g=a.ra;b=b.ra;a=V(a.ra.q);return new Uw(d,e,Pu(g,b,a,!1),c)}function xw(a,b,c){var d=a.Va,e=a.Oa;if(e.b())e=R();else{e=e.o();var g=b.Oa;if(g.b())e=R();else{g=g.o();var h=V(e.q);e=new L(Pu(e,g,h,!1))}}g=a.ra;b=b.ra;a=V(a.ra.q);return new Uw(d,e,dv(g,b,a,!1),c)}function cB(a,b,c){var d=a.Oa;return new Uw(a.Va,d.b()?R():new L(b.n(d.o())),c.n(a.ra),a.Pd)}
+function LX(a,b,c,d,e){var g=a.Va,h=a.Oa;h.b()?h=R():(h=h.o(),h=new L(h.Kc(b,c,d,e)));return new Uw(g,h,a.ra.Kc(b,c,d,e),a.Pd)}f.u=function(){var a=this.Oa;if(a.b())return""+this.ra;a=a.o();return"mut "+(Pe(new E(a),this.Va.ib)?"":a)+".."+this.ra};f.H=function(){return"FieldType"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Oa;case 1:return this.ra;default:return $K(W(),a)}};f.D=function(a){return a instanceof Uw};f.B=function(){return AL(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Uw&&a.Va===this.Va){var b=this.Oa,c=a.Oa;if(null===b?null===c:b.i(c))return b=this.ra,a=a.ra,null===b?null===a:mC(b,a)}return!1};f.$classData=q({kZ:0},!1,"mlscript.TyperDatatypes$FieldType",{kZ:1,g:1,E:1,v:1,l:1});function nY(a){a=a.AK().m();a=new Ef(a,new y(b=>new vl(b.V)));return Aq(Bq(),a)}function oY(a){var b=a.rr().Dh;a=a.AK().Ja(new y(c=>c.V));return"#"+(b+("\x3c"+ze(a,"",",",""))+"\x3e")}
+function XB(a){return!!(a&&a.$classData&&a.$classData.rb.KO)}function pY(a,b){if(null===b)throw null;a.q=b;a.Be=a.q.Im;a.pe=-1+a.Be|0;a.oe=a;b.Fp=1+b.Fp|0}function zA(){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0}zA.prototype=new YP;zA.prototype.constructor=zA;function qY(){}qY.prototype=zA.prototype;zA.prototype.i=function(a){return mC(this,a)};
+zA.prototype.B=function(){if(0===(1&this.dd)<<24>>24&&0===(1&this.dd)<<24>>24){if(this instanceof lx)var a=this.sp;else if(this instanceof OA)a=this.Hi.B();else if(null!==this&&Gs(this))a=AL(this);else throw new w(this);this.ze=a;this.dd=(1|this.dd)<<24>>24}return this.ze};function pD(a){if(0===(2&a.dd)<<24>>24&&0===(2&a.dd)<<24>>24){a:if(a instanceof cC)var b=!0;else{for(b=ED(a,!1);!b.b();){if(pD(b.e())){b=!0;break a}b=b.f()}b=!1}a.Ae=b;a.dd=(2|a.dd)<<24>>24}return a.Ae}
+zA.prototype.Kc=function(a,b,c,d){var e=this.q,g=this.q.Df,h=ap();return fD(e,this,g,c,a,h,d,b)};zA.prototype.rT=function(){return uy(this)};function jx(a,b,c,d,e,g){a.Ga=c;a.lh=d;a.go=e;a.Zm=g;if(null===b)throw null;a.Wu=b;a.Ix=!e.b();return a}function kx(){this.go=this.lh=this.Ga=null;this.Ix=this.Zm=!1;this.Wu=null}kx.prototype=new p;kx.prototype.constructor=kx;function rY(){}f=rY.prototype=kx.prototype;
+f.u=function(){var a=this.Ix?"o: ":"",b=this.Ga;b.b()?b=this.lh:(b=b.o(),b=this.lh+":"+b);return a+"\u2039"+b+"\u203a"};f.H=function(){return"TypeProvenance"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.Ga;case 1:return this.lh;case 2:return this.go;case 3:return this.Zm;default:return $K(W(),a)}};f.D=function(a){return a instanceof kx};
+f.B=function(){var a=lb("TypeProvenance");a=W().C(-889275714,a);var b=this.Ga;b=My(W(),b);a=W().C(a,b);b=this.lh;b=My(W(),b);a=W().C(a,b);b=this.go;b=My(W(),b);a=W().C(a,b);b=this.Zm?1231:1237;a=W().C(a,b);return W().Ma(a,4)};f.i=function(a){if(this===a)return!0;if(a instanceof kx&&a.Wu===this.Wu){if(this.Zm===a.Zm){var b=this.Ga,c=a.Ga;b=null===b?null===c:b.i(c)}else b=!1;if(b&&this.lh===a.lh)return b=this.go,a=a.go,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({VO:0},!1,"mlscript.TyperDatatypes$TypeProvenance",{VO:1,g:1,E:1,v:1,l:1});function NP(a){if(null===a)throw null;}NP.prototype=new kS;NP.prototype.constructor=NP;NP.prototype.u=function(){return"TypeProvenance"};NP.prototype.$classData=q({HZ:0},!1,"mlscript.TyperDatatypes$TypeProvenance$",{HZ:1,$ba:1,g:1,qaa:1,l:1});function dQ(a,b){this.Qd=a;this.qe=b}dQ.prototype=new p;dQ.prototype.constructor=dQ;f=dQ.prototype;f.u=function(){return this.Bw()};
+f.Bw=function(){var a=this.qe;if(!0===this.Qd&&!0===a)return"\u00b1";a=this.qe;if(!1===this.Qd&&!0===a)return"-";a=this.qe;if(!0===this.Qd&&!1===a)return"+";a=this.qe;if(!1===this.Qd&&!1===a)return"\x3d";throw new w(this);};f.H=function(){return"VarianceInfo"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Qd;case 1:return this.qe;default:return $K(W(),a)}};f.D=function(a){return a instanceof dQ};
+f.B=function(){var a=lb("VarianceInfo");a=W().C(-889275714,a);var b=this.Qd?1231:1237;a=W().C(a,b);b=this.qe?1231:1237;a=W().C(a,b);return W().Ma(a,2)};f.i=function(a){return this===a?!0:a instanceof dQ?this.Qd===a.Qd&&this.qe===a.qe:!1};f.$classData=q({f_:0},!1,"mlscript.VarianceInfo",{f_:1,g:1,E:1,v:1,l:1});function gE(){this.SA=null;pz();var a=u();this.SA=qz(a)}gE.prototype=new p;gE.prototype.constructor=gE;
+function sn(a){if(a.SA.b())return t().d;Jo();var b=a.SA;Od();b=Ko(Pd(u(),b));a.SA.mg();t();return new L(b)}function Qo(a,b){a=sn(a);if(a instanceof L)return new z(a.k,b);if(t().d===a)return b;throw new w(a);}function po(a,b){a=sn(a);if(a instanceof L){a=a.k;t();b=rn(b);var c=O().c;return new Ud(new z(a,new z(b,c)))}if(t().d===a)return t(),new fe(b);throw new w(a);}f=gE.prototype;f.H=function(){return"TemporaryVariableEmitter"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};
+f.D=function(a){return a instanceof gE};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){return a instanceof gE};f.$classData=q({B_:0},!1,"mlscript.codegen.TemporaryVariableEmitter",{B_:1,g:1,E:1,v:1,l:1});function NE(a,b){this.Wi=a;this.mj=b}NE.prototype=new p;NE.prototype.constructor=NE;f=NE.prototype;
+f.u=function(){var a=ze(this.Wi,""," and ",""),b=this.mj.b()?"":" ",c=this.mj,d=O().c;if(null===d?null===c:d.i(c))d="";else{if(c===u())d=u();else{d=c.e();var e=d=new z(d.Sj.x,u());for(c=c.f();c!==u();){var g=c.e();g=new z(g.Sj.x,u());e=e.p=g;c=c.f()}}d=ze(d,"(",", ",")")}return a+b+d};
+function sY(a,b){var c=a.Wi;a=a.mj;if(null===b)throw new w(b);var d=b.Wi;b=b.mj;var e=O().c;if(null===e?null===d:e.i(d))return new NE(c,dl(b,a));if(d instanceof z)return e=d.z,e.lf=dl(e.lf,a),new NE(dl(d,c),b);throw new w(d);}function tY(a,b){var c=O().c;if(null===c?null===b:c.i(b))return a;if(b instanceof z)return c=b.z,c.lf=dl(c.lf,a.mj),new NE(dl(b,a.Wi),O().c);throw new w(b);}
+function Vea(a,b){a:for(var c=O().c,d=a.Wi,e=R();;){var g=!1,h=null,k=O().c;if(null===k?null===d:k.i(d)){b=e;break a}if(d instanceof z){g=!0;h=d;var l=h.z;k=h.p;if(l instanceof OE){h=l;if(Pe(new E(h.$x),b)){t();b=new L(new tl(c,h,k));break a}c=Xq(c,h);d=k;continue}}if(g&&(l=h.z,k=h.p,l instanceof UE)){h=l;if(Pe(new E(h.Yx),b)){t();b=new L(new tl(c,h,k));break a}c=Xq(c,h);d=k;continue}if(g&&(l=h.z,k=h.p,l instanceof SE)){h=l;Pe(new E(h.Wx),b)?(g=c,e.b()&&(t(),e=new L(new tl(g,h,k))),d=k):(c=Xq(c,h),
+d=k);continue}if(g)g=h.p,c=Xq(c,h.z),d=g;else throw new w(d);}if(b.b())return R();b=b.o();if(null!==b)a=G(new H,b.hb,new NE(dl(b.Rd,b.kc),a.mj));else throw new w(b);return new L(a)}function uY(a,b){var c=a.Wi,d=O().c;if(null===d?null===c:d.i(c))return c=O().c,b=b.ha(),new NE(c,dl(a.mj,b));if(c instanceof z)return c=c.z,d=c.lf,c.lf=dl(b.ha(),d),a;throw new w(c);}f.H=function(){return"Conjunction"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.Wi;case 1:return this.mj;default:return $K(W(),a)}};f.D=function(a){return a instanceof NE};f.B=function(){return AL(this)};f.i=function(a){if(this===a)return!0;if(a instanceof NE){var b=this.Wi,c=a.Wi;if(null===b?null===c:b.i(c))return b=this.mj,a=a.mj,null===b?null===a:b.i(a)}return!1};f.$classData=q({Q_:0},!1,"mlscript.ucs.Conjunction",{Q_:1,g:1,E:1,v:1,l:1});function bF(a,b,c,d){this.fr=a;this.ZA=b;this.Sj=c;this.gr=d}bF.prototype=new p;
+bF.prototype.constructor=bF;f=bF.prototype;f.H=function(){return"LetBinding"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.fr;case 1:return this.ZA;case 2:return this.Sj;case 3:return this.gr;default:return $K(W(),a)}};f.D=function(a){return a instanceof bF};
+f.B=function(){var a=lb("LetBinding");a=W().C(-889275714,a);var b=this.fr;b=My(W(),b);a=W().C(a,b);b=this.ZA?1231:1237;a=W().C(a,b);b=this.Sj;b=My(W(),b);a=W().C(a,b);b=this.gr;b=My(W(),b);a=W().C(a,b);return W().Ma(a,4)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof bF&&this.ZA===a.ZA&&this.fr===a.fr){var b=this.Sj,c=a.Sj;if(null===b?null===c:b.i(c))return b=this.gr,a=a.gr,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({T_:0},!1,"mlscript.ucs.LetBinding",{T_:1,g:1,E:1,v:1,l:1});class vY extends wS{constructor(a){super();yF(this,a,null,!0)}}vY.prototype.$classData=q({h0:0},!1,"mlscript.ucs.PartialTermError",{h0:1,OF:1,pc:1,g:1,l:1});function wY(a,b,c){this.no=a;this.nh=b;this.ZP=c}wY.prototype=new p;wY.prototype.constructor=wY;function GE(a){var b=a.no;b.b()?(a=a.nh,a instanceof wm||xm("`term` must be a `SimpleTerm` when `local` is empty")):a=b.o();return a}
+function xY(a){var b=a.no;if(b.b())return R();b=b.o();return new L(new bF(aF(),!1,b,a.nh))}f=wY.prototype;f.u=function(){var a=this.no;a:if(t().d===a)a="";else{if(a instanceof L){var b=a.k;if(null!==b){a=b.x+" @ ";break a}}throw new w(a);}return a+""+Zz(this.nh,!1)};f.H=function(){return"Scrutinee"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.no;case 1:return this.nh;default:return $K(W(),a)}};f.D=function(a){return a instanceof wY};f.B=function(){return AL(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof wY){var b=this.no,c=a.no;if(null===b?null===c:b.i(c))return b=this.nh,a=a.nh,null===b?null===a:b.i(a)}return!1};f.$classData=q({i0:0},!1,"mlscript.ucs.Scrutinee",{i0:1,g:1,E:1,v:1,l:1});q({l0:0},!1,"mlscript.utils.algorithms$CyclicGraphError",{l0:1,qd:1,pc:1,g:1,l:1});function yY(){}yY.prototype=new lT;yY.prototype.constructor=yY;function zY(){}zY.prototype=yY.prototype;function RD(a){var b=new oT;yF(b,a,null,!0);return b}class oT extends wS{}
+oT.prototype.$classData=q({a3:0},!1,"scala.NotImplementedError",{a3:1,OF:1,pc:1,g:1,l:1});function qG(){}qG.prototype=new p;qG.prototype.constructor=qG;f=qG.prototype;f.Ob=function(a,b){return GQ(this,a,b)};f.u=function(){return"\x3cfunction1\x3e"};f.Lc=function(){return!1};f.AJ=function(a){throw new w(a);};f.n=function(a){this.AJ(a)};f.$classData=q({g3:0},!1,"scala.PartialFunction$$anon$1",{g3:1,g:1,za:1,la:1,l:1});function FQ(a,b){this.GK=a;this.mR=b}FQ.prototype=new p;
+FQ.prototype.constructor=FQ;f=FQ.prototype;f.u=function(){return"\x3cfunction1\x3e"};f.Lc=function(a){return this.GK.Lc(a)};f.n=function(a){return this.mR.n(this.GK.n(a))};f.Ob=function(a,b){var c=this.GK.Ob(a,pG().Hv);return rG(pG(),c)?b.n(a):this.mR.n(c)};f.$classData=q({h3:0},!1,"scala.PartialFunction$AndThen",{h3:1,g:1,za:1,la:1,l:1});function EQ(a,b){this.IK=a;this.HK=b}EQ.prototype=new p;EQ.prototype.constructor=EQ;f=EQ.prototype;f.u=function(){return"\x3cfunction1\x3e"};
+f.Lc=function(a){a=this.IK.Ob(a,pG().Hv);return!rG(pG(),a)&&this.HK.Lc(a)};f.n=function(a){return this.HK.n(this.IK.n(a))};f.Ob=function(a,b){var c=this.IK.Ob(a,pG().Hv);return rG(pG(),c)?b.n(a):this.HK.Ob(c,new y(()=>b.n(a)))};f.$classData=q({i3:0},!1,"scala.PartialFunction$Combined",{i3:1,g:1,za:1,la:1,l:1});function Wr(a){this.k3=a}Wr.prototype=new cS;Wr.prototype.constructor=Wr;function Vr(a,b){a=a.k3.Ob(b,pG().Hv);return rG(pG(),a)?R():new L(a)}Wr.prototype.n=function(a){return Vr(this,a)};
+Wr.prototype.$classData=q({j3:0},!1,"scala.PartialFunction$Lifted",{j3:1,dM:1,g:1,la:1,l:1});function Ue(a){this.gG=null;this.Jv=a}Ue.prototype=new p;Ue.prototype.constructor=Ue;function Wea(){var a=new Ue(J(new K,["",".",""]));null===a.gG&&null===a.gG&&(a.gG=new uG(a));return a.gG}f=Ue.prototype;f.H=function(){return"StringContext"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Jv:$K(W(),a)};f.D=function(a){return a instanceof Ue};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Ue){var b=this.Jv;a=a.Jv;return null===b?null===a:b.i(a)}return!1};f.$classData=q({p3:0},!1,"scala.StringContext",{p3:1,g:1,E:1,v:1,l:1});function AY(){}AY.prototype=new p;AY.prototype.constructor=AY;function BY(){}f=BY.prototype=AY.prototype;f.m=function(){return this};f.b=function(){return!this.s()};f.nb=function(a){return kv(this,a)};f.Mn=function(a){return NT(this,a)};f.ph=function(a){return this.qk(a,-1)};
+f.qk=function(a,b){return OT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.Ca=function(a){cH(this,a)};f.De=function(a,b){return mB(this,a,b)};f.th=function(a){return eH(this,a)};f.Gc=function(a,b,c){return NB(this,a,b,c)};f.aj=function(a){return gH(this,a)};f.$i=function(a){return hH(this,a)};f.Gh=function(a,b,c,d){return iH(this,a,b,c,d)};f.ha=function(){Od();return Pd(u(),this)};f.Ti=function(){return pp(qp(),this)};f.Bj=function(a){return kB(this,a)};f.ad=function(){return er(this)};
+f.Q=function(){return-1};f.Ja=function(a){return new Ef(this,a)};function CY(){this.sm=null;this.sm=DY()}CY.prototype=new wT;CY.prototype.constructor=CY;CY.prototype.$classData=q({$4:0},!1,"scala.collection.Iterable$",{$4:1,pG:1,g:1,bg:1,l:1});var EY;function DK(){EY||(EY=new CY);return EY}function FY(){this.VR=this.UR=this.Nt=null;uea(this);GY=this;this.UR=tc();this.VR=new U(()=>HY().UR)}FY.prototype=new VT;FY.prototype.constructor=FY;
+FY.prototype.$classData=q({H5:0},!1,"scala.collection.Map$",{H5:1,I5:1,g:1,Ey:1,l:1});var GY;function HY(){GY||(GY=new FY);return GY}function IY(){this.YR=null;JY=this;this.YR=new KY}IY.prototype=new p;IY.prototype.constructor=IY;f=IY.prototype;f.Eb=function(){var a=new EV(16,.75);return new dU(a,new y(b=>new qv(b)))};f.Hh=function(a){return(a=(op(),pp(qp(),a)))&&a.$classData&&a.$classData.rb.oL?a:new qv(a)};f.Ib=function(a){return ZT(eU(),a)};f.X=function(){return this.YR};
+f.$classData=q({O5:0},!1,"scala.collection.MapView$",{O5:1,g:1,Nba:1,Ey:1,l:1});var JY;function LY(){this.Bl=null}LY.prototype=new p;LY.prototype.constructor=LY;function MY(){}MY.prototype=LY.prototype;function RE(a,b){return a.Bl.Hh(b)}function TE(a){return a.Bl.X()}f=LY.prototype;f.vl=function(a){return this.Bl.Ib(a)};f.Eb=function(){return this.Bl.Eb()};f.Ib=function(a){return this.vl(a)};f.X=function(){return TE(this)};f.Hh=function(a){return RE(this,a)};
+function hl(a){return a.Ii(new y(b=>b))}function NY(a,b){return a.vc(new OY(a,b))}function Xea(a,b){return a.wo(new y(c=>ml(nl(),b,c)),0)}function QU(a,b){return a.qo(new y(c=>ml(nl(),c,b)))}function Oca(a,b){return 0>b||b>a.K()?Rq().Pa:new PY(a,b)}function qw(a,b){var c=a.K(),d=a.ti();if(1===c)c=a.e(),d.$(c);else if(1<c){d.he(c);var e=new zc(c);a.Gc(e,0,2147483647);hj(Pj(),e,b);for(a=0;a<c;)d.$(e.a[a]),a=1+a|0}return d.Kb()}function QY(a,b,c){return a.Zh(new RY(c,b))}
+function SY(a){return 0===a.ab(0)}function TY(a,b){var c=a.Q();if(-1!==c){var d=b.Q();c=-1!==d&&c!==d}else c=!1;if(c)return!1;a:{a=a.m();for(b=b.m();a.s()&&b.s();)if(!ml(nl(),a.t(),b.t())){b=!1;break a}b=a.s()===b.s()}return b}function UY(){this.sm=null;this.sm=Bq()}UY.prototype=new wT;UY.prototype.constructor=UY;UY.prototype.$classData=q({X5:0},!1,"scala.collection.Set$",{X5:1,pG:1,g:1,bg:1,l:1});var VY;function WY(){VY||(VY=new UY);return VY}
+function XY(a,b){var c=a.Ub().Eb(),d=a.Ub().Eb();a.Ca(new y(e=>{e=b.n(e);c.$(e.h());return d.$(e.j())}));return G(new H,c.Kb(),d.Kb())}function YY(a,b){var c=a.Ub().Eb();for(a=a.m();a.s();){var d=b.n(a.t());c.$(d)}return c.Kb()}function zX(a,b){var c=a.Ub().Eb();for(a=a.m();a.s();){var d=b.n(a.t());c.zc(d)}return c.Kb()}function Bf(a,b){var c=a.Ub().Eb();a=a.m();for(b=b.m();a.s()&&b.s();){var d=G(new H,a.t(),b.t());c.$(d)}return c.Kb()}
+function Hf(a){var b=a.Ub().Eb(),c=0;for(a=a.m();a.s();){var d=G(new H,a.t(),c);b.$(d);c=1+c|0}return b.Kb()}function ZY(a,b){var c=a.ti();for(a=a.m();a.s();){var d=a.t();!1!==!!b.n(d)&&c.$(d)}return c.Kb()}function Pt(a,b){var c=a.Ub().Eb(),d=a.Ub().Eb();a.Ca(new y(e=>{e=b.n(e);if(e instanceof fe)return c.$(e.aa);if(e instanceof Ud)return d.$(e.fa);throw new w(e);}));return G(new H,c.Kb(),d.Kb())}
+function $Y(a,b){var c=a.ti();if(0<=b){var d=-b|0,e=a.Q();-1!==e&&c.he(e+d|0)}b=a.m().ph(b);for(a=a.m();b.s();)d=a.t(),c.$(d),b.t();return c.Kb()}function Yea(a,b,c){a=a.Eb();a.he(b);for(var d=0;d<b;){var e=Es(c);a.$(e);d=1+d|0}return a.Kb()}function aZ(a){this.GL=!1;this.XG=0;this.kS=this.Zv=null;if(null===a)throw null;this.kS=a;this.GL=!1;this.XG=0;this.Zv=a.dc}aZ.prototype=new gS;aZ.prototype.constructor=aZ;f=aZ.prototype;f.u=function(){return"\x3cfunction1\x3e"};
+f.ey=function(a,b){var c=My(W(),a),d=$G(bH(),c);this.GL?this.XG=lU(this.Zv,a,b,c,d,0,this.XG):(this.Zv=iU(this.Zv,a,b,c,d,0,!0),this.Zv!==this.kS.dc&&(this.GL=!0,this.XG=lI(HH(),kI(HH(),d,0))))};f.ba=function(a,b){this.ey(a,b)};f.n=function(a){this.ey(a.h(),a.j())};f.$classData=q({Y6:0},!1,"scala.collection.immutable.HashMap$accum$1",{Y6:1,nH:1,g:1,kz:1,la:1});function bZ(){this.sm=null;this.sm=Od()}bZ.prototype=new wT;bZ.prototype.constructor=bZ;
+bZ.prototype.Ib=function(a){return ZJ(a)?a:vT.prototype.Ib.call(this,a)};bZ.prototype.$classData=q({g7:0},!1,"scala.collection.immutable.Iterable$",{g7:1,pG:1,g:1,bg:1,l:1});var cZ;function DY(){cZ||(cZ=new bZ);return cZ}function dZ(){this.Ry=null;eZ=this;this.Ry=fZ(new gZ(new U(()=>hV())))}dZ.prototype=new p;dZ.prototype.constructor=dZ;f=dZ.prototype;f.Hh=function(a){return aU(this,a)};
+function Zea(a,b,c){var d=new aw(b),e=new IQ(c);return new gZ(new U(()=>{for(var g=d.rc,h=e.ve;0<h&&!g.b();)g=hZ(g).Lf(),d.rc=g,h=-1+h|0,e.ve=h;return hZ(g)}))}function aU(a,b){return b instanceof gZ?b:0===b.Q()?a.Ry:new gZ(new U(()=>iZ(FK(),b.m())))}function jZ(a,b,c){return b.s()?(a=b.t(),new eV(a,new gZ(new U(()=>jZ(FK(),b,c))))):Es(c)}function iZ(a,b){return b.s()?(a=b.t(),new eV(a,new gZ(new U(()=>iZ(FK(),b))))):hV()}
+function kZ(a,b,c){return new gZ(new U(()=>{FK();var d=kZ(FK(),b+c|0,c);return new eV(b,d)}))}f.Eb=function(){return new lZ};f.X=function(){return this.Ry};f.Ib=function(a){return aU(this,a)};f.$classData=q({i7:0},!1,"scala.collection.immutable.LazyList$",{i7:1,g:1,Nk:1,bg:1,l:1});var eZ;function FK(){eZ||(eZ=new dZ);return eZ}function mZ(){this.Pt=null;this.Pt=xV()}mZ.prototype=new XT;mZ.prototype.constructor=mZ;
+function Ov(a,b,c){if(b&&b.$classData&&b.$classData.rb.FS){O();var d=b.se();if(null===c?null===d:c.i(d))return b}return WT.prototype.qr.call(a,b,c)}mZ.prototype.qr=function(a,b){return Ov(this,a,b)};mZ.prototype.$classData=q({y8:0},!1,"scala.collection.immutable.SortedMap$",{y8:1,Z5:1,g:1,xL:1,l:1});var nZ;function sv(){nZ||(nZ=new mZ);return nZ}function oZ(a){this.Uk=a.We;this.bu=a.Jd}oZ.prototype=new eR;oZ.prototype.constructor=oZ;oZ.prototype.u=function(){return"\x3cfunction1\x3e"};
+oZ.prototype.n=function(a){this.bu=fR(this,this.bu,a.h(),a.j())};oZ.prototype.$classData=q({I8:0},!1,"scala.collection.immutable.TreeMap$Adder",{I8:1,e8:1,yS:1,g:1,la:1});function pZ(){}pZ.prototype=new p;pZ.prototype.constructor=pZ;
+function qZ(a,b,c){if(b instanceof rZ&&(a=b.Xe,null===c?null===a:c.i(a)))return b;if(b&&b.$classData&&b.$classData.rb.PG&&(a=b.se(),null===c?null===a:c.i(a)))return sZ(new rZ,jJ(nJ(),b.m(),b.ka()),c);if(b instanceof tZ&&(c===Fq()?a=!0:(a=Fq(),a=c===a.NB),a))return c===Fq()===0<b.lc?a=b.m():(a=new QX(b),a=uZ(new vZ,a)),b=jJ(nJ(),a,b.K()),sZ(new rZ,b,c);a=null;for(b=b.m();b.s();)a=gJ(nJ(),a,b.t(),null,!1,c);return sZ(new rZ,a,c)}pZ.prototype.GB=function(a){return new wZ(a)};
+pZ.prototype.pr=function(a,b){return qZ(0,a,b)};pZ.prototype.ng=function(a){return xZ(a)};pZ.prototype.$classData=q({M8:0},!1,"scala.collection.immutable.TreeSet$",{M8:1,g:1,dS:1,oG:1,l:1});var yZ;function zZ(){yZ||(yZ=new pZ);return yZ}function AZ(){BZ=this}AZ.prototype=new p;AZ.prototype.constructor=AZ;function CZ(a,b){a=a.Eb();var c=b.Q();0<=c&&a.he(c);a.zc(b);return a.Kb()}AZ.prototype.Eb=function(){var a=ce();return new dU(a,new y(b=>new Jr(b)))};AZ.prototype.vc=function(a){return CZ(this,a)};
+AZ.prototype.$classData=q({a9:0},!1,"scala.collection.immutable.WrappedString$",{a9:1,g:1,Pba:1,TK:1,l:1});var BZ;function DZ(){BZ||(BZ=new AZ);return BZ}function dU(a,b){this.OS=this.sC=null;if(null===a)throw null;this.sC=a;this.OS=b}dU.prototype=new p;dU.prototype.constructor=dU;f=dU.prototype;f.he=function(a){this.sC.he(a)};f.Kb=function(){return this.OS.n(this.sC.Kb())};f.zc=function(a){this.sC.zc(a);return this};f.$=function(a){this.sC.$(a);return this};
+f.$classData=q({v9:0},!1,"scala.collection.mutable.Builder$$anon$1",{v9:1,g:1,xg:1,xf:1,wf:1});function PV(a,b){a.lk=b;return a}function QV(){this.lk=null}QV.prototype=new p;QV.prototype.constructor=QV;function EZ(){}f=EZ.prototype=QV.prototype;f.he=function(){};function EF(a,b){a.lk.$(b);return a}function FZ(a,b){a.lk.zc(b);return a}f.zc=function(a){return FZ(this,a)};f.$=function(a){return EF(this,a)};f.Kb=function(){return this.lk};
+f.$classData=q({tC:0},!1,"scala.collection.mutable.GrowableBuilder",{tC:1,g:1,xg:1,xf:1,wf:1});function GZ(){this.sm=null;this.sm=QF()}GZ.prototype=new wT;GZ.prototype.constructor=GZ;GZ.prototype.$classData=q({Y9:0},!1,"scala.collection.mutable.Iterable$",{Y9:1,pG:1,g:1,bg:1,l:1});var HZ;function rO(){HZ||(HZ=new GZ);return HZ}function IZ(){this.Nt=null;this.Nt=Ty()}IZ.prototype=new VT;IZ.prototype.constructor=IZ;
+IZ.prototype.$classData=q({n$:0},!1,"scala.collection.mutable.Map$",{n$:1,I5:1,g:1,Ey:1,l:1});var JZ;function Xu(){JZ||(JZ=new IZ);return JZ}function KZ(){this.sm=null;this.sm=pz()}KZ.prototype=new wT;KZ.prototype.constructor=KZ;KZ.prototype.$classData=q({A$:0},!1,"scala.collection.mutable.Set$",{A$:1,pG:1,g:1,bg:1,l:1});var LZ;function jA(){LZ||(LZ=new KZ);return LZ}function MZ(){this.Pt=null;this.Pt=$V()}MZ.prototype=new XT;MZ.prototype.constructor=MZ;
+MZ.prototype.$classData=q({D$:0},!1,"scala.collection.mutable.SortedMap$",{D$:1,Z5:1,g:1,xL:1,l:1});var NZ;function Hw(){NZ||(NZ=new MZ);return NZ}function Hq(a,b,c){a.Qg=b;a.mT=c;yF(a,null,null,!1);return a}class Iq extends vea{constructor(){super();this.mT=this.Qg=null}Cj(){return this.mT}pQ(){}}Iq.prototype.$classData=q({lT:0},!1,"scala.runtime.NonLocalReturnControl",{lT:1,s4:1,pc:1,g:1,l:1});function OZ(){}OZ.prototype=new p;OZ.prototype.constructor=OZ;function PZ(){}PZ.prototype=OZ.prototype;
+function GP(a){return a instanceof Ud?new L(a.fa):R()}function QZ(){}QZ.prototype=new hW;QZ.prototype.constructor=QZ;function RZ(){}RZ.prototype=QZ.prototype;class qb extends iW{constructor(a){super();yF(this,a,null,!0)}}qb.prototype.$classData=q({O0:0},!1,"java.lang.ArithmeticException",{O0:1,Te:1,qd:1,pc:1,g:1,l:1});var eaa=q({T0:0},!1,"java.lang.Byte",{T0:1,ur:1,g:1,l:1,nf:1,Et:1},a=>Zb(a));function Kj(a){var b=new SZ;yF(b,a,null,!0);return b}
+function UL(){var a=new SZ;yF(a,null,null,!0);return a}class SZ extends iW{}SZ.prototype.$classData=q({ak:0},!1,"java.lang.IllegalArgumentException",{ak:1,Te:1,qd:1,pc:1,g:1,l:1});function XH(a){var b=new TZ;yF(b,a,null,!0);return b}class TZ extends iW{}TZ.prototype.$classData=q({CQ:0},!1,"java.lang.IllegalStateException",{CQ:1,Te:1,qd:1,pc:1,g:1,l:1});function aL(a,b){yF(a,b,null,!0);return a}class bL extends iW{}
+bL.prototype.$classData=q({eK:0},!1,"java.lang.IndexOutOfBoundsException",{eK:1,Te:1,qd:1,pc:1,g:1,l:1});class Aj extends iW{constructor(){super();yF(this,null,null,!0)}}Aj.prototype.$classData=q({n1:0},!1,"java.lang.NegativeArraySizeException",{n1:1,Te:1,qd:1,pc:1,g:1,l:1});function oL(a){var b=new UZ;yF(b,a,null,!0);return b}function le(){var a=new UZ;yF(a,null,null,!0);return a}class UZ extends iW{}UZ.prototype.$classData=q({o1:0},!1,"java.lang.NullPointerException",{o1:1,Te:1,qd:1,pc:1,g:1,l:1});
+var faa=q({q1:0},!1,"java.lang.Short",{q1:1,ur:1,g:1,l:1,nf:1,Et:1},a=>$b(a));function DT(){var a=new VZ;yF(a,null,null,!0);return a}function nv(a){var b=new VZ;yF(b,a,null,!0);return b}class VZ extends iW{}VZ.prototype.$classData=q({A1:0},!1,"java.lang.UnsupportedOperationException",{A1:1,Te:1,qd:1,pc:1,g:1,l:1});function WZ(){}WZ.prototype=new yS;WZ.prototype.constructor=WZ;function XZ(){}XZ.prototype=WZ.prototype;
+WZ.prototype.i=function(a){if(a===this)a=!0;else if(a&&a.$classData&&a.$classData.rb.OQ){var b;if(b=a.ka()===this.ka()){a=a.vv();a:{for(;a.s();)if(b=a.t(),!this.L(b)){a=!0;break a}a=!1}b=!a}a=b}else a=!1;return a};WZ.prototype.B=function(){for(var a=this.vv(),b=0;a.s();){var c=b;b=a.t();c|=0;b=ib(b)+c|0}return b|0};class kK extends iW{constructor(){super();yF(this,"mutation occurred during iteration",null,!0)}}
+kK.prototype.$classData=q({I1:0},!1,"java.util.ConcurrentModificationException",{I1:1,Te:1,qd:1,pc:1,g:1,l:1});function YZ(a,b){if(null===b)var c=0;else c=ib(b),c^=c>>>16|0;a=ZZ(a,b,c,c&(-1+a.wl.a.length|0));return null===a?null:a.xv}
+function $Z(a,b){this.wl=null;this.yv=this.jK=0;this.RQ=b;if(0>a)throw Kj("initialCapacity \x3c 0");if(0>=b)throw Kj("loadFactor \x3c\x3d 0.0");a=-1+a|0;a=4<a?a:4;a=(-2147483648>>Math.clz32(a)&a)<<1;this.wl=new (md(EN).Ia)(1073741824>a?a:1073741824);this.jK=Eb(this.wl.a.length*this.RQ);this.yv=0}$Z.prototype=new wN;$Z.prototype.constructor=$Z;f=$Z.prototype;f.ka=function(){return this.yv};f.LF=function(a){return YZ(this,a)};
+f.EF=function(a){if(null===a)var b=0;else b=ib(a),b^=b>>>16|0;return null!==ZZ(this,a,b,b&(-1+this.wl.a.length|0))};f.JF=function(){return new a_(this)};function ZZ(a,b,c,d){for(a=a.wl.a[d];;){if(null===a)return null;c===a.oy?(d=a.xB,d=null===b?null===d:La(b,d)):d=!1;if(d)return a;if(c<a.oy)return null;a=a.xr}}f.$classData=q({U1:0},!1,"java.util.HashMap",{U1:1,E1:1,g:1,SQ:1,l:1,Ff:1});function $ea(){var a=new b_,b=new $Z(16,.75);a.zv=b;return a}function b_(){this.zv=null}b_.prototype=new wN;
+b_.prototype.constructor=b_;f=b_.prototype;f.EF=function(a){return this.zv.EF(new bk(a))};f.LF=function(a){return YZ(this.zv,new bk(a))};f.ka=function(){return this.zv.yv};f.JF=function(){return new c_(this)};f.$classData=q({Y1:0},!1,"java.util.IdentityHashMap",{Y1:1,E1:1,g:1,SQ:1,l:1,Ff:1});function AH(a){var b=new d_;yF(b,a,null,!0);return b}function LU(){var a=new d_;yF(a,null,null,!0);return a}class d_ extends iW{}
+d_.prototype.$classData=q({u2:0},!1,"java.util.NoSuchElementException",{u2:1,Te:1,qd:1,pc:1,g:1,l:1});function e_(){this.ld="block"}e_.prototype=new kz;e_.prototype.constructor=e_;f=e_.prototype;f.H=function(){return"Block"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof e_};f.B=function(){return 64279661};f.u=function(){return"Block"};f.$classData=q({WT:0},!1,"mlscript.Block$",{WT:1,sx:1,g:1,E:1,v:1,l:1});var f_;
+function g_(){f_||(f_=new e_);return f_}function Xk(){}Xk.prototype=new eW;Xk.prototype.constructor=Xk;function afa(a,b){switch(a){case 40:return O(),a=Ik(),new fe(a);case 41:return O(),a=Ik(),new Ud(a);case 123:return O(),a=Jk(),new fe(a);case 125:return O(),a=Jk(),new Ud(a);case 91:return O(),a=Kk(),new fe(a);case 93:return O(),a=Kk(),new Ud(a);case 8249:return O(),a=Lk(),new fe(a);case 8250:return O(),a=Lk(),new Ud(a);default:return b.n(hc(a))}}
+function bfa(a){switch(a){case 40:return!0;case 41:return!0;case 123:return!0;case 125:return!0;case 91:return!0;case 93:return!0;case 8249:return!0;case 8250:return!0;default:return!1}}Xk.prototype.Lc=function(a){return bfa(Ea(a))};Xk.prototype.Ob=function(a,b){return afa(Ea(a),b)};Xk.prototype.$classData=q({aU:0},!1,"mlscript.BracketKind$$anonfun$unapply$1",{aU:1,Kf:1,g:1,la:1,za:1,l:1});function h_(){this.Vo=this.Uo=this.Wo=null;this.ci=0}h_.prototype=new Rk;h_.prototype.constructor=h_;f=h_.prototype;
+f.H=function(){return"Angle"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof h_};f.B=function(){return 63408307};f.u=function(){return"Angle"};f.$classData=q({bU:0},!1,"mlscript.BracketKind$Angle$",{bU:1,ru:1,g:1,E:1,v:1,l:1});var i_;function Lk(){i_||(i_=new h_);return i_}function j_(){this.Vo=this.Uo=this.Wo=null;this.ci=0}j_.prototype=new Rk;j_.prototype.constructor=j_;f=j_.prototype;f.H=function(){return"Curly"};f.G=function(){return 0};
+f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof j_};f.B=function(){return 65474477};f.u=function(){return"Curly"};f.$classData=q({cU:0},!1,"mlscript.BracketKind$Curly$",{cU:1,ru:1,g:1,E:1,v:1,l:1});var k_;function Jk(){k_||(k_=new j_);return k_}function l_(){this.Vo=this.Uo=this.Wo=null;this.ci=0}l_.prototype=new Rk;l_.prototype.constructor=l_;f=l_.prototype;f.H=function(){return"Indent"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};
+f.D=function(a){return a instanceof l_};f.B=function(){return-2100372276};f.u=function(){return"Indent"};f.$classData=q({dU:0},!1,"mlscript.BracketKind$Indent$",{dU:1,ru:1,g:1,E:1,v:1,l:1});var m_;function Mk(){m_||(m_=new l_);return m_}function n_(){this.Vo=this.Uo=this.Wo=null;this.ci=0}n_.prototype=new Rk;n_.prototype.constructor=n_;f=n_.prototype;f.H=function(){return"Quasiquote"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof n_};f.B=function(){return-404865879};
+f.u=function(){return"Quasiquote"};f.$classData=q({eU:0},!1,"mlscript.BracketKind$Quasiquote$",{eU:1,ru:1,g:1,E:1,v:1,l:1});var o_;function Nk(){o_||(o_=new n_);return o_}function p_(){this.Vo=this.Uo=this.Wo=null;this.ci=0}p_.prototype=new Rk;p_.prototype.constructor=p_;f=p_.prototype;f.H=function(){return"QuasiquoteTriple"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof p_};f.B=function(){return-2129833369};f.u=function(){return"QuasiquoteTriple"};
+f.$classData=q({fU:0},!1,"mlscript.BracketKind$QuasiquoteTriple$",{fU:1,ru:1,g:1,E:1,v:1,l:1});var q_;function Ok(){q_||(q_=new p_);return q_}function r_(){this.Vo=this.Uo=this.Wo=null;this.ci=0}r_.prototype=new Rk;r_.prototype.constructor=r_;f=r_.prototype;f.H=function(){return"Round"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof r_};f.B=function(){return 79151470};f.u=function(){return"Round"};
+f.$classData=q({gU:0},!1,"mlscript.BracketKind$Round$",{gU:1,ru:1,g:1,E:1,v:1,l:1});var s_;function Ik(){s_||(s_=new r_);return s_}function t_(){this.Vo=this.Uo=this.Wo=null;this.ci=0}t_.prototype=new Rk;t_.prototype.constructor=t_;f=t_.prototype;f.H=function(){return"Square"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof t_};f.B=function(){return-1810807491};f.u=function(){return"Square"};
+f.$classData=q({hU:0},!1,"mlscript.BracketKind$Square$",{hU:1,ru:1,g:1,E:1,v:1,l:1});var u_;function Kk(){u_||(u_=new t_);return u_}function v_(){this.Vo=this.Uo=this.Wo=null;this.ci=0}v_.prototype=new Rk;v_.prototype.constructor=v_;f=v_.prototype;f.H=function(){return"Unquote"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof v_};f.B=function(){return 1385561955};f.u=function(){return"Unquote"};
+f.$classData=q({iU:0},!1,"mlscript.BracketKind$Unquote$",{iU:1,ru:1,g:1,E:1,v:1,l:1});var w_;function Pk(){w_||(w_=new v_);return w_}function es(a){this.Iw=a}es.prototype=new Wz;es.prototype.constructor=es;f=es.prototype;f.H=function(){return"CLOSE_BRACKET"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Iw:$K(W(),a)};f.D=function(a){return a instanceof es};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){return this===a?!0:a instanceof es?this.Iw===a.Iw:!1};f.$classData=q({jU:0},!1,"mlscript.CLOSE_BRACKET",{jU:1,yk:1,g:1,E:1,v:1,l:1});function oX(a){this.rz=null;if(null===a)throw null;this.rz=a}oX.prototype=new eW;oX.prototype.constructor=oX;f=oX.prototype;
+f.nr=function(a,b){a:{if(null!==a){var c=a.h();if(c instanceof Mu){c=c.pd;var d=this.rz.Bk;if(null===d?null===c:d.i(c)){c=!0;break a}}}if(null!==a&&(c=a.j(),c instanceof Mu&&(c=c.pd,d=this.rz.Bk,null===d?null===c:d.i(c)))){c=!0;break a}c=!1}return c?!0:b.n(a)};f.sr=function(a){if(null!==a){var b=a.h();if(b instanceof Mu){b=b.pd;var c=this.rz.Bk;if(null===c?null===b:c.i(b))return!0}}return null!==a&&(a=a.j(),a instanceof Mu&&(a=a.pd,b=this.rz.Bk,null===b?null===a:b.i(a)))?!0:!1};f.Lc=function(a){return this.sr(a)};
+f.Ob=function(a,b){return this.nr(a,b)};f.$classData=q({sU:0},!1,"mlscript.ConstraintSolver$$anonfun$$nestedInanonfun$constrainImpl$103$1",{sU:1,Kf:1,g:1,la:1,za:1,l:1});function FX(a,b,c,d,e,g,h){this.DM=this.vH=this.BM=null;this.CM=!1;this.GM=this.EM=this.FM=null;if(null===a)throw null;this.BM=a;this.vH=b;this.DM=c;this.CM=d;this.FM=e;this.EM=g;this.GM=h}FX.prototype=new eW;FX.prototype.constructor=FX;f=FX.prototype;
+f.wJ=function(a,b){return a instanceof nC?EX(this.BM,this.vH.$a.n(a.rp.x),this.DM,this.CM,this.FM,this.EM,this.GM,this.vH):b.n(a)};f.PJ=function(a){return a instanceof nC};f.Lc=function(a){return this.PJ(a)};f.Ob=function(a,b){return this.wJ(a,b)};f.$classData=q({tU:0},!1,"mlscript.ConstraintSolver$$anonfun$1",{tU:1,Kf:1,g:1,la:1,za:1,l:1});function wX(a,b,c){this.HM=b;this.IM=c}wX.prototype=new eW;wX.prototype.constructor=wX;f=wX.prototype;
+f.xJ=function(a,b){var c=a.ma().Ga;if(Nm(new E(c),this.HM.Ga))if(c=a.ma().Ga,c.b())c=!1;else{c=c.o();var d=this.IM.Ga;d.b()?c=!0:(d=d.o(),c=OX(c,d)||Sy(d,c))}else c=!1;return c?a:b.n(a)};f.QJ=function(a){var b=a.ma().Ga;if(Nm(new E(b),this.HM.Ga)){a=a.ma().Ga;if(a.b())return!1;a=a.o();b=this.IM.Ga;if(b.b())return!0;b=b.o();return OX(a,b)||Sy(b,a)}return!1};f.Lc=function(a){return this.QJ(a)};f.Ob=function(a,b){return this.xJ(a,b)};
+f.$classData=q({uU:0},!1,"mlscript.ConstraintSolver$$anonfun$2",{uU:1,Kf:1,g:1,la:1,za:1,l:1});function xX(){}xX.prototype=new eW;xX.prototype.constructor=xX;f=xX.prototype;f.yJ=function(a,b){if(null!==a){var c=a.Ga,d=a.go;if(d instanceof L&&(d=d.k,!c.b()))return G(new H,d,a)}return b.n(a)};f.RJ=function(a){if(null!==a){var b=a.Ga;if(a.go instanceof L&&!b.b())return!0}return!1};f.Lc=function(a){return this.RJ(a)};f.Ob=function(a,b){return this.yJ(a,b)};
+f.$classData=q({vU:0},!1,"mlscript.ConstraintSolver$$anonfun$3",{vU:1,Kf:1,g:1,la:1,za:1,l:1});function uX(a,b,c){this.Ow=b;this.xU=c}uX.prototype=new eW;uX.prototype.constructor=uX;f=uX.prototype;
+f.yJ=function(a,b){if(null!==a){var c=a.Ga,d=a.lh;if(c instanceof L){var e=c.k;if(this.Ow.L(e)||a.Zm)h=!1;else{var g=!1;for(h=this.Ow.m();!g&&h.s();)g=h.t(),g=Sy(e,g);var h=!g}if(h)return this.Ow.Ca(new y(k=>{if(Sy(k,e))return this.xU.$(k)})),this.Ow.oh(e),a=new Te(new Ue(J(new K,["\u2022 this ",":"]))),d=[We(Xe(),d)],d=Ye(a,J(new K,d)),G(new H,d,c)}}return b.n(a)};
+f.RJ=function(a){if(null!==a){var b=a.Ga;if(b instanceof L){b=b.k;if(this.Ow.L(b)||a.Zm)b=!1;else{var c=!1;for(a=this.Ow.m();!c&&a.s();)c=a.t(),c=Sy(b,c);b=!c}if(b)return!0}}return!1};f.Lc=function(a){return this.RJ(a)};f.Ob=function(a,b){return this.yJ(a,b)};f.$classData=q({wU:0},!1,"mlscript.ConstraintSolver$$anonfun$4",{wU:1,Kf:1,g:1,la:1,za:1,l:1});function AX(a,b,c){this.KM=b;this.JM=c}AX.prototype=new eW;AX.prototype.constructor=AX;f=AX.prototype;
+f.nr=function(a,b){if(null!==a){var c=a.h(),d=a.j(),e=d.Ga;e.b()?e=!1:(e=e.o(),e=!this.KM.L(e));if(e)return this.JM.Am?(a=new Te(new Ue(J(new K,["Note: "," ",""]))),c=[We(Xe(),d.lh),We(Xe(),c)],c=Ye(a,J(new K,c))):(a=new Te(new Ue(J(new K,["      "," ",""]))),c=[We(Xe(),d.lh),We(Xe(),c)],c=Ye(a,J(new K,c))),this.JM.Am=!1,c=Ye(new Te(new Ue(J(new K,[""," is defined at:"]))),J(new K,[c])),G(new H,c,d.Ga)}return b.n(a)};
+f.sr=function(a){return null!==a&&(a=a.j().Ga,a.b()?a=!1:(a=a.o(),a=!this.KM.L(a)),a)?!0:!1};f.Lc=function(a){return this.sr(a)};f.Ob=function(a,b){return this.nr(a,b)};f.$classData=q({yU:0},!1,"mlscript.ConstraintSolver$$anonfun$5",{yU:1,Kf:1,g:1,la:1,za:1,l:1});function yX(){}yX.prototype=new eW;yX.prototype.constructor=yX;f=yX.prototype;f.xJ=function(a,b){return a instanceof cv||a instanceof Qv||Uv(a)||a instanceof zv||a instanceof fw||a instanceof FA||b.n(a)};
+f.QJ=function(a){return a instanceof cv||a instanceof Qv||Uv(a)||a instanceof zv||a instanceof fw||a instanceof FA};f.Lc=function(a){return this.QJ(a)};f.Ob=function(a,b){return this.xJ(a,b)};f.$classData=q({zU:0},!1,"mlscript.ConstraintSolver$$anonfun$lhsIsPlain$1$1",{zU:1,Kf:1,g:1,la:1,za:1,l:1});function x_(){}x_.prototype=new Wz;x_.prototype.constructor=x_;f=x_.prototype;f.H=function(){return"DEINDENT"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};
+f.D=function(a){return a instanceof x_};f.B=function(){return 1524287597};f.u=function(){return"DEINDENT"};f.$classData=q({DU:0},!1,"mlscript.DEINDENT$",{DU:1,yk:1,g:1,E:1,v:1,l:1});var y_;function rs(){y_||(y_=new x_);return y_}function sy(a){return!!(a&&a.$classData&&a.$classData.rb.ud)}function z_(){}z_.prototype=new jl;z_.prototype.constructor=z_;f=z_.prototype;f.H=function(){return"Lexing"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof z_};
+f.B=function(){return-2022196861};f.u=function(){return"Lexing"};f.$classData=q({JU:0},!1,"mlscript.Diagnostic$Lexing$",{JU:1,SM:1,g:1,E:1,v:1,l:1});var A_;function ir(){A_||(A_=new z_);return A_}function B_(){}B_.prototype=new jl;B_.prototype.constructor=B_;f=B_.prototype;f.H=function(){return"Parsing"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof B_};f.B=function(){return 871689872};f.u=function(){return"Parsing"};
+f.$classData=q({KU:0},!1,"mlscript.Diagnostic$Parsing$",{KU:1,SM:1,g:1,E:1,v:1,l:1});var C_;function ws(){C_||(C_=new B_);return C_}function D_(){}D_.prototype=new jl;D_.prototype.constructor=D_;f=D_.prototype;f.H=function(){return"Typing"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof D_};f.B=function(){return-1774931561};f.u=function(){return"Typing"};f.$classData=q({LU:0},!1,"mlscript.Diagnostic$Typing$",{LU:1,SM:1,g:1,E:1,v:1,l:1});var E_;
+function lu(){E_||(E_=new D_);return E_}function F_(){}F_.prototype=new Wz;F_.prototype.constructor=F_;f=F_.prototype;f.H=function(){return"INDENT"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof F_};f.B=function(){return-2130910036};f.u=function(){return"INDENT"};f.$classData=q({YU:0},!1,"mlscript.INDENT$",{YU:1,yk:1,g:1,E:1,v:1,l:1});var G_;function ks(){G_||(G_=new F_);return G_}function Xn(a,b,c){this.pV=b;this.qV=c}Xn.prototype=new eW;
+Xn.prototype.constructor=Xn;f=Xn.prototype;f.pj=function(a,b){if(a instanceof Zn){var c=a.wd,d=a.Rb,e=a.Ch,g=a.Yc;if(g instanceof fe&&(g=g.aa,c.b()||(c.b()?0:c.o())))return this.pV.oh(d.x),new Dp(!(c.b()||!c.o()),new Ep(this.qV),d,e,(O(),new fe(g)))}return b.n(a)};f.rj=function(a){if(a instanceof Zn){var b=a.wd;if(a.Yc instanceof fe&&(b.b()||(b.b()?0:b.o())))return!0}return!1};f.Lc=function(a){return this.rj(a)};f.Ob=function(a,b){return this.pj(a,b)};
+f.$classData=q({oV:0},!1,"mlscript.JSBackend$$anonfun$1",{oV:1,Kf:1,g:1,la:1,za:1,l:1});function Yn(a,b,c){this.iN=b;this.sV=c}Yn.prototype=new eW;Yn.prototype.constructor=Yn;f=Yn.prototype;f.pj=function(a,b){if(a instanceof Zn){var c=a.wd,d=a.Rb,e=a.Ch,g=a.Yc;if(g instanceof Ud&&(g=g.fa,a.Pl&&!this.iN.L(d.x)))return new Dp(!(c.b()||!c.o()),new Ep(this.sV),d,e,(O(),new Ud(g)))}return b.n(a)};f.rj=function(a){if(a instanceof Zn){var b=a.Rb;if(a.Yc instanceof Ud&&a.Pl&&!this.iN.L(b.x))return!0}return!1};
+f.Lc=function(a){return this.rj(a)};f.Ob=function(a,b){return this.pj(a,b)};f.$classData=q({rV:0},!1,"mlscript.JSBackend$$anonfun$2",{rV:1,Kf:1,g:1,la:1,za:1,l:1});function ao(){}ao.prototype=new eW;ao.prototype.constructor=ao;f=ao.prototype;f.pj=function(a,b){return a instanceof yo?a:b.n(a)};f.rj=function(a){return a instanceof yo};f.Lc=function(a){return this.rj(a)};f.Ob=function(a,b){return this.pj(a,b)};f.$classData=q({tV:0},!1,"mlscript.JSBackend$$anonfun$3",{tV:1,Kf:1,g:1,la:1,za:1,l:1});
+function yz(a,b){this.kD=a;this.jD=b}yz.prototype=new Jp;yz.prototype.constructor=yz;f=yz.prototype;f.xa=function(){for(var a=Sp(Qp()," catch ("+this.kD.tq+") "),b=this.jD,c=Qp().ye;!b.b();){var d=b.e();c=Iz(c,d.xa());b=b.f()}return Rp(a,Oz(c))};f.H=function(){return"JSCatchClause"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.kD;case 1:return this.jD;default:return $K(W(),a)}};f.D=function(a){return a instanceof yz};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof yz){var b=this.kD,c=a.kD;if(null===b?null===c:b.i(c))return b=this.jD,a=a.jD,null===b?null===a:b.i(a)}return!1};f.$classData=q({BV:0},!1,"mlscript.JSCatchClause",{BV:1,Xc:1,g:1,E:1,v:1,l:1});function vO(){}vO.prototype=new eW;vO.prototype.constructor=vO;vO.prototype.Lc=function(a){return a instanceof xO};vO.prototype.Ob=function(a,b){return a instanceof xO?a.ax:b.n(a)};
+vO.prototype.$classData=q({zW:0},!1,"mlscript.Message$$anonfun$typeBits$1",{zW:1,Kf:1,g:1,la:1,za:1,l:1});function xO(a){this.ax=a}xO.prototype=new Pq;xO.prototype.constructor=xO;f=xO.prototype;f.H=function(){return"Code"};f.G=function(){return 1};f.I=function(a){return 0===a?this.ax:$K(W(),a)};f.D=function(a){return a instanceof xO};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof xO){var b=this.ax;a=a.ax;return null===b?null===a:b.i(a)}return!1};f.$classData=q({BW:0},!1,"mlscript.Message$Code",{BW:1,AW:1,g:1,E:1,v:1,l:1});function Vq(a){this.Jz=a}Vq.prototype=new Pq;Vq.prototype.constructor=Vq;f=Vq.prototype;f.H=function(){return"Text"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Jz:$K(W(),a)};f.D=function(a){return a instanceof Vq};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){return this===a?!0:a instanceof Vq?this.Jz===a.Jz:!1};f.$classData=q({DW:0},!1,"mlscript.Message$Text",{DW:1,AW:1,g:1,E:1,v:1,l:1});function Dp(a,b,c,d,e){this.pN=this.oN=this.nN=null;this.rN=this.sN=0;this.tN=this.qN=null;this.Fs=0;this.hE=a;this.gE=b;this.uq=c;this.iE=d;this.bx=e;Nq(this);if(e instanceof Ud)a=e.fa;else{if(!(e instanceof fe))throw new w(e);a=e.aa}a=this.nN=a;b=O().c;this.oN=new z(c,new z(a,b))}Dp.prototype=new p;Dp.prototype.constructor=Dp;f=Dp.prototype;
+f.jn=function(){0===(1&this.Fs)<<24>>24&&0===(1&this.Fs)<<24>>24&&(this.pN=zq(this),this.Fs=(1|this.Fs)<<24>>24);return this.pN};f.rn=function(){return this.sN};f.fm=function(a){this.sN=a};f.qn=function(){return this.rN};f.em=function(a){this.rN=a};f.pn=function(){return this.qN};f.on=function(a){this.qN=a};f.A=function(){0===(2&this.Fs)<<24>>24&&0===(2&this.Fs)<<24>>24&&(this.tN=Dq(this),this.Fs=(2|this.Fs)<<24>>24);return this.tN};f.Vj=function(){return this.oN};f.H=function(){return"MethodDef"};
+f.G=function(){return 5};f.I=function(a){switch(a){case 0:return this.hE;case 1:return this.gE;case 2:return this.uq;case 3:return this.iE;case 4:return this.bx;default:return $K(W(),a)}};f.D=function(a){return a instanceof Dp};f.B=function(){var a=lb("MethodDef");a=W().C(-889275714,a);var b=this.hE?1231:1237;a=W().C(a,b);b=this.gE;b=My(W(),b);a=W().C(a,b);b=this.uq;b=My(W(),b);a=W().C(a,b);b=this.iE;b=My(W(),b);a=W().C(a,b);b=this.bx;b=My(W(),b);a=W().C(a,b);return W().Ma(a,5)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Dp){if(this.hE===a.hE){var b=this.gE,c=a.gE;b=null===b?null===c:b.i(c)}else b=!1;if(b&&(b=this.uq,c=a.uq,null===b?null===c:b.i(c))&&(b=this.iE,c=a.iE,null===b?null===c:b.i(c)))return b=this.bx,a=a.bx,null===b?null===a:b.i(a)}return!1};f.$classData=q({EW:0},!1,"mlscript.MethodDef",{EW:1,g:1,Ta:1,E:1,v:1,l:1});
+function kw(a){if(!a.rE){var b=a.vd.m(),c=a.fc;a:{if(c instanceof L&&(c=c.k,c instanceof Mu)){c=c.Fv().bc(c.pd);break a}c=ap()}for(;b.s();){var d=b.t();if(d instanceof nC){var e=d.Fv();c=c.Ce(e).bc(d.rp)}}a.qE=c;a.rE=!0}return a.qE}function Ku(a,b,c,d,e){this.pE=null;this.Mz=!1;this.qE=this.Fa=null;this.rE=!1;this.fc=b;this.vd=c;this.be=d;this.Me=e;if(null===a)throw null;this.Fa=a}Ku.prototype=new gv;Ku.prototype.constructor=Ku;f=Ku.prototype;
+f.u=function(){var a=this.fc;a=a.b()?"":a.o();var b=this.be,c=this.vd.m().nb(new U(()=>new Ou(this.Me)));c=new Ef(c,new y(d=>"\u2227"+d));return""+a+b+ze(c,"","","")};f.H=function(){return"LhsRefined"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.fc;case 1:return this.vd;case 2:return this.be;case 3:return this.Me;default:return $K(W(),a)}};f.D=function(a){return a instanceof Ku};f.B=function(){return AL(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Ku&&a.Fa===this.Fa){var b=this.fc,c=a.fc;(null===b?null===c:b.i(c))?(b=this.vd,c=a.vd,b=null===b?null===c:b.i(c)):b=!1;if(b&&(b=this.be,c=a.be,null===b?null===c:mC(b,c)))return b=this.Me,a=a.Me,null===b?null===a:b.i(a)}return!1};f.$classData=q({fX:0},!1,"mlscript.NormalForms$LhsRefined",{fX:1,eX:1,g:1,E:1,v:1,l:1});function IS(a){this.pE=null;this.Mz=!1;this.Fa=null;if(null===a)throw null;this.Fa=a}IS.prototype=new gv;IS.prototype.constructor=IS;
+f=IS.prototype;f.u=function(){return"\u22a4"};f.H=function(){return"LhsTop"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof IS};f.B=function(){return-2019595394};f.$classData=q({gX:0},!1,"mlscript.NormalForms$LhsTop$",{gX:1,eX:1,g:1,E:1,v:1,l:1});function jw(a,b,c,d){this.Nz=null;this.jx=!1;this.Aa=null;this.Xb=b;this.mb=c;this.Dc=d;rw(this,a)}jw.prototype=new tw;jw.prototype.constructor=jw;
+function cfa(a,b,c,d,e){var g=a.Aa,h=a.Xb,k=a.mb;if(k.b())k=R();else{k=k.o();if(k instanceof fe)k=k.aa,t(),k=k.qv(b,c,d,e),k=new fe(k);else if(k instanceof Ud)k=k.fa,t(),k=H_(k,b,c,d,e),k=new Ud(k);else throw new w(k);k=new L(k)}a=new pv(new qv(a.Dc),new y(r=>rv(r,b,c,d,e)));var l=sv(),m=Su(),n=op().ga;return new jw(g,h,k,(new tv(l,new Uu(m,n))).vc(a))}f=jw.prototype;
+f.u=function(){var a=ze(this.Xb,"","|",""),b=this.mb;if(b.b())b="";else{b=b.o();if(b instanceof Ud)b=""+b.fa;else{if(!(b instanceof fe))throw new w(b);b=""+b.aa}b="|"+b}var c=new Ou(this.Dc);c=new Ef(c,new y(d=>"|"+d));return a+b+ze(c,"","","")};f.H=function(){return"RhsBases"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.Xb;case 1:return this.mb;case 2:return this.Dc;default:return $K(W(),a)}};f.D=function(a){return a instanceof jw};f.B=function(){return AL(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof jw&&a.Aa===this.Aa){var b=this.Xb,c=a.Xb;(null===b?null===c:b.i(c))?(b=this.mb,c=a.mb,b=null===b?null===c:b.i(c)):b=!1;if(b)return b=this.Dc,a=a.Dc,null===b?null===a:b.i(a)}return!1};f.HJ=function(a,b,c,d){return cfa(this,a,b,c,d)};f.$classData=q({hX:0},!1,"mlscript.NormalForms$RhsBases",{hX:1,CN:1,g:1,E:1,v:1,l:1});function JS(a){this.Nz=null;this.jx=!1;this.Aa=null;rw(this,a)}JS.prototype=new tw;JS.prototype.constructor=JS;f=JS.prototype;
+f.u=function(){return"\u22a5"};f.H=function(){return"RhsBot"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof JS};f.B=function(){return-1847837782};f.HJ=function(){return this};f.$classData=q({iX:0},!1,"mlscript.NormalForms$RhsBot$",{iX:1,CN:1,g:1,E:1,v:1,l:1});function iw(a,b,c){this.Nz=null;this.jx=!1;this.Aa=null;this.me=b;this.Ne=c;rw(this,a)}iw.prototype=new tw;iw.prototype.constructor=iw;
+function H_(a,b,c,d,e){var g=a.Aa,h=a.me,k=a.Ne,l=k.Va,m=k.Oa;if(m.b())m=R();else{m=m.o();var n=a.Aa,r=a.Aa.Df,v=ap();m=new L(fD(n,m,r,d,b,v,e,c))}n=k.ra;r=a.Aa;a=a.Aa.Df;v=ap();return new iw(g,h,new Uw(l,m,fD(r,n,a,d,b,v,e,c),k.Pd))}f=iw.prototype;f.u=function(){return"{"+this.me.x+":"+this.Ne+"}"};f.H=function(){return"RhsField"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.me;case 1:return this.Ne;default:return $K(W(),a)}};f.D=function(a){return a instanceof iw};f.B=function(){return AL(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof iw&&a.Aa===this.Aa){var b=this.me,c=a.me;if(null===b?null===c:b.i(c))return b=this.Ne,a=a.Ne,null===b?null===a:b.i(a)}return!1};f.HJ=function(a,b,c,d){return H_(this,a,b,c,d)};f.$classData=q({jX:0},!1,"mlscript.NormalForms$RhsField",{jX:1,CN:1,g:1,E:1,v:1,l:1});
+var efa=function dfa(a,b,c){if(b instanceof Ql){var e=b.Vl,g=b.ml;if(e instanceof vl&&"this"===e.x)return c.oh(G(new H,g,(t(),new L(e)))),t().d}if(b instanceof vl)return"this"===b.x?(t(),new L(b)):(c.oh(G(new H,b,t().d)),t().d);if(b instanceof I_)return t().d;if(b instanceof Pm||b&&b.$classData&&b.$classData.rb.md||b instanceof Ct||b instanceof BS||b instanceof zS||b instanceof Dt){b=b.Vj();for(e=t().d;!b.b();)g=e,e=b.e(),e=g.b()?dfa(a,e,c):g,b=b.f();return e}throw new w(b);};
+function ffa(a,b,c,d,e,g,h){for(;;)if(b instanceof z){var k=b.z;b=b.p;if(k instanceof Ct)var l=t().d;else if(k instanceof Pm){var m=k;l=Rw(a,m,c,d,e,!0);if(!(g||b.b()&&h))if(m instanceof Dl||m instanceof Ol)JX(a,We(Xe(),"Pure expression does nothing in statement position."),m.A(),d);else{k=ux(a,l,jx(new kx,a,Lq(m),"expression in statement position",(tx(a),t().d),(tx(a),!1)));var n=a.Ck,r=new y(((x,A)=>B=>{fr();var C=Ye(new Te(new Ue(J(new K,["Expression in statement position should have type `()`."]))),
+u()),D=t().d;C=G(new H,C,D);D=Ye(new Te(new Ue(J(new K,["Use a comma expression `... , ()` to explicitly discard non-unit values, making your intent clearer."]))),u());var F=t().d;D=G(new H,D,F);A.n(hr(0,new z(C,new z(D,B.vt())),x.$c,lu()))})(a,d));m=jx(new kx,a,m.A(),hu(m),(tx(a),t().d),(tx(a),!1));var v=Sw(a).ob;Tw(a,k,n,r,m,c,v)}t();l=new L(l)}else sy(k)?(l=k,k=a,n=new Te(new Ue(J(new K,["Illegal position for this "," statement."]))),r=[We(Xe(),l.jb())],Lw(k,Ye(n,J(new K,r)),l.A(),d),l=t().d):
+xm("Program reached and unexpected state.");k=O().c;if(null===k?null===b:k.i(b))return l}else{a=O().c;if(null===a?null===b:a.i(b))return t().d;throw new w(b);}}function J_(){this.io=this.ho=this.jo=null;this.Fp=this.Gp=this.an=this.Ep=0;this.qa=null;this.r=0;this.zk=this.Pq=this.Uq=this.xp=this.Bp=this.Cp=this.Sq=this.zp=this.Rq=this.wp=this.Ap=this.yp=this.Qq=this.Tq=null;this.Dp=0;this.hs=this.yq=this.Aq=this.Bq=this.zq=this.Dq=this.Cq=null;this.Im=this.Pw=0;this.Ku=null}J_.prototype=new DX;
+J_.prototype.constructor=J_;function K_(){}K_.prototype=J_.prototype;
+function Dy(a,b,c,d,e,g,h,k,l,m){if(Ot(new E(d.pb),zp())&&h.b()){if(g.b())return e=d.gb,g=O().c,new fw(a,e,g,V(a));c=zx(a);d=d.gb;if(g===u())g=u();else{m=g.e();h=m=new z(m.hb,u());for(g=g.f();g!==u();)k=g.e(),k=new z(k.hb,u()),h=h.p=k,g=g.f();g=m}return yx(c,e,new fw(a,d,g,V(a)))}if(Ot(new E(d.pb),Bp())||Ot(new E(d.pb),zp())){Ot(new E(d.pb),zp())&&Lw(a,Ye(new Te(new Ue(J(new K,["Parameterized modules are not yet supported"]))),u()),c,m);a.F&&(l=ut(Q(),"| ",a.r)+("params: "+h+" ")+k,ff(gf(),l+"\n"));
+if(!b)if(h.b()){if(k.b())return e=new Te(new Ue(J(new K,["Class "," cannot be instantiated as it exposes no constructor"]))),g=[We(Xe(),d.gb.V)],Lw(a,Ye(e,J(new K,g)),c,m);b=new Te(new Ue(J(new K,["Construction of unparameterized class "," should use the `new` keyword"])));l=[We(Xe(),d.gb.V)];Lw(a,Ye(b,J(new K,l)),c,m)}else k.b()||Lw(a,Ye(new Te(new Ue(J(new K,["Construction of class with auxiliary constructor should use the `new` keyword"]))),u()),c,m);if(k instanceof L)c=k.k,m=ry(lv(),c,new y(n=>
+{var r=V(a);return new Uw(n.q,R(),n,r)}));else{if(t().d!==k)throw new w(k);m=h.b()?O().c:h.o()}c=zx(a);m=JF(lv(),m,it());m=new zv(a,m,V(a));d=d.gb;if(g===u())g=u();else{h=g.e();k=h=new z(h.hb,u());for(g=g.f();g!==u();)b=g.e(),b=new z(b.hb,u()),k=k.p=b,g=g.f();g=h}g=new fw(a,d,g,V(a));return yx(c,e,new cv(a,m,g,V(a)))}return Ey(a)}function Vy(a,b){pz();var c=u();c=qz(c);return new XX(a,efa(a,b,c),Aq(Bq(),c))}
+function of(a,b,c,d,e,g){var h=a.qa;if(a.F){var k=ut(Q(),"| ",a.r)+(d.da+". Typing ")+b;ff(gf(),k+"\n")}a.r=1+a.r|0;try{for(var l=c.b(),m=ef(b);!m.b();){var n=m.e();if(n instanceof Zn){k=n;if(k.wd.b())if(c.b())v=!1;else var r=c.o().CB(),v=Ot(new E(r),g_());else v=!1;v&&Lw(a,Ye(new Te(new Ue(J(new K,["Cannot use `val` or `fun` in local block; use `let` instead."]))),u()),k.A(),e)}m=m.f()}var x=Xu().X(),A=ef(b);Od();var B=new fp;Od();var C=new fp;for(b=A;!b.b();){var D=b.e();if(D instanceof Ct){m=D;
+t();var F=new fe(m)}else t(),F=new Ud(D);if(F instanceof fe)wp(B,F.aa);else if(F instanceof Ud)wp(C,F.fa);else throw new w(F);b=b.f()}var I=B.ha(),M=C.ha(),N=Xu().X();B=va=>{if(va instanceof Zn){var Ra=va.Rb;if(va.Yc instanceof Ud)return rx(va)&&Lw(a,We(Xe(),"`let` bindings must have a right-hand side"),va.A(),e),N.ou(Ra.x,new y(rb=>{if(rb instanceof L)return rb=rb.k,Lw(a,We(Xe(),"A type signature for '"+Ra.x+"' was already given"),va.A(),e),t(),new L(rb);if(t().d===rb)return t(),new L(va);throw new w(rb);
+})),!1}return!0};a:for(var P;;)if(I.b()){P=u();break}else{var T=I.e(),Y=I.f();if(!1===!!B(T))I=Y;else for(T=I;;){if(Y.b())P=T;else{var Z=Y.e();if(!1!==!!B(Z)){Y=Y.f();continue}Z=Y;var S=new z(T.e(),u()),ea=T.f();for(Y=S;ea!==Z;){var ia=new z(ea.e(),u());Y=Y.p=ia;ea=ea.f()}var X=Z.f();for(ea=X;!X.b();){var sa=X.e();if(!1===!!B(sa)){for(;ea!==X;){var Ja=new z(ea.e(),u());Y=Y.p=Ja;ea=ea.f()}ea=X.f()}X=X.f()}ea.b()||(Y.p=ea);P=S}break a}}var Xa=l?N.ry(new y(va=>{if(null!==va){va=va.j();var Ra=new fx(a,
+va,g,d,e),rb=va.hj;rb.b()||(rb=rb.o().x,Wx(d,G(new H,rb,Ra)));return G(new H,va.Cf.x,Ra)}throw new w(va);})):O().c;S=va=>{if(null!==va){if(va instanceof Zn){up(tp(),va.kx.b());var Ra=N.U(va.Rb.x);if(Ra instanceof L){Ra=Ra.k;var rb=va.wd,xb=va.Rb,mc=va.hj,Ha=va.Ch,Ka=va.Yc,Oa=va.Pz,Na=va.lx,Da=va.Om;t();var ta=new Zn(rb,xb,mc,Ha,Ka,Oa,Na,Da,new L(Ra),c,va.Pl,va.Oz)}else ta=new Zn(va.wd,va.Rb,va.hj,va.Ch,va.Yc,va.Pz,va.lx,va.Om,va.kx,c,va.Pl,va.Oz)}else{if(!(va instanceof yo))throw new w(va);Xca(new E(va.gb.V),
+a.tP)&&(Ra=new Te(new Ue(J(new K,["Type name '","' is reserved"]))),rb=[We(Xe(),va.gb.V)],Lw(a,Ye(Ra,J(new K,rb)),va.A(),e));ta=va}var Ya=new fx(a,ta,g,d,e);if(ta instanceof yo)va=d.$a,Ra=G(new H,ta.gb.V,Ya),va.$(Ra);else if(ta instanceof Zn)va=ta.hj,va.b()||(va=va.o().x,Wx(d,G(new H,va,Ya)));else throw new w(ta);x.ou(ta.Cf.x,new y(dc=>{if(dc instanceof L){if(!(ta instanceof Zn&&ta.wd instanceof L)){dc=new Te(new Ue(J(new K,["Redefinition of '","'"])));var ka=[We(Xe(),ta.Cf.x)];Lw(a,Ye(dc,J(new K,
+ka)),ta.A(),e)}t();return new L(Ya)}if(t().d===dc)return t(),new L(Ya);throw new w(dc);}));return G(new H,ta.Cf.x,Ya)}throw new w(va);};if(P===u())var Fa=u();else{var za=P.e(),Qa=new z(S(za),u());za=Qa;for(var Ma=P.f();Ma!==u();){var Ga=Ma.e(),ab=new z(S(Ga),u());za=za.p=ab;Ma=Ma.f()}Fa=Qa}Jw(d,Fa);Jw(d,Xa);var Hb=ry(lv(),Xa,new y(va=>{var Ra=!1,rb=null;va=Kx(va,e);if(va instanceof bx&&(Ra=!0,rb=va,!rb.Mb.Pz.b()))return a.La;if(Ra)return rb.Nn();xm("Program reached and unexpected state.")}));op();
+var bc=pp(qp(),Hb);lv();var yb=un(Fa,Xa),tb=ry(0,yb,new y(va=>{va=Kx(va,e);if(va instanceof bx){var Ra=bc.U(va.Ua());if(Ra instanceof L){Ra=Ra.k;var rb=va.Mb.A();rb=jx(new kx,a,rb,cy(va.Mb),(tx(a),t().d),(tx(a),!1));Nea(a,va.Nn(),Ra,d,e,rb)}else Ra=va.Ua(),rb=new qx(a,va.Nn(),va.Mb.Rb),Wx(d,G(new H,Ra,rb)),Ra=va.Mb.hj,Ra.b()?Ra=R():(Ra=Ra.o(),Ra=new L(Ra.x)),Ra.b()||(Ra=Ra.o(),rb=new qx(a,va.Nn(),va.Mb.Rb),Wx(d,G(new H,Ra,rb)))}return new ix(a,va)}));Jw(d,tb);if(c.b())var eb=R();else{var kb=c.o();
+eb=new L(kb.CB())}b:if(t().d===eb)var Rb=!0;else{if(eb instanceof L){var Gb=eb.k;if(g_()===Gb||hx()===Gb){Rb=!0;break b}}Rb=!1}if(Rb)var vb=!0;else if(eb instanceof L&&eb.k instanceof WS)vb=!1;else throw new w(eb);var Tb=new y(va=>": "+va);if(a.F){var Nb=ut(Q(),"| ",a.r)+"Typing unit statements";ff(gf(),Nb+"\n")}a.r=1+a.r|0;try{var ic=ffa(a,M,d,e,g,l,vb)}finally{a.r=-1+a.r|0}if(dx(new E(Tb),a.qa)&&a.F){var Va=""+ut(Q(),"| ",a.r)+Tb.n(ic);ff(gf(),Va+"\n")}if(tb===u())var cb=u();else{var zb=tb.e(),
+Ub=new z(zb.j().kh,u());l=Ub;for(var jb=tb.f();jb!==u();){var db=jb.e(),ub=new z(db.j().kh,u());l=l.p=ub;jb=jb.f()}cb=Ub}var Aa=new By(a,cb,ic)}finally{a.r=-1+a.r|0}dx(new E(h),a.qa)&&a.F&&(h=""+ut(Q(),"| ",a.r)+h.n(Aa),ff(gf(),h+"\n"));return Aa}
+function Jx(a,b,c,d,e){var g=Xu().X(),h=c.x;c=b.Ag();if(d.b()){var k=b.Ag();b=n=>{if(null!==n){n=n.hb;var r=n.ji;t();var v=new L(n),x=n.kg,A=O().c,B=O().c;return new lx(a,n.Xa,A,B,v,x,!1,r)}throw new w(n);};if(k===u())b=u();else{d=k.e();var l=d=new z(b(d),u());for(k=k.f();k!==u();){var m=k.e();m=new z(b(m),u());l=l.p=m;k=k.f()}b=d}}else b=d.o();c=new Wq(c,c,b);b=new fn((n,r)=>{n=G(new H,n,r);var v=n.y;r=n.w;if(null!==v){n=v.kc;v=v.hb;if(r instanceof lx){if(a.F){var x=ut(Q(),"| ",a.r)+("Passing "+
+n.V+" :: "+v+" \x3c\x3d\x3c ")+r;ff(gf(),x+"\n")}}else{a.F&&(x=ut(Q(),"| ",a.r)+("Assigning "+n.V+" :: "+v+" :\x3d "+r+" where ")+xx(r),ff(gf(),x+"\n"));x=v.ji;t();var A=new L(v),B=v.kg,C=vy(v),D=rA(v),F=r.Ea();x=new lx(a,F,C,D,A,B,!1,x);a.F&&(A=ut(Q(),"| ",a.r)+("Set "+x+" ~\x3e ")+v,ff(gf(),A+"\n"));up(tp(),x.Sb.b());if(!vy(x).b())throw new Yj("assertion failed: "+vy(x));if(!rA(x).b())throw new Yj("assertion failed: "+rA(x));wy(x,(t(),new L(r)));r=x}v=G(new H,v,r);g.$(v);v=h+"#"+n.V;t();n=new Vw(a,
+n,new Uw(a,new L(r),r,V(a)),!0,e.da);return G(new H,v,n)}throw new w(n);});Yq();c=Ew(c,b);op();c=pp(qp(),c);return G(new H,g,c)}function Fx(){}Fx.prototype=new eW;Fx.prototype.constructor=Fx;f=Fx.prototype;f.pj=function(a,b){return a instanceof Zn&&!rx(a)?a.Rb:b.n(a)};f.rj=function(a){return a instanceof Zn&&!rx(a)?!0:!1};f.Lc=function(a){return this.rj(a)};f.Ob=function(a,b){return this.pj(a,b)};
+f.$classData=q({rX:0},!1,"mlscript.NuTypeDefs$DelayedTypeInfoImpl$$anonfun$$nestedInanonfun$allFields$4$1",{rX:1,Kf:1,g:1,la:1,za:1,l:1});function sx(){}sx.prototype=new eW;sx.prototype.constructor=sx;f=sx.prototype;f.pj=function(a,b){if(a instanceof Zn){var c=a.wd,d=a.Yc;c=t().d===c?!0:c instanceof L&&!1===!!c.k?!0:!1;if(c&&d instanceof fe)return a}return b.n(a)};f.rj=function(a){if(a instanceof Zn){var b=a.wd;a=a.Yc;b=t().d===b?!0:b instanceof L&&!1===!!b.k?!0:!1;if(b&&a instanceof fe)return!0}return!1};
+f.Lc=function(a){return this.rj(a)};f.Ob=function(a,b){return this.pj(a,b)};f.$classData=q({sX:0},!1,"mlscript.NuTypeDefs$DelayedTypeInfoImpl$$anonfun$2",{sX:1,Kf:1,g:1,la:1,za:1,l:1});function Zy(a){this.FN=null;if(null===a)throw null;this.FN=a}Zy.prototype=new eW;Zy.prototype.constructor=Zy;Zy.prototype.Lc=function(a){return a instanceof Vw||a instanceof bx};
+Zy.prototype.Ob=function(a,b){if(a instanceof Vw)b=a.ij.Zr(),a=G(new H,b,a.ig);else if(a instanceof bx){b=a.hh;a=a.Mb.Rb;var c=V(this.FN.J);b=new Uw(b.q,R(),b,c);a=G(new H,a,b)}else a=b.n(a);return a};Zy.prototype.$classData=q({tX:0},!1,"mlscript.NuTypeDefs$DelayedTypeInfoImpl$$anonfun$3",{tX:1,Kf:1,g:1,la:1,za:1,l:1});function L_(){}L_.prototype=new eW;L_.prototype.constructor=L_;L_.prototype.Lc=function(a){return null!==a&&a.Rd instanceof L?!0:!1};
+L_.prototype.Ob=function(a,b){a:{if(null!==a){var c=a.hb,d=a.Rd;if(d instanceof L){a=G(new H,c,d.k);break a}}a=b.n(a)}return a};L_.prototype.$classData=q({BX:0},!1,"mlscript.NuTypeDefs$TypedNuCls$$anonfun$1",{BX:1,Kf:1,g:1,la:1,za:1,l:1});function Zr(a){this.qx=a}Zr.prototype=new Wz;Zr.prototype.constructor=Zr;f=Zr.prototype;f.H=function(){return"OPEN_BRACKET"};f.G=function(){return 1};f.I=function(a){return 0===a?this.qx:$K(W(),a)};f.D=function(a){return a instanceof Zr};f.B=function(){return AL(this)};
+f.u=function(){return VK(this)};f.i=function(a){return this===a?!0:a instanceof Zr?this.qx===a.qx:!1};f.$classData=q({IX:0},!1,"mlscript.OPEN_BRACKET",{IX:1,yk:1,g:1,E:1,v:1,l:1});function gz(){}gz.prototype=new eW;gz.prototype.constructor=gz;f=gz.prototype;f.vJ=function(a,b){if(a instanceof Pl){var c=a.Za,d=a.Qb,e=c.A();if(e.b())e=!1;else{e=e.o();var g=d.A();g.b()?e=!1:(g=g.o(),e=e.fh>g.fh)}if(e)return G(new H,c,d)}return b.n(a)};
+f.OJ=function(a){if(a instanceof Pl){var b=a.Qb;a=a.Za.A();a.b()?b=!1:(a=a.o(),b=b.A(),b.b()?b=!1:(b=b.o(),b=a.fh>b.fh));if(b)return!0}return!1};f.Lc=function(a){return this.OJ(a)};f.Ob=function(a,b){return this.vJ(a,b)};f.$classData=q({KX:0},!1,"mlscript.OpApp$$anonfun$unapply$1",{KX:1,Kf:1,g:1,la:1,za:1,l:1});function cf(a){this.NN=null;this.$H=!1;this.Xz=a}cf.prototype=new p;cf.prototype.constructor=cf;f=cf.prototype;
+f.nv=function(){if(!this.$H&&!this.$H){for(var a=TE(PE()),b=this.Xz,c=null,d=null;b!==u();){var e=b.e().nv();if(null===e)throw new w(e);var g=e.j();a.zc(e.h());for(e=g.m();e.s();)g=new z(e.t(),u()),null===d?c=g:d.p=g,d=g;b=b.f()}d=null===c?u():c;Od();b=new fp;Od();for(c=new fp;!d.b();){e=d.e();if(e instanceof Oo)t(),e=new fe(e);else if(e&&e.$classData&&e.$classData.rb.ce)t(),e=new Ud(e);else{if(!(e instanceof Zn))throw e instanceof Po&&xm("Program reached and unexpected state."),new w(e);var h=e;
+e=h.wd;g=h.Rb;h=h.Yc;t();e=new No(!(!e.b()&&!e.o()),g,h,e.b());e=new Ud(e)}if(e instanceof fe)wp(b,e.aa);else if(e instanceof Ud)wp(c,e.fa);else throw new w(e);d=d.f()}b=G(new H,b.ha(),c.ha());a=a.ha();this.NN=G(new H,a,b);this.$H=!0}return this.NN};f.H=function(){return"Pgrm"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Xz:$K(W(),a)};f.D=function(a){return a instanceof cf};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof cf){var b=this.Xz;a=a.Xz;return null===b?null===a:b.i(a)}return!1};f.$classData=q({NX:0},!1,"mlscript.Pgrm",{NX:1,g:1,Faa:1,E:1,v:1,l:1});function Bz(a,b){this.zE=a;this.yE=b}Bz.prototype=new Gz;Bz.prototype.constructor=Bz;f=Bz.prototype;f.Ua=function(){return this.zE};f.dQ=function(a){return this.yE.n(a)};f.H=function(){return"BuiltinFunc"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.zE;case 1:return this.yE;default:return $K(W(),a)}};f.D=function(a){return a instanceof Bz};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Bz&&this.zE===a.zE){var b=this.yE;a=a.yE;return null===b?null===a:b.i(a)}return!1};f.$classData=q({SX:0},!1,"mlscript.Polyfill$BuiltinFunc",{SX:1,TX:1,g:1,E:1,v:1,l:1});function wz(a,b){this.BE=a;this.AE=b}wz.prototype=new Gz;
+wz.prototype.constructor=wz;f=wz.prototype;f.Ua=function(){return this.BE};f.dQ=function(a){return this.AE.n(a)};f.H=function(){return"RuntimeHelper"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.BE;case 1:return this.AE;default:return $K(W(),a)}};f.D=function(a){return a instanceof wz};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof wz&&this.BE===a.BE){var b=this.AE;a=a.AE;return null===b?null===a:b.i(a)}return!1};
+f.$classData=q({UX:0},!1,"mlscript.Polyfill$RuntimeHelper",{UX:1,TX:1,g:1,E:1,v:1,l:1});function I_(){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0}I_.prototype=new ZS;I_.prototype.constructor=I_;function M_(){}M_.prototype=I_.prototype;I_.prototype.Vj=function(){return EP(this)};function yn(a){0===(1&a.Qe)<<24>>24&&0===(1&a.Qe)<<24>>24&&(a.Dg=hea(a),a.Qe=(1|a.Qe)<<24>>24);return a.Dg}
+function zn(a){0===(2&a.Qe)<<24>>24&&0===(2&a.Qe)<<24>>24&&(a.Eg=iea(a),a.Qe=(2|a.Qe)<<24>>24);return a.Eg}function HP(){}HP.prototype=new eW;HP.prototype.constructor=HP;f=HP.prototype;f.nr=function(a,b){if(null!==a){var c=a.j();if(null!==c&&(c=c.ya,c instanceof Cl))return c.Fm}return b.n(a)};f.sr=function(a){return null!==a&&(a=a.j(),null!==a&&a.ya instanceof Cl)?!0:!1};f.Lc=function(a){return this.sr(a)};f.Ob=function(a,b){return this.nr(a,b)};
+f.$classData=q({yY:0},!1,"mlscript.TypeLikeImpl$$anonfun$1",{yY:1,Kf:1,g:1,la:1,za:1,l:1});function IP(){}IP.prototype=new eW;IP.prototype.constructor=IP;f=IP.prototype;f.pj=function(a,b){return a instanceof Ct?a:b.n(a)};f.rj=function(a){return a instanceof Ct};f.Lc=function(a){return this.rj(a)};f.Ob=function(a,b){return this.pj(a,b)};f.$classData=q({zY:0},!1,"mlscript.TypeLikeImpl$$anonfun$2",{zY:1,Kf:1,g:1,la:1,za:1,l:1});function CP(a,b){this.WN=b}CP.prototype=new eW;
+CP.prototype.constructor=CP;f=CP.prototype;
+f.pj=function(a,b){if(a instanceof Po){b=a.ks;a=yP(this.WN);var c=b.Ra;b=h=>{if(null!==h){var k=new L(h);if(!k.b()&&(h=k.k.h(),k=k.k.j(),t().d===h&&null!==k)){h=k.yb;k=k.ya;var l=tm().Cg;if((null===l?null===h:l.i(h))&&k instanceof Cl&&(h=k.ai,k=k.Fm,h instanceof vl))return h.x+": "+yf(k,0,this.WN)}}xm("ill-formed constructor parameter")};if(c===u())b=u();else{var d=c.e(),e=d=new z(b(d),u());for(c=c.f();c!==u();){var g=c.e();g=new z(b(g),u());e=e.p=g;c=c.f()}b=d}return a+"constructor("+ze(b,"",", ",
+"")+")\n"}return b.n(a)};f.rj=function(a){return a instanceof Po};f.Lc=function(a){return this.rj(a)};f.Ob=function(a,b){return this.pj(a,b)};f.$classData=q({AY:0},!1,"mlscript.TypeLikeImpl$$anonfun$showIn$38",{AY:1,Kf:1,g:1,la:1,za:1,l:1});function DP(){}DP.prototype=new eW;DP.prototype.constructor=DP;f=DP.prototype;f.pj=function(a,b){return a instanceof Ct?a:b.n(a)};f.rj=function(a){return a instanceof Ct};f.Lc=function(a){return this.rj(a)};f.Ob=function(a,b){return this.pj(a,b)};
+f.$classData=q({BY:0},!1,"mlscript.TypeLikeImpl$$anonfun$showIn$39",{BY:1,Kf:1,g:1,la:1,za:1,l:1});function bB(){}bB.prototype=new eW;bB.prototype.constructor=bB;f=bB.prototype;f.wJ=function(a,b){if(a instanceof nC){var c=a.rp;if(null!==c)return a=c.x,Nu(Q(),a)}return b.n(a)};f.PJ=function(a){return a instanceof nC&&null!==a.rp?!0:!1};f.Lc=function(a){return this.PJ(a)};f.Ob=function(a,b){return this.wJ(a,b)};f.$classData=q({EY:0},!1,"mlscript.TypeSimplifier$$anonfun$1",{EY:1,Kf:1,g:1,la:1,za:1,l:1});
+function wA(a){this.jA=null;if(null===a)throw null;this.jA=a}wA.prototype=new eW;wA.prototype.constructor=wA;f=wA.prototype;
+f.nr=function(a,b){if(null!==a){var c=a.h(),d=a.j();if(null!==c){iC(this.jA);var e=c.Sb;if(!e.b()&&(e=e.o(),d instanceof L)){if(d.k)return a=G(new H,!0,e),G(new H,a,c);a=G(new H,!1,e);return G(new H,a,c)}}}if(null!==a&&(c=a.h(),d=a.j(),d instanceof L)){if(d.k){a=vy(c);for(b=this.jA.ib;!a.b();)d=a.e(),e=V(b.q),b=dv(b,d,e,!1),a=a.f();a=G(new H,!0,b);return G(new H,a,c)}a=rA(c);for(b=this.jA.La;!a.b();)d=a.e(),e=V(b.q),b=sA(b,d,e),a=a.f();a=G(new H,!1,b);return G(new H,a,c)}return b.n(a)};
+f.sr=function(a){if(null!==a){var b=a.h(),c=a.j();if(null!==b&&(iC(this.jA),!b.Sb.b()&&c instanceof L))return!0}return null!==a&&a.j()instanceof L?!0:!1};f.Lc=function(a){return this.sr(a)};f.Ob=function(a,b){return this.nr(a,b)};f.$classData=q({FY:0},!1,"mlscript.TypeSimplifier$$anonfun$2",{FY:1,Kf:1,g:1,la:1,za:1,l:1});function N_(a,b){this.ZN=b}N_.prototype=new eW;N_.prototype.constructor=N_;N_.prototype.Lc=function(a){return a instanceof qx};
+N_.prototype.Ob=function(a,b){a instanceof qx?(b=a.tp,a=a.vA,up(tp(),!this.ZN.kt.b()),this.ZN.kt=a.kt,a=b):a=b.n(a);return a};N_.prototype.$classData=q({LY:0},!1,"mlscript.Typer$$anonfun$$nestedInanonfun$typeTerm$2$1",{LY:1,Kf:1,g:1,la:1,za:1,l:1});function O_(){}O_.prototype=new eW;O_.prototype.constructor=O_;f=O_.prototype;f.vJ=function(a,b){if(a instanceof vl)return a;if(a instanceof Cl){var c=a.ai;if(c instanceof vl)return c}return b.n(a)};
+f.OJ=function(a){return a instanceof vl||a instanceof Cl&&a.ai instanceof vl?!0:!1};f.Lc=function(a){return this.OJ(a)};f.Ob=function(a,b){return this.vJ(a,b)};f.$classData=q({MY:0},!1,"mlscript.Typer$$anonfun$1",{MY:1,Kf:1,g:1,la:1,za:1,l:1});function P_(a,b,c,d,e,g){this.nI=this.oI=this.lI=null;this.qI=!1;this.mI=this.pI=null;if(null===a)throw null;this.lI=a;this.oI=b;this.nI=c;this.qI=d;this.pI=e;this.mI=g}P_.prototype=new eW;P_.prototype.constructor=P_;f=P_.prototype;
+f.nr=function(a,b){if(null!==a){var c=a.j();if(c instanceof bx)return Q_(this.lI,c,this.oI,this.nI,this.qI,this.pI,this.mI)}return null!==a&&(c=a.j(),c instanceof Cx)?Q_(this.lI,c,this.oI,this.nI,this.qI,this.pI,this.mI):b.n(a)};f.sr=function(a){return null!==a&&a.j()instanceof bx||null!==a&&a.j()instanceof Cx?!0:!1};f.Lc=function(a){return this.sr(a)};f.Ob=function(a,b){return this.nr(a,b)};f.$classData=q({NY:0},!1,"mlscript.Typer$$anonfun$mkTypingUnit$1$1",{NY:1,Kf:1,g:1,la:1,za:1,l:1});
+function R_(a){this.go=this.lh=this.Ga=null;this.Ix=this.Zm=!1;this.Wu=null;jx(this,a,t().d,"expression",(tx(a),t().d),(tx(a),!1))}R_.prototype=new rY;R_.prototype.constructor=R_;R_.prototype.u=function(){return"[NO PROV]"};R_.prototype.$classData=q({RY:0},!1,"mlscript.Typer$NoProv$",{RY:1,VO:1,g:1,E:1,v:1,l:1});function vC(){}vC.prototype=new eW;vC.prototype.constructor=vC;f=vC.prototype;f.zJ=function(a,b){if(a instanceof L){var c=a.k;if(c instanceof qx&&(c=c.tp,null!==c))return DB(c)}return b.n(a)};
+f.SJ=function(a){return a instanceof L&&(a=a.k,a instanceof qx&&null!==a.tp)?!0:!1};f.Lc=function(a){return this.SJ(a)};f.Ob=function(a,b){return this.zJ(a,b)};f.$classData=q({TY:0},!1,"mlscript.Typer$ValidPatVar$$anonfun$unapply$3",{TY:1,Kf:1,g:1,la:1,za:1,l:1});function wC(a,b,c){this.dO=this.Ex=this.cO=null;if(null===a)throw null;this.cO=a;this.Ex=b;this.dO=c}wC.prototype=new eW;wC.prototype.constructor=wC;f=wC.prototype;
+f.zJ=function(a,b){if(a instanceof L){var c=a.k;if(c instanceof Mu&&(c=c.pd,c instanceof vl&&this.Ex.x===c.x)){a=this.cO.rI;b=new Te(new Ue(J(new K,["Variable name '","' already names a symbol in scope. "])));c=[We(Xe(),this.Ex.x)];JX(a,PX(PX(Ye(b,J(new K,c)),We(Xe(),"If you want to refer to that symbol, you can use `scope."+this.Ex.x+"`; ")),We(Xe(),"if not, give your future readers a break and use another name :^)")),this.Ex.A(),this.dO);return}}return b.n(a)};
+f.SJ=function(a){return a instanceof L&&(a=a.k,a instanceof Mu&&(a=a.pd,a instanceof vl&&this.Ex.x===a.x))?!0:!1};f.Lc=function(a){return this.SJ(a)};f.Ob=function(a,b){return this.zJ(a,b)};f.$classData=q({UY:0},!1,"mlscript.Typer$ValidPatVar$$anonfun$unapply$4",{UY:1,Kf:1,g:1,la:1,za:1,l:1});function hX(){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0}hX.prototype=new qY;hX.prototype.constructor=hX;function S_(){}S_.prototype=hX.prototype;
+function ZB(){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0}ZB.prototype=new qY;ZB.prototype.constructor=ZB;function T_(){}T_.prototype=ZB.prototype;ZB.prototype.Ea=function(){return this.mc().Ea()};ZB.prototype.ub=function(a,b){return this.mc().ub(a,b)};ZB.prototype.u=function(){return"["+this.mc()+"]"};function qx(a,b,c){this.J=null;this.tp=b;this.vA=c;FC(this,a)}qx.prototype=new HC;qx.prototype.constructor=qx;f=qx.prototype;f.H=function(){return"VarSymbol"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.tp;case 1:return this.vA;default:return $K(W(),a)}};f.D=function(a){return a instanceof qx};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof qx&&a.J===this.J){var b=this.tp,c=a.tp;if(null===b?null===c:mC(b,c))return b=this.vA,a=a.vA,null===b?null===a:b.i(a)}return!1};f.$classData=q({MZ:0},!1,"mlscript.TyperDatatypes$VarSymbol",{MZ:1,UO:1,g:1,E:1,v:1,l:1});function aQ(){}aQ.prototype=new eW;
+aQ.prototype.constructor=aQ;f=aQ.prototype;f.pj=function(a,b){return a instanceof Zn&&a.Yc.tv()?a.Rb.x:b.n(a)};f.rj=function(a){return a instanceof Zn&&a.Yc.tv()?!0:!1};f.Lc=function(a){return this.rj(a)};f.Ob=function(a,b){return this.pj(a,b)};f.$classData=q({$Z:0},!1,"mlscript.TypingUnitImpl$$anonfun$3",{$Z:1,Kf:1,g:1,la:1,za:1,l:1});function YE(a,b,c,d){this.lf=null;this.bv=a;this.cv=b;this.Ux=c;this.I_=d;qE(this)}YE.prototype=new sE;YE.prototype.constructor=YE;f=YE.prototype;f.Cv=function(){return this.I_};
+f.u=function(){return"\u00ab"+this.bv+" \x3d "+this.cv+"\u00bb"+tE(this)};f.H=function(){return"Binding"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.bv;case 1:return this.cv;case 2:return this.Ux;default:return $K(W(),a)}};f.D=function(a){return a instanceof YE};f.B=function(){var a=lb("Binding");a=W().C(-889275714,a);var b=this.bv;b=My(W(),b);a=W().C(a,b);b=this.cv;b=My(W(),b);a=W().C(a,b);b=this.Ux?1231:1237;a=W().C(a,b);return W().Ma(a,3)};
+f.i=function(a){if(this===a)return!0;if(a instanceof YE&&this.Ux===a.Ux){var b=this.bv,c=a.bv;if(null===b?null===c:b.i(c))return b=this.cv,a=a.cv,null===b?null===a:b.i(a)}return!1};f.$classData=q({H_:0},!1,"mlscript.ucs.Clause$Binding",{H_:1,VA:1,g:1,E:1,v:1,l:1});function XE(a,b){this.lf=null;this.Vx=a;this.K_=b;qE(this)}XE.prototype=new sE;XE.prototype.constructor=XE;f=XE.prototype;f.Cv=function(){return this.K_};f.u=function(){return"\u00ab"+this.Vx+"\u00bb"+tE(this)};f.H=function(){return"BooleanTest"};
+f.G=function(){return 1};f.I=function(a){return 0===a?this.Vx:$K(W(),a)};f.D=function(a){return a instanceof XE};f.B=function(){return AL(this)};f.i=function(a){if(this===a)return!0;if(a instanceof XE){var b=this.Vx;a=a.Vx;return null===b?null===a:b.i(a)}return!1};f.$classData=q({J_:0},!1,"mlscript.ucs.Clause$BooleanTest",{J_:1,VA:1,g:1,E:1,v:1,l:1});function WE(a,b,c,d){this.lf=null;this.ev=a;this.dv=b;this.ay=c;this.UP=d;qE(this)}WE.prototype=new sE;WE.prototype.constructor=WE;f=WE.prototype;
+f.Cv=function(){return this.UP};f.u=function(){return"\u00ab"+this.ev+" is Tuple#"+this.dv+"\u00bb"+tE(this)};f.H=function(){return"MatchTuple"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.ev;case 1:return this.dv;case 2:return this.ay;default:return $K(W(),a)}};f.D=function(a){return a instanceof WE};
+f.B=function(){var a=lb("MatchTuple");a=W().C(-889275714,a);var b=this.ev;b=My(W(),b);a=W().C(a,b);b=this.dv;a=W().C(a,b);b=this.ay;b=My(W(),b);a=W().C(a,b);return W().Ma(a,3)};f.i=function(a){if(this===a)return!0;if(a instanceof WE&&this.dv===a.dv){var b=this.ev,c=a.ev;if(null===b?null===c:b.i(c))return b=this.ay,a=a.ay,null===b?null===a:b.i(a)}return!1};f.$classData=q({P_:0},!1,"mlscript.ucs.Clause$MatchTuple",{P_:1,VA:1,g:1,E:1,v:1,l:1});function $E(){}$E.prototype=new zE;
+$E.prototype.constructor=$E;f=$E.prototype;f.u=function(){return"pattern destruction"};f.H=function(){return"FieldExtraction"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof $E};f.B=function(){return 1536009313};f.$classData=q({U_:0},!1,"mlscript.ucs.LetBinding$Kind$FieldExtraction$",{U_:1,WP:1,g:1,E:1,v:1,l:1});var ZE;function U_(){}U_.prototype=new zE;U_.prototype.constructor=U_;f=U_.prototype;f.u=function(){return"interleaved let"};f.H=function(){return"InterleavedLet"};
+f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof U_};f.B=function(){return 1258608914};f.$classData=q({V_:0},!1,"mlscript.ucs.LetBinding$Kind$InterleavedLet$",{V_:1,WP:1,g:1,E:1,v:1,l:1});var V_;function KE(){V_||(V_=new U_);return V_}function W_(){}W_.prototype=new zE;W_.prototype.constructor=W_;f=W_.prototype;f.u=function(){return"scrutinee alias"};f.H=function(){return"ScrutineeAlias"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};
+f.D=function(a){return a instanceof W_};f.B=function(){return-1538996278};f.$classData=q({W_:0},!1,"mlscript.ucs.LetBinding$Kind$ScrutineeAlias$",{W_:1,WP:1,g:1,E:1,v:1,l:1});var X_;function aF(){X_||(X_=new W_);return X_}function FE(a,b){this.pt=null;this.Tj=a;this.pl=b;this.pt=jA().X()}FE.prototype=new iF;FE.prototype.constructor=FE;f=FE.prototype;f.xt=function(){return this.pl};f.oQ=function(){var a=this.Tj.j().ia();return VE(new FE(G(new H,this.Tj.iy(),a),this.pl.or()),this.pt)};
+f.FF=function(a,b){var c=!1,d=null;if(a instanceof Dl)return!1;if(a instanceof vl){c=!0;d=a;var e=d.x;if("true"===e||"false"===e)return!1}if(c&&d.x===this.Tj.h().x)return!0;if(c){a=b.U(d.x);if(a instanceof L)return a.k.L(this.Tj.h().x);if(R()===a)return!1;throw new w(a);}throw new w(a);};function Y_(a,b){var c=a.Tj.j();b=b.m();b=new iy(b,new y(d=>!a.Tj.j().L(d)),!1);c.zc(b)}f.H=function(){return"Constructor"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.Tj;case 1:return this.pl;default:return $K(W(),a)}};f.D=function(a){return a instanceof FE};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof FE){var b=this.Tj,c=a.Tj;if(null===b?null===c:b.i(c))return b=this.pl,a=a.pl,null===b?null===a:b.i(a)}return!1};f.$classData=q({c0:0},!1,"mlscript.ucs.MutCaseOf$MutCase$Constructor",{c0:1,b0:1,g:1,E:1,v:1,l:1});
+function EE(a,b){this.pt=null;this.ir=a;this.Jp=b;this.pt=jA().X()}EE.prototype=new iF;EE.prototype.constructor=EE;f=EE.prototype;f.xt=function(){return this.Jp};f.oQ=function(){return VE(new EE(this.ir,this.Jp.or()),this.pt)};f.FF=function(a){var b=a instanceof Dl?!0:a instanceof vl&&"true"===a.x?!0:a instanceof vl&&"false"===a.x?!0:!1;if(b)return Pe(new E(a),this.ir);if(a instanceof vl)return!1;throw new w(a);};f.H=function(){return"Literal"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.ir;case 1:return this.Jp;default:return $K(W(),a)}};f.D=function(a){return a instanceof EE};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof EE){var b=this.ir,c=a.ir;if(null===b?null===c:b.i(c))return b=this.Jp,a=a.Jp,null===b?null===a:b.i(a)}return!1};f.$classData=q({d0:0},!1,"mlscript.ucs.MutCaseOf$MutCase$Literal",{d0:1,b0:1,g:1,E:1,v:1,l:1});function Z_(){$_=this;O()}Z_.prototype=new kF;
+Z_.prototype.constructor=Z_;f=Z_.prototype;f.oo=function(a){var b=O().c;return new a0(a,new z(a,b))};f.H=function(){return"Empty"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof Z_};f.B=function(){return 67081517};f.u=function(){return"Empty"};f.$classData=q({e0:0},!1,"mlscript.ucs.PartialTerm$Empty$",{e0:1,YP:1,g:1,E:1,v:1,l:1});var $_;function b0(){$_||($_=new Z_);return $_}function c0(a,b,c){this.uF=a;this.vF=b;this.$A=c}c0.prototype=new kF;
+c0.prototype.constructor=c0;f=c0.prototype;f.oo=function(a,b){var c=rF(tF(),a,b);if(null===c)throw new w(c);a=c.h();c=c.j();a=pF(tF(),this.uF,this.vF,a,b);if(t().d===c)return new a0(a,this.$A);if(c instanceof L)return c=c.k,b=pF(tF(),a,new vl("and"),c,b),new a0(b,new z(c,this.$A));throw new w(c);};f.H=function(){return"Half"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.uF;case 1:return this.vF;case 2:return this.$A;default:return $K(W(),a)}};
+f.D=function(a){return a instanceof c0};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof c0){var b=this.uF,c=a.uF;if(null===b?null===c:b.i(c))if(b=this.vF,c=a.vF,null===b?null===c:b.i(c))return b=this.$A,a=a.$A,null===b?null===a:b.i(a)}return!1};f.$classData=q({f0:0},!1,"mlscript.ucs.PartialTerm$Half",{f0:1,YP:1,g:1,E:1,v:1,l:1});function a0(a,b){this.jr=a;this.aB=b}a0.prototype=new kF;a0.prototype.constructor=a0;f=a0.prototype;
+f.oo=function(a){throw new vY("expect an operator but term "+a+" was given");};function d0(a,b){return new c0(a.jr,b,new z(b,a.aB))}f.H=function(){return"Total"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.jr;case 1:return this.aB;default:return $K(W(),a)}};f.D=function(a){return a instanceof a0};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof a0){var b=this.jr,c=a.jr;if(null===b?null===c:b.i(c))return b=this.aB,a=a.aB,null===b?null===a:b.i(a)}return!1};f.$classData=q({g0:0},!1,"mlscript.ucs.PartialTerm$Total",{g0:1,YP:1,g:1,E:1,v:1,l:1});function pQ(){}pQ.prototype=new zY;pQ.prototype.constructor=pQ;pQ.prototype.n=function(a){return a};pQ.prototype.u=function(){return"generalized constraint"};
+pQ.prototype.$classData=q({V2:0},!1,"scala.$less$colon$less$$anon$1",{V2:1,cba:1,dba:1,g:1,la:1,l:1});class w extends iW{constructor(a){super();this.kR=null;this.FK=!1;this.fG=a;yF(this,null,null,!0)}qj(){if(!this.FK&&!this.FK){if(null===this.fG)var a="null";else try{a=nb(this.fG)+" (of class "+na(this.fG)+")"}catch(b){a="an instance of class "+na(this.fG)}this.kR=a;this.FK=!0}return this.kR}}w.prototype.$classData=q({Z2:0},!1,"scala.MatchError",{Z2:1,Te:1,qd:1,pc:1,g:1,l:1});function e0(){}
+e0.prototype=new p;e0.prototype.constructor=e0;function f0(){}f=f0.prototype=e0.prototype;f.b=function(){return this===R()};f.Q=function(){return this.b()?0:1};f.L=function(a){return!this.b()&&ml(nl(),this.o(),a)};f.m=function(){if(this.b())return Rq().Pa;Rq();var a=this.o();return new g0(a)};f.ha=function(){if(this.b()){O();var a=u();return Pd(u(),a)}return new z(this.o(),O().c)};function G(a,b,c){a.y=b;a.w=c;return a}function H(){this.w=this.y=null}H.prototype=new p;H.prototype.constructor=H;
+function h0(){}f=h0.prototype=H.prototype;f.G=function(){return 2};f.I=function(a){a:switch(a){case 0:a=this.h();break a;case 1:a=this.j();break a;default:throw aL(new bL,a+" is out of bounds (min 0, max 1)");}return a};f.h=function(){return this.y};f.j=function(){return this.w};f.u=function(){return"("+this.h()+","+this.j()+")"};f.Cw=function(){return G(new H,this.j(),this.h())};f.iy=function(){return this.h()};f.H=function(){return"Tuple2"};f.D=function(a){return a instanceof H};f.B=function(){return AL(this)};
+f.i=function(a){return this===a?!0:a instanceof H?ml(nl(),this.h(),a.h())&&ml(nl(),this.j(),a.j()):!1};f.Rc=function(){return!!this.h()};f.aQ=function(){return Ea(this.h())};f.ut=function(){return this.h()|0};f.cy=function(){return!!this.j()};f.Sc=function(){return this.j()|0};f.$classData=q({by:0},!1,"scala.Tuple2",{by:1,g:1,LB:1,E:1,v:1,l:1});function tl(a,b,c){this.kc=a;this.hb=b;this.Rd=c}tl.prototype=new p;tl.prototype.constructor=tl;f=tl.prototype;f.G=function(){return 3};
+f.I=function(a){a:switch(a){case 0:a=this.kc;break a;case 1:a=this.hb;break a;case 2:a=this.Rd;break a;default:throw aL(new bL,a+" is out of bounds (min 0, max 2)");}return a};f.u=function(){return"("+this.kc+","+this.hb+","+this.Rd+")"};f.H=function(){return"Tuple3"};f.D=function(a){return a instanceof tl};f.B=function(){return AL(this)};f.i=function(a){return this===a?!0:a instanceof tl?ml(nl(),this.kc,a.kc)&&ml(nl(),this.hb,a.hb)&&ml(nl(),this.Rd,a.Rd):!1};
+f.$classData=q({J0:0},!1,"scala.Tuple3",{J0:1,g:1,hba:1,E:1,v:1,l:1});function Gp(a,b,c,d){this.Uj=a;this.oj=b;this.oi=c;this.Xi=d}Gp.prototype=new p;Gp.prototype.constructor=Gp;f=Gp.prototype;f.G=function(){return 4};f.I=function(a){return qea(this,a)};f.u=function(){return"("+this.Uj+","+this.oj+","+this.oi+","+this.Xi+")"};f.H=function(){return"Tuple4"};f.D=function(a){return a instanceof Gp};f.B=function(){return AL(this)};
+f.i=function(a){return this===a?!0:a instanceof Gp?ml(nl(),this.Uj,a.Uj)&&ml(nl(),this.oj,a.oj)&&ml(nl(),this.oi,a.oi)&&ml(nl(),this.Xi,a.Xi):!1};f.$classData=q({K0:0},!1,"scala.Tuple4",{K0:1,g:1,iba:1,E:1,v:1,l:1});function WX(a,b,c,d,e){this.hv=a;this.qt=b;this.kr=c;this.iv=d;this.jv=e}WX.prototype=new p;WX.prototype.constructor=WX;f=WX.prototype;f.G=function(){return 5};f.I=function(a){return rea(this,a)};f.u=function(){return"("+this.hv+","+this.qt+","+this.kr+","+this.iv+","+this.jv+")"};
+f.H=function(){return"Tuple5"};f.D=function(a){return a instanceof WX};f.B=function(){return AL(this)};f.i=function(a){return this===a?!0:a instanceof WX?ml(nl(),this.hv,a.hv)&&ml(nl(),this.qt,a.qt)&&ml(nl(),this.kr,a.kr)&&ml(nl(),this.iv,a.iv)&&ml(nl(),this.jv,a.jv):!1};f.$classData=q({L0:0},!1,"scala.Tuple5",{L0:1,g:1,jba:1,E:1,v:1,l:1});function bo(a,b,c,d,e,g){this.lr=a;this.mr=b;this.rt=c;this.st=d;this.tt=e;this.kv=g}bo.prototype=new p;bo.prototype.constructor=bo;f=bo.prototype;f.G=function(){return 6};
+f.I=function(a){return sea(this,a)};f.u=function(){return"("+this.lr+","+this.mr+","+this.rt+","+this.st+","+this.tt+","+this.kv+")"};f.H=function(){return"Tuple6"};f.D=function(a){return a instanceof bo};f.B=function(){return AL(this)};f.i=function(a){return this===a?!0:a instanceof bo?ml(nl(),this.lr,a.lr)&&ml(nl(),this.mr,a.mr)&&ml(nl(),this.rt,a.rt)&&ml(nl(),this.st,a.st)&&ml(nl(),this.tt,a.tt)&&ml(nl(),this.kv,a.kv):!1};f.$classData=q({M0:0},!1,"scala.Tuple6",{M0:1,g:1,kba:1,E:1,v:1,l:1});
+function i0(a){this.RB=a}i0.prototype=new sT;i0.prototype.constructor=i0;i0.prototype.$classData=q({U4:0},!1,"scala.collection.ClassTagSeqFactory$AnySeqDelegate",{U4:1,Mba:1,g:1,bg:1,l:1,Nk:1});function j0(){this.Bl=null;this.Bl=xe()}j0.prototype=new MY;j0.prototype.constructor=j0;j0.prototype.$classData=q({X4:0},!1,"scala.collection.IndexedSeq$",{X4:1,FG:1,g:1,Nk:1,bg:1,l:1});var k0;function l0(a,b,c){for(a=a.Sd();a.s();)b=c.ba(a.t(),b);return b}
+function n0(a,b){return a.Ub().Ib(o0(new p0,b,a))}function q0(a,b){return a.vc(r0(new s0,a,b))}function t0(a,b){return a.Ub().Ib(u0(new v0,a,b))}function SF(a){return a.va(-1+a.K()|0)}function w0(a){return ze(a,a.Ih()+"(",", ",")")}function Fs(a){return!!(a&&a.$classData&&a.$classData.rb.na)}function xo(a,b){this.zy=null;this.Lv=0;this.GR=this.XK=null;if(null===a)throw null;this.XK=a;this.GR=b;this.zy=Rq().Pa;this.Lv=-1}xo.prototype=new BY;xo.prototype.constructor=xo;
+xo.prototype.s=function(){if(-1===this.Lv){for(;!this.zy.s();){if(!this.XK.s())return this.Lv=0,this.zy=Rq().Pa,!1;this.zy=null;this.zy=this.GR.n(this.XK.t()).m();this.Lv=-1}this.Lv=1;return!0}return 1===this.Lv};xo.prototype.t=function(){this.s()&&(this.Lv=-1);return this.zy.t()};xo.prototype.$classData=q({e5:0},!1,"scala.collection.Iterator$$anon$10",{e5:1,Sa:1,g:1,Ka:1,M:1,N:1});function is(a,b){this.YK=null;this.g5=b;this.qG=!1;this.ZK=a}is.prototype=new BY;is.prototype.constructor=is;
+is.prototype.s=function(){return this.qG?!0:this.ZK.s()?(this.YK=this.ZK.t(),this.g5.n(this.YK)?this.qG=!0:this.ZK=Rq().Pa,this.qG):!1};is.prototype.t=function(){return this.s()?(this.qG=!1,this.YK):Rq().Pa.t()};is.prototype.$classData=q({f5:0},!1,"scala.collection.Iterator$$anon$11",{f5:1,Sa:1,g:1,Ka:1,M:1,N:1});function x0(a,b){this.rG=this.sG=null;if(null===a)throw null;this.rG=a;this.sG=b.m()}x0.prototype=new BY;x0.prototype.constructor=x0;f=x0.prototype;
+f.Q=function(){var a=this.rG.Q(),b=this.sG.Q();return a<b?a:b};f.s=function(){return this.rG.s()&&this.sG.s()};f.gm=function(){return G(new H,this.rG.t(),this.sG.t())};f.t=function(){return this.gm()};f.$classData=q({h5:0},!1,"scala.collection.Iterator$$anon$14",{h5:1,Sa:1,g:1,Ka:1,M:1,N:1});function Ao(a){this.uG=0;this.tG=null;if(null===a)throw null;this.tG=a;this.uG=0}Ao.prototype=new BY;Ao.prototype.constructor=Ao;f=Ao.prototype;f.Q=function(){return this.tG.Q()};f.s=function(){return this.tG.s()};
+f.gm=function(){var a=G(new H,this.tG.t(),this.uG);this.uG=1+this.uG|0;return a};f.t=function(){return this.gm()};f.$classData=q({i5:0},!1,"scala.collection.Iterator$$anon$16",{i5:1,Sa:1,g:1,Ka:1,M:1,N:1});function ST(){}ST.prototype=new BY;ST.prototype.constructor=ST;f=ST.prototype;f.s=function(){return!1};f.Q=function(){return 0};f.qk=function(){return this};f.t=function(){throw AH("next on empty iterator");};
+f.$classData=q({j5:0},!1,"scala.collection.Iterator$$anon$19",{j5:1,Sa:1,g:1,Ka:1,M:1,N:1});function g0(a){this.l5=a;this.vG=!1}g0.prototype=new BY;g0.prototype.constructor=g0;g0.prototype.s=function(){return!this.vG};g0.prototype.t=function(){if(this.vG)return Rq().Pa.t();this.vG=!0;return this.l5};g0.prototype.qk=function(a,b){return this.vG||0<a||0===b?Rq().Pa:this};g0.prototype.$classData=q({k5:0},!1,"scala.collection.Iterator$$anon$20",{k5:1,Sa:1,g:1,Ka:1,M:1,N:1});function y0(a){this.o5=a}
+y0.prototype=new BY;y0.prototype.constructor=y0;y0.prototype.s=function(){return!0};y0.prototype.t=function(){return Es(this.o5)};y0.prototype.$classData=q({n5:0},!1,"scala.collection.Iterator$$anon$27",{n5:1,Sa:1,g:1,Ka:1,M:1,N:1});function iy(a,b,c){this.wG=null;this.xG=!1;this.IR=this.SB=null;this.HR=!1;if(null===a)throw null;this.SB=a;this.IR=b;this.HR=c;this.xG=!1}iy.prototype=new BY;iy.prototype.constructor=iy;
+iy.prototype.s=function(){if(!this.xG){if(!this.SB.s())return!1;for(this.wG=this.SB.t();!!this.IR.n(this.wG)===this.HR;){if(!this.SB.s())return!1;this.wG=this.SB.t()}this.xG=!0}return!0};iy.prototype.t=function(){return this.s()?(this.xG=!1,this.wG):Rq().Pa.t()};iy.prototype.$classData=q({p5:0},!1,"scala.collection.Iterator$$anon$6",{p5:1,Sa:1,g:1,Ka:1,M:1,N:1});
+function hy(a,b){this.NR=null;this.yG=!1;this.LR=this.aL=this.MR=null;if(null===a)throw null;this.aL=a;this.LR=b;this.NR=Vn();this.yG=!1}hy.prototype=new BY;hy.prototype.constructor=hy;hy.prototype.s=function(){for(;;){if(this.yG)return!0;if(this.aL.s()){var a=this.aL.t();if(this.NR.oh(this.LR.n(a)))return this.MR=a,this.yG=!0}else return!1}};hy.prototype.t=function(){return this.s()?(this.yG=!1,this.MR):Rq().Pa.t()};
+hy.prototype.$classData=q({r5:0},!1,"scala.collection.Iterator$$anon$8",{r5:1,Sa:1,g:1,Ka:1,M:1,N:1});function Ef(a,b){this.OR=this.zG=null;if(null===a)throw null;this.zG=a;this.OR=b}Ef.prototype=new BY;Ef.prototype.constructor=Ef;Ef.prototype.Q=function(){return this.zG.Q()};Ef.prototype.s=function(){return this.zG.s()};Ef.prototype.t=function(){return this.OR.n(this.zG.t())};Ef.prototype.$classData=q({s5:0},!1,"scala.collection.Iterator$$anon$9",{s5:1,Sa:1,g:1,Ka:1,M:1,N:1});
+function MT(a){this.tm=a;this.Rp=this.Bo=null;this.Mv=!1}MT.prototype=new BY;MT.prototype.constructor=MT;
+MT.prototype.s=function(){if(this.Mv)return!0;if(null!==this.tm){if(this.tm.s())return this.Mv=!0;a:for(;;){if(null===this.Bo){this.Rp=this.tm=null;var a=!1;break a}this.tm=Es(this.Bo.v5).m();this.Rp===this.Bo&&(this.Rp=this.Rp.AG);for(this.Bo=this.Bo.AG;this.tm instanceof MT;)a=this.tm,this.tm=a.tm,this.Mv=a.Mv,null!==a.Bo&&(null===this.Rp&&(this.Rp=a.Rp),a.Rp.AG=this.Bo,this.Bo=a.Bo);if(this.Mv){a=!0;break a}if(null!==this.tm&&this.tm.s()){a=this.Mv=!0;break a}}return a}return!1};
+MT.prototype.t=function(){return this.s()?(this.Mv=!1,this.tm.t()):Rq().Pa.t()};MT.prototype.nb=function(a){a=new lH(a,null);null===this.Bo?this.Bo=a:this.Rp.AG=a;this.Rp=a;null===this.tm&&(this.tm=Rq().Pa);return this};MT.prototype.$classData=q({t5:0},!1,"scala.collection.Iterator$ConcatIterator",{t5:1,Sa:1,g:1,Ka:1,M:1,N:1});function z0(a){for(;0<a.Nv;)a.By.s()?(a.By.t(),a.Nv=-1+a.Nv|0):a.Nv=0}function A0(a,b){if(0>a.Co)return-1;a=a.Co-b|0;return 0>a?0:a}
+function PT(a,b,c){this.By=a;this.Co=c;this.Nv=b}PT.prototype=new BY;PT.prototype.constructor=PT;f=PT.prototype;f.Q=function(){var a=this.By.Q();if(0>a)return-1;a=a-this.Nv|0;a=0>a?0:a;if(0>this.Co)return a;var b=this.Co;return b<a?b:a};f.s=function(){z0(this);return 0!==this.Co&&this.By.s()};f.t=function(){z0(this);return 0<this.Co?(this.Co=-1+this.Co|0,this.By.t()):0>this.Co?this.By.t():Rq().Pa.t()};
+f.qk=function(a,b){a=0<a?a:0;if(0>b)b=A0(this,a);else if(b<=a)b=0;else if(0>this.Co)b=b-a|0;else{var c=A0(this,a);b=b-a|0;b=c<b?c:b}if(0===b)return Rq().Pa;this.Nv=this.Nv+a|0;this.Co=b;return this};f.$classData=q({w5:0},!1,"scala.collection.Iterator$SliceIterator",{w5:1,Sa:1,g:1,Ka:1,M:1,N:1});function $O(a,b){this.y5=b;this.bL=a;this.TB=null}$O.prototype=new BY;$O.prototype.constructor=$O;
+$O.prototype.s=function(){if(null===this.TB){var a=this.y5.n(this.bL);if(null===a)throw oL("null during unfold");this.TB=a;this.bL=null}return!this.TB.b()};$O.prototype.t=function(){if(this.s()){var a=this.TB.o();if(null===a)throw new w(a);var b=a.h();this.bL=a.j();this.TB=null;return b}return Rq().Pa.t()};$O.prototype.$classData=q({x5:0},!1,"scala.collection.Iterator$UnfoldIterator",{x5:1,Sa:1,g:1,Ka:1,M:1,N:1});
+function B0(a){this.PR=this.dL=this.cL=null;if(null===a)throw null;this.PR=a;this.cL=a.Cy.ck.m();this.dL=a.Cy.dk.m()}B0.prototype=new BY;B0.prototype.constructor=B0;B0.prototype.s=function(){return this.cL.s()&&this.dL.s()};B0.prototype.t=function(){return this.PR.QR.ba(this.cL.t(),this.dL.t())};B0.prototype.$classData=q({B5:0},!1,"scala.collection.LazyZip2$$anon$1$$anon$2",{B5:1,Sa:1,g:1,Ka:1,M:1,N:1});
+function C0(a){for(;!a.BG.s()&&a.eL.s()&&a.fL.s();)a.BG=a.RR.SR.ba(a.eL.t(),a.fL.t()).m();return a.BG}function D0(a){this.RR=this.BG=this.fL=this.eL=null;if(null===a)throw null;this.RR=a;this.eL=a.Ov.ck.m();this.fL=a.Ov.dk.m();this.BG=Rq().Pa}D0.prototype=new BY;D0.prototype.constructor=D0;D0.prototype.s=function(){return C0(this).s()};D0.prototype.t=function(){return C0(this).t()};D0.prototype.$classData=q({D5:0},!1,"scala.collection.LazyZip2$$anon$3$$anon$4",{D5:1,Sa:1,g:1,Ka:1,M:1,N:1});
+function E0(a){this.hL=this.gL=null;this.gL=a.Dy.ck.m();this.hL=a.Dy.dk.m()}E0.prototype=new BY;E0.prototype.constructor=E0;E0.prototype.s=function(){return this.gL.s()&&this.hL.s()};E0.prototype.gm=function(){return G(new H,this.gL.t(),this.hL.t())};E0.prototype.t=function(){return this.gm()};E0.prototype.$classData=q({F5:0},!1,"scala.collection.LazyZip2$$anon$7$$anon$8",{F5:1,Sa:1,g:1,Ka:1,M:1,N:1});
+function jv(a,b){var c=b.Q();if(0<=c)return a.ab(c);if(b&&b.$classData&&b.$classData.rb.CG){for(;;)if(a.b()?0:!b.b())a=a.f(),b=b.f();else break;a=!a.b();b=!b.b();return a===b?0:a?1:-1}for(b=b.m();;)if(!a.b()&&b.s())a=a.f(),b.t();else break;a=!a.b();b=b.s();return a===b?0:a?1:-1}function F0(a,b){return 0<=b&&0<a.ab(b)}function eB(a,b){if(0>b)throw aL(new bL,""+b);a=a.Jc(b);if(a.b())throw aL(new bL,""+b);return a.e()}function YA(a,b,c){for(;!a.b();)b=c.ba(b,a.e()),a=a.f();return b}
+function G0(a,b){if(b&&b.$classData&&b.$classData.rb.CG)a:for(;;){if(a===b){a=!0;break a}if((a.b()?0:!b.b())&&ml(nl(),a.e(),b.e()))a=a.f(),b=b.f();else{a=a.b()&&b.b();break a}}else a=TY(a,b);return a}function H0(a,b,c){var d=0<c?c:0;for(a=a.Jc(c);!a.b();){if(b.n(a.e()))return d;d=1+d|0;a=a.f()}return-1}function I0(a){this.nL=null;this.nL=a.m()}I0.prototype=new BY;I0.prototype.constructor=I0;I0.prototype.s=function(){return this.nL.s()};I0.prototype.t=function(){return this.nL.t().h()};
+I0.prototype.$classData=q({M5:0},!1,"scala.collection.MapOps$$anon$2",{M5:1,Sa:1,g:1,Ka:1,M:1,N:1});function Ou(a){this.Ot=null;this.Ot=a.m()}Ou.prototype=new BY;Ou.prototype.constructor=Ou;Ou.prototype.s=function(){return this.Ot.s()};Ou.prototype.t=function(){return this.Ot.t().j()};Ou.prototype.$classData=q({N5:0},!1,"scala.collection.MapOps$$anon$3",{N5:1,Sa:1,g:1,Ka:1,M:1,N:1});
+function gfa(a){Ty();var b=u(),c=Uy(b);b=a.qL;b=(b&&b.$classData&&b.$classData.rb.Ac?b:b.FC()).Ja(new y(n=>{if(ca(c)!==da(Ky)){var r=c.U(n);if(r instanceof L)r=r.k;else if(R()===r)r=c.Xf,Ly(c,n,r,!1);else throw new w(r);}else{r=My(W(),n);r^=r>>>16|0;var v=r&(-1+c.eb.a.length|0),x=c.eb.a[v];x=null===x?null:Ny(x,n,r);if(null!==x)r=x.Ah;else{x=c.eb;var A=c.Xf;(1+c.Xf|0)>=c.hu&&Oy(c,c.eb.a.length<<1);Py(c,n,A,!1,r,x===c.eb?v:r&(-1+c.eb.a.length|0));r=A}}return G(new H,n,r)}));var d=new y(n=>n.Sc()),e=
+Fq();b=QY(b,d,e);d=op();d=b.Gb(d.ga);if(null===d)throw new w(d);b=d.h();d=d.j();var g=new Xc(c.Xf);d.Ca(new y(n=>{n|=0;g.a[n]=1+g.a[n]|0}));d=new Xc(g.a.length);e=0;e=a.U5;var h=d.a.length;a=-1+h|0;if(!(0>=h))for(h=0;;){var k=h,l=e,m=g.a[k];d.a[k]=l<m?l:m;e=e-d.a[k]|0;if(h===a)break;h=1+h|0}k0||(k0=new j0);return new tl((new xT(k0)).vc(b),g,d)}
+function PY(a,b){this.$R=this.vm=this.HG=this.ZR=this.IG=null;this.GG=!1;this.qL=null;this.U5=b;if(null===a)throw null;this.qL=a;a=gfa(this);if(null===a)throw new w(a);this.IG=new tl(a.kc,a.hb,a.Rd);this.ZR=this.IG.kc;this.HG=this.IG.hb;this.vm=this.IG.Rd;a=this.HG;rl();for(var c=b=0,d=new Xc(1+a.a.length|0);c<a.a.length;)d.a[c]=b|0,b=(b|0)+a.a[c]|0,c=1+c|0;d.a[c]=b|0;this.$R=d;this.GG=!0}PY.prototype=new BY;PY.prototype.constructor=PY;PY.prototype.s=function(){return this.GG};
+PY.prototype.t=function(){this.GG||Rq().Pa.t();var a=this.qL.ti(),b=this.vm.a.length,c=-1+b|0;if(!(0>=b))for(b=0;;){var d=b,e=this.vm.a[d],g=-1+e|0;if(!(0>=e))for(e=0;;){var h=this.ZR.va(this.$R.a[d]+e|0);a.$(h);if(e===g)break;e=1+e|0}if(b===c)break;b=1+b|0}a=a.Kb();for(b=-1+this.vm.a.length|0;0<=b&&this.vm.a[b]===this.HG.a[b];)b=-1+b|0;c=this.vm;b=-1+b|0;a:{d=-1+c.a.length|0;for(b=b<d?b:d;0<=b;){if(0<c.a[b])break a;b=-1+b|0}b=-1}if(0>b)this.GG=!1;else{c=1;for(d=1+b|0;d<this.vm.a.length;)c=c+this.vm.a[d]|
+0,d=1+d|0;d=b;this.vm.a[d]=-1+this.vm.a[d]|0;d=1+b|0;g=this.vm.a.length;b=-1+g|0;if(!(d>=g))for(;;){g=d;e=c;h=this.HG.a[g];this.vm.a[g]=e<h?e:h;c=c-this.vm.a[g]|0;if(d===b)break;d=1+d|0}}return a};PY.prototype.$classData=q({T5:0},!1,"scala.collection.SeqOps$CombinationsItr",{T5:1,Sa:1,g:1,Ka:1,M:1,N:1});function J0(a,b){var c=Fs(b)?new JT(a,b):a.m().nb(new U(()=>b.m()));return a.vc(c)}function K0(){this.Mt=null}K0.prototype=new uT;K0.prototype.constructor=K0;function L0(){}L0.prototype=K0.prototype;
+function Om(a){this.QG=a}Om.prototype=new BY;Om.prototype.constructor=Om;Om.prototype.s=function(){return!this.QG.b()};Om.prototype.t=function(){var a=this.QG.e();this.QG=this.QG.f();return a};Om.prototype.$classData=q({h6:0},!1,"scala.collection.StrictOptimizedLinearSeqOps$$anon$1",{h6:1,Sa:1,g:1,Ka:1,M:1,N:1});function wH(a,b){this.SG=a;this.m6=b;this.Jy=a.length;this.cj=0}wH.prototype=new BY;wH.prototype.constructor=wH;wH.prototype.s=function(){return this.cj<this.Jy};
+function xH(a){if(a.cj>=a.Jy)a=Rq().Pa.t();else{for(var b=a.cj;;){if(a.cj<a.Jy){var c=a.SG.charCodeAt(a.cj);c=!(13===c||10===c)}else c=!1;if(c)a.cj=1+a.cj|0;else break}c=a.cj;if(a.cj<a.Jy){var d=a.SG.charCodeAt(a.cj);a.cj=1+a.cj|0;if(a.cj<a.Jy){var e=a.SG.charCodeAt(a.cj);d=13===d&&10===e}else d=!1;d&&(a.cj=1+a.cj|0);a.m6||(c=a.cj)}a=a.SG.substring(b,c)}return a}wH.prototype.t=function(){return xH(this)};
+wH.prototype.$classData=q({l6:0},!1,"scala.collection.StringOps$$anon$1",{l6:1,Sa:1,g:1,Ka:1,M:1,N:1});function js(a){this.o6=a;this.TG=-1+a.length|0}js.prototype=new BY;js.prototype.constructor=js;js.prototype.s=function(){return 0<=this.TG};js.prototype.t=function(){try{var a=this.o6.charCodeAt(this.TG);this.TG=-1+this.TG|0;var b=a}catch(c){if(c instanceof bL)b=Ea(Rq().Pa.t());else throw c;}return hc(b)};
+js.prototype.$classData=q({n6:0},!1,"scala.collection.StringOps$ReverseIterator",{n6:1,Sa:1,g:1,Ka:1,M:1,N:1});function M0(a,b){this.ZB=null;this.$B=a;this.DL=b;this.Sv=-1;this.Up=0}M0.prototype=new BY;M0.prototype.constructor=M0;M0.prototype.Q=function(){return this.Sv};M0.prototype.s=function(){if(null===this.ZB){var a=this.DL;for(this.ZB=Mv(256>a?a:256);this.Up<this.DL&&this.$B.s();)ol(this.ZB,this.$B.t()),this.Up=1+this.Up|0;this.$B.s()||(this.Sv=0);this.Up=0}return 0!==this.Sv};
+M0.prototype.t=function(){if(this.s()){var a=this.ZB.va(this.Up);-1===this.Sv?(N0(this.ZB,this.Up,this.$B.t()),this.$B.s()||(this.Sv=0)):this.Sv=-1+this.Sv|0;this.Up=1+this.Up|0;this.Up===this.DL&&(this.Up=0);return a}return Rq().Pa.t()};M0.prototype.$classData=q({x6:0},!1,"scala.collection.View$DropRightIterator",{x6:1,Sa:1,g:1,Ka:1,M:1,N:1});function O0(a){null!==a.gC&&(a.Nr=rU(a.Nr));a.gC=null}function WU(){this.Nr=this.gC=null;this.Nr=new aI(0,0,kG().EK,kG().KB,0,0)}WU.prototype=new p;
+WU.prototype.constructor=WU;f=WU.prototype;f.he=function(){};
+function SQ(a,b,c,d,e,g,h){if(b instanceof aI){var k=kI(HH(),g,h),l=lI(HH(),k);if(0!==(b.Db&l)){var m=oI(HH(),b.Db,k,l);a=b.Ef(m);k=b.Jb(m);if(k===e&&ml(nl(),a,c))b.te.a[1+(m<<1)|0]=d;else{var n=b.Tf(m);m=$G(bH(),k);e=jU(b,a,n,k,m,c,d,e,g,5+h|0);mU(b,l,m,e)}}else if(0!==(b.qc&l))l=oI(HH(),b.qc,k,l),l=b.qh(l),k=l.ka(),m=l.uc(),SQ(a,l,c,d,e,g,5+h|0),b.kd=b.kd+(l.ka()-k|0)|0,b.ui=b.ui+(l.uc()-m|0)|0;else{h=b.pi(l);k=h<<1;m=b.te;a=new zc(2+m.a.length|0);m.wa(0,a,0,k);a.a[k]=c;a.a[1+k|0]=d;m.wa(k,a,2+
+k|0,m.a.length-k|0);c=b.Vg;if(0>h)throw P0();if(h>c.a.length)throw P0();d=new Xc(1+c.a.length|0);c.wa(0,d,0,h);d.a[h]=e;c.wa(h,d,1+h|0,c.a.length-h|0);b.Db|=l;b.te=a;b.Vg=d;b.kd=1+b.kd|0;b.ui=b.ui+g|0}}else if(b instanceof oU)e=KU(b,c),b.of=0>e?b.of.hn(G(new H,c,d)):b.of.$r(e,G(new H,c,d));else throw new w(b);}function UU(a){if(0===a.Nr.kd)return Ez().Mr;null===a.gC&&(a.gC=new TU(a.Nr));return a.gC}
+function Q0(a,b){O0(a);var c=b.h();c=My(W(),c);var d=$G(bH(),c);SQ(a,a.Nr,b.h(),b.j(),c,d,0);return a}function R0(a,b,c){O0(a);var d=My(W(),b);SQ(a,a.Nr,b,c,d,$G(bH(),d),0);return a}function VU(a,b){O0(a);if(b instanceof TU)new RQ(a,b);else if(b instanceof DV)for(b=S0(b);b.s();){var c=b.t(),d=c.mk;d^=d>>>16|0;var e=$G(bH(),d);SQ(a,a.Nr,c.Wk,c.Ah,d,e,0)}else if(jV(b))b.og(new fn((g,h)=>R0(a,g,h)));else for(b=b.m();b.s();)Q0(a,b.t());return a}f.zc=function(a){return VU(this,a)};
+f.$=function(a){return Q0(this,a)};f.Kb=function(){return UU(this)};f.$classData=q({Z6:0},!1,"scala.collection.immutable.HashMapBuilder",{Z6:1,g:1,Po:1,xg:1,xf:1,wf:1});function cV(){this.Or=this.$v=null;this.Or=new CJ(0,0,kG().EK,kG().KB,0,0)}cV.prototype=new p;cV.prototype.constructor=cV;f=cV.prototype;f.he=function(){};
+function UQ(a,b,c,d,e,g){if(b instanceof CJ){var h=kI(HH(),e,g),k=lI(HH(),h);if(0!==(b.db&k)){h=oI(HH(),b.db,h,k);a=b.ed(h);var l=b.Jb(h);l===d&&ml(nl(),a,c)?(d=b.pi(k),b.Uc.a[d]=a):(h=$G(bH(),l),d=zU(b,a,l,h,c,d,e,5+g|0),CU(b,k,h,d))}else if(0!==(b.Pb&k))k=oI(HH(),b.Pb,h,k),k=b.Nh(k),h=k.ka(),l=k.uc(),UQ(a,k,c,d,e,5+g|0),b.Fb=b.Fb+(k.ka()-h|0)|0,b.Ve=b.Ve+(k.uc()-l|0)|0;else{g=b.pi(k);h=b.Uc;a=new zc(1+h.a.length|0);h.wa(0,a,0,g);a.a[g]=c;h.wa(g,a,1+g|0,h.a.length-g|0);c=b.Ud;if(0>g)throw P0();if(g>
+c.a.length)throw P0();h=new Xc(1+c.a.length|0);c.wa(0,h,0,g);h.a[g]=d;c.wa(g,h,1+g|0,c.a.length-g|0);b.db|=k;b.Uc=a;b.Ud=h;b.Fb=1+b.Fb|0;b.Ve=b.Ve+e|0}}else if(b instanceof FU)d=Xea(b.Kg,c),b.Kg=0>d?b.Kg.hn(c):b.Kg.$r(d,c);else throw new w(b);}function aV(a){if(0===a.Or.Fb)return dV().Fo;null===a.$v&&(a.$v=new ZU(a.Or));return a.$v}function T0(a,b){null!==a.$v&&(a.Or=IU(a.Or));a.$v=null;var c=My(W(),b),d=$G(bH(),c);UQ(a,a.Or,b,c,d,0);return a}
+function bV(a,b){null!==a.$v&&(a.Or=IU(a.Or));a.$v=null;if(b instanceof ZU)new TQ(a,b);else for(b=b.m();b.s();)T0(a,b.t());return a}f.zc=function(a){return bV(this,a)};f.$=function(a){return T0(this,a)};f.Kb=function(){return aV(this)};f.$classData=q({c7:0},!1,"scala.collection.immutable.HashSetBuilder",{c7:1,g:1,Po:1,xg:1,xf:1,wf:1});function U0(){this.Bl=null;this.Bl=GK()}U0.prototype=new MY;U0.prototype.constructor=U0;function we(a,b){return V0(b)?b:LY.prototype.vl.call(a,b)}
+U0.prototype.Ib=function(a){return we(this,a)};U0.prototype.vl=function(a){return we(this,a)};U0.prototype.$classData=q({e7:0},!1,"scala.collection.immutable.IndexedSeq$",{e7:1,FG:1,g:1,Nk:1,bg:1,l:1});var W0;function xe(){W0||(W0=new U0);return W0}function lZ(){this.mS=this.Qy=null;this.mg()}lZ.prototype=new p;lZ.prototype.constructor=lZ;f=lZ.prototype;f.he=function(){};f.mg=function(){var a=new VH;FK();this.mS=new gZ(new U(()=>WH(a)));this.Qy=a};
+function hfa(a){YH(a.Qy,new U(()=>hV()));return a.mS}function ifa(a,b){var c=new VH;YH(a.Qy,new U(()=>{FK();FK();return new eV(b,new gZ(new U(()=>WH(c))))}));a.Qy=c;return a}function jfa(a,b){if(0!==b.Q()){var c=new VH;YH(a.Qy,new U(()=>jZ(FK(),b.m(),new U(()=>WH(c)))));a.Qy=c}return a}f.zc=function(a){return jfa(this,a)};f.$=function(a){return ifa(this,a)};f.Kb=function(){return hfa(this)};f.$classData=q({j7:0},!1,"scala.collection.immutable.LazyList$LazyBuilder",{j7:1,g:1,Po:1,xg:1,xf:1,wf:1});
+function X0(a){this.hC=a}X0.prototype=new BY;X0.prototype.constructor=X0;X0.prototype.s=function(){return!this.hC.b()};X0.prototype.t=function(){if(this.hC.b())return Rq().Pa.t();var a=hZ(this.hC).e();this.hC=hZ(this.hC).Lf();return a};X0.prototype.$classData=q({l7:0},!1,"scala.collection.immutable.LazyList$LazyIterator",{l7:1,Sa:1,g:1,Ka:1,M:1,N:1});function Y0(){this.iC=this.jC=null;Z0=this;this.jC=G(new H,u(),u());this.iC=new VQ}Y0.prototype=new p;Y0.prototype.constructor=Y0;f=Y0.prototype;
+f.Hh=function(a){return Pd(u(),a)};f.Eb=function(){return new fp};f.X=function(){return u()};f.Ib=function(a){return Pd(u(),a)};f.$classData=q({s7:0},!1,"scala.collection.immutable.List$",{s7:1,g:1,Qt:1,Nk:1,bg:1,l:1});var Z0;function Od(){Z0||(Z0=new Y0);return Z0}function $0(a,b){if(null===b)throw null;a.Vt=b;a.Yp=0}function a1(){this.Yp=0;this.Vt=null}a1.prototype=new BY;a1.prototype.constructor=a1;function b1(){}b1.prototype=a1.prototype;a1.prototype.s=function(){return 2>this.Yp};
+a1.prototype.t=function(){switch(this.Yp){case 0:var a=this.wj(this.Vt.hk,this.Vt.xn);break;case 1:a=this.wj(this.Vt.ik,this.Vt.yn);break;default:a=Rq().Pa.t()}this.Yp=1+this.Yp|0;return a};a1.prototype.ph=function(a){this.Yp=this.Yp+a|0;return this};function c1(a,b){if(null===b)throw null;a.Zp=b;a.$p=0}function d1(){this.$p=0;this.Zp=null}d1.prototype=new BY;d1.prototype.constructor=d1;function e1(){}e1.prototype=d1.prototype;d1.prototype.s=function(){return 3>this.$p};
+d1.prototype.t=function(){switch(this.$p){case 0:var a=this.wj(this.Zp.dj,this.Zp.Fl);break;case 1:a=this.wj(this.Zp.Mi,this.Zp.Qk);break;case 2:a=this.wj(this.Zp.Ni,this.Zp.Rk);break;default:a=Rq().Pa.t()}this.$p=1+this.$p|0;return a};d1.prototype.ph=function(a){this.$p=this.$p+a|0;return this};function f1(a,b){if(null===b)throw null;a.zn=b;a.aq=0}function g1(){this.aq=0;this.zn=null}g1.prototype=new BY;g1.prototype.constructor=g1;function h1(){}h1.prototype=g1.prototype;
+g1.prototype.s=function(){return 4>this.aq};g1.prototype.t=function(){switch(this.aq){case 0:var a=this.wj(this.zn.Th,this.zn.Aj);break;case 1:a=this.wj(this.zn.xh,this.zn.ej);break;case 2:a=this.wj(this.zn.Wg,this.zn.Oi);break;case 3:a=this.wj(this.zn.Xg,this.zn.Pi);break;default:a=Rq().Pa.t()}this.aq=1+this.aq|0;return a};g1.prototype.ph=function(a){this.aq=this.aq+a|0;return this};function lV(){this.bq=null;this.Sy=!1;this.Wt=null;this.bq=nf();this.Sy=!1}lV.prototype=new p;
+lV.prototype.constructor=lV;f=lV.prototype;f.he=function(){};function kV(a,b){return a.Sy?(VU(a.Wt,b),a):lR(a,b)}f.zc=function(a){return kV(this,a)};f.$=function(a){var b=a.h();a=a.j();if(this.Sy)R0(this.Wt,b,a);else if(4>this.bq.ka())this.bq=this.bq.Em(b,a);else if(this.bq.L(b))this.bq=this.bq.Em(b,a);else{this.Sy=!0;null===this.Wt&&(this.Wt=new WU);var c=this.bq;R0(R0(R0(R0(this.Wt,c.Th,c.Aj),c.xh,c.ej),c.Wg,c.Oi),c.Xg,c.Pi);R0(this.Wt,b,a)}return this};
+f.Kb=function(){return this.Sy?UU(this.Wt):this.bq};f.$classData=q({J7:0},!1,"scala.collection.immutable.MapBuilderImpl",{J7:1,g:1,Po:1,xg:1,xf:1,wf:1});function i1(a){this.wn=this.Nc=0;this.wh=null;this.vi=0;this.Do=this.Ok=null;JH(this,a)}i1.prototype=new LH;i1.prototype.constructor=i1;f=i1.prototype;f.m=function(){return this};f.b=function(){return!this.s()};f.nb=function(a){return kv(this,a)};f.Mn=function(a){return NT(this,a)};f.ph=function(a){return OT(this,a,-1)};
+f.qk=function(a,b){return OT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.Ca=function(a){cH(this,a)};f.De=function(a,b){return mB(this,a,b)};f.th=function(a){return eH(this,a)};f.Gc=function(a,b,c){return NB(this,a,b,c)};f.aj=function(a){return gH(this,a)};f.$i=function(a){return hH(this,a)};f.Gh=function(a,b,c,d){return iH(this,a,b,c,d)};f.ha=function(){Od();return Pd(u(),this)};f.Ti=function(){return pp(qp(),this)};f.Bj=function(a){return kB(this,a)};f.ad=function(){return er(this)};
+f.Q=function(){return-1};f.t=function(){if(!this.s())throw LU();var a=this.wh.Ef(this.Nc);this.Nc=1+this.Nc|0;return a};f.Ja=function(a){return new Ef(this,a)};f.$classData=q({K7:0},!1,"scala.collection.immutable.MapKeyIterator",{K7:1,Vv:1,g:1,Ka:1,M:1,N:1});function j1(a){this.gk=0;this.Ut=null;this.Pk=0;this.Xv=this.Wv=null;this.LL=0;this.uS=null;OH(this,a);this.LL=0}j1.prototype=new QH;j1.prototype.constructor=j1;f=j1.prototype;f.m=function(){return this};f.b=function(){return!this.s()};
+f.nb=function(a){return kv(this,a)};f.Mn=function(a){return NT(this,a)};f.ph=function(a){return OT(this,a,-1)};f.qk=function(a,b){return OT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.Ca=function(a){cH(this,a)};f.De=function(a,b){return mB(this,a,b)};f.th=function(a){return eH(this,a)};f.Gc=function(a,b,c){return NB(this,a,b,c)};f.aj=function(a){return gH(this,a)};f.$i=function(a){return hH(this,a)};f.Gh=function(a,b,c,d){return iH(this,a,b,c,d)};f.ha=function(){Od();return Pd(u(),this)};
+f.Ti=function(){return pp(qp(),this)};f.Bj=function(a){return kB(this,a)};f.ad=function(){return er(this)};f.Q=function(){return-1};f.B=function(){var a=BL(),b=this.uS;return zL(a,this.LL,My(W(),b))};f.Ja=function(a){return new Ef(this,a)};f.t=function(){if(!this.s())throw LU();this.LL=this.Ut.Jb(this.gk);this.uS=this.Ut.Tf(this.gk);this.gk=-1+this.gk|0;return this};f.$classData=q({L7:0},!1,"scala.collection.immutable.MapKeyValueTupleHashIterator",{L7:1,jS:1,g:1,Ka:1,M:1,N:1});
+function k1(a){this.wn=this.Nc=0;this.wh=null;this.vi=0;this.Do=this.Ok=null;JH(this,a)}k1.prototype=new LH;k1.prototype.constructor=k1;f=k1.prototype;f.m=function(){return this};f.b=function(){return!this.s()};f.nb=function(a){return kv(this,a)};f.Mn=function(a){return NT(this,a)};f.ph=function(a){return OT(this,a,-1)};f.qk=function(a,b){return OT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.Ca=function(a){cH(this,a)};f.De=function(a,b){return mB(this,a,b)};
+f.th=function(a){return eH(this,a)};f.Gc=function(a,b,c){return NB(this,a,b,c)};f.aj=function(a){return gH(this,a)};f.$i=function(a){return hH(this,a)};f.Gh=function(a,b,c,d){return iH(this,a,b,c,d)};f.ha=function(){Od();return Pd(u(),this)};f.Ti=function(){return pp(qp(),this)};f.Bj=function(a){return kB(this,a)};f.ad=function(){return er(this)};f.Q=function(){return-1};f.gm=function(){if(!this.s())throw LU();var a=this.wh.rv(this.Nc);this.Nc=1+this.Nc|0;return a};
+f.Ja=function(a){return new Ef(this,a)};f.t=function(){return this.gm()};f.$classData=q({M7:0},!1,"scala.collection.immutable.MapKeyValueTupleIterator",{M7:1,Vv:1,g:1,Ka:1,M:1,N:1});function l1(a){this.gk=0;this.Ut=null;this.Pk=0;this.Xv=this.Wv=null;OH(this,a)}l1.prototype=new QH;l1.prototype.constructor=l1;f=l1.prototype;f.m=function(){return this};f.b=function(){return!this.s()};f.nb=function(a){return kv(this,a)};f.Mn=function(a){return NT(this,a)};f.ph=function(a){return OT(this,a,-1)};
+f.qk=function(a,b){return OT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.Ca=function(a){cH(this,a)};f.De=function(a,b){return mB(this,a,b)};f.th=function(a){return eH(this,a)};f.Gc=function(a,b,c){return NB(this,a,b,c)};f.aj=function(a){return gH(this,a)};f.$i=function(a){return hH(this,a)};f.Gh=function(a,b,c,d){return iH(this,a,b,c,d)};f.ha=function(){Od();return Pd(u(),this)};f.Ti=function(){return pp(qp(),this)};f.Bj=function(a){return kB(this,a)};f.ad=function(){return er(this)};
+f.Q=function(){return-1};f.gm=function(){if(!this.s())throw LU();var a=this.Ut.rv(this.gk);this.gk=-1+this.gk|0;return a};f.Ja=function(a){return new Ef(this,a)};f.t=function(){return this.gm()};f.$classData=q({N7:0},!1,"scala.collection.immutable.MapKeyValueTupleReverseIterator",{N7:1,jS:1,g:1,Ka:1,M:1,N:1});function m1(a){this.wn=this.Nc=0;this.wh=null;this.vi=0;this.Do=this.Ok=null;JH(this,a)}m1.prototype=new LH;m1.prototype.constructor=m1;f=m1.prototype;f.m=function(){return this};f.b=function(){return!this.s()};
+f.nb=function(a){return kv(this,a)};f.Mn=function(a){return NT(this,a)};f.ph=function(a){return OT(this,a,-1)};f.qk=function(a,b){return OT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.Ca=function(a){cH(this,a)};f.De=function(a,b){return mB(this,a,b)};f.th=function(a){return eH(this,a)};f.Gc=function(a,b,c){return NB(this,a,b,c)};f.aj=function(a){return gH(this,a)};f.$i=function(a){return hH(this,a)};f.Gh=function(a,b,c,d){return iH(this,a,b,c,d)};f.ha=function(){Od();return Pd(u(),this)};
+f.Ti=function(){return pp(qp(),this)};f.Bj=function(a){return kB(this,a)};f.ad=function(){return er(this)};f.Q=function(){return-1};f.t=function(){if(!this.s())throw LU();var a=this.wh.Tf(this.Nc);this.Nc=1+this.Nc|0;return a};f.Ja=function(a){return new Ef(this,a)};f.$classData=q({R7:0},!1,"scala.collection.immutable.MapValueIterator",{R7:1,Vv:1,g:1,Ka:1,M:1,N:1});
+function n1(a){a.xi<=a.Lg&&Rq().Pa.t();a.ew=1+a.ew|0;for(var b=a.wS.To(a.ew);0===b.a.length;)a.ew=1+a.ew|0,b=a.wS.To(a.ew);a.YG=a.Yt;var c=a.T7/2|0,d=a.ew-c|0;a.dw=(1+c|0)-(0>d?-d|0:d)|0;c=a.dw;switch(c){case 1:a.Go=b;break;case 2:a.aw=b;break;case 3:a.bw=b;break;case 4:a.cw=b;break;case 5:a.Uy=b;break;case 6:a.ML=b;break;default:throw new w(c);}a.Yt=a.YG+Math.imul(b.a.length,1<<Math.imul(5,-1+a.dw|0))|0;a.Yt>a.Bn&&(a.Yt=a.Bn);1<a.dw&&(a.kC=-1+(1<<Math.imul(5,a.dw))|0)}
+function o1(a){var b=(a.Lg-a.xi|0)+a.Bn|0;b===a.Yt&&n1(a);if(1<a.dw){b=b-a.YG|0;var c=a.kC^b;1024>c?a.Go=a.aw.a[31&(b>>>5|0)]:(32768>c?a.aw=a.bw.a[31&(b>>>10|0)]:(1048576>c?a.bw=a.cw.a[31&(b>>>15|0)]:(33554432>c?a.cw=a.Uy.a[31&(b>>>20|0)]:(a.Uy=a.ML.a[b>>>25|0],a.cw=a.Uy.a[0]),a.bw=a.cw.a[0]),a.aw=a.bw.a[0]),a.Go=a.aw.a[0]);a.kC=b}a.xi=a.xi-a.Lg|0;b=a.Go.a.length;c=a.xi;a.cq=b<c?b:c;a.Lg=0}
+function p1(a,b,c){this.ML=this.Uy=this.cw=this.bw=this.aw=null;this.wS=a;this.Bn=b;this.T7=c;this.Go=a.R;this.cq=this.Go.a.length;this.kC=this.Lg=0;this.xi=this.Bn;this.ew=0;this.dw=1;this.YG=0;this.Yt=this.cq}p1.prototype=new p;p1.prototype.constructor=p1;f=p1.prototype;f.m=function(){return this};f.b=function(){return this.xi<=this.Lg};f.nb=function(a){return kv(this,a)};f.qk=function(a,b){return OT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.Ca=function(a){cH(this,a)};
+f.De=function(a,b){return mB(this,a,b)};f.th=function(a){return eH(this,a)};f.aj=function(a){return gH(this,a)};f.$i=function(a){return hH(this,a)};f.Gh=function(a,b,c,d){return iH(this,a,b,c,d)};f.ha=function(){Od();return Pd(u(),this)};f.Ti=function(){return pp(qp(),this)};f.Bj=function(a){return kB(this,a)};f.ad=function(){return er(this)};f.Q=function(){return this.xi-this.Lg|0};f.s=function(){return this.xi>this.Lg};
+f.t=function(){this.Lg===this.cq&&o1(this);var a=this.Go.a[this.Lg];this.Lg=1+this.Lg|0;return a};
+f.ph=function(a){if(0<a){a=((this.Lg-this.xi|0)+this.Bn|0)+a|0;var b=this.Bn;a=a<b?a:b;if(a===this.Bn)this.cq=this.xi=this.Lg=0;else{for(;a>=this.Yt;)n1(this);b=a-this.YG|0;if(1<this.dw){var c=this.kC^b;1024>c||(32768>c||(1048576>c||(33554432>c||(this.Uy=this.ML.a[b>>>25|0]),this.cw=this.Uy.a[31&(b>>>20|0)]),this.bw=this.cw.a[31&(b>>>15|0)]),this.aw=this.bw.a[31&(b>>>10|0)]);this.Go=this.aw.a[31&(b>>>5|0)];this.kC=b}this.cq=this.Go.a.length;this.Lg=31&b;this.xi=this.Lg+(this.Bn-a|0)|0;this.cq>this.xi&&
+(this.cq=this.xi)}}return this};f.Mn=function(a){a<(this.xi-this.Lg|0)&&(a=(this.xi-this.Lg|0)-(0>a?0:a)|0,this.Bn=this.Bn-a|0,this.xi=this.xi-a|0,this.xi<this.cq&&(this.cq=this.xi),this.Bn<this.Yt&&(this.Yt=this.Bn));return this};
+f.Gc=function(a,b,c){var d=wG(xG(),a),e=this.xi-this.Lg|0;c=c<e?c:e;d=d-b|0;d=c<d?c:d;d=0<d?d:0;c=0;for(e=a instanceof zc;c<d;){this.Lg===this.cq&&o1(this);var g=d-c|0,h=this.Go.a.length-this.Lg|0;g=g<h?g:h;e?this.Go.wa(this.Lg,a,b+c|0,g):VG(SG(),this.Go,this.Lg,a,b+c|0,g);this.Lg=this.Lg+g|0;c=c+g|0}return d};f.Ja=function(a){return new Ef(this,a)};f.$classData=q({S7:0},!1,"scala.collection.immutable.NewVectorIterator",{S7:1,g:1,Ka:1,M:1,N:1,Ff:1});
+function q1(a,b,c,d){a.Xy=b;a.hw=d;null===b?d=null:(d=-2+((32-Math.clz32(1+(2147483647&b.ea)|0)|0)<<1)|0,d=new (md(zJ).Ia)(d));a.Cn=d;a.Wd=0;if(c.b())b=r1(a,b);else if(b=c.o(),null===a.Xy)b=null;else a:for(c=a.Xy;;){if(null===c){if(0===a.Wd){b=null;break a}a.Wd=-1+a.Wd|0;b=a.Cn.a[a.Wd];break a}a.hw.uj(b,c.Wa)?(a.Cn.a[a.Wd]=c,a.Wd=1+a.Wd|0,c=c.sa):c=c.ta}a.Hc=b}function s1(){this.Cn=this.hw=this.Xy=null;this.Wd=0;this.Hc=null}s1.prototype=new BY;s1.prototype.constructor=s1;function t1(){}
+t1.prototype=s1.prototype;s1.prototype.s=function(){return null!==this.Hc};s1.prototype.t=function(){var a=this.Hc;return null!==a?(this.Hc=r1(this,a.ta),this.yK(a)):Rq().Pa.t()};function r1(a,b){for(;;){if(null===b){if(0===a.Wd)return null;a.Wd=-1+a.Wd|0;return a.Cn.a[a.Wd]}if(null===b.sa)return b;a.Cn.a[a.Wd]=b;a.Wd=1+a.Wd|0;b=b.sa}}function u1(){this.Bl=null;this.Bl=Od()}u1.prototype=new MY;u1.prototype.constructor=u1;
+function v1(a,b){return b&&b.$classData&&b.$classData.rb.Mg?b:LY.prototype.vl.call(a,b)}u1.prototype.Ib=function(a){return v1(this,a)};u1.prototype.vl=function(a){return v1(this,a)};u1.prototype.$classData=q({i8:0},!1,"scala.collection.immutable.Seq$",{i8:1,FG:1,g:1,Nk:1,bg:1,l:1});var w1;function EK(){w1||(w1=new u1);return w1}function OF(){this.kw=null;this.oC=!1;this.lw=null;this.kw=ap();this.oC=!1}OF.prototype=new p;OF.prototype.constructor=OF;f=OF.prototype;f.he=function(){};
+function MF(a){return a.oC?aV(a.lw):a.kw}function NF(a,b){if(a.oC)T0(a.lw,b);else if(4>a.kw.ka())a.kw=a.kw.bc(b);else if(!a.kw.L(b)){a.oC=!0;null===a.lw&&(a.lw=new cV);var c=a.kw;a.lw.$(c.Ho).$(c.eq).$(c.fq).$(c.gq);T0(a.lw,b)}return a}function oV(a,b){return a.oC?(bV(a.lw,b),a):lR(a,b)}f.zc=function(a){return oV(this,a)};f.$=function(a){return NF(this,a)};f.Kb=function(){return MF(this)};f.$classData=q({s8:0},!1,"scala.collection.immutable.SetBuilderImpl",{s8:1,g:1,Po:1,xg:1,xf:1,wf:1});
+function x1(a){this.wn=this.Nc=0;this.wh=null;this.vi=0;this.Do=this.Ok=null;this.NL=0;JH(this,a);this.NL=0}x1.prototype=new LH;x1.prototype.constructor=x1;f=x1.prototype;f.m=function(){return this};f.b=function(){return!this.s()};f.nb=function(a){return kv(this,a)};f.Mn=function(a){return NT(this,a)};f.ph=function(a){return OT(this,a,-1)};f.qk=function(a,b){return OT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.Ca=function(a){cH(this,a)};f.De=function(a,b){return mB(this,a,b)};
+f.th=function(a){return eH(this,a)};f.Gc=function(a,b,c){return NB(this,a,b,c)};f.aj=function(a){return gH(this,a)};f.$i=function(a){return hH(this,a)};f.Gh=function(a,b,c,d){return iH(this,a,b,c,d)};f.ha=function(){Od();return Pd(u(),this)};f.Ti=function(){return pp(qp(),this)};f.Bj=function(a){return kB(this,a)};f.ad=function(){return er(this)};f.Q=function(){return-1};f.B=function(){return this.NL};f.t=function(){if(!this.s())throw LU();this.NL=this.wh.Jb(this.Nc);this.Nc=1+this.Nc|0;return this};
+f.Ja=function(a){return new Ef(this,a)};f.$classData=q({t8:0},!1,"scala.collection.immutable.SetHashIterator",{t8:1,Vv:1,g:1,Ka:1,M:1,N:1});function y1(a){this.wn=this.Nc=0;this.wh=null;this.vi=0;this.Do=this.Ok=null;JH(this,a)}y1.prototype=new LH;y1.prototype.constructor=y1;f=y1.prototype;f.m=function(){return this};f.b=function(){return!this.s()};f.nb=function(a){return kv(this,a)};f.Mn=function(a){return NT(this,a)};f.ph=function(a){return OT(this,a,-1)};f.qk=function(a,b){return OT(this,a,b)};
+f.u=function(){return"\x3citerator\x3e"};f.Ca=function(a){cH(this,a)};f.De=function(a,b){return mB(this,a,b)};f.th=function(a){return eH(this,a)};f.Gc=function(a,b,c){return NB(this,a,b,c)};f.aj=function(a){return gH(this,a)};f.$i=function(a){return hH(this,a)};f.Gh=function(a,b,c,d){return iH(this,a,b,c,d)};f.ha=function(){Od();return Pd(u(),this)};f.Ti=function(){return pp(qp(),this)};f.Bj=function(a){return kB(this,a)};f.ad=function(){return er(this)};f.Q=function(){return-1};
+f.t=function(){if(!this.s())throw LU();var a=this.wh.ed(this.Nc);this.Nc=1+this.Nc|0;return a};f.Ja=function(a){return new Ef(this,a)};f.$classData=q({u8:0},!1,"scala.collection.immutable.SetIterator",{u8:1,Vv:1,g:1,Ka:1,M:1,N:1});function z1(a){this.gk=0;this.Ut=null;this.Pk=0;this.Xv=this.Wv=null;OH(this,a)}z1.prototype=new QH;z1.prototype.constructor=z1;f=z1.prototype;f.m=function(){return this};f.b=function(){return!this.s()};f.nb=function(a){return kv(this,a)};
+f.Mn=function(a){return NT(this,a)};f.ph=function(a){return OT(this,a,-1)};f.qk=function(a,b){return OT(this,a,b)};f.u=function(){return"\x3citerator\x3e"};f.Ca=function(a){cH(this,a)};f.De=function(a,b){return mB(this,a,b)};f.th=function(a){return eH(this,a)};f.Gc=function(a,b,c){return NB(this,a,b,c)};f.aj=function(a){return gH(this,a)};f.$i=function(a){return hH(this,a)};f.Gh=function(a,b,c,d){return iH(this,a,b,c,d)};f.ha=function(){Od();return Pd(u(),this)};f.Ti=function(){return pp(qp(),this)};
+f.Bj=function(a){return kB(this,a)};f.ad=function(){return er(this)};f.Q=function(){return-1};f.t=function(){if(!this.s())throw LU();var a=this.Ut.ed(this.gk);this.gk=-1+this.gk|0;return a};f.Ja=function(a){return new Ef(this,a)};f.$classData=q({x8:0},!1,"scala.collection.immutable.SetReverseIterator",{x8:1,jS:1,g:1,Ka:1,M:1,N:1});
+function A1(){this.HS=0;this.IS=null;B1=this;try{var a=fh(gh(),"scala.collection.immutable.Vector.defaultApplyPreferredMaxLength","250");var b=TH(UH(),a,10)}catch(c){throw c;}this.HS=b;this.IS=new p1(HJ(),0,0)}A1.prototype=new p;A1.prototype.constructor=A1;f=A1.prototype;f.Hh=function(a){return pU(0,a)};
+function pU(a,b){if(b instanceof C1)return b;a=b.Q();if(0===a)return HJ();if(0<a&&32>=a){a:{if(b instanceof Fu){var c=b.ag().uh();if(null!==c&&c===da(jd)){b=b.vn;break a}}ZJ(b)?(a=new zc(a),b.Gc(a,0,2147483647),b=a):(a=new zc(a),b.m().Gc(a,0,2147483647),b=a)}return new IJ(b)}return OU(new NU,b).im()}f.Eb=function(){return new NU};f.Ib=function(a){return pU(0,a)};f.X=function(){return HJ()};f.$classData=q({P8:0},!1,"scala.collection.immutable.Vector$",{P8:1,g:1,Qt:1,Nk:1,bg:1,l:1});var B1;
+function GK(){B1||(B1=new A1);return B1}function D1(a,b){var c=b.a.length;if(0<c){32===a.Yd&&E1(a);var d=32-a.Yd|0;d=d<c?d:c;c=c-d|0;b.wa(0,a.af,a.Yd,d);a.Yd=a.Yd+d|0;0<c&&(E1(a),b.wa(d,a.af,0,c),a.Yd=a.Yd+c|0)}}function kfa(a,b){for(var c=b.On(),d=0;d<c;){var e=b.To(d),g=c/2|0,h=d-g|0;g=(1+g|0)-(0>h?-h|0:h)|0;1===g?D1(a,e):VJ(JJ(),-2+g|0,e,new y(k=>{D1(a,k)}));d=1+d|0}return a}
+function E1(a){var b=32+a.yi|0,c=b^a.yi;a.yi=b;a.Yd=0;if(1024>c)1===a.wg&&(a.sd=new (md(md(jd)).Ia)(32),a.sd.a[0]=a.af,a.wg=1+a.wg|0),a.af=new zc(32),a.sd.a[31&(b>>>5|0)]=a.af;else if(32768>c)2===a.wg&&(a.ue=new (md(md(md(jd))).Ia)(32),a.ue.a[0]=a.sd,a.wg=1+a.wg|0),a.af=new zc(32),a.sd=new (md(md(jd)).Ia)(32),a.sd.a[31&(b>>>5|0)]=a.af,a.ue.a[31&(b>>>10|0)]=a.sd;else if(1048576>c)3===a.wg&&(a.Jf=new (md(md(md(md(jd)))).Ia)(32),a.Jf.a[0]=a.ue,a.wg=1+a.wg|0),a.af=new zc(32),a.sd=new (md(md(jd)).Ia)(32),
+a.ue=new (md(md(md(jd))).Ia)(32),a.sd.a[31&(b>>>5|0)]=a.af,a.ue.a[31&(b>>>10|0)]=a.sd,a.Jf.a[31&(b>>>15|0)]=a.ue;else if(33554432>c)4===a.wg&&(a.Pg=new (md(md(md(md(md(jd))))).Ia)(32),a.Pg.a[0]=a.Jf,a.wg=1+a.wg|0),a.af=new zc(32),a.sd=new (md(md(jd)).Ia)(32),a.ue=new (md(md(md(jd))).Ia)(32),a.Jf=new (md(md(md(md(jd)))).Ia)(32),a.sd.a[31&(b>>>5|0)]=a.af,a.ue.a[31&(b>>>10|0)]=a.sd,a.Jf.a[31&(b>>>15|0)]=a.ue,a.Pg.a[31&(b>>>20|0)]=a.Jf;else if(1073741824>c)5===a.wg&&(a.Si=new (md(md(md(md(md(md(jd)))))).Ia)(64),
+a.Si.a[0]=a.Pg,a.wg=1+a.wg|0),a.af=new zc(32),a.sd=new (md(md(jd)).Ia)(32),a.ue=new (md(md(md(jd))).Ia)(32),a.Jf=new (md(md(md(md(jd)))).Ia)(32),a.Pg=new (md(md(md(md(md(jd))))).Ia)(32),a.sd.a[31&(b>>>5|0)]=a.af,a.ue.a[31&(b>>>10|0)]=a.sd,a.Jf.a[31&(b>>>15|0)]=a.ue,a.Pg.a[31&(b>>>20|0)]=a.Jf,a.Si.a[31&(b>>>25|0)]=a.Pg;else throw Kj("advance1("+b+", "+c+"): a1\x3d"+a.af+", a2\x3d"+a.sd+", a3\x3d"+a.ue+", a4\x3d"+a.Jf+", a5\x3d"+a.Pg+", a6\x3d"+a.Si+", depth\x3d"+a.wg);}
+function NU(){this.af=this.sd=this.ue=this.Jf=this.Pg=this.Si=null;this.wg=this.Gl=this.yi=this.Yd=0;this.af=new zc(32);this.Gl=this.yi=this.Yd=0;this.wg=1}NU.prototype=new p;NU.prototype.constructor=NU;f=NU.prototype;f.he=function(){};function lfa(a,b){a.wg=1;var c=b.a.length;a.Yd=31&c;a.yi=c-a.Yd|0;a.af=32===b.a.length?b:Jj(Pj(),b,0,32);0===a.Yd&&0<a.yi&&(a.Yd=32,a.yi=-32+a.yi|0)}
+function F1(a,b){var c=b.On();switch(c){case 0:break;case 1:a.wg=1;c=b.R.a.length;a.Yd=31&c;a.yi=c-a.Yd|0;b=b.R;a.af=32===b.a.length?b:Jj(Pj(),b,0,32);break;case 3:c=b.yh;var d=b.Z;a.af=32===d.a.length?d:Jj(Pj(),d,0,32);a.wg=2;a.Gl=32-b.Ri|0;d=b.ca+a.Gl|0;a.Yd=31&d;a.yi=d-a.Yd|0;a.sd=new (md(md(jd)).Ia)(32);a.sd.a[0]=b.R;c.wa(0,a.sd,1,c.a.length);a.sd.a[1+c.a.length|0]=a.af;break;case 5:c=b.cg;d=b.tg;var e=b.Z;a.af=32===e.a.length?e:Jj(Pj(),e,0,32);a.wg=3;a.Gl=1024-b.zh|0;e=b.ca+a.Gl|0;a.Yd=31&e;
+a.yi=e-a.Yd|0;a.ue=new (md(md(md(jd))).Ia)(32);a.ue.a[0]=UJ(JJ(),b.R,b.Wh);c.wa(0,a.ue,1,c.a.length);a.sd=zj(Pj(),d,32);a.ue.a[1+c.a.length|0]=a.sd;a.sd.a[d.a.length]=a.af;break;case 7:c=b.Ye;d=b.qf;e=b.pf;var g=b.Z;a.af=32===g.a.length?g:Jj(Pj(),g,0,32);a.wg=4;a.Gl=32768-b.dg|0;g=b.ca+a.Gl|0;a.Yd=31&g;a.yi=g-a.Yd|0;a.Jf=new (md(md(md(md(jd)))).Ia)(32);a.Jf.a[0]=UJ(JJ(),UJ(JJ(),b.R,b.ug),b.vg);c.wa(0,a.Jf,1,c.a.length);a.ue=zj(Pj(),d,32);a.sd=zj(Pj(),e,32);a.Jf.a[1+c.a.length|0]=a.ue;a.ue.a[d.a.length]=
+a.sd;a.sd.a[e.a.length]=a.af;break;case 9:c=b.Xd;d=b.ge;e=b.fe;g=b.ee;var h=b.Z;a.af=32===h.a.length?h:Jj(Pj(),h,0,32);a.wg=5;a.Gl=1048576-b.Ze|0;h=b.ca+a.Gl|0;a.Yd=31&h;a.yi=h-a.Yd|0;a.Pg=new (md(md(md(md(md(jd))))).Ia)(32);a.Pg.a[0]=UJ(JJ(),UJ(JJ(),UJ(JJ(),b.R,b.rf),b.sf),b.tf);c.wa(0,a.Pg,1,c.a.length);a.Jf=zj(Pj(),d,32);a.ue=zj(Pj(),e,32);a.sd=zj(Pj(),g,32);a.Pg.a[1+c.a.length|0]=a.Jf;a.Jf.a[d.a.length]=a.ue;a.ue.a[e.a.length]=a.sd;a.sd.a[g.a.length]=a.af;break;case 11:c=b.rd;d=b.Nd;e=b.Md;g=
+b.Ld;h=b.Kd;var k=b.Z;a.af=32===k.a.length?k:Jj(Pj(),k,0,32);a.wg=6;a.Gl=33554432-b.Fe|0;k=b.ca+a.Gl|0;a.Yd=31&k;a.yi=k-a.Yd|0;a.Si=new (md(md(md(md(md(md(jd)))))).Ia)(32);a.Si.a[0]=UJ(JJ(),UJ(JJ(),UJ(JJ(),UJ(JJ(),b.R,b.Ge),b.He),b.Ie),b.Je);c.wa(0,a.Si,1,c.a.length);a.Pg=zj(Pj(),d,32);a.Jf=zj(Pj(),e,32);a.ue=zj(Pj(),g,32);a.sd=zj(Pj(),h,32);a.Si.a[1+c.a.length|0]=a.Pg;a.Pg.a[d.a.length]=a.Jf;a.Jf.a[e.a.length]=a.ue;a.ue.a[g.a.length]=a.sd;a.sd.a[h.a.length]=a.af;break;default:throw new w(c);}0===
+a.Yd&&0<a.yi&&(a.Yd=32,a.yi=-32+a.yi|0);return a}function PU(a,b){32===a.Yd&&E1(a);a.af.a[a.Yd]=b;a.Yd=1+a.Yd|0;return a}function OU(a,b){return b instanceof C1?0===a.Yd&&0===a.yi?F1(a,b):kfa(a,b):lR(a,b)}
+f.im=function(){var a=this.Yd+this.yi|0,b=a-this.Gl|0;if(0===b)return GK(),HJ();if(32>=a){if(32===b)return new IJ(this.af);var c=this.af;return new IJ(zj(Pj(),c,b))}if(1024>=a){var d=31&(-1+a|0),e=(-1+a|0)>>>5|0,g=this.sd,h=Jj(Pj(),g,1,e),k=this.sd.a[0],l=this.sd.a[e],m=1+d|0,n=l.a.length===m?l:zj(Pj(),l,m);return new KJ(k,32-this.Gl|0,h,n,b)}if(32768>=a){var r=31&(-1+a|0),v=31&((-1+a|0)>>>5|0),x=(-1+a|0)>>>10|0,A=this.ue,B=Jj(Pj(),A,1,x),C=this.ue.a[0],D=C.a.length,F=Jj(Pj(),C,1,D),I=this.ue.a[0].a[0],
+M=this.ue.a[x],N=zj(Pj(),M,v),P=this.ue.a[x].a[v],T=1+r|0,Y=P.a.length===T?P:zj(Pj(),P,T),Z=I.a.length;return new LJ(I,Z,F,Z+(F.a.length<<5)|0,B,N,Y,b)}if(1048576>=a){var S=31&(-1+a|0),ea=31&((-1+a|0)>>>5|0),ia=31&((-1+a|0)>>>10|0),X=(-1+a|0)>>>15|0,sa=this.Jf,Ja=Jj(Pj(),sa,1,X),Xa=this.Jf.a[0],Fa=Xa.a.length,za=Jj(Pj(),Xa,1,Fa),Qa=this.Jf.a[0].a[0],Ma=Qa.a.length,Ga=Jj(Pj(),Qa,1,Ma),ab=this.Jf.a[0].a[0].a[0],Hb=this.Jf.a[X],bc=zj(Pj(),Hb,ia),yb=this.Jf.a[X].a[ia],tb=zj(Pj(),yb,ea),eb=this.Jf.a[X].a[ia].a[ea],
+kb=1+S|0,Rb=eb.a.length===kb?eb:zj(Pj(),eb,kb),Gb=ab.a.length,vb=Gb+(Ga.a.length<<5)|0;return new MJ(ab,Gb,Ga,vb,za,vb+(za.a.length<<10)|0,Ja,bc,tb,Rb,b)}if(33554432>=a){var Tb=31&(-1+a|0),Nb=31&((-1+a|0)>>>5|0),ic=31&((-1+a|0)>>>10|0),Va=31&((-1+a|0)>>>15|0),cb=(-1+a|0)>>>20|0,zb=this.Pg,Ub=Jj(Pj(),zb,1,cb),jb=this.Pg.a[0],db=jb.a.length,ub=Jj(Pj(),jb,1,db),Aa=this.Pg.a[0].a[0],va=Aa.a.length,Ra=Jj(Pj(),Aa,1,va),rb=this.Pg.a[0].a[0].a[0],xb=rb.a.length,mc=Jj(Pj(),rb,1,xb),Ha=this.Pg.a[0].a[0].a[0].a[0],
+Ka=this.Pg.a[cb],Oa=zj(Pj(),Ka,Va),Na=this.Pg.a[cb].a[Va],Da=zj(Pj(),Na,ic),ta=this.Pg.a[cb].a[Va].a[ic],Ya=zj(Pj(),ta,Nb),dc=this.Pg.a[cb].a[Va].a[ic].a[Nb],ka=1+Tb|0,ya=dc.a.length===ka?dc:zj(Pj(),dc,ka),Sa=Ha.a.length,xc=Sa+(mc.a.length<<5)|0,Sb=xc+(Ra.a.length<<10)|0;return new NJ(Ha,Sa,mc,xc,Ra,Sb,ub,Sb+(ub.a.length<<15)|0,Ub,Oa,Da,Ya,ya,b)}var uc=31&(-1+a|0),Lb=31&((-1+a|0)>>>5|0),lc=31&((-1+a|0)>>>10|0),Xb=31&((-1+a|0)>>>15|0),ec=31&((-1+a|0)>>>20|0),Ab=(-1+a|0)>>>25|0,Ob=this.Si,fb=Jj(Pj(),
+Ob,1,Ab),Wa=this.Si.a[0],bb=Wa.a.length,Ia=Jj(Pj(),Wa,1,bb),Ua=this.Si.a[0].a[0],pc=Ua.a.length,sc=Jj(Pj(),Ua,1,pc),Ba=this.Si.a[0].a[0].a[0],ob=Ba.a.length,nc=Jj(Pj(),Ba,1,ob),Ib=this.Si.a[0].a[0].a[0].a[0],vc=Ib.a.length,Vb=Jj(Pj(),Ib,1,vc),fc=this.Si.a[0].a[0].a[0].a[0].a[0],Bc=this.Si.a[Ab],Pb=zj(Pj(),Bc,ec),Jb=this.Si.a[Ab].a[ec],gc=zj(Pj(),Jb,Xb),Cb=this.Si.a[Ab].a[ec].a[Xb],cc=zj(Pj(),Cb,lc),yc=this.Si.a[Ab].a[ec].a[Xb].a[lc],Mc=zj(Pj(),yc,Lb),qc=this.Si.a[Ab].a[ec].a[Xb].a[lc].a[Lb],oc=1+
+uc|0,Qc=qc.a.length===oc?qc:zj(Pj(),qc,oc),jc=fc.a.length,sb=jc+(Vb.a.length<<5)|0,Gc=sb+(nc.a.length<<10)|0,Wb=Gc+(sc.a.length<<15)|0;return new OJ(fc,jc,Vb,sb,nc,Gc,sc,Wb,Ia,Wb+(Ia.a.length<<20)|0,fb,Pb,gc,cc,Mc,Qc,b)};f.u=function(){return"VectorBuilder(len1\x3d"+this.Yd+", lenRest\x3d"+this.yi+", offset\x3d"+this.Gl+", depth\x3d"+this.wg+")"};f.Kb=function(){return this.im()};f.zc=function(a){return OU(this,a)};f.$=function(a){return PU(this,a)};
+f.$classData=q({X8:0},!1,"scala.collection.immutable.VectorBuilder",{X8:1,g:1,Po:1,xg:1,xf:1,wf:1});function G1(){}G1.prototype=new p;G1.prototype.constructor=G1;f=G1.prototype;f.Hh=function(a){return RF(a)};function RF(a){var b=a.Q();if(0<=b){var c=new zc(16<b?b:16);Fs(a)?a.Gc(c,0,2147483647):a.m().Gc(c,0,2147483647);return H1(new I1,c,b)}return Lv(kl(),a)}f.Eb=function(){return new DF};f.X=function(){return kl()};f.Ib=function(a){return RF(a)};
+f.$classData=q({d9:0},!1,"scala.collection.mutable.ArrayBuffer$",{d9:1,g:1,Qt:1,Nk:1,bg:1,l:1});var J1;function QF(){J1||(J1=new G1);return J1}function DF(){this.lk=null;PV(this,kl())}DF.prototype=new EZ;DF.prototype.constructor=DF;DF.prototype.he=function(a){K1(this.lk,a)};DF.prototype.$classData=q({e9:0},!1,"scala.collection.mutable.ArrayBuffer$$anon$1",{e9:1,tC:1,g:1,xg:1,xf:1,wf:1});function L1(){}L1.prototype=new p;L1.prototype.constructor=L1;f=L1.prototype;f.Hh=function(a){return M1(a)};
+function M1(a){var b=a.Q();if(0<=b){var c=N1(0,b);Fs(a)?a.Gc(c,0,2147483647):a.m().Gc(c,0,2147483647);return O1(new P1,c,0,b)}return vU(Q1(),a)}f.Eb=function(){return new R1};function N1(a,b){if(!(0<=b))throw Kj("requirement failed: Non-negative array size required");a=(-2147483648>>>Math.clz32(b)|0)<<1;if(!(0<=a))throw Kj("requirement failed: ArrayDeque too big - cannot allocate ArrayDeque of length "+b);return new zc(16<a?a:16)}f.X=function(){return Q1()};f.Ib=function(a){return M1(a)};
+f.$classData=q({h9:0},!1,"scala.collection.mutable.ArrayDeque$",{h9:1,g:1,Qt:1,Nk:1,bg:1,l:1});var S1;function T1(){S1||(S1=new L1);return S1}function R1(){this.lk=null;PV(this,Q1())}R1.prototype=new EZ;R1.prototype.constructor=R1;R1.prototype.he=function(a){var b=this.lk;a>((b.Ke-b.Zd|0)&(-1+b.ec.a.length|0))&&a>=b.ec.a.length&&U1(b,a)};R1.prototype.$classData=q({i9:0},!1,"scala.collection.mutable.ArrayDeque$$anon$1",{i9:1,tC:1,g:1,xg:1,xf:1,wf:1});function V1(){this.Bl=null;this.Bl=W1()}
+V1.prototype=new MY;V1.prototype.constructor=V1;V1.prototype.$classData=q({u9:0},!1,"scala.collection.mutable.Buffer$",{u9:1,FG:1,g:1,Nk:1,bg:1,l:1});var X1;function PE(){X1||(X1=new V1);return X1}function EV(a,b){this.lk=null;PV(this,CV(new DV,a,b))}EV.prototype=new EZ;EV.prototype.constructor=EV;EV.prototype.he=function(a){this.lk.he(a)};EV.prototype.$classData=q({L9:0},!1,"scala.collection.mutable.HashMap$$anon$6",{L9:1,tC:1,g:1,xg:1,xf:1,wf:1});
+function Y1(a,b){if(null===b)throw null;a.uw=b;a.hq=0;a.Lo=null;a.vw=b.eb.a.length}function Z1(){this.hq=0;this.Lo=null;this.vw=0;this.uw=null}Z1.prototype=new BY;Z1.prototype.constructor=Z1;function $1(){}$1.prototype=Z1.prototype;Z1.prototype.s=function(){if(null!==this.Lo)return!0;for(;this.hq<this.vw;){var a=this.uw.eb.a[this.hq];this.hq=1+this.hq|0;if(null!==a)return this.Lo=a,!0}return!1};Z1.prototype.t=function(){if(this.s()){var a=this.lB(this.Lo);this.Lo=this.Lo.$d;return a}return Rq().Pa.t()};
+function LV(a,b){this.lk=null;PV(this,JV(new KV,a,b))}LV.prototype=new EZ;LV.prototype.constructor=LV;LV.prototype.he=function(a){this.lk.he(a)};LV.prototype.$classData=q({S9:0},!1,"scala.collection.mutable.HashSet$$anon$4",{S9:1,tC:1,g:1,xg:1,xf:1,wf:1});function a2(a,b){if(null===b)throw null;a.uC=b;a.iu=0;a.Ur=null;a.vC=b.zg.a.length}function b2(){this.iu=0;this.Ur=null;this.vC=0;this.uC=null}b2.prototype=new BY;b2.prototype.constructor=b2;function c2(){}c2.prototype=b2.prototype;
+b2.prototype.s=function(){if(null!==this.Ur)return!0;for(;this.iu<this.vC;){var a=this.uC.zg.a[this.iu];this.iu=1+this.iu|0;if(null!==a)return this.Ur=a,!0}return!1};b2.prototype.t=function(){if(this.s()){var a=this.DJ(this.Ur);this.Ur=this.Ur.yg;return a}return Rq().Pa.t()};function d2(){this.wC=null}d2.prototype=new p;d2.prototype.constructor=d2;function e2(){}e2.prototype=d2.prototype;d2.prototype.he=function(){};d2.prototype.zc=function(a){return lR(this,a)};d2.prototype.Kb=function(){return this.wC};
+function f2(){this.Bl=null;this.Bl=QF()}f2.prototype=new MY;f2.prototype.constructor=f2;f2.prototype.$classData=q({X9:0},!1,"scala.collection.mutable.IndexedSeq$",{X9:1,FG:1,g:1,Nk:1,bg:1,l:1});var g2;function WC(a){this.xC=a.Gn}WC.prototype=new BY;WC.prototype.constructor=WC;WC.prototype.s=function(){return null!==this.xC};WC.prototype.gm=function(){if(this.s()){var a=G(new H,this.xC.ju,this.xC.Fn);this.xC=this.xC.zm;return a}return Rq().Pa.t()};WC.prototype.t=function(){return this.gm()};
+WC.prototype.$classData=q({b$:0},!1,"scala.collection.mutable.LinkedHashMap$$anon$2",{b$:1,Sa:1,g:1,Ka:1,M:1,N:1});function h2(a){this.jH=a.Gn}h2.prototype=new BY;h2.prototype.constructor=h2;h2.prototype.s=function(){return null!==this.jH};h2.prototype.t=function(){if(this.s()){var a=this.jH.ju;this.jH=this.jH.zm;return a}return Rq().Pa.t()};h2.prototype.$classData=q({c$:0},!1,"scala.collection.mutable.LinkedHashMap$$anon$3",{c$:1,Sa:1,g:1,Ka:1,M:1,N:1});function i2(a){this.kH=a.Gn}i2.prototype=new BY;
+i2.prototype.constructor=i2;i2.prototype.s=function(){return null!==this.kH};i2.prototype.t=function(){if(this.s()){var a=this.kH.Fn;this.kH=this.kH.zm;return a}return Rq().Pa.t()};i2.prototype.$classData=q({d$:0},!1,"scala.collection.mutable.LinkedHashMap$$anon$4",{d$:1,Sa:1,g:1,Ka:1,M:1,N:1});function qA(a){this.lH=a.ku}qA.prototype=new BY;qA.prototype.constructor=qA;qA.prototype.s=function(){return null!==this.lH};qA.prototype.t=function(){if(this.s()){var a=this.lH.zw;this.lH=this.lH.Mo;return a}return Rq().Pa.t()};
+qA.prototype.$classData=q({j$:0},!1,"scala.collection.mutable.LinkedHashSet$$anon$2",{j$:1,Sa:1,g:1,Ka:1,M:1,N:1});function j2(){}j2.prototype=new p;j2.prototype.constructor=j2;f=j2.prototype;f.Hh=function(a){return ep(new fp,a)};f.Eb=function(){return PV(new QV,new fp)};f.X=function(){return new fp};f.Ib=function(a){return ep(new fp,a)};f.$classData=q({m$:0},!1,"scala.collection.mutable.ListBuffer$",{m$:1,g:1,Qt:1,Nk:1,bg:1,l:1});var k2;function l2(){k2||(k2=new j2);return k2}
+function m2(a,b){this.gT=0;this.hT=a;this.q$=b;this.gT=Es(b)|0}m2.prototype=new BY;m2.prototype.constructor=m2;m2.prototype.s=function(){mK();var a=this.gT,b=Es(this.q$)|0;jK(a,b);return this.hT.s()};m2.prototype.t=function(){return this.hT.t()};m2.prototype.$classData=q({p$:0},!1,"scala.collection.mutable.MutationTracker$CheckedIterator",{p$:1,Sa:1,g:1,Ka:1,M:1,N:1});function n2(){}n2.prototype=new p;n2.prototype.constructor=n2;f=n2.prototype;f.Hh=function(a){return vU(new tU(16),a)};
+f.Eb=function(){return PV(new QV,new tU(16))};f.X=function(){return new tU(16)};f.Ib=function(a){return vU(new tU(16),a)};f.$classData=q({s$:0},!1,"scala.collection.mutable.Queue$",{s$:1,g:1,Qt:1,Nk:1,bg:1,l:1});var o2;function p2(){o2||(o2=new n2);return o2}function q2(a){!a.fz.b()&&null!==a.iq&&0<=a.DC.Da(a.iq.Oo,a.fz.o())&&(a.iq=null)}
+function r2(a,b,c,d,e){a.fz=d;a.DC=e;if(R()===c)xK(),e=b.zi,e=null===e?null:uK(e);else{if(!(c instanceof L))throw new w(c);c=c.k;xK();d=b.zi;if(null===d)e=null;else{b=null;for(var g=1;null!==d&&0!==g;)b=d,g=e.Da(c,d.Oo),d=0>g?d.Vc:d.Bc;e=0>=g?b:vK(0,b)}}a.iq=e;q2(a)}function s2(){this.iq=this.DC=this.fz=null}s2.prototype=new BY;s2.prototype.constructor=s2;function t2(){}t2.prototype=s2.prototype;s2.prototype.s=function(){return null!==this.iq};
+s2.prototype.t=function(){var a=this.iq;if(null===a)throw AH("next on empty iterator");this.iq=vK(xK(),a);q2(this);return this.zK(a)};function u2(){}u2.prototype=new p;u2.prototype.constructor=u2;f=u2.prototype;f.Hh=function(a){return vU(new IX(16),a)};f.Eb=function(){return PV(new QV,new IX(16))};f.X=function(){return new IX(16)};f.Ib=function(a){return vU(new IX(16),a)};f.$classData=q({H$:0},!1,"scala.collection.mutable.Stack$",{H$:1,g:1,Qt:1,Nk:1,bg:1,l:1});var v2;
+function w2(){v2||(v2=new u2);return v2}function x2(a,b,c){return 0===a.Da(b,c)}function y2(a,b,c){return a.Yj(b,c)?b:c}function z2(a,b,c){return a.uj(b,c)?b:c}function A2(a,b){return b instanceof B2?(b=b.sn,null!==b&&b.i(a)):!1}var nfa=function mfa(a,b){return $f(b)?"Array["+mfa(a,bg(b))+"]":b.qi.name};class fX extends Iq{constructor(a){super();Hq(this,a,void 0)}Cj(){}}fX.prototype.$classData=q({baa:0},!1,"scala.runtime.NonLocalReturnControl$mcV$sp",{baa:1,lT:1,s4:1,pc:1,g:1,l:1});
+function iD(a){this.nT=0;this.jaa=a;this.oH=0;this.nT=a.G()}iD.prototype=new BY;iD.prototype.constructor=iD;iD.prototype.s=function(){return this.oH<this.nT};iD.prototype.t=function(){var a=this.jaa.I(this.oH);this.oH=1+this.oH|0;return a};iD.prototype.$classData=q({iaa:0},!1,"scala.runtime.ScalaRunTime$$anon$1",{iaa:1,Sa:1,g:1,Ka:1,M:1,N:1});function C2(){}C2.prototype=new p;C2.prototype.constructor=C2;f=C2.prototype;f.Hh=function(a){return D2(a)};f.Eb=function(){return E2()};
+function D2(a){var b=E2();return lR(b,a).Kb()}f.Ib=function(a){return D2(a)};f.X=function(){return E2()};f.$classData=q({N$:0},!1,"scala.scalajs.js.WrappedArray$",{N$:1,g:1,Qt:1,Nk:1,bg:1,l:1});var F2;function W1(){F2||(F2=new C2);return F2}function G2(){}G2.prototype=new p;G2.prototype.constructor=G2;f=G2.prototype;f.Hh=function(a){return H2(this,a)};function H2(a,b){return a.Eb().zc(b).Kb()}f.Eb=function(){return new dU(Md(new Nd,[]),new y(a=>J(new K,a.Xr)))};f.Ib=function(a){return H2(this,a)};
+f.X=function(){var a=new K;J(a,[]);return a};f.$classData=q({W$:0},!1,"scala.scalajs.runtime.WrappedVarArgs$",{W$:1,g:1,Qt:1,Nk:1,bg:1,l:1});var I2;function J2(){I2||(I2=new G2);return I2}function fe(a){this.aa=a}fe.prototype=new PZ;fe.prototype.constructor=fe;f=fe.prototype;f.TJ=function(){return!0};f.tv=function(){return!1};f.H=function(){return"Left"};f.G=function(){return 1};f.I=function(a){return 0===a?this.aa:$K(W(),a)};f.D=function(a){return a instanceof fe};f.B=function(){return AL(this)};
+f.u=function(){return VK(this)};f.i=function(a){return this===a?!0:a instanceof fe?ml(nl(),this.aa,a.aa):!1};f.$classData=q({n4:0},!1,"scala.util.Left",{n4:1,l4:1,g:1,E:1,v:1,l:1});function Ud(a){this.fa=a}Ud.prototype=new PZ;Ud.prototype.constructor=Ud;f=Ud.prototype;f.TJ=function(){return!1};f.tv=function(){return!0};f.H=function(){return"Right"};f.G=function(){return 1};f.I=function(a){return 0===a?this.fa:$K(W(),a)};f.D=function(a){return a instanceof Ud};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){return this===a?!0:a instanceof Ud?ml(nl(),this.fa,a.fa):!1};var K2=q({p4:0},!1,"scala.util.Right",{p4:1,l4:1,g:1,E:1,v:1,l:1});Ud.prototype.$classData=K2;function Ne(a){this.Zl=a}Ne.prototype=new QL;Ne.prototype.constructor=Ne;f=Ne.prototype;f.H=function(){return"Line"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Zl:$K(W(),a)};f.D=function(a){return a instanceof Ne};f.B=function(){var a=lb("Line");a=W().C(-889275714,a);var b=this.Zl;a=W().C(a,b);return W().Ma(a,1)};
+f.u=function(){return VK(this)};f.i=function(a){return this===a?!0:a instanceof Ne?this.Zl===a.Zl:!1};f.$classData=q({y0:0},!1,"sourcecode.Line",{y0:1,A0:1,g:1,E:1,v:1,l:1});function Oe(a){this.fn=a}Oe.prototype=new QL;Oe.prototype.constructor=Oe;f=Oe.prototype;f.H=function(){return"Name"};f.G=function(){return 1};f.I=function(a){return 0===a?this.fn:$K(W(),a)};f.D=function(a){return a instanceof Oe};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){return this===a?!0:a instanceof Oe?this.fn===a.fn:!1};f.$classData=q({z0:0},!1,"sourcecode.Name",{z0:1,A0:1,g:1,E:1,v:1,l:1});function P0(){var a=new dI;yF(a,null,null,!0);return a}class dI extends bL{}dI.prototype.$classData=q({P0:0},!1,"java.lang.ArrayIndexOutOfBoundsException",{P0:1,eK:1,Te:1,qd:1,pc:1,g:1,l:1});function mb(a){return ig(mg(),a)}
+var iaa=q({X0:0},!1,"java.lang.Double",{X0:1,ur:1,g:1,l:1,nf:1,Et:1,UF:1},a=>"number"===typeof a),haa=q({Z0:0},!1,"java.lang.Float",{Z0:1,ur:1,g:1,l:1,nf:1,Et:1,UF:1},a=>ja(a)),gaa=q({b1:0},!1,"java.lang.Integer",{b1:1,ur:1,g:1,l:1,nf:1,Et:1,UF:1},a=>ha(a)),kaa=q({g1:0},!1,"java.lang.Long",{g1:1,ur:1,g:1,l:1,nf:1,Et:1,UF:1},a=>a instanceof ma);class ZL extends SZ{constructor(a){super();yF(this,a,null,!0)}}
+ZL.prototype.$classData=q({p1:0},!1,"java.lang.NumberFormatException",{p1:1,ak:1,Te:1,qd:1,pc:1,g:1,l:1});function gk(a,b){return a.codePointAt(b)|0}function lb(a){for(var b=0,c=1,d=-1+a.length|0;0<=d;)b=b+Math.imul(a.charCodeAt(d),c)|0,c=Math.imul(31,c),d=-1+d|0;return b}function pa(a,b){for(var c=a.length,d=b.length,e=c<d?c:d,g=0;g!==e;){var h=g;h=a.charCodeAt(g)-b.charCodeAt(h)|0;if(0!==h)return h;g=1+g|0}return c-d|0}
+function L2(a,b,c,d){if(b>a.length||0>b||0>b)throw a=new tH,yF(a,"Index out of Bound",null,!0),a;d=d-0|0;for(var e=0;e<b;)c.a[e+d|0]=a.charCodeAt(e),e=1+e|0}function vH(a,b){b=TL(Pr(),b);return a.indexOf(b)|0}
+function je(a,b,c){b=Dk(b);a=new cq(b,a);a.VQ=0;a.Av=a.UQ;a.YF=0;a.Bv=null;a.qy=0;b=new jW;for(b.ly=LQ(new Sq);LN(a);){var d=a,e=b,g=c,h=d.Av,k=d.qy,l=MN(d);kW(e,h.substring(k,l));h=g.length;for(k=0;k<h;)switch(l=g.charCodeAt(k),l){case 36:for(l=k=1+k|0;;){if(k<h){var m=g.charCodeAt(k);m=48<=m&&57>=m}else m=!1;if(m)k=1+k|0;else break}UH();l=g.substring(l,k);m=TH(0,l,10);l=d;var n=KN(l);l=l.lK;if(0>m||m>l.O2)throw aL(new bL,""+m);l=n[l.P2[m]|0];l=void 0!==l?l:null;null!==l&&kW(e,l);break;case 92:k=
+1+k|0;k<h&&lW(e,g.charCodeAt(k));k=1+k|0;break;default:lW(e,l),k=1+k|0}d.qy=NN(d)}kW(b,a.Av.substring(a.qy));a.qy=a.Av.length;return b.u()}
+function M2(a,b){b=Dk(b);if(""===a)b=new (md(fa).Ia)([""]);else{var c=new cq(b,a);b=[];for(var d=0;2147483646>(b.length|0)&&LN(c);){if(0!==NN(c)){var e=MN(c);b.push(a.substring(d,e))}d=NN(c)}b.push(a.substring(d));for(c=b.length|0;;)if(0!==c?(a=b[-1+c|0],a=null!==a&&La(a,"")):a=!1,a)c=-1+c|0;else break;a=new (md(fa).Ia)(c);for(d=0;d<c;)e=d,a.a[e]=b[e],d=1+d|0;b=a}return b}function or(a){for(var b=a.length,c=new Ic(b),d=0;d<b;)c.a[d]=a.charCodeAt(d),d=1+d|0;return c}
+var fa=q({D0:0},!1,"java.lang.String",{D0:1,g:1,l:1,nf:1,ZJ:1,Et:1,UF:1},a=>"string"===typeof a);class tH extends bL{}tH.prototype.$classData=q({x1:0},!1,"java.lang.StringIndexOutOfBoundsException",{x1:1,eK:1,Te:1,qd:1,pc:1,g:1,l:1});class DM extends TZ{constructor(){super();yF(this,null,null,!0)}}DM.prototype.$classData=q({S1:0},!1,"java.util.FormatterClosedException",{S1:1,CQ:1,Te:1,qd:1,pc:1,g:1,l:1});function a_(a){this.VF=null;if(null===a)throw null;this.VF=a}a_.prototype=new XZ;
+a_.prototype.constructor=a_;a_.prototype.vv=function(){return new GN(this.VF)};a_.prototype.ka=function(){return this.VF.yv};a_.prototype.L=function(a){if(ck(a)){var b=this.VF,c=a.so();if(null===c)var d=0;else d=ib(c),d^=d>>>16|0;b=ZZ(b,c,d,d&(-1+b.wl.a.length|0));if(null!==b)return b=b.xv,a=a.to(),null===b?null===a:La(b,a)}return!1};a_.prototype.$classData=q({V1:0},!1,"java.util.HashMap$EntrySet",{V1:1,F1:1,D1:1,g:1,OQ:1,d1:1,v2:1});function c_(a){this.yB=null;if(null===a)throw null;this.yB=a}
+c_.prototype=new XZ;c_.prototype.constructor=c_;c_.prototype.vv=function(){return new FN(this)};c_.prototype.ka=function(){return this.yB.zv.yv};c_.prototype.L=function(a){if(ck(a)){var b=a.so();if(this.yB.EF(b))return b=this.yB.LF(b),Object.is(b,a.to())}return!1};c_.prototype.$classData=q({Z1:0},!1,"java.util.IdentityHashMap$EntrySet",{Z1:1,F1:1,D1:1,g:1,OQ:1,d1:1,v2:1});class N2 extends SZ{}
+class ek extends SZ{constructor(a,b,c){super();this.L2=a;this.N2=b;this.M2=c;yF(this,null,null,!0)}qj(){var a=this.M2,b=this.N2,c=this.L2+(0>a?"":" near index "+a)+"\n"+b;if(0<=a&&null!==b&&a<b.length){if(0>a)throw UL();a=" ".repeat(a);c=c+"\n"+a+"^"}return c}}ek.prototype.$classData=q({K2:0},!1,"java.util.regex.PatternSyntaxException",{K2:1,ak:1,Te:1,qd:1,pc:1,g:1,l:1});function cs(a,b,c){this.Cc=a;this.td=b;this.Mf=c}cs.prototype=new Wz;cs.prototype.constructor=cs;f=cs.prototype;f.H=function(){return"BRACKETS"};
+f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Cc;case 1:return this.td;default:return $K(W(),a)}};f.D=function(a){return a instanceof cs};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof cs&&this.Cc===a.Cc){var b=this.td;a=a.td;return null===b?null===a:b.i(a)}return!1};f.$classData=q({UT:0},!1,"mlscript.BRACKETS",{UT:1,yk:1,g:1,Wm:1,E:1,v:1,l:1});function O2(){}O2.prototype=new Wz;
+O2.prototype.constructor=O2;f=O2.prototype;f.H=function(){return"COMMA"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof O2};f.B=function(){return 64305845};f.u=function(){return"COMMA"};f.$classData=q({kU:0},!1,"mlscript.COMMA$",{kU:1,yk:1,g:1,Wm:1,E:1,v:1,l:1});var P2;function Xr(){P2||(P2=new O2);return P2}function gs(a){this.PC=a}gs.prototype=new Wz;gs.prototype.constructor=gs;f=gs.prototype;f.H=function(){return"COMMENT"};f.G=function(){return 1};
+f.I=function(a){return 0===a?this.PC:$K(W(),a)};f.D=function(a){return a instanceof gs};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){return this===a?!0:a instanceof gs?this.PC===a.PC:!1};f.$classData=q({lU:0},!1,"mlscript.COMMENT",{lU:1,yk:1,g:1,Wm:1,E:1,v:1,l:1});function Q2(){}Q2.prototype=new Wz;Q2.prototype.constructor=Q2;f=Q2.prototype;f.H=function(){return"ERROR"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};
+f.D=function(a){return a instanceof Q2};f.B=function(){return 66247144};f.u=function(){return"ERROR"};f.$classData=q({MU:0},!1,"mlscript.ERROR$",{MU:1,yk:1,g:1,Wm:1,E:1,v:1,l:1});var R2;function ts(){R2||(R2=new Q2);return R2}function Sn(a,b){this.UM=null;this.WM=this.XM=0;this.YM=this.VM=null;this.ms=0;this.Yf=a;this.Rg=b;Nq(this)}Sn.prototype=new p;Sn.prototype.constructor=Sn;f=Sn.prototype;f.Vj=function(){var a=this.Yf.ha(),b=this.Rg,c=O().c;return dl(new z(b,c),a)};
+f.jn=function(){0===(1&this.ms)<<24>>24&&0===(1&this.ms)<<24>>24&&(this.UM=zq(this),this.ms=(1|this.ms)<<24>>24);return this.UM};f.rn=function(){return this.XM};f.fm=function(a){this.XM=a};f.qn=function(){return this.WM};f.em=function(a){this.WM=a};f.pn=function(){return this.VM};f.on=function(a){this.VM=a};f.A=function(){0===(2&this.ms)<<24>>24&&0===(2&this.ms)<<24>>24&&(this.YM=Dq(this),this.ms=(2|this.ms)<<24>>24);return this.YM};f.H=function(){return"Field"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.Yf;case 1:return this.Rg;default:return $K(W(),a)}};f.D=function(a){return a instanceof Sn};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Sn){var b=this.Yf,c=a.Yf;if(null===b?null===c:b.i(c))return b=this.Rg,a=a.Rg,null===b?null===a:b.i(a)}return!1};f.$classData=q({RU:0},!1,"mlscript.Field",{RU:1,g:1,yaa:1,Ta:1,E:1,v:1,l:1});
+function sm(a,b){this.dN=null;this.fN=this.gN=0;this.hN=this.eN=null;this.os=0;this.yb=a;this.ya=b;Nq(this)}sm.prototype=new p;sm.prototype.constructor=sm;f=sm.prototype;f.Vj=function(){var a=this.ya,b=O().c;return new z(a,b)};f.jn=function(){0===(1&this.os)<<24>>24&&0===(1&this.os)<<24>>24&&(this.dN=zq(this),this.os=(1|this.os)<<24>>24);return this.dN};f.rn=function(){return this.gN};f.fm=function(a){this.gN=a};f.qn=function(){return this.fN};f.em=function(a){this.fN=a};f.pn=function(){return this.eN};
+f.on=function(a){this.eN=a};f.A=function(){0===(2&this.os)<<24>>24&&0===(2&this.os)<<24>>24&&(this.hN=Dq(this),this.os=(2|this.os)<<24>>24);return this.hN};f.H=function(){return"Fld"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.yb;case 1:return this.ya;default:return $K(W(),a)}};f.D=function(a){return a instanceof sm};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof sm){var b=this.yb,c=a.yb;if(null===b?null===c:b.i(c))return b=this.ya,a=a.ya,null===b?null===a:b.i(a)}return!1};f.$classData=q({SU:0},!1,"mlscript.Fld",{SU:1,g:1,Aaa:1,Ta:1,E:1,v:1,l:1});function St(a,b,c){this.ZM=null;this.aN=this.bN=0;this.cN=this.$M=null;this.ns=0;this.je=a;this.ch=b;this.Bh=c;Nq(this)}St.prototype=new p;St.prototype.constructor=St;f=St.prototype;f.Vj=function(){return O().c};
+f.u=function(){if(null===this)throw new w(this);var a=(this.je?"m":"")+(this.ch?"s":"")+(this.Bh?"g":"");return""===a?"_":a};f.jn=function(){0===(1&this.ns)<<24>>24&&0===(1&this.ns)<<24>>24&&(this.ZM=zq(this),this.ns=(1|this.ns)<<24>>24);return this.ZM};f.rn=function(){return this.bN};f.fm=function(a){this.bN=a};f.qn=function(){return this.aN};f.em=function(a){this.aN=a};f.pn=function(){return this.$M};f.on=function(a){this.$M=a};
+f.A=function(){0===(2&this.ns)<<24>>24&&0===(2&this.ns)<<24>>24&&(this.cN=Dq(this),this.ns=(2|this.ns)<<24>>24);return this.cN};f.H=function(){return"FldFlags"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.je;case 1:return this.ch;case 2:return this.Bh;default:return $K(W(),a)}};f.D=function(a){return a instanceof St};
+f.B=function(){var a=lb("FldFlags");a=W().C(-889275714,a);var b=this.je?1231:1237;a=W().C(a,b);b=this.ch?1231:1237;a=W().C(a,b);b=this.Bh?1231:1237;a=W().C(a,b);return W().Ma(a,3)};f.i=function(a){return this===a?!0:a instanceof St?this.je===a.je&&this.ch===a.ch&&this.Bh===a.Bh:!1};f.$classData=q({TU:0},!1,"mlscript.FldFlags",{TU:1,g:1,zaa:1,Ta:1,E:1,v:1,l:1});function bs(a,b){this.ae=a;this.ke=b}bs.prototype=new Wz;bs.prototype.constructor=bs;f=bs.prototype;f.H=function(){return"IDENT"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.ae;case 1:return this.ke;default:return $K(W(),a)}};f.D=function(a){return a instanceof bs};f.B=function(){var a=lb("IDENT");a=W().C(-889275714,a);var b=this.ae;b=My(W(),b);a=W().C(a,b);b=this.ke?1231:1237;a=W().C(a,b);return W().Ma(a,2)};f.u=function(){return VK(this)};f.i=function(a){return this===a?!0:a instanceof bs?this.ke===a.ke&&this.ae===a.ae:!1};f.$classData=q({XU:0},!1,"mlscript.IDENT",{XU:1,yk:1,g:1,Wm:1,E:1,v:1,l:1});
+function Wo(a){this.bD=a}Wo.prototype=new fO;Wo.prototype.constructor=Wo;f=Wo.prototype;f.sh=function(){return 22};f.xa=function(){Qp();var a=this.bD;if(a===u())var b=u();else{b=a.e();var c=b=new z(Up(b,Vp().Az),u());for(a=a.f();a!==u();){var d=a.e();d=new z(Up(d,Vp().Az),u());c=c.p=d;a=a.f()}}return Uz(b)};f.H=function(){return"JSArray"};f.G=function(){return 1};f.I=function(a){return 0===a?this.bD:$K(W(),a)};f.D=function(a){return a instanceof Wo};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Wo){var b=this.bD;a=a.bD;return null===b?null===a:b.i(a)}return!1};f.$classData=q({jV:0},!1,"mlscript.JSArray",{jV:1,Vi:1,Xc:1,g:1,E:1,v:1,l:1});function Hl(a){this.aD=a}Hl.prototype=new oO;Hl.prototype.constructor=Hl;f=Hl.prototype;f.xa=function(){Qp();var a=this.aD;if(a===u())var b=u();else{b=a.e();var c=b=new z(b.xa(),u());for(a=a.f();a!==u();){var d=a.e();d=new z(d.xa(),u());c=c.p=d;a=a.f()}}return Uz(b)};f.H=function(){return"JSArrayPattern"};
+f.G=function(){return 1};f.I=function(a){return 0===a?this.aD:$K(W(),a)};f.D=function(a){return a instanceof Hl};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Hl){var b=this.aD;a=a.aD;return null===b?null===a:b.i(a)}return!1};f.$classData=q({kV:0},!1,"mlscript.JSArrayPattern",{kV:1,BH:1,Xc:1,g:1,E:1,v:1,l:1});function oo(a,b){this.wz=a;this.cD=b}oo.prototype=new fO;oo.prototype.constructor=oo;f=oo.prototype;f.sh=function(){return 2};
+f.xa=function(){var a=Rp(Pp(Hf(this.wz).De(Qp().ye,new fn((g,h)=>{var k=G(new H,g,h);g=k.y;h=k.w;if(null!==h)return k=h.h(),h=h.Sc(),Rp(Rp(g,k instanceof El?Sp(Qp(),"_"+h):k.xa()),Pe(new E(h),-1+this.wz.K()|0)?Qp().ye:Sp(Qp(),", "));throw new w(k);})),!0),Qp().SN),b=!1,c=null,d=this.cD;a:{if(d instanceof fe){b=!0;c=d;var e=c.aa;if(e instanceof vo){b=Pp(e.xa(),!0);break a}}if(b)b=Up(c.aa,2);else if(d instanceof Ud){d=d.fa;Qp();if(d===u())b=u();else for(b=d.e(),c=b=new z(b.xa(),u()),d=d.f();d!==u();)e=
+d.e(),e=new z(e.xa(),u()),c=c.p=e,d=d.f();b=Oz(Sz(b))}else throw new w(d);}return Rp(a,b)};f.H=function(){return"JSArrowFn"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.wz;case 1:return this.cD;default:return $K(W(),a)}};f.D=function(a){return a instanceof oo};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof oo){var b=this.wz,c=a.wz;if(null===b?null===c:b.i(c))return b=this.cD,a=a.cD,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({lV:0},!1,"mlscript.JSArrowFn",{lV:1,Vi:1,Xc:1,g:1,E:1,v:1,l:1});function Lo(a,b){this.dD=a;this.eD=b}Lo.prototype=new fO;Lo.prototype.constructor=Lo;f=Lo.prototype;f.sh=function(){return 3};f.xa=function(){return Rp(Rp(Up(this.dD,3),Sp(Qp()," \x3d ")),Up(this.eD,3))};f.H=function(){return"JSAssignExpr"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.dD;case 1:return this.eD;default:return $K(W(),a)}};f.D=function(a){return a instanceof Lo};f.B=function(){return AL(this)};
+f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Lo){var b=this.dD,c=a.dD;if(null===b?null===c:b.i(c))return b=this.eD,a=a.eD,null===b?null===a:b.i(a)}return!1};f.$classData=q({mV:0},!1,"mlscript.JSAssignExpr",{mV:1,Vi:1,Xc:1,g:1,E:1,v:1,l:1});function gn(a,b,c){this.Rw=a;this.hD=b;this.iD=c}gn.prototype=new fO;gn.prototype.constructor=gn;f=gn.prototype;
+f.sh=function(){var a=bO(Lm()).U(this.Rw);if(a instanceof L)return a.k|0;if(R()===a)throw vS(new wS,"Unknown binary operator: "+this.Rw);throw new w(a);};f.xa=function(){return Rp(Rp(Up(this.hD,this.sh()),Sp(Qp()," "+this.Rw+" ")),Up(this.iD,this.sh()))};f.H=function(){return"JSBinary"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.Rw;case 1:return this.hD;case 2:return this.iD;default:return $K(W(),a)}};f.D=function(a){return a instanceof gn};f.B=function(){return AL(this)};
+f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof gn&&this.Rw===a.Rw){var b=this.hD,c=a.hD;if(null===b?null===c:b.i(c))return b=this.iD,a=a.iD,null===b?null===a:b.i(a)}return!1};f.$classData=q({zV:0},!1,"mlscript.JSBinary",{zV:1,Vi:1,Xc:1,g:1,E:1,v:1,l:1});q({CV:0},!1,"mlscript.JSClassDecl",{CV:1,el:1,Xc:1,g:1,E:1,v:1,l:1});function Mo(a){this.lD=a}Mo.prototype=new fO;Mo.prototype.constructor=Mo;f=Mo.prototype;f.sh=function(){return 22};f.xa=function(){return this.lD.xa()};
+f.H=function(){return"JSClassExpr"};f.G=function(){return 1};f.I=function(a){return 0===a?this.lD:$K(W(),a)};f.D=function(a){return a instanceof Mo};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Mo){var b=this.lD;a=a.lD;return null===b?null===a:b.i(a)}return!1};f.$classData=q({DV:0},!1,"mlscript.JSClassExpr",{DV:1,Vi:1,Xc:1,g:1,E:1,v:1,l:1});
+function xp(a,b,c,d,e,g,h,k,l,m,n,r,v,x){this.Ds=a;this.Au=b;this.Sw=c;this.Xw=d;this.Tw=e;this.Zw=g;this.sq=h;this.zz=k;this.Ww=l;this.Uw=m;this.Vw=n;this.yz=r;this.xz=v;this.Yw=x;$U(dV(),b)}xp.prototype=new qO;xp.prototype.constructor=xp;f=xp.prototype;
+f.xa=function(){var a=new fp,b=this.sq.m();b=new Ao(b);var c=this.zz;b=Qu(b,c instanceof L?"..."+c.k:"",new fn((k,l)=>""===l?""+k.h():k.h()+", "+l));for(c=this.yz;!c.b();){var d="  #"+c.e()+";";wp(a,d);c=c.f()}for(c=hl(this.Xw);!c.b();)d="  #"+c.e()+";",wp(a,d),c=c.f();for(c=hl(this.Sw);!c.b();){var e=c.e();if(null!==e)d=e.Rc(),e=e.j(),this.Xw.L(e)||wp(a,"  #"+e+";"),wp(a,"  get "+e+"() { return this.#"+e+"; }"),d&&wp(a,"  set "+e+"($value) { return this.#"+e+" \x3d $value; }");else throw new w(e);
+c=c.f()}wp(a,"  constructor("+b+") {");if(!this.Tw.b()){b=this.Zw.m();b=new Ao(b);for(c="";b.s();)d=c,c=b.gm(),c=Pe(new E(c.Sc()),-1+this.Zw.K()|0)?""+d+c.h().xa():""+d+c.h().xa()+", ";wp(a,"    super("+c+");")}for(b=this.Uw;!b.b();)c="    "+b.e()+".implement(this);",wp(a,c),b=b.f();if(!this.xz){b=this.Au.K();if(!Pe(new E(b),this.sq.K()))throw new Yj("assertion failed: fields and ctorParams have different size in class "+this.Ds+".");b=this.Au;c=new Wq(b,b,this.sq);b=c.ck.m();for(c=c.dk.m();b.s()&&
+c.s();)d=b.t(),e=c.t(),wp(a,"    this.#"+d+" \x3d "+e+";")}for(b=this.Vw;!b.b();){c=Kz(Kz(b.e().xa())).$f;c=ze(c,"","\n","");var g=M2(c,"\n");c=(k=>l=>wp(k,l))(a);d=g.a.length;e=0;if(null!==g)for(;e<d;)c(g.a[e]),e=1+e|0;else if(g instanceof Xc)for(;e<d;)c(g.a[e]),e=1+e|0;else if(g instanceof ed)for(;e<d;)c(g.a[e]),e=1+e|0;else if(g instanceof Zc)for(;e<d;){var h=g.a[e];c(new ma(h.W,h.Y));e=1+e|0}else if(g instanceof $c)for(;e<d;)c(g.a[e]),e=1+e|0;else if(g instanceof Ic)for(;e<d;)c(hc(g.a[e])),e=
+1+e|0;else if(g instanceof Pc)for(;e<d;)c(g.a[e]),e=1+e|0;else if(g instanceof Sc)for(;e<d;)c(g.a[e]),e=1+e|0;else if(g instanceof Ec)for(;e<d;)c(g.a[e]),e=1+e|0;else throw new w(g);b=b.f()}wp(a,"  }");a=Rz(Qp(),a.ha());b=this.Ww;for(c=Qp().ye;!b.b();)d=b.e(),c=Iz(c,Kz(d.xa())),b=b.f();b=c;c=this.Yw;for(d=Qp().ye;!c.b();)e=c.e(),d=Iz(Iz(d,Sp(Qp(),"static")),Kz(e.xa())),c=c.f();c=d;d=Sp(Qp(),"}");e=this.Tw;if(e instanceof L)return e=e.k,Iz(Iz(Iz(Iz(Rp(Rp(Sp(Qp(),"class "+this.Ds+" extends "),e.xa()),
+Sp(Qp()," {")),a),b),c),d);if(R()===e){if(this.Au.b()&&this.Ww.b()&&this.Uw.b()&&this.Sw.b()&&this.Vw.b()&&this.Yw.b())return Sp(Qp(),"class "+this.Ds+" {}");Qp();e="class "+this.Ds+" {";g=O().c;return Iz(Iz(Iz(Iz(Rz(0,new z(e,g)),a),b),c),d)}throw new w(e);};f.H=function(){return"JSClassNewDecl"};f.G=function(){return 14};
+f.I=function(a){switch(a){case 0:return this.Ds;case 1:return this.Au;case 2:return this.Sw;case 3:return this.Xw;case 4:return this.Tw;case 5:return this.Zw;case 6:return this.sq;case 7:return this.zz;case 8:return this.Ww;case 9:return this.Uw;case 10:return this.Vw;case 11:return this.yz;case 12:return this.xz;case 13:return this.Yw;default:return $K(W(),a)}};f.D=function(a){return a instanceof xp};
+f.B=function(){var a=lb("JSClassNewDecl");a=W().C(-889275714,a);var b=this.Ds;b=My(W(),b);a=W().C(a,b);b=this.Au;b=My(W(),b);a=W().C(a,b);b=this.Sw;b=My(W(),b);a=W().C(a,b);b=this.Xw;b=My(W(),b);a=W().C(a,b);b=this.Tw;b=My(W(),b);a=W().C(a,b);b=this.Zw;b=My(W(),b);a=W().C(a,b);b=this.sq;b=My(W(),b);a=W().C(a,b);b=this.zz;b=My(W(),b);a=W().C(a,b);b=this.Ww;b=My(W(),b);a=W().C(a,b);b=this.Uw;b=My(W(),b);a=W().C(a,b);b=this.Vw;b=My(W(),b);a=W().C(a,b);b=this.yz;b=My(W(),b);a=W().C(a,b);b=this.xz?1231:
+1237;a=W().C(a,b);b=this.Yw;b=My(W(),b);a=W().C(a,b);return W().Ma(a,14)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof xp){if(this.xz===a.xz)if(this.Ds===a.Ds){var b=this.Au,c=a.Au;b=null===b?null===c:b.i(c)}else b=!1;else b=!1;b?(b=this.Sw,c=a.Sw,(null===b?null===c:b.i(c))?(b=this.Xw,c=a.Xw,b=null===b?null===c:b.i(c)):b=!1,b?(b=this.Tw,c=a.Tw,(null===b?null===c:b.i(c))?(b=this.Zw,c=a.Zw,b=null===b?null===c:b.i(c)):b=!1):b=!1):b=!1;if(b&&(b=this.sq,c=a.sq,(null===b?null===c:b.i(c))?(b=this.zz,c=a.zz,(null===b?null===c:b.i(c))?(b=this.Ww,c=a.Ww,b=null===b?null===
+c:b.i(c)):b=!1):b=!1,b&&(b=this.Uw,c=a.Uw,(null===b?null===c:b.i(c))?(b=this.Vw,c=a.Vw,b=null===b?null===c:b.i(c)):b=!1,b&&(b=this.yz,c=a.yz,null===b?null===c:b.i(c)))))return b=this.Yw,a=a.Yw,null===b?null===a:b.i(a)}return!1};f.$classData=q({HV:0},!1,"mlscript.JSClassNewDecl",{HV:1,el:1,Xc:1,g:1,E:1,v:1,l:1});function Ro(a){this.rD=a}Ro.prototype=new fO;Ro.prototype.constructor=Ro;f=Ro.prototype;f.sh=function(){return 1};
+f.xa=function(){var a=Qp(),b=this.rD;if(b===u())var c=u();else{c=b.e();var d=c=new z(c.xa(),u());for(b=b.f();b!==u();){var e=b.e();e=new z(e.xa(),u());d=d.p=e;b=b.f()}}d=Qp();return Uba(a,c,d.RN)};f.H=function(){return"JSCommaExpr"};f.G=function(){return 1};f.I=function(a){return 0===a?this.rD:$K(W(),a)};f.D=function(a){return a instanceof Ro};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Ro){var b=this.rD;a=a.rD;return null===b?null===a:b.i(a)}return!1};f.$classData=q({IV:0},!1,"mlscript.JSCommaExpr",{IV:1,Vi:1,Xc:1,g:1,E:1,v:1,l:1});function qn(a,b){this.sD=a;this.$w=b}qn.prototype=new qO;qn.prototype.constructor=qn;f=qn.prototype;f.xa=function(){var a=Sp(Qp(),"const "+this.sD+" \x3d "),b=this.$w instanceof Ro?Pp(this.$w.xa(),!0):this.$w.xa();return Rp(Rp(a,b),Qp().zx)};f.H=function(){return"JSConstDecl"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.sD;case 1:return this.$w;default:return $K(W(),a)}};f.D=function(a){return a instanceof qn};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof qn&&this.sD===a.sD){var b=this.$w;a=a.$w;return null===b?null===a:b.i(a)}return!1};f.$classData=q({KV:0},!1,"mlscript.JSConstDecl",{KV:1,el:1,Xc:1,g:1,E:1,v:1,l:1});function Bo(a){this.Bz=a}Bo.prototype=new qO;Bo.prototype.constructor=Bo;f=Bo.prototype;
+f.xa=function(){return Rp(Pp(this.Bz.xa(),this.Bz instanceof vo),Qp().zx)};f.H=function(){return"JSExprStmt"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Bz:$K(W(),a)};f.D=function(a){return a instanceof Bo};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Bo){var b=this.Bz;a=a.Bz;return null===b?null===a:b.i(a)}return!1};f.$classData=q({NV:0},!1,"mlscript.JSExprStmt",{NV:1,el:1,Xc:1,g:1,E:1,v:1,l:1});
+function Az(a,b,c){this.yD=a;this.xD=b;this.wD=c}Az.prototype=new qO;Az.prototype.constructor=Az;f=Az.prototype;f.xa=function(){for(var a=Rp(Rp(Rp(Rp(Sp(Qp(),"for (const "),this.yD.xa()),Sp(Qp()," in ")),this.xD.xa()),Sp(Qp(),")")),b=this.wD,c=Qp().ye;!b.b();){var d=b.e();c=Iz(c,d.xa());b=b.f()}return Rp(a,Oz(c))};f.H=function(){return"JSForInStmt"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.yD;case 1:return this.xD;case 2:return this.wD;default:return $K(W(),a)}};
+f.D=function(a){return a instanceof Az};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Az){var b=this.yD,c=a.yD;if(null===b?null===c:b.i(c))if(b=this.xD,c=a.xD,null===b?null===c:b.i(c))return b=this.wD,a=a.wD,null===b?null===a:b.i(a)}return!1};f.$classData=q({QV:0},!1,"mlscript.JSForInStmt",{QV:1,el:1,Xc:1,g:1,E:1,v:1,l:1});function sz(a,b,c){this.AD=a;this.BD=b;this.zD=c}sz.prototype=new qO;sz.prototype.constructor=sz;f=sz.prototype;
+f.xa=function(){for(var a=Rp(Rp(Sp(Qp(),"function "+this.AD),Op(Lp(),this.BD)),Qp().bA),b=this.zD,c=Qp().ye;!b.b();){var d=b.e();c=Iz(c,d.xa());b=b.f()}return Rp(a,Oz(c))};f.H=function(){return"JSFuncDecl"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.AD;case 1:return this.BD;case 2:return this.zD;default:return $K(W(),a)}};f.D=function(a){return a instanceof sz};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof sz&&this.AD===a.AD){var b=this.BD,c=a.BD;if(null===b?null===c:b.i(c))return b=this.zD,a=a.zD,null===b?null===a:b.i(a)}return!1};f.$classData=q({RV:0},!1,"mlscript.JSFuncDecl",{RV:1,el:1,Xc:1,g:1,E:1,v:1,l:1});function wo(a,b,c){this.DD=a;this.ED=b;this.CD=c}wo.prototype=new fO;wo.prototype.constructor=wo;f=wo.prototype;f.sh=function(){return 22};
+f.xa=function(){Qp();var a=this.DD;a=Rp(Rp(Sp(0,"function "+(a.b()?"":a.o())),Op(Lp(),this.ED)),Qp().bA);Qp();var b=this.CD;if(b===u())var c=u();else{c=b.e();var d=c=new z(c.xa(),u());for(b=b.f();b!==u();){var e=b.e();e=new z(e.xa(),u());d=d.p=e;b=b.f()}}return Rp(a,Oz(Sz(c)))};f.H=function(){return"JSFuncExpr"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.DD;case 1:return this.ED;case 2:return this.CD;default:return $K(W(),a)}};f.D=function(a){return a instanceof wo};
+f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof wo){var b=this.DD,c=a.DD;if(null===b?null===c:b.i(c))if(b=this.ED,c=a.ED,null===b?null===c:b.i(c))return b=this.CD,a=a.CD,null===b?null===a:b.i(a)}return!1};f.$classData=q({SV:0},!1,"mlscript.JSFuncExpr",{SV:1,Vi:1,Xc:1,g:1,E:1,v:1,l:1});function km(a){this.tq=a}km.prototype=new fO;km.prototype.constructor=km;f=km.prototype;f.sh=function(){return 22};
+f.xa=function(){return Sp(Qp(),this.tq)};f.H=function(){return"JSIdent"};f.G=function(){return 1};f.I=function(a){return 0===a?this.tq:$K(W(),a)};f.D=function(a){return a instanceof km};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){return this===a?!0:a instanceof km?this.tq===a.tq:!1};f.$classData=q({TV:0},!1,"mlscript.JSIdent",{TV:1,Vi:1,Xc:1,g:1,E:1,v:1,l:1});function dp(a,b,c){this.GD=a;this.FD=b;this.Cz=c}dp.prototype=new qO;dp.prototype.constructor=dp;f=dp.prototype;
+f.xa=function(){var a=Sp(Qp(),"if ");a:{var b=this.GD.xa();switch(b.$f.K()){case 0:var c=b;break a;case 1:var d=b.$f;if(d===u())c=u();else for(c=d.e(),b=c=new z(Mz(c),u()),d=d.f();d!==u();){var e=d.e();e=new z(Mz(e),u());b=b.p=e;d=d.f()}c=new Hz(c);break a;default:c=new Jz("(",0);e=b.$f;if(e===u())b=u();else for(b=e.e(),d=b=new z(Lz(b),u()),e=e.f();e!==u();){var g=e.e();g=new z(Lz(g),u());d=d.p=g;e=e.f()}t();d=J(new K,[new Jz(")",0)]);b=dl(Pd(u(),d),b);c=new Hz(new z(c,b))}}a=Rp(Rp(a,c),Qp().bA);
+c=this.FD;for(b=Qp().ye;!c.b();)d=c.e(),b=Iz(b,d.xa()),c=c.f();a=Rp(a,Oz(b));c=this.Cz;b=O().c;if(null===b?null===c:b.i(c))c=Qp().ye;else{c=Sp(Qp()," else ");b=this.Cz;for(d=Qp().ye;!b.b();)e=b.e(),d=Iz(d,e.xa()),b=b.f();c=Rp(c,Oz(d))}return Rp(a,c)};f.H=function(){return"JSIfStmt"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.GD;case 1:return this.FD;case 2:return this.Cz;default:return $K(W(),a)}};f.D=function(a){return a instanceof dp};f.B=function(){return AL(this)};
+f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof dp){var b=this.GD,c=a.GD;if(null===b?null===c:b.i(c))if(b=this.FD,c=a.FD,null===b?null===c:b.i(c))return b=this.Cz,a=a.Cz,null===b?null===a:b.i(a)}return!1};f.$classData=q({UV:0},!1,"mlscript.JSIfStmt",{UV:1,el:1,Xc:1,g:1,E:1,v:1,l:1});function dn(a,b,c,d){this.HD=a;this.Fz=b;this.Ez=c;this.Dz=d}dn.prototype=new fO;dn.prototype.constructor=dn;f=dn.prototype;f.sh=function(){return 22};
+f.xa=function(){var a=this.HD;if(R()===a){a=Sp(Qp(),Op(Lp(),this.Fz)+" \x3d\x3e ");var b=!1,c=null,d=this.Ez;a:{if(d instanceof fe){b=!0;c=d;var e=c.aa;if(e instanceof vo){b=Pp(e.xa(),!0);break a}}if(b)b=Up(c.aa,2);else if(d instanceof Ud){b=d.fa;for(c=Qp().ye;!b.b();)d=b.e(),c=Iz(c,d.xa()),b=b.f();b=Oz(c)}else throw new w(d);}return Rp(Pp(Rp(a,b),!0),Tp(Lp(),this.Dz))}if(a instanceof L){a=a.k;a=Sp(Qp(),"function "+a+Op(Lp(),this.Fz)+" ");b=this.Ez;if(b instanceof fe)b=rn(b.aa).xa();else{if(!(b instanceof
+Ud))throw new w(b);b=b.fa;for(c=Qp().ye;!b.b();)d=b.e(),c=Iz(c,d.xa()),b=b.f();b=c}return Rp(Pp(Rp(a,Oz(b)),!0),Tp(Lp(),this.Dz))}throw new w(a);};f.H=function(){return"JSImmEvalFn"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.HD;case 1:return this.Fz;case 2:return this.Ez;case 3:return this.Dz;default:return $K(W(),a)}};f.D=function(a){return a instanceof dn};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof dn){var b=this.HD,c=a.HD;(null===b?null===c:b.i(c))?(b=this.Fz,c=a.Fz,b=null===b?null===c:b.i(c)):b=!1;if(b&&(b=this.Ez,c=a.Ez,null===b?null===c:b.i(c)))return b=this.Dz,a=a.Dz,null===b?null===a:b.i(a)}return!1};f.$classData=q({VV:0},!1,"mlscript.JSImmEvalFn",{VV:1,Vi:1,Xc:1,g:1,E:1,v:1,l:1});function kn(a,b){this.ID=a;this.JD=b}kn.prototype=new fO;kn.prototype.constructor=kn;f=kn.prototype;f.sh=function(){return 12};
+f.xa=function(){return Rp(Rp(this.ID.xa(),Sp(Qp()," instanceof ")),this.JD.xa())};f.H=function(){return"JSInstanceOf"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.ID;case 1:return this.JD;default:return $K(W(),a)}};f.D=function(a){return a instanceof kn};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof kn){var b=this.ID,c=a.ID;if(null===b?null===c:b.i(c))return b=this.JD,a=a.JD,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({WV:0},!1,"mlscript.JSInstanceOf",{WV:1,Vi:1,Xc:1,g:1,E:1,v:1,l:1});function cn(a,b){this.KD=a;this.Gz=b}cn.prototype=new fO;cn.prototype.constructor=cn;f=cn.prototype;f.sh=function(){return 20};f.xa=function(){var a=Up(this.KD,20),b=Hf(this.Gz).De(Qp().ye,new fn((c,d)=>{var e=G(new H,c,d);c=e.y;d=e.w;if(null!==d)return e=d.Sc(),Rp(Rp(c,Up(d.h(),Vp().Az)),Pe(new E(e),-1+this.Gz.K()|0)?Qp().ye:Sp(Qp(),", "));throw new w(e);}));return Rp(a,Pp(b,!0))};f.H=function(){return"JSInvoke"};
+f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.KD;case 1:return this.Gz;default:return $K(W(),a)}};f.D=function(a){return a instanceof cn};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof cn){var b=this.KD,c=a.KD;if(null===b?null===c:b.i(c))return b=this.Gz,a=a.Gz,null===b?null===a:b.i(a)}return!1};f.$classData=q({XV:0},!1,"mlscript.JSInvoke",{XV:1,Vi:1,Xc:1,g:1,E:1,v:1,l:1});function Eo(a){this.Hz=a}
+Eo.prototype=new qO;Eo.prototype.constructor=Eo;f=Eo.prototype;f.xa=function(){return Rp(Rp(Sp(Qp(),"let "),Hf(this.Hz).De(Qp().ye,new fn((a,b)=>{var c=G(new H,a,b);a=c.y;b=c.w;if(null!==b){c=b.h();b=b.Sc();a:{if(null!==c){var d=c.h(),e=c.j();if(t().d===e){c=Sp(Qp(),d);break a}}if(null!==c&&(d=c.h(),e=c.j(),e instanceof L)){c=e.k;c=Rp(Rp(Sp(Qp(),d),Sp(Qp()," \x3d ")),c.xa());break a}throw new w(c);}return Rp(Rp(a,c),Pe(new E(b),-1+this.Hz.K()|0)?Qp().ye:Sp(Qp(),", "))}throw new w(c);}))),Qp().zx)};
+f.H=function(){return"JSLetDecl"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Hz:$K(W(),a)};f.D=function(a){return a instanceof Eo};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Eo){var b=this.Hz;a=a.Hz;return null===b?null===a:b.i(a)}return!1};f.$classData=q({YV:0},!1,"mlscript.JSLetDecl",{YV:1,el:1,Xc:1,g:1,E:1,v:1,l:1});function hn(a){this.LD=a}hn.prototype=new fO;hn.prototype.constructor=hn;f=hn.prototype;
+f.sh=function(){return 22};f.xa=function(){return Sp(Qp(),this.LD)};f.H=function(){return"JSLit"};f.G=function(){return 1};f.I=function(a){return 0===a?this.LD:$K(W(),a)};f.D=function(a){return a instanceof hn};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){return this===a?!0:a instanceof hn?this.LD===a.LD:!1};f.$classData=q({$V:0},!1,"mlscript.JSLit",{$V:1,Vi:1,Xc:1,g:1,E:1,v:1,l:1});function xl(a){this.MD=a}xl.prototype=new oO;xl.prototype.constructor=xl;f=xl.prototype;
+f.xa=function(){return Sp(Qp(),this.MD)};f.H=function(){return"JSNamePattern"};f.G=function(){return 1};f.I=function(a){return 0===a?this.MD:$K(W(),a)};f.D=function(a){return a instanceof xl};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){return this===a?!0:a instanceof xl?this.MD===a.MD:!1};f.$classData=q({bW:0},!1,"mlscript.JSNamePattern",{bW:1,BH:1,Xc:1,g:1,E:1,v:1,l:1});function $m(a){this.ND=a}$m.prototype=new fO;$m.prototype.constructor=$m;f=$m.prototype;
+f.sh=function(){return 21};f.xa=function(){return Rp(Sp(Qp(),"new "),this.ND.xa())};f.H=function(){return"JSNew"};f.G=function(){return 1};f.I=function(a){return 0===a?this.ND:$K(W(),a)};f.D=function(a){return a instanceof $m};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof $m){var b=this.ND;a=a.ND;return null===b?null===a:b.i(a)}return!1};f.$classData=q({cW:0},!1,"mlscript.JSNew",{cW:1,Vi:1,Xc:1,g:1,E:1,v:1,l:1});
+function Bl(a){this.OD=a}Bl.prototype=new oO;Bl.prototype.constructor=Bl;f=Bl.prototype;
+f.xa=function(){Qp();var a=this.OD,b=g=>{if(null!==g){var h=new L(g);if(!h.b()){var k=h.k.h();h=h.k.j();if(h instanceof L&&h.k instanceof El)return Sp(Qp(),k)}}if(null!==g&&(h=new L(g),!h.b()&&(k=h.k.h(),h=h.k.j(),h instanceof L)))return g=h.k,Rp(Sp(Qp(),k+": "),g.xa());if(null!==g&&(h=new L(g),!h.b()&&(k=h.k.h(),h=h.k.j(),t().d===h)))return Sp(Qp(),k);throw new w(g);};if(a===u())b=u();else{var c=a.e(),d=c=new z(b(c),u());for(a=a.f();a!==u();){var e=a.e();e=new z(b(e),u());d=d.p=e;a=a.f()}b=c}return Tz(b)};
+f.H=function(){return"JSObjectPattern"};f.G=function(){return 1};f.I=function(a){return 0===a?this.OD:$K(W(),a)};f.D=function(a){return a instanceof Bl};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Bl){var b=this.OD;a=a.OD;return null===b?null===a:b.i(a)}return!1};f.$classData=q({dW:0},!1,"mlscript.JSObjectPattern",{dW:1,BH:1,Xc:1,g:1,E:1,v:1,l:1});function Vo(a){this.PD=a}Vo.prototype=new fO;Vo.prototype.constructor=Vo;f=Vo.prototype;
+f.sh=function(){return 0};f.xa=function(){return Up(this.PD,0)};f.H=function(){return"JSParenthesis"};f.G=function(){return 1};f.I=function(a){return 0===a?this.PD:$K(W(),a)};f.D=function(a){return a instanceof Vo};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Vo){var b=this.PD;a=a.PD;return null===b?null===a:b.i(a)}return!1};f.$classData=q({eW:0},!1,"mlscript.JSParenthesis",{eW:1,Vi:1,Xc:1,g:1,E:1,v:1,l:1});
+function vo(a,b){this.QD=a;this.RD=b}vo.prototype=new fO;vo.prototype.constructor=vo;f=vo.prototype;f.sh=function(){return 22};
+f.xa=function(){Qp();var a=this.QD,b=g=>{if(null!==g){var h=g.h();g=g.j();return Rp(Sp(Qp(),zl(Al(),h)+": "),Up(g,Vp().Az))}throw new w(g);};if(a===u())b=u();else{var c=a.e(),d=c=new z(b(c),u());for(a=a.f();a!==u();){var e=a.e();e=new z(b(e),u());d=d.p=e;a=a.f()}b=c}a=this.RD;if(a===u())c=u();else for(c=a.e(),d=c=new z(c.xa(),u()),a=a.f();a!==u();)e=a.e(),e=new z(e.xa(),u()),d=d.p=e,a=a.f();return Tz(un(b,c))};f.H=function(){return"JSRecord"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.QD;case 1:return this.RD;default:return $K(W(),a)}};f.D=function(a){return a instanceof vo};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof vo){var b=this.QD,c=a.QD;if(null===b?null===c:b.i(c))return b=this.RD,a=a.RD,null===b?null===a:b.i(a)}return!1};f.$classData=q({fW:0},!1,"mlscript.JSRecord",{fW:1,Vi:1,Xc:1,g:1,E:1,v:1,l:1});function Io(a){this.SD=a}Io.prototype=new qO;
+Io.prototype.constructor=Io;f=Io.prototype;f.xa=function(){var a=this.SD;if(a instanceof L)a=a.k,a=Rp(Sp(Qp(),"return "),Nz(a.xa()));else{if(R()!==a)throw new w(a);a=Sp(Qp(),"return")}return Rp(a,Qp().zx)};f.H=function(){return"JSReturnStmt"};f.G=function(){return 1};f.I=function(a){return 0===a?this.SD:$K(W(),a)};f.D=function(a){return a instanceof Io};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Io){var b=this.SD;a=a.SD;return null===b?null===a:b.i(a)}return!1};f.$classData=q({gW:0},!1,"mlscript.JSReturnStmt",{gW:1,el:1,Xc:1,g:1,E:1,v:1,l:1});function hO(a,b,c){this.XD=a;this.VD=b;this.WD=c}hO.prototype=new qO;hO.prototype.constructor=hO;f=hO.prototype;
+f.xa=function(){for(var a=Rp(Rp(Sp(Qp(),"switch ("),this.XD.xa()),Sp(Qp(),") {")),b=this.VD,c=Qp().ye;!b.b();){var d=b.e();c=Iz(c,Kz(d.xa()));b=b.f()}a=Iz(a,c);b=this.WD;if(b instanceof L)b=Iz(Kz(b.k.xa()),Sp(Qp(),"}"));else{if(t().d!==b)throw new w(b);b=Sp(Qp(),"}")}return Iz(a,b)};f.H=function(){return"JSSwitchStmt"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.XD;case 1:return this.VD;case 2:return this.WD;default:return $K(W(),a)}};f.D=function(a){return a instanceof hO};
+f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof hO){var b=this.XD,c=a.XD;if(null===b?null===c:b.i(c))if(b=this.VD,c=a.VD,null===b?null===c:b.i(c))return b=this.WD,a=a.WD,null===b?null===a:b.i(a)}return!1};f.$classData=q({iW:0},!1,"mlscript.JSSwitchStmt",{iW:1,el:1,Xc:1,g:1,E:1,v:1,l:1});function on(a,b,c){this.$D=a;this.ZD=b;this.YD=c}on.prototype=new fO;on.prototype.constructor=on;f=on.prototype;f.sh=function(){return 4};
+f.xa=function(){return Rp(Rp(Rp(Rp(Up(this.$D,4),Sp(Qp()," ? ")),Up(this.ZD,4)),Sp(Qp()," : ")),Up(this.YD,4))};f.H=function(){return"JSTenary"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.$D;case 1:return this.ZD;case 2:return this.YD;default:return $K(W(),a)}};f.D=function(a){return a instanceof on};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof on){var b=this.$D,c=a.$D;if(null===b?null===c:b.i(c))if(b=this.ZD,c=a.ZD,null===b?null===c:b.i(c))return b=this.YD,a=a.YD,null===b?null===a:b.i(a)}return!1};f.$classData=q({jW:0},!1,"mlscript.JSTenary",{jW:1,Vi:1,Xc:1,g:1,E:1,v:1,l:1});function bn(a){this.aE=a}bn.prototype=new qO;bn.prototype.constructor=bn;f=bn.prototype;f.xa=function(){return Rp(Rp(Sp(Qp(),"throw "),Nz(this.aE.xa())),Qp().zx)};f.H=function(){return"JSThrowStmt"};f.G=function(){return 1};
+f.I=function(a){return 0===a?this.aE:$K(W(),a)};f.D=function(a){return a instanceof bn};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof bn){var b=this.aE;a=a.aE;return null===b?null===a:b.i(a)}return!1};f.$classData=q({kW:0},!1,"mlscript.JSThrowStmt",{kW:1,el:1,Xc:1,g:1,E:1,v:1,l:1});function xz(a,b){this.bE=a;this.cE=b}xz.prototype=new qO;xz.prototype.constructor=xz;f=xz.prototype;
+f.xa=function(){for(var a=Sp(Qp(),"try "),b=this.bE,c=Qp().ye;!b.b();){var d=b.e();c=Iz(c,d.xa());b=b.f()}return Rp(Rp(a,Oz(c)),this.cE.xa())};f.H=function(){return"JSTryStmt"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.bE;case 1:return this.cE;default:return $K(W(),a)}};f.D=function(a){return a instanceof xz};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof xz){var b=this.bE,c=a.bE;if(null===b?null===c:b.i(c))return b=this.cE,a=a.cE,null===b?null===a:b.i(a)}return!1};f.$classData=q({lW:0},!1,"mlscript.JSTryStmt",{lW:1,el:1,Xc:1,g:1,E:1,v:1,l:1});function $o(a,b){this.Iz=a;this.dE=b}$o.prototype=new fO;$o.prototype.constructor=$o;f=$o.prototype;f.sh=function(){return 15};f.xa=function(){return Rp("typeof"===this.Iz?Sp(Qp(),"typeof "):Sp(Qp(),this.Iz),Up(this.dE,15))};f.H=function(){return"JSUnary"};
+f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Iz;case 1:return this.dE;default:return $K(W(),a)}};f.D=function(a){return a instanceof $o};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof $o&&this.Iz===a.Iz){var b=this.dE;a=a.dE;return null===b?null===a:b.i(a)}return!1};f.$classData=q({mW:0},!1,"mlscript.JSUnary",{mW:1,Vi:1,Xc:1,g:1,E:1,v:1,l:1});function Zo(a,b){this.fE=a;this.eE=b}Zo.prototype=new qO;
+Zo.prototype.constructor=Zo;f=Zo.prototype;f.xa=function(){return Rp(Rp(Rp(Sp(Qp(),"while ("),this.fE.xa()),Sp(Qp(),") ")),Oz(this.eE.xa()))};f.H=function(){return"JSWhileStmt"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.fE;case 1:return this.eE;default:return $K(W(),a)}};f.D=function(a){return a instanceof Zo};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Zo){var b=this.fE,c=a.fE;if(null===b?null===c:b.i(c))return b=this.eE,a=a.eE,null===b?null===a:b.i(a)}return!1};f.$classData=q({oW:0},!1,"mlscript.JSWhileStmt",{oW:1,el:1,Xc:1,g:1,E:1,v:1,l:1});function El(){}El.prototype=new oO;El.prototype.constructor=El;f=El.prototype;f.xa=function(){return Qp().ye};f.H=function(){return"JSWildcardPattern"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof El};
+f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){return a instanceof El};f.$classData=q({pW:0},!1,"mlscript.JSWildcardPattern",{pW:1,BH:1,Xc:1,g:1,E:1,v:1,l:1});function as(a){this.Na=a}as.prototype=new Wz;as.prototype.constructor=as;f=as.prototype;f.H=function(){return"KEYWORD"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Na:$K(W(),a)};f.D=function(a){return a instanceof as};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){return this===a?!0:a instanceof as?this.Na===a.Na:!1};f.$classData=q({qW:0},!1,"mlscript.KEYWORD",{qW:1,yk:1,g:1,Wm:1,E:1,v:1,l:1});function fs(a){this.Cu=a}fs.prototype=new Wz;fs.prototype.constructor=fs;f=fs.prototype;f.H=function(){return"LITVAL"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Cu:$K(W(),a)};f.D=function(a){return a instanceof fs};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof fs){var b=this.Cu;a=a.Cu;return null===b?null===a:b.i(a)}return!1};f.$classData=q({rW:0},!1,"mlscript.LITVAL",{rW:1,yk:1,g:1,Wm:1,E:1,v:1,l:1});function S2(){}S2.prototype=new Wz;S2.prototype.constructor=S2;f=S2.prototype;f.H=function(){return"NEWLINE"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof S2};f.B=function(){return-1731062412};f.u=function(){return"NEWLINE"};
+f.$classData=q({HW:0},!1,"mlscript.NEWLINE$",{HW:1,yk:1,g:1,Wm:1,E:1,v:1,l:1});var T2;function qs(){T2||(T2=new S2);return T2}function LO(){}LO.prototype=new p;LO.prototype.constructor=LO;f=LO.prototype;f.uj=function(a,b){return 0>=this.Da(a,b)};f.Yj=function(a,b){return 0<=this.Da(a,b)};f.Xj=function(a,b){return 0<this.Da(a,b)};f.Yi=function(a,b){return x2(this,a,b)};f.Jk=function(a,b){return y2(this,a,b)};f.Kk=function(a,b){return z2(this,a,b)};f.sj=function(a){return A2(this,a)};
+f.Da=function(a,b){return Pea(a,b)};f.$classData=q({$W:0},!1,"mlscript.NormalForms$Conjunct$Ordering$",{$W:1,g:1,lm:1,Ji:1,mm:1,km:1,l:1});function FP(){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0}FP.prototype=new M_;FP.prototype.constructor=FP;function U2(){}U2.prototype=FP.prototype;function V2(){}V2.prototype=new Wz;V2.prototype.constructor=V2;f=V2.prototype;f.H=function(){return"QUOTE"};f.G=function(){return 0};
+f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof V2};f.B=function(){return 77416028};f.u=function(){return"QUOTE"};f.$classData=q({VX:0},!1,"mlscript.QUOTE$",{VX:1,yk:1,g:1,Wm:1,E:1,v:1,l:1});var W2;function Yr(){W2||(W2=new V2);return W2}function ss(a){this.ux=a}ss.prototype=new Wz;ss.prototype.constructor=ss;f=ss.prototype;f.H=function(){return"SELECT"};f.G=function(){return 1};f.I=function(a){return 0===a?this.ux:$K(W(),a)};f.D=function(a){return a instanceof ss};f.B=function(){return AL(this)};
+f.u=function(){return VK(this)};f.i=function(a){return this===a?!0:a instanceof ss?this.ux===a.ux:!1};f.$classData=q({aY:0},!1,"mlscript.SELECT",{aY:1,yk:1,g:1,Wm:1,E:1,v:1,l:1});function X2(){}X2.prototype=new Wz;X2.prototype.constructor=X2;f=X2.prototype;f.H=function(){return"SEMI"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof X2};f.B=function(){return 2541422};f.u=function(){return"SEMI"};
+f.$classData=q({bY:0},!1,"mlscript.SEMI$",{bY:1,yk:1,g:1,Wm:1,E:1,v:1,l:1});var Y2;function ds(){Y2||(Y2=new X2);return Y2}function Z2(){}Z2.prototype=new Wz;Z2.prototype.constructor=Z2;f=Z2.prototype;f.H=function(){return"SPACE"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof Z2};f.B=function(){return 79100134};f.u=function(){return"SPACE"};f.$classData=q({cY:0},!1,"mlscript.SPACE$",{cY:1,yk:1,g:1,Wm:1,E:1,v:1,l:1});var $2;
+function Se(){$2||($2=new Z2);return $2}function a3(){this.io=this.ho=this.jo=null;this.Fp=this.Gp=this.an=this.Ep=0;this.qa=null;this.r=0;this.zk=this.Pq=this.Uq=this.xp=this.Bp=this.Cp=this.Sq=this.zp=this.Rq=this.wp=this.Ap=this.yp=this.Qq=this.Tq=null;this.Dp=0;this.hs=this.yq=this.Aq=this.Bq=this.zq=this.Dq=this.Cq=null;this.Im=this.Pw=0;this.iA=this.hA=this.Ku=null}a3.prototype=new K_;a3.prototype.constructor=a3;function b3(){}b3.prototype=a3.prototype;
+function c3(a){null===a.hA&&null===a.hA&&(a.hA=new aY(a))}function ofa(a){null===a.iA&&null===a.iA&&(a.iA=new bA(a))}function bz(a,b,c,d){if(!Ot(new E(b.pb),Bp())&&!Ot(new E(b.pb),zp()))throw Kj("requirement failed: "+b.pb);var e=new vl(b.gb.V);if(a.$c&&Nm(new E(b.gb.V),"Object")){tp();var g=gq(new Ep("Object"));b=d.$a.U(b.gb.V);b.b()?b=R():(b=b.o(),b=new L(gx(b)));b=b.b()?ap():b.o();g=g.Ce(b)}else g=jY(d,b.gb.V);return new Mu(a,e,g,c)}
+function rD(a,b,c,d){if(!Ot(new E(b.jj),Bp())&&!Ot(new E(b.jj),zp()))throw Kj("requirement failed: "+b.jj);return new Mu(a,new vl(b.Wl.V),jY(d,b.Wl.V),c)}function TD(a,b,c){At(tp(),Ot(new E(b.jj),Fp()));return new nC(a,new vl(b.Wl.V),ap(),c)}function Xx(a,b,c,d){At(tp(),Ot(new E(b.pb),Fp()));var e=new vl(b.gb.V);b=d.$a.U(b.gb.V);b.b()?b=R():(b=b.o(),b=new L(gx(b)));return new nC(a,e,b.b()?ap():b.o(),c)}
+function fB(a,b,c,d){if(b instanceof fw)return fB(a,gB(b,c,!1,d),c,d);if(b instanceof LA){var e=b.ic,g=b.jc;if(!1===b.tc){b=fB(a,e,c,d);a=fB(a,g,c,d);c=b.Q()+a.Q()|0;c=Lv(Lv(Mv(8<c?c:8),b),a);a=Xu().X();for(c=sl(c).m();c.s();){g=c.t();d=g.h();b=a.U(d);if(b instanceof L)b=b.k,g=Nv(b,g.j(),V(b.Va));else{if(R()!==b)throw new w(b);g=g.j()}a.bj(d,g)}c=qp();return(new Pv(c)).vc(a)}}if(b instanceof Qv)return a=b.Ba,op(),pp(qp(),a);if(b instanceof ZB)return fB(a,b.mc(),c,d);if(b instanceof Tv){var h=b.kf;
+return fB(a,b.Ic,c,d).Fk(new y(k=>h.L(k.h())))}if(b instanceof cC)return fB(a,b.Sf,c,d);if(Uv(b)||b instanceof cv||b instanceof Vv||b instanceof lx||b instanceof MA||b instanceof FA||b instanceof LA||b instanceof Wv||b instanceof eC||b instanceof Qx||b instanceof Jv)return nf();throw new w(b);}function Fv(){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0}Fv.prototype=new S_;Fv.prototype.constructor=Fv;function d3(){}d3.prototype=Fv.prototype;
+function pba(a,b){b=G(new H,a,b);var c=b.y,d=b.w;if(Uv(c)&&c.q===a.q&&Uv(d)&&d.q===a.q)return uw(c,d);c=b.y;if(Uv(c)&&c.q===a.q)return-1;c=b.w;if(Uv(c)&&c.q===a.q)return 1;if(b.y instanceof cv&&b.w instanceof cv)return 0;if(b.y instanceof cv)return-1;if(b.w instanceof cv)return 1;if(b.y instanceof Sv&&b.w instanceof Sv)return 0;if(b.y instanceof Sv)return-1;if(b.w instanceof Sv)return 1;if(b.y instanceof zv&&b.w instanceof zv)return 0;if(b.y instanceof zv)return-1;if(b.w instanceof zv)return 1;if(b.y instanceof
+Tv&&b.w instanceof Tv)return 0;if(b.y instanceof Tv)return-1;if(b.w instanceof Tv)return 1;if(b.y instanceof Jv&&b.w instanceof Jv)return 0;if(b.y instanceof Jv)return-1;if(b.w instanceof Jv)return 1;if(b.y instanceof Wv&&b.w instanceof Wv)return 0;throw new w(b);}Fv.prototype.kq=function(){return wv(xv(this.q))};Fv.prototype.Kc=function(a,b,c,d){return this.At(a,b,c,d)};function ix(a,b){this.J=null;this.kh=b;FC(this,a);b.Ua()}ix.prototype=new WP;ix.prototype.constructor=ix;f=ix.prototype;f.fQ=function(){return this.kh};
+f.fd=function(){return this.kh.fd()};f.H=function(){return"CompletedTypeInfo"};f.G=function(){return 1};f.I=function(a){return 0===a?this.kh:$K(W(),a)};f.D=function(a){return a instanceof ix};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof ix&&a.J===this.J){var b=this.kh;a=a.kh;return null===b?null===a:b.i(a)}return!1};f.$classData=q({$Y:0},!1,"mlscript.TyperDatatypes$CompletedTypeInfo",{$Y:1,nZ:1,UO:1,g:1,E:1,v:1,l:1});
+function Dt(a){this.xP=this.wP=this.vP=null;this.zP=this.AP=0;this.BP=this.yP=null;this.Rj=0;this.Kx=a;Nq(this)}Dt.prototype=new p;Dt.prototype.constructor=Dt;f=Dt.prototype;f.Vj=function(){0===(1&this.Rj)<<24>>24&&0===(1&this.Rj)<<24>>24&&(this.vP=this.Kx,this.Rj=(1|this.Rj)<<24>>24);return this.vP};function ef(a){0===(2&a.Rj)<<24>>24&&0===(2&a.Rj)<<24>>24&&(a.wP=mea(a),a.Rj=(2|a.Rj)<<24>>24);return a.wP}
+f.jn=function(){0===(4&this.Rj)<<24>>24&&0===(4&this.Rj)<<24>>24&&(this.xP=zq(this),this.Rj=(4|this.Rj)<<24>>24);return this.xP};f.rn=function(){return this.AP};f.fm=function(a){this.AP=a};f.qn=function(){return this.zP};f.em=function(a){this.zP=a};f.pn=function(){return this.yP};f.on=function(a){this.yP=a};f.A=function(){0===(8&this.Rj)<<24>>24&&0===(8&this.Rj)<<24>>24&&(this.BP=Dq(this),this.Rj=(8|this.Rj)<<24>>24);return this.BP};f.H=function(){return"TypingUnit"};f.G=function(){return 1};
+f.I=function(a){return 0===a?this.Kx:$K(W(),a)};f.D=function(a){return a instanceof Dt};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Dt){var b=this.Kx;a=a.Kx;return null===b?null===a:b.i(a)}return!1};f.$classData=q({ZZ:0},!1,"mlscript.TypingUnit",{ZZ:1,g:1,Taa:1,Ta:1,E:1,v:1,l:1});function e3(){this.ld="value"}e3.prototype=new SN;e3.prototype.constructor=e3;f=e3.prototype;f.H=function(){return"Val"};f.G=function(){return 0};
+f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof e3};f.B=function(){return 85761};f.u=function(){return"Val"};f.$classData=q({d_:0},!1,"mlscript.Val$",{d_:1,sz:1,sx:1,g:1,E:1,v:1,l:1});var f3;function hx(){f3||(f3=new e3);return f3}function go(a,b){this.BA=a;this.Nx=b;this.bF=a;this.DP=!1}go.prototype=new p;go.prototype.constructor=go;f=go.prototype;f.xo=function(){return this.BA};f.zo=function(){return this.bF};f.u=function(){return"function "+this.BA};f.H=function(){return"BuiltinSymbol"};
+f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.BA;case 1:return this.Nx;default:return $K(W(),a)}};f.D=function(a){return a instanceof go};f.B=function(){return AL(this)};f.i=function(a){return this===a?!0:a instanceof go?this.BA===a.BA&&this.Nx===a.Nx:!1};f.$classData=q({o_:0},!1,"mlscript.codegen.BuiltinSymbol",{o_:1,g:1,mt:1,cr:1,E:1,v:1,l:1});
+class gm extends xF{constructor(a){super();this.ZI=a;yF(this,a,null,!0)}H(){return"CodeGenError"}G(){return 1}I(a){return 0===a?this.ZI:$K(W(),a)}D(a){return a instanceof gm}B(){return AL(this)}i(a){return this===a?!0:a instanceof gm?this.ZI===a.ZI:!1}}gm.prototype.$classData=q({q_:0},!1,"mlscript.codegen.CodeGenError",{q_:1,qd:1,pc:1,g:1,l:1,E:1,v:1});function lo(a,b,c,d,e){this.dr=a;this.Ox=b;this.Px=c;this.EA=d;this.FA=e;this.OP=!1}lo.prototype=new p;lo.prototype.constructor=lo;f=lo.prototype;
+f.u=function(){return"new class member "+this.dr};f.xo=function(){return this.dr};f.zo=function(){return this.dr};f.H=function(){return"NewClassMemberSymbol"};f.G=function(){return 5};f.I=function(a){switch(a){case 0:return this.dr;case 1:return this.Ox;case 2:return this.Px;case 3:return this.EA;case 4:return this.FA;default:return $K(W(),a)}};f.D=function(a){return a instanceof lo};
+f.B=function(){var a=lb("NewClassMemberSymbol");a=W().C(-889275714,a);var b=this.dr;b=My(W(),b);a=W().C(a,b);b=this.Ox;b=My(W(),b);a=W().C(a,b);b=this.Px?1231:1237;a=W().C(a,b);b=this.EA?1231:1237;a=W().C(a,b);b=this.FA;b=My(W(),b);a=W().C(a,b);return W().Ma(a,5)};f.i=function(a){if(this===a)return!0;if(a instanceof lo&&this.Px===a.Px&&this.EA===a.EA&&this.dr===a.dr){var b=this.Ox,c=a.Ox;if(null===b?null===c:b.i(c))return b=this.FA,a=a.FA,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({u_:0},!1,"mlscript.codegen.NewClassMemberSymbol",{u_:1,g:1,mt:1,cr:1,E:1,v:1,l:1});function io(a,b,c,d,e){this.av=a;this.nt=b;this.RA=c;this.QA=d;this.z_=e}io.prototype=new p;io.prototype.constructor=io;f=io.prototype;f.xo=function(){return this.av};f.zo=function(){return this.nt};f.u=function(){return"value "+this.av};f.H=function(){return"StubValueSymbol"};f.G=function(){return 4};
+f.I=function(a){switch(a){case 0:return this.av;case 1:return this.nt;case 2:return this.RA;case 3:return this.QA;default:return $K(W(),a)}};f.D=function(a){return a instanceof io};f.B=function(){var a=lb("StubValueSymbol");a=W().C(-889275714,a);var b=this.av;b=My(W(),b);a=W().C(a,b);b=this.nt;b=My(W(),b);a=W().C(a,b);b=this.RA?1231:1237;a=W().C(a,b);b=this.QA;b=My(W(),b);a=W().C(a,b);return W().Ma(a,4)};
+f.i=function(a){if(this===a)return!0;if(a instanceof io&&this.RA===a.RA&&this.av===a.av&&this.nt===a.nt){var b=this.QA;a=a.QA;return null===b?null===a:b.i(a)}return!1};f.$classData=q({y_:0},!1,"mlscript.codegen.StubValueSymbol",{y_:1,g:1,mt:1,cr:1,E:1,v:1,l:1});function nn(a,b,c){this.er=a;this.fJ=b;this.rF=c}nn.prototype=new p;nn.prototype.constructor=nn;f=nn.prototype;f.xo=function(){return this.er};f.mv=function(){return this.rF};f.u=function(){return"type "+this.er};f.H=function(){return"TypeAliasSymbol"};
+f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.er;case 1:return this.fJ;case 2:return this.rF;default:return $K(W(),a)}};f.D=function(a){return a instanceof nn};f.B=function(){return AL(this)};f.i=function(a){if(this===a)return!0;if(a instanceof nn){if(this.er===a.er){var b=this.fJ,c=a.fJ;b=null===b?null===c:b.i(c)}else b=!1;if(b)return b=this.rF,a=a.rF,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({D_:0},!1,"mlscript.codegen.TypeAliasSymbol",{D_:1,g:1,UA:1,cr:1,E:1,v:1,l:1});
+class jo extends xF{constructor(a){super();this.gJ=a;var b=kl();for(a=new L(a);;){var c=a;if(c instanceof L)a=c.k,ol(b,a.av),a=a.QA,c=!0;else if(R()===c)c=!1;else throw new w(c);if(!c)break}a=ze(b,"",", ","");c=a.lastIndexOf(", ")|0;a=-1<c?a.substring(0,c)+" and "+a.substring(2+c|0):a;b=b.Zg;yF(this,a+" "+(0<(1===b?0:1>b?-1:1)?"are":"is")+" not implemented",null,!0)}H(){return"UnimplementedError"}G(){return 1}I(a){return 0===a?this.gJ:$K(W(),a)}D(a){return a instanceof jo}B(){return AL(this)}i(a){if(this===
+a)return!0;if(a instanceof jo){var b=this.gJ;a=a.gJ;return null===b?null===a:b.i(a)}return!1}}jo.prototype.$classData=q({E_:0},!1,"mlscript.codegen.UnimplementedError",{E_:1,qd:1,pc:1,g:1,l:1,E:1,v:1});function SE(a,b){this.lf=null;this.Wx=a;this.M_=b;qE(this)}SE.prototype=new hQ;SE.prototype.constructor=SE;f=SE.prototype;f.Cv=function(){return this.M_};f.u=function(){return"\u00ab"+this.Wx+" is any"+tE(this)};f.H=function(){return"MatchAny"};f.G=function(){return 1};
+f.I=function(a){return 0===a?this.Wx:$K(W(),a)};f.D=function(a){return a instanceof SE};f.B=function(){return AL(this)};f.i=function(a){if(this===a)return!0;if(a instanceof SE){var b=this.Wx;a=a.Wx;return null===b?null===a:b.i(a)}return!1};f.$classData=q({L_:0},!1,"mlscript.ucs.Clause$MatchAny",{L_:1,XP:1,VA:1,g:1,E:1,v:1,l:1});function UE(a,b,c,d){this.lf=null;this.Yx=a;this.Xx=b;this.WA=c;this.tF=d;qE(this)}UE.prototype=new hQ;UE.prototype.constructor=UE;f=UE.prototype;f.Cv=function(){return this.tF};
+f.u=function(){return"\u00ab"+this.Yx+" is "+this.Xx+"\u00bb"+tE(this)};f.H=function(){return"MatchClass"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.Yx;case 1:return this.Xx;case 2:return this.WA;default:return $K(W(),a)}};f.D=function(a){return a instanceof UE};f.B=function(){return AL(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof UE){var b=this.Yx,c=a.Yx;if(null===b?null===c:b.i(c))if(b=this.Xx,c=a.Xx,null===b?null===c:b.i(c))return b=this.WA,a=a.WA,null===b?null===a:b.i(a)}return!1};f.$classData=q({N_:0},!1,"mlscript.ucs.Clause$MatchClass",{N_:1,XP:1,VA:1,g:1,E:1,v:1,l:1});function OE(a,b,c){this.lf=null;this.$x=a;this.Zx=b;this.TP=c;qE(this)}OE.prototype=new hQ;OE.prototype.constructor=OE;f=OE.prototype;f.Cv=function(){return this.TP};
+f.u=function(){return"\u00ab"+this.$x+" is "+this.Zx+tE(this)};f.H=function(){return"MatchLiteral"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.$x;case 1:return this.Zx;default:return $K(W(),a)}};f.D=function(a){return a instanceof OE};f.B=function(){return AL(this)};f.i=function(a){if(this===a)return!0;if(a instanceof OE){var b=this.$x,c=a.$x;if(null===b?null===c:b.i(c))return b=this.Zx,a=a.Zx,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({O_:0},!1,"mlscript.ucs.Clause$MatchLiteral",{O_:1,XP:1,VA:1,g:1,E:1,v:1,l:1});function HE(a){this.ni=this.fv=null;this.ot=a;iQ(this)}HE.prototype=new kQ;HE.prototype.constructor=HE;f=HE.prototype;f.jb=function(){return"Consequent("+Zz(this.ot,!1)+")"};f.zt=function(){};f.or=function(){var a=new HE(this.ot);return QE(a,this.ni)};f.Bt=function(){return!0};f.ky=function(){return!0};
+f.dm=function(a,b){var c=new fp,d=We(Xe(),"Found a duplicated branch"),e=t().d;d=G(new H,d,e);wp(c,d);d=We(Xe(),"This branch");a:{if(null!==a&&(e=new L(a),!e.b())){var g=e.k.j();if(null!==e.k.h())break a}throw new w(a);}a=g.A();a=G(new H,d,a);wp(c,a);a=We(Xe(),"is subsumed by the branch here.");d=this.ot.A();a=G(new H,a,d);wp(c,a);b.n(hr(fr(),c.ha(),!0,lu()))};f.Op=function(){return 0};f.H=function(){return"Consequent"};f.G=function(){return 1};f.I=function(a){return 0===a?this.ot:$K(W(),a)};
+f.D=function(a){return a instanceof HE};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof HE){var b=this.ot;a=a.ot;return null===b?null===a:b.i(a)}return!1};f.$classData=q({Y_:0},!1,"mlscript.ucs.MutCaseOf$Consequent",{Y_:1,kJ:1,g:1,lJ:1,E:1,v:1,l:1});function CE(a,b,c){this.ni=this.fv=null;this.hr=a;this.Dk=b;this.Fh=c;iQ(this)}CE.prototype=new kQ;CE.prototype.constructor=CE;f=CE.prototype;
+f.jb=function(){return"IfThenElse("+Zz(this.hr,!1)+", whenTrue \x3d "+lQ(this.Dk)+", whenFalse \x3d "+lQ(this.Fh)+")"};f.or=function(){var a=new CE(this.hr,this.Dk.or(),this.Fh.or());return QE(a,this.ni)};f.zt=function(a){this.Dk.zt(a);Pe(new E(this.Fh),IE())?this.Fh=a:this.Fh.zt(a)};f.Bt=function(){return this.Dk.Bt()&&this.Fh.Bt()};f.ky=function(a,b){return this.Dk.ky(a,b)&&this.Fh.ky(a,b)};
+f.dm=function(a,b,c,d,e){if(null!==a){var g=new L(a);if(!g.b()){var h=g.k.h();g=g.k.j();if(null!==h){var k=h.Wi;h=h.mj;var l=O().c;if(null===l?null===k:l.i(k)){a=this.Op(h,g,b,c,d,e);Pe(new E(a),0)&&(fr(),a=Ye(new Te(new Ue(J(new K,["Found a redundant else branch"]))),u()),c=g.A(),a=G(new H,a,c),c=O().c,b.n(hr(0,new z(a,c),!0,lu())));return}}}}if(null!==a&&(g=new L(a),!g.b()&&(h=g.k.h(),g=g.k.j(),null!==h&&(k=h.Wi,h=h.mj,k instanceof z&&(l=k.z,k=k.p,l instanceof XE&&Pe(new E(l.Vx),this.hr)))))){lF(this.Dk,
+l.lf);this.Dk.dm(G(new H,new NE(k,h),g),b,c,d,e);return}if(null!==a&&(g=new L(a),!g.b()&&(g=g.k.h(),null!==g&&(g=g.Wi,g instanceof z)))){g=g.z;mQ(this.Dk,a,c,d,e);k=this.Fh;k instanceof HE?(fr(),a=We(Xe(),"duplicated else in the if-then-else"),c=t().d,a=G(new H,a,c),c=O().c,b.n(hr(0,new z(a,c),!0,lu()))):IE()===k?(b=gF(),this.Fh=cF(b,a.h(),a.j()),lF(this.Fh,g.lf)):this.Fh.dm(a,b,c,d,e);return}throw new w(a);};
+f.Op=function(a,b,c,d,e,g){var h=this.Dk.Op(a,b,c,d,e,g),k=this.Fh;if(k instanceof HE)a=0;else if(IE()===k)b=new HE(b),this.Fh=QE(b,a),a=1;else{if(!(k instanceof CE||k instanceof DE))throw new w(k);a=this.Fh.Op(a,b,c,d,e,g)}return h+a|0};f.H=function(){return"IfThenElse"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.hr;case 1:return this.Dk;case 2:return this.Fh;default:return $K(W(),a)}};f.D=function(a){return a instanceof CE};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof CE){var b=this.hr,c=a.hr;if(null===b?null===c:b.i(c))if(b=this.Dk,c=a.Dk,null===b?null===c:b.i(c))return b=this.Fh,a=a.Fh,null===b?null===a:b.i(a)}return!1};f.$classData=q({Z_:0},!1,"mlscript.ucs.MutCaseOf$IfThenElse",{Z_:1,kJ:1,g:1,lJ:1,E:1,v:1,l:1});function DE(a,b,c){this.ni=this.fv=null;this.mo=a;this.mh=b;this.nj=c;iQ(this)}DE.prototype=new kQ;DE.prototype.constructor=DE;f=DE.prototype;
+f.jb=function(){var a=this.mh.K(),b=this.mo,c=WF(ve(),"branch",a,!0),d=this.nj;d=d.b()?"no wildcard":"wildcard \x3d "+lQ(d.o());return"Match("+b+", "+a+" "+c+", "+d+")"};f.or=function(){var a=this.mo,b=this.mh.Ja(new y(d=>d.oQ())),c=this.nj;c.b()?c=R():(c=c.o(),c=new L(c.or()));a=new DE(a,b,c);return QE(a,this.ni)};f.zt=function(a){for(var b=this.mh.m();b.s();)b.t().xt().zt(a);b=this.nj;b.b()||b.o().zt(a)};
+f.Bt=function(){for(var a=!0,b=this.mh.m();a&&b.s();)a=b.t().xt().Bt();return a?(a=this.nj,a.b()?!0:a.o().Bt()):!1};
+f.ky=function(a,b){a=b.U(a.n(this.mo));if(R()===a)no();else{if(a instanceof L)return a=a.k.tj(),!(new iy(a,new y(c=>{if(c instanceof fe){c=c.aa|0;for(var d=this.mh.m(),e=!1;!e&&d.s();)a:if(e=d.t(),e instanceof EE)e=!1;else{if(e instanceof FE){var g=e.Tj;if(null!==g&&(g=new L(g),!g.b()&&(g=g.k.h(),null!==g))){e=g.x==="Tuple#"+c;break a}}throw new w(e);}return e}if(c instanceof Ud){c=c.fa;d=this.mh.m();for(e=!1;!e&&d.s();)a:if(e=d.t(),e instanceof EE)e=Pe(new E(c),e.ir);else{if(e instanceof FE&&(g=
+e.Tj,null!==g&&(g=new L(g),!g.b()))){e=Pe(new E(c),g.k.h());break a}throw new w(e);}return e}throw new w(c);}),!0)).s();throw new w(a);}};
+f.dm=function(a,b,c,d,e){var g=Cc=>{if(Cc instanceof YE){var Fc=Cc.bv,qd=Cc.cv;if(!1===Cc.Ux){var Yb=!1;for(Cc=this.ni.m();!Yb&&Cc.s();){var Nc=Cc.t();a:{if(null!==Nc){Yb=Nc.fr;var ad=Nc.Sj;Nc=Nc.gr;if(aF()===Yb){Yb=Pe(new E(ad),Fc)&&Pe(new E(Nc),qd);break a}}Yb=!1}}Fc=Yb}else Fc=!1;if(Fc)return!1}return!0},h=a.h().Wi;a:for(var k;;)if(h.b()){k=u();break}else{var l=h.e(),m=h.f();if(!1===!!g(l))h=m;else for(var n=h,r=m;;){if(r.b())k=n;else{var v=r.e();if(!1!==!!g(v)){r=r.f();continue}for(var x=r,A=
+new z(n.e(),u()),B=n.f(),C=A;B!==x;){var D=new z(B.e(),u());C=C.p=D;B=B.f()}for(var F=x.f(),I=F;!F.b();){var M=F.e();if(!1===!!g(M)){for(;I!==F;){var N=new z(I.e(),u());C=C.p=N;I=I.f()}I=F.f()}F=F.f()}I.b()||(C.p=I);k=A}break a}}var P=G(new H,new NE(k,a.h().mj),a.j()),T=!1,Y=null,Z=Vea(P.y,this.mo);a:if(t().d===Z)b:{var S=new L(P);if(!S.b()){var ea=S.k.h(),ia=S.k.j();if(null!==ea){var X=ea.Wi,sa=ea.mj;if(X instanceof z){var Ja=X.z,Xa=X.p;if(Ja instanceof WE){var Fa=Ja.dv,za=Ja.ay;if(Pe(new E(Ja.ev),
+this.mo)){var Qa=new vl("Tuple#"+Fa);c:{for(var Ma=this.mh.m();Ma.s();){var Ga=Ma.t();if(Ga.FF(Qa,e)){var ab=new L(Ga);break c}}ab=R()}c:{var Hb=t().d;var bc=null!==Hb&&Hb===ab?!0:ab instanceof L&&ab.k instanceof EE?!0:!1;if(bc){var yb=gF(),tb=cF(yb,new NE(Xa,sa),ia);lF(tb,Ja.lf);var eb=this.mh,kb=PE().vl(za),Rb=VE(new FE(G(new H,Qa,kb),tb),Ja.UP);eb.$(Rb)}else{if(ab instanceof L){var Gb=ab.k;if(Gb instanceof FE){lF(Gb.pl,Ja.lf);Y_(Gb,za);Gb.pl.dm(G(new H,new NE(Xa,sa),ia),b,c,d,e);break c}}throw new w(ab);
+}}break b}}}}}var vb=new L(P);if(!vb.b()){var Tb=vb.k.h(),Nb=vb.k.j();if(null!==Tb){var ic=Tb.Wi,Va=Tb.mj,cb=O().c;if(null===cb?null===ic:cb.i(ic)){var zb=this.Op(Va,Nb,b,c,d,e);if(Pe(new E(zb),0)){fr();var Ub=Ye(new Te(new Ue(J(new K,["Found a redundant else branch"]))),u()),jb=Nb.A(),db=G(new H,Ub,jb),ub=O().c;b.n(hr(0,new z(db,ub),!0,lu()))}break b}}}var Aa=new L(P);if(Aa.b())throw new w(P);for(var va=Aa.k.h(),Ra=Aa.k.j(),rb=this.mh.m();rb.s();)mQ(rb.t().xt(),G(new H,va,Ra),c,d,e);var xb=this.nj;
+if(t().d===xb){t();var mc=gF(),Ha=cF(mc,va,Ra);this.nj=new L(Ha)}else if(xb instanceof L)xb.k.dm(G(new H,va,Ra),b,c,d,e);else throw new w(xb);}else{if(Z instanceof L){T=!0;Y=Z;var Ka=Y.k;if(null!==Ka){var Oa=new L(Ka);if(!Oa.b()){var Na=Oa.k.h(),Da=Oa.k.j();if(Na instanceof UE){var ta=Na.Xx,Ya=Na.WA,dc=this.mh.m(),ka=new iy(dc,new y(Cc=>Cc.FF(ta,e)),!1);if(ka.s())for(;ka.s();){var ya=ka.t();b:if(!(ya instanceof EE)){if(ya instanceof FE){var Sa=ya,xc=Sa.Tj;if(null!==xc){var Sb=new L(xc);if(!Sb.b()){var uc=
+Sb.k.h();if(null!==uc){uc.x===ta.x?(lF(Sa.pl,Na.lf),Y_(Sa,Ya),Sa.pl.dm(G(new H,Da,P.w),b,c,d,e)):(lF(Sa.pl,Na.lf),Y_(Sa,Ya),Sa.pl.dm(P,b,c,d,e));break b}}}}throw new w(ya);}}else{var Lb=this.nj;b:{if(Lb instanceof L){var lc=Lb.k;if(!lc.Bt()){var Xb=lc.or(),ec=gF();Xb.zt(cF(ec,Da,P.w));lF(Xb,Na.lf);var Ab=this.mh,Ob=PE().vl(Ya),fb=VE(new FE(G(new H,ta,Ob),Xb),Na.tF);Ab.$(fb);break b}}if(Lb instanceof L||R()===Lb){var Wa=gF(),bb=cF(Wa,Da,P.w);lF(bb,Na.lf);var Ia=this.mh,Ua=PE().vl(Ya),pc=VE(new FE(G(new H,
+ta,Ua),bb),Na.tF);Ia.$(pc)}else throw new w(Lb);}}break a}}}}if(T){var sc=Y.k;if(null!==sc){var Ba=new L(sc);if(!Ba.b()){var ob=Ba.k.h(),nc=Ba.k.j();if(ob instanceof OE){var Ib=ob.Zx;b:{for(var vc=this.mh.m();vc.s();){var Vb=vc.t();if(Vb.FF(Ib,e)){var fc=new L(Vb);break b}}fc=R()}b:{var Bc=t().d;var Pb=null!==Bc&&Bc===fc?!0:fc instanceof L&&fc.k instanceof FE?!0:!1;if(Pb){var Jb=gF(),gc=cF(Jb,nc,P.w);lF(gc,ob.lf);var Cb=this.mh,cc=VE(new EE(Ib,gc),ob.TP);Cb.$(cc)}else{if(fc instanceof L){var yc=fc.k;
+if(yc instanceof EE){lF(yc.Jp,ob.lf);yc.Jp.dm(G(new H,nc,P.w),b,c,d,e);break b}}throw new w(fc);}}break a}}}}if(T){var Mc=Y.k;if(null!==Mc){var qc=new L(Mc);if(!qc.b()){var oc=qc.k.j();if(qc.k.h()instanceof SE){for(var Qc=this.mh.m(),jc=new iy(Qc,new y(Cc=>Cc.xt().ky(c,d)),!0);jc.s();)mQ(jc.t().xt(),G(new H,oc,P.w),c,d,e);var sb=this.nj;if(t().d===sb){t();var Gc=gF(),Wb=cF(Gc,oc,P.w);this.nj=new L(Wb)}else if(sb instanceof L)sb.k.dm(G(new H,oc,P.w),b,c,d,e);else throw new w(sb);break a}}}}throw new w(Z);
+}};f.Op=function(a,b,c,d,e,g){var h=this.mh.m();h=new Ef(h,new y(l=>{if(l instanceof FE)return l.pl.Op(a,b,c,d,e,g);if(l instanceof EE)return l.Jp.Op(a,b,c,d,e,g);throw new w(l);}));g3||(g3=new h3);h=fda(h);var k=this.nj;if(t().d===k)t(),k=new HE(b),k=QE(k,a),this.nj=new L(k),k=1;else{if(!(k instanceof L))throw new w(k);k=k.k.Op(a,b,c,d,e,g)}return(h|0)+k|0};f.H=function(){return"Match"};f.G=function(){return 3};
+f.I=function(a){switch(a){case 0:return this.mo;case 1:return this.mh;case 2:return this.nj;default:return $K(W(),a)}};f.D=function(a){return a instanceof DE};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof DE){var b=this.mo,c=a.mo;if(null===b?null===c:b.i(c))if(b=this.mh,c=a.mh,null===b?null===c:i3(b,c))return b=this.nj,a=a.nj,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({$_:0},!1,"mlscript.ucs.MutCaseOf$Match",{$_:1,kJ:1,g:1,lJ:1,E:1,v:1,l:1});function j3(){this.ni=this.fv=null;iQ(this)}j3.prototype=new kQ;j3.prototype.constructor=j3;f=j3.prototype;f.jb=function(){return"MissingCase"};f.zt=function(){};f.Bt=function(){return!1};f.ky=function(){return!1};f.dm=function(){xm("`MissingCase` is a placeholder and cannot be merged")};f.Op=function(){return 0};f.H=function(){return"MissingCase"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};
+f.D=function(a){return a instanceof j3};f.B=function(){return-1279461994};f.u=function(){return"MissingCase"};f.or=function(){return IE()};f.$classData=q({a0:0},!1,"mlscript.ucs.MutCaseOf$MissingCase$",{a0:1,kJ:1,g:1,lJ:1,E:1,v:1,l:1});var k3;function IE(){k3||(k3=new j3);return k3}function l3(){}l3.prototype=new f0;l3.prototype.constructor=l3;f=l3.prototype;f.H=function(){return"None"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof l3};f.B=function(){return 2433880};
+f.u=function(){return"None"};f.o=function(){throw AH("None.get");};f.$classData=q({$2:0},!1,"scala.None$",{$2:1,b3:1,g:1,M:1,E:1,v:1,l:1});var m3;function R(){m3||(m3=new l3);return m3}function L(a){this.k=a}L.prototype=new f0;L.prototype.constructor=L;f=L.prototype;f.o=function(){return this.k};f.H=function(){return"Some"};f.G=function(){return 1};f.I=function(a){return 0===a?this.k:$K(W(),a)};f.D=function(a){return a instanceof L};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){return this===a?!0:a instanceof L?ml(nl(),this.k,a.k):!1};f.$classData=q({n3:0},!1,"scala.Some",{n3:1,b3:1,g:1,M:1,E:1,v:1,l:1});class NQ extends SZ{constructor(a,b){super();At(tp(),0<=b&&b<a.length);var c=b===(-1+a.length|0)?"at terminal":"'\\"+hc(a.charCodeAt(1+b|0))+"' not one of [\\b, \\t, \\n, \\f, \\r, \\\\, \\\", \\', \\uxxxx] at";yF(this,"invalid escape "+c+" index "+b+' in "'+a+'". Use \\\\ for literal \\.',null,!0)}}
+NQ.prototype.$classData=q({r3:0},!1,"scala.StringContext$InvalidEscapeException",{r3:1,ak:1,Te:1,qd:1,pc:1,g:1,l:1});class OQ extends SZ{constructor(a,b){super();yF(this,"invalid unicode escape at index "+b+" of "+a,null,!0)}}OQ.prototype.$classData=q({s3:0},!1,"scala.StringContext$InvalidUnicodeEscapeException",{s3:1,ak:1,Te:1,qd:1,pc:1,g:1,l:1});function PQ(a,b){this.w=this.y=null;this.xF=a;this.nJ=b;G(this,null,null)}PQ.prototype=new h0;PQ.prototype.constructor=PQ;f=PQ.prototype;f.aQ=function(){return this.xF};
+f.Sc=function(){return this.nJ};f.Cw=function(){return new n3(this.nJ,this.xF)};f.iy=function(){return hc(this.xF)};f.j=function(){return this.nJ};f.h=function(){return hc(this.xF)};f.$classData=q({E0:0},!1,"scala.Tuple2$mcCI$sp",{E0:1,by:1,g:1,LB:1,E:1,v:1,l:1});function n3(a,b){this.w=this.y=null;this.yF=a;this.$P=b;G(this,null,null)}n3.prototype=new h0;n3.prototype.constructor=n3;f=n3.prototype;f.ut=function(){return this.yF};f.Cw=function(){return new PQ(this.$P,this.yF)};f.iy=function(){return this.yF};
+f.j=function(){return hc(this.$P)};f.h=function(){return this.yF};f.$classData=q({F0:0},!1,"scala.Tuple2$mcIC$sp",{F0:1,by:1,g:1,LB:1,E:1,v:1,l:1});function Yt(a,b){this.w=this.y=null;this.AF=a;this.pJ=b;G(this,null,null)}Yt.prototype=new h0;Yt.prototype.constructor=Yt;f=Yt.prototype;f.ut=function(){return this.AF};f.cy=function(){return this.pJ};f.Cw=function(){return new o3(this.pJ,this.AF)};f.iy=function(){return this.AF};f.j=function(){return this.pJ};f.h=function(){return this.AF};
+f.$classData=q({H0:0},!1,"scala.Tuple2$mcIZ$sp",{H0:1,by:1,g:1,LB:1,E:1,v:1,l:1});function o3(a,b){this.w=this.y=null;this.BF=a;this.qJ=b;G(this,null,null)}o3.prototype=new h0;o3.prototype.constructor=o3;f=o3.prototype;f.Rc=function(){return this.BF};f.Sc=function(){return this.qJ};f.Cw=function(){return new Yt(this.qJ,this.BF)};f.iy=function(){return this.BF};f.j=function(){return this.qJ};f.h=function(){return this.BF};
+f.$classData=q({I0:0},!1,"scala.Tuple2$mcZI$sp",{I0:1,by:1,g:1,LB:1,E:1,v:1,l:1});function p3(){}p3.prototype=new p;p3.prototype.constructor=p3;function q3(){}f=q3.prototype=p3.prototype;f.Ub=function(){return DK()};f.Ih=function(){return this.Oc()};f.Oc=function(){return"Iterable"};f.u=function(){return w0(this)};f.Gk=function(a){return this.Ub().Ib(a)};f.ti=function(){return this.Ub().Eb()};f.e=function(){return this.m().t()};f.Mc=function(){return yT(this)};f.$k=function(a){return iv(this,a)};
+f.Fk=function(a){return this.vc(new r3(this,a,!1))};f.BK=function(a){var b=new r3(this,a,!0);return G(new H,this.vc(new r3(this,a,!1)),this.vc(b))};f.Jc=function(a){return zT(this,a)};f.Bb=function(a){return this.vc(s3(new t3,this,a))};f.f=function(){return CT(this)};f.MJ=function(){if(this.b())throw DT();return this.Bb(1)};f.Ja=function(a){return FT(this,a)};f.tl=function(a){return IT(this,a)};f.Gb=function(a){return KT(this,a)};f.Ca=function(a){cH(this,a)};f.ul=function(a){return nw(this,a)};
+f.qo=function(a){return ey(this,a)};f.De=function(a,b){return mB(this,a,b)};f.mf=function(a,b){return Qu(this,a,b)};f.th=function(a){return eH(this,a)};f.b=function(){return!this.m().s()};f.ka=function(){return hs(this)};f.Gc=function(a,b,c){return NB(this,a,b,c)};f.aj=function(a){return gH(this,a)};f.$i=function(a){return hH(this,a)};f.Gh=function(a,b,c,d){return iH(this,a,b,c,d)};f.ha=function(){Od();return Pd(u(),this)};f.Ti=function(){return pp(qp(),this)};f.FC=function(){return v1(EK(),this)};
+f.Bj=function(a){return kB(this,a)};f.ad=function(){return er(this)};f.Q=function(){return-1};f.vc=function(a){return this.Gk(a)};function Du(a,b){a.tn=b;a.wc=0;a.Al=wG(xG(),a.tn);return a}function Eu(){this.tn=null;this.Al=this.wc=0}Eu.prototype=new BY;Eu.prototype.constructor=Eu;function u3(){}f=u3.prototype=Eu.prototype;f.Q=function(){return this.Al-this.wc|0};f.s=function(){return this.wc<this.Al};
+f.t=function(){try{var a=XG(xG(),this.tn,this.wc);this.wc=1+this.wc|0;return a}catch(b){if(b instanceof dI)return Rq().Pa.t();throw b;}};f.ph=function(a){if(0<a){a=this.wc+a|0;if(0>a)a=this.Al;else{var b=this.Al;a=b<a?b:a}this.wc=a}return this};f.$classData=q({Qp:0},!1,"scala.collection.ArrayOps$ArrayIterator",{Qp:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});function Kr(a,b){a.UK=b;a.Er=0;a.bk=b.K();return a}function Lr(){this.UK=null;this.bk=this.Er=0}Lr.prototype=new BY;Lr.prototype.constructor=Lr;
+function v3(){}f=v3.prototype=Lr.prototype;f.Q=function(){return this.bk};f.s=function(){return 0<this.bk};f.t=function(){if(0<this.bk){var a=this.UK.va(this.Er);this.Er=1+this.Er|0;this.bk=-1+this.bk|0;return a}return Rq().Pa.t()};f.ph=function(a){0<a&&(this.Er=this.Er+a|0,a=this.bk-a|0,this.bk=0>a?0:a);return this};f.qk=function(a,b){a=0>a?0:a>this.bk?this.bk:a;b=(0>b?0:b>this.bk?this.bk:b)-a|0;this.bk=0>b?0:b;this.Er=this.Er+a|0;return this};
+f.$classData=q({CR:0},!1,"scala.collection.IndexedSeqView$IndexedSeqViewIterator",{CR:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});function uZ(a,b){a.VK=b;a.zj=b.K();a.Kv=-1+a.zj|0;return a}function vZ(){this.VK=null;this.Kv=this.zj=0}vZ.prototype=new BY;vZ.prototype.constructor=vZ;function w3(){}w3.prototype=vZ.prototype;vZ.prototype.s=function(){return 0<this.zj};vZ.prototype.t=function(){if(0<this.zj){var a=this.VK.va(this.Kv);this.Kv=-1+this.Kv|0;this.zj=-1+this.zj|0;return a}return Rq().Pa.t()};
+vZ.prototype.qk=function(a,b){0<this.zj&&(this.zj<=a?this.zj=0:0>=a?0<=b&&b<this.zj&&(this.zj=b):(this.Kv=this.Kv-a|0,this.zj=0<=b&&b<this.zj?b<=a?0:b-a|0:this.zj-a|0));return this};vZ.prototype.$classData=q({DR:0},!1,"scala.collection.IndexedSeqView$IndexedSeqViewReverseIterator",{DR:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});function TT(){this.wC=null;this.wC=Rq().Pa}TT.prototype=new e2;TT.prototype.constructor=TT;function pfa(a,b){a.wC=a.wC.nb(new U(()=>{Rq();return new g0(b)}));return a}
+TT.prototype.$=function(a){return pfa(this,a)};TT.prototype.$classData=q({m5:0},!1,"scala.collection.Iterator$$anon$21",{m5:1,Vba:1,g:1,Po:1,xg:1,xf:1,wf:1});function Ex(a,b){this.JR=null;this.Ay=0;this.KR=this.$K=null;if(null===a)throw null;this.$K=a;this.KR=b;this.Ay=0}Ex.prototype=new BY;Ex.prototype.constructor=Ex;f=Ex.prototype;f.u=function(){return"\x3cfunction1\x3e"};f.n=function(){return fL()};
+f.s=function(){for(var a=fL();0===this.Ay;)if(this.$K.s()){var b=this.$K.t();b=this.KR.Ob(b,this);a!==b&&(this.JR=b,this.Ay=1)}else this.Ay=-1;return 1===this.Ay};f.t=function(){return this.s()?(this.Ay=0,this.JR):Rq().Pa.t()};f.$classData=q({q5:0},!1,"scala.collection.Iterator$$anon$7",{q5:1,Sa:1,g:1,Ka:1,M:1,N:1,la:1});function x3(a,b,c){a=a.U(b);if(a instanceof L)return a.k;if(R()===a)return Es(c);throw new w(a);}
+function HA(a,b){var c=a.U(b);if(R()===c)return a.IF(b);if(c instanceof L)return c.k;throw new w(c);}function y3(a,b,c){return a.Se(b,new U(()=>c.n(b)))}function z3(a){throw AH("key not found: "+a);}function A3(a,b){var c=a.vj();a=Fs(b)?new JT(a,b):a.m().nb(new U(()=>b.m()));return c.Ib(a)}function B3(a,b,c,d,e){a=a.m();a=new Ef(a,new y(g=>{if(null!==g)return g.h()+" -\x3e "+g.j();throw new w(g);}));return iH(a,b,c,d,e)}function C3(){this.Mt=null;this.Mt=uv()}C3.prototype=new L0;
+C3.prototype.constructor=C3;C3.prototype.$classData=q({e6:0},!1,"scala.collection.SortedSet$",{e6:1,Y5:1,V4:1,g:1,oG:1,l:1,dS:1});var D3;function E3(a,b){var c=a.ti(),d=Vn();for(a=a.m();a.s();){var e=a.t();d.oh(b.n(e))&&c.$(e)}return c.Kb()}function F3(a,b){var c=a.Ik().Eb();0<=a.Q()&&c.he(1+a.K()|0);c.$(b);c.zc(a);return c.Kb()}function Xq(a,b){var c=a.Ik().Eb();0<=a.Q()&&c.he(1+a.K()|0);c.zc(a);c.$(b);return c.Kb()}function G3(a,b){var c=a.Ik().Eb();c.zc(a);c.zc(b);return c.Kb()}
+function H3(){this.FL=this.iS=null;this.EL=!1;I3=this;this.FL=new i0(this)}H3.prototype=new p;H3.prototype.constructor=H3;function J3(a,b){return a instanceof K3?a:KQ(0,rQ(SG(),a,b))}f=H3.prototype;f.sy=function(a){var b=new DF;return new dU(b,new y(c=>KQ(JQ(),kB(c,a))))};
+function KQ(a,b){if(null===b)return null;if(b instanceof zc)return new Fu(b);if(b instanceof Xc)return new L3(b);if(b instanceof ed)return new M3(b);if(b instanceof Zc)return new N3(b);if(b instanceof $c)return new O3(b);if(b instanceof Ic)return new P3(b);if(b instanceof Pc)return new Q3(b);if(b instanceof Sc)return new R3(b);if(b instanceof Ec)return new S3(b);if(ph(b))return new T3(b);throw new w(b);}f.GB=function(a){return this.sy(a)};f.pr=function(a,b){return J3(a,b)};
+f.ng=function(){this.EL||this.EL||(this.iS=new Fu(new zc(0)),this.EL=!0);return this.iS};f.$classData=q({G6:0},!1,"scala.collection.immutable.ArraySeq$",{G6:1,g:1,f6:1,T4:1,S4:1,oG:1,l:1});var I3;function JQ(){I3||(I3=new H3);return I3}function ZJ(a){return!!(a&&a.$classData&&a.$classData.rb.xc)}function U3(a){this.Yp=0;this.Vt=null;$0(this,a)}U3.prototype=new b1;U3.prototype.constructor=U3;U3.prototype.wj=function(a,b){return G(new H,a,b)};
+U3.prototype.$classData=q({y7:0},!1,"scala.collection.immutable.Map$Map2$$anon$1",{y7:1,qS:1,Sa:1,g:1,Ka:1,M:1,N:1});function V3(a){this.Yp=0;this.Vt=null;$0(this,a)}V3.prototype=new b1;V3.prototype.constructor=V3;V3.prototype.wj=function(a){return a};V3.prototype.$classData=q({z7:0},!1,"scala.collection.immutable.Map$Map2$$anon$2",{z7:1,qS:1,Sa:1,g:1,Ka:1,M:1,N:1});function W3(a){this.Yp=0;this.Vt=null;$0(this,a)}W3.prototype=new b1;W3.prototype.constructor=W3;W3.prototype.wj=function(a,b){return b};
+W3.prototype.$classData=q({A7:0},!1,"scala.collection.immutable.Map$Map2$$anon$3",{A7:1,qS:1,Sa:1,g:1,Ka:1,M:1,N:1});function X3(a){this.$p=0;this.Zp=null;c1(this,a)}X3.prototype=new e1;X3.prototype.constructor=X3;X3.prototype.wj=function(a,b){return G(new H,a,b)};X3.prototype.$classData=q({C7:0},!1,"scala.collection.immutable.Map$Map3$$anon$4",{C7:1,rS:1,Sa:1,g:1,Ka:1,M:1,N:1});function Y3(a){this.$p=0;this.Zp=null;c1(this,a)}Y3.prototype=new e1;Y3.prototype.constructor=Y3;Y3.prototype.wj=function(a){return a};
+Y3.prototype.$classData=q({D7:0},!1,"scala.collection.immutable.Map$Map3$$anon$5",{D7:1,rS:1,Sa:1,g:1,Ka:1,M:1,N:1});function Z3(a){this.$p=0;this.Zp=null;c1(this,a)}Z3.prototype=new e1;Z3.prototype.constructor=Z3;Z3.prototype.wj=function(a,b){return b};Z3.prototype.$classData=q({E7:0},!1,"scala.collection.immutable.Map$Map3$$anon$6",{E7:1,rS:1,Sa:1,g:1,Ka:1,M:1,N:1});function $3(a){this.aq=0;this.zn=null;f1(this,a)}$3.prototype=new h1;$3.prototype.constructor=$3;
+$3.prototype.wj=function(a,b){return G(new H,a,b)};$3.prototype.$classData=q({G7:0},!1,"scala.collection.immutable.Map$Map4$$anon$7",{G7:1,sS:1,Sa:1,g:1,Ka:1,M:1,N:1});function a4(a){this.aq=0;this.zn=null;f1(this,a)}a4.prototype=new h1;a4.prototype.constructor=a4;a4.prototype.wj=function(a){return a};a4.prototype.$classData=q({H7:0},!1,"scala.collection.immutable.Map$Map4$$anon$8",{H7:1,sS:1,Sa:1,g:1,Ka:1,M:1,N:1});function b4(a){this.aq=0;this.zn=null;f1(this,a)}b4.prototype=new h1;
+b4.prototype.constructor=b4;b4.prototype.wj=function(a,b){return b};b4.prototype.$classData=q({I7:0},!1,"scala.collection.immutable.Map$Map4$$anon$9",{I7:1,sS:1,Sa:1,g:1,Ka:1,M:1,N:1});function hE(a,b,c,d){this.nC=b;this.Wy=c;this.fw=!d;this.Vy=a}hE.prototype=new BY;hE.prototype.constructor=hE;f=hE.prototype;f.Q=function(){return this.fw?1+pb(this.Wy-this.Vy|0,this.nC)|0:0};f.s=function(){return this.fw};function c4(a){a.fw||Rq().Pa.t();var b=a.Vy;a.fw=b!==a.Wy;a.Vy=b+a.nC|0;return b}
+f.ph=function(a){if(0<a){var b=this.Vy,c=b>>31;a=Math.imul(this.nC,a);var d=a>>31;a=b+a|0;b=(-2147483648^a)<(-2147483648^b)?1+(c+d|0)|0:c+d|0;0<this.nC?(c=this.Wy,d=c>>31,this.Vy=(d===b?(-2147483648^c)<(-2147483648^a):d<b)?c:a,c=this.Wy,d=c>>31,this.fw=b===d?(-2147483648^a)<=(-2147483648^c):b<d):0>this.nC&&(c=this.Wy,d=c>>31,this.Vy=(d===b?(-2147483648^c)>(-2147483648^a):d>b)?c:a,c=this.Wy,d=c>>31,this.fw=b===d?(-2147483648^a)>=(-2147483648^c):b>d)}return this};f.t=function(){return c4(this)};
+f.$classData=q({$7:0},!1,"scala.collection.immutable.RangeIterator",{$7:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});function d4(a,b,c){this.Cn=this.hw=this.Xy=null;this.Wd=0;this.Hc=null;q1(this,a,b,c)}d4.prototype=new t1;d4.prototype.constructor=d4;d4.prototype.yK=function(a){return G(new H,a.Wa,a.Wb)};d4.prototype.$classData=q({b8:0},!1,"scala.collection.immutable.RedBlackTree$EntriesIterator",{b8:1,zS:1,Sa:1,g:1,Ka:1,M:1,N:1});
+function e4(a,b){this.Cn=this.hw=this.Xy=null;this.Wd=0;this.Hc=null;q1(this,a,R(),b)}e4.prototype=new t1;e4.prototype.constructor=e4;e4.prototype.yK=function(){no()};e4.prototype.$classData=q({c8:0},!1,"scala.collection.immutable.RedBlackTree$EqualsIterator",{c8:1,zS:1,Sa:1,g:1,Ka:1,M:1,N:1});function f4(a,b,c){this.Cn=this.hw=this.Xy=null;this.Wd=0;this.Hc=null;q1(this,a,b,c)}f4.prototype=new t1;f4.prototype.constructor=f4;f4.prototype.yK=function(a){return a.Wa};
+f4.prototype.$classData=q({d8:0},!1,"scala.collection.immutable.RedBlackTree$KeysIterator",{d8:1,zS:1,Sa:1,g:1,Ka:1,M:1,N:1});function g4(){this.Dn=this.Io=0}g4.prototype=new BY;g4.prototype.constructor=g4;function h4(){}h4.prototype=g4.prototype;g4.prototype.Q=function(){return this.Dn};g4.prototype.s=function(){return 0<this.Dn};g4.prototype.t=function(){if(this.s()){var a=this.va(this.Io);this.Io=1+this.Io|0;this.Dn=-1+this.Dn|0;return a}return Rq().Pa.t()};
+g4.prototype.ph=function(a){0<a&&(this.Io=this.Io+a|0,a=this.Dn-a|0,this.Dn=0>a?0:a);return this};function i4(){this.Mt=null;this.Mt=zZ()}i4.prototype=new L0;i4.prototype.constructor=i4;function oA(a,b,c){if(b&&b.$classData&&b.$classData.rb.OL){O();var d=b.se();if(null===c?null===d:c.i(d))return b}return tT.prototype.pr.call(a,b,c)}i4.prototype.pr=function(a,b){return oA(this,a,b)};i4.prototype.$classData=q({C8:0},!1,"scala.collection.immutable.SortedSet$",{C8:1,Y5:1,V4:1,g:1,oG:1,l:1,dS:1});var j4;
+function uv(){j4||(j4=new i4);return j4}function k4(){}k4.prototype=new p;k4.prototype.constructor=k4;function l4(){}l4.prototype=k4.prototype;k4.prototype.he=function(){};function m4(){this.SL=this.TL=null;n4=this;this.TL=new i0(this);this.SL=new zQ(new zc(0))}m4.prototype=new p;m4.prototype.constructor=m4;f=m4.prototype;f.sy=function(a){a=new o4(a.uh());return new dU(a,new y(b=>p4(yQ(),b)))};
+function p4(a,b){if(null===b)return null;if(b instanceof zc)return new zQ(b);if(b instanceof Xc)return new q4(b);if(b instanceof ed)return new r4(b);if(b instanceof Zc)return new s4(b);if(b instanceof $c)return new t4(b);if(b instanceof Ic)return new AQ(b);if(b instanceof Pc)return new u4(b);if(b instanceof Sc)return new v4(b);if(b instanceof Ec)return new w4(b);if(ph(b))return new x4(b);throw new w(b);}f.GB=function(a){return this.sy(a)};f.pr=function(a,b){return p4(0,rQ(SG(),a,b))};f.ng=function(){return this.SL};
+f.$classData=q({j9:0},!1,"scala.collection.mutable.ArraySeq$",{j9:1,g:1,f6:1,T4:1,S4:1,oG:1,l:1});var n4;function yQ(){n4||(n4=new m4);return n4}function y4(a){this.hq=0;this.Lo=null;this.vw=0;this.uw=null;Y1(this,a)}y4.prototype=new $1;y4.prototype.constructor=y4;y4.prototype.lB=function(a){return G(new H,a.Wk,a.Ah)};y4.prototype.$classData=q({G9:0},!1,"scala.collection.mutable.HashMap$$anon$1",{G9:1,fH:1,Sa:1,g:1,Ka:1,M:1,N:1});
+function z4(a){this.hq=0;this.Lo=null;this.vw=0;this.uw=null;Y1(this,a)}z4.prototype=new $1;z4.prototype.constructor=z4;z4.prototype.lB=function(a){return a.Wk};z4.prototype.$classData=q({H9:0},!1,"scala.collection.mutable.HashMap$$anon$2",{H9:1,fH:1,Sa:1,g:1,Ka:1,M:1,N:1});function A4(a){this.hq=0;this.Lo=null;this.vw=0;this.uw=null;Y1(this,a)}A4.prototype=new $1;A4.prototype.constructor=A4;A4.prototype.lB=function(a){return a.Ah};
+A4.prototype.$classData=q({I9:0},!1,"scala.collection.mutable.HashMap$$anon$3",{I9:1,fH:1,Sa:1,g:1,Ka:1,M:1,N:1});function B4(a){this.hq=0;this.Lo=null;this.vw=0;this.uw=null;Y1(this,a)}B4.prototype=new $1;B4.prototype.constructor=B4;B4.prototype.lB=function(a){return a};B4.prototype.$classData=q({J9:0},!1,"scala.collection.mutable.HashMap$$anon$4",{J9:1,fH:1,Sa:1,g:1,Ka:1,M:1,N:1});
+function C4(a){this.hq=0;this.Lo=null;this.vw=0;this.uw=null;this.WL=0;if(null===a)throw null;Y1(this,a);this.WL=0}C4.prototype=new $1;C4.prototype.constructor=C4;C4.prototype.B=function(){return this.WL};C4.prototype.lB=function(a){var b=BL(),c=a.mk;a=a.Ah;this.WL=pS(b,c^(c>>>16|0),My(W(),a));return this};C4.prototype.$classData=q({K9:0},!1,"scala.collection.mutable.HashMap$$anon$5",{K9:1,fH:1,Sa:1,g:1,Ka:1,M:1,N:1});function D4(a){this.iu=0;this.Ur=null;this.vC=0;this.uC=null;a2(this,a)}
+D4.prototype=new c2;D4.prototype.constructor=D4;D4.prototype.DJ=function(a){return a.xm};D4.prototype.$classData=q({P9:0},!1,"scala.collection.mutable.HashSet$$anon$1",{P9:1,RS:1,Sa:1,g:1,Ka:1,M:1,N:1});function E4(a){this.iu=0;this.Ur=null;this.vC=0;this.uC=null;a2(this,a)}E4.prototype=new c2;E4.prototype.constructor=E4;E4.prototype.DJ=function(a){return a};E4.prototype.$classData=q({Q9:0},!1,"scala.collection.mutable.HashSet$$anon$2",{Q9:1,RS:1,Sa:1,g:1,Ka:1,M:1,N:1});
+function F4(a){this.iu=0;this.Ur=null;this.vC=0;this.uC=null;this.XL=0;if(null===a)throw null;a2(this,a);this.XL=0}F4.prototype=new c2;F4.prototype.constructor=F4;F4.prototype.B=function(){return this.XL};F4.prototype.DJ=function(a){this.XL=G4(a.nk);return this};F4.prototype.$classData=q({R9:0},!1,"scala.collection.mutable.HashSet$$anon$3",{R9:1,RS:1,Sa:1,g:1,Ka:1,M:1,N:1});function H4(a,b,c,d){this.iq=this.DC=this.fz=null;r2(this,a,b,c,d)}H4.prototype=new t2;H4.prototype.constructor=H4;
+H4.prototype.zK=function(a){return G(new H,a.Oo,a.Vr)};H4.prototype.$classData=q({u$:0},!1,"scala.collection.mutable.RedBlackTree$EntriesIterator",{u$:1,iT:1,Sa:1,g:1,Ka:1,M:1,N:1});function I4(a,b,c,d){this.iq=this.DC=this.fz=null;r2(this,a,b,c,d)}I4.prototype=new t2;I4.prototype.constructor=I4;I4.prototype.zK=function(a){return a.Oo};I4.prototype.$classData=q({v$:0},!1,"scala.collection.mutable.RedBlackTree$KeysIterator",{v$:1,iT:1,Sa:1,g:1,Ka:1,M:1,N:1});
+function J4(a,b,c,d){this.iq=this.DC=this.fz=null;r2(this,a,b,c,d)}J4.prototype=new t2;J4.prototype.constructor=J4;J4.prototype.zK=function(a){return a.Vr};J4.prototype.$classData=q({y$:0},!1,"scala.collection.mutable.RedBlackTree$ValuesIterator",{y$:1,iT:1,Sa:1,g:1,Ka:1,M:1,N:1});function Uu(a,b){this.z3=b}Uu.prototype=new p;Uu.prototype.constructor=Uu;f=Uu.prototype;f.uj=function(a,b){return 0>=this.Da(a,b)};f.Yj=function(a,b){return 0<=this.Da(a,b)};f.Xj=function(a,b){return 0<this.Da(a,b)};
+f.Yi=function(a,b){return x2(this,a,b)};f.Jk=function(a,b){return y2(this,a,b)};f.Kk=function(a,b){return z2(this,a,b)};f.sj=function(a){return A2(this,a)};f.Da=function(a,b){return oa(this.z3.n(a),b)};f.$classData=q({y3:0},!1,"scala.math.LowPriorityOrderingImplicits$$anon$2",{y3:1,g:1,lm:1,Ji:1,mm:1,km:1,l:1});function RY(a,b){this.MK=this.rR=null;if(null===a)throw null;this.rR=a;this.MK=b}RY.prototype=new p;RY.prototype.constructor=RY;f=RY.prototype;f.uj=function(a,b){return 0>=this.Da(a,b)};
+f.Yj=function(a,b){return 0<=this.Da(a,b)};f.Xj=function(a,b){return 0<this.Da(a,b)};f.Yi=function(a,b){return x2(this,a,b)};f.Jk=function(a,b){return y2(this,a,b)};f.Kk=function(a,b){return z2(this,a,b)};f.sj=function(a){return A2(this,a)};f.Da=function(a,b){return this.rR.Da(this.MK.n(a),this.MK.n(b))};f.$classData=q({F3:0},!1,"scala.math.Ordering$$anon$1",{F3:1,g:1,lm:1,Ji:1,mm:1,km:1,l:1});function OD(a,b){this.iG=a;this.It=b}OD.prototype=new p;OD.prototype.constructor=OD;f=OD.prototype;
+f.Yi=function(a,b){return x2(this,a,b)};f.Jk=function(a,b){return y2(this,a,b)};f.Kk=function(a,b){return z2(this,a,b)};f.sj=function(a){return A2(this,a)};f.Da=function(a,b){return this.iG.Da(this.It.n(a),this.It.n(b))};f.Xj=function(a,b){return this.iG.Xj(this.It.n(a),this.It.n(b))};f.Yj=function(a,b){return this.iG.Yj(this.It.n(a),this.It.n(b))};f.uj=function(a,b){return this.iG.uj(this.It.n(a),this.It.n(b))};
+f.$classData=q({G3:0},!1,"scala.math.Ordering$$anon$5",{G3:1,g:1,lm:1,Ji:1,mm:1,km:1,l:1});function B2(a){this.sn=a}B2.prototype=new p;B2.prototype.constructor=B2;f=B2.prototype;f.sj=function(a){var b=this.sn;return null===a?null===b:a.i(b)};f.Da=function(a,b){return this.sn.Da(b,a)};f.uj=function(a,b){return this.sn.uj(b,a)};f.Yj=function(a,b){return this.sn.Yj(b,a)};f.Xj=function(a,b){return this.sn.Xj(b,a)};f.Yi=function(a,b){return this.sn.Yi(b,a)};f.Jk=function(a,b){return this.sn.Kk(a,b)};
+f.Kk=function(a,b){return this.sn.Jk(a,b)};f.i=function(a){if(null!==a&&this===a)return!0;if(a instanceof B2){var b=this.sn;a=a.sn;return null===b?null===a:b.i(a)}return!1};f.B=function(){return Math.imul(41,this.sn.B())};f.$classData=q({N3:0},!1,"scala.math.Ordering$Reverse",{N3:1,g:1,lm:1,Ji:1,mm:1,km:1,l:1});function eT(a,b){this.jG=a;this.kG=b}eT.prototype=new p;eT.prototype.constructor=eT;f=eT.prototype;f.uj=function(a,b){return 0>=this.Da(a,b)};f.Yj=function(a,b){return 0<=this.Da(a,b)};
+f.Xj=function(a,b){return 0<this.Da(a,b)};f.Yi=function(a,b){return x2(this,a,b)};f.Jk=function(a,b){return y2(this,a,b)};f.Kk=function(a,b){return z2(this,a,b)};f.sj=function(a){return A2(this,a)};f.i=function(a){if(null!==a&&this===a)return!0;if(a instanceof eT){var b=this.jG,c=a.jG;if(null===b?null===c:b.i(c))return b=this.kG,a=a.kG,null===b?null===a:b.i(a)}return!1};
+f.B=function(){var a=this.jG,b=this.kG,c=BL();var d=c.C(-889275714,lb("Tuple2"));for(var e=0;2>e;){var g=e;switch(g){case 0:g=a;break;case 1:g=b;break;default:throw aL(new bL,g+" is out of bounds (min 0, max 1)");}d=c.C(d,My(W(),g));e=1+e|0}return c.Ma(d,2)};f.Da=function(a,b){var c=this.jG.Da(a.h(),b.h());return 0!==c?c:this.kG.Da(a.j(),b.j())};f.$classData=q({Q3:0},!1,"scala.math.Ordering$Tuple2Ordering",{Q3:1,g:1,lm:1,Ji:1,mm:1,km:1,l:1});function jB(a){this.lG=a}jB.prototype=new p;
+jB.prototype.constructor=jB;f=jB.prototype;f.D=function(a){return!!(a&&a.$classData&&a.$classData.rb.Lk)};f.i=function(a){if(a&&a.$classData&&a.$classData.rb.Lk){var b=this.uh();a=a.uh();b=b===a}else b=!1;return b};f.B=function(){var a=this.lG;return My(W(),a)};f.u=function(){return nfa(this,this.lG)};f.uh=function(){return this.lG};f.si=function(a){var b=this.lG;return rh(th(),b,a)};f.$classData=q({V3:0},!1,"scala.reflect.ClassTag$GenericClassTag",{V3:1,g:1,Lk:1,nm:1,pm:1,l:1,v:1});
+function K4(){}K4.prototype=new RZ;K4.prototype.constructor=K4;function L4(){}L4.prototype=K4.prototype;K4.prototype.uJ=function(a){a=null===a?"null":nb(a);ff(this,null===a?"null":a)};class GM extends N2{constructor(a){super();this.K1=a;yF(this,null,null,!0);if(null===a)throw le();}qj(){return"Flags \x3d '"+this.K1+"'"}}GM.prototype.$classData=q({J1:0},!1,"java.util.DuplicateFormatFlagsException",{J1:1,Np:1,ak:1,Te:1,qd:1,pc:1,g:1,l:1});
+class IW extends N2{constructor(a,b){super();this.N1=a;this.M1=b;yF(this,null,null,!0);if(null===a)throw le();}qj(){return"Conversion \x3d "+hc(this.M1)+", Flags \x3d "+this.N1}}IW.prototype.$classData=q({L1:0},!1,"java.util.FormatFlagsConversionMismatchException",{L1:1,Np:1,ak:1,Te:1,qd:1,pc:1,g:1,l:1});class OM extends N2{constructor(a){super();this.d2=a;yF(this,null,null,!0)}qj(){return this.d2}}
+OM.prototype.$classData=q({c2:0},!1,"java.util.IllegalFormatArgumentIndexException",{c2:1,Np:1,ak:1,Te:1,qd:1,pc:1,g:1,l:1});class SM extends N2{constructor(a){super();this.f2=a;yF(this,null,null,!0)}qj(){return"Code point \x3d 0x"+(+(this.f2>>>0)).toString(16)}}SM.prototype.$classData=q({e2:0},!1,"java.util.IllegalFormatCodePointException",{e2:1,Np:1,ak:1,Te:1,qd:1,pc:1,g:1,l:1});
+class JW extends N2{constructor(a,b){super();this.i2=a;this.h2=b;yF(this,null,null,!0);if(null===b)throw le();}qj(){return String.fromCharCode(this.i2)+" !\x3d "+this.h2.qi.name}}JW.prototype.$classData=q({g2:0},!1,"java.util.IllegalFormatConversionException",{g2:1,Np:1,ak:1,Te:1,qd:1,pc:1,g:1,l:1});class HW extends N2{constructor(a){super();this.k2=a;yF(this,null,null,!0);if(null===a)throw le();}qj(){return"Flags \x3d '"+this.k2+"'"}}
+HW.prototype.$classData=q({j2:0},!1,"java.util.IllegalFormatFlagsException",{j2:1,Np:1,ak:1,Te:1,qd:1,pc:1,g:1,l:1});class GW extends N2{constructor(a){super();this.m2=a;yF(this,null,null,!0)}qj(){return""+this.m2}}GW.prototype.$classData=q({l2:0},!1,"java.util.IllegalFormatPrecisionException",{l2:1,Np:1,ak:1,Te:1,qd:1,pc:1,g:1,l:1});class IM extends N2{constructor(a){super();this.o2=a;yF(this,null,null,!0)}qj(){return""+this.o2}}
+IM.prototype.$classData=q({n2:0},!1,"java.util.IllegalFormatWidthException",{n2:1,Np:1,ak:1,Te:1,qd:1,pc:1,g:1,l:1});class PM extends N2{constructor(a){super();this.r2=a;yF(this,null,null,!0);if(null===a)throw le();}qj(){return"Format specifier '"+this.r2+"'"}}PM.prototype.$classData=q({q2:0},!1,"java.util.MissingFormatArgumentException",{q2:1,Np:1,ak:1,Te:1,qd:1,pc:1,g:1,l:1});
+class LM extends N2{constructor(a){super();this.t2=a;yF(this,null,null,!0);if(null===a)throw le();}qj(){return this.t2}}LM.prototype.$classData=q({s2:0},!1,"java.util.MissingFormatWidthException",{s2:1,Np:1,ak:1,Te:1,qd:1,pc:1,g:1,l:1});class FW extends N2{constructor(a){super();this.x2=a;yF(this,null,null,!0);if(null===a)throw le();}qj(){return"Conversion \x3d '"+this.x2+"'"}}FW.prototype.$classData=q({w2:0},!1,"java.util.UnknownFormatConversionException",{w2:1,Np:1,ak:1,Te:1,qd:1,pc:1,g:1,l:1});
+function M4(){this.ld="type alias"}M4.prototype=new XS;M4.prototype.constructor=M4;f=M4.prototype;f.H=function(){return"Als"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof M4};f.B=function(){return 65928};f.u=function(){return"Als"};f.$classData=q({OT:0},!1,"mlscript.Als$",{OT:1,EE:1,sz:1,sx:1,g:1,E:1,v:1,l:1});var N4;function Ap(){N4||(N4=new M4);return N4}
+function um(a,b,c){this.mz=null;this.oz=this.pz=0;this.qz=this.nz=null;this.Rn=0;this.Xo=a;this.Tn=b;this.Un=c;Nq(this)}um.prototype=new AS;um.prototype.constructor=um;f=um.prototype;f.H=function(){return"Case"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.Xo;case 1:return this.Tn;case 2:return this.Un;default:return $K(W(),a)}};f.D=function(a){return a instanceof um};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof um){var b=this.Xo,c=a.Xo;if(null===b?null===c:b.i(c))if(b=this.Tn,c=a.Tn,null===b?null===c:b.i(c))return b=this.Un,a=a.Un,null===b?null===a:b.i(a)}return!1};f.$classData=q({mU:0},!1,"mlscript.Case",{mU:1,yM:1,g:1,zM:1,Ta:1,E:1,v:1,l:1});function zP(a){a.Jw||(a.Kw=Faa(a),a.Jw=!0);return a.Kw}
+function cl(){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.Yo=!1;this.Kw=null;this.Jw=!1}cl.prototype=new M_;cl.prototype.constructor=cl;function O4(){}O4.prototype=cl.prototype;function fP(){this.SC=this.RC=null;this.UC=this.VC=0;this.WC=this.TC=null;this.cl=0}fP.prototype=new p;fP.prototype.constructor=fP;function P4(){}f=P4.prototype=fP.prototype;
+f.jb=function(){if(this instanceof No)var a="definition";else if(this instanceof Oo)a="type declaration";else throw new w(this);return a};f.Vj=function(){return eP(this)};f.Wr=function(){return Mx(this)};f.nv=function(){0===(1&this.cl)<<24>>24&&0===(1&this.cl)<<24>>24&&(this.RC=cP(this),this.cl=(1|this.cl)<<24>>24);return this.RC};f.jn=function(){0===(2&this.cl)<<24>>24&&0===(2&this.cl)<<24>>24&&(this.SC=zq(this),this.cl=(2|this.cl)<<24>>24);return this.SC};f.rn=function(){return this.VC};
+f.fm=function(a){this.VC=a};f.qn=function(){return this.UC};f.em=function(a){this.UC=a};f.pn=function(){return this.TC};f.on=function(a){this.TC=a};f.A=function(){0===(4&this.cl)<<24>>24&&0===(4&this.cl)<<24>>24&&(this.WC=Dq(this),this.cl=(4|this.cl)<<24>>24);return this.WC};
+class Ff extends Df{constructor(a,b,c){super();this.YC=b;this.wH=c;this.pq=a;yF(this,a,null,!0)}vt(){return this.YC}H(){return"ErrorReport"}G(){return 3}I(a){switch(a){case 0:return this.pq;case 1:return this.YC;case 2:return this.wH;default:return $K(W(),a)}}D(a){return a instanceof Ff}B(){return AL(this)}i(a){if(this===a)return!0;if(a instanceof Ff&&this.pq===a.pq){var b=this.YC,c=a.YC;return(null===b?null===c:b.i(c))?this.wH===a.wH:!1}return!1}}
+Ff.prototype.$classData=q({OU:0},!1,"mlscript.ErrorReport",{OU:1,IU:1,qd:1,pc:1,g:1,l:1,E:1,v:1});function $t(a){this.rs=null;this.ts=this.us=0;this.vs=this.ss=null;this.dl=0;this.ap=a;Nq(this)}$t.prototype=new CS;$t.prototype.constructor=$t;f=$t.prototype;f.H=function(){return"IfBlock"};f.G=function(){return 1};f.I=function(a){return 0===a?this.ap:$K(W(),a)};f.D=function(a){return a instanceof $t};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof $t){var b=this.ap;a=a.ap;return null===b?null===a:b.i(a)}return!1};f.$classData=q({$U:0},!1,"mlscript.IfBlock",{$U:1,uz:1,g:1,vz:1,Ta:1,E:1,v:1,l:1});function gu(a){this.rs=null;this.ts=this.us=0;this.vs=this.ss=null;this.dl=0;this.ws=a;Nq(this)}gu.prototype=new CS;gu.prototype.constructor=gu;f=gu.prototype;f.H=function(){return"IfElse"};f.G=function(){return 1};f.I=function(a){return 0===a?this.ws:$K(W(),a)};
+f.D=function(a){return a instanceof gu};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof gu){var b=this.ws;a=a.ws;return null===b?null===a:b.i(a)}return!1};f.$classData=q({aV:0},!1,"mlscript.IfElse",{aV:1,uz:1,g:1,vz:1,Ta:1,E:1,v:1,l:1});function Ss(a,b,c,d){this.rs=null;this.ts=this.us=0;this.vs=this.ss=null;this.dl=0;this.Qw=a;this.xu=b;this.yu=c;this.wu=d;Nq(this)}Ss.prototype=new CS;Ss.prototype.constructor=Ss;f=Ss.prototype;
+f.H=function(){return"IfLet"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.Qw;case 1:return this.xu;case 2:return this.yu;case 3:return this.wu;default:return $K(W(),a)}};f.D=function(a){return a instanceof Ss};f.B=function(){var a=lb("IfLet");a=W().C(-889275714,a);var b=this.Qw?1231:1237;a=W().C(a,b);b=this.xu;b=My(W(),b);a=W().C(a,b);b=this.yu;b=My(W(),b);a=W().C(a,b);b=this.wu;b=My(W(),b);a=W().C(a,b);return W().Ma(a,4)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Ss){if(this.Qw===a.Qw){var b=this.xu,c=a.xu;b=null===b?null===c:b.i(c)}else b=!1;if(b&&(b=this.yu,c=a.yu,null===b?null===c:b.i(c)))return b=this.wu,a=a.wu,null===b?null===a:b.i(a)}return!1};f.$classData=q({bV:0},!1,"mlscript.IfLet",{bV:1,uz:1,g:1,vz:1,Ta:1,E:1,v:1,l:1});function Tt(a,b,c){this.rs=null;this.ts=this.us=0;this.vs=this.ss=null;this.dl=0;this.Wn=a;this.Xn=b;this.Yn=c;Nq(this)}Tt.prototype=new CS;Tt.prototype.constructor=Tt;f=Tt.prototype;
+f.H=function(){return"IfOpApp"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.Wn;case 1:return this.Xn;case 2:return this.Yn;default:return $K(W(),a)}};f.D=function(a){return a instanceof Tt};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Tt){var b=this.Wn,c=a.Wn;if(null===b?null===c:b.i(c))if(b=this.Xn,c=a.Xn,null===b?null===c:b.i(c))return b=this.Yn,a=a.Yn,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({cV:0},!1,"mlscript.IfOpApp",{cV:1,uz:1,g:1,vz:1,Ta:1,E:1,v:1,l:1});function mu(a,b){this.rs=null;this.ts=this.us=0;this.vs=this.ss=null;this.dl=0;this.xs=a;this.ys=b;Nq(this)}mu.prototype=new CS;mu.prototype.constructor=mu;f=mu.prototype;f.H=function(){return"IfOpsApp"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.xs;case 1:return this.ys;default:return $K(W(),a)}};f.D=function(a){return a instanceof mu};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof mu){var b=this.xs,c=a.xs;if(null===b?null===c:b.i(c))return b=this.ys,a=a.ys,null===b?null===a:b.i(a)}return!1};f.$classData=q({dV:0},!1,"mlscript.IfOpsApp",{dV:1,uz:1,g:1,vz:1,Ta:1,E:1,v:1,l:1});function Ut(a,b){this.rs=null;this.ts=this.us=0;this.vs=this.ss=null;this.dl=0;this.Km=a;this.Lm=b;Nq(this)}Ut.prototype=new CS;Ut.prototype.constructor=Ut;f=Ut.prototype;f.H=function(){return"IfThen"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.Km;case 1:return this.Lm;default:return $K(W(),a)}};f.D=function(a){return a instanceof Ut};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Ut){var b=this.Km,c=a.Km;if(null===b?null===c:b.i(c))return b=this.Lm,a=a.Lm,null===b?null===a:b.i(a)}return!1};f.$classData=q({eV:0},!1,"mlscript.IfThen",{eV:1,uz:1,g:1,vz:1,Ta:1,E:1,v:1,l:1});function wn(a,b){this.nD=a;this.mD=b}wn.prototype=new ES;
+wn.prototype.constructor=wn;f=wn.prototype;f.xa=function(){var a=Sp(Qp(),"get "+zl(Al(),this.nD)+"() "),b=this.mD;if(b instanceof fe)b=b.aa,b=(new Io((t(),new L(b)))).xa();else{if(!(b instanceof Ud))throw new w(b);b=b.fa;for(var c=Qp().ye;!b.b();){var d=b.e();c=Iz(c,d.xa());b=b.f()}b=c}return Rp(a,Oz(b))};f.H=function(){return"JSClassGetter"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.nD;case 1:return this.mD;default:return $K(W(),a)}};
+f.D=function(a){return a instanceof wn};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof wn&&this.nD===a.nD){var b=this.mD;a=a.mD;return null===b?null===a:b.i(a)}return!1};f.$classData=q({EV:0},!1,"mlscript.JSClassGetter",{EV:1,FV:1,el:1,Xc:1,g:1,E:1,v:1,l:1});function vn(a,b,c){this.pD=a;this.qD=b;this.oD=c}vn.prototype=new ES;vn.prototype.constructor=vn;f=vn.prototype;
+f.xa=function(){var a=Rp(Rp(Sp(Qp(),zl(Al(),this.pD)),Op(Lp(),this.qD)),Qp().bA),b=this.oD;if(b instanceof fe)b=b.aa,b=(new Io((t(),new L(b)))).xa();else{if(!(b instanceof Ud))throw new w(b);b=b.fa;for(var c=Qp().ye;!b.b();){var d=b.e();c=Iz(c,d.xa());b=b.f()}b=c}return Rp(a,Oz(b))};f.H=function(){return"JSClassMethod"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.pD;case 1:return this.qD;case 2:return this.oD;default:return $K(W(),a)}};
+f.D=function(a){return a instanceof vn};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof vn&&this.pD===a.pD){var b=this.qD,c=a.qD;if(null===b?null===c:b.i(c))return b=this.oD,a=a.oD,null===b?null===a:b.i(a)}return!1};f.$classData=q({GV:0},!1,"mlscript.JSClassMethod",{GV:1,FV:1,el:1,Xc:1,g:1,E:1,v:1,l:1});function Q4(){this.ld="mixin"}Q4.prototype=new XS;Q4.prototype.constructor=Q4;f=Q4.prototype;f.H=function(){return"Mxn"};f.G=function(){return 0};
+f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof Q4};f.B=function(){return 77827};f.u=function(){return"Mxn"};f.$classData=q({GW:0},!1,"mlscript.Mxn$",{GW:1,EE:1,sz:1,sx:1,g:1,E:1,v:1,l:1});var R4;function cp(){R4||(R4=new Q4);return R4}function S4(){this.mz=null;this.oz=this.pz=0;this.qz=this.nz=null;this.Rn=0;Nq(this)}S4.prototype=new AS;S4.prototype.constructor=S4;f=S4.prototype;f.H=function(){return"NoCases"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};
+f.D=function(a){return a instanceof S4};f.B=function(){return-546441758};f.u=function(){return"NoCases"};f.$classData=q({VW:0},!1,"mlscript.NoCases$",{VW:1,yM:1,g:1,zM:1,Ta:1,E:1,v:1,l:1});var T4;function zm(){T4||(T4=new S4);return T4}function U4(a){Nq(a);if(a instanceof yo)var b=a.gb.Zr();else{if(!(a instanceof Zn))throw new w(a);b=a.Rb}a.Cf=b}function Ct(){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.sE=this.tE=this.Cf=null;this.gp=0}Ct.prototype=new ZS;
+Ct.prototype.constructor=Ct;function V4(){}V4.prototype=Ct.prototype;Ct.prototype.jb=function(){return cy(this)};Ct.prototype.Vj=function(){return eP(this)};Ct.prototype.Wr=function(){return Mx(this)};function Cp(a){0===(1&a.gp)<<24>>24&&0===(1&a.gp)<<24>>24&&(a.tE=gea(a),a.gp=(1|a.gp)<<24>>24);return a.tE}Ct.prototype.nv=function(){0===(2&this.gp)<<24>>24&&0===(2&this.gp)<<24>>24&&(this.sE=cP(this),this.gp=(2|this.gp)<<24>>24);return this.sE};
+function ax(a,b,c,d,e){this.nc=this.px=null;this.Ju=b;this.Rl=c;this.rk=d;this.Ql=e;MS(this,a,Ap())}ax.prototype=new NS;ax.prototype.constructor=ax;f=ax.prototype;f.Ea=function(){return this.Ju};f.Yr=function(){return this.Rl};f.Ag=function(){return this.rk};f.fd=function(){return this.Rl.pb};f.Ua=function(){return this.Rl.gb.V};f.cG=function(){return this.Rl.gb};f.aG=function(){return nf()};f.tr=function(){return!this.Rl.Hj.b()};f.Mp=function(){return!0};
+function qfa(a,b,c,d,e){var g=new Iw(d.S,d.Ec,d.hc,d.Ed,1+d.da|0,d.Pc,d.Zc,d.Lb,d.yc,d.tb,d.$a,d.od,d.cb),h=a.nc;d=d.da;var k=a.Rl,l=a.rk,m=x=>{var A=x.kc,B=x.hb.Kc(b,c,g,e);return new tl(A,hD(B),x.Rd)};if(l===u())m=u();else{var n=l.e(),r=n=new z(m(n),u());for(l=l.f();l!==u();){var v=l.e();v=new z(m(v),u());r=r.p=v;l=l.f()}m=n}return new ax(h,d,k,m,a.Ql.Kc(b,c,g,e))}
+function rfa(a,b,c){var d=a.nc,e=a.Ju,g=a.Rl,h=a.rk,k=r=>{var v=r.kc,x=c.ba(t().d,r.hb);return new tl(v,hD(x),r.Rd)};if(h===u())k=u();else{var l=h.e(),m=l=new z(k(l),u());for(h=h.f();h!==u();){var n=h.e();n=new z(k(n),u());m=m.p=n;h=h.f()}k=l}return new ax(d,e,g,k,c.ba(b,a.Ql))}
+function sfa(a,b,c){var d=a.nc,e=a.Ju,g=a.Rl,h=a.rk,k=r=>{var v=r.kc,x=c.ba(new TB(b),r.hb);return new tl(v,hD(x),r.Rd)};if(h===u())k=u();else{var l=h.e(),m=l=new z(k(l),u());for(h=h.f();h!==u();){var n=h.e();n=new z(k(n),u());m=m.p=n;h=h.f()}k=l}return new ax(d,e,g,k,c.ba(b,a.Ql))}f.H=function(){return"TypedNuAls"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.Ju;case 1:return this.Rl;case 2:return this.rk;case 3:return this.Ql;default:return $K(W(),a)}};
+f.D=function(a){return a instanceof ax};f.B=function(){var a=lb("TypedNuAls");a=W().C(-889275714,a);var b=this.Ju;a=W().C(a,b);b=this.Rl;b=My(W(),b);a=W().C(a,b);b=this.rk;b=My(W(),b);a=W().C(a,b);b=this.Ql;b=My(W(),b);a=W().C(a,b);return W().Ma(a,4)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof ax&&a.nc===this.nc){if(this.Ju===a.Ju){var b=this.Rl,c=a.Rl;b=null===b?null===c:b.i(c)}else b=!1;if(b&&(b=this.rk,c=a.rk,null===b?null===c:b.i(c)))return b=this.Ql,a=a.Ql,null===b?null===a:mC(b,a)}return!1};f.cm=function(a,b){return sfa(this,a,b)};f.yl=function(a,b,c){return rfa(this,a,c)};f.ro=function(a,b,c,d){return qfa(this,a,b,c,d)};f.$classData=q({zX:0},!1,"mlscript.NuTypeDefs$TypedNuAls",{zX:1,YH:1,g:1,Rs:1,nx:1,E:1,v:1,l:1});
+function By(a,b,c){this.q=null;this.xk=b;this.Ul=c;if(null===a)throw null;this.q=a}By.prototype=new fT;By.prototype.constructor=By;function dca(a,b,c){var d=a.q,e=a.xk;if(e===u())c=u();else{var g=e.e(),h=g=new z(cz(g,b,c),u());for(e=e.f();e!==u();){var k=e.e();k=new z(cz(k,b,c),u());h=h.p=k;e=e.f()}c=g}a=a.Ul;return new By(d,c,a.b()?R():new L(b.n(a.o())))}
+function wB(a,b,c,d){var e=a.q,g=a.xk;if(g===u())d=u();else{var h=g.e(),k=h=new z(h.yl(b,!0,c,d),u());for(g=g.f();g!==u();){var l=g.e();l=new z(l.yl(b,!0,c,d),u());k=k.p=l;g=g.f()}d=h}a=a.Ul;a.b()?b=R():(a=a.o(),b=new L(c.ba(b,a)));return new By(e,d,b)}
+function ica(a,b,c,d){var e=a.q,g=a.xk;if(g===u())d=u();else{var h=g.e(),k=h=new z(h.cm(b,c,d),u());for(g=g.f();g!==u();){var l=g.e();l=new z(l.cm(b,c,d),u());k=k.p=l;g=g.f()}d=h}a=a.Ul;a.b()?b=R():(a=a.o(),b=new L(c.ba(b,a)));return new By(e,d,b)}f=By.prototype;f.u=function(){var a=Xq(this.xk,this.Ul);return"TypedTypingUnit("+CF(GF(),a)+")"};f.H=function(){return"TypedTypingUnit"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.xk;case 1:return this.Ul;default:return $K(W(),a)}};f.D=function(a){return a instanceof By};f.B=function(){return AL(this)};f.i=function(a){if(this===a)return!0;if(a instanceof By&&a.q===this.q){var b=this.xk,c=a.xk;if(null===b?null===c:b.i(c))return b=this.Ul,a=a.Ul,null===b?null===a:b.i(a)}return!1};f.$classData=q({HX:0},!1,"mlscript.NuTypeDefs$TypedTypingUnit",{HX:1,Paa:1,Gg:1,g:1,Hg:1,E:1,v:1,l:1});
+function Cw(){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0}Cw.prototype=new d3;Cw.prototype.constructor=Cw;function W4(){}W4.prototype=Cw.prototype;
+class Gf extends Df{constructor(a,b,c){super();this.aF=b;this.YI=c;this.pq=a;yF(this,a,null,!0)}vt(){return this.aF}H(){return"WarningReport"}G(){return 3}I(a){switch(a){case 0:return this.pq;case 1:return this.aF;case 2:return this.YI;default:return $K(W(),a)}}D(a){return a instanceof Gf}B(){return AL(this)}i(a){if(this===a)return!0;if(a instanceof Gf&&this.pq===a.pq){var b=this.aF,c=a.aF;return(null===b?null===c:b.i(c))?this.YI===a.YI:!1}return!1}}
+Gf.prototype.$classData=q({h_:0},!1,"mlscript.WarningReport",{h_:1,IU:1,qd:1,pc:1,g:1,l:1,E:1,v:1});function ym(a){this.mz=null;this.oz=this.pz=0;this.qz=this.nz=null;this.Rn=0;this.dn=a;Nq(this)}ym.prototype=new AS;ym.prototype.constructor=ym;f=ym.prototype;f.H=function(){return"Wildcard"};f.G=function(){return 1};f.I=function(a){return 0===a?this.dn:$K(W(),a)};f.D=function(a){return a instanceof ym};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof ym){var b=this.dn;a=a.dn;return null===b?null===a:b.i(a)}return!1};f.$classData=q({l_:0},!1,"mlscript.Wildcard",{l_:1,yM:1,g:1,zM:1,Ta:1,E:1,v:1,l:1});function mn(a,b,c,d,e){this.TA=a;this.Tx=b;this.eJ=c;this.Sx=d;this.dJ=e}mn.prototype=new p;mn.prototype.constructor=mn;f=mn.prototype;f.xo=function(){return this.TA};f.zo=function(){return this.Tx};f.mv=function(){return this.Sx};f.u=function(){return"trait "+this.TA};f.H=function(){return"TraitSymbol"};
+f.G=function(){return 5};f.I=function(a){switch(a){case 0:return this.TA;case 1:return this.Tx;case 2:return this.eJ;case 3:return this.Sx;case 4:return this.dJ;default:return $K(W(),a)}};f.D=function(a){return a instanceof mn};f.B=function(){return AL(this)};f.i=function(a){if(this===a)return!0;if(a instanceof mn&&this.TA===a.TA&&this.Tx===a.Tx){var b=this.eJ,c=a.eJ;if(null===b?null===c:b.i(c))if(b=this.Sx,c=a.Sx,null===b?null===c:b.i(c))return b=this.dJ,a=a.dJ,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({C_:0},!1,"mlscript.codegen.TraitSymbol",{C_:1,g:1,UA:1,cr:1,mt:1,E:1,v:1,l:1});function X4(a,b){a.Hb&&Nx(a,b)}function tfa(a,b,c,d){a.Hb?Lx(a,b,c,d):Es(c)}function Y4(a){var b="tmp"+a.XA;a.XA=1+a.XA|0;return b}function Z4(a,b){for(var c=Y4(a);b.hc.L(c);)c=Y4(a);return c}function $4(a,b,c,d,e){e.Hk(a5(a,b,d),new U(()=>Xu().X()))}function ufa(a,b,c,d,e,g){g.Hk(a5(a,b,e),new U(()=>Xu().X())).Hk((t(),new fe(c)),new U(()=>TE(PE()))).zc(d)}
+function b5(a,b,c,d,e,g){g.Hk(a5(a,b,e),new U(()=>Xu().X())).Hk((t(),new Ud(c)),new U(()=>TE(PE()))).zc(d)}
+function c5(a,b,c,d,e,g){var h=TE(PE());c=c.m();d=new x0(c,d);d=new xo(d,new y(k=>{if(null!==k){var l=k.h(),m=k.j();if(l instanceof vl&&"_"===l.x)return t(),k=new vl("_"),k=G(new H,m,k),new L(k)}if(null!==k&&(m=k.h(),l=k.j(),m instanceof vl)){var n=m.x;n=Xz(Q(),n);n.b()?n=!1:(n=n.o(),n=Ea(n),n=bE(Pr(),n));if(n)return t(),k=G(new H,l,m),new L(k)}if(null!==k){var r=k.h();m=k.j();if(null!==r)return k=g.Hk(GE(b),new U(()=>Xu().X())).Hk(m,new U(()=>{var v=new vl(Z4(a,e));return OS(v,r)})),l=G(new H,k,
+r),h.$(l),t(),k=G(new H,m,k),new L(k)}throw new w(k);}));Od();d=Pd(u(),d);return G(new H,h.ha(),d)}function d5(a,b,c,d,e,g,h){c=c.m();c=new xo(c,new y(k=>{if(null!==k){var l=k.j();k=e5(a,k.h(),b.ZP,d);var m=O().c;return f5(a,k,l,!1,d,e,g,h,m)}throw new w(k);}));Od();return Pd(u(),c)}
+function e5(a,b,c,d){var e=()=>{if(b instanceof vl){if(a.Hb&&a.F){var l=ut(Q(),"| ",a.r)+"The scrutinee does not need an alias.";ff(gf(),l+"\n")}return new wY(t().d,b,c)}if(a.YA.EF(b))l=a.YA.LF(b);else{l=new vl(Z4(a,d));l=OS(l,b);var m=a.YA.zv,n=new bk(b),r=Qb(n.py);b:{var v=r^(r>>>16|0);r=1+m.yv|0;if(r>=m.jK){var x=m.wl,A=x.a.length,B=A<<1,C=new (md(EN).Ia)(B);m.wl=C;m.jK=Eb(B*m.RQ);for(B=0;B<A;){for(var D=null,F=null,I=x.a[B];null!==I;)0===(I.oy&A)?(null===D?C.a[B]=I:D.xr=I,D=I):(null===F?C.a[A+
+B|0]=I:F.xr=I,F=I),I=I.xr;null!==D&&(D.xr=null);null!==F&&(F.xr=null);B=1+B|0}}x=v&(-1+m.wl.a.length|0);A=m.wl.a[x];if(null===A)m.wl.a[x]=new DN(n,v,l,null,null);else{for(C=null;null!==A&&A.oy<=v;){A.oy===v?(C=A.xB,C=null===n?null===C:La(n,C)):C=!1;if(C){A.xv=l;break b}C=A;A=A.xr}n=new DN(n,v,l,C,A);null===C?m.wl.a[x]=n:C.xr=n;null!==A}m.yv=r}}a.Hb&&a.F&&(m=ut(Q(),"| ",a.r)+"The scrutinee needs an alias: "+l,ff(gf(),m+"\n"));return new wY((t(),new L(l)),b,c)},g=a.qa;if(a.Hb){if(a.F){var h=ut(Q(),
+"| ",a.r)+("Making a scrutinee for `"+b)+"`";ff(gf(),h+"\n")}a.r=1+a.r|0;try{var k=e()}finally{a.r=-1+a.r|0}dx(new E(g),a.qa)&&a.F&&(e=""+ut(Q(),"| ",a.r)+g.n(k),ff(gf(),e+"\n"))}else k=e();return k}
+var f5=function vfa(a,b,c,d,e,g,h,k,l){return Lx(a,new U(()=>"[Desugarer.destructPattern] scrutinee \x3d "+b.nh+"; pattern \x3d "+c),new U(()=>{var n=!1,r=null,v=!1,x=null,A=!1,B=null;if(c instanceof vl&&(n=!0,r=c,"_"===r.x&&d)){$4(a,b,iu(ju(),r.A()),e,h);var C=new SE(b,r.A().ha()),D=O().c;return new z(C,D)}if(n&&"_"===r.x)return O().c;if(n&&("true"===r.x||"false"===r.x)){b5(a,b,r,iu(ju(),r.A()),e,h);var F=r,I=b.nh.A().ha(),M=new OE(b,F,dl(r.A().ha(),I));M.lf=xY(b).ha();X4(a,new U(()=>"Add bindings to the clause: "+
+xY(b)));var N=O().c;return new z(M,N)}if(c instanceof Dl){b5(a,b,c,iu(ju(),c.A()),e,h);var P=b.nh.A().ha(),T=new OE(b,c,dl(c.A().ha(),P));T.lf=xY(b).ha();X4(a,new U(()=>"Add bindings to the clause: "+xY(b)));var Y=O().c;return new z(T,Y)}if(n){var Z=r.x,S=Xz(Q(),Z),ea=new y(rc=>{rc=Ea(rc);return bE(Pr(),rc)});if(!S.b()&&ea.n(S.o())){var ia=b.nh.A().ha(),X=dl(r.A().ha(),ia);if(d){$4(a,b,iu(ju(),r.A()),e,h);var sa=new SE(b,X),Ja=new YE(r,GE(b),!d,X),Xa=O().c;return new z(sa,new z(Ja,Xa))}var Fa=new YE(r,
+b.nh,!d,X),za=O().c;return new z(Fa,za)}}if(n){var Qa=r.x,Ma=!1,Ga=null,ab=e.tb.U(Qa),Hb=new U(()=>uC(e,e,Qa)),bc=ab.b()?Es(Hb):ab;a:{if(bc instanceof L){Ma=!0;Ga=bc;var yb=Ga.k;if(yb instanceof VP&&yb.J===a){var tb=yb.fd();if(Ot(new E(tb),Bp()))var eb=!0;else{var kb=yb.fd();eb=Ot(new E(kb),zp())}if(eb)break a}}if(Ma){var Rb=Ga.k;if(Rb instanceof VP&&Rb.J===a){var Gb=Rb.fd();if(Ot(new E(Gb),Fp())){var vb=new Te(new Ue(J(new K,["Cannot match on trait `","`"]))),Tb=[We(Xe(),Qa)];throw iT(new jT,Ye(vb,
+J(new K,Tb)),r.A());}}}if(!(Ma&&Ga.k instanceof YX&&Ga.k.FE===a)){var Nb=new Te(new Ue(J(new K,["Cannot find constructor `","` in scope"]))),ic=[We(Xe(),Qa)];throw iT(new jT,Ye(Nb,J(new K,ic)),r.A());}}X4(a,new U((rc=>()=>"Build a Clause.MatchClass from "+b+" where pattern is "+rc)(r)));b5(a,b,r,iu(ju(),r.A()),e,h);var Va=new UE(b,r,O().c,g5()),cb=O().c;return new z(Va,cb)}if(c instanceof Pl){v=!0;x=c;var zb=x.Za,Ub=x.Qb;if(zb instanceof vl){var jb=zb.x;if(Ub instanceof Gl){var db=Ub.Ra,ub=e.tb.U(jb),
+Aa=new y(rc=>G(new H,rc.jj,rc.at)),va=ub.b()?R():new L(Aa.n(ub.o())),Ra=new U(()=>{var rc=!1,sd=null,Kc=uC(e,e,jb);if(Kc instanceof L&&(rc=!0,sd=Kc,Kc=sd.k,Kc instanceof fx)){var Qd=Kc.Ab.fd();if(Ot(new E(Qd),Bp()))return t(),rc=Kc.Ab.fd(),sd=px(Kc),Kc=new U(()=>O().c),rc=G(new H,rc,Qt(sd.b()?Es(Kc):sd.o(),new y(Ad=>Ad.h().x))),new L(rc)}if(rc&&(rc=sd.k,rc instanceof ix&&(rc=rc.kh,rc instanceof Yw)))return t(),sd=rc.Ij,Kc=new U(()=>O().c),rc=G(new H,rc.Rf.pb,Qt(sd.b()?Es(Kc):sd.o(),new y(Ad=>Ad.h().x))),
+new L(rc);rc=new Te(new Ue(J(new K,["Illegal pattern `","`"])));sd=[We(Xe(),jb)];throw iT(new jT,Ye(rc,J(new K,sd)),zb.A());}),rb=va.b()?Es(Ra):va;if(t().d===rb){var xb=new Te(new Ue(J(new K,["Cannot find class `","` in scope"]))),mc=[We(Xe(),jb)];throw iT(new jT,Ye(xb,J(new K,mc)),zb.A());}if(rb instanceof L){var Ha=rb.k;if(null!==Ha){var Ka=Ha.h(),Oa=Ha.j(),Na=db.K();if(Pe(new E(Na),Oa.K())){var Da=db.m(),ta=c5(a,b,new Ef(Da,new y(rc=>rc.j().ya)),Oa,e,k);if(null!==ta)var Ya=G(new H,ta.h(),ta.j());
+else throw new w(ta);var dc=Ya.h(),ka=Ya.j();b5(a,b,zb,iu(ju(),x.A()),e,h);var ya=c.A().ha(),Sa=new UE(b,zb,ka,dl(g5(),ya));X4(a,new U(()=>"Build a Clause.MatchClass from "+b+" where pattern is "+c));X4(a,new U(()=>"Fragments: "+l));X4(a,new U(()=>"The locations of the clause: "+Sa.tF));var xc=d5(a,b,dc,e,g,h,k);return new z(Sa,xc)}var Sb=Oa.K();db.K();var uc=new Te(new Ue(J(new K,"; ; expects ; ; but found ; ;".split(";")))),Lb=We(Xe(),Ka.ld),lc=We(Xe(),jb),Xb=We(Xe(),""+Sb),ec=We(Xe(),WF(ve(),"parameter",
+Sb,!1));Xe();var Ab=db.K(),Ob=[Lb,lc,Xb,ec,We(0,""+Ab),We(Xe(),WF(ve(),"parameter",Sb,!1))];throw iT(new jT,Ye(uc,J(new K,Ob)),x.A());}}throw new w(rb);}}}if(v){var fb=x.Za,Wa=x.Qb;if(fb instanceof Pl){var bb=fb.Za,Ia=fb.Qb;if(bb instanceof vl){var Ua=bb.x;if(Ia instanceof Gl){var pc=Ia.Ra;if(pc instanceof z){var sc=pc.z,Ba=pc.p;if(null!==sc){var ob=new L(sc);if(!ob.b()){var nc=ob.k.j();if(null!==nc){var Ib=nc.ya,vc=O().c;if((null===vc?null===Ba:vc.i(Ba))&&Wa instanceof Gl){var Vb=Wa.Ra;if(Vb instanceof
+z){var fc=Vb.z,Bc=Vb.p;if(null!==fc){var Pb=new L(fc);if(!Pb.b()){var Jb=Pb.k.j();if(null!==Jb){var gc=Jb.ya,Cb=O().c;if(null===Cb?null===Bc:Cb.i(Bc)){var cc=!1,yc=null,Mc=e.tb.U(Ua);if(t().d===Mc){var qc=new Te(new Ue(J(new K,["Cannot find operator `","` in the context"]))),oc=[We(Xe(),Ua)];throw iT(new jT,Ye(qc,J(new K,oc)),bb.A());}if(Mc instanceof L){cc=!0;yc=Mc;var Qc=yc.k,jc=Qc.at.K();if(Pe(new E(jc),2)){var sb=O().c,Gc=c5(a,b,new z(Ib,new z(gc,sb)),Qc.at,e,k);if(null!==Gc)var Wb=G(new H,Gc.h(),
+Gc.j());else throw new w(Gc);var Cc=Wb.h(),Fc=Wb.j();b5(a,b,bb,iu(ju(),x.A()),e,h);var qd=new UE(b,bb,Fc,g5());X4(a,new U(()=>"Build a Clause.MatchClass from "+b+" where operator is "+bb));var Yb=d5(a,b,Cc,e,g,h,k);return new z(qd,Yb)}}if(cc){var Nc=yc.k;Nc.at.K();var ad=Nc.at.K(),Uc=new Te(new Ue(J(new K,[""," `","` expects "," "," but found two parameters"]))),cd=[We(Xe(),Nc.jj.ld),We(Xe(),Ua),We(Xe(),""+ad),We(Xe(),WF(ve(),"parameter",ad,!1))];throw iT(new jT,Ye(Uc,J(new K,cd)),x.A());}throw new w(Mc);
+}}}}}}}}}}}}}}if(c instanceof Fl){A=!0;B=c;var kc=B.gg;if(!1===B.bi&&kc instanceof Gl)return h5(a,kc,b,e,k,g,h)}if(c instanceof Gl)return h5(a,c,b,e,k,g,h);if(A){var Vc=B.gg;if(!1===B.bi)return vfa(a,b,Vc,d,e,g,h,k,l)}var Hc=new Ue(J(new K,["illegal pattern"]));throw iT(new jT,Ye(new Te(Hc),u()),c.A());}),new y(n=>"[Desugarer.destructPattern] Result: "+ze(n,"",", ","")))};function g5(){return TE(PE()).ha()}
+var xfa=function wfa(a,b,c){var e=()=>{var l=b.zs;if(l instanceof L){var m=l.k;if(m instanceof Xl)return wfa(a,m,new z(b.bp,c))}if(c.b())return G(new H,b.bp,l);m=er(new z(b.bp,c)).m();m=new xo(m,new y(n=>{if(n instanceof $t)return n.ap;O();t();return new CQ(new fe(n))}));Od();m=Pd(u(),m);return G(new H,new $t(m),l)},g=new y(l=>"[unfoldNestedIf] ("+ag(ca(l.h()))+", "+l.j()+")");if(a.Hb){if(a.F){var h=ut(Q(),"| ",a.r)+"[unfoldNestedIf]";ff(gf(),h+"\n")}a.r=1+a.r|0;try{var k=e()}finally{a.r=-1+a.r|0}dx(new E(g),
+a.qa)&&a.F&&(e=""+ut(Q(),"| ",a.r)+g.n(k),ff(gf(),e+"\n"))}else k=e();return k};
+function yfa(a,b,c,d,e,g){var h=()=>{var n=Xu().X(),r=TE(PE()),v=TE(PE());i5(a,b,b0(),new NE(O().c,O().c),v,r,d,e,g,n);c.b()||(n=c.o(),v=new NE(O().c,O().c),n=G(new H,v,n),r.$(n));a.Hb&&a.F&&(n=ut(Q(),"| ",a.r)+"Decision paths:",ff(gf(),n+"\n"));for(n=r.m();n.s();){var x=n.t();a:{if(null!==x&&(v=new L(x),!v.b())){x=v.k.h();v=v.k.j();a.Hb&&a.F&&(v=ut(Q(),"| ",a.r)+("+ "+x+" \x3d\x3e ")+v,ff(gf(),v+"\n"));break a}throw new w(x);}}return r.ha()},k=new y(n=>{var r=n.K();n=n.K();return"[desugarIf] produces "+
+r+" "+WF(ve(),"path",n,!1)});if(a.Hb){if(a.F){var l=ut(Q(),"| ",a.r)+"[desugarIf] with fallback "+c;ff(gf(),l+"\n")}a.r=1+a.r|0;try{var m=h()}finally{a.r=-1+a.r|0}dx(new E(k),a.qa)&&a.F&&(h=""+ut(Q(),"| ",a.r)+k.n(m),ff(gf(),h+"\n"))}else m=h();return m}
+function a5(a,b,c){var d=()=>{var k=b.nh;if(k instanceof vl){var l=k.x;if(a.Hb&&a.F){var m=ut(Q(),"| ",a.r)+"The original scrutinee is an reference.";ff(gf(),m+"\n")}l=c.hc.U(l);if(l instanceof L&&(m=l.k,m instanceof qx))return l=m.vA.kt,l.b()?(t(),k=new fe(k.x)):(k=l.o()|0,t(),k=new Ud(k)),k;if(l instanceof L||t().d===l)return t(),new fe(k.x);throw new w(l);}a.Hb&&a.F&&(k=ut(Q(),"| ",a.r)+"The scrutinee was localized because it might be effectful.",ff(gf(),k+"\n"));k=b.no;if(t().d===k)throw vS(new wS,
+"check your `makeScrutinee`");if(k instanceof L)return k=k.k,t(),new fe(k.x);throw new w(k);},e=a.qa;if(a.Hb){if(a.F){var g=ut(Q(),"| ",a.r)+"[getScrutineeKey] "+b;ff(gf(),g+"\n")}a.r=1+a.r|0;try{var h=d()}finally{a.r=-1+a.r|0}dx(new E(e),a.qa)&&a.F&&(d=""+ut(Q(),"| ",a.r)+e.n(h),ff(gf(),d+"\n"))}else h=d();return h}
+var zfa=function j5(a,b,c,d,e,g,h){tfa(a,new U(()=>"[checkExhaustive] "+b.jb()),new U(()=>{if(!(b instanceof HE)){if(IE()===b){var l=!1,m=null;if(c instanceof L){l=!0;m=c;var n=m.k;if(n instanceof CE){var r=n.hr;if(Pe(new E(n.Fh),b))throw l=new Te(new Ue(J(new K,["The case when this is false is not handled: ",""]))),m=[We(Xe(),Zz(r,!1))],iT(new jT,Ye(l,J(new K,m)),r.A());xm("`MissingCase` are not supposed to be the true branch of `IfThenElse`")}}l&&m.k instanceof DE&&xm("`MissingCase` are not supposed to be a case of `Match`");
+a:if(c instanceof L&&c.k instanceof HE)r=!0;else{if(c instanceof L&&(r=c.k,IE()===r)){r=!0;break a}r=t().d===c?!0:!1}r&&xm("Program reached and unexpected state.");throw new w(c);}if(b instanceof CE)r=b.Dk,j5(a,b.Fh,(t(),new L(b)),d,e,g,h),j5(a,r,(t(),new L(b)),d,e,g,h);else if(b instanceof DE){var v=b.mo;r=b.mh;l=b.nj;m=!1;n=null;var x=g.U(a5(a,v,d));a:{t().d===x&&xm("unreachable case: unknown scrutinee "+v.nh);if(x instanceof L&&(m=!0,n=x,!l.b())){X4(a,new U(()=>"The match has a default branch. So, it is always safe."));
+break a}if(m){m=n.k;X4(a,new U(()=>"The exhaustiveness map is"));g.og(new fn((C,D)=>{X4(a,new U(()=>{var F=D.tj();return"- "+C+" -\x3e "+ze(F,"",", ","")}))}));X4(a,new U(()=>"The scrutinee key is "+a5(a,v,d)));X4(a,new U(()=>"Pattern map of the scrutinee:"));m.b()?X4(a,new U(()=>"\x3cEmpty\x3e")):m.og(new fn((C,D)=>{X4(a,new U(()=>"- "+C+" \x3d\x3e "+D))}));tp();n=r.m();var A=Aq(0,new xo(n,new y(C=>{if(C instanceof EE)return O().c;if(C instanceof FE){var D=C.Tj;if(null!==D&&(D=new L(D),!D.b()&&(D=
+D.k.h(),null!==D))){C=h.U(D.x);D=new U(()=>O().c);var F=new y(I=>I);return C.b()?Es(D):F.n(C.o())}}throw new w(C);})));X4(a,new U(()=>"The match can cover following classes"));X4(a,new U(()=>ze(A,"{",", ","}")));n=r.m();m=m.dG(new Ef(n,new y(C=>{if(C instanceof EE)return C=C.ir,t(),new Ud(C);if(C instanceof FE){var D=C.Tj;if(null!==D&&(D=new L(D),!D.b())){C=D.k.h();tp();Q();D=C.x;Q();D=M2(D,"\\"+hc(35));D=ps(D);Od();D=Pd(u(),D);if(D instanceof z){var F=D.p;if("Tuple"===D.z&&F instanceof z){D=F.z;
+F=F.p;var I=O().c;if(null===I?null===F:I.i(F)){D=$D(aE(),D);if(t().d===D)return t(),new Ud(C);if(D instanceof L)return C=D.k|0,t(),new fe(C);throw new w(D);}}}t();return new Ud(C)}}throw new w(C);}))).Fk(new y(C=>{if(null!==C){var D=new L(C);if(!D.b()&&(D=D.k.h(),D instanceof Ud&&(D=D.fa,D instanceof vl)))return!A.L(D.x)}if(null!==C&&(D=new L(C),!D.b()&&D.k.h()instanceof fe)||null!==C&&(D=new L(C),!D.b()&&D.k.h()instanceof Ud))return!0;throw new w(C);}));X4(a,new U(()=>"Missing cases"));m.og(new fn((C,
+D)=>{X4(a,new U(()=>"- "+C+" -\x3e "+D))}));if(m.b())break a;else{var B=m.ka();r=Ye(new Te(new Ue(J(new K,["The match is not exhaustive."]))),u());r=G(new H,r,v.ZP);l=new Te(new Ue(J(new K,["The scrutinee at this position misses "," ","."])));n=[We(Xe(),""+B),We(Xe(),WF(ve(),"case",B,!1))];l=Ye(l,J(new K,n));n=v.nh.A();l=G(new H,l,n);m=m.m();m=new Ao(m);m=new xo(m,new y(C=>{if(null!==C){var D=C.h(),F=C.Sc();if(null!==D){C=D.h();D=D.j();if(C instanceof fe)C=(C.aa|0)+"-ary tuple";else if(C instanceof
+Ud)C=Zz(C.fa,!1);else throw new w(C);var I="[Missing Case "+(1+F|0)+"/"+B+"]";F=new Te(new Ue(J(new K,[""," `","`"])));C=[We(Xe(),I),We(Xe(),C)];F=Ye(F,J(new K,C));C=t().d;F=G(new H,F,C);D=D.m();D=new Ao(D);D=new Ef(D,new y(M=>{if(null!==M){var N=M.h();M=Pe(new E(M.Sc()),0)?Ye(new Te(new Ue(J(new K,["It first appears here."]))),u()):Ye(new Te(new Ue(J(new K,["And here."]))),u());t();return G(new H,M,new L(N))}throw new w(M);}));Od();D=Pd(u(),D);return new z(F,D)}}throw new w(C);}));Od();m=Pd(u(),
+m);l=new z(l,m);throw hT(new jT,new z(r,l));}}throw new w(x);}m=new y(C=>{j5(a,C,(t(),new L(b)),d,e,g,h)});l.b()||m.n(l.o());cH(r,new y(C=>{j5(a,C.xt(),(t(),new L(b)),d,e,g,h)}))}else throw new w(b);}}),new y(()=>"[checkExhaustive] "+b.jb()))};
+function Afa(a,b,c){var d=()=>{tp();var k=b.ni.m();k=k5(a,b,Aq(0,new Ef(k,new y(r=>r.Sj))),c);var l=tF(),m=b.ni.ha(),n=ap();return mF(l,m,n,k)},e=new y(()=>"[constructTerm]");if(a.Hb){if(a.F){var g=ut(Q(),"| ",a.r)+"[constructTerm]";ff(gf(),g+"\n")}a.r=1+a.r|0;try{var h=d()}finally{a.r=-1+a.r|0}dx(new E(e),a.qa)&&a.F&&(d=""+ut(Q(),"| ",a.r)+e.n(h),ff(gf(),d+"\n"))}else h=d();return h}
+function Bfa(a,b,c,d,e,g){var h=()=>{var n=O().c;if(null===n?null===b:n.i(b))return IE();if(b instanceof z){var r=b.z;n=b.p;if(null!==r){var v=new L(r);if(!v.b()){r=v.k.h();v=v.k.j();var x=gF(),A=cF(x,r,v);r=()=>{for(var D=eF(gF(),A);!D.b();){var F=D.e();a.Hb&&a.F&&(F=""+ut(Q(),"| ",a.r)+F,ff(gf(),F+"\n"));D=D.f()}};v=a.qa;if(a.Hb){a.F&&(x=ut(Q(),"| ",a.r)+"*** Initial tree ***",ff(gf(),x+"\n"));a.r=1+a.r|0;try{var B=r()}finally{a.r=-1+a.r|0}dx(new E(v),a.qa)&&a.F&&(B=""+ut(Q(),"| ",a.r)+v.n(B),ff(gf(),
+B+"\n"))}else r();for(;!n.b();){B=n.e();A.dm(B,c,d,e,g);a.Hb&&a.F&&(B=ut(Q(),"| ",a.r)+("*** Merging `"+B.h()+" \x3d\x3e "+B.j())+"` ***",ff(gf(),B+"\n"));B=(D=>()=>{for(var F=eF(gF(),D);!F.b();){var I=F.e();a.Hb&&a.F&&(I=""+ut(Q(),"| ",a.r)+I,ff(gf(),I+"\n"));F=F.f()}})(A);r=a.qa;if(a.Hb){a.F&&(v=ut(Q(),"| ",a.r)+"*** Updated tree ***",ff(gf(),v+"\n"));a.r=1+a.r|0;try{var C=B()}finally{a.r=-1+a.r|0}dx(new E(r),a.qa)&&a.F&&(B=""+ut(Q(),"| ",a.r)+r.n(C),ff(gf(),B+"\n"))}else B();n=n.f()}return A}}}throw new w(b);
+},k=new y(()=>"[buildCaseTree]");if(a.Hb){if(a.F){var l=ut(Q(),"| ",a.r)+"[buildCaseTree]";ff(gf(),l+"\n")}a.r=1+a.r|0;try{var m=h()}finally{a.r=-1+a.r|0}dx(new E(k),a.qa)&&a.F&&(h=""+ut(Q(),"| ",a.r)+k.n(m),ff(gf(),h+"\n"))}else m=h();return m}
+function Cfa(a,b){var c=()=>{var h=b.tb.m();h=new iy(h,new y(k=>!k.j().GE.b()),!1);h=new Ef(h,new y(k=>{if(null!==k){var l=k.h();k=k.j().Bx.m();k=new Ef(k,new y(m=>m.V));Od();k=Pd(u(),k);return G(new H,l,k)}throw new w(k);}));h=pp(tp().JK,h);return Sca(xE(),h)},d=new y(()=>"[getClassHierarchy]");if(a.Hb){if(a.F){var e=ut(Q(),"| ",a.r)+"[getClassHierarchy]";ff(gf(),e+"\n")}a.r=1+a.r|0;try{var g=c()}finally{a.r=-1+a.r|0}dx(new E(d),a.qa)&&a.F&&(a=""+ut(Q(),"| ",a.r)+d.n(g),ff(gf(),a+"\n"))}else g=c();
+return g}function h5(a,b,c,d,e,g,h){var k=b.Ra.m();k=new Ef(k,new y(v=>v.j().ya));var l=b.Ra.K(),m=1>l;if(m)var n=0;else{var r=l>>31;n=-1+l|0;r=-1!==n?r:-1+r|0;n=1+n|0;r=0===n?1+r|0:r;n=(0===r?-1<(-2147483648^n):0<r)?-1:n}0>n&&$Q(bR(),1,l,1,!0);n=xe().Eb();for(l=new hE(1,1,l,m);l.fw;)m="_"+c4(l),n.$(m);l=n.Kb();Od();l=c5(a,c,k,Pd(u(),l),d,e);if(null===l)throw new w(l);k=l.h();l=l.j();ufa(a,c,b.Ra.K(),iu(ju(),b.A()),d,h);b=new WE(c,b.Ra.K(),l,g5());a=d5(a,c,k,d,g,h,e);return new z(b,a)}
+function l5(a,b,c,d,e,g){for(var h=null,k=null;b!==u();){var l=b.e(),m=!1,n=null;a:{if(l instanceof Pl){m=!0;n=l;var r=n.Za,v=n.Qb;if(r instanceof Pl){var x=r;r=x.Za;x=x.Qb;if(r instanceof vl&&"is"===r.x&&x instanceof Gl&&(r=x.Ra,r instanceof z&&(x=r,r=x.z,x=x.p,null!==r&&(r=new L(r),!r.b()&&(r=r.k.j(),null!==r))))){r=r.ya;var A=O().c;if((null===A?null===x:A.i(x))&&v instanceof Gl&&(v=v.Ra,v instanceof z&&(x=v.z,v=v.p,null!==x&&(x=new L(x),!x.b()&&(x=x.k.j(),null!==x&&(x=x.ya,A=O().c,(null===A?null===
+v:A.i(v))&&!a.$c)))))){n=n.A();n=e5(a,r,n,c);l=O().c;n=f5(a,n,x,!0,c,d,e,g,l);break a}}}}if(m&&(m=n.Za,v=n.Qb,m instanceof vl&&"is"===m.x&&null!==v&&(m=mz(eu(),v),!m.b()&&null!==m.o()&&0===m.o().ab(2)))){l=m.o();l=eB(l,0);m=m.o();m=eB(m,1);n=n.A();n=e5(a,l,n,c);l=O().c;n=f5(a,n,m,!0,c,d,e,g,l);break a}n=new XE(l,g5());O();n=new CQ(n)}for(n=n.m();n.s();)l=new z(n.t(),u()),null===k?h=l:k.p=l,k=l;b=b.f()}return null===h?u():h}
+var Dfa=function m5(a,b,c,d,e,g,h,k,l,m,n){var v=()=>{var C=!1,D=null,F=!1,I=null;a:{if(c instanceof fe){C=!0;D=c;var M=D.aa;if(M instanceof gu){F=G(new H,e,M.ws);h.$(F);break a}}if(C){var N=D.aa;if(N instanceof Ut&&(M=N.Km,N=N.Lm,M instanceof vl&&"_"===M.x)){F=G(new H,e,N);h.$(F);break a}}if(C&&(M=D.aa,M instanceof Ut)){I=M.Km;F=M.Lm;C=rF(tF(),I,a.$c);if(null===C)throw new w(C);I=C.j();C=d.oo(C.h(),a.$c).jr;D=O().c;C=f5(a,b,C,!0,k,l,m,n,D);C=sY(e,uY(new NE(C,O().c),g));a.Hb&&a.F&&(D=ut(Q(),"| ",
+a.r)+"Result: "+ze(C.Wi,"",", ",""),ff(gf(),D+"\n"));if(t().d===I)F=G(new H,C,F),h.$(F);else if(I instanceof L)i5(a,new Ut(I.k,F),b0(),C,g,h,k,l,m,n);else throw new w(I);break a}if(C&&(M=D.aa,M instanceof Tt)){N=M.Wn;var P=M.Xn;M=M.Yn;if(null!==P&&"and"===P.x){I=rF(tF(),N,a.$c);if(null===I)throw new w(I);F=I.h();I=I.j();C=O().c;F=f5(a,b,F,!0,k,l,m,n,C);I.b()?I=O().c:(I=I.o(),I=qF(tF(),I),O(),I=l5(a,I,k,l,m,n));F=sY(e,uY(new NE(dl(I,F),O().c),g));i5(a,M,b0(),F,g,h,k,l,m,n);break a}}if(C&&(M=D.aa,M instanceof
+Tt)){C=M.Wn;I=M.Xn;F=M.Yn;C=rF(tF(),C,a.$c);b:{if(null!==C&&(D=C.h(),M=C.j(),M instanceof L)){I=M.k;C=O().c;C=f5(a,b,D,!0,k,l,m,n,C);I=qF(tF(),I);O();I=l5(a,I,k,l,m,n);I=sY(e,uY(new NE(dl(I,C),O().c),g));i5(a,F,b0(),I,g,h,k,l,m,n);break b}if(null!==C&&(D=C.h(),M=C.j(),t().d===M)){F=(t(),new fe(F));I=d0(d.oo(D,a.$c),I);m5(a,b,F,I,e,g,h,k,l,m,n);break b}throw new w(C);}break a}if(C&&(M=D.aa,M instanceof mu)){I=M.xs;F=M.ys;I=rF(tF(),I,a.$c);b:{if(null!==I&&(C=I.h(),D=I.j(),t().d===D)){for(I=d.oo(C,a.$c);!F.b();){D=
+F.e();c:{if(null!==D&&(C=new L(D),!C.b())){D=C.k.h();C=C.k.j();m5(a,b,(t(),new fe(C)),d0(I,D),e,g,h,k,l,m,n);break c}throw new w(D);}F=F.f()}break b}if(null!==I&&(C=I.h(),D=I.j(),D instanceof L)){I=D.k;C=d.oo(C,a.$c).jr;D=O().c;C=f5(a,b,C,!0,k,l,m,n,D);I=qF(tF(),I);D=I.MJ();O();D=l5(a,D,k,l,m,n);for(C=sY(e,uY(new NE(dl(D,C),O().c),g));!F.b();){D=F.e();c:{if(null!==D&&(M=new L(D),!M.b())){D=M.k.j();M=I.Mc();N=O().c;i5(a,D,new a0(M,new z(M,N)),C,g,h,k,l,m,n);break c}throw new w(D);}F=F.f()}break b}throw new w(I);
+}break a}if(C&&(M=D.aa,M instanceof $t)){for(F=M.ap;!F.b();)I=F.e(),m5(a,b,I,d,e,g,h,k,l,m,n),F=F.f();break a}C&&D.aa instanceof Ss&&vF();if(c instanceof Ud&&(F=!0,I=c,M=I.fa,M instanceof Zn&&(D=M.wd,C=M.Rb,M=M.Yc,D instanceof L&&(D=!!D.k,M instanceof fe)))){F=M.aa;F=new bF(KE(),D,C,F);g.$(F);break a}if(F)throw F=I.fa,I=new Te(new Ue(J(new K,["Illegal interleaved statement ",""]))),C=[We(Xe(),F.u())],iT(new jT,Ye(I,J(new K,C)),F.A());throw new w(c);}},x=new y(()=>"[desugarMatchBranch]");if(a.Hb){if(a.F){var A=
+ut(Q(),"| ",a.r)+"[desugarMatchBranch]";ff(gf(),A+"\n")}a.r=1+a.r|0;try{var B=v()}finally{a.r=-1+a.r|0}dx(new E(x),a.qa)&&a.F&&(v=""+ut(Q(),"| ",a.r)+x.n(B),ff(gf(),v+"\n"))}else v()},i5=function n5(a,b,c,d,e,g,h,k,l,m){var r=()=>{var B=!1,C=null,D=!1,F=null;a:if(b instanceof mu)for(D=b.ys,F=c.oo(b.xs,a.$c);!D.b();){C=D.e();b:{if(null!==C&&(B=new L(C),!B.b())){n5(a,B.k.j(),d0(F,B.k.h()),d,e,g,h,k,l,m);break b}throw new w(C);}D=D.f()}else{if(b instanceof Ut){B=!0;C=b;var I=C.Km,M=C.Lm;if(I instanceof
+vl&&"_"===I.x){F=G(new H,d,M);g.$(F);break a}}if(B)F=C.Lm,D=c.oo(C.Km,a.$c),C=qF(tF(),D.jr),dl(D.aB,C),D=l5(a,C,h,k,l,m),D=uY(tY(d,D),e),F=G(new H,D,F),g.$(F);else{if(b instanceof Tt&&(D=!0,F=b,B=F.Wn,C=F.Xn,I=F.Yn,null!==C&&"is"===C.x&&I instanceof $t)){F=I.ap;D=c.oo(B,a.$c).jr;B=D.A();C=C.A();b:{if(B instanceof L&&(B=B.k,C instanceof L)){C=C.k;t();C=xs(B,C);C=new L(C);break b}C=t().d}D=e5(a,D,C,h);C=D.no;if(C instanceof L)C=d;else{if(t().d!==C)throw new w(C);C=d}for(B=e.ia();!F.b();)I=F.e(),Dfa(a,
+D,I,b0(),C,B,g,h,k,l,m),F=F.f();break a}if(D&&(B=F.Wn,I=F.Xn,C=F.Yn,null!==I&&"and"===I.x)){F=c.oo(B,a.$c).jr;D=O().c;F=new z(F,D);O();F=tY(d,l5(a,F,h,k,l,m));n5(a,C,b0(),F,e,g,h,k,l,m);break a}if(D)D=F.Yn,C=F.Xn,F=d0(c.oo(F.Wn,a.$c),C),n5(a,D,F,d,e,g,h,k,l,m);else if(b instanceof Ss&&vF(),b instanceof gu)F=b.ws,D=uY(d,e),F=G(new H,D,F),g.$(F);else if(b instanceof $t)for(F=b.ap;!F.b();){D=F.e();C=!1;b:if(D instanceof fe)n5(a,D.aa,c,d,e,g,h,k,l,m);else{if(D instanceof Ud&&(C=!0,B=D,B=B.fa,B instanceof
+Zn&&(M=B,I=M.wd,B=M.Rb,M=M.Yc,I instanceof L&&(I=!!I.k,M instanceof fe)))){D=M.aa;a.Hb&&a.F&&(C=ut(Q(),"| ",a.r)+"Found interleaved binding "+B.x,ff(gf(),C+"\n"));D=new bF(KE(),I,B,D);e.$(D);break b}if(C)throw vS(new wS,"unexpected statements at desugarIfBody");throw new w(D);}F=F.f()}else throw new w(b);}}},v=new y(()=>"[desugarIfBody]");if(a.Hb){if(a.F){var x=ut(Q(),"| ",a.r)+"[desugarIfBody]";ff(gf(),x+"\n")}a.r=1+a.r|0;try{var A=r()}finally{a.r=-1+a.r|0}dx(new E(v),a.qa)&&a.F&&(r=""+ut(Q(),"| ",
+a.r)+v.n(A),ff(gf(),r+"\n"))}else r()},p5=function o5(a,b,c,d,e,g){var k=!1,l=null;if(b instanceof z){k=!0;l=b;var m=l.z,n=l.p;if(m instanceof FE){var r=m.Tj;m=m.pl;if(null!==r&&(r=new L(r),!r.b())){b=r.k.h();l=r.k.j();a.Hb&&a.F&&(k=ut(Q(),"| ",a.r),r=l.m(),r=new Ef(r,new y(D=>D.h()+" -\x3e "+D.j())),k=k+("\u2022 Constructor pattern: "+b+"("+ze(r,"",", ",""))+")",ff(gf(),k+"\n"));k=l.m();k=new Ef(k,new y(D=>D.j()));m=k5(a,m,c.Ce(k),g);r=!1;var v=null;k=uC(g,g,b.x);a:{if(k instanceof L){r=!0;v=k;var x=
+v.k;if(x instanceof ix&&(x=x.kh,x instanceof Cx)){k=Cp(x.Yr());break a}}if(r&&(r=v.k,r instanceof fx)){k=Cp(r.Ab);break a}r=k instanceof L&&k.k instanceof VP?!0:k instanceof L&&k.k instanceof qx?!0:t().d===k?!0:!1;if(r)k=t().d;else throw new w(k);}a:{if(GE(d)instanceof vl&&k instanceof L&&(k=k.k,!l.b())){v=FV();r=new fp;for(x=l.m();x.s();){var A=x.t();b:{if(null!==A){var B=new L(A);if(!B.b()){var C=B.k.h();B=B.k.j();if(null!==B){A=B.x;B=v.U(C);B instanceof L?wp(r,G(new H,B.k,A)):v.bj(C,A);break b}}}throw new w(A);
+}}v=t().d;l=new sm(tm().Cg,new Gl(l.Ii(new y(D=>D.h())).Ja(new y(D=>{if(null!==D){var F=new L(D);if(!F.b()&&(F=F.k.j(),null!==F)){F=F.x;if("_"===F)return D=t().d,F=new sm(tm().Cg,new vl(Z4(a,g))),G(new H,D,F);D=t().d;F=new sm(tm().Cg,new vl(F));return G(new H,D,F)}}throw new w(D);})).ha()));l=G(new H,v,l);v=O().c;l=new Gl(new z(l,v));r=r.ha();for(r=Km(r);!r.b();)v=r.e(),m=new Rl(!1,new vl(v.j()),new vl(v.h()),m),r=r.f();l=new Ol(l,m);m=t().d;r=tm().Cg;k=new Ql(b,new vl(k.Cf.x));v=t().d;x=new sm(tm().Cg,
+GE(d));v=G(new H,v,x);x=O().c;k=new sm(r,new Pl(k,new Gl(new z(v,x))));m=G(new H,m,k);k=O().c;l=new Pl(l,new Gl(new z(m,k)));break a}l=l.Fk(new y(D=>Nm(new E(D.j().x),"_"))).ha();l=Efa(a,GE(d),l,m,d,g)}return new um(b,l,o5(a,n,c,d,e,g))}}}if(k&&(m=l.z,n=l.p,m instanceof EE))return b=m.ir,l=m.Jp,a.Hb&&a.F&&(m=ut(Q(),"| ",a.r)+"\u2022 Literal pattern: "+b,ff(gf(),m+"\n")),new um(b,k5(a,l,c,g),o5(a,n,c,d,e,g));d=O().c;if(null===d?null===b:d.i(b)){if(R()===e)return a.Hb&&a.F&&(c=ut(Q(),"| ",a.r)+"\u2022 No wildcard branch",
+ff(gf(),c+"\n")),zm();if(e instanceof L)return e=e.k,a.Hb&&a.F&&(d=ut(Q(),"| ",a.r)+"\u2022 Wildcard branch",ff(gf(),d+"\n")),new ym(k5(a,e,c,g));throw new w(e);}throw new w(b);},k5=function q5(a,b,c,d){var g=()=>{if(b instanceof HE){var m=b.ot,n=tF(),r=b.ni.ha();return mF(n,r,c,m)}if(b instanceof DE){m=b.mo;var v=b.mh,x=b.nj;a.Hb&&a.F&&(n=ut(Q(),"| ",a.r)+"\u2022 Owned let bindings",ff(gf(),n+"\n"));n=b.ni.m();n=new iy(n,new y(F=>Pe(new E(F.fr),KE())),!0);Od();n=Pd(u(),n);if(n.b()){if(a.Hb&&a.F){var A=
+ut(Q(),"| ",a.r)+"  * \x3cNo bindings\x3e";ff(gf(),A+"\n")}}else for(A=n;!A.b();){var B=A.e();if(null!==B){var C=B.fr,D=B.Sj;B=B.gr;a.Hb&&a.F&&(C=ut(Q(),"| ",a.r)+("  * ("+C+") "+D+" \x3d ")+B,ff(gf(),C+"\n"))}else throw new w(B);A=A.f()}A=v.m();A=new Ef(A,new y(F=>F.xt()));A=kv(A,new U(()=>x));A=new xo(A,new y(F=>F.ni));A=new iy(A,new y(F=>Pe(new E(F.fr),KE())),!1);Od();A=Pd(u(),A);a.Hb&&a.F&&(C=ut(Q(),"| ",a.r)+"\u2022 Collect interleaved let bindings from case branches",ff(gf(),C+"\n"));if(A.b())a.Hb&&
+a.F&&(C=ut(Q(),"| ",a.r)+"  * \x3cNo interleaved bindings\x3e",ff(gf(),C+"\n"));else for(C=A;!C.b();){B=C.e();if(null!==B)D=B.Sj,B=B.gr,a.Hb&&a.F&&(D=ut(Q(),"| ",a.r)+("  * "+D+" \x3d ")+B,ff(gf(),D+"\n"));else throw new w(B);C=C.f()}if(v.b()){if(R()===x)throw a.Hb&&a.F&&(n=ut(Q(),"| ",a.r)+"\u2022 The match has neither branches nor default case",ff(gf(),n+"\n")),n=new Ue(J(new K,["found an empty match"])),iT(new jT,Ye(new Te(n),u()),m.nh.A());if(!(x instanceof L))throw new w(x);r=x.k;a.Hb&&a.F&&
+(v=ut(Q(),"| ",a.r)+"\u2022 Degenerated case: the match only has a wildcard",ff(gf(),v+"\n"));r=q5(a,r,c,d);v=m.no;if(t().d!==v){if(!(v instanceof L))throw new w(v);r=new Rl(!1,v.k,m.nh,r)}}else{a.Hb&&a.F&&(C=ut(Q(),"| ",a.r)+"\u2022 The match has some case branches",ff(gf(),C+"\n"));C=new y(()=>"\u2022 End for each");if(a.Hb){a.F&&(D=ut(Q(),"| ",a.r)+"\u2022 For each case branch",ff(gf(),D+"\n"));a.r=1+a.r|0;try{r=p5(a,v.ha(),c,m,x,d)}finally{a.r=-1+a.r|0}dx(new E(C),a.qa)&&a.F&&(v=""+ut(Q(),"| ",
+a.r)+C.n(r),ff(gf(),v+"\n"))}else r=p5(a,v.ha(),c,m,x,d);v=m.no;if(t().d===v)r=new Ul(m.nh,r);else{if(!(v instanceof L))throw new w(v);v=v.k;r=new Rl(!1,v,m.nh,new Ul(v,r))}}m=tF();v=tF();r=mF(v,A,c,r);return mF(m,n,c,r)}if(IE()===b)throw m=new Ue(J(new K,["missing a default branch"])),iT(new jT,Ye(new Te(m),u()),t().d);if(b instanceof CE)return m=b.hr,n=b.Dk,A=b.Fh,r=tF(),v=A.ni.ha(),C=A.ni.m(),C=new Ef(C,new y(F=>F.Sj)),A=q5(a,A,c.Ce(C),d),r=mF(r,v,c,A),v=tF(),A=n.ni.ha(),C=n.ni.m(),C=new Ef(C,
+new y(F=>F.Sj)),n=q5(a,n,c.Ce(C),d),n=mF(v,A,c,n),r=new ym(r),n=new um(new vl("true"),n,r),new Ul(m,n);throw new w(b);},h=a.qa;if(a.Hb){if(a.F){var k=ut(Q(),"| ",a.r)+("[rec] "+b.jb()+" -| {"+ze(c,"",", ",""))+"}";ff(gf(),k+"\n")}a.r=1+a.r|0;try{var l=g()}finally{a.r=-1+a.r|0}dx(new E(h),a.qa)&&a.F&&(g=""+ut(Q(),"| ",a.r)+h.n(l),ff(gf(),g+"\n"))}else l=g();return l},Efa=function r5(a,b,c,d,e,g){var k=O().c;if(null===k?null===c:k.i(c))return d;if(c instanceof z){var l=c.z;k=c.p;if(null!==l&&(l=new L(l),
+!l.b())){var m=l.k.h();l=l.k.j();if(null!==l){c=l.x;var n=e.nh;if(n instanceof vl&&c===n.x)return b=new vl(Z4(a,g)),c=GE(e),m=new Ql(b,new vl(m)),new Rl(!1,b,c,new Rl(!1,l,OS(m,e.nh),r5(a,b,k,d,e,g)));m=new Ql(b,new vl(m));return new Rl(!1,l,OS(m,e.nh),r5(a,b,k,d,e,g))}}}throw new w(c);};
+function s5(){this.io=this.ho=this.jo=null;this.Fp=this.Gp=this.an=this.Ep=0;this.qa=null;this.r=0;this.zk=this.Pq=this.Uq=this.xp=this.Bp=this.Cp=this.Sq=this.zp=this.Rq=this.wp=this.Ap=this.yp=this.Qq=this.Tq=null;this.Dp=0;this.hs=this.yq=this.Aq=this.Bq=this.zq=this.Dq=this.Cq=null;this.Im=this.Pw=0;this.iA=this.hA=this.Ku=null;this.Hb=!1;this.XA=0;this.YA=null}s5.prototype=new b3;s5.prototype.constructor=s5;function t5(){}t5.prototype=s5.prototype;
+function Ffa(a,b,c,d){var e=()=>{var l=Cfa(a,c);vE(xE(),l,new y(A=>{X4(a,A)}),"Super-class map","\x3c:");var m=Rca(xE(),l);vE(xE(),m,new y(A=>{X4(a,A)}),"Sub-class map",":\x3e");var n=xfa(a,b,O().c);if(null===n)throw new w(n);var r=n.h(),v=n.j();n=Xu().X();if(a.Hb&&a.F){var x=ut(Q(),"| ",a.r)+"### Desugar the UCS to decision paths ###";ff(gf(),x+"\n")}r=yfa(a,r,v,c,d,n);a.Hb&&a.F&&(v=ut(Q(),"| ",a.r)+"Exhaustiveness map",ff(gf(),v+"\n"));n.b()?a.Hb&&a.F&&(v=ut(Q(),"| ",a.r)+"  * \x3cNo entries\x3e",
+ff(gf(),v+"\n")):n.og(new fn((A,B)=>{a.Hb&&a.F&&(A=ut(Q(),"| ",a.r)+"  * Patterns of "+A,ff(gf(),A+"\n"));B.b()?a.Hb&&a.F&&(B=ut(Q(),"| ",a.r)+"    + \x3cNo patterns\x3e",ff(gf(),B+"\n")):B.og(new fn((C,D)=>{if(C instanceof fe)C="()^"+(C.aa|0);else{if(!(C instanceof Ud))throw new w(C);C=Zz(C.fa,!1)}D=ze(D,"[",", ","]");a.Hb&&a.F&&(D=ut(Q(),"| ",a.r)+("    + "+C+" -\x3e ")+D,ff(gf(),D+"\n"))}))}));a.Hb&&a.F&&(v=ut(Q(),"| ",a.r)+"### Build a case tree from decision paths ###",ff(gf(),v+"\n"));tp();
+n=n.m();n=pp(0,new Ef(n,new y(A=>{if(null!==A){var B=A.h();A=A.j();A=pp(tp().JK,A);return G(new H,B,A)}throw new w(A);})));l=Bfa(a,r,d,new y(A=>a5(a,A,c)),n,l);a.Hb&&a.F&&(r=ut(Q(),"| ",a.r)+"### Checking exhaustiveness of the case tree ###",ff(gf(),r+"\n"));zfa(a,l,t().d,c,d,n,m);a.Hb&&a.F&&(m=ut(Q(),"| ",a.r)+"### Construct a term from the case tree ###",ff(gf(),m+"\n"));m=Afa(a,l,c);a.F&&(l=ut(Q(),"| ",a.r)+"Desugared term: "+Zz(m,!1),ff(gf(),l+"\n"));b.oc=(t(),new L(m));return m},g=a.qa;if(a.Hb){if(a.F){var h=
+ut(Q(),"| ",a.r)+"[desugarIf]";ff(gf(),h+"\n")}a.r=1+a.r|0;try{var k=e()}finally{a.r=-1+a.r|0}dx(new E(g),a.qa)&&a.F&&(e=""+ut(Q(),"| ",a.r)+g.n(k),ff(gf(),e+"\n"))}else k=e();return k}function Gu(a,b){this.w=this.y=null;this.zF=a;this.oJ=b;G(this,null,null)}Gu.prototype=new h0;Gu.prototype.constructor=Gu;f=Gu.prototype;f.ut=function(){return this.zF};f.Sc=function(){return this.oJ};f.Cw=function(){return new Gu(this.oJ,this.zF)};f.iy=function(){return this.zF};f.j=function(){return this.oJ};
+f.h=function(){return this.zF};f.$classData=q({G0:0},!1,"scala.Tuple2$mcII$sp",{G0:1,by:1,g:1,LB:1,E:1,v:1,l:1,gba:1});function GG(a){this.tn=null;this.Al=this.wc=0;this.A4=a;Du(this,a)}GG.prototype=new u3;GG.prototype.constructor=GG;GG.prototype.t=function(){try{var a=this.A4.a[this.wc];this.wc=1+this.wc|0;var b=a}catch(c){if(c instanceof dI)b=Rq().Pa.t()|0;else throw c;}return b};
+GG.prototype.$classData=q({z4:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcB$sp",{z4:1,Qp:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});function FG(a){this.tn=null;this.Al=this.wc=0;this.C4=a;Du(this,a)}FG.prototype=new u3;FG.prototype.constructor=FG;FG.prototype.t=function(){try{var a=this.C4.a[this.wc];this.wc=1+this.wc|0;var b=a}catch(c){if(c instanceof dI)b=Ea(Rq().Pa.t());else throw c;}return hc(b)};
+FG.prototype.$classData=q({B4:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcC$sp",{B4:1,Qp:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});function CG(a){this.tn=null;this.Al=this.wc=0;this.E4=a;Du(this,a)}CG.prototype=new u3;CG.prototype.constructor=CG;CG.prototype.t=function(){try{var a=this.E4.a[this.wc];this.wc=1+this.wc|0;var b=a}catch(c){if(c instanceof dI)b=+Rq().Pa.t();else throw c;}return b};
+CG.prototype.$classData=q({D4:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcD$sp",{D4:1,Qp:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});function EG(a){this.tn=null;this.Al=this.wc=0;this.G4=a;Du(this,a)}EG.prototype=new u3;EG.prototype.constructor=EG;EG.prototype.t=function(){try{var a=this.G4.a[this.wc];this.wc=1+this.wc|0;var b=a}catch(c){if(c instanceof dI)b=Math.fround(Rq().Pa.t());else throw c;}return b};
+EG.prototype.$classData=q({F4:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcF$sp",{F4:1,Qp:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});function BG(a){this.tn=null;this.Al=this.wc=0;this.I4=a;Du(this,a)}BG.prototype=new u3;BG.prototype.constructor=BG;BG.prototype.t=function(){try{var a=this.I4.a[this.wc];this.wc=1+this.wc|0;var b=a}catch(c){if(c instanceof dI)b=Rq().Pa.t()|0;else throw c;}return b};
+BG.prototype.$classData=q({H4:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcI$sp",{H4:1,Qp:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});function DG(a){this.tn=null;this.Al=this.wc=0;this.K4=a;Du(this,a)}DG.prototype=new u3;DG.prototype.constructor=DG;DG.prototype.t=function(){try{var a=this.K4.a[this.wc],b=a.W,c=a.Y;this.wc=1+this.wc|0;var d=new ma(b,c)}catch(e){if(e instanceof dI)d=Za(Rq().Pa.t());else throw e;}return d};
+DG.prototype.$classData=q({J4:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcJ$sp",{J4:1,Qp:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});function HG(a){this.tn=null;this.Al=this.wc=0;this.M4=a;Du(this,a)}HG.prototype=new u3;HG.prototype.constructor=HG;HG.prototype.t=function(){try{var a=this.M4.a[this.wc];this.wc=1+this.wc|0;var b=a}catch(c){if(c instanceof dI)b=Rq().Pa.t()|0;else throw c;}return b};
+HG.prototype.$classData=q({L4:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcS$sp",{L4:1,Qp:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});function JG(a){this.tn=null;this.Al=this.wc=0;Du(this,a)}JG.prototype=new u3;JG.prototype.constructor=JG;JG.prototype.t=function(){try{this.wc=1+this.wc|0}catch(a){if(a instanceof dI)Rq().Pa.t();else throw a;}};JG.prototype.$classData=q({N4:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcV$sp",{N4:1,Qp:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});
+function IG(a){this.tn=null;this.Al=this.wc=0;this.P4=a;Du(this,a)}IG.prototype=new u3;IG.prototype.constructor=IG;IG.prototype.t=function(){try{var a=this.P4.a[this.wc];this.wc=1+this.wc|0;var b=a}catch(c){if(c instanceof dI)b=!!Rq().Pa.t();else throw c;}return b};IG.prototype.$classData=q({O4:0},!1,"scala.collection.ArrayOps$ArrayIterator$mcZ$sp",{O4:1,Qp:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});function CQ(a){this.WK=a}CQ.prototype=new q3;CQ.prototype.constructor=CQ;f=CQ.prototype;f.m=function(){Rq();return new g0(this.WK)};
+f.Q=function(){return 1};f.e=function(){return this.WK};f.Mc=function(){return this.WK};f.Bb=function(a){return 0<a?DK().X():this};f.Jc=function(a){return 0<a?DK().X():this};f.$classData=q({a5:0},!1,"scala.collection.Iterable$$anon$1",{a5:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1});function u5(a,b){if(a.b())throw nv("empty.min");var c=a.se();return(null===b?null===c:b.i(c))?a.e():b.sj(a.se())?a.Mc():gH(a,b)}
+function v5(a,b){if(a.b())throw nv("empty.max");var c=a.se();return(null===b?null===c:b.i(c))?a.Mc():b.sj(a.se())?a.e():hH(a,b)}function w5(a){return a.Ih()+"(\x3cnot computed\x3e)"}function x5(a,b){for(b=b.m();b.s();){var c=b.t();a=a.xj(c)}return a}function y5(a,b,c){var d=a.U(b);c=c.n(d);d=G(new H,d,c);c=d.y;var e=d.w;if(R()===c&&R()===e)return a;c=d.w;if(d.y instanceof L&&R()===c)return a.xj(b);c=d.w;if(c instanceof L)return a.Em(b,c.k);throw new w(d);}
+function z5(a){this.Dn=this.Io=0;this.BS=null;if(null===a)throw null;this.BS=a;this.Io=0;this.Dn=2}z5.prototype=new h4;z5.prototype.constructor=z5;z5.prototype.va=function(a){a:{var b=this.BS;switch(a){case 0:a=b.Zt;break a;case 1:a=b.jw;break a;default:throw new w(a);}}return a};z5.prototype.$classData=q({n8:0},!1,"scala.collection.immutable.Set$Set2$$anon$1",{n8:1,ES:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});
+function A5(a){this.Dn=this.Io=0;this.CS=null;if(null===a)throw null;this.CS=a;this.Io=0;this.Dn=3}A5.prototype=new h4;A5.prototype.constructor=A5;A5.prototype.va=function(a){a:{var b=this.CS;switch(a){case 0:a=b.Qr;break a;case 1:a=b.$t;break a;case 2:a=b.au;break a;default:throw new w(a);}}return a};A5.prototype.$classData=q({p8:0},!1,"scala.collection.immutable.Set$Set3$$anon$2",{p8:1,ES:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});
+function B5(a){this.Dn=this.Io=0;this.DS=null;if(null===a)throw null;this.DS=a;this.Io=0;this.Dn=4}B5.prototype=new h4;B5.prototype.constructor=B5;B5.prototype.va=function(a){return Gfa(this.DS,a)};B5.prototype.$classData=q({r8:0},!1,"scala.collection.immutable.Set$Set4$$anon$3",{r8:1,ES:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});function uV(a){this.bH=null;this.Uk=a;this.cu=null}uV.prototype=new eR;uV.prototype.constructor=uV;f=uV.prototype;f.he=function(){};f.Kb=function(){return tV(new sV,qJ(this.cu),this.Uk)};
+f.zc=function(a){a:{if(a instanceof sV){var b=a.We,c=this.Uk;if(null===b?null===c:b.i(c)){this.cu=null===this.cu?a.Jd:mJ(nJ(),qJ(this.cu),a.Jd,this.Uk);break a}}a&&a.$classData&&a.$classData.rb.Mk?(null===this.bH&&null===this.bH&&(this.bH=new yV(this)),b=this.bH,b.Yy=b.aH.cu,a.og(b),b.aH.cu=b.Yy,b.Yy=null):lR(this,a)}return this};f.$=function(a){this.cu=fR(this,this.cu,a.h(),a.j());return this};
+f.$classData=q({J8:0},!1,"scala.collection.immutable.TreeMap$TreeMapBuilder",{J8:1,e8:1,yS:1,g:1,Po:1,xg:1,xf:1,wf:1});function wZ(a){this.Uk=a;this.Sr=null}wZ.prototype=new hR;wZ.prototype.constructor=wZ;f=wZ.prototype;f.he=function(){};f.Kb=function(){return sZ(new rZ,qJ(this.Sr),this.Uk)};
+f.zc=function(a){a:{if(a instanceof rZ){var b=a.Xe,c=this.Uk;if(null===b?null===c:b.i(c)){this.Sr=null===this.Sr?a.Hf:mJ(nJ(),qJ(this.Sr),a.Hf,this.Uk);break a}}if(a instanceof sV&&(b=a.We,c=this.Uk,null===b?null===c:b.i(c))){this.Sr=null===this.Sr?a.Jd:mJ(nJ(),qJ(this.Sr),a.Jd,this.Uk);break a}lR(this,a)}return this};f.$=function(a){this.Sr=iR(this,this.Sr,a);return this};f.$classData=q({N8:0},!1,"scala.collection.immutable.TreeSet$TreeSetBuilder",{N8:1,Rba:1,yS:1,g:1,Po:1,xg:1,xf:1,wf:1});
+function o4(a){this.MS=!1;this.QL=null;this.qC=a;this.MS=a===da(td);this.QL=[]}o4.prototype=new l4;o4.prototype.constructor=o4;function C5(a,b){a.QL.push(a.MS?Ea(b):null===b?a.qC.qi.jz:b);return a}f=o4.prototype;f.Kb=function(){return md((this.qC===da(pd)?da(la):this.qC===da(jH)||this.qC===da(kH)?da(jd):this.qC).qi).iz(this.QL)};f.u=function(){return"ArrayBuilder.generic"};f.zc=function(a){for(a=a.m();a.s();){var b=a.t();C5(this,b)}return this};f.$=function(a){return C5(this,a)};
+f.$classData=q({g9:0},!1,"scala.collection.mutable.ArrayBuilder$generic",{g9:1,Uba:1,g:1,Po:1,xg:1,xf:1,wf:1,l:1});
+function D5(a,b,c,d){var e=1+wG(xG(),b)|0;if(0>c||c>=e)throw aL(new bL,c+" is out of bounds (min 0, max "+(-1+e|0)+")");e=(a.Ke-a.Zd|0)&(-1+a.ec.a.length|0)|0;var g=wG(xG(),b)-c|0;e=e<g?e:g;d=d<e?d:e;if(0<d){e=(a.Ke-a.Zd|0)&(-1+a.ec.a.length|0);if(0>=e)throw aL(new bL,"0 is out of bounds (min 0, max "+(-1+e|0)+")");e=(a.Zd+0|0)&(-1+a.ec.a.length|0);g=a.ec.a.length-e|0;g=d<g?d:g;VG(SG(),a.ec,e,b,c,g);d=d-g|0;0<d&&VG(SG(),a.ec,0,b,c+g|0,d)}return b}
+function E5(a,b){this.UK=null;this.PS=this.bk=this.Er=0;this.x9=b;Kr(this,a);this.PS=Es(b)|0}E5.prototype=new v3;E5.prototype.constructor=E5;E5.prototype.s=function(){mK();var a=this.PS,b=Es(this.x9)|0;jK(a,b);return 0<this.bk};E5.prototype.$classData=q({w9:0},!1,"scala.collection.mutable.CheckedIndexedSeqView$CheckedIterator",{w9:1,CR:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});function F5(a,b){this.VK=null;this.QS=this.Kv=this.zj=0;this.z9=b;uZ(this,a);this.QS=Es(b)|0}F5.prototype=new w3;
+F5.prototype.constructor=F5;F5.prototype.s=function(){mK();var a=this.QS,b=Es(this.z9)|0;jK(a,b);return 0<this.zj};F5.prototype.$classData=q({y9:0},!1,"scala.collection.mutable.CheckedIndexedSeqView$CheckedReverseIterator",{y9:1,DR:1,Sa:1,g:1,Ka:1,M:1,N:1,l:1});function G5(){}G5.prototype=new p;G5.prototype.constructor=G5;f=G5.prototype;f.uj=function(a,b){return 0>=this.Da(a,b)};f.Yj=function(a,b){return 0<=this.Da(a,b)};f.Xj=function(a,b){return 0<this.Da(a,b)};
+f.Yi=function(a,b){return x2(this,a,b)};f.Jk=function(a,b){return y2(this,a,b)};f.Kk=function(a,b){return z2(this,a,b)};f.sj=function(a){return A2(this,a)};f.Da=function(a,b){a=!!a;return a===!!b?0:a?1:-1};f.$classData=q({H3:0},!1,"scala.math.Ordering$Boolean$",{H3:1,g:1,sba:1,lm:1,Ji:1,mm:1,km:1,l:1});var H5;function PG(){H5||(H5=new G5);return H5}function I5(){}I5.prototype=new p;I5.prototype.constructor=I5;f=I5.prototype;f.uj=function(a,b){return 0>=this.Da(a,b)};
+f.Yj=function(a,b){return 0<=this.Da(a,b)};f.Xj=function(a,b){return 0<this.Da(a,b)};f.Yi=function(a,b){return x2(this,a,b)};f.Jk=function(a,b){return y2(this,a,b)};f.Kk=function(a,b){return z2(this,a,b)};f.sj=function(a){return A2(this,a)};f.Da=function(a,b){return(a|0)-(b|0)|0};f.$classData=q({I3:0},!1,"scala.math.Ordering$Byte$",{I3:1,g:1,tba:1,lm:1,Ji:1,mm:1,km:1,l:1});var J5;function NG(){J5||(J5=new I5);return J5}function K5(){}K5.prototype=new p;K5.prototype.constructor=K5;f=K5.prototype;
+f.uj=function(a,b){return 0>=this.Da(a,b)};f.Yj=function(a,b){return 0<=this.Da(a,b)};f.Xj=function(a,b){return 0<this.Da(a,b)};f.Yi=function(a,b){return x2(this,a,b)};f.Jk=function(a,b){return y2(this,a,b)};f.Kk=function(a,b){return z2(this,a,b)};f.sj=function(a){return A2(this,a)};f.Da=function(a,b){return Ea(a)-Ea(b)|0};f.$classData=q({J3:0},!1,"scala.math.Ordering$Char$",{J3:1,g:1,vba:1,lm:1,Ji:1,mm:1,km:1,l:1});var L5;function MG(){L5||(L5=new K5);return L5}function M5(){}M5.prototype=new p;
+M5.prototype.constructor=M5;f=M5.prototype;f.uj=function(a,b){return 0>=this.Da(a,b)};f.Yj=function(a,b){return 0<=this.Da(a,b)};f.Xj=function(a,b){return 0<this.Da(a,b)};f.Yi=function(a,b){return x2(this,a,b)};f.Jk=function(a,b){return y2(this,a,b)};f.Kk=function(a,b){return z2(this,a,b)};f.sj=function(a){return A2(this,a)};f.Da=function(a,b){var c=Za(a);a=c.W;c=c.Y;var d=Za(b);b=d.W;d=d.Y;return ua(xa(),a,c,b,d)};
+f.$classData=q({M3:0},!1,"scala.math.Ordering$Long$",{M3:1,g:1,wba:1,lm:1,Ji:1,mm:1,km:1,l:1});var N5;function LG(){N5||(N5=new M5);return N5}function O5(){}O5.prototype=new p;O5.prototype.constructor=O5;f=O5.prototype;f.uj=function(a,b){return 0>=this.Da(a,b)};f.Yj=function(a,b){return 0<=this.Da(a,b)};f.Xj=function(a,b){return 0<this.Da(a,b)};f.Yi=function(a,b){return x2(this,a,b)};f.Jk=function(a,b){return y2(this,a,b)};f.Kk=function(a,b){return z2(this,a,b)};f.sj=function(a){return A2(this,a)};
+f.Da=function(a,b){return(a|0)-(b|0)|0};f.$classData=q({O3:0},!1,"scala.math.Ordering$Short$",{O3:1,g:1,xba:1,lm:1,Ji:1,mm:1,km:1,l:1});var P5;function OG(){P5||(P5=new O5);return P5}function Q5(){}Q5.prototype=new p;Q5.prototype.constructor=Q5;f=Q5.prototype;f.uj=function(a,b){return 0>=this.Da(a,b)};f.Yj=function(a,b){return 0<=this.Da(a,b)};f.Xj=function(a,b){return 0<this.Da(a,b)};f.Yi=function(a,b){return x2(this,a,b)};f.Jk=function(a,b){return y2(this,a,b)};
+f.Kk=function(a,b){return z2(this,a,b)};f.sj=function(a){return A2(this,a)};f.Da=function(a,b){return pa(a,b)};f.$classData=q({P3:0},!1,"scala.math.Ordering$String$",{P3:1,g:1,yba:1,lm:1,Ji:1,mm:1,km:1,l:1});var R5;function cT(){R5||(R5=new Q5);return R5}function S5(){this.Ki=null;this.Gf=0}S5.prototype=new p;S5.prototype.constructor=S5;function T5(){}T5.prototype=S5.prototype;S5.prototype.u=function(){return this.Ki};S5.prototype.D=function(a){return a instanceof S5};
+S5.prototype.i=function(a){return this===a};S5.prototype.B=function(){return this.Gf};function U5(){}U5.prototype=new p;U5.prototype.constructor=U5;function V5(){}V5.prototype=U5.prototype;U5.prototype.D=function(a){return!!(a&&a.$classData&&a.$classData.rb.om)};
+class $d extends iW{constructor(a){super();this.mu=a;yF(this,null,null,!0)}qj(){return nb(this.mu)}H(){return"JavaScriptException"}G(){return 1}I(a){return 0===a?this.mu:$K(W(),a)}D(a){return a instanceof $d}B(){return AL(this)}i(a){if(this===a)return!0;if(a instanceof $d){var b=this.mu;a=a.mu;return ml(nl(),b,a)}return!1}}$d.prototype.$classData=q({L$:0},!1,"scala.scalajs.js.JavaScriptException",{L$:1,Te:1,qd:1,pc:1,g:1,l:1,E:1,v:1});function Zg(a){this.f1=a;this.PF=""}Zg.prototype=new L4;
+Zg.prototype.constructor=Zg;function ff(a,b){for(;""!==b;){var c=b.indexOf("\n")|0;if(0>c)a.PF=""+a.PF+b,b="";else{var d=""+a.PF+b.substring(0,c);"undefined"!==typeof console&&(a.f1&&console.error?console.error(d):console.log(d));a.PF="";b=b.substring(1+c|0)}}}Zg.prototype.$classData=q({e1:0},!1,"java.lang.JSConsoleBasedPrintStream",{e1:1,uaa:1,saa:1,taa:1,g:1,yT:1,R0:1,zT:1,rQ:1});function Vw(a,b,c,d,e){this.Iu=null;this.ij=b;this.ig=c;this.bo=d;this.Tz=e;if(null===a)throw null;this.Iu=a}
+Vw.prototype=new p;Vw.prototype.constructor=Vw;f=Vw.prototype;f.Mp=function(){return this.bo};f.Ea=function(){return this.Tz};f.Ua=function(){return this.ij.Ua()};f.fd=function(){return this.ij instanceof Ep?Ap():hx()};f.A=function(){return this.ij.A()};f.tr=function(){return!0};f.Nn=function(){return this.ig.ra};f.H=function(){return"NuParam"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.ij;case 1:return this.ig;case 2:return this.bo;default:return $K(W(),a)}};
+f.D=function(a){return a instanceof Vw};f.B=function(){var a=lb("NuParam");a=W().C(-889275714,a);var b=this.ij;b=My(W(),b);a=W().C(a,b);b=this.ig;b=My(W(),b);a=W().C(a,b);b=this.bo?1231:1237;a=W().C(a,b);return W().Ma(a,3)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Vw&&a.Iu===this.Iu){if(this.bo===a.bo){var b=this.ij,c=a.ij;b=null===b?null===c:b.i(c)}else b=!1;if(b)return b=this.ig,a=a.ig,null===b?null===a:b.i(a)}return!1};f.bG=function(){return this.Iu};
+f.cm=function(a,b){var c=this.Iu,d=this.ij,e=this.ig,g=e.Va,h=e.Oa;h.b()?h=R():(h=h.o(),h=new L(b.ba(new UB(a),h)));return new Vw(c,d,new Uw(g,h,b.ba(a,e.ra),e.Pd),this.bo,this.Tz)};f.yl=function(a,b,c){b=this.Iu;var d=this.ij,e=this.ig,g=e.Va,h=e.Oa;if(h.b())h=R();else{h=h.o();if(a.b())var k=R();else k=!!a.o(),k=new L(!k);h=new L(c.ba(k,h))}return new Vw(b,d,new Uw(g,h,c.ba(a,e.ra),e.Pd),this.bo,this.Tz)};f.ro=function(a,b,c,d){return new Vw(this.Iu,this.ij,LX(this.ig,a,b,c,d),this.bo,c.da)};
+f.$classData=q({wX:0},!1,"mlscript.NuTypeDefs$NuParam",{wX:1,g:1,nx:1,xE:1,Rs:1,TN:1,E:1,v:1,l:1});function Hfa(a){if(!a.SH){var b=a.Ei,c=a.gh,d=k=>{if(null!==k){var l=k.kc,m=k.hb;if(null!==l){k=a.Rf.gb.V+"#"+l.V;var n=a.nc,r=a.nc;t();l=new Vw(n,l,new Uw(r,new L(m),m,V(a.nc)),!0,a.Sm);return G(new H,k,l)}}throw new w(k);};if(c===u())d=u();else{var e=c.e(),g=e=new z(d(e),u());for(c=c.f();c!==u();){var h=c.e();h=new z(d(h),u());g=g.p=h;c=c.f()}d=e}a.TH=b.bf(d).bf(a.Tm);a.SH=!0}return a.TH}
+function Yw(a,b,c,d,e,g,h,k,l,m,n){this.RH=this.TH=this.nc=this.px=null;this.SH=!1;this.Sm=b;this.Rf=c;this.gh=d;this.Ij=e;this.gl=g;this.Ei=h;this.Um=k;this.sk=l;this.ip=m;this.Tm=n;MS(this,a,Bp());this.RH=t().d}Yw.prototype=new NS;Yw.prototype.constructor=Yw;f=Yw.prototype;f.Ea=function(){return this.Sm};f.Yr=function(){return this.Rf};f.Ag=function(){return this.gh};f.aG=function(){return this.Ei};f.fd=function(){return this.Rf.pb};f.cG=function(){return this.Rf.gb};f.Ua=function(){return this.Rf.gb.V};
+f.tr=function(){return!0};f.Mp=function(){return!0};f.LC=function(){return this.SH?this.TH:Hfa(this)};
+function Ay(a,b){var c=a.RH;if(c instanceof L)return c.k;if(t().d===c){c=a.nc;var d=new y(r=>"\x3d "+r);if(c.F){var e=ut(Q(),"| ",c.r)+"Computing variances of "+a.Rf.gb.V;ff(gf(),e+"\n")}c.r=1+c.r|0;try{var g=new $e;ofa(a.nc);var h=Xu().X(),k=jA().X();a.Ei.og(new fn((r,v)=>{if(!(v instanceof Vw&&v.ij instanceof Ep)){r=ID;if(g.sb)var x=g.vb;else{if(null===g)throw le();x=g.sb?g.vb:me(g,new LS(a,b,k,h))}r(x,gA(a.nc).Pj,v)}}));var l=a.gh.m(),m=h.bf(new Ex(l,new L_(a)));a.RH=(t(),new L(m));var n=m}finally{c.r=
+-1+c.r|0}dx(new E(d),c.qa)&&c.F&&(l=""+ut(Q(),"| ",c.r)+d.n(n),ff(gf(),l+"\n"));return n}throw new w(c);}function RA(a,b,c){return Ay(a,c).Se(b,new U(()=>ou().Yl))}
+function Zw(a,b,c,d,e){var g=new Iw(d.S,d.Ec,d.hc,d.Ed,1+d.da|0,d.Pc,d.Zc,d.Lb,d.yc,d.tb,d.$a,d.od,d.cb),h=a.nc;d=d.da;var k=a.Rf,l=a.gh,m=B=>{var C=B.kc,D=B.hb.Kc(b,c,g,e);return new tl(C,hD(D),B.Rd)};if(l===u())m=u();else{var n=l.e(),r=n=new z(m(n),u());for(l=l.f();l!==u();){var v=l.e();v=new z(m(v),u());r=r.p=v;l=l.f()}m=n}n=a.Ij;n.b()?n=R():(n=n.o(),n=new L(ry(lv(),n,new y(B=>LX(B,b,c,g,e)))));r=a.gl;r.b()?r=R():(r=r.o(),r=new L(ry(lv(),r,new y(B=>B.Kc(b,c,g,e)))));l=KF(lv(),a.Ei,new y(B=>B.ro(b,
+c,g,e)));op();l=pp(qp(),l);v=a.Um.Kc(b,c,g,e);var x=a.sk.Kc(b,c,g,e),A=a.ip;a=KF(lv(),a.Tm,new y(B=>B.ro(b,c,g,e)));op();return new Yw(h,d,k,m,n,r,l,v,x,A,pp(qp(),a))}
+function Ifa(a,b,c,d,e){var g=a.nc,h=a.Sm,k=a.Rf,l=a.gh,m=B=>{var C=B.kc,D=d.ba(t().d,B.hb);return new tl(C,hD(D),B.Rd)};if(l===u())m=u();else{var n=l.e(),r=n=new z(m(n),u());for(l=l.f();l!==u();){var v=l.e();v=new z(m(v),u());r=r.p=v;l=l.f()}m=n}n=a.Ij;n.b()?n=R():(n=n.o(),n=new L(ry(lv(),n,new y(B=>{var C=B.Va,D=B.Oa;if(D.b())D=R();else{D=D.o();if(b.b())var F=R();else F=!!b.o(),F=new L(!F);D=new L(d.ba(F,D))}return new Uw(C,D,d.ba(b,B.ra),B.Pd)}))));r=a.gl;r.b()?r=R():(r=r.o(),r=new L(ry(lv(),r,
+new y(B=>{if(b.b())var C=R();else C=!!b.o(),C=new L(!C);return d.ba(C,B)}))));l=KF(lv(),a.Ei,new y(B=>B.yl(b,c,d,e)));op();l=pp(qp(),l);b.b()?v=R():(v=!!b.o(),v=new L(!v));v=d.ba(v,a.Um);var x=d.ba(b,a.sk),A=a.ip;a=KF(lv(),a.Tm,new y(B=>B.yl(b,c,d,e)));op();return new Yw(g,h,k,m,n,r,l,v,x,A,pp(qp(),a))}
+function Jfa(a,b,c,d){var e=a.nc,g=a.Sm,h=a.Rf,k=a.gh,l=A=>{var B=A.kc,C=c.ba(new TB(b),A.hb);return new tl(B,hD(C),A.Rd)};if(k===u())l=u();else{var m=k.e(),n=m=new z(l(m),u());for(k=k.f();k!==u();){var r=k.e();r=new z(l(r),u());n=n.p=r;k=k.f()}l=m}m=a.Ij;m.b()?m=R():(m=m.o(),m=new L(ry(lv(),m,new y(A=>{var B=A.Va,C=A.Oa;C.b()?C=R():(C=C.o(),C=new L(c.ba(new UB(b),C)));return new Uw(B,C,c.ba(b,A.ra),A.Pd)}))));n=a.gl;n.b()?n=R():(n=n.o(),n=new L(ry(lv(),n,new y(A=>c.ba(new UB(b),A)))));k=KF(lv(),
+a.Ei,new y(A=>A.cm(b,c,d)));op();k=pp(qp(),k);r=c.ba(new UB(b),a.Um);var v=c.ba(b,a.sk),x=a.ip;a=KF(lv(),a.Tm,new y(A=>A.cm(b,c,d)));op();return new Yw(e,g,h,l,m,n,k,r,v,x,pp(qp(),a))}f.u=function(){var a=this.Ei;return"TypedNuCls("+this.Sm+", "+this.Rf.gb+",\n\t"+this.gh+",\n\t"+this.Ij+",\n\tthis: "+this.Um+", "+CF(GF(),a)+",\n\t: "+this.sk+", "+this.ip+", "+this.Tm+")"};f.H=function(){return"TypedNuCls"};f.G=function(){return 10};
+f.I=function(a){switch(a){case 0:return this.Sm;case 1:return this.Rf;case 2:return this.gh;case 3:return this.Ij;case 4:return this.gl;case 5:return this.Ei;case 6:return this.Um;case 7:return this.sk;case 8:return this.ip;case 9:return this.Tm;default:return $K(W(),a)}};f.D=function(a){return a instanceof Yw};
+f.B=function(){var a=lb("TypedNuCls");a=W().C(-889275714,a);var b=this.Sm;a=W().C(a,b);b=this.Rf;b=My(W(),b);a=W().C(a,b);b=this.gh;b=My(W(),b);a=W().C(a,b);b=this.Ij;b=My(W(),b);a=W().C(a,b);b=this.gl;b=My(W(),b);a=W().C(a,b);b=this.Ei;b=My(W(),b);a=W().C(a,b);b=this.Um;b=My(W(),b);a=W().C(a,b);b=this.sk;b=My(W(),b);a=W().C(a,b);b=this.ip;b=My(W(),b);a=W().C(a,b);b=this.Tm;b=My(W(),b);a=W().C(a,b);return W().Ma(a,10)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Yw&&a.nc===this.nc){if(this.Sm===a.Sm){var b=this.Rf,c=a.Rf;b=null===b?null===c:b.i(c)}else b=!1;b?(b=this.gh,c=a.gh,(null===b?null===c:b.i(c))?(b=this.Ij,c=a.Ij,(null===b?null===c:b.i(c))?(b=this.gl,c=a.gl,b=null===b?null===c:b.i(c)):b=!1):b=!1):b=!1;if(b&&(b=this.Ei,c=a.Ei,(null===b?null===c:b.i(c))?(b=this.Um,c=a.Um,(null===b?null===c:mC(b,c))?(b=this.sk,c=a.sk,b=null===b?null===c:mC(b,c)):b=!1):b=!1,b&&(b=this.ip,c=a.ip,null===b?null===c:b.i(c))))return b=
+this.Tm,a=a.Tm,null===b?null===a:b.i(a)}return!1};f.cm=function(a,b,c){return Jfa(this,a,b,c)};f.yl=function(a,b,c,d){return Ifa(this,a,b,c,d)};f.ro=function(a,b,c,d){return Zw(this,a,b,c,d)};f.$classData=q({AX:0},!1,"mlscript.NuTypeDefs$TypedNuCls",{AX:1,YH:1,g:1,Rs:1,nx:1,HN:1,E:1,v:1,l:1});function cx(a,b){this.ox=null;this.wE=b;if(null===a)throw null;this.ox=a}cx.prototype=new p;cx.prototype.constructor=cx;f=cx.prototype;f.Ea=function(){return this.ox.Gd};f.fd=function(){return hx()};f.A=function(){return t().d};
+f.Ua=function(){return this.wE.Cf.x};f.tr=function(){return!0};f.Mp=function(){return!0};f.Nn=function(){return Ey(this.ox)};f.H=function(){return"TypedNuDummy"};f.G=function(){return 1};f.I=function(a){return 0===a?this.wE:$K(W(),a)};f.D=function(a){return a instanceof cx};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof cx&&a.ox===this.ox){var b=this.wE;a=a.wE;return null===b?null===a:b.i(a)}return!1};f.bG=function(){return this.ox};
+f.cm=function(){return this};f.yl=function(){return this};f.ro=function(){return this};f.$classData=q({DX:0},!1,"mlscript.NuTypeDefs$TypedNuDummy",{DX:1,g:1,Rs:1,nx:1,xE:1,TN:1,E:1,v:1,l:1});function bx(a,b,c,d,e){this.MN=this.LN=null;this.Ss=0;this.Sl=null;this.jp=b;this.Mb=c;this.hh=d;this.Ts=e;if(null===a)throw null;this.Sl=a}bx.prototype=new p;bx.prototype.constructor=bx;f=bx.prototype;f.Ea=function(){return this.jp};f.tr=function(){return this.Ts};f.fd=function(){return hx()};f.Ua=function(){return this.Mb.Rb.x};
+f.A=function(){return this.Mb.A()};f.ma=function(){0===(1&this.Ss)<<24>>24&&0===(1&this.Ss)<<24>>24&&(this.LN=jx(new kx,this.Sl,this.Mb.A(),"member",(tx(this.Sl),t().d),(tx(this.Sl),!1)),this.Ss=(1|this.Ss)<<24>>24);return this.LN};f.Mp=function(){return!rx(this.Mb)};f.Nn=function(){0===(2&this.Ss)<<24>>24&&0===(2&this.Ss)<<24>>24&&(this.MN=this.Mb.Om.b()?yx(zx(this.Sl),this.jp,this.hh):this.hh,this.Ss=(2|this.Ss)<<24>>24);return this.MN};
+function Iy(a){var b=a.Mb.Yc;b instanceof fe?a=Vy(a.Sl,b.aa):(a=a.Sl,null===a.Ku&&null===a.Ku&&(a.Ku=new WO(a)),a=a.Ku,a.OH||a.OH||(a.JN=new XX(a.IN,t().d,ap()),a.OH=!0),a=a.JN);return a}f.H=function(){return"TypedNuFun"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.jp;case 1:return this.Mb;case 2:return this.hh;default:return $K(W(),a)}};f.D=function(a){return a instanceof bx};
+f.B=function(){var a=lb("TypedNuFun");a=W().C(-889275714,a);var b=this.jp;a=W().C(a,b);b=this.Mb;b=My(W(),b);a=W().C(a,b);b=this.hh;b=My(W(),b);a=W().C(a,b);return W().Ma(a,3)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof bx&&a.Sl===this.Sl){if(this.jp===a.jp){var b=this.Mb,c=a.Mb;b=null===b?null===c:b.i(c)}else b=!1;if(b)return b=this.hh,a=a.hh,null===b?null===a:mC(b,a)}return!1};f.bG=function(){return this.Sl};
+f.cm=function(a,b){return new bx(this.Sl,this.jp,this.Mb,b.ba(a,this.hh),this.Ts)};f.yl=function(a,b,c){return new bx(this.Sl,this.jp,this.Mb,c.ba(a,this.hh),this.Ts)};f.ro=function(a,b,c,d){var e=new Iw(c.S,c.Ec,c.hc,c.Ed,1+c.da|0,c.Pc,c.Zc,c.Lb,c.yc,c.tb,c.$a,c.od,c.cb);return new bx(this.Sl,c.da,this.Mb,this.hh.Kc(a,b,e,d),this.Ts)};f.$classData=q({EX:0},!1,"mlscript.NuTypeDefs$TypedNuFun",{EX:1,g:1,Rs:1,nx:1,xE:1,TN:1,E:1,v:1,l:1});
+function Kfa(a){if(!a.UH){var b=a.Jj,c=a.kl,d=k=>{if(null!==k){var l=k.kc,m=k.hb;if(null!==l){k=a.il.gb.V+"#"+l.V;var n=a.nc,r=a.nc;t();l=new Vw(n,l,new Uw(r,new L(m),m,V(a.nc)),!1,a.Fq);return G(new H,k,l)}}throw new w(k);};if(c===u())d=u();else{var e=c.e(),g=e=new z(d(e),u());for(c=c.f();c!==u();){var h=c.e();h=new z(d(h),u());g=g.p=h;c=c.f()}d=e}a.VH=b.bf(d);a.UH=!0}return a.VH}
+function Nw(a,b,c,d,e,g,h,k){this.VH=this.nc=this.px=null;this.UH=!1;this.Fq=b;this.il=c;this.jl=d;this.hl=e;this.kl=g;this.Tl=h;this.Jj=k;MS(this,a,cp())}Nw.prototype=new NS;Nw.prototype.constructor=Nw;f=Nw.prototype;f.Ea=function(){return this.Fq};f.Yr=function(){return this.il};f.Ag=function(){return this.kl};f.aG=function(){return this.Jj};f.fd=function(){return this.il.pb};f.cG=function(){return this.il.gb};f.Ua=function(){return this.il.gb.V};f.tr=function(){return!0};f.Mp=function(){return!0};
+f.LC=function(){return this.UH?this.VH:Kfa(this)};
+function Qw(a,b,c,d,e){var g=new Iw(d.S,d.Ec,d.hc,d.Ed,1+d.da|0,d.Pc,d.Zc,d.Lb,d.yc,d.tb,d.$a,d.od,d.cb),h=a.nc;d=d.da;var k=a.il,l=a.jl.Kc(b,c,g,e),m=a.hl.Kc(b,c,g,e),n=a.kl,r=B=>{var C=B.kc,D=B.hb.Kc(b,c,g,e);return new tl(C,hD(D),B.Rd)};if(n===u())r=u();else{var v=n.e(),x=v=new z(r(v),u());for(n=n.f();n!==u();){var A=n.e();A=new z(r(A),u());x=x.p=A;n=n.f()}r=v}v=ry(lv(),a.Tl,new y(B=>LX(B,b,c,g,e)));a=KF(lv(),a.Jj,new y(B=>B.ro(b,c,g,e)));op();return new Nw(h,d,k,l,m,r,v,pp(qp(),a))}
+function Lfa(a,b,c,d,e){var g=a.nc,h=a.Fq,k=a.il;if(b.b())var l=R();else l=!!b.o(),l=new L(!l);l=d.ba(l,a.jl);if(b.b())var m=R();else m=!!b.o(),m=new L(!m);m=d.ba(m,a.hl);var n=a.kl,r=B=>{var C=B.kc,D=d.ba(t().d,B.hb);return new tl(C,hD(D),B.Rd)};if(n===u())r=u();else{var v=n.e(),x=v=new z(r(v),u());for(n=n.f();n!==u();){var A=n.e();A=new z(r(A),u());x=x.p=A;n=n.f()}r=v}v=ry(lv(),a.Tl,new y(B=>{var C=B.Va,D=B.Oa;if(D.b())D=R();else{D=D.o();if(b.b())var F=R();else F=!!b.o(),F=new L(!F);D=new L(d.ba(F,
+D))}return new Uw(C,D,d.ba(b,B.ra),B.Pd)}));a=KF(lv(),a.Jj,new y(B=>B.yl(b,c,d,e)));op();return new Nw(g,h,k,l,m,r,v,pp(qp(),a))}
+function Mfa(a,b,c,d){var e=a.nc,g=a.Fq,h=a.il,k=c.ba(new UB(b),a.jl),l=c.ba(new UB(b),a.hl),m=a.kl,n=A=>{var B=A.kc,C=c.ba(new TB(b),A.hb);return new tl(B,hD(C),A.Rd)};if(m===u())n=u();else{var r=m.e(),v=r=new z(n(r),u());for(m=m.f();m!==u();){var x=m.e();x=new z(n(x),u());v=v.p=x;m=m.f()}n=r}r=ry(lv(),a.Tl,new y(A=>{var B=A.Va,C=A.Oa;C.b()?C=R():(C=C.o(),C=new L(c.ba(new UB(b),C)));return new Uw(B,C,c.ba(b,A.ra),A.Pd)}));a=KF(lv(),a.Jj,new y(A=>A.cm(b,c,d)));op();return new Nw(e,g,h,k,l,n,r,pp(qp(),
+a))}f.u=function(){var a=this.Jj;return"TypedNuMxn("+this.Fq+", "+this.il.gb+",\n\tthis: "+this.jl+",\n\tsuper: "+this.hl+",\n\ttparams: "+this.kl+",\n\tparams: "+this.Tl+",\n\tmembers: "+CF(GF(),a)+"\n)"};f.H=function(){return"TypedNuMxn"};f.G=function(){return 7};f.I=function(a){switch(a){case 0:return this.Fq;case 1:return this.il;case 2:return this.jl;case 3:return this.hl;case 4:return this.kl;case 5:return this.Tl;case 6:return this.Jj;default:return $K(W(),a)}};
+f.D=function(a){return a instanceof Nw};f.B=function(){var a=lb("TypedNuMxn");a=W().C(-889275714,a);var b=this.Fq;a=W().C(a,b);b=this.il;b=My(W(),b);a=W().C(a,b);b=this.jl;b=My(W(),b);a=W().C(a,b);b=this.hl;b=My(W(),b);a=W().C(a,b);b=this.kl;b=My(W(),b);a=W().C(a,b);b=this.Tl;b=My(W(),b);a=W().C(a,b);b=this.Jj;b=My(W(),b);a=W().C(a,b);return W().Ma(a,7)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Nw&&a.nc===this.nc){if(this.Fq===a.Fq){var b=this.il,c=a.il;b=null===b?null===c:b.i(c)}else b=!1;b?(b=this.jl,c=a.jl,(null===b?null===c:mC(b,c))?(b=this.hl,c=a.hl,b=null===b?null===c:mC(b,c)):b=!1):b=!1;if(b&&(b=this.kl,c=a.kl,(null===b?null===c:b.i(c))?(b=this.Tl,c=a.Tl,b=null===b?null===c:b.i(c)):b=!1,b))return b=this.Jj,a=a.Jj,null===b?null===a:b.i(a)}return!1};f.cm=function(a,b,c){return Mfa(this,a,b,c)};
+f.yl=function(a,b,c,d){return Lfa(this,a,b,c,d)};f.ro=function(a,b,c,d){return Qw(this,a,b,c,d)};f.$classData=q({FX:0},!1,"mlscript.NuTypeDefs$TypedNuMxn",{FX:1,YH:1,g:1,Rs:1,nx:1,HN:1,E:1,v:1,l:1});
+function Nfa(a){if(!a.WH){var b=a.tk,c=a.wk,d=k=>{if(null!==k){var l=k.kc,m=k.hb;if(null!==l){k=a.vk.gb.V+"#"+l.V;var n=a.nc,r=a.nc;t();l=new Vw(n,l,new Uw(r,new L(m),m,V(a.nc)),!0,a.Hq);return G(new H,k,l)}}throw new w(k);};if(c===u())d=u();else{var e=c.e(),g=e=new z(d(e),u());for(c=c.f();c!==u();){var h=c.e();h=new z(d(h),u());g=g.p=h;c=c.f()}d=e}a.XH=b.bf(d).bf(a.Vm);a.WH=!0}return a.XH}
+function Ww(a,b,c,d,e,g,h,k,l){this.XH=this.nc=this.px=null;this.WH=!1;this.Hq=b;this.vk=c;this.wk=d;this.tk=e;this.co=g;this.uk=h;this.Gq=k;this.Vm=l;MS(this,a,Fp())}Ww.prototype=new NS;Ww.prototype.constructor=Ww;f=Ww.prototype;f.Ea=function(){return this.Hq};f.Yr=function(){return this.vk};f.Ag=function(){return this.wk};f.aG=function(){return this.tk};f.fd=function(){return this.vk.pb};f.cG=function(){return this.vk.gb};f.Ua=function(){return this.vk.gb.V};f.tr=function(){return!0};f.Mp=function(){return!0};
+f.LC=function(){return this.WH?this.XH:Nfa(this)};
+function Xw(a,b,c,d,e){var g=new Iw(d.S,d.Ec,d.hc,d.Ed,1+d.da|0,d.Pc,d.Zc,d.Lb,d.yc,d.tb,d.$a,d.od,d.cb),h=a.nc;d=d.da;var k=a.vk,l=a.wk,m=x=>{var A=x.kc,B=x.hb.Kc(b,c,g,e);return new tl(A,hD(B),x.Rd)};if(l===u())m=u();else{var n=l.e(),r=n=new z(m(n),u());for(l=l.f();l!==u();){var v=l.e();v=new z(m(v),u());r=r.p=v;l=l.f()}m=n}n=KF(lv(),a.tk,new y(x=>x.ro(b,c,g,e)));op();n=pp(qp(),n);r=a.co.Kc(b,c,g,e);l=a.uk.Kc(b,c,g,e);v=a.Gq;a=KF(lv(),a.Vm,new y(x=>x.ro(b,c,g,e)));op();return new Ww(h,d,k,m,n,r,
+l,v,pp(qp(),a))}function Ofa(a,b,c,d,e){var g=a.nc,h=a.Hq,k=a.vk,l=a.wk,m=x=>{var A=x.kc,B=d.ba(t().d,x.hb);return new tl(A,hD(B),x.Rd)};if(l===u())m=u();else{var n=l.e(),r=n=new z(m(n),u());for(l=l.f();l!==u();){var v=l.e();v=new z(m(v),u());r=r.p=v;l=l.f()}m=n}n=KF(lv(),a.tk,new y(x=>x.yl(b,c,d,e)));op();n=pp(qp(),n);b.b()?r=R():(r=!!b.o(),r=new L(!r));r=d.ba(r,a.co);l=d.ba(b,a.uk);v=a.Gq;a=KF(lv(),a.Vm,new y(x=>x.yl(b,c,d,e)));op();return new Ww(g,h,k,m,n,r,l,v,pp(qp(),a))}
+function Pfa(a,b,c,d){var e=a.nc,g=a.Hq,h=a.vk,k=a.wk,l=v=>{var x=v.kc,A=c.ba(new TB(b),v.hb);return new tl(x,hD(A),v.Rd)};if(k===u())l=u();else{var m=k.e(),n=m=new z(l(m),u());for(k=k.f();k!==u();){var r=k.e();r=new z(l(r),u());n=n.p=r;k=k.f()}l=m}m=KF(lv(),a.tk,new y(v=>v.cm(b,c,d)));op();m=pp(qp(),m);n=c.ba(new UB(b),a.co);k=c.ba(b,a.uk);r=a.Gq;a=KF(lv(),a.Vm,new y(v=>v.cm(b,c,d)));op();return new Ww(e,g,h,l,m,n,k,r,pp(qp(),a))}f.H=function(){return"TypedNuTrt"};f.G=function(){return 8};
+f.I=function(a){switch(a){case 0:return this.Hq;case 1:return this.vk;case 2:return this.wk;case 3:return this.tk;case 4:return this.co;case 5:return this.uk;case 6:return this.Gq;case 7:return this.Vm;default:return $K(W(),a)}};f.D=function(a){return a instanceof Ww};
+f.B=function(){var a=lb("TypedNuTrt");a=W().C(-889275714,a);var b=this.Hq;a=W().C(a,b);b=this.vk;b=My(W(),b);a=W().C(a,b);b=this.wk;b=My(W(),b);a=W().C(a,b);b=this.tk;b=My(W(),b);a=W().C(a,b);b=this.co;b=My(W(),b);a=W().C(a,b);b=this.uk;b=My(W(),b);a=W().C(a,b);b=this.Gq;b=My(W(),b);a=W().C(a,b);b=this.Vm;b=My(W(),b);a=W().C(a,b);return W().Ma(a,8)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Ww&&a.nc===this.nc){if(this.Hq===a.Hq){var b=this.vk,c=a.vk;b=null===b?null===c:b.i(c)}else b=!1;b?(b=this.wk,c=a.wk,(null===b?null===c:b.i(c))?(b=this.tk,c=a.tk,b=null===b?null===c:b.i(c)):b=!1):b=!1;if(b&&(b=this.co,c=a.co,(null===b?null===c:mC(b,c))?(b=this.uk,c=a.uk,b=null===b?null===c:mC(b,c)):b=!1,b&&(b=this.Gq,c=a.Gq,null===b?null===c:b.i(c))))return b=this.Vm,a=a.Vm,null===b?null===a:b.i(a)}return!1};
+f.cm=function(a,b,c){return Pfa(this,a,b,c)};f.yl=function(a,b,c,d){return Ofa(this,a,b,c,d)};f.ro=function(a,b,c,d){return Xw(this,a,b,c,d)};f.$classData=q({GX:0},!1,"mlscript.NuTypeDefs$TypedNuTrt",{GX:1,YH:1,g:1,Rs:1,nx:1,HN:1,E:1,v:1,l:1});function BP(a,b){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.yx=a;this.aA=b;Nq(this)}BP.prototype=new ZS;BP.prototype.constructor=BP;f=BP.prototype;f.Vj=function(){return this.yx};f.H=function(){return"Signature"};
+f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.yx;case 1:return this.aA;default:return $K(W(),a)}};f.D=function(a){return a instanceof BP};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof BP){var b=this.yx,c=a.yx;if(null===b?null===c:b.i(c))return b=this.aA,a=a.aA,null===b?null===a:b.i(a)}return!1};f.$classData=q({hY:0},!1,"mlscript.Signature",{hY:1,ih:1,g:1,jh:1,Ta:1,Haa:1,E:1,v:1,l:1});
+function W5(a){Nq(a);a.oc=t().d;a.nd=t().d}function Pm(){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0}Pm.prototype=new p;Pm.prototype.constructor=Pm;function X5(){}f=X5.prototype=Pm.prototype;f.jb=function(){return hu(this)};f.Wr=function(){return Zz(this,!1)};f.Vj=function(){return eP(this)};f.nv=function(){0===(1&this.gc)<<24>>24&&0===(1&this.gc)<<24>>24&&(this.yd=cP(this),this.gc=(1|this.gc)<<24>>24);return this.yd};
+f.jn=function(){0===(2&this.gc)<<24>>24&&0===(2&this.gc)<<24>>24&&(this.zd=zq(this),this.gc=(2|this.gc)<<24>>24);return this.zd};f.rn=function(){return this.Cd};f.fm=function(a){this.Cd=a};f.qn=function(){return this.Bd};f.em=function(a){this.Bd=a};f.pn=function(){return this.Ad};f.on=function(a){this.Ad=a};f.A=function(){0===(4&this.gc)<<24>>24&&0===(4&this.gc)<<24>>24&&(this.Dd=Dq(this),this.gc=(4|this.gc)<<24>>24);return this.Dd};function Y5(){this.ld="trait"}Y5.prototype=new XS;
+Y5.prototype.constructor=Y5;f=Y5.prototype;f.H=function(){return"Trt"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof Y5};f.B=function(){return 84374};f.u=function(){return"Trt"};f.$classData=q({qY:0},!1,"mlscript.Trt$",{qY:1,EE:1,sz:1,sx:1,g:1,ZH:1,E:1,v:1,l:1});var Z5;function Fp(){Z5||(Z5=new Y5);return Z5}function Vv(){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0}Vv.prototype=new W4;Vv.prototype.constructor=Vv;
+function $5(){}$5.prototype=Vv.prototype;function LA(a,b,c,d,e){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0;this.tc=b;this.ic=c;this.jc=d;this.KE=e;pY(this,a)}LA.prototype=new qY;LA.prototype.constructor=LA;f=LA.prototype;f.ma=function(){return this.KE};f.Ea=function(){var a=this.ic.Ea(),b=this.jc.Ea();return a>b?a:b};f.ub=function(a,b){var c=this.ic.ub(a,b);a=this.jc.ub(a,b);return c>a?c:a};f.u=function(){return"("+this.ic+" "+(this.tc?"|":"\x26")+" "+this.jc+")"};
+f.H=function(){return"ComposedType"};f.G=function(){return 3};f.I=function(a){switch(a){case 0:return this.tc;case 1:return this.ic;case 2:return this.jc;default:return $K(W(),a)}};f.D=function(a){return a instanceof LA};f.$classData=q({aZ:0},!1,"mlscript.TyperDatatypes$ComposedType",{aZ:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,E:1,v:1,l:1});function Qfa(a){if(!a.uI){var b=ED(a,!1).m();b=new Ef(b,new y(d=>d.Ea()));var c=Fq();a.vI=hH(b,c)|0;a.uI=!0}return a.vI}
+function eC(a,b,c){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.vI=this.dd=0;this.hO=null;this.uI=!1;this.Lj=b;this.kj=c;pY(this,a);this.hO=c.ma()}eC.prototype=new qY;eC.prototype.constructor=eC;f=eC.prototype;f.ma=function(){return this.hO};f.Ea=function(){return this.uI?this.vI:Qfa(this)};f.ub=function(a,b){var c=ED(this,!1).m();c=new Ef(c,new y(e=>e.ub(a,b)));var d=Fq();return hH(c,d)|0};
+f.u=function(){var a=this.kj,b=this.Lj,c=h=>{if(null!==h)return h.h()+" \x3c: "+h.j();throw new w(h);};if(b===u())c=u();else{var d=b.e(),e=d=new z(c(d),u());for(b=b.f();b!==u();){var g=b.e();g=new z(c(g),u());e=e.p=g;b=b.f()}c=d}return"{"+a+" where: "+ze(c,"",", ","")+"}"};f.H=function(){return"ConstrainedType"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Lj;case 1:return this.kj;default:return $K(W(),a)}};f.D=function(a){return a instanceof eC};
+f.$classData=q({bZ:0},!1,"mlscript.TyperDatatypes$ConstrainedType",{bZ:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,E:1,v:1,l:1});function FA(a,b,c){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0;this.Eh=b;this.hZ=c;pY(this,a)}FA.prototype=new qY;FA.prototype.constructor=FA;f=FA.prototype;f.ma=function(){return this.hZ};f.Ea=function(){return this.q.Gd};f.ub=function(){return this.q.Gd};f.u=function(){return this.Eh?"\u22a5":"\u22a4"};f.H=function(){return"ExtrType"};f.G=function(){return 1};
+f.I=function(a){return 0===a?this.Eh:$K(W(),a)};f.D=function(a){return a instanceof FA};f.$classData=q({gZ:0},!1,"mlscript.TyperDatatypes$ExtrType",{gZ:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,E:1,v:1,l:1});function MA(a,b,c){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0;this.Fc=b;this.rA=c;pY(this,a)}MA.prototype=new qY;MA.prototype.constructor=MA;f=MA.prototype;f.ma=function(){return this.rA};f.Ea=function(){return this.Fc.Ea()};f.ub=function(a,b){return this.Fc.ub(a,b)};
+f.u=function(){return"~("+this.Fc+")"};f.H=function(){return"NegType"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Fc:$K(W(),a)};f.D=function(a){return a instanceof MA};f.$classData=q({pZ:0},!1,"mlscript.TyperDatatypes$NegType",{pZ:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,E:1,v:1,l:1});function Qv(a,b,c){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.OO=this.dd=0;this.FI=!1;this.Ba=b;this.Nj=c;pY(this,a)}Qv.prototype=new qY;Qv.prototype.constructor=Qv;f=Qv.prototype;f.ma=function(){return this.Nj};
+f.Ea=function(){this.FI||this.FI||(this.OO=this.ub(this.q.Df,jA().X()),this.FI=!0);return this.OO};f.ub=function(a,b){var c=this.Ba.m();c=new Ef(c,new y(e=>e.j().ub(a,b)));var d=Fq();c=Jq(c,d);return(c.b()?this.q.Gd:c.o())|0};function ov(a,b,c,d,e){return XC(a.q,a,t().d,new fn((g,h)=>h.Kc(b,c,d,e)))}
+function Gea(a){var b=a.Ba,c=h=>{var k=a.q,l=O().c;return new Qv(k,new z(h,l),a.Nj)};if(b===u())c=u();else{var d=b.e(),e=d=new z(c(d),u());for(b=b.f();b!==u();){var g=b.e();g=new z(c(g),u());e=e.p=g;b=b.f()}c=d}for(d=a.q.La;!c.b();)e=c.e(),d=new LA(a.q,!1,d,e,V(a.q)),c=c.f();return d}function Lu(a){var b=a.q,c=a.Ba,d=new y(h=>h.h()),e=Su(),g=op().ga;return new Qv(b,QY(c,d,new Uu(e,g)),a.Nj)}
+f.u=function(){var a=this.Ba;if(a===u())var b=u();else{b=a.e();var c=b=new z(b.h().x+": "+b.j(),u());for(a=a.f();a!==u();){var d=a.e();d=new z(d.h().x+": "+d.j(),u());c=c.p=d;a=a.f()}}return"{"+ze(b,"",", ","")+"}"};f.H=function(){return"RecordType"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Ba:$K(W(),a)};f.D=function(a){return a instanceof Qv};f.Kc=function(a,b,c,d){return ov(this,a,b,c,d)};
+f.$classData=q({xZ:0},!1,"mlscript.TyperDatatypes$RecordType",{xZ:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,E:1,v:1,l:1});function cC(a,b,c,d){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0;this.Fg=b;this.Sf=c;this.TO=d;pY(this,a)}cC.prototype=new qY;cC.prototype.constructor=cC;f=cC.prototype;f.ma=function(){return this.TO};f.Ea=function(){var a=this.Fg.Ea(),b=this.Sf.Ea();return a>b?a:b};f.ub=function(a,b){var c=this.Fg.ub(a,b);a=this.Sf.ub(a,b);return c>a?c:a};
+f.u=function(){return this.Fg+".."+this.Sf};f.H=function(){return"TypeBounds"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Fg;case 1:return this.Sf;default:return $K(W(),a)}};f.D=function(a){return a instanceof cC};f.$classData=q({FZ:0},!1,"mlscript.TyperDatatypes$TypeBounds",{FZ:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,E:1,v:1,l:1});
+function Hn(a,b,c,d,e,g,h,k,l){this.HP=null;this.FP=!1;this.GP=this.IP=this.EP=null;this.Hp=a;this.$I=b;this.cF=c;this.eF=d;this.hF=e;this.dF=g;this.gF=h;this.fF=k;this.CA=l;cE(this);this.HP=O().c;this.FP=!0;this.EP=t().d;this.IP=t().d}Hn.prototype=new p;Hn.prototype.constructor=Hn;f=Hn.prototype;f.wK=function(){return this.GP};f.xK=function(a){this.GP=a};f.Ua=function(){return this.Hp};f.mv=function(){return this.cF};f.EB=function(){return this.eF};f.ZL=function(){return this.hF};f.HF=function(){return this.dF};
+f.vy=function(){return this.gF};f.FB=function(){return this.fF};f.CK=function(){return this.CA};f.u=function(){return"mixin "+this.Hp};f.xo=function(){return this.Hp};f.zo=function(){return this.Hp};f.pH=function(){return this.HP};f.UJ=function(){return this.FP};f.GF=function(){return this.EP};f.iM=function(){return this.IP};f.H=function(){return"MixinSymbol"};f.G=function(){return 9};
+f.I=function(a){switch(a){case 0:return this.Hp;case 1:return this.$I;case 2:return this.cF;case 3:return this.eF;case 4:return this.hF;case 5:return this.dF;case 6:return this.gF;case 7:return this.fF;case 8:return this.CA;default:return $K(W(),a)}};f.D=function(a){return a instanceof Hn};f.B=function(){return AL(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Hn){if(this.Hp===a.Hp){var b=this.$I,c=a.$I;b=null===b?null===c:b.i(c)}else b=!1;b?(b=this.cF,c=a.cF,(null===b?null===c:b.i(c))?(b=this.eF,c=a.eF,b=null===b?null===c:b.i(c)):b=!1):b=!1;if(b&&(b=this.hF,c=a.hF,(null===b?null===c:b.i(c))?(b=this.dF,c=a.dF,b=null===b?null===c:b.i(c)):b=!1,b&&(b=this.gF,c=a.gF,null===b?null===c:b.i(c)))&&(b=this.fF,c=a.fF,null===b?null===c:b.i(c)))return b=this.CA,a=a.CA,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({r_:0},!1,"mlscript.codegen.MixinSymbol",{r_:1,g:1,UA:1,cr:1,mt:1,pF:1,E:1,v:1,l:1});function ln(a,b,c,d,e,g,h,k,l){this.KP=!1;this.LP=this.NP=this.MP=this.JP=null;this.lj=a;this.aJ=b;this.iF=c;this.kF=d;this.mF=e;this.jF=g;this.nF=h;this.lF=k;this.DA=l;cE(this);this.KP=!1;this.JP=t().d;this.MP=O().c;this.NP=t().d}ln.prototype=new p;ln.prototype.constructor=ln;f=ln.prototype;f.wK=function(){return this.LP};f.xK=function(a){this.LP=a};f.Ua=function(){return this.lj};f.mv=function(){return this.iF};
+f.EB=function(){return this.kF};f.ZL=function(){return this.mF};f.HF=function(){return this.jF};f.pH=function(){return this.nF};f.FB=function(){return this.lF};f.CK=function(){return this.DA};f.u=function(){return"module "+this.lj};f.xo=function(){return this.lj};f.zo=function(){return this.lj};f.UJ=function(){return this.KP};f.GF=function(){return this.JP};f.vy=function(){return this.MP};f.iM=function(){return this.NP};f.H=function(){return"ModuleSymbol"};f.G=function(){return 9};
+f.I=function(a){switch(a){case 0:return this.lj;case 1:return this.aJ;case 2:return this.iF;case 3:return this.kF;case 4:return this.mF;case 5:return this.jF;case 6:return this.nF;case 7:return this.lF;case 8:return this.DA;default:return $K(W(),a)}};f.D=function(a){return a instanceof ln};f.B=function(){return AL(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof ln){if(this.lj===a.lj){var b=this.aJ,c=a.aJ;b=null===b?null===c:b.i(c)}else b=!1;b?(b=this.iF,c=a.iF,(null===b?null===c:b.i(c))?(b=this.kF,c=a.kF,b=null===b?null===c:b.i(c)):b=!1):b=!1;if(b&&(b=this.mF,c=a.mF,(null===b?null===c:b.i(c))?(b=this.jF,c=a.jF,b=null===b?null===c:b.i(c)):b=!1,b&&(b=this.nF,c=a.nF,null===b?null===c:b.i(c)))&&(b=this.lF,c=a.lF,null===b?null===c:b.i(c)))return b=this.DA,a=a.DA,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({t_:0},!1,"mlscript.codegen.ModuleSymbol",{t_:1,g:1,UA:1,cr:1,mt:1,pF:1,E:1,v:1,l:1});function jn(a,b,c,d,e,g,h,k,l,m,n,r,v){this.PP=null;this.mi=a;this.oF=b;this.IA=c;this.GA=d;this.JA=e;this.OA=g;this.MA=h;this.HA=k;this.NA=l;this.LA=m;this.KA=n;this.Qx=r;this.$u=v;cE(this)}jn.prototype=new p;jn.prototype.constructor=jn;f=jn.prototype;f.wK=function(){return this.PP};f.xK=function(a){this.PP=a};f.Ua=function(){return this.mi};f.GF=function(){return this.IA};f.mv=function(){return this.GA};
+f.EB=function(){return this.JA};f.iM=function(){return this.OA};f.ZL=function(){return this.MA};f.HF=function(){return this.HA};f.pH=function(){return this.NA};f.vy=function(){return this.LA};f.FB=function(){return this.KA};f.CK=function(){return this.Qx};f.UJ=function(){return this.$u};f.u=function(){return"new class "+this.mi};f.xo=function(){return this.mi};f.zo=function(){return this.mi};f.H=function(){return"NewClassSymbol"};f.G=function(){return 13};
+f.I=function(a){switch(a){case 0:return this.mi;case 1:return this.oF;case 2:return this.IA;case 3:return this.GA;case 4:return this.JA;case 5:return this.OA;case 6:return this.MA;case 7:return this.HA;case 8:return this.NA;case 9:return this.LA;case 10:return this.KA;case 11:return this.Qx;case 12:return this.$u;default:return $K(W(),a)}};f.D=function(a){return a instanceof jn};
+f.B=function(){var a=lb("NewClassSymbol");a=W().C(-889275714,a);var b=this.mi;b=My(W(),b);a=W().C(a,b);b=this.oF;b=My(W(),b);a=W().C(a,b);b=this.IA;b=My(W(),b);a=W().C(a,b);b=this.GA;b=My(W(),b);a=W().C(a,b);b=this.JA;b=My(W(),b);a=W().C(a,b);b=this.OA;b=My(W(),b);a=W().C(a,b);b=this.MA;b=My(W(),b);a=W().C(a,b);b=this.HA;b=My(W(),b);a=W().C(a,b);b=this.NA;b=My(W(),b);a=W().C(a,b);b=this.LA;b=My(W(),b);a=W().C(a,b);b=this.KA;b=My(W(),b);a=W().C(a,b);b=this.Qx;b=My(W(),b);a=W().C(a,b);b=this.$u?1231:
+1237;a=W().C(a,b);return W().Ma(a,13)};
+f.i=function(a){if(this===a)return!0;if(a instanceof jn){if(this.$u===a.$u)if(this.mi===a.mi){var b=this.oF,c=a.oF;b=null===b?null===c:b.i(c)}else b=!1;else b=!1;b?(b=this.IA,c=a.IA,(null===b?null===c:b.i(c))?(b=this.GA,c=a.GA,(null===b?null===c:b.i(c))?(b=this.JA,c=a.JA,b=null===b?null===c:b.i(c)):b=!1):b=!1):b=!1;if(b&&(b=this.OA,c=a.OA,(null===b?null===c:b.i(c))?(b=this.MA,c=a.MA,(null===b?null===c:b.i(c))?(b=this.HA,c=a.HA,b=null===b?null===c:b.i(c)):b=!1):b=!1,b&&(b=this.NA,c=a.NA,(null===b?
+null===c:b.i(c))?(b=this.LA,c=a.LA,b=null===b?null===c:b.i(c)):b=!1,b&&(b=this.KA,c=a.KA,null===b?null===c:b.i(c)))))return b=this.Qx,a=a.Qx,null===b?null===a:b.i(a)}return!1};f.$classData=q({v_:0},!1,"mlscript.codegen.NewClassSymbol",{v_:1,g:1,UA:1,cr:1,mt:1,pF:1,E:1,v:1,l:1});function a6(a,b){for(;;){if(0>=a||b.b())return b;a=-1+a|0;b=b.f()}}function jba(a,b){for(;;)if(!a.b()&&b.n(a.e()))a=a.f();else break;return a}
+function b6(a,b){var c=a.vj().Eb();for(a=a.m();a.s();){var d=b.n(a.t());c.$(d)}return c.Kb()}function c6(a,b){var c=a.vj().Eb();c.zc(a);c.zc(b);return c.Kb()}function ky(a,b){if(0>=a.ab(1))return a;for(var c=a.ti(),d=Vn(),e=a.m(),g=!1;e.s();){var h=e.t();d.oh(b.n(h))?c.$(h):g=!0}return g?c.Kb():a}function tr(a,b){this.hG=0;this.gd=a;if(null===a)throw Kj("null value for BigDecimal");if(null===b)throw Kj("null MathContext for BigDecimal");this.hG=1565550863}tr.prototype=new cW;
+tr.prototype.constructor=tr;f=tr.prototype;f.sl=function(a){return uW(this.gd,a.gd)};
+f.B=function(){if(1565550863===this.hG){if(this.uv()&&4934>(pr(this.gd)-this.gd.xb|0))var a=d6(new KR,vW(this.gd)).B();else{a=this.gd.Lp();if(Infinity!==a&&-Infinity!==a){var b=lr();a=e6(this,BR(a,b.xy))}else a=!1;if(a)a=this.gd.Lp(),a=ZK(W(),a);else{a=sW(this.gd);b=BL();var c=b.Pp,d;var e=d=a.xb,g=e>>31,h=d>>31;d=e-d|0;g=(-2147483648^d)>(-2147483648^e)?-1+(g-h|0)|0:g-h|0;64>a.$h?(e=a.Bg,0===e.W&&0===e.Y?(e=hN(),d=new ma(d,g),g=d.W,d=d.W===g&&d.Y===g>>31?jN(e,aa,d.W):0<=d.Y?eN(0,2147483647):eN(0,
+-2147483648)):d=jN(hN(),a.Bg,mN(hN(),new ma(d,g)))):d=FR(new mr,$M(a),mN(hN(),new ma(d,g)));a=c.call(b,vW(d).B(),a.xb)}}this.hG=a}return this.hG};
+f.i=function(a){if(a instanceof tr)return e6(this,a);if(a instanceof KR){var b=f6(a),c=pr(this.gd);if(b>3.3219280948873626*(-2+(c-this.gd.xb|0)|0)){if(this.uv())try{var d=new L(d6(new KR,pW(this.gd)))}catch(e){if(e instanceof qb)d=R();else throw e;}else d=R();if(d.b())return!1;b=d.o();return g6(a,b)}return!1}return"number"===typeof a?(b=+a,Infinity!==b&&-Infinity!==b&&(a=this.gd.Lp(),Infinity!==a&&-Infinity!==a&&a===b)?(b=lr(),e6(this,BR(a,b.xy))):!1):ja(a)?(b=Math.fround(a),Infinity!==b&&-Infinity!==
+b&&(a=this.gd.pv(),Infinity!==a&&-Infinity!==a&&a===b)?(b=lr(),e6(this,BR(a,b.xy))):!1):this.pB()&&AK(this,a)};f.WJ=function(){try{return oW(this.gd,8),!0}catch(a){if(a instanceof qb)return!1;throw a;}};f.YJ=function(){try{return oW(this.gd,16),!0}catch(a){if(a instanceof qb)return!1;throw a;}};f.XJ=function(){return this.MF()&&0<=oW(this.gd,32).W&&65535>=oW(this.gd,32).W};f.MF=function(){try{return oW(this.gd,32),!0}catch(a){if(a instanceof qb)return!1;throw a;}};
+f.pB=function(){try{return oW(this.gd,64),!0}catch(a){if(a instanceof qb)return!1;throw a;}};f.uv=function(){return 0>=this.gd.xb?!0:0>=sW(this.gd).xb};function e6(a,b){return 0===uW(a.gd,b.gd)}f.jB=function(){return this.gd.Zi()<<24>>24};f.EC=function(){return this.gd.Zi()<<16>>16};f.Zi=function(){return this.gd.Zi()};f.xl=function(){return this.gd.xl()};f.pv=function(){return this.gd.pv()};f.Lp=function(){return this.gd.Lp()};f.u=function(){return this.gd.u()};
+f.$l=function(a){return uW(this.gd,a.gd)};f.qT=function(){return this.gd};f.$classData=q({u3:0},!1,"scala.math.BigDecimal",{u3:1,R3:1,ur:1,g:1,l:1,S3:1,sR:1,yj:1,nf:1});function h6(a){a=a.Uf;return!(0===a.W&&-2147483648===a.Y)}function i6(a){a=Ni(j6(a),2147483647);return 0!==a.Ya&&!a.i(NK().qR)}function JR(a,b,c){a.jm=b;a.Uf=c;return a}function d6(a,b){JR(a,b,63>=yh(Sh(),b)?b.xl():new ma(0,-2147483648));return a}function KR(){this.jm=null;this.Uf=aa}KR.prototype=new cW;KR.prototype.constructor=KR;
+f=KR.prototype;f.sl=function(a){return k6(this,a)};function j6(a){var b=a.jm;if(null!==b)return b;var c=a.Uf;b=c.W;c=c.Y;b=ri(Ph(),new ma(b,c));return a.jm=b}f.B=function(){if(this.pB()){var a=this.xl(),b=a.W;a=a.Y;return(-1===a?0<=(-2147483648^b):-1<a)&&(0===a?-1>=(-2147483648^b):0>a)?b:YK(W(),new ma(b,a))}b=j6(this);return My(W(),b)};
+f.i=function(a){if(a instanceof KR)return g6(this,a);if(a instanceof tr)return a.i(this);if("number"===typeof a){a=+a;var b=f6(this);if(53>=b)b=!0;else{var c=l6(this);b=1024>=b&&c>=(-53+b|0)&&1024>c}return(b?!i6(this):!1)&&this.Lp()===a}return ja(a)?(a=Math.fround(a),b=f6(this),24>=b?b=!0:(c=l6(this),b=128>=b&&c>=(-24+b|0)&&128>c),b&&!i6(this)?(b=j6(this),hM(jM(),Vh(bi(),b))===a):!1):this.pB()&&AK(this,a)};
+f.WJ=function(){var a=this.Uf,b=a.Y;return(-1===b?2147483520<=(-2147483648^a.W):-1<b)?(a=this.Uf,b=a.Y,0===b?-2147483521>=(-2147483648^a.W):0>b):!1};f.YJ=function(){var a=this.Uf,b=a.Y;return(-1===b?2147450880<=(-2147483648^a.W):-1<b)?(a=this.Uf,b=a.Y,0===b?-2147450881>=(-2147483648^a.W):0>b):!1};f.XJ=function(){if(0<=this.Uf.Y){var a=this.Uf,b=a.Y;return 0===b?-2147418113>=(-2147483648^a.W):0>b}return!1};
+f.MF=function(){var a=this.Uf,b=a.Y;return(-1===b?0<=(-2147483648^a.W):-1<b)?(a=this.Uf,b=a.Y,0===b?-1>=(-2147483648^a.W):0>b):!1};f.pB=function(){return h6(this)||QK(nl(),this.jm,NK().LK)};f.uv=function(){return!0};function g6(a,b){return h6(a)?h6(b)?(a=a.Uf,b=b.Uf,a.W===b.W&&a.Y===b.Y):!1:!h6(b)&&QK(nl(),a.jm,b.jm)}function k6(a,b){if(h6(a)){if(h6(b)){var c=a.Uf;a=c.W;c=c.Y;var d=b.Uf;b=d.W;d=d.Y;return ua(xa(),a,c,b,d)}return-b.jm.Ya|0}return h6(b)?a.jm.Ya:fM(a.jm,b.jm)}
+function lba(a){if(h6(a)){var b=NK(),c=a.Uf;a=c.W;c=c.Y;return OR(b,new ma(-a|0,0!==a?~c:-c|0))}return PR(NK(),ui(j6(a)))}function l6(a){if(h6(a)){var b=a.Uf;if(0===b.W&&0===b.Y)return-1;b=a.Uf;a=b.W;b=b.Y;return 0!==a?0===a?32:31-Math.clz32(a&(-a|0))|0:32+(0===b?32:31-Math.clz32(b&(-b|0))|0)|0}return wW(j6(a))}
+function f6(a){if(h6(a)){if(0>a.Uf.Y){a=a.Uf;var b=a.Y;a=1+a.W|0;var c=0===a?1+b|0:b;b=-a|0;a=0!==a?~c:-c|0;return 64-(0!==a?Math.clz32(a):32+Math.clz32(b)|0)|0}b=a.Uf;a=b.W;b=b.Y;return 64-(0!==b?Math.clz32(b):32+Math.clz32(a)|0)|0}a=a.jm;return yh(Sh(),a)}f.jB=function(){return this.Zi()<<24>>24};f.EC=function(){return this.Zi()<<16>>16};f.Zi=function(){return h6(this)?this.Uf.W:j6(this).Zi()};f.xl=function(){return h6(this)?this.Uf:this.jm.xl()};
+f.pv=function(){var a=j6(this);return hM(jM(),Vh(bi(),a))};f.Lp=function(){if(this.pB())if(-2097152<=this.Uf.Y){var a=this.Uf,b=a.Y;a=2097152===b?0===a.W:2097152>b}else a=!1;else a=!1;if(a)return a=this.Uf,cG(xa(),a.W,a.Y);a=j6(this);return aM(qa(),Vh(bi(),a))};f.u=function(){if(h6(this)){var a=this.Uf;return bG(xa(),a.W,a.Y)}a=this.jm;return Vh(bi(),a)};f.$l=function(a){return k6(this,a)};f.qT=function(){return j6(this)};
+var NR=q({w3:0},!1,"scala.math.BigInt",{w3:1,R3:1,ur:1,g:1,l:1,S3:1,sR:1,yj:1,nf:1});KR.prototype.$classData=NR;function m6(){this.NB=null;n6=this;this.NB=new B2(this)}m6.prototype=new p;m6.prototype.constructor=m6;f=m6.prototype;f.sj=function(a){return a===this.NB};f.uj=function(a,b){return 0>=this.Da(a,b)};f.Yj=function(a,b){return 0<=this.Da(a,b)};f.Xj=function(a,b){return 0<this.Da(a,b)};f.Yi=function(a,b){return x2(this,a,b)};f.Jk=function(a,b){return y2(this,a,b)};
+f.Kk=function(a,b){return z2(this,a,b)};f.Da=function(a,b){a|=0;b|=0;return a===b?0:a<b?-1:1};f.$classData=q({K3:0},!1,"scala.math.Ordering$Int$",{K3:1,g:1,L3:1,lm:1,Ji:1,mm:1,km:1,l:1,uba:1});var n6;function Fq(){n6||(n6=new m6);return n6}function o6(){this.Ki=null;this.Gf=0}o6.prototype=new T5;o6.prototype.constructor=o6;function p6(){}p6.prototype=o6.prototype;o6.prototype.uh=function(){return da(rd)};o6.prototype.si=function(a){return new Ec(a)};function q6(){this.Ki=null;this.Gf=0}
+q6.prototype=new T5;q6.prototype.constructor=q6;function r6(){}r6.prototype=q6.prototype;q6.prototype.uh=function(){return da(xd)};q6.prototype.si=function(a){return new Pc(a)};function s6(){this.Ki=null;this.Gf=0}s6.prototype=new T5;s6.prototype.constructor=s6;function t6(){}t6.prototype=s6.prototype;s6.prototype.uh=function(){return da(td)};s6.prototype.si=function(a){return new Ic(a)};function u6(){this.Ki=null;this.Gf=0}u6.prototype=new T5;u6.prototype.constructor=u6;function v6(){}
+v6.prototype=u6.prototype;u6.prototype.uh=function(){return da(Ld)};u6.prototype.si=function(a){return new ed(a)};function w6(){this.Ki=null;this.Gf=0}w6.prototype=new T5;w6.prototype.constructor=w6;function x6(){}x6.prototype=w6.prototype;w6.prototype.uh=function(){return da(Gd)};w6.prototype.si=function(a){return new $c(a)};function y6(){this.Ki=null;this.Gf=0}y6.prototype=new T5;y6.prototype.constructor=y6;function z6(){}z6.prototype=y6.prototype;y6.prototype.uh=function(){return da(Ed)};
+y6.prototype.si=function(a){return new Xc(a)};function A6(){this.Ki=null;this.Gf=0}A6.prototype=new T5;A6.prototype.constructor=A6;function B6(){}B6.prototype=A6.prototype;A6.prototype.uh=function(){return da(Fd)};A6.prototype.si=function(a){return new Zc(a)};function C6(){this.OB=null;this.Br=0}C6.prototype=new V5;C6.prototype.constructor=C6;function D6(){}D6.prototype=C6.prototype;C6.prototype.u=function(){return this.OB};C6.prototype.i=function(a){return this===a};C6.prototype.B=function(){return this.Br};
+function E6(){this.Ki=null;this.Gf=0}E6.prototype=new T5;E6.prototype.constructor=E6;function F6(){}F6.prototype=E6.prototype;E6.prototype.uh=function(){return da(Cd)};E6.prototype.si=function(a){return new Sc(a)};function G6(){this.Ki=null;this.Gf=0}G6.prototype=new T5;G6.prototype.constructor=G6;function H6(){}H6.prototype=G6.prototype;G6.prototype.uh=function(){return da(pd)};G6.prototype.si=function(a){return new (md(la).Ia)(a)};
+function mP(a,b){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.Bi=a;this.Ci=b;Nq(this)}mP.prototype=new M_;mP.prototype.constructor=mP;f=mP.prototype;f.H=function(){return"Bounds"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Bi;case 1:return this.Ci;default:return $K(W(),a)}};f.D=function(a){return a instanceof mP};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof mP){var b=this.Bi,c=a.Bi;if(null===b?null===c:b.i(c))return b=this.Ci,a=a.Ci,null===b?null===a:b.i(a)}return!1};f.$classData=q({YT:0},!1,"mlscript.Bounds",{YT:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,E:1,v:1,l:1});function I6(){this.ld="class"}I6.prototype=new XS;I6.prototype.constructor=I6;f=I6.prototype;f.H=function(){return"Cls"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof I6};f.B=function(){return 67850};
+f.u=function(){return"Cls"};f.$classData=q({oU:0},!1,"mlscript.Cls$",{oU:1,EE:1,sz:1,sx:1,g:1,AM:1,ZH:1,E:1,v:1,l:1});var J6;function Bp(){J6||(J6=new I6);return J6}function qP(a,b,c){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.Lw=a;this.Mw=b;this.Nw=c;Nq(this)}qP.prototype=new M_;qP.prototype.constructor=qP;f=qP.prototype;f.H=function(){return"Constrained"};f.G=function(){return 3};
+f.I=function(a){switch(a){case 0:return this.Lw;case 1:return this.Mw;case 2:return this.Nw;default:return $K(W(),a)}};f.D=function(a){return a instanceof qP};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof qP){var b=this.Lw,c=a.Lw;if(null===b?null===c:b.i(c))if(b=this.Mw,c=a.Mw,null===b?null===c:b.i(c))return b=this.Nw,a=a.Nw,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({rU:0},!1,"mlscript.Constrained",{rU:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,E:1,v:1,l:1});function Wt(a,b){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.ps=a;this.qs=b;Nq(this)}Wt.prototype=new M_;Wt.prototype.constructor=Wt;f=Wt.prototype;f.H=function(){return"Function"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.ps;case 1:return this.qs;default:return $K(W(),a)}};
+f.D=function(a){return a instanceof Wt};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Wt){var b=this.ps,c=a.ps;if(null===b?null===c:b.i(c))return b=this.qs,a=a.qs,null===b?null===a:b.i(a)}return!1};f.$classData=q({WU:0},!1,"mlscript.Function",{WU:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,E:1,v:1,l:1});function K6(){this.ld="module"}K6.prototype=new XS;K6.prototype.constructor=K6;f=K6.prototype;f.H=function(){return"Mod"};f.G=function(){return 0};
+f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof K6};f.B=function(){return 77538};f.u=function(){return"Mod"};f.$classData=q({FW:0},!1,"mlscript.Mod$",{FW:1,EE:1,sz:1,sx:1,g:1,AM:1,ZH:1,E:1,v:1,l:1});var L6;function zp(){L6||(L6=new K6);return L6}function kP(a){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.cx=a;Nq(this)}kP.prototype=new M_;kP.prototype.constructor=kP;f=kP.prototype;f.H=function(){return"Neg"};
+f.G=function(){return 1};f.I=function(a){return 0===a?this.cx:$K(W(),a)};f.D=function(a){return a instanceof kP};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof kP){var b=this.cx;a=a.cx;return null===b?null===a:b.i(a)}return!1};f.$classData=q({KW:0},!1,"mlscript.Neg",{KW:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,E:1,v:1,l:1});
+function Tn(a){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.Xs=a;Nq(this)}Tn.prototype=new M_;Tn.prototype.constructor=Tn;f=Tn.prototype;f.H=function(){return"Record"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Xs:$K(W(),a)};f.D=function(a){return a instanceof Tn};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Tn){var b=this.Xs;a=a.Xs;return null===b?null===a:b.i(a)}return!1};f.$classData=q({YX:0},!1,"mlscript.Record",{YX:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,E:1,v:1,l:1});function lP(a,b){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.tx=a;this.Zz=b;Nq(this)}lP.prototype=new M_;lP.prototype.constructor=lP;f=lP.prototype;f.H=function(){return"Rem"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.tx;case 1:return this.Zz;default:return $K(W(),a)}};f.D=function(a){return a instanceof lP};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof lP){var b=this.tx,c=a.tx;if(null===b?null===c:b.i(c))return b=this.Zz,a=a.Zz,null===b?null===a:b.i(a)}return!1};f.$classData=q({ZX:0},!1,"mlscript.Rem",{ZX:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,E:1,v:1,l:1});
+function tP(a,b){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.vx=a;this.wx=b;Nq(this)}tP.prototype=new M_;tP.prototype.constructor=tP;f=tP.prototype;f.H=function(){return"Selection"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.vx;case 1:return this.wx;default:return $K(W(),a)}};f.D=function(a){return a instanceof tP};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof tP){var b=this.vx,c=a.vx;if(null===b?null===c:b.i(c))return b=this.wx,a=a.wx,null===b?null===a:b.i(a)}return!1};f.$classData=q({eY:0},!1,"mlscript.Selection",{eY:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,E:1,v:1,l:1});function rP(a){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.Ax=a;Nq(this)}rP.prototype=new M_;rP.prototype.constructor=rP;f=rP.prototype;f.H=function(){return"Splice"};
+f.G=function(){return 1};f.I=function(a){return 0===a?this.Ax:$K(W(),a)};f.D=function(a){return a instanceof rP};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof rP){var b=this.Ax;a=a.Ax;return null===b?null===a:b.i(a)}return!1};f.$classData=q({lY:0},!1,"mlscript.Splice",{lY:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,E:1,v:1,l:1});
+function jP(a){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.Mu=a;Nq(this)}jP.prototype=new M_;jP.prototype.constructor=jP;f=jP.prototype;f.H=function(){return"Tuple"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Mu:$K(W(),a)};f.D=function(a){return a instanceof jP};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof jP){var b=this.Mu;a=a.Mu;return null===b?null===a:b.i(a)}return!1};f.$classData=q({sY:0},!1,"mlscript.Tuple",{sY:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,E:1,v:1,l:1});function M6(a){tp();return gq(a)}function N6(a,b,c,d,e){if(Bp()!==b&&zp()!==b&&Ap()!==b&&Fp()!==b){var g=new Te(new Ue(J(new K,[""," "," cannot be used as a type"])));b=[We(Xe(),b.ld),We(Xe(),c)];Lw(a,Ye(g,J(new K,b)),d,e)}}
+function O6(a,b,c,d,e,g){d=d.U(c);d.b()&&(d=e.tb.U(c),d.b()?d=R():(d=d.o(),d=new L(G(new H,d.jj,d.Xm.K()))));if(d.b())if(e=uC(e,e,c),e.b())e=R();else a:{if(d=e.o(),d instanceof ix&&(e=d.kh,e instanceof Cx)){N6(a,e.Yr().pb,e.cG().V,b,g);t();d=e.Yr().pb;e=e.Ag();e=G(new H,d,e.K());e=new L(e);break a}if(d instanceof fx){e=d.Ab.fd();N6(a,e,d.Ab.Cf.x,b,g);var h=!1;e=null;d=d.Ab;if(d instanceof yo){h=!0;e=d;var k=e.pb,l=e.hg;if(Bp()===k||zp()===k||Ap()===k||Fp()===k){t();e=G(new H,k,l.K());e=new L(e);break a}}if(h&&
+(h=e.pb,e=e.hg,cp()===h)){t();e=G(new H,h,e.K());e=new L(e);break a}if(d instanceof Zn){e=t().d;break a}throw new w(d);}e=t().d}else e=d;if(e.b())return O(),new fe(new U(()=>Lw(a,We(Xe(),"type identifier not found: "+c),b,g)));O();e=e.o();return new Ud(e)}
+function Rfa(a,b,c,d,e,g,h){var k=tD(b,c);k instanceof fw&&xm("Program reached and unexpected state.");if(k instanceof Mu&&(k=k.pd,k instanceof vl)){h=!1;b=null;k=Mea(a,k.x,d.Zr(),c,e);if(k instanceof Ud){h=!0;b=k;var l=b.fa;if(l instanceof Yw)return l.gh.b()||no(),e=l.Rf,d=g.A(),tx(a),g=t().d,bz(a,e,jx(new kx,a,d,"type selection",g,!0),c)}if(h&&(c=b.fa,c instanceof ax))return c.rk.b()||no(),c.Ql;if(h)return g=b.fa,c=new Te(new Ue(J(new K,["Illegal selection of "," member in type position"]))),g=
+[We(Xe(),g.fd().ld)],Lw(a,Ye(c,J(new K,g)),d.A(),e);if(k instanceof fe)return GX(a,k.aa,e);throw new w(k);}d=new Te(new Ue(J(new K,["Illegal prefix of type selection: ",""])));c=[wO(Xe(),AD(b,c))];return Lw(a,Ye(d,J(new K,c)),h.A(),e)}
+var Sfa=function P6(a,b,c,d,e,g,h,k,l,m,n){return Lx(a,new U(()=>c.da+". type "+wO(Xe(),b).Wr()),new U(()=>{var v=!1,x=null,A=!1,B=null;if(gl()===b){var C=b.A(),D=t().d;return new FA(a,!1,jx(new kx,a,C,"top type",D,!0))}if(el()===b){var F=b.A(),I=t().d;return new FA(a,!0,jx(new kx,a,F,"bottom type",I,!0))}if(b instanceof mP){v=!0;x=b;var M=x.Bi,N=x.Ci;if(el()===M&&gl()===N){var P=b.A(),T=t().d,Y=jx(new kx,a,P,"type wildcard",T,!0);return new cC(a,new FA(a,!0,Y),new FA(a,!1,Y),Y)}}if(v){var Z=x.Ci,
+S=P6(a,x.Bi,c,d,e,g,h,k,l,m,n),ea=P6(a,Z,c,d,e,g,h,k,l,m,n),ia=b.A(),X=t().d,sa=jx(new kx,a,ia,"type bounds",X,!0),Ja=Sw(a).ob;Tw(a,S,ea,e,sa,c,Ja);return new cC(a,S,ea,sa)}if(b instanceof jP){var Xa=b.Mu,Fa=ry(lv(),Xa,new y(Ta=>{var wb=Ta.Yf,$a=new y(wa=>P6(a,wa,c,d,e,g,h,k,l,m,n));return new Uw(a,wb.b()?R():new L($a.n(wb.o())),P6(a,Ta.Rg,c,d,e,g,h,k,l,m,n),jx(new kx,a,Ta.A(),"tuple field",(tx(a),t().d),(tx(a),!1)))})),za=b.A(),Qa=t().d;return new zv(a,Fa,jx(new kx,a,za,"tuple type",Qa,!0))}if(b instanceof
+rP){var Ma=Qt(b.Ax,new y(Ta=>{if(Ta instanceof fe){Ta=P6(a,Ta.aa,c,d,e,g,h,k,l,m,n);var wb=Ta.ma(),$a=t().d,wa=t().d,hb=O().c,ra=O().c;wb=new lx(a,c.da,hb,ra,$a,wa,!1,wb);$a=Ta.ma();wb=new Sv(a,new Uw(wb.q,R(),wb,$a),Ta.ma());$a=Ta.ma();wa=Sw(a).ob;Tw(a,Ta,wb,e,$a,c,wa);t();return new fe(Ta)}if(Ta instanceof Ud)return Ta=Ta.fa,t(),wb=Ta.Yf,$a=new y(wc=>P6(a,wc,c,d,e,g,h,k,l,m,n)),Ta=new Uw(a,wb.b()?R():new L($a.n(wb.o())),P6(a,Ta.Rg,c,d,e,g,h,k,l,m,n),jx(new kx,a,Ta.A(),"splice field",(tx(a),t().d),
+(tx(a),!1))),new Ud(Ta);throw new w(Ta);})),Ga=b.A(),ab=t().d;return new Wv(a,Ma,jx(new kx,a,Ga,"splice type",ab,!0))}if(b instanceof hP){var Hb=b.As,bc=b.Bs;if(g)var yb=new y(Ta=>{var wb=P6(a,Hb,c,d,e,g,h,k,l,m,n),$a=P6(a,bc,c,d,e,g,h,k,l,m,n);return Pu(wb,$a,Ta,!1)});else{var tb=P6(a,Hb,c,d,e,g,h,k,l,m,n),eb=P6(a,bc,c,d,e,g,h,k,l,m,n);yb=new y(Ta=>new LA(a,!1,tb,eb,Ta))}var kb=b.A(),Rb=t().d;return yb.n(jx(new kx,a,kb,"intersection type",Rb,!0))}if(b instanceof iP){var Gb=b.ht,vb=b.it;if(g)var Tb=
+new y(Ta=>{var wb=P6(a,Gb,c,d,e,g,h,k,l,m,n),$a=P6(a,vb,c,d,e,g,h,k,l,m,n);return dv(wb,$a,Ta,!1)});else{var Nb=P6(a,Gb,c,d,e,g,h,k,l,m,n),ic=P6(a,vb,c,d,e,g,h,k,l,m,n);Tb=new y(Ta=>new LA(a,!0,Nb,ic,Ta))}var Va=b.A(),cb=t().d;return Tb.n(jx(new kx,a,Va,"union type",cb,!0))}if(b instanceof kP){var zb=P6(a,b.cx,c,d,e,g,h,k,l,m,n),Ub=b.A(),jb=t().d;return new MA(a,zb,jx(new kx,a,Ub,"type negation",jb,!0))}if(b instanceof Tn){var db=b.Xs,ub=b.A(),Aa=t().d,va=jx(new kx,a,ub,"record type",Aa,!0);ET(db,
+new y(Ta=>Ta.h().x),new y(Ta=>Ta.h())).Ca(new y(Ta=>{if(null!==Ta&&(Ta=new L(Ta),!Ta.b())){var wb=Ta.k.h();Ta=Ta.k.j();if(0<Ta.ab(1)){var $a=new Te(new Ue(J(new K,["Multiple declarations of field name "," in ",""])));wb=[We(Xe(),wb),We(Xe(),va.lh)];wb=Ye($a,J(new K,wb));$a=b.A();wb=G(new H,wb,$a);Ta=Qt(Ta,new y(wa=>{var hb=Ye(new Te(new Ue(J(new K,["Declared at"]))),u());wa=wa.A();return G(new H,hb,wa)}));return ay(a,new z(wb,Ta),e)}}}));return SA(xv(a),Qt(db,new y(Ta=>{hB(ve(),Ta.h().x)&&Lw(a,Ye(new Te(new Ue(J(new K,
+["Field identifiers must start with a small letter"]))),u()),Ta.h().A(),e);var wb=Ta.h(),$a=Ta.j().Yf,wa=new y(ac=>P6(a,ac,c,d,e,g,h,k,l,m,n));$a=$a.b()?R():new L(wa.n($a.o()));wa=P6(a,Ta.j().Rg,c,d,e,g,h,k,l,m,n);var hb=Ta.h(),ra=new vl(""),wc=Ta.j().A();hb=new Pl(hb,Cq(ra,wc));hb=Lq(hb);Ta=new Uw(a,$a,wa,jx(new kx,a,hb,(Ta.j().Yf.b()?"":"mutable ")+"record field",(tx(a),t().d),(tx(a),!1)));return G(new H,wb,Ta)})),va)}if(b instanceof Wt){var Ra=b.qs,rb=P6(a,b.ps,c,d,e,g,h,k,l,m,n),xb=P6(a,Ra,c,
+d,e,g,h,k,l,m,n),mc=b.A(),Ha=t().d;return new cv(a,rb,xb,jx(new kx,a,mc,"function type",Ha,!0))}if(b instanceof nP){var Ka=b.Mx,Oa=P6(a,b.Lx,c,d,e,g,h,k,l,m,n),Na=Qt(Ka.Xs,new y(Ta=>{if(null!==Ta){var wb=Ta.h(),$a=Ta.j();Ta=$a.Yf;var wa=new y(ra=>P6(a,ra,c,d,e,g,h,k,l,m,n));Ta=Ta.b()?R():new L(wa.n(Ta.o()));wa=P6(a,$a.Rg,c,d,e,g,h,k,l,m,n);var hb=new vl("");$a=$a.A();$a=new Pl(wb,Cq(hb,$a));$a=Lq($a);hb=t().d;Ta=new Uw(a,Ta,wa,jx(new kx,a,$a,"extension field",hb,!0));return G(new H,wb,Ta)}throw new w(Ta);
+})),Da=Ka.A(),ta=t().d,Ya=new Qv(a,Na,jx(new kx,a,Da,"extension record",ta,!0)),dc=b.A(),ka=t().d;return new $y(a,Oa,Ya,jx(new kx,a,dc,"extension type",ka,!0))}if(b instanceof oP){var ya=b.Es,Sa=a.$c?yq(ya):fq(ya),xc=b.A(),Sb=t().d;return new Mu(a,ya,Sa,jx(new kx,a,xc,"literal type",Sb,!0))}if(b instanceof Ep&&(A=!0,B=b,"this"===B.V)){var uc=!1,Lb=null,lc=c.hc.U("this");lc instanceof L&&(uc=!0,Lb=lc,Lb.k instanceof VP&&xm("Program reached and unexpected state."));if(uc){var Xb=Lb.k;if(Xb instanceof
+qx){var ec=Xb.tp;if(null!==ec)return ec}}if(t().d===lc){var Ab=Ye(new Te(new Ue(J(new K,["undeclared `this`"]))),u()),Ob=b.A(),fb=G(new H,Ab,Ob),Wa=O().c;return ay(a,new z(fb,Wa),e)}throw new w(lc);}if(b instanceof sP){var bb=b.nA;return P6(a,new Ep(UF(ve(),bb)),c,d,e,g,h,k,l,m,n)}if(A){var Ia=B.V,Ua=b.A(),pc=t().d,sc=jx(new kx,a,Ua,"type reference",pc,!0);return h.Se(Ia,new U((Ta=>()=>{var wb=O6(a,Ua,Ia,m,n,e);if(wb instanceof Ud){var $a=wb.fa;if(null!==$a){$a=$a.Sc();if(Pe(new E($a),0))return new fw(a,
+Ta,O().c,sc);var wa=c.$a.U(Ia);if(wa instanceof L){var hb=!1,ra=null;wa=wa.k.Ab;if(wa instanceof yo&&(hb=!0,ra=wa,wa=ra.pb,Bp()===wa||zp()===wa))return wb=c.$a.n(Ia).Ab,$a=t().d,bz(a,wb,jx(new kx,a,Ua,"class tag",$a,!0),c);if(hb&&(wa=ra.pb,Fp()===wa))return wb=c.$a.n(Ia).Ab,$a=t().d,Xx(a,wb,jx(new kx,a,Ua,"class tag",$a,!0),c);if(hb&&(hb=ra.pb,Ap()===hb))return wb=O().xR,new fw(a,Ta,Yea(wb,$a,new U(()=>{var wc=V(a),ac=t().d,Id=t().d,ud=O().c,be=O().c;return new lx(a,c.da,ud,be,ac,Id,!1,wc)})),sc);
+xm("Program reached and unexpected state.")}else return wb=new Te(new Ue(J(new K,["Type "," takes parameters"]))),$a=[We(Xe(),Ia)],Lw(a,Ye(wb,J(new K,$a)),Ua,e)}}if(wb instanceof fe){wb=wb.aa;""===Ia?$a=!0:($a=Hu(Q(),Ia),$a=!bE(Pr(),$a));if(!$a&&($a=G(new H,O6(a,Ua,Nu(Q(),Ia),m,n,e),c.tb.U(Nu(Q(),Ia))),hb=$a.y,$a=$a.w,hb instanceof Ud&&(hb=hb.fa,null!==hb&&(hb=hb.h(),$a instanceof L)))){wb=$a.k;if(Bp()===hb)return $a=t().d,rD(a,wb,jx(new kx,a,Ua,"class tag",$a,!0),c);if(Fp()===hb)return $a=t().d,
+TD(a,wb,jx(new kx,a,Ua,"trait tag",$a,!0));if(Ap()===hb)return wb=new Te(new Ue(J(new K,["Type alias "," cannot be used as a type tag"]))),$a=[We(Xe(),Nu(Q(),Ia))],Lw(a,Ye(wb,J(new K,$a)),Ua,e);if(zp()===hb)return wb=new Te(new Ue(J(new K,["Module "," cannot be used as a type tag"]))),$a=[We(Xe(),Nu(Q(),Ia))],Lw(a,Ye(wb,J(new K,$a)),Ua,e);if(cp()===hb)return wb=new Te(new Ue(J(new K,["Mixin "," cannot be used as a type tag"]))),$a=[We(Xe(),Nu(Q(),Ia))],Lw(a,Ye(wb,J(new K,$a)),Ua,e);throw new w(hb);
+}return Es(wb)}throw new w(wb);})(B)))}if(b instanceof jt){var Ba=GP(b.pp),ob=new y(Ta=>h.U(Ta)),nc=Ba.b()?R():ob.n(Ba.o()),Ib=new U(()=>{var Ta=d.Se(b,new U(()=>k.Hk(b,new U(()=>{var wa=V(a),hb=t().d,ra=aT(b),wc=new y(Id=>kda(Q(),Id,new y(ud=>Nm(new E(hc(Ea(ud))),hc(39)))));ra=ra.b()||wc.n(ra.o())?ra:R();wc=O().c;var ac=O().c;return new lx(a,l,wc,ac,hb,ra,!1,wa)})))),wb=b.A(),$a=t().d;wb=jx(new kx,a,wb,"type variable",$a,!0);return ux(Ta.q,Ta,wb)});return nc.b()?Es(Ib):nc.o()}if(b instanceof pP){var vc=
+b.Gw,Vb=b.Hw,fc=b.A(),Bc=t().d,Pb=jx(new kx,a,fc,"applied type reference",Bc,!0),Jb=O6(a,b.A(),vc.V,m,n,e);if(Jb instanceof Ud){var gc=Jb.fa;if(null!==gc){var Cb=gc.Sc(),cc=Vb.K();if(Pe(new E(cc),Cb))var yc=Qt(Vb,new y(Ta=>P6(a,Ta,c,d,e,g,h,k,l,m,n)));else{var Mc=new Te(new Ue(J(new K,["Wrong number of type arguments \u2013 expected ",", found ",""]))),qc=We(Xe(),""+Cb);Xe();var oc=Vb.K(),Qc=[qc,We(0,""+oc)];Lw(a,Ye(Mc,J(new K,Qc)),b.A(),e);var jc=Vb.m(),sb=new Ef(jc,new y(Ta=>P6(a,Ta,c,d,e,g,h,k,
+l,m,n))),Gc=kv(sb,new U(()=>{O();return new y0(new U(()=>{var Ta=V(a),wb=t().d,$a=t().d,wa=O().c,hb=O().c;return new lx(a,c.da,wa,hb,wb,$a,!1,Ta)}))})).Mn(Cb);Od();yc=Pd(u(),Gc)}return new fw(a,vc,yc,Pb)}}if(Jb instanceof fe)return Es(Jb.aa);throw new w(Jb);}if(b instanceof tP){var Wb=b.vx,Cc=b.wx,Fc=P6(a,Wb,c,d,e,g,h,k,l,m,n);return Rfa(a,Fc,c,Cc,e,b,Wb)}if(b instanceof lP){var qd=b.Zz,Yb=P6(a,b.tx,c,d,e,g,h,k,l,m,n),Nc=Su(),ad=op().ga,Uc=new Uu(Nc,ad),cd=oA(uv(),qd,Uc),kc=b.A(),Vc=t().d;return new Tv(a,
+Yb,cd,jx(new kx,a,kc,"field removal type",Vc,!0))}if(b instanceof qP){var Hc=b.Lw,rc=b.Mw,sd=b.Nw;if(Hc instanceof I_)var Kc=Hc;else xm("Program reached and unexpected state.");for(var Qd=P6(a,Kc,c,d,e,g,h,k,l,m,n),Ad=new y(Ta=>{a:{if(null!==Ta){var wb=Ta.h(),$a=Ta.j();if(null!==$a){var wa=$a.Bi;$a=$a.Ci;Ta=P6(a,wa,c,d,e,g,h,k,l,m,n);var hb=d.n(wb);wa=jx(new kx,a,wa.A(),"lower bound specifiation",(tx(a),t().d),(tx(a),!1));var ra=Sw(a).ob;Tw(a,Ta,hb,e,wa,c,ra);wb=d.n(wb);Ta=P6(a,$a,c,d,e,g,h,k,l,m,
+n);$a=jx(new kx,a,$a.A(),"upper bound specifiation",(tx(a),t().d),(tx(a),!1));hb=Sw(a).ob;Tw(a,wb,Ta,e,$a,c,hb);break a}}throw new w(Ta);}}),kd=rc;!kd.b();)Ad.n(kd.e()),kd=kd.f();for(var Hd=new y(Ta=>{if(null!==Ta){var wb=Ta.Bi,$a=Ta.Ci;Ta=P6(a,wb,c,d,e,g,h,k,l,m,n);var wa=P6(a,$a,c,d,e,g,h,k,l,m,n);wb=jx(new kx,a,Wca(wF(),wb.A(),$a.A(),new fn((hb,ra)=>xs(hb,ra))),"constraint specifiation",(tx(a),t().d),(tx(a),!1));$a=Sw(a).ob;Tw(a,Ta,wa,e,wb,c,$a)}else throw new w(Ta);}),Rd=sd;!Rd.b();)Hd.n(Rd.e()),
+Rd=Rd.f();return Qd}if(b instanceof Vt){var Bd=b.Ws,ae=b.Vs,dd=jx(new kx,a,ae.A(),"polymorphic type",(tx(a),t().d),(tx(a),!1)),od=new y(Ta=>{var wb=new aw(d);Qt(Bd,new y($a=>{if($a instanceof fe)xm("Program reached and unexpected state.");else{if($a instanceof Ud){$a=$a.fa;var wa=$a.A(),hb=aT($a);wa=jx(new kx,a,wa,"quantified type variable",hb,!0);hb=t().d;var ra=aT($a),wc=O().c,ac=O().c;wa=new lx(a,Ta.da,wc,ac,hb,ra,!1,wa);wb.rc=wb.rc.Pn(G(new H,$a,wa));return wa}throw new w($a);}}));return P6(a,
+ae,Ta,wb.rc,e,g,h,k,l,m,n)});Sw(c.S);return Px(c,od,e,dd)}throw new w(b);}),new y(v=>"\x3d\x3e "+v))};function Q6(a,b,c,d,e,g,h){var k=tc();try{var l=new IQ(0),m=new y(r=>{if(r instanceof Ff){if(Pe(new E(l.ve),0)){var v=Ey(a),x=new y(()=>{}),A=V(a),B=Sw(a).ob;Tw(a,v,d,x,A,e,B);g.n(r)}else if(3<=l.ve)throw Hq(new Iq,k,d);l.ve=1+l.ve|0}else g.n(r)}),n=Sw(a).ob;Tw(a,b,c,m,h,e,n);return d}catch(r){if(r instanceof Iq){b=r;if(b.Qg===k)return b.Cj();throw b;}throw r;}}
+function R6(a,b,c,d){if(!b.tJ().b()){var e=new Te(new Ue(J(new K,["Class "," is abstract and cannot be instantiated"])));b=[We(Xe(),b.Cf.x)];Lw(a,Ye(e,J(new K,b)),c.A(),d)}}function S6(a,b,c,d){if(b.Om.b()){var e=new Te(new Ue(J(new K,[""," `","` is not mutable and cannot be reassigned"])));b=[We(Xe(),cy(b)),We(Xe(),b.Rb.x)];Lw(a,Ye(e,J(new K,b)),c.Ga,d)}}
+function T6(a,b,c,d,e,g){if(a.F){var h=""+ut(Q(),"| ",a.r)+G(new H,b,c.$a.U(b));ff(gf(),h+"\n")}c=c.$a.U(b);if(t().d===c)return g=new Te(new Ue(J(new K,["Type `","` cannot be used in `new` expression"]))),b=[We(Xe(),b)],Lw(a,Ye(g,J(new K,b)),d.A(),e);if(c instanceof L){b=c.k;if(null!==b&&!Ot(new E(b.Qu),Bp()))return d=new Te(new Ue(J(new K,[""," "," cannot be used in `new` expression"]))),Xe(),Q(),b=[We(0,Nu(0,b.Qu.ld)),We(Xe(),b.sO)],Lw(a,Ye(d,J(new K,b)),g.Ga,e);if(null!==b)return h=b.Ab,h.tJ().b()||
+(c=new Te(new Ue(J(new K,["Class "," is abstract and cannot be instantiated"]))),h=[We(Xe(),h.Cf.x)],Lw(a,Ye(c,J(new K,h)),d.A(),e)),Cy(b,!0,g.Ga,e);throw new w(b);}throw new w(c);}
+var Tfa=function U6(a,b,c){b=uy(b);if(b instanceof Qx){var e=b.Re;if(null!==e&&(e=Hv(Iv(a),e,c),!e.b()&&(e=e.k,e instanceof cv)))return O(),a=J(new K,[e]),Pd(u(),a)}if(b instanceof cv)return O(),a=J(new K,[b]),Pd(u(),a);if(b instanceof lx){var g=vy(b);if(g===u())a=u();else{b=g.e();e=b=new z(U6(a,b,c),u());for(g=g.f();g!==u();){var h=g.e();h=new z(U6(a,h,c),u());e=e.p=h;g=g.f()}a=b}c=op().ga;return zX(a,c)}return b instanceof LA&&(g=b.ic,e=b.jc,Pe(new E(b.tc),!1))?(b=U6(a,g,c),a=U6(a,e,c),un(b,a)):
 O().c};
-function K6(a,b,c,d,e,g){if(a.YO){dw(c.V);var h=1+c.fa|0,k=ru().U();h=new Uv(c.V,c.Vc,c.Xa,c.kd,h,c.Ac,c.vb,c.fb,c.ud,k);a=cw(a,b,h,d,e,!0);gp(fp(),c.V.$h||h.hb.b());ru().U();b=Ww(c.V);e=h.hb.m();e=new ho(e,new z((m=>n=>{if(null!==n){var r=n.i();n=n.j().m();return new eg(n,new z(u=>{if(null!==u){var w=u.Xc();u=u.j();gp(fp(),u.Ca()>m.fa);return w?G(new H,u,r):G(new H,r,u)}throw new x(u);}))}throw new x(n);})(c)));je();a=Xw(b,le(v(),e),a);b=c.V;b.D&&(b=Hs(Q(),"| ",b.q)+("Inferred poly constr: "+a+"  \u2014\u2014 where ")+
-Yw(a),Af(Bf(),b+"\n"));c.V.D&&sr(new E(a),a)&&(b=c.V,b.D&&(b=Hs(Q(),"| ",b.q)+("Refreshed:            "+a+"  \u2014\u2014 where ")+Yw(a),Af(Bf(),b+"\n")));a=Zw($w(c.V),c.fa,a);h.hb.eg();b=h.hb;gp(fp(),c.V.$h||h.hb.b());if(!b.b()){h=c.V.pa;e=c.V;e.D&&(k=Hs(Q(),"| ",e.q)+"UNSTASHING... (out)",Af(Bf(),k+"\n"));e.q=1+e.q|0;try{b.ya(new z(((m,n)=>r=>{if(null!==r){var u=r.i();for(r=r.j().m();r.s();){var w=r.t();a:{if(null!==w){var y=w.j();if(!0===w.Xc()){w=dw(m.V).Cb;ew(m.V,y,u,d,g,n,w);break a}}if(null!==
-w&&(y=w.j(),!1===w.Xc())){w=dw(m.V).Cb;ew(m.V,u,y,d,g,n,w);break a}throw new x(w);}}}else throw new x(r);})(c,c)));b.eg();var l=void 0}finally{e.q=-1+e.q|0}Gw(new E(h),e.pa)&&e.D&&(c=""+Hs(Q(),"| ",e.q)+h.n(l),Af(Bf(),c+"\n"))}return a}return cw(a,b,c,d,e,!0)}
-function rea(a,b,c,d,e,g,h){var k=L6(a,b,d,e,g);g=t().f;t();var l=c.w;l=(0<=l.length&&"_"===l.substring(0,1)?0:!rD(c))?new M(c.w):R();var m=O().c,n=O().c;g=new Ow(a,d.fa,m,n,g,l,!1,h);b=Vw(a,k,Mw(new Nw,a,jq(b),"receiver",(Uw(a),t().f),(Uw(a),!1)));k=Pu(a);l=Mw(new Nw,a,c.C(),"field selector",(Uw(a),t().f),(Uw(a),!1));l=new ww(g.p,R(),g,l);c=G(new H,c,l);l=O().c;c=uA(k,new A(c,l),h);return G6(a,b,c,g,d,e,h)}
-function M6(a,b,c,d,e,g,h,k){if(a.Qc)var l=t().f;else{var m=c.w;a:{if(null!==m&&(l=Lba(tda(),m),!l.b()&&null!==l.o()&&0===l.o().$a(2))){m=l.o().ua(0);l=l.o().ua(1);l=hY(d,(t(),new M(m)),l);break a}l=hY(d,t().f,m)}}if(l instanceof M){l=l.k;if(l.qaa().b()){if(!(0<l.n2().$a(1)))throw new rk("assertion failed: "+l);m=new mf(new nf(J(new L,["Implicit call to method "," is forbidden because it is ambiguous."])));var n=[pf(qf(),c.w)];m=sf(m,J(new L,n));e=e.C();e=G(new H,m,e);m=new mf(new nf(J(new L,["Unrelated methods named ",
-" are defined by:"])));c=[pf(qf(),c.w)];c=sf(m,J(new L,c));m=t().f;c=G(new H,c,m);var r=l.n2();m=y=>{y=d.vb.n(y.X);var B=new mf(new nf(J(new L,["\u2022 "," ",""]))),D=[pf(qf(),y.dj.td),nO(qf(),y.Kl)];B=sf(B,J(new L,D));y=y.Kl.C();return G(new H,B,y)};if(r===v())m=v();else{n=r.e();var u=n=new A(m(n),v());for(r=r.g();r!==v();){var w=r.e();w=new A(m(w),v());u=u.r=w;r=r.g()}m=n}yx(a,new A(e,new A(c,m)),g)}h=L6(a,b,d,g,h);b=t().f;c=t().f;e=O().c;m=O().c;b=new Ow(a,d.fa,e,m,b,c,!1,k);l=l.H$();return G6(a,
-vA(l,d),new yu(a,N6(a,h),b,k),b,d,g,k)}if(t().f===l){if(a.Qc?0:IA(Ne(),c.w))return k=new mf(new nf(J(new L,["Method "," not found"]))),h=[pf(qf(),c.w)],Xv(a,sf(k,J(new L,h)),e.C(),g);b instanceof xm&&(l=new Wl("super"),b=b.C(),b=aq(l,b));return rea(a,b,c,d,g,h,k)}throw new x(l);}
-var uea=function sea(a,b,c,d,e,g,h){for(;;){var l=b;if(l instanceof A){b=l;var m=b.A;b=b.r;if(null!==m){var n=m.i();m=m.Hx();if(null!==n)if(l=n.i(),n=n.j(),m)if(m=n.Da,m instanceof fm||m instanceof Wl){t();c=c.mm(G(new H,l,new me(n.Da)));continue}else return m=new Wl(tea(l,d.Jm())),n=n.Da,t(),new om(!1,m,n,sea(a,b,c.mm(G(new H,l,new te(m))),d,e,g,h));else{t();c=c.mm(G(new H,l,new me(n.Da)));continue}}}b=O().c;if(null===b?null===l:b.h(l)){d=((r,u,w)=>y=>{var B=!1,D=null,C=r.Y(y.w);if(C instanceof M){B=
-!0;D=C;var F=D.k;if(F instanceof te)return y=F.ca,G(new H,R(),new ws(Ct().Kg,y))}if(B&&(B=D.k,B instanceof me))return y=B.ia,G(new H,R(),new ws(Ct().Kg,y));if(R()===C)return C=new mf(new nf(J(new L,["Argument named '","' is missing from this function call"]))),y=[pf(qf(),y.w)],Xv(a,sf(C,J(new L,y)),u.C(),w),G(new H,R(),new ws(Ct().Kg,new Wl("error")));throw new x(C);})(c,d,g);if(e===v())e=v();else{g=e.e();b=g=new A(d(g),v());for(e=e.g();e!==v();)c=e.e(),c=new A(d(c),v()),b=b.r=c,e=e.g();e=g}e=new im(e);
-return new mm(h,e)}throw new x(l);}};function O6(a,b,c,d,e,g,h){if(null!==b){var k=b.Ma,l=b.oa;if(k instanceof M&&(k=k.k,k instanceof Ow&&l instanceof Ow&&hf(new E(k),l)))return a=P6(a,l,c,d,e,g,h),new Cn((t(),new M(a)),a)}l=b.Ma;l.b()?l=R():(l=l.o(),l=new M(P6(a,l,c,d,e,g,h)));return new Cn(l,P6(a,b.oa,c,d,e,g,h))}function Q6(a,b,c,d,e,g,h){je();b=le(v(),b);var k=new z(m=>m.i()),l=dT();b=OY(b,k,l);return new Ss(Hn(b,new F_(a,c,d,e,g,h)))}
-var P6=function R6(a,b,c,d,e,g,h){for(;;){var l=!1,m=null,n=!1,r=null,u=!1,w=null,y=!1,B=null,D=!1,C=null,F=CB(b);if(F instanceof Ow&&(l=!0,m=F,d))return S6(m);if(l)return c.MN.yd(m,new U(((wc,Xb,gc,hc,gd,kc)=>()=>{var ud=S6(wc);if(!Xb.L(wc)){Xb.S(wc);var za=wc.Wb;if(za instanceof M){var Qa=R6(a,za.k,gc,gd,Xb,hc,kc);za=hc.Lb;Qa=new dP(Qa,Qa);Qa=G(new H,ud,Qa);hc.Lb=new A(Qa,za)}else if(t().f===za){za=ny(wc);for(Qa=a.tb;!za.b();){var xc=za.e(),yd=V(Qa.p);Qa=zu(Qa,xc,yd,!1);za=za.g()}za=R6(a,Qa,gc,
-gd,Xb,hc,kc);Qa=Tz(wc);for(xc=a.Na;!Qa.b();){yd=Qa.e();var be=V(xc.p);xc=Uz(xc,yd,be);Qa=Qa.g()}xc=R6(a,xc,gc,gd,Xb,hc,kc);if(sr(new E(za),Il())||sr(new E(xc),Jl()))Qa=hc.Lb,za=new dP(za,xc),za=G(new H,ud,za),hc.Lb=new A(za,Qa)}else throw new x(za);}return ud})(m,e,c,g,d,h)));if(F instanceof yu){var I=F,K=I.Xb;return new nt(R6(a,I.Mb,c,d,e,g,h),R6(a,K,c,d,e,g,h))}if(F instanceof nA){n=!0;r=F;var N=r.cc,P=r.dc;if(!0===r.nc){var T=a.uE,aa=a.xI,Y=V(a.uE.p),S=zu(T,aa,Y,!1);return hba(r,S,h)?new sp("Bool"):
-new $O(R6(a,N,c,d,e,g,h),R6(a,P,c,d,e,g,h))}}if(n){var Z=r.cc,ka=r.dc;if(!1===r.nc)return new ZO(R6(a,Z,c,d,e,g,h),R6(a,ka,c,d,e,g,h))}if(F instanceof dv){var X=F.Ba;return new En(Mx(Du(),X,new z(((wc,Xb,gc,hc,gd)=>kc=>O6(a,kc,wc,Xb,gc,hc,gd))(c,d,e,g,h))))}if(F instanceof Ru){var sa=F.Ub;return new aP(Mx(Du(),sa,new z(((wc,Xb,gc,hc,gd)=>kc=>O6(a,kc,wc,Xb,gc,hc,gd))(c,d,e,g,h))))}if(F instanceof fv){u=!0;w=F;var Ia=w.ld;if(null!==Ia){var Za=Ia.Ma,Ga=Ia.oa;if(R()===Za){var xa=new sp("Array"),Ra=R6(a,
-Ga,c,d,e,g,h),Ja=O().c;return new gP(xa,new A(Ra,Ja))}}}if(u){var La=O6(a,w.ld,c,d,e,g,h),pb=new sp("MutArray"),Fb=La.Pf,Gb=new dP(Fb.b()?Il():Fb.o(),La.Jg),Hb=O().c;return new gP(pb,new A(Gb,Hb))}if(F instanceof jv){var tb=F.zn,kb=((wc,Xb,gc,hc,gd)=>kc=>{if(kc instanceof te)return kc=kc.ca,t(),kc=R6(a,kc,wc,Xb,gc,hc,gd),new te(kc);if(kc instanceof me){kc=kc.ia;t();var ud=kc.Ma;ud.b()?ud=R():(ud=ud.o(),ud=new M(R6(a,ud,wc,Xb,gc,hc,gd)));kc=new Cn(ud,R6(a,kc.oa,wc,Xb,gc,hc,gd));return new me(kc)}throw new x(kc);
-})(c,d,e,g,h);if(tb===v())var gb=v();else{for(var Vb=tb.e(),bb=new A(kb(Vb),v()),nb=bb,Tb=tb.g();Tb!==v();){var ub=Tb.e(),Ub=new A(kb(ub),v());nb=nb.r=Ub;Tb=Tb.g()}gb=bb}return new iP(gb)}if(F instanceof oA)return new bP(R6(a,F.xc,c,d,e,g,h));if(F instanceof gA&&(y=!0,B=F,!0===B.sh))return Il();if(y&&!1===B.sh)return Jl();if(F instanceof ry){var $a=F,cb=$a.Ko,Na=R6(a,$a.hq,c,d,e,g,h);Du();return new eP(Na,new En(Mx(0,cb.Ba,new z(((wc,Xb,gc,hc,gd)=>kc=>O6(a,kc,wc,Xb,gc,hc,gd))(c,d,e,g,h)))))}if(F instanceof
-sB){var Ca=F;tB(a);t();var Ba=Ca.gc(),Oa=new M(Ba);if(!Oa.b()){b=Oa.k;continue}}if(qB(F)){var wa=F.Gq();if(wa instanceof Wl){var ea=wa.w;return a.Em.L(ea)||"this"===ea?new sp(ea):new jP(hu(Q(),ea))}if(wa instanceof fm)return new fP(wa);throw new x(wa);}if(F instanceof Pw){var la=F.Xh,Ka=la.dg;if(Ka instanceof M){var Ua=Ka.k;if(IA(Ne(),Ua))return new sp(Ua)}b=la}else{if(F instanceof rB){var ya=F,ib=ya.aI,Lb=ya.Am;if(null!==Lb){var ec=Lb.Xh;return ib?vea(ec):wea(ec)}}if(F instanceof uv){D=!0;C=F;var Mb=
-C.ob,Jb=C.Vb,Kb=O().c;if(null===Kb?null===Jb:Kb.h(Jb))return Mb}if(D){var eb=C.ob,Wb=C;t();return new gP(eb,qv(Wb,new M(!0),new Um(((wc,Xb,gc,hc,gd)=>(kc,ud)=>{a:{if(kc instanceof M){if(!0===!!kc.k){var za=a.Na;za=null===za?null===ud:HB(za,ud)}else za=!1;if(za){kc=!0;break a}}if(kc instanceof M&&(!1===!!kc.k?(kc=a.tb,kc=null===kc?null===ud:HB(kc,ud)):kc=!1,kc)){kc=!0;break a}kc=!1}return kc?new dP(Il(),Jl()):R6(a,ud,wc,Xb,gc,hc,gd)})(c,d,e,g,h)),h))}if(F instanceof wB){var mc=F,ua=mc.Jf;return new dP(R6(a,
-mc.vg,c,d,e,g,h),R6(a,ua,c,d,e,g,h))}if(F instanceof gv){var Pa=F,xb=Pa.Ye;return new cP(R6(a,Pa.Bc,c,d,e,g,h),(je(),le(v(),xb)))}if(F instanceof Xu){var Yb=F.Wh,zb=((wc,Xb,gc,hc,gd)=>kc=>R6(a,kc,wc,Xb,gc,hc,gd))(c,d,e,g,h);if(Yb===v())var Sb=v();else{for(var Ma=Yb.e(),Ea=new A(zb(Ma),v()),ab=Ea,Db=Yb.g();Db!==v();){var mb=Db.e(),vb=new A(zb(mb),v());ab=ab.r=vb;Db=Db.g()}Sb=Ea}var Ya=Fn();return MG(Sb,Ya)}if(F instanceof px){var Wa=F,rb=Wa.Ld,pa=Wa.ve,Fa=g.Lb.K(),Ib=R6(a,pa,c,d,e,g,h),qb=Eq(g.Lb).m().fh(Fa),
-Nb=iE().jl(qb),fc=BC(pa,rb,a.tf).m(),Ac=aT(Ib),tc=Nb.m(),vc=new eg(tc,new z(wc=>wc.i())),sc=Ac.af(vc),uc=Nb.m(),lc=new ho(uc,new z(wc=>aT(wc.j()))),Wc=sc.af(lc),Cc=new Gx(fc,new z((wc=>Xb=>wc.L(S6(Xb)))(Wc)),!1);if(Cc.s()){var Dc=new eg(Cc,new z(wc=>{wc=S6(wc);t();return new me(wc)}));je();return new mt(le(v(),Dc),Ib)}return Ib}if(F instanceof yB){for(var Ec=F,Ic=Ec.Aj,Xc=Ec.ej,Sc=ru().U(),oc=Ic;!oc.b();){var qc=oc.e();Sc.Ai(qc.i(),new U(()=>{je();return new Wo})).S(qc.j());oc=oc.g()}var Tc=Jf(),
-Nc=new ov(Tc);Sc.ya(new z((wc=>Xb=>{if(null!==Xb)wc.Lb=wc.Lb.mm(G(new H,Xb.i(),Xb.j().Eb()));else throw new x(Xb);})(Nc)));var Pc=Nc.Lb;je();var Oc=le(v(),Pc);if(Oc.b())var $c=je().LB;else{je();var Lc=new Wo;je();for(var Zb=new Wo,ed=Oc.m();ed.s();){var $b=ed.t();ip(0<$b.j().Pk(1)?Lc:Zb,$b)}var Fc=G(new H,Lc.ea(),Zb.ea());var Yc=Fc.z;if(v().h(Yc))$c=G(new H,v(),Oc);else{var nc=Fc.x;$c=v().h(nc)?G(new H,Oc,v()):Fc}}if(null===$c)throw new x($c);for(var Ob=$c.i(),cc=$c.j(),Gc=Mx(Du(),cc,new z(wc=>wc.e())),
-Bc=ru().U(),qd=Gc;!qd.b();){var Gd=qd.e();Bc.Ai(Gd.j(),new U(()=>{je();return new Wo})).S(Gd.i());qd=qd.g()}var cd=Jf(),rd=new ov(cd);Bc.ya(new z((wc=>Xb=>{if(null!==Xb)wc.Lb=wc.Lb.mm(G(new H,Xb.i(),Xb.j().Eb()));else throw new x(Xb);})(rd)));var Id=rd.Lb;je();var Ha=le(v(),Id),jc=Mx(Du(),Ob,new z(wc=>{wc=wc.m();if(!wc.s())throw Fu("empty.reduceLeft");for(var Xb=!0,gc=null;wc.s();){var hc=wc.t();if(Xb)gc=hc,Xb=!1;else{var gd=V(gc.p);gc=Uz(gc,hc,gd)}}return gc})),Rb=Mx(Du(),Ha,new z(wc=>{wc=wc.m();
-if(!wc.s())throw Fu("empty.reduceLeft");for(var Xb=!0,gc=null;wc.s();){var hc=wc.t();if(Xb)gc=hc,Xb=!1;else{var gd=V(gc.p);gc=zu(gc,hc,gd,!1)}}return gc}));if(Rb===v())var Uc=v();else{for(var Rc=Rb.e(),Cd=new A(Rc.Et(),v()),od=Cd,Va=Rb.g();Va!==v();){var wb=Va.e(),db=new A(wb.Et(),v());od=od.r=db;Va=Va.g()}Uc=Cd}var Jc=mn(jc,Uc),Vc=((wc,Xb,gc,hc,gd)=>kc=>{if(null!==kc){var ud=kc.j();return new dP(R6(a,kc.i(),wc,Xb,gc,hc,gd),R6(a,ud,wc,Xb,gc,hc,gd))}throw new x(kc);})(c,d,e,g,h);if(Jc===v())var Ta=
-v();else{for(var kd=Jc.e(),ld=new A(Vc(kd),v()),qe=ld,Wd=Jc.g();Wd!==v();){var Rd=Wd.e(),Me=new A(Vc(Rd),v());qe=qe.r=Me;Wd=Wd.g()}Ta=ld}return new hP(R6(a,Xc,c,d,e,g,h),O().c,Ta)}throw new x(F);}}};
-function Gf(a,b,c,d){this.Cn=this.Bn=this.Dn=null;this.Vo=this.Wo=this.Dm=this.Uo=0;this.pa=null;this.q=0;this.bl=this.iq=this.mq=this.No=this.Ro=this.So=this.kq=this.Po=this.jq=this.Mo=this.Qo=this.Oo=this.lq=null;this.To=0;this.Ar=this.Up=this.Wp=this.Xp=this.Vp=this.Zp=this.Yp=null;this.nm=this.mw=0;this.Lz=this.Kz=this.bu=null;this.Hb=!1;this.zA=0;this.vE=this.wE=this.tE=this.sE=this.AA=null;this.bP=this.$h=this.zE=this.ZO=this.YO=this.oq=this.aP=this.yI=this.zI=this.Qc=this.aA=this.AE=this.D=
-!1;this.tf=this.md=0;this.dP=this.XO=this.BI=this.cP=this.Em=this.xE=this.$O=this.pq=this.AI=this.qk=this.VO=this.xI=this.uE=this.Fj=this.pk=this.fj=this.WO=this.yg=this.Bs=this.tb=this.Na=null;this.yE=0;this.D=a;this.AE=b;this.aA=c;this.Qc=d;Xaa(this);gY||(gY=new fY);null===this.So&&null===this.So&&(this.So=new QP(this));this.bl=this.So;mE(iE());this.To=0;this.mw=1E4;this.nm=0;this.Hb=!1;this.zA=0;this.AA=xda();this.$h=this.zE=this.ZO=this.YO=this.oq=this.aP=this.yI=this.zI=!1;this.bP=!0;this.md=
-0;this.tf=1024;this.Na=new gA(this,!1,T6(this));this.tb=new gA(this,!0,T6(this));this.Bs=d?new gu(this,new Jo(!0),Wp(),T6(this)):new gu(this,new Wl("unit"),Wp(),T6(this));this.yg=d?RP(this.bl,new sp("Bool"),O().c,T6(this)):new gu(this,new Wl("bool"),Wp(),T6(this));new gu(this,new Wl("Object"),Wp(),T6(this));this.WO=d?RP(this.bl,new sp("Object"),O().c,T6(this)):this.Na;this.fj=d?RP(this.bl,new sp("Int"),O().c,T6(this)):new gu(this,new Wl("int"),C6(new sp("number")),T6(this));this.pk=d?RP(this.bl,new sp("Num"),
-O().c,T6(this)):new gu(this,new Wl("number"),Wp(),T6(this));this.Fj=d?RP(this.bl,new sp("Str"),O().c,T6(this)):new gu(this,new Wl("string"),Wp(),T6(this));this.uE=d?RP(this.bl,new sp("true"),O().c,T6(this)):new gu(this,new Wl("true"),C6(new sp("bool")),T6(this));this.xI=d?RP(this.bl,new sp("false"),O().c,T6(this)):new gu(this,new Wl("false"),C6(new sp("bool")),T6(this));this.VO=new IB(this,new Wl("Eql"),Wp(),V(this));this.qk=new Wl("error");O();var e=G(new H,"unit",this.Bs),g=G(new H,"bool",this.yg),
-h=G(new H,"int",this.fj),k=G(new H,"number",this.pk),l=G(new H,"string",this.Fj),m=G(new H,"anything",this.Na),n=[e,g,h,k,l,m,G(new H,"nothing",this.tb)],r=J(new L,n);this.AI=le(v(),r);this.pq=new iq(0,0,new Xe("\x3cprelude\x3e",0,Tl()));t();var u=pp(),w=new sp("Object"),y=O().c,B=t().f,D=t().f,C=t().f,F=O().c,I=t().f,K=t().f,N=new Ss(O().c),P=t().f;t();var T=new io(u,w,y,B,D,C,F,I,K,N,P,new M(this.pq)),aa=tp(),Y=new sp("Eql");t();var S=Tt().cA,Z=G(new H,new M(S),new sp("A")),ka=O().c,X=new A(Z,ka),
-sa=t().f,Ia=t().f,Za=t().f,Ga=O().c,xa=t().f,Ra=t().f,Ja=new Ss(O().c),La=t().f;t();var pb=new io(aa,Y,X,sa,Ia,Za,Ga,xa,Ra,Ja,La,new M(this.pq)),Fb=pp(),Gb=new sp("Num"),Hb=O().c,tb=t().f,kb=t().f,gb=t().f,Vb=O().c,bb=t().f,nb=t().f,Tb=new Ss(O().c),ub=t().f;t();var Ub=new io(Fb,Gb,Hb,tb,kb,gb,Vb,bb,nb,Tb,ub,new M(this.pq)),$a=pp(),cb=new sp("Int"),Na=O().c,Ca=t().f,Ba=t().f,Oa=t().f,wa=new Wl("Num"),ea=O().c,la=new A(wa,ea),Ka=t().f,Ua=t().f,ya=new Ss(O().c),ib=t().f;t();var Lb=new io($a,cb,Na,Ca,
-Ba,Oa,la,Ka,Ua,ya,ib,new M(this.pq)),ec=pp(),Mb=new sp("Bool"),Jb=O().c,Kb=t().f,eb=t().f;t();var Wb=new $O(new sp("true"),new sp("false")),mc=new M(Wb),ua=O().c,Pa=t().f,xb=t().f,Yb=new Ss(O().c),zb=t().f;t();var Sb=new io(ec,Mb,Jb,Kb,eb,mc,ua,Pa,xb,Yb,zb,new M(this.pq)),Ma=mp(),Ea=new sp("true"),ab=O().c,Db=t().f,mb=t().f,vb=t().f,Ya=new Wl("Bool"),Wa=O().c,rb=new io(Ma,Ea,ab,Db,mb,vb,new A(Ya,Wa),t().f,t().f,new Ss(O().c),t().f,t().f),pa=mp(),Fa=new sp("false"),Ib=O().c,qb=t().f,Nb=t().f,fc=t().f,
-Ac=new Wl("Bool"),tc=O().c,vc=new io(pa,Fa,Ib,qb,Nb,fc,new A(Ac,tc),t().f,t().f,new Ss(O().c),t().f,t().f),sc=pp(),uc=new sp("Str"),lc=O().c,Wc=t().f,Cc=t().f,Dc=t().f,Ec=O().c,Ic=t().f,Xc=t().f,Sc=new Ss(O().c),oc=t().f;t();var qc=new io(sc,uc,lc,Wc,Cc,Dc,Ec,Ic,Xc,Sc,oc,new M(this.pq)),Tc=np(),Nc=new sp("undefined"),Pc=O().c,Oc=t().f,$c=t().f;t();var Lc=new fP(new Jo(!0)),Zb=new M(Lc),ed=O().c,$b=t().f,Fc=t().f,Yc=new Ss(O().c),nc=t().f;t();var Ob=new io(Tc,Nc,Pc,Oc,$c,Zb,ed,$b,Fc,Yc,nc,new M(this.pq)),
-cc=np(),Gc=new sp("null"),Bc=O().c,qd=t().f,Gd=t().f;t();var cd=new fP(new Jo(!1)),rd=new M(cd),Id=O().c,Ha=t().f,jc=t().f,Rb=new Ss(O().c),Uc=t().f;t();var Rc=[T,pb,Ub,Lb,Sb,rb,vc,qc,Ob,new io(cc,Gc,Bc,qd,Gd,rd,Id,Ha,jc,Rb,Uc,new M(this.pq))],Cd=J(new L,Rc);this.$O=le(v(),Cd);var od=new bY(this,pp(),new sp("?"),O().c,this.Na,O().c,O().c,Wp(),t().f,O().c,(T2(this),t().f)),Va=new bY(this,pp(),new sp("int"),O().c,this.Na,O().c,O().c,C6(new sp("number")),t().f,O().c,(T2(this),t().f)),wb=new bY(this,
-pp(),new sp("number"),O().c,this.Na,O().c,O().c,Wp(),t().f,O().c,(T2(this),t().f)),db=new bY(this,pp(),new sp("bool"),O().c,this.Na,O().c,O().c,Wp(),t().f,O().c,(T2(this),t().f)),Jc=new bY(this,pp(),new sp("true"),O().c,this.Na,O().c,O().c,C6(new sp("bool")),t().f,O().c,(T2(this),t().f)),Vc=new bY(this,pp(),new sp("false"),O().c,this.Na,O().c,O().c,C6(new sp("bool")),t().f,O().c,(T2(this),t().f)),Ta=new bY(this,pp(),new sp("string"),O().c,this.Na,O().c,O().c,Wp(),t().f,O().c,(T2(this),t().f)),kd=
-new bY(this,np(),new sp("undefined"),O().c,new gu(this,new Jo(!0),Wp(),V(this)),O().c,O().c,Wp(),t().f,O().c,(T2(this),t().f)),ld=new bY(this,np(),new sp("null"),O().c,new gu(this,new Jo(!1),Wp(),V(this)),O().c,O().c,Wp(),t().f,O().c,(T2(this),t().f)),qe=new bY(this,np(),new sp("anything"),O().c,this.Na,O().c,O().c,Wp(),t().f,O().c,(T2(this),t().f)),Wd=new bY(this,np(),new sp("nothing"),O().c,this.tb,O().c,O().c,Wp(),t().f,O().c,(T2(this),t().f)),Rd=new bY(this,pp(),new sp("error"),O().c,this.Na,
-O().c,O().c,Wp(),t().f,O().c,(T2(this),t().f)),Me=new bY(this,pp(),new sp("unit"),O().c,this.Na,O().c,O().c,Wp(),t().f,O().c,(T2(this),t().f)),wc=T6(this),Xb=t().f,gc=t().f,hc=O().c,gd=O().c,kc=new Ow(this,1,hc,gd,Xb,gc,!1,wc),ud=np(),za=new sp("Array");O();var Qa=new sp("A"),xc=[G(new H,Qa,kc)],yd=J(new L,xc),be=new bY(this,ud,za,le(v(),yd),new fv(this,new ww(this,R(),kc,T6(this)),T6(this)),O().c,O().c,Wp(),t().f,O().c,(T2(this),t().f));t();var yc=ru(),Od=Tt().bA,sd=[G(new H,kc,Od)],he=yc.wh(J(new L,
-sd));be.iu=new M(he);var ue=T6(this),sg=t().f,Se=t().f,Kf=O().c,$e=O().c,rf=new Ow(this,1,Kf,$e,sg,Se,!1,ue),He=np(),Ze=new sp("MutArray");O();var jf=new sp("A"),tf=[G(new H,jf,rf)],Te=J(new L,tf),hg=new bY(this,He,Ze,le(v(),Te),new fv(this,new ww(this,new M(rf),rf,T6(this)),T6(this)),O().c,O().c,Wp(),t().f,O().c,(T2(this),t().f));t();var eh=ru(),fh=Tt().En,tg=[G(new H,rf,fh)],Jg=eh.wh(J(new L,tg));hg.iu=new M(Jg);var Gh=O().c;this.xE=new A(od,new A(Va,new A(wb,new A(db,new A(Jc,new A(Vc,new A(Ta,
-new A(kd,new A(ld,new A(qe,new A(Wd,new A(Rd,new A(Me,new A(be,new A(hg,Gh)))))))))))))));var zg=this.xE.m(),ig=new eg(zg,new z(vn=>vn.Kl.X)),qh=new ho(ig,new z(vn=>{var hr=BF(Ne(),vn);vn=hu(Q(),vn);var sw=O().c;return new A(hr,new A(vn,sw))}));this.Em=Zp($p(),qh).Yb("Object").Yb("Num").Yb("Str");this.cP=this.Em.Yb("Eql");var gh=V(this),Wg=t().f,Uf=t().f,rh=O().c,Rh=O().c;this.BI=new Ow(this,1,rh,Rh,Wg,Uf,!1,gh);var Sg=V(this),Hh=t().f,Xg=t().f,jg=O().c,Ag=O().c,Cf=new Ow(this,1,jg,Ag,Hh,Xg,!1,Sg),
-Bg=d?new vp(new yu(this,U6(this,this.fj,this.fj),this.fj,V(this)),new yu(this,U6(this,this.pk,this.pk),this.pk,V(this)),new yu(this,U6(this,this.pk,this.pk),this.yg,V(this)),new yu(this,U6(this,this.Fj,this.Fj),this.yg,V(this))):new vp(new yu(this,N6(this,this.fj),new yu(this,N6(this,this.fj),this.fj,V(this)),V(this)),new yu(this,N6(this,this.pk),new yu(this,N6(this,this.pk),this.pk,V(this)),V(this)),new yu(this,N6(this,this.pk),new yu(this,N6(this,this.pk),this.yg,V(this)),V(this)),new yu(this,N6(this,
-this.Fj),new yu(this,N6(this,this.Fj),this.yg,V(this)),V(this)));if(null!==Bg)var Lf=new vp(Bg.Jj,Bg.jj,Bg.ci,Bg.Qi);else throw new x(Bg);var Df=Lf.Jj,kg=Lf.jj,df=Lf.ci,Kg=Lf.Qi;fp();var Mf=G(new H,"true",this.uE),Vf=G(new H,"false",this.xI),Cg=new uv(this,new sp("True"),O().c,V(this)),Ef=G(new H,"True",Cg),Wf=new uv(this,new sp("False"),O().c,V(this)),de=G(new H,"False",Wf),Ee=G(new H,"NaN",this.pk),Sh=G(new H,"document",this.tb),hi=G(new H,"window",this.tb),vi=new yu(this,N6(this,this.Na),this.Fj,
-V(this)),Lg=G(new H,"typeof",vi),Tg=new yu(this,N6(this,this.Na),this.Fj,V(this)),cj=G(new H,"toString",Tg),Cj=new yu(this,N6(this,this.Na),this.Fj,V(this)),Dj=G(new H,"String",Cj),wi=new yu(this,N6(this,this.yg),this.yg,V(this)),Ki=G(new H,"not",wi),Yg=new yu(this,N6(this,this.fj),this.fj,V(this)),dj=G(new H,"succ",Yg),ii=new px(this,this.md,new yu(this,N6(this,Cf),this.Bs,V(this))),ji=G(new H,"log",ii),Th=new px(this,this.md,new yu(this,N6(this,Cf),this.Bs,V(this))),Ej=G(new H,"discard",Th),ej=
-new yu(this,N6(this,this.fj),this.fj,V(this)),xd=G(new H,"negate",ej),ke=new yu(this,N6(this,this.pk),this.fj,V(this)),Ie=G(new H,"round",ke),Qf=G(new H,"add",Df),hh=G(new H,"sub",Df),lg=G(new H,"mul",Df),Uh=G(new H,"div",Df),Zg=new yu(this,N6(this,this.fj),this.fj,V(this)),Vh=G(new H,"sqrt",Zg),fj=G(new H,"lt",df),gj=G(new H,"le",df),Li=G(new H,"gt",df),Mi=G(new H,"ge",df),hj=G(new H,"slt",Kg),Fj=G(new H,"sle",Kg),Qj=G(new H,"sgt",Kg),Ni=G(new H,"sge",Kg),Gj=new yu(this,N6(this,this.Fj),this.fj,
-V(this)),Hj=G(new H,"length",Gj),lk=new yu(this,N6(this,this.Fj),new yu(this,N6(this,this.Fj),this.Fj,V(this)),V(this)),md=G(new H,"concat",lk),Ue=this.Fj,Jd=V(this),uf=new yu(this,new fv(this,new ww(Ue.p,R(),Ue,Jd),V(this)),this.Fj,V(this)),Dl=G(new H,"join",uf),gl=V(this),am=t().f,xk=t().f,Ae=O().c,Ff=O().c,vf=new Ow(this,1,Ae,Ff,am,xk,!1,gl),Xf=new px(this,this.md,new yu(this,N6(this,vf),new yu(this,N6(this,vf),this.yg,V(this)),V(this))),Ij=G(new H,"eq",Xf),Rj=V(this),hl=t().f,El=t().f,on=O().c,
-Oi=O().c,ee=new Ow(this,1,on,Oi,hl,El,!1,Rj),Re=new px(this,this.md,new yu(this,N6(this,ee),new yu(this,N6(this,ee),this.yg,V(this)),V(this))),Ji=G(new H,"ne",Re),jk=G(new H,"error",this.tb),Vg=this.BI,kk=this.md,eo=t().f,dr=this.Na,Ud=V(this),ne=new ww(dr.p,R(),dr,Ud),Fe=G(new H,eo,ne),Bk=t().f,sn=V(this),Hc=new ww(Vg.p,R(),Vg,sn),Sd=G(new H,Bk,Hc),Hd=O().c,Be=new px(this,kk,new yu(this,new Ru(this,new A(Fe,new A(Sd,Hd)),V(this)),Vg,V(this))),mj=G(new H,",",Be),bm=G(new H,"+",Df),Km=G(new H,"-",
-Df),tn=G(new H,"*",Df),ut=G(new H,"%",Df),pE=G(new H,"/",kg),qE=G(new H,"\x3c",df),vt=G(new H,"\x3e",df),zz=G(new H,"\x3c\x3d",df),gw=G(new H,"\x3e\x3d",df),qs=G(new H,"\x3d\x3d",df),er=this.BI,hw=new sp("Eql"),iw=O().c,rE=new uv(this,hw,new A(er,iw),V(this)),wt=new px(this,this.md,new yu(this,U6(this,rE,er),this.yg,V(this))),xt=G(new H,"\x3d\x3d\x3d",wt),Az=G(new H,"\x3c\x3e",df),jw=d?new yu(this,U6(this,this.yg,this.yg),this.yg,V(this)):new yu(this,N6(this,this.yg),new yu(this,N6(this,this.yg),
-this.yg,V(this)),V(this)),kw=G(new H,"\x26\x26",jw),lw=d?new yu(this,U6(this,this.yg,this.yg),this.yg,V(this)):new yu(this,N6(this,this.yg),new yu(this,N6(this,this.yg),this.yg,V(this)),V(this)),rs=G(new H,"||",lw),ss=V(this),ts=t().f,Bz=t().f,sE=O().c,mw=O().c,yt=new Ow(this,1,sE,mw,ts,Bz,!1,ss),tE=new px(this,this.md,new yu(this,N6(this,yt),yt,V(this))),nw=G(new H,"id",tE),ow=V(this),fr=t().f,Cz=t().f,Dz=O().c,uE=O().c,us=new Ow(this,1,Dz,uE,fr,Cz,!1,ow),vs=new px(this,this.md,new yu(this,N6(this,
-this.yg),new yu(this,N6(this,us),new yu(this,N6(this,us),us,V(this)),V(this)),V(this))),zt=G(new H,"if",vs),pw=V(this),qw=t().f,At=t().f,Ez=O().c,Xo=O().c,gr=new Ow(this,1,Ez,Xo,qw,At,!1,pw),Fz=new px(this,0,new fv(this,new ww(this,(t(),new M(gr)),gr,V(this)),V(this))),Gz=[Mf,Vf,Ef,de,Ee,Sh,hi,Lg,cj,Dj,Ki,dj,ji,Ej,xd,Ie,Qf,hh,lg,Uh,Vh,fj,gj,Li,Mi,hj,Fj,Qj,Ni,Hj,md,Dl,Ij,Ji,jk,mj,bm,Km,tn,ut,pE,qE,vt,zz,gw,qs,xt,Az,kw,rs,nw,zt,G(new H,"emptyArray",Fz)],rw=J(new L,Gz),Hz=bp(0,rw);if(d)Jz=O().c;else var vE=
-this.AI,Iz=ht(this.AI,new z(vn=>{var hr=hu(Q(),vn.i());return G(new H,hr,vn.j())})),Jz=mn(vE,Iz);this.XO=Hz.oe(Jz);this.dP=Zp(fp().gv,J(new L,"| \x26 ~ neg and or is".split(" ")));this.yE=0}Gf.prototype=new j5;Gf.prototype.constructor=Gf;function If(a){null===a.sE&&null===a.sE&&(a.sE=new BP(a));return a.sE}function V(a){null===a.tE&&null===a.tE&&(a.tE=new H_(a));return a.tE}function TB(a){null===a.wE&&null===a.wE&&(a.wE=new UB(a));return a.wE}
-function V6(a){null===a.vE&&null===a.vE&&(a.vE=new NB(a));return a.vE}function Lx(a,b,c){var d=b.C();b=Lt(b);Uw(a);var e=t().f;return Mw(new Nw,a,d,b,e,c)}function T6(a){var b=t().f;Uw(a);var c=t().f;return Mw(new Nw,a,b,"type",c,!0)}function N6(a,b){var c=t().f,d=b.qa();b=G(new H,c,new ww(b.p,R(),b,d));c=O().c;return new Ru(a,new A(b,c),V(a))}
-function U6(a,b,c){var d=t().f,e=b.qa();b=new ww(b.p,R(),b,e);d=G(new H,d,b);b=t().f;e=c.qa();c=new ww(c.p,R(),c,e);c=G(new H,b,c);b=O().c;return new Ru(a,new A(d,new A(c,b)),V(a))}function Qw(a,b,c,d,e,g){return xea(a,b,c,d,e,g).i()}
-function xea(a,b,c,d,e,g){var h=new z(u=>"\x3d\x3e "+u.i()+" \u2014\u2014\u2014 "+Qe(u.j(),"",", ",""));if(a.D){var k=Hs(Q(),"| ",a.q)+"Typing type "+nO(qf(),b).mr();Af(Bf(),k+"\n")}a.q=1+a.q|0;try{if(a.D){var l=Hs(Q(),"| ",a.q)+("vars\x3d"+e+" newDefsInfo\x3d")+g;Af(Bf(),l+"\n")}var m=c.fa,n=ru().U(),r=G(new H,pea(a,b,c,Jf(),d,!0,e,n,m,g,c),new dp(n))}finally{a.q=-1+a.q|0}Gw(new E(h),a.pa)&&a.D&&(a=""+Hs(Q(),"| ",a.q)+h.n(r),Af(Bf(),a+"\n"));return r}
-function W6(a,b,c,d,e){return cw(a,b,new Uv(c.V,c.Vc,c.Xa,c.kd,c.fa,!0,c.vb,c.fb,c.ud,c.hb),d,e,!1)}
-function Ox(a,b,c,d,e,g,h){var k=!1,l=null;if(b instanceof xo){k=!0;l=b;var m=l.Gp,n=l.Ot;if(!1===l.Dr&&null!==m&&"_"===m.w&&n instanceof te)return Ox(a,n.ca,c,d,e,g,h)}if(k&&(m=l.Dr,k=l.Gp,l=l.Ot,l instanceof te))return b=l.ca,"_"===k.w&&(h=new mf(new nf(J(new L,["Illegal definition name: ",""]))),c=[pf(qf(),k.w)],Xv(a,sf(h,J(new L,c)),k.C(),e)),b=X6(a,m,k.w,b,d,e,g),t(),g=Y6(a),k.Fs=new M(g),g=k.w,h=new Sw(a,b,k),g=G(new H,g,h),d.Xa.S(g),t(),t(),d=G(new H,k.w,b),new me(new M(d));if(b instanceof
-im&&(k=b.Ra,!c)){a:{if(k instanceof A&&(m=k.A,c=k.r,null!==m&&(m.i()instanceof M?(m=O().c,c=null===m?null===c:m.h(c)):c=!1,c))){k="field";break a}c=O().c;k=(null===c?null===k:c.h(k))?"empty tuple":"tuple"}OX(a,pf(qf(),"Useless "+k+" in statement position."),b.C(),e);t();d=new px(a,a.md,cw(a,b,d,e,g,h));return new te(d)}if(b instanceof Ln)return g=cw(a,b,d,e,g,h),c||(b instanceof Wl||b instanceof fm?OX(a,pf(qf(),"Pure expression does nothing in statement position."),b.C(),e):(h=Vw(a,g,Mw(new Nw,a,
-jq(b),"expression in statement position",(Uw(a),t().f),(Uw(a),!1))),k=a.Bs,c=new z(r=>{Fq();var u=sf(new mf(new nf(J(new L,["Expression in statement position should have type `unit`."]))),v()),w=t().f;u=G(new H,u,w);w=sf(new mf(new nf(J(new L,["Use the `discard` function to discard non-unit values, making the intent clearer."]))),v());var y=t().f;w=G(new H,w,y);e.n(Hq(0,new A(u,new A(w,r.Os())),a.Qc,Qt()))}),b=Mw(new Nw,a,b.C(),Lt(b),(Uw(a),t().f),(Uw(a),!1)),m=dw(a).Cb,ew(a,h,k,c,b,d,m))),t(),new te(g);
-d=new mf(new nf(J(new L,["Illegal position for this "," statement."])));g=[pf(qf(),b.yb())];Xv(a,sf(d,J(new L,g)),b.C(),e);t();d=t().f;return new me(d)}
-function X6(a,b,c,d,e,g,h){var k=Mw(new Nw,a,d.C(),"binding of "+Lt(d),(Uw(a),t().f),(Uw(a),!1));if(b){var l=V(a);b=t().f;t();var m=new M(c),n=O().c,r=O().c;l=new Ow(a,1+e.fa|0,n,r,b,m,!0,l);b=new Sw(a,l,new Wl(c));b=G(new H,c,b);e.Xa.S(b);t();c=new Wl(c);var u=new Uv(e.V,e.Vc,e.Xa,e.kd,e.fa,e.Ac,e.vb,e.fb,new M(c),e.hb);c=1+u.fa|0;b=ru().U();c=new Uv(u.V,u.Vc,u.Xa,u.kd,c,u.Ac,u.vb,u.fb,u.ud,b);t();d=cw(a,d,c,g,h,a.aP);h=dw(a).Cb;ew(a,d,l,g,k,c,h);jA(l,(t(),new M(d)));d=c.hb;gp(fp(),u.V.$h||c.hb.b());
-if(!d.b()){h=u.V.pa;c=u.V;c.D&&(b=Hs(Q(),"| ",c.q)+"UNSTASHING... (out)",Af(Bf(),b+"\n"));c.q=1+c.q|0;try{d.ya(new z(y=>{if(null!==y){var B=y.i();for(y=y.j().m();y.s();){var D=y.t();a:{if(null!==D){var C=D.j();if(!0===D.Xc()){D=dw(u.V).Cb;ew(u.V,C,B,g,k,u,D);break a}}if(null!==D&&(C=D.j(),!1===D.Xc())){D=dw(u.V).Cb;ew(u.V,B,C,g,k,u,D);break a}throw new x(D);}}}else throw new x(y);}));d.eg();var w=void 0}finally{c.q=-1+c.q|0}Gw(new E(h),c.pa)&&c.D&&(w=""+Hs(Q(),"| ",c.q)+h.n(w),Af(Bf(),w+"\n"))}w=
-l}else if(w=1+e.fa|0,c=ru().U(),c=new Uv(e.V,e.Vc,e.Xa,e.kd,w,e.Ac,e.vb,e.fb,e.ud,c),w=cw(a,d,c,g,h,!0),d=c.hb,gp(fp(),e.V.$h||c.hb.b()),!d.b()){h=e.V.pa;c=e.V;c.D&&(b=Hs(Q(),"| ",c.q)+"UNSTASHING... (out)",Af(Bf(),b+"\n"));c.q=1+c.q|0;try{d.ya(new z(((y,B)=>D=>{if(null!==D){var C=D.i();for(D=D.j().m();D.s();){var F=D.t();a:{if(null!==F){var I=F.j();if(!0===F.Xc()){F=dw(y.V).Cb;ew(y.V,I,C,g,k,B,F);break a}}if(null!==F&&(I=F.j(),!1===F.Xc())){F=dw(y.V).Cb;ew(y.V,C,I,g,k,B,F);break a}throw new x(F);
-}}}else throw new x(D);})(e,e))),d.eg(),l=void 0}finally{c.q=-1+c.q|0}Gw(new E(h),c.pa)&&c.D&&(d=""+Hs(Q(),"| ",c.q)+h.n(l),Af(Bf(),d+"\n"))}return new px(a,e.fa,w)}function Vw(a,b,c){return a.bP?new qA(a,b,c):b}function L6(a,b,c,d,e){return cw(a,b,c,d,e,!1)}
-function cw(a,b,c,d,e,g){return kx(a,new U(()=>c.fa+". Typing "+(c.Ac?"pattern":"term")+" "+b),new U(()=>{var h=Lx(a,b,!1),k=!1,l=null,m=!1,n=null,r=!1,u=null,w=!1,y=null,B=!1,D=null,C=!1,F=null,I=!1,K=null;if(b instanceof Wl&&(k=!0,l=b,"_"===l.w)){if(c.Ac){var N=Mw(new Nw,a,l.C(),"wildcard",(Uw(a),t().f),(Uw(a),!1)),P=t().f,T=t().f,aa=O().c,Y=O().c;return new Ow(a,c.fa,aa,Y,P,T,!1,N)}return Xv(a,sf(new mf(new nf(J(new L,["Widlcard in expression position."]))),v()),l.C(),d)}if(b instanceof em){m=
-!0;n=b;var S=n.Ni,Z=n.po;if(S instanceof Wl){var ka=OB(V6(a),S,c,d);if(!ka.b()){var X=ka.o(),sa=new Uv(c.V,c.Vc,c.Xa,c.kd,c.fa,!1,c.vb,c.fb,c.ud,c.hb),Ia=Jf(),Za=Qw(a,Z,sa,d,e,Ia);Mw(new Nw,a,a.AE?S.C():t().f,"variable",(Uw(a),t().f),(Uw(a),!1));var Ga=c.Xa.Y(X);if(Ga instanceof M)return Xv(a,pf(qf(),"Duplicate use of annotated pattern variable "+X),S.C(),d);if(t().f===Ga){var xa=new Sw(a,Za,S),Ra=G(new H,X,xa);c.Xa.S(Ra);return Za}throw new x(Ga);}}}if(m){var Ja=n.po,La=cw(a,n.Ni,c,d,e,!0),pb=new Uv(c.V,
-c.Vc,c.Xa,c.kd,c.fa,!1,c.vb,c.fb,c.ud,c.hb),Fb=Jf(),Gb=Qw(a,Ja,pb,d,e,Fb);if(c.Ac){var Hb=dw(a).Cb;PX(a,La,Gb,d,h,c,Hb);return Gb}return G6(a,La,Gb,Gb,c,d,h)}if(k){var tb=OB(V6(a),l,c,d);if(!tb.b()){var kb=tb.o(),gb=Mw(new Nw,a,a.AE?l.C():t().f,"variable",(Uw(a),t().f),(Uw(a),!1)),Vb=c.Xa.Y(kb),bb=new D_(a,l);if(Vb.b())ub=R();else var nb=new qr(bb),Tb=Vb.o(),ub=pr(nb,Tb);var Ub=new U((Hc=>()=>{var Sd=new Ow(a,c.fa,O().c,O().c,t().f,Rx(Nt(),a.D,new U(()=>kb)),(KP(a),!1),gb);t();var Hd=Y6(a);Hc.Fs=
-new M(Hd);Hd=new Sw(a,Sd,Hc);Hd=G(new H,kb,Hd);c.Xa.S(Hd);return Sd})(l));return ub.b()?Zr(Ub):ub.o()}}if(k){var $a=SB(TB(a),l,d);if(!$a.b()){var cb=$a.k,Na=PB(c,cb),Ca=new U(()=>Xv(a,pf(qf(),"identifier not found: "+cb),b.C(),d)),Ba=new z(Hc=>{if(Hc instanceof Sw)return Hc.zs;if(Hc instanceof MP){if(Hc instanceof Lw){var Sd=Hc.rh;if(Sd instanceof Ew)return Sd.no();if(Sd instanceof xw)return Sd.cg.oa;if(Sd instanceof Aw)return H6(a,Sd.Gf,b,d),Vx(Sd.ic,!1,h.Ia,Sd.Gf,Sd.um,Sd.Zg,Sd.yj,Sd.Wk,0,d);if(Sd&&
-Sd.$classData&&Sd.$classData.pb.ms)return Hc=new mf(new nf(J(new L,[""," "," cannot be used in term position"]))),Sd=[pf(qf(),Sd.zd().td),pf(qf(),Sd.Sa())],Xv(a,sf(Hc,J(new L,Sd)),h.Ia,d);throw new x(Sd);}if(Hc instanceof Iw)return H6(a,Hc.Kb,b,d),Ux(Hc,!1,h.Ia,d)}throw new x(Hc);}),Oa=Na.b()?Zr(Ca):Ba.n(Na.o());return Vw(a,Oa,h)}}if(b instanceof fm)return new gu(a,b,a.Qc?Xp(b):Up(b),h);if(b instanceof xm){Xv(a,pf(qf(),"Illegal use of `super`"),b.C(),d);var wa=new Wl("super"),ea=b.C();return cw(a,
-aq(wa,ea),c,d,e,g)}if(b instanceof mm){r=!0;u=b;var la=u.kb;if(la instanceof Wl){var Ka=la.w;"neg"!==Ka&&"~"===Ka}}if(r){var Ua=u.kb;if(Ua instanceof mm){var ya=Ua.kb;ya instanceof Wl&&"|"===ya.w}}if(r){var ib=u.kb;if(ib instanceof mm){var Lb=ib.kb;Lb instanceof Wl&&"\x26"===Lb.w}}if(b instanceof Zl){var ec=b.vn,Mb=Mw(new Nw,a,b.C(),"record literal",(Uw(a),t().f),(Uw(a),!1));GT(ec,new z(Hc=>Hc.i().w),new z(Hc=>Hc.i())).ya(new z(Hc=>{if(null!==Hc&&(Hc=new M(Hc),!Hc.b())){var Sd=Hc.k.i();Hc=Hc.k.j();
-if(0<Hc.$a(1)){var Hd=new mf(new nf(J(new L,["Multiple declarations of field name "," in ",""])));Sd=[pf(qf(),Sd),pf(qf(),Mb.th)];Sd=sf(Hd,J(new L,Sd));Hd=b.C();Sd=G(new H,Sd,Hd);Hc=ht(Hc,new z(Be=>{var mj=sf(new mf(new nf(J(new L,["Declared at"]))),v());Be=Be.C();return G(new H,mj,Be)}));return yx(a,new A(Sd,Hc),d)}}}));return uA(Pu(a),ht(ec,new z(Hc=>{if(null!==Hc){var Sd=Hc.i(),Hd=Hc.j();if(null!==Hd){var Be=Hd.vc;Hd=Hd.Da;if(null!==Be){Be=Be.pf;IA(Ne(),Sd.w)&&Xv(a,sf(new mf(new nf(J(new L,["Field identifiers must start with a small letter"]))),
-v()),b.C(),d);Hc=cw(a,Hd,c,d,e,!0);Hd=Mw(new Nw,a,(new mm(Sd,Hd)).C(),(Be?"mutable ":"")+"record field",(Uw(a),t().f),(Uw(a),!1));if(Be){Be=t().f;t();var mj=new M(Sd.w),bm=O().c,Km=O().c;Be=new Ow(a,c.fa,bm,Km,Be,mj,!1,Hd);Hc=G6(a,Hc,Be,Be,c,d,h);return G(new H,Sd,new ww(a,new M(Hc),Hc,Hd))}return G(new H,Sd,new ww(Hc.p,R(),Hc,Hd))}}}throw new x(Hc);})),Mb)}b instanceof im&&(w=!0,y=b);if(w){var Jb=y.Ra,Kb=ht(yea(Jb,Jb,new z(Hc=>{if(null!==Hc){var Sd=Hc.i(),Hd=Hc.j();if(null!==Hd){var Be=Hd.vc,mj=
-Hd.Da;if(Sd instanceof M&&(Hd=Sd.k,c.Ac)){Hc=new em(Hd,VS(mj,d));Hd=Hd.C();var bm=new U(()=>mj.C()),Km=new z(tn=>{tn=Zs(tn,mj.C());return bt().n(tn)});Hd=Hd.b()?Zr(bm):Km.n(Hd.o());return G(new H,Sd,new ws(Be,aq(Hc,Hd)))}return Hc}}throw new x(Hc);})),new z(Hc=>{if(null!==Hc){var Sd=Hc.i(),Hd=Hc.j();if(null!==Hd){var Be=Hd.vc;Hd=Hd.Da;if(null!==Be){Hc=Be.pf;if(Be.ri){Be=sf(new mf(new nf(J(new L,["Cannot use `val` in this position"]))),v());Dt();var mj=Sd.ea();Xv(a,Be,Et(0,new A(Hd,mj)),d)}Be=cw(a,
-Hd,c,d,e,!0);Hd=Mw(new Nw,a,Hd.C(),(Hc?"mutable ":"")+"tuple field",(Uw(a),t().f),(Uw(a),!1));if(Hc){Hc=t().f;mj=new z(tn=>tn.w);mj=Sd.b()?R():new M(mj.n(Sd.o()));var bm=O().c,Km=O().c;Hc=new Ow(a,c.fa,bm,Km,Hc,mj,!1,Hd);Be=G6(a,Be,Hc,Hc,c,d,h);return G(new H,Sd,new ww(a,new M(Be),Be,Hd))}return G(new H,Sd,new ww(Be.p,R(),Be,Hd))}}}throw new x(Hc);}));a:{var eb=O().c;if(null===eb?null===Jb:eb.h(Jb))var Wb=!0;else{if(Jb instanceof A){var mc=Jb.A,ua=Jb.r;if(null!==mc){var Pa=mc.i();if(t().f===Pa)var xb=
-O().c,Yb=null===xb?null===ua:xb.h(ua);else Yb=!1;if(Yb){Wb=!0;break a}}}Wb=!1}}return new Ru(a,Kb,Wb?V(a):Mw(new Nw,a,b.C(),"tuple literal",(Uw(a),t().f),(Uw(a),!1)))}if(b instanceof sm){var zb=b.gu,Sb=L6(a,b.fu,c,d,e),Ma=L6(a,zb,c,d,e);G6(a,Ma,a.fj,a.Na,c,d,h);var Ea=t().f,ab=t().f,Db=O().c,mb=O().c,vb=new Ow(a,c.fa,Db,mb,Ea,ab,!1,h),Ya=Tz(vb),Wa=new uv(a,new sp("undefined"),O().c,V(a)),rb=Mw(new Nw,h.qu,h.Ia,"prohibited undefined element",h.An,h.Bm),pa=pA(Wa,rb,!1);mA(vb,new A(pa,Ya));var Fa=Mw(new Nw,
-a,zb.C(),"array element",(Uw(a),t().f),(Uw(a),!1)),Ib=G6(a,Sb,new fv(a,new ww(vb.p,R(),vb,Fa),h),vb,c,d,h),qb=new sp("undefined"),Nb=O().c,fc=new uv(a,qb,Nb,Mw(new Nw,h.qu,h.Ia,"possibly-undefined array access",h.An,h.Bm)),Ac=V(Ib.p);return zu(Ib,fc,Ac,!1)}if(b instanceof hm){B=!0;D=b;var tc=D.Sh;if(!1===D.Sk&&tc instanceof pm)return cw(a,tc,c,d,e,g)}if(B)return cw(a,D.Sh,c,d,e,g);if(b instanceof pm){C=!0;F=b;var vc=F.Rk;if(vc instanceof A){var sc=vc.A,uc=vc.r;if(sc instanceof Ln){var lc=O().c;if(null===
-lc?null===uc:lc.h(uc))return cw(a,sc,c,d,e,g)}}}if(C){var Wc=F.Rk,Cc=O().c;if(null===Cc?null===Wc:Cc.h(Wc)){var Dc=a.Bs;return Vw(Dc.p,Dc,h)}}if(c.Ac){var Ec=new mf(new nf(J(new L,["Unsupported pattern shape",":"]))),Ic=[a.D?pf(qf()," ("+ja(b).u()+")"):pf(qf(),"")];return Xv(a,sf(Ec,J(new L,Ic)),b.C(),d)}if(b instanceof lm){I=!0;K=b;var Xc=K.Dl,Sc=K.El;if(hf(new E(g),!0)){mx(a,new U(()=>"TYPING POLY LAM"));var oc=Of(c),qc=new z(Hc=>{var Sd=W6(a,Xc,Hc,d,e);Hc=cw(a,Sc,Hc,d,e,a.zI||hf(new E(g),!0)&&
-a.$h);return new yu(a,Sd,Hc,Mw(new Nw,a,b.C(),"function",(Uw(a),t().f),(Uw(a),!1)))});dw(oc.V);return ox(oc,qc,d,h)}}if(I){var Tc=K.Dl,Nc=K.El,Pc=Of(c),Oc=W6(a,Tc,Pc,d,e);gp(fp(),!hf(new E(g),!0));var $c=cw(a,Nc,Pc,d,e,a.zI||hf(new E(g),!0));return new yu(a,Oc,$c,Mw(new Nw,a,b.C(),"function",(Uw(a),t().f),(Uw(a),!1)))}if(b instanceof um){var Lc=new um(b.gs),Zb=new im(O().c),ed=b.C(),$b=new z(Hc=>new iq(Hc.Xg,Hc.Xg,Hc.Wg)),Fc=ed.b()?R():new M($b.n(ed.o()));return L6(a,new mm(Lc,aq(Zb,Fc)),c,d,e)}if(r){var Yc=
-u.kb,nc=u.hc;if(Yc instanceof um){var Ob=Yc.gs;Ob instanceof km&&Xv(a,sf(new mf(new nf(J(new L,["Type arguments in `new` expressions are not yet supported"]))),v()),h.Ia,d);var cc=VS(Ob,d),Gc=Jf(),Bc=Qw(a,cc,c,d,e,Gc),qd=!1,Gd=null,cd=dB(Bc);a:if(cd instanceof uv)var rd=I6(a,cd.ob.X,c,b,d,h);else{if(cd instanceof gu){qd=!0;Gd=cd;var Id=Gd.ed,Ha=a.qk;if(null===Ha?null===Id:Ha.h(Id)){rd=Gd;break a}}if(qd){var jc=Gd.ed;if(jc instanceof Wl){rd=I6(a,jc.w,c,b,d,h);break a}}var Rb=new mf(new nf(J(new L,
-["Unexpected type `","` after `new` keyword"]))),Uc=[nO(qf(),UC(Bc,c))],Rc=sf(Rb,J(new L,Uc)),Cd=Ob.C(),od=G(new H,Rc,Cd),Va=O().c;rd=yx(a,new A(od,Va),d)}var wb=t().f,db=t().f,Jc=O().c,Vc=O().c,Ta=new Ow(a,c.fa,Jc,Vc,wb,db,!1,h),kd=Mw(new Nw,a,nc.C(),"argument list",(Uw(a),t().f),(Uw(a),!1)),ld=cw(a,nc,c,d,e,g);return G6(a,rd,new yu(a,Vw(ld.p,ld,kd),Ta,V(a)),Ta,c,d,h)}}if(r){var qe=u.kb;if(qe instanceof mm){var Wd=qe.kb;if(Wd instanceof Wl&&"is"===Wd.w){var Rd=new lt(b,new Wl("true"));t();var Me=
-new Wl("false"),wc=new tm(Rd,new M(Me));b.dd=(t(),new M(wc));return cw(a,wc,c,d,e,g)}}}if(r){var Xb=u.kb;if(Xb instanceof Wl&&"is"===Xb.w){var gc=new lt(b,new Wl("true"));t();var hc=new Wl("false"),gd=new tm(gc,new M(hc));b.dd=(t(),new M(gd));return cw(a,gd,c,d,e,g)}}if(r){var kc=u.kb,ud=u.hc;if(kc instanceof mm){var za=kc.kb,Qa=kc.hc;if(za instanceof Wl&&"and"===za.w&&null!==Qa){var xc=Ey(Gt(),Qa);if(!xc.b()&&null!==xc.o()&&0===xc.o().$a(1)){var yd=xc.o(),be=FA(yd,0);if(null!==ud){var yc=Ey(Gt(),
-ud);if(!yc.b()&&null!==yc.o()&&0===yc.o().$a(1)){var Od=yc.o(),sd=FA(Od,0),he=new lt(be,sd);t();var ue=new Wl("false"),sg=new tm(he,new M(ue));b.dd=(t(),new M(sg));return cw(a,sg,c,d,e,g)}}}}}}if(r){var Se=u.kb,Kf=u.hc;if(Se instanceof Wl&&"and"===Se.w&&null!==Kf){var $e=Ey(Gt(),Kf);if(!$e.b()&&null!==$e.o()&&0===$e.o().$a(2)){var rf=$e.o(),He=FA(rf,0),Ze=$e.o(),jf=FA(Ze,1),tf=new lt(He,jf);t();var Te=new Wl("false"),hg=new tm(tf,new M(Te));b.dd=(t(),new M(hg));return cw(a,hg,c,d,e,g)}}}if(r){var eh=
-u.kb,fh=u.hc;if(null!==eh&&fh instanceof im&&fh.Ra.Ln(new z(Hc=>!Hc.i().b()))){var tg=cw(a,eh,c,d,e,g),Jg=qea(a,tg,c),Gh=!1,zg=null;if(Jg instanceof A){Gh=!0;zg=Jg;var ig=zg.A,qh=zg.r;if(null!==ig){var gh=ig.Mb;if(gh instanceof Ru){var Wg=gh.Ub,Uf=O().c;if(null===Uf?null===qh:Uf.h(qh)){if(Wg.Ln(new z(Hc=>Hc.i().b())))return Xv(a,pf(qf(),"Cannot use named arguments as the function type has untyped arguments"),fh.C(),d);var rh=ht(Wg,new z(Hc=>{Hc=Hc.i();if(Hc instanceof M)return Hc.k;if(t().f===Hc)Dn("Program reached and unexpected state.");
-else throw new x(Hc);}));return zea(a,b,eh,fh,rh,tg,c,d,e)}}}}if(Gh&&zg.r instanceof A){var Rh=new mf(new nf(J(new L,["More than one function signature found in type `","` for function call with named arguments"]))),Sg=[nO(qf(),UC(tg,c))];return Xv(a,sf(Rh,J(new L,Sg)),eh.C(),d)}a:{var Hh=O().c;if(null===Hh?null===Jg:Hh.h(Jg))var Xg=!0;else{if(Jg instanceof A){var jg=Jg.r,Ag=O().c;if(null===Ag?null===jg:Ag.h(jg)){Xg=!0;break a}}Xg=!1}}if(Xg){var Cf=new mf(new nf(J(new L,["Cannot retrieve appropriate function signature from type `",
-"` for applying named arguments"]))),Bg=[nO(qf(),UC(tg,c))];return Xv(a,sf(Cf,J(new L,Bg)),eh.C(),d)}throw new x(Jg);}}if(r){var Lf=u.kb,Df=u.hc,kg=L6(a,Lf,c,d,e);if(Df instanceof im){var df=Df.Ra,Kg=ht(df,new z(Hc=>{if(null!==Hc){var Sd=Hc.i(),Hd=Hc.j();if(null!==Hd){var Be=Hd.Da;if(null!==Hd.vc)return Hc=Mw(new Nw,a,Be.C(),"argument",(Uw(a),t().f),(Uw(a),!1)),Be=K6(a,Be,c,d,e,h),G(new H,Sd,new ww(Be.p,R(),Be,Hc))}}throw new x(Hc);}));a:{var Mf=O().c;if(null===Mf?null===df:Mf.h(df))var Vf=!0;else{if(df instanceof
-A){var Cg=df.A,Ef=df.r;if(null!==Cg){var Wf=Cg.i();if(t().f===Wf)var de=O().c,Ee=null===de?null===Ef:de.h(Ef);else Ee=!1;if(Ee){Vf=!0;break a}}}Vf=!1}}var Sh=new Ru(a,Kg,Vf?V(a):Mw(new Nw,a,Df.C(),"argument list",(Uw(a),t().f),(Uw(a),!1)))}else Sh=K6(a,Df,c,d,e,h);var hi=t().f,vi=t().f,Lg=O().c,Tg=O().c,cj=new Ow(a,c.fa,Lg,Tg,hi,vi,!1,h),Cj=Vw(a,Sh,Mw(new Nw,a,jq(Df),"argument",(Uw(a),t().f),(Uw(a),!1))),Dj=Mw(new Nw,a,jq(Lf),"applied expression",(Uw(a),t().f),(Uw(a),!1)),wi=Vw(a,kg,Dj);return G6(a,
-wi,new yu(a,Cj,cj,h),cj,c,d,h)}if(b instanceof nm){var Ki=b.Co,Yg=b.wn,dj=!1,ii=null;if(Ki instanceof Wl){dj=!0;ii=Ki;var ji=ii.w;if(IA(Ne(),ji)&&c.vb.L(ji)){var Th=hY(c,(t(),new M(ji)),Yg.w);if(Th instanceof M){var Ej=Th.k.H$();return vA(Ej,c)}if(t().f===Th){var ej=new mf(new nf(J(new L,["Class "," has no method ",""]))),xd=[pf(qf(),ji),pf(qf(),Yg.w)];Xv(a,sf(ej,J(new L,xd)),b.C(),d);return M6(a,Ki,Yg,c,b,d,e,h)}throw new x(Th);}}if(dj){var ke=ii.w;if("unapply"===Yg.w){var Ie=!1,Qf=null,hh=PB(c,
-ke);a:{if(hh instanceof M){Ie=!0;Qf=hh;var lg=Qf.k;if(lg instanceof Lw){var Uh=lg.rh;if(Uh instanceof Aw){var Zg=qp(Uh.Gf);break a}}}if(Ie){var Vh=Qf.k;if(Vh instanceof Iw){Zg=qp(Vh.Kb);break a}}Zg=t().f}if(Zg instanceof M){var fj=Zg.k;if(null!==fj){var gj=fj.cd;if(gj instanceof te)return cw(a,gj.ca,c,d,e,!0)}}}}return M6(a,Ki,Yg,c,b,d,e,h)}if(b instanceof om){var Li=b.Wr,Mi=b.Op,hj=b.Pp,Fj=b.vo;if(a.Qc&&!Li){var Qj=cw(a,hj,c,d,e,g),Ni=Of(c),Gj=Mi.w,Hj=new Sw(a,Qj,Mi),lk=G(new H,Gj,Hj);Ni.Xa.S(lk);
-return cw(a,Fj,Ni,d,e,g)}var md=X6(a,Li,Mi.w,hj,c,d,e),Ue=Of(c),Jd=Mi.w,uf=new Sw(a,md,Mi),Dl=G(new H,Jd,uf);Ue.Xa.S(Dl);return cw(a,Fj,Ue,d,e,g)}if(C){var gl=F.Rk;if(a.Qc){var am=new Ss(gl);t();var xk=Nf(a,am,new M(F),c,d,e).Jl,Ae=new U(()=>a.Bs);return xk.b()?Zr(Ae):xk.o()}return Z6(a,gl,!1,O().c,!1,Of(c),d,h,e,g)}if(b instanceof qm){var Ff=b.vu,vf=L6(a,b.wu,c,d,e),Xf=L6(a,Ff,c,d,e),Ij=Ff.vn.m(),Rj=new eg(Ij,new z(Hc=>Hc.i())),hl=mu(),El=ap().wa,on=new ou(hl,El),Oi=Rz(Mu(),Rj,on),ee=JA(vf,Oi);return ju(ee,
-Xf,h,!1)}if(b instanceof rm){var Re=b.Fp,Ji=b.Ep,jk=L6(a,Re,c,d,e);if(a.Qc){var Vg=a.WO;G6(a,jk,Vw(Vg.p,Vg,h),a.Na,c,d,h)}var kk=$6(a,xl(new E_(a)).Nb(Re,new z(()=>{t();return R()})),Ji,c,d,e,g);if(null!==kk)var eo=G(new H,kk.i(),kk.j());else throw new x(kk);var dr=eo.j(),Ud=eo.i().we(a.tb,new Um((Hc,Sd)=>{var Hd=G(new H,Hc,Sd);Sd=Hd.z;Hc=Hd.x;if(null!==Sd){Hd=Sd.i();Sd=Sd.j();var Be=V(Hd.p);Sd=ju(Hd,Sd,Be,!1);Be=V(Hd.p);Hd=pA(Hd,Be,!1);Be=V(Hc.p);Hc=ju(Hc,Hd,Be,!1);Hd=V(Sd.p);return zu(Sd,Hc,Hd,
-!1)}throw new x(Hd);}));return G6(a,jk,Ud,dr,c,d,h)}if(b instanceof tm)try{return cw(a,cea(a,b,c,d),c,d,e,g)}catch(Hc){if(Hc instanceof lT)return yx(a,Hc.EP,d);throw Hc;}if(b instanceof km){var ne=b.ym;Xv(a,sf(new mf(new nf(J(new L,["Type application syntax is not yet supported"]))),v()),b.C(),d);return cw(a,ne,c,d,e,g)}if(b instanceof wm)return Z6(a,wq(b.uu,b.tu),!1,O().c,!0,c,d,h,e,g);if(b instanceof vm){var Fe=b.Pt,Bk=b.Ir,sn=new z(Hc=>{var Sd=ht(Fe,new z(Hd=>{if(null!==Hd){var Be=Hd.Go;if(Be instanceof
-me){Be=Be.ia;var mj=Mw(new Nw,a,Hd.C(),"quantified type variable",(Uw(a),t().f),(Uw(a),!1)),bm=t().f;t();var Km=new M(Be),tn=O().c,ut=O().c;Hd=new Pw(a,new Ow(a,Hc.fa,tn,ut,bm,Km,!1,mj),Mw(new Nw,a,Hd.C(),"rigid type variable",(Uw(a),t().f),(Uw(a),!1)));return G(new H,Be,Hd)}}Dn("Program reached and unexpected state.")}));Sd=e.oe(Sd);return(new z(Hd=>L6(a,Bk,Hc,d,Hd))).n(Sd)});dw(c.V);return ox(c,sn,d,h)}if(b instanceof ym)return Xv(a,sf(new mf(new nf(J(new L,["Unexpected equation in this position"]))),
-v()),b.C(),d);if(b instanceof zm)return Xv(a,sf(new mf(new nf(J(new L,["Refinement terms are not yet supported"]))),v()),b.C(),d);throw new x(b);}),new z(h=>c.fa+". : "+h))}
-function $6(a,b,c,d,e,g,h){var k=id();try{if(Nm()===c){var l=O().c;return G(new H,l,a.tb)}if(c instanceof Mm){var m=c.qq,n=Mw(new Nw,a,c.C(),"wildcard pattern",(Uw(a),t().f),(Uw(a),!1)),r=t().f,u=t().f,w=O().c,y=O().c,B=new Ow(a,d.fa,w,y,r,u,!1,n),D=Of(d);if(b instanceof M){var C=b.k,F=C.w,I=new Sw(a,B,C),K=G(new H,F,I);D.Xa.S(K);var N=cw(a,m,D,e,g,h),P=G(new H,B,a.Na),T=O().c;return G(new H,new A(P,T),N)}var aa=G(new H,B,a.Na),Y=O().c,S=new A(aa,Y),Z=cw(a,m,d,e,g,h);return G(new H,S,Z)}if(c instanceof
-Im){var ka=c.yr,X=c.xr,sa=c.zr;if(ka instanceof fm)var Ia=new gu(a,ka,a.Qc?Xp(ka):Up(ka),Mw(new Nw,a,ka.C(),"literal pattern",(Uw(a),t().f),(Uw(a),!1))),Za=G(new H,Ia,Ia);else{if(!(ka instanceof Wl))throw new x(ka);var Ga=ka.w,xa=Mw(new Nw,a,ka.C(),"type pattern",(Uw(a),t().f),(Uw(a),!1)),Ra=d.vb.Y(Ga);if(R()===Ra){var Ja=()=>{var $b=new gu(a,a.qk,Wp(),xa),Fc=G(new H,$b,$b),Yc=O().c;Fc=new A(Fc,Yc);throw fq(new gq,k,G(new H,Fc,$b));},La=PB(d,Ga);a:{if(La instanceof M){var pb=La.k;if(pb instanceof
-MP){var Fb=pb.zd();if(Gw(new E(Fb),pp()))var Gb=pb.zd(),Hb=Gw(new E(Gb),mp());else Hb=!1;if(Hb)var tb=pb.zd(),kb=Gw(new E(tb),tp());else kb=!1;kb&&Xv(a,sf(new mf(new nf(J(new L,["can only match on classes and traits"]))),v()),ka.C(),e);var gb=Mw(new Nw,a,ka.C(),"class pattern",(Uw(a),t().f),(Uw(a),!1)),Vb=!1,bb=null;if(pb instanceof Iw){var nb=pb.Kb;nb instanceof io||Dn("Program reached and unexpected state.");var Tb=ty(a,nb,gb,d),ub=Pu(a),Ub=pb.pg(),$a=$b=>{if(null!==$b){var Fc=$b.ec,Yc=$b.gb;$b=
-$b.xd;var nc=Yc.Zh;t();var Ob=new M(Yc);Yc=Yc.dg;var cc=O().c,Gc=O().c;nc=new Ow(a,d.fa,cc,Gc,Ob,Yc,!1,nc);Ob=new Wl(Ga+"#"+Fc.X);Fc=Fc.C();return G(new H,aq(Ob,Fc),qD(pD(a),$b.b()?Tt().En:$b.o(),nc,nc,V(a)))}throw new x($b);};if(Ub===v())var cb=v();else{for(var Na=Ub.e(),Ca=new A($a(Na),v()),Ba=Ca,Oa=Ub.g();Oa!==v();){var wa=Oa.e(),ea=new A($a(wa),v());Ba=Ba.r=ea;Oa=Oa.g()}cb=Ca}var la=uA(ub,cb,V(a));if(a.D){var Ka=Hs(Q(),"| ",a.q)+("Match arm "+Ga+": "+Tb+" \x26 ")+la;Af(Bf(),Ka+"\n")}Za=G(new H,
-Tb,la);break a}if(pb instanceof Lw){Vb=!0;bb=pb;var Ua=bb.rh;if(Ua instanceof Aw){var ya=ty(a,Ua.Gf,gb,d),ib=Pu(a),Lb=Ua.Zg,ec=$b=>{if(null!==$b){var Fc=$b.ec,Yc=$b.gb;$b=$b.xd;var nc=Yc.Zh;t();var Ob=new M(Yc),cc=Yc.dg,Gc=O().c,Bc=O().c;nc=new Ow(a,d.fa,Gc,Bc,Ob,cc,!1,nc);Ob=new Wl(Ga+"#"+Fc.X);Fc=Fc.C();return G(new H,aq(Ob,Fc),qD(pD(a),$b.b()?tA(Ua,Yc,d):$b.o(),nc,nc,V(a)))}throw new x($b);};if(Lb===v())var Mb=v();else{for(var Jb=Lb.e(),Kb=new A(ec(Jb),v()),eb=Kb,Wb=Lb.g();Wb!==v();){var mc=Wb.e(),
-ua=new A(ec(mc),v());eb=eb.r=ua;Wb=Wb.g()}Mb=Kb}var Pa=uA(ib,Mb,V(a));if(a.D){var xb=Hs(Q(),"| ",a.q)+("Match arm "+Ga+": "+ya+" \x26 ")+Pa;Af(Bf(),xb+"\n")}Za=G(new H,ya,Pa);break a}}if(Vb){Za=Ja();break a}throw new x(pb);}}Xv(a,pf(qf(),"type identifier not found: "+Ga),ka.C(),e);Za=Ja()}}else{if(!(Ra instanceof M))throw new x(Ra);var Yb=Ra.k,zb=Yb.dj;if(np()===zb||mp()===zb||Qo()===zb){var Sb=Xv(a,sf(new mf(new nf(J(new L,["can only match on classes and traits"]))),v()),ka.C(),e);Za=G(new H,Sb,
-Sb)}else if(pp()===zb){var Ma=LC(a,Yb,Mw(new Nw,a,ka.C(),"class pattern",(Uw(a),t().f),(Uw(a),!1)),d);Za=G(new H,Ma,Ma)}else if(tp()===zb){var Ea=mD(a,Yb,Mw(new Nw,a,ka.C(),"trait pattern",(Uw(a),t().f),(Uw(a),!1)));Za=G(new H,Ea,Ea)}else throw new x(zb);}}if(null===Za)throw new x(Za);var ab=Za.i(),Db=Za.j(),mb=Of(d);if(b instanceof M){var vb=b.k;if(a.Qc){var Ya=vb.w,Wa=V(ab.p),rb=new Sw(a,ju(ab,Db,Wa,!1),vb),pa=G(new H,Ya,rb);mb.Xa.S(pa);var Fa=cw(a,X,mb,e,g,h),Ib=new Ul(G(new H,ab,Db),Fa,$6(a,b,
-sa,d,e,g,h))}else{var qb=Mw(new Nw,a,vb.C(),"refined scrutinee",(Uw(a),t().f),(Uw(a),!1)),Nb=t().f,fc=t().f,Ac=O().c,tc=O().c,vc=new Ow(a,d.fa,Ac,tc,Nb,fc,!1,qb),sc=vb.w,uc=new Sw(a,vc,vb),lc=G(new H,sc,uc);mb.Xa.S(lc);var Wc=cw(a,X,mb,e,g,h);Ib=new Ul(G(new H,Db,vc),Wc,$6(a,b,sa,d,e,g,h))}}else if(t().f===b){var Cc=cw(a,X,mb,e,g,h);Ib=new Ul(G(new H,ab,a.Na),Cc,$6(a,b,sa,d,e,g,h))}else throw new x(b);a:{if(null!==Ib){var Dc=Ib.ec,Ec=Ib.gb,Ic=Ib.xd;if(null!==Ic){var Xc=Ic.i(),Sc=Ic.j();var oc=Dc;
-var qc=Ec;var Tc=Xc;var Nc=Sc;break a}}throw new x(Ib);}var Pc=qc,Oc=Nc,$c=new A(oc,Tc),Lc=V(Pc.p),Zb=zu(Pc,Oc,Lc,!1);return G(new H,$c,Zb)}throw new x(c);}catch($b){if($b instanceof gq){var ed=$b;if(ed.Hg===k)return ed.wj();throw ed;}throw $b;}}
-function Z6(a,b,c,d,e,g,h,k,l,m){var n=!1,r=null;if(b instanceof A){n=!0;r=b;var u=r.A,w=r.r;if(u instanceof Wl&&c)return t(),e=new M(u),u=new ws(Ct().Kg,u),e=G(new H,e,u),u=O().c,e=new im(new A(e,u)),Z6(a,new A(e,w),c,d,!1,g,h,k,l,m)}if(n&&(w=r.A,u=r.r,w instanceof pm))return Z6(a,Fl(u,w.Rk),c,d,!1,g,h,k,l,m);if(n&&(u=r.A,w=r.r,u instanceof im)){u=u.Ra;var y=O().c;if(null===y?null===u:y.h(u))return Z6(a,w,c,d,!1,g,h,k,l,m)}if(n&&(u=r.A,w=r.r,u instanceof im&&(u=u.Ra,u instanceof A))){var B=u.A;y=
-u.r;if(null!==B){u=B.i();var D=B.j();if(null!==D&&(B=D.Da,null!==D.vc)){a:{if(B instanceof hm&&(e=B.Sh,!1===B.Sk&&g.Ac)){e=W6(a,e,g,h,l);break a}e=g.Ac&&u.b();e=new Uv(g.V,g.Vc,g.Xa,g.kd,g.fa,e,g.vb,g.fb,g.ud,g.hb);e=y.b()?cw(a,new hm(c,B),e,h,l,m):cw(a,B,e,h,l,m)}r=!1;n=null;a:{if(u instanceof M&&(r=!0,n=u,b=n.k,g.Ac)){n=Mw(new Nw,a,B.C(),"parameter type",(Uw(a),t().f),(Uw(a),!1));r=new Ow(a,g.fa,O().c,O().c,t().f,(KP(a),t().f),(KP(a),!1),n);B=dw(a).Cb;ew(a,r,e,h,n,g,B);e=b.w;b=new Sw(a,r,b);e=G(new H,
-e,b);g.Xa.S(e);e=r;break a}r&&(r=n.k,b=r.w,r=new Sw(a,e,r),b=G(new H,b,r),g.Xa.S(b))}y=new im(y);w=new A(y,w);e=G(new H,u,e);return Z6(a,w,c,new A(e,d),!1,g,h,k,l,m)}}}if(n&&(w=r.A,u=r.r,w instanceof Ln&&(y=O().c,null===y?null===u:y.h(u))))return d.b()||OX(a,pf(qf(),"Previous field definitions are discarded by this returned expression."),w.C(),h),cw(a,w,g,h,l,m);if(n){w=r.r;y=r.A.Nu();if(null===y)throw new x(y);u=y.j();for(y=y.i();!y.b();)h.n(y.e()),y=y.g();for(b=y=null;u!==v();){r=u.e();for(r=xP(Ox(a,
-r,e,g,h,l,m)).m();r.s();)n=new A(r.t(),v()),null===b?y=n:b.r=n,b=n;u=u.g()}e=(null===y?v():y).m();u=ap().wa;e=new ho(e,u);Vv(g,new eg(e,new z(C=>{var F=C.i();C=new Sw(a,C.j(),new Wl(C.i()));return G(new H,F,C)})));return Z6(a,w,c,d,!1,g,h,k,l,m)}g=O().c;if(null===g?null===b:g.h(b)){if(c)return c=Eq(d).m(),c=new ko(c),c=new eg(c,new z(C=>{if(null!==C){var F=C.i();if(null!==F){var I=F.i();F=F.j();if(I instanceof M)return C=I.k,I=V(a),F=new ww(F.p,R(),F,I),G(new H,C,F)}}if(null!==C&&(F=C.i(),I=C.Lc(),
-null!==F)){var K=F.i();F=F.j();if(t().f===K)return OX(a,pf(qf(),"Missing name for record field"),F.qa().Ia,h),C=new Wl("_"+(1+I|0)),I=V(a),G(new H,C,new ww(F.p,R(),F,I))}throw new x(C);})),je(),c=le(v(),c),uA(Pu(a),c,k);Du();c=Eq(d).m();return new Ru(a,Mx(0,c,new z(C=>{var F=V(a);return new ww(C.p,R(),C,F)})),k)}throw new x(b);}
-function tea(a,b){for(var c=iZ(O().dR,1,1);;){if(c.b())b=R();else{var d=fZ(c).e();if(b.L(new Wl(a+"_"+(d|0)))){c=fZ(c).Cf();continue}b=new M(d)}break}b.b()&&Dn("Program reached and unexpected state.");return a+"_"+b.o()}
-function zea(a,b,c,d,e,g,h,k,l){a:{for(var m=d.Ra;!m.b();){if(!m.e().i().b()){m=!0;break a}m=m.g()}m=!1}a:{for(var n=d.Ra;!n.b();){if(n.e().i().b()){n=!0;break a}n=n.g()}n=!1}a:{for(var r=0,u=R5(0,d.Ra);!u.b();){if(!u.e().i().b())break a;r=1+r|0;u=u.g()}r=-1}u=0;for(var w=d.Ra,y=-1;!w.b();)w.e().i().b()&&(y=u),w=w.g(),u=1+u|0;if(m&&n&&r<y)return Xv(a,sf(new mf(new nf(J(new L,["Unnamed arguments should appear first when using named arguments"]))),v()),d.C(),k);if(0===pv(d.Ra,e)){r=mg(d.Ra);g=B=>{if(null!==
-B){var D=B.i();B=B.Lc();var C=D.i();if(C instanceof M)return G(new H,G(new H,C.k.w,D.j()),!0);if(t().f===C)return G(new H,G(new H,FA(e,B).w,D.j()),!1);throw new x(C);}throw new x(B);};if(r===v())g=v();else{m=r.e();n=m=new A(g(m),v());for(r=r.g();r!==v();)u=r.e(),u=new A(g(u),v()),n=n.r=u,r=r.g();g=m}m=ru().U();for(n=g.m();n.s();)r=n.t(),m.Ai(r.i().i(),new U(()=>{je();return new Wo})).S(r);n=Xy().br;for(m=m.m();m.s();){r=m.t();if(null===r)throw new x(r);n=a7(n,r.i(),r.j().Eb())}m=n;0>Uca(m,e)&&m.$b.ya(new z(B=>
-{var D=B.j();if(D instanceof A&&D.r instanceof A)return D=new mf(new nf(J(new L,["Argument for parameter '","' is duplicated"]))),B=[pf(qf(),B.i())],Xv(a,sf(D,J(new L,B)),d.C(),k)}));fp();m=v();c=uea(a,g,bp(0,m),d,e,k,c);a.D&&(g=Hs(Q(),"| ",a.q)+"Desugared is here \x3d\x3e "+c,Af(Bf(),g+"\n"));b.dd=(t(),new M(c));return cw(a,c,h,k,l,!1)}b=new mf(new nf(J(new L,["Number of arguments doesn't match function signature `","`"])));h=[nO(qf(),UC(g,h))];return Xv(a,sf(b,J(new L,h)),d.C(),k)}
-function Rf(a,b,c,d){var e=O().c;e=new ov(e);var g=Lz().U();a:{var h=new LB(a,Jf());if(b instanceof aA)a=P6(a,b,h,c,g,e,d);else{if(b instanceof cA){dA(a);t();var k=new M(b);if(!k.b()){b=k.k;var l=b.ok;if(l===v())k=v();else{k=l.e();var m=k=new A(G_(a,k,h,d,c,g,e),v());for(l=l.g();l!==v();){var n=l.e();n=new A(G_(a,n,h,d,c,g,e),v());m=m.r=n;l=l.g()}}b=b.Jl;b.b()?a=R():(b=b.o(),a=new M(P6(a,b,h,c,g,e,d)));a=new sP(k,a);break a}}throw new x(b);}}return e.Lb.b()?a:new hP(a,e.Lb,O().c)}
-function Y6(a){var b=a.yE;a.yE=1+a.yE|0;return b}
-function G_(a,b,c,d,e,g,h){if(b instanceof Dw){var k=b.Hl,l=b.Gl,m=MB(c,b.ik),n=k.nb,r=k.eb,u=k.bg,w=t().f,y=t().f;t();var B=P6(a,l,m,e,g,h,d);return new io(n,r,u,w,y,new M(B),O().c,t().f,t().f,new Ss(O().c),k.Vk,k.rm)}if(b instanceof Zv){var D=b.Yk,C=b.Zk,F=b.Xk,I=b.Il,K=b.zj,N=MB(c,b.$k),P=D.nb,T=D.eb,aa=D.bg;t();var Y=cd=>{var rd=t().f;cd=new ws(Ct().Kg,new em(cd.i(),P6(a,cd.j().oa,N,e,g,h,d)));return G(new H,rd,cd)};if(I===v())var S=v();else{for(var Z=I.e(),ka=new A(Y(Z),v()),X=ka,sa=I.g();sa!==
-v();){var Ia=sa.e(),Za=new A(Y(Ia),v());X=X.r=Za;sa=sa.g()}S=ka}var Ga=new im(S),xa=new M(Ga),Ra=t().f,Ja=t().f,La=O().c,pb=ru().U(),Fb=tu(a.Na,F,d,!0,pb)?R():new M(P6(a,F,N,e,g,h,d)),Gb=ru().U(),Hb=!tu(a.Na,C,d,!0,Gb);return new io(P,T,aa,xa,Ra,Ja,La,Fb,Hb?new M(P6(a,C,N,e,g,h,d)):R(),Q6(a,K,N,d,e,g,h),D.Vk,D.rm)}if(b instanceof Aw){var tb=b.Gf,kb=b.yj,gb=b.Wk,Vb=b.ui,bb=b.wm,nb=b.jk,Tb=b.zo,ub=MB(c,b.Zg),Ub=tb.nb,$a=tb.eb,cb=tb.bg;if(kb.b())var Na=R();else{var Ca=kb.o(),Ba=cd=>{var rd=t().f;cd=
-new ws(Ct().Kg,new em(cd.i(),P6(a,cd.j().oa,ub,e,g,h,d)));return G(new H,rd,cd)};if(Ca===v())var Oa=v();else{for(var wa=Ca.e(),ea=new A(Ba(wa),v()),la=ea,Ka=Ca.g();Ka!==v();){var Ua=Ka.e(),ya=new A(Ba(Ua),v());la=la.r=ya;Ka=Ka.g()}Oa=ea}Na=new M(new im(Oa))}var ib=tb.sm,Lb=ru().U(),ec=tu(a.Na,nb,d,!0,Lb)?R():new M(P6(a,nb,ub,e,g,h,d));je();var Mb=le(v(),Tb),Jb=mu(),Kb=ap().wa,eb=Fv(Mb,new ou(Jb,Kb));if(eb===v())var Wb=v();else{for(var mc=eb.e(),ua=new A(mc.pr(),v()),Pa=ua,xb=eb.g();xb!==v();){var Yb=
-xb.e(),zb=new A(Yb.pr(),v());Pa=Pa.r=zb;xb=xb.g()}Wb=ua}var Sb=t().f,Ma=ru().U(),Ea=tu(a.Na,bb,d,!0,Ma)?R():new M(P6(a,bb,ub,e,g,h,d)),ab=Q6(a,Vb,ub,d,e,g,h);if(gb instanceof M){var Db=gb.k,mb=cd=>{var rd=t().f;cd=new ws(Ct().Kg,new em(cd.i(),P6(a,cd.j(),ub,e,g,h,d)));return G(new H,rd,cd)};if(Db===v())var vb=v();else{for(var Ya=Db.e(),Wa=new A(mb(Ya),v()),rb=Wa,pa=Db.g();pa!==v();){var Fa=pa.e(),Ib=new A(mb(Fa),v());rb=rb.r=Ib;pa=pa.g()}vb=Wa}var qb=new zo(new im(vb),new pm(O().c)),Nb=zf(ab),fc=
-new Ss(new A(qb,Nb))}else{if(t().f!==gb)throw new x(gb);fc=ab}return new io(Ub,$a,cb,Na,ib,ec,Wb,Sb,Ea,fc,tb.Vk,tb.rm)}if(b instanceof yw){var Ac=b.mk,tc=b.kk,vc=b.un,sc=b.lk,uc=b.bq,lc=MB(c,b.nk),Wc=Ac.nb,Cc=Ac.eb,Dc=Ac.bg,Ec=t().f,Ic=Ac.sm,Xc=ru().U(),Sc=tu(a.Na,sc,d,!0,Xc)?R():new M(P6(a,sc,lc,e,g,h,d));je();var oc=le(v(),uc),qc=mu(),Tc=ap().wa,Nc=Fv(oc,new ou(qc,Tc));if(Nc===v())var Pc=v();else{for(var Oc=Nc.e(),$c=new A(Oc.pr(),v()),Lc=$c,Zb=Nc.g();Zb!==v();){var ed=Zb.e(),$b=new A(ed.pr(),v());
-Lc=Lc.r=$b;Zb=Zb.g()}Pc=$c}var Fc=t().f,Yc=ru().U(),nc=!tu(a.Na,vc,d,!0,Yc);return new io(Wc,Cc,Dc,Ec,Ic,Sc,Pc,Fc,nc?new M(P6(a,vc,lc,e,g,h,d)):R(),Q6(a,tc,lc,d,e,g,h),Ac.Vk,Ac.rm)}if(b instanceof Ew){var Ob=b.jd,cc=Ob.Sd,Gc=Ob.Qb,Bc=Ob.bj,qd=O().c;t();var Gd=P6(a,b.no(),c,e,g,h,d);return new Kn(cc,Gc,Bc,qd,new me(Gd),Ob.tz,Ob.Ow,Ob.VD,Ob.UD,Ob.yo)}if(b instanceof xw)$n();else if(b instanceof Fw)$n();else throw new x(b);}
-Gf.prototype.$classData=q({gY:0},!1,"mlscript.Typer",{gY:1,paa:1,daa:1,Y$:1,R$:1,X$:1,iaa:1,kaa:1,d:1,faa:1});function px(a,b,c){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.vO=this.Wc=0;this.wO=null;this.hI=!1;this.Ld=b;this.ve=c;mY(this,a);if(!(b<a.tf))throw dk("requirement failed: "+this.Ld);this.wO=c.qa()}px.prototype=new nY;px.prototype.constructor=px;f=px.prototype;f.qa=function(){return this.wO};
-f.Ca=function(){this.hI||this.hI||(this.vO=this.rb(this.Ld,Lz().U()),this.hI=!0);return this.vO};f.rb=function(a,b){var c=this.Ld;return this.ve.rb(a<c?a:c,b)};f.u=function(){return"\u2039\u2200 "+this.Ld+". "+this.ve+"\u203a"};f.H=function(){return"PolymorphicType"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Ld;case 1:return this.ve;default:return JK(W(),a)}};f.E=function(a){return a instanceof px};
-f.$classData=q({PY:0},!1,"mlscript.TyperDatatypes$PolymorphicType",{PY:1,Mg:1,wg:1,d:1,xg:1,Ng:1,laa:1,F:1,v:1,l:1});function qA(a,b,c){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0;this.yi=b;this.oE=c;mY(this,a)}qA.prototype=new J_;qA.prototype.constructor=qA;f=qA.prototype;f.gc=function(){return this.yi};f.qa=function(){return this.oE};f.u=function(){return""+this.yi};f.H=function(){return"ProvType"};f.G=function(){return 1};
-f.I=function(a){return 0===a?this.yi:JK(W(),a)};f.E=function(a){return a instanceof qA};f.$classData=q({RY:0},!1,"mlscript.TyperDatatypes$ProvType",{RY:1,iI:1,Mg:1,wg:1,d:1,xg:1,Ng:1,F:1,v:1,l:1});function uv(a,b,c,d){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0;this.qI=null;this.ob=b;this.Vb=c;this.Ml=d;mY(this,a);this.qI=t().f}uv.prototype=new nY;uv.prototype.constructor=uv;f=uv.prototype;f.qa=function(){return this.Ml};
-f.Ca=function(){var a=this.Vb.m();a=new eg(a,new z(c=>c.Ca()));var b=dq();a=hq(a,b);return(a.b()?this.p.md:a.o())|0};f.rb=function(a,b){var c=this.Vb.m();c=new eg(c,new z(e=>e.rb(a,b)));var d=dq();c=hq(c,d);return(c.b()?this.p.md:c.o())|0};function Ju(a,b,c,d,e){var g=a.p,h=a.ob,k=a.Vb;if(k===v())b=v();else{var l=k.e(),m=l=new A(l.Dc(b,c,d,e),v());for(k=k.g();k!==v();){var n=k.e();n=new A(n.Dc(b,c,d,e),v());m=m.r=n;k=k.g()}b=l}return new uv(g,h,b,a.Ml)}
-f.u=function(){var a=this.p.Em.L(this.ob.X)?hu(Q(),this.ob.X):this.ob.X;return this.Vb.b()?a:a+"["+Qe(this.Vb,"",",","")+"]"};f.H=function(){return"TypeRef"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.ob;case 1:return this.Vb;default:return JK(W(),a)}};f.E=function(a){return a instanceof uv};f.Dc=function(a,b,c,d){return Ju(this,a,b,c,d)};f.$classData=q({dZ:0},!1,"mlscript.TyperDatatypes$TypeRef",{dZ:1,Mg:1,wg:1,d:1,xg:1,Ng:1,maa:1,F:1,v:1,l:1});
-function Aea(a){if(!a.sI){var b=a.hq,c=a.Ko.Ba.m();c=new eg(c,new z(g=>g.i()));var d=mu(),e=ap().wa;d=new ou(d,e);c=Rz(Mu(),c,d);b=JA(b,c);c=a.Ko;d=V(b.p);a.tI=ju(b,c,d,!1);a.sI=!0}return a.tI}function ry(a,b,c,d){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0;this.tI=null;this.sI=!1;this.hq=b;this.Ko=c;this.jZ=d;mY(this,a)}ry.prototype=new J_;ry.prototype.constructor=ry;f=ry.prototype;f.qa=function(){return this.jZ};f.gc=function(){return this.sI?this.tI:Aea(this)};
-f.u=function(){return this.hq+" w/ "+this.Ko};f.H=function(){return"WithType"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.hq;case 1:return this.Ko;default:return JK(W(),a)}};f.E=function(a){return a instanceof ry};f.$classData=q({iZ:0},!1,"mlscript.TyperDatatypes$WithType",{iZ:1,iI:1,Mg:1,wg:1,d:1,xg:1,Ng:1,F:1,v:1,l:1});
-function eP(a,b){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.px=a;this.qx=b;mq(this)}eP.prototype=new C_;eP.prototype.constructor=eP;f=eP.prototype;f.H=function(){return"WithExtension"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.px;case 1:return this.qx;default:return JK(W(),a)}};f.E=function(a){return a instanceof eP};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof eP){var b=this.px,c=a.px;if(null===b?null===c:b.h(c))return b=this.qx,a=a.qx,null===b?null===a:b.h(a)}return!1};f.$classData=q({HZ:0},!1,"mlscript.WithExtension",{HZ:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,F:1,v:1,l:1});q({JZ:0},!1,"mlscript.codegen.ClassSymbol",{JZ:1,d:1,wA:1,rq:1,Gs:1,Wi:1,xe:1,F:1,v:1,l:1});function b7(){}b7.prototype=new g3;b7.prototype.constructor=b7;function c7(){}c7.prototype=b7.prototype;b7.prototype.Ob=function(){return gU()};
-b7.prototype.u=function(){return m5(this)};b7.prototype.Hc=function(){return"View"};function dp(a){this.VK=null;if(null===a)throw null;this.VK=a}dp.prototype=new g3;dp.prototype.constructor=dp;dp.prototype.Q=function(){return this.VK.Q()};dp.prototype.m=function(){return this.VK.Qd()};dp.prototype.$classData=q({f5:0},!1,"scala.collection.MapOps$$anon$1",{f5:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,jg:1,l:1});
-function d7(a,b){if(a===b)return!0;if(b&&b.$classData&&b.$classData.pb.Vj)if(a.ka()===b.ka())try{return a.OL(b)}catch(c){throw c;}else return!1;else return!1}function e7(){this.Rq=0;this.pB="Any";O();this.Rq=bd(this)}e7.prototype=new t6;e7.prototype.constructor=e7;e7.prototype.jh=function(){return ma(Md)};e7.prototype.gi=function(a){return new jd(a)};e7.prototype.$classData=q({q3:0},!1,"scala.reflect.ManifestFactory$AnyManifest$",{q3:1,wK:1,vK:1,d:1,Yl:1,zk:1,Xl:1,Zl:1,l:1,v:1});var f7;
-function KH(){f7||(f7=new e7);return f7}function g7(){this.wf=0;this.Ci="Boolean";this.wf=bd(this)}g7.prototype=new f6;g7.prototype.constructor=g7;g7.prototype.$classData=q({r3:0},!1,"scala.reflect.ManifestFactory$BooleanManifest$",{r3:1,Uaa:1,ct:1,d:1,Yl:1,zk:1,Xl:1,Zl:1,l:1,v:1});var h7;function dL(){h7||(h7=new g7);return h7}function i7(){this.wf=0;this.Ci="Byte";this.wf=bd(this)}i7.prototype=new h6;i7.prototype.constructor=i7;
-i7.prototype.$classData=q({s3:0},!1,"scala.reflect.ManifestFactory$ByteManifest$",{s3:1,Vaa:1,ct:1,d:1,Yl:1,zk:1,Xl:1,Zl:1,l:1,v:1});var j7;function bL(){j7||(j7=new i7);return j7}function k7(){this.wf=0;this.Ci="Char";this.wf=bd(this)}k7.prototype=new j6;k7.prototype.constructor=k7;k7.prototype.$classData=q({t3:0},!1,"scala.reflect.ManifestFactory$CharManifest$",{t3:1,Waa:1,ct:1,d:1,Yl:1,zk:1,Xl:1,Zl:1,l:1,v:1});var l7;function Tq(){l7||(l7=new k7);return l7}
-function m7(){this.wf=0;this.Ci="Double";this.wf=bd(this)}m7.prototype=new l6;m7.prototype.constructor=m7;m7.prototype.$classData=q({u3:0},!1,"scala.reflect.ManifestFactory$DoubleManifest$",{u3:1,Xaa:1,ct:1,d:1,Yl:1,zk:1,Xl:1,Zl:1,l:1,v:1});var n7;function ZK(){n7||(n7=new m7);return n7}function o7(){this.wf=0;this.Ci="Float";this.wf=bd(this)}o7.prototype=new n6;o7.prototype.constructor=o7;
-o7.prototype.$classData=q({v3:0},!1,"scala.reflect.ManifestFactory$FloatManifest$",{v3:1,Yaa:1,ct:1,d:1,Yl:1,zk:1,Xl:1,Zl:1,l:1,v:1});var p7;function aL(){p7||(p7=new o7);return p7}function q7(){this.wf=0;this.Ci="Int";this.wf=bd(this)}q7.prototype=new p6;q7.prototype.constructor=q7;q7.prototype.$classData=q({w3:0},!1,"scala.reflect.ManifestFactory$IntManifest$",{w3:1,Zaa:1,ct:1,d:1,Yl:1,zk:1,Xl:1,Zl:1,l:1,v:1});var r7;function Rl(){r7||(r7=new q7);return r7}
-function s7(){this.wf=0;this.Ci="Long";this.wf=bd(this)}s7.prototype=new r6;s7.prototype.constructor=s7;s7.prototype.$classData=q({x3:0},!1,"scala.reflect.ManifestFactory$LongManifest$",{x3:1,$aa:1,ct:1,d:1,Yl:1,zk:1,Xl:1,Zl:1,l:1,v:1});var t7;function $K(){t7||(t7=new s7);return t7}function LR(){this.Rq=0;this.pB="Nothing";O();this.Rq=bd(this)}LR.prototype=new t6;LR.prototype.constructor=LR;LR.prototype.jh=function(){return ma(TG)};LR.prototype.gi=function(a){return new jd(a)};
-LR.prototype.$classData=q({y3:0},!1,"scala.reflect.ManifestFactory$NothingManifest$",{y3:1,wK:1,vK:1,d:1,Yl:1,zk:1,Xl:1,Zl:1,l:1,v:1});var KR;function NR(){this.Rq=0;this.pB="Null";O();this.Rq=bd(this)}NR.prototype=new t6;NR.prototype.constructor=NR;NR.prototype.jh=function(){return ma(SG)};NR.prototype.gi=function(a){return new jd(a)};NR.prototype.$classData=q({z3:0},!1,"scala.reflect.ManifestFactory$NullManifest$",{z3:1,wK:1,vK:1,d:1,Yl:1,zk:1,Xl:1,Zl:1,l:1,v:1});var MR;
-function u7(){this.Rq=0;this.pB="Object";O();this.Rq=bd(this)}u7.prototype=new t6;u7.prototype.constructor=u7;u7.prototype.jh=function(){return ma(Md)};u7.prototype.gi=function(a){return new jd(a)};u7.prototype.$classData=q({A3:0},!1,"scala.reflect.ManifestFactory$ObjectManifest$",{A3:1,wK:1,vK:1,d:1,Yl:1,zk:1,Xl:1,Zl:1,l:1,v:1});var v7;function AG(){v7||(v7=new u7);return v7}function w7(){this.wf=0;this.Ci="Short";this.wf=bd(this)}w7.prototype=new v6;w7.prototype.constructor=w7;
-w7.prototype.$classData=q({B3:0},!1,"scala.reflect.ManifestFactory$ShortManifest$",{B3:1,aba:1,ct:1,d:1,Yl:1,zk:1,Xl:1,Zl:1,l:1,v:1});var x7;function cL(){x7||(x7=new w7);return x7}function y7(){this.wf=0;this.Ci="Unit";this.wf=bd(this)}y7.prototype=new x6;y7.prototype.constructor=y7;y7.prototype.$classData=q({C3:0},!1,"scala.reflect.ManifestFactory$UnitManifest$",{C3:1,bba:1,ct:1,d:1,Yl:1,zk:1,Xl:1,Zl:1,l:1,v:1});var z7;function JR(){z7||(z7=new y7);return z7}function A7(a){this.hm=a}
-A7.prototype=new p;A7.prototype.constructor=A7;f=A7.prototype;f.gl=function(a){dq();var b=this.hm;a|=0;return b===a?0:b<a?-1:1};f.sk=function(a){dq();var b=this.hm;a|=0;return b===a?0:b<a?-1:1};f.u=function(){return""+this.hm};f.EJ=function(){return this.Tu()&&this.Ri()===this.MA()};f.GJ=function(){return this.Tu()&&this.Ri()===this.gC()};f.FJ=function(){return this.Tu()&&0<=this.Ri()&&65535>=this.Ri()};f.ap=function(){return this.hm};f.Pu=function(){return Math.fround(this.hm)};
-f.ll=function(){var a=this.hm;return new fb(a,a>>31)};f.Ri=function(){return this.hm};f.MA=function(){return this.hm<<24>>24};f.gC=function(){return this.hm<<16>>16};f.Tu=function(){return!0};f.oF=function(){return!0};f.y=function(){return this.hm};f.h=function(a){CK||(CK=new BK);return a instanceof A7?this.hm===a.hm:!1};f.$classData=q({A$:0},!1,"scala.runtime.RichInt",{A$:1,d:1,yba:1,$Q:1,Haa:1,Gaa:1,wba:1,Wi:1,xe:1,xba:1});
-function gP(a,b){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.dw=a;this.ew=b;mq(this)}gP.prototype=new C_;gP.prototype.constructor=gP;f=gP.prototype;f.H=function(){return"AppliedType"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.dw;case 1:return this.ew;default:return JK(W(),a)}};f.E=function(a){return a instanceof gP};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof gP){var b=this.dw,c=a.dw;if(null===b?null===c:b.h(c))return b=this.ew,a=a.ew,null===b?null===a:b.h(a)}return!1};f.$classData=q({xT:0},!1,"mlscript.AppliedType",{xT:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,iW:1,F:1,v:1,l:1});function B7(){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;mq(this)}B7.prototype=new M2;B7.prototype.constructor=B7;f=B7.prototype;f.H=function(){return"Bot"};f.G=function(){return 0};
-f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof B7};f.y=function(){return 66983};f.u=function(){return"Bot"};f.$classData=q({CT:0},!1,"mlscript.Bot$",{CT:1,xz:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,F:1,v:1,l:1});var C7;function Il(){C7||(C7=new B7);return C7}function zo(a,b){this.uM=this.tM=null;this.wM=this.xM=0;this.yM=this.vM=null;this.om=0;this.Cr=a;this.Br=b;mq(this)}zo.prototype=new p;zo.prototype.constructor=zo;f=zo.prototype;f.yb=function(){return"constructor"};f.Kj=function(){return WO(this)};
-f.mr=function(){return lx(this)};f.Nu=function(){0===(1&this.om)<<24>>24&&0===(1&this.om)<<24>>24&&(this.tM=UO(this),this.om=(1|this.om)<<24>>24);return this.tM};f.Jm=function(){0===(2&this.om)<<24>>24&&0===(2&this.om)<<24>>24&&(this.uM=Yp(this),this.om=(2|this.om)<<24>>24);return this.uM};f.Rm=function(){return this.xM};f.Tl=function(a){this.xM=a};f.Qm=function(){return this.wM};f.Sl=function(a){this.wM=a};f.Pm=function(){return this.vM};f.Om=function(a){this.vM=a};
-f.C=function(){0===(4&this.om)<<24>>24&&0===(4&this.om)<<24>>24&&(this.yM=bq(this),this.om=(4|this.om)<<24>>24);return this.yM};f.H=function(){return"Constructor"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Cr;case 1:return this.Br;default:return JK(W(),a)}};f.E=function(a){return a instanceof zo};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof zo){var b=this.Cr,c=a.Cr;if(null===b?null===c:b.h(c))return b=this.Br,a=a.Br,null===b?null===a:b.h(a)}return!1};f.$classData=q({eU:0},!1,"mlscript.Constructor",{eU:1,d:1,Ie:1,re:1,Ke:1,Za:1,of:1,S$:1,F:1,v:1,l:1});function fP(a){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.Xr=a;mq(this)}fP.prototype=new M2;fP.prototype.constructor=fP;f=fP.prototype;f.H=function(){return"Literal"};
-f.G=function(){return 1};f.I=function(a){return 0===a?this.Xr:JK(W(),a)};f.E=function(a){return a instanceof fP};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof fP){var b=this.Xr;a=a.Xr;return null===b?null===a:b.h(a)}return!1};f.$classData=q({UV:0},!1,"mlscript.Literal",{UV:1,xz:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,F:1,v:1,l:1});
-function mt(a,b){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.qs=a;this.ps=b;mq(this)}mt.prototype=new C_;mt.prototype.constructor=mt;f=mt.prototype;f.H=function(){return"PolyType"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.qs;case 1:return this.ps;default:return JK(W(),a)}};f.E=function(a){return a instanceof mt};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof mt){var b=this.qs,c=a.qs;if(null===b?null===c:b.h(c))return b=this.ps,a=a.ps,null===b?null===a:b.h(a)}return!1};f.$classData=q({nX:0},!1,"mlscript.PolyType",{nX:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,aaa:1,F:1,v:1,l:1});function D7(){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;mq(this)}D7.prototype=new M2;D7.prototype.constructor=D7;f=D7.prototype;f.H=function(){return"Top"};f.G=function(){return 0};
-f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof D7};f.y=function(){return 84277};f.u=function(){return"Top"};f.$classData=q({MX:0},!1,"mlscript.Top$",{MX:1,xz:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,F:1,v:1,l:1});var E7;function Jl(){E7||(E7=new D7);return E7}function jP(a){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.Qz=a;mq(this)}jP.prototype=new M2;jP.prototype.constructor=jP;f=jP.prototype;f.H=function(){return"TypeTag"};
-f.G=function(){return 1};f.I=function(a){return 0===a?this.Qz:JK(W(),a)};f.E=function(a){return a instanceof jP};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){return this===a?!0:a instanceof jP?this.Qz===a.Qz:!1};f.$classData=q({eY:0},!1,"mlscript.TypeTag",{eY:1,xz:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,F:1,v:1,l:1});function Uu(){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0}Uu.prototype=new I_;Uu.prototype.constructor=Uu;function F7(){}
-F7.prototype=Uu.prototype;Uu.prototype.sk=function(a){return iT(this,a)};Uu.prototype.gl=function(a){return iT(this,a)};var lu=q({jE:0},!1,"mlscript.TyperDatatypes$AbstractTag",{jE:1,Ho:1,Mg:1,wg:1,d:1,xg:1,Ng:1,Wz:1,Wi:1,xe:1,lx:1});Uu.prototype.$classData=lu;function oC(a,b){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0;this.pO=this.qO=null;this.cI=!1;this.dI=b;mY(this,a);this.pO=V(a)}oC.prototype=new J_;oC.prototype.constructor=oC;f=oC.prototype;
-f.gc=function(){if(!this.cI&&!this.cI){var a=this.dI,b=V(this.dI.p);this.qO=pA(a,b,!1);this.cI=!0}return this.qO};f.qa=function(){return this.pO};f.H=function(){return"NegAbsTag"};f.G=function(){return 1};f.I=function(a){return 0===a?this.dI:JK(W(),a)};f.E=function(a){return a instanceof oC};f.$classData=q({KY:0},!1,"mlscript.TyperDatatypes$NegAbsTag",{KY:1,iI:1,Mg:1,wg:1,d:1,xg:1,Ng:1,lx:1,F:1,v:1,l:1});
-function nC(a,b){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0;this.rO=this.sO=null;this.eI=!1;this.fI=b;mY(this,a);this.rO=V(a)}nC.prototype=new J_;nC.prototype.constructor=nC;f=nC.prototype;f.gc=function(){if(!this.eI&&!this.eI){var a=this.fI,b=V(this.fI.p);this.sO=pA(a,b,!1);this.eI=!0}return this.sO};f.qa=function(){return this.rO};f.H=function(){return"NegVar"};f.G=function(){return 1};f.I=function(a){return 0===a?this.fI:JK(W(),a)};
-f.E=function(a){return a instanceof nC};f.$classData=q({MY:0},!1,"mlscript.TyperDatatypes$NegVar",{MY:1,iI:1,Mg:1,wg:1,d:1,xg:1,Ng:1,lx:1,F:1,v:1,l:1});function G7(a){if(0===(1&a.Yh)<<24>>24&&0===(1&a.Yh)<<24>>24){var b=a.rI;b.b()?b=R():(b=b.o(),b=G7(b),b=b.b()?a.rI:b);a.NO=b;a.Yh=(1|a.Yh)<<24>>24}return a.NO}
-function H7(a){if(0===(4&a.Yh)<<24>>24&&0===(4&a.Yh)<<24>>24){t();var b=JD().BP,c=a.dg;c=c.b()?"_":c.o();a:{for(var d=c.length,e=0;e<d;){var g=c.charCodeAt(e);if(!hf(new E(hd(g)),hd(39))){d=e;break a}e=1+e|0}d=-1}b=""+b+(-1===d?"":c.substring(d));b=new M(b);t();c=LP(a.p);c=new ns(new te(c),b);t();d=LP(a.p);b=new ns(new te(d),b);a.OO=G(new H,c,b);a.Yh=(4|a.Yh)<<24>>24}return a.OO}
-function Ow(a,b,c,d,e,g,h,k){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0;this.Wb=this.JO=this.KO=this.OO=this.LO=this.NO=null;this.Yh=this.Jo=this.MO=0;this.Va=b;this.HO=c;this.IO=d;this.rI=e;this.dg=g;this.Zh=k;mY(this,a);Os(fp(),b<=a.tf);this.Wb=t().f;this.MO=a.nm;this.Jo=LP(a)}Ow.prototype=new nY;Ow.prototype.constructor=Ow;f=Ow.prototype;f.sk=function(a){return hT(this,a)};f.Ca=function(){return this.Va};f.qa=function(){return this.Zh};
-function jA(a,b){fp();var c=b.b()?!0:b.o().Ca()<=a.Va;Os(0,c);a.Wb=b}function ny(a){if(!a.Wb.b())throw dk("requirement failed: "+a);return a.HO}function Tz(a){if(!a.Wb.b())throw dk("requirement failed: "+a);return a.IO}function kA(a,b){if(!a.Wb.b())throw dk("requirement failed: "+a);a.HO=b}function mA(a,b){if(!a.Wb.b())throw dk("requirement failed: "+a);a.IO=b}function eba(a){if(hf(new E(a.p.nm),a.MO)){var b=a.rI;return b.b()?a:b.o()}return a}
-f.rb=function(a,b){if(this.Va<=a)return this.Va;if(b.L(this))return this.p.md;b.S(this);var c=this.Wb;if(c instanceof M)return c.k.rb(a,b);if(t().f===c){c=ny(this).m().mb(new U(()=>Tz(this).m()));c=new eg(c,new z(e=>e.rb(a,b)));var d=dq();c=hq(c,d);return(c.b()?this.p.md:c.o())|0}throw new x(c);};function S6(a){0===(2&a.Yh)<<24>>24&&0===(2&a.Yh)<<24>>24&&(t(),a.LO=new ns(new te(a.Jo),a.dg),a.Yh=(2|a.Yh)<<24>>24);return a.LO}
-function vea(a){0===(8&a.Yh)<<24>>24&&0===(8&a.Yh)<<24>>24&&(a.KO=H7(a).i(),a.Yh=(8|a.Yh)<<24>>24);return a.KO}function wea(a){0===(16&a.Yh)<<24>>24&&0===(16&a.Yh)<<24>>24&&(a.JO=H7(a).j(),a.Yh=(16|a.Yh)<<24>>24);return a.JO}function hT(a,b){a=new A7(a.Jo);b=b.Jo;dq();a=a.hm;return a===b?0:a<b?-1:1}
-f.u=function(){var a=G7(this);if(a instanceof M){a=a.k;if(!hf(new E(a.dg),this.dg))throw new rk("assertion failed: "+G(new H,a.dg,this.dg));a=I7(a)+"_"+this.Jo+sC(this.p,this.Va)}else{if(t().f!==a)throw new x(a);a=""+I7(this)+sC(this.p,this.Va)}return a+(this.Wb.b()?"":"#")};function I7(a){var b=a.dg;return""+(b.b()?"\u03b1":b.o())+a.Jo}f.gl=function(a){return hT(this,a)};var L2=q({fZ:0},!1,"mlscript.TyperDatatypes$TypeVariable",{fZ:1,Mg:1,wg:1,d:1,xg:1,Ng:1,GO:1,Wi:1,xe:1,lx:1,Yy:1});
-Ow.prototype.$classData=L2;function WG(a,b){this.xR=this.fy=null;if(null===a)throw null;this.fy=a;this.xR=b}WG.prototype=new c7;WG.prototype.constructor=WG;WG.prototype.Q=function(){return ZG(this.fy)};WG.prototype.b=function(){return this.fy.Sj.b()||this.fy.Tj.b()};WG.prototype.m=function(){return new q0(this)};WG.prototype.$classData=q({V4:0},!1,"scala.collection.LazyZip2$$anon$1",{V4:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1});
-function XG(a,b){this.zR=this.mv=null;if(null===a)throw null;this.mv=a;this.zR=b}XG.prototype=new c7;XG.prototype.constructor=XG;XG.prototype.Q=function(){return 0===this.mv.Sj.Q()||0===this.mv.Tj.Q()?0:-1};XG.prototype.b=function(){return this.mv.Sj.b()||this.mv.Tj.b()};XG.prototype.m=function(){return new s0(this)};XG.prototype.$classData=q({X4:0},!1,"scala.collection.LazyZip2$$anon$3",{X4:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1});
-function nD(a){this.gy=null;if(null===a)throw null;this.gy=a}nD.prototype=new c7;nD.prototype.constructor=nD;nD.prototype.Q=function(){return ZG(this.gy)};nD.prototype.b=function(){return this.gy.Sj.b()||this.gy.Tj.b()};nD.prototype.m=function(){return new t0(this)};nD.prototype.$classData=q({Z4:0},!1,"scala.collection.LazyZip2$$anon$7",{Z4:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1});function J7(a){this.YK=a}J7.prototype=new c7;J7.prototype.constructor=J7;J7.prototype.m=function(){return this.YK.Qd()};
-J7.prototype.Q=function(){return this.YK.Q()};J7.prototype.b=function(){return this.YK.b()};J7.prototype.$classData=q({m5:0},!1,"scala.collection.MapView$Values",{m5:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1});function Z2(a,b){return a===b?!0:b&&b.$classData&&b.$classData.pb.tc&&b.E(a)?a.dt(b):!1}function K7(a,b,c,d){a.yB=b;a.hp=c;a.ky=d;a.eL=!1;return a}function L7(a,b){var c=new M7;K7(c,a,a.K(),b);return c}function M7(){this.yB=this.KR=null;this.hp=0;this.ky=null;this.dL=this.eL=!1}
-M7.prototype=new p;M7.prototype.constructor=M7;f=M7.prototype;f.Ob=function(){return gU()};f.u=function(){return m5(this)};f.xh=function(){return"SeqView"};f.hi=function(){return gU().Db()};f.hl=function(a){return KT(this,a)};f.zi=function(a){return LY(this,a)};f.Ad=function(){return(new N7(this)).m()};f.Rn=function(a,b){var c=this.m();return NT(c,a,b)};f.L=function(a){return SU(this,a)};f.Pk=function(a){return qC(this,a)};f.$a=function(a){return qC(this,a)};f.e=function(){return this.m().t()};
-f.Fc=function(){return AT(this)};f.Gb=function(a){return MT(this,a)};f.ya=function(a){KG(this,a)};f.Ln=function(a){return Cx(this,a)};f.ge=function(a,b){return NA(this,a,b)};f.we=function(a,b){return ku(this,a,b)};f.Bi=function(a){return MG(this,a)};f.yc=function(a,b,c){return NG(this,a,b,c)};f.Ui=function(a){return PG(this,a)};f.Ti=function(a){return QG(this,a)};f.vh=function(a,b,c,d){return RG(this,a,b,c,d)};f.ea=function(){je();return le(v(),this)};f.Li=function(){return bp(cp(),this)};
-f.hC=function(){return k1(nK(),this)};f.vj=function(a){return LA(this,a)};function O7(a){if(!a.dL&&!a.dL){var b=a.hp;if(0===b)b=O().c;else if(1===b)O(),b=[a.yB.e()],b=J(new L,b),b=le(v(),b);else{b=new jd(b);a.yB.yc(b,0,2147483647);var c=a.ky;xj(fk(),b,c);b=BQ(AQ(),b)}a.eL=!0;a.yB=null;a.KR=b;a.dL=!0}return a.KR}function P7(a){var b=a.yB;return a.eL?O7(a):b}f.ua=function(a){return O7(this).ua(a)};f.K=function(){return this.hp};f.m=function(){return qq().Oa.mb(new U(()=>O7(this).m()))};f.Q=function(){return this.hp};
-f.b=function(){return 0===this.hp};f.Rc=function(){return new N7(this)};f.LL=function(a){var b=this.ky;return(null===a?null===b:a.h(b))?this:a.Nj(this.ky)?new N7(this):K7(new M7,P7(this),this.hp,a)};f.qc=function(a){return aU(gU(),a)};f.zb=function(a){return Q7(new R7,this,a)};f.Cc=function(a){return S7(new T7,this,a)};f.Zb=function(a){return U7(new V7,a,this)};f.Ga=function(a){return W7(new X7,this,a)};f.Ph=function(a){return this.LL(a)};
-f.$classData=q({p5:0},!1,"scala.collection.SeqView$Sorted",{p5:1,d:1,Di:1,ib:1,na:1,M:1,N:1,ad:1,la:1,ma:1,l:1});function Y7(a){if(!a.sG){var b=new Z7,c=O7(a.Ym);b.pv=c;a.rG=b;a.sG=!0}return a.rG}function N7(a){this.rG=null;this.sG=!1;this.Ym=null;if(null===a)throw null;this.Ym=a}N7.prototype=new p;N7.prototype.constructor=N7;f=N7.prototype;f.Ob=function(){return gU()};f.u=function(){return m5(this)};f.xh=function(){return"SeqView"};f.hi=function(){return gU().Db()};
-f.hl=function(a){return KT(this,a)};f.zi=function(a){return LY(this,a)};f.Ad=function(){return this.Ym.m()};f.Rn=function(a,b){var c=this.m();return NT(c,a,b)};f.L=function(a){return SU(this,a)};f.Pk=function(a){return qC(this,a)};f.$a=function(a){return qC(this,a)};f.e=function(){return this.m().t()};f.Fc=function(){return AT(this)};f.Gb=function(a){return MT(this,a)};f.ya=function(a){KG(this,a)};f.Ln=function(a){return Cx(this,a)};f.ge=function(a,b){return NA(this,a,b)};
-f.we=function(a,b){return ku(this,a,b)};f.Bi=function(a){return MG(this,a)};f.yc=function(a,b,c){return NG(this,a,b,c)};f.Ui=function(a){return PG(this,a)};f.Ti=function(a){return QG(this,a)};f.vh=function(a,b,c,d){return RG(this,a,b,c,d)};f.ea=function(){je();return le(v(),this)};f.Li=function(){return bp(cp(),this)};f.hC=function(){return k1(nK(),this)};f.vj=function(a){return LA(this,a)};f.ua=function(a){return(this.sG?this.rG:Y7(this)).ua(a)};f.K=function(){return this.Ym.hp};
-f.m=function(){return qq().Oa.mb(new U(()=>(this.sG?this.rG:Y7(this)).m()))};f.Q=function(){return this.Ym.hp};f.b=function(){return 0===this.Ym.hp};f.Rc=function(){return this.Ym};f.LL=function(a){var b=this.Ym.ky;return(null===a?null===b:a.h(b))?this.Ym:a.Nj(this.Ym.ky)?this:K7(new M7,P7(this.Ym),this.Ym.hp,a)};f.qc=function(a){return aU(gU(),a)};f.zb=function(a){return Q7(new R7,this,a)};f.Cc=function(a){return S7(new T7,this,a)};f.Zb=function(a){return U7(new V7,a,this)};
-f.Ga=function(a){return W7(new X7,this,a)};f.Ph=function(a){return this.LL(a)};f.$classData=q({q5:0},!1,"scala.collection.SeqView$Sorted$ReverseSorted",{q5:1,d:1,Di:1,ib:1,na:1,M:1,N:1,ad:1,la:1,ma:1,l:1});function bU(a){this.O5=a}bU.prototype=new c7;bU.prototype.constructor=bU;bU.prototype.m=function(){return Zr(this.O5)};bU.prototype.$classData=q({N5:0},!1,"scala.collection.View$$anon$1",{N5:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1});function LT(a,b){this.iL=a;this.jL=b}LT.prototype=new c7;
-LT.prototype.constructor=LT;LT.prototype.m=function(){return this.iL.m().mb(new U(()=>this.jL.m()))};LT.prototype.Q=function(){var a=this.iL.Q();if(0<=a){var b=this.jL.Q();return 0<=b?a+b|0:-1}return-1};LT.prototype.b=function(){return this.iL.b()&&this.jL.b()};LT.prototype.$classData=q({P5:0},!1,"scala.collection.View$Concat",{P5:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1});function MY(a,b){this.kL=a;this.R5=b}MY.prototype=new c7;MY.prototype.constructor=MY;
-MY.prototype.m=function(){var a=this.kL.m();return new Fx(a,this.R5)};MY.prototype.Q=function(){return 0===this.kL.Q()?0:-1};MY.prototype.b=function(){return this.kL.b()};MY.prototype.$classData=q({Q5:0},!1,"scala.collection.View$DistinctBy",{Q5:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1});function CT(a,b,c){a.py=b;a.EB=c;a.rv=0<c?c:0;return a}function DT(){this.py=null;this.rv=this.EB=0}DT.prototype=new c7;DT.prototype.constructor=DT;function $7(){}$7.prototype=DT.prototype;DT.prototype.m=function(){return this.py.m().fh(this.EB)};
-DT.prototype.Q=function(){var a=this.py.Q();return 0<=a?(a=a-this.rv|0,0<a?a:0):-1};DT.prototype.b=function(){return!this.m().s()};DT.prototype.$classData=q({yG:0},!1,"scala.collection.View$Drop",{yG:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1});function i3(a,b,c){a.oy=b;a.CB=c;a.DB=0<c?c:0;return a}function j3(){this.oy=null;this.DB=this.CB=0}j3.prototype=new c7;j3.prototype.constructor=j3;function a8(){}a8.prototype=j3.prototype;
-j3.prototype.m=function(){gU();var a=this.oy.m();var b=this.CB;if(!(0>=b)){var c=a.Q();a=0<=c?a.qn(c-b|0):new B0(a,b)}return a};j3.prototype.Q=function(){var a=this.oy.Q();return 0<=a?(a=a-this.DB|0,0<a?a:0):-1};j3.prototype.b=function(){return 0<=this.Q()?0===this.Q():!this.m().s()};j3.prototype.$classData=q({zG:0},!1,"scala.collection.View$DropRight",{zG:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1});function h3(a,b,c){this.OR=a;this.W5=b;this.V5=c}h3.prototype=new c7;
-h3.prototype.constructor=h3;h3.prototype.m=function(){var a=this.OR.m();return new Gx(a,this.W5,this.V5)};h3.prototype.Q=function(){return 0===this.OR.Q()?0:-1};h3.prototype.b=function(){return!this.m().s()};h3.prototype.$classData=q({U5:0},!1,"scala.collection.View$Filter",{U5:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1});q({X5:0},!1,"scala.collection.View$FlatMap",{X5:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1});function IT(a,b,c){a.sv=b;a.FB=c;return a}
-function JT(){this.FB=this.sv=null}JT.prototype=new c7;JT.prototype.constructor=JT;function b8(){}b8.prototype=JT.prototype;JT.prototype.m=function(){var a=this.sv.m();return new eg(a,this.FB)};JT.prototype.Q=function(){return this.sv.Q()};JT.prototype.b=function(){return this.sv.b()};JT.prototype.$classData=q({AG:0},!1,"scala.collection.View$Map",{AG:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1});function c8(){this.qy=this.GB=null}c8.prototype=new c7;c8.prototype.constructor=c8;
-function d8(){}d8.prototype=c8.prototype;c8.prototype.m=function(){return(new LT(new e8(this.GB),this.qy)).m()};c8.prototype.Q=function(){var a=this.qy.Q();return 0<=a?1+a|0:-1};function e8(a){this.Z5=a}e8.prototype=new c7;e8.prototype.constructor=e8;e8.prototype.m=function(){qq();return new X_(this.Z5)};e8.prototype.Q=function(){return 1};e8.prototype.b=function(){return!1};e8.prototype.$classData=q({Y5:0},!1,"scala.collection.View$Single",{Y5:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1});
-function f8(a,b,c){var d=a.Y(b);c=c.n(d);d=G(new H,d,c);c=d.z;var e=d.x;if(R()===c&&R()===e)return a;c=d.x;if(d.z instanceof M&&R()===c)return a.rj(b);c=d.x;if(c instanceof M)return a.km(b,c.k);throw new x(d);}function Y2(){}Y2.prototype=new p;Y2.prototype.constructor=Y2;f=Y2.prototype;f.Qj=function(a,b){return 0>=this.Fa(a,b)};f.xk=function(a,b){return 0<=this.Fa(a,b)};f.wk=function(a,b){return 0<this.Fa(a,b)};f.lj=function(a,b){return n2(this,a,b)};f.nl=function(a,b){return o2(this,a,b)};
-f.ol=function(a,b){return p2(this,a,b)};f.Nj=function(a){return q2(this,a)};f.Fa=function(a,b){a|=0;b|=0;return a===b?0:a<b?-1:1};f.$classData=q({V2:0},!1,"scala.math.Numeric$IntIsIntegral$",{V2:1,d:1,Maa:1,Jaa:1,Laa:1,Um:1,Si:1,Wm:1,Tm:1,l:1,f3:1});var X2;function ZO(a,b){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.hw=null;this.gw=!1;this.Sr=a;this.Tr=b;this.qo=!1;mq(this)}ZO.prototype=new E4;ZO.prototype.constructor=ZO;f=ZO.prototype;
-f.dK=function(){return this.Sr};f.lK=function(){return this.Tr};f.H=function(){return"Inter"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Sr;case 1:return this.Tr;default:return JK(W(),a)}};f.E=function(a){return a instanceof ZO};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof ZO){var b=this.Sr,c=a.Sr;if(null===b?null===c:b.h(c))return b=this.Tr,a=a.Tr,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({JU:0},!1,"mlscript.Inter",{JU:1,ST:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,TT:1,F:1,v:1,l:1});function yo(a,b,c,d,e,g,h,k){this.vC=this.uC=null;this.xC=this.yC=0;this.zC=this.wC=null;this.Tk=0;this.Gz=a;this.Hz=b;this.Jz=c;this.Fz=d;this.IH=e;this.JH=g;this.Iz=h;this.HH=k;mq(this)}yo.prototype=new F4;yo.prototype.constructor=yo;f=yo.prototype;f.H=function(){return"TypeDef"};f.G=function(){return 8};
-f.I=function(a){switch(a){case 0:return this.Gz;case 1:return this.Hz;case 2:return this.Jz;case 3:return this.Fz;case 4:return this.IH;case 5:return this.JH;case 6:return this.Iz;case 7:return this.HH;default:return JK(W(),a)}};f.E=function(a){return a instanceof yo};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof yo){if(this.Gz===a.Gz){var b=this.Hz,c=a.Hz;b=null===b?null===c:b.h(c)}else b=!1;b?(b=this.Jz,c=a.Jz,(null===b?null===c:b.h(c))?(b=this.Fz,c=a.Fz,b=null===b?null===c:b.h(c)):b=!1):b=!1;if(b&&(b=this.IH,c=a.IH,(null===b?null===c:b.h(c))?(b=this.JH,c=a.JH,b=null===b?null===c:b.h(c)):b=!1,b&&(b=this.Iz,c=a.Iz,null===b?null===c:b.h(c))))return b=this.HH,a=a.HH,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({RX:0},!1,"mlscript.TypeDef",{RX:1,hU:1,d:1,Ie:1,re:1,Ke:1,Za:1,of:1,iU:1,F:1,v:1,l:1});function yu(a,b,c,d){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.oO=this.Wc=0;this.bI=!1;this.Mb=b;this.Xb=c;this.Bj=d;mY(this,a)}yu.prototype=new M4;yu.prototype.constructor=yu;f=yu.prototype;f.qa=function(){return this.Bj};f.Ca=function(){if(!this.bI&&!this.bI){var a=this.Mb.Ca(),b=this.Xb.Ca();this.oO=a>b?a:b;this.bI=!0}return this.oO};
-f.rb=function(a,b){var c=this.Mb.rb(a,b);a=this.Xb.rb(a,b);return c>a?c:a};function g8(a,b,c,d,e){return new yu(a.p,a.Mb.Dc(b,c,d,e),a.Xb.Dc(b,c,d,e),a.Bj)}
-f.u=function(){var a=!1,b=null,c=this.Mb;a:{if(c instanceof Ru){a=!0;b=c;var d=b.Ub;if(d instanceof A){var e=d.A;d=d.r;if(null!==e){var g=e.i();e=e.j();if(t().f===g&&null!==e&&(g=e.Ma,e=e.oa,t().f===g&&e instanceof Ru&&(g=O().c,null===g?null===d:g.h(d)))){c="["+h8(e)+"]";break a}}}}a&&(a=b.Ub,a instanceof A&&(b=a.A,a=a.r,null!==b&&(d=b.i(),b=b.j(),t().f===d?(d=O().c,a=null===d?null===a:d.h(a)):a=!1,a&&(c=b.u()))))}return"("+c+" -\x3e "+this.Xb+")"};f.H=function(){return"FunctionType"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.Mb;case 1:return this.Xb;default:return JK(W(),a)}};f.E=function(a){return a instanceof yu};f.Ts=function(a,b,c,d){return g8(this,a,b,c,d)};f.Qu=function(a,b,c,d){return g8(this,a,b,c,d)};f.$classData=q({IY:0},!1,"mlscript.TyperDatatypes$FunctionType",{IY:1,Sz:1,jx:1,Ho:1,Mg:1,wg:1,d:1,xg:1,Ng:1,F:1,v:1,l:1});
-function Xu(a,b,c){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.uO=this.Wc=0;this.gI=!1;this.Wh=b;this.fq=c;mY(this,a);Os(fp(),0<b.$a(0))}Xu.prototype=new M4;Xu.prototype.constructor=Xu;f=Xu.prototype;f.qa=function(){return this.fq};function ZW(a,b,c){var d=a.p,e=a.Wh,g=m=>new yu(a.p,b.n(m.Mb),c.n(m.Xb),m.Bj);if(e===v())g=v();else{var h=e.e(),k=h=new A(g(h),v());for(e=e.g();e!==v();){var l=e.e();l=new A(g(l),v());k=k.r=l;e=e.g()}g=h}return new Xu(d,g,a.fq)}
-function SA(a,b,c){var d=a.p,e=a.Wh,g=m=>{var n=a.p;if(b.b())var r=R();else r=!!b.o(),r=new M(!r);return new yu(n,c.aa(r,m.Mb),c.aa(b,m.Xb),m.Bj)};if(e===v())g=v();else{var h=e.e(),k=h=new A(g(h),v());for(e=e.g();e!==v();){var l=e.e();l=new A(g(l),v());k=k.r=l;e=e.g()}g=h}return new Xu(d,g,a.fq)}
-function Saa(a,b,c){var d=a.p,e=a.Wh,g=m=>new yu(a.p,c.aa(new nB(b),m.Mb),c.aa(b,m.Xb),m.Bj);if(e===v())g=v();else{var h=e.e(),k=h=new A(g(h),v());for(e=e.g();e!==v();){var l=e.e();l=new A(g(l),v());k=k.r=l;e=e.g()}g=h}return new Xu(d,g,a.fq)}
-function qX(a){var b=a.Wh;if(b===v())var c=v();else{c=b.e();var d=c=new A(G(new H,c.Mb,c.Xb),v());for(b=b.g();b!==v();){var e=b.e();e=new A(G(new H,e.Mb,e.Xb),v());d=d.r=e;b=b.g()}}d=ap();b=c.Gb(d.wa);if(null===b)throw new x(b);d=b.j();c=a.p;b=b.i().m();if(!b.s())throw Fu("empty.reduceLeft");e=!0;for(var g=null;b.s();){var h=b.t();if(e)g=h,e=!1;else{var k=V(g.p);g=zu(g,h,k,!1)}}b=g;d=d.m();if(!d.s())throw Fu("empty.reduceLeft");e=!0;for(g=null;d.s();)h=d.t(),e?(g=h,e=!1):(k=V(g.p),g=zu(g,h,k,!1));
-return new yu(c,b,g,a.fq)}f.Ca=function(){this.gI||this.gI||(this.uO=this.rb(this.p.tf,Lz().U()),this.gI=!0);return this.uO};f.rb=function(a,b){var c=this.Wh.m();c=new eg(c,new z(e=>e.rb(a,b)));var d=dq();return QG(c,d)|0};function i8(a,b,c,d,e){var g=a.p,h=a.Wh;if(h===v())b=v();else{var k=h.e(),l=k=new A(g8(k,b,c,d,e),v());for(h=h.g();h!==v();){var m=h.e();m=new A(g8(m,b,c,d,e),v());l=l.r=m;h=h.g()}b=k}return new Xu(g,b,a.fq)}f.H=function(){return"Overload"};f.G=function(){return 1};
-f.I=function(a){return 0===a?this.Wh:JK(W(),a)};f.E=function(a){return a instanceof Xu};f.u=function(){return EK(this)};f.Ts=function(a,b,c,d){return i8(this,a,b,c,d)};f.Qu=function(a,b,c,d){return i8(this,a,b,c,d)};f.$classData=q({OY:0},!1,"mlscript.TyperDatatypes$Overload",{OY:1,Sz:1,jx:1,Ho:1,Mg:1,wg:1,d:1,xg:1,Ng:1,F:1,v:1,l:1});function gv(a,b,c,d){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0;this.Bc=b;this.Ye=c;this.Lo=d;mY(this,a)}gv.prototype=new M4;
-gv.prototype.constructor=gv;f=gv.prototype;f.qa=function(){return this.Lo};f.Ca=function(){return this.Bc.Ca()};f.rb=function(a,b){return this.Bc.rb(a,b)};f.u=function(){return this.Bc+"\\"+Qe(this.Ye,"","-","")};f.H=function(){return"Without"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Bc;case 1:return this.Ye;default:return JK(W(),a)}};f.E=function(a){return a instanceof gv};f.Ts=function(a,b,c,d){return new gv(this.p,this.Bc.Dc(a,b,c,d),this.Ye,this.Lo)};
-f.Qu=function(a,b,c,d){return new gv(this.p,this.Bc.Dc(a,b,c,d),this.Ye,this.Lo)};f.$classData=q({kZ:0},!1,"mlscript.TyperDatatypes$Without",{kZ:1,Sz:1,jx:1,Ho:1,Mg:1,wg:1,d:1,xg:1,Ng:1,F:1,v:1,l:1});function $O(a,b){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.hw=null;this.gw=!1;this.Cs=a;this.Ds=b;this.qo=!0;mq(this)}$O.prototype=new E4;$O.prototype.constructor=$O;f=$O.prototype;f.dK=function(){return this.Cs};f.lK=function(){return this.Ds};
-f.H=function(){return"Union"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Cs;case 1:return this.Ds;default:return JK(W(),a)}};f.E=function(a){return a instanceof $O};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof $O){var b=this.Cs,c=a.Cs;if(null===b?null===c:b.h(c))return b=this.Ds,a=a.Ds,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({wZ:0},!1,"mlscript.Union",{wZ:1,ST:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,TT:1,F:1,v:1,l:1});function j8(){}j8.prototype=new g3;j8.prototype.constructor=j8;function k8(){}f=k8.prototype=j8.prototype;f.E=function(){return!0};f.h=function(a){return d7(this,a)};f.y=function(){var a=kL();return lL(a,this,a.qB)};f.Ob=function(){return UY()};f.Hc=function(){return"Set"};f.u=function(){return l0(this)};f.OL=function(a){return this.il(a)};f.af=function(a){return y0(this,a)};f.n=function(a){return this.L(a)};
-function l8(a,b){if(a===b)return!0;if(b&&b.$classData&&b.$classData.pb.Ak)if(a.ka()===b.ka())try{return a.il(new z(c=>Ol(Pl(),b.yd(c.i(),FY().CR),c.j())))}catch(c){throw c;}else return!1;else return!1}function m8(a,b){var c=a.zp().bv(a.Wd());c.oc(a);c.oc(b);return c.Eb()}function mm(a,b){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.kb=a;this.hc=b;M5(this)}mm.prototype=new N5;mm.prototype.constructor=mm;f=mm.prototype;f.H=function(){return"App"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.kb;case 1:return this.hc;default:return JK(W(),a)}};f.E=function(a){return a instanceof mm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof mm){var b=this.kb,c=a.kb;if(null===b?null===c:b.h(c))return b=this.hc,a=a.hc,null===b?null===a:b.h(a)}return!1};f.$classData=q({wT:0},!1,"mlscript.App",{wT:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});
-function em(a,b){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.Ni=a;this.po=b;M5(this)}em.prototype=new N5;em.prototype.constructor=em;f=em.prototype;f.H=function(){return"Asc"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Ni;case 1:return this.po;default:return JK(W(),a)}};f.E=function(a){return a instanceof em};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof em){var b=this.Ni,c=a.Ni;if(null===b?null===c:b.h(c))return b=this.po,a=a.po,null===b?null===a:b.h(a)}return!1};f.$classData=q({yT:0},!1,"mlscript.Asc",{yT:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});function hm(a,b){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.Sk=a;this.Sh=b;M5(this)}hm.prototype=new N5;hm.prototype.constructor=hm;f=hm.prototype;f.H=function(){return"Bra"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.Sk;case 1:return this.Sh;default:return JK(W(),a)}};f.E=function(a){return a instanceof hm};f.y=function(){var a=dc("Bra");a=W().B(-889275714,a);var b=this.Sk?1231:1237;a=W().B(a,b);b=this.Sh;b=dy(W(),b);a=W().B(a,b);return W().La(a,2)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof hm&&this.Sk===a.Sk){var b=this.Sh;a=a.Sh;return null===b?null===a:b.h(a)}return!1};
-f.$classData=q({ET:0},!1,"mlscript.Bra",{ET:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});function rm(a,b){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.Fp=a;this.Ep=b;M5(this)}rm.prototype=new N5;rm.prototype.constructor=rm;f=rm.prototype;f.H=function(){return"CaseOf"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Fp;case 1:return this.Ep;default:return JK(W(),a)}};f.E=function(a){return a instanceof rm};f.y=function(){return jL(this)};
-f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof rm){var b=this.Fp,c=a.Fp;if(null===b?null===c:b.h(c))return b=this.Ep,a=a.Ep,null===b?null===a:b.h(a)}return!1};f.$classData=q({QT:0},!1,"mlscript.CaseOf",{QT:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});
-function xo(a,b,c,d){this.vC=this.uC=null;this.xC=this.yC=0;this.zC=this.wC=null;this.Tk=0;this.zM=null;this.Dr=a;this.Gp=b;this.Ot=c;this.AC=d;mq(this);if(c instanceof me)a=c.ia;else{if(!(c instanceof te))throw new x(c);a=c.ca}this.zM=a}xo.prototype=new F4;xo.prototype.constructor=xo;f=xo.prototype;f.H=function(){return"Def"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.Dr;case 1:return this.Gp;case 2:return this.Ot;case 3:return this.AC;default:return JK(W(),a)}};
-f.E=function(a){return a instanceof xo};f.y=function(){var a=dc("Def");a=W().B(-889275714,a);var b=this.Dr?1231:1237;a=W().B(a,b);b=this.Gp;b=dy(W(),b);a=W().B(a,b);b=this.Ot;b=dy(W(),b);a=W().B(a,b);b=this.AC?1231:1237;a=W().B(a,b);return W().La(a,4)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof xo&&this.Dr===a.Dr&&this.AC===a.AC){var b=this.Gp,c=a.Gp;if(null===b?null===c:b.h(c))return b=this.Ot,a=a.Ot,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({jU:0},!1,"mlscript.Def",{jU:1,hU:1,d:1,Ie:1,re:1,Ke:1,Za:1,of:1,iU:1,If:1,F:1,v:1,l:1});function ym(a,b){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.Ip=a;this.Er=b;M5(this)}ym.prototype=new N5;ym.prototype.constructor=ym;f=ym.prototype;f.H=function(){return"Eqn"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Ip;case 1:return this.Er;default:return JK(W(),a)}};f.E=function(a){return a instanceof ym};f.y=function(){return jL(this)};
-f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof ym){var b=this.Ip,c=a.Ip;if(null===b?null===c:b.h(c))return b=this.Er,a=a.Er,null===b?null===a:b.h(a)}return!1};f.$classData=q({pU:0},!1,"mlscript.Eqn",{pU:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});function vm(a,b){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.Pt=a;this.Ir=b;M5(this)}vm.prototype=new N5;vm.prototype.constructor=vm;f=vm.prototype;f.H=function(){return"Forall"};
-f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Pt;case 1:return this.Ir;default:return JK(W(),a)}};f.E=function(a){return a instanceof vm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof vm){var b=this.Pt,c=a.Pt;if(null===b?null===c:b.h(c))return b=this.Ir,a=a.Ir,null===b?null===a:b.h(a)}return!1};f.$classData=q({xU:0},!1,"mlscript.Forall",{xU:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});
-function tm(a,b){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.Qr=a;this.rw=b;M5(this)}tm.prototype=new N5;tm.prototype.constructor=tm;f=tm.prototype;f.H=function(){return"If"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Qr;case 1:return this.rw;default:return JK(W(),a)}};f.E=function(a){return a instanceof tm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof tm){var b=this.Qr,c=a.Qr;if(null===b?null===c:b.h(c))return b=this.rw,a=a.rw,null===b?null===a:b.h(a)}return!1};f.$classData=q({BU:0},!1,"mlscript.If",{BU:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});function lm(a,b){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.Dl=a;this.El=b;M5(this)}lm.prototype=new N5;lm.prototype.constructor=lm;f=lm.prototype;f.H=function(){return"Lam"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.Dl;case 1:return this.El;default:return JK(W(),a)}};f.E=function(a){return a instanceof lm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof lm){var b=this.Dl,c=a.Dl;if(null===b?null===c:b.h(c))return b=this.El,a=a.El,null===b?null===a:b.h(a)}return!1};f.$classData=q({SV:0},!1,"mlscript.Lam",{SV:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});
-function om(a,b,c,d){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.Wr=a;this.Op=b;this.Pp=c;this.vo=d;M5(this)}om.prototype=new N5;om.prototype.constructor=om;f=om.prototype;f.H=function(){return"Let"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.Wr;case 1:return this.Op;case 2:return this.Pp;case 3:return this.vo;default:return JK(W(),a)}};f.E=function(a){return a instanceof om};
-f.y=function(){var a=dc("Let");a=W().B(-889275714,a);var b=this.Wr?1231:1237;a=W().B(a,b);b=this.Op;b=dy(W(),b);a=W().B(a,b);b=this.Pp;b=dy(W(),b);a=W().B(a,b);b=this.vo;b=dy(W(),b);a=W().B(a,b);return W().La(a,4)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof om){if(this.Wr===a.Wr){var b=this.Op,c=a.Op;b=null===b?null===c:b.h(c)}else b=!1;if(b&&(b=this.Pp,c=a.Pp,null===b?null===c:b.h(c)))return b=this.vo,a=a.vo,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({TV:0},!1,"mlscript.Let",{TV:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});function um(a){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.gs=a;M5(this)}um.prototype=new N5;um.prototype.constructor=um;f=um.prototype;f.H=function(){return"NuNew"};f.G=function(){return 1};f.I=function(a){return 0===a?this.gs:JK(W(),a)};f.E=function(a){return a instanceof um};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof um){var b=this.gs;a=a.gs;return null===b?null===a:b.h(a)}return!1};f.$classData=q({OW:0},!1,"mlscript.NuNew",{OW:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});
-function io(a,b,c,d,e,g,h,k,l,m,n,r){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.SD=this.TD=this.sf=null;this.xo=0;this.nb=a;this.eb=b;this.bg=c;this.Lg=d;this.sm=e;this.xj=g;this.ti=h;this.Pw=k;this.hs=l;this.Uh=m;this.Vk=n;this.rm=r;K4(this)}io.prototype=new L4;io.prototype.constructor=io;f=io.prototype;f.aJ=function(){return this.rm};f.H=function(){return"NuTypeDef"};f.G=function(){return 10};
-f.I=function(a){switch(a){case 0:return this.nb;case 1:return this.eb;case 2:return this.bg;case 3:return this.Lg;case 4:return this.sm;case 5:return this.xj;case 6:return this.ti;case 7:return this.Pw;case 8:return this.hs;case 9:return this.Uh;default:return JK(W(),a)}};f.E=function(a){return a instanceof io};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof io){if(this.nb===a.nb){var b=this.eb,c=a.eb;b=null===b?null===c:b.h(c)}else b=!1;b?(b=this.bg,c=a.bg,(null===b?null===c:b.h(c))?(b=this.Lg,c=a.Lg,(null===b?null===c:b.h(c))?(b=this.sm,c=a.sm,b=null===b?null===c:b.h(c)):b=!1):b=!1):b=!1;if(b&&(b=this.xj,c=a.xj,(null===b?null===c:b.h(c))?(b=this.ti,c=a.ti,b=null===b?null===c:b.h(c)):b=!1,b&&(b=this.Pw,c=a.Pw,null===b?null===c:b.h(c)))&&(b=this.hs,c=a.hs,null===b?null===c:b.h(c)))return b=this.Uh,
-a=a.Uh,null===b?null===a:b.h(a)}return!1};f.zd=function(){return this.nb};f.DF=function(){return this.nb};f.$classData=q({PW:0},!1,"mlscript.NuTypeDef",{PW:1,LW:1,$g:1,d:1,ah:1,Za:1,re:1,Ke:1,MW:1,kX:1,F:1,v:1,l:1});function Zl(a){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.vn=a;M5(this)}Zl.prototype=new N5;Zl.prototype.constructor=Zl;f=Zl.prototype;f.H=function(){return"Rcd"};f.G=function(){return 1};f.I=function(a){return 0===a?this.vn:JK(W(),a)};
-f.E=function(a){return a instanceof Zl};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Zl){var b=this.vn;a=a.vn;return null===b?null===a:b.h(a)}return!1};f.$classData=q({tX:0},!1,"mlscript.Rcd",{tX:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});function zm(a,b){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.cu=a;this.du=b;M5(this)}zm.prototype=new N5;
-zm.prototype.constructor=zm;f=zm.prototype;f.H=function(){return"Rft"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.cu;case 1:return this.du;default:return JK(W(),a)}};f.E=function(a){return a instanceof zm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof zm){var b=this.cu,c=a.cu;if(null===b?null===c:b.h(c))return b=this.du,a=a.du,null===b?null===a:b.h(a)}return!1};
-f.$classData=q({wX:0},!1,"mlscript.Rft",{wX:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});function nm(a,b){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.Co=a;this.wn=b;M5(this)}nm.prototype=new N5;nm.prototype.constructor=nm;f=nm.prototype;f.H=function(){return"Sel"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Co;case 1:return this.wn;default:return JK(W(),a)}};f.E=function(a){return a instanceof nm};f.y=function(){return jL(this)};
-f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof nm){var b=this.Co,c=a.Co;if(null===b?null===c:b.h(c))return b=this.wn,a=a.wn,null===b?null===a:b.h(a)}return!1};f.$classData=q({AX:0},!1,"mlscript.Sel",{AX:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});function sm(a,b){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.fu=a;this.gu=b;M5(this)}sm.prototype=new N5;sm.prototype.constructor=sm;f=sm.prototype;f.H=function(){return"Subs"};
-f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.fu;case 1:return this.gu;default:return JK(W(),a)}};f.E=function(a){return a instanceof sm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof sm){var b=this.fu,c=a.fu;if(null===b?null===c:b.h(c))return b=this.gu,a=a.gu,null===b?null===a:b.h(a)}return!1};f.$classData=q({KX:0},!1,"mlscript.Subs",{KX:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});
-function xm(){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;M5(this)}xm.prototype=new N5;xm.prototype.constructor=xm;f=xm.prototype;f.H=function(){return"Super"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof xm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){return a instanceof xm};
-f.$classData=q({LX:0},!1,"mlscript.Super",{LX:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});function km(a,b){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.ym=a;this.ts=b;M5(this)}km.prototype=new N5;km.prototype.constructor=km;f=km.prototype;f.H=function(){return"TyApp"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.ym;case 1:return this.ts;default:return JK(W(),a)}};f.E=function(a){return a instanceof km};f.y=function(){return jL(this)};
-f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof km){var b=this.ym,c=a.ym;if(null===b?null===c:b.h(c))return b=this.ts,a=a.ts,null===b?null===a:b.h(a)}return!1};f.$classData=q({QX:0},!1,"mlscript.TyApp",{QX:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});function fv(a,b,c){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0;this.ld=b;this.ix=c;mY(this,a)}fv.prototype=new Q5;fv.prototype.constructor=fv;f=fv.prototype;f.Mj=function(){return this.ld};
-f.qa=function(){return this.ix};f.Ca=function(){return this.ld.Ca()};f.rb=function(a,b){return this.ld.rb(a,b)};f.u=function(){return"Array\u2039"+this.ld+"\u203a"};f.H=function(){return"ArrayType"};f.G=function(){return 1};f.I=function(a){return 0===a?this.ld:JK(W(),a)};f.E=function(a){return a instanceof fv};f.Ts=function(a,b,c,d){return new fv(this.p,QX(this.ld,a,b,c,d),this.ix)};f.Qu=function(a,b,c,d){return new fv(this.p,QX(this.ld,a,b,c,d),this.ix)};
-f.$classData=q({sY:0},!1,"mlscript.TyperDatatypes$ArrayType",{sY:1,PN:1,Sz:1,jx:1,Ho:1,Mg:1,wg:1,d:1,xg:1,Ng:1,F:1,v:1,l:1});function Bea(a){if(0===(1&a.ys)<<24>>24){var b=a.zn,c=h=>{if(h instanceof te)return h.ca.Ca();if(h instanceof me)return h.ia.Ca();throw new x(h);};if(b===v())c=v();else{var d=b.e(),e=d=new A(c(d),v());for(b=b.g();b!==v();){var g=b.e();g=new A(c(g),v());e=e.r=g;b=b.g()}c=d}d=dq();a.lI=QG(c,d)|0;a.ys=(1|a.ys)<<24>>24}return a.lI}
-function Cea(a){if(0===(2&a.ys)<<24>>24){var b=a.zn,c=h=>{if(h instanceof te){h=h.ca;if(h instanceof iv)return h.Mj();$n()}else{if(h instanceof me)return h.ia;throw new x(h);}};if(b===v())c=v();else{var d=b.e(),e=d=new A(c(d),v());for(b=b.g();b!==v();){var g=b.e();g=new A(c(g),v());e=e.r=g;b=b.g()}c=d}c=c.m();if(!c.s())throw Fu("empty.reduceLeft");d=!0;for(b=null;c.s();)e=c.t(),d?(b=e,d=!1):b=Kv(b,e,V(b.Ua));a.kI=b;a.ys=(2|a.ys)<<24>>24}return a.kI}
-function jv(a,b,c){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.lI=this.Wc=0;this.kI=null;this.ys=0;this.zn=b;this.ou=c;mY(this,a);Os(fp(),!b.b())}jv.prototype=new Q5;jv.prototype.constructor=jv;f=jv.prototype;f.qa=function(){return this.ou};f.Ca=function(){return 0===(1&this.ys)<<24>>24?Bea(this):this.lI};
-f.Qu=function(a,b,c,d){var e=this.p,g=this.zn,h=n=>{if(n instanceof te)return n=n.ca,t(),n=n.Dc(a,b,c,d),new te(n);if(n instanceof me)return n=n.ia,t(),n=QX(n,a,b,c,d),new me(n);throw new x(n);};if(g===v())h=v();else{var k=g.e(),l=k=new A(h(k),v());for(g=g.g();g!==v();){var m=g.e();m=new A(h(m),v());l=l.r=m;g=g.g()}h=k}return new jv(e,h,this.ou)};
-f.rb=function(a,b){var c=this.zn,d=k=>{if(k instanceof te)return k.ca.rb(a,b);if(k instanceof me)return k.ia.rb(a,b);throw new x(k);};if(c===v())d=v();else{var e=c.e(),g=e=new A(d(e),v());for(c=c.g();c!==v();){var h=c.e();h=new A(d(h),v());g=g.r=h;c=c.g()}d=e}e=dq();return QG(d,e)|0};f.Mj=function(){return 0===(2&this.ys)<<24>>24?Cea(this):this.kI};
-function TA(a,b,c,d,e){var g=a.p,h=a.zn;a=n=>{if(n instanceof te)return n=n.ca,t(),n=b.n(n),new te(n);if(n instanceof me)return n=n.ia,t(),n=DA(n,c,d),new me(n);throw new x(n);};if(h===v())a=v();else{var k=h.e(),l=k=new A(a(k),v());for(h=h.g();h!==v();){var m=h.e();m=new A(a(m),v());l=l.r=m;h=h.g()}a=k}return new jv(g,a,e)}f.H=function(){return"SpliceType"};f.G=function(){return 1};f.I=function(a){return 0===a?this.zn:JK(W(),a)};f.E=function(a){return a instanceof jv};f.u=function(){return EK(this)};
-f.Ts=function(a,b,c,d){return this.Qu(a,b,c,d)};f.$classData=q({WY:0},!1,"mlscript.TyperDatatypes$SpliceType",{WY:1,PN:1,Sz:1,jx:1,Ho:1,Mg:1,wg:1,d:1,xg:1,Ng:1,F:1,v:1,l:1});function Dea(a){if(0===(2&a.Dj)<<24>>24){var b=a.Ub.m();b=new eg(b,new z(d=>d.j().Ca()));var c=dq();b=hq(b,c);a.oI=(b.b()?0:b.o())|0;a.Dj=(2|a.Dj)<<24>>24}return a.oI}
-function Eea(a){if(0===(8&a.Dj)<<24>>24){var b=a.p,c=mg(a.Ub),d=k=>{if(null!==k){var l=k.i(),m=k.Lc();if(null!==l)return k=l.j(),G(new H,new Wl(""+m),k)}throw new x(k);};if(c===v())d=v();else{var e=c.e(),g=e=new A(d(e),v());for(c=c.g();c!==v();){var h=c.e();h=new A(d(h),v());g=g.r=h;c=c.g()}d=e}a.pI=new dv(b,d,a.gq);a.Dj=(8|a.Dj)<<24>>24}return a.pI}
-function Ru(a,b,c){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0;this.AO=null;this.oI=0;this.pI=this.BO=null;this.Dj=0;this.Ub=b;this.gq=c;mY(this,a)}Ru.prototype=new Q5;Ru.prototype.constructor=Ru;f=Ru.prototype;f.qa=function(){return this.gq};
-f.Mj=function(){if(0===(1&this.Dj)<<24>>24&&0===(1&this.Dj)<<24>>24){var a=this.Ub;if(a===v())var b=v();else{b=a.e();var c=b=new A(b.j(),v());for(a=a.g();a!==v();){var d=a.e();d=new A(d.j(),v());c=c.r=d;a=a.g()}}if(b.b())b=R();else{b=b.m();if(!b.s())throw Fu("empty.reduceLeft");c=!0;for(d=null;b.s();)a=b.t(),c?(d=a,c=!1):d=Kv(d,a,V(d.Ua));b=new M(d)}b.b()?(b=this.p.tb,c=V(this.p),b=new ww(b.p,R(),b,c)):b=b.o();this.AO=b;this.Dj=(1|this.Dj)<<24>>24}return this.AO};
-f.Ca=function(){return 0===(2&this.Dj)<<24>>24?Dea(this):this.oI};f.rb=function(a,b){var c=this.Ub.m();c=new eg(c,new z(e=>e.j().rb(a,b)));var d=dq();c=hq(c,d);return(c.b()?this.p.md:c.o())|0};function n8(a,b,c,d,e){var g=a.p;Du();return new Ru(g,Mx(0,a.Ub,new z(h=>QX(h,b,c,d,e))),a.gq)}function Qv(a){0===(4&a.Dj)<<24>>24&&0===(4&a.Dj)<<24>>24&&(a.BO=new fv(a.p,a.Mj(),a.gq),a.Dj=(4|a.Dj)<<24>>24);return a.BO}f.Ap=function(){return 0===(8&this.Dj)<<24>>24?Eea(this):this.pI};
-function h8(a){var b=a.Ub;a=g=>{var h=g.i();return(h.b()?"":h.o().w+": ")+g.j()+","};if(b===v())a=v();else{var c=b.e(),d=c=new A(a(c),v());for(b=b.g();b!==v();){var e=b.e();e=new A(a(e),v());d=d.r=e;b=b.g()}a=c}return Qe(a,""," ","")}f.u=function(){return"("+h8(this)+")"};f.H=function(){return"TupleType"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Ub:JK(W(),a)};f.E=function(a){return a instanceof Ru};f.Ts=function(a,b,c,d){return n8(this,a,b,c,d)};
-f.Qu=function(a,b,c,d){return n8(this,a,b,c,d)};f.$classData=q({$Y:0},!1,"mlscript.TyperDatatypes$TupleType",{$Y:1,PN:1,Sz:1,jx:1,Ho:1,Mg:1,wg:1,d:1,xg:1,Ng:1,F:1,v:1,l:1});function wm(a,b){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.tu=a;this.uu=b;M5(this)}wm.prototype=new N5;wm.prototype.constructor=wm;f=wm.prototype;f.H=function(){return"Where"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.tu;case 1:return this.uu;default:return JK(W(),a)}};f.E=function(a){return a instanceof wm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof wm){var b=this.tu,c=a.tu;if(null===b?null===c:b.h(c))return b=this.uu,a=a.uu,null===b?null===a:b.h(a)}return!1};f.$classData=q({EZ:0},!1,"mlscript.Where",{EZ:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});
-function qm(a,b){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.wu=a;this.vu=b;M5(this)}qm.prototype=new N5;qm.prototype.constructor=qm;f=qm.prototype;f.H=function(){return"With"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.wu;case 1:return this.vu;default:return JK(W(),a)}};f.E=function(a){return a instanceof qm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof qm){var b=this.wu,c=a.wu;if(null===b?null===c:b.h(c))return b=this.vu,a=a.vu,null===b?null===a:b.h(a)}return!1};f.$classData=q({GZ:0},!1,"mlscript.With",{GZ:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,F:1,v:1,l:1});function o8(){}o8.prototype=new g3;o8.prototype.constructor=o8;function p8(){}f=p8.prototype=o8.prototype;f.E=function(){return!0};f.h=function(a){return Z2(this,a)};f.y=function(){return gS(this)};f.u=function(){return l0(this)};
-f.Hm=function(a){return KT(this,a)};f.hl=function(a){return this.Hm(a)};f.ka=function(){return this.K()};f.zi=function(a){return LY(this,a)};f.Ad=function(){return this.Rc().m()};f.vJ=function(a){return 0<=a&&0<this.$a(a)};f.Rn=function(a,b){var c=this.m();return NT(c,a,b)};f.L=function(a){return SU(this,a)};f.Ph=function(a){return Fv(this,a)};f.Pk=function(a){return this.$a(a)};f.$a=function(a){return qC(this,a)};f.b=function(){return QY(this)};f.dt=function(a){return RY(this,a)};
-f.Nb=function(a,b){return xQ(this,a,b)};f.Ec=function(a){return this.vJ(a|0)};function q8(){}q8.prototype=new c7;q8.prototype.constructor=q8;function r8(){}f=r8.prototype=q8.prototype;f.Fh=function(a){return W7(new X7,this,a)};f.Hh=function(a){return U7(new V7,a,this)};f.Bh=function(a){return S7(new T7,this,a)};f.zh=function(a){return Q7(new R7,this,a)};f.Hc=function(){return"SeqView"};f.hl=function(a){return KT(this,a)};f.zi=function(a){return LY(this,a)};f.Ad=function(){return this.Rc().m()};
-f.Rn=function(a,b){var c=this.m();return NT(c,a,b)};f.L=function(a){return SU(this,a)};f.Pk=function(a){return this.$a(a)};f.$a=function(a){return qC(this,a)};f.b=function(){return QY(this)};f.Ph=function(a){return L7(this,a)};f.zb=function(a){return this.zh(a)};f.Cc=function(a){return this.Bh(a)};f.Zb=function(a){return this.Hh(a)};f.Ga=function(a){return this.Fh(a)};function iU(){}iU.prototype=new c7;iU.prototype.constructor=iU;f=iU.prototype;f.m=function(){return qq().Oa};f.Q=function(){return 0};
-f.b=function(){return!0};f.H=function(){return"Empty"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.E=function(a){return a instanceof iU};f.y=function(){return 67081517};f.$classData=q({T5:0},!1,"scala.collection.View$Empty$",{T5:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,F:1,v:1});var hU;
-function Kn(a,b,c,d,e,g,h,k,l,m){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.SD=this.TD=this.sf=null;this.xo=0;this.oN=this.pN=null;this.Sd=a;this.Qb=b;this.bj=c;this.qh=d;this.cd=e;this.tz=g;this.Ow=h;this.VD=k;this.UD=l;this.yo=m;K4(this);if(e instanceof me)a=e.ia;else{if(!(e instanceof te))throw new x(e);a=e.ca}this.pN=a;this.oN=R()}Kn.prototype=new L4;Kn.prototype.constructor=Kn;f=Kn.prototype;f.zd=function(){return Kw()};f.aJ=function(){return this.oN};
-function Yx(a){return a.Ow.b()?a.cd.TA():!0}f.H=function(){return"NuFunDef"};f.G=function(){return 5};f.I=function(a){switch(a){case 0:return this.Sd;case 1:return this.Qb;case 2:return this.bj;case 3:return this.qh;case 4:return this.cd;default:return JK(W(),a)}};f.E=function(a){return a instanceof Kn};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Kn){var b=this.Sd,c=a.Sd;(null===b?null===c:b.h(c))?(b=this.Qb,c=a.Qb,b=null===b?null===c:b.h(c)):b=!1;if(b&&(b=this.bj,c=a.bj,null===b?null===c:b.h(c))&&(b=this.qh,c=a.qh,null===b?null===c:b.h(c)))return b=this.cd,a=a.cd,null===b?null===a:b.h(a)}return!1};f.$classData=q({NW:0},!1,"mlscript.NuFunDef",{NW:1,LW:1,$g:1,d:1,ah:1,Za:1,re:1,Ke:1,MW:1,Ie:1,of:1,F:1,v:1,l:1});
-function s8(a){M5(a);if(a instanceof Wl)var b=a.w;else{if(!(a instanceof fm))throw new x(a);b=rz(a,!1)}a.vi=b}function uY(){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.vi=null}uY.prototype=new N5;uY.prototype.constructor=uY;function t8(){}t8.prototype=uY.prototype;uY.prototype.sk=function(a){return sb(this.vi,a.vi)};uY.prototype.gl=function(a){return sb(this.vi,a.vi)};
-function im(a){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.Ra=a;M5(this)}im.prototype=new N5;im.prototype.constructor=im;f=im.prototype;f.H=function(){return"Tup"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Ra:JK(W(),a)};f.E=function(a){return a instanceof im};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof im){var b=this.Ra;a=a.Ra;return null===b?null===a:b.h(a)}return!1};
-f.$classData=q({OX:0},!1,"mlscript.Tup",{OX:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,caa:1,F:1,v:1,l:1});function ns(a,b){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.Go=a;this.Rz=b;mq(this);Os(fp(),b.b()||a.BJ())}ns.prototype=new M2;ns.prototype.constructor=ns;f=ns.prototype;f.sk=function(a){return cT(this,a)};
-f.u=function(){var a=this.Go;if(a instanceof me)a=a.ia;else{if(!(a instanceof te))throw new x(a);a="\u03b1"+(a.ca|0)}return a};f.H=function(){return"TypeVar"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Go;case 1:return this.Rz;default:return JK(W(),a)}};f.E=function(a){return a instanceof ns};f.y=function(){return jL(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof ns){var b=this.Go,c=a.Go;if(null===b?null===c:b.h(c))return b=this.Rz,a=a.Rz,null===b?null===a:b.h(a)}return!1};f.gl=function(a){return cT(this,a)};f.$classData=q({fY:0},!1,"mlscript.TypeVar",{fY:1,xz:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,haa:1,Wi:1,xe:1,F:1,v:1,l:1});function u8(){}u8.prototype=new g3;u8.prototype.constructor=u8;function v8(){}f=v8.prototype=u8.prototype;f.E=function(){return!0};f.h=function(a){return l8(this,a)};
-f.y=function(){var a=kL();if(this.b())a=a.RF;else{var b=new iS,c=a.Sq;this.Ag(b);c=a.B(c,b.xK);c=a.B(c,b.yK);c=a.dp(c,b.zK);a=a.La(c,b.AK)}return a};f.Hc=function(){return"Map"};f.u=function(){return l0(this)};f.vk=function(a){return this.pj().Ib(a)};f.hi=function(){return this.pj().Db()};f.yd=function(a,b){return n3(this,a,b)};f.n=function(a){return iA(this,a)};f.Nb=function(a,b){return o3(this,a,b)};f.Pq=function(){return w8(new x8,this)};f.aT=function(){return new dp(this)};f.oj=function(){return new x0(this)};
-f.Qd=function(){return new iu(this)};f.Ag=function(a){for(var b=this.m();b.s();){var c=b.t();a.aa(c.i(),c.j())}};f.kF=function(a){return p3(a)};f.L=function(a){return!this.Y(a).b()};f.Ec=function(a){return this.L(a)};f.Ux=function(a){return this.pj().Ib(IT(new JT,this,a))};f.Ol=function(a){return q3(this,a)};f.oe=function(a){return this.Ol(a)};f.vh=function(a,b,c,d){return r3(this,a,b,c,d)};f.qc=function(a){return this.vk(a)};function S7(a,b,c){a.jy=b;a.oG=c;CT(a,b,c);return a}
-function T7(){this.py=null;this.rv=this.EB=0;this.jy=null;this.oG=0}T7.prototype=new $7;T7.prototype.constructor=T7;function y8(){}f=y8.prototype=T7.prototype;f.Fh=function(a){return W7(new X7,this,a)};f.Hh=function(a){return U7(new V7,a,this)};f.zh=function(a){return Q7(new R7,this,a)};f.Hc=function(){return"SeqView"};f.hl=function(a){return KT(this,a)};f.zi=function(a){return LY(this,a)};f.Ad=function(){return this.Rc().m()};f.Rn=function(a,b){var c=this.m();return NT(c,a,b)};
-f.L=function(a){return SU(this,a)};f.Pk=function(a){return this.$a(a)};f.$a=function(a){return qC(this,a)};f.b=function(){return QY(this)};f.K=function(){var a=this.jy.K()-this.rv|0;return 0<a?a:0};f.ua=function(a){return this.jy.ua(a+this.rv|0)};f.Bh=function(a){return S7(new T7,this.jy,this.oG+a|0)};f.Ph=function(a){return L7(this,a)};f.zb=function(a){return this.zh(a)};f.Zb=function(a){return this.Hh(a)};f.Ga=function(a){return this.Fh(a)};f.Cc=function(a){return this.Bh(a)};
-f.$classData=q({$K:0},!1,"scala.collection.SeqView$Drop",{$K:1,yG:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1});function Q7(a,b,c){a.nG=b;i3(a,b,c);b=b.K()-(0<c?c:0)|0;a.iy=0<b?b:0;return a}function R7(){this.oy=null;this.DB=this.CB=0;this.nG=null;this.iy=0}R7.prototype=new a8;R7.prototype.constructor=R7;function z8(){}f=z8.prototype=R7.prototype;f.Fh=function(a){return W7(new X7,this,a)};f.Hh=function(a){return U7(new V7,a,this)};f.Bh=function(a){return S7(new T7,this,a)};
-f.zh=function(a){return Q7(new R7,this,a)};f.Hc=function(){return"SeqView"};f.hl=function(a){return KT(this,a)};f.zi=function(a){return LY(this,a)};f.Ad=function(){return this.Rc().m()};f.Rn=function(a,b){var c=this.m();return NT(c,a,b)};f.L=function(a){return SU(this,a)};f.Pk=function(a){return this.$a(a)};f.$a=function(a){return qC(this,a)};f.b=function(){return QY(this)};f.K=function(){return this.iy};f.ua=function(a){return this.nG.ua(a)};f.Ph=function(a){return L7(this,a)};f.zb=function(a){return this.zh(a)};
-f.Cc=function(a){return this.Bh(a)};f.Zb=function(a){return this.Hh(a)};f.Ga=function(a){return this.Fh(a)};f.$classData=q({aL:0},!1,"scala.collection.SeqView$DropRight",{aL:1,zG:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1});function dU(a,b){a.ov=b;return a}function eU(){this.ov=null}eU.prototype=new r8;eU.prototype.constructor=eU;function A8(){}f=A8.prototype=eU.prototype;f.ua=function(a){return this.ov.ua(a)};f.K=function(){return this.ov.K()};f.m=function(){return this.ov.m()};
-f.Q=function(){return this.ov.Q()};f.b=function(){return this.ov.b()};f.$classData=q({IR:0},!1,"scala.collection.SeqView$Id",{IR:1,rB:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1});function W7(a,b,c){a.wB=b;a.pG=c;IT(a,b,c);return a}function X7(){this.pG=this.wB=this.FB=this.sv=null}X7.prototype=new b8;X7.prototype.constructor=X7;function B8(){}f=B8.prototype=X7.prototype;f.Fh=function(a){return W7(new X7,this,a)};f.Hh=function(a){return U7(new V7,a,this)};
-f.Bh=function(a){return S7(new T7,this,a)};f.zh=function(a){return Q7(new R7,this,a)};f.Hc=function(){return"SeqView"};f.hl=function(a){return KT(this,a)};f.zi=function(a){return LY(this,a)};f.Ad=function(){return this.Rc().m()};f.Rn=function(a,b){var c=this.m();return NT(c,a,b)};f.L=function(a){return SU(this,a)};f.Pk=function(a){return this.$a(a)};f.$a=function(a){return qC(this,a)};f.b=function(){return QY(this)};f.ua=function(a){return this.pG.n(this.wB.ua(a))};f.K=function(){return this.wB.K()};
-f.Ph=function(a){return L7(this,a)};f.zb=function(a){return this.zh(a)};f.Cc=function(a){return this.Bh(a)};f.Zb=function(a){return this.Hh(a)};f.Ga=function(a){return this.Fh(a)};f.$classData=q({bL:0},!1,"scala.collection.SeqView$Map",{bL:1,AG:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1});function U7(a,b,c){a.qG=b;a.xB=c;a.GB=b;a.qy=c;return a}function V7(){this.xB=this.qG=this.qy=this.GB=null}V7.prototype=new d8;V7.prototype.constructor=V7;function C8(){}f=C8.prototype=V7.prototype;
-f.Fh=function(a){return W7(new X7,this,a)};f.Hh=function(a){return U7(new V7,a,this)};f.Bh=function(a){return S7(new T7,this,a)};f.zh=function(a){return Q7(new R7,this,a)};f.Hc=function(){return"SeqView"};f.hl=function(a){return KT(this,a)};f.zi=function(a){return LY(this,a)};f.Ad=function(){return this.Rc().m()};f.Rn=function(a,b){var c=this.m();return NT(c,a,b)};f.L=function(a){return SU(this,a)};f.Pk=function(a){return this.$a(a)};f.$a=function(a){return qC(this,a)};f.b=function(){return QY(this)};
-f.ua=function(a){return 0===a?this.qG:this.xB.ua(-1+a|0)};f.K=function(){return 1+this.xB.K()|0};f.Ph=function(a){return L7(this,a)};f.zb=function(a){return this.zh(a)};f.Cc=function(a){return this.Bh(a)};f.Zb=function(a){return this.Hh(a)};f.Ga=function(a){return this.Fh(a)};f.$classData=q({cL:0},!1,"scala.collection.SeqView$Prepended",{cL:1,PR:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1});function Z7(){this.pv=null}Z7.prototype=new r8;Z7.prototype.constructor=Z7;function D8(){}
-f=D8.prototype=Z7.prototype;f.ua=function(a){return this.pv.ua((-1+this.K()|0)-a|0)};f.K=function(){return this.pv.K()};f.m=function(){return this.pv.Ad()};f.Q=function(){return this.pv.Q()};f.b=function(){return this.pv.b()};f.$classData=q({JR:0},!1,"scala.collection.SeqView$Reverse",{JR:1,rB:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1});
-function E8(a,b){if(a===b)return!0;if(b&&b.$classData&&b.$classData.pb.tG){var c=b.Wd(),d=a.Wd();if(null===c?null===d:c.h(d)){if(a.ka()===b.ka()){c=a.m();b=b.m();for(d=!0;d&&c.s();)d=a.Wd().lj(c.t(),b.t());return d}return!1}}return d7(a,b)}function F8(a,b,c){var d=a.Y(b);c=c.n(d);d=G(new H,d,c);var e=d.z,g=d.x;if(R()!==e||R()!==g)if(e=d.x,d.z instanceof M&&R()===e)a.lB(b);else if(e=d.x,e instanceof M)a.Qh(b,e.k);else throw new x(d);return c}
-function G8(a,b,c){var d=a.Y(b);if(d instanceof M)return d.k;if(R()===d)return c=Zr(c),a.Qh(b,c),c;throw new x(d);}function pm(a){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.Rk=a;M5(this)}pm.prototype=new N5;pm.prototype.constructor=pm;f=pm.prototype;f.H=function(){return"Blk"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Rk:JK(W(),a)};f.E=function(a){return a instanceof pm};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof pm){var b=this.Rk;a=a.Rk;return null===b?null===a:b.h(a)}return!1};f.DF=function(){return c_()};f.$classData=q({AT:0},!1,"mlscript.Blk",{AT:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,Q$:1,kX:1,F:1,v:1,l:1});function gu(a,b,c,d){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0;this.QN=null;this.XH=!1;this.ed=b;this.kE=c;this.vY=d;mY(this,a)}gu.prototype=new U2;gu.prototype.constructor=gu;f=gu.prototype;f.u=function(){return lY(this)};
-f.sk=function(a){return iT(this,a)};f.dv=function(){this.XH||this.XH||(this.QN=kY(this),this.XH=!0);return this.QN};f.Gq=function(){return this.ed};f.iK=function(){return this.kE};f.qa=function(){return this.vY};function daa(a,b){return hf(new E(b.ed),a.ed)?(t(),new M(a)):b.dv().L(a.ed)?(t(),new M(b)):a.dv().L(b.ed)?(t(),new M(a)):t().f}f.Ca=function(){return this.p.md};f.rb=function(){return this.p.md};f.H=function(){return"ClassTag"};f.G=function(){return 2};
-f.I=function(a){switch(a){case 0:return this.ed;case 1:return this.kE;default:return JK(W(),a)}};f.E=function(a){return a instanceof gu};f.gl=function(a){return iT(this,a)};f.Ts=function(){return this};f.Pn=function(){return this.ed};f.$classData=q({uY:0},!1,"mlscript.TyperDatatypes$ClassTag",{uY:1,jx:1,Ho:1,Mg:1,wg:1,d:1,xg:1,Ng:1,Wz:1,Wi:1,xe:1,tO:1,F:1,v:1,l:1});function H8(){}H8.prototype=new c7;H8.prototype.constructor=H8;function I8(){}f=I8.prototype=H8.prototype;f.aT=function(){return new J7(this)};
-f.u=function(){return m5(this)};f.Hc=function(){return"MapView"};f.yd=function(a,b){return n3(this,a,b)};f.n=function(a){return iA(this,a)};f.Nb=function(a,b){return o3(this,a,b)};f.oj=function(){return new x0(this)};f.Qd=function(){return new iu(this)};f.kF=function(a){return p3(a)};f.L=function(a){return!this.Y(a).b()};f.Ec=function(a){return!this.Y(a).b()};f.oe=function(a){return q3(this,a)};f.vh=function(a,b,c,d){return r3(this,a,b,c,d)};f.pj=function(){HY||(HY=new GY);return HY};
-function dY(a,b){return J8(new K8,a,new z(()=>b))}function lV(a){return!!(a&&a.$classData&&a.$classData.pb.er)}function fm(){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.vi=null}fm.prototype=new t8;fm.prototype.constructor=fm;function L8(){}L8.prototype=fm.prototype;function sp(a){this.Se=this.Re=this.Xe=null;this.Ue=this.Ve=0;this.We=this.Te=null;this.mc=0;this.ug=this.tg=null;this.te=0;this.HN=null;this.NH=!1;this.X=a;mq(this)}sp.prototype=new M2;
-sp.prototype.constructor=sp;f=sp.prototype;f.sk=function(a){return sb(this.X,a.X)};f.pr=function(){if(!this.NH&&!this.NH){var a=new Wl(this.X),b=this.C();this.HN=aq(a,b);this.NH=!0}return this.HN};f.Sa=function(){return this.X};f.H=function(){return"TypeName"};f.G=function(){return 1};f.I=function(a){return 0===a?this.X:JK(W(),a)};f.E=function(a){return a instanceof sp};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){return this===a?!0:a instanceof sp?this.X===a.X:!1};f.gl=function(a){return sb(this.X,a.X)};f.$classData=q({ZX:0},!1,"mlscript.TypeName",{ZX:1,xz:1,wi:1,$g:1,d:1,ah:1,Za:1,xi:1,iW:1,eaa:1,Wi:1,xe:1,hW:1,F:1,v:1,l:1});function rB(a,b,c,d,e){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.nO=this.Wc=0;this.mO=null;this.aI=b;this.Am=c;this.FY=d;this.nE=e;mY(this,a);this.nO=a.md;this.mO=c.Xh}rB.prototype=new F7;rB.prototype.constructor=rB;f=rB.prototype;f.qa=function(){return this.FY};
-f.Ca=function(){return this.nO};f.rb=function(){return 0};f.u=function(){return this.aI?"\u22a5("+this.Am+")":"\u22a4("+this.Am+")"};f.H=function(){return"Extruded"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.aI;case 1:return this.Am;default:return JK(W(),a)}};f.E=function(a){return a instanceof rB};f.Pn=function(){return this.mO};f.$classData=q({EY:0},!1,"mlscript.TyperDatatypes$Extruded",{EY:1,jE:1,Ho:1,Mg:1,wg:1,d:1,xg:1,Ng:1,Wz:1,Wi:1,xe:1,lx:1,GO:1,F:1,v:1,l:1});
-function Pw(a,b,c){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.nu=this.Wc=0;this.Xh=b;this.xs=c;mY(this,a);this.nu=b.Va}Pw.prototype=new F7;Pw.prototype.constructor=Pw;f=Pw.prototype;f.qa=function(){return this.xs};f.rb=function(a,b){return this.Xh.rb(a,b)};f.Ca=function(){return this.nu};f.u=function(){var a=I7(this.Xh),b=0<=a.length&&"'"===a.substring(0,1)?qg(Q(),a,1,a.length):a;a=bu(Q(),a);return"\u2018"+b+(hf(new E(hd(a)),hd(39))?"_":"")+sC(this.p,this.nu)};f.H=function(){return"SkolemTag"};
-f.G=function(){return 1};f.I=function(a){return 0===a?this.Xh:JK(W(),a)};f.E=function(a){return a instanceof Pw};f.Pn=function(){return this.Xh};f.$classData=q({VY:0},!1,"mlscript.TyperDatatypes$SkolemTag",{VY:1,jE:1,Ho:1,Mg:1,wg:1,d:1,xg:1,Ng:1,Wz:1,Wi:1,xe:1,lx:1,GO:1,F:1,v:1,l:1});function IB(a,b,c,d){this.p=null;this.Ud=this.fe=this.de=0;this.Td=null;this.ee=!1;this.Wc=0;this.zO=null;this.mI=!1;this.Io=b;this.nI=c;this.ZY=d;mY(this,a)}IB.prototype=new F7;IB.prototype.constructor=IB;f=IB.prototype;
-f.u=function(){return lY(this)};f.dv=function(){this.mI||this.mI||(this.zO=kY(this),this.mI=!0);return this.zO};f.iK=function(){return this.nI};f.qa=function(){return this.ZY};f.rb=function(){return this.p.md};f.Ca=function(){return this.p.md};f.H=function(){return"TraitTag"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Io;case 1:return this.nI;default:return JK(W(),a)}};f.E=function(a){return a instanceof IB};f.Pn=function(){return this.Io};f.Gq=function(){return this.Io};
-f.$classData=q({YY:0},!1,"mlscript.TyperDatatypes$TraitTag",{YY:1,jE:1,Ho:1,Mg:1,wg:1,d:1,xg:1,Ng:1,Wz:1,Wi:1,xe:1,lx:1,tO:1,F:1,v:1,l:1});function M8(){}M8.prototype=new r8;M8.prototype.constructor=M8;function N8(){}f=N8.prototype=M8.prototype;f.m=function(){return Vq(new Wq,this)};f.Ad=function(){return sZ(new tZ,this)};f.Gh=function(a){return d0(new e0,a,this)};f.Ah=function(a){return g0(new h0,this,a)};f.yh=function(a){return O8(new P8,this,a)};f.Eh=function(a){return j0(new k0,this,a)};
-f.Hc=function(){return"IndexedSeqView"};f.we=function(a,b){return b0(this,a,b)};f.Rc=function(){return new Q8(this)};f.e=function(){return this.ua(0)};f.Fc=function(){return zF(this)};f.$a=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.Fh=function(a){return this.Eh(a)};f.Ga=function(a){return this.Eh(a)};f.zh=function(a){return this.yh(a)};f.zb=function(a){return this.yh(a)};f.Bh=function(a){return this.Ah(a)};f.Cc=function(a){return this.Ah(a)};f.Hh=function(a){return this.Gh(a)};
-f.Zb=function(a){return this.Gh(a)};function w8(a,b){if(null===b)throw null;a.nv=b;return a}function x8(){this.nv=null}x8.prototype=new k8;x8.prototype.constructor=x8;function R8(){}f=R8.prototype=x8.prototype;f.m=function(){return this.nv.oj()};f.L=function(a){return this.nv.L(a)};f.ka=function(){return this.nv.ka()};f.Q=function(){return this.nv.Q()};f.b=function(){return this.nv.b()};
-f.$classData=q({DR:0},!1,"scala.collection.MapOps$KeySet",{DR:1,am:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Vj:1,sl:1,ja:1,v:1,vB:1,jg:1,l:1});function IY(){}IY.prototype=new I8;IY.prototype.constructor=IY;f=IY.prototype;f.Y=function(){return R()};f.m=function(){return qq().Oa};f.Q=function(){return 0};f.b=function(){return!0};f.$classData=q({j5:0},!1,"scala.collection.MapView$$anon$1",{j5:1,gR:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,XK:1,Uj:1,za:1,ja:1});function Iu(a){this.hG=a}Iu.prototype=new I8;
-Iu.prototype.constructor=Iu;f=Iu.prototype;f.Y=function(a){return this.hG.Y(a)};f.m=function(){return this.hG.m()};f.Q=function(){return this.hG.Q()};f.b=function(){return this.hG.b()};f.$classData=q({k5:0},!1,"scala.collection.MapView$Id",{k5:1,gR:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,XK:1,Uj:1,za:1,ja:1});function Hu(a,b){this.iG=a;this.ER=b}Hu.prototype=new I8;Hu.prototype.constructor=Hu;f=Hu.prototype;f.m=function(){var a=this.iG.m();return new eg(a,new z(b=>G(new H,b.i(),this.ER.n(b.j()))))};
-f.Y=function(a){a=this.iG.Y(a);var b=this.ER;return a.b()?R():new M(b.n(a.o()))};f.Q=function(){return this.iG.Q()};f.b=function(){return this.iG.b()};f.$classData=q({l5:0},!1,"scala.collection.MapView$MapValues",{l5:1,gR:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,XK:1,Uj:1,za:1,ja:1});
-function S8(a,b){if(a===b)return!0;if(b&&b.$classData&&b.$classData.pb.zB){var c=b.Wd(),d=a.Wd();if(null===c?null===d:c.h(d)){if(a.ka()===b.ka()){c=a.m();b=b.m();for(d=!0;d&&c.s();){d=c.t();var e=b.t();d=a.Wd().lj(d.i(),e.i())&&Ol(Pl(),d.j(),e.j())}return d}return!1}}return l8(a,b)}function T8(){}T8.prototype=new k8;T8.prototype.constructor=T8;function U8(){}U8.prototype=T8.prototype;T8.prototype.Ob=function(){return $p()};T8.prototype.Zx=function(a){a=a.m();for(var b=this;a.s();){var c=a.t();b=b.tk(c)}return b};
-function g0(a,b,c){S7(a,b,c);return a}function h0(){this.py=null;this.rv=this.EB=0;this.jy=null;this.oG=0}h0.prototype=new y8;h0.prototype.constructor=h0;function V8(){}f=V8.prototype=h0.prototype;f.m=function(){return Vq(new Wq,this)};f.Ad=function(){return sZ(new tZ,this)};f.Gh=function(a){return d0(new e0,a,this)};f.Ah=function(a){return g0(new h0,this,a)};f.yh=function(a){return O8(new P8,this,a)};f.Eh=function(a){return j0(new k0,this,a)};f.Hc=function(){return"IndexedSeqView"};
-f.we=function(a,b){return b0(this,a,b)};f.Rc=function(){return new Q8(this)};f.e=function(){return this.ua(0)};f.Fc=function(){return zF(this)};f.$a=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.Fh=function(a){return this.Eh(a)};f.Ga=function(a){return this.Eh(a)};f.zh=function(a){return this.yh(a)};f.zb=function(a){return this.yh(a)};f.Bh=function(a){return this.Ah(a)};f.Cc=function(a){return this.Ah(a)};f.Hh=function(a){return this.Gh(a)};f.Zb=function(a){return this.Gh(a)};
-f.$classData=q({hR:0},!1,"scala.collection.IndexedSeqView$Drop",{hR:1,$K:1,yG:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1,Un:1,Sb:1});function O8(a,b,c){Q7(a,b,c);return a}function P8(){this.oy=null;this.DB=this.CB=0;this.nG=null;this.iy=0}P8.prototype=new z8;P8.prototype.constructor=P8;function W8(){}f=W8.prototype=P8.prototype;f.m=function(){return Vq(new Wq,this)};f.Ad=function(){return sZ(new tZ,this)};f.Gh=function(a){return d0(new e0,a,this)};
-f.Ah=function(a){return g0(new h0,this,a)};f.yh=function(a){return O8(new P8,this,a)};f.Eh=function(a){return j0(new k0,this,a)};f.Hc=function(){return"IndexedSeqView"};f.we=function(a,b){return b0(this,a,b)};f.Rc=function(){return new Q8(this)};f.e=function(){return this.ua(0)};f.Fc=function(){return zF(this)};f.$a=function(a){var b=this.iy;return b===a?0:b<a?-1:1};f.Q=function(){return this.iy};f.Fh=function(a){return this.Eh(a)};f.Ga=function(a){return this.Eh(a)};f.zh=function(a){return this.yh(a)};
-f.zb=function(a){return this.yh(a)};f.Bh=function(a){return this.Ah(a)};f.Cc=function(a){return this.Ah(a)};f.Hh=function(a){return this.Gh(a)};f.Zb=function(a){return this.Gh(a)};f.$classData=q({iR:0},!1,"scala.collection.IndexedSeqView$DropRight",{iR:1,aL:1,zG:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1,Un:1,Sb:1});function $X(a){this.ov=null;dU(this,a)}$X.prototype=new A8;$X.prototype.constructor=$X;f=$X.prototype;f.m=function(){return Vq(new Wq,this)};
-f.Ad=function(){return sZ(new tZ,this)};f.Hc=function(){return"IndexedSeqView"};f.we=function(a,b){return b0(this,a,b)};f.Rc=function(){return new Q8(this)};f.e=function(){return this.ua(0)};f.Fc=function(){return zF(this)};f.$a=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.Fh=function(a){return j0(new k0,this,a)};f.Ga=function(a){return j0(new k0,this,a)};f.zh=function(a){return O8(new P8,this,a)};f.zb=function(a){return O8(new P8,this,a)};
-f.Bh=function(a){return g0(new h0,this,a)};f.Cc=function(a){return g0(new h0,this,a)};f.Hh=function(a){return d0(new e0,a,this)};f.Zb=function(a){return d0(new e0,a,this)};f.$classData=q({s4:0},!1,"scala.collection.IndexedSeqView$Id",{s4:1,IR:1,rB:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1,Un:1,Sb:1});function j0(a,b,c){W7(a,b,c);return a}function k0(){this.pG=this.wB=this.FB=this.sv=null}k0.prototype=new B8;k0.prototype.constructor=k0;function X8(){}f=X8.prototype=k0.prototype;
-f.m=function(){return Vq(new Wq,this)};f.Ad=function(){return sZ(new tZ,this)};f.Gh=function(a){return d0(new e0,a,this)};f.Ah=function(a){return g0(new h0,this,a)};f.yh=function(a){return O8(new P8,this,a)};f.Eh=function(a){return j0(new k0,this,a)};f.Hc=function(){return"IndexedSeqView"};f.we=function(a,b){return b0(this,a,b)};f.Rc=function(){return new Q8(this)};f.e=function(){return this.ua(0)};f.Fc=function(){return zF(this)};f.$a=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};
-f.Fh=function(a){return this.Eh(a)};f.Ga=function(a){return this.Eh(a)};f.zh=function(a){return this.yh(a)};f.zb=function(a){return this.yh(a)};f.Bh=function(a){return this.Ah(a)};f.Cc=function(a){return this.Ah(a)};f.Hh=function(a){return this.Gh(a)};f.Zb=function(a){return this.Gh(a)};f.$classData=q({lR:0},!1,"scala.collection.IndexedSeqView$Map",{lR:1,bL:1,AG:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1,Un:1,Sb:1});function d0(a,b,c){U7(a,b,c);return a}
-function e0(){this.xB=this.qG=this.qy=this.GB=null}e0.prototype=new C8;e0.prototype.constructor=e0;function Y8(){}f=Y8.prototype=e0.prototype;f.m=function(){return Vq(new Wq,this)};f.Ad=function(){return sZ(new tZ,this)};f.Gh=function(a){return d0(new e0,a,this)};f.Ah=function(a){return g0(new h0,this,a)};f.yh=function(a){return O8(new P8,this,a)};f.Eh=function(a){return j0(new k0,this,a)};f.Hc=function(){return"IndexedSeqView"};f.we=function(a,b){return b0(this,a,b)};f.Rc=function(){return new Q8(this)};
-f.e=function(){return this.ua(0)};f.Fc=function(){return zF(this)};f.$a=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.Fh=function(a){return this.Eh(a)};f.Ga=function(a){return this.Eh(a)};f.zh=function(a){return this.yh(a)};f.zb=function(a){return this.yh(a)};f.Bh=function(a){return this.Ah(a)};f.Cc=function(a){return this.Ah(a)};f.Hh=function(a){return this.Gh(a)};f.Zb=function(a){return this.Gh(a)};
-f.$classData=q({mR:0},!1,"scala.collection.IndexedSeqView$Prepended",{mR:1,cL:1,PR:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1,Un:1,Sb:1});function Q8(a){this.pv=a}Q8.prototype=new D8;Q8.prototype.constructor=Q8;f=Q8.prototype;f.m=function(){return Vq(new Wq,this)};f.Ad=function(){return sZ(new tZ,this)};f.Hc=function(){return"IndexedSeqView"};f.we=function(a,b){return b0(this,a,b)};f.Rc=function(){return new Q8(this)};f.e=function(){return this.ua(0)};f.Fc=function(){return zF(this)};
-f.$a=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.Fh=function(a){return j0(new k0,this,a)};f.Ga=function(a){return j0(new k0,this,a)};f.zh=function(a){return O8(new P8,this,a)};f.zb=function(a){return O8(new P8,this,a)};f.Bh=function(a){return g0(new h0,this,a)};f.Cc=function(a){return g0(new h0,this,a)};f.Hh=function(a){return d0(new e0,a,this)};f.Zb=function(a){return d0(new e0,a,this)};
-f.$classData=q({t4:0},!1,"scala.collection.IndexedSeqView$Reverse",{t4:1,JR:1,rB:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1,Un:1,Sb:1});function Z8(a){this.ip=null;if(null===a)throw null;this.ip=a}Z8.prototype=new p;Z8.prototype.constructor=Z8;f=Z8.prototype;f.Wd=function(){return this.ip.Wd()};f.m=function(){return this.ip.oj()};f.L=function(a){return this.ip.L(a)};f.ka=function(){return this.ip.ka()};f.Q=function(){return this.ip.Q()};f.b=function(){return this.ip.b()};
-f.h=function(a){return E8(this,a)};f.Ui=function(a){return k5(this,a)};f.Ti=function(a){return l5(this,a)};f.E=function(){return!0};f.y=function(){var a=kL();return lL(a,this,a.qB)};f.Ob=function(){return UY()};f.u=function(){return l0(this)};f.OL=function(a){return Cv(this,a)};f.af=function(a){return y0(this,a)};f.xh=function(){return"SortedSet"};f.e=function(){return this.ip.oj().t()};f.Fc=function(){return AT(this)};f.Pk=function(a){return qC(this,a)};f.Cc=function(a){return BT(this,a)};
-f.zb=function(a){return this.qc(i3(new j3,this,a))};f.Ga=function(a){return HT(this,a)};f.hl=function(a){return KT(this,a)};f.Gb=function(a){return MT(this,a)};f.ya=function(a){KG(this,a)};f.ge=function(a,b){return NA(this,a,b)};f.we=function(a,b){return ku(this,a,b)};f.Bi=function(a){return MG(this,a)};f.yc=function(a,b,c){return NG(this,a,b,c)};f.vh=function(a,b,c,d){return RG(this,a,b,c,d)};f.ea=function(){je();return le(v(),this)};f.Li=function(){return bp(cp(),this)};
-f.vj=function(a){return LA(this,a)};f.Rc=function(){return Eq(this)};f.n=function(a){return this.ip.L(a)};f.qc=function(a){t3||(t3=new s3);return t3.Eq(a,this.ip.Wd())};f.$classData=q({y5:0},!1,"scala.collection.SortedMapOps$KeySortedSet",{y5:1,d:1,tG:1,Vj:1,la:1,M:1,na:1,N:1,ma:1,sl:1,ja:1,v:1,NR:1,ly:1,MR:1,vB:1,x5:1});function $8(){}$8.prototype=new p8;$8.prototype.constructor=$8;function a9(){}a9.prototype=$8.prototype;$8.prototype.hC=function(){return this};
-function b9(a,b){this.sS=a;this.Fy=b}b9.prototype=new N8;b9.prototype.constructor=b9;f=b9.prototype;f.ua=function(a){return this.sS.ua(a)};f.K=function(){return this.sS.Tg};f.xh=function(){return"ArrayBufferView"};f.m=function(){return new u5(this,this.Fy)};f.Ad=function(){return new v5(this,this.Fy)};f.Gh=function(a){return new c9(a,this,this.Fy)};f.Ah=function(a){return new d9(this,a,this.Fy)};f.yh=function(a){return new e9(this,a,this.Fy)};f.Eh=function(a){return new f9(this,a,this.Fy)};f.Fh=function(a){return this.Eh(a)};
-f.Ga=function(a){return this.Eh(a)};f.zh=function(a){return this.yh(a)};f.zb=function(a){return this.yh(a)};f.Bh=function(a){return this.Ah(a)};f.Cc=function(a){return this.Ah(a)};f.Hh=function(a){return this.Gh(a)};f.Zb=function(a){return this.Gh(a)};f.$classData=q({A8:0},!1,"scala.collection.mutable.ArrayBufferView",{A8:1,S3:1,rB:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1,Un:1,Sb:1});function g9(a){this.nv=null;w8(this,a)}g9.prototype=new R8;g9.prototype.constructor=g9;
-g9.prototype.Ob=function(){return YV()};g9.prototype.$classData=q({A9:0},!1,"scala.collection.mutable.LinkedHashMap$LinkedKeySet",{A9:1,DR:1,am:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Vj:1,sl:1,ja:1,v:1,vB:1,jg:1,l:1});function h9(){}h9.prototype=new v8;h9.prototype.constructor=h9;function i9(){}f=i9.prototype=h9.prototype;f.pj=function(){return cp()};f.Li=function(){return this};f.SL=function(a){return dY(this,a)};f.IF=function(a){return n5(this,a)};f.kC=function(a,b){return o5(this,a,b)};
-f.mm=function(a){return this.lm(a.i(),a.j())};f.$s=function(){return j9(new k9,this)};f.Ob=function(){return BY()};f.Pq=function(){return this.$s()};function l9(a,b){return K0(b)?a.K()===b.K():!0}
-function m9(a,b){if(K0(b)){if(a===b)return!0;var c=a.K(),d=c===b.K();if(d){var e=0,g=a.Ix(),h=b.Ix();g=g<h?g:h;h=c>>31;var k=g>>>31|0|g>>31<<1;for(g=(h===k?(-2147483648^c)>(-2147483648^g<<1):h>k)?g:c;e<g&&d;)d=Ol(Pl(),a.ua(e),b.ua(e)),e=1+e|0;if(e<c&&d)for(a=a.m().fh(e),b=b.m().fh(e);d&&a.s();)d=Ol(Pl(),a.t(),b.t())}return d}return RY(a,b)}function K0(a){return!!(a&&a.$classData&&a.$classData.pb.Ih)}function n9(){}n9.prototype=new U8;n9.prototype.constructor=n9;f=n9.prototype;f.ka=function(){return 0};
-f.b=function(){return!0};f.Q=function(){return 0};f.OL=function(){return!0};f.L=function(){return!1};f.m=function(){return qq().Oa};f.ya=function(){};f.tk=function(){return this};f.Yb=function(a){return new o9(a)};f.Zx=function(){return this};f.$classData=q({F7:0},!1,"scala.collection.immutable.Set$EmptySet$",{F7:1,Vq:1,am:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Vj:1,sl:1,ja:1,v:1,tp:1,sc:1,gr:1,l:1});var p9;function Wp(){p9||(p9=new n9);return p9}function Xq(a){this.ny=a}Xq.prototype=new N8;
-Xq.prototype.constructor=Xq;f=Xq.prototype;f.K=function(){return this.ny.length};f.u=function(){return"StringView("+this.ny+")"};f.H=function(){return"StringView"};f.G=function(){return 1};f.I=function(a){return 0===a?this.ny:JK(W(),a)};f.E=function(a){return a instanceof Xq};f.y=function(){return jL(this)};f.h=function(a){return this===a?!0:a instanceof Xq?this.ny===a.ny:!1};f.ua=function(a){return hd(this.ny.charCodeAt(a))};
-f.$classData=q({L5:0},!1,"scala.collection.StringView",{L5:1,S3:1,rB:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1,Un:1,Sb:1,F:1,v:1});function o9(a){this.Hv=a}o9.prototype=new U8;o9.prototype.constructor=o9;f=o9.prototype;f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.zb=function(a){return YY(this,a)};f.ka=function(){return 1};f.b=function(){return!1};f.Q=function(){return 1};f.L=function(a){return Ol(Pl(),a,this.Hv)};
-f.Qn=function(a){return this.L(a)?this:new q9(this.Hv,a)};f.Kn=function(a){return Ol(Pl(),a,this.Hv)?Wp():this};f.m=function(){qq();return new X_(this.Hv)};f.ya=function(a){a.n(this.Hv)};f.il=function(a){return!!a.n(this.Hv)};f.e=function(){return this.Hv};f.tk=function(a){return this.Kn(a)};f.Yb=function(a){return this.Qn(a)};f.$classData=q({G7:0},!1,"scala.collection.immutable.Set$Set1",{G7:1,Vq:1,am:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Vj:1,sl:1,ja:1,v:1,tp:1,sc:1,gr:1,Ab:1,l:1});
-function q9(a,b){this.rt=a;this.Iv=b}q9.prototype=new U8;q9.prototype.constructor=q9;f=q9.prototype;f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.zb=function(a){return YY(this,a)};f.ka=function(){return 2};f.b=function(){return!1};f.Q=function(){return 2};f.L=function(a){return Ol(Pl(),a,this.rt)||Ol(Pl(),a,this.Iv)};f.Qn=function(a){return this.L(a)?this:new r9(this.rt,this.Iv,a)};
-f.Kn=function(a){return Ol(Pl(),a,this.rt)?new o9(this.Iv):Ol(Pl(),a,this.Iv)?new o9(this.rt):this};f.m=function(){return new p5(this)};f.ya=function(a){a.n(this.rt);a.n(this.Iv)};f.il=function(a){return!!a.n(this.rt)&&!!a.n(this.Iv)};f.e=function(){return this.rt};f.tk=function(a){return this.Kn(a)};f.Yb=function(a){return this.Qn(a)};f.$classData=q({H7:0},!1,"scala.collection.immutable.Set$Set2",{H7:1,Vq:1,am:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Vj:1,sl:1,ja:1,v:1,tp:1,sc:1,gr:1,Ab:1,l:1});
-function r9(a,b,c){this.fr=a;this.st=b;this.tt=c}r9.prototype=new U8;r9.prototype.constructor=r9;f=r9.prototype;f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.zb=function(a){return YY(this,a)};f.ka=function(){return 3};f.b=function(){return!1};f.Q=function(){return 3};f.L=function(a){return Ol(Pl(),a,this.fr)||Ol(Pl(),a,this.st)||Ol(Pl(),a,this.tt)};f.Qn=function(a){return this.L(a)?this:new s9(this.fr,this.st,this.tt,a)};
-f.Kn=function(a){return Ol(Pl(),a,this.fr)?new q9(this.st,this.tt):Ol(Pl(),a,this.st)?new q9(this.fr,this.tt):Ol(Pl(),a,this.tt)?new q9(this.fr,this.st):this};f.m=function(){return new q5(this)};f.ya=function(a){a.n(this.fr);a.n(this.st);a.n(this.tt)};f.il=function(a){return!!a.n(this.fr)&&!!a.n(this.st)&&!!a.n(this.tt)};f.e=function(){return this.fr};f.tk=function(a){return this.Kn(a)};f.Yb=function(a){return this.Qn(a)};
-f.$classData=q({J7:0},!1,"scala.collection.immutable.Set$Set3",{J7:1,Vq:1,am:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Vj:1,sl:1,ja:1,v:1,tp:1,sc:1,gr:1,Ab:1,l:1});function s9(a,b,c,d){this.ao=a;this.up=b;this.vp=c;this.wp=d}s9.prototype=new U8;s9.prototype.constructor=s9;f=s9.prototype;f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.zb=function(a){return YY(this,a)};f.ka=function(){return 4};f.b=function(){return!1};f.Q=function(){return 4};
-f.L=function(a){return Ol(Pl(),a,this.ao)||Ol(Pl(),a,this.up)||Ol(Pl(),a,this.vp)||Ol(Pl(),a,this.wp)};f.Qn=function(a){return this.L(a)?this:t9(t9(t9(t9(t9(fV().Zn,this.ao),this.up),this.vp),this.wp),a)};f.Kn=function(a){return Ol(Pl(),a,this.ao)?new r9(this.up,this.vp,this.wp):Ol(Pl(),a,this.up)?new r9(this.ao,this.vp,this.wp):Ol(Pl(),a,this.vp)?new r9(this.ao,this.up,this.wp):Ol(Pl(),a,this.wp)?new r9(this.ao,this.up,this.vp):this};f.m=function(){return new r5(this)};
-function dea(a,b){switch(b){case 0:return a.ao;case 1:return a.up;case 2:return a.vp;case 3:return a.wp;default:throw new x(b);}}f.ya=function(a){a.n(this.ao);a.n(this.up);a.n(this.vp);a.n(this.wp)};f.il=function(a){return!!a.n(this.ao)&&!!a.n(this.up)&&!!a.n(this.vp)&&!!a.n(this.wp)};f.e=function(){return this.ao};f.tk=function(a){return this.Kn(a)};f.Yb=function(a){return this.Qn(a)};
-f.$classData=q({L7:0},!1,"scala.collection.immutable.Set$Set4",{L7:1,Vq:1,am:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Vj:1,sl:1,ja:1,v:1,tp:1,sc:1,gr:1,Ab:1,l:1});function u9(){}u9.prototype=new p8;u9.prototype.constructor=u9;function v9(){}v9.prototype=u9.prototype;u9.prototype.ga=function(){var a=this.hi();a.oc(this);return a.Eb()};function d9(a,b,c){this.py=null;this.rv=this.EB=0;this.jy=null;this.oG=0;this.yl=c;g0(this,a,b)}d9.prototype=new V8;d9.prototype.constructor=d9;f=d9.prototype;
-f.m=function(){return new u5(this,this.yl)};f.Ad=function(){return new v5(this,this.yl)};f.Gh=function(a){return new c9(a,this,this.yl)};f.Ah=function(a){return new d9(this,a,this.yl)};f.yh=function(a){return new e9(this,a,this.yl)};f.Eh=function(a){return new f9(this,a,this.yl)};f.Fh=function(a){return new f9(this,a,this.yl)};f.Ga=function(a){return new f9(this,a,this.yl)};f.zh=function(a){return new e9(this,a,this.yl)};f.zb=function(a){return new e9(this,a,this.yl)};
-f.Bh=function(a){return new d9(this,a,this.yl)};f.Cc=function(a){return new d9(this,a,this.yl)};f.Hh=function(a){return new c9(a,this,this.yl)};f.Zb=function(a){return new c9(a,this,this.yl)};f.$classData=q({V8:0},!1,"scala.collection.mutable.CheckedIndexedSeqView$Drop",{V8:1,hR:1,$K:1,yG:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1,Un:1,Sb:1,CL:1});function e9(a,b,c){this.oy=null;this.DB=this.CB=0;this.nG=null;this.iy=0;this.xl=c;O8(this,a,b)}e9.prototype=new W8;
-e9.prototype.constructor=e9;f=e9.prototype;f.m=function(){return new u5(this,this.xl)};f.Ad=function(){return new v5(this,this.xl)};f.Gh=function(a){return new c9(a,this,this.xl)};f.Ah=function(a){return new d9(this,a,this.xl)};f.yh=function(a){return new e9(this,a,this.xl)};f.Eh=function(a){return new f9(this,a,this.xl)};f.Fh=function(a){return new f9(this,a,this.xl)};f.Ga=function(a){return new f9(this,a,this.xl)};f.zh=function(a){return new e9(this,a,this.xl)};
-f.zb=function(a){return new e9(this,a,this.xl)};f.Bh=function(a){return new d9(this,a,this.xl)};f.Cc=function(a){return new d9(this,a,this.xl)};f.Hh=function(a){return new c9(a,this,this.xl)};f.Zb=function(a){return new c9(a,this,this.xl)};f.$classData=q({W8:0},!1,"scala.collection.mutable.CheckedIndexedSeqView$DropRight",{W8:1,iR:1,aL:1,zG:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1,Un:1,Sb:1,CL:1});function f9(a,b,c){this.pG=this.wB=this.FB=this.sv=null;this.zl=c;j0(this,a,b)}
-f9.prototype=new X8;f9.prototype.constructor=f9;f=f9.prototype;f.m=function(){return new u5(this,this.zl)};f.Ad=function(){return new v5(this,this.zl)};f.Gh=function(a){return new c9(a,this,this.zl)};f.Ah=function(a){return new d9(this,a,this.zl)};f.yh=function(a){return new e9(this,a,this.zl)};f.Eh=function(a){return new f9(this,a,this.zl)};f.Fh=function(a){return new f9(this,a,this.zl)};f.Ga=function(a){return new f9(this,a,this.zl)};f.zh=function(a){return new e9(this,a,this.zl)};
-f.zb=function(a){return new e9(this,a,this.zl)};f.Bh=function(a){return new d9(this,a,this.zl)};f.Cc=function(a){return new d9(this,a,this.zl)};f.Hh=function(a){return new c9(a,this,this.zl)};f.Zb=function(a){return new c9(a,this,this.zl)};f.$classData=q({X8:0},!1,"scala.collection.mutable.CheckedIndexedSeqView$Map",{X8:1,lR:1,bL:1,AG:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1,Un:1,Sb:1,CL:1});function c9(a,b,c){this.xB=this.qG=this.qy=this.GB=null;this.Al=c;d0(this,a,b)}
-c9.prototype=new Y8;c9.prototype.constructor=c9;f=c9.prototype;f.m=function(){return new u5(this,this.Al)};f.Ad=function(){return new v5(this,this.Al)};f.Gh=function(a){return new c9(a,this,this.Al)};f.Ah=function(a){return new d9(this,a,this.Al)};f.yh=function(a){return new e9(this,a,this.Al)};f.Eh=function(a){return new f9(this,a,this.Al)};f.Fh=function(a){return new f9(this,a,this.Al)};f.Ga=function(a){return new f9(this,a,this.Al)};f.zh=function(a){return new e9(this,a,this.Al)};
-f.zb=function(a){return new e9(this,a,this.Al)};f.Bh=function(a){return new d9(this,a,this.Al)};f.Cc=function(a){return new d9(this,a,this.Al)};f.Hh=function(a){return new c9(a,this,this.Al)};f.Zb=function(a){return new c9(a,this,this.Al)};f.$classData=q({Y8:0},!1,"scala.collection.mutable.CheckedIndexedSeqView$Prepended",{Y8:1,mR:1,cL:1,PR:1,Bd:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,ad:1,l:1,Di:1,ib:1,Un:1,Sb:1,CL:1});
-function Ho(a){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.vi=null;this.nw=a;s8(this)}Ho.prototype=new L8;Ho.prototype.constructor=Ho;f=Ho.prototype;f.H=function(){return"DecLit"};f.G=function(){return 1};f.I=function(a){return 0===a?this.nw:JK(W(),a)};f.E=function(a){return a instanceof Ho};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){if(this===a)return!0;if(a instanceof Ho){var b=this.nw;a=a.nw;return null===b?null===a:b.h(a)}return!1};f.$classData=q({gU:0},!1,"mlscript.DecLit",{gU:1,iH:1,dE:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,Yy:1,eE:1,Wi:1,xe:1,jH:1,F:1,v:1,l:1});function Do(a){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.vi=null;this.Rr=a;s8(this)}Do.prototype=new L8;Do.prototype.constructor=Do;f=Do.prototype;f.H=function(){return"IntLit"};f.G=function(){return 1};
-f.I=function(a){return 0===a?this.Rr:JK(W(),a)};f.E=function(a){return a instanceof Do};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){if(this===a)return!0;if(a instanceof Do){var b=this.Rr;a=a.Rr;return null===b?null===a:b.h(a)}return!1};f.$classData=q({IU:0},!1,"mlscript.IntLit",{IU:1,iH:1,dE:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,Yy:1,eE:1,Wi:1,xe:1,jH:1,F:1,v:1,l:1});
-function Io(a){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.vi=null;this.dx=a;s8(this)}Io.prototype=new L8;Io.prototype.constructor=Io;f=Io.prototype;f.H=function(){return"StrLit"};f.G=function(){return 1};f.I=function(a){return 0===a?this.dx:JK(W(),a)};f.E=function(a){return a instanceof Io};f.y=function(){return jL(this)};f.u=function(){return EK(this)};f.h=function(a){return this===a?!0:a instanceof Io?this.dx===a.dx:!1};
-f.$classData=q({JX:0},!1,"mlscript.StrLit",{JX:1,iH:1,dE:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,Yy:1,eE:1,Wi:1,xe:1,jH:1,F:1,v:1,l:1});function Jo(a){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.vi=null;this.Es=a;s8(this)}Jo.prototype=new L8;Jo.prototype.constructor=Jo;f=Jo.prototype;f.H=function(){return"UnitLit"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Es:JK(W(),a)};f.E=function(a){return a instanceof Jo};
-f.y=function(){var a=dc("UnitLit");a=W().B(-889275714,a);var b=this.Es?1231:1237;a=W().B(a,b);return W().La(a,1)};f.u=function(){return EK(this)};f.h=function(a){return this===a?!0:a instanceof Jo?this.Es===a.Es:!1};f.$classData=q({xZ:0},!1,"mlscript.UnitLit",{xZ:1,iH:1,dE:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,Yy:1,eE:1,Wi:1,xe:1,jH:1,F:1,v:1,l:1});
-function Wl(a){this.Me=this.Le=this.se=this.dd=null;this.Oe=this.Pe=0;this.Qe=this.Ne=null;this.Jc=0;this.Fs=this.vi=null;this.w=a;s8(this);this.Fs=t().f}Wl.prototype=new t8;Wl.prototype.constructor=Wl;f=Wl.prototype;f.pr=function(){return this};f.Sa=function(){return this.w};f.H=function(){return"Var"};f.G=function(){return 1};f.I=function(a){return 0===a?this.w:JK(W(),a)};f.E=function(a){return a instanceof Wl};f.y=function(){return jL(this)};f.u=function(){return EK(this)};
-f.h=function(a){return this===a?!0:a instanceof Wl?this.w===a.w:!1};f.$classData=q({zZ:0},!1,"mlscript.Var",{zZ:1,dE:1,rg:1,d:1,If:1,Ie:1,re:1,Ke:1,Za:1,of:1,sg:1,Yy:1,eE:1,Wi:1,xe:1,oaa:1,hW:1,F:1,v:1,l:1});function w9(){}w9.prototype=new i9;w9.prototype.constructor=w9;f=w9.prototype;f.ka=function(){return 0};f.Q=function(){return 0};f.b=function(){return!0};f.hJ=function(a){throw iH("key not found: "+a);};f.L=function(){return!1};f.Y=function(){return R()};f.yd=function(a,b){return Zr(b)};f.m=function(){return qq().Oa};
-f.oj=function(){return qq().Oa};f.Qd=function(){return qq().Oa};f.Ol=function(a){return lV(a)?a:q3(this,a)};f.rj=function(){return this};f.lm=function(a,b){return new x9(a,b)};f.n=function(a){this.hJ(a)};f.$classData=q({Q6:0},!1,"scala.collection.immutable.Map$EmptyMap$",{Q6:1,jt:1,$l:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Ak:1,Uj:1,za:1,ja:1,dm:1,v:1,er:1,sc:1,pt:1,l:1});var y9;function Jf(){y9||(y9=new w9);return y9}function J8(a,b,c){a.Ii=b;a.dn=c;return a}function K8(){this.dn=this.Ii=null}
-K8.prototype=new i9;K8.prototype.constructor=K8;function z9(){}f=z9.prototype=K8.prototype;f.Y=function(a){return this.Ii.Y(a)};f.kF=function(a){return this.dn.n(a)};f.Ob=function(){return this.Ii.Ob()};f.m=function(){return this.Ii.m()};f.b=function(){return this.Ii.b()};f.pj=function(){return this.Ii.pj()};f.OP=function(a){return J8(new K8,this.Ii.Ol(a),this.dn)};f.QQ=function(a){return J8(new K8,this.Ii.rj(a),this.dn)};f.$S=function(a,b){return J8(new K8,this.Ii.lm(a,b),this.dn)};
-f.qJ=function(a){return J8(new K8,this.Ii.pj().Ib(a),this.dn)};f.qc=function(a){return this.qJ(a)};f.vk=function(a){return this.qJ(a)};f.lm=function(a,b){return this.$S(a,b)};f.rj=function(a){return this.QQ(a)};f.Ol=function(a){return this.OP(a)};f.$classData=q({aS:0},!1,"scala.collection.immutable.Map$WithDefault",{aS:1,jt:1,$l:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Ak:1,Uj:1,za:1,ja:1,dm:1,v:1,er:1,sc:1,pt:1,l:1});function j9(a,b){if(null===b)throw null;a.fm=b;return a}function k9(){this.fm=null}
-k9.prototype=new U8;k9.prototype.constructor=k9;function A9(){}f=A9.prototype=k9.prototype;f.m=function(){return this.fm.oj()};f.L=function(a){return this.fm.L(a)};f.ka=function(){return this.fm.ka()};f.Q=function(){return this.fm.Q()};f.b=function(){return this.fm.b()};f.Qn=function(a){if(this.fm.L(a))return this;var b=Wp();return y0(b,this).Yb(a)};f.Kn=function(a){if(this.fm.L(a)){var b=Wp();return y0(b,this).tk(a)}return this};f.tk=function(a){return this.Kn(a)};f.Yb=function(a){return this.Qn(a)};
-f.$classData=q({cS:0},!1,"scala.collection.immutable.MapOps$ImmutableKeySet",{cS:1,Vq:1,am:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Vj:1,sl:1,ja:1,v:1,tp:1,sc:1,gr:1,vB:1,jg:1,l:1});function B9(a){this.fm=null;j9(this,a)}B9.prototype=new A9;B9.prototype.constructor=B9;f=B9.prototype;f.Qn=function(a){var b=dy(W(),a),c=HG(JG(),b);a=kU(this.fm.$b,a,null,b,c,0,!1);return a===this.fm.$b?this:(new VU(a)).$s()};f.Kn=function(a){a=C9(this.fm,a);return a===this.fm?this:a.$s()};f.tk=function(a){return this.Kn(a)};
-f.Yb=function(a){return this.Qn(a)};f.$classData=q({r6:0},!1,"scala.collection.immutable.HashMap$HashKeySet",{r6:1,cS:1,Vq:1,am:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Vj:1,sl:1,ja:1,v:1,tp:1,sc:1,gr:1,vB:1,jg:1,l:1});function x9(a,b){this.ul=a;this.mp=b}x9.prototype=new i9;x9.prototype.constructor=x9;f=x9.prototype;f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.uk=function(a){return this.Ou(a,!1)};f.zb=function(a){return YY(this,a)};f.ka=function(){return 1};f.Q=function(){return 1};
-f.b=function(){return!1};f.n=function(a){if(Ol(Pl(),a,this.ul))return this.mp;throw iH("key not found: "+a);};f.L=function(a){return Ol(Pl(),a,this.ul)};f.Y=function(a){return Ol(Pl(),a,this.ul)?new M(this.mp):R()};f.yd=function(a,b){return Ol(Pl(),a,this.ul)?this.mp:Zr(b)};f.m=function(){qq();var a=G(new H,this.ul,this.mp);return new X_(a)};f.oj=function(){qq();return new X_(this.ul)};f.Qd=function(){qq();return new X_(this.mp)};
-f.km=function(a,b){return Ol(Pl(),a,this.ul)?new x9(this.ul,b):new D9(this.ul,this.mp,a,b)};f.ev=function(a){return Ol(Pl(),a,this.ul)?Jf():this};f.ya=function(a){a.n(G(new H,this.ul,this.mp))};f.il=function(a){return!!a.n(G(new H,this.ul,this.mp))};f.Ou=function(a,b){return!!a.n(G(new H,this.ul,this.mp))!==b?this:Jf()};f.y=function(){var a=0,b=0,c=1,d=fS(kL(),this.ul,this.mp);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=kL().Sq;d=kL().B(d,a);d=kL().B(d,b);d=kL().dp(d,c);return kL().La(d,1)};f.rj=function(a){return this.ev(a)};
-f.lm=function(a,b){return this.km(a,b)};f.$classData=q({R6:0},!1,"scala.collection.immutable.Map$Map1",{R6:1,jt:1,$l:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Ak:1,Uj:1,za:1,ja:1,dm:1,v:1,er:1,sc:1,pt:1,Ab:1,l:1});function D9(a,b,c,d){this.Xj=a;this.an=b;this.Yj=c;this.bn=d}D9.prototype=new i9;D9.prototype.constructor=D9;f=D9.prototype;f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.uk=function(a){return this.Ou(a,!1)};f.zb=function(a){return YY(this,a)};f.ka=function(){return 2};
-f.Q=function(){return 2};f.b=function(){return!1};f.n=function(a){if(Ol(Pl(),a,this.Xj))return this.an;if(Ol(Pl(),a,this.Yj))return this.bn;throw iH("key not found: "+a);};f.L=function(a){return Ol(Pl(),a,this.Xj)||Ol(Pl(),a,this.Yj)};f.Y=function(a){return Ol(Pl(),a,this.Xj)?new M(this.an):Ol(Pl(),a,this.Yj)?new M(this.bn):R()};f.yd=function(a,b){return Ol(Pl(),a,this.Xj)?this.an:Ol(Pl(),a,this.Yj)?this.bn:Zr(b)};f.m=function(){return new K3(this)};f.oj=function(){return new L3(this)};f.Qd=function(){return new M3(this)};
-f.km=function(a,b){return Ol(Pl(),a,this.Xj)?new D9(this.Xj,b,this.Yj,this.bn):Ol(Pl(),a,this.Yj)?new D9(this.Xj,this.an,this.Yj,b):new E9(this.Xj,this.an,this.Yj,this.bn,a,b)};f.ev=function(a){return Ol(Pl(),a,this.Xj)?new x9(this.Yj,this.bn):Ol(Pl(),a,this.Yj)?new x9(this.Xj,this.an):this};f.ya=function(a){a.n(G(new H,this.Xj,this.an));a.n(G(new H,this.Yj,this.bn))};f.il=function(a){return!!a.n(G(new H,this.Xj,this.an))&&!!a.n(G(new H,this.Yj,this.bn))};
-f.Ou=function(a,b){var c=null,d=null,e=0;!!a.n(G(new H,this.Xj,this.an))!==b&&(c=this.Xj,d=this.an,e=1+e|0);!!a.n(G(new H,this.Yj,this.bn))!==b&&(0===e&&(c=this.Yj,d=this.bn),e=1+e|0);a=e;switch(a){case 0:return Jf();case 1:return new x9(c,d);case 2:return this;default:throw new x(a);}};
-f.y=function(){var a=0,b=0,c=1,d=fS(kL(),this.Xj,this.an);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=fS(kL(),this.Yj,this.bn);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=kL().Sq;d=kL().B(d,a);d=kL().B(d,b);d=kL().dp(d,c);return kL().La(d,2)};f.rj=function(a){return this.ev(a)};f.lm=function(a,b){return this.km(a,b)};f.$classData=q({S6:0},!1,"scala.collection.immutable.Map$Map2",{S6:1,jt:1,$l:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Ak:1,Uj:1,za:1,ja:1,dm:1,v:1,er:1,sc:1,pt:1,Ab:1,l:1});
-function E9(a,b,c,d,e,g){this.Yi=a;this.vl=b;this.Ei=c;this.Ek=d;this.Fi=e;this.Fk=g}E9.prototype=new i9;E9.prototype.constructor=E9;f=E9.prototype;f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.uk=function(a){return this.Ou(a,!1)};f.zb=function(a){return YY(this,a)};f.ka=function(){return 3};f.Q=function(){return 3};f.b=function(){return!1};
-f.n=function(a){if(Ol(Pl(),a,this.Yi))return this.vl;if(Ol(Pl(),a,this.Ei))return this.Ek;if(Ol(Pl(),a,this.Fi))return this.Fk;throw iH("key not found: "+a);};f.L=function(a){return Ol(Pl(),a,this.Yi)||Ol(Pl(),a,this.Ei)||Ol(Pl(),a,this.Fi)};f.Y=function(a){return Ol(Pl(),a,this.Yi)?new M(this.vl):Ol(Pl(),a,this.Ei)?new M(this.Ek):Ol(Pl(),a,this.Fi)?new M(this.Fk):R()};f.yd=function(a,b){return Ol(Pl(),a,this.Yi)?this.vl:Ol(Pl(),a,this.Ei)?this.Ek:Ol(Pl(),a,this.Fi)?this.Fk:Zr(b)};f.m=function(){return new N3(this)};
-f.oj=function(){return new O3(this)};f.Qd=function(){return new P3(this)};f.km=function(a,b){return Ol(Pl(),a,this.Yi)?new E9(this.Yi,b,this.Ei,this.Ek,this.Fi,this.Fk):Ol(Pl(),a,this.Ei)?new E9(this.Yi,this.vl,this.Ei,b,this.Fi,this.Fk):Ol(Pl(),a,this.Fi)?new E9(this.Yi,this.vl,this.Ei,this.Ek,this.Fi,b):new F9(this.Yi,this.vl,this.Ei,this.Ek,this.Fi,this.Fk,a,b)};
-f.ev=function(a){return Ol(Pl(),a,this.Yi)?new D9(this.Ei,this.Ek,this.Fi,this.Fk):Ol(Pl(),a,this.Ei)?new D9(this.Yi,this.vl,this.Fi,this.Fk):Ol(Pl(),a,this.Fi)?new D9(this.Yi,this.vl,this.Ei,this.Ek):this};f.ya=function(a){a.n(G(new H,this.Yi,this.vl));a.n(G(new H,this.Ei,this.Ek));a.n(G(new H,this.Fi,this.Fk))};f.il=function(a){return!!a.n(G(new H,this.Yi,this.vl))&&!!a.n(G(new H,this.Ei,this.Ek))&&!!a.n(G(new H,this.Fi,this.Fk))};
-f.Ou=function(a,b){var c=null,d=null,e=null,g=null,h=0;!!a.n(G(new H,this.Yi,this.vl))!==b&&(c=this.Yi,e=this.vl,h=1+h|0);!!a.n(G(new H,this.Ei,this.Ek))!==b&&(0===h?(c=this.Ei,e=this.Ek):(d=this.Ei,g=this.Ek),h=1+h|0);!!a.n(G(new H,this.Fi,this.Fk))!==b&&(0===h?(c=this.Fi,e=this.Fk):1===h&&(d=this.Fi,g=this.Fk),h=1+h|0);a=h;switch(a){case 0:return Jf();case 1:return new x9(c,e);case 2:return new D9(c,e,d,g);case 3:return this;default:throw new x(a);}};
-f.y=function(){var a=0,b=0,c=1,d=fS(kL(),this.Yi,this.vl);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=fS(kL(),this.Ei,this.Ek);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=fS(kL(),this.Fi,this.Fk);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=kL().Sq;d=kL().B(d,a);d=kL().B(d,b);d=kL().dp(d,c);return kL().La(d,3)};f.rj=function(a){return this.ev(a)};f.lm=function(a,b){return this.km(a,b)};
-f.$classData=q({W6:0},!1,"scala.collection.immutable.Map$Map3",{W6:1,jt:1,$l:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Ak:1,Uj:1,za:1,ja:1,dm:1,v:1,er:1,sc:1,pt:1,Ab:1,l:1});function F9(a,b,c,d,e,g,h,k){this.Jh=a;this.tj=b;this.mh=c;this.Zi=d;this.Qg=e;this.Gi=g;this.Rg=h;this.Hi=k}F9.prototype=new i9;F9.prototype.constructor=F9;f=F9.prototype;f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.uk=function(a){return this.Ou(a,!1)};f.zb=function(a){return YY(this,a)};f.ka=function(){return 4};
-f.Q=function(){return 4};f.b=function(){return!1};f.n=function(a){if(Ol(Pl(),a,this.Jh))return this.tj;if(Ol(Pl(),a,this.mh))return this.Zi;if(Ol(Pl(),a,this.Qg))return this.Gi;if(Ol(Pl(),a,this.Rg))return this.Hi;throw iH("key not found: "+a);};f.L=function(a){return Ol(Pl(),a,this.Jh)||Ol(Pl(),a,this.mh)||Ol(Pl(),a,this.Qg)||Ol(Pl(),a,this.Rg)};
-f.Y=function(a){return Ol(Pl(),a,this.Jh)?new M(this.tj):Ol(Pl(),a,this.mh)?new M(this.Zi):Ol(Pl(),a,this.Qg)?new M(this.Gi):Ol(Pl(),a,this.Rg)?new M(this.Hi):R()};f.yd=function(a,b){return Ol(Pl(),a,this.Jh)?this.tj:Ol(Pl(),a,this.mh)?this.Zi:Ol(Pl(),a,this.Qg)?this.Gi:Ol(Pl(),a,this.Rg)?this.Hi:Zr(b)};f.m=function(){return new Q3(this)};f.oj=function(){return new R3(this)};f.Qd=function(){return new S3(this)};
-f.km=function(a,b){return Ol(Pl(),a,this.Jh)?new F9(this.Jh,b,this.mh,this.Zi,this.Qg,this.Gi,this.Rg,this.Hi):Ol(Pl(),a,this.mh)?new F9(this.Jh,this.tj,this.mh,b,this.Qg,this.Gi,this.Rg,this.Hi):Ol(Pl(),a,this.Qg)?new F9(this.Jh,this.tj,this.mh,this.Zi,this.Qg,b,this.Rg,this.Hi):Ol(Pl(),a,this.Rg)?new F9(this.Jh,this.tj,this.mh,this.Zi,this.Qg,this.Gi,this.Rg,b):a7(a7(a7(a7(a7(Xy().br,this.Jh,this.tj),this.mh,this.Zi),this.Qg,this.Gi),this.Rg,this.Hi),a,b)};
-f.ev=function(a){return Ol(Pl(),a,this.Jh)?new E9(this.mh,this.Zi,this.Qg,this.Gi,this.Rg,this.Hi):Ol(Pl(),a,this.mh)?new E9(this.Jh,this.tj,this.Qg,this.Gi,this.Rg,this.Hi):Ol(Pl(),a,this.Qg)?new E9(this.Jh,this.tj,this.mh,this.Zi,this.Rg,this.Hi):Ol(Pl(),a,this.Rg)?new E9(this.Jh,this.tj,this.mh,this.Zi,this.Qg,this.Gi):this};f.ya=function(a){a.n(G(new H,this.Jh,this.tj));a.n(G(new H,this.mh,this.Zi));a.n(G(new H,this.Qg,this.Gi));a.n(G(new H,this.Rg,this.Hi))};
-f.il=function(a){return!!a.n(G(new H,this.Jh,this.tj))&&!!a.n(G(new H,this.mh,this.Zi))&&!!a.n(G(new H,this.Qg,this.Gi))&&!!a.n(G(new H,this.Rg,this.Hi))};
-f.Ou=function(a,b){var c=null,d=null,e=null,g=null,h=null,k=null,l=0;!!a.n(G(new H,this.Jh,this.tj))!==b&&(c=this.Jh,g=this.tj,l=1+l|0);!!a.n(G(new H,this.mh,this.Zi))!==b&&(0===l?(c=this.mh,g=this.Zi):(d=this.mh,h=this.Zi),l=1+l|0);!!a.n(G(new H,this.Qg,this.Gi))!==b&&(0===l?(c=this.Qg,g=this.Gi):1===l?(d=this.Qg,h=this.Gi):(e=this.Qg,k=this.Gi),l=1+l|0);!!a.n(G(new H,this.Rg,this.Hi))!==b&&(0===l?(c=this.Rg,g=this.Hi):1===l?(d=this.Rg,h=this.Hi):2===l&&(e=this.Rg,k=this.Hi),l=1+l|0);a=l;switch(a){case 0:return Jf();
-case 1:return new x9(c,g);case 2:return new D9(c,g,d,h);case 3:return new E9(c,g,d,h,e,k);case 4:return this;default:throw new x(a);}};f.y=function(){var a=0,b=0,c=1,d=fS(kL(),this.Jh,this.tj);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=fS(kL(),this.mh,this.Zi);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=fS(kL(),this.Qg,this.Gi);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=fS(kL(),this.Rg,this.Hi);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=kL().Sq;d=kL().B(d,a);d=kL().B(d,b);d=kL().dp(d,c);return kL().La(d,4)};f.rj=function(a){return this.ev(a)};
-f.lm=function(a,b){return this.km(a,b)};f.$classData=q({$6:0},!1,"scala.collection.immutable.Map$Map4",{$6:1,jt:1,$l:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Ak:1,Uj:1,za:1,ja:1,dm:1,v:1,er:1,sc:1,pt:1,Ab:1,l:1});function G9(a,b){return new H9(a,new z(()=>b))}function Faa(a){return I9(new J9,a,new z(()=>0))}function K9(a,b){return a.nd===b?a:new aV(b)}
-function L9(a,b){b=b.m();for(var c=a.nd;b.s();){var d=b.t(),e=dy(W(),d),g=HG(JG(),e);c=FU(c,d,e,g,0);if(c!==a.nd){if(0===c.Fb)return fV().Zn;for(;b.s();)if(a=b.t(),d=dy(W(),a),e=HG(JG(),d),GU(c,a,d,e),0===c.Fb)return fV().Zn;return new aV(c)}}return a}function aV(a){this.nd=a}aV.prototype=new U8;aV.prototype.constructor=aV;f=aV.prototype;f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.Ob=function(){return fV()};f.Q=function(){return this.nd.Fb};f.ka=function(){return this.nd.Fb};
-f.b=function(){return 0===this.nd.Fb};f.m=function(){return this.b()?qq().Oa:new n1(this.nd)};f.L=function(a){var b=dy(W(),a),c=HG(JG(),b);return this.nd.Rs(a,b,c,0)};function t9(a,b){var c=dy(W(),b),d=HG(JG(),c);b=AU(a.nd,b,c,d,0);return K9(a,b)}
-function Fea(a,b){if(b instanceof aV){if(a.b())return b;var c=LU(a.nd,b.nd,0);return c===b.nd?b:K9(a,c)}if(b instanceof MV)for(b=new u4(b),c=a.nd;b.s();){var d=b.t(),e=w4(d.ck),g=HG(JG(),e);c=AU(c,d.Lk,e,g,0);if(c!==a.nd){for(a=VH(pH(),UH(pH(),g,0));b.s();)d=b.t(),e=w4(d.ck),g=HG(JG(),e),a=DU(c,d.Lk,e,g,0,a);return new aV(c)}}else for(b=b.m(),c=a.nd;b.s();)if(d=b.t(),e=dy(W(),d),g=HG(JG(),e),c=AU(c,d,e,g,0),c!==a.nd){for(a=VH(pH(),UH(pH(),g,0));b.s();)d=b.t(),e=dy(W(),d),g=HG(JG(),e),a=DU(c,d,e,g,
-0,a);return new aV(c)}return a}f.e=function(){return this.m().t()};f.Fc=function(){return(new o1(this.nd)).t()};f.ya=function(a){this.nd.ya(a)};f.h=function(a){if(a instanceof aV){if(this===a)return!0;var b=this.nd;a=a.nd;return null===b?null===a:b.h(a)}return d7(this,a)};f.xh=function(){return"HashSet"};f.y=function(){var a=new m1(this.nd);return lL(kL(),a,kL().qB)};
-function Gea(a,b){if(a.b())return a;if(b instanceof aV)return b.b()?a:0===JU(a.nd,b.nd,0).Fb?fV().Zn:K9(a,JU(a.nd,b.nd,0));if(b instanceof MV){for(var c=new u4(b),d=a.nd;c.s();){var e=c.t(),g=w4(e.ck),h=HG(JG(),g);d=FU(d,e.Lk,g,h,0);if(d!==a.nd){if(0===d.Fb)return fV().Zn;for(;c.s();)if(a=c.t(),e=w4(a.ck),g=HG(JG(),e),GU(d,a.Lk,e,g),0===d.Fb)return fV().Zn;return new aV(d)}}return a}c=b.Q();return 0===c?a:c<=a.nd.Fb?L9(a,b):M9(a,new z(k=>b.L(k)),!0)}
-function Hea(a,b){return b&&b.$classData&&b.$classData.pb.Vj?Gea(a,b):b instanceof rZ&&b.K()>a.nd.Fb?M9(a,new z(c=>oa(c)?!QA(b,c|0):!0),!1):L9(a,b)}function M9(a,b,c){b=IU(a.nd,b,c);return b===a.nd?a:0===b.Fb?fV().Zn:new aV(b)}f.zb=function(a){return YY(this,a)};f.Cc=function(a){return BT(this,a)};f.Zx=function(a){return Hea(this,a)};f.af=function(a){return Fea(this,a)};f.tk=function(a){var b=dy(W(),a),c=HG(JG(),b);a=FU(this.nd,a,b,c,0);return K9(this,a)};f.Yb=function(a){return t9(this,a)};
-f.$classData=q({v6:0},!1,"scala.collection.immutable.HashSet",{v6:1,Vq:1,am:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Vj:1,sl:1,ja:1,v:1,tp:1,sc:1,gr:1,$7:1,D5:1,Ab:1,jg:1,l:1});function N9(){}N9.prototype=new k8;N9.prototype.constructor=N9;function O9(){}f=O9.prototype=N9.prototype;f.eh=function(a){this.L(a)?a=!1:(this.S(a),a=!0);return a};
-f.mJ=function(a){if(!this.b()){KH();if(0<=this.Q()){var b=this.Q();b=new jd(b);this.yc(b,0,2147483647)}else{b=[];for(var c=this.m();c.s();){var d=c.t();b.push(null===d?null:d)}b=new jd(b)}c=b.a.length;for(d=0;d<c;){var e=b.a[d];a.n(e)||this.im(e);d=1+d|0}}};f.Pd=function(){};f.oc=function(a){return cR(this,a)};f.Eb=function(){return this};
-var Jea=function Iea(a,b){oK();return new eZ(new U(()=>{if(a.b())return jV();oK();var d=b.n(fZ(a).e()),e=Iea(fZ(a).Cf(),b);return new gV(d,e)}))},Lea=function Kea(a,b){if(b.b())return jV();oK();var d=fZ(a).e();oK();return new gV(d,new eZ(new U(()=>Kea(fZ(a).Cf(),fZ(b).Cf()))))};
-function P9(a,b,c,d,e){b.ha=""+b.ha+c;if(!a.tl)b.ha+="\x3cnot computed\x3e";else if(!a.b()){c=fZ(a).e();b.ha=""+b.ha+c;c=a;var g=fZ(a).Cf();if(c!==g&&(!g.tl||fZ(c)!==fZ(g))&&(c=g,g.tl&&!g.b()))for(g=fZ(g).Cf();c!==g&&g.tl&&!g.b()&&fZ(c)!==fZ(g);){b.ha=""+b.ha+d;var h=fZ(c).e();b.ha=""+b.ha+h;c=fZ(c).Cf();g=fZ(g).Cf();g.tl&&!g.b()&&(g=fZ(g).Cf())}if(!g.tl||g.b()){for(;c!==g;)b.ha=""+b.ha+d,a=fZ(c).e(),b.ha=""+b.ha+a,c=fZ(c).Cf();c.tl||(b.ha=""+b.ha+d,b.ha+="\x3cnot computed\x3e")}else{h=a;for(a=0;;){var k=
-h,l=g;if(k!==l&&fZ(k)!==fZ(l))h=fZ(h).Cf(),g=fZ(g).Cf(),a=1+a|0;else break}h=c;k=g;(h===k||fZ(h)===fZ(k))&&0<a&&(b.ha=""+b.ha+d,a=fZ(c).e(),b.ha=""+b.ha+a,c=fZ(c).Cf());for(;;)if(a=c,h=g,a!==h&&fZ(a)!==fZ(h))b.ha=""+b.ha+d,a=fZ(c).e(),b.ha=""+b.ha+a,c=fZ(c).Cf();else break;b.ha=""+b.ha+d;b.ha+="\x3ccycle\x3e"}}b.ha=""+b.ha+e;return b}function eZ(a){this.WR=null;this.qL=!1;this.VR=a;this.rL=this.tl=!1}eZ.prototype=new a9;eZ.prototype.constructor=eZ;f=eZ.prototype;f.Hc=function(){return"LinearSeq"};
-f.Og=function(){return this.b()?R():new M(this.e())};f.K=function(){for(var a=this,b=0;!a.b();)b=1+b|0,a=a.g();return b};f.Fc=function(){if(this.b())throw iH("LinearSeq.last");for(var a=this,b=this.g();!b.b();)a=b,b=b.g();return a.e()};f.$a=function(a){if(0>a)a=1;else a:for(var b=this,c=0;;){if(c===a){a=b.b()?0:1;break a}if(b.b()){a=-1;break a}c=1+c|0;b=b.g()}return a};f.vJ=function(a){return u0(this,a)};f.ua=function(a){return FA(this,a)};
-f.Ln=function(a){a:{for(var b=this;!b.b();){if(a.n(b.e())){a=!0;break a}b=b.g()}a=!1}return a};f.L=function(a){a:{for(var b=this;!b.b();){if(Ol(Pl(),b.e(),a)){a=!0;break a}b=b.g()}a=!1}return a};f.dt=function(a){return v0(this,a)};f.Rn=function(a,b){return w0(this,a,b)};function fZ(a){if(!a.qL&&!a.qL){if(a.rL)throw SK("self-referential LazyList or a derivation thereof has no more elements");a.rL=!0;try{var b=Zr(a.VR)}finally{a.rL=!1}a.tl=!0;a.VR=null;a.WR=b;a.qL=!0}return a.WR}
-f.b=function(){return fZ(this)===jV()};f.Q=function(){return this.tl&&this.b()?0:-1};f.e=function(){return fZ(this).e()};function dZ(a){var b=a,c=a;for(b.b()||(b=fZ(b).Cf());c!==b&&!b.b();){b=fZ(b).Cf();if(b.b())break;b=fZ(b).Cf();if(b===c)break;c=fZ(c).Cf()}return a}f.m=function(){return this.tl&&this.b()?qq().Oa:new M0(this)};f.ya=function(a){for(var b=this;!b.b();)a.n(fZ(b).e()),b=fZ(b).Cf()};f.ge=function(a,b){for(var c=this;;){if(c.b())return a;var d=fZ(c).Cf();a=b.aa(a,fZ(c).e());c=d}};
-f.xh=function(){return"LazyList"};function Q9(a,b){oK();return new eZ(new U(()=>{if(a.b()){var c=Zr(b);return c instanceof eZ?fZ(c):0===c.Q()?jV():gZ(oK(),c.m())}oK();c=fZ(a).e();var d=Q9(fZ(a).Cf(),b);return new gV(c,d)}))}function Mea(a,b){return a.tl&&a.b()?cU(oK(),b):Q9(a,new U(()=>b))}f.Bi=function(a){if(this.b())throw Fu("empty.reduceLeft");for(var b=fZ(this).e(),c=fZ(this).Cf();!c.b();)b=a.aa(b,fZ(c).e()),c=fZ(c).Cf();return b};
-function Nea(a,b){oK();return new eZ(new U(()=>{oK();return new gV(b,a)}))}function R9(a,b){return a.tl&&a.b()?oK().uy:Jea(a,b)}f.Gb=function(a){return G(new H,R9(this,new z(b=>a.n(b).i())),R9(this,new z(b=>a.n(b).j())))};function Oea(a,b){if(0>=b)return a;if(a.tl&&a.b())return oK().uy;oK();return new eZ(new U(()=>{for(var c=a,d=b;0<d&&!c.b();)d=-1+d|0,c=fZ(c).Cf();return Lea(a,c)}))}f.vh=function(a,b,c,d){dZ(this);P9(this,a.mf,b,c,d);return a};
-f.u=function(){return P9(this,tq(new rq,"LazyList"),"(",", ",")").ha};f.n=function(a){return FA(this,a|0)};f.Ec=function(a){return u0(this,a|0)};f.zb=function(a){return Oea(this,a)};f.Cc=function(a){return 0>=a?this:this.tl&&this.b()?oK().uy:wda(oK(),this,a)};f.Ga=function(a){return R9(this,a)};f.Zb=function(a){return Nea(this,a)};f.Hm=function(a){return Mea(this,a)};f.g=function(){return fZ(this).Cf()};f.Ob=function(){return oK()};
-f.$classData=q({C6:0},!1,"scala.collection.immutable.LazyList",{C6:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,sL:1,gG:1,AR:1,XR:1,l:1});function Uq(a){this.Nh=a}Uq.prototype=new a9;Uq.prototype.constructor=Uq;f=Uq.prototype;f.E=function(a){return l9(this,a)};f.Hc=function(){return"IndexedSeq"};f.m=function(){return Vq(new Wq,new Xq(this.Nh))};f.Ad=function(){return sZ(new tZ,new Xq(this.Nh))};f.we=function(a,b){return b0(this,a,b)};f.Rc=function(){return new Q8(this)};
-f.Zb=function(a){return c0(this,a)};f.Cc=function(a){return f0(this,a)};f.zb=function(a){return this.qc(O8(new P8,this,a))};f.Ga=function(a){return i0(this,a)};f.e=function(){return hd(this.Nh.charCodeAt(0))};f.Fc=function(){return zF(this)};f.$a=function(a){var b=this.Nh.length;return b===a?0:b<a?-1:1};f.Q=function(){return this.Nh.length};f.hi=function(){return BZ().Db()};f.K=function(){return this.Nh.length};f.u=function(){return this.Nh};
-f.yc=function(a,b,c){if(a instanceof td){var d=this.Nh.length;c=c<d?c:d;d=a.a.length-b|0;c=c<d?c:d;c=0<c?c:0;A2(this.Nh,c,a,b);return c}return NG(this,a,b,c)};f.dt=function(a){return a instanceof Uq?this.Nh===a.Nh:m9(this,a)};f.xh=function(){return"WrappedString"};f.Ix=function(){return 2147483647};f.h=function(a){return a instanceof Uq?this.Nh===a.Nh:Z2(this,a)};f.Ob=function(){return Pe()};f.Hm=function(a){return a instanceof Uq?new Uq(this.Nh+a.Nh):KT(this,a)};f.qc=function(a){return AZ(BZ(),a)};
-f.vk=function(a){return AZ(BZ(),a)};f.n=function(a){return hd(this.Nh.charCodeAt(a|0))};f.ua=function(a){return hd(this.Nh.charCodeAt(a))};f.$classData=q({u8:0},!1,"scala.collection.immutable.WrappedString",{u8:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,l:1});function J(a,b){a.KL=b;return a}function L(){this.KL=null}L.prototype=new p;L.prototype.constructor=L;f=L.prototype;f.zi=function(a){return Ix(this,a)};
-f.Ph=function(a){return Fv(this,a)};f.Zb=function(a){return v3(this,a)};f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.zb=function(a){return YY(this,a)};f.E=function(a){return l9(this,a)};f.dt=function(a){return m9(this,a)};f.Ix=function(){AH||(AH=new zH);return AH.TR};f.m=function(){var a=new $X(this);return Vq(new Wq,a)};f.Ad=function(){var a=new $X(this);return sZ(new tZ,a)};f.we=function(a,b){return b0(this,a,b)};f.Rc=function(){return new Q8(this)};
-f.Cc=function(a){return f0(this,a)};f.e=function(){return this.ua(0)};f.Fc=function(){return zF(this)};f.$a=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.hC=function(){return this};f.h=function(a){return Z2(this,a)};f.y=function(){return gS(this)};f.u=function(){return l0(this)};f.hl=function(a){return w3(this,a)};f.ka=function(){return this.K()};f.Rn=function(a,b){var c=new $X(this);c=Vq(new Wq,c);return NT(c,a,b)};f.L=function(a){return SU(this,a)};
-f.Pk=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.b=function(){return QY(this)};f.Nb=function(a,b){return xQ(this,a,b)};f.hi=function(){return z2().Db()};f.g=function(){return ET(this)};f.ya=function(a){KG(this,a)};f.Ln=function(a){return Cx(this,a)};f.ge=function(a,b){return NA(this,a,b)};f.Bi=function(a){return MG(this,a)};f.yc=function(a,b,c){return NG(this,a,b,c)};f.Ui=function(a){return PG(this,a)};f.Ti=function(a){return QG(this,a)};f.vh=function(a,b,c,d){return RG(this,a,b,c,d)};
-f.ea=function(){je();return le(v(),this)};f.Li=function(){return bp(cp(),this)};f.vj=function(a){return LA(this,a)};f.yk=function(){return z2()};f.K=function(){return this.KL.length|0};f.ua=function(a){return this.KL[a]};f.xh=function(){return"WrappedVarArgs"};f.qc=function(a){return x2(z2(),a)};f.Ec=function(a){a|=0;return 0<=a&&0<this.$a(a)};f.n=function(a){return this.ua(a|0)};f.Ob=function(){return z2()};
-f.$classData=q({p$:0},!1,"scala.scalajs.runtime.WrappedVarArgs",{p$:1,d:1,Ih:1,Dg:1,sc:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Sg:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,l:1});function VU(a){this.$b=a}VU.prototype=new i9;VU.prototype.constructor=VU;f=VU.prototype;f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.uk=function(a){a=uU(this.$b,a,!1);return a===this.$b?this:0===a.bd?Xy().br:new VU(a)};f.pj=function(){return Xy()};f.Q=function(){return this.$b.bd};f.ka=function(){return this.$b.bd};
-f.b=function(){return 0===this.$b.bd};f.$s=function(){return 0===this.$b.bd?Wp():new B9(this)};f.m=function(){return this.b()?qq().Oa:new $0(this.$b)};f.oj=function(){return this.b()?qq().Oa:new Y0(this.$b)};f.Qd=function(){return this.b()?qq().Oa:new b1(this.$b)};f.Ad=function(){return this.b()?qq().Oa:new a1(this.$b)};f.L=function(a){var b=dy(W(),a),c=HG(JG(),b);return this.$b.fF(a,b,c,0)};f.n=function(a){var b=dy(W(),a),c=HG(JG(),b);return this.$b.iJ(a,b,c,0)};
-f.Y=function(a){var b=dy(W(),a),c=HG(JG(),b);return this.$b.mF(a,b,c,0)};f.yd=function(a,b){var c=dy(W(),a),d=HG(JG(),c);return this.$b.sJ(a,c,d,0,b)};function a7(a,b,c){var d=dy(W(),b);b=kU(a.$b,b,c,d,HG(JG(),d),0,!0);return b===a.$b?a:new VU(b)}function C9(a,b){var c=dy(W(),b);b=pU(a.$b,b,c,HG(JG(),c),0);return b===a.$b?a:new VU(b)}
-function Pea(a,b){if(b instanceof VU){if(a.b()||sU(a.$b,b.$b,0)===b.$b)return b;b=sU(a.$b,b.$b,0);return b===a.$b?a:new VU(b)}if(b instanceof FV){b=H0(b);for(var c=a.$b;b.s();){var d=b.t(),e=d.bk;e^=e>>>16|0;var g=HG(JG(),e);c=kU(c,d.Kk,d.ph,e,g,0,!0);if(c!==a.$b){for(a=VH(pH(),UH(pH(),g,0));b.s();)d=b.t(),e=d.bk,e^=e>>>16|0,a=nU(c,d.Kk,d.ph,e,HG(JG(),e),0,a);return new VU(c)}}return a}if(lV(b)){if(b.b())return a;c=new ZY(a);b.Ag(c);b=c.xv;return b===a.$b?a:new VU(b)}b=b.m();return b.s()?(c=new ZY(a),
-KG(b,c),b=c.xv,b===a.$b?a:new VU(b)):a}f.ya=function(a){this.$b.ya(a)};f.Ag=function(a){this.$b.Ag(a)};f.h=function(a){if(a instanceof VU){if(this===a)return!0;var b=this.$b;a=a.$b;return null===b?null===a:b.h(a)}return l8(this,a)};f.y=function(){if(this.b())return kL().RF;var a=new Z0(this.$b);return lL(kL(),a,kL().Sq)};f.xh=function(){return"HashMap"};
-function Qea(a,b){if(a.b())return a;if(b instanceof aV){if(b.b())return a;b=new PQ(b.nd);for(var c=a.$b;0<c.bd&&b.s();){var d=b.lh.Jb(b.Gc),e=b.lh.Yc(b.Gc),g=HG(JG(),d);c=pU(c,e,d,g,0);b.Gc=1+b.Gc|0}b=c;return b===a.$b?a:0>=b.bd?Xy().br:new VU(b)}if(b instanceof MV){if(b.b())return a;b=new u4(b);for(d=a.$b;b.s();)if(c=b.t(),e=w4(c.ck),g=HG(JG(),e),d=pU(d,c.Lk,e,g,0),0===d.bd)return Xy().br;b=d;return b===a.$b?a:new VU(b)}b=b.m();for(d=a.$b;b.s();)if(c=b.t(),e=dy(W(),c),g=HG(JG(),e),d=pU(d,c,e,g,0),
-0===d.bd)return Xy().br;b=d;return b===a.$b?a:new VU(b)}f.Cc=function(a){return BT(this,a)};f.zb=function(a){return YY(this,a)};f.IF=function(a){return Qea(this,a)};f.Fc=function(){return this.Ad().t()};f.e=function(){return this.m().t()};f.Ol=function(a){return Pea(this,a)};f.rj=function(a){return C9(this,a)};f.kC=function(a,b){return o5(this,a,b)};f.lm=function(a,b){return a7(this,a,b)};f.Pq=function(){return this.$s()};
-f.$classData=q({p6:0},!1,"scala.collection.immutable.HashMap",{p6:1,jt:1,$l:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Ak:1,Uj:1,za:1,ja:1,dm:1,v:1,er:1,sc:1,pt:1,Z7:1,vG:1,Ab:1,jg:1,l:1});function S9(){}S9.prototype=new v9;S9.prototype.constructor=S9;function T9(){}T9.prototype=S9.prototype;S9.prototype.oc=function(a){return cR(this,a)};function U9(){}U9.prototype=new v8;U9.prototype.constructor=U9;function V9(){}f=V9.prototype=U9.prototype;f.pj=function(){return ru()};
-f.TL=function(a){return I9(new J9,this,a)};f.Vi=function(a,b){this.Y(a);this.Qh(a,b)};f.Qh=function(a,b){a=G(new H,a,b);this.S(a)};f.Gt=function(a,b){return F8(this,a,b)};f.Ai=function(a,b){return G8(this,a,b)};f.lB=function(a){this.Y(a).b()||this.im(a)};f.Pd=function(){};f.oc=function(a){return cR(this,a)};f.Ob=function(){return iO()};f.Eb=function(){return this};function W9(a){this.co=null;if(null===a)throw null;this.co=a}W9.prototype=new U8;W9.prototype.constructor=W9;f=W9.prototype;f.Wd=function(){return this.co.Wd()};
-f.m=function(){return new x0(this.co)};f.L=function(a){return!this.co.Y(a).b()};f.ka=function(){return this.co.ka()};f.Q=function(){return this.co.Q()};f.b=function(){return this.co.b()};f.Hc=function(){return"SortedSet"};f.h=function(a){return E8(this,a)};f.Ui=function(a){return k5(this,a)};f.Ti=function(a){return l5(this,a)};f.qc=function(a){return Rz(Mu(),a,this.co.Wd())};f.vk=function(a){return Rz(Mu(),a,this.co.Wd())};f.tk=function(a){return Rz(Mu(),this,this.co.Wd()).tk(a)};
-f.Yb=function(a){return Rz(Mu(),this,this.co.Wd()).Yb(a)};f.$classData=q({W7:0},!1,"scala.collection.immutable.SortedMapOps$ImmutableKeySortedSet",{W7:1,Vq:1,am:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Vj:1,sl:1,ja:1,v:1,tp:1,sc:1,gr:1,wL:1,tG:1,NR:1,ly:1,MR:1,Y7:1,vB:1,x5:1});
-function X9(a,b,c){var d=c&(-1+a.Af.a.length|0),e=a.Af.a[d];if(null===e)a.Af.a[d]=new MJ(b,c,null);else{for(var g=null,h=e;null!==h&&h.ck<=c;){if(h.ck===c&&Ol(Pl(),b,h.Lk))return!1;g=h;h=h.He}null===g?a.Af.a[d]=new MJ(b,c,e):g.He=new MJ(b,c,g.He)}a.uj=1+a.uj|0;return!0}
-function Y9(a,b){var c=a.Af.a.length;a.GL=Mc(b*a.MG);if(0===a.uj)a.Af=new (Nd(NJ).Ja)(b);else{var d=a.Af;a.Af=Tj(fk(),d,b);d=new MJ(null,0,null);for(var e=new MJ(null,0,null);c<b;){for(var g=0;g<c;){var h=a.Af.a[g];if(null!==h){d.He=null;e.He=null;for(var k=d,l=e,m=h;null!==m;){var n=m.He;0===(m.ck&c)?k=k.He=m:l=l.He=m;m=n}k.He=null;h!==d.He&&(a.Af.a[g]=d.He);null!==e.He&&(a.Af.a[g+c|0]=e.He,l.He=null)}g=1+g|0}c<<=1}}}
-function Z9(a){a=-1+a|0;a=4<a?a:4;a=(-2147483648>>Math.clz32(a)&a)<<1;return 1073741824>a?a:1073741824}function LV(a,b,c){a.MG=c;a.Af=new (Nd(NJ).Ja)(Z9(b));a.GL=Mc(a.Af.a.length*a.MG);a.uj=0;return a}function Gn(){var a=new MV;LV(a,16,.75);return a}function MV(){this.MG=0;this.Af=null;this.uj=this.GL=0}MV.prototype=new O9;MV.prototype.constructor=MV;f=MV.prototype;f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.zb=function(a){return YY(this,a)};f.ka=function(){return this.uj};
-function w4(a){return a^(a>>>16|0)}f.L=function(a){var b=w4(dy(W(),a)),c=this.Af.a[b&(-1+this.Af.a.length|0)];if(null===c)a=null;else a:for(;;){if(b===c.ck&&Ol(Pl(),a,c.Lk)){a=c;break a}if(null===c.He||c.ck>b){a=null;break a}c=c.He}return null!==a};f.Pd=function(a){a=Z9(Mc((1+a|0)/this.MG));a>this.Af.a.length&&Y9(this,a)};f.eh=function(a){(1+this.uj|0)>=this.GL&&Y9(this,this.Af.a.length<<1);return X9(this,a,w4(dy(W(),a)))};
-function KV(a,b){a.Pd(b.Q());if(b instanceof aV)return b.nd.nJ(new Um((d,e)=>{X9(a,d,w4(e|0))})),a;if(b instanceof MV){for(b=new u4(b);b.s();){var c=b.t();X9(a,c.Lk,c.ck)}return a}return cR(a,b)}f.HF=function(a){a:{var b=w4(dy(W(),a)),c=b&(-1+this.Af.a.length|0),d=this.Af.a[c];if(null!==d)if(d.ck===b&&Ol(Pl(),d.Lk,a))this.Af.a[c]=d.He,this.uj=-1+this.uj|0;else for(c=d,d=d.He;null!==d&&d.ck<=b;){if(d.ck===b&&Ol(Pl(),d.Lk,a)){c.He=d.He;this.uj=-1+this.uj|0;break a}c=d;d=d.He}}};f.m=function(){return new t4(this)};
-f.eg=function(){var a=this.Af;Sj(fk(),a,null);this.uj=0};f.Ob=function(){return Hy()};f.Q=function(){return this.uj};f.b=function(){return 0===this.uj};f.ya=function(a){for(var b=this.Af.a.length,c=0;c<b;){var d=this.Af.a[c];null!==d&&d.ya(a);c=1+c|0}};f.xh=function(){return"HashSet"};f.y=function(){var a=new t4(this);a=a.s()?new v4(this):a;return lL(kL(),a,kL().qB)};f.im=function(a){this.HF(a)};f.S=function(a){this.eh(a);return this};
-f.mJ=function(a){if(!this.b())for(var b=0;b<this.Af.a.length;){for(var c=this.Af.a[b];null!==c&&!a.n(c.Lk);)c=c.He,this.uj=-1+this.uj|0;if(null!==c)for(var d=c,e=c.He;null!==e;)a.n(e.Lk)?d=e:(d.He=e.He,this.uj=-1+this.uj|0),e=e.He;this.Af.a[b]=c;b=1+b|0}};f.oc=function(a){return KV(this,a)};f.$classData=q({h9:0},!1,"scala.collection.mutable.HashSet",{h9:1,w8:1,am:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Vj:1,sl:1,ja:1,v:1,U9:1,Vg:1,W9:1,Ug:1,vf:1,og:1,lf:1,kf:1,nn:1,Ab:1,l:1});
-function $9(a){var b=a.Gk,c=b>>31,d=a.Dd;a=d>>31;d=b-d|0;return new fb(d,(-2147483648^d)>(-2147483648^b)?-1+(c-a|0)|0:c-a|0)}function a$(a){var b=$9(a),c=a.fc,d=c>>31;a=Cb();b=bj(a,b.W,b.Z,c,d);a=a.Kc;return 0===b&&0===a}
-function b$(a,b,c,d){a.Dd=b;a.Gk=c;a.fc=d;a.$i=b>c&&0<d||b<c&&0>d||b===c&&!a.Km();if(0===d)throw dk("step cannot be 0.");if(a.$i)b=0;else{b=$9(a);var e=a.fc,g=e>>31;var h=Cb();b=ki(h,b.W,b.Z,e,g);h=h.Kc;g=a.Km()||!a$(a)?1:0;e=g>>31;g=b+g|0;h=new fb(g,(-2147483648^g)<(-2147483648^b)?1+(h+e|0)|0:h+e|0);b=h.W;h=h.Z;b=(0===h?-1<(-2147483648^b):0<h)?-1:b}a.Hk=b;switch(d){case 1:c=a.Km()?c:-1+c|0;break;case -1:c=a.Km()?c:1+c|0;break;default:b=$9(a),h=d>>31,b=bj(Cb(),b.W,b.Z,d,h),c=0!==b?c-b|0:a.Km()?c:
-c-d|0}a.Fv=c}function rZ(){this.fc=this.Gk=this.Dd=0;this.$i=!1;this.Fv=this.Hk=0}rZ.prototype=new a9;rZ.prototype.constructor=rZ;function c$(){}f=c$.prototype=rZ.prototype;f.zi=function(a){return Ix(this,a)};f.Zb=function(a){return v3(this,a)};f.Hm=function(a){return w3(this,a)};f.Gb=function(a){return VY(this,a)};f.E=function(a){return l9(this,a)};f.yk=function(){return Pe()};f.Hc=function(){return"IndexedSeq"};f.Ad=function(){var a=new $X(this);return sZ(new tZ,a)};
-f.we=function(a,b){return b0(this,a,b)};f.Rc=function(){return new Q8(this)};f.$a=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.m=function(){return new BD(this.Dd,this.fc,this.Fv,this.$i)};f.b=function(){return this.$i};f.K=function(){return 0>this.Hk?RQ(TQ(),this.Dd,this.Gk,this.fc,this.Km()):this.Hk};function d$(a){if(a.$i)throw a=SQ("last"),a instanceof pe?a.Dt:a;return a.Fv}function e$(a){if(a.$i)throw a=SQ("head"),a instanceof pe?a.Dt:a;return a.Dd}
-function f$(a){0>a.Hk&&RQ(TQ(),a.Dd,a.Gk,a.fc,a.Km())}f.ya=function(a){if(!this.$i)for(var b=this.Dd;;){a.n(b);if(b===this.Fv)break;b=b+this.fc|0}};f.dt=function(a){if(a instanceof rZ){var b=this.K();switch(b){case 0:return a.$i;case 1:return 1===a.K()&&this.Dd===a.Dd;default:return a.K()===b&&this.Dd===a.Dd&&this.fc===a.fc}}else return m9(this,a)};
-function Rea(a,b){if(0>=b)return a;if(0<=a.Hk)return b=a.Hk-b|0,0>=b||a.$i?(b=a.Dd,a=new PA(b,b,a.fc)):a=b>=a.Hk&&0<=a.Hk?a:new g$(a.Dd,a.Dd+Math.imul(a.fc,-1+b|0)|0,a.fc),a;b=d$(a)-Math.imul(a.fc,b)|0;return 0<a.fc&&b<a.Dd||0>a.fc&&b>a.Dd?(b=a.Dd,new PA(b,b,a.fc)):new g$(a.Dd,b,a.fc)}function QA(a,b){return!(b===a.Gk&&!a.Km())&&(0<a.fc?!(b<a.Dd||b>a.Gk)&&(1===a.fc||0===Kc(b-a.Dd|0,a.fc)):!(b<a.Gk||b>a.Dd)&&(-1===a.fc||0===Kc(b-a.Dd|0,a.fc)))}f.L=function(a){return oa(a)?QA(this,a|0):SU(this,a)};
-f.Ix=function(){return 2147483647};f.h=function(a){if(a instanceof rZ){if(this.$i)return a.$i;if(a.$i||this.Dd!==a.Dd)return!1;var b=d$(this);return b===d$(a)&&(this.Dd===b||this.fc===a.fc)}return Z2(this,a)};f.y=function(){if(2<=this.K()){var a=kL(),b=this.fc,c=this.Fv;return hL(a.B(a.B(a.B(a.ig,this.Dd),b),c))}return gS(this)};f.u=function(){var a=this.Km()?"to":"until",b=1===this.fc?"":" by "+this.fc;return(this.$i?"empty ":a$(this)?"":"inexact ")+"Range "+this.Dd+" "+a+" "+this.Gk+b};f.xh=function(){return"Range"};
-f.Ps=function(a){f$(this);if(0>a||a>=this.Hk)throw KK(new LK,a+" is out of bounds (min 0, max "+(-1+this.Hk|0)+")");return this.Dd+Math.imul(this.fc,a)|0};f.Ob=function(){return Pe()};f.Ph=function(a){return a===dq()?0<this.fc?this:this.$i?this:new g$(d$(this),this.Dd,-this.fc|0):Fv(this,a)};f.Ti=function(a){if(a===dq())a=0<this.fc?d$(this):e$(this);else{var b=dq();a=a===b.oB?0<this.fc?e$(this):d$(this):QG(this,a)|0}return a};
-f.Ui=function(a){if(a===dq())a=0<this.fc?e$(this):d$(this);else{var b=dq();a=a===b.oB?0<this.fc?d$(this):e$(this):PG(this,a)|0}return a};f.zb=function(a){return Rea(this,a)};f.Cc=function(a){if(0>=a||this.$i)a=this;else if(a>=this.Hk&&0<=this.Hk)a=this.Gk,a=new PA(a,a,this.fc);else{a=this.Dd+Math.imul(this.fc,a)|0;var b=this.Gk,c=this.fc;a=this.Km()?new g$(a,b,c):new PA(a,b,c)}return a};f.n=function(a){return this.Ps(a|0)};f.ua=function(a){return this.Ps(a)};
-f.Ga=function(a){f$(this);return WY(this,a)};f.g=function(){if(this.$i){var a=SQ("tail");throw a instanceof pe?a.Dt:a;}1===this.Hk?(a=this.Gk,a=new PA(a,a,this.fc)):a=this.Km()?new g$(this.Dd+this.fc|0,this.Gk,this.fc):new PA(this.Dd+this.fc|0,this.Gk,this.fc);return a};f.e=function(){return e$(this)};f.Fc=function(){return d$(this)};function WV(){this.aC=this.Jy=this.bC=null;this.bC=new ZV(this)}WV.prototype=new O9;WV.prototype.constructor=WV;f=WV.prototype;f.Gb=function(a){return VY(this,a)};
-f.Ga=function(a){return WY(this,a)};f.zb=function(a){return YY(this,a)};f.Ob=function(){return YV()};f.Fc=function(){if(0<this.ka())return this.aC.$B;throw iH("Cannot call .last on empty LinkedHashSet");};f.e=function(){if(0<this.ka())return this.Jy.$B;throw iH("Cannot call .head on empty LinkedHashSet");};f.ka=function(){return this.bC.Ft()};f.Q=function(){return this.ka()};f.b=function(){return 0===this.ka()};f.L=function(a){return null!==dR(this.bC,a)};
-f.HF=function(a){a=kR(this.bC,a);null!==a&&(null===a.Yv?this.Jy=a.kr:a.Yv.kr=a.kr,null===a.kr?this.aC=a.Yv:a.kr.Yv=a.Yv,a.Yv=null,a.kr=null)};f.m=function(){return new Z1(this)};f.ya=function(a){for(var b=this.Jy;null!==b;)a.n(b.$B),b=b.kr};f.Hc=function(){return"LinkedHashSet"};f.im=function(a){this.HF(a)};f.S=function(a){jR(this.bC,a,null);return this};
-f.$classData=q({B9:0},!1,"scala.collection.mutable.LinkedHashSet",{B9:1,w8:1,am:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Vj:1,sl:1,ja:1,v:1,U9:1,Vg:1,W9:1,Ug:1,vf:1,og:1,lf:1,kf:1,nn:1,Ab:1,jg:1,l:1});function I9(a,b,c){a.Oh=b;a.Zv=c;return a}function J9(){this.Zv=this.Oh=null}J9.prototype=new V9;J9.prototype.constructor=J9;function h$(){}f=h$.prototype=J9.prototype;f.kF=function(a){return this.Zv.n(a)};f.m=function(){return this.Oh.m()};f.b=function(){return this.Oh.b()};f.Q=function(){return this.Oh.Q()};
-f.pj=function(){return this.Oh.pj()};f.eg=function(){this.Oh.eg()};f.Y=function(a){return this.Oh.Y(a)};f.WS=function(a){this.Oh.im(a)};f.KP=function(a){this.Oh.S(a);return this};f.PP=function(a){return this.Oh.Ol(a).TL(this.Zv)};f.rJ=function(a){return I9(new J9,this.Oh.pj().Ib(a),this.Zv)};f.qc=function(a){return this.rJ(a)};f.vk=function(a){return this.rJ(a)};f.Ol=function(a){return this.PP(a)};f.S=function(a){return this.KP(a)};f.im=function(a){this.WS(a)};
-f.$classData=q({NS:0},!1,"scala.collection.mutable.Map$WithDefault",{NS:1,JG:1,$l:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Ak:1,Uj:1,za:1,ja:1,dm:1,v:1,eC:1,Vg:1,RG:1,Ug:1,vf:1,og:1,lf:1,kf:1,nn:1,l:1});
-function Sea(a,b){if(QY(a))return b;if(QY(b))return a;var c=a.Yf()instanceof jd;if(c!==b.Yf()instanceof jd)return null;if(c){c=a.Yf();b=b.Yf();a=dG(eG(),c)+dG(eG(),b)|0;a=new jd(a);var d=dG(eG(),c);c.va(0,a,0,d);c=dG(eG(),c);d=dG(eG(),b);b.va(0,a,c,d);return BQ(AQ(),a)}c=a.Yf();b=b.Yf();d=dG(eG(),c)+dG(eG(),b)|0;a=a.Tf().gi(d);d=dG(eG(),c);c.va(0,a,0,d);c=dG(eG(),c);d=dG(eG(),b);b.va(0,a,c,d);return BQ(AQ(),a)}
-function i$(a,b){var c=b.Q();if(0===c)return a;KH();var d=[];0<=c&&dG(eG(),a.Yf());a=a.Yf();c=dG(eG(),a);for(var e=0;e<c;){var g=EG(eG(),a,e);d.push(null===g?null:g);e=1+e|0}for(b=b.m();b.s();)a=b.t(),d.push(null===a?null:a);return BQ(AQ(),new jd(d))}function A3(){}A3.prototype=new a9;A3.prototype.constructor=A3;function j$(){}f=j$.prototype=A3.prototype;f.vk=function(a){AQ();var b=this.Tf();return z3(a,b)};f.hi=function(){var a=AQ(),b=this.Tf();return a.Vx(b)};f.zi=function(a){return Ix(this,a)};
-f.Gb=function(a){return VY(this,a)};f.E=function(a){return l9(this,a)};f.dt=function(a){return m9(this,a)};f.Hc=function(){return"IndexedSeq"};f.Ad=function(){var a=new $X(this);return sZ(new tZ,a)};f.Rc=function(){return new Q8(this)};f.e=function(){return this.ua(0)};f.Fc=function(){return zF(this)};f.$a=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.yk=function(){return AQ().nL};
-f.hg=function(a){AQ();var b=this.Yf();KH();var c=1+dG(eG(),b)|0;c=new jd(c);c.a[0]=a;CG(zG(),b,0,c,1,dG(eG(),b));return BQ(0,c)};f.ge=function(a,b){for(var c=this.Yf(),d=0;d<dG(eG(),c);){var e=EG(eG(),c,d);a=b.aa(a,e);d=1+d|0}return a};f.we=function(a,b){for(var c=this.Yf(),d=dG(eG(),c);0<d;){d=-1+d|0;var e=EG(eG(),c,d);a=b.aa(e,a)}return a};f.xh=function(){return"ArraySeq"};f.yc=function(a,b,c){var d=this.K(),e=dG(eG(),a);c=c<d?c:d;e=e-b|0;e=c<e?c:e;e=0<e?e:0;0<e&&CG(zG(),this.Yf(),0,a,b,e);return e};
-f.Ix=function(){return 2147483647};f.oi=function(a){if(1>=dG(eG(),this.Yf()))return this;zG();var b=this.Yf(),c=this.K();AG();Dg(ma(Md),Gg(ja(b)))?b=yg(ma(Md))?BG(b,c):Vj(fk(),b,c,ma(Nd(Md))):(c=new jd(c),CG(zG(),b,0,c,0,dG(eG(),b)),b=c);xj(fk(),b,a);return new $t(b)};f.qc=function(a){AQ();var b=this.Tf();return z3(a,b)};f.Ph=function(a){return this.oi(a)};f.g=function(){AQ();Cr();var a=this.Yf();if(0===dG(eG(),a))throw Fu("tail of empty array");a=Dr(Cr(),a,1,dG(eG(),a));return BQ(0,a)};
-f.zb=function(a){if(0>=a)var b=this;else AQ(),Cr(),b=this.Yf(),a=dG(eG(),b)-(0<a?a:0)|0,b=Dr(Cr(),b,0,a),b=BQ(0,b);return b};f.Cc=function(a){return 0>=a?this:BQ(AQ(),Br(Cr(),this.Yf(),a))};f.Hm=function(a){if(a instanceof A3){var b=Sea(this,a);a=null===b?i$(this,a):b}else a=i$(this,a);return a};f.Zb=function(a){return this.hg(a)};f.Ga=function(a){for(var b=new jd(this.K()),c=0;c<b.a.length;)b.a[c]=a.n(this.ua(c)),c=1+c|0;return BQ(AQ(),b)};f.Ob=function(){return AQ().nL};
-function PA(a,b,c){this.fc=this.Gk=this.Dd=0;this.$i=!1;this.Fv=this.Hk=0;b$(this,a,b,c)}PA.prototype=new c$;PA.prototype.constructor=PA;PA.prototype.Km=function(){return!1};PA.prototype.$classData=q({s7:0},!1,"scala.collection.immutable.Range$Exclusive",{s7:1,q7:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,l:1});function g$(a,b,c){this.fc=this.Gk=this.Dd=0;this.$i=!1;this.Fv=this.Hk=0;b$(this,a,b,c)}g$.prototype=new c$;
-g$.prototype.constructor=g$;g$.prototype.Km=function(){return!0};g$.prototype.$classData=q({t7:0},!1,"scala.collection.immutable.Range$Inclusive",{t7:1,q7:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,l:1});function H9(a,b){this.dn=this.Ii=null;J8(this,a,b)}H9.prototype=new z9;H9.prototype.constructor=H9;f=H9.prototype;f.eB=function(){return new W9(this)};f.Hc=function(){return"SortedMap"};f.h=function(a){return S8(this,a)};
-f.OQ=function(a,b){return this.zp().Fq(IT(new JT,this,a),b)};f.Wd=function(){return this.Ii.Wd()};f.zp=function(){return this.Ii.zp()};function k$(a,b,c){return new H9(a.Ii.km(b,c),a.dn)}function l$(a,b){return new H9(a.Ii.OA(b),a.dn)}function m$(a,b){return new H9(a.Ii.zp().Fq(b,a.Ii.Wd()),a.dn)}f.oe=function(a){return l$(this,a)};f.kC=function(a,b){return f8(this,a,b)};f.mm=function(a){return k$(this,a.i(),a.j())};f.Pq=function(){return new W9(this)};f.$s=function(){return new W9(this)};
-f.SL=function(a){return G9(this,a)};f.qc=function(a){return m$(this,a)};f.vk=function(a){return m$(this,a)};f.qJ=function(a){return m$(this,a)};f.rj=function(a){return new H9(this.Ii.rj(a),this.dn)};f.QQ=function(a){return new H9(this.Ii.rj(a),this.dn)};f.Ol=function(a){return l$(this,a)};f.OP=function(a){return l$(this,a)};f.OA=function(a){return l$(this,a)};f.lm=function(a,b){return k$(this,a,b)};f.km=function(a,b){return k$(this,a,b)};f.$S=function(a,b){return k$(this,a,b)};
-f.$classData=q({U7:0},!1,"scala.collection.immutable.SortedMap$WithDefault",{U7:1,aS:1,jt:1,$l:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Ak:1,Uj:1,za:1,ja:1,dm:1,v:1,er:1,sc:1,pt:1,l:1,mS:1,zB:1,hL:1,ly:1,gL:1,V7:1});function r1(){this.R=null}r1.prototype=new a9;r1.prototype.constructor=r1;function n$(){}f=n$.prototype=r1.prototype;f.zi=function(a){return Ix(this,a)};f.Ph=function(a){return Fv(this,a)};f.Gb=function(a){return VY(this,a)};f.E=function(a){return l9(this,a)};
-f.dt=function(a){return m9(this,a)};f.Hc=function(){return"IndexedSeq"};f.Ad=function(){var a=new $X(this);return sZ(new tZ,a)};f.we=function(a,b){return b0(this,a,b)};f.Rc=function(){return new Q8(this)};f.$a=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.yk=function(){return pK()};f.K=function(){return this instanceof o$?this.ba:this.R.a.length};f.m=function(){return qJ()===this?pK().pS:new e1(this,this.K(),this.rn())};
-function OU(a,b,c){for(var d=0,e=a.R.a.length;d!==e;){if(!!b.n(a.R.a[d])===c){for(var g=0,h=1+d|0;h<e;)!!b.n(a.R.a[h])!==c&&(g|=1<<h),h=1+h|0;e=g;e=d+XH(CH(),e)|0;if(a instanceof o$){h=new PU;for(var k=0;k<d;)RU(h,a.R.a[k]),k=1+k|0;for(k=1+d|0;d!==e;)0!==(1<<k&g)&&(RU(h,a.R.a[k]),d=1+d|0),k=1+k|0;p$(a,new z(((m,n,r)=>u=>!!m.n(u)!==n?RU(r,u):void 0)(b,c,h)));return h.Vl()}if(0===e)return qJ();h=new jd(e);a.R.va(0,h,0,d);for(k=1+d|0;d!==e;)0!==(1<<k&g)&&(h.a[d]=a.R.a[k],d=1+d|0),k=1+k|0;return new rJ(h)}d=
-1+d|0}if(a instanceof o$){var l=new PU;Jda(l,a.R);p$(a,new z(m=>!!b.n(m)!==c?RU(l,m):void 0));return l.Vl()}return a}f.el=function(a,b){var c=4+this.rn()|0;if(0<b&&b<c){var d=new ov(this);if(IJ(a))a.ya(new z(e=>{d.Lb=d.Lb.Im(e)}));else for(a=a.m();a.s();)b=a.t(),d.Lb=d.Lb.Im(b);return d.Lb}if(this.K()<(b>>>5|0)&&a instanceof r1){b=new $X(this);for(b=sZ(new tZ,b);0<b.sj;)a=a.pl(b.t());return a}return QU(u1(new PU,this),a).Vl()};f.xh=function(){return"Vector"};
-f.yc=function(a,b,c){return this.m().yc(a,b,c)};f.Ix=function(){return pK().oS};f.hh=function(a){return KK(new LK,a+" is out of bounds (min 0, max "+(-1+this.K()|0)+")")};f.e=function(){if(0===this.R.a.length)throw iH("empty.head");return this.R.a[0]};f.Fc=function(){if(this instanceof o$){var a=this.$;if(0===a.a.length)throw iH("empty.tail");return a.a[-1+a.a.length|0]}return this.R.a[-1+this.R.a.length|0]};
-f.ya=function(a){for(var b=this.rn(),c=0;c<b;){var d=sJ(),e=b/2|0,g=c-e|0;EJ(d,-1+((1+e|0)-(0>g?-g|0:g)|0)|0,this.oo(c),a);c=1+c|0}};f.zb=function(a){a=this.K()-(0<a?a:0)|0;return q$(this,0,a)};f.Cc=function(a){var b=this.K();return q$(this,a,b)};f.Hm=function(a){var b=a.Q();return 0===b?this:this.el(a,b)};f.Ob=function(){return pK()};function r$(){}r$.prototype=new v9;r$.prototype.constructor=r$;function s$(){}f=s$.prototype=r$.prototype;f.zi=function(a){return u3(this,a)};
-f.Zb=function(a){return v3(this,a)};f.Hm=function(a){return w3(this,a)};f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.zb=function(a){return YY(this,a)};f.Hc=function(){return"IndexedSeq"};f.Ad=function(){var a=new $X(this);return sZ(new tZ,a)};f.we=function(a,b){return b0(this,a,b)};f.Rc=function(){return new Q8(this)};f.Cc=function(a){return f0(this,a)};f.e=function(){return this.ua(0)};f.Fc=function(){return zF(this)};
-f.$a=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.yk=function(){return pQ().BL};function t$(a,b){var c=a.Tf().jh(),d=c===ma(Vd);a=[];b.Q();for(b=b.m();b.s();){var e=b.t();a.push(d?Eb(e):null===e?c.ei.Oy:e)}pQ();c=c===ma(Qd)?ma(Xa):c===ma(SG)||c===ma(TG)?ma(Md):c;return f4(0,Nd(c.ei).Ny(a))}f.hi=function(){return pQ().Vx(this.Tf())};f.xh=function(){return"ArraySeq"};
-f.yc=function(a,b,c){var d=this.K(),e=dG(eG(),a);c=c<d?c:d;e=e-b|0;e=c<e?c:e;e=0<e?e:0;0<e&&CG(zG(),this.fl(),0,a,b,e);return e};f.h=function(a){return a instanceof r$&&dG(eG(),this.fl())!==dG(eG(),a.fl())?!1:Z2(this,a)};f.Ph=function(a){pQ();Cr();return f4(0,nu(this.fl(),a))};f.ga=function(){return f4(pQ(),rG(eG(),this.fl()))};f.qc=function(a){return t$(this,a)};f.vk=function(a){return t$(this,a)};f.Ob=function(){return pQ().BL};function I3(a){this.Xq=a}I3.prototype=new j$;
-I3.prototype.constructor=I3;f=I3.prototype;f.K=function(){return this.Xq.a.length};f.y=function(){var a=kL();return nL(a,this.Xq,a.ig)};f.h=function(a){if(a instanceof I3){var b=this.Xq;a=a.Xq;return Nj(fk(),b,a)}return Z2(this,a)};f.oi=function(a){if(1>=this.K())return this;if(a===wG()){a=this.Xq.ga();var b=xG(),c=wG();yG(b,a,a.a.length,c);return new I3(a)}return A3.prototype.oi.call(this,a)};f.m=function(){return new pG(this.Xq)};
-f.hg=function(a){if("boolean"===typeof a){a=!!a;var b=this.Xq;dL();var c=new pd(1+b.a.length|0);c.a[0]=a;CG(zG(),b,0,c,1,b.a.length);return new I3(c)}return A3.prototype.hg.call(this,a)};f.IA=function(a){return this.Xq.a[a]};f.Zb=function(a){return this.hg(a)};f.Ph=function(a){return this.oi(a)};f.n=function(a){return this.IA(a|0)};f.ua=function(a){return this.IA(a)};f.Tf=function(){return dL()};f.Yf=function(){return this.Xq};
-f.$classData=q({b6:0},!1,"scala.collection.immutable.ArraySeq$ofBoolean",{b6:1,Wq:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,Tq:1,l:1});function G3(a){this.Yq=a}G3.prototype=new j$;G3.prototype.constructor=G3;f=G3.prototype;f.K=function(){return this.Yq.a.length};f.JA=function(a){return this.Yq.a[a]};f.y=function(){var a=kL();return oL(a,this.Yq,a.ig)};
-f.h=function(a){if(a instanceof G3){var b=this.Yq;a=a.Yq;return Mj(fk(),b,a)}return Z2(this,a)};f.oi=function(a){return 1>=this.K()?this:a===uG()?(a=this.Yq.ga(),vj(fk(),a),new G3(a)):A3.prototype.oi.call(this,a)};f.m=function(){return new nG(this.Yq)};f.hg=function(a){if(dd(a)){a|=0;var b=this.Yq;bL();var c=new vd(1+b.a.length|0);c.a[0]=a;CG(zG(),b,0,c,1,b.a.length);return new G3(c)}return A3.prototype.hg.call(this,a)};f.Zb=function(a){return this.hg(a)};f.Ph=function(a){return this.oi(a)};
-f.n=function(a){return this.JA(a|0)};f.ua=function(a){return this.JA(a)};f.Tf=function(){return bL()};f.Yf=function(){return this.Yq};f.$classData=q({c6:0},!1,"scala.collection.immutable.ArraySeq$ofByte",{c6:1,Wq:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,Tq:1,l:1});function F3(a){this.kp=a}F3.prototype=new j$;F3.prototype.constructor=F3;f=F3.prototype;f.K=function(){return this.kp.a.length};f.KA=function(a){return this.kp.a[a]};
-f.y=function(){var a=kL();return pL(a,this.kp,a.ig)};f.h=function(a){if(a instanceof F3){var b=this.kp;a=a.kp;return Lj(fk(),b,a)}return Z2(this,a)};f.oi=function(a){return 1>=this.K()?this:a===tG()?(a=this.kp.ga(),tj(fk(),a),new F3(a)):A3.prototype.oi.call(this,a)};f.m=function(){return new mG(this.kp)};f.hg=function(a){if(a instanceof fa){a=Eb(a);var b=this.kp;Tq();var c=new td(1+b.a.length|0);c.a[0]=a;CG(zG(),b,0,c,1,b.a.length);return new F3(c)}return A3.prototype.hg.call(this,a)};
-f.vh=function(a,b,c,d){return(new rQ(this.kp)).vh(a,b,c,d)};f.Zb=function(a){return this.hg(a)};f.Ph=function(a){return this.oi(a)};f.n=function(a){return hd(this.KA(a|0))};f.ua=function(a){return hd(this.KA(a))};f.Tf=function(){return Tq()};f.Yf=function(){return this.kp};f.$classData=q({d6:0},!1,"scala.collection.immutable.ArraySeq$ofChar",{d6:1,Wq:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,Tq:1,l:1});
-function C3(a){this.kt=a}C3.prototype=new j$;C3.prototype.constructor=C3;f=C3.prototype;f.K=function(){return this.kt.a.length};f.y=function(){var a=kL();return qL(a,this.kt,a.ig)};f.h=function(a){if(a instanceof C3){var b=this.kt;a=a.kt;return Oj(fk(),b,a)}return Z2(this,a)};f.m=function(){return new jG(this.kt)};f.hg=function(a){if("number"===typeof a){a=+a;var b=this.kt;ZK();var c=new Dd(1+b.a.length|0);c.a[0]=a;CG(zG(),b,0,c,1,b.a.length);return new C3(c)}return A3.prototype.hg.call(this,a)};
-f.FA=function(a){return this.kt.a[a]};f.Zb=function(a){return this.hg(a)};f.n=function(a){return this.FA(a|0)};f.ua=function(a){return this.FA(a)};f.Tf=function(){return ZK()};f.Yf=function(){return this.kt};f.$classData=q({e6:0},!1,"scala.collection.immutable.ArraySeq$ofDouble",{e6:1,Wq:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,Tq:1,l:1});function E3(a){this.lt=a}E3.prototype=new j$;E3.prototype.constructor=E3;f=E3.prototype;
-f.K=function(){return this.lt.a.length};f.y=function(){var a=kL();return rL(a,this.lt,a.ig)};f.h=function(a){if(a instanceof E3){var b=this.lt;a=a.lt;return Pj(fk(),b,a)}return Z2(this,a)};f.m=function(){return new lG(this.lt)};f.hg=function(a){if(va(a)){a=Math.fround(a);var b=this.lt;aL();var c=new Bd(1+b.a.length|0);c.a[0]=a;CG(zG(),b,0,c,1,b.a.length);return new E3(c)}return A3.prototype.hg.call(this,a)};f.GA=function(a){return this.lt.a[a]};f.Zb=function(a){return this.hg(a)};
-f.n=function(a){return this.GA(a|0)};f.ua=function(a){return this.GA(a)};f.Tf=function(){return aL()};f.Yf=function(){return this.lt};f.$classData=q({f6:0},!1,"scala.collection.immutable.ArraySeq$ofFloat",{f6:1,Wq:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,Tq:1,l:1});function B3(a){this.Zq=a}B3.prototype=new j$;B3.prototype.constructor=B3;f=B3.prototype;f.K=function(){return this.Zq.a.length};
-f.y=function(){var a=kL();return sL(a,this.Zq,a.ig)};f.h=function(a){if(a instanceof B3){var b=this.Zq;a=a.Zq;return Jj(fk(),b,a)}return Z2(this,a)};f.oi=function(a){return 1>=this.K()?this:a===dq()?(a=this.Zq.ga(),jj(fk(),a),new B3(a)):A3.prototype.oi.call(this,a)};f.m=function(){return new iG(this.Zq)};f.hg=function(a){if(oa(a)){a|=0;var b=this.Zq;Rl();var c=new zd(1+b.a.length|0);c.a[0]=a;CG(zG(),b,0,c,1,b.a.length);return new B3(c)}return A3.prototype.hg.call(this,a)};f.Ps=function(a){return this.Zq.a[a]};
-f.Zb=function(a){return this.hg(a)};f.Ph=function(a){return this.oi(a)};f.n=function(a){return this.Ps(a|0)};f.ua=function(a){return this.Ps(a)};f.Tf=function(){return Rl()};f.Yf=function(){return this.Zq};f.$classData=q({g6:0},!1,"scala.collection.immutable.ArraySeq$ofInt",{g6:1,Wq:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,Tq:1,l:1});function D3(a){this.$q=a}D3.prototype=new j$;D3.prototype.constructor=D3;f=D3.prototype;
-f.K=function(){return this.$q.a.length};f.y=function(){var a=kL();return tL(a,this.$q,a.ig)};f.h=function(a){if(a instanceof D3){var b=this.$q;a=a.$q;return Bj(fk(),b,a)}return Z2(this,a)};f.oi=function(a){return 1>=this.K()?this:a===sG()?(a=this.$q.ga(),pj(fk(),a),new D3(a)):A3.prototype.oi.call(this,a)};f.m=function(){return new kG(this.$q)};
-f.hg=function(a){if(a instanceof fb){var b=Qb(a);a=b.W;b=b.Z;var c=this.$q;$K();var d=new Ad(1+c.a.length|0);d.a[0]=Qb(new fb(a,b));CG(zG(),c,0,d,1,c.a.length);return new D3(d)}return A3.prototype.hg.call(this,a)};f.HA=function(a){return this.$q.a[a]};f.Zb=function(a){return this.hg(a)};f.Ph=function(a){return this.oi(a)};f.n=function(a){return this.HA(a|0)};f.ua=function(a){return this.HA(a)};f.Tf=function(){return $K()};f.Yf=function(){return this.$q};
-f.$classData=q({h6:0},!1,"scala.collection.immutable.ArraySeq$ofLong",{h6:1,Wq:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,Tq:1,l:1});function $t(a){this.Zm=a}$t.prototype=new j$;$t.prototype.constructor=$t;f=$t.prototype;f.Tf=function(){return fG(gG(),Gg(ja(this.Zm)))};f.K=function(){return this.Zm.a.length};f.ua=function(a){return this.Zm.a[a]};f.y=function(){var a=kL();return mL(a,this.Zm,a.ig)};
-f.h=function(a){return a instanceof $t?jQ(zG(),this.Zm,a.Zm):Z2(this,a)};function u$(a,b){if(1>=a.Zm.a.length)return a;a=a.Zm.ga();xj(fk(),a,b);return new $t(a)}f.m=function(){return Yt(new Zt,this.Zm)};f.Ph=function(a){return u$(this,a)};f.oi=function(a){return u$(this,a)};f.n=function(a){return this.ua(a|0)};f.Yf=function(){return this.Zm};
-f.$classData=q({i6:0},!1,"scala.collection.immutable.ArraySeq$ofRef",{i6:1,Wq:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,Tq:1,l:1});function H3(a){this.ar=a}H3.prototype=new j$;H3.prototype.constructor=H3;f=H3.prototype;f.K=function(){return this.ar.a.length};f.LA=function(a){return this.ar.a[a]};f.y=function(){var a=kL();return uL(a,this.ar,a.ig)};
-f.h=function(a){if(a instanceof H3){var b=this.ar;a=a.ar;return Kj(fk(),b,a)}return Z2(this,a)};f.oi=function(a){return 1>=this.K()?this:a===vG()?(a=this.ar.ga(),rj(fk(),a),new H3(a)):A3.prototype.oi.call(this,a)};f.m=function(){return new oG(this.ar)};f.hg=function(a){if(fd(a)){a|=0;var b=this.ar;cL();var c=new wd(1+b.a.length|0);c.a[0]=a;CG(zG(),b,0,c,1,b.a.length);return new H3(c)}return A3.prototype.hg.call(this,a)};f.Zb=function(a){return this.hg(a)};f.Ph=function(a){return this.oi(a)};
-f.n=function(a){return this.LA(a|0)};f.ua=function(a){return this.LA(a)};f.Tf=function(){return cL()};f.Yf=function(){return this.ar};f.$classData=q({j6:0},!1,"scala.collection.immutable.ArraySeq$ofShort",{j6:1,Wq:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,Tq:1,l:1});function J3(a){this.ry=a}J3.prototype=new j$;J3.prototype.constructor=J3;f=J3.prototype;f.K=function(){return this.ry.a.length};
-f.y=function(){var a=kL();return vL(a,this.ry,a.ig)};f.h=function(a){return a instanceof J3?this.ry.a.length===a.ry.a.length:Z2(this,a)};f.m=function(){return new qG(this.ry)};f.n=function(){};f.ua=function(){};f.Tf=function(){return JR()};f.Yf=function(){return this.ry};f.$classData=q({k6:0},!1,"scala.collection.immutable.ArraySeq$ofUnit",{k6:1,Wq:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,Tq:1,l:1});
-function Ex(a,b,c){a:for(;;){if(a.b()){c=v();break a}var d=a.e(),e=a.g();if(!!b.n(d)!==c){b:for(var g=c;;){if(e.b()){c=a;break b}c=e.e();if(!!b.n(c)!==g)e=e.g();else{var h=a;d=e;c=b;b=g;a=new A(h.e(),v());g=h.g();for(e=a;g!==d;)h=new A(g.e(),v()),e=e.r=h,g=g.g();for(g=d=d.g();!d.b();){h=d.e();if(!!c.n(h)===b){for(;g!==d;)h=new A(g.e(),v()),e=e.r=h,g=g.g();g=d.g()}d=d.g()}g.b()||(e.r=g);c=a;break b}}break a}a=e}return c}
-function yea(a,b,c){for(var d=null,e=null;;){if(b.b()){if(null===d)return a;e.r=a;return d}var g=b.e(),h=c.n(g);if(Object.is(h,g))b=b.g();else{for(;a!==b;)g=new A(a.e(),v()),null===d&&(d=g),null!==e&&(e.r=g),e=g,a=a.g();h=new A(h,v());null===d&&(d=h);null!==e&&(e.r=h);e=h;b=b.g();e=h=e;a=b}}}function hS(){}hS.prototype=new a9;hS.prototype.constructor=hS;function v$(){}f=v$.prototype=hS.prototype;f.zi=function(a){return Ix(this,a)};f.Ph=function(a){return Fv(this,a)};f.m=function(){return new lq(this)};
-f.Gb=function(a){return VY(this,a)};f.zb=function(a){return YY(this,a)};f.Hc=function(){return"LinearSeq"};f.vJ=function(a){return u0(this,a)};f.ua=function(a){return FA(this,a)};f.ge=function(a,b){return AA(this,a,b)};f.dt=function(a){return v0(this,a)};f.Rn=function(a,b){return w0(this,a,b)};f.yk=function(){return je()};function Fl(a,b){if(a.b())return b;if(b.b())return a;var c=new A(b.e(),a),d=c;for(b=b.g();!b.b();){var e=new A(b.e(),a);d=d.r=e;b=b.g()}return c}f.b=function(){return this===v()};
-function le(a,b){if(b instanceof hS)return Fl(a,b);if(0===b.Q())return a;if(b instanceof Wo&&a.b())return b.ea();b=b.m();if(b.s()){for(var c=new A(b.t(),a),d=c;b.s();){var e=new A(b.t(),a);d=d.r=e}return c}return a}function mn(a,b){return b instanceof hS?Fl(b,a):w3(a,b)}function Ks(a,b){if(a.b()||0>=b)return v();for(var c=new A(a.e(),v()),d=c,e=a.g(),g=1;;){if(e.b())return a;if(g<b){g=1+g|0;var h=new A(e.e(),v());d=d.r=h;e=e.g()}else break}return c}
-function ht(a,b){if(a===v())return v();var c=new A(b.n(a.e()),v()),d=c;for(a=a.g();a!==v();){var e=new A(b.n(a.e()),v());d=d.r=e;a=a.g()}return c}function Hn(a,b){if(a===v())return v();for(var c=null,d;null===c;)if(d=b.Nb(a.e(),je().KB),d!==je().KB&&(c=new A(d,v())),a=a.g(),a===v())return null===c?v():c;for(var e=c;a!==v();)d=b.Nb(a.e(),je().KB),d!==je().KB&&(d=new A(d,v()),e=e.r=d),a=a.g();return c}
-function cX(a,b){for(var c=null,d=null;a!==v();){for(var e=b.n(a.e()).m();e.s();){var g=new A(e.t(),v());null===d?c=g:d.r=g;d=g}a=a.g()}return null===c?v():c}f.ya=function(a){for(var b=this;!b.b();)a.n(b.e()),b=b.g()};function jp(a){for(var b=v();!a.b();){var c=a.e();b=new A(c,b);a=a.g()}return b}f.we=function(a,b){for(var c=jp(this);!c.b();)a=b.aa(c.e(),a),c=c.g();return a};f.K=function(){for(var a=this,b=0;!a.b();)b=1+b|0,a=a.g();return b};
-f.$a=function(a){if(0>a)a=1;else a:for(var b=this,c=0;;){if(c===a){a=b.b()?0:1;break a}if(b.b()){a=-1;break a}c=1+c|0;b=b.g()}return a};f.il=function(a){for(var b=this;!b.b();){if(!a.n(b.e()))return!1;b=b.g()}return!0};f.Ln=function(a){for(var b=this;!b.b();){if(a.n(b.e()))return!0;b=b.g()}return!1};f.L=function(a){for(var b=this;!b.b();){if(Ol(Pl(),b.e(),a))return!0;b=b.g()}return!1};function pX(a,b){for(;!a.b();){if(b.n(a.e()))return new M(a.e());a=a.g()}return R()}
-f.Fc=function(){if(this.b())throw iH("List.last");for(var a=this,b=this.g();!b.b();)a=b,b=b.g();return a.e()};f.xh=function(){return"List"};f.jK=function(a){if(this.b())return je().LB;for(var b=this.hi(),c=this.hi(),d=this.m();d.s();){var e=d.t();(a.n(e)?b:c).S(e)}a=G(new H,b.Eb(),c.Eb());return null!==a&&(b=a.i(),v().h(b))?G(new H,v(),this):null!==a&&(b=a.j(),v().h(b))?G(new H,this,v()):a};f.ea=function(){return this};
-f.h=function(a){var b;if(a instanceof hS)a:for(b=this;;){if(b===a){b=!0;break a}var c=b.b(),d=a.b();if(c||d||!Ol(Pl(),b.e(),a.e())){b=c&&d;break a}b=b.g();a=a.g()}else b=Z2(this,a);return b};f.n=function(a){return FA(this,a|0)};f.Ec=function(a){return u0(this,a|0)};f.Cc=function(a){return R5(a,this)};f.Ga=function(a){return ht(this,a)};f.Hm=function(a){return mn(this,a)};f.Zb=function(a){return new A(a,this)};f.Ob=function(){return je()};function w$(){this.R=null}w$.prototype=new n$;
-w$.prototype.constructor=w$;function x$(){}x$.prototype=w$.prototype;function q$(a,b,c){b=0<b?b:0;var d=a.K();c=c<d?c:d;return(c-b|0)===a.K()?a:c<=b?qJ():a.pn(b,c)}function m4(a){this.Mv=a}m4.prototype=new s$;m4.prototype.constructor=m4;f=m4.prototype;f.K=function(){return this.Mv.a.length};f.y=function(){var a=kL();return nL(a,this.Mv,a.ig)};f.h=function(a){if(a instanceof m4){var b=this.Mv;a=a.Mv;return Nj(fk(),b,a)}return r$.prototype.h.call(this,a)};f.m=function(){return new pG(this.Mv)};
-f.IA=function(a){return this.Mv.a[a]};f.n=function(a){return this.IA(a|0)};f.ua=function(a){return this.IA(a)};f.Tf=function(){return dL()};f.fl=function(){return this.Mv};f.$classData=q({F8:0},!1,"scala.collection.mutable.ArraySeq$ofBoolean",{F8:1,ir:1,$j:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,dk:1,Vg:1,ek:1,Ug:1,vf:1,Mk:1,Zc:1,Sb:1,Nk:1,$c:1,Ab:1,l:1});function k4(a){this.Nv=a}k4.prototype=new s$;k4.prototype.constructor=k4;f=k4.prototype;f.K=function(){return this.Nv.a.length};
-f.JA=function(a){return this.Nv.a[a]};f.y=function(){var a=kL();return oL(a,this.Nv,a.ig)};f.h=function(a){if(a instanceof k4){var b=this.Nv;a=a.Nv;return Mj(fk(),b,a)}return r$.prototype.h.call(this,a)};f.m=function(){return new nG(this.Nv)};f.n=function(a){return this.JA(a|0)};f.ua=function(a){return this.JA(a)};f.Tf=function(){return bL()};f.fl=function(){return this.Nv};
-f.$classData=q({G8:0},!1,"scala.collection.mutable.ArraySeq$ofByte",{G8:1,ir:1,$j:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,dk:1,Vg:1,ek:1,Ug:1,vf:1,Mk:1,Zc:1,Sb:1,Nk:1,$c:1,Ab:1,l:1});function rQ(a){this.hn=a}rQ.prototype=new s$;rQ.prototype.constructor=rQ;f=rQ.prototype;f.K=function(){return this.hn.a.length};f.KA=function(a){return this.hn.a[a]};f.y=function(){var a=kL();return pL(a,this.hn,a.ig)};
-f.h=function(a){if(a instanceof rQ){var b=this.hn;a=a.hn;return Lj(fk(),b,a)}return r$.prototype.h.call(this,a)};f.m=function(){return new mG(this.hn)};f.vh=function(a,b,c,d){var e=a.mf;0!==b.length&&(e.ha=""+e.ha+b);b=this.hn.a.length;if(0!==b)if(""===c)qW(e,this.hn);else{e.K();var g=String.fromCharCode(this.hn.a[0]);e.ha=""+e.ha+g;for(g=1;g<b;){e.ha=""+e.ha+c;var h=String.fromCharCode(this.hn.a[g]);e.ha=""+e.ha+h;g=1+g|0}}0!==d.length&&(e.ha=""+e.ha+d);return a};
-f.n=function(a){return hd(this.KA(a|0))};f.ua=function(a){return hd(this.KA(a))};f.Tf=function(){return Tq()};f.fl=function(){return this.hn};f.$classData=q({H8:0},!1,"scala.collection.mutable.ArraySeq$ofChar",{H8:1,ir:1,$j:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,dk:1,Vg:1,ek:1,Ug:1,vf:1,Mk:1,Zc:1,Sb:1,Nk:1,$c:1,Ab:1,l:1});function h4(a){this.Ov=a}h4.prototype=new s$;h4.prototype.constructor=h4;f=h4.prototype;f.K=function(){return this.Ov.a.length};
-f.y=function(){var a=kL();return qL(a,this.Ov,a.ig)};f.h=function(a){if(a instanceof h4){var b=this.Ov;a=a.Ov;return Oj(fk(),b,a)}return r$.prototype.h.call(this,a)};f.m=function(){return new jG(this.Ov)};f.FA=function(a){return this.Ov.a[a]};f.n=function(a){return this.FA(a|0)};f.ua=function(a){return this.FA(a)};f.Tf=function(){return ZK()};f.fl=function(){return this.Ov};
-f.$classData=q({I8:0},!1,"scala.collection.mutable.ArraySeq$ofDouble",{I8:1,ir:1,$j:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,dk:1,Vg:1,ek:1,Ug:1,vf:1,Mk:1,Zc:1,Sb:1,Nk:1,$c:1,Ab:1,l:1});function j4(a){this.Pv=a}j4.prototype=new s$;j4.prototype.constructor=j4;f=j4.prototype;f.K=function(){return this.Pv.a.length};f.y=function(){var a=kL();return rL(a,this.Pv,a.ig)};f.h=function(a){if(a instanceof j4){var b=this.Pv;a=a.Pv;return Pj(fk(),b,a)}return r$.prototype.h.call(this,a)};
-f.m=function(){return new lG(this.Pv)};f.GA=function(a){return this.Pv.a[a]};f.n=function(a){return this.GA(a|0)};f.ua=function(a){return this.GA(a)};f.Tf=function(){return aL()};f.fl=function(){return this.Pv};f.$classData=q({J8:0},!1,"scala.collection.mutable.ArraySeq$ofFloat",{J8:1,ir:1,$j:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,dk:1,Vg:1,ek:1,Ug:1,vf:1,Mk:1,Zc:1,Sb:1,Nk:1,$c:1,Ab:1,l:1});function g4(a){this.Qv=a}g4.prototype=new s$;g4.prototype.constructor=g4;f=g4.prototype;
-f.K=function(){return this.Qv.a.length};f.y=function(){var a=kL();return sL(a,this.Qv,a.ig)};f.h=function(a){if(a instanceof g4){var b=this.Qv;a=a.Qv;return Jj(fk(),b,a)}return r$.prototype.h.call(this,a)};f.m=function(){return new iG(this.Qv)};f.Ps=function(a){return this.Qv.a[a]};f.n=function(a){return this.Ps(a|0)};f.ua=function(a){return this.Ps(a)};f.Tf=function(){return Rl()};f.fl=function(){return this.Qv};
-f.$classData=q({K8:0},!1,"scala.collection.mutable.ArraySeq$ofInt",{K8:1,ir:1,$j:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,dk:1,Vg:1,ek:1,Ug:1,vf:1,Mk:1,Zc:1,Sb:1,Nk:1,$c:1,Ab:1,l:1});function i4(a){this.Rv=a}i4.prototype=new s$;i4.prototype.constructor=i4;f=i4.prototype;f.K=function(){return this.Rv.a.length};f.y=function(){var a=kL();return tL(a,this.Rv,a.ig)};f.h=function(a){if(a instanceof i4){var b=this.Rv;a=a.Rv;return Bj(fk(),b,a)}return r$.prototype.h.call(this,a)};
-f.m=function(){return new kG(this.Rv)};f.HA=function(a){return this.Rv.a[a]};f.n=function(a){return this.HA(a|0)};f.ua=function(a){return this.HA(a)};f.Tf=function(){return $K()};f.fl=function(){return this.Rv};f.$classData=q({L8:0},!1,"scala.collection.mutable.ArraySeq$ofLong",{L8:1,ir:1,$j:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,dk:1,Vg:1,ek:1,Ug:1,vf:1,Mk:1,Zc:1,Sb:1,Nk:1,$c:1,Ab:1,l:1});function qQ(a){this.zt=a}qQ.prototype=new s$;qQ.prototype.constructor=qQ;f=qQ.prototype;
-f.Tf=function(){return fG(gG(),Gg(ja(this.zt)))};f.K=function(){return this.zt.a.length};f.ua=function(a){return this.zt.a[a]};f.y=function(){var a=kL();return mL(a,this.zt,a.ig)};f.h=function(a){return a instanceof qQ?jQ(zG(),this.zt,a.zt):r$.prototype.h.call(this,a)};f.m=function(){return Yt(new Zt,this.zt)};f.n=function(a){return this.ua(a|0)};f.fl=function(){return this.zt};
-f.$classData=q({M8:0},!1,"scala.collection.mutable.ArraySeq$ofRef",{M8:1,ir:1,$j:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,dk:1,Vg:1,ek:1,Ug:1,vf:1,Mk:1,Zc:1,Sb:1,Nk:1,$c:1,Ab:1,l:1});function l4(a){this.Sv=a}l4.prototype=new s$;l4.prototype.constructor=l4;f=l4.prototype;f.K=function(){return this.Sv.a.length};f.LA=function(a){return this.Sv.a[a]};f.y=function(){var a=kL();return uL(a,this.Sv,a.ig)};
-f.h=function(a){if(a instanceof l4){var b=this.Sv;a=a.Sv;return Kj(fk(),b,a)}return r$.prototype.h.call(this,a)};f.m=function(){return new oG(this.Sv)};f.n=function(a){return this.LA(a|0)};f.ua=function(a){return this.LA(a)};f.Tf=function(){return cL()};f.fl=function(){return this.Sv};f.$classData=q({N8:0},!1,"scala.collection.mutable.ArraySeq$ofShort",{N8:1,ir:1,$j:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,dk:1,Vg:1,ek:1,Ug:1,vf:1,Mk:1,Zc:1,Sb:1,Nk:1,$c:1,Ab:1,l:1});
-function n4(a){this.Gy=a}n4.prototype=new s$;n4.prototype.constructor=n4;f=n4.prototype;f.K=function(){return this.Gy.a.length};f.y=function(){var a=kL();return vL(a,this.Gy,a.ig)};f.h=function(a){return a instanceof n4?this.Gy.a.length===a.Gy.a.length:r$.prototype.h.call(this,a)};f.m=function(){return new qG(this.Gy)};f.n=function(){};f.ua=function(){};f.Tf=function(){return JR()};f.fl=function(){return this.Gy};
-f.$classData=q({O8:0},!1,"scala.collection.mutable.ArraySeq$ofUnit",{O8:1,ir:1,$j:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,dk:1,Vg:1,ek:1,Ug:1,vf:1,Mk:1,Zc:1,Sb:1,Nk:1,$c:1,Ab:1,l:1});function y$(a,b,c,d){(1+a.Of|0)>=a.At&&fy(a,a.cb.a.length<<1);return gy(a,b,c,!1,d,d&(-1+a.cb.a.length|0))}function cy(a,b,c,d){(1+a.Of|0)>=a.At&&fy(a,a.cb.a.length<<1);var e=dy(W(),b);e^=e>>>16|0;return gy(a,b,c,d,e,e&(-1+a.cb.a.length|0))}
-function gy(a,b,c,d,e,g){var h=a.cb.a[g];if(null===h)a.cb.a[g]=new KJ(b,e,c,null);else{for(var k=null,l=h;null!==l&&l.bk<=e;){if(l.bk===e&&Ol(Pl(),b,l.Kk))return a=l.ph,l.ph=c,d?new M(a):null;k=l;l=l.Id}null===k?a.cb.a[g]=new KJ(b,e,c,h):k.Id=new KJ(b,e,c,k.Id)}a.Of=1+a.Of|0;return null}
-function z$(a,b){var c=dy(W(),b);a:{c^=c>>>16|0;var d=c&(-1+a.cb.a.length|0),e=a.cb.a[d];if(null===e)a=null;else if(e.bk===c&&Ol(Pl(),e.Kk,b))a.cb.a[d]=e.Id,a.Of=-1+a.Of|0,a=e;else{d=e;for(e=e.Id;null!==e&&e.bk<=c;){if(e.bk===c&&Ol(Pl(),e.Kk,b)){d.Id=e.Id;a.Of=-1+a.Of|0;a=e;break a}d=e;e=e.Id}a=null}}return a}
-function fy(a,b){if(0>b)throw SK("new HashMap table size "+b+" exceeds maximum");var c=a.cb.a.length;a.At=Mc(b*a.LG);if(0===a.Of)a.cb=new (Nd(LJ).Ja)(b);else{var d=a.cb;a.cb=Tj(fk(),d,b);d=new KJ(null,0,null,null);for(var e=new KJ(null,0,null,null);c<b;){for(var g=0;g<c;){var h=a.cb.a[g];if(null!==h){d.Id=null;e.Id=null;for(var k=d,l=e,m=h;null!==m;){var n=m.Id;0===(m.bk&c)?k=k.Id=m:l=l.Id=m;m=n}k.Id=null;h!==d.Id&&(a.cb.a[g]=d.Id);null!==e.Id&&(a.cb.a[g+c|0]=e.Id,l.Id=null)}g=1+g|0}c<<=1}}}
-function A$(a){a=-1+a|0;a=4<a?a:4;a=(-2147483648>>Math.clz32(a)&a)<<1;return 1073741824>a?a:1073741824}function EV(a,b,c){a.LG=c;a.cb=new (Nd(LJ).Ja)(A$(b));a.At=Mc(a.cb.a.length*a.LG);a.Of=0;return a}function HV(){var a=new FV;EV(a,16,.75);return a}function FV(){this.LG=0;this.cb=null;this.Of=this.At=0}FV.prototype=new V9;FV.prototype.constructor=FV;f=FV.prototype;f.Ux=function(a){return S5(this,a)};f.Ol=function(a){return T5(this,a)};f.Gb=function(a){return VY(this,a)};
-f.Ga=function(a){return WY(this,a)};f.zb=function(a){return YY(this,a)};f.ka=function(){return this.Of};f.L=function(a){var b=dy(W(),a);b^=b>>>16|0;var c=this.cb.a[b&(-1+this.cb.a.length|0)];return null!==(null===c?null:ey(c,a,b))};f.Pd=function(a){a=A$(Mc((1+a|0)/this.LG));a>this.cb.a.length&&fy(this,a)};
-function DV(a,b){a.Pd(b.Q());if(b instanceof VU)return b.$b.oJ(new jW((d,e,g)=>{g|=0;y$(a,d,e,g^(g>>>16|0))})),a;if(b instanceof FV){for(b=H0(b);b.s();){var c=b.t();y$(a,c.Kk,c.ph,c.bk)}return a}return b&&b.$classData&&b.$classData.pb.eC?(b.Ag(new Um((d,e)=>{var g=dy(W(),d);return y$(a,d,e,g^(g>>>16|0))})),a):cR(a,b)}
-f.Gt=function(a,b){if(ja(this)!==ma(by))return F8(this,a,b);var c=dy(W(),a);c^=c>>>16|0;var d=c&(-1+this.cb.a.length|0);var e=null;var g=null;var h=this.cb.a[d];if(null!==h)for(var k=null;;){if(c===h.bk&&Ol(Pl(),a,h.Kk))g=k,e=h;else if(!(null===h.Id||h.bk>c)){var l=h.Id;k=h;h=l;continue}break}k=e;k=null===k?R():new M(k.ph);b=b.n(k);k=G(new H,k,b);h=k.z;l=k.x;if(R()!==h||R()!==l)if(h=k.x,k.z instanceof M&&R()===h)null!==g?g.Id=e.Id:this.cb.a[d]=e.Id,this.Of=-1+this.Of|0;else if(g=k.z,h=k.x,R()===g&&
-h instanceof M)e=h.k,d=(1+this.Of|0)>=this.At?(fy(this,this.cb.a.length<<1),c&(-1+this.cb.a.length|0)):d,gy(this,a,e,!1,c,d);else if(a=k.x,k.z instanceof M&&a instanceof M)e.ph=a.k;else throw new x(k);return b};f.m=function(){return 0===this.Of?qq().Oa:new o4(this)};f.oj=function(){return 0===this.Of?qq().Oa:new p4(this)};f.Qd=function(){return 0===this.Of?qq().Oa:new q4(this)};function H0(a){return 0===a.Of?qq().Oa:new r4(a)}f.eg=function(){var a=this.cb;Sj(fk(),a,null);this.Of=0};
-f.Y=function(a){var b=dy(W(),a);b^=b>>>16|0;var c=this.cb.a[b&(-1+this.cb.a.length|0)];a=null===c?null:ey(c,a,b);return null===a?R():new M(a.ph)};f.n=function(a){var b=dy(W(),a);b^=b>>>16|0;var c=this.cb.a[b&(-1+this.cb.a.length|0)];b=null===c?null:ey(c,a,b);return null===b?p3(a):b.ph};f.yd=function(a,b){if(ja(this)!==ma(by))return n3(this,a,b);var c=dy(W(),a);c^=c>>>16|0;var d=this.cb.a[c&(-1+this.cb.a.length|0)];a=null===d?null:ey(d,a,c);return null===a?Zr(b):a.ph};
-f.Ai=function(a,b){if(ja(this)!==ma(by))return G8(this,a,b);var c=dy(W(),a);c^=c>>>16|0;var d=c&(-1+this.cb.a.length|0),e=this.cb.a[d];e=null===e?null:ey(e,a,c);if(null!==e)return e.ph;e=this.cb;b=Zr(b);(1+this.Of|0)>=this.At&&fy(this,this.cb.a.length<<1);gy(this,a,b,!1,c,e===this.cb?d:c&(-1+this.cb.a.length|0));return b};f.Vi=function(a,b){null===cy(this,a,b,!0)&&R()};f.lB=function(a){null===z$(this,a)&&R()};f.Qh=function(a,b){cy(this,a,b,!1)};f.Q=function(){return this.Of};
-f.b=function(){return 0===this.Of};f.ya=function(a){for(var b=this.cb.a.length,c=0;c<b;){var d=this.cb.a[c];null!==d&&d.ya(a);c=1+c|0}};f.Ag=function(a){for(var b=this.cb.a.length,c=0;c<b;){var d=this.cb.a[c];null!==d&&d.Ag(a);c=1+c|0}};f.pj=function(){return ky()};f.Hc=function(){return"HashMap"};f.y=function(){if(this.b())return kL().RF;var a=new s4(this);return lL(kL(),a,kL().Sq)};f.im=function(a){z$(this,a)};f.S=function(a){cy(this,a.i(),a.j(),!1);return this};
-f.oc=function(a){return DV(this,a)};var by=q({Z8:0},!1,"scala.collection.mutable.HashMap",{Z8:1,JG:1,$l:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Ak:1,Uj:1,za:1,ja:1,dm:1,v:1,eC:1,Vg:1,RG:1,Ug:1,vf:1,og:1,lf:1,kf:1,nn:1,Ab:1,vG:1,l:1});FV.prototype.$classData=by;function B$(a,b,c,d){a.$=c;a.ba=d;a.R=b}function o$(){this.$=this.R=null;this.ba=0}o$.prototype=new x$;o$.prototype.constructor=o$;function C$(){}C$.prototype=o$.prototype;
-function p$(a,b){for(var c=a.rn(),d=1;d<c;){var e=sJ(),g=c/2|0,h=d-g|0;EJ(e,-1+((1+g|0)-(0>h?-h|0:h)|0)|0,a.oo(d),b);d=1+d|0}}function rJ(a){this.R=a}rJ.prototype=new x$;rJ.prototype.constructor=rJ;f=rJ.prototype;f.ua=function(a){if(0<=a&&a<this.R.a.length)return this.R.a[a];throw this.hh(a);};f.qr=function(a,b){if(0<=a&&a<this.R.a.length){var c=this.R.ga();c.a[a]=b;return new rJ(c)}throw this.hh(a);};
-f.Im=function(a){if(32>this.R.a.length)return new rJ(AJ(sJ(),this.R,a));var b=this.R,c=sJ().Sc,d=new jd(1);d.a[0]=a;return new tJ(b,32,c,d,33)};f.pl=function(a){var b=this.R.a.length;if(32>b)return new rJ(CJ(sJ(),a,this.R));var c=new jd(1);c.a[0]=a;return new tJ(c,1,sJ().Sc,this.R,1+b|0)};f.Tn=function(a){return new rJ(FJ(sJ(),this.R,a))};f.pn=function(a,b){var c=this.R;return new rJ(ck(fk(),c,a,b))};
-f.jm=function(){if(1===this.R.a.length)return qJ();var a=this.R,b=a.a.length;return new rJ(ck(fk(),a,1,b))};f.rn=function(){return 1};f.oo=function(){return this.R};f.el=function(a,b){var c=HJ(sJ(),this.R,a);return null!==c?new rJ(c):r1.prototype.el.call(this,a,b)};f.g=function(){return this.jm()};f.Ga=function(a){return this.Tn(a)};f.Zb=function(a){return this.pl(a)};f.n=function(a){a|=0;if(0<=a&&a<this.R.a.length)return this.R.a[a];throw this.hh(a);};
-f.$classData=q({l8:0},!1,"scala.collection.immutable.Vector1",{l8:1,Dy:1,Cy:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,jg:1,l:1});function A(a,b){this.A=a;this.r=b}A.prototype=new v$;A.prototype.constructor=A;f=A.prototype;f.e=function(){return this.A};f.H=function(){return"::"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.A;case 1:return this.r;default:return JK(W(),a)}};f.g=function(){return this.r};
-f.Og=function(){return new M(this.A)};f.$classData=q({$5:0},!1,"scala.collection.immutable.$colon$colon",{$5:1,M6:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,sL:1,gG:1,AR:1,XR:1,B5:1,$c:1,Ab:1,Kh:1,jg:1,l:1,F:1});function D$(){this.eS=null;E$=this;this.eS=G(new H,v(),v())}D$.prototype=new v$;D$.prototype.constructor=D$;f=D$.prototype;f.tJ=function(){throw iH("head of empty list");};f.Q=function(){return 0};f.m=function(){return qq().Oa};f.Gb=function(){return this.eS};
-f.H=function(){return"Nil"};f.G=function(){return 0};f.I=function(a){return JK(W(),a)};f.uJ=function(){throw Fu("init of empty list");};f.Fc=function(){throw iH("last of empty list");};f.g=function(){throw Fu("tail of empty list");};f.Og=function(){return R()};f.e=function(){this.tJ()};f.$classData=q({o7:0},!1,"scala.collection.immutable.Nil$",{o7:1,M6:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,sL:1,gG:1,AR:1,XR:1,B5:1,$c:1,Ab:1,Kh:1,jg:1,l:1,F:1});var E$;
-function v(){E$||(E$=new D$);return E$}function F$(a,b){return b===a.xf?a:qZ(new pZ,b,a.Ce)}function G$(a,b){if(null===b)throw ze();return b.qb?b.sb:Ce(b,new BV(a))}function qZ(a,b,c){a.xf=b;a.Ce=c;if(null===c)throw YK("ordering must not be null");return a}function vZ(a){var b=new pZ;qZ(b,null,a);return b}function pZ(){this.Ce=this.xf=null}pZ.prototype=new U8;pZ.prototype.constructor=pZ;f=pZ.prototype;f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.Hc=function(){return"SortedSet"};
-f.hi=function(){return new uZ(this.Ce)};f.Wd=function(){return this.Ce};f.ka=function(){return nI(XI(),this.xf)};f.b=function(){return 0===nI(XI(),this.xf)};f.e=function(){return RI(XI(),this.xf).Wa};f.Fc=function(){return SI(XI(),this.xf).Wa};f.Ui=function(a){return a!==this.Ce||this.b()?k5(this,a):this.e()};f.Ti=function(a){return a!==this.Ce||this.b()?l5(this,a):this.Fc()};f.ya=function(a){var b=XI(),c=this.xf;null!==c&&Wba(b,c,a)};
-f.m=function(){XI();var a=this.xf;XI();var b=R();return new W3(a,b,this.Ce)};f.L=function(a){XI();return null!==PI(0,this.xf,a,this.Ce)};function Tea(a,b){return F$(a,UI(XI(),a.xf,new Um(c=>!!b.n(c))))}
-f.h=function(a){if(a instanceof pZ){var b=this.Ce,c=a.Ce;if(null===b?null===c:b.h(c)){XI();b=this.xf;a=a.xf;c=this.Ce;var d;if(!(d=b===a)&&(d=null!==b)&&(d=null!==a)&&(d=(2147483647&b.da)===(2147483647&a.da))){b=new V3(b,c);a=new V3(a,c);for(c=!0;c&&null!==b.zc&&null!==a.zc;)b.zc===a.zc?(0===b.Ed?d=null:(b.Ed=-1+b.Ed|0,d=b.fn.a[b.Ed]),b.zc=d,0===a.Ed?d=null:(a.Ed=-1+a.Ed|0,d=a.fn.a[a.Ed]),a.zc=d):(c=Object.is(b.zc.Wa,a.zc.Wa)?!0:b.Gv.lj(b.zc.Wa,a.zc.Wa),b.zc=g1(b,b.zc.sa),a.zc=g1(a,a.zc.sa));d=c&&
-null===b.zc&&null===a.zc}return d}}return E8(this,a)};f.xh=function(){return"TreeSet"};f.qc=function(a){return oZ(xZ(),a,this.Ce)};f.vk=function(a){return oZ(xZ(),a,this.Ce)};f.uk=function(a){return Tea(this,a)};f.Zx=function(a){a:{if(a instanceof pZ){var b=this.Ce,c=a.Ce;if(null===b?null===c:b.h(c)){b=XI();a=ZH(GI(b,this.xf,a.xf,this.Ce));a=F$(this,a);break a}}b=new xf;a=a.m();c=b.qb?b.sb:G$(this,b);KG(a,c);a=F$(this,(b.qb?b.sb:G$(this,b)).HG)}return a};
-f.af=function(a){a:{if(a instanceof pZ){var b=this.Ce,c=a.Ce;if(null===b?null===c:b.h(c)){a=WI(XI(),this.xf,a.xf,this.Ce);break a}}a=a.m();for(b=this.xf;a.s();)b=QI(XI(),b,a.t(),null,!1,this.Ce);a=b}return F$(this,a)};f.tk=function(a){var b=XI();a=ZH(yI(b,this.xf,a,this.Ce));return F$(this,a)};f.Yb=function(a){return F$(this,QI(XI(),this.xf,a,null,!1,this.Ce))};
-f.zb=function(a){var b=nI(XI(),this.xf)-(0<a?a:0)|0;if(0>=b)a=vZ(this.Ce);else if(b>=nI(XI(),this.xf))a=this;else{a=new pZ;var c=XI();b=ZH(qI(c,this.xf,b));a=qZ(a,b,this.Ce)}return a};f.Cc=function(a){if(0>=a)var b=this;else if(a>=nI(XI(),this.xf))b=vZ(this.Ce);else{b=new pZ;var c=XI();a=ZH(pI(c,this.xf,a));b=qZ(b,a,this.Ce)}return b};
-f.$classData=q({f8:0},!1,"scala.collection.immutable.TreeSet",{f8:1,Vq:1,am:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Vj:1,sl:1,ja:1,v:1,tp:1,sc:1,gr:1,wL:1,tG:1,NR:1,ly:1,MR:1,Y7:1,nba:1,kba:1,D5:1,Ab:1,$7:1,jg:1,l:1});function H$(){this.$=this.R=null;this.ba=0;B$(this,sJ().xL,sJ().xL,0)}H$.prototype=new C$;H$.prototype.constructor=H$;f=H$.prototype;f.qr=function(a){throw this.hh(a);};f.Im=function(a){var b=new jd(1);b.a[0]=a;return new rJ(b)};f.pl=function(a){var b=new jd(1);b.a[0]=a;return new rJ(b)};
-f.jm=function(){throw Fu("empty.tail");};f.pn=function(){return this};f.rn=function(){return 0};f.oo=function(){return null};f.h=function(a){return this===a||!(a instanceof r1)&&Z2(this,a)};f.el=function(a){return rU(pK(),a)};f.hh=function(a){return KK(new LK,a+" is out of bounds (empty vector)")};f.g=function(){return this.jm()};f.Ga=function(){return this};f.Zb=function(a){return this.pl(a)};f.n=function(a){throw this.hh(a|0);};f.ua=function(a){throw this.hh(a);};
-f.$classData=q({k8:0},!1,"scala.collection.immutable.Vector0$",{k8:1,HB:1,Dy:1,Cy:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,jg:1,l:1});var I$;function qJ(){I$||(I$=new H$);return I$}function tJ(a,b,c,d,e){this.$=this.R=null;this.ba=0;this.Ji=b;this.nh=c;B$(this,a,d,e)}tJ.prototype=new C$;tJ.prototype.constructor=tJ;f=tJ.prototype;
-f.ua=function(a){if(0<=a&&a<this.ba){var b=a-this.Ji|0;return 0<=b?(a=b>>>5|0,a<this.nh.a.length?this.nh.a[a].a[31&b]:this.$.a[31&b]):this.R.a[a]}throw this.hh(a);};
-f.qr=function(a,b){if(0<=a&&a<this.ba){if(a>=this.Ji){var c=a-this.Ji|0;a=c>>>5|0;c&=31;if(a<this.nh.a.length){var d=this.nh.ga(),e=d.a[a].ga();e.a[c]=b;d.a[a]=e;return new tJ(this.R,this.Ji,d,this.$,this.ba)}a=this.$.ga();a.a[c]=b;return new tJ(this.R,this.Ji,this.nh,a,this.ba)}c=this.R.ga();c.a[a]=b;return new tJ(c,this.Ji,this.nh,this.$,this.ba)}throw this.hh(a);};
-f.Im=function(a){if(32>this.$.a.length)return a=AJ(sJ(),this.$,a),new tJ(this.R,this.Ji,this.nh,a,1+this.ba|0);if(30>this.nh.a.length){var b=BJ(sJ(),this.nh,this.$),c=new jd(1);c.a[0]=a;return new tJ(this.R,this.Ji,b,c,1+this.ba|0)}b=this.R;c=this.Ji;var d=this.nh,e=this.Ji,g=sJ().Xf,h=this.$,k=new (Nd(Nd(Md)).Ja)(1);k.a[0]=h;h=new jd(1);h.a[0]=a;return new uJ(b,c,d,960+e|0,g,k,h,1+this.ba|0)};
-f.pl=function(a){if(32>this.Ji){var b=CJ(sJ(),a,this.R);return new tJ(b,1+this.Ji|0,this.nh,this.$,1+this.ba|0)}if(30>this.nh.a.length)return b=new jd(1),b.a[0]=a,a=DJ(sJ(),this.R,this.nh),new tJ(b,1,a,this.$,1+this.ba|0);b=new jd(1);b.a[0]=a;a=this.R;var c=new (Nd(Nd(Md)).Ja)(1);c.a[0]=a;return new uJ(b,1,c,1+this.Ji|0,sJ().Xf,this.nh,this.$,1+this.ba|0)};f.Tn=function(a){var b=FJ(sJ(),this.R,a),c=GJ(sJ(),2,this.nh,a);a=FJ(sJ(),this.$,a);return new tJ(b,this.Ji,c,a,this.ba)};
-f.pn=function(a,b){a=new oJ(a,b);pJ(a,1,this.R);pJ(a,2,this.nh);pJ(a,1,this.$);return a.Vl()};f.jm=function(){if(1<this.Ji){var a=this.R,b=a.a.length;a=ck(fk(),a,1,b);return new tJ(a,-1+this.Ji|0,this.nh,this.$,-1+this.ba|0)}return this.pn(1,this.ba)};f.rn=function(){return 3};f.oo=function(a){switch(a){case 0:return this.R;case 1:return this.nh;case 2:return this.$;default:throw new x(a);}};
-f.el=function(a,b){var c=HJ(sJ(),this.$,a);return null!==c?new tJ(this.R,this.Ji,this.nh,c,(this.ba-this.$.a.length|0)+c.a.length|0):r1.prototype.el.call(this,a,b)};f.g=function(){return this.jm()};f.Ga=function(a){return this.Tn(a)};f.Zb=function(a){return this.pl(a)};f.n=function(a){var b=a|0;if(0<=b&&b<this.ba)return a=b-this.Ji|0,0<=a?(b=a>>>5|0,b<this.nh.a.length?this.nh.a[b].a[31&a]:this.$.a[31&a]):this.R.a[b];throw this.hh(b);};
-f.$classData=q({m8:0},!1,"scala.collection.immutable.Vector2",{m8:1,HB:1,Dy:1,Cy:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,jg:1,l:1});function uJ(a,b,c,d,e,g,h,k){this.$=this.R=null;this.ba=0;this.Lh=b;this.Mh=c;this.oh=d;this.Vf=e;this.kg=g;B$(this,a,h,k)}uJ.prototype=new C$;uJ.prototype.constructor=uJ;f=uJ.prototype;
-f.ua=function(a){if(0<=a&&a<this.ba){var b=a-this.oh|0;if(0<=b){a=b>>>10|0;var c=31&(b>>>5|0);b&=31;return a<this.Vf.a.length?this.Vf.a[a].a[c].a[b]:c<this.kg.a.length?this.kg.a[c].a[b]:this.$.a[b]}return a>=this.Lh?(b=a-this.Lh|0,this.Mh.a[b>>>5|0].a[31&b]):this.R.a[a]}throw this.hh(a);};
-f.qr=function(a,b){if(0<=a&&a<this.ba){if(a>=this.oh){var c=a-this.oh|0,d=c>>>10|0;a=31&(c>>>5|0);c&=31;if(d<this.Vf.a.length){var e=this.Vf.ga(),g=e.a[d].ga(),h=g.a[a].ga();h.a[c]=b;g.a[a]=h;e.a[d]=g;return new uJ(this.R,this.Lh,this.Mh,this.oh,e,this.kg,this.$,this.ba)}if(a<this.kg.a.length)return d=this.kg.ga(),e=d.a[a].ga(),e.a[c]=b,d.a[a]=e,new uJ(this.R,this.Lh,this.Mh,this.oh,this.Vf,d,this.$,this.ba);a=this.$.ga();a.a[c]=b;return new uJ(this.R,this.Lh,this.Mh,this.oh,this.Vf,this.kg,a,this.ba)}if(a>=
-this.Lh)return c=a-this.Lh|0,a=c>>>5|0,c&=31,d=this.Mh.ga(),e=d.a[a].ga(),e.a[c]=b,d.a[a]=e,new uJ(this.R,this.Lh,d,this.oh,this.Vf,this.kg,this.$,this.ba);c=this.R.ga();c.a[a]=b;return new uJ(c,this.Lh,this.Mh,this.oh,this.Vf,this.kg,this.$,this.ba)}throw this.hh(a);};
-f.Im=function(a){if(32>this.$.a.length)return a=AJ(sJ(),this.$,a),new uJ(this.R,this.Lh,this.Mh,this.oh,this.Vf,this.kg,a,1+this.ba|0);if(31>this.kg.a.length){var b=BJ(sJ(),this.kg,this.$),c=new jd(1);c.a[0]=a;return new uJ(this.R,this.Lh,this.Mh,this.oh,this.Vf,b,c,1+this.ba|0)}if(30>this.Vf.a.length){b=BJ(sJ(),this.Vf,BJ(sJ(),this.kg,this.$));c=sJ().Sc;var d=new jd(1);d.a[0]=a;return new uJ(this.R,this.Lh,this.Mh,this.oh,b,c,d,1+this.ba|0)}b=this.R;c=this.Lh;d=this.Mh;var e=this.oh,g=this.Vf,h=
-this.oh,k=sJ().Zj,l=BJ(sJ(),this.kg,this.$),m=new (Nd(Nd(Nd(Md))).Ja)(1);m.a[0]=l;l=sJ().Sc;var n=new jd(1);n.a[0]=a;return new vJ(b,c,d,e,g,30720+h|0,k,m,l,n,1+this.ba|0)};
-f.pl=function(a){if(32>this.Lh){var b=CJ(sJ(),a,this.R);return new uJ(b,1+this.Lh|0,this.Mh,1+this.oh|0,this.Vf,this.kg,this.$,1+this.ba|0)}if(1024>this.oh)return b=new jd(1),b.a[0]=a,a=DJ(sJ(),this.R,this.Mh),new uJ(b,1,a,1+this.oh|0,this.Vf,this.kg,this.$,1+this.ba|0);if(30>this.Vf.a.length){b=new jd(1);b.a[0]=a;a=sJ().Sc;var c=DJ(sJ(),DJ(sJ(),this.R,this.Mh),this.Vf);return new uJ(b,1,a,1,c,this.kg,this.$,1+this.ba|0)}b=new jd(1);b.a[0]=a;a=sJ().Sc;c=DJ(sJ(),this.R,this.Mh);var d=new (Nd(Nd(Nd(Md))).Ja)(1);
-d.a[0]=c;return new vJ(b,1,a,1,d,1+this.oh|0,sJ().Zj,this.Vf,this.kg,this.$,1+this.ba|0)};f.Tn=function(a){var b=FJ(sJ(),this.R,a),c=GJ(sJ(),2,this.Mh,a),d=GJ(sJ(),3,this.Vf,a),e=GJ(sJ(),2,this.kg,a);a=FJ(sJ(),this.$,a);return new uJ(b,this.Lh,c,this.oh,d,e,a,this.ba)};f.pn=function(a,b){a=new oJ(a,b);pJ(a,1,this.R);pJ(a,2,this.Mh);pJ(a,3,this.Vf);pJ(a,2,this.kg);pJ(a,1,this.$);return a.Vl()};
-f.jm=function(){if(1<this.Lh){var a=this.R,b=a.a.length;a=ck(fk(),a,1,b);return new uJ(a,-1+this.Lh|0,this.Mh,-1+this.oh|0,this.Vf,this.kg,this.$,-1+this.ba|0)}return this.pn(1,this.ba)};f.rn=function(){return 5};f.oo=function(a){switch(a){case 0:return this.R;case 1:return this.Mh;case 2:return this.Vf;case 3:return this.kg;case 4:return this.$;default:throw new x(a);}};
-f.el=function(a,b){var c=HJ(sJ(),this.$,a);return null!==c?new uJ(this.R,this.Lh,this.Mh,this.oh,this.Vf,this.kg,c,(this.ba-this.$.a.length|0)+c.a.length|0):r1.prototype.el.call(this,a,b)};f.g=function(){return this.jm()};f.Ga=function(a){return this.Tn(a)};f.Zb=function(a){return this.pl(a)};
-f.n=function(a){var b=a|0;if(0<=b&&b<this.ba){a=b-this.oh|0;if(0<=a){b=a>>>10|0;var c=31&(a>>>5|0);a&=31;return b<this.Vf.a.length?this.Vf.a[b].a[c].a[a]:c<this.kg.a.length?this.kg.a[c].a[a]:this.$.a[a]}return b>=this.Lh?(a=b-this.Lh|0,this.Mh.a[a>>>5|0].a[31&a]):this.R.a[b]}throw this.hh(b);};f.$classData=q({n8:0},!1,"scala.collection.immutable.Vector3",{n8:1,HB:1,Dy:1,Cy:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,jg:1,l:1});
-function vJ(a,b,c,d,e,g,h,k,l,m,n){this.$=this.R=null;this.ba=0;this.Eg=b;this.lg=c;this.Fg=d;this.mg=e;this.Wf=g;this.De=h;this.df=k;this.cf=l;B$(this,a,m,n)}vJ.prototype=new C$;vJ.prototype.constructor=vJ;f=vJ.prototype;
-f.ua=function(a){if(0<=a&&a<this.ba){var b=a-this.Wf|0;if(0<=b){a=b>>>15|0;var c=31&(b>>>10|0),d=31&(b>>>5|0);b&=31;return a<this.De.a.length?this.De.a[a].a[c].a[d].a[b]:c<this.df.a.length?this.df.a[c].a[d].a[b]:d<this.cf.a.length?this.cf.a[d].a[b]:this.$.a[b]}return a>=this.Fg?(b=a-this.Fg|0,this.mg.a[b>>>10|0].a[31&(b>>>5|0)].a[31&b]):a>=this.Eg?(b=a-this.Eg|0,this.lg.a[b>>>5|0].a[31&b]):this.R.a[a]}throw this.hh(a);};
-f.qr=function(a,b){if(0<=a&&a<this.ba){if(a>=this.Wf){var c=a-this.Wf|0,d=c>>>15|0,e=31&(c>>>10|0);a=31&(c>>>5|0);c&=31;if(d<this.De.a.length){var g=this.De.ga(),h=g.a[d].ga(),k=h.a[e].ga(),l=k.a[a].ga();l.a[c]=b;k.a[a]=l;h.a[e]=k;g.a[d]=h;return new vJ(this.R,this.Eg,this.lg,this.Fg,this.mg,this.Wf,g,this.df,this.cf,this.$,this.ba)}if(e<this.df.a.length)return d=this.df.ga(),g=d.a[e].ga(),h=g.a[a].ga(),h.a[c]=b,g.a[a]=h,d.a[e]=g,new vJ(this.R,this.Eg,this.lg,this.Fg,this.mg,this.Wf,this.De,d,this.cf,
-this.$,this.ba);if(a<this.cf.a.length)return e=this.cf.ga(),d=e.a[a].ga(),d.a[c]=b,e.a[a]=d,new vJ(this.R,this.Eg,this.lg,this.Fg,this.mg,this.Wf,this.De,this.df,e,this.$,this.ba);a=this.$.ga();a.a[c]=b;return new vJ(this.R,this.Eg,this.lg,this.Fg,this.mg,this.Wf,this.De,this.df,this.cf,a,this.ba)}if(a>=this.Fg)return e=a-this.Fg|0,a=e>>>10|0,c=31&(e>>>5|0),e&=31,d=this.mg.ga(),g=d.a[a].ga(),h=g.a[c].ga(),h.a[e]=b,g.a[c]=h,d.a[a]=g,new vJ(this.R,this.Eg,this.lg,this.Fg,d,this.Wf,this.De,this.df,this.cf,
-this.$,this.ba);if(a>=this.Eg)return c=a-this.Eg|0,a=c>>>5|0,c&=31,e=this.lg.ga(),d=e.a[a].ga(),d.a[c]=b,e.a[a]=d,new vJ(this.R,this.Eg,e,this.Fg,this.mg,this.Wf,this.De,this.df,this.cf,this.$,this.ba);c=this.R.ga();c.a[a]=b;return new vJ(c,this.Eg,this.lg,this.Fg,this.mg,this.Wf,this.De,this.df,this.cf,this.$,this.ba)}throw this.hh(a);};
-f.Im=function(a){if(32>this.$.a.length)return a=AJ(sJ(),this.$,a),new vJ(this.R,this.Eg,this.lg,this.Fg,this.mg,this.Wf,this.De,this.df,this.cf,a,1+this.ba|0);if(31>this.cf.a.length){var b=BJ(sJ(),this.cf,this.$),c=new jd(1);c.a[0]=a;return new vJ(this.R,this.Eg,this.lg,this.Fg,this.mg,this.Wf,this.De,this.df,b,c,1+this.ba|0)}if(31>this.df.a.length){b=BJ(sJ(),this.df,BJ(sJ(),this.cf,this.$));c=sJ().Sc;var d=new jd(1);d.a[0]=a;return new vJ(this.R,this.Eg,this.lg,this.Fg,this.mg,this.Wf,this.De,b,
-c,d,1+this.ba|0)}if(30>this.De.a.length){b=BJ(sJ(),this.De,BJ(sJ(),this.df,BJ(sJ(),this.cf,this.$)));c=sJ().Xf;d=sJ().Sc;var e=new jd(1);e.a[0]=a;return new vJ(this.R,this.Eg,this.lg,this.Fg,this.mg,this.Wf,b,c,d,e,1+this.ba|0)}b=this.R;c=this.Eg;d=this.lg;e=this.Fg;var g=this.mg,h=this.Wf,k=this.De,l=this.Wf,m=sJ().wt,n=BJ(sJ(),this.df,BJ(sJ(),this.cf,this.$)),r=new (Nd(Nd(Nd(Nd(Md)))).Ja)(1);r.a[0]=n;n=sJ().Xf;var u=sJ().Sc,w=new jd(1);w.a[0]=a;return new wJ(b,c,d,e,g,h,k,983040+l|0,m,r,n,u,w,1+
-this.ba|0)};
-f.pl=function(a){if(32>this.Eg){var b=CJ(sJ(),a,this.R);return new vJ(b,1+this.Eg|0,this.lg,1+this.Fg|0,this.mg,1+this.Wf|0,this.De,this.df,this.cf,this.$,1+this.ba|0)}if(1024>this.Fg)return b=new jd(1),b.a[0]=a,a=DJ(sJ(),this.R,this.lg),new vJ(b,1,a,1+this.Fg|0,this.mg,1+this.Wf|0,this.De,this.df,this.cf,this.$,1+this.ba|0);if(32768>this.Wf){b=new jd(1);b.a[0]=a;a=sJ().Sc;var c=DJ(sJ(),DJ(sJ(),this.R,this.lg),this.mg);return new vJ(b,1,a,1,c,1+this.Wf|0,this.De,this.df,this.cf,this.$,1+this.ba|0)}if(30>
-this.De.a.length){b=new jd(1);b.a[0]=a;a=sJ().Sc;c=sJ().Xf;var d=DJ(sJ(),DJ(sJ(),DJ(sJ(),this.R,this.lg),this.mg),this.De);return new vJ(b,1,a,1,c,1,d,this.df,this.cf,this.$,1+this.ba|0)}b=new jd(1);b.a[0]=a;a=sJ().Sc;c=sJ().Xf;d=DJ(sJ(),DJ(sJ(),this.R,this.lg),this.mg);var e=new (Nd(Nd(Nd(Nd(Md)))).Ja)(1);e.a[0]=d;return new wJ(b,1,a,1,c,1,e,1+this.Wf|0,sJ().wt,this.De,this.df,this.cf,this.$,1+this.ba|0)};
-f.Tn=function(a){var b=FJ(sJ(),this.R,a),c=GJ(sJ(),2,this.lg,a),d=GJ(sJ(),3,this.mg,a),e=GJ(sJ(),4,this.De,a),g=GJ(sJ(),3,this.df,a),h=GJ(sJ(),2,this.cf,a);a=FJ(sJ(),this.$,a);return new vJ(b,this.Eg,c,this.Fg,d,this.Wf,e,g,h,a,this.ba)};f.pn=function(a,b){a=new oJ(a,b);pJ(a,1,this.R);pJ(a,2,this.lg);pJ(a,3,this.mg);pJ(a,4,this.De);pJ(a,3,this.df);pJ(a,2,this.cf);pJ(a,1,this.$);return a.Vl()};
-f.jm=function(){if(1<this.Eg){var a=this.R,b=a.a.length;a=ck(fk(),a,1,b);return new vJ(a,-1+this.Eg|0,this.lg,-1+this.Fg|0,this.mg,-1+this.Wf|0,this.De,this.df,this.cf,this.$,-1+this.ba|0)}return this.pn(1,this.ba)};f.rn=function(){return 7};f.oo=function(a){switch(a){case 0:return this.R;case 1:return this.lg;case 2:return this.mg;case 3:return this.De;case 4:return this.df;case 5:return this.cf;case 6:return this.$;default:throw new x(a);}};
-f.el=function(a,b){var c=HJ(sJ(),this.$,a);return null!==c?new vJ(this.R,this.Eg,this.lg,this.Fg,this.mg,this.Wf,this.De,this.df,this.cf,c,(this.ba-this.$.a.length|0)+c.a.length|0):r1.prototype.el.call(this,a,b)};f.g=function(){return this.jm()};f.Ga=function(a){return this.Tn(a)};f.Zb=function(a){return this.pl(a)};
-f.n=function(a){var b=a|0;if(0<=b&&b<this.ba){a=b-this.Wf|0;if(0<=a){b=a>>>15|0;var c=31&(a>>>10|0),d=31&(a>>>5|0);a&=31;return b<this.De.a.length?this.De.a[b].a[c].a[d].a[a]:c<this.df.a.length?this.df.a[c].a[d].a[a]:d<this.cf.a.length?this.cf.a[d].a[a]:this.$.a[a]}return b>=this.Fg?(a=b-this.Fg|0,this.mg.a[a>>>10|0].a[31&(a>>>5|0)].a[31&a]):b>=this.Eg?(a=b-this.Eg|0,this.lg.a[a>>>5|0].a[31&a]):this.R.a[b]}throw this.hh(b);};
-f.$classData=q({o8:0},!1,"scala.collection.immutable.Vector4",{o8:1,HB:1,Dy:1,Cy:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,jg:1,l:1});function wJ(a,b,c,d,e,g,h,k,l,m,n,r,u,w){this.$=this.R=null;this.ba=0;this.Mf=b;this.ef=c;this.Nf=d;this.ff=e;this.yf=g;this.gf=h;this.Ee=k;this.Fd=l;this.Od=m;this.Nd=n;this.Md=r;B$(this,a,u,w)}wJ.prototype=new C$;wJ.prototype.constructor=wJ;f=wJ.prototype;
-f.ua=function(a){if(0<=a&&a<this.ba){var b=a-this.Ee|0;if(0<=b){a=b>>>20|0;var c=31&(b>>>15|0),d=31&(b>>>10|0),e=31&(b>>>5|0);b&=31;return a<this.Fd.a.length?this.Fd.a[a].a[c].a[d].a[e].a[b]:c<this.Od.a.length?this.Od.a[c].a[d].a[e].a[b]:d<this.Nd.a.length?this.Nd.a[d].a[e].a[b]:e<this.Md.a.length?this.Md.a[e].a[b]:this.$.a[b]}return a>=this.yf?(b=a-this.yf|0,this.gf.a[b>>>15|0].a[31&(b>>>10|0)].a[31&(b>>>5|0)].a[31&b]):a>=this.Nf?(b=a-this.Nf|0,this.ff.a[b>>>10|0].a[31&(b>>>5|0)].a[31&b]):a>=this.Mf?
-(b=a-this.Mf|0,this.ef.a[b>>>5|0].a[31&b]):this.R.a[a]}throw this.hh(a);};
-f.qr=function(a,b){if(0<=a&&a<this.ba){if(a>=this.Ee){var c=a-this.Ee|0,d=c>>>20|0,e=31&(c>>>15|0),g=31&(c>>>10|0);a=31&(c>>>5|0);c&=31;if(d<this.Fd.a.length){var h=this.Fd.ga(),k=h.a[d].ga(),l=k.a[e].ga(),m=l.a[g].ga(),n=m.a[a].ga();n.a[c]=b;m.a[a]=n;l.a[g]=m;k.a[e]=l;h.a[d]=k;return new wJ(this.R,this.Mf,this.ef,this.Nf,this.ff,this.yf,this.gf,this.Ee,h,this.Od,this.Nd,this.Md,this.$,this.ba)}if(e<this.Od.a.length)return d=this.Od.ga(),h=d.a[e].ga(),k=h.a[g].ga(),l=k.a[a].ga(),l.a[c]=b,k.a[a]=l,
-h.a[g]=k,d.a[e]=h,new wJ(this.R,this.Mf,this.ef,this.Nf,this.ff,this.yf,this.gf,this.Ee,this.Fd,d,this.Nd,this.Md,this.$,this.ba);if(g<this.Nd.a.length)return e=this.Nd.ga(),d=e.a[g].ga(),h=d.a[a].ga(),h.a[c]=b,d.a[a]=h,e.a[g]=d,new wJ(this.R,this.Mf,this.ef,this.Nf,this.ff,this.yf,this.gf,this.Ee,this.Fd,this.Od,e,this.Md,this.$,this.ba);if(a<this.Md.a.length)return g=this.Md.ga(),e=g.a[a].ga(),e.a[c]=b,g.a[a]=e,new wJ(this.R,this.Mf,this.ef,this.Nf,this.ff,this.yf,this.gf,this.Ee,this.Fd,this.Od,
-this.Nd,g,this.$,this.ba);a=this.$.ga();a.a[c]=b;return new wJ(this.R,this.Mf,this.ef,this.Nf,this.ff,this.yf,this.gf,this.Ee,this.Fd,this.Od,this.Nd,this.Md,a,this.ba)}if(a>=this.yf)return e=a-this.yf|0,a=e>>>15|0,c=31&(e>>>10|0),g=31&(e>>>5|0),e&=31,d=this.gf.ga(),h=d.a[a].ga(),k=h.a[c].ga(),l=k.a[g].ga(),l.a[e]=b,k.a[g]=l,h.a[c]=k,d.a[a]=h,new wJ(this.R,this.Mf,this.ef,this.Nf,this.ff,this.yf,d,this.Ee,this.Fd,this.Od,this.Nd,this.Md,this.$,this.ba);if(a>=this.Nf)return g=a-this.Nf|0,a=g>>>10|
-0,c=31&(g>>>5|0),g&=31,e=this.ff.ga(),d=e.a[a].ga(),h=d.a[c].ga(),h.a[g]=b,d.a[c]=h,e.a[a]=d,new wJ(this.R,this.Mf,this.ef,this.Nf,e,this.yf,this.gf,this.Ee,this.Fd,this.Od,this.Nd,this.Md,this.$,this.ba);if(a>=this.Mf)return c=a-this.Mf|0,a=c>>>5|0,c&=31,g=this.ef.ga(),e=g.a[a].ga(),e.a[c]=b,g.a[a]=e,new wJ(this.R,this.Mf,g,this.Nf,this.ff,this.yf,this.gf,this.Ee,this.Fd,this.Od,this.Nd,this.Md,this.$,this.ba);c=this.R.ga();c.a[a]=b;return new wJ(c,this.Mf,this.ef,this.Nf,this.ff,this.yf,this.gf,
-this.Ee,this.Fd,this.Od,this.Nd,this.Md,this.$,this.ba)}throw this.hh(a);};
-f.Im=function(a){if(32>this.$.a.length)return a=AJ(sJ(),this.$,a),new wJ(this.R,this.Mf,this.ef,this.Nf,this.ff,this.yf,this.gf,this.Ee,this.Fd,this.Od,this.Nd,this.Md,a,1+this.ba|0);if(31>this.Md.a.length){var b=BJ(sJ(),this.Md,this.$),c=new jd(1);c.a[0]=a;return new wJ(this.R,this.Mf,this.ef,this.Nf,this.ff,this.yf,this.gf,this.Ee,this.Fd,this.Od,this.Nd,b,c,1+this.ba|0)}if(31>this.Nd.a.length){b=BJ(sJ(),this.Nd,BJ(sJ(),this.Md,this.$));c=sJ().Sc;var d=new jd(1);d.a[0]=a;return new wJ(this.R,this.Mf,
-this.ef,this.Nf,this.ff,this.yf,this.gf,this.Ee,this.Fd,this.Od,b,c,d,1+this.ba|0)}if(31>this.Od.a.length){b=BJ(sJ(),this.Od,BJ(sJ(),this.Nd,BJ(sJ(),this.Md,this.$)));c=sJ().Xf;d=sJ().Sc;var e=new jd(1);e.a[0]=a;return new wJ(this.R,this.Mf,this.ef,this.Nf,this.ff,this.yf,this.gf,this.Ee,this.Fd,b,c,d,e,1+this.ba|0)}if(30>this.Fd.a.length){b=BJ(sJ(),this.Fd,BJ(sJ(),this.Od,BJ(sJ(),this.Nd,BJ(sJ(),this.Md,this.$))));c=sJ().Zj;d=sJ().Xf;e=sJ().Sc;var g=new jd(1);g.a[0]=a;return new wJ(this.R,this.Mf,
-this.ef,this.Nf,this.ff,this.yf,this.gf,this.Ee,b,c,d,e,g,1+this.ba|0)}b=this.R;c=this.Mf;d=this.ef;e=this.Nf;g=this.ff;var h=this.yf,k=this.gf,l=this.Ee,m=this.Fd,n=this.Ee,r=sJ().IG,u=BJ(sJ(),this.Od,BJ(sJ(),this.Nd,BJ(sJ(),this.Md,this.$))),w=new (Nd(Nd(Nd(Nd(Nd(Md))))).Ja)(1);w.a[0]=u;u=sJ().Zj;var y=sJ().Xf,B=sJ().Sc,D=new jd(1);D.a[0]=a;return new xJ(b,c,d,e,g,h,k,l,m,31457280+n|0,r,w,u,y,B,D,1+this.ba|0)};
-f.pl=function(a){if(32>this.Mf){var b=CJ(sJ(),a,this.R);return new wJ(b,1+this.Mf|0,this.ef,1+this.Nf|0,this.ff,1+this.yf|0,this.gf,1+this.Ee|0,this.Fd,this.Od,this.Nd,this.Md,this.$,1+this.ba|0)}if(1024>this.Nf)return b=new jd(1),b.a[0]=a,a=DJ(sJ(),this.R,this.ef),new wJ(b,1,a,1+this.Nf|0,this.ff,1+this.yf|0,this.gf,1+this.Ee|0,this.Fd,this.Od,this.Nd,this.Md,this.$,1+this.ba|0);if(32768>this.yf){b=new jd(1);b.a[0]=a;a=sJ().Sc;var c=DJ(sJ(),DJ(sJ(),this.R,this.ef),this.ff);return new wJ(b,1,a,1,
-c,1+this.yf|0,this.gf,1+this.Ee|0,this.Fd,this.Od,this.Nd,this.Md,this.$,1+this.ba|0)}if(1048576>this.Ee){b=new jd(1);b.a[0]=a;a=sJ().Sc;c=sJ().Xf;var d=DJ(sJ(),DJ(sJ(),DJ(sJ(),this.R,this.ef),this.ff),this.gf);return new wJ(b,1,a,1,c,1,d,1+this.Ee|0,this.Fd,this.Od,this.Nd,this.Md,this.$,1+this.ba|0)}if(30>this.Fd.a.length){b=new jd(1);b.a[0]=a;a=sJ().Sc;c=sJ().Xf;d=sJ().Zj;var e=DJ(sJ(),DJ(sJ(),DJ(sJ(),DJ(sJ(),this.R,this.ef),this.ff),this.gf),this.Fd);return new wJ(b,1,a,1,c,1,d,1,e,this.Od,this.Nd,
-this.Md,this.$,1+this.ba|0)}b=new jd(1);b.a[0]=a;a=sJ().Sc;c=sJ().Xf;d=sJ().Zj;e=DJ(sJ(),DJ(sJ(),DJ(sJ(),this.R,this.ef),this.ff),this.gf);var g=new (Nd(Nd(Nd(Nd(Nd(Md))))).Ja)(1);g.a[0]=e;return new xJ(b,1,a,1,c,1,d,1,g,1+this.Ee|0,sJ().IG,this.Fd,this.Od,this.Nd,this.Md,this.$,1+this.ba|0)};
-f.Tn=function(a){var b=FJ(sJ(),this.R,a),c=GJ(sJ(),2,this.ef,a),d=GJ(sJ(),3,this.ff,a),e=GJ(sJ(),4,this.gf,a),g=GJ(sJ(),5,this.Fd,a),h=GJ(sJ(),4,this.Od,a),k=GJ(sJ(),3,this.Nd,a),l=GJ(sJ(),2,this.Md,a);a=FJ(sJ(),this.$,a);return new wJ(b,this.Mf,c,this.Nf,d,this.yf,e,this.Ee,g,h,k,l,a,this.ba)};f.pn=function(a,b){a=new oJ(a,b);pJ(a,1,this.R);pJ(a,2,this.ef);pJ(a,3,this.ff);pJ(a,4,this.gf);pJ(a,5,this.Fd);pJ(a,4,this.Od);pJ(a,3,this.Nd);pJ(a,2,this.Md);pJ(a,1,this.$);return a.Vl()};
-f.jm=function(){if(1<this.Mf){var a=this.R,b=a.a.length;a=ck(fk(),a,1,b);return new wJ(a,-1+this.Mf|0,this.ef,-1+this.Nf|0,this.ff,-1+this.yf|0,this.gf,-1+this.Ee|0,this.Fd,this.Od,this.Nd,this.Md,this.$,-1+this.ba|0)}return this.pn(1,this.ba)};f.rn=function(){return 9};
-f.oo=function(a){switch(a){case 0:return this.R;case 1:return this.ef;case 2:return this.ff;case 3:return this.gf;case 4:return this.Fd;case 5:return this.Od;case 6:return this.Nd;case 7:return this.Md;case 8:return this.$;default:throw new x(a);}};f.el=function(a,b){var c=HJ(sJ(),this.$,a);return null!==c?new wJ(this.R,this.Mf,this.ef,this.Nf,this.ff,this.yf,this.gf,this.Ee,this.Fd,this.Od,this.Nd,this.Md,c,(this.ba-this.$.a.length|0)+c.a.length|0):r1.prototype.el.call(this,a,b)};f.g=function(){return this.jm()};
-f.Ga=function(a){return this.Tn(a)};f.Zb=function(a){return this.pl(a)};
-f.n=function(a){var b=a|0;if(0<=b&&b<this.ba){a=b-this.Ee|0;if(0<=a){b=a>>>20|0;var c=31&(a>>>15|0),d=31&(a>>>10|0),e=31&(a>>>5|0);a&=31;return b<this.Fd.a.length?this.Fd.a[b].a[c].a[d].a[e].a[a]:c<this.Od.a.length?this.Od.a[c].a[d].a[e].a[a]:d<this.Nd.a.length?this.Nd.a[d].a[e].a[a]:e<this.Md.a.length?this.Md.a[e].a[a]:this.$.a[a]}return b>=this.yf?(a=b-this.yf|0,this.gf.a[a>>>15|0].a[31&(a>>>10|0)].a[31&(a>>>5|0)].a[31&a]):b>=this.Nf?(a=b-this.Nf|0,this.ff.a[a>>>10|0].a[31&(a>>>5|0)].a[31&a]):b>=
-this.Mf?(a=b-this.Mf|0,this.ef.a[a>>>5|0].a[31&a]):this.R.a[b]}throw this.hh(b);};f.$classData=q({p8:0},!1,"scala.collection.immutable.Vector5",{p8:1,HB:1,Dy:1,Cy:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,jg:1,l:1});
-function xJ(a,b,c,d,e,g,h,k,l,m,n,r,u,w,y,B,D){this.$=this.R=null;this.ba=0;this.hf=b;this.je=c;this.jf=d;this.ke=e;this.Fe=g;this.le=h;this.he=k;this.me=l;this.ie=m;this.hd=n;this.sd=r;this.rd=u;this.qd=w;this.pd=y;B$(this,a,B,D)}xJ.prototype=new C$;xJ.prototype.constructor=xJ;f=xJ.prototype;
-f.ua=function(a){if(0<=a&&a<this.ba){var b=a-this.ie|0;if(0<=b){a=b>>>25|0;var c=31&(b>>>20|0),d=31&(b>>>15|0),e=31&(b>>>10|0),g=31&(b>>>5|0);b&=31;return a<this.hd.a.length?this.hd.a[a].a[c].a[d].a[e].a[g].a[b]:c<this.sd.a.length?this.sd.a[c].a[d].a[e].a[g].a[b]:d<this.rd.a.length?this.rd.a[d].a[e].a[g].a[b]:e<this.qd.a.length?this.qd.a[e].a[g].a[b]:g<this.pd.a.length?this.pd.a[g].a[b]:this.$.a[b]}return a>=this.he?(b=a-this.he|0,this.me.a[b>>>20|0].a[31&(b>>>15|0)].a[31&(b>>>10|0)].a[31&(b>>>5|
-0)].a[31&b]):a>=this.Fe?(b=a-this.Fe|0,this.le.a[b>>>15|0].a[31&(b>>>10|0)].a[31&(b>>>5|0)].a[31&b]):a>=this.jf?(b=a-this.jf|0,this.ke.a[b>>>10|0].a[31&(b>>>5|0)].a[31&b]):a>=this.hf?(b=a-this.hf|0,this.je.a[b>>>5|0].a[31&b]):this.R.a[a]}throw this.hh(a);};
-f.qr=function(a,b){if(0<=a&&a<this.ba){if(a>=this.ie){var c=a-this.ie|0,d=c>>>25|0,e=31&(c>>>20|0),g=31&(c>>>15|0),h=31&(c>>>10|0);a=31&(c>>>5|0);c&=31;if(d<this.hd.a.length){var k=this.hd.ga(),l=k.a[d].ga(),m=l.a[e].ga(),n=m.a[g].ga(),r=n.a[h].ga(),u=r.a[a].ga();u.a[c]=b;r.a[a]=u;n.a[h]=r;m.a[g]=n;l.a[e]=m;k.a[d]=l;return new xJ(this.R,this.hf,this.je,this.jf,this.ke,this.Fe,this.le,this.he,this.me,this.ie,k,this.sd,this.rd,this.qd,this.pd,this.$,this.ba)}if(e<this.sd.a.length)return d=this.sd.ga(),
-k=d.a[e].ga(),l=k.a[g].ga(),m=l.a[h].ga(),n=m.a[a].ga(),n.a[c]=b,m.a[a]=n,l.a[h]=m,k.a[g]=l,d.a[e]=k,new xJ(this.R,this.hf,this.je,this.jf,this.ke,this.Fe,this.le,this.he,this.me,this.ie,this.hd,d,this.rd,this.qd,this.pd,this.$,this.ba);if(g<this.rd.a.length)return e=this.rd.ga(),d=e.a[g].ga(),k=d.a[h].ga(),l=k.a[a].ga(),l.a[c]=b,k.a[a]=l,d.a[h]=k,e.a[g]=d,new xJ(this.R,this.hf,this.je,this.jf,this.ke,this.Fe,this.le,this.he,this.me,this.ie,this.hd,this.sd,e,this.qd,this.pd,this.$,this.ba);if(h<this.qd.a.length)return g=
-this.qd.ga(),e=g.a[h].ga(),d=e.a[a].ga(),d.a[c]=b,e.a[a]=d,g.a[h]=e,new xJ(this.R,this.hf,this.je,this.jf,this.ke,this.Fe,this.le,this.he,this.me,this.ie,this.hd,this.sd,this.rd,g,this.pd,this.$,this.ba);if(a<this.pd.a.length)return h=this.pd.ga(),g=h.a[a].ga(),g.a[c]=b,h.a[a]=g,new xJ(this.R,this.hf,this.je,this.jf,this.ke,this.Fe,this.le,this.he,this.me,this.ie,this.hd,this.sd,this.rd,this.qd,h,this.$,this.ba);a=this.$.ga();a.a[c]=b;return new xJ(this.R,this.hf,this.je,this.jf,this.ke,this.Fe,this.le,
-this.he,this.me,this.ie,this.hd,this.sd,this.rd,this.qd,this.pd,a,this.ba)}if(a>=this.he)return e=a-this.he|0,a=e>>>20|0,c=31&(e>>>15|0),h=31&(e>>>10|0),g=31&(e>>>5|0),e&=31,d=this.me.ga(),k=d.a[a].ga(),l=k.a[c].ga(),m=l.a[h].ga(),n=m.a[g].ga(),n.a[e]=b,m.a[g]=n,l.a[h]=m,k.a[c]=l,d.a[a]=k,new xJ(this.R,this.hf,this.je,this.jf,this.ke,this.Fe,this.le,this.he,d,this.ie,this.hd,this.sd,this.rd,this.qd,this.pd,this.$,this.ba);if(a>=this.Fe)return g=a-this.Fe|0,a=g>>>15|0,c=31&(g>>>10|0),h=31&(g>>>5|0),
-g&=31,e=this.le.ga(),d=e.a[a].ga(),k=d.a[c].ga(),l=k.a[h].ga(),l.a[g]=b,k.a[h]=l,d.a[c]=k,e.a[a]=d,new xJ(this.R,this.hf,this.je,this.jf,this.ke,this.Fe,e,this.he,this.me,this.ie,this.hd,this.sd,this.rd,this.qd,this.pd,this.$,this.ba);if(a>=this.jf)return h=a-this.jf|0,a=h>>>10|0,c=31&(h>>>5|0),h&=31,g=this.ke.ga(),e=g.a[a].ga(),d=e.a[c].ga(),d.a[h]=b,e.a[c]=d,g.a[a]=e,new xJ(this.R,this.hf,this.je,this.jf,g,this.Fe,this.le,this.he,this.me,this.ie,this.hd,this.sd,this.rd,this.qd,this.pd,this.$,this.ba);
-if(a>=this.hf)return c=a-this.hf|0,a=c>>>5|0,c&=31,h=this.je.ga(),g=h.a[a].ga(),g.a[c]=b,h.a[a]=g,new xJ(this.R,this.hf,h,this.jf,this.ke,this.Fe,this.le,this.he,this.me,this.ie,this.hd,this.sd,this.rd,this.qd,this.pd,this.$,this.ba);c=this.R.ga();c.a[a]=b;return new xJ(c,this.hf,this.je,this.jf,this.ke,this.Fe,this.le,this.he,this.me,this.ie,this.hd,this.sd,this.rd,this.qd,this.pd,this.$,this.ba)}throw this.hh(a);};
-f.Im=function(a){if(32>this.$.a.length)return a=AJ(sJ(),this.$,a),new xJ(this.R,this.hf,this.je,this.jf,this.ke,this.Fe,this.le,this.he,this.me,this.ie,this.hd,this.sd,this.rd,this.qd,this.pd,a,1+this.ba|0);if(31>this.pd.a.length){var b=BJ(sJ(),this.pd,this.$),c=new jd(1);c.a[0]=a;return new xJ(this.R,this.hf,this.je,this.jf,this.ke,this.Fe,this.le,this.he,this.me,this.ie,this.hd,this.sd,this.rd,this.qd,b,c,1+this.ba|0)}if(31>this.qd.a.length){b=BJ(sJ(),this.qd,BJ(sJ(),this.pd,this.$));c=sJ().Sc;
-var d=new jd(1);d.a[0]=a;return new xJ(this.R,this.hf,this.je,this.jf,this.ke,this.Fe,this.le,this.he,this.me,this.ie,this.hd,this.sd,this.rd,b,c,d,1+this.ba|0)}if(31>this.rd.a.length){b=BJ(sJ(),this.rd,BJ(sJ(),this.qd,BJ(sJ(),this.pd,this.$)));c=sJ().Xf;d=sJ().Sc;var e=new jd(1);e.a[0]=a;return new xJ(this.R,this.hf,this.je,this.jf,this.ke,this.Fe,this.le,this.he,this.me,this.ie,this.hd,this.sd,b,c,d,e,1+this.ba|0)}if(31>this.sd.a.length){b=BJ(sJ(),this.sd,BJ(sJ(),this.rd,BJ(sJ(),this.qd,BJ(sJ(),
-this.pd,this.$))));c=sJ().Zj;d=sJ().Xf;e=sJ().Sc;var g=new jd(1);g.a[0]=a;return new xJ(this.R,this.hf,this.je,this.jf,this.ke,this.Fe,this.le,this.he,this.me,this.ie,this.hd,b,c,d,e,g,1+this.ba|0)}if(62>this.hd.a.length){b=BJ(sJ(),this.hd,BJ(sJ(),this.sd,BJ(sJ(),this.rd,BJ(sJ(),this.qd,BJ(sJ(),this.pd,this.$)))));c=sJ().wt;d=sJ().Zj;e=sJ().Xf;g=sJ().Sc;var h=new jd(1);h.a[0]=a;return new xJ(this.R,this.hf,this.je,this.jf,this.ke,this.Fe,this.le,this.he,this.me,this.ie,b,c,d,e,g,h,1+this.ba|0)}throw DL();
+function V6(a,b,c,d,e,g){if(a.oP){Sw(c.S);var h=1+c.da|0,k=Hw(),l=Su(),m=op().ga;k=k.Hd(new Uu(l,m));h=new Iw(c.S,c.Ec,c.hc,c.Ed,h,c.Pc,c.Zc,c.Lb,c.yc,c.tb,c.$a,c.od,k);a=Rw(a,b,h,d,e,!0);up(tp(),c.S.li||h.cb.b());Xu().X();b=vx(c.S);e=h.cb.m();e=new xo(e,new y((r=>v=>{if(null!==v){var x=v.h();v=v.j().m();return new Ef(v,new y(A=>{if(null!==A){var B=A.Rc();A=A.j();up(tp(),A.Ea()>r.da);return B?G(new H,A,x):G(new H,x,A)}throw new w(A);}))}throw new w(v);})(c)));Od();a=wx(b,Pd(u(),e),a);b=c.S;b.F&&(b=
+ut(Q(),"| ",b.r)+("Inferred poly constr: "+a+"  \u2014\u2014 where ")+xx(a),ff(gf(),b+"\n"));c.S.F&&Nm(new E(a),a)&&(b=c.S,b.F&&(b=ut(Q(),"| ",b.r)+("Refreshed:            "+a+"  \u2014\u2014 where ")+xx(a),ff(gf(),b+"\n")));a=yx(zx(c.S),c.da,a);h.cb.mg();b=h.cb;up(tp(),c.S.li||h.cb.b());if(!b.b()){h=c.S.qa;e=c.S;e.F&&(k=ut(Q(),"| ",e.r)+"UNSTASHING... (out)",ff(gf(),k+"\n"));e.r=1+e.r|0;try{b.Ca(new y(((r,v)=>x=>{if(null!==x){var A=x.h();for(x=x.j().m();x.s();){var B=x.t();a:{if(null!==B){var C=
+B.j();if(!0===B.Rc()){B=Sw(r.S).ob;Tw(r.S,C,A,d,g,v,B);break a}}if(null!==B&&(C=B.j(),!1===B.Rc())){B=Sw(r.S).ob;Tw(r.S,A,C,d,g,v,B);break a}throw new w(B);}}}else throw new w(x);})(c,c)));b.mg();var n=void 0}finally{e.r=-1+e.r|0}dx(new E(h),e.qa)&&e.F&&(c=""+ut(Q(),"| ",e.r)+h.n(n),ff(gf(),c+"\n"))}return a}return Rw(a,b,c,d,e,!0)}
+function Ufa(a,b,c,d,e,g,h){var k=W6(a,b,d,e,g);g=t().d;t();var l=c.x;l=(0<=l.length&&"_"===l.substring(0,1)?0:!YD(c))?new L(c.x):R();var m=O().c,n=O().c;g=new lx(a,d.da,m,n,g,l,!1,h);b=ux(a,k,jx(new kx,a,Lq(b),"receiver",(tx(a),t().d),(tx(a),!1)));k=xv(a);l=jx(new kx,a,c.A(),"field selector",(tx(a),t().d),(tx(a),!1));l=new Uw(g.q,R(),g,l);c=G(new H,c,l);l=O().c;c=SA(k,new z(c,l),h);return Q6(a,b,c,g,d,e,h)}
+function X6(a,b,c,d,e,g,h,k){if(a.$c)var l=t().d;else{var m=c.x;a:{if(null!==m&&(l=dda(Wea(),m),!l.b()&&null!==l.o()&&0===l.o().ab(2))){m=l.o().va(0);l=l.o().va(1);l=hY(d,(t(),new L(m)),l);break a}l=hY(d,t().d,m)}}if(l instanceof L){l=l.k;if(l.Waa().b()){if(!(0<l.T2().ab(1)))throw new Yj("assertion failed: "+l);m=new Te(new Ue(J(new K,["Implicit call to method "," is forbidden because it is ambiguous."])));var n=[We(Xe(),c.x)];m=Ye(m,J(new K,n));e=e.A();e=G(new H,m,e);m=new Te(new Ue(J(new K,["Unrelated methods named ",
+" are defined by:"])));c=[We(Xe(),c.x)];c=Ye(m,J(new K,c));m=t().d;c=G(new H,c,m);var r=l.T2();m=A=>{A=d.tb.n(A.V);var B=new Te(new Ue(J(new K,["\u2022 "," ",""]))),C=[We(Xe(),A.jj.ld),wO(Xe(),A.Wl)];B=Ye(B,J(new K,C));A=A.Wl.A();return G(new H,B,A)};if(r===u())m=u();else{n=r.e();var v=n=new z(m(n),u());for(r=r.f();r!==u();){var x=r.e();x=new z(m(x),u());v=v.p=x;r=r.f()}m=n}ay(a,new z(e,new z(c,m)),g)}h=W6(a,b,d,g,h);b=t().d;c=t().d;e=O().c;m=O().c;b=new lx(a,d.da,e,m,b,c,!1,k);l=l.maa();return Q6(a,
+TA(l,d),new cv(a,Y6(a,h),b,k),b,d,g,k)}if(t().d===l){if(a.$c?0:hB(ve(),c.x))return k=new Te(new Ue(J(new K,["Method "," not found"]))),h=[We(Xe(),c.x)],Lw(a,Ye(k,J(new K,h)),e.A(),g);b instanceof am&&(l=new vl("super"),b=b.A(),b=Cq(l,b));return Ufa(a,b,c,d,g,h,k)}throw new w(l);}function Vfa(a,b,c){for(;;){var d=tD(a,b);if(d instanceof Qx)a=d,c.Am=!0,a=TA(a,b);else return a}}
+var Yfa=function Wfa(a,b,c,d,e,g,h){for(;;){var l=b;if(l instanceof z){b=l;var m=b.z;b=b.p;if(null!==m){var n=m.h();m=m.cy();if(null!==n)if(l=n.h(),n=n.j(),m)if(m=n.ya,m instanceof Dl||m instanceof vl){t();c=c.Pn(G(new H,l,new Ud(n.ya)));continue}else return m=new vl(Xfa(l,d.jn())),n=n.ya,t(),new Rl(!1,m,n,Wfa(a,b,c.Pn(G(new H,l,new fe(m))),d,e,g,h));else{t();c=c.Pn(G(new H,l,new Ud(n.ya)));continue}}}b=O().c;if(null===b?null===l:b.i(l)){d=((r,v,x)=>A=>{var B=!1,C=null,D=r.U(A.x);if(D instanceof L){B=
+!0;C=D;var F=C.k;if(F instanceof fe)return A=F.aa,G(new H,R(),new sm(tm().Cg,A))}if(B&&(B=C.k,B instanceof Ud))return A=B.fa,G(new H,R(),new sm(tm().Cg,A));if(R()===D)return D=new Te(new Ue(J(new K,["Argument named '","' is missing from this function call"]))),A=[We(Xe(),A.x)],Lw(a,Ye(D,J(new K,A)),v.A(),x),G(new H,R(),new sm(tm().Cg,new vl("error")));throw new w(D);})(c,d,g);if(e===u())e=u();else{g=e.e();b=g=new z(d(g),u());for(e=e.f();e!==u();)c=e.e(),c=new z(d(c),u()),b=b.p=c,e=e.f();e=g}e=new Gl(e);
+return new Pl(h,e)}throw new w(l);}};function Z6(a,b,c,d,e,g,h){if(null!==b){var k=b.Oa,l=b.ra;if(k instanceof L&&(k=k.k,k instanceof lx&&l instanceof lx&&Pe(new E(k),l)))return a=$6(a,l,c,d,e,g,h),new Sn((t(),new L(a)),a)}l=b.Oa;l.b()?l=R():(l=l.o(),l=new L($6(a,l,c,d,e,g,h)));return new Sn(l,$6(a,b.ra,c,d,e,g,h))}function a7(a,b,c,d,e,g,h){Od();b=Pd(u(),b);var k=new y(m=>m.h()),l=cT();b=QY(b,k,l);return new Dt(Wn(b,new P_(a,c,d,e,g,h)))}
+var $6=function b7(a,b,c,d,e,g,h){for(;;){var l=!1,m=null,n=!1,r=null,v=!1,x=null,A=!1,B=null,C=!1,D=null,F=uy(b);if(F instanceof lx&&(l=!0,m=F,d))return c7(m);if(l)return c.bO.Se(m,new U(((Kd,ld,Jd,Dd,Xd,Yc)=>()=>{var Ce=c7(Kd);if(ld.oh(Kd)){var te=Kd.Sb;if(te instanceof L){var Ie=b7(a,te.k,Jd,Xd,ld,Dd,Yc);te=Dd.rc;Ie=new mP(Ie,Ie);Ie=G(new H,Ce,Ie);Dd.rc=new z(Ie,te)}else if(t().d===te){te=vy(Kd);for(Ie=a.ib;!te.b();){var Jf=te.e(),df=V(Ie.q);Ie=dv(Ie,Jf,df,!1);te=te.f()}te=b7(a,Ie,Jd,Xd,ld,Dd,
+Yc);Ie=rA(Kd);for(Jf=a.La;!Ie.b();){df=Ie.e();var vg=V(Jf.q);Jf=sA(Jf,df,vg);Ie=Ie.f()}Jf=b7(a,Jf,Jd,Xd,ld,Dd,Yc);if(Nm(new E(te),el())||Nm(new E(Jf),gl()))Ie=Dd.rc,te=new mP(te,Jf),te=G(new H,Ce,te),Dd.rc=new z(te,Ie)}else throw new w(te);}return Ce})(m,e,c,g,d,h)));if(F instanceof cv){var I=F,M=I.ac;return new Wt(b7(a,I.Nb,c,d,e,g,h),b7(a,M,c,d,e,g,h))}if(F instanceof LA){n=!0;r=F;var N=r.ic,P=r.jc;if(!0===r.tc){var T=a.UE,Y=a.TI,Z=V(a.UE.q),S=dv(T,Y,Z,!1);return Aca(r,S,h)?new Ep("Bool"):new iP(b7(a,
+N,c,d,e,g,h),b7(a,P,c,d,e,g,h))}}if(n){var ea=r.ic,ia=r.jc;if(!1===r.tc)return new hP(b7(a,ea,c,d,e,g,h),b7(a,ia,c,d,e,g,h))}if(F instanceof Qv){var X=F.Ba;return new Tn(ry(lv(),X,new y(((Kd,ld,Jd,Dd,Xd)=>Yc=>Z6(a,Yc,Kd,ld,Jd,Dd,Xd))(c,d,e,g,h))))}if(F instanceof zv){var sa=F.Yb;return new jP(ry(lv(),sa,new y(((Kd,ld,Jd,Dd,Xd)=>Yc=>Z6(a,Yc,Kd,ld,Jd,Dd,Xd))(c,d,e,g,h))))}if(F instanceof Sv){v=!0;x=F;var Ja=x.Fd;if(null!==Ja){var Xa=Ja.Oa,Fa=Ja.ra;if(R()===Xa){var za=new Ep("Array"),Qa=b7(a,Fa,c,d,
+e,g,h),Ma=O().c;return new pP(za,new z(Qa,Ma))}}}if(v){var Ga=Z6(a,x.Fd,c,d,e,g,h),ab=new Ep("MutArray"),Hb=Ga.Yf,bc=new mP(Hb.b()?el():Hb.o(),Ga.Rg),yb=O().c;return new pP(ab,new z(bc,yb))}if(F instanceof Wv){var tb=F.fo,eb=((Kd,ld,Jd,Dd,Xd)=>Yc=>{if(Yc instanceof fe)return Yc=Yc.aa,t(),Yc=b7(a,Yc,Kd,ld,Jd,Dd,Xd),new fe(Yc);if(Yc instanceof Ud){Yc=Yc.fa;t();var Ce=Yc.Oa;Ce.b()?Ce=R():(Ce=Ce.o(),Ce=new L(b7(a,Ce,Kd,ld,Jd,Dd,Xd)));Yc=new Sn(Ce,b7(a,Yc.ra,Kd,ld,Jd,Dd,Xd));return new Ud(Yc)}throw new w(Yc);
+})(c,d,e,g,h);if(tb===u())var kb=u();else{for(var Rb=tb.e(),Gb=new z(eb(Rb),u()),vb=Gb,Tb=tb.f();Tb!==u();){var Nb=Tb.e(),ic=new z(eb(Nb),u());vb=vb.p=ic;Tb=Tb.f()}kb=Gb}return new rP(kb)}if(F instanceof MA)return new kP(b7(a,F.Fc,c,d,e,g,h));if(F instanceof FA&&(A=!0,B=F,!0===B.Eh))return el();if(A&&!1===B.Eh)return gl();if(F instanceof $y){var Va=F,cb=Va.up,zb=b7(a,Va.Oq,c,d,e,g,h);lv();return new nP(zb,new Tn(ry(0,cb.Ba,new y(((Kd,ld,Jd,Dd,Xd)=>Yc=>Z6(a,Yc,Kd,ld,Jd,Dd,Xd))(c,d,e,g,h)))))}if(F instanceof
+ZB){var Ub=F;$B(a);t();var jb=Ub.mc(),db=new L(jb);if(!db.b()){b=db.k;continue}}if(XB(F)){var ub=F.rr();if(ub instanceof vl){var Aa=ub.x;return a.cn.L(Aa)||"this"===Aa?new Ep(Aa):new sP(Nu(Q(),Aa))}if(ub instanceof Dl)return new oP(ub);throw new w(ub);}if(F instanceof mx){var va=F.hi,Ra=va.kg;if(Ra instanceof L){var rb=Ra.k;if(hB(ve(),rb))return new Ep(rb)}b=va}else{if(F instanceof YB){var xb=F,mc=xb.pA,Ha=xb.Ym;if(null!==Ha){var Ka=Ha.hi;return mc?Zfa(Ka):$fa(Ka)}}if(F instanceof fw){C=!0;D=F;var Oa=
+D.qb,Na=D.Zb,Da=O().c;if(null===Da?null===Na:Da.i(Na))return Oa}if(C){var ta=D.qb,Ya=D;t();return new pP(ta,bw(Ya,new L(!0),new fn(((Kd,ld,Jd,Dd,Xd)=>(Yc,Ce)=>{a:{if(Yc instanceof L){if(!0===!!Yc.k){var te=a.La;te=null===te?null===Ce:mC(te,Ce)}else te=!1;if(te){Yc=!0;break a}}if(Yc instanceof L&&(!1===!!Yc.k?(Yc=a.ib,Yc=null===Yc?null===Ce:mC(Yc,Ce)):Yc=!1,Yc)){Yc=!0;break a}Yc=!1}return Yc?new mP(el(),gl()):b7(a,Ce,Kd,ld,Jd,Dd,Xd)})(c,d,e,g,h)),h))}if(F instanceof cC){var dc=F,ka=dc.Sf;return new mP(b7(a,
+dc.Fg,c,d,e,g,h),b7(a,ka,c,d,e,g,h))}if(F instanceof Tv){var ya=F,Sa=ya.kf;return new lP(b7(a,ya.Ic,c,d,e,g,h),(Od(),Pd(u(),Sa)))}if(F instanceof Jv){var xc=F.gi,Sb=((Kd,ld,Jd,Dd,Xd)=>Yc=>b7(a,Yc,Kd,ld,Jd,Dd,Xd))(c,d,e,g,h);if(xc===u())var uc=u();else{for(var Lb=xc.e(),lc=new z(Sb(Lb),u()),Xb=lc,ec=xc.f();ec!==u();){var Ab=ec.e(),Ob=new z(Sb(Ab),u());Xb=Xb.p=Ob;ec=ec.f()}uc=lc}var fb=Un();return eH(uc,fb)}if(F instanceof Qx){var Wa=F,bb=Wa.de,Ia=Wa.Re,Ua=g.rc.K(),pc=b7(a,Ia,c,d,e,g,h),sc=er(g.rc).m().ph(Ua),
+Ba=PE().vl(sc),ob=gD(Ia,bb,a.Df).m(),nc=$S(pc),Ib=Ba.m(),vc=new Ef(Ib,new y(Kd=>Kd.h())),Vb=nc.Ce(vc),fc=Ba.m(),Bc=new xo(fc,new y(Kd=>$S(Kd.j()))),Pb=Vb.Ce(Bc),Jb=new iy(ob,new y((Kd=>ld=>Kd.L(c7(ld)))(Pb)),!1);if(Jb.s()){tp();ms();var gc=null;for(gc=[];Jb.s();){var Cb=Jb.t();gc.push(null===Cb?null:Cb)}var cc=new (md(RX).Ia)(gc),yc=Su(),Mc=op().ga,qc=Tu(cc,new Uu(yc,Mc)),oc=Kd=>{Kd=c7(Kd);t();return new Ud(Kd)},Qc=qc.a.length,jc=new (md(K2).Ia)(Qc);if(0<Qc){var sb=0;if(null!==qc)for(;sb<Qc;)jc.a[sb]=
+oc(qc.a[sb]),sb=1+sb|0;else if(qc instanceof Xc)for(var Gc=qc;sb<Qc;)jc.a[sb]=oc(Gc.a[sb]),sb=1+sb|0;else if(qc instanceof ed)for(var Wb=qc;sb<Qc;)jc.a[sb]=oc(Wb.a[sb]),sb=1+sb|0;else if(qc instanceof Zc)for(var Cc=qc;sb<Qc;){var Fc=Cc.a[sb];jc.a[sb]=oc(new ma(Fc.W,Fc.Y));sb=1+sb|0}else if(qc instanceof $c)for(var qd=qc;sb<Qc;)jc.a[sb]=oc(qd.a[sb]),sb=1+sb|0;else if(qc instanceof Ic)for(var Yb=qc;sb<Qc;)jc.a[sb]=oc(hc(Yb.a[sb])),sb=1+sb|0;else if(qc instanceof Pc)for(var Nc=qc;sb<Qc;)jc.a[sb]=oc(Nc.a[sb]),
+sb=1+sb|0;else if(qc instanceof Sc)for(var ad=qc;sb<Qc;)jc.a[sb]=oc(ad.a[sb]),sb=1+sb|0;else if(qc instanceof Ec)for(var Uc=qc;sb<Qc;)jc.a[sb]=oc(Uc.a[sb]),sb=1+sb|0;else throw new w(qc);}var cd=ps(jc);Od();return new Vt(Pd(u(),cd),pc)}return pc}if(F instanceof eC){for(var kc=F,Vc=kc.Lj,Hc=kc.kj,rc=new lA,sd=new lA,Kc=Vc;!Kc.b();){var Qd=Kc.e();if(null!==Qd){var Ad=Qd.h(),kd=Qd.j(),Hd=rc.U(Ad);if(Hd instanceof L)var Rd=Hd.k;else{if(R()!==Hd)throw new w(Hd);var Bd=TE(PE());rc.bh(Ad,Bd);Rd=Bd}Rd.$(kd)}else throw new w(Qd);
+Kc=Kc.f()}Od();var ae=Pd(u(),rc);if(ae.b())var dd=Od().jC;else{Od();var od=new fp;Od();for(var Ta=new fp,wb=ae.m();wb.s();){var $a=wb.t();wp(0<$a.j().$k(1)?od:Ta,$a)}var wa=G(new H,od.ha(),Ta.ha());var hb=wa.y;if(u().i(hb))dd=G(new H,u(),ae);else{var ra=wa.w;dd=u().i(ra)?G(new H,ae,u()):wa}}if(null===dd)throw new w(dd);for(var wc=dd.h(),ac=dd.j();!ac.b();){var Id=ac.e();if(null!==Id){var ud=Id.h(),be=Id.j().e(),re=sd.U(be);if(re instanceof L)var pe=re.k;else{if(R()!==re)throw new w(re);var bd=TE(PE());
+sd.bh(be,bd);pe=bd}pe.$(ud)}else throw new w(Id);ac=ac.f()}Od();var Rc=Pd(u(),sd),Wc=ry(lv(),wc,new y(Kd=>Kd.th(new fn((ld,Jd)=>{var Dd=V(ld.q);return sA(ld,Jd,Dd)})))),Wd=ry(lv(),Rc,new y(Kd=>Kd.th(new fn((ld,Jd)=>{var Dd=V(ld.q);return dv(ld,Jd,Dd,!1)}))));if(Wd===u())var zd=u();else{for(var Pa=Wd.e(),Db=new z(Pa.Cw(),u()),Oc=Db,Tc=Wd.f();Tc!==u();){var Sd=Tc.e(),Jc=new z(Sd.Cw(),u());Oc=Oc.p=Jc;Tc=Tc.f()}zd=Db}var vd=un(Wc,zd),hd=((Kd,ld,Jd,Dd,Xd)=>Yc=>{if(null!==Yc){var Ce=Yc.j();return new mP(b7(a,
+Yc.h(),Kd,ld,Jd,Dd,Xd),b7(a,Ce,Kd,ld,Jd,Dd,Xd))}throw new w(Yc);})(c,d,e,g,h);if(vd===u())var de=u();else{for(var ye=vd.e(),jf=new z(hd(ye),u()),af=jf,pf=vd.f();pf!==u();){var kf=pf.e(),Be=new z(hd(kf),u());af=af.p=Be;pf=pf.f()}de=jf}return new qP(b7(a,Hc,c,d,e,g,h),O().c,de)}throw new w(F);}}};
+function hf(a,b,c,d){this.io=this.ho=this.jo=null;this.Fp=this.Gp=this.an=this.Ep=0;this.qa=null;this.r=0;this.zk=this.Pq=this.Uq=this.xp=this.Bp=this.Cp=this.Sq=this.zp=this.Rq=this.wp=this.Ap=this.yp=this.Qq=this.Tq=null;this.Dp=0;this.hs=this.yq=this.Aq=this.Bq=this.zq=this.Dq=this.Cq=null;this.Im=this.Pw=0;this.iA=this.hA=this.Ku=null;this.Hb=!1;this.XA=0;this.VE=this.WE=this.TE=this.SE=this.YA=null;this.sP=this.li=this.ZE=this.pP=this.oP=this.Wq=this.rP=this.UI=this.VI=this.$c=this.zA=this.$E=
+this.F=!1;this.Df=this.Gd=0;this.uP=this.nP=this.XI=this.tP=this.cn=this.XE=this.qP=this.bn=this.WI=this.Bk=this.lP=this.RE=this.TI=this.UE=this.Qj=this.Ak=this.ki=this.mP=this.lg=this.Ck=this.ib=this.La=null;this.YE=0;this.F=a;this.$E=b;this.zA=c;this.$c=d;oca(this);cY||(cY=new bY);null===this.Cp&&null===this.Cp&&(this.Cp=new ZP(this));this.zk=this.Cp;TE(PE());this.Dp=0;this.Pw=1E4;this.Im=0;this.Hb=!1;this.XA=0;this.YA=$ea();this.li=this.ZE=this.pP=this.oP=this.Wq=this.rP=this.UI=this.VI=!1;this.sP=
+!0;this.Gd=0;this.Df=1024;this.La=new FA(this,!1,d7(this));this.ib=new FA(this,!0,d7(this));this.Ck=d?new Mu(this,new Gm(!0),ap(),d7(this)):new Mu(this,new vl("unit"),ap(),d7(this));this.lg=d?$P(this.zk,new Ep("Bool"),O().c,d7(this)):new Mu(this,new vl("bool"),ap(),d7(this));new Mu(this,new vl("Object"),ap(),d7(this));this.mP=d?$P(this.zk,new Ep("Object"),O().c,d7(this)):this.La;this.ki=d?$P(this.zk,new Ep("Int"),O().c,d7(this)):new Mu(this,new vl("int"),M6(new Ep("number")),d7(this));this.Ak=d?$P(this.zk,
+new Ep("Num"),O().c,d7(this)):new Mu(this,new vl("number"),ap(),d7(this));this.Qj=d?$P(this.zk,new Ep("Str"),O().c,d7(this)):new Mu(this,new vl("string"),ap(),d7(this));this.UE=d?$P(this.zk,new Ep("true"),O().c,d7(this)):new Mu(this,new vl("true"),M6(new Ep("bool")),d7(this));this.TI=d?$P(this.zk,new Ep("false"),O().c,d7(this)):new Mu(this,new vl("false"),M6(new Ep("bool")),d7(this));this.RE=$P(this.zk,new Ep("Annotation"),O().c,d7(this));this.lP=new nC(this,new vl("Eql"),ap(),V(this));this.Bk=new vl("error");
+O();var e=G(new H,"unit",this.Ck),g=G(new H,"bool",this.lg),h=G(new H,"int",this.ki),k=G(new H,"number",this.Ak),l=G(new H,"string",this.Qj),m=G(new H,"anything",this.La),n=[e,g,h,k,l,m,G(new H,"nothing",this.ib)],r=J(new K,n);this.WI=Pd(u(),r);this.bn=new Kq(0,0,new Ge("\x3cprelude\x3e",0,Gaa()));t();var v=Bp(),x=new Ep("Object"),A=O().c,B=t().d,C=t().d,D=t().d,F=O().c,I=t().d,M=t().d,N=new Dt(O().c),P=t().d;t();var T=new yo(v,x,A,B,C,D,F,I,M,N,P,new L(this.bn),O().c),Y=Fp(),Z=new Ep("Eql");t();
+var S=ou().AA,ea=G(new H,new L(S),new Ep("A")),ia=O().c,X=new z(ea,ia),sa=t().d,Ja=t().d,Xa=t().d,Fa=O().c,za=t().d,Qa=t().d,Ma=new Dt(O().c),Ga=t().d;t();var ab=new yo(Y,Z,X,sa,Ja,Xa,Fa,za,Qa,Ma,Ga,new L(this.bn),O().c),Hb=Bp(),bc=new Ep("Num"),yb=O().c,tb=t().d,eb=t().d,kb=t().d,Rb=O().c,Gb=t().d,vb=t().d,Tb=new Dt(O().c),Nb=t().d;t();var ic=new yo(Hb,bc,yb,tb,eb,kb,Rb,Gb,vb,Tb,Nb,new L(this.bn),O().c),Va=Bp(),cb=new Ep("Int"),zb=O().c,Ub=t().d,jb=t().d,db=t().d,ub=new vl("Num"),Aa=O().c,va=new z(ub,
+Aa),Ra=t().d,rb=t().d,xb=new Dt(O().c),mc=t().d;t();var Ha=new yo(Va,cb,zb,Ub,jb,db,va,Ra,rb,xb,mc,new L(this.bn),O().c),Ka=Bp(),Oa=new Ep("Bool"),Na=O().c,Da=t().d,ta=t().d;t();var Ya=new iP(new Ep("true"),new Ep("false")),dc=new L(Ya),ka=O().c,ya=t().d,Sa=t().d,xc=new Dt(O().c),Sb=t().d;t();var uc=new yo(Ka,Oa,Na,Da,ta,dc,ka,ya,Sa,xc,Sb,new L(this.bn),O().c),Lb=zp(),lc=new Ep("true"),Xb=O().c,ec=t().d,Ab=t().d,Ob=t().d,fb=new vl("Bool"),Wa=O().c,bb=new yo(Lb,lc,Xb,ec,Ab,Ob,new z(fb,Wa),t().d,t().d,
+new Dt(O().c),t().d,t().d,O().c),Ia=zp(),Ua=new Ep("false"),pc=O().c,sc=t().d,Ba=t().d,ob=t().d,nc=new vl("Bool"),Ib=O().c,vc=new yo(Ia,Ua,pc,sc,Ba,ob,new z(nc,Ib),t().d,t().d,new Dt(O().c),t().d,t().d,O().c),Vb=Bp(),fc=new Ep("Str"),Bc=O().c,Pb=t().d,Jb=t().d,gc=t().d,Cb=O().c,cc=t().d,yc=t().d,Mc=new Dt(O().c),qc=t().d;t();var oc=new yo(Vb,fc,Bc,Pb,Jb,gc,Cb,cc,yc,Mc,qc,new L(this.bn),O().c),Qc=Ap(),jc=new Ep("undefined"),sb=O().c,Gc=t().d,Wb=t().d;t();var Cc=new oP(new Gm(!0)),Fc=new L(Cc),qd=O().c,
+Yb=t().d,Nc=t().d,ad=new Dt(O().c),Uc=t().d;t();var cd=new yo(Qc,jc,sb,Gc,Wb,Fc,qd,Yb,Nc,ad,Uc,new L(this.bn),O().c),kc=Ap(),Vc=new Ep("null"),Hc=O().c,rc=t().d,sd=t().d;t();var Kc=new oP(new Gm(!1)),Qd=new L(Kc),Ad=O().c,kd=t().d,Hd=t().d,Rd=new Dt(O().c),Bd=t().d;t();var ae=new yo(kc,Vc,Hc,rc,sd,Qd,Ad,kd,Hd,Rd,Bd,new L(this.bn),O().c),dd=Bp(),od=new Ep("Annotation"),Ta=O().c,wb=t().d,$a=t().d,wa=t().d,hb=O().c,ra=t().d,wc=t().d,ac=new Dt(O().c),Id=t().d;t();var ud=new yo(dd,od,Ta,wb,$a,wa,hb,ra,
+wc,ac,Id,new L(this.bn),O().c),be=Bp(),re=new Ep("Code");t();var pe=ou().Zu,bd=new L(pe),Rc=new Ep("T"),Wc=G(new H,bd,Rc);t();var Wd=ou().Zu,zd=new L(Wd),Pa=new Ep("C"),Db=G(new H,zd,Pa),Oc=O().c,Tc=new z(Wc,new z(Db,Oc)),Sd=t().d,Jc=t().d,vd=t().d,hd=O().c,de=t().d,ye=t().d,jf=new Dt(O().c),af=t().d;t();var pf=new yo(be,re,Tc,Sd,Jc,vd,hd,de,ye,jf,af,new L(this.bn),O().c),kf=Bp(),Be=new Ep("Var");t();var Kd=ou().Yl,ld=new L(Kd),Jd=new Ep("T"),Dd=G(new H,ld,Jd);t();var Xd=ou().Yl,Yc=new L(Xd),Ce=new Ep("C"),
+te=G(new H,Yc,Ce),Ie=O().c,Jf=new z(Dd,new z(te,Ie)),df=t().d,vg=t().d,wg=t().d,xg=new vl("Code"),eg=new Ep("T"),vh=new Ep("C"),fg=O().c,ih=new Il(xg,new z(eg,new z(vh,fg))),Ig=O().c,Tf=new z(ih,Ig),Jg=t().d,jh=t().d,yg=new Dt(O().c),gg=t().d;t();var Cf=[T,ab,ic,Ha,uc,bb,vc,oc,cd,ae,ud,pf,new yo(kf,Be,Jf,df,vg,wg,Tf,Jg,jh,yg,gg,new L(this.bn),O().c)],Uf=J(new K,Cf);this.qP=Pd(u(),Uf);var $g=new YX(this,Bp(),new Ep("?"),O().c,this.La,O().c,O().c,ap(),t().d,O().c,(c3(this),t().d)),Ah=new YX(this,Bp(),
+new Ep("int"),O().c,this.La,O().c,O().c,M6(new Ep("number")),t().d,O().c,(c3(this),t().d)),Kg=new YX(this,Bp(),new Ep("number"),O().c,this.La,O().c,O().c,ap(),t().d,O().c,(c3(this),t().d)),Vf=new YX(this,Bp(),new Ep("bool"),O().c,this.La,O().c,O().c,ap(),t().d,O().c,(c3(this),t().d)),hg=new YX(this,Bp(),new Ep("true"),O().c,this.La,O().c,O().c,M6(new Ep("bool")),t().d,O().c,(c3(this),t().d)),zg=new YX(this,Bp(),new Ep("false"),O().c,this.La,O().c,O().c,M6(new Ep("bool")),t().d,O().c,(c3(this),t().d)),
+Lg=new YX(this,Bp(),new Ep("string"),O().c,this.La,O().c,O().c,ap(),t().d,O().c,(c3(this),t().d)),Mg=new YX(this,Ap(),new Ep("undefined"),O().c,new Mu(this,new Gm(!0),ap(),V(this)),O().c,O().c,ap(),t().d,O().c,(c3(this),t().d)),Wf=new YX(this,Ap(),new Ep("null"),O().c,new Mu(this,new Gm(!1),ap(),V(this)),O().c,O().c,ap(),t().d,O().c,(c3(this),t().d)),Ng=new YX(this,Ap(),new Ep("anything"),O().c,this.La,O().c,O().c,ap(),t().d,O().c,(c3(this),t().d)),Kf=new YX(this,Ap(),new Ep("nothing"),O().c,this.ib,
+O().c,O().c,ap(),t().d,O().c,(c3(this),t().d)),xf=new YX(this,Bp(),new Ep("error"),O().c,this.La,O().c,O().c,ap(),t().d,O().c,(c3(this),t().d)),Og=new YX(this,Bp(),new Ep("unit"),O().c,this.La,O().c,O().c,ap(),t().d,O().c,(c3(this),t().d)),mi=d7(this),Ci=t().d,Xh=t().d,wh=O().c,Bh=O().c,ng=new lx(this,1,wh,Bh,Ci,Xh,!1,mi),kh=Ap(),Kh=new Ep("Array");O();var ni=new Ep("A"),Lh=[G(new H,ni,ng)],lh=J(new K,Lh),Ch=new YX(this,kh,Kh,Pd(u(),lh),new Sv(this,new Uw(this,R(),ng,d7(this)),d7(this)),O().c,O().c,
+ap(),t().d,O().c,(c3(this),t().d));t();var Dh=Xu(),Yh=ou().Zu,ah=[G(new H,ng,Yh)],oi=Dh.Hh(J(new K,ah));Ch.Nu=new L(oi);var mj=d7(this),wd=t().d,ge=t().d,De=O().c,qf=O().c,og=new lx(this,1,De,qf,wd,ge,!1,mj),Xf=Ap(),mh=new Ep("MutArray");O();var Ag=new Ep("A"),Bg=[G(new H,Ag,og)],Eh=J(new K,Bg),Pg=new YX(this,Xf,mh,Pd(u(),Eh),new Sv(this,new Uw(this,new L(og),og,d7(this)),d7(this)),O().c,O().c,ap(),t().d,O().c,(c3(this),t().d));t();var Di=Xu(),Mh=ou().Yl,pi=[G(new H,og,Mh)],Xi=Di.Hh(J(new K,pi));
+Pg.Nu=new L(Xi);var Qg=O().c;this.XE=new z($g,new z(Ah,new z(Kg,new z(Vf,new z(hg,new z(zg,new z(Lg,new z(Mg,new z(Wf,new z(Ng,new z(Kf,new z(xf,new z(Og,new z(Ch,new z(Pg,Qg)))))))))))))));var nh=this.XE.m(),bh=new Ef(nh,new y(ev=>ev.Wl.V)),Mj=new xo(bh,new y(ev=>{var m0=UF(ve(),ev);ev=Nu(Q(),ev);var iga=O().c;return new z(m0,new z(ev,iga))}));this.cn=Aq(Bq(),Mj).bc("Object").bc("Num").bc("Str");this.tP=this.cn.bc("Eql");var Nj=V(this),ie=t().d,Ac=t().d,Ve=O().c,Td=O().c;this.XI=new lx(this,1,Ve,
+Td,ie,Ac,!1,Nj);var lf=V(this),Yi=t().d,Jl=t().d,ll=O().c,Bj=O().c,$k=new lx(this,1,ll,Bj,Yi,Jl,!1,lf),Zh=d?new Gp(new cv(this,e7(this,this.ki,this.ki),this.ki,V(this)),new cv(this,e7(this,this.Ak,this.Ak),this.Ak,V(this)),new cv(this,e7(this,this.Ak,this.Ak),this.lg,V(this)),new cv(this,e7(this,this.Qj,this.Qj),this.lg,V(this))):new Gp(new cv(this,Y6(this,this.ki),new cv(this,Y6(this,this.ki),this.ki,V(this)),V(this)),new cv(this,Y6(this,this.Ak),new cv(this,Y6(this,this.Ak),this.Ak,V(this)),V(this)),
+new cv(this,Y6(this,this.Ak),new cv(this,Y6(this,this.Ak),this.lg,V(this)),V(this)),new cv(this,Y6(this,this.Qj),new cv(this,Y6(this,this.Qj),this.lg,V(this)),V(this)));if(null!==Zh)var Ei=new Gp(Zh.Uj,Zh.oj,Zh.oi,Zh.Xi);else throw new w(Zh);var Yd=Ei.Uj,bf=Ei.oj,rf=Ei.oi,Cg=Ei.Xi;tp();var nj=G(new H,"true",this.UE),Jh=G(new H,"false",this.TI),If=new fw(this,new Ep("True"),O().c,V(this)),Hg=G(new H,"True",If),He=new fw(this,new Ep("False"),O().c,V(this)),lj=G(new H,"False",He),Wi=G(new H,"NaN",this.Ak),
+Oj=G(new H,"document",this.ib),mo=G(new H,"window",this.ib),mm=new cv(this,Y6(this,this.La),this.Qj,V(this)),nm=G(new H,"typeof",mm),dq=new cv(this,Y6(this,this.La),this.Qj,V(this)),Zd=G(new H,"toString",dq),sf=new cv(this,Y6(this,this.La),this.Qj,V(this)),oj=G(new H,"String",sf),al=new cv(this,Y6(this,this.lg),this.lg,V(this)),Ll=G(new H,"not",al),Qm=new cv(this,Y6(this,this.ki),this.ki,V(this)),Rm=G(new H,"succ",Qm),hq=new Qx(this,this.Gd,new cv(this,Y6(this,$k),this.Ck,V(this))),Bn=G(new H,"log",
+hq),hp=new Qx(this,this.Gd,new cv(this,Y6(this,$k),this.Ck,V(this))),ru=G(new H,"discard",hp),qr=new cv(this,Y6(this,this.ki),this.ki,V(this)),Xs=G(new H,"negate",qr),rr=new cv(this,Y6(this,this.Ak),this.ki,V(this)),iq=G(new H,"round",rr),qo=G(new H,"add",Yd),qm=G(new H,"sub",Yd),jq=G(new H,"mul",Yd),pl=G(new H,"div",Yd),ro=new cv(this,Y6(this,this.ki),this.ki,V(this)),Cn=G(new H,"sqrt",ro),ip=G(new H,"lt",rf),so=G(new H,"le",rf),Dn=G(new H,"gt",rf),sr=G(new H,"ge",rf),kq=G(new H,"slt",Cg),ql=G(new H,
+"sle",Cg),Ys=G(new H,"sgt",Cg),Sm=G(new H,"sge",Cg),Nl=new cv(this,Y6(this,this.Qj),this.ki,V(this)),jp=G(new H,"length",Nl),lq=new cv(this,Y6(this,this.Qj),new cv(this,Y6(this,this.Qj),this.Qj,V(this)),V(this)),mq=G(new H,"concat",lq),Tm=this.Qj,En=V(this),to=new cv(this,new Sv(this,new Uw(Tm.q,R(),Tm,En),V(this)),this.Qj,V(this)),Fn=G(new H,"join",to),nq=V(this),Um=t().d,kp=t().d,oq=O().c,su=O().c,Gn=new lx(this,1,oq,su,Um,kp,!1,nq),ur=new Qx(this,this.Gd,new cv(this,Y6(this,Gn),new cv(this,Y6(this,
+Gn),this.lg,V(this)),V(this))),In=G(new H,"eq",ur),Zs=V(this),$s=t().d,pq=t().d,vr=O().c,Vm=O().c,Jn=new lx(this,1,vr,Vm,$s,pq,!1,Zs),wr=new Qx(this,this.Gd,new cv(this,Y6(this,Jn),new cv(this,Y6(this,Jn),this.lg,V(this)),V(this))),at=G(new H,"ne",wr),xr=G(new H,"error",this.ib),lp=this.XI,Kn=this.Gd,qq=t().d,yr=this.La,rq=V(this),sq=new Uw(yr.q,R(),yr,rq),bt=G(new H,qq,sq),tq=t().d,zr=V(this),ct=new Uw(lp.q,R(),lp,zr),Ar=G(new H,tq,ct),uq=O().c,Br=new Qx(this,Kn,new cv(this,new zv(this,new z(bt,
+new z(Ar,uq)),V(this)),lp,V(this))),Ln=G(new H,",",Br),vq=G(new H,"+",Yd),Cr=G(new H,"-",Yd),tu=G(new H,"*",Yd),uu=G(new H,"+.",bf),dt=G(new H,"-.",bf),vu=G(new H,"*.",bf),Dr=G(new H,"%",Yd),uo=G(new H,"/",bf),Er=G(new H,"\x3c",rf),et=G(new H,"\x3e",rf),ft=G(new H,"\x3c\x3d",rf),gt=G(new H,"\x3e\x3d",rf),Wm=G(new H,"\x3d\x3d",rf),Fr=this.XI,mp=new Ep("Eql"),wu=O().c,ht=new fw(this,mp,new z(Fr,wu),V(this)),wq=new Qx(this,this.Gd,new cv(this,e7(this,ht,Fr),this.lg,V(this))),xq=G(new H,"\x3d\x3d\x3d",
+wq),Gr=G(new H,"\x3c\x3e",rf),xu=d?new cv(this,e7(this,this.lg,this.lg),this.lg,V(this)):new cv(this,Y6(this,this.lg),new cv(this,Y6(this,this.lg),this.lg,V(this)),V(this)),yu=G(new H,"\x26\x26",xu),Re=d?new cv(this,e7(this,this.lg,this.lg),this.lg,V(this)):new cv(this,Y6(this,this.lg),new cv(this,Y6(this,this.lg),this.lg,V(this)),V(this)),rj=G(new H,"||",Re),ai=V(this),rm=t().d,Nn=t().d,zu=O().c,Au=O().c,Av=new lx(this,1,zu,Au,rm,Nn,!1,ai),oy=new Qx(this,this.Gd,new cv(this,Y6(this,Av),Av,V(this))),
+Bv=G(new H,"id",oy),Cv=V(this),py=t().d,qy=t().d,Dv=O().c,Ee=O().c,Ca=new lx(this,1,Dv,Ee,py,qy,!1,Cv),Lc=new Qx(this,this.Gd,new cv(this,Y6(this,this.lg),new cv(this,Y6(this,Ca),new cv(this,Y6(this,Ca),Ca,V(this)),V(this)),V(this))),yd=G(new H,"if",Lc),Qe=V(this),Xj=t().d,fl=t().d,Gk=O().c,$n=O().c,$R=new lx(this,1,Gk,$n,Xj,fl,!1,Qe),jga=new Qx(this,0,new Sv(this,new Uw(this,(t(),new L($R)),$R,V(this)),V(this))),kga=G(new H,"emptyArray",jga),lga=V(this),mga=t().d,nga=t().d,oga=O().c,pga=O().c,a$=
+new lx(this,1,oga,pga,mga,nga,!1,lga),qga=new Ep("Code"),rga=this.ib,sga=O().c,tga=new Qx(this,0,new cv(this,Y6(this,new fw(this,qga,new z(a$,new z(rga,sga)),V(this))),a$,V(this))),uga=G(new H,"run",tga),vga=Y6(this,this.ki),wga=new Ep("Code"),xga=this.ki,yga=this.ib,zga=O().c,Aga=new cv(this,vga,new fw(this,wga,new z(xga,new z(yga,zga)),V(this)),V(this)),Bga=[nj,Jh,Hg,lj,Wi,Oj,mo,nm,Zd,oj,Ll,Rm,Bn,ru,Xs,iq,qo,qm,jq,pl,Cn,ip,so,Dn,sr,kq,ql,Ys,Sm,jp,mq,Fn,In,at,xr,Ln,vq,Cr,tu,uu,dt,vu,Dr,uo,Er,et,
+ft,gt,Wm,xq,Gr,yu,rj,Bv,yd,kga,uga,G(new H,"Const",Aga)],Cga=J(new K,Bga),Dga=pp(0,Cga);if(d)b$=O().c;else var Ega=this.WI,Fga=Qt(this.WI,new y(ev=>{var m0=Nu(Q(),ev.h());return G(new H,m0,ev.j())})),b$=un(Ega,Fga);this.nP=Dga.bf(b$);this.uP=Aq(tp().Iv,J(new K,"| \x26 ~ neg and or is".split(" ")));this.YE=0}hf.prototype=new t5;hf.prototype.constructor=hf;function raa(a){null===a.SE&&null===a.SE&&(a.SE=new KP(a));return a.SE}function V(a){null===a.TE&&null===a.TE&&(a.TE=new R_(a));return a.TE}
+function yC(a){null===a.WE&&null===a.WE&&(a.WE=new zC(a));return a.WE}function f7(a){null===a.VE&&null===a.VE&&(a.VE=new sC(a));return a.VE}function ny(a,b,c){var d=b.A();b=hu(b);tx(a);var e=t().d;return jx(new kx,a,d,b,e,c)}function d7(a){var b=t().d;tx(a);var c=t().d;return jx(new kx,a,b,"type",c,!0)}function Y6(a,b){var c=t().d,d=b.ma();b=G(new H,c,new Uw(b.q,R(),b,d));c=O().c;return new zv(a,new z(b,c),V(a))}
+function e7(a,b,c){var d=t().d,e=b.ma();b=new Uw(b.q,R(),b,e);d=G(new H,d,b);b=t().d;e=c.ma();c=new Uw(c.q,R(),c,e);c=G(new H,b,c);b=O().c;return new zv(a,new z(d,new z(c,b)),V(a))}function ox(a,b,c,d,e,g){return aga(a,b,c,d,e,g).h()}
+function aga(a,b,c,d,e,g){var h=new y(v=>"\x3d\x3e "+v.h()+" \u2014\u2014\u2014 "+ze(v.j(),"",", ",""));if(a.F){var k=ut(Q(),"| ",a.r)+"Typing type "+wO(Xe(),b).Wr();ff(gf(),k+"\n")}a.r=1+a.r|0;try{if(a.F){var l=ut(Q(),"| ",a.r)+("vars\x3d"+e+" newDefsInfo\x3d")+g;ff(gf(),l+"\n")}var m=c.da,n=Xu().X(),r=G(new H,Sfa(a,b,c,nf(),d,!0,e,n,m,g,c),new rp(n))}finally{a.r=-1+a.r|0}dx(new E(h),a.qa)&&a.F&&(a=""+ut(Q(),"| ",a.r)+h.n(r),ff(gf(),a+"\n"));return r}
+function g7(a,b,c,d,e){return Rw(a,b,new Iw(c.S,c.Ec,c.hc,c.Ed,c.da,c.Pc,c.Zc,c.Lb,!0,c.tb,c.$a,c.od,c.cb),d,e,!1)}
+function ty(a,b,c,d,e,g,h){var k=!1,l=null;if(b instanceof No){k=!0;l=b;var m=l.oq,n=l.vu;if(!1===l.ls&&null!==m&&"_"===m.x&&n instanceof fe)return ty(a,n.aa,c,d,e,g,h)}if(k&&(m=l.ls,k=l.oq,l=l.vu,l instanceof fe))return b=l.aa,"_"===k.x&&(h=new Te(new Ue(J(new K,["Illegal definition name: ",""]))),c=[We(Xe(),k.x)],Lw(a,Ye(h,J(new K,c)),k.A(),e)),b=h7(a,m,k.x,b,d,e,g),t(),g=i7(a),k.kt=new L(g),g=k.x,h=new qx(a,b,k),Wx(d,G(new H,g,h)),t(),t(),d=G(new H,k.x,b),new Ud(new L(d));if(b instanceof Gl&&(k=
+b.Ra,!c)){a:{if(k instanceof z&&(m=k.z,c=k.p,null!==m&&(m.h()instanceof L?(m=O().c,c=null===m?null===c:m.i(c)):c=!1,c))){k="field";break a}c=O().c;k=(null===c?null===k:c.i(k))?"empty tuple":"tuple"}JX(a,We(Xe(),"Useless "+k+" in statement position."),b.A(),e);t();d=new Qx(a,a.Gd,Rw(a,b,d,e,g,h));return new fe(d)}if(b instanceof Pm)return g=Rw(a,b,d,e,g,h),c||(b instanceof vl||b instanceof Dl?JX(a,We(Xe(),"Pure expression does nothing in statement position."),b.A(),e):(h=ux(a,g,jx(new kx,a,Lq(b),"expression in statement position",
+(tx(a),t().d),(tx(a),!1))),k=a.Ck,c=new y(r=>{fr();var v=Ye(new Te(new Ue(J(new K,["Expression in statement position should have type `unit`."]))),u()),x=t().d;v=G(new H,v,x);x=Ye(new Te(new Ue(J(new K,["Use the `discard` function to discard non-unit values, making the intent clearer."]))),u());var A=t().d;x=G(new H,x,A);e.n(hr(0,new z(v,new z(x,r.vt())),a.$c,lu()))}),b=jx(new kx,a,b.A(),hu(b),(tx(a),t().d),(tx(a),!1)),m=Sw(a).ob,Tw(a,h,k,c,b,d,m))),t(),new fe(g);d=new Te(new Ue(J(new K,["Illegal position for this ",
+" statement."])));g=[We(Xe(),b.jb())];Lw(a,Ye(d,J(new K,g)),b.A(),e);t();d=t().d;return new Ud(d)}
+function h7(a,b,c,d,e,g,h){var k=jx(new kx,a,d.A(),"binding of "+hu(d),(tx(a),t().d),(tx(a),!1));if(b){var l=V(a);b=t().d;t();var m=new L(c),n=O().c,r=O().c;l=new lx(a,1+e.da|0,n,r,b,m,!0,l);b=new qx(a,l,new vl(c));Wx(e,G(new H,c,b));t();c=new vl(c);var v=new Iw(e.S,e.Ec,e.hc,e.Ed,e.da,e.Pc,e.Zc,e.Lb,e.yc,e.tb,e.$a,new L(c),e.cb);c=1+v.da|0;b=Hw();m=Su();n=op().ga;b=b.Hd(new Uu(m,n));c=new Iw(v.S,v.Ec,v.hc,v.Ed,c,v.Pc,v.Zc,v.Lb,v.yc,v.tb,v.$a,v.od,b);t();d=Rw(a,d,c,g,h,a.rP);h=Sw(a).ob;Tw(a,d,l,g,
+k,c,h);wy(l,(t(),new L(d)));d=c.cb;up(tp(),v.S.li||c.cb.b());if(!d.b()){h=v.S.qa;c=v.S;c.F&&(b=ut(Q(),"| ",c.r)+"UNSTASHING... (out)",ff(gf(),b+"\n"));c.r=1+c.r|0;try{d.Ca(new y(A=>{if(null!==A){var B=A.h();for(A=A.j().m();A.s();){var C=A.t();a:{if(null!==C){var D=C.j();if(!0===C.Rc()){C=Sw(v.S).ob;Tw(v.S,D,B,g,k,v,C);break a}}if(null!==C&&(D=C.j(),!1===C.Rc())){C=Sw(v.S).ob;Tw(v.S,B,D,g,k,v,C);break a}throw new w(C);}}}else throw new w(A);}));d.mg();var x=void 0}finally{c.r=-1+c.r|0}dx(new E(h),
+c.qa)&&c.F&&(d=""+ut(Q(),"| ",c.r)+h.n(x),ff(gf(),d+"\n"))}d=l}else if(x=1+e.da|0,c=Hw(),b=Su(),m=op().ga,c=c.Hd(new Uu(b,m)),x=new Iw(e.S,e.Ec,e.hc,e.Ed,x,e.Pc,e.Zc,e.Lb,e.yc,e.tb,e.$a,e.od,c),d=Rw(a,d,x,g,h,!0),h=x.cb,up(tp(),e.S.li||x.cb.b()),!h.b()){x=e.S.qa;c=e.S;c.F&&(b=ut(Q(),"| ",c.r)+"UNSTASHING... (out)",ff(gf(),b+"\n"));c.r=1+c.r|0;try{h.Ca(new y(((A,B)=>C=>{if(null!==C){var D=C.h();for(C=C.j().m();C.s();){var F=C.t();a:{if(null!==F){var I=F.j();if(!0===F.Rc()){F=Sw(A.S).ob;Tw(A.S,I,D,
+g,k,B,F);break a}}if(null!==F&&(I=F.j(),!1===F.Rc())){F=Sw(A.S).ob;Tw(A.S,D,I,g,k,B,F);break a}throw new w(F);}}}else throw new w(C);})(e,e))),h.mg(),l=void 0}finally{c.r=-1+c.r|0}dx(new E(x),c.qa)&&c.F&&(h=""+ut(Q(),"| ",c.r)+x.n(l),ff(gf(),h+"\n"))}return new Qx(a,e.da,d)}function ux(a,b,c){if(a.sP){var d=b.ma();return Ot(new E(d),c)?b:new OA(a,b,c)}return b}function W6(a,b,c,d,e){return Rw(a,b,c,d,e,!1)}
+function j7(a,b,c,d){if(b.Lb){var e=d7(a),g=t().d,h=t().d,k=O().c,l=O().c,m=new lx(a,b.da,k,l,g,h,!1,e);e=fY(c);c=Tea(c,m);g=new y(n=>{if(n instanceof Ff){var r=Ey(a),v=new y(()=>{}),x=V(a),A=Sw(a).ob;Tw(a,r,m,v,x,b,A)}d.n(n)});h=V(a);k=Sw(a).ob;Tw(a,e,c,g,h,b,k);gY(b,m)}}
+function Rw(a,b,c,d,e,g){return Lx(a,new U(()=>c.da+". Typing "+(c.yc?"pattern":"term")+" "+b),new U(()=>{var h=ny(a,b,!1),k=!1,l=null,m=!1,n=null,r=!1,v=null,x=!1,A=null,B=!1,C=null,D=!1,F=null,I=!1,M=null,N=!1,P=null;if(b instanceof vl&&(k=!0,l=b,"_"===l.x)){if(c.yc){var T=jx(new kx,a,l.A(),"wildcard",(tx(a),t().d),(tx(a),!1)),Y=t().d,Z=t().d,S=O().c,ea=O().c;return new lx(a,c.da,S,ea,Y,Z,!1,T)}return Lw(a,Ye(new Te(new Ue(J(new K,["Widlcard in expression position."]))),u()),l.A(),d)}if(b instanceof
+Ml){var ia=b.Ml,X=Rw(a,b.gs,c,d,e,g);Q6(a,X,a.RE,a.Ck,c,d,h);return Rw(a,ia,c,d,e,g)}if(b instanceof Cl){m=!0;n=b;var sa=n.ai,Ja=n.Fm;if(sa instanceof vl){var Xa=tC(f7(a),sa,c,d);if(!Xa.b()){var Fa=Xa.o(),za=new Iw(c.S,c.Ec,c.hc,c.Ed,c.da,c.Pc,c.Zc,c.Lb,!1,c.tb,c.$a,c.od,c.cb),Qa=nf(),Ma=ox(a,Ja,za,d,e,Qa);jx(new kx,a,a.$E?sa.A():t().d,"variable",(tx(a),t().d),(tx(a),!1));var Ga=c.hc.U(Fa);if(Ga instanceof L)return Lw(a,We(Xe(),"Duplicate use of annotated pattern variable "+Fa),sa.A(),d);if(t().d===
+Ga){var ab=new qx(a,Ma,sa);Wx(c,G(new H,Fa,ab));return Ma}throw new w(Ga);}}}if(m){var Hb=n.Fm,bc=Rw(a,n.ai,c,d,e,!0),yb=new Iw(c.S,c.Ec,c.hc,c.Ed,c.da,c.Pc,c.Zc,c.Lb,!1,c.tb,c.$a,c.od,c.cb),tb=nf(),eb=ox(a,Hb,yb,d,e,tb);if(c.yc){var kb=Sw(a).ob;KX(a,bc,eb,d,h,c,kb);return eb}return Q6(a,bc,eb,eb,c,d,h)}if(k){var Rb=tC(f7(a),l,c,d);if(!Rb.b()){var Gb=Rb.o(),vb=jx(new kx,a,a.$E?l.A():t().d,"variable",(tx(a),t().d),(tx(a),!1)),Tb=c.hc.U(Gb),Nb=new N_(a,l);if(Tb.b())cb=R();else var ic=new Wr(Nb),Va=
+Tb.o(),cb=Vr(ic,Va);var zb=new U((Ca=>()=>{var Lc=new lx(a,c.da,O().c,O().c,t().d,zy(ju(),a.F,new U(()=>Gb)),(TP(a),!1),vb);t();var yd=i7(a);Ca.kt=new L(yd);yd=new qx(a,Lc,Ca);Wx(c,G(new H,Gb,yd));return Lc})(l));return cb.b()?Es(zb):cb.o()}}if(k){var Ub=xC(yC(a),l,d);if(!Ub.b()){var jb=Ub.k,db=uC(c,c,jb),ub=new U(()=>Lw(a,We(Xe(),"identifier not found: "+jb),b.A(),d)),Aa=new y(Ca=>{if(Ca instanceof qx){Ca=Ca.tp;if(c.Lb){var Lc=eY(c,jb),yd=new y(Qe=>{gY(c,Qe)});Lc.b()||yd.n(Lc.o())}return Ca}if(Ca instanceof
+VP){if(Ca instanceof ix){Lc=Ca.kh;if(Lc instanceof bx)return Lc.Nn();if(Lc instanceof Vw)return Lc.ig.ra;if(Lc instanceof Yw)return R6(a,Lc.Rf,b,d),Dy(Lc.nc,!1,h.Ga,Lc.Rf,Lc.Sm,Lc.gh,Lc.Ij,Lc.gl,0,d);if(Lc&&Lc.$classData&&Lc.$classData.rb.Rs)return Ca=new Te(new Ue(J(new K,[""," "," cannot be used in term position"]))),Lc=[We(Xe(),Lc.fd().ld),We(Xe(),Lc.Ua())],Lw(a,Ye(Ca,J(new K,Lc)),h.Ga,d);throw new w(Lc);}if(Ca instanceof fx)return R6(a,Ca.Ab,b,d),Cy(Ca,!1,h.Ga,d)}throw new w(Ca);}),va=db.b()?
+Es(ub):Aa.n(db.o());return ux(a,va,h)}}if(b instanceof Dl)return new Mu(a,b,a.$c?yq(b):fq(b),h);if(b instanceof am){Lw(a,We(Xe(),"Illegal use of `super`"),b.A(),d);var Ra=new vl("super"),rb=b.A();return Rw(a,Cq(Ra,rb),c,d,e,g)}if(b instanceof Pl){r=!0;v=b;var xb=v.Za;if(xb instanceof vl){var mc=xb.x;"neg"!==mc&&"~"===mc}}if(r){var Ha=v.Za;if(Ha instanceof Pl){var Ka=Ha.Za;Ka instanceof vl&&"|"===Ka.x}}if(r){var Oa=v.Za;if(Oa instanceof Pl){var Na=Oa.Za;Na instanceof vl&&"\x26"===Na.x}}if(b instanceof
+yl){var Da=b.ll,ta=jx(new kx,a,b.A(),"record literal",(tx(a),t().d),(tx(a),!1));ET(Da,new y(Ca=>Ca.h().x),new y(Ca=>Ca.h())).Ca(new y(Ca=>{if(null!==Ca&&(Ca=new L(Ca),!Ca.b())){var Lc=Ca.k.h();Ca=Ca.k.j();if(0<Ca.ab(1)){var yd=new Te(new Ue(J(new K,["Multiple declarations of field name "," in ",""])));Lc=[We(Xe(),Lc),We(Xe(),ta.lh)];Lc=Ye(yd,J(new K,Lc));yd=b.A();Lc=G(new H,Lc,yd);Ca=Qt(Ca,new y(Qe=>{var Xj=Ye(new Te(new Ue(J(new K,["Declared at"]))),u());Qe=Qe.A();return G(new H,Xj,Qe)}));return ay(a,
+new z(Lc,Ca),d)}}}));return SA(xv(a),Qt(Da,new y(Ca=>{if(null!==Ca){var Lc=Ca.h(),yd=Ca.j();if(null!==yd){var Qe=yd.yb;yd=yd.ya;if(null!==Qe){Qe=Qe.je;hB(ve(),Lc.x)&&Lw(a,Ye(new Te(new Ue(J(new K,["Field identifiers must start with a small letter"]))),u()),b.A(),d);Ca=Rw(a,yd,c,d,e,!0);yd=jx(new kx,a,(new Pl(Lc,yd)).A(),(Qe?"mutable ":"")+"record field",(tx(a),t().d),(tx(a),!1));if(Qe){Qe=t().d;t();var Xj=new L(Lc.x),fl=O().c,Gk=O().c;Qe=new lx(a,c.da,fl,Gk,Qe,Xj,!1,yd);Ca=Q6(a,Ca,Qe,Qe,c,d,h);return G(new H,
+Lc,new Uw(a,new L(Ca),Ca,yd))}return G(new H,Lc,new Uw(Ca.q,R(),Ca,yd))}}}throw new w(Ca);})),ta)}b instanceof Gl&&(x=!0,A=b);if(x){var Ya=A.Ra,dc=Qt(bga(Ya,Ya,new y(Ca=>{if(null!==Ca){var Lc=Ca.h(),yd=Ca.j();if(null!==yd){var Qe=yd.yb,Xj=yd.ya;if(Lc instanceof L&&(yd=Lc.k,c.yc)){Ca=new Cl(yd,nx(Xj,d));yd=yd.A();var fl=new U(()=>Xj.A()),Gk=new y($n=>{$n=Kt($n,Xj.A());return it().n($n)});yd=yd.b()?Es(fl):Gk.n(yd.o());return G(new H,Lc,new sm(Qe,Cq(Ca,yd)))}return Ca}}throw new w(Ca);})),new y(Ca=>
+{if(null!==Ca){var Lc=Ca.h(),yd=Ca.j();if(null!==yd){var Qe=yd.yb;yd=yd.ya;if(null!==Qe){Ca=Qe.je;if(Qe.Bh){Qe=Ye(new Te(new Ue(J(new K,["Cannot use `val` in this position"]))),u());cu();var Xj=Lc.ha();Lw(a,Qe,du(0,new z(yd,Xj)),d)}Qe=Rw(a,yd,c,d,e,!0);yd=jx(new kx,a,yd.A(),(Ca?"mutable ":"")+"tuple field",(tx(a),t().d),(tx(a),!1));if(Ca){Ca=t().d;Xj=new y($n=>$n.x);Xj=Lc.b()?R():new L(Xj.n(Lc.o()));var fl=O().c,Gk=O().c;Ca=new lx(a,c.da,fl,Gk,Ca,Xj,!1,yd);Qe=Q6(a,Qe,Ca,Ca,c,d,h);return G(new H,Lc,
+new Uw(a,new L(Qe),Qe,yd))}return G(new H,Lc,new Uw(Qe.q,R(),Qe,yd))}}}throw new w(Ca);}));a:{var ka=O().c;if(null===ka?null===Ya:ka.i(Ya))var ya=!0;else{if(Ya instanceof z){var Sa=Ya.z,xc=Ya.p;if(null!==Sa){var Sb=Sa.h();if(t().d===Sb)var uc=O().c,Lb=null===uc?null===xc:uc.i(xc);else Lb=!1;if(Lb){ya=!0;break a}}}ya=!1}}return new zv(a,dc,ya?V(a):jx(new kx,a,b.A(),"tuple literal",(tx(a),t().d),(tx(a),!1)))}if(b instanceof Vl){var lc=b.mp,Xb=W6(a,b.lp,c,d,e),ec=W6(a,lc,c,d,e);Q6(a,ec,a.ki,a.La,c,d,
+h);var Ab=t().d,Ob=t().d,fb=O().c,Wa=O().c,bb=new lx(a,c.da,fb,Wa,Ab,Ob,!1,h),Ia=rA(bb),Ua=new fw(a,new Ep("undefined"),O().c,V(a)),pc=jx(new kx,h.Wu,h.Ga,"prohibited undefined element",h.go,h.Zm),sc=NA(Ua,pc,!1);KA(bb,new z(sc,Ia));var Ba=jx(new kx,a,lc.A(),"array element",(tx(a),t().d),(tx(a),!1)),ob=Q6(a,Xb,new Sv(a,new Uw(bb.q,R(),bb,Ba),h),bb,c,d,h),nc=new Ep("undefined"),Ib=O().c,vc=new fw(a,nc,Ib,jx(new kx,h.Wu,h.Ga,"possibly-undefined array access",h.go,h.Zm)),Vb=V(ob.q);return dv(ob,vc,Vb,
+!1)}if(b instanceof dm){var fc=b.Zq,Bc=W6(a,b.$q,c,d,e);Q6(a,Bc,a.lg,a.Ck,c,d,h);var Pb=new Gm(!0),Jb=O().c;return Rw(a,new Sl(new z(fc,new z(Pb,Jb))),c,d,e,g)}if(b instanceof Wl){B=!0;C=b;var gc=C.Gm,Cb=C.Qn;if(gc instanceof Ql){var cc=gc.Vl,yc=gc.ml,Mc=W6(a,cc,c,d,e),qc=jx(new kx,a,gc.A(),"assigned selection",(tx(a),t().d),(tx(a),!1)),oc=t().d;t();var Qc=yc.x,jc=zy(0,!(0<=Qc.length&&"_"===Qc.substring(0,1)),new U(()=>yc.x)),sb=O().c,Gc=O().c,Wb=new lx(a,c.da,sb,Gc,oc,jc,!1,qc),Cc=ux(a,Mc,jx(new kx,
+a,Lq(cc),"receiver",(tx(a),t().d),(tx(a),!1))),Fc=xv(a),qd=G(new H,yc,new Uw(a,new L(Wb),a.La,jx(new kx,a,yc.A(),"assigned field",(tx(a),t().d),(tx(a),!1)))),Yb=O().c;Q6(a,Cc,SA(Fc,new z(qd,Yb),qc),Wb,c,d,h);var Nc=W6(a,Cb,c,d,e),ad=a.Ck;return Q6(a,Nc,Wb,ux(ad.q,ad,h),c,d,h)}}if(B){var Uc=C.Gm,cd=C.Qn;if(Uc instanceof Vl){var kc=Uc.lp,Vc=Uc.mp,Hc=W6(a,kc,c,d,e),rc=jx(new kx,a,Uc.A(),"assigned array element",(tx(a),t().d),(tx(a),!1)),sd=t().d,Kc=t().d,Qd=O().c,Ad=O().c,kd=new lx(a,c.da,Qd,Ad,sd,Kc,
+!1,rc),Hd=ux(a,Hc,jx(new kx,a,Lq(kc),"receiver",(tx(a),t().d),(tx(a),!1)));Q6(a,Hd,new Sv(a,new Uw(a,new L(kd),kd,rc),h),a.La,c,d,h);var Rd=W6(a,Vc,c,d,e);Q6(a,Rd,a.ki,a.La,c,d,h);var Bd=W6(a,cd,c,d,e),ae=a.Ck;return Q6(a,Bd,kd,ux(ae.q,ae,h),c,d,h)}}if(B){var dd=C.Gm,od=C.Qn;if(dd instanceof vl){var Ta=Rw(a,od,c,d,e,g),wb=!1,$a=null,wa=uC(c,c,dd.x);if(wa instanceof L){wb=!0;$a=wa;var hb=$a.k;if(hb instanceof qx){var ra=a.Ck;return Q6(a,Ta,hb.tp,ux(ra.q,ra,h),c,d,h)}}if(wb){var wc=$a.k;if(wc instanceof
+ix){var ac=wc.kh;if(ac instanceof bx){S6(a,ac.Mb,h,d);var Id=ac.Nn(),ud=a.Ck;return Q6(a,Ta,Id,ux(ud.q,ud,h),c,d,h)}}}if(wb){var be=$a.k;if(be instanceof fx){null===a.Qq&&null===a.Qq&&(a.Qq=new BC(a));t();var re=new L(be.Ab);if(!re.b()){var pe=re.k;if(pe instanceof Zn){S6(a,pe,h,d);var bd=Ux(be),Rc=a.Ck;return Q6(a,Ta,bd,ux(Rc.q,Rc,h),c,d,h)}}}}var Wc=Ye(new Te(new Ue(J(new K,["Illegal assignment"]))),u()),Wd=G(new H,Wc,h.Ga),zd=new Te(new Ue(J(new K,["cannot assign to ",""]))),Pa=[We(Xe(),hu(dd))],
+Db=Ye(zd,J(new K,Pa)),Oc=dd.A(),Tc=G(new H,Db,Oc),Sd=O().c;return ay(a,new z(Wd,new z(Tc,Sd)),d)}}if(B){var Jc=C.Gm,vd=Ye(new Te(new Ue(J(new K,["Illegal assignment"]))),u()),hd=G(new H,vd,h.Ga),de=new Te(new Ue(J(new K,["cannot assign to ",""]))),ye=[We(Xe(),hu(Jc))],jf=Ye(de,J(new K,ye)),af=Jc.A(),pf=G(new H,jf,af),kf=O().c;return ay(a,new z(hd,new z(pf,kf)),d)}if(b instanceof Fl){D=!0;F=b;var Be=F.gg;if(!1===F.bi&&Be instanceof Sl)return Rw(a,Be,c,d,e,g)}if(D)return Rw(a,F.gg,c,d,e,g);if(b instanceof
+Sl){I=!0;M=b;var Kd=M.Dj;if(Kd instanceof z){var ld=Kd.z,Jd=Kd.p;if(ld instanceof Pm){var Dd=O().c;if(null===Dd?null===Jd:Dd.i(Jd))return Rw(a,ld,c,d,e,g)}}}if(I){var Xd=M.Dj,Yc=O().c;if(null===Yc?null===Xd:Yc.i(Xd)){var Ce=a.Ck;return ux(Ce.q,Ce,h)}}if(c.yc){var te=new Te(new Ue(J(new K,["Unsupported pattern shape",":"]))),Ie=[a.F?We(Xe()," ("+ca(b).u()+")"):We(Xe(),"")];return Lw(a,Ye(te,J(new K,Ie)),b.A(),d)}if(b instanceof Ol){N=!0;P=b;var Jf=P.Ej,df=P.Fj;if(Pe(new E(g),!0)){Nx(a,new U(()=>"TYPING POLY LAM"));
+var vg=c.Lb?iY(c):tf(c),wg=new y(Ca=>{var Lc=g7(a,Jf,Ca,d,e),yd=Rw(a,df,Ca,d,e,a.VI||Pe(new E(g),!0)&&a.li);j7(a,c,Ca,d);return new cv(a,Lc,yd,jx(new kx,a,b.A(),"function",(tx(a),t().d),(tx(a),!1)))});Sw(vg.S);return Px(vg,wg,d,h)}}if(N){var xg=P.Ej,eg=P.Fj,vh=c.Lb?iY(c):tf(c),fg=g7(a,xg,vh,d,e);up(tp(),!Pe(new E(g),!0));var ih=Rw(a,eg,vh,d,e,a.VI||Pe(new E(g),!0));j7(a,c,vh,d);return new cv(a,fg,ih,jx(new kx,a,b.A(),"function",(tx(a),t().d),(tx(a),!1)))}if(b instanceof Yl){var Ig=new Yl(b.hp),Tf=
+new Gl(O().c),Jg=b.A(),jh=new y(Ca=>new Kq(Ca.eh,Ca.eh,Ca.dh)),yg=Jg.b()?R():new L(jh.n(Jg.o()));return W6(a,new Pl(Ig,Cq(Tf,yg)),c,d,e)}if(r){var gg=v.Za,Cf=v.Qb;if(gg instanceof Yl){var Uf=gg.hp;Uf instanceof Il&&Lw(a,Ye(new Te(new Ue(J(new K,["Type arguments in `new` expressions are not yet supported"]))),u()),h.Ga,d);var $g=nx(Uf,d),Ah=nf(),Kg=ox(a,$g,c,d,e,Ah),Vf=!1,hg=null,zg=DB(Kg);a:if(zg instanceof fw)var Lg=T6(a,zg.qb.V,c,b,d,h);else{if(zg instanceof Mu){Vf=!0;hg=zg;var Mg=hg.pd,Wf=a.Bk;
+if(null===Wf?null===Mg:Wf.i(Mg)){Lg=hg;break a}}if(Vf){var Ng=hg.pd;if(Ng instanceof vl){Lg=T6(a,Ng.x,c,b,d,h);break a}}var Kf=new Te(new Ue(J(new K,["Unexpected type `","` after `new` keyword"]))),xf=[wO(Xe(),AD(Kg,c))],Og=Ye(Kf,J(new K,xf)),mi=Uf.A(),Ci=G(new H,Og,mi),Xh=O().c;Lg=ay(a,new z(Ci,Xh),d)}var wh=t().d,Bh=t().d,ng=O().c,kh=O().c,Kh=new lx(a,c.da,ng,kh,wh,Bh,!1,h),ni=jx(new kx,a,Cf.A(),"argument list",(tx(a),t().d),(tx(a),!1)),Lh=Rw(a,Cf,c,d,e,g);return Q6(a,Lg,new cv(a,ux(Lh.q,Lh,ni),
+Kh,V(a)),Kh,c,d,h)}}if(r){var lh=v.Za;if(lh instanceof Pl){var Ch=lh.Za;if(Ch instanceof vl&&"is"===Ch.x){var Dh=new Ut(b,new vl("true"));t();var Yh=new vl("false"),ah=new Xl(Dh,new L(Yh));b.oc=(t(),new L(ah));return Rw(a,ah,c,d,e,g)}}}if(r){var oi=v.Za;if(oi instanceof vl&&"is"===oi.x){var mj=new Ut(b,new vl("true"));t();var wd=new vl("false"),ge=new Xl(mj,new L(wd));b.oc=(t(),new L(ge));return Rw(a,ge,c,d,e,g)}}if(r){var De=v.Za,qf=v.Qb;if(De instanceof Pl){var og=De.Za,Xf=De.Qb;if(og instanceof
+vl&&"and"===og.x&&null!==Xf){var mh=mz(eu(),Xf);if(!mh.b()&&null!==mh.o()&&0===mh.o().ab(1)){var Ag=mh.o(),Bg=eB(Ag,0);if(null!==qf){var Eh=mz(eu(),qf);if(!Eh.b()&&null!==Eh.o()&&0===Eh.o().ab(1)){var Pg=Eh.o(),Di=eB(Pg,0),Mh=new Ut(Bg,Di);t();var pi=new vl("false"),Xi=new Xl(Mh,new L(pi));b.oc=(t(),new L(Xi));return Rw(a,Xi,c,d,e,g)}}}}}}if(r){var Qg=v.Za,nh=v.Qb;if(Qg instanceof vl&&"and"===Qg.x&&null!==nh){var bh=mz(eu(),nh);if(!bh.b()&&null!==bh.o()&&0===bh.o().ab(2)){var Mj=bh.o(),Nj=eB(Mj,0),
+ie=bh.o(),Ac=eB(ie,1),Ve=new Ut(Nj,Ac);t();var Td=new vl("false"),lf=new Xl(Ve,new L(Td));b.oc=(t(),new L(lf));return Rw(a,lf,c,d,e,g)}}}if(r){var Yi=v.Za,Jl=v.Qb;if(null!==Yi&&Jl instanceof Gl&&Jl.Ra.qo(new y(Ca=>!Ca.h().b()))){var ll=Rw(a,Yi,c,d,e,g),Bj=Tfa(a,ll,c),$k=!1,Zh=null;if(Bj instanceof z){$k=!0;Zh=Bj;var Ei=Zh.z,Yd=Zh.p;if(null!==Ei){var bf=Ei.Nb;if(bf instanceof zv){var rf=bf.Yb,Cg=O().c;if(null===Cg?null===Yd:Cg.i(Yd)){if(rf.qo(new y(Ca=>Ca.h().b())))return Lw(a,We(Xe(),"Cannot use named arguments as the function type has untyped arguments"),
+Jl.A(),d);var nj=Qt(rf,new y(Ca=>{Ca=Ca.h();if(Ca instanceof L)return Ca.k;if(t().d===Ca)xm("Program reached and unexpected state.");else throw new w(Ca);}));return cga(a,b,Yi,Jl,nj,ll,c,d,e)}}}}if($k&&Zh.p instanceof z){var Jh=new Te(new Ue(J(new K,["More than one function signature found in type `","` for function call with named arguments"]))),If=[wO(Xe(),AD(ll,c))];return Lw(a,Ye(Jh,J(new K,If)),Yi.A(),d)}a:{var Hg=O().c;if(null===Hg?null===Bj:Hg.i(Bj))var He=!0;else{if(Bj instanceof z){var lj=
+Bj.p,Wi=O().c;if(null===Wi?null===lj:Wi.i(lj)){He=!0;break a}}He=!1}}if(He){var Oj=new Te(new Ue(J(new K,["Cannot retrieve appropriate function signature from type `","` for applying named arguments"]))),mo=[wO(Xe(),AD(ll,c))];return Lw(a,Ye(Oj,J(new K,mo)),Yi.A(),d)}throw new w(Bj);}}if(r){var mm=v.Za,nm=v.Qb,dq=W6(a,mm,c,d,e);if(nm instanceof Gl){var Zd=nm.Ra,sf=Qt(Zd,new y(Ca=>{if(null!==Ca){var Lc=Ca.h(),yd=Ca.j();if(null!==yd){var Qe=yd.ya;if(null!==yd.yb)return Ca=jx(new kx,a,Qe.A(),"argument",
+(tx(a),t().d),(tx(a),!1)),Qe=V6(a,Qe,c,d,e,h),G(new H,Lc,new Uw(Qe.q,R(),Qe,Ca))}}throw new w(Ca);}));a:{var oj=O().c;if(null===oj?null===Zd:oj.i(Zd))var al=!0;else{if(Zd instanceof z){var Ll=Zd.z,Qm=Zd.p;if(null!==Ll){var Rm=Ll.h();if(t().d===Rm)var hq=O().c,Bn=null===hq?null===Qm:hq.i(Qm);else Bn=!1;if(Bn){al=!0;break a}}}al=!1}}var hp=new zv(a,sf,al?V(a):jx(new kx,a,nm.A(),"argument list",(tx(a),t().d),(tx(a),!1)))}else hp=V6(a,nm,c,d,e,h);var ru=t().d,qr=t().d,Xs=O().c,rr=O().c,iq=new lx(a,c.da,
+Xs,rr,ru,qr,!1,h),qo=ux(a,hp,jx(new kx,a,Lq(nm),"argument",(tx(a),t().d),(tx(a),!1))),qm=jx(new kx,a,Lq(mm),"applied expression",(tx(a),t().d),(tx(a),!1)),jq=ux(a,dq,qm);return Q6(a,jq,new cv(a,qo,iq,h),iq,c,d,h)}if(b instanceof Ql){var pl=b.Vl,ro=b.ml,Cn=!1,ip=null;if(pl instanceof vl){Cn=!0;ip=pl;var so=ip.x;if(hB(ve(),so)&&c.tb.L(so)){var Dn=hY(c,(t(),new L(so)),ro.x);if(Dn instanceof L){var sr=Dn.k.maa();return TA(sr,c)}if(t().d===Dn){var kq=new Te(new Ue(J(new K,["Class "," has no method ",""]))),
+ql=[We(Xe(),so),We(Xe(),ro.x)];Lw(a,Ye(kq,J(new K,ql)),b.A(),d);return X6(a,pl,ro,c,b,d,e,h)}throw new w(Dn);}}if(Cn){var Ys=ip.x;if("unapply"===ro.x){var Sm=!1,Nl=null,jp=uC(c,c,Ys);a:{if(jp instanceof L){Sm=!0;Nl=jp;var lq=Nl.k;if(lq instanceof ix){var mq=lq.kh;if(mq instanceof Yw){var Tm=Cp(mq.Rf);break a}}}if(Sm){var En=Nl.k;if(En instanceof fx){Tm=Cp(En.Ab);break a}}Tm=t().d}if(Tm instanceof L){var to=Tm.k;if(null!==to){var Fn=to.Yc;if(Fn instanceof fe)return Rw(a,Fn.aa,c,d,e,!0)}}}}return X6(a,
+pl,ro,c,b,d,e,h)}if(b instanceof Rl){var nq=b.ep,Um=b.Zn,kp=b.$n,oq=b.Mm;if(c.Lb){var su=Rw(a,kp,c,d,e,g),Gn=iY(c),ur=Um.x,In=new qx(a,su,Um);Wx(Gn,G(new H,ur,In));var Zs=Rw(a,oq,Gn,d,e,g);j7(a,c,Gn,d);return Zs}if(a.$c&&!nq){var $s=Rw(a,kp,c,d,e,g),pq=tf(c),vr=Um.x,Vm=new qx(a,$s,Um);Wx(pq,G(new H,vr,Vm));return Rw(a,oq,pq,d,e,g)}var Jn=h7(a,nq,Um.x,kp,c,d,e),wr=tf(c),at=Um.x,xr=new qx(a,Jn,Um);Wx(wr,G(new H,at,xr));return Rw(a,oq,wr,d,e,g)}if(I){var lp=M.Dj;if(a.$c){var Kn=new Dt(lp);t();var qq=
+of(a,Kn,new L(M),c,d,e).Ul,yr=new U(()=>a.Ck);return qq.b()?Es(yr):qq.o()}return k7(a,lp,!1,O().c,!1,tf(c),d,h,e,g)}if(b instanceof Tl){var rq=b.ar,sq=W6(a,b.br,c,d,e),bt=W6(a,rq,c,d,e),tq=rq.ll.m(),zr=new Ef(tq,new y(Ca=>Ca.h())),ct=Su(),Ar=op().ga,uq=new Uu(ct,Ar),Br=oA(uv(),zr,uq),Ln=iB(sq,Br);return Pu(Ln,bt,h,!1)}if(b instanceof Ul){var vq=b.Sn,Cr=b.Hm,tu=c.Lb?iY(c):c;return(new y(Ca=>{var Lc=W6(a,vq,Ca,d,e);if(a.$c){var yd=a.mP;Q6(a,Lc,ux(yd.q,yd,h),a.La,Ca,d,h)}yd=l7(a,Wk(new O_(a)).Ob(vq,
+new y(()=>{t();return R()})),Cr,Ca,d,e,g);if(null!==yd)var Qe=G(new H,yd.h(),yd.j());else throw new w(yd);yd=Qe.h();Qe=Qe.j();j7(a,c,Ca,d);yd=yd.mf(a.ib,new fn((Xj,fl)=>{var Gk=G(new H,Xj,fl);fl=Gk.y;Xj=Gk.w;if(null!==fl){Gk=fl.h();fl=fl.j();var $n=V(Gk.q);fl=Pu(Gk,fl,$n,!1);$n=V(Gk.q);Gk=NA(Gk,$n,!1);$n=V(Xj.q);Xj=Pu(Xj,Gk,$n,!1);Gk=V(fl.q);return dv(fl,Xj,Gk,!1)}throw new w(Gk);}));return Q6(a,Lc,yd,Qe,Ca,d,h)})).n(tu)}if(b instanceof Xl)try{return Rw(a,Ffa(a,b,c,d),c,d,e,g)}catch(Ca){if(Ca instanceof
+jT)return ay(a,Ca.VP,d);throw Ca;}if(b instanceof Il){var uu=b.nl;Lw(a,Ye(new Te(new Ue(J(new K,["Type application syntax is not yet supported"]))),u()),b.A(),d);return Rw(a,uu,c,d,e,g)}if(b instanceof $l)return k7(a,Xq(b.lt,b.Yq),!1,O().c,!0,c,d,h,e,g);if(b instanceof Zl){var dt=b.qq,vu=b.$o,Dr=new y(Ca=>{var Lc=Qt(dt,new y(yd=>{if(null!==yd){var Qe=yd.pp;if(Qe instanceof Ud){Qe=Qe.fa;var Xj=jx(new kx,a,yd.A(),"quantified type variable",(tx(a),t().d),(tx(a),!1)),fl=t().d;t();var Gk=new L(Qe),$n=
+O().c,$R=O().c;yd=new mx(a,new lx(a,Ca.da,$n,$R,fl,Gk,!1,Xj),jx(new kx,a,yd.A(),"rigid type variable",(tx(a),t().d),(tx(a),!1)));return G(new H,Qe,yd)}}xm("Program reached and unexpected state.")}));Lc=e.bf(Lc);return(new y(yd=>W6(a,vu,Ca,d,yd))).n(Lc)});Sw(c.S);return Px(c,Dr,d,h)}if(b instanceof Kl){var uo=Rw(a,b.cp,c,d,e,!0),Er=new GA(!1),et=Vfa(uo,c,Er);if(!Er.Am){var ft=new Te(new Ue(J(new K,["Inferred type `","` of this "," cannot be instantiated"]))),gt=[wO(Xe(),AD(uo,c)),We(Xe(),uo.ma().lh)];
+JX(a,Ye(ft,J(new K,gt)),h.Ga,d)}return et}if(b instanceof bm)return Lw(a,Ye(new Te(new Ue(J(new K,["Unexpected equation in this position"]))),u()),b.A(),d);if(b instanceof em){var Wm=b.Iq;if(c.Lb)return Lw(a,Ye(new Te(new Ue(J(new K,["Nested quotation is not allowed."]))),u()),b.A(),d);var Fr=iY(c),mp=Rw(a,Wm,Fr,d,e,g),wu=new Ep("Code"),ht=fY(Fr),wq=O().c;return new fw(a,wu,new z(mp,new z(ht,wq)),jx(new kx,a,b.A(),"code fragment",(tx(a),t().d),(tx(a),!1)))}if(b instanceof fm){var xq=b.jt;if(c.Lb){var Gr=
+Uea(c),xu=Rw(a,xq,Gr,d,e,g),yu=jx(new kx,a,b.A(),"code fragment body type",(tx(a),t().d),(tx(a),!1)),Re=t().d,rj=t().d,ai=O().c,rm=O().c,Nn=new lx(a,c.da,ai,rm,Re,rj,!1,yu),zu=jx(new kx,a,xq.A(),"code fragment context type",(tx(a),t().d),(tx(a),!1)),Au=t().d,Av=t().d,oy=O().c,Bv=O().c,Cv=new lx(a,c.da,oy,Bv,Au,Av,!1,zu),py=new Ep("Code"),qy=O().c,Dv=Q6(a,xu,new fw(a,py,new z(Nn,new z(Cv,qy)),jx(new kx,a,xq.A(),"unquote body",(tx(a),t().d),(tx(a),!1))),Nn,Gr,d,h);gY(c,Cv);var Ee=jx(new kx,a,b.A(),
+"unquote",(tx(a),t().d),(tx(a),!1));return ux(Dv.q,Dv,Ee)}return Lw(a,We(Xe(),"Unquotes should be enclosed with a quasiquote."),b.A(),d)}if(b instanceof cm)return Lw(a,Ye(new Te(new Ue(J(new K,["Refinement terms are not yet supported"]))),u()),b.A(),d);throw new w(b);}),new y(h=>c.da+". : "+h))}
+function l7(a,b,c,d,e,g,h){var k=tc();try{if(zm()===c){var l=O().c;return G(new H,l,a.ib)}if(c instanceof ym){var m=c.dn,n=jx(new kx,a,c.A(),"wildcard pattern",(tx(a),t().d),(tx(a),!1)),r=t().d,v=t().d,x=O().c,A=O().c,B=new lx(a,d.da,x,A,r,v,!1,n),C=d.Lb?iY(d):tf(d);if(b instanceof L){var D=b.k,F=D.x,I=new qx(a,B,D);Wx(C,G(new H,F,I));var M=Rw(a,m,C,e,g,h),N=G(new H,B,a.La),P=O().c,T=G(new H,new z(N,P),M)}else{var Y=G(new H,B,a.La),Z=O().c,S=new z(Y,Z),ea=Rw(a,m,d,e,g,h);T=G(new H,S,ea)}j7(a,d,C,
+e);return T}if(c instanceof um){var ia=c.Xo,X=c.Tn,sa=c.Un;if(ia instanceof Dl)var Ja=new Mu(a,ia,a.$c?yq(ia):fq(ia),jx(new kx,a,ia.A(),"literal pattern",(tx(a),t().d),(tx(a),!1))),Xa=G(new H,Ja,Ja);else{if(!(ia instanceof vl))throw new w(ia);var Fa=ia.x,za=jx(new kx,a,ia.A(),"type pattern",(tx(a),t().d),(tx(a),!1)),Qa=d.tb.U(Fa);if(R()===Qa){var Ma=()=>{var Yb=new Mu(a,a.Bk,ap(),za),Nc=G(new H,Yb,Yb),ad=O().c;Nc=new z(Nc,ad);throw Hq(new Iq,k,G(new H,Nc,Yb));},Ga=uC(d,d,Fa);a:{if(Ga instanceof L){var ab=
+Ga.k;if(ab instanceof VP){var Hb=ab.fd();if(dx(new E(Hb),Bp()))var bc=ab.fd(),yb=dx(new E(bc),zp());else yb=!1;if(yb)var tb=ab.fd(),eb=dx(new E(tb),Fp());else eb=!1;eb&&Lw(a,Ye(new Te(new Ue(J(new K,["can only match on classes and traits"]))),u()),ia.A(),e);var kb=jx(new kx,a,ia.A(),"class pattern",(tx(a),t().d),(tx(a),!1)),Rb=!1,Gb=null;if(ab instanceof fx){var vb=ab.Ab;vb instanceof yo||xm("Program reached and unexpected state.");var Tb=bz(a,vb,kb,d),Nb=xv(a),ic=ab.Ag(),Va=Yb=>{if(null!==Yb){var Nc=
+Yb.kc,ad=Yb.hb;Yb=Yb.Rd;var Uc=ad.ji;t();var cd=new L(ad);ad=ad.kg;var kc=O().c,Vc=O().c;Uc=new lx(a,d.da,kc,Vc,cd,ad,!1,Uc);cd=new vl(Fa+"#"+Nc.V);Nc=Nc.A();return G(new H,Cq(cd,Nc),XD(WD(a),Yb.b()?ou().Yl:Yb.o(),Uc,Uc,V(a)))}throw new w(Yb);};if(ic===u())var cb=u();else{for(var zb=ic.e(),Ub=new z(Va(zb),u()),jb=Ub,db=ic.f();db!==u();){var ub=db.e(),Aa=new z(Va(ub),u());jb=jb.p=Aa;db=db.f()}cb=Ub}var va=SA(Nb,cb,V(a));if(a.F){var Ra=ut(Q(),"| ",a.r)+("Match arm "+Fa+": "+Tb+" \x26 ")+va;ff(gf(),
+Ra+"\n")}Xa=G(new H,Tb,va);break a}if(ab instanceof ix){Rb=!0;Gb=ab;var rb=Gb.kh;if(rb instanceof Yw){var xb=bz(a,rb.Rf,kb,d),mc=xv(a),Ha=rb.gh,Ka=Yb=>{if(null!==Yb){var Nc=Yb.kc,ad=Yb.hb;Yb=Yb.Rd;var Uc=ad.ji;t();var cd=new L(ad),kc=ad.kg,Vc=O().c,Hc=O().c;Uc=new lx(a,d.da,Vc,Hc,cd,kc,!1,Uc);cd=new vl(Fa+"#"+Nc.V);Nc=Nc.A();return G(new H,Cq(cd,Nc),XD(WD(a),Yb.b()?RA(rb,ad,d):Yb.o(),Uc,Uc,V(a)))}throw new w(Yb);};if(Ha===u())var Oa=u();else{for(var Na=Ha.e(),Da=new z(Ka(Na),u()),ta=Da,Ya=Ha.f();Ya!==
+u();){var dc=Ya.e(),ka=new z(Ka(dc),u());ta=ta.p=ka;Ya=Ya.f()}Oa=Da}var ya=SA(mc,Oa,V(a));if(a.F){var Sa=ut(Q(),"| ",a.r)+("Match arm "+Fa+": "+xb+" \x26 ")+ya;ff(gf(),Sa+"\n")}Xa=G(new H,xb,ya);break a}}if(Rb){Xa=Ma();break a}throw new w(ab);}}Lw(a,We(Xe(),"type identifier not found: "+Fa),ia.A(),e);Xa=Ma()}}else{if(!(Qa instanceof L))throw new w(Qa);var xc=Qa.k,Sb=xc.jj;if(Ap()===Sb||zp()===Sb||cp()===Sb){var uc=Lw(a,Ye(new Te(new Ue(J(new K,["can only match on classes and traits"]))),u()),ia.A(),
+e);Xa=G(new H,uc,uc)}else if(Bp()===Sb){var Lb=rD(a,xc,jx(new kx,a,ia.A(),"class pattern",(tx(a),t().d),(tx(a),!1)),d);Xa=G(new H,Lb,Lb)}else if(Fp()===Sb){var lc=TD(a,xc,jx(new kx,a,ia.A(),"trait pattern",(tx(a),t().d),(tx(a),!1)));Xa=G(new H,lc,lc)}else throw new w(Sb);}}if(null===Xa)throw new w(Xa);var Xb=Xa.h(),ec=Xa.j(),Ab=d.Lb?iY(d):tf(d);if(b instanceof L){var Ob=b.k;if(a.$c){var fb=Ob.x,Wa=V(Xb.q),bb=new qx(a,Pu(Xb,ec,Wa,!1),Ob);Wx(Ab,G(new H,fb,bb));var Ia=Rw(a,X,Ab,e,g,h),Ua=new tl(G(new H,
+Xb,ec),Ia,l7(a,b,sa,d,e,g,h))}else{var pc=jx(new kx,a,Ob.A(),"refined scrutinee",(tx(a),t().d),(tx(a),!1)),sc=t().d,Ba=t().d,ob=O().c,nc=O().c,Ib=new lx(a,d.da,ob,nc,sc,Ba,!1,pc),vc=Ob.x,Vb=new qx(a,Ib,Ob);Wx(Ab,G(new H,vc,Vb));var fc=Rw(a,X,Ab,e,g,h);Ua=new tl(G(new H,ec,Ib),fc,l7(a,b,sa,d,e,g,h))}}else if(t().d===b){var Bc=Rw(a,X,Ab,e,g,h);Ua=new tl(G(new H,Xb,a.La),Bc,l7(a,b,sa,d,e,g,h))}else throw new w(b);a:{if(null!==Ua){var Pb=Ua.kc,Jb=Ua.hb,gc=Ua.Rd;if(null!==gc){var Cb=gc.h(),cc=gc.j();var yc=
+Pb;var Mc=Jb;var qc=Cb;var oc=cc;break a}}throw new w(Ua);}var Qc=yc,jc=Mc,sb=qc,Gc=oc;j7(a,d,Ab,e);var Wb=new z(Qc,sb),Cc=V(jc.q),Fc=dv(jc,Gc,Cc,!1);return G(new H,Wb,Fc)}throw new w(c);}catch(Yb){if(Yb instanceof Iq){var qd=Yb;if(qd.Qg===k)return qd.Cj();throw qd;}throw Yb;}}
+function k7(a,b,c,d,e,g,h,k,l,m){var n=!1,r=null;if(b instanceof z){n=!0;r=b;var v=r.z,x=r.p;if(v instanceof vl&&c)return t(),e=new L(v),v=new sm(tm().Cg,v),e=G(new H,e,v),v=O().c,e=new Gl(new z(e,v)),k7(a,new z(e,x),c,d,!1,g,h,k,l,m)}if(n&&(x=r.z,v=r.p,x instanceof Sl))return k7(a,dl(v,x.Dj),c,d,!1,g,h,k,l,m);if(n&&(v=r.z,x=r.p,v instanceof Gl)){v=v.Ra;var A=O().c;if(null===A?null===v:A.i(v))return k7(a,x,c,d,!1,g,h,k,l,m)}if(n&&(v=r.z,x=r.p,v instanceof Gl&&(v=v.Ra,v instanceof z))){var B=v.z;A=
+v.p;if(null!==B){v=B.h();var C=B.j();if(null!==C&&(B=C.ya,null!==C.yb)){a:{if(B instanceof Fl&&(e=B.gg,!1===B.bi&&g.yc)){e=g7(a,e,g,h,l);break a}e=g.yc&&v.b();e=new Iw(g.S,g.Ec,g.hc,g.Ed,g.da,g.Pc,g.Zc,g.Lb,e,g.tb,g.$a,g.od,g.cb);e=A.b()?Rw(a,new Fl(c,B),e,h,l,m):Rw(a,B,e,h,l,m)}r=!1;n=null;a:{if(v instanceof L&&(r=!0,n=v,b=n.k,g.yc)){n=jx(new kx,a,B.A(),"parameter type",(tx(a),t().d),(tx(a),!1));r=new lx(a,g.da,O().c,O().c,t().d,(TP(a),t().d),(TP(a),!1),n);B=Sw(a).ob;Tw(a,r,e,h,n,g,B);e=b.x;b=new qx(a,
+r,b);Wx(g,G(new H,e,b));e=r;break a}r&&(r=n.k,b=r.x,r=new qx(a,e,r),Wx(g,G(new H,b,r)))}A=new Gl(A);x=new z(A,x);e=G(new H,v,e);return k7(a,x,c,new z(e,d),!1,g,h,k,l,m)}}}if(n&&(x=r.z,v=r.p,x instanceof Pm&&(A=O().c,null===A?null===v:A.i(v))))return d.b()||JX(a,We(Xe(),"Previous field definitions are discarded by this returned expression."),x.A(),h),Rw(a,x,g,h,l,m);if(n){x=r.p;A=r.z.nv();if(null===A)throw new w(A);v=A.j();for(A=A.h();!A.b();)h.n(A.e()),A=A.f();for(b=A=null;v!==u();){r=v.e();for(r=
+GP(ty(a,r,e,g,h,l,m)).m();r.s();)n=new z(r.t(),u()),null===b?A=n:b.p=n,b=n;v=v.f()}e=(null===A?u():A).m();v=op().ga;e=new xo(e,v);Jw(g,new Ef(e,new y(D=>{var F=D.h();D=new qx(a,D.j(),new vl(D.h()));return G(new H,F,D)})));return k7(a,x,c,d,!1,g,h,k,l,m)}g=O().c;if(null===g?null===b:g.i(b)){if(c)return c=er(d).m(),c=new Ao(c),c=new Ef(c,new y(D=>{if(null!==D){var F=D.h();if(null!==F){var I=F.h();F=F.j();if(I instanceof L)return D=I.k,I=V(a),F=new Uw(F.q,R(),F,I),G(new H,D,F)}}if(null!==D&&(F=D.h(),
+I=D.Sc(),null!==F)){var M=F.h();F=F.j();if(t().d===M)return JX(a,We(Xe(),"Missing name for record field"),F.ma().Ga,h),D=new vl("_"+(1+I|0)),I=V(a),G(new H,D,new Uw(F.q,R(),F,I))}throw new w(D);})),Od(),c=Pd(u(),c),SA(xv(a),c,k);lv();c=er(d).m();return new zv(a,ry(0,c,new y(D=>{var F=V(a);return new Uw(D.q,R(),D,F)})),k)}throw new w(b);}
+function Xfa(a,b){for(var c=kZ(O().wR,1,1);;){if(c.b())b=R();else{var d=hZ(c).e();if(b.L(new vl(a+"_"+(d|0)))){c=hZ(c).Lf();continue}b=new L(d)}break}b.b()&&xm("Program reached and unexpected state.");return a+"_"+b.o()}
+function cga(a,b,c,d,e,g,h,k,l){a:{for(var m=d.Ra;!m.b();){if(!m.e().h().b()){m=!0;break a}m=m.f()}m=!1}a:{for(var n=d.Ra;!n.b();){if(n.e().h().b()){n=!0;break a}n=n.f()}n=!1}a:{for(var r=0,v=a6(0,d.Ra);!v.b();){if(!v.e().h().b())break a;r=1+r|0;v=v.f()}r=-1}v=0;for(var x=d.Ra,A=-1;!x.b();)x.e().h().b()&&(A=v),x=x.f(),v=1+v|0;if(m&&n&&r<A)return Lw(a,Ye(new Te(new Ue(J(new K,["Unnamed arguments should appear first when using named arguments"]))),u()),d.A(),k);if(0===jv(d.Ra,e)){r=Hf(d.Ra);g=B=>{if(null!==
+B){var C=B.h();B=B.Sc();var D=C.h();if(D instanceof L)return G(new H,G(new H,D.k.x,C.j()),!0);if(t().d===D)return G(new H,G(new H,eB(e,B).x,C.j()),!1);throw new w(D);}throw new w(B);};if(r===u())g=u();else{m=r.e();n=m=new z(g(m),u());for(r=r.f();r!==u();)v=r.e(),v=new z(g(v),u()),n=n.p=v,r=r.f();g=m}m=Xu().X();for(n=g.m();n.s();)r=n.t(),m.Hk(r.h().h(),new U(()=>{Od();return new fp})).$(r);n=Ez().Mr;for(m=m.m();m.s();){r=m.t();if(null===r)throw new w(r);n=m7(n,r.h(),r.j().Kb())}m=n;0>hv(m,e)&&m.dc.Ca(new y(B=>
+{var C=B.j();if(C instanceof z&&C.p instanceof z)return C=new Te(new Ue(J(new K,["Argument for parameter '","' is duplicated"]))),B=[We(Xe(),B.h())],Lw(a,Ye(C,J(new K,B)),d.A(),k)}));tp();m=u();c=Yfa(a,g,pp(0,m),d,e,k,c);a.F&&(g=ut(Q(),"| ",a.r)+"Desugared is here \x3d\x3e "+c,ff(gf(),g+"\n"));b.oc=(t(),new L(c));return Rw(a,c,h,k,l,!1)}b=new Te(new Ue(J(new K,["Number of arguments doesn't match function signature `","`"])));h=[wO(Xe(),AD(g,h))];return Lw(a,Ye(b,J(new K,h)),d.A(),k)}
+function uf(a,b,c,d){var e=O().c;e=new aw(e);var g=jA().X();a:{var h=new qC(a,nf());if(b instanceof zA)a=$6(a,b,h,c,g,e,d);else{if(b instanceof BA){CA(a);t();var k=new L(b);if(!k.b()){b=k.k;var l=b.xk;if(l===u())k=u();else{k=l.e();var m=k=new z(Q_(a,k,h,d,c,g,e),u());for(l=l.f();l!==u();){var n=l.e();n=new z(Q_(a,n,h,d,c,g,e),u());m=m.p=n;l=l.f()}}b=b.Ul;b.b()?a=R():(b=b.o(),a=new L($6(a,b,h,c,g,e,d)));a=new BP(k,a);break a}}throw new w(b);}}return e.rc.b()?a:new qP(a,e.rc,O().c)}
+function i7(a){var b=a.YE;a.YE=1+a.YE|0;return b}
+function Q_(a,b,c,d,e,g,h){if(b instanceof ax){var k=b.Rl,l=b.Ql,m=rC(c,b.rk),n=k.pb,r=k.gb,v=k.hg,x=t().d,A=t().d;t();var B=$6(a,l,m,e,g,h,d);return new yo(n,r,v,x,A,new L(B),O().c,t().d,t().d,new Dt(O().c),k.fl,k.Pm,k.Rz)}if(b instanceof Nw){var C=b.il,D=b.jl,F=b.hl,I=b.Tl,M=b.Jj,N=rC(c,b.kl),P=C.pb,T=C.gb,Y=C.hg;t();var Z=Kc=>{var Qd=t().d;Kc=new sm(tm().Cg,new Cl(Kc.h(),$6(a,Kc.j().ra,N,e,g,h,d)));return G(new H,Qd,Kc)};if(I===u())var S=u();else{for(var ea=I.e(),ia=new z(Z(ea),u()),X=ia,sa=I.f();sa!==
+u();){var Ja=sa.e(),Xa=new z(Z(Ja),u());X=X.p=Xa;sa=sa.f()}S=ia}var Fa=new Gl(S),za=new L(Fa),Qa=t().d,Ma=t().d,Ga=O().c,ab=Xu().X(),Hb=Zu(a.La,F,d,!0,ab)?R():new L($6(a,F,N,e,g,h,d)),bc=Xu().X(),yb=!Zu(a.La,D,d,!0,bc);return new yo(P,T,Y,za,Qa,Ma,Ga,Hb,yb?new L($6(a,D,N,e,g,h,d)):R(),a7(a,M,N,d,e,g,h),C.fl,C.Pm,C.Rz)}if(b instanceof Yw){var tb=b.Rf,eb=b.Ij,kb=b.gl,Rb=b.Ei,Gb=b.Um,vb=b.sk,Tb=b.ip,Nb=rC(c,b.gh),ic=tb.pb,Va=tb.gb,cb=tb.hg;if(eb.b())var zb=R();else{var Ub=eb.o(),jb=Kc=>{var Qd=t().d;
+Kc=new sm(tm().Cg,new Cl(Kc.h(),$6(a,Kc.j().ra,Nb,e,g,h,d)));return G(new H,Qd,Kc)};if(Ub===u())var db=u();else{for(var ub=Ub.e(),Aa=new z(jb(ub),u()),va=Aa,Ra=Ub.f();Ra!==u();){var rb=Ra.e(),xb=new z(jb(rb),u());va=va.p=xb;Ra=Ra.f()}db=Aa}zb=new L(new Gl(db))}var mc=tb.Qm,Ha=Xu().X(),Ka=Zu(a.La,vb,d,!0,Ha)?R():new L($6(a,vb,Nb,e,g,h,d));Od();var Oa=Pd(u(),Tb),Na=Su(),Da=op().ga,ta=qw(Oa,new Uu(Na,Da));if(ta===u())var Ya=u();else{for(var dc=ta.e(),ka=new z(dc.Zr(),u()),ya=ka,Sa=ta.f();Sa!==u();){var xc=
+Sa.e(),Sb=new z(xc.Zr(),u());ya=ya.p=Sb;Sa=Sa.f()}Ya=ka}var uc=t().d,Lb=Xu().X(),lc=Zu(a.La,Gb,d,!0,Lb)?R():new L($6(a,Gb,Nb,e,g,h,d)),Xb=a7(a,Rb,Nb,d,e,g,h);if(kb instanceof L){var ec=kb.k,Ab=Kc=>{var Qd=t().d;Kc=new sm(tm().Cg,new Cl(Kc.h(),$6(a,Kc.j(),Nb,e,g,h,d)));return G(new H,Qd,Kc)};if(ec===u())var Ob=u();else{for(var fb=ec.e(),Wa=new z(Ab(fb),u()),bb=Wa,Ia=ec.f();Ia!==u();){var Ua=Ia.e(),pc=new z(Ab(Ua),u());bb=bb.p=pc;Ia=Ia.f()}Ob=Wa}var sc=new Po(new Gl(Ob),new Sl(O().c)),Ba=ef(Xb),ob=
+new Dt(new z(sc,Ba))}else{if(t().d!==kb)throw new w(kb);ob=Xb}return new yo(ic,Va,cb,zb,mc,Ka,Ya,uc,lc,ob,tb.fl,tb.Pm,tb.Rz)}if(b instanceof Ww){var nc=b.vk,Ib=b.tk,vc=b.co,Vb=b.uk,fc=b.Gq,Bc=rC(c,b.wk),Pb=nc.pb,Jb=nc.gb,gc=nc.hg,Cb=t().d,cc=nc.Qm,yc=Xu().X(),Mc=Zu(a.La,Vb,d,!0,yc)?R():new L($6(a,Vb,Bc,e,g,h,d));Od();var qc=Pd(u(),fc),oc=Su(),Qc=op().ga,jc=qw(qc,new Uu(oc,Qc));if(jc===u())var sb=u();else{for(var Gc=jc.e(),Wb=new z(Gc.Zr(),u()),Cc=Wb,Fc=jc.f();Fc!==u();){var qd=Fc.e(),Yb=new z(qd.Zr(),
+u());Cc=Cc.p=Yb;Fc=Fc.f()}sb=Wb}var Nc=t().d,ad=Xu().X(),Uc=!Zu(a.La,vc,d,!0,ad);return new yo(Pb,Jb,gc,Cb,cc,Mc,sb,Nc,Uc?new L($6(a,vc,Bc,e,g,h,d)):R(),a7(a,Ib,Bc,d,e,g,h),nc.fl,nc.Pm,nc.Rz)}if(b instanceof bx){var cd=b.Mb,kc=cd.wd,Vc=cd.Rb,Hc=cd.hj,rc=O().c;t();var sd=$6(a,b.Nn(),c,e,g,h,d);return new Zn(kc,Vc,Hc,rc,new Ud(sd),cd.Pz,cd.lx,cd.Om,cd.kx,cd.Qz,cd.Pl,cd.Oz)}if(b instanceof Vw)no();else if(b instanceof cx)no();else throw new w(b);}
+hf.prototype.$classData=q({KY:0},!1,"mlscript.Typer",{KY:1,Vaa:1,Jaa:1,Daa:1,waa:1,Caa:1,Oaa:1,Qaa:1,g:1,Laa:1});function Qx(a,b,c){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.MO=this.dd=0;this.NO=null;this.DI=!1;this.de=b;this.Re=c;pY(this,a);if(!(b<a.Df))throw Kj("requirement failed: "+this.de);this.NO=c.ma()}Qx.prototype=new qY;Qx.prototype.constructor=Qx;f=Qx.prototype;f.ma=function(){return this.NO};
+f.Ea=function(){this.DI||this.DI||(this.MO=this.ub(this.de,jA().X()),this.DI=!0);return this.MO};f.ub=function(a,b){var c=this.de;return this.Re.ub(a<c?a:c,b)};f.u=function(){return"\u2039\u2200 "+this.de+". "+this.Re+"\u203a"};f.H=function(){return"PolymorphicType"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.de;case 1:return this.Re;default:return $K(W(),a)}};f.D=function(a){return a instanceof Qx};
+f.$classData=q({tZ:0},!1,"mlscript.TyperDatatypes$PolymorphicType",{tZ:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,Raa:1,E:1,v:1,l:1});function OA(a,b,c){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0;this.Hi=b;this.NE=c;pY(this,a)}OA.prototype=new T_;OA.prototype.constructor=OA;f=OA.prototype;f.mc=function(){return this.Hi};f.ma=function(){return this.NE};f.u=function(){return""+this.Hi};f.H=function(){return"ProvType"};f.G=function(){return 1};
+f.I=function(a){return 0===a?this.Hi:$K(W(),a)};f.D=function(a){return a instanceof OA};f.$classData=q({vZ:0},!1,"mlscript.TyperDatatypes$ProvType",{vZ:1,EI:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,E:1,v:1,l:1});function fw(a,b,c,d){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0;this.MI=null;this.qb=b;this.Zb=c;this.Xl=d;pY(this,a);this.MI=t().d}fw.prototype=new qY;fw.prototype.constructor=fw;f=fw.prototype;f.ma=function(){return this.Xl};
+f.Ea=function(){var a=this.Zb.m();a=new Ef(a,new y(c=>c.Ea()));var b=Fq();a=Jq(a,b);return(a.b()?this.q.Gd:a.o())|0};f.ub=function(a,b){var c=this.Zb.m();c=new Ef(c,new y(e=>e.ub(a,b)));var d=Fq();c=Jq(c,d);return(c.b()?this.q.Gd:c.o())|0};function rv(a,b,c,d,e){var g=a.q,h=a.qb,k=a.Zb;if(k===u())b=u();else{var l=k.e(),m=l=new z(l.Kc(b,c,d,e),u());for(k=k.f();k!==u();){var n=k.e();n=new z(n.Kc(b,c,d,e),u());m=m.p=n;k=k.f()}b=l}return new fw(g,h,b,a.Xl)}
+f.u=function(){var a=this.q.cn.L(this.qb.V)?Nu(Q(),this.qb.V):this.qb.V;return this.Zb.b()?a:a+"["+ze(this.Zb,"",",","")+"]"};f.H=function(){return"TypeRef"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.qb;case 1:return this.Zb;default:return $K(W(),a)}};f.D=function(a){return a instanceof fw};f.Kc=function(a,b,c,d){return rv(this,a,b,c,d)};f.$classData=q({IZ:0},!1,"mlscript.TyperDatatypes$TypeRef",{IZ:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,Saa:1,E:1,v:1,l:1});
+function dga(a){if(!a.OI){var b=a.Oq,c=a.up.Ba.m();c=new Ef(c,new y(g=>g.h()));var d=Su(),e=op().ga;d=new Uu(d,e);c=oA(uv(),c,d);b=iB(b,c);c=a.up;d=V(b.q);a.PI=Pu(b,c,d,!1);a.OI=!0}return a.PI}function $y(a,b,c,d){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0;this.PI=null;this.OI=!1;this.Oq=b;this.up=c;this.OZ=d;pY(this,a)}$y.prototype=new T_;$y.prototype.constructor=$y;f=$y.prototype;f.ma=function(){return this.OZ};f.mc=function(){return this.OI?this.PI:dga(this)};
+f.u=function(){return this.Oq+" w/ "+this.up};f.H=function(){return"WithType"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Oq;case 1:return this.up;default:return $K(W(),a)}};f.D=function(a){return a instanceof $y};f.$classData=q({NZ:0},!1,"mlscript.TyperDatatypes$WithType",{NZ:1,EI:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,E:1,v:1,l:1});
+function nP(a,b){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.Lx=a;this.Mx=b;Nq(this)}nP.prototype=new M_;nP.prototype.constructor=nP;f=nP.prototype;f.H=function(){return"WithExtension"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Lx;case 1:return this.Mx;default:return $K(W(),a)}};f.D=function(a){return a instanceof nP};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof nP){var b=this.Lx,c=a.Lx;if(null===b?null===c:b.i(c))return b=this.Mx,a=a.Mx,null===b?null===a:b.i(a)}return!1};f.$classData=q({n_:0},!1,"mlscript.WithExtension",{n_:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,E:1,v:1,l:1});q({p_:0},!1,"mlscript.codegen.ClassSymbol",{p_:1,g:1,UA:1,cr:1,mt:1,yj:1,nf:1,E:1,v:1,l:1});function n7(){}n7.prototype=new q3;n7.prototype.constructor=n7;function o7(){}o7.prototype=n7.prototype;n7.prototype.Ub=function(){return eU()};
+n7.prototype.u=function(){return w5(this)};n7.prototype.Oc=function(){return"View"};function rp(a){this.mL=null;if(null===a)throw null;this.mL=a}rp.prototype=new q3;rp.prototype.constructor=rp;rp.prototype.Q=function(){return this.mL.Q()};rp.prototype.m=function(){return this.mL.ie()};rp.prototype.$classData=q({L5:0},!1,"scala.collection.MapOps$$anon$1",{L5:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,sg:1,l:1});
+function kY(a,b){if(a===b)return!0;if(b&&b.$classData&&b.$classData.rb.fk)if(a.ka()===b.ka())try{return a.fM(b)}catch(c){throw c;}else return!1;else return!1}function p7(){this.Br=0;this.OB="Any";O();this.Br=Qb(this)}p7.prototype=new D6;p7.prototype.constructor=p7;p7.prototype.uh=function(){return da(jd)};p7.prototype.si=function(a){return new zc(a)};p7.prototype.$classData=q({W3:0},!1,"scala.reflect.ManifestFactory$AnyManifest$",{W3:1,OK:1,NK:1,g:1,om:1,Lk:1,nm:1,pm:1,l:1,v:1});var q7;
+function IB(){q7||(q7=new p7);return q7}function r7(){this.Gf=0;this.Ki="Boolean";this.Gf=Qb(this)}r7.prototype=new p6;r7.prototype.constructor=r7;r7.prototype.$classData=q({X3:0},!1,"scala.reflect.ManifestFactory$BooleanManifest$",{X3:1,zba:1,Kt:1,g:1,om:1,Lk:1,nm:1,pm:1,l:1,v:1});var s7;function uL(){s7||(s7=new r7);return s7}function t7(){this.Gf=0;this.Ki="Byte";this.Gf=Qb(this)}t7.prototype=new r6;t7.prototype.constructor=t7;
+t7.prototype.$classData=q({Y3:0},!1,"scala.reflect.ManifestFactory$ByteManifest$",{Y3:1,Aba:1,Kt:1,g:1,om:1,Lk:1,nm:1,pm:1,l:1,v:1});var u7;function sL(){u7||(u7=new t7);return u7}function v7(){this.Gf=0;this.Ki="Char";this.Gf=Qb(this)}v7.prototype=new t6;v7.prototype.constructor=v7;v7.prototype.$classData=q({Z3:0},!1,"scala.reflect.ManifestFactory$CharManifest$",{Z3:1,Bba:1,Kt:1,g:1,om:1,Lk:1,nm:1,pm:1,l:1,v:1});var w7;function Ir(){w7||(w7=new v7);return w7}
+function x7(){this.Gf=0;this.Ki="Double";this.Gf=Qb(this)}x7.prototype=new v6;x7.prototype.constructor=x7;x7.prototype.$classData=q({$3:0},!1,"scala.reflect.ManifestFactory$DoubleManifest$",{$3:1,Cba:1,Kt:1,g:1,om:1,Lk:1,nm:1,pm:1,l:1,v:1});var y7;function pL(){y7||(y7=new x7);return y7}function z7(){this.Gf=0;this.Ki="Float";this.Gf=Qb(this)}z7.prototype=new x6;z7.prototype.constructor=z7;
+z7.prototype.$classData=q({a4:0},!1,"scala.reflect.ManifestFactory$FloatManifest$",{a4:1,Dba:1,Kt:1,g:1,om:1,Lk:1,nm:1,pm:1,l:1,v:1});var A7;function rL(){A7||(A7=new z7);return A7}function B7(){this.Gf=0;this.Ki="Int";this.Gf=Qb(this)}B7.prototype=new z6;B7.prototype.constructor=B7;B7.prototype.$classData=q({b4:0},!1,"scala.reflect.ManifestFactory$IntManifest$",{b4:1,Eba:1,Kt:1,g:1,om:1,Lk:1,nm:1,pm:1,l:1,v:1});var C7;function rl(){C7||(C7=new B7);return C7}
+function D7(){this.Gf=0;this.Ki="Long";this.Gf=Qb(this)}D7.prototype=new B6;D7.prototype.constructor=D7;D7.prototype.$classData=q({c4:0},!1,"scala.reflect.ManifestFactory$LongManifest$",{c4:1,Fba:1,Kt:1,g:1,om:1,Lk:1,nm:1,pm:1,l:1,v:1});var E7;function qL(){E7||(E7=new D7);return E7}function UR(){this.Br=0;this.OB="Nothing";O();this.Br=Qb(this)}UR.prototype=new D6;UR.prototype.constructor=UR;UR.prototype.uh=function(){return da(kH)};UR.prototype.si=function(a){return new zc(a)};
+UR.prototype.$classData=q({d4:0},!1,"scala.reflect.ManifestFactory$NothingManifest$",{d4:1,OK:1,NK:1,g:1,om:1,Lk:1,nm:1,pm:1,l:1,v:1});var TR;function WR(){this.Br=0;this.OB="Null";O();this.Br=Qb(this)}WR.prototype=new D6;WR.prototype.constructor=WR;WR.prototype.uh=function(){return da(jH)};WR.prototype.si=function(a){return new zc(a)};WR.prototype.$classData=q({e4:0},!1,"scala.reflect.ManifestFactory$NullManifest$",{e4:1,OK:1,NK:1,g:1,om:1,Lk:1,nm:1,pm:1,l:1,v:1});var VR;
+function F7(){this.Br=0;this.OB="Object";O();this.Br=Qb(this)}F7.prototype=new D6;F7.prototype.constructor=F7;F7.prototype.uh=function(){return da(jd)};F7.prototype.si=function(a){return new zc(a)};F7.prototype.$classData=q({f4:0},!1,"scala.reflect.ManifestFactory$ObjectManifest$",{f4:1,OK:1,NK:1,g:1,om:1,Lk:1,nm:1,pm:1,l:1,v:1});var G7;function TG(){G7||(G7=new F7);return G7}function H7(){this.Gf=0;this.Ki="Short";this.Gf=Qb(this)}H7.prototype=new F6;H7.prototype.constructor=H7;
+H7.prototype.$classData=q({g4:0},!1,"scala.reflect.ManifestFactory$ShortManifest$",{g4:1,Gba:1,Kt:1,g:1,om:1,Lk:1,nm:1,pm:1,l:1,v:1});var I7;function tL(){I7||(I7=new H7);return I7}function J7(){this.Gf=0;this.Ki="Unit";this.Gf=Qb(this)}J7.prototype=new H6;J7.prototype.constructor=J7;J7.prototype.$classData=q({h4:0},!1,"scala.reflect.ManifestFactory$UnitManifest$",{h4:1,Hba:1,Kt:1,g:1,om:1,Lk:1,nm:1,pm:1,l:1,v:1});var K7;function SR(){K7||(K7=new J7);return K7}function vw(a){this.al=a}
+vw.prototype=new p;vw.prototype.constructor=vw;f=vw.prototype;f.$l=function(a){Fq();var b=this.al;a|=0;return b===a?0:b<a?-1:1};f.sl=function(a){Fq();var b=this.al;a|=0;return b===a?0:b<a?-1:1};f.u=function(){return""+this.al};f.WJ=function(){return this.uv()&&this.Zi()===this.jB()};f.YJ=function(){return this.uv()&&this.Zi()===this.EC()};f.XJ=function(){return this.uv()&&0<=this.Zi()&&65535>=this.Zi()};f.Lp=function(){return this.al};f.pv=function(){return Math.fround(this.al)};
+f.xl=function(){var a=this.al;return new ma(a,a>>31)};f.Zi=function(){return this.al};f.jB=function(){return this.al<<24>>24};f.EC=function(){return this.al<<16>>16};f.uv=function(){return!0};f.MF=function(){return!0};f.B=function(){return this.al};f.i=function(a){TK||(TK=new SK);return a instanceof vw?this.al===a.al:!1};f.$classData=q({faa:0},!1,"scala.runtime.RichInt",{faa:1,g:1,dca:1,sR:1,mba:1,lba:1,bca:1,yj:1,nf:1,cca:1});
+function pP(a,b){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.Gw=a;this.Hw=b;Nq(this)}pP.prototype=new M_;pP.prototype.constructor=pP;f=pP.prototype;f.H=function(){return"AppliedType"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Gw;case 1:return this.Hw;default:return $K(W(),a)}};f.D=function(a){return a instanceof pP};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof pP){var b=this.Gw,c=a.Gw;if(null===b?null===c:b.i(c))return b=this.Hw,a=a.Hw,null===b?null===a:b.i(a)}return!1};f.$classData=q({RT:0},!1,"mlscript.AppliedType",{RT:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,JW:1,E:1,v:1,l:1});function L7(){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;Nq(this)}L7.prototype=new U2;L7.prototype.constructor=L7;f=L7.prototype;f.H=function(){return"Bot"};f.G=function(){return 0};
+f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof L7};f.B=function(){return 66983};f.u=function(){return"Bot"};f.$classData=q({XT:0},!1,"mlscript.Bot$",{XT:1,Vz:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,E:1,v:1,l:1});var M7;function el(){M7||(M7=new L7);return M7}function Po(a,b){this.MM=this.LM=null;this.OM=this.PM=0;this.QM=this.NM=null;this.Jm=0;this.ks=a;this.js=b;Nq(this)}Po.prototype=new p;Po.prototype.constructor=Po;f=Po.prototype;f.jb=function(){return"constructor"};f.Vj=function(){return eP(this)};
+f.Wr=function(){return Mx(this)};f.nv=function(){0===(1&this.Jm)<<24>>24&&0===(1&this.Jm)<<24>>24&&(this.LM=cP(this),this.Jm=(1|this.Jm)<<24>>24);return this.LM};f.jn=function(){0===(2&this.Jm)<<24>>24&&0===(2&this.Jm)<<24>>24&&(this.MM=zq(this),this.Jm=(2|this.Jm)<<24>>24);return this.MM};f.rn=function(){return this.PM};f.fm=function(a){this.PM=a};f.qn=function(){return this.OM};f.em=function(a){this.OM=a};f.pn=function(){return this.NM};f.on=function(a){this.NM=a};
+f.A=function(){0===(4&this.Jm)<<24>>24&&0===(4&this.Jm)<<24>>24&&(this.QM=Dq(this),this.Jm=(4|this.Jm)<<24>>24);return this.QM};f.H=function(){return"Constructor"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.ks;case 1:return this.js;default:return $K(W(),a)}};f.D=function(a){return a instanceof Po};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Po){var b=this.ks,c=a.ks;if(null===b?null===c:b.i(c))return b=this.js,a=a.js,null===b?null===a:b.i(a)}return!1};f.$classData=q({CU:0},!1,"mlscript.Constructor",{CU:1,g:1,ud:1,md:1,xd:1,Ta:1,Od:1,xaa:1,E:1,v:1,l:1});function oP(a){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.Es=a;Nq(this)}oP.prototype=new U2;oP.prototype.constructor=oP;f=oP.prototype;f.H=function(){return"Literal"};
+f.G=function(){return 1};f.I=function(a){return 0===a?this.Es:$K(W(),a)};f.D=function(a){return a instanceof oP};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof oP){var b=this.Es;a=a.Es;return null===b?null===a:b.i(a)}return!1};f.$classData=q({uW:0},!1,"mlscript.Literal",{uW:1,Vz:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,E:1,v:1,l:1});
+function Vt(a,b){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.Ws=a;this.Vs=b;Nq(this)}Vt.prototype=new M_;Vt.prototype.constructor=Vt;f=Vt.prototype;f.H=function(){return"PolyType"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Ws;case 1:return this.Vs;default:return $K(W(),a)}};f.D=function(a){return a instanceof Vt};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Vt){var b=this.Ws,c=a.Ws;if(null===b?null===c:b.i(c))return b=this.Vs,a=a.Vs,null===b?null===a:b.i(a)}return!1};f.$classData=q({PX:0},!1,"mlscript.PolyType",{PX:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,Gaa:1,E:1,v:1,l:1});function N7(){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;Nq(this)}N7.prototype=new U2;N7.prototype.constructor=N7;f=N7.prototype;f.H=function(){return"Top"};f.G=function(){return 0};
+f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof N7};f.B=function(){return 84277};f.u=function(){return"Top"};f.$classData=q({pY:0},!1,"mlscript.Top$",{pY:1,Vz:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,E:1,v:1,l:1});var O7;function gl(){O7||(O7=new N7);return O7}function sP(a){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.nA=a;Nq(this)}sP.prototype=new U2;sP.prototype.constructor=sP;f=sP.prototype;f.H=function(){return"TypeTag"};
+f.G=function(){return 1};f.I=function(a){return 0===a?this.nA:$K(W(),a)};f.D=function(a){return a instanceof sP};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){return this===a?!0:a instanceof sP?this.nA===a.nA:!1};f.$classData=q({IY:0},!1,"mlscript.TypeTag",{IY:1,Vz:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,E:1,v:1,l:1});function Gv(){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0}Gv.prototype=new S_;Gv.prototype.constructor=Gv;function P7(){}
+P7.prototype=Gv.prototype;Gv.prototype.sl=function(a){return uw(this,a)};Gv.prototype.$l=function(a){return uw(this,a)};var Ru=q({IE:0},!1,"mlscript.TyperDatatypes$AbstractTag",{IE:1,qp:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,uA:1,yj:1,nf:1,Hx:1});Gv.prototype.$classData=Ru;function VC(a,b){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0;this.GO=this.HO=null;this.yI=!1;this.zI=b;pY(this,a);this.GO=V(a)}VC.prototype=new T_;VC.prototype.constructor=VC;f=VC.prototype;
+f.mc=function(){if(!this.yI&&!this.yI){var a=this.zI,b=V(this.zI.q);this.HO=NA(a,b,!1);this.yI=!0}return this.HO};f.ma=function(){return this.GO};f.H=function(){return"NegAbsTag"};f.G=function(){return 1};f.I=function(a){return 0===a?this.zI:$K(W(),a)};f.D=function(a){return a instanceof VC};f.$classData=q({oZ:0},!1,"mlscript.TyperDatatypes$NegAbsTag",{oZ:1,EI:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,Hx:1,E:1,v:1,l:1});
+function UC(a,b){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0;this.IO=this.JO=null;this.AI=!1;this.BI=b;pY(this,a);this.IO=V(a)}UC.prototype=new T_;UC.prototype.constructor=UC;f=UC.prototype;f.mc=function(){if(!this.AI&&!this.AI){var a=this.BI,b=V(this.BI.q);this.JO=NA(a,b,!1);this.AI=!0}return this.JO};f.ma=function(){return this.IO};f.H=function(){return"NegVar"};f.G=function(){return 1};f.I=function(a){return 0===a?this.BI:$K(W(),a)};
+f.D=function(a){return a instanceof UC};f.$classData=q({qZ:0},!1,"mlscript.TyperDatatypes$NegVar",{qZ:1,EI:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,Hx:1,E:1,v:1,l:1});function Q7(a){if(0===(1&a.ii)<<24>>24&&0===(1&a.ii)<<24>>24){var b=a.NI;b.b()?b=R():(b=b.o(),b=Q7(b),b=b.b()?a.NI:b);a.dP=b;a.ii=(1|a.ii)<<24>>24}return a.dP}
+function R7(a){if(0===(4&a.ii)<<24>>24&&0===(4&a.ii)<<24>>24){t();var b=pE().SP,c=a.kg;c=c.b()?"_":c.o();a:{for(var d=c.length,e=0;e<d;){var g=c.charCodeAt(e);if(!Pe(new E(hc(g)),hc(39))){d=e;break a}e=1+e|0}d=-1}b=""+b+(-1===d?"":c.substring(d));b=new L(b);t();c=UP(a.q);c=new jt(new fe(c),b);t();d=UP(a.q);b=new jt(new fe(d),b);a.eP=G(new H,c,b);a.ii=(4|a.ii)<<24>>24}return a.eP}
+function lx(a,b,c,d,e,g,h,k){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0;this.Sb=this.$O=this.aP=this.eP=this.bP=this.dP=null;this.ii=this.sp=this.cP=0;this.Xa=b;this.YO=c;this.ZO=d;this.NI=e;this.kg=g;this.ji=k;pY(this,a);At(tp(),b<=a.Df);this.Sb=t().d;this.cP=a.Im;this.sp=UP(a)}lx.prototype=new qY;lx.prototype.constructor=lx;f=lx.prototype;f.sl=function(a){return gT(this,a)};f.Ea=function(){return this.Xa};f.ma=function(){return this.ji};
+function wy(a,b){tp();var c=b.b()?!0:b.o().Ea()<=a.Xa;At(0,c);a.Sb=b}function vy(a){if(!a.Sb.b())throw Kj("requirement failed: "+a);return a.YO}function rA(a){if(!a.Sb.b())throw Kj("requirement failed: "+a);return a.ZO}function IA(a,b){if(!a.Sb.b())throw Kj("requirement failed: "+a);a.YO=b}function KA(a,b){if(!a.Sb.b())throw Kj("requirement failed: "+a);a.ZO=b}function xca(a){if(Pe(new E(a.q.Im),a.cP)){var b=a.NI;return b.b()?a:b.o()}return a}
+f.ub=function(a,b){if(this.Xa<=a)return this.Xa;if(b.L(this))return this.q.Gd;b.$(this);var c=this.Sb;if(c instanceof L)return c.k.ub(a,b);if(t().d===c){c=vy(this).m().nb(new U(()=>rA(this).m()));c=new Ef(c,new y(e=>e.ub(a,b)));var d=Fq();c=Jq(c,d);return(c.b()?this.q.Gd:c.o())|0}throw new w(c);};function c7(a){0===(2&a.ii)<<24>>24&&0===(2&a.ii)<<24>>24&&(t(),a.bP=new jt(new fe(a.sp),a.kg),a.ii=(2|a.ii)<<24>>24);return a.bP}
+function Zfa(a){0===(8&a.ii)<<24>>24&&0===(8&a.ii)<<24>>24&&(a.aP=R7(a).h(),a.ii=(8|a.ii)<<24>>24);return a.aP}function $fa(a){0===(16&a.ii)<<24>>24&&0===(16&a.ii)<<24>>24&&(a.$O=R7(a).j(),a.ii=(16|a.ii)<<24>>24);return a.$O}function gT(a,b){a=new vw(a.sp);b=b.sp;Fq();a=a.al;return a===b?0:a<b?-1:1}
+f.u=function(){var a=Q7(this);if(a instanceof L){a=a.k;if(!Pe(new E(a.kg),this.kg))throw new Yj("assertion failed: "+G(new H,a.kg,this.kg));a=S7(a)+"_"+this.sp+YC(this.q,this.Xa)}else{if(t().d!==a)throw new w(a);a=""+S7(this)+YC(this.q,this.Xa)}return a+(this.Sb.b()?"":"#")};function S7(a){var b=a.kg;return""+(b.b()?"\u03b1":b.o())+a.sp}f.$l=function(a){return gT(this,a)};var RX=q({KZ:0},!1,"mlscript.TyperDatatypes$TypeVariable",{KZ:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,XO:1,yj:1,nf:1,Hx:1,tz:1});
+lx.prototype.$classData=RX;function nH(a,b){this.QR=this.Cy=null;if(null===a)throw null;this.Cy=a;this.QR=b}nH.prototype=new o7;nH.prototype.constructor=nH;nH.prototype.Q=function(){return qH(this.Cy)};nH.prototype.b=function(){return this.Cy.ck.b()||this.Cy.dk.b()};nH.prototype.m=function(){return new B0(this)};nH.prototype.$classData=q({A5:0},!1,"scala.collection.LazyZip2$$anon$1",{A5:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1});
+function oH(a,b){this.SR=this.Ov=null;if(null===a)throw null;this.Ov=a;this.SR=b}oH.prototype=new o7;oH.prototype.constructor=oH;oH.prototype.Q=function(){return 0===this.Ov.ck.Q()||0===this.Ov.dk.Q()?0:-1};oH.prototype.b=function(){return this.Ov.ck.b()||this.Ov.dk.b()};oH.prototype.m=function(){return new D0(this)};oH.prototype.$classData=q({C5:0},!1,"scala.collection.LazyZip2$$anon$3",{C5:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1});
+function UD(a){this.Dy=null;if(null===a)throw null;this.Dy=a}UD.prototype=new o7;UD.prototype.constructor=UD;UD.prototype.Q=function(){return qH(this.Dy)};UD.prototype.b=function(){return this.Dy.ck.b()||this.Dy.dk.b()};UD.prototype.m=function(){return new E0(this)};UD.prototype.$classData=q({E5:0},!1,"scala.collection.LazyZip2$$anon$7",{E5:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1});function T7(a){this.pL=a}T7.prototype=new o7;T7.prototype.constructor=T7;T7.prototype.m=function(){return this.pL.ie()};
+T7.prototype.Q=function(){return this.pL.Q()};T7.prototype.b=function(){return this.pL.b()};T7.prototype.$classData=q({S5:0},!1,"scala.collection.MapView$Values",{S5:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1});function i3(a,b){return a===b?!0:b&&b.$classData&&b.$classData.rb.Ac&&b.D(a)?a.Lt(b):!1}function U7(a,b,c,d){a.XB=b;a.Sp=c;a.Hy=d;a.wL=!1;return a}function V7(a,b){var c=new W7;U7(c,a,a.K(),b);return c}function W7(){this.XB=this.cS=null;this.Sp=0;this.Hy=null;this.vL=this.wL=!1}
+W7.prototype=new p;W7.prototype.constructor=W7;f=W7.prototype;f.Ub=function(){return eU()};f.u=function(){return w5(this)};f.Ih=function(){return"SeqView"};f.ti=function(){return eU().Eb()};f.tl=function(a){return IT(this,a)};f.Ii=function(a){return NY(this,a)};f.Sd=function(){return(new X7(this)).m()};f.wo=function(a,b){var c=this.m();return LT(c,a,b)};f.L=function(a){return QU(this,a)};f.$k=function(a){return iv(this,a)};f.ab=function(a){return iv(this,a)};f.e=function(){return this.m().t()};
+f.Mc=function(){return yT(this)};f.Gb=function(a){return KT(this,a)};f.Ca=function(a){cH(this,a)};f.qo=function(a){return ey(this,a)};f.De=function(a,b){return mB(this,a,b)};f.mf=function(a,b){return Qu(this,a,b)};f.th=function(a){return eH(this,a)};f.Gc=function(a,b,c){return NB(this,a,b,c)};f.aj=function(a){return gH(this,a)};f.$i=function(a){return hH(this,a)};f.Gh=function(a,b,c,d){return iH(this,a,b,c,d)};f.ha=function(){Od();return Pd(u(),this)};f.Ti=function(){return pp(qp(),this)};
+f.FC=function(){return v1(EK(),this)};f.Bj=function(a){return kB(this,a)};function Y7(a){if(!a.vL&&!a.vL){var b=a.Sp;if(0===b)b=O().c;else if(1===b)O(),b=[a.XB.e()],b=J(new K,b),b=Pd(u(),b);else{b=new zc(b);a.XB.Gc(b,0,2147483647);var c=a.Hy;hj(Pj(),b,c);b=KQ(JQ(),b)}a.wL=!0;a.XB=null;a.cS=b;a.vL=!0}return a.cS}function Z7(a){var b=a.XB;return a.wL?Y7(a):b}f.va=function(a){return Y7(this).va(a)};f.K=function(){return this.Sp};f.m=function(){return Rq().Pa.nb(new U(()=>Y7(this).m()))};f.Q=function(){return this.Sp};
+f.b=function(){return 0===this.Sp};f.ad=function(){return new X7(this)};f.cM=function(a){var b=this.Hy;return(null===a?null===b:a.i(b))?this:a.sj(this.Hy)?new X7(this):U7(new W7,Z7(this),this.Sp,a)};f.vc=function(a){return ZT(eU(),a)};f.Bb=function(a){return $7(new a8,this,a)};f.Jc=function(a){return b8(new c8,this,a)};f.cc=function(a){return d8(new e8,a,this)};f.Ja=function(a){return f8(new g8,this,a)};f.Zh=function(a){return this.cM(a)};
+f.$classData=q({V5:0},!1,"scala.collection.SeqView$Sorted",{V5:1,g:1,Li:1,kb:1,pa:1,M:1,N:1,jd:1,na:1,oa:1,l:1});function h8(a){if(!a.OG){var b=new i8,c=Y7(a.un);b.Rv=c;a.NG=b;a.OG=!0}return a.NG}function X7(a){this.NG=null;this.OG=!1;this.un=null;if(null===a)throw null;this.un=a}X7.prototype=new p;X7.prototype.constructor=X7;f=X7.prototype;f.Ub=function(){return eU()};f.u=function(){return w5(this)};f.Ih=function(){return"SeqView"};f.ti=function(){return eU().Eb()};
+f.tl=function(a){return IT(this,a)};f.Ii=function(a){return NY(this,a)};f.Sd=function(){return this.un.m()};f.wo=function(a,b){var c=this.m();return LT(c,a,b)};f.L=function(a){return QU(this,a)};f.$k=function(a){return iv(this,a)};f.ab=function(a){return iv(this,a)};f.e=function(){return this.m().t()};f.Mc=function(){return yT(this)};f.Gb=function(a){return KT(this,a)};f.Ca=function(a){cH(this,a)};f.qo=function(a){return ey(this,a)};f.De=function(a,b){return mB(this,a,b)};
+f.mf=function(a,b){return Qu(this,a,b)};f.th=function(a){return eH(this,a)};f.Gc=function(a,b,c){return NB(this,a,b,c)};f.aj=function(a){return gH(this,a)};f.$i=function(a){return hH(this,a)};f.Gh=function(a,b,c,d){return iH(this,a,b,c,d)};f.ha=function(){Od();return Pd(u(),this)};f.Ti=function(){return pp(qp(),this)};f.FC=function(){return v1(EK(),this)};f.Bj=function(a){return kB(this,a)};f.va=function(a){return(this.OG?this.NG:h8(this)).va(a)};f.K=function(){return this.un.Sp};
+f.m=function(){return Rq().Pa.nb(new U(()=>(this.OG?this.NG:h8(this)).m()))};f.Q=function(){return this.un.Sp};f.b=function(){return 0===this.un.Sp};f.ad=function(){return this.un};f.cM=function(a){var b=this.un.Hy;return(null===a?null===b:a.i(b))?this.un:a.sj(this.un.Hy)?this:U7(new W7,Z7(this.un),this.un.Sp,a)};f.vc=function(a){return ZT(eU(),a)};f.Bb=function(a){return $7(new a8,this,a)};f.Jc=function(a){return b8(new c8,this,a)};f.cc=function(a){return d8(new e8,a,this)};
+f.Ja=function(a){return f8(new g8,this,a)};f.Zh=function(a){return this.cM(a)};f.$classData=q({W5:0},!1,"scala.collection.SeqView$Sorted$ReverseSorted",{W5:1,g:1,Li:1,kb:1,pa:1,M:1,N:1,jd:1,na:1,oa:1,l:1});function $T(a){this.t6=a}$T.prototype=new o7;$T.prototype.constructor=$T;$T.prototype.m=function(){return Es(this.t6)};$T.prototype.$classData=q({s6:0},!1,"scala.collection.View$$anon$1",{s6:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1});function JT(a,b){this.AL=a;this.BL=b}JT.prototype=new o7;
+JT.prototype.constructor=JT;JT.prototype.m=function(){return this.AL.m().nb(new U(()=>this.BL.m()))};JT.prototype.Q=function(){var a=this.AL.Q();if(0<=a){var b=this.BL.Q();return 0<=b?a+b|0:-1}return-1};JT.prototype.b=function(){return this.AL.b()&&this.BL.b()};JT.prototype.$classData=q({u6:0},!1,"scala.collection.View$Concat",{u6:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1});function OY(a,b){this.CL=a;this.w6=b}OY.prototype=new o7;OY.prototype.constructor=OY;
+OY.prototype.m=function(){var a=this.CL.m();return new hy(a,this.w6)};OY.prototype.Q=function(){return 0===this.CL.Q()?0:-1};OY.prototype.b=function(){return this.CL.b()};OY.prototype.$classData=q({v6:0},!1,"scala.collection.View$DistinctBy",{v6:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1});function AT(a,b,c){a.My=b;a.cC=c;a.Tv=0<c?c:0;return a}function BT(){this.My=null;this.Tv=this.cC=0}BT.prototype=new o7;BT.prototype.constructor=BT;function j8(){}j8.prototype=BT.prototype;BT.prototype.m=function(){return this.My.m().ph(this.cC)};
+BT.prototype.Q=function(){var a=this.My.Q();return 0<=a?(a=a-this.Tv|0,0<a?a:0):-1};BT.prototype.b=function(){return!this.m().s()};BT.prototype.$classData=q({UG:0},!1,"scala.collection.View$Drop",{UG:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1});function s3(a,b,c){a.Ly=b;a.aC=c;a.bC=0<c?c:0;return a}function t3(){this.Ly=null;this.bC=this.aC=0}t3.prototype=new o7;t3.prototype.constructor=t3;function k8(){}k8.prototype=t3.prototype;
+t3.prototype.m=function(){eU();var a=this.Ly.m();var b=this.aC;if(!(0>=b)){var c=a.Q();a=0<=c?a.Mn(c-b|0):new M0(a,b)}return a};t3.prototype.Q=function(){var a=this.Ly.Q();return 0<=a?(a=a-this.bC|0,0<a?a:0):-1};t3.prototype.b=function(){return 0<=this.Q()?0===this.Q():!this.m().s()};t3.prototype.$classData=q({VG:0},!1,"scala.collection.View$DropRight",{VG:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1});function r3(a,b,c){this.gS=a;this.B6=b;this.A6=c}r3.prototype=new o7;
+r3.prototype.constructor=r3;r3.prototype.m=function(){var a=this.gS.m();return new iy(a,this.B6,this.A6)};r3.prototype.Q=function(){return 0===this.gS.Q()?0:-1};r3.prototype.b=function(){return!this.m().s()};r3.prototype.$classData=q({z6:0},!1,"scala.collection.View$Filter",{z6:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1});q({C6:0},!1,"scala.collection.View$FlatMap",{C6:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1});function GT(a,b,c){a.Uv=b;a.dC=c;return a}
+function HT(){this.dC=this.Uv=null}HT.prototype=new o7;HT.prototype.constructor=HT;function l8(){}l8.prototype=HT.prototype;HT.prototype.m=function(){var a=this.Uv.m();return new Ef(a,this.dC)};HT.prototype.Q=function(){return this.Uv.Q()};HT.prototype.b=function(){return this.Uv.b()};HT.prototype.$classData=q({WG:0},!1,"scala.collection.View$Map",{WG:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1});function m8(){this.Ny=this.eC=null}m8.prototype=new o7;m8.prototype.constructor=m8;
+function n8(){}n8.prototype=m8.prototype;m8.prototype.m=function(){return(new JT(new o8(this.eC),this.Ny)).m()};m8.prototype.Q=function(){var a=this.Ny.Q();return 0<=a?1+a|0:-1};function o8(a){this.E6=a}o8.prototype=new o7;o8.prototype.constructor=o8;o8.prototype.m=function(){Rq();return new g0(this.E6)};o8.prototype.Q=function(){return 1};o8.prototype.b=function(){return!1};o8.prototype.$classData=q({D6:0},!1,"scala.collection.View$Single",{D6:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1});
+function p8(a,b,c){var d=a.U(b);c=c.n(d);d=G(new H,d,c);c=d.y;var e=d.w;if(R()===c&&R()===e)return a;c=d.w;if(d.y instanceof L&&R()===c)return a.xj(b);c=d.w;if(c instanceof L)return a.Dm(b,c.k);throw new w(d);}function h3(){}h3.prototype=new p;h3.prototype.constructor=h3;f=h3.prototype;f.uj=function(a,b){return 0>=this.Da(a,b)};f.Yj=function(a,b){return 0<=this.Da(a,b)};f.Xj=function(a,b){return 0<this.Da(a,b)};f.Yi=function(a,b){return x2(this,a,b)};f.Jk=function(a,b){return y2(this,a,b)};
+f.Kk=function(a,b){return z2(this,a,b)};f.sj=function(a){return A2(this,a)};f.Da=function(a,b){a|=0;b|=0;return a===b?0:a<b?-1:1};f.$classData=q({A3:0},!1,"scala.math.Numeric$IntIsIntegral$",{A3:1,g:1,rba:1,oba:1,qba:1,lm:1,Ji:1,mm:1,km:1,l:1,L3:1});var g3;function hP(a,b){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.Kw=null;this.Jw=!1;this.As=a;this.Bs=b;this.Yo=!1;Nq(this)}hP.prototype=new O4;hP.prototype.constructor=hP;f=hP.prototype;
+f.vK=function(){return this.As};f.DK=function(){return this.Bs};f.H=function(){return"Inter"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.As;case 1:return this.Bs;default:return $K(W(),a)}};f.D=function(a){return a instanceof hP};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof hP){var b=this.As,c=a.As;if(null===b?null===c:b.i(c))return b=this.Bs,a=a.Bs,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({hV:0},!1,"mlscript.Inter",{hV:1,pU:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,qU:1,E:1,v:1,l:1});function Oo(a,b,c,d,e,g,h,k){this.SC=this.RC=null;this.UC=this.VC=0;this.WC=this.TC=null;this.cl=0;this.dA=a;this.eA=b;this.gA=c;this.cA=d;this.eI=e;this.fI=g;this.fA=h;this.dI=k;Nq(this)}Oo.prototype=new P4;Oo.prototype.constructor=Oo;f=Oo.prototype;f.H=function(){return"TypeDef"};f.G=function(){return 8};
+f.I=function(a){switch(a){case 0:return this.dA;case 1:return this.eA;case 2:return this.gA;case 3:return this.cA;case 4:return this.eI;case 5:return this.fI;case 6:return this.fA;case 7:return this.dI;default:return $K(W(),a)}};f.D=function(a){return a instanceof Oo};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Oo){if(this.dA===a.dA){var b=this.eA,c=a.eA;b=null===b?null===c:b.i(c)}else b=!1;b?(b=this.gA,c=a.gA,(null===b?null===c:b.i(c))?(b=this.cA,c=a.cA,b=null===b?null===c:b.i(c)):b=!1):b=!1;if(b&&(b=this.eI,c=a.eI,(null===b?null===c:b.i(c))?(b=this.fI,c=a.fI,b=null===b?null===c:b.i(c)):b=!1,b&&(b=this.fA,c=a.fA,null===b?null===c:b.i(c))))return b=this.dI,a=a.dI,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({uY:0},!1,"mlscript.TypeDef",{uY:1,FU:1,g:1,ud:1,md:1,xd:1,Ta:1,Od:1,GU:1,E:1,v:1,l:1});function cv(a,b,c,d){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.FO=this.dd=0;this.xI=!1;this.Nb=b;this.ac=c;this.Mj=d;pY(this,a)}cv.prototype=new W4;cv.prototype.constructor=cv;f=cv.prototype;f.ma=function(){return this.Mj};f.Ea=function(){if(!this.xI&&!this.xI){var a=this.Nb.Ea(),b=this.ac.Ea();this.FO=a>b?a:b;this.xI=!0}return this.FO};
+f.ub=function(a,b){var c=this.Nb.ub(a,b);a=this.ac.ub(a,b);return c>a?c:a};function q8(a,b,c,d,e){return new cv(a.q,a.Nb.Kc(b,c,d,e),a.ac.Kc(b,c,d,e),a.Mj)}
+f.u=function(){var a=!1,b=null,c=this.Nb;a:{if(c instanceof zv){a=!0;b=c;var d=b.Yb;if(d instanceof z){var e=d.z;d=d.p;if(null!==e){var g=e.h();e=e.j();if(t().d===g&&null!==e&&(g=e.Oa,e=e.ra,t().d===g&&e instanceof zv&&(g=O().c,null===g?null===d:g.i(d)))){c="["+r8(e)+"]";break a}}}}a&&(a=b.Yb,a instanceof z&&(b=a.z,a=a.p,null!==b&&(d=b.h(),b=b.j(),t().d===d?(d=O().c,a=null===d?null===a:d.i(a)):a=!1,a&&(c=b.u()))))}return"("+c+" -\x3e "+this.ac+")"};f.H=function(){return"FunctionType"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.Nb;case 1:return this.ac;default:return $K(W(),a)}};f.D=function(a){return a instanceof cv};f.At=function(a,b,c,d){return q8(this,a,b,c,d)};f.qv=function(a,b,c,d){return q8(this,a,b,c,d)};f.$classData=q({mZ:0},!1,"mlscript.TyperDatatypes$FunctionType",{mZ:1,qA:1,Gx:1,qp:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,E:1,v:1,l:1});
+function Jv(a,b,c){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.LO=this.dd=0;this.CI=!1;this.gi=b;this.Mq=c;pY(this,a);At(tp(),0<b.ab(0))}Jv.prototype=new W4;Jv.prototype.constructor=Jv;f=Jv.prototype;f.ma=function(){return this.Mq};function VW(a,b,c){var d=a.q,e=a.gi,g=m=>new cv(a.q,b.n(m.Nb),c.n(m.ac),m.Mj);if(e===u())g=u();else{var h=e.e(),k=h=new z(g(h),u());for(e=e.f();e!==u();){var l=e.e();l=new z(g(l),u());k=k.p=l;e=e.f()}g=h}return new Jv(d,g,a.Mq)}
+function rB(a,b,c){var d=a.q,e=a.gi,g=m=>{var n=a.q;if(b.b())var r=R();else r=!!b.o(),r=new L(!r);return new cv(n,c.ba(r,m.Nb),c.ba(b,m.ac),m.Mj)};if(e===u())g=u();else{var h=e.e(),k=h=new z(g(h),u());for(e=e.f();e!==u();){var l=e.e();l=new z(g(l),u());k=k.p=l;e=e.f()}g=h}return new Jv(d,g,a.Mq)}
+function jca(a,b,c){var d=a.q,e=a.gi,g=m=>new cv(a.q,c.ba(new UB(b),m.Nb),c.ba(b,m.ac),m.Mj);if(e===u())g=u();else{var h=e.e(),k=h=new z(g(h),u());for(e=e.f();e!==u();){var l=e.e();l=new z(g(l),u());k=k.p=l;e=e.f()}g=h}return new Jv(d,g,a.Mq)}
+function mX(a){var b=a.gi;if(b===u())var c=u();else{c=b.e();var d=c=new z(G(new H,c.Nb,c.ac),u());for(b=b.f();b!==u();){var e=b.e();e=new z(G(new H,e.Nb,e.ac),u());d=d.p=e;b=b.f()}}d=op();b=c.Gb(d.ga);if(null===b)throw new w(b);d=b.j();c=a.q;b=b.h().m();if(!b.s())throw nv("empty.reduceLeft");e=!0;for(var g=null;b.s();){var h=b.t();if(e)g=h,e=!1;else{var k=V(g.q);g=dv(g,h,k,!1)}}b=g;d=d.m();if(!d.s())throw nv("empty.reduceLeft");e=!0;for(g=null;d.s();)h=d.t(),e?(g=h,e=!1):(k=V(g.q),g=dv(g,h,k,!1));
+return new cv(c,b,g,a.Mq)}f.Ea=function(){this.CI||this.CI||(this.LO=this.ub(this.q.Df,jA().X()),this.CI=!0);return this.LO};f.ub=function(a,b){var c=this.gi.m();c=new Ef(c,new y(e=>e.ub(a,b)));var d=Fq();return hH(c,d)|0};function s8(a,b,c,d,e){var g=a.q,h=a.gi;if(h===u())b=u();else{var k=h.e(),l=k=new z(q8(k,b,c,d,e),u());for(h=h.f();h!==u();){var m=h.e();m=new z(q8(m,b,c,d,e),u());l=l.p=m;h=h.f()}b=k}return new Jv(g,b,a.Mq)}f.H=function(){return"Overload"};f.G=function(){return 1};
+f.I=function(a){return 0===a?this.gi:$K(W(),a)};f.D=function(a){return a instanceof Jv};f.u=function(){return VK(this)};f.At=function(a,b,c,d){return s8(this,a,b,c,d)};f.qv=function(a,b,c,d){return s8(this,a,b,c,d)};f.$classData=q({sZ:0},!1,"mlscript.TyperDatatypes$Overload",{sZ:1,qA:1,Gx:1,qp:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,E:1,v:1,l:1});function Tv(a,b,c,d){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0;this.Ic=b;this.kf=c;this.vp=d;pY(this,a)}Tv.prototype=new W4;
+Tv.prototype.constructor=Tv;f=Tv.prototype;f.ma=function(){return this.vp};f.Ea=function(){return this.Ic.Ea()};f.ub=function(a,b){return this.Ic.ub(a,b)};f.u=function(){return this.Ic+"\\"+ze(this.kf,"","-","")};f.H=function(){return"Without"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Ic;case 1:return this.kf;default:return $K(W(),a)}};f.D=function(a){return a instanceof Tv};f.At=function(a,b,c,d){return new Tv(this.q,this.Ic.Kc(a,b,c,d),this.kf,this.vp)};
+f.qv=function(a,b,c,d){return new Tv(this.q,this.Ic.Kc(a,b,c,d),this.kf,this.vp)};f.$classData=q({PZ:0},!1,"mlscript.TyperDatatypes$Without",{PZ:1,qA:1,Gx:1,qp:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,E:1,v:1,l:1});function iP(a,b){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.Kw=null;this.Jw=!1;this.ht=a;this.it=b;this.Yo=!0;Nq(this)}iP.prototype=new O4;iP.prototype.constructor=iP;f=iP.prototype;f.vK=function(){return this.ht};f.DK=function(){return this.it};
+f.H=function(){return"Union"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.ht;case 1:return this.it;default:return $K(W(),a)}};f.D=function(a){return a instanceof iP};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof iP){var b=this.ht,c=a.ht;if(null===b?null===c:b.i(c))return b=this.it,a=a.it,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({a_:0},!1,"mlscript.Union",{a_:1,pU:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,qU:1,E:1,v:1,l:1});function t8(){}t8.prototype=new q3;t8.prototype.constructor=t8;function u8(){}f=u8.prototype=t8.prototype;f.D=function(){return!0};f.i=function(a){return kY(this,a)};f.B=function(){var a=BL();return CL(a,this,a.PB)};f.Ub=function(){return WY()};f.Oc=function(){return"Set"};f.u=function(){return w0(this)};f.fM=function(a){return this.ul(a)};f.Ce=function(a){return J0(this,a)};f.n=function(a){return this.L(a)};
+function v8(a,b){if(a===b)return!0;if(b&&b.$classData&&b.$classData.rb.Mk)if(a.ka()===b.ka())try{return a.ul(new y(c=>ml(nl(),b.Se(c.h(),HY().VR),c.j())))}catch(c){throw c;}else return!1;else return!1}function w8(a,b){var c=a.jq().Dv(a.se());c.zc(a);c.zc(b);return c.Kb()}function Ml(a,b){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.gs=a;this.Ml=b;W5(this)}Ml.prototype=new X5;Ml.prototype.constructor=Ml;f=Ml.prototype;f.H=function(){return"Ann"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.gs;case 1:return this.Ml;default:return $K(W(),a)}};f.D=function(a){return a instanceof Ml};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Ml){var b=this.gs,c=a.gs;if(null===b?null===c:b.i(c))return b=this.Ml,a=a.Ml,null===b?null===a:b.i(a)}return!1};f.$classData=q({PT:0},!1,"mlscript.Ann",{PT:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});
+function Pl(a,b){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.Za=a;this.Qb=b;W5(this)}Pl.prototype=new X5;Pl.prototype.constructor=Pl;f=Pl.prototype;f.H=function(){return"App"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Za;case 1:return this.Qb;default:return $K(W(),a)}};f.D=function(a){return a instanceof Pl};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Pl){var b=this.Za,c=a.Za;if(null===b?null===c:b.i(c))return b=this.Qb,a=a.Qb,null===b?null===a:b.i(a)}return!1};f.$classData=q({QT:0},!1,"mlscript.App",{QT:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});function Cl(a,b){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.ai=a;this.Fm=b;W5(this)}Cl.prototype=new X5;Cl.prototype.constructor=Cl;f=Cl.prototype;f.H=function(){return"Asc"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.ai;case 1:return this.Fm;default:return $K(W(),a)}};f.D=function(a){return a instanceof Cl};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Cl){var b=this.ai,c=a.ai;if(null===b?null===c:b.i(c))return b=this.Fm,a=a.Fm,null===b?null===a:b.i(a)}return!1};f.$classData=q({ST:0},!1,"mlscript.Asc",{ST:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});
+function Wl(a,b){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.Gm=a;this.Qn=b;W5(this)}Wl.prototype=new X5;Wl.prototype.constructor=Wl;f=Wl.prototype;f.H=function(){return"Assign"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Gm;case 1:return this.Qn;default:return $K(W(),a)}};f.D=function(a){return a instanceof Wl};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Wl){var b=this.Gm,c=a.Gm;if(null===b?null===c:b.i(c))return b=this.Qn,a=a.Qn,null===b?null===a:b.i(a)}return!1};f.$classData=q({TT:0},!1,"mlscript.Assign",{TT:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});function Fl(a,b){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.bi=a;this.gg=b;W5(this)}Fl.prototype=new X5;Fl.prototype.constructor=Fl;f=Fl.prototype;f.H=function(){return"Bra"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.bi;case 1:return this.gg;default:return $K(W(),a)}};f.D=function(a){return a instanceof Fl};f.B=function(){var a=lb("Bra");a=W().C(-889275714,a);var b=this.bi?1231:1237;a=W().C(a,b);b=this.gg;b=My(W(),b);a=W().C(a,b);return W().Ma(a,2)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Fl&&this.bi===a.bi){var b=this.gg;a=a.gg;return null===b?null===a:b.i(a)}return!1};
+f.$classData=q({ZT:0},!1,"mlscript.Bra",{ZT:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});function Ul(a,b){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.Sn=a;this.Hm=b;W5(this)}Ul.prototype=new X5;Ul.prototype.constructor=Ul;f=Ul.prototype;f.H=function(){return"CaseOf"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Sn;case 1:return this.Hm;default:return $K(W(),a)}};f.D=function(a){return a instanceof Ul};f.B=function(){return AL(this)};
+f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Ul){var b=this.Sn,c=a.Sn;if(null===b?null===c:b.i(c))return b=this.Hm,a=a.Hm,null===b?null===a:b.i(a)}return!1};f.$classData=q({nU:0},!1,"mlscript.CaseOf",{nU:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});
+function No(a,b,c,d){this.SC=this.RC=null;this.UC=this.VC=0;this.WC=this.TC=null;this.cl=0;this.RM=null;this.ls=a;this.oq=b;this.vu=c;this.XC=d;Nq(this);if(c instanceof Ud)a=c.fa;else{if(!(c instanceof fe))throw new w(c);a=c.aa}this.RM=a}No.prototype=new P4;No.prototype.constructor=No;f=No.prototype;f.H=function(){return"Def"};f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.ls;case 1:return this.oq;case 2:return this.vu;case 3:return this.XC;default:return $K(W(),a)}};
+f.D=function(a){return a instanceof No};f.B=function(){var a=lb("Def");a=W().C(-889275714,a);var b=this.ls?1231:1237;a=W().C(a,b);b=this.oq;b=My(W(),b);a=W().C(a,b);b=this.vu;b=My(W(),b);a=W().C(a,b);b=this.XC?1231:1237;a=W().C(a,b);return W().Ma(a,4)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof No&&this.ls===a.ls&&this.XC===a.XC){var b=this.oq,c=a.oq;if(null===b?null===c:b.i(c))return b=this.vu,a=a.vu,null===b?null===a:b.i(a)}return!1};
+f.$classData=q({HU:0},!1,"mlscript.Def",{HU:1,FU:1,g:1,ud:1,md:1,xd:1,Ta:1,Od:1,GU:1,ce:1,E:1,v:1,l:1});function bm(a,b){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.Vn=a;this.Zo=b;W5(this)}bm.prototype=new X5;bm.prototype.constructor=bm;f=bm.prototype;f.H=function(){return"Eqn"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Vn;case 1:return this.Zo;default:return $K(W(),a)}};f.D=function(a){return a instanceof bm};f.B=function(){return AL(this)};
+f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof bm){var b=this.Vn,c=a.Vn;if(null===b?null===c:b.i(c))return b=this.Zo,a=a.Zo,null===b?null===a:b.i(a)}return!1};f.$classData=q({NU:0},!1,"mlscript.Eqn",{NU:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});function Zl(a,b){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.qq=a;this.$o=b;W5(this)}Zl.prototype=new X5;Zl.prototype.constructor=Zl;f=Zl.prototype;f.H=function(){return"Forall"};
+f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.qq;case 1:return this.$o;default:return $K(W(),a)}};f.D=function(a){return a instanceof Zl};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Zl){var b=this.qq,c=a.qq;if(null===b?null===c:b.i(c))return b=this.$o,a=a.$o,null===b?null===a:b.i(a)}return!1};f.$classData=q({VU:0},!1,"mlscript.Forall",{VU:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});
+function Xl(a,b){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.bp=a;this.zs=b;W5(this)}Xl.prototype=new X5;Xl.prototype.constructor=Xl;f=Xl.prototype;f.H=function(){return"If"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.bp;case 1:return this.zs;default:return $K(W(),a)}};f.D=function(a){return a instanceof Xl};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Xl){var b=this.bp,c=a.bp;if(null===b?null===c:b.i(c))return b=this.zs,a=a.zs,null===b?null===a:b.i(a)}return!1};f.$classData=q({ZU:0},!1,"mlscript.If",{ZU:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});function Kl(a){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.cp=a;W5(this)}Kl.prototype=new X5;Kl.prototype.constructor=Kl;f=Kl.prototype;f.H=function(){return"Inst"};f.G=function(){return 1};
+f.I=function(a){return 0===a?this.cp:$K(W(),a)};f.D=function(a){return a instanceof Kl};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Kl){var b=this.cp;a=a.cp;return null===b?null===a:b.i(a)}return!1};f.$classData=q({fV:0},!1,"mlscript.Inst",{fV:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});
+function Ol(a,b){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.Ej=a;this.Fj=b;W5(this)}Ol.prototype=new X5;Ol.prototype.constructor=Ol;f=Ol.prototype;f.H=function(){return"Lam"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Ej;case 1:return this.Fj;default:return $K(W(),a)}};f.D=function(a){return a instanceof Ol};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Ol){var b=this.Ej,c=a.Ej;if(null===b?null===c:b.i(c))return b=this.Fj,a=a.Fj,null===b?null===a:b.i(a)}return!1};f.$classData=q({sW:0},!1,"mlscript.Lam",{sW:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});function Rl(a,b,c,d){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.ep=a;this.Zn=b;this.$n=c;this.Mm=d;W5(this)}Rl.prototype=new X5;Rl.prototype.constructor=Rl;f=Rl.prototype;f.H=function(){return"Let"};
+f.G=function(){return 4};f.I=function(a){switch(a){case 0:return this.ep;case 1:return this.Zn;case 2:return this.$n;case 3:return this.Mm;default:return $K(W(),a)}};f.D=function(a){return a instanceof Rl};f.B=function(){var a=lb("Let");a=W().C(-889275714,a);var b=this.ep?1231:1237;a=W().C(a,b);b=this.Zn;b=My(W(),b);a=W().C(a,b);b=this.$n;b=My(W(),b);a=W().C(a,b);b=this.Mm;b=My(W(),b);a=W().C(a,b);return W().Ma(a,4)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Rl){if(this.ep===a.ep){var b=this.Zn,c=a.Zn;b=null===b?null===c:b.i(c)}else b=!1;if(b&&(b=this.$n,c=a.$n,null===b?null===c:b.i(c)))return b=this.Mm,a=a.Mm,null===b?null===a:b.i(a)}return!1};f.$classData=q({tW:0},!1,"mlscript.Let",{tW:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});function Yl(a){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.hp=a;W5(this)}Yl.prototype=new X5;
+Yl.prototype.constructor=Yl;f=Yl.prototype;f.H=function(){return"NuNew"};f.G=function(){return 1};f.I=function(a){return 0===a?this.hp:$K(W(),a)};f.D=function(a){return a instanceof Yl};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Yl){var b=this.hp;a=a.hp;return null===b?null===a:b.i(a)}return!1};f.$classData=q({pX:0},!1,"mlscript.NuNew",{pX:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});
+function yo(a,b,c,d,e,g,h,k,l,m,n,r,v){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.sE=this.tE=this.Cf=null;this.gp=0;this.pb=a;this.gb=b;this.hg=c;this.Sg=d;this.Qm=e;this.Hj=g;this.Di=h;this.mx=k;this.Ns=l;this.ei=m;this.fl=n;this.Pm=r;this.Rz=v;U4(this)}yo.prototype=new V4;yo.prototype.constructor=yo;f=yo.prototype;f.tJ=function(){return this.Pm};f.H=function(){return"NuTypeDef"};f.G=function(){return 10};
+f.I=function(a){switch(a){case 0:return this.pb;case 1:return this.gb;case 2:return this.hg;case 3:return this.Sg;case 4:return this.Qm;case 5:return this.Hj;case 6:return this.Di;case 7:return this.mx;case 8:return this.Ns;case 9:return this.ei;default:return $K(W(),a)}};f.D=function(a){return a instanceof yo};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof yo){if(this.pb===a.pb){var b=this.gb,c=a.gb;b=null===b?null===c:b.i(c)}else b=!1;b?(b=this.hg,c=a.hg,(null===b?null===c:b.i(c))?(b=this.Sg,c=a.Sg,(null===b?null===c:b.i(c))?(b=this.Qm,c=a.Qm,b=null===b?null===c:b.i(c)):b=!1):b=!1):b=!1;if(b&&(b=this.Hj,c=a.Hj,(null===b?null===c:b.i(c))?(b=this.Di,c=a.Di,b=null===b?null===c:b.i(c)):b=!1,b&&(b=this.mx,c=a.mx,null===b?null===c:b.i(c)))&&(b=this.Ns,c=a.Ns,null===b?null===c:b.i(c)))return b=this.ei,
+a=a.ei,null===b?null===a:b.i(a)}return!1};f.fd=function(){return this.pb};f.CB=function(){return this.pb};f.$classData=q({qX:0},!1,"mlscript.NuTypeDef",{qX:1,mX:1,ih:1,g:1,jh:1,Ta:1,md:1,xd:1,nX:1,MX:1,E:1,v:1,l:1});function em(a){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.Iq=a;W5(this)}em.prototype=new X5;em.prototype.constructor=em;f=em.prototype;f.H=function(){return"Quoted"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Iq:$K(W(),a)};
+f.D=function(a){return a instanceof em};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof em){var b=this.Iq;a=a.Iq;return null===b?null===a:b.i(a)}return!1};f.$classData=q({WX:0},!1,"mlscript.Quoted",{WX:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});function yl(a){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.ll=a;W5(this)}yl.prototype=new X5;yl.prototype.constructor=yl;
+f=yl.prototype;f.H=function(){return"Rcd"};f.G=function(){return 1};f.I=function(a){return 0===a?this.ll:$K(W(),a)};f.D=function(a){return a instanceof yl};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof yl){var b=this.ll;a=a.ll;return null===b?null===a:b.i(a)}return!1};f.$classData=q({XX:0},!1,"mlscript.Rcd",{XX:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});
+function cm(a,b){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.Ys=a;this.Zs=b;W5(this)}cm.prototype=new X5;cm.prototype.constructor=cm;f=cm.prototype;f.H=function(){return"Rft"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Ys;case 1:return this.Zs;default:return $K(W(),a)}};f.D=function(a){return a instanceof cm};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof cm){var b=this.Ys,c=a.Ys;if(null===b?null===c:b.i(c))return b=this.Zs,a=a.Zs,null===b?null===a:b.i(a)}return!1};f.$classData=q({$X:0},!1,"mlscript.Rft",{$X:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});function Ql(a,b){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.Vl=a;this.ml=b;W5(this)}Ql.prototype=new X5;Ql.prototype.constructor=Ql;f=Ql.prototype;f.H=function(){return"Sel"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.Vl;case 1:return this.ml;default:return $K(W(),a)}};f.D=function(a){return a instanceof Ql};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Ql){var b=this.Vl,c=a.Vl;if(null===b?null===c:b.i(c))return b=this.ml,a=a.ml,null===b?null===a:b.i(a)}return!1};f.$classData=q({dY:0},!1,"mlscript.Sel",{dY:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});
+function Vl(a,b){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.lp=a;this.mp=b;W5(this)}Vl.prototype=new X5;Vl.prototype.constructor=Vl;f=Vl.prototype;f.H=function(){return"Subs"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.lp;case 1:return this.mp;default:return $K(W(),a)}};f.D=function(a){return a instanceof Vl};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Vl){var b=this.lp,c=a.lp;if(null===b?null===c:b.i(c))return b=this.mp,a=a.mp,null===b?null===a:b.i(a)}return!1};f.$classData=q({nY:0},!1,"mlscript.Subs",{nY:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});function am(){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;W5(this)}am.prototype=new X5;am.prototype.constructor=am;f=am.prototype;f.H=function(){return"Super"};f.G=function(){return 0};
+f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof am};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){return a instanceof am};f.$classData=q({oY:0},!1,"mlscript.Super",{oY:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});function Il(a,b){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.nl=a;this.np=b;W5(this)}Il.prototype=new X5;Il.prototype.constructor=Il;f=Il.prototype;f.H=function(){return"TyApp"};
+f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.nl;case 1:return this.np;default:return $K(W(),a)}};f.D=function(a){return a instanceof Il};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Il){var b=this.nl,c=a.nl;if(null===b?null===c:b.i(c))return b=this.np,a=a.np,null===b?null===a:b.i(a)}return!1};f.$classData=q({tY:0},!1,"mlscript.TyApp",{tY:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});
+function Sv(a,b,c){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0;this.Fd=b;this.Fx=c;pY(this,a)}Sv.prototype=new $5;Sv.prototype.constructor=Sv;f=Sv.prototype;f.Zj=function(){return this.Fd};f.ma=function(){return this.Fx};f.Ea=function(){return this.Fd.Ea()};f.ub=function(a,b){return this.Fd.ub(a,b)};f.u=function(){return"Array\u2039"+this.Fd+"\u203a"};f.H=function(){return"ArrayType"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Fd:$K(W(),a)};
+f.D=function(a){return a instanceof Sv};f.At=function(a,b,c,d){return new Sv(this.q,LX(this.Fd,a,b,c,d),this.Fx)};f.qv=function(a,b,c,d){return new Sv(this.q,LX(this.Fd,a,b,c,d),this.Fx)};f.$classData=q({WY:0},!1,"mlscript.TyperDatatypes$ArrayType",{WY:1,eO:1,qA:1,Gx:1,qp:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,E:1,v:1,l:1});
+function ega(a){if(0===(1&a.ft)<<24>>24){var b=a.fo,c=h=>{if(h instanceof fe)return h.aa.Ea();if(h instanceof Ud)return h.fa.Ea();throw new w(h);};if(b===u())c=u();else{var d=b.e(),e=d=new z(c(d),u());for(b=b.f();b!==u();){var g=b.e();g=new z(c(g),u());e=e.p=g;b=b.f()}c=d}d=Fq();a.HI=hH(c,d)|0;a.ft=(1|a.ft)<<24>>24}return a.HI}
+function fga(a){if(0===(2&a.ft)<<24>>24){var b=a.fo,c=h=>{if(h instanceof fe){h=h.aa;if(h instanceof Vv)return h.Zj();no()}else{if(h instanceof Ud)return h.fa;throw new w(h);}};if(b===u())c=u();else{var d=b.e(),e=d=new z(c(d),u());for(b=b.f();b!==u();){var g=b.e();g=new z(c(g),u());e=e.p=g;b=b.f()}c=d}c=c.m();if(!c.s())throw nv("empty.reduceLeft");d=!0;for(b=null;c.s();)e=c.t(),d?(b=e,d=!1):b=xw(b,e,V(b.Va));a.GI=b;a.ft=(2|a.ft)<<24>>24}return a.GI}
+function Wv(a,b,c){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.HI=this.dd=0;this.GI=null;this.ft=0;this.fo=b;this.Uu=c;pY(this,a);At(tp(),!b.b())}Wv.prototype=new $5;Wv.prototype.constructor=Wv;f=Wv.prototype;f.ma=function(){return this.Uu};f.Ea=function(){return 0===(1&this.ft)<<24>>24?ega(this):this.HI};
+f.qv=function(a,b,c,d){var e=this.q,g=this.fo,h=n=>{if(n instanceof fe)return n=n.aa,t(),n=n.Kc(a,b,c,d),new fe(n);if(n instanceof Ud)return n=n.fa,t(),n=LX(n,a,b,c,d),new Ud(n);throw new w(n);};if(g===u())h=u();else{var k=g.e(),l=k=new z(h(k),u());for(g=g.f();g!==u();){var m=g.e();m=new z(h(m),u());l=l.p=m;g=g.f()}h=k}return new Wv(e,h,this.Uu)};
+f.ub=function(a,b){var c=this.fo,d=k=>{if(k instanceof fe)return k.aa.ub(a,b);if(k instanceof Ud)return k.fa.ub(a,b);throw new w(k);};if(c===u())d=u();else{var e=c.e(),g=e=new z(d(e),u());for(c=c.f();c!==u();){var h=c.e();h=new z(d(h),u());g=g.p=h;c=c.f()}d=e}e=Fq();return hH(d,e)|0};f.Zj=function(){return 0===(2&this.ft)<<24>>24?fga(this):this.GI};
+function sB(a,b,c,d,e){var g=a.q,h=a.fo;a=n=>{if(n instanceof fe)return n=n.aa,t(),n=b.n(n),new fe(n);if(n instanceof Ud)return n=n.fa,t(),n=cB(n,c,d),new Ud(n);throw new w(n);};if(h===u())a=u();else{var k=h.e(),l=k=new z(a(k),u());for(h=h.f();h!==u();){var m=h.e();m=new z(a(m),u());l=l.p=m;h=h.f()}a=k}return new Wv(g,a,e)}f.H=function(){return"SpliceType"};f.G=function(){return 1};f.I=function(a){return 0===a?this.fo:$K(W(),a)};f.D=function(a){return a instanceof Wv};f.u=function(){return VK(this)};
+f.At=function(a,b,c,d){return this.qv(a,b,c,d)};f.$classData=q({AZ:0},!1,"mlscript.TyperDatatypes$SpliceType",{AZ:1,eO:1,qA:1,Gx:1,qp:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,E:1,v:1,l:1});function gga(a){if(0===(2&a.Oj)<<24>>24){var b=a.Yb.m();b=new Ef(b,new y(d=>d.j().Ea()));var c=Fq();b=Jq(b,c);a.KI=(b.b()?0:b.o())|0;a.Oj=(2|a.Oj)<<24>>24}return a.KI}
+function hga(a){if(0===(8&a.Oj)<<24>>24){var b=a.q,c=Hf(a.Yb),d=k=>{if(null!==k){var l=k.h(),m=k.Sc();if(null!==l)return k=l.j(),G(new H,new vl(""+m),k)}throw new w(k);};if(c===u())d=u();else{var e=c.e(),g=e=new z(d(e),u());for(c=c.f();c!==u();){var h=c.e();h=new z(d(h),u());g=g.p=h;c=c.f()}d=e}a.LI=new Qv(b,d,a.Nq);a.Oj=(8|a.Oj)<<24>>24}return a.LI}
+function zv(a,b,c){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0;this.RO=null;this.KI=0;this.LI=this.SO=null;this.Oj=0;this.Yb=b;this.Nq=c;pY(this,a)}zv.prototype=new $5;zv.prototype.constructor=zv;f=zv.prototype;f.ma=function(){return this.Nq};
+f.Zj=function(){if(0===(1&this.Oj)<<24>>24&&0===(1&this.Oj)<<24>>24){var a=this.Yb;if(a===u())var b=u();else{b=a.e();var c=b=new z(b.j(),u());for(a=a.f();a!==u();){var d=a.e();d=new z(d.j(),u());c=c.p=d;a=a.f()}}if(b.b())b=R();else{b=b.m();if(!b.s())throw nv("empty.reduceLeft");c=!0;for(d=null;b.s();)a=b.t(),c?(d=a,c=!1):d=xw(d,a,V(d.Va));b=new L(d)}b.b()?(b=this.q.ib,c=V(this.q),b=new Uw(b.q,R(),b,c)):b=b.o();this.RO=b;this.Oj=(1|this.Oj)<<24>>24}return this.RO};
+f.Ea=function(){return 0===(2&this.Oj)<<24>>24?gga(this):this.KI};f.ub=function(a,b){var c=this.Yb.m();c=new Ef(c,new y(e=>e.j().ub(a,b)));var d=Fq();c=Jq(c,d);return(c.b()?this.q.Gd:c.o())|0};function x8(a,b,c,d,e){var g=a.q;lv();return new zv(g,ry(0,a.Yb,new y(h=>LX(h,b,c,d,e))),a.Nq)}function Dw(a){0===(4&a.Oj)<<24>>24&&0===(4&a.Oj)<<24>>24&&(a.SO=new Sv(a.q,a.Zj(),a.Nq),a.Oj=(4|a.Oj)<<24>>24);return a.SO}f.kq=function(){return 0===(8&this.Oj)<<24>>24?hga(this):this.LI};
+function r8(a){var b=a.Yb;a=g=>{var h=g.h();return(h.b()?"":h.o().x+": ")+g.j()+","};if(b===u())a=u();else{var c=b.e(),d=c=new z(a(c),u());for(b=b.f();b!==u();){var e=b.e();e=new z(a(e),u());d=d.p=e;b=b.f()}a=c}return ze(a,""," ","")}f.u=function(){return"("+r8(this)+")"};f.H=function(){return"TupleType"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Yb:$K(W(),a)};f.D=function(a){return a instanceof zv};f.At=function(a,b,c,d){return x8(this,a,b,c,d)};
+f.qv=function(a,b,c,d){return x8(this,a,b,c,d)};f.$classData=q({EZ:0},!1,"mlscript.TyperDatatypes$TupleType",{EZ:1,eO:1,qA:1,Gx:1,qp:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,E:1,v:1,l:1});function fm(a){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.jt=a;W5(this)}fm.prototype=new X5;fm.prototype.constructor=fm;f=fm.prototype;f.H=function(){return"Unquoted"};f.G=function(){return 1};f.I=function(a){return 0===a?this.jt:$K(W(),a)};f.D=function(a){return a instanceof fm};
+f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof fm){var b=this.jt;a=a.jt;return null===b?null===a:b.i(a)}return!1};f.$classData=q({c_:0},!1,"mlscript.Unquoted",{c_:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});function $l(a,b){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.Yq=a;this.lt=b;W5(this)}$l.prototype=new X5;$l.prototype.constructor=$l;f=$l.prototype;f.H=function(){return"Where"};
+f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.Yq;case 1:return this.lt;default:return $K(W(),a)}};f.D=function(a){return a instanceof $l};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof $l){var b=this.Yq,c=a.Yq;if(null===b?null===c:b.i(c))return b=this.lt,a=a.lt,null===b?null===a:b.i(a)}return!1};f.$classData=q({j_:0},!1,"mlscript.Where",{j_:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});
+function dm(a,b){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.$q=a;this.Zq=b;W5(this)}dm.prototype=new X5;dm.prototype.constructor=dm;f=dm.prototype;f.H=function(){return"While"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.$q;case 1:return this.Zq;default:return $K(W(),a)}};f.D=function(a){return a instanceof dm};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof dm){var b=this.$q,c=a.$q;if(null===b?null===c:b.i(c))return b=this.Zq,a=a.Zq,null===b?null===a:b.i(a)}return!1};f.$classData=q({k_:0},!1,"mlscript.While",{k_:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});function Tl(a,b){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.br=a;this.ar=b;W5(this)}Tl.prototype=new X5;Tl.prototype.constructor=Tl;f=Tl.prototype;f.H=function(){return"With"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.br;case 1:return this.ar;default:return $K(W(),a)}};f.D=function(a){return a instanceof Tl};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Tl){var b=this.br,c=a.br;if(null===b?null===c:b.i(c))return b=this.ar,a=a.ar,null===b?null===a:b.i(a)}return!1};f.$classData=q({m_:0},!1,"mlscript.With",{m_:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,E:1,v:1,l:1});function y8(){}y8.prototype=new q3;
+y8.prototype.constructor=y8;function z8(){}f=z8.prototype=y8.prototype;f.D=function(){return!0};f.i=function(a){return i3(this,a)};f.B=function(){return qS(this)};f.u=function(){return w0(this)};f.gn=function(a){return IT(this,a)};f.tl=function(a){return this.gn(a)};f.ka=function(){return this.K()};f.Ii=function(a){return NY(this,a)};f.Sd=function(){return this.ad().m()};f.NJ=function(a){return 0<=a&&0<this.ab(a)};f.wo=function(a,b){var c=this.m();return LT(c,a,b)};
+f.L=function(a){return QU(this,a)};f.Zh=function(a){return qw(this,a)};f.$k=function(a){return this.ab(a)};f.ab=function(a){return iv(this,a)};f.b=function(){return SY(this)};f.Lt=function(a){return TY(this,a)};f.Ob=function(a,b){return GQ(this,a,b)};f.Lc=function(a){return this.NJ(a|0)};function A8(){}A8.prototype=new o7;A8.prototype.constructor=A8;function B8(){}f=B8.prototype=A8.prototype;f.Ph=function(a){return f8(new g8,this,a)};f.Rh=function(a){return d8(new e8,a,this)};
+f.Mh=function(a){return b8(new c8,this,a)};f.Kh=function(a){return $7(new a8,this,a)};f.Oc=function(){return"SeqView"};f.tl=function(a){return IT(this,a)};f.Ii=function(a){return NY(this,a)};f.Sd=function(){return this.ad().m()};f.wo=function(a,b){var c=this.m();return LT(c,a,b)};f.L=function(a){return QU(this,a)};f.$k=function(a){return this.ab(a)};f.ab=function(a){return iv(this,a)};f.b=function(){return SY(this)};f.Zh=function(a){return V7(this,a)};f.Bb=function(a){return this.Kh(a)};f.Jc=function(a){return this.Mh(a)};
+f.cc=function(a){return this.Rh(a)};f.Ja=function(a){return this.Ph(a)};function gU(){}gU.prototype=new o7;gU.prototype.constructor=gU;f=gU.prototype;f.m=function(){return Rq().Pa};f.Q=function(){return 0};f.b=function(){return!0};f.H=function(){return"Empty"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.D=function(a){return a instanceof gU};f.B=function(){return 67081517};
+f.$classData=q({y6:0},!1,"scala.collection.View$Empty$",{y6:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,E:1,v:1});var fU;function EB(a,b){if(a.L(b))return!1;a.$(b);return!0}
+function Zn(a,b,c,d,e,g,h,k,l,m,n,r){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.sE=this.tE=this.Cf=null;this.gp=0;this.DN=this.EN=null;this.wd=a;this.Rb=b;this.hj=c;this.Ch=d;this.Yc=e;this.Pz=g;this.lx=h;this.Om=k;this.kx=l;this.Qz=m;this.Pl=n;this.Oz=r;U4(this);if(e instanceof Ud)a=e.fa;else{if(!(e instanceof fe))throw new w(e);a=e.aa}this.EN=a;this.DN=R()}Zn.prototype=new V4;Zn.prototype.constructor=Zn;f=Zn.prototype;f.fd=function(){return hx()};f.tJ=function(){return this.DN};
+function rx(a){return a.wd.b()?!1:!a.Pl}function Gy(a){return a.lx.b()?a.Yc.tv():!0}function Ix(a){if(a.wd.b())return!0;a=a.Yc;if(a instanceof fe)return oea(a.aa);if(a instanceof Ud)return!1;throw new w(a);}f.H=function(){return"NuFunDef"};f.G=function(){return 5};f.I=function(a){switch(a){case 0:return this.wd;case 1:return this.Rb;case 2:return this.hj;case 3:return this.Ch;case 4:return this.Yc;default:return $K(W(),a)}};f.D=function(a){return a instanceof Zn};f.B=function(){return AL(this)};
+f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Zn){var b=this.wd,c=a.wd;(null===b?null===c:b.i(c))?(b=this.Rb,c=a.Rb,b=null===b?null===c:b.i(c)):b=!1;if(b&&(b=this.hj,c=a.hj,null===b?null===c:b.i(c))&&(b=this.Ch,c=a.Ch,null===b?null===c:b.i(c)))return b=this.Yc,a=a.Yc,null===b?null===a:b.i(a)}return!1};f.$classData=q({oX:0},!1,"mlscript.NuFunDef",{oX:1,mX:1,ih:1,g:1,jh:1,Ta:1,md:1,xd:1,nX:1,ud:1,Od:1,E:1,v:1,l:1});
+function C8(a){W5(a);if(a instanceof vl)var b=a.x;else{if(!(a instanceof Dl))throw new w(a);b=Zz(a,!1)}a.Dh=b}function wm(){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.Dh=null}wm.prototype=new X5;wm.prototype.constructor=wm;function D8(){}D8.prototype=wm.prototype;wm.prototype.sl=function(a){return pa(this.Dh,a.Dh)};wm.prototype.$l=function(a){return pa(this.Dh,a.Dh)};
+function Gl(a){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.Ra=a;W5(this)}Gl.prototype=new X5;Gl.prototype.constructor=Gl;f=Gl.prototype;f.H=function(){return"Tup"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Ra:$K(W(),a)};f.D=function(a){return a instanceof Gl};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Gl){var b=this.Ra;a=a.Ra;return null===b?null===a:b.i(a)}return!1};
+f.$classData=q({rY:0},!1,"mlscript.Tup",{rY:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,Iaa:1,E:1,v:1,l:1});function jt(a,b){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.pp=a;this.oA=b;Nq(this);At(tp(),b.b()||a.TJ())}jt.prototype=new U2;jt.prototype.constructor=jt;f=jt.prototype;f.sl=function(a){return bT(this,a)};
+f.u=function(){var a=this.pp;if(a instanceof Ud)a=a.fa;else{if(!(a instanceof fe))throw new w(a);a="\u03b1"+(a.aa|0)}return a};f.H=function(){return"TypeVar"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.pp;case 1:return this.oA;default:return $K(W(),a)}};f.D=function(a){return a instanceof jt};f.B=function(){return AL(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof jt){var b=this.pp,c=a.pp;if(null===b?null===c:b.i(c))return b=this.oA,a=a.oA,null===b?null===a:b.i(a)}return!1};f.$l=function(a){return bT(this,a)};f.$classData=q({JY:0},!1,"mlscript.TypeVar",{JY:1,Vz:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,Naa:1,yj:1,nf:1,E:1,v:1,l:1});function E8(){}E8.prototype=new q3;E8.prototype.constructor=E8;function F8(){}f=F8.prototype=E8.prototype;f.D=function(){return!0};f.i=function(a){return v8(this,a)};
+f.B=function(){var a=BL();if(this.b())a=a.mG;else{var b=new sS,c=a.Cr;this.og(b);c=a.C(c,b.PK);c=a.C(c,b.QK);c=a.Pp(c,b.RK);a=a.Ma(c,b.SK)}return a};f.Oc=function(){return"Map"};f.u=function(){return w0(this)};f.Gk=function(a){return this.vj().Ib(a)};f.ti=function(){return this.vj().Eb()};f.Se=function(a,b){return x3(this,a,b)};f.n=function(a){return HA(this,a)};f.Ob=function(a,b){return y3(this,a,b)};f.zr=function(){return G8(new H8,this)};f.tT=function(){return new rp(this)};f.tj=function(){return new I0(this)};
+f.ie=function(){return new Ou(this)};f.og=function(a){for(var b=this.m();b.s();){var c=b.t();a.ba(c.h(),c.j())}};f.IF=function(a){return z3(a)};f.L=function(a){return!this.U(a).b()};f.Lc=function(a){return this.L(a)};f.ry=function(a){return this.vj().Ib(GT(new HT,this,a))};f.am=function(a){return A3(this,a)};f.bf=function(a){return this.am(a)};f.Gh=function(a,b,c,d){return B3(this,a,b,c,d)};f.vc=function(a){return this.Gk(a)};function b8(a,b,c){a.Gy=b;a.KG=c;AT(a,b,c);return a}
+function c8(){this.My=null;this.Tv=this.cC=0;this.Gy=null;this.KG=0}c8.prototype=new j8;c8.prototype.constructor=c8;function I8(){}f=I8.prototype=c8.prototype;f.Ph=function(a){return f8(new g8,this,a)};f.Rh=function(a){return d8(new e8,a,this)};f.Kh=function(a){return $7(new a8,this,a)};f.Oc=function(){return"SeqView"};f.tl=function(a){return IT(this,a)};f.Ii=function(a){return NY(this,a)};f.Sd=function(){return this.ad().m()};f.wo=function(a,b){var c=this.m();return LT(c,a,b)};
+f.L=function(a){return QU(this,a)};f.$k=function(a){return this.ab(a)};f.ab=function(a){return iv(this,a)};f.b=function(){return SY(this)};f.K=function(){var a=this.Gy.K()-this.Tv|0;return 0<a?a:0};f.va=function(a){return this.Gy.va(a+this.Tv|0)};f.Mh=function(a){return b8(new c8,this.Gy,this.KG+a|0)};f.Zh=function(a){return V7(this,a)};f.Bb=function(a){return this.Kh(a)};f.cc=function(a){return this.Rh(a)};f.Ja=function(a){return this.Ph(a)};f.Jc=function(a){return this.Mh(a)};
+f.$classData=q({rL:0},!1,"scala.collection.SeqView$Drop",{rL:1,UG:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1});function $7(a,b,c){a.JG=b;s3(a,b,c);b=b.K()-(0<c?c:0)|0;a.Fy=0<b?b:0;return a}function a8(){this.Ly=null;this.bC=this.aC=0;this.JG=null;this.Fy=0}a8.prototype=new k8;a8.prototype.constructor=a8;function J8(){}f=J8.prototype=a8.prototype;f.Ph=function(a){return f8(new g8,this,a)};f.Rh=function(a){return d8(new e8,a,this)};f.Mh=function(a){return b8(new c8,this,a)};
+f.Kh=function(a){return $7(new a8,this,a)};f.Oc=function(){return"SeqView"};f.tl=function(a){return IT(this,a)};f.Ii=function(a){return NY(this,a)};f.Sd=function(){return this.ad().m()};f.wo=function(a,b){var c=this.m();return LT(c,a,b)};f.L=function(a){return QU(this,a)};f.$k=function(a){return this.ab(a)};f.ab=function(a){return iv(this,a)};f.b=function(){return SY(this)};f.K=function(){return this.Fy};f.va=function(a){return this.JG.va(a)};f.Zh=function(a){return V7(this,a)};f.Bb=function(a){return this.Kh(a)};
+f.Jc=function(a){return this.Mh(a)};f.cc=function(a){return this.Rh(a)};f.Ja=function(a){return this.Ph(a)};f.$classData=q({sL:0},!1,"scala.collection.SeqView$DropRight",{sL:1,VG:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1});function bU(a,b){a.Qv=b;return a}function cU(){this.Qv=null}cU.prototype=new B8;cU.prototype.constructor=cU;function K8(){}f=K8.prototype=cU.prototype;f.va=function(a){return this.Qv.va(a)};f.K=function(){return this.Qv.K()};f.m=function(){return this.Qv.m()};
+f.Q=function(){return this.Qv.Q()};f.b=function(){return this.Qv.b()};f.$classData=q({aS:0},!1,"scala.collection.SeqView$Id",{aS:1,QB:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1});function f8(a,b,c){a.VB=b;a.LG=c;GT(a,b,c);return a}function g8(){this.LG=this.VB=this.dC=this.Uv=null}g8.prototype=new l8;g8.prototype.constructor=g8;function L8(){}f=L8.prototype=g8.prototype;f.Ph=function(a){return f8(new g8,this,a)};f.Rh=function(a){return d8(new e8,a,this)};
+f.Mh=function(a){return b8(new c8,this,a)};f.Kh=function(a){return $7(new a8,this,a)};f.Oc=function(){return"SeqView"};f.tl=function(a){return IT(this,a)};f.Ii=function(a){return NY(this,a)};f.Sd=function(){return this.ad().m()};f.wo=function(a,b){var c=this.m();return LT(c,a,b)};f.L=function(a){return QU(this,a)};f.$k=function(a){return this.ab(a)};f.ab=function(a){return iv(this,a)};f.b=function(){return SY(this)};f.va=function(a){return this.LG.n(this.VB.va(a))};f.K=function(){return this.VB.K()};
+f.Zh=function(a){return V7(this,a)};f.Bb=function(a){return this.Kh(a)};f.Jc=function(a){return this.Mh(a)};f.cc=function(a){return this.Rh(a)};f.Ja=function(a){return this.Ph(a)};f.$classData=q({tL:0},!1,"scala.collection.SeqView$Map",{tL:1,WG:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1});function d8(a,b,c){a.MG=b;a.WB=c;a.eC=b;a.Ny=c;return a}function e8(){this.WB=this.MG=this.Ny=this.eC=null}e8.prototype=new n8;e8.prototype.constructor=e8;function M8(){}f=M8.prototype=e8.prototype;
+f.Ph=function(a){return f8(new g8,this,a)};f.Rh=function(a){return d8(new e8,a,this)};f.Mh=function(a){return b8(new c8,this,a)};f.Kh=function(a){return $7(new a8,this,a)};f.Oc=function(){return"SeqView"};f.tl=function(a){return IT(this,a)};f.Ii=function(a){return NY(this,a)};f.Sd=function(){return this.ad().m()};f.wo=function(a,b){var c=this.m();return LT(c,a,b)};f.L=function(a){return QU(this,a)};f.$k=function(a){return this.ab(a)};f.ab=function(a){return iv(this,a)};f.b=function(){return SY(this)};
+f.va=function(a){return 0===a?this.MG:this.WB.va(-1+a|0)};f.K=function(){return 1+this.WB.K()|0};f.Zh=function(a){return V7(this,a)};f.Bb=function(a){return this.Kh(a)};f.Jc=function(a){return this.Mh(a)};f.cc=function(a){return this.Rh(a)};f.Ja=function(a){return this.Ph(a)};f.$classData=q({uL:0},!1,"scala.collection.SeqView$Prepended",{uL:1,hS:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1});function i8(){this.Rv=null}i8.prototype=new B8;i8.prototype.constructor=i8;function N8(){}
+f=N8.prototype=i8.prototype;f.va=function(a){return this.Rv.va((-1+this.K()|0)-a|0)};f.K=function(){return this.Rv.K()};f.m=function(){return this.Rv.Sd()};f.Q=function(){return this.Rv.Q()};f.b=function(){return this.Rv.b()};f.$classData=q({bS:0},!1,"scala.collection.SeqView$Reverse",{bS:1,QB:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1});
+function O8(a,b){if(a===b)return!0;if(b&&b.$classData&&b.$classData.rb.PG){var c=b.se(),d=a.se();if(null===c?null===d:c.i(d)){if(a.ka()===b.ka()){c=a.m();b=b.m();for(d=!0;d&&c.s();)d=a.se().Yi(c.t(),b.t());return d}return!1}}return kY(a,b)}function P8(a,b,c){var d=a.U(b);c=c.n(d);d=G(new H,d,c);var e=d.y,g=d.w;if(R()!==e||R()!==g)if(e=d.w,d.y instanceof L&&R()===e)a.JB(b);else if(e=d.w,e instanceof L)a.bh(b,e.k);else throw new w(d);return c}
+function pX(a,b,c){var d=a.U(b);if(d instanceof L)return d.k;if(R()===d)return c=Es(c),a.bh(b,c),c;throw new w(d);}function Sl(a){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.Dj=a;W5(this)}Sl.prototype=new X5;Sl.prototype.constructor=Sl;f=Sl.prototype;f.H=function(){return"Blk"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Dj:$K(W(),a)};f.D=function(a){return a instanceof Sl};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Sl){var b=this.Dj;a=a.Dj;return null===b?null===a:b.i(a)}return!1};f.CB=function(){return g_()};f.$classData=q({VT:0},!1,"mlscript.Blk",{VT:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,vaa:1,MX:1,E:1,v:1,l:1});function Mu(a,b,c,d){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0;this.fO=null;this.tI=!1;this.pd=b;this.JE=c;this.ZY=d;pY(this,a)}Mu.prototype=new d3;Mu.prototype.constructor=Mu;f=Mu.prototype;f.u=function(){return oY(this)};
+f.sl=function(a){return uw(this,a)};f.Fv=function(){this.tI||this.tI||(this.fO=nY(this),this.tI=!0);return this.fO};f.rr=function(){return this.pd};f.AK=function(){return this.JE};f.ma=function(){return this.ZY};function sba(a,b){return Pe(new E(b.pd),a.pd)?(t(),new L(a)):b.Fv().L(a.pd)?(t(),new L(b)):a.Fv().L(b.pd)?(t(),new L(a)):t().d}f.Ea=function(){return this.q.Gd};f.ub=function(){return this.q.Gd};f.H=function(){return"ClassTag"};f.G=function(){return 2};
+f.I=function(a){switch(a){case 0:return this.pd;case 1:return this.JE;default:return $K(W(),a)}};f.D=function(a){return a instanceof Mu};f.$l=function(a){return uw(this,a)};f.At=function(){return this};f.uo=function(){return this.pd};f.$classData=q({YY:0},!1,"mlscript.TyperDatatypes$ClassTag",{YY:1,Gx:1,qp:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,uA:1,yj:1,nf:1,KO:1,E:1,v:1,l:1});function Q8(){}Q8.prototype=new o7;Q8.prototype.constructor=Q8;function R8(){}f=R8.prototype=Q8.prototype;f.tT=function(){return new T7(this)};
+f.u=function(){return w5(this)};f.Oc=function(){return"MapView"};f.Se=function(a,b){return x3(this,a,b)};f.n=function(a){return HA(this,a)};f.Ob=function(a,b){return y3(this,a,b)};f.tj=function(){return new I0(this)};f.ie=function(){return new Ou(this)};f.IF=function(a){return z3(a)};f.L=function(a){return!this.U(a).b()};f.Lc=function(a){return!this.U(a).b()};f.bf=function(a){return A3(this,a)};f.Gh=function(a,b,c,d){return B3(this,a,b,c,d)};f.vj=function(){JY||(JY=new IY);return JY};
+function $X(a,b){return S8(new T8,a,new y(()=>b))}function jV(a){return!!(a&&a.$classData&&a.$classData.rb.Pr)}function Dl(){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.Dh=null}Dl.prototype=new D8;Dl.prototype.constructor=Dl;function U8(){}U8.prototype=Dl.prototype;function Ep(a){this.df=this.cf=this.jf=null;this.ff=this.gf=0;this.hf=this.ef=null;this.sc=0;this.Eg=this.Dg=null;this.Qe=0;this.XN=null;this.jI=!1;this.V=a;Nq(this)}Ep.prototype=new U2;
+Ep.prototype.constructor=Ep;f=Ep.prototype;f.sl=function(a){return pa(this.V,a.V)};f.Zr=function(){if(!this.jI&&!this.jI){var a=new vl(this.V),b=this.A();this.XN=Cq(a,b);this.jI=!0}return this.XN};f.Ua=function(){return this.V};f.H=function(){return"TypeName"};f.G=function(){return 1};f.I=function(a){return 0===a?this.V:$K(W(),a)};f.D=function(a){return a instanceof Ep};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){return this===a?!0:a instanceof Ep?this.V===a.V:!1};f.$l=function(a){return pa(this.V,a.V)};f.$classData=q({CY:0},!1,"mlscript.TypeName",{CY:1,Vz:1,Fi:1,ih:1,g:1,jh:1,Ta:1,Gi:1,JW:1,Kaa:1,yj:1,nf:1,IW:1,E:1,v:1,l:1});function YB(a,b,c,d,e){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.EO=this.dd=0;this.DO=null;this.pA=b;this.Ym=c;this.jZ=d;this.ME=e;pY(this,a);this.EO=a.Gd;this.DO=c.hi}YB.prototype=new P7;YB.prototype.constructor=YB;f=YB.prototype;f.ma=function(){return this.jZ};
+f.Ea=function(){return this.EO};f.ub=function(){return 0};f.u=function(){return this.pA?"\u22a5("+this.Ym+")":"\u22a4("+this.Ym+")"};f.H=function(){return"Extruded"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.pA;case 1:return this.Ym;default:return $K(W(),a)}};f.D=function(a){return a instanceof YB};f.uo=function(){return this.DO};f.$classData=q({iZ:0},!1,"mlscript.TyperDatatypes$Extruded",{iZ:1,IE:1,qp:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,uA:1,yj:1,nf:1,Hx:1,XO:1,E:1,v:1,l:1});
+function mx(a,b,c){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.Tu=this.dd=0;this.hi=b;this.et=c;pY(this,a);this.Tu=b.Xa}mx.prototype=new P7;mx.prototype.constructor=mx;f=mx.prototype;f.ma=function(){return this.et};f.ub=function(a,b){return this.hi.ub(a,b)};f.Ea=function(){return this.Tu};f.u=function(){var a=S7(this.hi),b=0<=a.length&&"'"===a.substring(0,1)?Of(Q(),a,1,a.length):a;a=Iu(Q(),a);return"\u2018"+b+(Pe(new E(hc(a)),hc(39))?"_":"")+YC(this.q,this.Tu)};f.H=function(){return"SkolemTag"};
+f.G=function(){return 1};f.I=function(a){return 0===a?this.hi:$K(W(),a)};f.D=function(a){return a instanceof mx};f.uo=function(){return this.hi};f.$classData=q({zZ:0},!1,"mlscript.TyperDatatypes$SkolemTag",{zZ:1,IE:1,qp:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,uA:1,yj:1,nf:1,Hx:1,XO:1,E:1,v:1,l:1});function nC(a,b,c,d){this.q=null;this.pe=this.Be=this.ze=0;this.oe=null;this.Ae=!1;this.dd=0;this.QO=null;this.II=!1;this.rp=b;this.JI=c;this.DZ=d;pY(this,a)}nC.prototype=new P7;nC.prototype.constructor=nC;f=nC.prototype;
+f.u=function(){return oY(this)};f.Fv=function(){this.II||this.II||(this.QO=nY(this),this.II=!0);return this.QO};f.AK=function(){return this.JI};f.ma=function(){return this.DZ};f.ub=function(){return this.q.Gd};f.Ea=function(){return this.q.Gd};f.H=function(){return"TraitTag"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.rp;case 1:return this.JI;default:return $K(W(),a)}};f.D=function(a){return a instanceof nC};f.uo=function(){return this.rp};f.rr=function(){return this.rp};
+f.$classData=q({CZ:0},!1,"mlscript.TyperDatatypes$TraitTag",{CZ:1,IE:1,qp:1,Tg:1,Gg:1,g:1,Hg:1,Ug:1,uA:1,yj:1,nf:1,Hx:1,KO:1,E:1,v:1,l:1});function V8(){}V8.prototype=new B8;V8.prototype.constructor=V8;function W8(){}f=W8.prototype=V8.prototype;f.m=function(){return Kr(new Lr,this)};f.Sd=function(){return uZ(new vZ,this)};f.Qh=function(a){return o0(new p0,a,this)};f.Lh=function(a){return r0(new s0,this,a)};f.Jh=function(a){return X8(new Y8,this,a)};f.Oh=function(a){return u0(new v0,this,a)};
+f.Oc=function(){return"IndexedSeqView"};f.mf=function(a,b){return l0(this,a,b)};f.ad=function(){return new Z8(this)};f.e=function(){return this.va(0)};f.Mc=function(){return SF(this)};f.ab=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.Ph=function(a){return this.Oh(a)};f.Ja=function(a){return this.Oh(a)};f.Kh=function(a){return this.Jh(a)};f.Bb=function(a){return this.Jh(a)};f.Mh=function(a){return this.Lh(a)};f.Jc=function(a){return this.Lh(a)};f.Rh=function(a){return this.Qh(a)};
+f.cc=function(a){return this.Qh(a)};function G8(a,b){if(null===b)throw null;a.Pv=b;return a}function H8(){this.Pv=null}H8.prototype=new u8;H8.prototype.constructor=H8;function $8(){}f=$8.prototype=H8.prototype;f.m=function(){return this.Pv.tj()};f.L=function(a){return this.Pv.L(a)};f.ka=function(){return this.Pv.ka()};f.Q=function(){return this.Pv.Q()};f.b=function(){return this.Pv.b()};
+f.$classData=q({WR:0},!1,"scala.collection.MapOps$KeySet",{WR:1,rm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,fk:1,Cl:1,la:1,v:1,UB:1,sg:1,l:1});function KY(){}KY.prototype=new R8;KY.prototype.constructor=KY;f=KY.prototype;f.U=function(){return R()};f.m=function(){return Rq().Pa};f.Q=function(){return 0};f.b=function(){return!0};f.$classData=q({P5:0},!1,"scala.collection.MapView$$anon$1",{P5:1,zR:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,oL:1,ek:1,za:1,la:1});function qv(a){this.DG=a}qv.prototype=new R8;
+qv.prototype.constructor=qv;f=qv.prototype;f.U=function(a){return this.DG.U(a)};f.m=function(){return this.DG.m()};f.Q=function(){return this.DG.Q()};f.b=function(){return this.DG.b()};f.$classData=q({Q5:0},!1,"scala.collection.MapView$Id",{Q5:1,zR:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,oL:1,ek:1,za:1,la:1});function pv(a,b){this.EG=a;this.XR=b}pv.prototype=new R8;pv.prototype.constructor=pv;f=pv.prototype;f.m=function(){var a=this.EG.m();return new Ef(a,new y(b=>G(new H,b.h(),this.XR.n(b.j()))))};
+f.U=function(a){a=this.EG.U(a);var b=this.XR;return a.b()?R():new L(b.n(a.o()))};f.Q=function(){return this.EG.Q()};f.b=function(){return this.EG.b()};f.$classData=q({R5:0},!1,"scala.collection.MapView$MapValues",{R5:1,zR:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,oL:1,ek:1,za:1,la:1});
+function lY(a,b){if(a===b)return!0;if(b&&b.$classData&&b.$classData.rb.YB){var c=b.se(),d=a.se();if(null===c?null===d:c.i(d)){if(a.ka()===b.ka()){c=a.m();b=b.m();for(d=!0;d&&c.s();){d=c.t();var e=b.t();d=a.se().Yi(d.h(),e.h())&&ml(nl(),d.j(),e.j())}return d}return!1}}return v8(a,b)}function a9(){}a9.prototype=new u8;a9.prototype.constructor=a9;function b9(){}b9.prototype=a9.prototype;a9.prototype.Ub=function(){return Bq()};a9.prototype.wy=function(a){a=a.m();for(var b=this;a.s();){var c=a.t();b=b.Ek(c)}return b};
+function r0(a,b,c){b8(a,b,c);return a}function s0(){this.My=null;this.Tv=this.cC=0;this.Gy=null;this.KG=0}s0.prototype=new I8;s0.prototype.constructor=s0;function c9(){}f=c9.prototype=s0.prototype;f.m=function(){return Kr(new Lr,this)};f.Sd=function(){return uZ(new vZ,this)};f.Qh=function(a){return o0(new p0,a,this)};f.Lh=function(a){return r0(new s0,this,a)};f.Jh=function(a){return X8(new Y8,this,a)};f.Oh=function(a){return u0(new v0,this,a)};f.Oc=function(){return"IndexedSeqView"};
+f.mf=function(a,b){return l0(this,a,b)};f.ad=function(){return new Z8(this)};f.e=function(){return this.va(0)};f.Mc=function(){return SF(this)};f.ab=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.Ph=function(a){return this.Oh(a)};f.Ja=function(a){return this.Oh(a)};f.Kh=function(a){return this.Jh(a)};f.Bb=function(a){return this.Jh(a)};f.Mh=function(a){return this.Lh(a)};f.Jc=function(a){return this.Lh(a)};f.Rh=function(a){return this.Qh(a)};f.cc=function(a){return this.Qh(a)};
+f.$classData=q({AR:0},!1,"scala.collection.IndexedSeqView$Drop",{AR:1,rL:1,UG:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1,Ao:1,Vb:1});function X8(a,b,c){$7(a,b,c);return a}function Y8(){this.Ly=null;this.bC=this.aC=0;this.JG=null;this.Fy=0}Y8.prototype=new J8;Y8.prototype.constructor=Y8;function d9(){}f=d9.prototype=Y8.prototype;f.m=function(){return Kr(new Lr,this)};f.Sd=function(){return uZ(new vZ,this)};f.Qh=function(a){return o0(new p0,a,this)};
+f.Lh=function(a){return r0(new s0,this,a)};f.Jh=function(a){return X8(new Y8,this,a)};f.Oh=function(a){return u0(new v0,this,a)};f.Oc=function(){return"IndexedSeqView"};f.mf=function(a,b){return l0(this,a,b)};f.ad=function(){return new Z8(this)};f.e=function(){return this.va(0)};f.Mc=function(){return SF(this)};f.ab=function(a){var b=this.Fy;return b===a?0:b<a?-1:1};f.Q=function(){return this.Fy};f.Ph=function(a){return this.Oh(a)};f.Ja=function(a){return this.Oh(a)};f.Kh=function(a){return this.Jh(a)};
+f.Bb=function(a){return this.Jh(a)};f.Mh=function(a){return this.Lh(a)};f.Jc=function(a){return this.Lh(a)};f.Rh=function(a){return this.Qh(a)};f.cc=function(a){return this.Qh(a)};f.$classData=q({BR:0},!1,"scala.collection.IndexedSeqView$DropRight",{BR:1,sL:1,VG:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1,Ao:1,Vb:1});function QX(a){this.Qv=null;bU(this,a)}QX.prototype=new K8;QX.prototype.constructor=QX;f=QX.prototype;f.m=function(){return Kr(new Lr,this)};
+f.Sd=function(){return uZ(new vZ,this)};f.Oc=function(){return"IndexedSeqView"};f.mf=function(a,b){return l0(this,a,b)};f.ad=function(){return new Z8(this)};f.e=function(){return this.va(0)};f.Mc=function(){return SF(this)};f.ab=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.Ph=function(a){return u0(new v0,this,a)};f.Ja=function(a){return u0(new v0,this,a)};f.Kh=function(a){return X8(new Y8,this,a)};f.Bb=function(a){return X8(new Y8,this,a)};
+f.Mh=function(a){return r0(new s0,this,a)};f.Jc=function(a){return r0(new s0,this,a)};f.Rh=function(a){return o0(new p0,a,this)};f.cc=function(a){return o0(new p0,a,this)};f.$classData=q({Y4:0},!1,"scala.collection.IndexedSeqView$Id",{Y4:1,aS:1,QB:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1,Ao:1,Vb:1});function u0(a,b,c){f8(a,b,c);return a}function v0(){this.LG=this.VB=this.dC=this.Uv=null}v0.prototype=new L8;v0.prototype.constructor=v0;function e9(){}f=e9.prototype=v0.prototype;
+f.m=function(){return Kr(new Lr,this)};f.Sd=function(){return uZ(new vZ,this)};f.Qh=function(a){return o0(new p0,a,this)};f.Lh=function(a){return r0(new s0,this,a)};f.Jh=function(a){return X8(new Y8,this,a)};f.Oh=function(a){return u0(new v0,this,a)};f.Oc=function(){return"IndexedSeqView"};f.mf=function(a,b){return l0(this,a,b)};f.ad=function(){return new Z8(this)};f.e=function(){return this.va(0)};f.Mc=function(){return SF(this)};f.ab=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};
+f.Ph=function(a){return this.Oh(a)};f.Ja=function(a){return this.Oh(a)};f.Kh=function(a){return this.Jh(a)};f.Bb=function(a){return this.Jh(a)};f.Mh=function(a){return this.Lh(a)};f.Jc=function(a){return this.Lh(a)};f.Rh=function(a){return this.Qh(a)};f.cc=function(a){return this.Qh(a)};f.$classData=q({ER:0},!1,"scala.collection.IndexedSeqView$Map",{ER:1,tL:1,WG:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1,Ao:1,Vb:1});function o0(a,b,c){d8(a,b,c);return a}
+function p0(){this.WB=this.MG=this.Ny=this.eC=null}p0.prototype=new M8;p0.prototype.constructor=p0;function f9(){}f=f9.prototype=p0.prototype;f.m=function(){return Kr(new Lr,this)};f.Sd=function(){return uZ(new vZ,this)};f.Qh=function(a){return o0(new p0,a,this)};f.Lh=function(a){return r0(new s0,this,a)};f.Jh=function(a){return X8(new Y8,this,a)};f.Oh=function(a){return u0(new v0,this,a)};f.Oc=function(){return"IndexedSeqView"};f.mf=function(a,b){return l0(this,a,b)};f.ad=function(){return new Z8(this)};
+f.e=function(){return this.va(0)};f.Mc=function(){return SF(this)};f.ab=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.Ph=function(a){return this.Oh(a)};f.Ja=function(a){return this.Oh(a)};f.Kh=function(a){return this.Jh(a)};f.Bb=function(a){return this.Jh(a)};f.Mh=function(a){return this.Lh(a)};f.Jc=function(a){return this.Lh(a)};f.Rh=function(a){return this.Qh(a)};f.cc=function(a){return this.Qh(a)};
+f.$classData=q({FR:0},!1,"scala.collection.IndexedSeqView$Prepended",{FR:1,uL:1,hS:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1,Ao:1,Vb:1});function Z8(a){this.Rv=a}Z8.prototype=new N8;Z8.prototype.constructor=Z8;f=Z8.prototype;f.m=function(){return Kr(new Lr,this)};f.Sd=function(){return uZ(new vZ,this)};f.Oc=function(){return"IndexedSeqView"};f.mf=function(a,b){return l0(this,a,b)};f.ad=function(){return new Z8(this)};f.e=function(){return this.va(0)};f.Mc=function(){return SF(this)};
+f.ab=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.Ph=function(a){return u0(new v0,this,a)};f.Ja=function(a){return u0(new v0,this,a)};f.Kh=function(a){return X8(new Y8,this,a)};f.Bb=function(a){return X8(new Y8,this,a)};f.Mh=function(a){return r0(new s0,this,a)};f.Jc=function(a){return r0(new s0,this,a)};f.Rh=function(a){return o0(new p0,a,this)};f.cc=function(a){return o0(new p0,a,this)};
+f.$classData=q({Z4:0},!1,"scala.collection.IndexedSeqView$Reverse",{Z4:1,bS:1,QB:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1,Ao:1,Vb:1});function g9(a){this.Tp=null;if(null===a)throw null;this.Tp=a}g9.prototype=new p;g9.prototype.constructor=g9;f=g9.prototype;f.se=function(){return this.Tp.se()};f.m=function(){return this.Tp.tj()};f.L=function(a){return this.Tp.L(a)};f.ka=function(){return this.Tp.ka()};f.Q=function(){return this.Tp.Q()};f.b=function(){return this.Tp.b()};
+f.i=function(a){return O8(this,a)};f.aj=function(a){return u5(this,a)};f.$i=function(a){return v5(this,a)};f.D=function(){return!0};f.B=function(){var a=BL();return CL(a,this,a.PB)};f.Ub=function(){return WY()};f.u=function(){return w0(this)};f.fM=function(a){return nw(this,a)};f.Ce=function(a){return J0(this,a)};f.Ih=function(){return"SortedSet"};f.e=function(){return this.Tp.tj().t()};f.Mc=function(){return yT(this)};f.$k=function(a){return iv(this,a)};f.Jc=function(a){return zT(this,a)};
+f.Bb=function(a){return this.vc(s3(new t3,this,a))};f.Ja=function(a){return FT(this,a)};f.tl=function(a){return IT(this,a)};f.Gb=function(a){return KT(this,a)};f.Ca=function(a){cH(this,a)};f.De=function(a,b){return mB(this,a,b)};f.mf=function(a,b){return Qu(this,a,b)};f.th=function(a){return eH(this,a)};f.Gc=function(a,b,c){return NB(this,a,b,c)};f.Gh=function(a,b,c,d){return iH(this,a,b,c,d)};f.ha=function(){Od();return Pd(u(),this)};f.Ti=function(){return pp(qp(),this)};
+f.Bj=function(a){return kB(this,a)};f.ad=function(){return er(this)};f.n=function(a){return this.Tp.L(a)};f.vc=function(a){D3||(D3=new C3);return D3.pr(a,this.Tp.se())};f.$classData=q({d6:0},!1,"scala.collection.SortedMapOps$KeySortedSet",{d6:1,g:1,PG:1,fk:1,na:1,M:1,pa:1,N:1,oa:1,Cl:1,la:1,v:1,fS:1,Iy:1,eS:1,UB:1,c6:1});function h9(){}h9.prototype=new z8;h9.prototype.constructor=h9;function i9(){}i9.prototype=h9.prototype;h9.prototype.FC=function(){return this};
+function j9(a,b){this.LS=a;this.bz=b}j9.prototype=new W8;j9.prototype.constructor=j9;f=j9.prototype;f.va=function(a){return this.LS.va(a)};f.K=function(){return this.LS.Zg};f.Ih=function(){return"ArrayBufferView"};f.m=function(){return new E5(this,this.bz)};f.Sd=function(){return new F5(this,this.bz)};f.Qh=function(a){return new k9(a,this,this.bz)};f.Lh=function(a){return new l9(this,a,this.bz)};f.Jh=function(a){return new m9(this,a,this.bz)};f.Oh=function(a){return new n9(this,a,this.bz)};f.Ph=function(a){return this.Oh(a)};
+f.Ja=function(a){return this.Oh(a)};f.Kh=function(a){return this.Jh(a)};f.Bb=function(a){return this.Jh(a)};f.Mh=function(a){return this.Lh(a)};f.Jc=function(a){return this.Lh(a)};f.Rh=function(a){return this.Qh(a)};f.cc=function(a){return this.Qh(a)};f.$classData=q({f9:0},!1,"scala.collection.mutable.ArrayBufferView",{f9:1,x4:1,QB:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1,Ao:1,Vb:1});function o9(a){this.Pv=null;G8(this,a)}o9.prototype=new $8;o9.prototype.constructor=o9;
+o9.prototype.Ub=function(){return KB()};o9.prototype.$classData=q({f$:0},!1,"scala.collection.mutable.LinkedHashMap$LinkedKeySet",{f$:1,WR:1,rm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,fk:1,Cl:1,la:1,v:1,UB:1,sg:1,l:1});function p9(){}p9.prototype=new F8;p9.prototype.constructor=p9;function q9(){}f=q9.prototype=p9.prototype;f.vj=function(){return qp()};f.Ti=function(){return this};f.jM=function(a){return $X(this,a)};f.dG=function(a){return x5(this,a)};f.IC=function(a,b){return y5(this,a,b)};
+f.Pn=function(a){return this.Em(a.h(),a.j())};f.Ht=function(){return r9(new s9,this)};f.Ub=function(){return DY()};f.zr=function(){return this.Ht()};function t9(a,b){return V0(b)?a.K()===b.K():!0}
+function u9(a,b){if(V0(b)){if(a===b)return!0;var c=a.K(),d=c===b.K();if(d){var e=0,g=a.dy(),h=b.dy();g=g<h?g:h;h=c>>31;var k=g>>>31|0|g>>31<<1;for(g=(h===k?(-2147483648^c)>(-2147483648^g<<1):h>k)?g:c;e<g&&d;)d=ml(nl(),a.va(e),b.va(e)),e=1+e|0;if(e<c&&d)for(a=a.m().ph(e),b=b.m().ph(e);d&&a.s();)d=ml(nl(),a.t(),b.t())}return d}return TY(a,b)}function V0(a){return!!(a&&a.$classData&&a.$classData.rb.Sh)}function v9(){}v9.prototype=new b9;v9.prototype.constructor=v9;f=v9.prototype;f.ka=function(){return 0};
+f.b=function(){return!0};f.Q=function(){return 0};f.fM=function(){return!0};f.L=function(){return!1};f.m=function(){return Rq().Pa};f.Ca=function(){};f.Ek=function(){return this};f.bc=function(a){return new w9(a)};f.wy=function(){return this};f.$classData=q({k8:0},!1,"scala.collection.immutable.Set$EmptySet$",{k8:1,Fr:1,rm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,fk:1,Cl:1,la:1,v:1,dq:1,xc:1,Rr:1,l:1});var x9;function ap(){x9||(x9=new v9);return x9}function Mr(a){this.Ky=a}Mr.prototype=new W8;
+Mr.prototype.constructor=Mr;f=Mr.prototype;f.K=function(){return this.Ky.length};f.u=function(){return"StringView("+this.Ky+")"};f.H=function(){return"StringView"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Ky:$K(W(),a)};f.D=function(a){return a instanceof Mr};f.B=function(){return AL(this)};f.i=function(a){return this===a?!0:a instanceof Mr?this.Ky===a.Ky:!1};f.va=function(a){return hc(this.Ky.charCodeAt(a))};
+f.$classData=q({q6:0},!1,"scala.collection.StringView",{q6:1,x4:1,QB:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1,Ao:1,Vb:1,E:1,v:1});function w9(a){this.iw=a}w9.prototype=new b9;w9.prototype.constructor=w9;f=w9.prototype;f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Bb=function(a){return $Y(this,a)};f.ka=function(){return 1};f.b=function(){return!1};f.Q=function(){return 1};f.L=function(a){return ml(nl(),a,this.iw)};
+f.vo=function(a){return this.L(a)?this:new y9(this.iw,a)};f.po=function(a){return ml(nl(),a,this.iw)?ap():this};f.m=function(){Rq();return new g0(this.iw)};f.Ca=function(a){a.n(this.iw)};f.ul=function(a){return!!a.n(this.iw)};f.e=function(){return this.iw};f.Ek=function(a){return this.po(a)};f.bc=function(a){return this.vo(a)};f.$classData=q({l8:0},!1,"scala.collection.immutable.Set$Set1",{l8:1,Fr:1,rm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,fk:1,Cl:1,la:1,v:1,dq:1,xc:1,Rr:1,Cb:1,l:1});
+function y9(a,b){this.Zt=a;this.jw=b}y9.prototype=new b9;y9.prototype.constructor=y9;f=y9.prototype;f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Bb=function(a){return $Y(this,a)};f.ka=function(){return 2};f.b=function(){return!1};f.Q=function(){return 2};f.L=function(a){return ml(nl(),a,this.Zt)||ml(nl(),a,this.jw)};f.vo=function(a){return this.L(a)?this:new z9(this.Zt,this.jw,a)};
+f.po=function(a){return ml(nl(),a,this.Zt)?new w9(this.jw):ml(nl(),a,this.jw)?new w9(this.Zt):this};f.m=function(){return new z5(this)};f.Ca=function(a){a.n(this.Zt);a.n(this.jw)};f.ul=function(a){return!!a.n(this.Zt)&&!!a.n(this.jw)};f.e=function(){return this.Zt};f.Ek=function(a){return this.po(a)};f.bc=function(a){return this.vo(a)};f.$classData=q({m8:0},!1,"scala.collection.immutable.Set$Set2",{m8:1,Fr:1,rm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,fk:1,Cl:1,la:1,v:1,dq:1,xc:1,Rr:1,Cb:1,l:1});
+function z9(a,b,c){this.Qr=a;this.$t=b;this.au=c}z9.prototype=new b9;z9.prototype.constructor=z9;f=z9.prototype;f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Bb=function(a){return $Y(this,a)};f.ka=function(){return 3};f.b=function(){return!1};f.Q=function(){return 3};f.L=function(a){return ml(nl(),a,this.Qr)||ml(nl(),a,this.$t)||ml(nl(),a,this.au)};f.vo=function(a){return this.L(a)?this:new A9(this.Qr,this.$t,this.au,a)};
+f.po=function(a){return ml(nl(),a,this.Qr)?new y9(this.$t,this.au):ml(nl(),a,this.$t)?new y9(this.Qr,this.au):ml(nl(),a,this.au)?new y9(this.Qr,this.$t):this};f.m=function(){return new A5(this)};f.Ca=function(a){a.n(this.Qr);a.n(this.$t);a.n(this.au)};f.ul=function(a){return!!a.n(this.Qr)&&!!a.n(this.$t)&&!!a.n(this.au)};f.e=function(){return this.Qr};f.Ek=function(a){return this.po(a)};f.bc=function(a){return this.vo(a)};
+f.$classData=q({o8:0},!1,"scala.collection.immutable.Set$Set3",{o8:1,Fr:1,rm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,fk:1,Cl:1,la:1,v:1,dq:1,xc:1,Rr:1,Cb:1,l:1});function A9(a,b,c,d){this.Ho=a;this.eq=b;this.fq=c;this.gq=d}A9.prototype=new b9;A9.prototype.constructor=A9;f=A9.prototype;f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Bb=function(a){return $Y(this,a)};f.ka=function(){return 4};f.b=function(){return!1};f.Q=function(){return 4};
+f.L=function(a){return ml(nl(),a,this.Ho)||ml(nl(),a,this.eq)||ml(nl(),a,this.fq)||ml(nl(),a,this.gq)};f.vo=function(a){return this.L(a)?this:B9(B9(B9(B9(B9(dV().Fo,this.Ho),this.eq),this.fq),this.gq),a)};f.po=function(a){return ml(nl(),a,this.Ho)?new z9(this.eq,this.fq,this.gq):ml(nl(),a,this.eq)?new z9(this.Ho,this.fq,this.gq):ml(nl(),a,this.fq)?new z9(this.Ho,this.eq,this.gq):ml(nl(),a,this.gq)?new z9(this.Ho,this.eq,this.fq):this};f.m=function(){return new B5(this)};
+function Gfa(a,b){switch(b){case 0:return a.Ho;case 1:return a.eq;case 2:return a.fq;case 3:return a.gq;default:throw new w(b);}}f.Ca=function(a){a.n(this.Ho);a.n(this.eq);a.n(this.fq);a.n(this.gq)};f.ul=function(a){return!!a.n(this.Ho)&&!!a.n(this.eq)&&!!a.n(this.fq)&&!!a.n(this.gq)};f.e=function(){return this.Ho};f.Ek=function(a){return this.po(a)};f.bc=function(a){return this.vo(a)};
+f.$classData=q({q8:0},!1,"scala.collection.immutable.Set$Set4",{q8:1,Fr:1,rm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,fk:1,Cl:1,la:1,v:1,dq:1,xc:1,Rr:1,Cb:1,l:1});function C9(){}C9.prototype=new z8;C9.prototype.constructor=C9;function D9(){}D9.prototype=C9.prototype;C9.prototype.ia=function(){var a=this.ti();a.zc(this);return a.Kb()};function l9(a,b,c){this.My=null;this.Tv=this.cC=0;this.Gy=null;this.KG=0;this.Il=c;r0(this,a,b)}l9.prototype=new c9;l9.prototype.constructor=l9;f=l9.prototype;
+f.m=function(){return new E5(this,this.Il)};f.Sd=function(){return new F5(this,this.Il)};f.Qh=function(a){return new k9(a,this,this.Il)};f.Lh=function(a){return new l9(this,a,this.Il)};f.Jh=function(a){return new m9(this,a,this.Il)};f.Oh=function(a){return new n9(this,a,this.Il)};f.Ph=function(a){return new n9(this,a,this.Il)};f.Ja=function(a){return new n9(this,a,this.Il)};f.Kh=function(a){return new m9(this,a,this.Il)};f.Bb=function(a){return new m9(this,a,this.Il)};
+f.Mh=function(a){return new l9(this,a,this.Il)};f.Jc=function(a){return new l9(this,a,this.Il)};f.Rh=function(a){return new k9(a,this,this.Il)};f.cc=function(a){return new k9(a,this,this.Il)};f.$classData=q({A9:0},!1,"scala.collection.mutable.CheckedIndexedSeqView$Drop",{A9:1,AR:1,rL:1,UG:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1,Ao:1,Vb:1,UL:1});function m9(a,b,c){this.Ly=null;this.bC=this.aC=0;this.JG=null;this.Fy=0;this.Hl=c;X8(this,a,b)}m9.prototype=new d9;
+m9.prototype.constructor=m9;f=m9.prototype;f.m=function(){return new E5(this,this.Hl)};f.Sd=function(){return new F5(this,this.Hl)};f.Qh=function(a){return new k9(a,this,this.Hl)};f.Lh=function(a){return new l9(this,a,this.Hl)};f.Jh=function(a){return new m9(this,a,this.Hl)};f.Oh=function(a){return new n9(this,a,this.Hl)};f.Ph=function(a){return new n9(this,a,this.Hl)};f.Ja=function(a){return new n9(this,a,this.Hl)};f.Kh=function(a){return new m9(this,a,this.Hl)};
+f.Bb=function(a){return new m9(this,a,this.Hl)};f.Mh=function(a){return new l9(this,a,this.Hl)};f.Jc=function(a){return new l9(this,a,this.Hl)};f.Rh=function(a){return new k9(a,this,this.Hl)};f.cc=function(a){return new k9(a,this,this.Hl)};f.$classData=q({B9:0},!1,"scala.collection.mutable.CheckedIndexedSeqView$DropRight",{B9:1,BR:1,sL:1,VG:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1,Ao:1,Vb:1,UL:1});function n9(a,b,c){this.LG=this.VB=this.dC=this.Uv=null;this.Jl=c;u0(this,a,b)}
+n9.prototype=new e9;n9.prototype.constructor=n9;f=n9.prototype;f.m=function(){return new E5(this,this.Jl)};f.Sd=function(){return new F5(this,this.Jl)};f.Qh=function(a){return new k9(a,this,this.Jl)};f.Lh=function(a){return new l9(this,a,this.Jl)};f.Jh=function(a){return new m9(this,a,this.Jl)};f.Oh=function(a){return new n9(this,a,this.Jl)};f.Ph=function(a){return new n9(this,a,this.Jl)};f.Ja=function(a){return new n9(this,a,this.Jl)};f.Kh=function(a){return new m9(this,a,this.Jl)};
+f.Bb=function(a){return new m9(this,a,this.Jl)};f.Mh=function(a){return new l9(this,a,this.Jl)};f.Jc=function(a){return new l9(this,a,this.Jl)};f.Rh=function(a){return new k9(a,this,this.Jl)};f.cc=function(a){return new k9(a,this,this.Jl)};f.$classData=q({C9:0},!1,"scala.collection.mutable.CheckedIndexedSeqView$Map",{C9:1,ER:1,tL:1,WG:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1,Ao:1,Vb:1,UL:1});function k9(a,b,c){this.WB=this.MG=this.Ny=this.eC=null;this.Kl=c;o0(this,a,b)}
+k9.prototype=new f9;k9.prototype.constructor=k9;f=k9.prototype;f.m=function(){return new E5(this,this.Kl)};f.Sd=function(){return new F5(this,this.Kl)};f.Qh=function(a){return new k9(a,this,this.Kl)};f.Lh=function(a){return new l9(this,a,this.Kl)};f.Jh=function(a){return new m9(this,a,this.Kl)};f.Oh=function(a){return new n9(this,a,this.Kl)};f.Ph=function(a){return new n9(this,a,this.Kl)};f.Ja=function(a){return new n9(this,a,this.Kl)};f.Kh=function(a){return new m9(this,a,this.Kl)};
+f.Bb=function(a){return new m9(this,a,this.Kl)};f.Mh=function(a){return new l9(this,a,this.Kl)};f.Jc=function(a){return new l9(this,a,this.Kl)};f.Rh=function(a){return new k9(a,this,this.Kl)};f.cc=function(a){return new k9(a,this,this.Kl)};f.$classData=q({D9:0},!1,"scala.collection.mutable.CheckedIndexedSeqView$Prepended",{D9:1,FR:1,uL:1,hS:1,Td:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,jd:1,l:1,Li:1,kb:1,Ao:1,Vb:1,UL:1});
+function Fm(a){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.Dh=null;this.uu=a;C8(this)}Fm.prototype=new U8;Fm.prototype.constructor=Fm;f=Fm.prototype;f.H=function(){return"DecLit"};f.G=function(){return 1};f.I=function(a){return 0===a?this.uu:$K(W(),a)};f.D=function(a){return a instanceof Fm};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){if(this===a)return!0;if(a instanceof Fm){var b=this.uu;a=a.uu;return null===b?null===a:b.i(a)}return!1};f.$classData=q({EU:0},!1,"mlscript.DecLit",{EU:1,EH:1,CE:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,tz:1,DE:1,yj:1,nf:1,FH:1,E:1,v:1,l:1});function Em(a){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.Dh=null;this.rq=a;C8(this)}Em.prototype=new U8;Em.prototype.constructor=Em;f=Em.prototype;f.H=function(){return"IntLit"};f.G=function(){return 1};
+f.I=function(a){return 0===a?this.rq:$K(W(),a)};f.D=function(a){return a instanceof Em};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){if(this===a)return!0;if(a instanceof Em){var b=this.rq;a=a.rq;return null===b?null===a:b.i(a)}return!1};f.$classData=q({gV:0},!1,"mlscript.IntLit",{gV:1,EH:1,CE:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,tz:1,DE:1,yj:1,nf:1,FH:1,E:1,v:1,l:1});
+function Dm(a){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.Dh=null;this.Lu=a;C8(this)}Dm.prototype=new U8;Dm.prototype.constructor=Dm;f=Dm.prototype;f.H=function(){return"StrLit"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Lu:$K(W(),a)};f.D=function(a){return a instanceof Dm};f.B=function(){return AL(this)};f.u=function(){return VK(this)};f.i=function(a){return this===a?!0:a instanceof Dm?this.Lu===a.Lu:!1};
+f.$classData=q({mY:0},!1,"mlscript.StrLit",{mY:1,EH:1,CE:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,tz:1,DE:1,yj:1,nf:1,FH:1,E:1,v:1,l:1});function Gm(a){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.Dh=null;this.Xq=a;C8(this)}Gm.prototype=new U8;Gm.prototype.constructor=Gm;f=Gm.prototype;f.H=function(){return"UnitLit"};f.G=function(){return 1};f.I=function(a){return 0===a?this.Xq:$K(W(),a)};f.D=function(a){return a instanceof Gm};
+f.B=function(){var a=lb("UnitLit");a=W().C(-889275714,a);var b=this.Xq?1231:1237;a=W().C(a,b);return W().Ma(a,1)};f.u=function(){return VK(this)};f.i=function(a){return this===a?!0:a instanceof Gm?this.Xq===a.Xq:!1};f.$classData=q({b_:0},!1,"mlscript.UnitLit",{b_:1,EH:1,CE:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,tz:1,DE:1,yj:1,nf:1,FH:1,E:1,v:1,l:1});
+function vl(a){this.zd=this.yd=this.nd=this.oc=null;this.Bd=this.Cd=0;this.Dd=this.Ad=null;this.gc=0;this.kt=this.Dh=null;this.x=a;C8(this);this.kt=t().d}vl.prototype=new D8;vl.prototype.constructor=vl;f=vl.prototype;f.Zr=function(){return this};f.Ua=function(){return this.x};f.H=function(){return"Var"};f.G=function(){return 1};f.I=function(a){return 0===a?this.x:$K(W(),a)};f.D=function(a){return a instanceof vl};f.B=function(){return AL(this)};f.u=function(){return VK(this)};
+f.i=function(a){return this===a?!0:a instanceof vl?this.x===a.x:!1};f.$classData=q({e_:0},!1,"mlscript.Var",{e_:1,CE:1,Oe:1,g:1,ce:1,ud:1,md:1,xd:1,Ta:1,Od:1,Pe:1,tz:1,DE:1,yj:1,nf:1,Uaa:1,IW:1,E:1,v:1,l:1});function E9(){}E9.prototype=new q9;E9.prototype.constructor=E9;f=E9.prototype;f.ka=function(){return 0};f.Q=function(){return 0};f.b=function(){return!0};f.AJ=function(a){throw AH("key not found: "+a);};f.L=function(){return!1};f.U=function(){return R()};f.Se=function(a,b){return Es(b)};f.m=function(){return Rq().Pa};
+f.tj=function(){return Rq().Pa};f.ie=function(){return Rq().Pa};f.am=function(a){return jV(a)?a:A3(this,a)};f.xj=function(){return this};f.Em=function(a,b){return new F9(a,b)};f.n=function(a){this.AJ(a)};f.$classData=q({v7:0},!1,"scala.collection.immutable.Map$EmptyMap$",{v7:1,Rt:1,qm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Mk:1,ek:1,za:1,la:1,um:1,v:1,Pr:1,xc:1,Xt:1,l:1});var G9;function nf(){G9||(G9=new E9);return G9}function S8(a,b,c){a.Qi=b;a.An=c;return a}function T8(){this.An=this.Qi=null}
+T8.prototype=new q9;T8.prototype.constructor=T8;function H9(){}f=H9.prototype=T8.prototype;f.U=function(a){return this.Qi.U(a)};f.IF=function(a){return this.An.n(a)};f.Ub=function(){return this.Qi.Ub()};f.m=function(){return this.Qi.m()};f.b=function(){return this.Qi.b()};f.vj=function(){return this.Qi.vj()};f.gQ=function(a){return S8(new T8,this.Qi.am(a),this.An)};f.iR=function(a){return S8(new T8,this.Qi.xj(a),this.An)};f.sT=function(a,b){return S8(new T8,this.Qi.Em(a,b),this.An)};
+f.IJ=function(a){return S8(new T8,this.Qi.vj().Ib(a),this.An)};f.vc=function(a){return this.IJ(a)};f.Gk=function(a){return this.IJ(a)};f.Em=function(a,b){return this.sT(a,b)};f.xj=function(a){return this.iR(a)};f.am=function(a){return this.gQ(a)};f.$classData=q({tS:0},!1,"scala.collection.immutable.Map$WithDefault",{tS:1,Rt:1,qm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Mk:1,ek:1,za:1,la:1,um:1,v:1,Pr:1,xc:1,Xt:1,l:1});function r9(a,b){if(null===b)throw null;a.wm=b;return a}function s9(){this.wm=null}
+s9.prototype=new b9;s9.prototype.constructor=s9;function I9(){}f=I9.prototype=s9.prototype;f.m=function(){return this.wm.tj()};f.L=function(a){return this.wm.L(a)};f.ka=function(){return this.wm.ka()};f.Q=function(){return this.wm.Q()};f.b=function(){return this.wm.b()};f.vo=function(a){if(this.wm.L(a))return this;var b=ap();return J0(b,this).bc(a)};f.po=function(a){if(this.wm.L(a)){var b=ap();return J0(b,this).Ek(a)}return this};f.Ek=function(a){return this.po(a)};f.bc=function(a){return this.vo(a)};
+f.$classData=q({vS:0},!1,"scala.collection.immutable.MapOps$ImmutableKeySet",{vS:1,Fr:1,rm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,fk:1,Cl:1,la:1,v:1,dq:1,xc:1,Rr:1,UB:1,sg:1,l:1});function J9(a){this.wm=null;r9(this,a)}J9.prototype=new I9;J9.prototype.constructor=J9;f=J9.prototype;f.vo=function(a){var b=My(W(),a),c=$G(bH(),b);a=iU(this.wm.dc,a,null,b,c,0,!1);return a===this.wm.dc?this:(new TU(a)).Ht()};f.po=function(a){a=K9(this.wm,a);return a===this.wm?this:a.Ht()};f.Ek=function(a){return this.po(a)};
+f.bc=function(a){return this.vo(a)};f.$classData=q({X6:0},!1,"scala.collection.immutable.HashMap$HashKeySet",{X6:1,vS:1,Fr:1,rm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,fk:1,Cl:1,la:1,v:1,dq:1,xc:1,Rr:1,UB:1,sg:1,l:1});function F9(a,b){this.El=a;this.Xp=b}F9.prototype=new q9;F9.prototype.constructor=F9;f=F9.prototype;f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Fk=function(a){return this.ov(a,!1)};f.Bb=function(a){return $Y(this,a)};f.ka=function(){return 1};f.Q=function(){return 1};
+f.b=function(){return!1};f.n=function(a){if(ml(nl(),a,this.El))return this.Xp;throw AH("key not found: "+a);};f.L=function(a){return ml(nl(),a,this.El)};f.U=function(a){return ml(nl(),a,this.El)?new L(this.Xp):R()};f.Se=function(a,b){return ml(nl(),a,this.El)?this.Xp:Es(b)};f.m=function(){Rq();var a=G(new H,this.El,this.Xp);return new g0(a)};f.tj=function(){Rq();return new g0(this.El)};f.ie=function(){Rq();return new g0(this.Xp)};
+f.Dm=function(a,b){return ml(nl(),a,this.El)?new F9(this.El,b):new L9(this.El,this.Xp,a,b)};f.Gv=function(a){return ml(nl(),a,this.El)?nf():this};f.Ca=function(a){a.n(G(new H,this.El,this.Xp))};f.ul=function(a){return!!a.n(G(new H,this.El,this.Xp))};f.ov=function(a,b){return!!a.n(G(new H,this.El,this.Xp))!==b?this:nf()};f.B=function(){var a=0,b=0,c=1,d=pS(BL(),this.El,this.Xp);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=BL().Cr;d=BL().C(d,a);d=BL().C(d,b);d=BL().Pp(d,c);return BL().Ma(d,1)};f.xj=function(a){return this.Gv(a)};
+f.Em=function(a,b){return this.Dm(a,b)};f.$classData=q({w7:0},!1,"scala.collection.immutable.Map$Map1",{w7:1,Rt:1,qm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Mk:1,ek:1,za:1,la:1,um:1,v:1,Pr:1,xc:1,Xt:1,Cb:1,l:1});function L9(a,b,c,d){this.hk=a;this.xn=b;this.ik=c;this.yn=d}L9.prototype=new q9;L9.prototype.constructor=L9;f=L9.prototype;f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Fk=function(a){return this.ov(a,!1)};f.Bb=function(a){return $Y(this,a)};f.ka=function(){return 2};
+f.Q=function(){return 2};f.b=function(){return!1};f.n=function(a){if(ml(nl(),a,this.hk))return this.xn;if(ml(nl(),a,this.ik))return this.yn;throw AH("key not found: "+a);};f.L=function(a){return ml(nl(),a,this.hk)||ml(nl(),a,this.ik)};f.U=function(a){return ml(nl(),a,this.hk)?new L(this.xn):ml(nl(),a,this.ik)?new L(this.yn):R()};f.Se=function(a,b){return ml(nl(),a,this.hk)?this.xn:ml(nl(),a,this.ik)?this.yn:Es(b)};f.m=function(){return new U3(this)};f.tj=function(){return new V3(this)};f.ie=function(){return new W3(this)};
+f.Dm=function(a,b){return ml(nl(),a,this.hk)?new L9(this.hk,b,this.ik,this.yn):ml(nl(),a,this.ik)?new L9(this.hk,this.xn,this.ik,b):new M9(this.hk,this.xn,this.ik,this.yn,a,b)};f.Gv=function(a){return ml(nl(),a,this.hk)?new F9(this.ik,this.yn):ml(nl(),a,this.ik)?new F9(this.hk,this.xn):this};f.Ca=function(a){a.n(G(new H,this.hk,this.xn));a.n(G(new H,this.ik,this.yn))};f.ul=function(a){return!!a.n(G(new H,this.hk,this.xn))&&!!a.n(G(new H,this.ik,this.yn))};
+f.ov=function(a,b){var c=null,d=null,e=0;!!a.n(G(new H,this.hk,this.xn))!==b&&(c=this.hk,d=this.xn,e=1+e|0);!!a.n(G(new H,this.ik,this.yn))!==b&&(0===e&&(c=this.ik,d=this.yn),e=1+e|0);a=e;switch(a){case 0:return nf();case 1:return new F9(c,d);case 2:return this;default:throw new w(a);}};
+f.B=function(){var a=0,b=0,c=1,d=pS(BL(),this.hk,this.xn);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=pS(BL(),this.ik,this.yn);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=BL().Cr;d=BL().C(d,a);d=BL().C(d,b);d=BL().Pp(d,c);return BL().Ma(d,2)};f.xj=function(a){return this.Gv(a)};f.Em=function(a,b){return this.Dm(a,b)};f.$classData=q({x7:0},!1,"scala.collection.immutable.Map$Map2",{x7:1,Rt:1,qm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Mk:1,ek:1,za:1,la:1,um:1,v:1,Pr:1,xc:1,Xt:1,Cb:1,l:1});
+function M9(a,b,c,d,e,g){this.dj=a;this.Fl=b;this.Mi=c;this.Qk=d;this.Ni=e;this.Rk=g}M9.prototype=new q9;M9.prototype.constructor=M9;f=M9.prototype;f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Fk=function(a){return this.ov(a,!1)};f.Bb=function(a){return $Y(this,a)};f.ka=function(){return 3};f.Q=function(){return 3};f.b=function(){return!1};
+f.n=function(a){if(ml(nl(),a,this.dj))return this.Fl;if(ml(nl(),a,this.Mi))return this.Qk;if(ml(nl(),a,this.Ni))return this.Rk;throw AH("key not found: "+a);};f.L=function(a){return ml(nl(),a,this.dj)||ml(nl(),a,this.Mi)||ml(nl(),a,this.Ni)};f.U=function(a){return ml(nl(),a,this.dj)?new L(this.Fl):ml(nl(),a,this.Mi)?new L(this.Qk):ml(nl(),a,this.Ni)?new L(this.Rk):R()};f.Se=function(a,b){return ml(nl(),a,this.dj)?this.Fl:ml(nl(),a,this.Mi)?this.Qk:ml(nl(),a,this.Ni)?this.Rk:Es(b)};f.m=function(){return new X3(this)};
+f.tj=function(){return new Y3(this)};f.ie=function(){return new Z3(this)};f.Dm=function(a,b){return ml(nl(),a,this.dj)?new M9(this.dj,b,this.Mi,this.Qk,this.Ni,this.Rk):ml(nl(),a,this.Mi)?new M9(this.dj,this.Fl,this.Mi,b,this.Ni,this.Rk):ml(nl(),a,this.Ni)?new M9(this.dj,this.Fl,this.Mi,this.Qk,this.Ni,b):new N9(this.dj,this.Fl,this.Mi,this.Qk,this.Ni,this.Rk,a,b)};
+f.Gv=function(a){return ml(nl(),a,this.dj)?new L9(this.Mi,this.Qk,this.Ni,this.Rk):ml(nl(),a,this.Mi)?new L9(this.dj,this.Fl,this.Ni,this.Rk):ml(nl(),a,this.Ni)?new L9(this.dj,this.Fl,this.Mi,this.Qk):this};f.Ca=function(a){a.n(G(new H,this.dj,this.Fl));a.n(G(new H,this.Mi,this.Qk));a.n(G(new H,this.Ni,this.Rk))};f.ul=function(a){return!!a.n(G(new H,this.dj,this.Fl))&&!!a.n(G(new H,this.Mi,this.Qk))&&!!a.n(G(new H,this.Ni,this.Rk))};
+f.ov=function(a,b){var c=null,d=null,e=null,g=null,h=0;!!a.n(G(new H,this.dj,this.Fl))!==b&&(c=this.dj,e=this.Fl,h=1+h|0);!!a.n(G(new H,this.Mi,this.Qk))!==b&&(0===h?(c=this.Mi,e=this.Qk):(d=this.Mi,g=this.Qk),h=1+h|0);!!a.n(G(new H,this.Ni,this.Rk))!==b&&(0===h?(c=this.Ni,e=this.Rk):1===h&&(d=this.Ni,g=this.Rk),h=1+h|0);a=h;switch(a){case 0:return nf();case 1:return new F9(c,e);case 2:return new L9(c,e,d,g);case 3:return this;default:throw new w(a);}};
+f.B=function(){var a=0,b=0,c=1,d=pS(BL(),this.dj,this.Fl);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=pS(BL(),this.Mi,this.Qk);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=pS(BL(),this.Ni,this.Rk);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=BL().Cr;d=BL().C(d,a);d=BL().C(d,b);d=BL().Pp(d,c);return BL().Ma(d,3)};f.xj=function(a){return this.Gv(a)};f.Em=function(a,b){return this.Dm(a,b)};
+f.$classData=q({B7:0},!1,"scala.collection.immutable.Map$Map3",{B7:1,Rt:1,qm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Mk:1,ek:1,za:1,la:1,um:1,v:1,Pr:1,xc:1,Xt:1,Cb:1,l:1});function N9(a,b,c,d,e,g,h,k){this.Th=a;this.Aj=b;this.xh=c;this.ej=d;this.Wg=e;this.Oi=g;this.Xg=h;this.Pi=k}N9.prototype=new q9;N9.prototype.constructor=N9;f=N9.prototype;f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Fk=function(a){return this.ov(a,!1)};f.Bb=function(a){return $Y(this,a)};f.ka=function(){return 4};
+f.Q=function(){return 4};f.b=function(){return!1};f.n=function(a){if(ml(nl(),a,this.Th))return this.Aj;if(ml(nl(),a,this.xh))return this.ej;if(ml(nl(),a,this.Wg))return this.Oi;if(ml(nl(),a,this.Xg))return this.Pi;throw AH("key not found: "+a);};f.L=function(a){return ml(nl(),a,this.Th)||ml(nl(),a,this.xh)||ml(nl(),a,this.Wg)||ml(nl(),a,this.Xg)};
+f.U=function(a){return ml(nl(),a,this.Th)?new L(this.Aj):ml(nl(),a,this.xh)?new L(this.ej):ml(nl(),a,this.Wg)?new L(this.Oi):ml(nl(),a,this.Xg)?new L(this.Pi):R()};f.Se=function(a,b){return ml(nl(),a,this.Th)?this.Aj:ml(nl(),a,this.xh)?this.ej:ml(nl(),a,this.Wg)?this.Oi:ml(nl(),a,this.Xg)?this.Pi:Es(b)};f.m=function(){return new $3(this)};f.tj=function(){return new a4(this)};f.ie=function(){return new b4(this)};
+f.Dm=function(a,b){return ml(nl(),a,this.Th)?new N9(this.Th,b,this.xh,this.ej,this.Wg,this.Oi,this.Xg,this.Pi):ml(nl(),a,this.xh)?new N9(this.Th,this.Aj,this.xh,b,this.Wg,this.Oi,this.Xg,this.Pi):ml(nl(),a,this.Wg)?new N9(this.Th,this.Aj,this.xh,this.ej,this.Wg,b,this.Xg,this.Pi):ml(nl(),a,this.Xg)?new N9(this.Th,this.Aj,this.xh,this.ej,this.Wg,this.Oi,this.Xg,b):m7(m7(m7(m7(m7(Ez().Mr,this.Th,this.Aj),this.xh,this.ej),this.Wg,this.Oi),this.Xg,this.Pi),a,b)};
+f.Gv=function(a){return ml(nl(),a,this.Th)?new M9(this.xh,this.ej,this.Wg,this.Oi,this.Xg,this.Pi):ml(nl(),a,this.xh)?new M9(this.Th,this.Aj,this.Wg,this.Oi,this.Xg,this.Pi):ml(nl(),a,this.Wg)?new M9(this.Th,this.Aj,this.xh,this.ej,this.Xg,this.Pi):ml(nl(),a,this.Xg)?new M9(this.Th,this.Aj,this.xh,this.ej,this.Wg,this.Oi):this};f.Ca=function(a){a.n(G(new H,this.Th,this.Aj));a.n(G(new H,this.xh,this.ej));a.n(G(new H,this.Wg,this.Oi));a.n(G(new H,this.Xg,this.Pi))};
+f.ul=function(a){return!!a.n(G(new H,this.Th,this.Aj))&&!!a.n(G(new H,this.xh,this.ej))&&!!a.n(G(new H,this.Wg,this.Oi))&&!!a.n(G(new H,this.Xg,this.Pi))};
+f.ov=function(a,b){var c=null,d=null,e=null,g=null,h=null,k=null,l=0;!!a.n(G(new H,this.Th,this.Aj))!==b&&(c=this.Th,g=this.Aj,l=1+l|0);!!a.n(G(new H,this.xh,this.ej))!==b&&(0===l?(c=this.xh,g=this.ej):(d=this.xh,h=this.ej),l=1+l|0);!!a.n(G(new H,this.Wg,this.Oi))!==b&&(0===l?(c=this.Wg,g=this.Oi):1===l?(d=this.Wg,h=this.Oi):(e=this.Wg,k=this.Oi),l=1+l|0);!!a.n(G(new H,this.Xg,this.Pi))!==b&&(0===l?(c=this.Xg,g=this.Pi):1===l?(d=this.Xg,h=this.Pi):2===l&&(e=this.Xg,k=this.Pi),l=1+l|0);a=l;switch(a){case 0:return nf();
+case 1:return new F9(c,g);case 2:return new L9(c,g,d,h);case 3:return new M9(c,g,d,h,e,k);case 4:return this;default:throw new w(a);}};f.B=function(){var a=0,b=0,c=1,d=pS(BL(),this.Th,this.Aj);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=pS(BL(),this.xh,this.ej);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=pS(BL(),this.Wg,this.Oi);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=pS(BL(),this.Xg,this.Pi);a=a+d|0;b^=d;c=Math.imul(c,1|d);d=BL().Cr;d=BL().C(d,a);d=BL().C(d,b);d=BL().Pp(d,c);return BL().Ma(d,4)};f.xj=function(a){return this.Gv(a)};
+f.Em=function(a,b){return this.Dm(a,b)};f.$classData=q({F7:0},!1,"scala.collection.immutable.Map$Map4",{F7:1,Rt:1,qm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Mk:1,ek:1,za:1,la:1,um:1,v:1,Pr:1,xc:1,Xt:1,Cb:1,l:1});function O9(a,b){return new P9(a,new y(()=>b))}function Xba(a){return Q9(new R9,a,new y(()=>0))}function S9(a,b){return a.Id===b?a:new ZU(b)}
+function T9(a,b){b=b.m();for(var c=a.Id;b.s();){var d=b.t(),e=My(W(),d),g=$G(bH(),e);c=DU(c,d,e,g,0);if(c!==a.Id){if(0===c.Fb)return dV().Fo;for(;b.s();)if(a=b.t(),d=My(W(),a),e=$G(bH(),d),EU(c,a,d,e),0===c.Fb)return dV().Fo;return new ZU(c)}}return a}function ZU(a){this.Id=a}ZU.prototype=new b9;ZU.prototype.constructor=ZU;f=ZU.prototype;f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Ub=function(){return dV()};f.Q=function(){return this.Id.Fb};f.ka=function(){return this.Id.Fb};
+f.b=function(){return 0===this.Id.Fb};f.m=function(){return this.b()?Rq().Pa:new y1(this.Id)};f.L=function(a){var b=My(W(),a),c=$G(bH(),b);return this.Id.yt(a,b,c,0)};function B9(a,b){var c=My(W(),b),d=$G(bH(),c);b=yU(a.Id,b,c,d,0);return S9(a,b)}
+function Gga(a,b){if(b instanceof ZU){if(a.b())return b;var c=JU(a.Id,b.Id,0);return c===b.Id?b:S9(a,c)}if(b instanceof KV)for(b=new E4(b),c=a.Id;b.s();){var d=b.t(),e=G4(d.nk),g=$G(bH(),e);c=yU(c,d.xm,e,g,0);if(c!==a.Id){for(a=lI(HH(),kI(HH(),g,0));b.s();)d=b.t(),e=G4(d.nk),g=$G(bH(),e),a=BU(c,d.xm,e,g,0,a);return new ZU(c)}}else for(b=b.m(),c=a.Id;b.s();)if(d=b.t(),e=My(W(),d),g=$G(bH(),e),c=yU(c,d,e,g,0),c!==a.Id){for(a=lI(HH(),kI(HH(),g,0));b.s();)d=b.t(),e=My(W(),d),g=$G(bH(),e),a=BU(c,d,e,g,
+0,a);return new ZU(c)}return a}f.e=function(){return this.m().t()};f.Mc=function(){return(new z1(this.Id)).t()};f.Ca=function(a){this.Id.Ca(a)};f.i=function(a){if(a instanceof ZU){if(this===a)return!0;var b=this.Id;a=a.Id;return null===b?null===a:b.i(a)}return kY(this,a)};f.Ih=function(){return"HashSet"};f.B=function(){var a=new x1(this.Id);return CL(BL(),a,BL().PB)};
+function Hga(a,b){if(a.b())return a;if(b instanceof ZU)return b.b()?a:0===HU(a.Id,b.Id,0).Fb?dV().Fo:S9(a,HU(a.Id,b.Id,0));if(b instanceof KV){for(var c=new E4(b),d=a.Id;c.s();){var e=c.t(),g=G4(e.nk),h=$G(bH(),g);d=DU(d,e.xm,g,h,0);if(d!==a.Id){if(0===d.Fb)return dV().Fo;for(;c.s();)if(a=c.t(),e=G4(a.nk),g=$G(bH(),e),EU(d,a.xm,e,g),0===d.Fb)return dV().Fo;return new ZU(d)}}return a}c=b.Q();return 0===c?a:c<=a.Id.Fb?T9(a,b):U9(a,new y(k=>b.L(k)),!0)}
+function Iga(a,b){return b&&b.$classData&&b.$classData.rb.fk?Hga(a,b):b instanceof tZ&&b.K()>a.Id.Fb?U9(a,new y(c=>ha(c)?!pB(b,c|0):!0),!1):T9(a,b)}function U9(a,b,c){b=GU(a.Id,b,c);return b===a.Id?a:0===b.Fb?dV().Fo:new ZU(b)}f.Bb=function(a){return $Y(this,a)};f.Jc=function(a){return zT(this,a)};f.wy=function(a){return Iga(this,a)};f.Ce=function(a){return Gga(this,a)};f.Ek=function(a){var b=My(W(),a),c=$G(bH(),b);a=DU(this.Id,a,b,c,0);return S9(this,a)};f.bc=function(a){return B9(this,a)};
+f.$classData=q({a7:0},!1,"scala.collection.immutable.HashSet",{a7:1,Fr:1,rm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,fk:1,Cl:1,la:1,v:1,dq:1,xc:1,Rr:1,F8:1,i6:1,Cb:1,sg:1,l:1});function V9(){}V9.prototype=new u8;V9.prototype.constructor=V9;function W9(){}W9.prototype=V9.prototype;V9.prototype.oh=function(a){return EB(this,a)};V9.prototype.he=function(){};V9.prototype.zc=function(a){return lR(this,a)};V9.prototype.Kb=function(){return this};
+var Kga=function Jga(a,b){FK();return new gZ(new U(()=>{if(a.b())return hV();FK();var d=b.n(hZ(a).e()),e=Jga(hZ(a).Lf(),b);return new eV(d,e)}))},Mga=function Lga(a,b){if(b.b())return hV();FK();var d=hZ(a).e();FK();return new eV(d,new gZ(new U(()=>Lga(hZ(a).Lf(),hZ(b).Lf()))))};
+function X9(a,b,c,d,e){b.ja=""+b.ja+c;if(!a.Dl)b.ja+="\x3cnot computed\x3e";else if(!a.b()){c=hZ(a).e();b.ja=""+b.ja+c;c=a;var g=hZ(a).Lf();if(c!==g&&(!g.Dl||hZ(c)!==hZ(g))&&(c=g,g.Dl&&!g.b()))for(g=hZ(g).Lf();c!==g&&g.Dl&&!g.b()&&hZ(c)!==hZ(g);){b.ja=""+b.ja+d;var h=hZ(c).e();b.ja=""+b.ja+h;c=hZ(c).Lf();g=hZ(g).Lf();g.Dl&&!g.b()&&(g=hZ(g).Lf())}if(!g.Dl||g.b()){for(;c!==g;)b.ja=""+b.ja+d,a=hZ(c).e(),b.ja=""+b.ja+a,c=hZ(c).Lf();c.Dl||(b.ja=""+b.ja+d,b.ja+="\x3cnot computed\x3e")}else{h=a;for(a=0;;){var k=
+h,l=g;if(k!==l&&hZ(k)!==hZ(l))h=hZ(h).Lf(),g=hZ(g).Lf(),a=1+a|0;else break}h=c;k=g;(h===k||hZ(h)===hZ(k))&&0<a&&(b.ja=""+b.ja+d,a=hZ(c).e(),b.ja=""+b.ja+a,c=hZ(c).Lf());for(;;)if(a=c,h=g,a!==h&&hZ(a)!==hZ(h))b.ja=""+b.ja+d,a=hZ(c).e(),b.ja=""+b.ja+a,c=hZ(c).Lf();else break;b.ja=""+b.ja+d;b.ja+="\x3ccycle\x3e"}}b.ja=""+b.ja+e;return b}function gZ(a){this.oS=null;this.IL=!1;this.nS=a;this.JL=this.Dl=!1}gZ.prototype=new i9;gZ.prototype.constructor=gZ;f=gZ.prototype;f.Oc=function(){return"LinearSeq"};
+f.Jg=function(){return this.b()?R():new L(this.e())};f.K=function(){for(var a=this,b=0;!a.b();)b=1+b|0,a=a.f();return b};f.Mc=function(){if(this.b())throw AH("LinearSeq.last");for(var a=this,b=this.f();!b.b();)a=b,b=b.f();return a.e()};f.ab=function(a){if(0>a)a=1;else a:for(var b=this,c=0;;){if(c===a){a=b.b()?0:1;break a}if(b.b()){a=-1;break a}c=1+c|0;b=b.f()}return a};f.NJ=function(a){return F0(this,a)};f.va=function(a){return eB(this,a)};
+f.qo=function(a){a:{for(var b=this;!b.b();){if(a.n(b.e())){a=!0;break a}b=b.f()}a=!1}return a};f.L=function(a){a:{for(var b=this;!b.b();){if(ml(nl(),b.e(),a)){a=!0;break a}b=b.f()}a=!1}return a};f.Lt=function(a){return G0(this,a)};f.wo=function(a,b){return H0(this,a,b)};function hZ(a){if(!a.IL&&!a.IL){if(a.JL)throw iL("self-referential LazyList or a derivation thereof has no more elements");a.JL=!0;try{var b=Es(a.nS)}finally{a.JL=!1}a.Dl=!0;a.nS=null;a.oS=b;a.IL=!0}return a.oS}
+f.b=function(){return hZ(this)===hV()};f.Q=function(){return this.Dl&&this.b()?0:-1};f.e=function(){return hZ(this).e()};function fZ(a){var b=a,c=a;for(b.b()||(b=hZ(b).Lf());c!==b&&!b.b();){b=hZ(b).Lf();if(b.b())break;b=hZ(b).Lf();if(b===c)break;c=hZ(c).Lf()}return a}f.m=function(){return this.Dl&&this.b()?Rq().Pa:new X0(this)};f.Ca=function(a){for(var b=this;!b.b();)a.n(hZ(b).e()),b=hZ(b).Lf()};f.De=function(a,b){for(var c=this;;){if(c.b())return a;var d=hZ(c).Lf();a=b.ba(a,hZ(c).e());c=d}};
+f.Ih=function(){return"LazyList"};function Y9(a,b){FK();return new gZ(new U(()=>{if(a.b()){var c=Es(b);return c instanceof gZ?hZ(c):0===c.Q()?hV():iZ(FK(),c.m())}FK();c=hZ(a).e();var d=Y9(hZ(a).Lf(),b);return new eV(c,d)}))}function Nga(a,b){return a.Dl&&a.b()?aU(FK(),b):Y9(a,new U(()=>b))}f.th=function(a){if(this.b())throw nv("empty.reduceLeft");for(var b=hZ(this).e(),c=hZ(this).Lf();!c.b();)b=a.ba(b,hZ(c).e()),c=hZ(c).Lf();return b};
+function Oga(a,b){FK();return new gZ(new U(()=>{FK();return new eV(b,a)}))}function Z9(a,b){return a.Dl&&a.b()?FK().Ry:Kga(a,b)}f.Gb=function(a){return G(new H,Z9(this,new y(b=>a.n(b).h())),Z9(this,new y(b=>a.n(b).j())))};function Pga(a,b){if(0>=b)return a;if(a.Dl&&a.b())return FK().Ry;FK();return new gZ(new U(()=>{for(var c=a,d=b;0<d&&!c.b();)d=-1+d|0,c=hZ(c).Lf();return Mga(a,c)}))}f.Gh=function(a,b,c,d){fZ(this);X9(this,a.yf,b,c,d);return a};
+f.u=function(){return X9(this,Uq(new Sq,"LazyList"),"(",", ",")").ja};f.n=function(a){return eB(this,a|0)};f.Lc=function(a){return F0(this,a|0)};f.Bb=function(a){return Pga(this,a)};f.Jc=function(a){return 0>=a?this:this.Dl&&this.b()?FK().Ry:Zea(FK(),this,a)};f.Ja=function(a){return Z9(this,a)};f.cc=function(a){return Oga(this,a)};f.gn=function(a){return Nga(this,a)};f.f=function(){return hZ(this).Lf()};f.Ub=function(){return FK()};
+f.$classData=q({h7:0},!1,"scala.collection.immutable.LazyList",{h7:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,KL:1,CG:1,TR:1,pS:1,l:1});function Jr(a){this.Xh=a}Jr.prototype=new i9;Jr.prototype.constructor=Jr;f=Jr.prototype;f.D=function(a){return t9(this,a)};f.Oc=function(){return"IndexedSeq"};f.m=function(){return Kr(new Lr,new Mr(this.Xh))};f.Sd=function(){return uZ(new vZ,new Mr(this.Xh))};f.mf=function(a,b){return l0(this,a,b)};f.ad=function(){return new Z8(this)};
+f.cc=function(a){return n0(this,a)};f.Jc=function(a){return q0(this,a)};f.Bb=function(a){return this.vc(X8(new Y8,this,a))};f.Ja=function(a){return t0(this,a)};f.e=function(){return hc(this.Xh.charCodeAt(0))};f.Mc=function(){return SF(this)};f.ab=function(a){var b=this.Xh.length;return b===a?0:b<a?-1:1};f.Q=function(){return this.Xh.length};f.ti=function(){return DZ().Eb()};f.K=function(){return this.Xh.length};f.u=function(){return this.Xh};
+f.Gc=function(a,b,c){if(a instanceof Ic){var d=this.Xh.length;c=c<d?c:d;d=a.a.length-b|0;c=c<d?c:d;c=0<c?c:0;L2(this.Xh,c,a,b);return c}return NB(this,a,b,c)};f.Lt=function(a){return a instanceof Jr?this.Xh===a.Xh:u9(this,a)};f.Ih=function(){return"WrappedString"};f.dy=function(){return 2147483647};f.i=function(a){return a instanceof Jr?this.Xh===a.Xh:i3(this,a)};f.Ub=function(){return xe()};f.gn=function(a){return a instanceof Jr?new Jr(this.Xh+a.Xh):IT(this,a)};f.vc=function(a){return CZ(DZ(),a)};
+f.Gk=function(a){return CZ(DZ(),a)};f.n=function(a){return hc(this.Xh.charCodeAt(a|0))};f.va=function(a){return hc(this.Xh.charCodeAt(a))};f.$classData=q({$8:0},!1,"scala.collection.immutable.WrappedString",{$8:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,l:1});function J(a,b){a.bM=b;return a}function K(){this.bM=null}K.prototype=new p;K.prototype.constructor=K;f=K.prototype;f.Ii=function(a){return ky(this,a)};
+f.Zh=function(a){return qw(this,a)};f.cc=function(a){return F3(this,a)};f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Bb=function(a){return $Y(this,a)};f.D=function(a){return t9(this,a)};f.Lt=function(a){return u9(this,a)};f.dy=function(){SH||(SH=new RH);return SH.lS};f.m=function(){var a=new QX(this);return Kr(new Lr,a)};f.Sd=function(){var a=new QX(this);return uZ(new vZ,a)};f.mf=function(a,b){return l0(this,a,b)};f.ad=function(){return new Z8(this)};
+f.Jc=function(a){return q0(this,a)};f.e=function(){return this.va(0)};f.Mc=function(){return SF(this)};f.ab=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.FC=function(){return this};f.i=function(a){return i3(this,a)};f.B=function(){return qS(this)};f.u=function(){return w0(this)};f.tl=function(a){return G3(this,a)};f.ka=function(){return this.K()};f.wo=function(a,b){var c=new QX(this);c=Kr(new Lr,c);return LT(c,a,b)};f.L=function(a){return QU(this,a)};
+f.$k=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.b=function(){return SY(this)};f.Ob=function(a,b){return GQ(this,a,b)};f.ti=function(){return J2().Eb()};f.f=function(){return CT(this)};f.Ca=function(a){cH(this,a)};f.qo=function(a){return ey(this,a)};f.De=function(a,b){return mB(this,a,b)};f.th=function(a){return eH(this,a)};f.Gc=function(a,b,c){return NB(this,a,b,c)};f.aj=function(a){return gH(this,a)};f.$i=function(a){return hH(this,a)};f.Gh=function(a,b,c,d){return iH(this,a,b,c,d)};
+f.ha=function(){Od();return Pd(u(),this)};f.Ti=function(){return pp(qp(),this)};f.Bj=function(a){return kB(this,a)};f.Ik=function(){return J2()};f.K=function(){return this.bM.length|0};f.va=function(a){return this.bM[a]};f.Ih=function(){return"WrappedVarArgs"};f.vc=function(a){return H2(J2(),a)};f.Lc=function(a){a|=0;return 0<=a&&0<this.ab(a)};f.n=function(a){return this.va(a|0)};f.Ub=function(){return J2()};
+f.$classData=q({V$:0},!1,"scala.scalajs.runtime.WrappedVarArgs",{V$:1,g:1,Sh:1,Mg:1,xc:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Yg:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,l:1});function TU(a){this.dc=a}TU.prototype=new q9;TU.prototype.constructor=TU;f=TU.prototype;f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Fk=function(a){a=sU(this.dc,a,!1);return a===this.dc?this:0===a.kd?Ez().Mr:new TU(a)};f.vj=function(){return Ez()};f.Q=function(){return this.dc.kd};f.ka=function(){return this.dc.kd};
+f.b=function(){return 0===this.dc.kd};f.Ht=function(){return 0===this.dc.kd?ap():new J9(this)};f.m=function(){return this.b()?Rq().Pa:new k1(this.dc)};f.tj=function(){return this.b()?Rq().Pa:new i1(this.dc)};f.ie=function(){return this.b()?Rq().Pa:new m1(this.dc)};f.Sd=function(){return this.b()?Rq().Pa:new l1(this.dc)};f.L=function(a){var b=My(W(),a),c=$G(bH(),b);return this.dc.DF(a,b,c,0)};f.n=function(a){var b=My(W(),a),c=$G(bH(),b);return this.dc.BJ(a,b,c,0)};
+f.U=function(a){var b=My(W(),a),c=$G(bH(),b);return this.dc.KF(a,b,c,0)};f.Se=function(a,b){var c=My(W(),a),d=$G(bH(),c);return this.dc.KJ(a,c,d,0,b)};function m7(a,b,c){var d=My(W(),b);b=iU(a.dc,b,c,d,$G(bH(),d),0,!0);return b===a.dc?a:new TU(b)}function K9(a,b){var c=My(W(),b);b=nU(a.dc,b,c,$G(bH(),c),0);return b===a.dc?a:new TU(b)}
+function Qga(a,b){if(b instanceof TU){if(a.b()||qU(a.dc,b.dc,0)===b.dc)return b;b=qU(a.dc,b.dc,0);return b===a.dc?a:new TU(b)}if(b instanceof DV){b=S0(b);for(var c=a.dc;b.s();){var d=b.t(),e=d.mk;e^=e>>>16|0;var g=$G(bH(),e);c=iU(c,d.Wk,d.Ah,e,g,0,!0);if(c!==a.dc){for(a=lI(HH(),kI(HH(),g,0));b.s();)d=b.t(),e=d.mk,e^=e>>>16|0,a=lU(c,d.Wk,d.Ah,e,$G(bH(),e),0,a);return new TU(c)}}return a}if(jV(b)){if(b.b())return a;c=new aZ(a);b.og(c);b=c.Zv;return b===a.dc?a:new TU(b)}b=b.m();return b.s()?(c=new aZ(a),
+cH(b,c),b=c.Zv,b===a.dc?a:new TU(b)):a}f.Ca=function(a){this.dc.Ca(a)};f.og=function(a){this.dc.og(a)};f.i=function(a){if(a instanceof TU){if(this===a)return!0;var b=this.dc;a=a.dc;return null===b?null===a:b.i(a)}return v8(this,a)};f.B=function(){if(this.b())return BL().mG;var a=new j1(this.dc);return CL(BL(),a,BL().Cr)};f.Ih=function(){return"HashMap"};
+function Rga(a,b){if(a.b())return a;if(b instanceof ZU){if(b.b())return a;b=new YQ(b.Id);for(var c=a.dc;0<c.kd&&b.s();){var d=b.wh.Jb(b.Nc),e=b.wh.ed(b.Nc),g=$G(bH(),d);c=nU(c,e,d,g,0);b.Nc=1+b.Nc|0}b=c;return b===a.dc?a:0>=b.kd?Ez().Mr:new TU(b)}if(b instanceof KV){if(b.b())return a;b=new E4(b);for(d=a.dc;b.s();)if(c=b.t(),e=G4(c.nk),g=$G(bH(),e),d=nU(d,c.xm,e,g,0),0===d.kd)return Ez().Mr;b=d;return b===a.dc?a:new TU(b)}b=b.m();for(d=a.dc;b.s();)if(c=b.t(),e=My(W(),c),g=$G(bH(),e),d=nU(d,c,e,g,0),
+0===d.kd)return Ez().Mr;b=d;return b===a.dc?a:new TU(b)}f.Jc=function(a){return zT(this,a)};f.Bb=function(a){return $Y(this,a)};f.dG=function(a){return Rga(this,a)};f.Mc=function(){return this.Sd().t()};f.e=function(){return this.m().t()};f.am=function(a){return Qga(this,a)};f.xj=function(a){return K9(this,a)};f.IC=function(a,b){return y5(this,a,b)};f.Em=function(a,b){return m7(this,a,b)};f.zr=function(){return this.Ht()};
+f.$classData=q({V6:0},!1,"scala.collection.immutable.HashMap",{V6:1,Rt:1,qm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Mk:1,ek:1,za:1,la:1,um:1,v:1,Pr:1,xc:1,Xt:1,E8:1,RG:1,Cb:1,sg:1,l:1});function $9(){}$9.prototype=new D9;$9.prototype.constructor=$9;function c$(){}c$.prototype=$9.prototype;$9.prototype.zc=function(a){return lR(this,a)};function d$(){}d$.prototype=new F8;d$.prototype.constructor=d$;function e$(){}f=e$.prototype=d$.prototype;f.vj=function(){return Xu()};
+f.kM=function(a){return Q9(new R9,this,a)};f.bj=function(a,b){this.U(a);this.bh(a,b)};f.bh=function(a,b){a=G(new H,a,b);this.$(a)};f.ou=function(a,b){return P8(this,a,b)};f.Hk=function(a,b){return pX(this,a,b)};f.JB=function(a){this.U(a).b()||this.Bm(a)};f.he=function(){};f.zc=function(a){return lR(this,a)};f.Ub=function(){return rO()};f.Kb=function(){return this};function f$(a){this.Jo=null;if(null===a)throw null;this.Jo=a}f$.prototype=new b9;f$.prototype.constructor=f$;f=f$.prototype;f.se=function(){return this.Jo.se()};
+f.m=function(){return new I0(this.Jo)};f.L=function(a){return!this.Jo.U(a).b()};f.ka=function(){return this.Jo.ka()};f.Q=function(){return this.Jo.Q()};f.b=function(){return this.Jo.b()};f.Oc=function(){return"SortedSet"};f.i=function(a){return O8(this,a)};f.aj=function(a){return u5(this,a)};f.$i=function(a){return v5(this,a)};f.vc=function(a){return oA(uv(),a,this.Jo.se())};f.Gk=function(a){return oA(uv(),a,this.Jo.se())};f.Ek=function(a){return oA(uv(),this,this.Jo.se()).Ek(a)};
+f.bc=function(a){return oA(uv(),this,this.Jo.se()).bc(a)};f.$classData=q({B8:0},!1,"scala.collection.immutable.SortedMapOps$ImmutableKeySortedSet",{B8:1,Fr:1,rm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,fk:1,Cl:1,la:1,v:1,dq:1,xc:1,Rr:1,OL:1,PG:1,fS:1,Iy:1,eS:1,D8:1,UB:1,c6:1});
+function g$(a,b,c){var d=c&(-1+a.zg.a.length|0),e=a.zg.a[d];if(null===e)a.zg.a[d]=new cK(b,c,null);else{for(var g=null,h=e;null!==h&&h.nk<=c;){if(h.nk===c&&ml(nl(),b,h.xm))return!1;g=h;h=h.yg}null===g?a.zg.a[d]=new cK(b,c,e):g.yg=new cK(b,c,g.yg)}a.ym=1+a.ym|0;return!0}
+function h$(a,b){var c=a.zg.a.length;a.YL=Eb(b*a.hH);if(0===a.ym)a.zg=new (md(dK).Ia)(b);else{var d=a.zg;a.zg=zj(Pj(),d,b);d=new cK(null,0,null);for(var e=new cK(null,0,null);c<b;){for(var g=0;g<c;){var h=a.zg.a[g];if(null!==h){d.yg=null;e.yg=null;for(var k=d,l=e,m=h;null!==m;){var n=m.yg;0===(m.nk&c)?k=k.yg=m:l=l.yg=m;m=n}k.yg=null;h!==d.yg&&(a.zg.a[g]=d.yg);null!==e.yg&&(a.zg.a[g+c|0]=e.yg,l.yg=null)}g=1+g|0}c<<=1}}}
+function i$(a){a=-1+a|0;a=4<a?a:4;a=(-2147483648>>Math.clz32(a)&a)<<1;return 1073741824>a?a:1073741824}function JV(a,b,c){a.hH=c;a.zg=new (md(dK).Ia)(i$(b));a.YL=Eb(a.zg.a.length*a.hH);a.ym=0;return a}function Vn(){var a=new KV;JV(a,16,.75);return a}function KV(){this.hH=0;this.zg=null;this.ym=this.YL=0}KV.prototype=new W9;KV.prototype.constructor=KV;f=KV.prototype;f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Bb=function(a){return $Y(this,a)};f.ka=function(){return this.ym};
+function G4(a){return a^(a>>>16|0)}f.L=function(a){var b=G4(My(W(),a)),c=this.zg.a[b&(-1+this.zg.a.length|0)];if(null===c)a=null;else a:for(;;){if(b===c.nk&&ml(nl(),a,c.xm)){a=c;break a}if(null===c.yg||c.nk>b){a=null;break a}c=c.yg}return null!==a};f.he=function(a){a=i$(Eb((1+a|0)/this.hH));a>this.zg.a.length&&h$(this,a)};f.oh=function(a){(1+this.ym|0)>=this.YL&&h$(this,this.zg.a.length<<1);return g$(this,a,G4(My(W(),a)))};
+function IV(a,b){a.he(b.Q());if(b instanceof ZU)return b.Id.FJ(new fn((d,e)=>{g$(a,d,G4(e|0))})),a;if(b instanceof KV){for(b=new E4(b);b.s();){var c=b.t();g$(a,c.xm,c.nk)}return a}return lR(a,b)}f.IB=function(a){a:{var b=G4(My(W(),a)),c=b&(-1+this.zg.a.length|0),d=this.zg.a[c];if(null!==d)if(d.nk===b&&ml(nl(),d.xm,a))this.zg.a[c]=d.yg,this.ym=-1+this.ym|0;else for(c=d,d=d.yg;null!==d&&d.nk<=b;){if(d.nk===b&&ml(nl(),d.xm,a)){c.yg=d.yg;this.ym=-1+this.ym|0;break a}c=d;d=d.yg}}};f.m=function(){return new D4(this)};
+f.mg=function(){var a=this.zg;yj(Pj(),a,null);this.ym=0};f.Ub=function(){return pz()};f.Q=function(){return this.ym};f.b=function(){return 0===this.ym};f.Ca=function(a){for(var b=this.zg.a.length,c=0;c<b;){var d=this.zg.a[c];null!==d&&d.Ca(a);c=1+c|0}};f.Ih=function(){return"HashSet"};f.B=function(){var a=new D4(this);a=a.s()?new F4(this):a;return CL(BL(),a,BL().PB)};f.Bm=function(a){this.IB(a)};f.$=function(a){this.oh(a);return this};f.zc=function(a){return IV(this,a)};
+f.$classData=q({N9:0},!1,"scala.collection.mutable.HashSet",{N9:1,b9:1,rm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,fk:1,Cl:1,la:1,v:1,z$:1,ah:1,B$:1,$g:1,Ff:1,xg:1,xf:1,wf:1,Jn:1,Cb:1,l:1});function j$(a){var b=a.Sk,c=b>>31,d=a.Vd;a=d>>31;d=b-d|0;return new ma(d,(-2147483648^d)>(-2147483648^b)?-1+(c-a|0)|0:c-a|0)}function k$(a){var b=j$(a),c=a.lc,d=c>>31;a=xa();b=Ri(a,b.W,b.Y,c,d);a=a.Qc;return 0===b&&0===a}
+function l$(a,b,c,d){a.Vd=b;a.Sk=c;a.lc=d;a.fj=b>c&&0<d||b<c&&0>d||b===c&&!a.kn();if(0===d)throw Kj("step cannot be 0.");if(a.fj)b=0;else{b=j$(a);var e=a.lc,g=e>>31;var h=xa();b=$h(h,b.W,b.Y,e,g);h=h.Qc;g=a.kn()||!k$(a)?1:0;e=g>>31;g=b+g|0;h=new ma(g,(-2147483648^g)<(-2147483648^b)?1+(h+e|0)|0:h+e|0);b=h.W;h=h.Y;b=(0===h?-1<(-2147483648^b):0<h)?-1:b}a.Tk=b;switch(d){case 1:c=a.kn()?c:-1+c|0;break;case -1:c=a.kn()?c:1+c|0;break;default:b=j$(a),h=d>>31,b=Ri(xa(),b.W,b.Y,d,h),c=0!==b?c-b|0:a.kn()?c:
+c-d|0}a.gw=c}function tZ(){this.lc=this.Sk=this.Vd=0;this.fj=!1;this.gw=this.Tk=0}tZ.prototype=new i9;tZ.prototype.constructor=tZ;function m$(){}f=m$.prototype=tZ.prototype;f.Ii=function(a){return ky(this,a)};f.cc=function(a){return F3(this,a)};f.gn=function(a){return G3(this,a)};f.Gb=function(a){return XY(this,a)};f.D=function(a){return t9(this,a)};f.Ik=function(){return xe()};f.Oc=function(){return"IndexedSeq"};f.Sd=function(){var a=new QX(this);return uZ(new vZ,a)};
+f.mf=function(a,b){return l0(this,a,b)};f.ad=function(){return new Z8(this)};f.ab=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.m=function(){return new hE(this.Vd,this.lc,this.gw,this.fj)};f.b=function(){return this.fj};f.K=function(){return 0>this.Tk?$Q(bR(),this.Vd,this.Sk,this.lc,this.kn()):this.Tk};function n$(a){if(a.fj)throw a=aR("last"),a instanceof $d?a.mu:a;return a.gw}function o$(a){if(a.fj)throw a=aR("head"),a instanceof $d?a.mu:a;return a.Vd}
+function p$(a){0>a.Tk&&$Q(bR(),a.Vd,a.Sk,a.lc,a.kn())}f.Ca=function(a){if(!this.fj)for(var b=this.Vd;;){a.n(b);if(b===this.gw)break;b=b+this.lc|0}};f.Lt=function(a){if(a instanceof tZ){var b=this.K();switch(b){case 0:return a.fj;case 1:return 1===a.K()&&this.Vd===a.Vd;default:return a.K()===b&&this.Vd===a.Vd&&this.lc===a.lc}}else return u9(this,a)};
+function Sga(a,b){if(0>=b)return a;if(0<=a.Tk)return b=a.Tk-b|0,0>=b||a.fj?(b=a.Vd,a=new oB(b,b,a.lc)):a=b>=a.Tk&&0<=a.Tk?a:new q$(a.Vd,a.Vd+Math.imul(a.lc,-1+b|0)|0,a.lc),a;b=n$(a)-Math.imul(a.lc,b)|0;return 0<a.lc&&b<a.Vd||0>a.lc&&b>a.Vd?(b=a.Vd,new oB(b,b,a.lc)):new q$(a.Vd,b,a.lc)}function pB(a,b){return!(b===a.Sk&&!a.kn())&&(0<a.lc?!(b<a.Vd||b>a.Sk)&&(1===a.lc||0===Bb(b-a.Vd|0,a.lc)):!(b<a.Sk||b>a.Vd)&&(-1===a.lc||0===Bb(b-a.Vd|0,a.lc)))}f.L=function(a){return ha(a)?pB(this,a|0):QU(this,a)};
+f.dy=function(){return 2147483647};f.i=function(a){if(a instanceof tZ){if(this.fj)return a.fj;if(a.fj||this.Vd!==a.Vd)return!1;var b=n$(this);return b===n$(a)&&(this.Vd===b||this.lc===a.lc)}return i3(this,a)};f.B=function(){if(2<=this.K()){var a=BL(),b=this.lc,c=this.gw;return yL(a.C(a.C(a.C(a.rg,this.Vd),b),c))}return qS(this)};f.u=function(){var a=this.kn()?"to":"until",b=1===this.lc?"":" by "+this.lc;return(this.fj?"empty ":k$(this)?"":"inexact ")+"Range "+this.Vd+" "+a+" "+this.Sk+b};f.Ih=function(){return"Range"};
+f.wt=function(a){p$(this);if(0>a||a>=this.Tk)throw aL(new bL,a+" is out of bounds (min 0, max "+(-1+this.Tk|0)+")");return this.Vd+Math.imul(this.lc,a)|0};f.Ub=function(){return xe()};f.Zh=function(a){return a===Fq()?0<this.lc?this:this.fj?this:new q$(n$(this),this.Vd,-this.lc|0):qw(this,a)};f.$i=function(a){if(a===Fq())a=0<this.lc?n$(this):o$(this);else{var b=Fq();a=a===b.NB?0<this.lc?o$(this):n$(this):hH(this,a)|0}return a};
+f.aj=function(a){if(a===Fq())a=0<this.lc?o$(this):n$(this);else{var b=Fq();a=a===b.NB?0<this.lc?n$(this):o$(this):gH(this,a)|0}return a};f.Bb=function(a){return Sga(this,a)};f.Jc=function(a){if(0>=a||this.fj)a=this;else if(a>=this.Tk&&0<=this.Tk)a=this.Sk,a=new oB(a,a,this.lc);else{a=this.Vd+Math.imul(this.lc,a)|0;var b=this.Sk,c=this.lc;a=this.kn()?new q$(a,b,c):new oB(a,b,c)}return a};f.n=function(a){return this.wt(a|0)};f.va=function(a){return this.wt(a)};
+f.Ja=function(a){p$(this);return YY(this,a)};f.f=function(){if(this.fj){var a=aR("tail");throw a instanceof $d?a.mu:a;}1===this.Tk?(a=this.Sk,a=new oB(a,a,this.lc)):a=this.kn()?new q$(this.Vd+this.lc|0,this.Sk,this.lc):new oB(this.Vd+this.lc|0,this.Sk,this.lc);return a};f.e=function(){return o$(this)};f.Mc=function(){return n$(this)};function MB(){this.yC=this.ku=this.zC=null;this.zC=new VV(this)}MB.prototype=new W9;MB.prototype.constructor=MB;f=MB.prototype;f.Gb=function(a){return XY(this,a)};
+f.Ja=function(a){return YY(this,a)};f.Bb=function(a){return $Y(this,a)};f.Ub=function(){return KB()};f.Mc=function(){if(0<this.ka())return this.yC.zw;throw AH("Cannot call .last on empty LinkedHashSet");};f.e=function(){if(0<this.ka())return this.ku.zw;throw AH("Cannot call .head on empty LinkedHashSet");};f.ka=function(){return this.zC.nu()};f.Q=function(){return this.ka()};f.b=function(){return 0===this.ka()};f.L=function(a){return null!==mR(this.zC,a)};
+function FB(a,b){sR(a.zC,b,null);return a}f.IB=function(a){a=tR(this.zC,a);null!==a&&(null===a.yw?this.ku=a.Mo:a.yw.Mo=a.Mo,null===a.Mo?this.yC=a.yw:a.Mo.yw=a.yw,a.yw=null,a.Mo=null)};f.m=function(){return new qA(this)};f.Ca=function(a){for(var b=this.ku;null!==b;)a.n(b.zw),b=b.Mo};f.Oc=function(){return"LinkedHashSet"};f.Bm=function(a){this.IB(a)};f.$=function(a){return FB(this,a)};
+f.$classData=q({g$:0},!1,"scala.collection.mutable.LinkedHashSet",{g$:1,b9:1,rm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,fk:1,Cl:1,la:1,v:1,z$:1,ah:1,B$:1,$g:1,Ff:1,xg:1,xf:1,wf:1,Jn:1,Cb:1,sg:1,l:1});function Q9(a,b,c){a.Yh=b;a.Aw=c;return a}function R9(){this.Aw=this.Yh=null}R9.prototype=new e$;R9.prototype.constructor=R9;function r$(){}f=r$.prototype=R9.prototype;f.IF=function(a){return this.Aw.n(a)};f.m=function(){return this.Yh.m()};f.b=function(){return this.Yh.b()};f.Q=function(){return this.Yh.Q()};
+f.vj=function(){return this.Yh.vj()};f.mg=function(){this.Yh.mg()};f.U=function(a){return this.Yh.U(a)};f.oT=function(a){this.Yh.Bm(a)};f.cQ=function(a){this.Yh.$(a);return this};f.hQ=function(a){return this.Yh.am(a).kM(this.Aw)};f.JJ=function(a){return Q9(new R9,this.Yh.vj().Ib(a),this.Aw)};f.vc=function(a){return this.JJ(a)};f.Gk=function(a){return this.JJ(a)};f.am=function(a){return this.hQ(a)};f.$=function(a){return this.cQ(a)};f.Bm=function(a){this.oT(a)};
+f.$classData=q({fT:0},!1,"scala.collection.mutable.Map$WithDefault",{fT:1,eH:1,qm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Mk:1,ek:1,za:1,la:1,um:1,v:1,CC:1,ah:1,mH:1,$g:1,Ff:1,xg:1,xf:1,wf:1,Jn:1,l:1});
+function Tga(a,b){if(SY(a))return b;if(SY(b))return a;var c=a.fg()instanceof zc;if(c!==b.fg()instanceof zc)return null;if(c){c=a.fg();b=b.fg();a=wG(xG(),c)+wG(xG(),b)|0;a=new zc(a);var d=wG(xG(),c);c.wa(0,a,0,d);c=wG(xG(),c);d=wG(xG(),b);b.wa(0,a,c,d);return KQ(JQ(),a)}c=a.fg();b=b.fg();d=wG(xG(),c)+wG(xG(),b)|0;a=a.ag().si(d);d=wG(xG(),c);c.wa(0,a,0,d);c=wG(xG(),c);d=wG(xG(),b);b.wa(0,a,c,d);return KQ(JQ(),a)}
+function s$(a,b){var c=b.Q();if(0===c)return a;IB();var d=[];0<=c&&wG(xG(),a.fg());a=a.fg();c=wG(xG(),a);for(var e=0;e<c;){var g=XG(xG(),a,e);d.push(null===g?null:g);e=1+e|0}for(b=b.m();b.s();)a=b.t(),d.push(null===a?null:a);return KQ(JQ(),new zc(d))}function K3(){}K3.prototype=new i9;K3.prototype.constructor=K3;function t$(){}f=t$.prototype=K3.prototype;f.Gk=function(a){JQ();var b=this.ag();return J3(a,b)};f.ti=function(){var a=JQ(),b=this.ag();return a.sy(b)};f.Ii=function(a){return ky(this,a)};
+f.Gb=function(a){return XY(this,a)};f.D=function(a){return t9(this,a)};f.Lt=function(a){return u9(this,a)};f.Oc=function(){return"IndexedSeq"};f.Sd=function(){var a=new QX(this);return uZ(new vZ,a)};f.ad=function(){return new Z8(this)};f.e=function(){return this.va(0)};f.Mc=function(){return SF(this)};f.ab=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.Ik=function(){return JQ().FL};
+f.qg=function(a){JQ();var b=this.fg();IB();var c=1+wG(xG(),b)|0;c=new zc(c);c.a[0]=a;VG(SG(),b,0,c,1,wG(xG(),b));return KQ(0,c)};f.De=function(a,b){for(var c=this.fg(),d=0;d<wG(xG(),c);){var e=XG(xG(),c,d);a=b.ba(a,e);d=1+d|0}return a};f.mf=function(a,b){for(var c=this.fg(),d=wG(xG(),c);0<d;){d=-1+d|0;var e=XG(xG(),c,d);a=b.ba(e,a)}return a};f.Ih=function(){return"ArraySeq"};f.Gc=function(a,b,c){var d=this.K(),e=wG(xG(),a);c=c<d?c:d;e=e-b|0;e=c<e?c:e;e=0<e?e:0;0<e&&VG(SG(),this.fg(),0,a,b,e);return e};
+f.dy=function(){return 2147483647};f.Ai=function(a){if(1>=wG(xG(),this.fg()))return this;SG();var b=this.fg(),c=this.K();TG();Zf(da(jd),bg(ca(b)))?b=Yf(da(jd))?UG(b,c):Cj(Pj(),b,c,da(md(jd))):(c=new zc(c),VG(SG(),b,0,c,0,wG(xG(),b)),b=c);hj(Pj(),b,a);return new Fu(b)};f.vc=function(a){JQ();var b=this.ag();return J3(a,b)};f.Zh=function(a){return this.Ai(a)};f.f=function(){JQ();ms();var a=this.fg();if(0===wG(xG(),a))throw nv("tail of empty array");a=ns(ms(),a,1,wG(xG(),a));return KQ(0,a)};
+f.Bb=function(a){if(0>=a)var b=this;else JQ(),ms(),b=this.fg(),a=wG(xG(),b)-(0<a?a:0)|0,b=ns(ms(),b,0,a),b=KQ(0,b);return b};f.Jc=function(a){return 0>=a?this:KQ(JQ(),ls(ms(),this.fg(),a))};f.gn=function(a){if(a instanceof K3){var b=Tga(this,a);a=null===b?s$(this,a):b}else a=s$(this,a);return a};f.cc=function(a){return this.qg(a)};f.Ja=function(a){for(var b=new zc(this.K()),c=0;c<b.a.length;)b.a[c]=a.n(this.va(c)),c=1+c|0;return KQ(JQ(),b)};f.Ub=function(){return JQ().FL};
+function oB(a,b,c){this.lc=this.Sk=this.Vd=0;this.fj=!1;this.gw=this.Tk=0;l$(this,a,b,c)}oB.prototype=new m$;oB.prototype.constructor=oB;oB.prototype.kn=function(){return!1};oB.prototype.$classData=q({Y7:0},!1,"scala.collection.immutable.Range$Exclusive",{Y7:1,W7:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,l:1});function q$(a,b,c){this.lc=this.Sk=this.Vd=0;this.fj=!1;this.gw=this.Tk=0;l$(this,a,b,c)}q$.prototype=new m$;
+q$.prototype.constructor=q$;q$.prototype.kn=function(){return!0};q$.prototype.$classData=q({Z7:0},!1,"scala.collection.immutable.Range$Inclusive",{Z7:1,W7:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,l:1});function P9(a,b){this.An=this.Qi=null;S8(this,a,b)}P9.prototype=new H9;P9.prototype.constructor=P9;f=P9.prototype;f.AB=function(){return new f$(this)};f.Oc=function(){return"SortedMap"};f.i=function(a){return lY(this,a)};
+f.gR=function(a,b){return this.jq().qr(GT(new HT,this,a),b)};f.se=function(){return this.Qi.se()};f.jq=function(){return this.Qi.jq()};function u$(a,b,c){return new P9(a.Qi.Dm(b,c),a.An)}function v$(a,b){return new P9(a.Qi.hy(b),a.An)}function w$(a,b){return new P9(a.Qi.jq().qr(b,a.Qi.se()),a.An)}f.bf=function(a){return v$(this,a)};f.IC=function(a,b){return p8(this,a,b)};f.Pn=function(a){return u$(this,a.h(),a.j())};f.zr=function(){return new f$(this)};f.Ht=function(){return new f$(this)};
+f.jM=function(a){return O9(this,a)};f.vc=function(a){return w$(this,a)};f.Gk=function(a){return w$(this,a)};f.IJ=function(a){return w$(this,a)};f.xj=function(a){return new P9(this.Qi.xj(a),this.An)};f.iR=function(a){return new P9(this.Qi.xj(a),this.An)};f.am=function(a){return v$(this,a)};f.gQ=function(a){return v$(this,a)};f.hy=function(a){return v$(this,a)};f.Em=function(a,b){return u$(this,a,b)};f.Dm=function(a,b){return u$(this,a,b)};f.sT=function(a,b){return u$(this,a,b)};
+f.$classData=q({z8:0},!1,"scala.collection.immutable.SortedMap$WithDefault",{z8:1,tS:1,Rt:1,qm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Mk:1,ek:1,za:1,la:1,um:1,v:1,Pr:1,xc:1,Xt:1,l:1,FS:1,YB:1,zL:1,Iy:1,yL:1,A8:1});function C1(){this.R=null}C1.prototype=new i9;C1.prototype.constructor=C1;function x$(){}f=x$.prototype=C1.prototype;f.Ii=function(a){return ky(this,a)};f.Zh=function(a){return qw(this,a)};f.Gb=function(a){return XY(this,a)};f.D=function(a){return t9(this,a)};
+f.Lt=function(a){return u9(this,a)};f.Oc=function(){return"IndexedSeq"};f.Sd=function(){var a=new QX(this);return uZ(new vZ,a)};f.mf=function(a,b){return l0(this,a,b)};f.ad=function(){return new Z8(this)};f.ab=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.Ik=function(){return GK()};f.K=function(){return this instanceof y$?this.ca:this.R.a.length};f.m=function(){return HJ()===this?GK().IS:new p1(this,this.K(),this.On())};
+function MU(a,b,c){for(var d=0,e=a.R.a.length;d!==e;){if(!!b.n(a.R.a[d])===c){for(var g=0,h=1+d|0;h<e;)!!b.n(a.R.a[h])!==c&&(g|=1<<h),h=1+h|0;e=g;e=d+nI(UH(),e)|0;if(a instanceof y$){h=new NU;for(var k=0;k<d;)PU(h,a.R.a[k]),k=1+k|0;for(k=1+d|0;d!==e;)0!==(1<<k&g)&&(PU(h,a.R.a[k]),d=1+d|0),k=1+k|0;z$(a,new y(((m,n,r)=>v=>!!m.n(v)!==n?PU(r,v):void 0)(b,c,h)));return h.im()}if(0===e)return HJ();h=new zc(e);a.R.wa(0,h,0,d);for(k=1+d|0;d!==e;)0!==(1<<k&g)&&(h.a[d]=a.R.a[k],d=1+d|0),k=1+k|0;return new IJ(h)}d=
+1+d|0}if(a instanceof y$){var l=new NU;lfa(l,a.R);z$(a,new y(m=>!!b.n(m)!==c?PU(l,m):void 0));return l.im()}return a}f.ql=function(a,b){var c=4+this.On()|0;if(0<b&&b<c){var d=new aw(this);if(ZJ(a))a.Ca(new y(e=>{d.rc=d.rc.hn(e)}));else for(a=a.m();a.s();)b=a.t(),d.rc=d.rc.hn(b);return d.rc}if(this.K()<(b>>>5|0)&&a instanceof C1){b=new QX(this);for(b=uZ(new vZ,b);0<b.zj;)a=a.zl(b.t());return a}return OU(F1(new NU,this),a).im()};f.Ih=function(){return"Vector"};
+f.Gc=function(a,b,c){return this.m().Gc(a,b,c)};f.dy=function(){return GK().HS};f.rh=function(a){return aL(new bL,a+" is out of bounds (min 0, max "+(-1+this.K()|0)+")")};f.e=function(){if(0===this.R.a.length)throw AH("empty.head");return this.R.a[0]};f.Mc=function(){if(this instanceof y$){var a=this.Z;if(0===a.a.length)throw AH("empty.tail");return a.a[-1+a.a.length|0]}return this.R.a[-1+this.R.a.length|0]};
+f.Ca=function(a){for(var b=this.On(),c=0;c<b;){var d=JJ(),e=b/2|0,g=c-e|0;VJ(d,-1+((1+e|0)-(0>g?-g|0:g)|0)|0,this.To(c),a);c=1+c|0}};f.Bb=function(a){a=this.K()-(0<a?a:0)|0;return A$(this,0,a)};f.Jc=function(a){var b=this.K();return A$(this,a,b)};f.gn=function(a){var b=a.Q();return 0===b?this:this.ql(a,b)};f.Ub=function(){return GK()};function B$(){}B$.prototype=new D9;B$.prototype.constructor=B$;function C$(){}f=C$.prototype=B$.prototype;f.Ii=function(a){return E3(this,a)};
+f.cc=function(a){return F3(this,a)};f.gn=function(a){return G3(this,a)};f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Bb=function(a){return $Y(this,a)};f.Oc=function(){return"IndexedSeq"};f.Sd=function(){var a=new QX(this);return uZ(new vZ,a)};f.mf=function(a,b){return l0(this,a,b)};f.ad=function(){return new Z8(this)};f.Jc=function(a){return q0(this,a)};f.e=function(){return this.va(0)};f.Mc=function(){return SF(this)};
+f.ab=function(a){var b=this.K();return b===a?0:b<a?-1:1};f.Q=function(){return this.K()};f.Ik=function(){return yQ().TL};function D$(a,b){var c=a.ag().uh(),d=c===da(td);a=[];b.Q();for(b=b.m();b.s();){var e=b.t();a.push(d?Ea(e):null===e?c.qi.jz:e)}yQ();c=c===da(pd)?da(la):c===da(jH)||c===da(kH)?da(jd):c;return p4(0,md(c.qi).iz(a))}f.ti=function(){return yQ().sy(this.ag())};f.Ih=function(){return"ArraySeq"};
+f.Gc=function(a,b,c){var d=this.K(),e=wG(xG(),a);c=c<d?c:d;e=e-b|0;e=c<e?c:e;e=0<e?e:0;0<e&&VG(SG(),this.rl(),0,a,b,e);return e};f.i=function(a){return a instanceof B$&&wG(xG(),this.rl())!==wG(xG(),a.rl())?!1:i3(this,a)};f.Zh=function(a){yQ();ms();return p4(0,Tu(this.rl(),a))};f.ia=function(){return p4(yQ(),KG(xG(),this.rl()))};f.vc=function(a){return D$(this,a)};f.Gk=function(a){return D$(this,a)};f.Ub=function(){return yQ().TL};function S3(a){this.Hr=a}S3.prototype=new t$;
+S3.prototype.constructor=S3;f=S3.prototype;f.K=function(){return this.Hr.a.length};f.B=function(){var a=BL();return EL(a,this.Hr,a.rg)};f.i=function(a){if(a instanceof S3){var b=this.Hr;a=a.Hr;return vj(Pj(),b,a)}return i3(this,a)};f.Ai=function(a){if(1>=this.K())return this;if(a===PG()){a=this.Hr.ia();var b=QG(),c=PG();RG(b,a,a.a.length,c);return new S3(a)}return K3.prototype.Ai.call(this,a)};f.m=function(){return new IG(this.Hr)};
+f.qg=function(a){if("boolean"===typeof a){a=!!a;var b=this.Hr;uL();var c=new Ec(1+b.a.length|0);c.a[0]=a;VG(SG(),b,0,c,1,b.a.length);return new S3(c)}return K3.prototype.qg.call(this,a)};f.fB=function(a){return this.Hr.a[a]};f.cc=function(a){return this.qg(a)};f.Zh=function(a){return this.Ai(a)};f.n=function(a){return this.fB(a|0)};f.va=function(a){return this.fB(a)};f.ag=function(){return uL()};f.fg=function(){return this.Hr};
+f.$classData=q({H6:0},!1,"scala.collection.immutable.ArraySeq$ofBoolean",{H6:1,Gr:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,Dr:1,l:1});function Q3(a){this.Ir=a}Q3.prototype=new t$;Q3.prototype.constructor=Q3;f=Q3.prototype;f.K=function(){return this.Ir.a.length};f.gB=function(a){return this.Ir.a[a]};f.B=function(){var a=BL();return FL(a,this.Ir,a.rg)};
+f.i=function(a){if(a instanceof Q3){var b=this.Ir;a=a.Ir;return uj(Pj(),b,a)}return i3(this,a)};f.Ai=function(a){return 1>=this.K()?this:a===NG()?(a=this.Ir.ia(),fj(Pj(),a),new Q3(a)):K3.prototype.Ai.call(this,a)};f.m=function(){return new GG(this.Ir)};f.qg=function(a){if(Zb(a)){a|=0;var b=this.Ir;sL();var c=new Pc(1+b.a.length|0);c.a[0]=a;VG(SG(),b,0,c,1,b.a.length);return new Q3(c)}return K3.prototype.qg.call(this,a)};f.cc=function(a){return this.qg(a)};f.Zh=function(a){return this.Ai(a)};
+f.n=function(a){return this.gB(a|0)};f.va=function(a){return this.gB(a)};f.ag=function(){return sL()};f.fg=function(){return this.Ir};f.$classData=q({I6:0},!1,"scala.collection.immutable.ArraySeq$ofByte",{I6:1,Gr:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,Dr:1,l:1});function P3(a){this.Vp=a}P3.prototype=new t$;P3.prototype.constructor=P3;f=P3.prototype;f.K=function(){return this.Vp.a.length};f.hB=function(a){return this.Vp.a[a]};
+f.B=function(){var a=BL();return GL(a,this.Vp,a.rg)};f.i=function(a){if(a instanceof P3){var b=this.Vp;a=a.Vp;return tj(Pj(),b,a)}return i3(this,a)};f.Ai=function(a){return 1>=this.K()?this:a===MG()?(a=this.Vp.ia(),dj(Pj(),a),new P3(a)):K3.prototype.Ai.call(this,a)};f.m=function(){return new FG(this.Vp)};f.qg=function(a){if(a instanceof ba){a=Ea(a);var b=this.Vp;Ir();var c=new Ic(1+b.a.length|0);c.a[0]=a;VG(SG(),b,0,c,1,b.a.length);return new P3(c)}return K3.prototype.qg.call(this,a)};
+f.Gh=function(a,b,c,d){return(new AQ(this.Vp)).Gh(a,b,c,d)};f.cc=function(a){return this.qg(a)};f.Zh=function(a){return this.Ai(a)};f.n=function(a){return hc(this.hB(a|0))};f.va=function(a){return hc(this.hB(a))};f.ag=function(){return Ir()};f.fg=function(){return this.Vp};f.$classData=q({J6:0},!1,"scala.collection.immutable.ArraySeq$ofChar",{J6:1,Gr:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,Dr:1,l:1});
+function M3(a){this.St=a}M3.prototype=new t$;M3.prototype.constructor=M3;f=M3.prototype;f.K=function(){return this.St.a.length};f.B=function(){var a=BL();return HL(a,this.St,a.rg)};f.i=function(a){if(a instanceof M3){var b=this.St;a=a.St;return wj(Pj(),b,a)}return i3(this,a)};f.m=function(){return new CG(this.St)};f.qg=function(a){if("number"===typeof a){a=+a;var b=this.St;pL();var c=new ed(1+b.a.length|0);c.a[0]=a;VG(SG(),b,0,c,1,b.a.length);return new M3(c)}return K3.prototype.qg.call(this,a)};
+f.cB=function(a){return this.St.a[a]};f.cc=function(a){return this.qg(a)};f.n=function(a){return this.cB(a|0)};f.va=function(a){return this.cB(a)};f.ag=function(){return pL()};f.fg=function(){return this.St};f.$classData=q({K6:0},!1,"scala.collection.immutable.ArraySeq$ofDouble",{K6:1,Gr:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,Dr:1,l:1});function O3(a){this.Tt=a}O3.prototype=new t$;O3.prototype.constructor=O3;f=O3.prototype;
+f.K=function(){return this.Tt.a.length};f.B=function(){var a=BL();return IL(a,this.Tt,a.rg)};f.i=function(a){if(a instanceof O3){var b=this.Tt;a=a.Tt;return xj(Pj(),b,a)}return i3(this,a)};f.m=function(){return new EG(this.Tt)};f.qg=function(a){if(ja(a)){a=Math.fround(a);var b=this.Tt;rL();var c=new $c(1+b.a.length|0);c.a[0]=a;VG(SG(),b,0,c,1,b.a.length);return new O3(c)}return K3.prototype.qg.call(this,a)};f.dB=function(a){return this.Tt.a[a]};f.cc=function(a){return this.qg(a)};
+f.n=function(a){return this.dB(a|0)};f.va=function(a){return this.dB(a)};f.ag=function(){return rL()};f.fg=function(){return this.Tt};f.$classData=q({L6:0},!1,"scala.collection.immutable.ArraySeq$ofFloat",{L6:1,Gr:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,Dr:1,l:1});function L3(a){this.Jr=a}L3.prototype=new t$;L3.prototype.constructor=L3;f=L3.prototype;f.K=function(){return this.Jr.a.length};
+f.B=function(){var a=BL();return JL(a,this.Jr,a.rg)};f.i=function(a){if(a instanceof L3){var b=this.Jr;a=a.Jr;return qj(Pj(),b,a)}return i3(this,a)};f.Ai=function(a){return 1>=this.K()?this:a===Fq()?(a=this.Jr.ia(),Ti(Pj(),a),new L3(a)):K3.prototype.Ai.call(this,a)};f.m=function(){return new BG(this.Jr)};f.qg=function(a){if(ha(a)){a|=0;var b=this.Jr;rl();var c=new Xc(1+b.a.length|0);c.a[0]=a;VG(SG(),b,0,c,1,b.a.length);return new L3(c)}return K3.prototype.qg.call(this,a)};f.wt=function(a){return this.Jr.a[a]};
+f.cc=function(a){return this.qg(a)};f.Zh=function(a){return this.Ai(a)};f.n=function(a){return this.wt(a|0)};f.va=function(a){return this.wt(a)};f.ag=function(){return rl()};f.fg=function(){return this.Jr};f.$classData=q({M6:0},!1,"scala.collection.immutable.ArraySeq$ofInt",{M6:1,Gr:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,Dr:1,l:1});function N3(a){this.Kr=a}N3.prototype=new t$;N3.prototype.constructor=N3;f=N3.prototype;
+f.K=function(){return this.Kr.a.length};f.B=function(){var a=BL();return KL(a,this.Kr,a.rg)};f.i=function(a){if(a instanceof N3){var b=this.Kr;a=a.Kr;return pj(Pj(),b,a)}return i3(this,a)};f.Ai=function(a){return 1>=this.K()?this:a===LG()?(a=this.Kr.ia(),$i(Pj(),a),new N3(a)):K3.prototype.Ai.call(this,a)};f.m=function(){return new DG(this.Kr)};
+f.qg=function(a){if(a instanceof ma){var b=Za(a);a=b.W;b=b.Y;var c=this.Kr;qL();var d=new Zc(1+c.a.length|0);d.a[0]=Za(new ma(a,b));VG(SG(),c,0,d,1,c.a.length);return new N3(d)}return K3.prototype.qg.call(this,a)};f.eB=function(a){return this.Kr.a[a]};f.cc=function(a){return this.qg(a)};f.Zh=function(a){return this.Ai(a)};f.n=function(a){return this.eB(a|0)};f.va=function(a){return this.eB(a)};f.ag=function(){return qL()};f.fg=function(){return this.Kr};
+f.$classData=q({N6:0},!1,"scala.collection.immutable.ArraySeq$ofLong",{N6:1,Gr:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,Dr:1,l:1});function Fu(a){this.vn=a}Fu.prototype=new t$;Fu.prototype.constructor=Fu;f=Fu.prototype;f.ag=function(){return yG(zG(),bg(ca(this.vn)))};f.K=function(){return this.vn.a.length};f.va=function(a){return this.vn.a[a]};f.B=function(){var a=BL();return DL(a,this.vn,a.rg)};
+f.i=function(a){return a instanceof Fu?sQ(SG(),this.vn,a.vn):i3(this,a)};function E$(a,b){if(1>=a.vn.a.length)return a;a=a.vn.ia();hj(Pj(),a,b);return new Fu(a)}f.m=function(){return Du(new Eu,this.vn)};f.Zh=function(a){return E$(this,a)};f.Ai=function(a){return E$(this,a)};f.n=function(a){return this.va(a|0)};f.fg=function(){return this.vn};
+f.$classData=q({O6:0},!1,"scala.collection.immutable.ArraySeq$ofRef",{O6:1,Gr:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,Dr:1,l:1});function R3(a){this.Lr=a}R3.prototype=new t$;R3.prototype.constructor=R3;f=R3.prototype;f.K=function(){return this.Lr.a.length};f.iB=function(a){return this.Lr.a[a]};f.B=function(){var a=BL();return LL(a,this.Lr,a.rg)};
+f.i=function(a){if(a instanceof R3){var b=this.Lr;a=a.Lr;return sj(Pj(),b,a)}return i3(this,a)};f.Ai=function(a){return 1>=this.K()?this:a===OG()?(a=this.Lr.ia(),bj(Pj(),a),new R3(a)):K3.prototype.Ai.call(this,a)};f.m=function(){return new HG(this.Lr)};f.qg=function(a){if($b(a)){a|=0;var b=this.Lr;tL();var c=new Sc(1+b.a.length|0);c.a[0]=a;VG(SG(),b,0,c,1,b.a.length);return new R3(c)}return K3.prototype.qg.call(this,a)};f.cc=function(a){return this.qg(a)};f.Zh=function(a){return this.Ai(a)};
+f.n=function(a){return this.iB(a|0)};f.va=function(a){return this.iB(a)};f.ag=function(){return tL()};f.fg=function(){return this.Lr};f.$classData=q({P6:0},!1,"scala.collection.immutable.ArraySeq$ofShort",{P6:1,Gr:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,Dr:1,l:1});function T3(a){this.Oy=a}T3.prototype=new t$;T3.prototype.constructor=T3;f=T3.prototype;f.K=function(){return this.Oy.a.length};
+f.B=function(){var a=BL();return ML(a,this.Oy,a.rg)};f.i=function(a){return a instanceof T3?this.Oy.a.length===a.Oy.a.length:i3(this,a)};f.m=function(){return new JG(this.Oy)};f.n=function(){};f.va=function(){};f.ag=function(){return SR()};f.fg=function(){return this.Oy};f.$classData=q({Q6:0},!1,"scala.collection.immutable.ArraySeq$ofUnit",{Q6:1,Gr:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,Dr:1,l:1});
+function gy(a,b,c){a:for(;;){if(a.b()){c=u();break a}var d=a.e(),e=a.f();if(!!b.n(d)!==c){b:for(var g=c;;){if(e.b()){c=a;break b}c=e.e();if(!!b.n(c)!==g)e=e.f();else{var h=a;d=e;c=b;b=g;a=new z(h.e(),u());g=h.f();for(e=a;g!==d;)h=new z(g.e(),u()),e=e.p=h,g=g.f();for(g=d=d.f();!d.b();){h=d.e();if(!!c.n(h)===b){for(;g!==d;)h=new z(g.e(),u()),e=e.p=h,g=g.f();g=d.f()}d=d.f()}g.b()||(e.p=g);c=a;break b}}break a}a=e}return c}
+function bga(a,b,c){for(var d=null,e=null;;){if(b.b()){if(null===d)return a;e.p=a;return d}var g=b.e(),h=c.n(g);if(Object.is(h,g))b=b.f();else{for(;a!==b;)g=new z(a.e(),u()),null===d&&(d=g),null!==e&&(e.p=g),e=g,a=a.f();h=new z(h,u());null===d&&(d=h);null!==e&&(e.p=h);e=h;b=b.f();e=h=e;a=b}}}function rS(){}rS.prototype=new i9;rS.prototype.constructor=rS;function F$(){}f=F$.prototype=rS.prototype;f.Ii=function(a){return ky(this,a)};f.Zh=function(a){return qw(this,a)};f.m=function(){return new Om(this)};
+f.Gb=function(a){return XY(this,a)};f.Bb=function(a){return $Y(this,a)};f.Oc=function(){return"LinearSeq"};f.NJ=function(a){return F0(this,a)};f.va=function(a){return eB(this,a)};f.De=function(a,b){return YA(this,a,b)};f.Lt=function(a){return G0(this,a)};f.wo=function(a,b){return H0(this,a,b)};f.Ik=function(){return Od()};function dl(a,b){if(a.b())return b;if(b.b())return a;var c=new z(b.e(),a),d=c;for(b=b.f();!b.b();){var e=new z(b.e(),a);d=d.p=e;b=b.f()}return c}f.b=function(){return this===u()};
+function Pd(a,b){if(b instanceof rS)return dl(a,b);if(0===b.Q())return a;if(b instanceof fp&&a.b())return b.ha();b=b.m();if(b.s()){for(var c=new z(b.t(),a),d=c;b.s();){var e=new z(b.t(),a);d=d.p=e}return c}return a}function un(a,b){return b instanceof rS?dl(b,a):G3(a,b)}function xt(a,b){if(a.b()||0>=b)return u();for(var c=new z(a.e(),u()),d=c,e=a.f(),g=1;;){if(e.b())return a;if(g<b){g=1+g|0;var h=new z(e.e(),u());d=d.p=h;e=e.f()}else break}return c}
+function Qt(a,b){if(a===u())return u();var c=new z(b.n(a.e()),u()),d=c;for(a=a.f();a!==u();){var e=new z(b.n(a.e()),u());d=d.p=e;a=a.f()}return c}function Wn(a,b){if(a===u())return u();for(var c=null,d;null===c;)if(d=b.Ob(a.e(),Od().iC),d!==Od().iC&&(c=new z(d,u())),a=a.f(),a===u())return null===c?u():c;for(var e=c;a!==u();)d=b.Ob(a.e(),Od().iC),d!==Od().iC&&(d=new z(d,u()),e=e.p=d),a=a.f();return c}
+function ZW(a,b){for(var c=null,d=null;a!==u();){for(var e=b.n(a.e()).m();e.s();){var g=new z(e.t(),u());null===d?c=g:d.p=g;d=g}a=a.f()}return null===c?u():c}f.Ca=function(a){for(var b=this;!b.b();)a.n(b.e()),b=b.f()};function Km(a){for(var b=u();!a.b();){var c=a.e();b=new z(c,b);a=a.f()}return b}f.mf=function(a,b){for(var c=Km(this);!c.b();)a=b.ba(c.e(),a),c=c.f();return a};f.K=function(){for(var a=this,b=0;!a.b();)b=1+b|0,a=a.f();return b};
+f.ab=function(a){if(0>a)a=1;else a:for(var b=this,c=0;;){if(c===a){a=b.b()?0:1;break a}if(b.b()){a=-1;break a}c=1+c|0;b=b.f()}return a};f.ul=function(a){for(var b=this;!b.b();){if(!a.n(b.e()))return!1;b=b.f()}return!0};f.qo=function(a){for(var b=this;!b.b();){if(a.n(b.e()))return!0;b=b.f()}return!1};f.L=function(a){for(var b=this;!b.b();){if(ml(nl(),b.e(),a))return!0;b=b.f()}return!1};function lX(a,b){for(;!a.b();){if(b.n(a.e()))return new L(a.e());a=a.f()}return R()}
+f.Mc=function(){if(this.b())throw AH("List.last");for(var a=this,b=this.f();!b.b();)a=b,b=b.f();return a.e()};f.Ih=function(){return"List"};f.BK=function(a){if(this.b())return Od().jC;for(var b=this.ti(),c=this.ti(),d=this.m();d.s();){var e=d.t();(a.n(e)?b:c).$(e)}a=G(new H,b.Kb(),c.Kb());return null!==a&&(b=a.h(),u().i(b))?G(new H,u(),this):null!==a&&(b=a.j(),u().i(b))?G(new H,this,u()):a};f.ha=function(){return this};
+f.i=function(a){var b;if(a instanceof rS)a:for(b=this;;){if(b===a){b=!0;break a}var c=b.b(),d=a.b();if(c||d||!ml(nl(),b.e(),a.e())){b=c&&d;break a}b=b.f();a=a.f()}else b=i3(this,a);return b};f.n=function(a){return eB(this,a|0)};f.Lc=function(a){return F0(this,a|0)};f.Jc=function(a){return a6(a,this)};f.Ja=function(a){return Qt(this,a)};f.gn=function(a){return un(this,a)};f.cc=function(a){return new z(a,this)};f.Ub=function(){return Od()};function G$(){this.R=null}G$.prototype=new x$;
+G$.prototype.constructor=G$;function H$(){}H$.prototype=G$.prototype;function A$(a,b,c){b=0<b?b:0;var d=a.K();c=c<d?c:d;return(c-b|0)===a.K()?a:c<=b?HJ():a.Ln(b,c)}function w4(a){this.nw=a}w4.prototype=new C$;w4.prototype.constructor=w4;f=w4.prototype;f.K=function(){return this.nw.a.length};f.B=function(){var a=BL();return EL(a,this.nw,a.rg)};f.i=function(a){if(a instanceof w4){var b=this.nw;a=a.nw;return vj(Pj(),b,a)}return B$.prototype.i.call(this,a)};f.m=function(){return new IG(this.nw)};
+f.fB=function(a){return this.nw.a[a]};f.n=function(a){return this.fB(a|0)};f.va=function(a){return this.fB(a)};f.ag=function(){return uL()};f.rl=function(){return this.nw};f.$classData=q({k9:0},!1,"scala.collection.mutable.ArraySeq$ofBoolean",{k9:1,Tr:1,kk:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,ok:1,ah:1,pk:1,$g:1,Ff:1,Xk:1,hd:1,Vb:1,Yk:1,id:1,Cb:1,l:1});function u4(a){this.ow=a}u4.prototype=new C$;u4.prototype.constructor=u4;f=u4.prototype;f.K=function(){return this.ow.a.length};
+f.gB=function(a){return this.ow.a[a]};f.B=function(){var a=BL();return FL(a,this.ow,a.rg)};f.i=function(a){if(a instanceof u4){var b=this.ow;a=a.ow;return uj(Pj(),b,a)}return B$.prototype.i.call(this,a)};f.m=function(){return new GG(this.ow)};f.n=function(a){return this.gB(a|0)};f.va=function(a){return this.gB(a)};f.ag=function(){return sL()};f.rl=function(){return this.ow};
+f.$classData=q({l9:0},!1,"scala.collection.mutable.ArraySeq$ofByte",{l9:1,Tr:1,kk:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,ok:1,ah:1,pk:1,$g:1,Ff:1,Xk:1,hd:1,Vb:1,Yk:1,id:1,Cb:1,l:1});function AQ(a){this.En=a}AQ.prototype=new C$;AQ.prototype.constructor=AQ;f=AQ.prototype;f.K=function(){return this.En.a.length};f.hB=function(a){return this.En.a[a]};f.B=function(){var a=BL();return GL(a,this.En,a.rg)};
+f.i=function(a){if(a instanceof AQ){var b=this.En;a=a.En;return tj(Pj(),b,a)}return B$.prototype.i.call(this,a)};f.m=function(){return new FG(this.En)};f.Gh=function(a,b,c,d){var e=a.yf;0!==b.length&&(e.ja=""+e.ja+b);b=this.En.a.length;if(0!==b)if(""===c)mW(e,this.En);else{e.K();var g=String.fromCharCode(this.En.a[0]);e.ja=""+e.ja+g;for(g=1;g<b;){e.ja=""+e.ja+c;var h=String.fromCharCode(this.En.a[g]);e.ja=""+e.ja+h;g=1+g|0}}0!==d.length&&(e.ja=""+e.ja+d);return a};
+f.n=function(a){return hc(this.hB(a|0))};f.va=function(a){return hc(this.hB(a))};f.ag=function(){return Ir()};f.rl=function(){return this.En};f.$classData=q({m9:0},!1,"scala.collection.mutable.ArraySeq$ofChar",{m9:1,Tr:1,kk:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,ok:1,ah:1,pk:1,$g:1,Ff:1,Xk:1,hd:1,Vb:1,Yk:1,id:1,Cb:1,l:1});function r4(a){this.pw=a}r4.prototype=new C$;r4.prototype.constructor=r4;f=r4.prototype;f.K=function(){return this.pw.a.length};
+f.B=function(){var a=BL();return HL(a,this.pw,a.rg)};f.i=function(a){if(a instanceof r4){var b=this.pw;a=a.pw;return wj(Pj(),b,a)}return B$.prototype.i.call(this,a)};f.m=function(){return new CG(this.pw)};f.cB=function(a){return this.pw.a[a]};f.n=function(a){return this.cB(a|0)};f.va=function(a){return this.cB(a)};f.ag=function(){return pL()};f.rl=function(){return this.pw};
+f.$classData=q({n9:0},!1,"scala.collection.mutable.ArraySeq$ofDouble",{n9:1,Tr:1,kk:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,ok:1,ah:1,pk:1,$g:1,Ff:1,Xk:1,hd:1,Vb:1,Yk:1,id:1,Cb:1,l:1});function t4(a){this.qw=a}t4.prototype=new C$;t4.prototype.constructor=t4;f=t4.prototype;f.K=function(){return this.qw.a.length};f.B=function(){var a=BL();return IL(a,this.qw,a.rg)};f.i=function(a){if(a instanceof t4){var b=this.qw;a=a.qw;return xj(Pj(),b,a)}return B$.prototype.i.call(this,a)};
+f.m=function(){return new EG(this.qw)};f.dB=function(a){return this.qw.a[a]};f.n=function(a){return this.dB(a|0)};f.va=function(a){return this.dB(a)};f.ag=function(){return rL()};f.rl=function(){return this.qw};f.$classData=q({o9:0},!1,"scala.collection.mutable.ArraySeq$ofFloat",{o9:1,Tr:1,kk:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,ok:1,ah:1,pk:1,$g:1,Ff:1,Xk:1,hd:1,Vb:1,Yk:1,id:1,Cb:1,l:1});function q4(a){this.rw=a}q4.prototype=new C$;q4.prototype.constructor=q4;f=q4.prototype;
+f.K=function(){return this.rw.a.length};f.B=function(){var a=BL();return JL(a,this.rw,a.rg)};f.i=function(a){if(a instanceof q4){var b=this.rw;a=a.rw;return qj(Pj(),b,a)}return B$.prototype.i.call(this,a)};f.m=function(){return new BG(this.rw)};f.wt=function(a){return this.rw.a[a]};f.n=function(a){return this.wt(a|0)};f.va=function(a){return this.wt(a)};f.ag=function(){return rl()};f.rl=function(){return this.rw};
+f.$classData=q({p9:0},!1,"scala.collection.mutable.ArraySeq$ofInt",{p9:1,Tr:1,kk:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,ok:1,ah:1,pk:1,$g:1,Ff:1,Xk:1,hd:1,Vb:1,Yk:1,id:1,Cb:1,l:1});function s4(a){this.sw=a}s4.prototype=new C$;s4.prototype.constructor=s4;f=s4.prototype;f.K=function(){return this.sw.a.length};f.B=function(){var a=BL();return KL(a,this.sw,a.rg)};f.i=function(a){if(a instanceof s4){var b=this.sw;a=a.sw;return pj(Pj(),b,a)}return B$.prototype.i.call(this,a)};
+f.m=function(){return new DG(this.sw)};f.eB=function(a){return this.sw.a[a]};f.n=function(a){return this.eB(a|0)};f.va=function(a){return this.eB(a)};f.ag=function(){return qL()};f.rl=function(){return this.sw};f.$classData=q({q9:0},!1,"scala.collection.mutable.ArraySeq$ofLong",{q9:1,Tr:1,kk:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,ok:1,ah:1,pk:1,$g:1,Ff:1,Xk:1,hd:1,Vb:1,Yk:1,id:1,Cb:1,l:1});function zQ(a){this.gu=a}zQ.prototype=new C$;zQ.prototype.constructor=zQ;f=zQ.prototype;
+f.ag=function(){return yG(zG(),bg(ca(this.gu)))};f.K=function(){return this.gu.a.length};f.va=function(a){return this.gu.a[a]};f.B=function(){var a=BL();return DL(a,this.gu,a.rg)};f.i=function(a){return a instanceof zQ?sQ(SG(),this.gu,a.gu):B$.prototype.i.call(this,a)};f.m=function(){return Du(new Eu,this.gu)};f.n=function(a){return this.va(a|0)};f.rl=function(){return this.gu};
+f.$classData=q({r9:0},!1,"scala.collection.mutable.ArraySeq$ofRef",{r9:1,Tr:1,kk:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,ok:1,ah:1,pk:1,$g:1,Ff:1,Xk:1,hd:1,Vb:1,Yk:1,id:1,Cb:1,l:1});function v4(a){this.tw=a}v4.prototype=new C$;v4.prototype.constructor=v4;f=v4.prototype;f.K=function(){return this.tw.a.length};f.iB=function(a){return this.tw.a[a]};f.B=function(){var a=BL();return LL(a,this.tw,a.rg)};
+f.i=function(a){if(a instanceof v4){var b=this.tw;a=a.tw;return sj(Pj(),b,a)}return B$.prototype.i.call(this,a)};f.m=function(){return new HG(this.tw)};f.n=function(a){return this.iB(a|0)};f.va=function(a){return this.iB(a)};f.ag=function(){return tL()};f.rl=function(){return this.tw};f.$classData=q({s9:0},!1,"scala.collection.mutable.ArraySeq$ofShort",{s9:1,Tr:1,kk:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,ok:1,ah:1,pk:1,$g:1,Ff:1,Xk:1,hd:1,Vb:1,Yk:1,id:1,Cb:1,l:1});
+function x4(a){this.cz=a}x4.prototype=new C$;x4.prototype.constructor=x4;f=x4.prototype;f.K=function(){return this.cz.a.length};f.B=function(){var a=BL();return ML(a,this.cz,a.rg)};f.i=function(a){return a instanceof x4?this.cz.a.length===a.cz.a.length:B$.prototype.i.call(this,a)};f.m=function(){return new JG(this.cz)};f.n=function(){};f.va=function(){};f.ag=function(){return SR()};f.rl=function(){return this.cz};
+f.$classData=q({t9:0},!1,"scala.collection.mutable.ArraySeq$ofUnit",{t9:1,Tr:1,kk:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,ok:1,ah:1,pk:1,$g:1,Ff:1,Xk:1,hd:1,Vb:1,Yk:1,id:1,Cb:1,l:1});function I$(a,b,c,d){(1+a.Xf|0)>=a.hu&&Oy(a,a.eb.a.length<<1);return Py(a,b,c,!1,d,d&(-1+a.eb.a.length|0))}function Ly(a,b,c,d){(1+a.Xf|0)>=a.hu&&Oy(a,a.eb.a.length<<1);var e=My(W(),b);e^=e>>>16|0;return Py(a,b,c,d,e,e&(-1+a.eb.a.length|0))}
+function Py(a,b,c,d,e,g){var h=a.eb.a[g];if(null===h)a.eb.a[g]=new aK(b,e,c,null);else{for(var k=null,l=h;null!==l&&l.mk<=e;){if(l.mk===e&&ml(nl(),b,l.Wk))return a=l.Ah,l.Ah=c,d?new L(a):null;k=l;l=l.$d}null===k?a.eb.a[g]=new aK(b,e,c,h):k.$d=new aK(b,e,c,k.$d)}a.Xf=1+a.Xf|0;return null}
+function J$(a,b){var c=My(W(),b);a:{c^=c>>>16|0;var d=c&(-1+a.eb.a.length|0),e=a.eb.a[d];if(null===e)a=null;else if(e.mk===c&&ml(nl(),e.Wk,b))a.eb.a[d]=e.$d,a.Xf=-1+a.Xf|0,a=e;else{d=e;for(e=e.$d;null!==e&&e.mk<=c;){if(e.mk===c&&ml(nl(),e.Wk,b)){d.$d=e.$d;a.Xf=-1+a.Xf|0;a=e;break a}d=e;e=e.$d}a=null}}return a}
+function Oy(a,b){if(0>b)throw iL("new HashMap table size "+b+" exceeds maximum");var c=a.eb.a.length;a.hu=Eb(b*a.gH);if(0===a.Xf)a.eb=new (md(bK).Ia)(b);else{var d=a.eb;a.eb=zj(Pj(),d,b);d=new aK(null,0,null,null);for(var e=new aK(null,0,null,null);c<b;){for(var g=0;g<c;){var h=a.eb.a[g];if(null!==h){d.$d=null;e.$d=null;for(var k=d,l=e,m=h;null!==m;){var n=m.$d;0===(m.mk&c)?k=k.$d=m:l=l.$d=m;m=n}k.$d=null;h!==d.$d&&(a.eb.a[g]=d.$d);null!==e.$d&&(a.eb.a[g+c|0]=e.$d,l.$d=null)}g=1+g|0}c<<=1}}}
+function K$(a){a=-1+a|0;a=4<a?a:4;a=(-2147483648>>Math.clz32(a)&a)<<1;return 1073741824>a?a:1073741824}function CV(a,b,c){a.gH=c;a.eb=new (md(bK).Ia)(K$(b));a.hu=Eb(a.eb.a.length*a.gH);a.Xf=0;return a}function FV(){var a=new DV;CV(a,16,.75);return a}function DV(){this.gH=0;this.eb=null;this.Xf=this.hu=0}DV.prototype=new e$;DV.prototype.constructor=DV;f=DV.prototype;f.ry=function(a){return b6(this,a)};f.am=function(a){return c6(this,a)};f.Gb=function(a){return XY(this,a)};
+f.Ja=function(a){return YY(this,a)};f.Bb=function(a){return $Y(this,a)};f.ka=function(){return this.Xf};f.L=function(a){var b=My(W(),a);b^=b>>>16|0;var c=this.eb.a[b&(-1+this.eb.a.length|0)];return null!==(null===c?null:Ny(c,a,b))};f.he=function(a){a=K$(Eb((1+a|0)/this.gH));a>this.eb.a.length&&Oy(this,a)};
+function BV(a,b){a.he(b.Q());if(b instanceof TU)return b.dc.GJ(new fW((d,e,g)=>{g|=0;I$(a,d,e,g^(g>>>16|0))})),a;if(b instanceof DV){for(b=S0(b);b.s();){var c=b.t();I$(a,c.Wk,c.Ah,c.mk)}return a}return b&&b.$classData&&b.$classData.rb.CC?(b.og(new fn((d,e)=>{var g=My(W(),d);return I$(a,d,e,g^(g>>>16|0))})),a):lR(a,b)}
+f.ou=function(a,b){if(ca(this)!==da(Ky))return P8(this,a,b);var c=My(W(),a);c^=c>>>16|0;var d=c&(-1+this.eb.a.length|0);var e=null;var g=null;var h=this.eb.a[d];if(null!==h)for(var k=null;;){if(c===h.mk&&ml(nl(),a,h.Wk))g=k,e=h;else if(!(null===h.$d||h.mk>c)){var l=h.$d;k=h;h=l;continue}break}k=e;k=null===k?R():new L(k.Ah);b=b.n(k);k=G(new H,k,b);h=k.y;l=k.w;if(R()!==h||R()!==l)if(h=k.w,k.y instanceof L&&R()===h)null!==g?g.$d=e.$d:this.eb.a[d]=e.$d,this.Xf=-1+this.Xf|0;else if(g=k.y,h=k.w,R()===g&&
+h instanceof L)e=h.k,d=(1+this.Xf|0)>=this.hu?(Oy(this,this.eb.a.length<<1),c&(-1+this.eb.a.length|0)):d,Py(this,a,e,!1,c,d);else if(a=k.w,k.y instanceof L&&a instanceof L)e.Ah=a.k;else throw new w(k);return b};f.m=function(){return 0===this.Xf?Rq().Pa:new y4(this)};f.tj=function(){return 0===this.Xf?Rq().Pa:new z4(this)};f.ie=function(){return 0===this.Xf?Rq().Pa:new A4(this)};function S0(a){return 0===a.Xf?Rq().Pa:new B4(a)}f.mg=function(){var a=this.eb;yj(Pj(),a,null);this.Xf=0};
+f.U=function(a){var b=My(W(),a);b^=b>>>16|0;var c=this.eb.a[b&(-1+this.eb.a.length|0)];a=null===c?null:Ny(c,a,b);return null===a?R():new L(a.Ah)};f.n=function(a){var b=My(W(),a);b^=b>>>16|0;var c=this.eb.a[b&(-1+this.eb.a.length|0)];b=null===c?null:Ny(c,a,b);return null===b?z3(a):b.Ah};f.Se=function(a,b){if(ca(this)!==da(Ky))return x3(this,a,b);var c=My(W(),a);c^=c>>>16|0;var d=this.eb.a[c&(-1+this.eb.a.length|0)];a=null===d?null:Ny(d,a,c);return null===a?Es(b):a.Ah};
+f.Hk=function(a,b){if(ca(this)!==da(Ky))return pX(this,a,b);var c=My(W(),a);c^=c>>>16|0;var d=c&(-1+this.eb.a.length|0),e=this.eb.a[d];e=null===e?null:Ny(e,a,c);if(null!==e)return e.Ah;e=this.eb;b=Es(b);(1+this.Xf|0)>=this.hu&&Oy(this,this.eb.a.length<<1);Py(this,a,b,!1,c,e===this.eb?d:c&(-1+this.eb.a.length|0));return b};f.bj=function(a,b){null===Ly(this,a,b,!0)&&R()};f.JB=function(a){null===J$(this,a)&&R()};f.bh=function(a,b){Ly(this,a,b,!1)};f.Q=function(){return this.Xf};
+f.b=function(){return 0===this.Xf};f.Ca=function(a){for(var b=this.eb.a.length,c=0;c<b;){var d=this.eb.a[c];null!==d&&d.Ca(a);c=1+c|0}};f.og=function(a){for(var b=this.eb.a.length,c=0;c<b;){var d=this.eb.a[c];null!==d&&d.og(a);c=1+c|0}};f.vj=function(){return Ty()};f.Oc=function(){return"HashMap"};f.B=function(){if(this.b())return BL().mG;var a=new C4(this);return CL(BL(),a,BL().Cr)};f.Bm=function(a){J$(this,a)};f.$=function(a){Ly(this,a.h(),a.j(),!1);return this};
+f.zc=function(a){return BV(this,a)};var Ky=q({E9:0},!1,"scala.collection.mutable.HashMap",{E9:1,eH:1,qm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Mk:1,ek:1,za:1,la:1,um:1,v:1,CC:1,ah:1,mH:1,$g:1,Ff:1,xg:1,xf:1,wf:1,Jn:1,Cb:1,RG:1,l:1});DV.prototype.$classData=Ky;function L$(a,b,c,d){a.Z=c;a.ca=d;a.R=b}function y$(){this.Z=this.R=null;this.ca=0}y$.prototype=new H$;y$.prototype.constructor=y$;function M$(){}M$.prototype=y$.prototype;
+function z$(a,b){for(var c=a.On(),d=1;d<c;){var e=JJ(),g=c/2|0,h=d-g|0;VJ(e,-1+((1+g|0)-(0>h?-h|0:h)|0)|0,a.To(d),b);d=1+d|0}}function IJ(a){this.R=a}IJ.prototype=new H$;IJ.prototype.constructor=IJ;f=IJ.prototype;f.va=function(a){if(0<=a&&a<this.R.a.length)return this.R.a[a];throw this.rh(a);};f.$r=function(a,b){if(0<=a&&a<this.R.a.length){var c=this.R.ia();c.a[a]=b;return new IJ(c)}throw this.rh(a);};
+f.hn=function(a){if(32>this.R.a.length)return new IJ(RJ(JJ(),this.R,a));var b=this.R,c=JJ().bd,d=new zc(1);d.a[0]=a;return new KJ(b,32,c,d,33)};f.zl=function(a){var b=this.R.a.length;if(32>b)return new IJ(TJ(JJ(),a,this.R));var c=new zc(1);c.a[0]=a;return new KJ(c,1,JJ().bd,this.R,1+b|0)};f.yo=function(a){return new IJ(WJ(JJ(),this.R,a))};f.Ln=function(a,b){var c=this.R;return new IJ(Jj(Pj(),c,a,b))};
+f.Cm=function(){if(1===this.R.a.length)return HJ();var a=this.R,b=a.a.length;return new IJ(Jj(Pj(),a,1,b))};f.On=function(){return 1};f.To=function(){return this.R};f.ql=function(a,b){var c=YJ(JJ(),this.R,a);return null!==c?new IJ(c):C1.prototype.ql.call(this,a,b)};f.f=function(){return this.Cm()};f.Ja=function(a){return this.yo(a)};f.cc=function(a){return this.zl(a)};f.n=function(a){a|=0;if(0<=a&&a<this.R.a.length)return this.R.a[a];throw this.rh(a);};
+f.$classData=q({R8:0},!1,"scala.collection.immutable.Vector1",{R8:1,$y:1,Zy:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,sg:1,l:1});function z(a,b){this.z=a;this.p=b}z.prototype=new F$;z.prototype.constructor=z;f=z.prototype;f.e=function(){return this.z};f.H=function(){return"::"};f.G=function(){return 2};f.I=function(a){switch(a){case 0:return this.z;case 1:return this.p;default:return $K(W(),a)}};f.f=function(){return this.p};
+f.Jg=function(){return new L(this.z)};f.$classData=q({F6:0},!1,"scala.collection.immutable.$colon$colon",{F6:1,r7:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,KL:1,CG:1,TR:1,pS:1,g6:1,id:1,Cb:1,Uh:1,sg:1,l:1,E:1});function N$(){this.xS=null;O$=this;this.xS=G(new H,u(),u())}N$.prototype=new F$;N$.prototype.constructor=N$;f=N$.prototype;f.LJ=function(){throw AH("head of empty list");};f.Q=function(){return 0};f.m=function(){return Rq().Pa};f.Gb=function(){return this.xS};
+f.H=function(){return"Nil"};f.G=function(){return 0};f.I=function(a){return $K(W(),a)};f.MJ=function(){throw nv("init of empty list");};f.Mc=function(){throw AH("last of empty list");};f.f=function(){throw nv("tail of empty list");};f.Jg=function(){return R()};f.e=function(){this.LJ()};f.$classData=q({U7:0},!1,"scala.collection.immutable.Nil$",{U7:1,r7:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,KL:1,CG:1,TR:1,pS:1,g6:1,id:1,Cb:1,Uh:1,sg:1,l:1,E:1});var O$;
+function u(){O$||(O$=new N$);return O$}function P$(a,b){return b===a.Hf?a:sZ(new rZ,b,a.Xe)}function Uga(a,b){if(null===b)throw le();return b.sb?b.vb:me(b,new zV(a))}function sZ(a,b,c){a.Hf=b;a.Xe=c;if(null===c)throw oL("ordering must not be null");return a}function xZ(a){var b=new rZ;sZ(b,null,a);return b}function rZ(){this.Xe=this.Hf=null}rZ.prototype=new b9;rZ.prototype.constructor=rZ;f=rZ.prototype;f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Oc=function(){return"SortedSet"};
+f.ti=function(){return new wZ(this.Xe)};f.se=function(){return this.Xe};f.ka=function(){return EI(nJ(),this.Hf)};f.b=function(){return 0===EI(nJ(),this.Hf)};f.e=function(){return hJ(nJ(),this.Hf).Wa};f.Mc=function(){return iJ(nJ(),this.Hf).Wa};f.aj=function(a){return a!==this.Xe||this.b()?u5(this,a):this.e()};f.$i=function(a){return a!==this.Xe||this.b()?v5(this,a):this.Mc()};f.Ca=function(a){var b=nJ(),c=this.Hf;null!==c&&oda(b,c,a)};
+f.m=function(){nJ();var a=this.Hf;nJ();var b=R();return new f4(a,b,this.Xe)};f.L=function(a){nJ();return null!==fJ(0,this.Hf,a,this.Xe)};function Vga(a,b){return P$(a,kJ(nJ(),a.Hf,new fn(c=>!!b.n(c))))}
+f.i=function(a){if(a instanceof rZ){var b=this.Xe,c=a.Xe;if(null===b?null===c:b.i(c)){nJ();b=this.Hf;a=a.Hf;c=this.Xe;var d;if(!(d=b===a)&&(d=null!==b)&&(d=null!==a)&&(d=(2147483647&b.ea)===(2147483647&a.ea))){b=new e4(b,c);a=new e4(a,c);for(c=!0;c&&null!==b.Hc&&null!==a.Hc;)b.Hc===a.Hc?(0===b.Wd?d=null:(b.Wd=-1+b.Wd|0,d=b.Cn.a[b.Wd]),b.Hc=d,0===a.Wd?d=null:(a.Wd=-1+a.Wd|0,d=a.Cn.a[a.Wd]),a.Hc=d):(c=Object.is(b.Hc.Wa,a.Hc.Wa)?!0:b.hw.Yi(b.Hc.Wa,a.Hc.Wa),b.Hc=r1(b,b.Hc.ta),a.Hc=r1(a,a.Hc.ta));d=c&&
+null===b.Hc&&null===a.Hc}return d}}return O8(this,a)};f.Ih=function(){return"TreeSet"};f.vc=function(a){return qZ(zZ(),a,this.Xe)};f.Gk=function(a){return qZ(zZ(),a,this.Xe)};f.Fk=function(a){return Vga(this,a)};f.wy=function(a){a:{if(a instanceof rZ){var b=this.Xe,c=a.Xe;if(null===b?null===c:b.i(c)){b=nJ();a=pI(XI(b,this.Hf,a.Hf,this.Xe));a=P$(this,a);break a}}b=new $e;a=a.m();c=b.sb?b.vb:Uga(this,b);cH(a,c);a=P$(this,(b.sb?b.vb:Uga(this,b)).cH)}return a};
+f.Ce=function(a){a:{if(a instanceof rZ){var b=this.Xe,c=a.Xe;if(null===b?null===c:b.i(c)){a=mJ(nJ(),this.Hf,a.Hf,this.Xe);break a}}a=a.m();for(b=this.Hf;a.s();)b=gJ(nJ(),b,a.t(),null,!1,this.Xe);a=b}return P$(this,a)};f.Ek=function(a){var b=nJ();a=pI(PI(b,this.Hf,a,this.Xe));return P$(this,a)};f.bc=function(a){return P$(this,gJ(nJ(),this.Hf,a,null,!1,this.Xe))};
+f.Bb=function(a){var b=EI(nJ(),this.Hf)-(0<a?a:0)|0;if(0>=b)a=xZ(this.Xe);else if(b>=EI(nJ(),this.Hf))a=this;else{a=new rZ;var c=nJ();b=pI(HI(c,this.Hf,b));a=sZ(a,b,this.Xe)}return a};f.Jc=function(a){if(0>=a)var b=this;else if(a>=EI(nJ(),this.Hf))b=xZ(this.Xe);else{b=new rZ;var c=nJ();a=pI(GI(c,this.Hf,a));b=sZ(b,a,this.Xe)}return b};
+f.$classData=q({L8:0},!1,"scala.collection.immutable.TreeSet",{L8:1,Fr:1,rm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,fk:1,Cl:1,la:1,v:1,dq:1,xc:1,Rr:1,OL:1,PG:1,fS:1,Iy:1,eS:1,D8:1,Tba:1,Qba:1,i6:1,Cb:1,F8:1,sg:1,l:1});function Q$(){this.Z=this.R=null;this.ca=0;L$(this,JJ().PL,JJ().PL,0)}Q$.prototype=new M$;Q$.prototype.constructor=Q$;f=Q$.prototype;f.$r=function(a){throw this.rh(a);};f.hn=function(a){var b=new zc(1);b.a[0]=a;return new IJ(b)};f.zl=function(a){var b=new zc(1);b.a[0]=a;return new IJ(b)};
+f.Cm=function(){throw nv("empty.tail");};f.Ln=function(){return this};f.On=function(){return 0};f.To=function(){return null};f.i=function(a){return this===a||!(a instanceof C1)&&i3(this,a)};f.ql=function(a){return pU(GK(),a)};f.rh=function(a){return aL(new bL,a+" is out of bounds (empty vector)")};f.f=function(){return this.Cm()};f.Ja=function(){return this};f.cc=function(a){return this.zl(a)};f.n=function(a){throw this.rh(a|0);};f.va=function(a){throw this.rh(a);};
+f.$classData=q({Q8:0},!1,"scala.collection.immutable.Vector0$",{Q8:1,fC:1,$y:1,Zy:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,sg:1,l:1});var R$;function HJ(){R$||(R$=new Q$);return R$}function KJ(a,b,c,d,e){this.Z=this.R=null;this.ca=0;this.Ri=b;this.yh=c;L$(this,a,d,e)}KJ.prototype=new M$;KJ.prototype.constructor=KJ;f=KJ.prototype;
+f.va=function(a){if(0<=a&&a<this.ca){var b=a-this.Ri|0;return 0<=b?(a=b>>>5|0,a<this.yh.a.length?this.yh.a[a].a[31&b]:this.Z.a[31&b]):this.R.a[a]}throw this.rh(a);};
+f.$r=function(a,b){if(0<=a&&a<this.ca){if(a>=this.Ri){var c=a-this.Ri|0;a=c>>>5|0;c&=31;if(a<this.yh.a.length){var d=this.yh.ia(),e=d.a[a].ia();e.a[c]=b;d.a[a]=e;return new KJ(this.R,this.Ri,d,this.Z,this.ca)}a=this.Z.ia();a.a[c]=b;return new KJ(this.R,this.Ri,this.yh,a,this.ca)}c=this.R.ia();c.a[a]=b;return new KJ(c,this.Ri,this.yh,this.Z,this.ca)}throw this.rh(a);};
+f.hn=function(a){if(32>this.Z.a.length)return a=RJ(JJ(),this.Z,a),new KJ(this.R,this.Ri,this.yh,a,1+this.ca|0);if(30>this.yh.a.length){var b=SJ(JJ(),this.yh,this.Z),c=new zc(1);c.a[0]=a;return new KJ(this.R,this.Ri,b,c,1+this.ca|0)}b=this.R;c=this.Ri;var d=this.yh,e=this.Ri,g=JJ().eg,h=this.Z,k=new (md(md(jd)).Ia)(1);k.a[0]=h;h=new zc(1);h.a[0]=a;return new LJ(b,c,d,960+e|0,g,k,h,1+this.ca|0)};
+f.zl=function(a){if(32>this.Ri){var b=TJ(JJ(),a,this.R);return new KJ(b,1+this.Ri|0,this.yh,this.Z,1+this.ca|0)}if(30>this.yh.a.length)return b=new zc(1),b.a[0]=a,a=UJ(JJ(),this.R,this.yh),new KJ(b,1,a,this.Z,1+this.ca|0);b=new zc(1);b.a[0]=a;a=this.R;var c=new (md(md(jd)).Ia)(1);c.a[0]=a;return new LJ(b,1,c,1+this.Ri|0,JJ().eg,this.yh,this.Z,1+this.ca|0)};f.yo=function(a){var b=WJ(JJ(),this.R,a),c=XJ(JJ(),2,this.yh,a);a=WJ(JJ(),this.Z,a);return new KJ(b,this.Ri,c,a,this.ca)};
+f.Ln=function(a,b){a=new FJ(a,b);GJ(a,1,this.R);GJ(a,2,this.yh);GJ(a,1,this.Z);return a.im()};f.Cm=function(){if(1<this.Ri){var a=this.R,b=a.a.length;a=Jj(Pj(),a,1,b);return new KJ(a,-1+this.Ri|0,this.yh,this.Z,-1+this.ca|0)}return this.Ln(1,this.ca)};f.On=function(){return 3};f.To=function(a){switch(a){case 0:return this.R;case 1:return this.yh;case 2:return this.Z;default:throw new w(a);}};
+f.ql=function(a,b){var c=YJ(JJ(),this.Z,a);return null!==c?new KJ(this.R,this.Ri,this.yh,c,(this.ca-this.Z.a.length|0)+c.a.length|0):C1.prototype.ql.call(this,a,b)};f.f=function(){return this.Cm()};f.Ja=function(a){return this.yo(a)};f.cc=function(a){return this.zl(a)};f.n=function(a){var b=a|0;if(0<=b&&b<this.ca)return a=b-this.Ri|0,0<=a?(b=a>>>5|0,b<this.yh.a.length?this.yh.a[b].a[31&a]:this.Z.a[31&a]):this.R.a[b];throw this.rh(b);};
+f.$classData=q({S8:0},!1,"scala.collection.immutable.Vector2",{S8:1,fC:1,$y:1,Zy:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,sg:1,l:1});function LJ(a,b,c,d,e,g,h,k){this.Z=this.R=null;this.ca=0;this.Vh=b;this.Wh=c;this.zh=d;this.cg=e;this.tg=g;L$(this,a,h,k)}LJ.prototype=new M$;LJ.prototype.constructor=LJ;f=LJ.prototype;
+f.va=function(a){if(0<=a&&a<this.ca){var b=a-this.zh|0;if(0<=b){a=b>>>10|0;var c=31&(b>>>5|0);b&=31;return a<this.cg.a.length?this.cg.a[a].a[c].a[b]:c<this.tg.a.length?this.tg.a[c].a[b]:this.Z.a[b]}return a>=this.Vh?(b=a-this.Vh|0,this.Wh.a[b>>>5|0].a[31&b]):this.R.a[a]}throw this.rh(a);};
+f.$r=function(a,b){if(0<=a&&a<this.ca){if(a>=this.zh){var c=a-this.zh|0,d=c>>>10|0;a=31&(c>>>5|0);c&=31;if(d<this.cg.a.length){var e=this.cg.ia(),g=e.a[d].ia(),h=g.a[a].ia();h.a[c]=b;g.a[a]=h;e.a[d]=g;return new LJ(this.R,this.Vh,this.Wh,this.zh,e,this.tg,this.Z,this.ca)}if(a<this.tg.a.length)return d=this.tg.ia(),e=d.a[a].ia(),e.a[c]=b,d.a[a]=e,new LJ(this.R,this.Vh,this.Wh,this.zh,this.cg,d,this.Z,this.ca);a=this.Z.ia();a.a[c]=b;return new LJ(this.R,this.Vh,this.Wh,this.zh,this.cg,this.tg,a,this.ca)}if(a>=
+this.Vh)return c=a-this.Vh|0,a=c>>>5|0,c&=31,d=this.Wh.ia(),e=d.a[a].ia(),e.a[c]=b,d.a[a]=e,new LJ(this.R,this.Vh,d,this.zh,this.cg,this.tg,this.Z,this.ca);c=this.R.ia();c.a[a]=b;return new LJ(c,this.Vh,this.Wh,this.zh,this.cg,this.tg,this.Z,this.ca)}throw this.rh(a);};
+f.hn=function(a){if(32>this.Z.a.length)return a=RJ(JJ(),this.Z,a),new LJ(this.R,this.Vh,this.Wh,this.zh,this.cg,this.tg,a,1+this.ca|0);if(31>this.tg.a.length){var b=SJ(JJ(),this.tg,this.Z),c=new zc(1);c.a[0]=a;return new LJ(this.R,this.Vh,this.Wh,this.zh,this.cg,b,c,1+this.ca|0)}if(30>this.cg.a.length){b=SJ(JJ(),this.cg,SJ(JJ(),this.tg,this.Z));c=JJ().bd;var d=new zc(1);d.a[0]=a;return new LJ(this.R,this.Vh,this.Wh,this.zh,b,c,d,1+this.ca|0)}b=this.R;c=this.Vh;d=this.Wh;var e=this.zh,g=this.cg,h=
+this.zh,k=JJ().jk,l=SJ(JJ(),this.tg,this.Z),m=new (md(md(md(jd))).Ia)(1);m.a[0]=l;l=JJ().bd;var n=new zc(1);n.a[0]=a;return new MJ(b,c,d,e,g,30720+h|0,k,m,l,n,1+this.ca|0)};
+f.zl=function(a){if(32>this.Vh){var b=TJ(JJ(),a,this.R);return new LJ(b,1+this.Vh|0,this.Wh,1+this.zh|0,this.cg,this.tg,this.Z,1+this.ca|0)}if(1024>this.zh)return b=new zc(1),b.a[0]=a,a=UJ(JJ(),this.R,this.Wh),new LJ(b,1,a,1+this.zh|0,this.cg,this.tg,this.Z,1+this.ca|0);if(30>this.cg.a.length){b=new zc(1);b.a[0]=a;a=JJ().bd;var c=UJ(JJ(),UJ(JJ(),this.R,this.Wh),this.cg);return new LJ(b,1,a,1,c,this.tg,this.Z,1+this.ca|0)}b=new zc(1);b.a[0]=a;a=JJ().bd;c=UJ(JJ(),this.R,this.Wh);var d=new (md(md(md(jd))).Ia)(1);
+d.a[0]=c;return new MJ(b,1,a,1,d,1+this.zh|0,JJ().jk,this.cg,this.tg,this.Z,1+this.ca|0)};f.yo=function(a){var b=WJ(JJ(),this.R,a),c=XJ(JJ(),2,this.Wh,a),d=XJ(JJ(),3,this.cg,a),e=XJ(JJ(),2,this.tg,a);a=WJ(JJ(),this.Z,a);return new LJ(b,this.Vh,c,this.zh,d,e,a,this.ca)};f.Ln=function(a,b){a=new FJ(a,b);GJ(a,1,this.R);GJ(a,2,this.Wh);GJ(a,3,this.cg);GJ(a,2,this.tg);GJ(a,1,this.Z);return a.im()};
+f.Cm=function(){if(1<this.Vh){var a=this.R,b=a.a.length;a=Jj(Pj(),a,1,b);return new LJ(a,-1+this.Vh|0,this.Wh,-1+this.zh|0,this.cg,this.tg,this.Z,-1+this.ca|0)}return this.Ln(1,this.ca)};f.On=function(){return 5};f.To=function(a){switch(a){case 0:return this.R;case 1:return this.Wh;case 2:return this.cg;case 3:return this.tg;case 4:return this.Z;default:throw new w(a);}};
+f.ql=function(a,b){var c=YJ(JJ(),this.Z,a);return null!==c?new LJ(this.R,this.Vh,this.Wh,this.zh,this.cg,this.tg,c,(this.ca-this.Z.a.length|0)+c.a.length|0):C1.prototype.ql.call(this,a,b)};f.f=function(){return this.Cm()};f.Ja=function(a){return this.yo(a)};f.cc=function(a){return this.zl(a)};
+f.n=function(a){var b=a|0;if(0<=b&&b<this.ca){a=b-this.zh|0;if(0<=a){b=a>>>10|0;var c=31&(a>>>5|0);a&=31;return b<this.cg.a.length?this.cg.a[b].a[c].a[a]:c<this.tg.a.length?this.tg.a[c].a[a]:this.Z.a[a]}return b>=this.Vh?(a=b-this.Vh|0,this.Wh.a[a>>>5|0].a[31&a]):this.R.a[b]}throw this.rh(b);};f.$classData=q({T8:0},!1,"scala.collection.immutable.Vector3",{T8:1,fC:1,$y:1,Zy:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,sg:1,l:1});
+function MJ(a,b,c,d,e,g,h,k,l,m,n){this.Z=this.R=null;this.ca=0;this.Ng=b;this.ug=c;this.Og=d;this.vg=e;this.dg=g;this.Ye=h;this.qf=k;this.pf=l;L$(this,a,m,n)}MJ.prototype=new M$;MJ.prototype.constructor=MJ;f=MJ.prototype;
+f.va=function(a){if(0<=a&&a<this.ca){var b=a-this.dg|0;if(0<=b){a=b>>>15|0;var c=31&(b>>>10|0),d=31&(b>>>5|0);b&=31;return a<this.Ye.a.length?this.Ye.a[a].a[c].a[d].a[b]:c<this.qf.a.length?this.qf.a[c].a[d].a[b]:d<this.pf.a.length?this.pf.a[d].a[b]:this.Z.a[b]}return a>=this.Og?(b=a-this.Og|0,this.vg.a[b>>>10|0].a[31&(b>>>5|0)].a[31&b]):a>=this.Ng?(b=a-this.Ng|0,this.ug.a[b>>>5|0].a[31&b]):this.R.a[a]}throw this.rh(a);};
+f.$r=function(a,b){if(0<=a&&a<this.ca){if(a>=this.dg){var c=a-this.dg|0,d=c>>>15|0,e=31&(c>>>10|0);a=31&(c>>>5|0);c&=31;if(d<this.Ye.a.length){var g=this.Ye.ia(),h=g.a[d].ia(),k=h.a[e].ia(),l=k.a[a].ia();l.a[c]=b;k.a[a]=l;h.a[e]=k;g.a[d]=h;return new MJ(this.R,this.Ng,this.ug,this.Og,this.vg,this.dg,g,this.qf,this.pf,this.Z,this.ca)}if(e<this.qf.a.length)return d=this.qf.ia(),g=d.a[e].ia(),h=g.a[a].ia(),h.a[c]=b,g.a[a]=h,d.a[e]=g,new MJ(this.R,this.Ng,this.ug,this.Og,this.vg,this.dg,this.Ye,d,this.pf,
+this.Z,this.ca);if(a<this.pf.a.length)return e=this.pf.ia(),d=e.a[a].ia(),d.a[c]=b,e.a[a]=d,new MJ(this.R,this.Ng,this.ug,this.Og,this.vg,this.dg,this.Ye,this.qf,e,this.Z,this.ca);a=this.Z.ia();a.a[c]=b;return new MJ(this.R,this.Ng,this.ug,this.Og,this.vg,this.dg,this.Ye,this.qf,this.pf,a,this.ca)}if(a>=this.Og)return e=a-this.Og|0,a=e>>>10|0,c=31&(e>>>5|0),e&=31,d=this.vg.ia(),g=d.a[a].ia(),h=g.a[c].ia(),h.a[e]=b,g.a[c]=h,d.a[a]=g,new MJ(this.R,this.Ng,this.ug,this.Og,d,this.dg,this.Ye,this.qf,this.pf,
+this.Z,this.ca);if(a>=this.Ng)return c=a-this.Ng|0,a=c>>>5|0,c&=31,e=this.ug.ia(),d=e.a[a].ia(),d.a[c]=b,e.a[a]=d,new MJ(this.R,this.Ng,e,this.Og,this.vg,this.dg,this.Ye,this.qf,this.pf,this.Z,this.ca);c=this.R.ia();c.a[a]=b;return new MJ(c,this.Ng,this.ug,this.Og,this.vg,this.dg,this.Ye,this.qf,this.pf,this.Z,this.ca)}throw this.rh(a);};
+f.hn=function(a){if(32>this.Z.a.length)return a=RJ(JJ(),this.Z,a),new MJ(this.R,this.Ng,this.ug,this.Og,this.vg,this.dg,this.Ye,this.qf,this.pf,a,1+this.ca|0);if(31>this.pf.a.length){var b=SJ(JJ(),this.pf,this.Z),c=new zc(1);c.a[0]=a;return new MJ(this.R,this.Ng,this.ug,this.Og,this.vg,this.dg,this.Ye,this.qf,b,c,1+this.ca|0)}if(31>this.qf.a.length){b=SJ(JJ(),this.qf,SJ(JJ(),this.pf,this.Z));c=JJ().bd;var d=new zc(1);d.a[0]=a;return new MJ(this.R,this.Ng,this.ug,this.Og,this.vg,this.dg,this.Ye,b,
+c,d,1+this.ca|0)}if(30>this.Ye.a.length){b=SJ(JJ(),this.Ye,SJ(JJ(),this.qf,SJ(JJ(),this.pf,this.Z)));c=JJ().eg;d=JJ().bd;var e=new zc(1);e.a[0]=a;return new MJ(this.R,this.Ng,this.ug,this.Og,this.vg,this.dg,b,c,d,e,1+this.ca|0)}b=this.R;c=this.Ng;d=this.ug;e=this.Og;var g=this.vg,h=this.dg,k=this.Ye,l=this.dg,m=JJ().du,n=SJ(JJ(),this.qf,SJ(JJ(),this.pf,this.Z)),r=new (md(md(md(md(jd)))).Ia)(1);r.a[0]=n;n=JJ().eg;var v=JJ().bd,x=new zc(1);x.a[0]=a;return new NJ(b,c,d,e,g,h,k,983040+l|0,m,r,n,v,x,1+
+this.ca|0)};
+f.zl=function(a){if(32>this.Ng){var b=TJ(JJ(),a,this.R);return new MJ(b,1+this.Ng|0,this.ug,1+this.Og|0,this.vg,1+this.dg|0,this.Ye,this.qf,this.pf,this.Z,1+this.ca|0)}if(1024>this.Og)return b=new zc(1),b.a[0]=a,a=UJ(JJ(),this.R,this.ug),new MJ(b,1,a,1+this.Og|0,this.vg,1+this.dg|0,this.Ye,this.qf,this.pf,this.Z,1+this.ca|0);if(32768>this.dg){b=new zc(1);b.a[0]=a;a=JJ().bd;var c=UJ(JJ(),UJ(JJ(),this.R,this.ug),this.vg);return new MJ(b,1,a,1,c,1+this.dg|0,this.Ye,this.qf,this.pf,this.Z,1+this.ca|0)}if(30>
+this.Ye.a.length){b=new zc(1);b.a[0]=a;a=JJ().bd;c=JJ().eg;var d=UJ(JJ(),UJ(JJ(),UJ(JJ(),this.R,this.ug),this.vg),this.Ye);return new MJ(b,1,a,1,c,1,d,this.qf,this.pf,this.Z,1+this.ca|0)}b=new zc(1);b.a[0]=a;a=JJ().bd;c=JJ().eg;d=UJ(JJ(),UJ(JJ(),this.R,this.ug),this.vg);var e=new (md(md(md(md(jd)))).Ia)(1);e.a[0]=d;return new NJ(b,1,a,1,c,1,e,1+this.dg|0,JJ().du,this.Ye,this.qf,this.pf,this.Z,1+this.ca|0)};
+f.yo=function(a){var b=WJ(JJ(),this.R,a),c=XJ(JJ(),2,this.ug,a),d=XJ(JJ(),3,this.vg,a),e=XJ(JJ(),4,this.Ye,a),g=XJ(JJ(),3,this.qf,a),h=XJ(JJ(),2,this.pf,a);a=WJ(JJ(),this.Z,a);return new MJ(b,this.Ng,c,this.Og,d,this.dg,e,g,h,a,this.ca)};f.Ln=function(a,b){a=new FJ(a,b);GJ(a,1,this.R);GJ(a,2,this.ug);GJ(a,3,this.vg);GJ(a,4,this.Ye);GJ(a,3,this.qf);GJ(a,2,this.pf);GJ(a,1,this.Z);return a.im()};
+f.Cm=function(){if(1<this.Ng){var a=this.R,b=a.a.length;a=Jj(Pj(),a,1,b);return new MJ(a,-1+this.Ng|0,this.ug,-1+this.Og|0,this.vg,-1+this.dg|0,this.Ye,this.qf,this.pf,this.Z,-1+this.ca|0)}return this.Ln(1,this.ca)};f.On=function(){return 7};f.To=function(a){switch(a){case 0:return this.R;case 1:return this.ug;case 2:return this.vg;case 3:return this.Ye;case 4:return this.qf;case 5:return this.pf;case 6:return this.Z;default:throw new w(a);}};
+f.ql=function(a,b){var c=YJ(JJ(),this.Z,a);return null!==c?new MJ(this.R,this.Ng,this.ug,this.Og,this.vg,this.dg,this.Ye,this.qf,this.pf,c,(this.ca-this.Z.a.length|0)+c.a.length|0):C1.prototype.ql.call(this,a,b)};f.f=function(){return this.Cm()};f.Ja=function(a){return this.yo(a)};f.cc=function(a){return this.zl(a)};
+f.n=function(a){var b=a|0;if(0<=b&&b<this.ca){a=b-this.dg|0;if(0<=a){b=a>>>15|0;var c=31&(a>>>10|0),d=31&(a>>>5|0);a&=31;return b<this.Ye.a.length?this.Ye.a[b].a[c].a[d].a[a]:c<this.qf.a.length?this.qf.a[c].a[d].a[a]:d<this.pf.a.length?this.pf.a[d].a[a]:this.Z.a[a]}return b>=this.Og?(a=b-this.Og|0,this.vg.a[a>>>10|0].a[31&(a>>>5|0)].a[31&a]):b>=this.Ng?(a=b-this.Ng|0,this.ug.a[a>>>5|0].a[31&a]):this.R.a[b]}throw this.rh(b);};
+f.$classData=q({U8:0},!1,"scala.collection.immutable.Vector4",{U8:1,fC:1,$y:1,Zy:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,sg:1,l:1});function NJ(a,b,c,d,e,g,h,k,l,m,n,r,v,x){this.Z=this.R=null;this.ca=0;this.Vf=b;this.rf=c;this.Wf=d;this.sf=e;this.If=g;this.tf=h;this.Ze=k;this.Xd=l;this.ge=m;this.fe=n;this.ee=r;L$(this,a,v,x)}NJ.prototype=new M$;NJ.prototype.constructor=NJ;f=NJ.prototype;
+f.va=function(a){if(0<=a&&a<this.ca){var b=a-this.Ze|0;if(0<=b){a=b>>>20|0;var c=31&(b>>>15|0),d=31&(b>>>10|0),e=31&(b>>>5|0);b&=31;return a<this.Xd.a.length?this.Xd.a[a].a[c].a[d].a[e].a[b]:c<this.ge.a.length?this.ge.a[c].a[d].a[e].a[b]:d<this.fe.a.length?this.fe.a[d].a[e].a[b]:e<this.ee.a.length?this.ee.a[e].a[b]:this.Z.a[b]}return a>=this.If?(b=a-this.If|0,this.tf.a[b>>>15|0].a[31&(b>>>10|0)].a[31&(b>>>5|0)].a[31&b]):a>=this.Wf?(b=a-this.Wf|0,this.sf.a[b>>>10|0].a[31&(b>>>5|0)].a[31&b]):a>=this.Vf?
+(b=a-this.Vf|0,this.rf.a[b>>>5|0].a[31&b]):this.R.a[a]}throw this.rh(a);};
+f.$r=function(a,b){if(0<=a&&a<this.ca){if(a>=this.Ze){var c=a-this.Ze|0,d=c>>>20|0,e=31&(c>>>15|0),g=31&(c>>>10|0);a=31&(c>>>5|0);c&=31;if(d<this.Xd.a.length){var h=this.Xd.ia(),k=h.a[d].ia(),l=k.a[e].ia(),m=l.a[g].ia(),n=m.a[a].ia();n.a[c]=b;m.a[a]=n;l.a[g]=m;k.a[e]=l;h.a[d]=k;return new NJ(this.R,this.Vf,this.rf,this.Wf,this.sf,this.If,this.tf,this.Ze,h,this.ge,this.fe,this.ee,this.Z,this.ca)}if(e<this.ge.a.length)return d=this.ge.ia(),h=d.a[e].ia(),k=h.a[g].ia(),l=k.a[a].ia(),l.a[c]=b,k.a[a]=l,
+h.a[g]=k,d.a[e]=h,new NJ(this.R,this.Vf,this.rf,this.Wf,this.sf,this.If,this.tf,this.Ze,this.Xd,d,this.fe,this.ee,this.Z,this.ca);if(g<this.fe.a.length)return e=this.fe.ia(),d=e.a[g].ia(),h=d.a[a].ia(),h.a[c]=b,d.a[a]=h,e.a[g]=d,new NJ(this.R,this.Vf,this.rf,this.Wf,this.sf,this.If,this.tf,this.Ze,this.Xd,this.ge,e,this.ee,this.Z,this.ca);if(a<this.ee.a.length)return g=this.ee.ia(),e=g.a[a].ia(),e.a[c]=b,g.a[a]=e,new NJ(this.R,this.Vf,this.rf,this.Wf,this.sf,this.If,this.tf,this.Ze,this.Xd,this.ge,
+this.fe,g,this.Z,this.ca);a=this.Z.ia();a.a[c]=b;return new NJ(this.R,this.Vf,this.rf,this.Wf,this.sf,this.If,this.tf,this.Ze,this.Xd,this.ge,this.fe,this.ee,a,this.ca)}if(a>=this.If)return e=a-this.If|0,a=e>>>15|0,c=31&(e>>>10|0),g=31&(e>>>5|0),e&=31,d=this.tf.ia(),h=d.a[a].ia(),k=h.a[c].ia(),l=k.a[g].ia(),l.a[e]=b,k.a[g]=l,h.a[c]=k,d.a[a]=h,new NJ(this.R,this.Vf,this.rf,this.Wf,this.sf,this.If,d,this.Ze,this.Xd,this.ge,this.fe,this.ee,this.Z,this.ca);if(a>=this.Wf)return g=a-this.Wf|0,a=g>>>10|
+0,c=31&(g>>>5|0),g&=31,e=this.sf.ia(),d=e.a[a].ia(),h=d.a[c].ia(),h.a[g]=b,d.a[c]=h,e.a[a]=d,new NJ(this.R,this.Vf,this.rf,this.Wf,e,this.If,this.tf,this.Ze,this.Xd,this.ge,this.fe,this.ee,this.Z,this.ca);if(a>=this.Vf)return c=a-this.Vf|0,a=c>>>5|0,c&=31,g=this.rf.ia(),e=g.a[a].ia(),e.a[c]=b,g.a[a]=e,new NJ(this.R,this.Vf,g,this.Wf,this.sf,this.If,this.tf,this.Ze,this.Xd,this.ge,this.fe,this.ee,this.Z,this.ca);c=this.R.ia();c.a[a]=b;return new NJ(c,this.Vf,this.rf,this.Wf,this.sf,this.If,this.tf,
+this.Ze,this.Xd,this.ge,this.fe,this.ee,this.Z,this.ca)}throw this.rh(a);};
+f.hn=function(a){if(32>this.Z.a.length)return a=RJ(JJ(),this.Z,a),new NJ(this.R,this.Vf,this.rf,this.Wf,this.sf,this.If,this.tf,this.Ze,this.Xd,this.ge,this.fe,this.ee,a,1+this.ca|0);if(31>this.ee.a.length){var b=SJ(JJ(),this.ee,this.Z),c=new zc(1);c.a[0]=a;return new NJ(this.R,this.Vf,this.rf,this.Wf,this.sf,this.If,this.tf,this.Ze,this.Xd,this.ge,this.fe,b,c,1+this.ca|0)}if(31>this.fe.a.length){b=SJ(JJ(),this.fe,SJ(JJ(),this.ee,this.Z));c=JJ().bd;var d=new zc(1);d.a[0]=a;return new NJ(this.R,this.Vf,
+this.rf,this.Wf,this.sf,this.If,this.tf,this.Ze,this.Xd,this.ge,b,c,d,1+this.ca|0)}if(31>this.ge.a.length){b=SJ(JJ(),this.ge,SJ(JJ(),this.fe,SJ(JJ(),this.ee,this.Z)));c=JJ().eg;d=JJ().bd;var e=new zc(1);e.a[0]=a;return new NJ(this.R,this.Vf,this.rf,this.Wf,this.sf,this.If,this.tf,this.Ze,this.Xd,b,c,d,e,1+this.ca|0)}if(30>this.Xd.a.length){b=SJ(JJ(),this.Xd,SJ(JJ(),this.ge,SJ(JJ(),this.fe,SJ(JJ(),this.ee,this.Z))));c=JJ().jk;d=JJ().eg;e=JJ().bd;var g=new zc(1);g.a[0]=a;return new NJ(this.R,this.Vf,
+this.rf,this.Wf,this.sf,this.If,this.tf,this.Ze,b,c,d,e,g,1+this.ca|0)}b=this.R;c=this.Vf;d=this.rf;e=this.Wf;g=this.sf;var h=this.If,k=this.tf,l=this.Ze,m=this.Xd,n=this.Ze,r=JJ().dH,v=SJ(JJ(),this.ge,SJ(JJ(),this.fe,SJ(JJ(),this.ee,this.Z))),x=new (md(md(md(md(md(jd))))).Ia)(1);x.a[0]=v;v=JJ().jk;var A=JJ().eg,B=JJ().bd,C=new zc(1);C.a[0]=a;return new OJ(b,c,d,e,g,h,k,l,m,31457280+n|0,r,x,v,A,B,C,1+this.ca|0)};
+f.zl=function(a){if(32>this.Vf){var b=TJ(JJ(),a,this.R);return new NJ(b,1+this.Vf|0,this.rf,1+this.Wf|0,this.sf,1+this.If|0,this.tf,1+this.Ze|0,this.Xd,this.ge,this.fe,this.ee,this.Z,1+this.ca|0)}if(1024>this.Wf)return b=new zc(1),b.a[0]=a,a=UJ(JJ(),this.R,this.rf),new NJ(b,1,a,1+this.Wf|0,this.sf,1+this.If|0,this.tf,1+this.Ze|0,this.Xd,this.ge,this.fe,this.ee,this.Z,1+this.ca|0);if(32768>this.If){b=new zc(1);b.a[0]=a;a=JJ().bd;var c=UJ(JJ(),UJ(JJ(),this.R,this.rf),this.sf);return new NJ(b,1,a,1,
+c,1+this.If|0,this.tf,1+this.Ze|0,this.Xd,this.ge,this.fe,this.ee,this.Z,1+this.ca|0)}if(1048576>this.Ze){b=new zc(1);b.a[0]=a;a=JJ().bd;c=JJ().eg;var d=UJ(JJ(),UJ(JJ(),UJ(JJ(),this.R,this.rf),this.sf),this.tf);return new NJ(b,1,a,1,c,1,d,1+this.Ze|0,this.Xd,this.ge,this.fe,this.ee,this.Z,1+this.ca|0)}if(30>this.Xd.a.length){b=new zc(1);b.a[0]=a;a=JJ().bd;c=JJ().eg;d=JJ().jk;var e=UJ(JJ(),UJ(JJ(),UJ(JJ(),UJ(JJ(),this.R,this.rf),this.sf),this.tf),this.Xd);return new NJ(b,1,a,1,c,1,d,1,e,this.ge,this.fe,
+this.ee,this.Z,1+this.ca|0)}b=new zc(1);b.a[0]=a;a=JJ().bd;c=JJ().eg;d=JJ().jk;e=UJ(JJ(),UJ(JJ(),UJ(JJ(),this.R,this.rf),this.sf),this.tf);var g=new (md(md(md(md(md(jd))))).Ia)(1);g.a[0]=e;return new OJ(b,1,a,1,c,1,d,1,g,1+this.Ze|0,JJ().dH,this.Xd,this.ge,this.fe,this.ee,this.Z,1+this.ca|0)};
+f.yo=function(a){var b=WJ(JJ(),this.R,a),c=XJ(JJ(),2,this.rf,a),d=XJ(JJ(),3,this.sf,a),e=XJ(JJ(),4,this.tf,a),g=XJ(JJ(),5,this.Xd,a),h=XJ(JJ(),4,this.ge,a),k=XJ(JJ(),3,this.fe,a),l=XJ(JJ(),2,this.ee,a);a=WJ(JJ(),this.Z,a);return new NJ(b,this.Vf,c,this.Wf,d,this.If,e,this.Ze,g,h,k,l,a,this.ca)};f.Ln=function(a,b){a=new FJ(a,b);GJ(a,1,this.R);GJ(a,2,this.rf);GJ(a,3,this.sf);GJ(a,4,this.tf);GJ(a,5,this.Xd);GJ(a,4,this.ge);GJ(a,3,this.fe);GJ(a,2,this.ee);GJ(a,1,this.Z);return a.im()};
+f.Cm=function(){if(1<this.Vf){var a=this.R,b=a.a.length;a=Jj(Pj(),a,1,b);return new NJ(a,-1+this.Vf|0,this.rf,-1+this.Wf|0,this.sf,-1+this.If|0,this.tf,-1+this.Ze|0,this.Xd,this.ge,this.fe,this.ee,this.Z,-1+this.ca|0)}return this.Ln(1,this.ca)};f.On=function(){return 9};
+f.To=function(a){switch(a){case 0:return this.R;case 1:return this.rf;case 2:return this.sf;case 3:return this.tf;case 4:return this.Xd;case 5:return this.ge;case 6:return this.fe;case 7:return this.ee;case 8:return this.Z;default:throw new w(a);}};f.ql=function(a,b){var c=YJ(JJ(),this.Z,a);return null!==c?new NJ(this.R,this.Vf,this.rf,this.Wf,this.sf,this.If,this.tf,this.Ze,this.Xd,this.ge,this.fe,this.ee,c,(this.ca-this.Z.a.length|0)+c.a.length|0):C1.prototype.ql.call(this,a,b)};f.f=function(){return this.Cm()};
+f.Ja=function(a){return this.yo(a)};f.cc=function(a){return this.zl(a)};
+f.n=function(a){var b=a|0;if(0<=b&&b<this.ca){a=b-this.Ze|0;if(0<=a){b=a>>>20|0;var c=31&(a>>>15|0),d=31&(a>>>10|0),e=31&(a>>>5|0);a&=31;return b<this.Xd.a.length?this.Xd.a[b].a[c].a[d].a[e].a[a]:c<this.ge.a.length?this.ge.a[c].a[d].a[e].a[a]:d<this.fe.a.length?this.fe.a[d].a[e].a[a]:e<this.ee.a.length?this.ee.a[e].a[a]:this.Z.a[a]}return b>=this.If?(a=b-this.If|0,this.tf.a[a>>>15|0].a[31&(a>>>10|0)].a[31&(a>>>5|0)].a[31&a]):b>=this.Wf?(a=b-this.Wf|0,this.sf.a[a>>>10|0].a[31&(a>>>5|0)].a[31&a]):b>=
+this.Vf?(a=b-this.Vf|0,this.rf.a[a>>>5|0].a[31&a]):this.R.a[b]}throw this.rh(b);};f.$classData=q({V8:0},!1,"scala.collection.immutable.Vector5",{V8:1,fC:1,$y:1,Zy:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,sg:1,l:1});
+function OJ(a,b,c,d,e,g,h,k,l,m,n,r,v,x,A,B,C){this.Z=this.R=null;this.ca=0;this.uf=b;this.Ge=c;this.vf=d;this.He=e;this.$e=g;this.Ie=h;this.Ee=k;this.Je=l;this.Fe=m;this.rd=n;this.Nd=r;this.Md=v;this.Ld=x;this.Kd=A;L$(this,a,B,C)}OJ.prototype=new M$;OJ.prototype.constructor=OJ;f=OJ.prototype;
+f.va=function(a){if(0<=a&&a<this.ca){var b=a-this.Fe|0;if(0<=b){a=b>>>25|0;var c=31&(b>>>20|0),d=31&(b>>>15|0),e=31&(b>>>10|0),g=31&(b>>>5|0);b&=31;return a<this.rd.a.length?this.rd.a[a].a[c].a[d].a[e].a[g].a[b]:c<this.Nd.a.length?this.Nd.a[c].a[d].a[e].a[g].a[b]:d<this.Md.a.length?this.Md.a[d].a[e].a[g].a[b]:e<this.Ld.a.length?this.Ld.a[e].a[g].a[b]:g<this.Kd.a.length?this.Kd.a[g].a[b]:this.Z.a[b]}return a>=this.Ee?(b=a-this.Ee|0,this.Je.a[b>>>20|0].a[31&(b>>>15|0)].a[31&(b>>>10|0)].a[31&(b>>>5|
+0)].a[31&b]):a>=this.$e?(b=a-this.$e|0,this.Ie.a[b>>>15|0].a[31&(b>>>10|0)].a[31&(b>>>5|0)].a[31&b]):a>=this.vf?(b=a-this.vf|0,this.He.a[b>>>10|0].a[31&(b>>>5|0)].a[31&b]):a>=this.uf?(b=a-this.uf|0,this.Ge.a[b>>>5|0].a[31&b]):this.R.a[a]}throw this.rh(a);};
+f.$r=function(a,b){if(0<=a&&a<this.ca){if(a>=this.Fe){var c=a-this.Fe|0,d=c>>>25|0,e=31&(c>>>20|0),g=31&(c>>>15|0),h=31&(c>>>10|0);a=31&(c>>>5|0);c&=31;if(d<this.rd.a.length){var k=this.rd.ia(),l=k.a[d].ia(),m=l.a[e].ia(),n=m.a[g].ia(),r=n.a[h].ia(),v=r.a[a].ia();v.a[c]=b;r.a[a]=v;n.a[h]=r;m.a[g]=n;l.a[e]=m;k.a[d]=l;return new OJ(this.R,this.uf,this.Ge,this.vf,this.He,this.$e,this.Ie,this.Ee,this.Je,this.Fe,k,this.Nd,this.Md,this.Ld,this.Kd,this.Z,this.ca)}if(e<this.Nd.a.length)return d=this.Nd.ia(),
+k=d.a[e].ia(),l=k.a[g].ia(),m=l.a[h].ia(),n=m.a[a].ia(),n.a[c]=b,m.a[a]=n,l.a[h]=m,k.a[g]=l,d.a[e]=k,new OJ(this.R,this.uf,this.Ge,this.vf,this.He,this.$e,this.Ie,this.Ee,this.Je,this.Fe,this.rd,d,this.Md,this.Ld,this.Kd,this.Z,this.ca);if(g<this.Md.a.length)return e=this.Md.ia(),d=e.a[g].ia(),k=d.a[h].ia(),l=k.a[a].ia(),l.a[c]=b,k.a[a]=l,d.a[h]=k,e.a[g]=d,new OJ(this.R,this.uf,this.Ge,this.vf,this.He,this.$e,this.Ie,this.Ee,this.Je,this.Fe,this.rd,this.Nd,e,this.Ld,this.Kd,this.Z,this.ca);if(h<this.Ld.a.length)return g=
+this.Ld.ia(),e=g.a[h].ia(),d=e.a[a].ia(),d.a[c]=b,e.a[a]=d,g.a[h]=e,new OJ(this.R,this.uf,this.Ge,this.vf,this.He,this.$e,this.Ie,this.Ee,this.Je,this.Fe,this.rd,this.Nd,this.Md,g,this.Kd,this.Z,this.ca);if(a<this.Kd.a.length)return h=this.Kd.ia(),g=h.a[a].ia(),g.a[c]=b,h.a[a]=g,new OJ(this.R,this.uf,this.Ge,this.vf,this.He,this.$e,this.Ie,this.Ee,this.Je,this.Fe,this.rd,this.Nd,this.Md,this.Ld,h,this.Z,this.ca);a=this.Z.ia();a.a[c]=b;return new OJ(this.R,this.uf,this.Ge,this.vf,this.He,this.$e,this.Ie,
+this.Ee,this.Je,this.Fe,this.rd,this.Nd,this.Md,this.Ld,this.Kd,a,this.ca)}if(a>=this.Ee)return e=a-this.Ee|0,a=e>>>20|0,c=31&(e>>>15|0),h=31&(e>>>10|0),g=31&(e>>>5|0),e&=31,d=this.Je.ia(),k=d.a[a].ia(),l=k.a[c].ia(),m=l.a[h].ia(),n=m.a[g].ia(),n.a[e]=b,m.a[g]=n,l.a[h]=m,k.a[c]=l,d.a[a]=k,new OJ(this.R,this.uf,this.Ge,this.vf,this.He,this.$e,this.Ie,this.Ee,d,this.Fe,this.rd,this.Nd,this.Md,this.Ld,this.Kd,this.Z,this.ca);if(a>=this.$e)return g=a-this.$e|0,a=g>>>15|0,c=31&(g>>>10|0),h=31&(g>>>5|0),
+g&=31,e=this.Ie.ia(),d=e.a[a].ia(),k=d.a[c].ia(),l=k.a[h].ia(),l.a[g]=b,k.a[h]=l,d.a[c]=k,e.a[a]=d,new OJ(this.R,this.uf,this.Ge,this.vf,this.He,this.$e,e,this.Ee,this.Je,this.Fe,this.rd,this.Nd,this.Md,this.Ld,this.Kd,this.Z,this.ca);if(a>=this.vf)return h=a-this.vf|0,a=h>>>10|0,c=31&(h>>>5|0),h&=31,g=this.He.ia(),e=g.a[a].ia(),d=e.a[c].ia(),d.a[h]=b,e.a[c]=d,g.a[a]=e,new OJ(this.R,this.uf,this.Ge,this.vf,g,this.$e,this.Ie,this.Ee,this.Je,this.Fe,this.rd,this.Nd,this.Md,this.Ld,this.Kd,this.Z,this.ca);
+if(a>=this.uf)return c=a-this.uf|0,a=c>>>5|0,c&=31,h=this.Ge.ia(),g=h.a[a].ia(),g.a[c]=b,h.a[a]=g,new OJ(this.R,this.uf,h,this.vf,this.He,this.$e,this.Ie,this.Ee,this.Je,this.Fe,this.rd,this.Nd,this.Md,this.Ld,this.Kd,this.Z,this.ca);c=this.R.ia();c.a[a]=b;return new OJ(c,this.uf,this.Ge,this.vf,this.He,this.$e,this.Ie,this.Ee,this.Je,this.Fe,this.rd,this.Nd,this.Md,this.Ld,this.Kd,this.Z,this.ca)}throw this.rh(a);};
+f.hn=function(a){if(32>this.Z.a.length)return a=RJ(JJ(),this.Z,a),new OJ(this.R,this.uf,this.Ge,this.vf,this.He,this.$e,this.Ie,this.Ee,this.Je,this.Fe,this.rd,this.Nd,this.Md,this.Ld,this.Kd,a,1+this.ca|0);if(31>this.Kd.a.length){var b=SJ(JJ(),this.Kd,this.Z),c=new zc(1);c.a[0]=a;return new OJ(this.R,this.uf,this.Ge,this.vf,this.He,this.$e,this.Ie,this.Ee,this.Je,this.Fe,this.rd,this.Nd,this.Md,this.Ld,b,c,1+this.ca|0)}if(31>this.Ld.a.length){b=SJ(JJ(),this.Ld,SJ(JJ(),this.Kd,this.Z));c=JJ().bd;
+var d=new zc(1);d.a[0]=a;return new OJ(this.R,this.uf,this.Ge,this.vf,this.He,this.$e,this.Ie,this.Ee,this.Je,this.Fe,this.rd,this.Nd,this.Md,b,c,d,1+this.ca|0)}if(31>this.Md.a.length){b=SJ(JJ(),this.Md,SJ(JJ(),this.Ld,SJ(JJ(),this.Kd,this.Z)));c=JJ().eg;d=JJ().bd;var e=new zc(1);e.a[0]=a;return new OJ(this.R,this.uf,this.Ge,this.vf,this.He,this.$e,this.Ie,this.Ee,this.Je,this.Fe,this.rd,this.Nd,b,c,d,e,1+this.ca|0)}if(31>this.Nd.a.length){b=SJ(JJ(),this.Nd,SJ(JJ(),this.Md,SJ(JJ(),this.Ld,SJ(JJ(),
+this.Kd,this.Z))));c=JJ().jk;d=JJ().eg;e=JJ().bd;var g=new zc(1);g.a[0]=a;return new OJ(this.R,this.uf,this.Ge,this.vf,this.He,this.$e,this.Ie,this.Ee,this.Je,this.Fe,this.rd,b,c,d,e,g,1+this.ca|0)}if(62>this.rd.a.length){b=SJ(JJ(),this.rd,SJ(JJ(),this.Nd,SJ(JJ(),this.Md,SJ(JJ(),this.Ld,SJ(JJ(),this.Kd,this.Z)))));c=JJ().du;d=JJ().jk;e=JJ().eg;g=JJ().bd;var h=new zc(1);h.a[0]=a;return new OJ(this.R,this.uf,this.Ge,this.vf,this.He,this.$e,this.Ie,this.Ee,this.Je,this.Fe,b,c,d,e,g,h,1+this.ca|0)}throw UL();
 };
-f.pl=function(a){if(32>this.hf){var b=CJ(sJ(),a,this.R);return new xJ(b,1+this.hf|0,this.je,1+this.jf|0,this.ke,1+this.Fe|0,this.le,1+this.he|0,this.me,1+this.ie|0,this.hd,this.sd,this.rd,this.qd,this.pd,this.$,1+this.ba|0)}if(1024>this.jf)return b=new jd(1),b.a[0]=a,a=DJ(sJ(),this.R,this.je),new xJ(b,1,a,1+this.jf|0,this.ke,1+this.Fe|0,this.le,1+this.he|0,this.me,1+this.ie|0,this.hd,this.sd,this.rd,this.qd,this.pd,this.$,1+this.ba|0);if(32768>this.Fe){b=new jd(1);b.a[0]=a;a=sJ().Sc;var c=DJ(sJ(),DJ(sJ(),
-this.R,this.je),this.ke);return new xJ(b,1,a,1,c,1+this.Fe|0,this.le,1+this.he|0,this.me,1+this.ie|0,this.hd,this.sd,this.rd,this.qd,this.pd,this.$,1+this.ba|0)}if(1048576>this.he){b=new jd(1);b.a[0]=a;a=sJ().Sc;c=sJ().Xf;var d=DJ(sJ(),DJ(sJ(),DJ(sJ(),this.R,this.je),this.ke),this.le);return new xJ(b,1,a,1,c,1,d,1+this.he|0,this.me,1+this.ie|0,this.hd,this.sd,this.rd,this.qd,this.pd,this.$,1+this.ba|0)}if(33554432>this.ie){b=new jd(1);b.a[0]=a;a=sJ().Sc;c=sJ().Xf;d=sJ().Zj;var e=DJ(sJ(),DJ(sJ(),DJ(sJ(),
-DJ(sJ(),this.R,this.je),this.ke),this.le),this.me);return new xJ(b,1,a,1,c,1,d,1,e,1+this.ie|0,this.hd,this.sd,this.rd,this.qd,this.pd,this.$,1+this.ba|0)}if(62>this.hd.a.length){b=new jd(1);b.a[0]=a;a=sJ().Sc;c=sJ().Xf;d=sJ().Zj;e=sJ().wt;var g=DJ(sJ(),DJ(sJ(),DJ(sJ(),DJ(sJ(),DJ(sJ(),this.R,this.je),this.ke),this.le),this.me),this.hd);return new xJ(b,1,a,1,c,1,d,1,e,1,g,this.sd,this.rd,this.qd,this.pd,this.$,1+this.ba|0)}throw DL();};
-f.Tn=function(a){var b=FJ(sJ(),this.R,a),c=GJ(sJ(),2,this.je,a),d=GJ(sJ(),3,this.ke,a),e=GJ(sJ(),4,this.le,a),g=GJ(sJ(),5,this.me,a),h=GJ(sJ(),6,this.hd,a),k=GJ(sJ(),5,this.sd,a),l=GJ(sJ(),4,this.rd,a),m=GJ(sJ(),3,this.qd,a),n=GJ(sJ(),2,this.pd,a);a=FJ(sJ(),this.$,a);return new xJ(b,this.hf,c,this.jf,d,this.Fe,e,this.he,g,this.ie,h,k,l,m,n,a,this.ba)};
-f.pn=function(a,b){a=new oJ(a,b);pJ(a,1,this.R);pJ(a,2,this.je);pJ(a,3,this.ke);pJ(a,4,this.le);pJ(a,5,this.me);pJ(a,6,this.hd);pJ(a,5,this.sd);pJ(a,4,this.rd);pJ(a,3,this.qd);pJ(a,2,this.pd);pJ(a,1,this.$);return a.Vl()};f.jm=function(){if(1<this.hf){var a=this.R,b=a.a.length;a=ck(fk(),a,1,b);return new xJ(a,-1+this.hf|0,this.je,-1+this.jf|0,this.ke,-1+this.Fe|0,this.le,-1+this.he|0,this.me,-1+this.ie|0,this.hd,this.sd,this.rd,this.qd,this.pd,this.$,-1+this.ba|0)}return this.pn(1,this.ba)};
-f.rn=function(){return 11};f.oo=function(a){switch(a){case 0:return this.R;case 1:return this.je;case 2:return this.ke;case 3:return this.le;case 4:return this.me;case 5:return this.hd;case 6:return this.sd;case 7:return this.rd;case 8:return this.qd;case 9:return this.pd;case 10:return this.$;default:throw new x(a);}};
-f.el=function(a,b){var c=HJ(sJ(),this.$,a);return null!==c?new xJ(this.R,this.hf,this.je,this.jf,this.ke,this.Fe,this.le,this.he,this.me,this.ie,this.hd,this.sd,this.rd,this.qd,this.pd,c,(this.ba-this.$.a.length|0)+c.a.length|0):r1.prototype.el.call(this,a,b)};f.g=function(){return this.jm()};f.Ga=function(a){return this.Tn(a)};f.Zb=function(a){return this.pl(a)};
-f.n=function(a){var b=a|0;if(0<=b&&b<this.ba){a=b-this.ie|0;if(0<=a){b=a>>>25|0;var c=31&(a>>>20|0),d=31&(a>>>15|0),e=31&(a>>>10|0),g=31&(a>>>5|0);a&=31;return b<this.hd.a.length?this.hd.a[b].a[c].a[d].a[e].a[g].a[a]:c<this.sd.a.length?this.sd.a[c].a[d].a[e].a[g].a[a]:d<this.rd.a.length?this.rd.a[d].a[e].a[g].a[a]:e<this.qd.a.length?this.qd.a[e].a[g].a[a]:g<this.pd.a.length?this.pd.a[g].a[a]:this.$.a[a]}return b>=this.he?(a=b-this.he|0,this.me.a[a>>>20|0].a[31&(a>>>15|0)].a[31&(a>>>10|0)].a[31&(a>>>
-5|0)].a[31&a]):b>=this.Fe?(a=b-this.Fe|0,this.le.a[a>>>15|0].a[31&(a>>>10|0)].a[31&(a>>>5|0)].a[31&a]):b>=this.jf?(a=b-this.jf|0,this.ke.a[a>>>10|0].a[31&(a>>>5|0)].a[31&a]):b>=this.hf?(a=b-this.hf|0,this.je.a[a>>>5|0].a[31&a]):this.R.a[b]}throw this.hh(b);};f.$classData=q({q8:0},!1,"scala.collection.immutable.Vector6",{q8:1,HB:1,Dy:1,Cy:1,kh:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,Dg:1,sc:1,Sg:1,Ih:1,Zc:1,Sb:1,ki:1,Kh:1,$c:1,Ab:1,jg:1,l:1});
-function re(){var a=new J$;a.mf=CQ(new rq);return a}function J$(){this.mf=null}J$.prototype=new v9;J$.prototype.constructor=J$;f=J$.prototype;f.Hc=function(){return"IndexedSeq"};f.m=function(){var a=new $X(this);return Vq(new Wq,a)};f.Ad=function(){var a=new $X(this);return sZ(new tZ,a)};f.we=function(a,b){return b0(this,a,b)};f.Rc=function(){return new Q8(this)};f.Zb=function(a){return c0(this,a)};f.Cc=function(a){return f0(this,a)};f.zb=function(a){return this.qc(O8(new P8,this,a))};
-f.Ga=function(a){return i0(this,a)};f.e=function(){return hd(this.mf.ha.charCodeAt(0))};f.Fc=function(){return zF(this)};f.$a=function(a){var b=this.mf.K();return b===a?0:b<a?-1:1};f.Pd=function(){};f.oc=function(a){return cR(this,a)};f.hi=function(){return RV(new SV,re())};f.K=function(){return this.mf.K()};f.Q=function(){return this.mf.K()};function se(a,b){a=a.mf;a.ha=""+a.ha+b}f.u=function(){return this.mf.ha};
-f.vj=function(a){if(a.jh()===ma(Vd)){a=this.mf.K();var b=new td(a);A2(this.mf.ha,a,b,0);a=b}else a=LA(this,a);return a};function K$(a,b){if(b instanceof Uq){var c=a.mf;BZ();c.ha=""+c.ha+b.Nh}else if(b instanceof rQ)qW(a.mf,b.hn);else if(b instanceof J$)c=a.mf,c.ha=""+c.ha+b.mf;else{var d=b.Q();if(0!==d)for(c=a.mf,0<d&&c.K(),b=b.m();b.s();)d=Eb(b.t()),d=String.fromCharCode(d),c.ha=""+c.ha+d}return a}f.NL=function(a,b){return this.mf.ha.substring(a,b)};f.b=function(){return 0===this.mf.K()};
-f.Ob=function(){W1||(W1=new V1);return W1};f.Eb=function(){return this.mf.ha};f.S=function(a){var b=this.mf;a=String.fromCharCode(Eb(a));b.ha=""+b.ha+a;return this};f.qc=function(a){return K$(re(),a)};f.vk=function(a){return K$(re(),a)};f.n=function(a){return hd(this.mf.ha.charCodeAt(a|0))};f.ua=function(a){return hd(this.mf.ha.charCodeAt(a))};
-f.$classData=q({c$:0},!1,"scala.collection.mutable.StringBuilder",{c$:1,$j:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,dk:1,Vg:1,ek:1,Ug:1,vf:1,io:1,og:1,lf:1,kf:1,Mk:1,Zc:1,Sb:1,Nk:1,HJ:1,l:1});function L$(a,b){null===b.Vv?a.kn=b.gm:b.Vv.gm=b.gm;null===b.gm?a.Xv=b.Vv:b.gm.Vv=b.Vv;b.Vv=null;b.gm=null}function Nz(){this.Xv=this.kn=this.Bl=null;this.Bl=new UV(this)}Nz.prototype=new V9;Nz.prototype.constructor=Nz;f=Nz.prototype;f.Ux=function(a){return S5(this,a)};
-f.Ol=function(a){return T5(this,a)};f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.zb=function(a){return YY(this,a)};f.pj=function(){TV||(TV=new PV);return TV};f.gB=function(){if(0<this.ka())return G(new H,this.Xv.Wv,this.Xv.jn);throw iH("Cannot call .last on empty LinkedHashMap");};f.SA=function(){if(0<this.ka())return G(new H,this.kn.Wv,this.kn.jn);throw iH("Cannot call .head on empty LinkedHashMap");};f.ka=function(){return this.Bl.Ft()};f.Q=function(){return this.ka()};
-f.b=function(){return 0===this.Bl.Ft()};f.Y=function(a){a=dR(this.Bl,a);return null===a?R():new M(a.jn)};f.L=function(a){return ja(this)===ma(M$)?null!==dR(this.Bl,a):!this.Y(a).b()};f.Vi=function(a,b){a=jR(this.Bl,a,b);null===a?R():a.jn=b};f.Qh=function(a,b){a=jR(this.Bl,a,b);null!==a&&(a.jn=b)};f.lB=function(a){a=kR(this.Bl,a);null===a?R():L$(this,a)};f.m=function(){return new Qz(this)};f.Pq=function(){return new g9(this)};f.oj=function(){return new X1(this)};
-f.Gt=function(a,b){var c=this.Bl,d=dy(W(),a);c=eR(c,d);d=fR(this.Bl,a,c);var e=null===d?R():new M(d.jn);b=b.n(e);e=G(new H,e,b);var g=e.z,h=e.x;if(R()!==g||R()!==h)if(g=e.x,e.z instanceof M&&R()===g)L$(this,d),lR(this.Bl,a,c);else if(h=e.z,g=e.x,R()===h&&g instanceof M)d=this.Bl,a=this.Bl.jJ(a,g.k),gR(d,a,c);else if(a=e.x,e.z instanceof M&&a instanceof M)d.jn=a.k;else throw new x(e);return b};f.Qd=function(){return new Y1(this)};
-f.ya=function(a){for(var b=this.kn;null!==b;)a.n(G(new H,b.Wv,b.jn)),b=b.gm};f.Ag=function(a){for(var b=this.kn;null!==b;)a.aa(b.Wv,b.jn),b=b.gm};f.eg=function(){for(var a=this.Bl,b=-1+a.Qk().a.length|0;0<=b;)a.Qk().a[b]=null,b=-1+b|0;a.My(0);iR(a,0);this.Xv=this.kn=null};f.Hc=function(){return"LinkedHashMap"};f.im=function(a){this.lB(a)};f.S=function(a){this.Vi(a.i(),a.j());return this};f.e=function(){return this.SA()};f.Fc=function(){return this.gB()};
-var M$=q({t9:0},!1,"scala.collection.mutable.LinkedHashMap",{t9:1,JG:1,$l:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Ak:1,Uj:1,za:1,ja:1,dm:1,v:1,eC:1,Vg:1,RG:1,Ug:1,vf:1,og:1,lf:1,kf:1,nn:1,qba:1,iba:1,Ab:1,vG:1,jg:1,l:1});Nz.prototype.$classData=M$;function N$(a){var b=Vo(new Wo,a);a.ln=b.ln;a.go=b.go;a.cC=!1}function Wo(){this.go=this.ln=null;this.cC=!1;this.dC=this.mn=0;this.ln=v();this.go=null;this.cC=!1;this.mn=0}Wo.prototype=new T9;Wo.prototype.constructor=Wo;f=Wo.prototype;f.Pd=function(){};
-f.zi=function(a){return u3(this,a)};f.Zb=function(a){return v3(this,a)};f.Hm=function(a){return w3(this,a)};f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.uk=function(a){return XY(this,a)};f.zb=function(a){return YY(this,a)};f.m=function(){return new c2(this.ln.m(),new U(()=>this.dC))};f.yk=function(){return b2()};f.ua=function(a){return FA(this.ln,a)};f.K=function(){return this.mn};f.Q=function(){return this.mn};f.b=function(){return 0===this.mn};
-f.ea=function(){this.cC=!this.b();return this.ln};function ip(a,b){a.dC=1+a.dC|0;a.cC&&N$(a);b=new A(b,v());0===a.mn?a.ln=b:a.go.r=b;a.go=b;a.mn=1+a.mn|0;return a}function Vo(a,b){b=b.m();if(b.s()){var c=1,d=new A(b.t(),v());for(a.ln=d;b.s();){var e=new A(b.t(),v());d=d.r=e;c=1+c|0}a.mn=c;a.go=d}return a}f.Fc=function(){if(null===this.go)throw iH("last of empty ListBuffer");return this.go.A};f.Hc=function(){return"ListBuffer"};
-f.oc=function(a){a=a.m();a.s()&&(a=Vo(new Wo,a),this.dC=1+this.dC|0,this.cC&&N$(this),0===this.mn?this.ln=a.ln:this.go.r=a.ln,this.go=a.go,this.mn=this.mn+a.mn|0);return this};f.S=function(a){return ip(this,a)};f.Eb=function(){return this.ea()};f.n=function(a){return FA(this.ln,a|0)};f.Ob=function(){return b2()};
-f.$classData=q({G9:0},!1,"scala.collection.mutable.ListBuffer",{G9:1,RB:1,$j:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,dk:1,Vg:1,ek:1,Ug:1,vf:1,TB:1,lf:1,kf:1,nn:1,$c:1,Ab:1,io:1,og:1,jg:1,l:1});function O$(a,b){return b===a.od?a:vV(new uV,b,a.Be)}function vV(a,b,c){a.od=b;a.Be=c;return a}function xV(a){var b=new uV;vV(b,null,a);return b}function uV(){this.Be=this.od=null}uV.prototype=new i9;uV.prototype.constructor=uV;f=uV.prototype;
-f.OQ=function(a,b){b=this.zp().bv(b);for(var c=this.m();c.s();){var d=a.n(c.t());b.S(d)}return b.Eb()};f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.Hc=function(){return"SortedMap"};f.hi=function(){return new wV(this.Be)};f.Wd=function(){return this.Be};f.zp=function(){return zV()};f.m=function(){XI();var a=this.od;XI();var b=R();return new U3(a,b,this.Be)};f.Y=function(a){XI();a=PI(0,this.od,a,this.Be);return null===a?R():new M(a.Tb)};
-f.yd=function(a,b){a=PI(XI(),this.od,a,this.Be);return null===a?Zr(b):a.Tb};function P$(a,b,c){return O$(a,QI(XI(),a.od,b,c,!0,a.Be))}function Q$(a,b){a:{if(b instanceof uV){var c=a.Be,d=b.Be;if(null===c?null===d:c.h(d)){b=WI(XI(),a.od,b.od,a.Be);break a}}if(b&&b.$classData&&b.$classData.pb.sL)if(b.b())b=a.od;else{for(c=new mZ(a);!b.b();)d=b.e(),c.ut=XQ(c,c.ut,d.i(),d.j()),b=b.g();b=$I(c.ut)}else{c=new mZ(a);for(b=b.m();b.s();)d=b.t(),c.ut=XQ(c,c.ut,d.i(),d.j());b=$I(c.ut)}}return O$(a,b)}
-f.ya=function(a){var b=XI(),c=this.od;null!==c&&Uba(b,c,a)};f.Ag=function(a){var b=XI(),c=this.od;null!==c&&Yba(b,c,a)};f.ka=function(){return nI(XI(),this.od)};f.Q=function(){return nI(XI(),this.od)};f.b=function(){return 0===nI(XI(),this.od)};f.SA=function(){var a=RI(XI(),this.od);return G(new H,a.Wa,a.Tb)};f.gB=function(){var a=SI(XI(),this.od);return G(new H,a.Wa,a.Tb)};function Uea(a,b){return O$(a,UI(XI(),a.od,new Um((c,d)=>!!b.n(G(new H,c,d)))))}
-f.jK=function(a){var b=nca(XI(),this.od,new Um((d,e)=>!!a.n(G(new H,d,e))));if(null===b)throw new x(b);var c=b.j();return G(new H,O$(this,b.i()),O$(this,c))};
-f.h=function(a){if(a instanceof uV){var b=this.Be,c=a.Be;if(null===b?null===c:b.h(c)){XI();b=this.od;a=a.od;c=this.Be;var d;if(!(d=b===a)&&(d=null!==b)&&(d=null!==a)&&(d=(2147483647&b.da)===(2147483647&a.da))){b=new V3(b,c);a=new V3(a,c);for(c=!0;c&&null!==b.zc&&null!==a.zc;)b.zc===a.zc?(0===b.Ed?d=null:(b.Ed=-1+b.Ed|0,d=b.fn.a[b.Ed]),b.zc=d,0===a.Ed?d=null:(a.Ed=-1+a.Ed|0,d=a.fn.a[a.Ed]),a.zc=d):(c=Object.is(b.zc.Wa,a.zc.Wa)||b.Gv.lj(b.zc.Wa,a.zc.Wa)?Ol(Pl(),b.zc.Tb,a.zc.Tb):!1,b.zc=g1(b,b.zc.sa),
-a.zc=g1(a,a.zc.sa));d=c&&null===b.zc&&null===a.zc}return d}}return S8(this,a)};f.xh=function(){return"TreeMap"};f.oe=function(a){return Q$(this,a)};f.qc=function(a){return tV(zV(),a,this.Be)};f.vk=function(a){return tV(zV(),a,this.Be)};f.kC=function(a,b){return f8(this,a,b)};f.mm=function(a){return P$(this,a.i(),a.j())};f.SL=function(a){return G9(this,a)};f.uk=function(a){return Uea(this,a)};
-f.zb=function(a){var b=nI(XI(),this.od)-(0<a?a:0)|0;if(0>=b)a=xV(this.Be);else if(b>=nI(XI(),this.od))a=this;else{a=new uV;var c=XI();b=ZH(qI(c,this.od,b));a=vV(a,b,this.Be)}return a};f.Cc=function(a){if(0>=a)var b=this;else if(a>=nI(XI(),this.od))b=xV(this.Be);else{b=new uV;var c=XI();a=ZH(pI(c,this.od,a));b=vV(b,a,this.Be)}return b};f.Fc=function(){return this.gB()};f.e=function(){return this.SA()};
-f.IF=function(a){a:{if(a instanceof pZ){var b=this.Be,c=a.Ce;if(null===b?null===c:b.h(c)){b=XI();a=ZH(GI(b,this.od,a.xf,this.Be));a=O$(this,a);break a}}a=n5(this,a)}return a};f.Ol=function(a){return Q$(this,a)};f.OA=function(a){return Q$(this,a)};f.lm=function(a,b){return P$(this,a,b)};f.km=function(a,b){return P$(this,a,b)};f.rj=function(a){var b=XI();a=ZH(yI(b,this.od,a,this.Be));return O$(this,a)};f.Pq=function(){return qZ(new pZ,this.od,this.Be)};f.$s=function(){return qZ(new pZ,this.od,this.Be)};
-f.eB=function(){return qZ(new pZ,this.od,this.Be)};f.$classData=q({a8:0},!1,"scala.collection.immutable.TreeMap",{a8:1,jt:1,$l:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Ak:1,Uj:1,za:1,ja:1,dm:1,v:1,er:1,sc:1,pt:1,mS:1,zB:1,hL:1,ly:1,gL:1,V7:1,mba:1,E5:1,vG:1,Ab:1,Z7:1,jg:1,l:1});function R$(a,b){this.Zv=this.Oh=null;I9(this,a,b)}R$.prototype=new h$;R$.prototype.constructor=R$;f=R$.prototype;f.Hc=function(){return"SortedMap"};f.h=function(a){return S8(this,a)};f.zp=function(){return this.Oh.zp()};f.Wd=function(){return this.Oh.Wd()};
-function S$(a,b){b=a.Oh.OA(b);return new R$(b,a.Zv)}function T$(a,b){return new R$(a.Oh.zp().Fq(b,a.Oh.Wd()),a.Zv)}f.oe=function(a){return S$(this,a)};f.Pq=function(){return new Z8(this)};f.TL=function(a){return new R$(this,a)};f.qc=function(a){return T$(this,a)};f.vk=function(a){return T$(this,a)};f.rJ=function(a){return T$(this,a)};f.Ol=function(a){return S$(this,a)};f.PP=function(a){return S$(this,a)};f.OA=function(a){return S$(this,a)};f.S=function(a){this.Oh.S(a);return this};
-f.KP=function(a){this.Oh.S(a);return this};f.im=function(a){this.Oh.im(a)};f.WS=function(a){this.Oh.im(a)};f.$classData=q({Z9:0},!1,"scala.collection.mutable.SortedMap$WithDefault",{Z9:1,NS:1,JG:1,$l:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Ak:1,Uj:1,za:1,ja:1,dm:1,v:1,eC:1,Vg:1,RG:1,Ug:1,vf:1,og:1,lf:1,kf:1,nn:1,l:1,X9:1,zB:1,hL:1,ly:1,gL:1,$9:1});function w1(a,b,c){a.yt=0;a.xt=b;a.Tg=c;return a}function Nl(){var a=new x1;w1(a,new jd(16),0);return a}
-function $u(a){var b=new x1;w1(b,new jd(1<a?a:1),0);return b}function x1(){this.yt=0;this.xt=null;this.Tg=0}x1.prototype=new T9;x1.prototype.constructor=x1;f=x1.prototype;f.zi=function(a){return u3(this,a)};f.Zb=function(a){return v3(this,a)};f.Hm=function(a){return w3(this,a)};f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.uk=function(a){return XY(this,a)};f.zb=function(a){return YY(this,a)};f.m=function(){return Sl(this).m()};f.Ad=function(){return Sl(this).Ad()};
-f.we=function(a,b){return b0(this,a,b)};f.Rc=function(){return new Q8(this)};f.Cc=function(a){return f0(this,a)};f.e=function(){return this.ua(0)};f.Fc=function(){return zF(this)};f.$a=function(a){var b=this.Tg;return b===a?0:b<a?-1:1};f.Q=function(){return this.Tg};
-function z1(a,b){xF();var c=a.xt;var d=a.Tg;if(!(b<=c.a.length)){var e=c.a.length;var g=e<<1;e=e>>>31|0|e>>31<<1;g=(0===e?-2147483632<(-2147483648^g):0<e)?new fb(g,e):new fb(16,0);e=g.Z;for(g=g.W;;){var h=g,k=b>>31,l=e;if(l===k?(-2147483648^h)<(-2147483648^b):l<k)e=g>>>31|0|e<<1,g<<=1;else break}b=e;if(0===b?-1>=(-2147483648^g):0>b)b=g;else{if(2147483647===d)throw a=new eF,fF(a,"Collections can not have more than 2147483647 elements",null,!0),a;b=2147483647}b=new jd(b);CG(zG(),c,0,b,0,d);c=b}a.xt=
-c}f.ua=function(a){var b=1+a|0;if(0>a)throw KK(new LK,a+" is out of bounds (min 0, max "+(-1+this.Tg|0)+")");if(b>this.Tg)throw KK(new LK,(-1+b|0)+" is out of bounds (min 0, max "+(-1+this.Tg|0)+")");return this.xt.a[a]};function C0(a,b,c){var d=1+b|0;if(0>b)throw KK(new LK,b+" is out of bounds (min 0, max "+(-1+a.Tg|0)+")");if(d>a.Tg)throw KK(new LK,(-1+d|0)+" is out of bounds (min 0, max "+(-1+a.Tg|0)+")");a.yt=1+a.yt|0;a.xt.a[b]=c}f.K=function(){return this.Tg};
-function Sl(a){return new b9(a,new U(()=>a.yt))}f.yk=function(){return xF()};function Ql(a,b){a.yt=1+a.yt|0;var c=a.Tg;z1(a,1+c|0);a.Tg=1+c|0;C0(a,c,b);return a}function Zu(a,b){if(b instanceof x1){var c=b.Tg;0<c&&(a.yt=1+a.yt|0,z1(a,a.Tg+c|0),CG(zG(),b.xt,0,a.xt,a.Tg,c),a.Tg=a.Tg+c|0)}else cR(a,b);return a}f.Hc=function(){return"ArrayBuffer"};f.yc=function(a,b,c){var d=this.Tg,e=dG(eG(),a);c=c<d?c:d;e=e-b|0;e=c<e?c:e;e=0<e?e:0;0<e&&CG(zG(),this.xt,0,a,b,e);return e};
-f.oc=function(a){return Zu(this,a)};f.S=function(a){return Ql(this,a)};f.Ob=function(){return xF()};f.n=function(a){return this.ua(a|0)};f.$classData=q({x8:0},!1,"scala.collection.mutable.ArrayBuffer",{x8:1,RB:1,$j:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,dk:1,Vg:1,ek:1,Ug:1,vf:1,TB:1,lf:1,kf:1,nn:1,NG:1,Mk:1,Zc:1,Sb:1,Nk:1,$c:1,Ab:1,jg:1,l:1});function ge(a,b){a.nr=b;return a}function u2(){var a=new ie;ge(a,[]);return a}function ie(){this.nr=null}ie.prototype=new T9;
-ie.prototype.constructor=ie;f=ie.prototype;f.Pd=function(){};f.Hc=function(){return"IndexedSeq"};f.m=function(){var a=new $X(this);return Vq(new Wq,a)};f.Ad=function(){var a=new $X(this);return sZ(new tZ,a)};f.we=function(a,b){return b0(this,a,b)};f.Rc=function(){return new Q8(this)};f.Zb=function(a){return c0(this,a)};f.Cc=function(a){return f0(this,a)};f.zb=function(a){return this.qc(O8(new P8,this,a))};f.Ga=function(a){return i0(this,a)};f.e=function(){return this.nr[0]};f.Fc=function(){return zF(this)};
-f.$a=function(a){var b=this.nr.length|0;return b===a?0:b<a?-1:1};f.zi=function(a){return u3(this,a)};f.Hm=function(a){return w3(this,a)};f.Gb=function(a){return VY(this,a)};f.uk=function(a){return XY(this,a)};f.yk=function(){return L1()};f.ua=function(a){return this.nr[a]};f.K=function(){return this.nr.length|0};f.Q=function(){return this.nr.length|0};f.xh=function(){return"WrappedArray"};f.Eb=function(){return this};f.S=function(a){this.nr.push(a);return this};f.n=function(a){return this.nr[a|0]};
-f.Ob=function(){return L1()};f.$classData=q({g$:0},!1,"scala.scalajs.js.WrappedArray",{g$:1,RB:1,$j:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,dk:1,Vg:1,ek:1,Ug:1,vf:1,TB:1,lf:1,kf:1,nn:1,$c:1,Ab:1,Mk:1,Zc:1,Sb:1,Nk:1,NG:1,og:1,l:1});
-function U$(a,b,c,d){if(0!==(b.a.length&(-1+b.a.length|0)))throw new rk("assertion failed: Array.length must be power of 2");var e=b.a.length;if(0>c||c>=e)throw KK(new LK,c+" is out of bounds (min 0, max "+(-1+e|0)+")");e=b.a.length;if(0>d||d>=e)throw KK(new LK,d+" is out of bounds (min 0, max "+(-1+e|0)+")");a.ac=b;a.Hd=c;a.ne=d}function D1(a,b,c,d){a.ac=b;a.Hd=c;a.ne=d;U$(a,a.ac,a.Hd,a.ne);return a}function F1(){var a=new E1;D1(a,C1(I1(),16),0,0);return a}
-function E1(){this.ac=null;this.ne=this.Hd=0}E1.prototype=new T9;E1.prototype.constructor=E1;function X$(){}f=X$.prototype=E1.prototype;f.ga=function(){return this.bK()};f.zi=function(a){return u3(this,a)};f.Zb=function(a){return v3(this,a)};f.Hm=function(a){return w3(this,a)};f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.uk=function(a){return XY(this,a)};f.zb=function(a){return YY(this,a)};f.m=function(){var a=new $X(this);return Vq(new Wq,a)};
-f.Ad=function(){var a=new $X(this);return sZ(new tZ,a)};f.we=function(a,b){return b0(this,a,b)};f.Rc=function(){return new Q8(this)};f.Cc=function(a){return f0(this,a)};f.e=function(){return this.ua(0)};f.Fc=function(){return zF(this)};f.$a=function(a){var b=(this.ne-this.Hd|0)&(-1+this.ac.a.length|0);return b===a?0:b<a?-1:1};f.Q=function(){return(this.ne-this.Hd|0)&(-1+this.ac.a.length|0)};
-f.ua=function(a){var b=(this.ne-this.Hd|0)&(-1+this.ac.a.length|0);if(0>a||a>=b)throw KK(new LK,a+" is out of bounds (min 0, max "+(-1+b|0)+")");return this.ac.a[(this.Hd+a|0)&(-1+this.ac.a.length|0)]};function wU(a,b){var c=1+((a.ne-a.Hd|0)&(-1+a.ac.a.length|0))|0;c>((a.ne-a.Hd|0)&(-1+a.ac.a.length|0))&&c>=a.ac.a.length&&J1(a,c);a.ac.a[a.ne]=b;a.ne=(1+a.ne|0)&(-1+a.ac.a.length|0);return a}
-function ida(a,b){var c=1+((a.ne-a.Hd|0)&(-1+a.ac.a.length|0))|0;c>((a.ne-a.Hd|0)&(-1+a.ac.a.length|0))&&c>=a.ac.a.length&&J1(a,c);a.Hd=(-1+a.Hd|0)&(-1+a.ac.a.length|0);a.ac.a[a.Hd]=b}function xU(a,b){var c=b.Q();if(0<c)for(c=c+((a.ne-a.Hd|0)&(-1+a.ac.a.length|0))|0,c>((a.ne-a.Hd|0)&(-1+a.ac.a.length|0))&&c>=a.ac.a.length&&J1(a,c),b=b.m();b.s();)c=b.t(),a.ac.a[a.ne]=c,a.ne=(1+a.ne|0)&(-1+a.ac.a.length|0);else for(b=b.m();b.s();)c=b.t(),wU(a,c);return a}
-function yU(a){if(a.b())throw iH("empty collection");var b=a.ac.a[a.Hd];a.ac.a[a.Hd]=null;a.Hd=(1+a.Hd|0)&(-1+a.ac.a.length|0);return b}f.K=function(){return(this.ne-this.Hd|0)&(-1+this.ac.a.length|0)};f.b=function(){return this.Hd===this.ne};f.cK=function(){return D1(new E1,this.ac.ga(),this.Hd,this.ne)};f.yk=function(){return I1()};f.yc=function(a,b,c){var d=(this.ne-this.Hd|0)&(-1+this.ac.a.length|0),e=dG(eG(),a);d=c<d?c:d;e=e-b|0;e=d<e?d:e;e=0<e?e:0;0<e&&t5(this,a,b,c);return e};
-f.vj=function(a){a=a.gi((this.ne-this.Hd|0)&(-1+this.ac.a.length|0));return t5(this,a,0,(this.ne-this.Hd|0)&(-1+this.ac.a.length|0))};function J1(a,b){if(b>=a.ac.a.length||16<a.ac.a.length&&(a.ac.a.length-b|0)>b){var c=(a.ne-a.Hd|0)&(-1+a.ac.a.length|0);b=C1(I1(),b);b=t5(a,b,0,c);U$(a,b,0,c)}}f.Hc=function(){return"ArrayDeque"};f.Ob=function(){return this.yk()};f.bK=function(){return this.cK()};f.oc=function(a){return xU(this,a)};f.S=function(a){return wU(this,a)};
-f.n=function(a){return this.ua(a|0)};f.$classData=q({zL:0},!1,"scala.collection.mutable.ArrayDeque",{zL:1,RB:1,$j:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,dk:1,Vg:1,ek:1,Ug:1,vf:1,TB:1,lf:1,kf:1,nn:1,NG:1,Mk:1,Zc:1,Sb:1,Nk:1,$c:1,Ab:1,uS:1,jg:1,l:1});function vU(a){this.ac=null;this.ne=this.Hd=0;a=C1(I1(),a);D1(this,a,0,0)}vU.prototype=new X$;vU.prototype.constructor=vU;f=vU.prototype;f.yk=function(){return f2()};f.Hc=function(){return"Queue"};
-function Y$(a){var b=RV(new SV,new vU(16));DZ(b,a);return b.ak}f.bK=function(){return Y$(this)};f.cK=function(){return Y$(this)};f.Ob=function(){return f2()};f.$classData=q({M9:0},!1,"scala.collection.mutable.Queue",{M9:1,zL:1,RB:1,$j:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,dk:1,Vg:1,ek:1,Ug:1,vf:1,TB:1,lf:1,kf:1,nn:1,NG:1,Mk:1,Zc:1,Sb:1,Nk:1,$c:1,Ab:1,uS:1,jg:1,l:1});function NX(a){this.ac=null;this.ne=this.Hd=0;a=C1(I1(),a);D1(this,a,0,0)}NX.prototype=new X$;
-NX.prototype.constructor=NX;f=NX.prototype;f.yk=function(){return m2()};f.Hc=function(){return"Stack"};function Z$(a){var b=RV(new SV,new NX(16));DZ(b,a);return b.ak}f.bK=function(){return Z$(this)};f.cK=function(){return Z$(this)};f.Ob=function(){return m2()};f.$classData=q({a$:0},!1,"scala.collection.mutable.Stack",{a$:1,zL:1,RB:1,$j:1,Mc:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,tc:1,za:1,ja:1,ib:1,v:1,dk:1,Vg:1,ek:1,Ug:1,vf:1,TB:1,lf:1,kf:1,nn:1,NG:1,Mk:1,Zc:1,Sb:1,Nk:1,$c:1,Ab:1,uS:1,jg:1,l:1});
-function bW(a){var b=new $$;b.Ok=new iK(null,0);b.on=a;return b}function $$(){this.on=this.Ok=null}$$.prototype=new V9;$$.prototype.constructor=$$;f=$$.prototype;f.OA=function(a){return m8(this,a)};f.Ux=function(a){return S5(this,a)};f.Gb=function(a){return VY(this,a)};f.Ga=function(a){return WY(this,a)};f.zb=function(a){return YY(this,a)};f.Hc=function(){return"SortedMap"};f.h=function(a){return S8(this,a)};f.hi=function(){return dW().bv(this.on)};f.Wd=function(){return this.on};
-f.m=function(){if(this.b())return qq().Oa;var a=this.Ok,b=R(),c=R();return new x4(a,b,c,this.on)};f.oj=function(){if(this.b())return qq().Oa;var a=this.Ok,b=R(),c=R();return new y4(a,b,c,this.on)};f.Qd=function(){if(this.b())return qq().Oa;var a=this.Ok,b=R(),c=R();return new z4(a,b,c,this.on)};f.eg=function(){gK();var a=this.Ok;a.ni=null;a.Ly=0};f.Y=function(a){gK();a=XJ(this.Ok.ni,a,this.on);return null===a?R():new M(a.lr)};f.ya=function(a){var b=gK(),c=this.Ok.ni;null!==c&&vca(b,c,a)};
-f.Ag=function(a){var b=gK(),c=this.Ok.ni;null!==c&&xca(b,c,a)};f.ka=function(){return this.Ok.Ly};f.Q=function(){return this.ka()};f.b=function(){gK();return null===this.Ok.ni};f.L=function(a){gK();return null!==XJ(this.Ok.ni,a,this.on)};f.SA=function(){gK();var a=this.Ok.ni;a=null===a?null:dK(a);return(null===a?R():new M(G(new H,a.ho,a.lr))).o()};f.gB=function(){gK();var a=this.Ok.ni;if(null===a)a=null;else a:for(;;){if(null===a.uc)break a;a=a.uc}return(null===a?R():new M(G(new H,a.ho,a.lr))).o()};
-f.xh=function(){return"TreeMap"};f.oe=function(a){return m8(this,a)};f.Pq=function(){return new Z8(this)};f.qc=function(a){return aW(dW(),a,this.on)};f.vk=function(a){return aW(dW(),a,this.on)};f.TL=function(a){return new R$(this,a)};f.Ol=function(a){return m8(this,a)};f.Fc=function(){return this.gB()};f.e=function(){return this.SA()};
-f.im=function(a){gK();var b=this.Ok,c=XJ(b.ni,a,this.on);if(null!==c){var d=c.Pc;if(null===c.Oc){var e=c.uc;$J(b,c,c.uc);a=c.ab}else if(null===c.uc)e=c.Oc,$J(b,c,c.Oc),a=c.ab;else{var g=dK(c.uc);d=g.Pc;e=g.uc;g.ab===c?a=g:(a=g.ab,$J(b,g,g.uc),g.uc=c.uc,g.uc.ab=g);$J(b,c,g);g.Oc=c.Oc;g.Oc.ab=g;g.Pc=c.Pc}if(!d){for(c=e;c!==b.ni&&cK(c);)c===a.Oc?(c=a.uc,c.Pc&&(c.Pc=!1,a.Pc=!0,YJ(b,a),c=a.uc),cK(c.Oc)&&cK(c.uc)?(c.Pc=!0,c=a):(cK(c.uc)&&(c.Oc.Pc=!1,c.Pc=!0,ZJ(b,c),c=a.uc),c.Pc=a.Pc,a.Pc=!1,c.uc.Pc=!1,
-YJ(b,a),c=b.ni)):(c=a.Oc,c.Pc&&(c.Pc=!1,a.Pc=!0,ZJ(b,a),c=a.Oc),cK(c.uc)&&cK(c.Oc)?(c.Pc=!0,c=a):(cK(c.Oc)&&(c.uc.Pc=!1,c.Pc=!0,YJ(b,c),c=a.Oc),c.Pc=a.Pc,a.Pc=!1,c.Oc.Pc=!1,ZJ(b,a),c=b.ni)),a=c.ab;null!==c&&(c.Pc=!1)}b.Ly=-1+b.Ly|0}};
-f.S=function(a){gK();var b=this.Ok,c=a.i(),d=a.j(),e=this.on;a=null;for(var g=b.ni,h=1;null!==g&&0!==h;)a=g,h=e.Fa(c,g.ho),g=0>h?g.Oc:g.uc;if(0===h)a.lr=d;else{c=new hK(c,d,!0,null,null,a);for(null===a?b.ni=c:0>h?a.Oc=c:a.uc=c;bK(c.ab);)c.ab===c.ab.ab.Oc?(a=c.ab.ab.uc,bK(a)?(c.ab.Pc=!1,a.Pc=!1,c.ab.ab.Pc=!0,c=c.ab.ab):(c===c.ab.uc&&(c=c.ab,YJ(b,c)),c.ab.Pc=!1,c.ab.ab.Pc=!0,ZJ(b,c.ab.ab))):(a=c.ab.ab.Oc,bK(a)?(c.ab.Pc=!1,a.Pc=!1,c.ab.ab.Pc=!0,c=c.ab.ab):(c===c.ab.Oc&&(c=c.ab,ZJ(b,c)),c.ab.Pc=!1,c.ab.ab.Pc=
-!0,YJ(b,c.ab.ab)));b.ni.Pc=!1;b.Ly=1+b.Ly|0}return this};f.zp=function(){return dW()};f.$classData=q({d$:0},!1,"scala.collection.mutable.TreeMap",{d$:1,JG:1,$l:1,ta:1,d:1,la:1,M:1,na:1,N:1,ma:1,Ak:1,Uj:1,za:1,ja:1,dm:1,v:1,eC:1,Vg:1,RG:1,Ug:1,vf:1,og:1,lf:1,kf:1,nn:1,X9:1,zB:1,hL:1,ly:1,gL:1,$9:1,Ab:1,vG:1,E5:1,jg:1,l:1});ca=new fb(0,0);$d.Oy=ca;typecheck=function(a){Je(vg(),a)};new (Nd(na).Ja)([]);
-(function(a){var b=document.querySelector("#mlscript-input");Ke(a,b.textContent);b.addEventListener("input",c=>{Je(vg(),c)})})(vg());
+f.zl=function(a){if(32>this.uf){var b=TJ(JJ(),a,this.R);return new OJ(b,1+this.uf|0,this.Ge,1+this.vf|0,this.He,1+this.$e|0,this.Ie,1+this.Ee|0,this.Je,1+this.Fe|0,this.rd,this.Nd,this.Md,this.Ld,this.Kd,this.Z,1+this.ca|0)}if(1024>this.vf)return b=new zc(1),b.a[0]=a,a=UJ(JJ(),this.R,this.Ge),new OJ(b,1,a,1+this.vf|0,this.He,1+this.$e|0,this.Ie,1+this.Ee|0,this.Je,1+this.Fe|0,this.rd,this.Nd,this.Md,this.Ld,this.Kd,this.Z,1+this.ca|0);if(32768>this.$e){b=new zc(1);b.a[0]=a;a=JJ().bd;var c=UJ(JJ(),UJ(JJ(),
+this.R,this.Ge),this.He);return new OJ(b,1,a,1,c,1+this.$e|0,this.Ie,1+this.Ee|0,this.Je,1+this.Fe|0,this.rd,this.Nd,this.Md,this.Ld,this.Kd,this.Z,1+this.ca|0)}if(1048576>this.Ee){b=new zc(1);b.a[0]=a;a=JJ().bd;c=JJ().eg;var d=UJ(JJ(),UJ(JJ(),UJ(JJ(),this.R,this.Ge),this.He),this.Ie);return new OJ(b,1,a,1,c,1,d,1+this.Ee|0,this.Je,1+this.Fe|0,this.rd,this.Nd,this.Md,this.Ld,this.Kd,this.Z,1+this.ca|0)}if(33554432>this.Fe){b=new zc(1);b.a[0]=a;a=JJ().bd;c=JJ().eg;d=JJ().jk;var e=UJ(JJ(),UJ(JJ(),UJ(JJ(),
+UJ(JJ(),this.R,this.Ge),this.He),this.Ie),this.Je);return new OJ(b,1,a,1,c,1,d,1,e,1+this.Fe|0,this.rd,this.Nd,this.Md,this.Ld,this.Kd,this.Z,1+this.ca|0)}if(62>this.rd.a.length){b=new zc(1);b.a[0]=a;a=JJ().bd;c=JJ().eg;d=JJ().jk;e=JJ().du;var g=UJ(JJ(),UJ(JJ(),UJ(JJ(),UJ(JJ(),UJ(JJ(),this.R,this.Ge),this.He),this.Ie),this.Je),this.rd);return new OJ(b,1,a,1,c,1,d,1,e,1,g,this.Nd,this.Md,this.Ld,this.Kd,this.Z,1+this.ca|0)}throw UL();};
+f.yo=function(a){var b=WJ(JJ(),this.R,a),c=XJ(JJ(),2,this.Ge,a),d=XJ(JJ(),3,this.He,a),e=XJ(JJ(),4,this.Ie,a),g=XJ(JJ(),5,this.Je,a),h=XJ(JJ(),6,this.rd,a),k=XJ(JJ(),5,this.Nd,a),l=XJ(JJ(),4,this.Md,a),m=XJ(JJ(),3,this.Ld,a),n=XJ(JJ(),2,this.Kd,a);a=WJ(JJ(),this.Z,a);return new OJ(b,this.uf,c,this.vf,d,this.$e,e,this.Ee,g,this.Fe,h,k,l,m,n,a,this.ca)};
+f.Ln=function(a,b){a=new FJ(a,b);GJ(a,1,this.R);GJ(a,2,this.Ge);GJ(a,3,this.He);GJ(a,4,this.Ie);GJ(a,5,this.Je);GJ(a,6,this.rd);GJ(a,5,this.Nd);GJ(a,4,this.Md);GJ(a,3,this.Ld);GJ(a,2,this.Kd);GJ(a,1,this.Z);return a.im()};f.Cm=function(){if(1<this.uf){var a=this.R,b=a.a.length;a=Jj(Pj(),a,1,b);return new OJ(a,-1+this.uf|0,this.Ge,-1+this.vf|0,this.He,-1+this.$e|0,this.Ie,-1+this.Ee|0,this.Je,-1+this.Fe|0,this.rd,this.Nd,this.Md,this.Ld,this.Kd,this.Z,-1+this.ca|0)}return this.Ln(1,this.ca)};
+f.On=function(){return 11};f.To=function(a){switch(a){case 0:return this.R;case 1:return this.Ge;case 2:return this.He;case 3:return this.Ie;case 4:return this.Je;case 5:return this.rd;case 6:return this.Nd;case 7:return this.Md;case 8:return this.Ld;case 9:return this.Kd;case 10:return this.Z;default:throw new w(a);}};
+f.ql=function(a,b){var c=YJ(JJ(),this.Z,a);return null!==c?new OJ(this.R,this.uf,this.Ge,this.vf,this.He,this.$e,this.Ie,this.Ee,this.Je,this.Fe,this.rd,this.Nd,this.Md,this.Ld,this.Kd,c,(this.ca-this.Z.a.length|0)+c.a.length|0):C1.prototype.ql.call(this,a,b)};f.f=function(){return this.Cm()};f.Ja=function(a){return this.yo(a)};f.cc=function(a){return this.zl(a)};
+f.n=function(a){var b=a|0;if(0<=b&&b<this.ca){a=b-this.Fe|0;if(0<=a){b=a>>>25|0;var c=31&(a>>>20|0),d=31&(a>>>15|0),e=31&(a>>>10|0),g=31&(a>>>5|0);a&=31;return b<this.rd.a.length?this.rd.a[b].a[c].a[d].a[e].a[g].a[a]:c<this.Nd.a.length?this.Nd.a[c].a[d].a[e].a[g].a[a]:d<this.Md.a.length?this.Md.a[d].a[e].a[g].a[a]:e<this.Ld.a.length?this.Ld.a[e].a[g].a[a]:g<this.Kd.a.length?this.Kd.a[g].a[a]:this.Z.a[a]}return b>=this.Ee?(a=b-this.Ee|0,this.Je.a[a>>>20|0].a[31&(a>>>15|0)].a[31&(a>>>10|0)].a[31&(a>>>
+5|0)].a[31&a]):b>=this.$e?(a=b-this.$e|0,this.Ie.a[a>>>15|0].a[31&(a>>>10|0)].a[31&(a>>>5|0)].a[31&a]):b>=this.vf?(a=b-this.vf|0,this.He.a[a>>>10|0].a[31&(a>>>5|0)].a[31&a]):b>=this.uf?(a=b-this.uf|0,this.Ge.a[a>>>5|0].a[31&a]):this.R.a[b]}throw this.rh(b);};f.$classData=q({W8:0},!1,"scala.collection.immutable.Vector6",{W8:1,fC:1,$y:1,Zy:1,vh:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,Mg:1,xc:1,Yg:1,Sh:1,hd:1,Vb:1,wi:1,Uh:1,id:1,Cb:1,sg:1,l:1});
+function ce(){var a=new S$;a.yf=LQ(new Sq);return a}function S$(){this.yf=null}S$.prototype=new D9;S$.prototype.constructor=S$;f=S$.prototype;f.Oc=function(){return"IndexedSeq"};f.m=function(){var a=new QX(this);return Kr(new Lr,a)};f.Sd=function(){var a=new QX(this);return uZ(new vZ,a)};f.mf=function(a,b){return l0(this,a,b)};f.ad=function(){return new Z8(this)};f.cc=function(a){return n0(this,a)};f.Jc=function(a){return q0(this,a)};f.Bb=function(a){return this.vc(X8(new Y8,this,a))};
+f.Ja=function(a){return t0(this,a)};f.e=function(){return hc(this.yf.ja.charCodeAt(0))};f.Mc=function(){return SF(this)};f.ab=function(a){var b=this.yf.K();return b===a?0:b<a?-1:1};f.he=function(){};f.zc=function(a){return lR(this,a)};f.ti=function(){return PV(new QV,ce())};f.K=function(){return this.yf.K()};f.Q=function(){return this.yf.K()};function ee(a,b){a=a.yf;a.ja=""+a.ja+b}f.u=function(){return this.yf.ja};
+f.Bj=function(a){if(a.uh()===da(td)){a=this.yf.K();var b=new Ic(a);L2(this.yf.ja,a,b,0);a=b}else a=kB(this,a);return a};function Wga(a,b){if(b instanceof Jr){var c=a.yf;DZ();c.ja=""+c.ja+b.Xh}else if(b instanceof AQ)mW(a.yf,b.En);else if(b instanceof S$)c=a.yf,c.ja=""+c.ja+b.yf;else{var d=b.Q();if(0!==d)for(c=a.yf,0<d&&c.K(),b=b.m();b.s();)d=Ea(b.t()),d=String.fromCharCode(d),c.ja=""+c.ja+d}return a}f.eM=function(a,b){return this.yf.ja.substring(a,b)};f.b=function(){return 0===this.yf.K()};
+f.Ub=function(){g2||(g2=new f2);return g2};f.Kb=function(){return this.yf.ja};f.$=function(a){var b=this.yf;a=String.fromCharCode(Ea(a));b.ja=""+b.ja+a;return this};f.vc=function(a){return Wga(ce(),a)};f.Gk=function(a){return Wga(ce(),a)};f.n=function(a){return hc(this.yf.ja.charCodeAt(a|0))};f.va=function(a){return hc(this.yf.ja.charCodeAt(a))};
+f.$classData=q({I$:0},!1,"scala.collection.mutable.StringBuilder",{I$:1,kk:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,ok:1,ah:1,pk:1,$g:1,Ff:1,Po:1,xg:1,xf:1,wf:1,Xk:1,hd:1,Vb:1,Yk:1,ZJ:1,l:1});function Xga(a,b){null===b.ww?a.Gn=b.zm:b.ww.zm=b.zm;null===b.zm?a.xw=b.ww:b.zm.ww=b.ww;b.ww=null;b.zm=null}function lA(){this.xw=this.Gn=this.Ll=null;this.Ll=new SV(this)}lA.prototype=new e$;lA.prototype.constructor=lA;f=lA.prototype;f.ry=function(a){return b6(this,a)};
+f.am=function(a){return c6(this,a)};f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Bb=function(a){return $Y(this,a)};f.vj=function(){RV||(RV=new NV);return RV};f.DB=function(){if(0<this.ka())return G(new H,this.xw.ju,this.xw.Fn);throw AH("Cannot call .last on empty LinkedHashMap");};f.oB=function(){if(0<this.ka())return G(new H,this.Gn.ju,this.Gn.Fn);throw AH("Cannot call .head on empty LinkedHashMap");};f.ka=function(){return this.Ll.nu()};f.Q=function(){return this.ka()};
+f.b=function(){return 0===this.Ll.nu()};f.U=function(a){a=mR(this.Ll,a);return null===a?R():new L(a.Fn)};f.L=function(a){return ca(this)===da(Yga)?null!==mR(this.Ll,a):!this.U(a).b()};f.bj=function(a,b){a=sR(this.Ll,a,b);null===a?R():a.Fn=b};f.bh=function(a,b){a=sR(this.Ll,a,b);null!==a&&(a.Fn=b)};f.JB=function(a){a=tR(this.Ll,a);null===a?R():Xga(this,a)};f.m=function(){return new WC(this)};f.zr=function(){return new o9(this)};f.tj=function(){return new h2(this)};
+f.ou=function(a,b){var c=this.Ll,d=My(W(),a);c=nR(c,d);d=oR(this.Ll,a,c);var e=null===d?R():new L(d.Fn);b=b.n(e);e=G(new H,e,b);var g=e.y,h=e.w;if(R()!==g||R()!==h)if(g=e.w,e.y instanceof L&&R()===g)Xga(this,d),uR(this.Ll,a,c);else if(h=e.y,g=e.w,R()===h&&g instanceof L)d=this.Ll,a=this.Ll.CJ(a,g.k),pR(d,a,c);else if(a=e.w,e.y instanceof L&&a instanceof L)d.Fn=a.k;else throw new w(e);return b};f.ie=function(){return new i2(this)};
+f.Ca=function(a){for(var b=this.Gn;null!==b;)a.n(G(new H,b.ju,b.Fn)),b=b.zm};f.og=function(a){for(var b=this.Gn;null!==b;)a.ba(b.ju,b.Fn),b=b.zm};f.mg=function(){for(var a=this.Ll,b=-1+a.bl().a.length|0;0<=b;)a.bl().a[b]=null,b=-1+b|0;a.hz(0);rR(a,0);this.xw=this.Gn=null};f.Oc=function(){return"LinkedHashMap"};f.Bm=function(a){this.JB(a)};f.$=function(a){this.bj(a.h(),a.j());return this};f.e=function(){return this.oB()};f.Mc=function(){return this.DB()};
+var Yga=q({Z9:0},!1,"scala.collection.mutable.LinkedHashMap",{Z9:1,eH:1,qm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Mk:1,ek:1,za:1,la:1,um:1,v:1,CC:1,ah:1,mH:1,$g:1,Ff:1,xg:1,xf:1,wf:1,Jn:1,Wba:1,Oba:1,Cb:1,RG:1,sg:1,l:1});lA.prototype.$classData=Yga;function Zga(a){var b=ep(new fp,a);a.Hn=b.Hn;a.No=b.No;a.AC=!1}function fp(){this.No=this.Hn=null;this.AC=!1;this.BC=this.In=0;this.Hn=u();this.No=null;this.AC=!1;this.In=0}fp.prototype=new c$;fp.prototype.constructor=fp;f=fp.prototype;f.he=function(){};
+f.Ii=function(a){return E3(this,a)};f.cc=function(a){return F3(this,a)};f.gn=function(a){return G3(this,a)};f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Fk=function(a){return ZY(this,a)};f.Bb=function(a){return $Y(this,a)};f.m=function(){return new m2(this.Hn.m(),new U(()=>this.BC))};f.Ik=function(){return l2()};f.va=function(a){return eB(this.Hn,a)};f.K=function(){return this.In};f.Q=function(){return this.In};f.b=function(){return 0===this.In};
+f.ha=function(){this.AC=!this.b();return this.Hn};function wp(a,b){a.BC=1+a.BC|0;a.AC&&Zga(a);b=new z(b,u());0===a.In?a.Hn=b:a.No.p=b;a.No=b;a.In=1+a.In|0;return a}function ep(a,b){b=b.m();if(b.s()){var c=1,d=new z(b.t(),u());for(a.Hn=d;b.s();){var e=new z(b.t(),u());d=d.p=e;c=1+c|0}a.In=c;a.No=d}return a}f.Mc=function(){if(null===this.No)throw AH("last of empty ListBuffer");return this.No.z};f.Oc=function(){return"ListBuffer"};
+f.zc=function(a){a=a.m();a.s()&&(a=ep(new fp,a),this.BC=1+this.BC|0,this.AC&&Zga(this),0===this.In?this.Hn=a.Hn:this.No.p=a.Hn,this.No=a.No,this.In=this.In+a.In|0);return this};f.$=function(a){return wp(this,a)};f.Kb=function(){return this.ha()};f.n=function(a){return eB(this.Hn,a|0)};f.Ub=function(){return l2()};
+f.$classData=q({l$:0},!1,"scala.collection.mutable.ListBuffer",{l$:1,pC:1,kk:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,ok:1,ah:1,pk:1,$g:1,Ff:1,rC:1,xf:1,wf:1,Jn:1,id:1,Cb:1,Po:1,xg:1,sg:1,l:1});function T$(a,b){return b===a.Jd?a:tV(new sV,b,a.We)}function tV(a,b,c){a.Jd=b;a.We=c;return a}function vV(a){var b=new sV;tV(b,null,a);return b}function sV(){this.We=this.Jd=null}sV.prototype=new q9;sV.prototype.constructor=sV;f=sV.prototype;
+f.gR=function(a,b){b=this.jq().Dv(b);for(var c=this.m();c.s();){var d=a.n(c.t());b.$(d)}return b.Kb()};f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Oc=function(){return"SortedMap"};f.ti=function(){return new uV(this.We)};f.se=function(){return this.We};f.jq=function(){return xV()};f.m=function(){nJ();var a=this.Jd;nJ();var b=R();return new d4(a,b,this.We)};f.U=function(a){nJ();a=fJ(0,this.Jd,a,this.We);return null===a?R():new L(a.Wb)};
+f.Se=function(a,b){a=fJ(nJ(),this.Jd,a,this.We);return null===a?Es(b):a.Wb};function U$(a,b,c){return T$(a,gJ(nJ(),a.Jd,b,c,!0,a.We))}function V$(a,b){a:{if(b instanceof sV){var c=a.We,d=b.We;if(null===c?null===d:c.i(d)){b=mJ(nJ(),a.Jd,b.Jd,a.We);break a}}if(b&&b.$classData&&b.$classData.rb.KL)if(b.b())b=a.Jd;else{for(c=new oZ(a);!b.b();)d=b.e(),c.bu=fR(c,c.bu,d.h(),d.j()),b=b.f();b=qJ(c.bu)}else{c=new oZ(a);for(b=b.m();b.s();)d=b.t(),c.bu=fR(c,c.bu,d.h(),d.j());b=qJ(c.bu)}}return T$(a,b)}
+f.Ca=function(a){var b=nJ(),c=this.Jd;null!==c&&mda(b,c,a)};f.og=function(a){var b=nJ(),c=this.Jd;null!==c&&qda(b,c,a)};f.ka=function(){return EI(nJ(),this.Jd)};f.Q=function(){return EI(nJ(),this.Jd)};f.b=function(){return 0===EI(nJ(),this.Jd)};f.oB=function(){var a=hJ(nJ(),this.Jd);return G(new H,a.Wa,a.Wb)};f.DB=function(){var a=iJ(nJ(),this.Jd);return G(new H,a.Wa,a.Wb)};function $ga(a,b){return T$(a,kJ(nJ(),a.Jd,new fn((c,d)=>!!b.n(G(new H,c,d)))))}
+f.BK=function(a){var b=Gda(nJ(),this.Jd,new fn((d,e)=>!!a.n(G(new H,d,e))));if(null===b)throw new w(b);var c=b.j();return G(new H,T$(this,b.h()),T$(this,c))};
+f.i=function(a){if(a instanceof sV){var b=this.We,c=a.We;if(null===b?null===c:b.i(c)){nJ();b=this.Jd;a=a.Jd;c=this.We;var d;if(!(d=b===a)&&(d=null!==b)&&(d=null!==a)&&(d=(2147483647&b.ea)===(2147483647&a.ea))){b=new e4(b,c);a=new e4(a,c);for(c=!0;c&&null!==b.Hc&&null!==a.Hc;)b.Hc===a.Hc?(0===b.Wd?d=null:(b.Wd=-1+b.Wd|0,d=b.Cn.a[b.Wd]),b.Hc=d,0===a.Wd?d=null:(a.Wd=-1+a.Wd|0,d=a.Cn.a[a.Wd]),a.Hc=d):(c=Object.is(b.Hc.Wa,a.Hc.Wa)||b.hw.Yi(b.Hc.Wa,a.Hc.Wa)?ml(nl(),b.Hc.Wb,a.Hc.Wb):!1,b.Hc=r1(b,b.Hc.ta),
+a.Hc=r1(a,a.Hc.ta));d=c&&null===b.Hc&&null===a.Hc}return d}}return lY(this,a)};f.Ih=function(){return"TreeMap"};f.bf=function(a){return V$(this,a)};f.vc=function(a){return rV(xV(),a,this.We)};f.Gk=function(a){return rV(xV(),a,this.We)};f.IC=function(a,b){return p8(this,a,b)};f.Pn=function(a){return U$(this,a.h(),a.j())};f.jM=function(a){return O9(this,a)};f.Fk=function(a){return $ga(this,a)};
+f.Bb=function(a){var b=EI(nJ(),this.Jd)-(0<a?a:0)|0;if(0>=b)a=vV(this.We);else if(b>=EI(nJ(),this.Jd))a=this;else{a=new sV;var c=nJ();b=pI(HI(c,this.Jd,b));a=tV(a,b,this.We)}return a};f.Jc=function(a){if(0>=a)var b=this;else if(a>=EI(nJ(),this.Jd))b=vV(this.We);else{b=new sV;var c=nJ();a=pI(GI(c,this.Jd,a));b=tV(b,a,this.We)}return b};f.Mc=function(){return this.DB()};f.e=function(){return this.oB()};
+f.dG=function(a){a:{if(a instanceof rZ){var b=this.We,c=a.Xe;if(null===b?null===c:b.i(c)){b=nJ();a=pI(XI(b,this.Jd,a.Hf,this.We));a=T$(this,a);break a}}a=x5(this,a)}return a};f.am=function(a){return V$(this,a)};f.hy=function(a){return V$(this,a)};f.Em=function(a,b){return U$(this,a,b)};f.Dm=function(a,b){return U$(this,a,b)};f.xj=function(a){var b=nJ();a=pI(PI(b,this.Jd,a,this.We));return T$(this,a)};f.zr=function(){return sZ(new rZ,this.Jd,this.We)};f.Ht=function(){return sZ(new rZ,this.Jd,this.We)};
+f.AB=function(){return sZ(new rZ,this.Jd,this.We)};f.$classData=q({G8:0},!1,"scala.collection.immutable.TreeMap",{G8:1,Rt:1,qm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Mk:1,ek:1,za:1,la:1,um:1,v:1,Pr:1,xc:1,Xt:1,FS:1,YB:1,zL:1,Iy:1,yL:1,A8:1,Sba:1,j6:1,RG:1,Cb:1,E8:1,sg:1,l:1});function W$(a,b){this.Aw=this.Yh=null;Q9(this,a,b)}W$.prototype=new r$;W$.prototype.constructor=W$;f=W$.prototype;f.Oc=function(){return"SortedMap"};f.i=function(a){return lY(this,a)};f.jq=function(){return this.Yh.jq()};f.se=function(){return this.Yh.se()};
+function X$(a,b){b=a.Yh.hy(b);return new W$(b,a.Aw)}function Y$(a,b){return new W$(a.Yh.jq().qr(b,a.Yh.se()),a.Aw)}f.bf=function(a){return X$(this,a)};f.zr=function(){return new g9(this)};f.kM=function(a){return new W$(this,a)};f.vc=function(a){return Y$(this,a)};f.Gk=function(a){return Y$(this,a)};f.JJ=function(a){return Y$(this,a)};f.am=function(a){return X$(this,a)};f.hQ=function(a){return X$(this,a)};f.hy=function(a){return X$(this,a)};f.$=function(a){this.Yh.$(a);return this};
+f.cQ=function(a){this.Yh.$(a);return this};f.Bm=function(a){this.Yh.Bm(a)};f.oT=function(a){this.Yh.Bm(a)};f.$classData=q({E$:0},!1,"scala.collection.mutable.SortedMap$WithDefault",{E$:1,fT:1,eH:1,qm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Mk:1,ek:1,za:1,la:1,um:1,v:1,CC:1,ah:1,mH:1,$g:1,Ff:1,xg:1,xf:1,wf:1,Jn:1,l:1,C$:1,YB:1,zL:1,Iy:1,yL:1,F$:1});function H1(a,b,c){a.fu=0;a.eu=b;a.Zg=c;return a}function kl(){var a=new I1;H1(a,new zc(16),0);return a}
+function Mv(a){var b=new I1;H1(b,new zc(1<a?a:1),0);return b}function I1(){this.fu=0;this.eu=null;this.Zg=0}I1.prototype=new c$;I1.prototype.constructor=I1;f=I1.prototype;f.Ii=function(a){return E3(this,a)};f.cc=function(a){return F3(this,a)};f.gn=function(a){return G3(this,a)};f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Fk=function(a){return ZY(this,a)};f.Bb=function(a){return $Y(this,a)};f.m=function(){return sl(this).m()};f.Sd=function(){return sl(this).Sd()};
+f.mf=function(a,b){return l0(this,a,b)};f.ad=function(){return new Z8(this)};f.Jc=function(a){return q0(this,a)};f.e=function(){return this.va(0)};f.Mc=function(){return SF(this)};f.ab=function(a){var b=this.Zg;return b===a?0:b<a?-1:1};f.Q=function(){return this.Zg};
+function K1(a,b){QF();var c=a.eu;var d=a.Zg;if(!(b<=c.a.length)){var e=c.a.length;var g=e<<1;e=e>>>31|0|e>>31<<1;g=(0===e?-2147483632<(-2147483648^g):0<e)?new ma(g,e):new ma(16,0);e=g.Y;for(g=g.W;;){var h=g,k=b>>31,l=e;if(l===k?(-2147483648^h)<(-2147483648^b):l<k)e=g>>>31|0|e<<1,g<<=1;else break}b=e;if(0===b?-1>=(-2147483648^g):0>b)b=g;else{if(2147483647===d)throw a=new xF,yF(a,"Collections can not have more than 2147483647 elements",null,!0),a;b=2147483647}b=new zc(b);VG(SG(),c,0,b,0,d);c=b}a.eu=
+c}f.va=function(a){var b=1+a|0;if(0>a)throw aL(new bL,a+" is out of bounds (min 0, max "+(-1+this.Zg|0)+")");if(b>this.Zg)throw aL(new bL,(-1+b|0)+" is out of bounds (min 0, max "+(-1+this.Zg|0)+")");return this.eu.a[a]};function N0(a,b,c){var d=1+b|0;if(0>b)throw aL(new bL,b+" is out of bounds (min 0, max "+(-1+a.Zg|0)+")");if(d>a.Zg)throw aL(new bL,(-1+d|0)+" is out of bounds (min 0, max "+(-1+a.Zg|0)+")");a.fu=1+a.fu|0;a.eu.a[b]=c}f.K=function(){return this.Zg};
+function sl(a){return new j9(a,new U(()=>a.fu))}f.Ik=function(){return QF()};function ol(a,b){a.fu=1+a.fu|0;var c=a.Zg;K1(a,1+c|0);a.Zg=1+c|0;N0(a,c,b);return a}function Lv(a,b){if(b instanceof I1){var c=b.Zg;0<c&&(a.fu=1+a.fu|0,K1(a,a.Zg+c|0),VG(SG(),b.eu,0,a.eu,a.Zg,c),a.Zg=a.Zg+c|0)}else lR(a,b);return a}f.Oc=function(){return"ArrayBuffer"};f.Gc=function(a,b,c){var d=this.Zg,e=wG(xG(),a);c=c<d?c:d;e=e-b|0;e=c<e?c:e;e=0<e?e:0;0<e&&VG(SG(),this.eu,0,a,b,e);return e};
+f.zc=function(a){return Lv(this,a)};f.$=function(a){return ol(this,a)};f.Ub=function(){return QF()};f.n=function(a){return this.va(a|0)};f.$classData=q({c9:0},!1,"scala.collection.mutable.ArrayBuffer",{c9:1,pC:1,kk:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,ok:1,ah:1,pk:1,$g:1,Ff:1,rC:1,xf:1,wf:1,Jn:1,iH:1,Xk:1,hd:1,Vb:1,Yk:1,id:1,Cb:1,sg:1,l:1});function Md(a,b){a.Xr=b;return a}function E2(){var a=new Nd;Md(a,[]);return a}function Nd(){this.Xr=null}Nd.prototype=new c$;
+Nd.prototype.constructor=Nd;f=Nd.prototype;f.he=function(){};f.Oc=function(){return"IndexedSeq"};f.m=function(){var a=new QX(this);return Kr(new Lr,a)};f.Sd=function(){var a=new QX(this);return uZ(new vZ,a)};f.mf=function(a,b){return l0(this,a,b)};f.ad=function(){return new Z8(this)};f.cc=function(a){return n0(this,a)};f.Jc=function(a){return q0(this,a)};f.Bb=function(a){return this.vc(X8(new Y8,this,a))};f.Ja=function(a){return t0(this,a)};f.e=function(){return this.Xr[0]};f.Mc=function(){return SF(this)};
+f.ab=function(a){var b=this.Xr.length|0;return b===a?0:b<a?-1:1};f.Ii=function(a){return E3(this,a)};f.gn=function(a){return G3(this,a)};f.Gb=function(a){return XY(this,a)};f.Fk=function(a){return ZY(this,a)};f.Ik=function(){return W1()};f.va=function(a){return this.Xr[a]};f.K=function(){return this.Xr.length|0};f.Q=function(){return this.Xr.length|0};f.Ih=function(){return"WrappedArray"};f.Kb=function(){return this};f.$=function(a){this.Xr.push(a);return this};f.n=function(a){return this.Xr[a|0]};
+f.Ub=function(){return W1()};f.$classData=q({M$:0},!1,"scala.scalajs.js.WrappedArray",{M$:1,pC:1,kk:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,ok:1,ah:1,pk:1,$g:1,Ff:1,rC:1,xf:1,wf:1,Jn:1,id:1,Cb:1,Xk:1,hd:1,Vb:1,Yk:1,iH:1,xg:1,l:1});
+function aha(a,b,c,d){if(0!==(b.a.length&(-1+b.a.length|0)))throw new Yj("assertion failed: Array.length must be power of 2");var e=b.a.length;if(0>c||c>=e)throw aL(new bL,c+" is out of bounds (min 0, max "+(-1+e|0)+")");e=b.a.length;if(0>d||d>=e)throw aL(new bL,d+" is out of bounds (min 0, max "+(-1+e|0)+")");a.ec=b;a.Zd=c;a.Ke=d}function O1(a,b,c,d){a.ec=b;a.Zd=c;a.Ke=d;aha(a,a.ec,a.Zd,a.Ke);return a}function Q1(){var a=new P1;O1(a,N1(T1(),16),0,0);return a}
+function P1(){this.ec=null;this.Ke=this.Zd=0}P1.prototype=new c$;P1.prototype.constructor=P1;function Z$(){}f=Z$.prototype=P1.prototype;f.ia=function(){return this.tK()};f.Ii=function(a){return E3(this,a)};f.cc=function(a){return F3(this,a)};f.gn=function(a){return G3(this,a)};f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Fk=function(a){return ZY(this,a)};f.Bb=function(a){return $Y(this,a)};f.m=function(){var a=new QX(this);return Kr(new Lr,a)};
+f.Sd=function(){var a=new QX(this);return uZ(new vZ,a)};f.mf=function(a,b){return l0(this,a,b)};f.ad=function(){return new Z8(this)};f.Jc=function(a){return q0(this,a)};f.e=function(){return this.va(0)};f.Mc=function(){return SF(this)};f.ab=function(a){var b=(this.Ke-this.Zd|0)&(-1+this.ec.a.length|0);return b===a?0:b<a?-1:1};f.Q=function(){return(this.Ke-this.Zd|0)&(-1+this.ec.a.length|0)};
+f.va=function(a){var b=(this.Ke-this.Zd|0)&(-1+this.ec.a.length|0);if(0>a||a>=b)throw aL(new bL,a+" is out of bounds (min 0, max "+(-1+b|0)+")");return this.ec.a[(this.Zd+a|0)&(-1+this.ec.a.length|0)]};function uU(a,b){var c=1+((a.Ke-a.Zd|0)&(-1+a.ec.a.length|0))|0;c>((a.Ke-a.Zd|0)&(-1+a.ec.a.length|0))&&c>=a.ec.a.length&&U1(a,c);a.ec.a[a.Ke]=b;a.Ke=(1+a.Ke|0)&(-1+a.ec.a.length|0);return a}
+function Hea(a,b){var c=1+((a.Ke-a.Zd|0)&(-1+a.ec.a.length|0))|0;c>((a.Ke-a.Zd|0)&(-1+a.ec.a.length|0))&&c>=a.ec.a.length&&U1(a,c);a.Zd=(-1+a.Zd|0)&(-1+a.ec.a.length|0);a.ec.a[a.Zd]=b}function vU(a,b){var c=b.Q();if(0<c)for(c=c+((a.Ke-a.Zd|0)&(-1+a.ec.a.length|0))|0,c>((a.Ke-a.Zd|0)&(-1+a.ec.a.length|0))&&c>=a.ec.a.length&&U1(a,c),b=b.m();b.s();)c=b.t(),a.ec.a[a.Ke]=c,a.Ke=(1+a.Ke|0)&(-1+a.ec.a.length|0);else for(b=b.m();b.s();)c=b.t(),uU(a,c);return a}
+function wU(a){if(a.b())throw AH("empty collection");var b=a.ec.a[a.Zd];a.ec.a[a.Zd]=null;a.Zd=(1+a.Zd|0)&(-1+a.ec.a.length|0);return b}f.K=function(){return(this.Ke-this.Zd|0)&(-1+this.ec.a.length|0)};f.b=function(){return this.Zd===this.Ke};f.uK=function(){return O1(new P1,this.ec.ia(),this.Zd,this.Ke)};f.Ik=function(){return T1()};f.Gc=function(a,b,c){var d=(this.Ke-this.Zd|0)&(-1+this.ec.a.length|0),e=wG(xG(),a);d=c<d?c:d;e=e-b|0;e=d<e?d:e;e=0<e?e:0;0<e&&D5(this,a,b,c);return e};
+f.Bj=function(a){a=a.si((this.Ke-this.Zd|0)&(-1+this.ec.a.length|0));return D5(this,a,0,(this.Ke-this.Zd|0)&(-1+this.ec.a.length|0))};function U1(a,b){if(b>=a.ec.a.length||16<a.ec.a.length&&(a.ec.a.length-b|0)>b){var c=(a.Ke-a.Zd|0)&(-1+a.ec.a.length|0);b=N1(T1(),b);b=D5(a,b,0,c);aha(a,b,0,c)}}f.Oc=function(){return"ArrayDeque"};f.Ub=function(){return this.Ik()};f.tK=function(){return this.uK()};f.zc=function(a){return vU(this,a)};f.$=function(a){return uU(this,a)};
+f.n=function(a){return this.va(a|0)};f.$classData=q({RL:0},!1,"scala.collection.mutable.ArrayDeque",{RL:1,pC:1,kk:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,ok:1,ah:1,pk:1,$g:1,Ff:1,rC:1,xf:1,wf:1,Jn:1,iH:1,Xk:1,hd:1,Vb:1,Yk:1,id:1,Cb:1,NS:1,sg:1,l:1});function tU(a){this.ec=null;this.Ke=this.Zd=0;a=N1(T1(),a);O1(this,a,0,0)}tU.prototype=new Z$;tU.prototype.constructor=tU;f=tU.prototype;f.Ik=function(){return p2()};f.Oc=function(){return"Queue"};
+function bha(a){var b=PV(new QV,new tU(16));FZ(b,a);return b.lk}f.tK=function(){return bha(this)};f.uK=function(){return bha(this)};f.Ub=function(){return p2()};f.$classData=q({r$:0},!1,"scala.collection.mutable.Queue",{r$:1,RL:1,pC:1,kk:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,ok:1,ah:1,pk:1,$g:1,Ff:1,rC:1,xf:1,wf:1,Jn:1,iH:1,Xk:1,hd:1,Vb:1,Yk:1,id:1,Cb:1,NS:1,sg:1,l:1});function IX(a){this.ec=null;this.Ke=this.Zd=0;a=N1(T1(),a);O1(this,a,0,0)}IX.prototype=new Z$;
+IX.prototype.constructor=IX;f=IX.prototype;f.Ik=function(){return w2()};f.Oc=function(){return"Stack"};function cha(a){var b=PV(new QV,new IX(16));FZ(b,a);return b.lk}f.tK=function(){return cha(this)};f.uK=function(){return cha(this)};f.Ub=function(){return w2()};f.$classData=q({G$:0},!1,"scala.collection.mutable.Stack",{G$:1,RL:1,pC:1,kk:1,Tc:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Ac:1,za:1,la:1,kb:1,v:1,ok:1,ah:1,pk:1,$g:1,Ff:1,rC:1,xf:1,wf:1,Jn:1,iH:1,Xk:1,hd:1,Vb:1,Yk:1,id:1,Cb:1,NS:1,sg:1,l:1});
+function YV(a){var b=new $$;b.Zk=new zK(null,0);b.Kn=a;return b}function $$(){this.Kn=this.Zk=null}$$.prototype=new e$;$$.prototype.constructor=$$;f=$$.prototype;f.hy=function(a){return w8(this,a)};f.ry=function(a){return b6(this,a)};f.Gb=function(a){return XY(this,a)};f.Ja=function(a){return YY(this,a)};f.Bb=function(a){return $Y(this,a)};f.Oc=function(){return"SortedMap"};f.i=function(a){return lY(this,a)};f.ti=function(){return $V().Dv(this.Kn)};f.se=function(){return this.Kn};
+f.m=function(){if(this.b())return Rq().Pa;var a=this.Zk,b=R(),c=R();return new H4(a,b,c,this.Kn)};f.tj=function(){if(this.b())return Rq().Pa;var a=this.Zk,b=R(),c=R();return new I4(a,b,c,this.Kn)};f.ie=function(){if(this.b())return Rq().Pa;var a=this.Zk,b=R(),c=R();return new J4(a,b,c,this.Kn)};f.mg=function(){xK();var a=this.Zk;a.zi=null;a.gz=0};f.U=function(a){xK();a=nK(this.Zk.zi,a,this.Kn);return null===a?R():new L(a.Vr)};f.Ca=function(a){var b=xK(),c=this.Zk.zi;null!==c&&Oda(b,c,a)};
+f.og=function(a){var b=xK(),c=this.Zk.zi;null!==c&&Qda(b,c,a)};f.ka=function(){return this.Zk.gz};f.Q=function(){return this.ka()};f.b=function(){xK();return null===this.Zk.zi};f.L=function(a){xK();return null!==nK(this.Zk.zi,a,this.Kn)};f.oB=function(){xK();var a=this.Zk.zi;a=null===a?null:uK(a);return(null===a?R():new L(G(new H,a.Oo,a.Vr))).o()};f.DB=function(){xK();var a=this.Zk.zi;if(null===a)a=null;else a:for(;;){if(null===a.Bc)break a;a=a.Bc}return(null===a?R():new L(G(new H,a.Oo,a.Vr))).o()};
+f.Ih=function(){return"TreeMap"};f.bf=function(a){return w8(this,a)};f.zr=function(){return new g9(this)};f.vc=function(a){return XV($V(),a,this.Kn)};f.Gk=function(a){return XV($V(),a,this.Kn)};f.kM=function(a){return new W$(this,a)};f.am=function(a){return w8(this,a)};f.Mc=function(){return this.DB()};f.e=function(){return this.oB()};
+f.Bm=function(a){xK();var b=this.Zk,c=nK(b.zi,a,this.Kn);if(null!==c){var d=c.Wc;if(null===c.Vc){var e=c.Bc;qK(b,c,c.Bc);a=c.bb}else if(null===c.Bc)e=c.Vc,qK(b,c,c.Vc),a=c.bb;else{var g=uK(c.Bc);d=g.Wc;e=g.Bc;g.bb===c?a=g:(a=g.bb,qK(b,g,g.Bc),g.Bc=c.Bc,g.Bc.bb=g);qK(b,c,g);g.Vc=c.Vc;g.Vc.bb=g;g.Wc=c.Wc}if(!d){for(c=e;c!==b.zi&&tK(c);)c===a.Vc?(c=a.Bc,c.Wc&&(c.Wc=!1,a.Wc=!0,oK(b,a),c=a.Bc),tK(c.Vc)&&tK(c.Bc)?(c.Wc=!0,c=a):(tK(c.Bc)&&(c.Vc.Wc=!1,c.Wc=!0,pK(b,c),c=a.Bc),c.Wc=a.Wc,a.Wc=!1,c.Bc.Wc=!1,
+oK(b,a),c=b.zi)):(c=a.Vc,c.Wc&&(c.Wc=!1,a.Wc=!0,pK(b,a),c=a.Vc),tK(c.Bc)&&tK(c.Vc)?(c.Wc=!0,c=a):(tK(c.Vc)&&(c.Bc.Wc=!1,c.Wc=!0,oK(b,c),c=a.Vc),c.Wc=a.Wc,a.Wc=!1,c.Vc.Wc=!1,pK(b,a),c=b.zi)),a=c.bb;null!==c&&(c.Wc=!1)}b.gz=-1+b.gz|0}};
+f.$=function(a){xK();var b=this.Zk,c=a.h(),d=a.j(),e=this.Kn;a=null;for(var g=b.zi,h=1;null!==g&&0!==h;)a=g,h=e.Da(c,g.Oo),g=0>h?g.Vc:g.Bc;if(0===h)a.Vr=d;else{c=new yK(c,d,!0,null,null,a);for(null===a?b.zi=c:0>h?a.Vc=c:a.Bc=c;sK(c.bb);)c.bb===c.bb.bb.Vc?(a=c.bb.bb.Bc,sK(a)?(c.bb.Wc=!1,a.Wc=!1,c.bb.bb.Wc=!0,c=c.bb.bb):(c===c.bb.Bc&&(c=c.bb,oK(b,c)),c.bb.Wc=!1,c.bb.bb.Wc=!0,pK(b,c.bb.bb))):(a=c.bb.bb.Vc,sK(a)?(c.bb.Wc=!1,a.Wc=!1,c.bb.bb.Wc=!0,c=c.bb.bb):(c===c.bb.Vc&&(c=c.bb,pK(b,c)),c.bb.Wc=!1,c.bb.bb.Wc=
+!0,oK(b,c.bb.bb)));b.zi.Wc=!1;b.gz=1+b.gz|0}return this};f.jq=function(){return $V()};f.$classData=q({J$:0},!1,"scala.collection.mutable.TreeMap",{J$:1,eH:1,qm:1,ua:1,g:1,na:1,M:1,pa:1,N:1,oa:1,Mk:1,ek:1,za:1,la:1,um:1,v:1,CC:1,ah:1,mH:1,$g:1,Ff:1,xg:1,xf:1,wf:1,Jn:1,C$:1,YB:1,zL:1,Iy:1,yL:1,F$:1,Cb:1,RG:1,j6:1,sg:1,l:1});aa=new ma(0,0);Fd.jz=aa;typecheck=function(a){qe(Qf(),a)};new (md(fa).Ia)([]);
+(function(a){var b=document.querySelector("#mlscript-input");se(a,b.textContent);b.addEventListener("input",c=>{qe(Qf(),c)})})(Qf());
 }).call(this);
 //# sourceMappingURL=mlscript-opt.js.map
diff --git a/js/src/main/scala/Main.scala b/js/src/main/scala/Main.scala
index f2f12e1c16..f8a7f9b1bb 100644
--- a/js/src/main/scala/Main.scala
+++ b/js/src/main/scala/Main.scala
@@ -159,7 +159,7 @@ object Main {
                             |""".stripMargin
 
           val backend = new JSWebBackend()
-          val (lines, resNames) = backend(pgrm, true)
+          val (lines, resNames) = backend(pgrm, newDefs = true)
           val code = lines.mkString("\n")
 
           // TODO: add a toggle button to show js code
diff --git a/shared/src/main/scala/mlscript/JSBackend.scala b/shared/src/main/scala/mlscript/JSBackend.scala
index 6e5905a47d..c52ba44d63 100644
--- a/shared/src/main/scala/mlscript/JSBackend.scala
+++ b/shared/src/main/scala/mlscript/JSBackend.scala
@@ -8,7 +8,7 @@ import scala.collection.mutable.{Set => MutSet}
 import scala.util.control.NonFatal
 import scala.util.chaining._
 
-abstract class JSBackend(allowUnresolvedSymbols: Bool) {
+abstract class JSBackend {
   def oldDefs: Bool
 
   protected implicit class TermOps(term: Term) {
@@ -146,10 +146,7 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
           return Left(CodeGenError(s"type alias ${name} is not a valid expression"))
         case S(_) => lastWords("register mismatch in scope")
         case N =>
-          if (allowUnresolvedSymbols)
-            JSIdent(name)
-          else
-            return Left(CodeGenError(s"unresolved symbol ${name}"))
+          return Left(CodeGenError(s"unresolved symbol ${name}"))
       }
     })
 
@@ -1317,7 +1314,7 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
   
 }
 
-class JSWebBackend extends JSBackend(allowUnresolvedSymbols = true) {
+class JSWebBackend extends JSBackend {
   def oldDefs = false
   
   // Name of the array that contains execution results
@@ -1448,7 +1445,7 @@ class JSWebBackend extends JSBackend(allowUnresolvedSymbols = true) {
     if (newDefs) generateNewDef(pgrm) else generate(pgrm)
 }
 
-abstract class JSTestBackend extends JSBackend(allowUnresolvedSymbols = false) {
+abstract class JSTestBackend extends JSBackend {
   
   private val lastResultSymbol = topLevelScope.declareValue("res", Some(false), false, N)
   private val resultIdent = JSIdent(lastResultSymbol.runtimeName)
diff --git a/shared/src/main/scala/mlscript/codegen/Codegen.scala b/shared/src/main/scala/mlscript/codegen/Codegen.scala
index e9fdf0b95e..f6ba1dabc6 100644
--- a/shared/src/main/scala/mlscript/codegen/Codegen.scala
+++ b/shared/src/main/scala/mlscript/codegen/Codegen.scala
@@ -589,7 +589,7 @@ class JSMember(`object`: JSExpr, property: JSExpr) extends JSExpr {
   override def precedence: Int = 20
   override def toSourceCode: SourceCode =
     `object`.toSourceCode.parenthesized(
-      `object`.precedence < precedence || `object`.isInstanceOf[JSRecord]
+      `object`.precedence < precedence || `object`.isInstanceOf[JSRecord] || `object`.isInstanceOf[JSNew]
     ) ++ SourceCode("[") ++ property.toSourceCode ++ SourceCode("]")
 
   override def isSimple: Bool = `object`.isSimple
@@ -602,7 +602,7 @@ object JSMember {
 class JSField(`object`: JSExpr, val property: JSIdent) extends JSMember(`object`, property) {
   override def toSourceCode: SourceCode =
     `object`.toSourceCode.parenthesized(
-      `object`.precedence < precedence || `object`.isInstanceOf[JSRecord]
+      `object`.precedence < precedence || `object`.isInstanceOf[JSRecord] || `object`.isInstanceOf[JSNew]
     ) ++ SourceCode(
       if (JSField.isValidFieldName(property.name)) {
         s".${property.name}"
diff --git a/shared/src/main/scala/mlscript/codegen/Scope.scala b/shared/src/main/scala/mlscript/codegen/Scope.scala
index 529856bcb9..6047bde797 100644
--- a/shared/src/main/scala/mlscript/codegen/Scope.scala
+++ b/shared/src/main/scala/mlscript/codegen/Scope.scala
@@ -86,6 +86,7 @@ class Scope(val name: Str, enclosing: Opt[Scope]) {
       "Wildcard",
       "NoCases",
       "discard",
+      "window",
     ) foreach { name =>
       register(BuiltinSymbol(name, name))
     }
diff --git a/shared/src/test/diff/codegen/New.mls b/shared/src/test/diff/codegen/New.mls
index 9909f20df2..f064bdfb52 100644
--- a/shared/src/test/diff/codegen/New.mls
+++ b/shared/src/test/diff/codegen/New.mls
@@ -107,3 +107,82 @@ c()
 //│     = C {}
 
 
+:js
+class X(val a: Int)
+new X(1).a
+//│ class X(a: Int)
+//│ Int
+//│ // Prelude
+//│ class TypingUnit10 {
+//│   #X;
+//│   constructor() {
+//│   }
+//│   get X() {
+//│     const qualifier = this;
+//│     if (this.#X === undefined) {
+//│       class X {
+//│         #a;
+//│         get a() { return this.#a; }
+//│         constructor(a) {
+//│           this.#a = a;
+//│         }
+//│       static
+//│         unapply(x) {
+//│           return [x.#a];
+//│         }
+//│       };
+//│       this.#X = ((a) => Object.freeze(new X(a)));
+//│       this.#X.class = X;
+//│       this.#X.unapply = X.unapply;
+//│     }
+//│     return this.#X;
+//│   }
+//│ }
+//│ const typing_unit10 = new TypingUnit10;
+//│ globalThis.X = typing_unit10.X;
+//│ // Query 1
+//│ res = new X.class(1).a;
+//│ // End of generated code
+//│ res
+//│     = 1
+
+:js
+class X {
+  val a = 1
+}
+(new X).a
+//│ class X {
+//│   constructor()
+//│   val a: 1
+//│ }
+//│ 1
+//│ // Prelude
+//│ class TypingUnit11 {
+//│   #X;
+//│   constructor() {
+//│   }
+//│   get X() {
+//│     const qualifier = this;
+//│     if (this.#X === undefined) {
+//│       class X {
+//│         #a;
+//│         get a() { return this.#a; }
+//│         constructor() {
+//│           this.#a = 1;
+//│           const a = this.#a;
+//│         }
+//│       };
+//│       this.#X = X;
+//│     }
+//│     return this.#X;
+//│   }
+//│ }
+//│ const typing_unit11 = new TypingUnit11;
+//│ globalThis.X = typing_unit11.X;
+//│ // Query 1
+//│ res = (new X).a;
+//│ // End of generated code
+//│ res
+//│     = 1
+
+
diff --git a/shared/src/test/diff/nu/CaseExpr.mls b/shared/src/test/diff/nu/CaseExpr.mls
index c6ebf859ed..5b317fe937 100644
--- a/shared/src/test/diff/nu/CaseExpr.mls
+++ b/shared/src/test/diff/nu/CaseExpr.mls
@@ -35,10 +35,10 @@ fun foo = case
 
 
 
-abstract class Option[out A]
+abstract class Option[out A]: Some[A] | None
 class Some[out A](val value: A) extends Option[A]
 module None extends Option[nothing]
-//│ abstract class Option[A]
+//│ abstract class Option[A]: None | Some[A]
 //│ class Some[A](value: A) extends Option
 //│ module None extends Option
 
diff --git a/shared/src/test/diff/nu/Eval.mls b/shared/src/test/diff/nu/Eval.mls
index 8f40aa530f..7f3886971e 100644
--- a/shared/src/test/diff/nu/Eval.mls
+++ b/shared/src/test/diff/nu/Eval.mls
@@ -79,10 +79,10 @@ test
 //│   1
 
 
-abstract class Option[out A]
+abstract class Option[out A]: Some[A] | None
 class Some[out A](val value: A) extends Option[A]
 module None extends Option[nothing]
-//│ abstract class Option[A]
+//│ abstract class Option[A]: None | Some[A]
 //│ class Some[A](value: A) extends Option
 //│ module None extends Option
 

From f6be56bbdafc784fe22f4ae03fb5cdb9377ae598 Mon Sep 17 00:00:00 2001
From: Lionel Parreaux <lionel.parreaux@gmail.com>
Date: Tue, 2 Apr 2024 11:40:47 +0800
Subject: [PATCH 113/147] Add a couple of useful tests

---
 shared/src/test/diff/nu/FunnyPoly.mls         | 152 ++++++++++++++++++
 shared/src/test/diff/nu/TupleParamBlunder.mls |  35 ++++
 2 files changed, 187 insertions(+)
 create mode 100644 shared/src/test/diff/nu/FunnyPoly.mls
 create mode 100644 shared/src/test/diff/nu/TupleParamBlunder.mls

diff --git a/shared/src/test/diff/nu/FunnyPoly.mls b/shared/src/test/diff/nu/FunnyPoly.mls
new file mode 100644
index 0000000000..21d6cbe464
--- /dev/null
+++ b/shared/src/test/diff/nu/FunnyPoly.mls
@@ -0,0 +1,152 @@
+:NewDefs
+:NoJS
+
+// * A bunch of semi-random polymorphism and extrusion tests.
+// * Some of them yield very ugly types. (They might improve once we use proper wildcard args.)
+// * I've been trying to reproduce/trigger the incompleteness of constraint solving
+// * for constraints like `MyClass[S] & ?b <: MyClass[T]` where ?b is a lower-level type variable.
+
+
+
+fun test(x: (forall 'a: 'a -> 'a) & 'b) =
+  let foo(y) =
+    x(y)
+  foo
+//│ fun test: forall 'a 'b 'c. (x: forall 'a0. 'a0 -> 'a0 & ~('a -> 'a) | 'a0 -> 'a0 & 'b -> 'c) -> 'b -> 'c
+
+
+type Id = forall 'a: 'a -> 'a
+//│ type Id = forall 'a. 'a -> 'a
+
+fun test(x: Id & 'b) =
+  let foo(y) = x(y)
+  foo
+//│ fun test: forall 'b 'c 'a. (x: Id & 'b -> 'c | Id & ~('a -> 'a)) -> 'b -> 'c
+
+fun test(x: Int | 'b) =
+  let foo(y) = (if true then x else y) : (Int | 'c)
+  foo
+//│ fun test: forall 'c. (x: Int | 'c) -> (forall 'c0. (Int | 'c0) -> (Int | 'c | 'c0))
+
+
+
+class Ref[T](x: T -> T)
+//│ class Ref[T](x: T -> T)
+
+class MyClass[A](x: A -> A)
+//│ class MyClass[A](x: A -> A)
+
+// Note: precedence of & is lower than that of ->
+fun mk: forall 'b: (Ref['b]) -> MyClass[Int] & 'b
+// fun mk(x) = error
+//│ fun mk: forall 'b. Ref['b] -> MyClass[Int] & 'b
+
+(x, y) => mk(x, y)
+//│ (anything, anything) -> nothing
+
+fun mk: forall 'a, 'b: (Ref['a], Ref['b]) -> (MyClass['a] & 'b)
+//│ fun mk: forall 'a 'b. (Ref['a], Ref['b]) -> (MyClass['a] & 'b)
+
+fun test(x, y) = mk(x, y)
+//│ fun test: forall 'a 'b. (Ref['a], Ref['b]) -> (MyClass['a] & 'b)
+
+:ns
+test
+//│ forall 'c 'd 'e 'a 'b. ('c, 'd) -> 'e
+//│   where
+//│     'e :> MyClass['a] & 'b
+//│     'd <: Ref['b]
+//│     'c <: Ref['a]
+
+
+
+fun test(x, y) =
+  let tmp = mk(x, y)
+  tmp
+//│ fun test: forall 'a 'b. (Ref['a], Ref['b]) -> (MyClass['a] & 'b)
+
+fun test(x, y) =
+  let tmp = mk(x, y)
+  let foo(z) = mk(z, tmp)
+  foo
+//│ fun test: forall 'a 'b 'b0. (Ref['a], Ref['b]) -> (forall 'a0. Ref['a0] -> (MyClass['a0] & 'b0))
+//│   where
+//│     'b <: Ref[?] | Ref[?] & ~{MyClass#A = 'a} | Ref['b0] | ~MyClass['a]
+
+fun test(x, y) =
+  let tmp = mk(x, y)
+  let foo(z) = mk(z, tmp) : MyClass['x]
+  foo
+//│ fun test: forall 'a 'b 'b0 'a0 'a1 'a2 'x. (Ref['a], Ref['b]) -> (forall 'a3 'x0. Ref['a3] -> MyClass['x0])
+//│   where
+//│     'x0 <: 'x
+//│     'a3 :> 'a2 | 'a1
+//│         <: 'a0
+//│     'b <: Ref[?] | Ref[?] & ~{MyClass#A = 'a} | Ref[in 'b0 out 'b0 & (MyClass[?] & ~{MyClass#A :> 'a0 & 'a1} | MyClass[in 'x out nothing] | {MyClass#A :> 'x <: nothing} & ~{MyClass#A :> 'a2 <: 'a2 | 'a0} | ~#MyClass | ~{MyClass#A :> 'a2 & 'a0 & 'a1})] & {
+//│       Ref#T :> 'b0 <: 'b0 & (MyClass[?] & ~{MyClass#A :> 'a0 & 'a1 <: 'a2 | 'a1} | MyClass[in 'x out nothing] | {MyClass#A = 'x} & ~{MyClass#A :> 'a2 <: 'a2 | 'a0} | ~#MyClass | ~{MyClass#A :> 'a2 & 'a0 & 'a1 <: 'a2 | 'a0 | 'a1})
+//│     } | ~MyClass['a]
+
+fun test(x, y) =
+  let tmp = mk(x, y)
+  let foo(z) = mk(z, tmp) : MyClass['x]
+  [tmp, foo]
+//│ fun test: forall 'a 'b 'b0 'a0 'a1 'a2 'x. (Ref['a], Ref['b]) -> [MyClass['a] & 'b, forall 'a3 'x0. Ref['a3] -> MyClass['x0]]
+//│   where
+//│     'x0 <: 'x
+//│     'a3 :> 'a2 | 'a1
+//│         <: 'a0
+//│     'b <: Ref[?] | Ref[?] & ~{MyClass#A = 'a} | Ref[in 'b0 out 'b0 & (MyClass[?] & ~{MyClass#A :> 'a0 & 'a1} | MyClass[in 'x out nothing] | {MyClass#A :> 'x <: nothing} & ~{MyClass#A :> 'a2 <: 'a2 | 'a0} | ~#MyClass | ~{MyClass#A :> 'a2 & 'a0 & 'a1})] & {
+//│       Ref#T :> 'b0 <: 'b0 & (MyClass[?] & ~{MyClass#A :> 'a0 & 'a1 <: 'a2 | 'a1} | MyClass[in 'x out nothing] | {MyClass#A = 'x} & ~{MyClass#A :> 'a2 <: 'a2 | 'a0} | ~#MyClass | ~{MyClass#A :> 'a2 & 'a0 & 'a1 <: 'a2 | 'a0 | 'a1})
+//│     } | ~MyClass['a]
+
+
+
+fun ref: 'a -> Ref['a]
+//│ fun ref: forall 'a. 'a -> Ref['a]
+
+fun test(x, y) =
+  let tmp = ref(mk(x, y))
+  let foo(z) = mk(z, tmp)
+  foo
+//│ fun test: forall 'a 'b. (Ref['a], Ref['b]) -> (forall 'a0. Ref['a0] -> (MyClass[in 'a0 | 'a out 'a & 'a0] & 'b))
+
+fun test(x, y) =
+  let tmp = ref(mk(x, y))
+  let foo(z) = mk(z, tmp) : MyClass['x]
+  foo
+//│ fun test: forall 'a 'b 'a0 'a1 'a2 'a3 'x 'x0. (Ref['a], Ref['b]) -> (forall 'a4 'x1. Ref['a4] -> MyClass['x1])
+//│   where
+//│     'x1 :> 'x0
+//│         <: 'x
+//│     'a4 :> 'a2 | 'a1
+//│         <: 'a0 & 'a3
+//│     'b <: MyClass[?] & ~{MyClass#A :> 'a0 & 'a1 | 'a <: 'a & ('a2 | 'a1 | 'a3)} | MyClass[in 'x out 'x & 'x0] | {MyClass#A :> 'x <: 'x & 'x0} & ~{MyClass#A :> 'a2 | 'a <: 'a & ('a2 | 'a0)} | ~MyClass[in 'a | 'a2 & ('a0 & 'a1 | 'a) out 'a & ('a2 | 'a0 | 'a1 | 'a3)]
+
+
+
+fun refined: forall 'A, 'B: (r: 'A) -> ('A & Ref['B])
+//│ fun refined: forall 'A 'B. (r: 'A) -> (Ref['B] & 'A)
+
+fun test(x: 'x) =
+  let foo() = refined(x)
+  foo
+//│ fun test: forall 'x. (x: 'x) -> (forall 'B. () -> (Ref['B] & 'x))
+
+// fun refined: forall 'A, 'B, 'C: (r: 'A, s: 'B) -> ('A & 'B & Ref['C])
+fun refined: forall 'A, 'B, 'C: (r: 'A, s: 'B) -> ('A & 'B)
+//│ fun refined: forall 'A 'B. (r: 'A, s: 'B) -> ('A & 'B)
+
+fun test(x: 'x) =
+  let foo(y: Ref['r] & 'y) = y
+  foo(x)
+//│ fun test: forall 'r 'y. (x: Ref['r] & 'y) -> (Ref['r] & 'y)
+
+fun test(x: 'x) =
+  let foo(y) = refined(x, y) : Ref['r]
+  foo
+//│ fun test: forall 'B 'r. (x: Ref[?] & ~'B | Ref[in 'r out nothing] | ~'B) -> (forall 'r0. 'B -> Ref['r0])
+//│   where
+//│     'r0 <: 'r
+
+
+
diff --git a/shared/src/test/diff/nu/TupleParamBlunder.mls b/shared/src/test/diff/nu/TupleParamBlunder.mls
new file mode 100644
index 0000000000..215ec4e0fa
--- /dev/null
+++ b/shared/src/test/diff/nu/TupleParamBlunder.mls
@@ -0,0 +1,35 @@
+:NewDefs
+
+
+// * TODO fix the parsing of this tuple-taking function signature!
+fun f: [Int, Int] -> Int
+fun f(a, b) = a + b  // should not be a valid implementation
+//│ fun f: (Int, Int) -> Int
+//│ fun f: (Int, Int) -> Int
+
+fun f: (Int, Int) -> Int
+fun f(a, b) = a + b
+//│ fun f: (Int, Int) -> Int
+//│ fun f: (Int, Int) -> Int
+
+:e
+fun f: [Int, Int] => Int
+fun f(a, b) = a + b
+//│ ╔══[ERROR] Type mismatch in definition:
+//│ ║  l.17: 	fun f(a, b) = a + b
+//│ ║        	    ^^^^^^^^^^^^^^^
+//│ ╟── type `[[Int, Int]]` does not match type `[?a, ?b]`
+//│ ║  l.16: 	fun f: [Int, Int] => Int
+//│ ║        	       ^^^^^^^^^^
+//│ ╟── Note: constraint arises from tuple literal:
+//│ ║  l.17: 	fun f(a, b) = a + b
+//│ ╙──      	     ^^^^^^
+//│ fun f: (Int, Int) -> Int
+//│ fun f: ([Int, Int]) -> Int
+
+fun f: (Int, Int) => Int
+fun f(a, b) = a + b
+//│ fun f: (Int, Int) -> Int
+//│ fun f: (Int, Int) -> Int
+
+

From d22ba92cecfb0a987bf29bde3c35372aa6c72285 Mon Sep 17 00:00:00 2001
From: Lionel Parreaux <lionel.parreaux@gmail.com>
Date: Wed, 3 Apr 2024 11:51:13 +0800
Subject: [PATCH 114/147] Fix flattening for multi-arg lambdas and improve some
 tests

---
 .../src/main/scala/mlscript/NewParser.scala   |  4 +
 .../src/test/diff/parser/FlatMultiArgLams.mls | 16 ++++
 .../test/diff/pretyper/ucs/examples/JSON.mls  | 88 ++++++++++---------
 .../pretyper/ucs/examples/LispInterpreter.mls | 25 +++---
 4 files changed, 77 insertions(+), 56 deletions(-)
 create mode 100644 shared/src/test/diff/parser/FlatMultiArgLams.mls

diff --git a/shared/src/main/scala/mlscript/NewParser.scala b/shared/src/main/scala/mlscript/NewParser.scala
index a2a54e7526..23366eeaa0 100644
--- a/shared/src/main/scala/mlscript/NewParser.scala
+++ b/shared/src/main/scala/mlscript/NewParser.scala
@@ -794,6 +794,10 @@ abstract class NewParser(origin: Origin, tokens: Ls[Stroken -> Loc], newDefs: Bo
             Bra(false, elt)
           case (Round, _) =>
             yeetSpaces match {
+              case (KEYWORD(opStr @ "=>"), l1) :: (NEWLINE, l2) :: _ /* if opPrec(opStr)._1 > prec */ =>
+                consume
+                val rhs = Blk(typingUnit.entities)
+                Lam(Tup(res), rhs)
               case (KEYWORD("=>"), l1) :: _ =>
                 consume
                 val e = expr(NewParser.opPrec("=>")._2)
diff --git a/shared/src/test/diff/parser/FlatMultiArgLams.mls b/shared/src/test/diff/parser/FlatMultiArgLams.mls
new file mode 100644
index 0000000000..5dc0f63404
--- /dev/null
+++ b/shared/src/test/diff/parser/FlatMultiArgLams.mls
@@ -0,0 +1,16 @@
+:NewDefs
+
+
+// Extracted frrom JSON.mls
+
+parseNegative(state).flatMap of (negative, state) =>
+parseIntegral(state).flatMap of (integral, state) =>
+parseFraction(state).flatMap of (fraction, state) =>
+parseExponent(state).flatMap of (exponent, state) =>
+let value = (integral +. fraction) *. exponent
+Success of (if negative then (0 -. value) else value), state
+//│ |parseNegative|(|state|)|.flatMap| |#of| |(|negative|,| |state|)| |#=>|↵|parseIntegral|(|state|)|.flatMap| |#of| |(|integral|,| |state|)| |#=>|↵|parseFraction|(|state|)|.flatMap| |#of| |(|fraction|,| |state|)| |#=>|↵|parseExponent|(|state|)|.flatMap| |#of| |(|exponent|,| |state|)| |#=>|↵|#let| |value| |#=| |(|integral| |+.| |fraction|)| |*.| |exponent|↵|Success| |#of| |(|#if| |negative| |#then| |(|0| |-.| |value|)| |#else| |value|)|,| |state|
+//│ Parsed: {(parseNegative(state,)).flatMap((negative, state,) => {(parseIntegral(state,)).flatMap((integral, state,) => {(parseFraction(state,)).flatMap((fraction, state,) => {(parseExponent(state,)).flatMap((exponent, state,) => {let value = *.('(' +.(integral, fraction,) ')', exponent,); Success('(' if (negative) then '(' -.(0, value,) ')' else value ')', state,)},)},)},)},)}
+//│ 
+
+
diff --git a/shared/src/test/diff/pretyper/ucs/examples/JSON.mls b/shared/src/test/diff/pretyper/ucs/examples/JSON.mls
index 6d5cc7437f..f37bdf0322 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/JSON.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/JSON.mls
@@ -53,20 +53,6 @@ fun (*>) strgt(a: NStr, b: NStr) = a.localeCompare(b) > 0
 declare fun Math: { log10: Num -> Num, floor: Num -> Num, ceil: Num -> Num }
 //│ fun Math: {ceil: Num -> Num, floor: Num -> Num, log10: Num -> Num}
 
-// Steal operators from OCaml:
-let (+.) numAdd' = numAdd
-let (-.) numSub' = numSub
-let (*.) numMul' = numMul
-//│ let (+.) numAdd': (Num, Num) -> Num
-//│ let (-.) numSub': (Num, Num) -> Num
-//│ let (*.) numMul': (Num, Num) -> Num
-//│ numAdd'
-//│         = [Function: numAdd]
-//│ numSub'
-//│         = [Function: numSub]
-//│ numMul'
-//│         = [Function: numMul]
-
 fun (!==) notEqual(x, y) = not(x === y)
 declare fun parseInt: (Str, Int) -> Int
 //│ fun (!==) notEqual: forall 'a. (Eql['a], 'a) -> Bool
@@ -116,15 +102,18 @@ fun (->) makePair(a, b) = [a, b]
 abstract class ListMap[K, out V]: (ConsMap[K, V] | NilMap)
 class ConsMap[K, out V](head: [K, V], tail: ListMap[K, V]) extends ListMap[K, V]
 module NilMap extends ListMap
+  
 fun containsKey(map: ListMap['K, 'V], key: 'K): Bool = if map is
   ConsMap([k, _], _) and k === key then true
   ConsMap(_, tail) then containsKey(tail, key)
   NilMap then false
+  
 fun (:+) insert(map, entry) = if map is
   ConsMap(entry', map) and
     entry'.0 === entry.0 then ConsMap(entry, map)
     else ConsMap(entry', insert(map, entry))
   NilMap then ConsMap(entry, NilMap)
+  
 fun showMap(map) =
   let showEntry([k, v]) = toString(k) ++ " -> " ++ toString(v)
   let rec aux(map) = if map is
@@ -192,6 +181,7 @@ fun success: forall 't: ('t, ParserState) -> ParseResult['t]
 fun success = (value, state) => Success(value, state)
 fun failure: forall 't: Str -> ParseResult[nothing]
 fun failure = error => Failure(error)
+  
 abstract class ParseResult[out T]: (Success[T] | Failure) {
   virtual fun flatMap(f: (T, ParserState) -> ParseResult['U]): ParseResult['U]
   virtual fun map(f: T -> 'U): ParseResult['U]
@@ -256,6 +246,7 @@ fun parseNumber(state: ParserState): ParseResult[Num] =
   let parseNegative(state): ParseResult[Bool] = if state.peek is
     Some("-") then Success(true, state.next)
     else Success(false, state)
+  
   // Parse one or more decimal digits
   // --------------------------------
   let parseDigits(state): ParseResult[Num] =
@@ -268,11 +259,13 @@ fun parseNumber(state: ParserState): ParseResult[Num] =
       Some([digit, state']) and aux(digit, state') is
         [num, state''] then Success(num, state'')
       None then Failure("expected one or more decimal digits")
+  
   // Parse the integral part of the number
   // -------------------------------------
   let parseIntegral(state): ParseResult[Num] = if state.nextDigit is
     Some([0, state']) then Success(0, state')
     else parseDigits(state)
+  
   // Parse the fractional part of the number
   // ---------------------------------------
   let parseFraction(state): ParseResult[Num] = if state.peek is
@@ -283,18 +276,18 @@ fun parseNumber(state: ParserState): ParseResult[Num] =
       Some("-") then Success(true, state.next)
       Some("+") then Success(false, state.next)
       else Success(false, state)
-    if state.peek is Some(e) and (e === "e") || (e === "E") then
-      parseSign(state.next).flatMap of (sign, state) =>
-        parseDigits(state).map of exponent =>
-          if sign then 10 ** (0 -. exponent) else 10 ** exponent
-    else
-      Success(1, state)
+    if state.peek is Some(e) and (e === "e") || (e === "E")
+    then parseSign(state.next).flatMap of (sign, state) =>
+      parseDigits(state).map of exponent =>
+      if sign then 10 ** (0 -. exponent) else 10 ** exponent
+    else Success(1, state)
+  
   parseNegative(state).flatMap of (negative, state) =>
-    parseIntegral(state).flatMap of (integral, state) =>
-      parseFraction(state).flatMap of (fraction, state) =>
-        parseExponent(state).flatMap of (exponent, state) =>
-          let value = (integral +. fraction) *. exponent
-          Success of (if negative then (0 -. value) else value), state
+  parseIntegral(state).flatMap of (integral, state) =>
+  parseFraction(state).flatMap of (fraction, state) =>
+  parseExponent(state).flatMap of (exponent, state) =>
+  let value = (integral +. fraction) *. exponent
+  Success of (if negative then (0 -. value) else value), state
 //│ fun parseNumber: (state: ParserState) -> ParseResult[Num]
 
 showParseResult of parseNumber of ParserState of String("0"), 0
@@ -324,6 +317,7 @@ showParseResult of parseNumber of ParserState of String("1E+1"), 0
 //│     = 'Success after 4: 10'
 
 fun parseString(state: ParserState): ParseResult[Str] =
+  
   let rec parseCodePoint(n, acc, state) = if
     n === 0 then Success(acc, state)
     state.peekCode is Some(code) and
@@ -332,6 +326,7 @@ fun parseString(state: ParserState): ParseResult[Str] =
       97 <= code and code <= 102 then parseCodePoint(n - 1, acc * 16 + code - 87, state.next)
       else Failure("expect " ++ toString(n) ++ " hex digit(s) instead of '" ++ String.fromCodePoint(code) ++ "'")
     else Failure("expect " ++ toString(n) ++ " hex digit(s) instead of end of input")
+  
   let rec parseContent(acc, state) = if state.peek is
     Some("\"") then Success(acc, state.next)
     Some("\\") and
@@ -347,12 +342,13 @@ fun parseString(state: ParserState): ParseResult[Str] =
         Some("t") then parseContent(acc ++ "\t", state'.next)
         Some("u") then
           parseCodePoint(4, 0, state'.next).flatMap of (codePoint, state) =>
-            if codePoint < 0xD800 || 0xDFFF < codePoint then
-              parseContent(acc ++ String.fromCodePoint(codePoint), state)
-            else Failure("invalid code point")
+          if codePoint < 0xD800 || 0xDFFF < codePoint
+          then parseContent(acc ++ String.fromCodePoint(codePoint), state)
+          else Failure("invalid code point")
         else Failure("invalid escape sequence")
     Some(ch) then parseContent(acc ++ ch, state.next)
     None then Failure("expected '\"' instead of end of input")
+  
   if state.peek is
     Some("\"") then parseContent("", state.next)
     Some(ch) then Failure("expected '\"' instead of '" ++ ch ++ "'")
@@ -395,10 +391,12 @@ fun parseTrue(state: ParserState): ParseResult[Bool] =
   if state.match("true") is
     Some(state) then Success(true, state)
     None then Failure("expected 'true'")
+  
 fun parseFalse(state: ParserState): ParseResult[Bool] =
   if state.match("false") is
     Some(state) then Success(false, state)
     None then Failure("expected 'false'")
+  
 fun parseNull(state: ParserState): ParseResult[()] =
   if state.match("null") is
     Some(state) then Success((), state)
@@ -410,24 +408,25 @@ fun parseNull(state: ParserState): ParseResult[()] =
 fun parseObjectEntry(state: ParserState): ParseResult[[Str, JsonValue]] =
   let state' = skipWhiteSpace(state)
   parseString(state').flatMap of (key, state) =>
-    let state' = skipWhiteSpace(state)
-    if state'.peek is
-      Some(":") then
-        parseValue(state'.next).flatMap of (value, state') =>
-          Success([key, value], state')
-      Some(ch) then Failure("expected ':' instead of '" ++ ch ++ "'")
-      None then Failure("expected ':' instead of end of input")
-    else Failure("expected ':' instead of end of input")
+  let state' = skipWhiteSpace(state)
+  if state'.peek is
+    Some(":") then
+      parseValue(state'.next).flatMap of (value, state') =>
+      Success([key, value], state')
+    Some(ch) then Failure("expected ':' instead of '" ++ ch ++ "'")
+    None then Failure("expected ':' instead of end of input")
+  else Failure("expected ':' instead of end of input")
+  
 fun parseObject(state: ParserState): ParseResult[ListMap[Str, JsonValue]] =
   let rec parseObjectTail(acc: ListMap[Str, JsonValue], state: ParserState) =
     let state' = skipWhiteSpace(state)
     if state'.peek is
       Some(",") then
         parseObjectEntry(state'.next).flatMap of (entry, state') =>
-          if containsKey(acc, entry.0) then
-            Failure("duplicate key '" ++ toString(entry.0) ++ "'")
-          else
-            parseObjectTail(ConsMap(entry, acc), state')
+        if containsKey(acc, entry.0) then
+          Failure("duplicate key '" ++ toString(entry.0) ++ "'")
+        else
+          parseObjectTail(ConsMap(entry, acc), state')
       Some("}") then Success(acc, state'.next)
       Some(ch) then Failure("expected ',' or ']' instead of " ++ ch)
       None then Failure("expected ',' or ']' instead of end of input")
@@ -437,14 +436,15 @@ fun parseObject(state: ParserState): ParseResult[ListMap[Str, JsonValue]] =
     None then Failure("expected ',' or ']' instead of end of input")
     else
       parseObjectEntry(state').flatMap of (head, state) =>
-        parseObjectTail(ConsMap(head, NilMap), state)
+      parseObjectTail(ConsMap(head, NilMap), state)
+  
 fun parseArray(state: ParserState): ParseResult[List[JsonValue]] =
   let rec parseArrayTail(acc, state) =
     let state' = skipWhiteSpace(state)
     if state'.peek is
       Some(",") then
         parseValue(state'.next).flatMap of (value, state') =>
-          parseArrayTail(value :: acc, state')
+        parseArrayTail(value :: acc, state')
       Some("]") then Success(reverse(acc), state'.next)
       Some(ch) then Failure("expected ',' or ']' instead of " ++ ch)
       None then Failure("expected ',' or ']' instead of end of input")
@@ -454,7 +454,8 @@ fun parseArray(state: ParserState): ParseResult[List[JsonValue]] =
     None then Failure("expected ',' or ']' instead of end of input")
     else
       parseValue(state').flatMap of (head, state) =>
-        parseArrayTail(head :: Nil, state)
+      parseArrayTail(head :: Nil, state)
+  
 fun parseValue(state: ParserState): ParseResult[JsonValue] =
   let state' = skipWhiteSpace(state)
   if state'.peek is
@@ -490,6 +491,7 @@ fun stringify(value: JsonValue): Str =
       ConsMap(head, tail) then showEntry(head) ++ ", " ++ aux(tail)
       NilMap then ""
     if map is NilMap then String("{}") else "{ " ++ aux(map) ++ " }"
+  
   if value is
     JsonNumber(n) then toString(n)
     JsonString(s) then "\"" ++ s ++ "\""
diff --git a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
index 9553e0c358..241a8dd217 100644
--- a/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
+++ b/shared/src/test/diff/pretyper/ucs/examples/LispInterpreter.mls
@@ -181,10 +181,9 @@ fun skipBlank(s: NStr, i: Int): Int =
 
 fun scanWhile(s: NStr, i: Int, p: Str -> Bool): Option[[Str, Int]] =
   let rec aux(acc, i) =
-    if i < s.length and s.charAt(i) is ch and p of ch then
-      aux(acc ++ ch, i + 1)
-    else
-      [acc, i]
+    if i < s.length and s.charAt(i) is ch and p of ch
+      then aux(acc ++ ch, i + 1)
+      else [acc, i]
   if aux("", i) is
     ["", _] then None
     [acc, i] then Some([acc, i])
@@ -238,10 +237,9 @@ fun isDigit(n) = 48 <= n and n <= 57
 fun isDigits(s: Str): Bool =
   let s' = String(s)
   let rec aux(i) =
-    if i < s'.length and isDigit of s'.charCodeAt(i) then
-      aux(i + 1)
-    else
-      i === s'.length
+    if i < s'.length and isDigit of s'.charCodeAt(i)
+      then aux(i + 1)
+      else i === s'.length
   aux(0)
 isDigits("123")
 isDigits("123jump")
@@ -275,6 +273,7 @@ fun parseExpr(tokens: List[Str]): [ParseResult[Data], List[Str]] =
       isDigits(token) then [(Success of Literal of IntLit of parseInt(token, 10)), tail]
       else [(Success of Symbol of token), tail]
     Nil then [Failure("Unexpected end of input, expect either `)` or more tokens."), Nil]
+  
 fun parseList(tokens: List[Str]): [ParseResult[DataList], List[Str]] =
   let rec collect(acc, ts) = if ts is
     Cons(")", tail) then [(Success of DataList of reverse of acc), tail]
@@ -442,12 +441,12 @@ fun builtinNull(args: List[Data]): Data = if args is
 //│ builtinNil
 //│            = DataList {}
 
-let globalEnv = emptyEnv ++: (
+let globalEnv = emptyEnv ++:
   ["eq", Literal(Lambda(builtinEq))] :: ["+", Literal(Lambda(builtinAdd))] ::
-    ["-", Literal(Lambda(builtinSub))] :: ["*", Literal(Lambda(builtinMul))] ::
-      ["nil", builtinNil] :: ["cons", Literal(Lambda(builtinCons))] ::
-        ["car", Literal(Lambda(builtinCar))] :: ["cdr", Literal(Lambda(builtinCdr))] ::
-          ["null", Literal(Lambda(builtinNull))] :: Nil)
+  ["-", Literal(Lambda(builtinSub))] :: ["*", Literal(Lambda(builtinMul))] ::
+  ["nil", builtinNil] :: ["cons", Literal(Lambda(builtinCons))] ::
+  ["car", Literal(Lambda(builtinCar))] :: ["cdr", Literal(Lambda(builtinCdr))] ::
+  ["null", Literal(Lambda(builtinNull))] :: Nil
 //│ let globalEnv: (name': Str) -> (DataList | Literal)
 //│ globalEnv
 //│           = [Function (anonymous)]

From fbfd775f721a62c84470b30d7b5b607d6c5252ce Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 24 Apr 2024 16:55:29 +0800
Subject: [PATCH 115/147] Remove class seal validation

---
 .../scala/mlscript/pretyper/PreTyper.scala    | 39 -------------------
 .../main/scala/mlscript/pretyper/Symbol.scala |  1 -
 .../ucs/stages/CoverageChecking.scala         |  4 --
 3 files changed, 44 deletions(-)

diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index a89271d7bc..4ac95772e0 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -218,20 +218,6 @@ class PreTyper extends Traceable with Diagnosable with Desugarer {
         self.baseTypes = bases
         println(s"base types of `${self.name}`: ${bases.iterator.map(_.name).mkString(", ")}")
       }
-      // Pass 1.2: Resolve signature types for collecting sealed derived types.
-      println("Resolve sealed signature types")
-      typeSymbols.foreach {
-        case _: MixinSymbol | _: TypeAliasSymbol | _: ModuleSymbol => ()
-        case symbol => symbol.defn.sig.foreach { unions =>
-          val derivedTypes = try extractSignatureTypes(unions) catch { case _: NotImplementedError => Nil }
-          symbol.sealedDerivedTypes = derivedTypes.flatMap { derivedType =>
-            val maybeSymbol = scopeWithTypes.getTypeSymbol(derivedType.name)
-            if (maybeSymbol.isEmpty) raiseError(msg"Undefined type $derivedType" -> derivedType.toLoc)
-            maybeSymbol
-          }
-          println(s">>> $name: ${symbol.sealedDerivedTypes.iterator.map(_.name).mkString(", ")}")
-        }
-      }
       // Pass 2: Build a complete scope and collect definitional terms and terms to be traversed.
       val (completeScope, thingsToTraverse) = statements.foldLeft[(Scope, Ls[(Term \/ DefinedTermSymbol, Scope)])](scopeWithTypes, Nil) {
         case ((scope, acc), term: Term) => (scope, (L(term), scope) :: acc)
@@ -278,31 +264,6 @@ class PreTyper extends Traceable with Diagnosable with Desugarer {
     trace(s"PreTyper <== $name: ${typingUnit.describe}") {
       traverseStatements(typingUnit.entities, name, scope)
     }({ scope => s"PreTyper ==> ${scope.showLocalSymbols}" })
-  
-  /**
-    * Extract types in class signatures. For example, for this piece of code
-    * ```mls
-    * abstract class Option[A]: Some[A] | None
-    * ```
-    * this function returns, `Some` and `None`.
-    *
-    * @param ty a type obtained from `NuTypeDef.sig`
-    * @return a list of type names, without any p
-    */
-  private def extractSignatureTypes(ty: Type): Ls[TypeName] = {
-    @tailrec
-    def rec(acc: Ls[TypeName], ty: Type): Ls[TypeName] = ty match {
-      case tn: TypeName => tn :: acc
-      case AppliedType(tn: TypeName, _) => tn :: acc
-      case Union(lhs, tn: TypeName) => rec(tn :: acc, lhs)
-      case Union(lhs, AppliedType(tn: TypeName, _)) => rec(tn :: acc, lhs)
-      case other =>
-        // Let's not raise warning for now.
-        // raiseWarning(msg"unknown type in signature" -> other.toLoc)
-        Nil
-    }
-    rec(Nil, ty).reverse
-  }
 
   def extractSuperTypes(parents: Ls[Term]): Ls[Var] = {
     @tailrec
diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index 3e3785fffc..afbeaf863c 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -26,7 +26,6 @@ package object symbol {
     override def name: Str = defn.name
 
     var baseTypes: Ls[TypeSymbol] = Nil
-    var sealedDerivedTypes: Ls[TypeSymbol] = Nil
 
     @inline def hasBaseClass(baseClassLikeSymbol: TypeSymbol): Bool =
       baseTypes.exists(_ === baseClassLikeSymbol)
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index 2639c99a1c..ed8f9f8c11 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -213,10 +213,6 @@ object CoverageChecking {
       * set `{ Z }`. Set `{ B, C }` represents that the scrutinee can be further
       * refined to class `B` or `class C`. Set `{ Z }` represents that if the
       * scrutinee is not `A`, then it can be `Z`.
-      * 
-      * If `A` is sealed to `B`, `C`, and `D`, then we get `{ B, C, D }` and
-      * `{ Z }`. Because if the scrutinee is assumed to be `A`, then it can also
-      * be `D` other than `B`, `C`.
       *
       * @param classLikeSymbol the type symbol represents the class like type
       * @return If the pattern set doesn't include the given type symbol, this

From 8ca2b3c94dc8faa4d2404a9f0a24762eaf2f3536 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 24 Apr 2024 17:11:13 +0800
Subject: [PATCH 116/147] Remove a piece of code introduced in merging

---
 shared/src/main/scala/mlscript/Typer.scala | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/shared/src/main/scala/mlscript/Typer.scala b/shared/src/main/scala/mlscript/Typer.scala
index 9d271dc922..b487476c8c 100644
--- a/shared/src/main/scala/mlscript/Typer.scala
+++ b/shared/src/main/scala/mlscript/Typer.scala
@@ -1684,12 +1684,6 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
                   err("type identifier not found: " + nme, pat.toLoc)(raise)
                   bail()
               }
-            case Some(td) =>
-              td.kind match {
-                case Als | Mod | Mxn => val t = err(msg"can only match on classes and traits", pat.toLoc)(raise); t -> t
-                case Cls => val t = clsNameToNomTag(td)(tp(pat.toLoc, "class pattern"), ctx); t -> t
-                case Trt => val t = trtNameToNomTag(td)(tp(pat.toLoc, "trait pattern"), ctx); t -> t
-              }
           }
       }
       val newCtx = if (ctx.inQuote) ctx.enterQuotedScope else ctx.nest

From 107e054b1930142193ec4db934223bf37e036e32 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Thu, 25 Apr 2024 10:02:30 +0800
Subject: [PATCH 117/147] Fix old code introduced in merging

---
 js/src/main/scala/Main.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/js/src/main/scala/Main.scala b/js/src/main/scala/Main.scala
index f8a7f9b1bb..e6c59c21fc 100644
--- a/js/src/main/scala/Main.scala
+++ b/js/src/main/scala/Main.scala
@@ -159,7 +159,7 @@ object Main {
                             |""".stripMargin
 
           val backend = new JSWebBackend()
-          val (lines, resNames) = backend(pgrm, newDefs = true)
+          val (lines, resNames) = backend(pgrm)
           val code = lines.mkString("\n")
 
           // TODO: add a toggle button to show js code

From a11e61cad5548d41b5602c34dda21222ca0db423 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Thu, 25 Apr 2024 10:41:15 +0800
Subject: [PATCH 118/147] Record symbol bugs in compiler tests

---
 .../test/diff/Defunctionalize/Lambdas.mls     |  2 +-
 .../test/diff/Defunctionalize/Modules.mls     |  6 ++--
 .../test/diff/Defunctionalize/OldMonoList.mls | 24 +++++++-------
 .../test/diff/Defunctionalize/SimpleFunc.mls  |  8 ++---
 shared/src/main/scala/mlscript/helpers.scala  | 17 +---------
 .../main/scala/mlscript/pretyper/Symbol.scala | 18 +++++++++++
 shared/src/test/diff/pretyper/ucs/Symbol.mls  | 32 +++++++++++++++++++
 7 files changed, 71 insertions(+), 36 deletions(-)
 create mode 100644 shared/src/test/diff/pretyper/ucs/Symbol.mls

diff --git a/compiler/shared/test/diff/Defunctionalize/Lambdas.mls b/compiler/shared/test/diff/Defunctionalize/Lambdas.mls
index d0539087fa..50471c0c23 100644
--- a/compiler/shared/test/diff/Defunctionalize/Lambdas.mls
+++ b/compiler/shared/test/diff/Defunctionalize/Lambdas.mls
@@ -41,7 +41,7 @@
 //│   Code(List(main$$1()))
 //│ }
 //│ class Lambda1$1$1()
-//│ fun apply$Lambda1$1$1: (anything, Object) -> Bool
+//│ fun apply$Lambda1$1$1: (anything, Bool) -> Bool
 //│ fun main$$1: () -> Bool
 //│ Bool
 //│ res
diff --git a/compiler/shared/test/diff/Defunctionalize/Modules.mls b/compiler/shared/test/diff/Defunctionalize/Modules.mls
index a5d1c6732b..48f5a7548b 100644
--- a/compiler/shared/test/diff/Defunctionalize/Modules.mls
+++ b/compiler/shared/test/diff/Defunctionalize/Modules.mls
@@ -20,8 +20,10 @@ x.y.f
 //│   fun main$$2 = () => let obj = let obj = x$2 in if obj is ‹(x$2) then y$x$2(obj,); else error› in if obj is ‹(Foo$1) then f$Foo$1(obj,); else error›
 //│   Code(List(main$$2()))
 //│ }
-//│ ╔══[WARNING] Found a redundant else branch
-//│ ╙──
+//│ ╔══[WARNING] the outer binding `x$2`
+//│ ╙── is shadowed by name pattern `x$2`
+//│ ╔══[WARNING] this case is unreachable
+//│ ╙── because it is subsumed by the branch
 //│ module x$2
 //│ class Foo$1()
 //│ let y$x$2: anything -> Foo$1
diff --git a/compiler/shared/test/diff/Defunctionalize/OldMonoList.mls b/compiler/shared/test/diff/Defunctionalize/OldMonoList.mls
index 532fede8be..856ea86ac4 100644
--- a/compiler/shared/test/diff/Defunctionalize/OldMonoList.mls
+++ b/compiler/shared/test/diff/Defunctionalize/OldMonoList.mls
@@ -42,19 +42,17 @@ fun add2(x) = x+2
 //│   fun apply$Lambda1$2$3 = (this, x,) => +(x, 1,)
 //│   Code(List(main$$5()))
 //│ }
-//│ class Lambda1$3$4()
-//│ class Nil$2()
-//│ class List$1(e: Int, tail: List$1 | Nil$2)
-//│ class Lambda1$2$3()
-//│ fun map$List$1: (Object, Object) -> List$1
-//│ fun add2$1: Int -> Int
-//│ fun main$$5: () -> List$1
-//│ fun apply$Lambda1$3$4: (anything, Int) -> Int
-//│ fun map$Nil$2: forall 'a. ('a & (List$1 | Nil$2), anything) -> (Nil$2 | 'a)
-//│ fun apply$Lambda1$2$3: (anything, Int) -> Int
-//│ List$1
-//│ res
-//│     = List$1 {}
+//│ /!!!\ Uncaught error: java.lang.Exception: Internal Error: Symbol already set for obj
+//│ 	at: mlscript.utils.package$.lastWords(package.scala:227)
+//│ 	at: mlscript.VarImpl.symbol_$eq(helpers.scala:870)
+//│ 	at: mlscript.VarImpl.symbol_$eq$(helpers.scala:864)
+//│ 	at: mlscript.Var.symbol_$eq(syntax.scala:67)
+//│ 	at: mlscript.ucs.Desugarer$VarOps.resolveTermSymbol(Desugarer.scala:124)
+//│ 	at: mlscript.ucs.Desugarer$VarOps.withResolvedTermSymbol(Desugarer.scala:129)
+//│ 	at: mlscript.ucs.stages.Desugaring.desugarPatternSplit(Desugaring.scala:432)
+//│ 	at: mlscript.ucs.stages.Desugaring.$anonfun$desugarTermBranch$2(Desugaring.scala:101)
+//│ 	at: mlscript.pretyper.Traceable.trace(Traceable.scala:39)
+//│ 	at: mlscript.pretyper.Traceable.trace$(Traceable.scala:36)
 
 :mono
 class List(e: Int, tail: List | Nil) {
diff --git a/compiler/shared/test/diff/Defunctionalize/SimpleFunc.mls b/compiler/shared/test/diff/Defunctionalize/SimpleFunc.mls
index e3ec697b00..dbf5455518 100644
--- a/compiler/shared/test/diff/Defunctionalize/SimpleFunc.mls
+++ b/compiler/shared/test/diff/Defunctionalize/SimpleFunc.mls
@@ -1,16 +1,16 @@
 :NewDefs
 
 :mono
-fun f(x: Int) = if x then 42 else 1337
+fun f(x: Bool) = if x then 42 else 1337
 //│ Lifted:
 //│ TypingUnit {
-//│   fun f$1 = (x: Int,) => if (x) then 42 else 1337
+//│   fun f$1 = (x: Bool,) => if (x) then 42 else 1337
 //│ }
 //│ Mono:
 //│ TypingUnit {
-//│   fun f$1 = (x: Int,) => if (x) then 42 else 1337
+//│   fun f$1 = (x: Bool,) => if (x) then 42 else 1337
 //│ }
-//│ fun f$1: (x: Int) -> (1337 | 42)
+//│ fun f$1: (x: Bool) -> (1337 | 42)
 
 :mono
 fun foo() = 42
diff --git a/shared/src/main/scala/mlscript/helpers.scala b/shared/src/main/scala/mlscript/helpers.scala
index cd9040987c..aa9505c371 100644
--- a/shared/src/main/scala/mlscript/helpers.scala
+++ b/shared/src/main/scala/mlscript/helpers.scala
@@ -841,7 +841,7 @@ trait LitImpl { self: Lit =>
   }
 }
 
-trait VarImpl { self: Var =>
+trait VarImpl extends pretyper.symbol.Symbolic { self: Var =>
   /** Check if the variable name is an integer. */
   def isIndex: Bool = name.headOption match {
     case S('0') => name.length === 1
@@ -854,21 +854,6 @@ trait VarImpl { self: Var =>
     (name.head.isLetter && name.head.isLower || name.head === '_' || name.head === '$') && name =/= "true" && name =/= "false"
   def toVar: Var = this
   var uid: Opt[Int] = N
-
-  // PreTyper additions
-  import pretyper.symbol.Symbol
-
-  private var _symbol: Opt[Symbol] = N
-  def symbolOption: Opt[Symbol] = _symbol
-  def symbol: Symbol = _symbol.getOrElse(???)
-  def symbol_=(symbol: Symbol): Unit =
-    _symbol match {
-      case N => _symbol = S(symbol)
-      case S(`symbol`) => ()
-      case S(_) => ???
-    }
-  // def withSymbol: Var = { symbol = S(new ValueSymbol(this, false)); this }
-  def withSymbol(symbol: Symbol): Var = { this.symbol = symbol; this }
 }
 
 trait TupImpl { self: Tup =>
diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index afbeaf863c..35c2feb971 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -108,4 +108,22 @@ package object symbol {
 
     override def nameVar: Var = nme
   }
+
+  trait Symbolic {
+    val name: String
+
+    private var _symbol: Opt[Symbol] = N
+
+    def symbolOption: Opt[Symbol] = _symbol
+    def symbol: Symbol = _symbol.getOrElse(lastWords(s"Symbol not set for $name"))
+    def symbol_=(symbol: Symbol): Unit =
+      _symbol match {
+        case N => _symbol = S(symbol)
+        case S(`symbol`) => ()
+        case S(current) =>
+          println(s"symbol: old ${current.name} vs new ${symbol.name}")
+          lastWords(s"Symbol already set for $name")
+      }
+    def withSymbol(symbol: Symbol): this.type = { this.symbol = symbol; this }
+  }
 }
diff --git a/shared/src/test/diff/pretyper/ucs/Symbol.mls b/shared/src/test/diff/pretyper/ucs/Symbol.mls
new file mode 100644
index 0000000000..bff06e35ce
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/Symbol.mls
@@ -0,0 +1,32 @@
+:NewDefs
+
+type List[A] = Cons[A] | Nil
+class Cons[A](head: A, tail: List[A])
+module Nil
+//│ type List[A] = Cons[A] | Nil
+//│ class Cons[A](head: A, tail: List[A])
+//│ module Nil
+
+fun (::) cons(head, tail) = Cons(head, tail)
+//│ fun (::) cons: forall 'A. ('A, List['A]) -> Cons['A]
+
+fun map(f, xs) = if xs is
+  Cons(head, tail) then f(head) :: map(f, tail)
+  Nil then Nil
+//│ fun map: forall 'A 'A0. ('A -> 'A0, Cons['A] | Nil) -> (Cons['A0] | Nil)
+
+// fun main$$5 = () =>
+//   let obj =
+//     let obj = '(' (new List$1)(1, (new List$1)(2, (new Nil$2)(),),) ')' in
+//       if obj is ‹(List$1) then map$List$1(obj, {Lambda1$2$3()},); else error›
+//     in
+//       if obj is ‹(List$1) then map$List$1(obj, {Lambda1$3$4()},); else error›
+// Got: Internal Error: Symbol already set for obj
+fun main(f) =
+  let obj = (let obj = Cons(1, Cons(2, Nil)) in (if obj is Cons(head, tail) then f(head) :: tail else Nil)) in
+    if obj is Cons(head, tail) then f(head) :: tail else Nil
+//│ fun main: forall 'A 'A0. ((1 | 2 | 'A) -> 'A) -> (Cons['A0] | Nil)
+//│   where
+//│     'A <: 'A0
+//│     'A0 :> 1 | 2
+//│         <: 'A

From 1d4b486521bc74553c611b05aba0a4b93ef9651a Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Thu, 25 Apr 2024 10:44:37 +0800
Subject: [PATCH 119/147] Amend a case which should emit warnings

---
 .../src/test/diff/pretyper/ucs/Refinement.mls | 27 ++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/shared/src/test/diff/pretyper/ucs/Refinement.mls b/shared/src/test/diff/pretyper/ucs/Refinement.mls
index 95b2b48a64..c928327017 100644
--- a/shared/src/test/diff/pretyper/ucs/Refinement.mls
+++ b/shared/src/test/diff/pretyper/ucs/Refinement.mls
@@ -31,7 +31,32 @@ x => if x is
 //│ res
 //│     = [Function: res]
 
-// NOT OK
+:w
+:ducs:desugar.result,postprocess.result
+x => if x is
+  refined(None) then x
+  Some then x
+//│ Desugared UCS term:
+//│ if
+//│   x*‡ is refined None then x
+//│   x*‡ is Some then x
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   refined None*† -> x
+//│   Some*◊ -> x
+//│ ╔══[WARNING] inconsistent refined pattern
+//│ ║  l.37: 	  refined(None) then x
+//│ ║        	          ^^^^
+//│ ╟── pattern `Some` is not refined
+//│ ║  l.38: 	  Some then x
+//│ ║        	  ^^^^
+//│ ╟── but pattern `None` is refined
+//│ ║  l.37: 	  refined(None) then x
+//│ ╙──      	          ^^^^
+//│ (None | Some[anything]) -> Some[nothing]
+//│ res
+//│     = [Function: res]
+
 :ducs:desugar.result,postprocess.result
 x => if x is
   refined(None) then x

From b56cacbdc629713469c4139eeb0e25650676fd30 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Sat, 27 Apr 2024 12:51:44 +0800
Subject: [PATCH 120/147] Make base type resolution for class-like symbols lazy

---
 .../scala/mlscript/pretyper/PreTyper.scala    | 85 +++----------------
 .../main/scala/mlscript/pretyper/Scope.scala  |  4 +-
 .../main/scala/mlscript/pretyper/Symbol.scala | 73 +++++++++++++---
 .../main/scala/mlscript/ucs/Desugarer.scala   |  6 +-
 .../scala/mlscript/ucs/context/Pattern.scala  | 12 +--
 .../mlscript/ucs/context/Scrutinee.scala      |  9 +-
 .../ucs/stages/CoverageChecking.scala         |  6 +-
 .../mlscript/ucs/stages/Desugaring.scala      |  2 +-
 .../scala/mlscript/ucs/stages/package.scala   |  3 +-
 .../src/main/scala/mlscript/utils/Lazy.scala  | 36 ++++++++
 shared/src/test/diff/pretyper/Errors.mls      | 77 ++++++++---------
 .../src/test/scala/mlscript/DiffTests.scala   |  1 +
 12 files changed, 164 insertions(+), 150 deletions(-)
 create mode 100644 shared/src/main/scala/mlscript/utils/Lazy.scala

diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index 4ac95772e0..f46752d1c6 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -4,8 +4,6 @@ import annotation.tailrec, collection.mutable.{Set => MutSet}, collection.immuta
 import mlscript._, utils._, shorthands._, Diagnostic.PreTyping, Message.MessageContext, symbol._, ucs.Desugarer
 
 class PreTyper extends Traceable with Diagnosable with Desugarer {
-  import PreTyper._
-
   /** A shorthand function to raise errors without specifying the source. */
   protected def raiseError(messages: (Message -> Opt[Loc])*): Unit =
     raiseError(PreTyping, messages: _*)
@@ -117,12 +115,8 @@ class PreTyper extends Traceable with Diagnosable with Desugarer {
         case Blk(stmts) =>
           traverseStatements(stmts, "block", scope)
           ()
-        case Subs(arr, idx) =>
-          traverseTerm(arr)
-          traverseTerm(idx)
-        case Bind(lhs, rhs) =>
-          traverseTerm(lhs)
-          traverseTerm(rhs)
+        case Subs(arr, idx) => traverseTerm(arr); traverseTerm(idx)
+        case Bind(lhs, rhs) => traverseTerm(lhs); traverseTerm(rhs)
         case Splc(fields) => fields.foreach {
           case L(t) => traverseTerm(t)
           case R(Fld(_, t)) => traverseTerm(t)
@@ -190,33 +184,18 @@ class PreTyper extends Traceable with Diagnosable with Desugarer {
   private def traverseStatements(statements: Ls[Statement], name: Str, parentScope: Scope): Scope =
     trace(s"traverseStatements <== $name: ${"statement".pluralize(statements.size, true)}") {
       // Pass 1: Build a scope with type symbols only.
-      val filterNuTypeDef = { (_: Statement) match { case t: NuTypeDef => S(t); case _ => N } }
-      val typeSymbols = statements.iterator.flatMap(filterNuTypeDef).map(TypeSymbol(_)).toList
+      val typeSymbols = statements.collect { case t: NuTypeDef => TypeSymbol(t) }
       val scopeWithTypes = parentScope.derive ++ typeSymbols
       println(typeSymbols.iterator.map(_.name).mkString("type symbols: {", ", ", "}"))
-      // val scopeWithTypes = statements.iterator.flatMap(filterNuTypeDef).foldLeft(parentScope.derive)(_ + TypeSymbol(_))
-      // Pass 1.1: Resolve subtyping relations. Build a graph and compute base types of each type.
-      // Keep a stable ordering of type symbols when printing the graph.
-      implicit val ord: Ordering[TypeSymbol] = new Ordering[TypeSymbol] {
-        override def compare(x: TypeSymbol, y: TypeSymbol): Int =
-          x.name.compareTo(y.name)
-      }
-      // Collect inheritance relations, represented by a map from a type symbol
-      // to its base types. If a type symbol is not found, we will ignore it
-      // and report the error (but not fatal).
-      val edges = typeSymbols.foldLeft(SortedMap.empty[TypeSymbol, Ls[TypeSymbol]]) { case (acc, self) =>
-        acc + (self -> extractSuperTypes(self.defn.parents).flatMap { nme =>
-          val maybeSymbol = scopeWithTypes.getTypeSymbol(nme.name)
-          if (maybeSymbol.isEmpty) {
-            raiseError(msg"could not find definition `${nme.name}`" -> nme.toLoc)
+      // Pass 1.1: Resolve parent type symbols.
+      typeSymbols.foreach {
+        case s: ClassLikeSymbol => s.parentTypeNames.foreach { nme =>
+          scopeWithTypes.getTypeSymbol(nme.name) match {
+            case S(symbol) => nme.symbol = symbol
+            case N => raiseError(msg"could not find definition `${nme.name}`" -> nme.toLoc)
           }
-          maybeSymbol
-        })
-      }
-      printGraph(edges, println(_), "inheritance relations", "->")
-      transitiveClosure(edges).foreachEntry { (self, bases) =>
-        self.baseTypes = bases
-        println(s"base types of `${self.name}`: ${bases.iterator.map(_.name).mkString(", ")}")
+        }
+        case _ => ()
       }
       // Pass 2: Build a complete scope and collect definitional terms and terms to be traversed.
       val (completeScope, thingsToTraverse) = statements.foldLeft[(Scope, Ls[(Term \/ DefinedTermSymbol, Scope)])](scopeWithTypes, Nil) {
@@ -264,46 +243,4 @@ class PreTyper extends Traceable with Diagnosable with Desugarer {
     trace(s"PreTyper <== $name: ${typingUnit.describe}") {
       traverseStatements(typingUnit.entities, name, scope)
     }({ scope => s"PreTyper ==> ${scope.showLocalSymbols}" })
-
-  def extractSuperTypes(parents: Ls[Term]): Ls[Var] = {
-    @tailrec
-    def rec(acc: Ls[Var], rest: Ls[Term]): Ls[Var] =
-      rest match {
-        case Nil => acc.reverse
-        case (nme: Var) :: tail => rec(nme :: acc, tail)
-        case (TyApp(ty, _)) :: tail => rec(acc, ty :: tail)
-        case (App(term, Tup(_))) :: tail => rec(acc, term :: tail)
-        case head :: tail =>
-          raiseWarning(msg"unknown type in parent types: ${head.showDbg}" -> head.toLoc)
-          rec(acc, tail)
-      }
-    rec(Nil, parents)
-  }
-}
-
-object PreTyper {
-  def transitiveClosure[A](graph: Map[A, List[A]])(implicit ord: Ordering[A]): SortedMap[A, List[A]] = {
-    def dfs(vertex: A, visited: Set[A]): Set[A] = {
-      if (visited.contains(vertex)) visited
-      else graph.getOrElse(vertex, List())
-        .foldLeft(visited + vertex)((acc, v) => dfs(v, acc))
-    }
-    graph.keys.map { vertex =>
-      val closure = dfs(vertex, Set())
-      vertex -> (closure - vertex).toList
-    }.toSortedMap
-  }
-
-  def printGraph(graph: Map[TypeSymbol, List[TypeSymbol]], print: (=> Any) => Unit, title: String, arrow: String): Unit = {
-    print(s"• $title")
-    if (graph.isEmpty)
-      print("  + <Empty>")
-    else
-      graph.foreachEntry { (source, targets) =>
-        print(s"  + ${source.name} $arrow " + {
-          if (targets.isEmpty) s"{}"
-          else targets.iterator.map(_.name).mkString("{ ", ", ", " }")
-        })
-      }
-  }
 }
diff --git a/shared/src/main/scala/mlscript/pretyper/Scope.scala b/shared/src/main/scala/mlscript/pretyper/Scope.scala
index b2a503435d..1baa04a515 100644
--- a/shared/src/main/scala/mlscript/pretyper/Scope.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Scope.scala
@@ -96,8 +96,8 @@ object Scope {
     // def cls(name: Str) = NuTypeDef(Trt, TypeName(name), Nil, N, N, N, Nil, N, N, TypingUnit(Nil))(N, N)
     def als(name: Str) = NuTypeDef(Als, TypeName(name), Nil, N, N, N, Nil, N, N, TypingUnit(Nil))(N, N, Nil)
     val builtinTypes = Ls(
-      new ModuleSymbol(mod("true")),
-      new ModuleSymbol(mod("false")),
+      new ModuleSymbol(mod("true"), Nil),
+      new ModuleSymbol(mod("false"), Nil),
       new TypeAliasSymbol(als("nothing")),
       new DummyClassSymbol(Var("Object")),
       new DummyClassSymbol(Var("Int")),
diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index 35c2feb971..451b89a023 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -2,9 +2,12 @@ package mlscript.pretyper
 
 import collection.mutable.{Buffer, Map => MutMap, Set => MutSet}
 import mlscript.{Loc, NuFunDef, NuTypeDef, Term, Type, TypeName, Var}
+import mlscript.{App, TyApp, Tup}
 import mlscript.{Cls, Trt, Mxn, Als, Mod}
 import mlscript.utils._, shorthands._
 import mlscript.ucs.context.Matchable
+import scala.annotation.tailrec
+import scala.collection.immutable.SortedSet
 
 package object symbol {
   sealed trait Symbol {
@@ -25,24 +28,33 @@ package object symbol {
     
     override def name: Str = defn.name
 
-    var baseTypes: Ls[TypeSymbol] = Nil
-
-    @inline def hasBaseClass(baseClassLikeSymbol: TypeSymbol): Bool =
-      baseTypes.exists(_ === baseClassLikeSymbol)
-
     def showDbg: Str = s"${defn.kind.str} $name"
   }
 
   object TypeSymbol {
     def apply(defn: NuTypeDef): TypeSymbol =
       defn.kind match {
-        case Cls => new ClassSymbol(defn)
+        case Cls => new ClassSymbol(defn, extractSuperTypes(defn.parents))
         case Als => new TypeAliasSymbol(defn)
         case Mxn => new MixinSymbol(defn)
-        case Trt => new TraitSymbol(defn)
-        case Mod => new ModuleSymbol(defn)
+        case Trt => new TraitSymbol(defn, extractSuperTypes(defn.parents))
+        case Mod => new ModuleSymbol(defn, extractSuperTypes(defn.parents))
       }
     def unapply(symbol: TypeSymbol): Opt[NuTypeDef] = S(symbol.defn)
+
+    private def extractSuperTypes(parents: Ls[Term]): Ls[Var] = {
+      @tailrec
+      def rec(acc: Ls[Var], rest: Ls[Term]): Ls[Var] =
+        rest match {
+          case Nil => acc.reverse
+          case (nme: Var) :: tail => rec(nme :: acc, tail)
+          case (TyApp(ty, _)) :: tail => rec(acc, ty :: tail)
+          case (App(term, Tup(_))) :: tail => rec(acc, term :: tail)
+          case head :: _ =>
+            lastWords(s"unknown type in parent types: ${head.showDbg}")
+        }
+      rec(Nil, parents)
+    }
   }
 
   /**
@@ -51,7 +63,9 @@ package object symbol {
     *
     * @param nme the name of the expect type symbol.
     */
-  final class DummyClassSymbol(val nme: Var) extends TypeSymbol {
+  final class DummyClassSymbol(val nme: Var) extends ClassLikeSymbol {
+    override val parentTypeNames: Ls[Var] = Nil
+    
     override def defn: NuTypeDef = die
 
     override def name: Str = nme.name
@@ -59,11 +73,39 @@ package object symbol {
     override def showDbg: Str = s"dummy class $name"
   }
 
-  final class ClassSymbol(override val defn: NuTypeDef) extends TypeSymbol {
+  trait ClassLikeSymbol extends TypeSymbol {
+    val parentTypeNames: Ls[Var]
+
+    private val _baseClassLikeSymbols: Lazy[SortedSet[ClassLikeSymbol]] = new mlscript.utils.Lazy({
+      implicit val ord: Ordering[ClassLikeSymbol] = new Ordering[ClassLikeSymbol] {
+        override def compare(x: ClassLikeSymbol, y: ClassLikeSymbol): Int =
+          x.name.compareTo(y.name)
+      }
+      val parentClassLikeSymbols = parentTypeNames.iterator.map(_.symbol).collect {
+        case s: ClassLikeSymbol => s
+      }.toList
+      SortedSet.from(
+        parentClassLikeSymbols.iterator ++
+        parentClassLikeSymbols.iterator.flatMap(_.baseClassLikeSymbols))
+    })
+
+    lazy val baseClassLikeSymbols: SortedSet[ClassLikeSymbol] = _baseClassLikeSymbols.get_!
+
+    def <:<(that: ClassLikeSymbol): Bool =
+      this === that || baseClassLikeSymbols.contains(that)
+  }
+
+  final class ClassSymbol(
+    override val defn: NuTypeDef,
+    override val parentTypeNames: Ls[Var]
+  ) extends ClassLikeSymbol {
     require(defn.kind === Cls)
   }
 
-  final class TraitSymbol(override val defn: NuTypeDef) extends TypeSymbol {
+  final class TraitSymbol(
+    override val defn: NuTypeDef,
+    override val parentTypeNames: Ls[Var]
+  ) extends ClassLikeSymbol {
     require(defn.kind === Trt)
   }
 
@@ -75,7 +117,10 @@ package object symbol {
     require(defn.kind === Als)
   }
 
-  final class ModuleSymbol(override val defn: NuTypeDef) extends TypeSymbol with TermSymbol {
+  final class ModuleSymbol(
+    override val defn: NuTypeDef,
+    override val parentTypeNames: Ls[Var]
+  ) extends ClassLikeSymbol with TermSymbol {
     require(defn.kind === Mod)
 
     override def nameVar: Var = defn.nameVar
@@ -125,5 +170,9 @@ package object symbol {
           lastWords(s"Symbol already set for $name")
       }
     def withSymbol(symbol: Symbol): this.type = { this.symbol = symbol; this }
+
+    def getClassLikeSymbol: Opt[ClassLikeSymbol] = _symbol.collectFirst {
+      case symbol: ClassLikeSymbol => symbol
+    }
   }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/Desugarer.scala b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
index d5b7719cdf..6b5f14b371 100644
--- a/shared/src/main/scala/mlscript/ucs/Desugarer.scala
+++ b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
@@ -47,8 +47,8 @@ trait Desugarer extends Transformation
       * get or create a dummy class symbol for it. The desugaring can continue
       * and `Typer` will throw an error for this miuse.
       */
-    private def requireClassLikeSymbol(symbol: TypeSymbol)(implicit context: Context): TypeSymbol = symbol match {
-      case symbol @ (_: TraitSymbol | _: ClassSymbol | _: ModuleSymbol | _: DummyClassSymbol) => symbol
+    private def requireClassLikeSymbol(symbol: TypeSymbol)(implicit context: Context): ClassLikeSymbol = symbol match {
+      case symbol: ClassLikeSymbol => symbol
       case symbol: MixinSymbol =>
         raiseDesugaringError(msg"Mixins are not allowed in pattern" -> nme.toLoc)
         context.getOrCreateDummyClassSymbol(nme)
@@ -127,7 +127,7 @@ trait Desugarer extends Transformation
     def withResolvedTermSymbol(implicit scope: Scope): Var = { nme.resolveTermSymbol; nme }
 
     /** Associate the `Var` with a class like symbol and returns the class like symbol. */
-    def resolveClassLikeSymbol(implicit scope: Scope, context: Context): TypeSymbol = {
+    def resolveClassLikeSymbol(implicit scope: Scope, context: Context): ClassLikeSymbol = {
       val symbol = scope.getTypeSymbol(nme.name) match {
         case S(symbol) => requireClassLikeSymbol(symbol)
         case N =>
diff --git a/shared/src/main/scala/mlscript/ucs/context/Pattern.scala b/shared/src/main/scala/mlscript/ucs/context/Pattern.scala
index 8fa96aece8..dce9622c61 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Pattern.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Pattern.scala
@@ -4,8 +4,7 @@ import collection.mutable.{Buffer, SortedMap => MutSortedMap}
 import mlscript.{Lit, Loc, Located, SimpleTerm, TypeName, Var}
 import mlscript.pretyper.symbol.TypeSymbol
 import mlscript.utils._, shorthands._
-import mlscript.pretyper.symbol.DummyClassSymbol
-import mlscript.pretyper.symbol.ModuleSymbol
+import mlscript.pretyper.symbol.{ClassLikeSymbol, DummyClassSymbol, ModuleSymbol}
 
 sealed abstract class Pattern {
   private val locationsBuffer: Buffer[Loc] = Buffer.empty
@@ -40,7 +39,7 @@ sealed abstract class Pattern {
 
 object Pattern {
   final case class ClassLike(
-      val classLikeSymbol: TypeSymbol,
+      val classLikeSymbol: ClassLikeSymbol,
       scrutinee: Scrutinee
   )(override val refined: Bool) extends Pattern {
     private var unappliedVarOpt: Opt[Var] = N
@@ -79,13 +78,10 @@ object Pattern {
       case otherSymbol: TypeSymbol => otherSymbol.defn.kind.str
     })} `${classLikeSymbol.name}`"
 
+    /** Checks whether this pattern can cover the given pattern. */
     override def matches(pat: SimpleTerm): Bool =
       pat match {
-        case pat: Var => pat.symbolOption match {
-          case S(patternSymbol: TypeSymbol) =>
-            patternSymbol === classLikeSymbol || patternSymbol.hasBaseClass(classLikeSymbol)
-          case S(_) | N => false
-        }
+        case pat: Var => pat.getClassLikeSymbol.fold(false)(_ <:< classLikeSymbol)
         case _: Lit => false
       }
 
diff --git a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
index 999c2cd9cd..a34808ce89 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
@@ -2,12 +2,9 @@ package mlscript.ucs.context
 
 import collection.mutable.{Buffer, SortedMap => MutSortedMap, SortedSet => MutSortedSet}
 import mlscript.{Lit, Loc, Var}
-import mlscript.pretyper.symbol.TypeSymbol
+import mlscript.pretyper.symbol.{ClassLikeSymbol, TypeSymbol}
 import mlscript.utils._, shorthands._
-import mlscript.DecLit
-import mlscript.IntLit
-import mlscript.StrLit
-import mlscript.UnitLit
+import mlscript.{DecLit, IntLit, StrLit, UnitLit}
 
 class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
   import Scrutinee._
@@ -36,7 +33,7 @@ class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
     * If there is already a `Pattern.ClassLike` for the given symbol, return it.
     * Otherwise, create a new `Pattern.ClassLike` and return it.
     */
-  def getOrCreateClassPattern(classLikeSymbol: TypeSymbol, refined: Bool): Pattern.ClassLike =
+  def getOrCreateClassPattern(classLikeSymbol: ClassLikeSymbol, refined: Bool): Pattern.ClassLike =
     classLikePatterns.getOrElseUpdate(classLikeSymbol, Pattern.ClassLike(classLikeSymbol, this)(refined))
 
   /**
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index ed8f9f8c11..e570aa5aa1 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -79,7 +79,7 @@ trait CoverageChecking { self: Desugarer with Traceable =>
                 diagnostics ++ checkCoverage(body, newPending, working - namedScrutinee, seen)
               )
             case ((unseenPatterns, diagnostics), (className: Var) -> body) =>
-              val classSymbol = className.symbolOption.flatMap(_.typeSymbolOption).getOrElse {
+              val classSymbol = className.getClassLikeSymbol.getOrElse {
                 throw new Exception(s"$className is not associated with a type symbol")
               }
               println(s"class symbol: `${classSymbol.name}`")
@@ -190,7 +190,7 @@ object CoverageChecking {
     }
 
     /** Separate a class-like pattern if it appears in `patterns`. */
-    def separate(classLikeSymbol: TypeSymbol): Opt[(Pattern.ClassLike, Ls[Pattern.ClassLike])] = {
+    def separate(classLikeSymbol: ClassLikeSymbol): Opt[(Pattern.ClassLike, Ls[Pattern.ClassLike])] = {
       classLikePatterns.foldRight[(Opt[Pattern.ClassLike], Ls[Pattern.ClassLike])]((N, Nil)) {
         case (pattern, (S(separated), rest)) => (S(separated), pattern :: rest)
         case (pattern, (N, rest)) if pattern.classLikeSymbol === classLikeSymbol => (S(pattern), rest)
@@ -220,7 +220,7 @@ object CoverageChecking {
       *         locations where the pattern appears, the related patterns, and
       *         unrelated patterns.
       */
-    def split(classLikeSymbol: TypeSymbol): Opt[(Pattern.ClassLike, CaseSet, CaseSet)] = {
+    def split(classLikeSymbol: ClassLikeSymbol): Opt[(Pattern.ClassLike, CaseSet, CaseSet)] = {
       def mk(pattern: Pattern): Opt[Lit \/ TypeSymbol] = pattern match {
         case Pattern.ClassLike(classLikeSymbol, _) => S(R(classLikeSymbol))
         case Pattern.Literal(literal) => S(L(literal))
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 7301ce60e6..0d651bf898 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -135,7 +135,7 @@ trait Desugaring { self: PreTyper =>
   private def flattenClassParameters(
       parentScrutineeVar: Var,
       parentScrutinee: Scrutinee,
-      parentClassLikeSymbol: TypeSymbol,
+      parentClassLikeSymbol: ClassLikeSymbol,
       parentRefined: Bool,
       parameters: Ls[s.Pattern],
   )(implicit context: Context): Ls[Opt[(Var, Opt[s.Pattern], Ls[Var])]] = {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/package.scala b/shared/src/main/scala/mlscript/ucs/stages/package.scala
index fe25dd0082..3d232a8705 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/package.scala
@@ -3,6 +3,7 @@ package mlscript.ucs
 import mlscript.{App, DecLit, Fld, FldFlags, IntLit, Lit, PlainTup, StrLit, Term, Tup, Var}
 import mlscript.pretyper.symbol.TypeSymbol
 import mlscript.utils._, shorthands._
+import mlscript.pretyper.symbol.ClassLikeSymbol
 
 package object stages {
   /**
@@ -53,7 +54,7 @@ package object stages {
     case (_, R(s)) if s.name === "Object" => true
     case (R(s1), R(s2)) if (s1.name === "true" || s1.name === "false") && s2.name === "Bool" => true
     case (R(s1), R(s2)) if s1.name === "Int" && s2.name === "Num" => true
-    case (R(s1), R(s2)) => s1 hasBaseClass s2
+    case (R(s1: ClassLikeSymbol), R(s2: ClassLikeSymbol)) => s1 <:< s2
     case (L(IntLit(_)), R(s)) if s.name === "Int" || s.name === "Num" => true
     case (L(StrLit(_)), R(s)) if s.name === "Str" => true
     case (L(DecLit(_)), R(s)) if s.name === "Num" => true
diff --git a/shared/src/main/scala/mlscript/utils/Lazy.scala b/shared/src/main/scala/mlscript/utils/Lazy.scala
new file mode 100644
index 0000000000..5f333039c1
--- /dev/null
+++ b/shared/src/main/scala/mlscript/utils/Lazy.scala
@@ -0,0 +1,36 @@
+package mlscript.utils
+
+import shorthands._
+
+abstract class Box[+A] {
+  def get: Opt[A]
+  def get_! : A
+  def isComputing: Bool
+}
+
+class Eager[+A](val value: A) extends Box[A] {
+  def isComputing = false
+  lazy val get = S(value)
+  def get_! = value
+}
+
+class Lazy[A](thunk: => A) extends Box[A] {
+  def isComputing = _isComputing
+  private var _isComputing = false
+  private var _value: Opt[A] = N
+  def get = if (_isComputing) N else S(get_!)
+  def get_! = {
+    assert(!_isComputing)
+    _compute
+  }
+  private def _compute = {
+    _isComputing = true
+    try {
+      val v = thunk
+      _value = S(v)
+      v
+    } finally {
+      _isComputing = false
+    }
+  }
+}
diff --git a/shared/src/test/diff/pretyper/Errors.mls b/shared/src/test/diff/pretyper/Errors.mls
index c3f4ff3351..810df17d95 100644
--- a/shared/src/test/diff/pretyper/Errors.mls
+++ b/shared/src/test/diff/pretyper/Errors.mls
@@ -497,9 +497,6 @@ class Derived0(n: Int) extends Base
 
 // ParamOverride
 mixin DerivedBad(n: Int) extends Base
-//│ ╔══[ERROR] could not find definition `Base`
-//│ ║  l.499: 	mixin DerivedBad(n: Int) extends Base
-//│ ╙──       	                                 ^^^^
 //│ ╔══[ERROR] mixin definitions cannot yet extend parents
 //│ ║  l.499: 	mixin DerivedBad(n: Int) extends Base
 //│ ╙──       	                                 ^^^^
@@ -512,65 +509,65 @@ fun foo(x, y) = x + y
 // PartialApp
 foo(2, _)
 //│ ╔══[ERROR] identifier `_` not found
-//│ ║  l.513: 	foo(2, _)
+//│ ║  l.510: 	foo(2, _)
 //│ ╙──       	       ^
 //│ ╔══[ERROR] Widlcard in expression position.
-//│ ║  l.513: 	foo(2, _)
+//│ ║  l.510: 	foo(2, _)
 //│ ╙──       	       ^
 //│ Int
 
 // PartialApp
 _.foo(1)
 //│ ╔══[ERROR] identifier `_` not found
-//│ ║  l.523: 	_.foo(1)
+//│ ║  l.520: 	_.foo(1)
 //│ ╙──       	^
 //│ ╔══[ERROR] Widlcard in expression position.
-//│ ║  l.523: 	_.foo(1)
+//│ ║  l.520: 	_.foo(1)
 //│ ╙──       	^
 //│ error
 
 // PartialApp
 _ + _
 //│ ╔══[ERROR] identifier `_` not found
-//│ ║  l.533: 	_ + _
+//│ ║  l.530: 	_ + _
 //│ ╙──       	^
 //│ ╔══[ERROR] identifier `_` not found
-//│ ║  l.533: 	_ + _
+//│ ║  l.530: 	_ + _
 //│ ╙──       	    ^
 //│ ╔══[ERROR] Widlcard in expression position.
-//│ ║  l.533: 	_ + _
+//│ ║  l.530: 	_ + _
 //│ ╙──       	^
 //│ ╔══[ERROR] Widlcard in expression position.
-//│ ║  l.533: 	_ + _
+//│ ║  l.530: 	_ + _
 //│ ╙──       	    ^
 //│ Int
 
 // PartialApp
 _2 + _1
 //│ ╔══[ERROR] identifier `_2` not found
-//│ ║  l.549: 	_2 + _1
+//│ ║  l.546: 	_2 + _1
 //│ ╙──       	^^
 //│ ╔══[ERROR] identifier `_1` not found
-//│ ║  l.549: 	_2 + _1
+//│ ║  l.546: 	_2 + _1
 //│ ╙──       	     ^^
 //│ ╔══[ERROR] identifier not found: _2
-//│ ║  l.549: 	_2 + _1
+//│ ║  l.546: 	_2 + _1
 //│ ╙──       	^^
 //│ ╔══[ERROR] identifier not found: _1
-//│ ║  l.549: 	_2 + _1
+//│ ║  l.546: 	_2 + _1
 //│ ╙──       	     ^^
 //│ Int
 
 // RefinedPatterns
 refined
 //│ ╔══[ERROR] identifier `refined` not found
-//│ ║  l.565: 	refined
+//│ ║  l.562: 	refined
 //│ ╙──       	^^^^^^^
 //│ ╔══[ERROR] Illegal use of reserved operator: refined
-//│ ║  l.565: 	refined
+//│ ║  l.562: 	refined
 //│ ╙──       	^^^^^^^
 //│ ╔══[ERROR] identifier not found: refined
-//│ ║  l.565: 	refined
+//│ ║  l.562: 	refined
 //│ ╙──       	^^^^^^^
 //│ error
 
@@ -583,13 +580,13 @@ class D() { fun f = 0 }
 // Refinements
 let d = D & { f: 0 }
 //│ ╔══[ERROR] identifier `&` not found
-//│ ║  l.584: 	let d = D & { f: 0 }
+//│ ║  l.581: 	let d = D & { f: 0 }
 //│ ╙──       	          ^
 //│ ╔══[ERROR] Illegal use of reserved operator: &
-//│ ║  l.584: 	let d = D & { f: 0 }
+//│ ║  l.581: 	let d = D & { f: 0 }
 //│ ╙──       	          ^
 //│ ╔══[ERROR] identifier not found: &
-//│ ║  l.584: 	let d = D & { f: 0 }
+//│ ║  l.581: 	let d = D & { f: 0 }
 //│ ╙──       	          ^
 //│ let d: error
 
@@ -600,63 +597,63 @@ x => x + 2
 // Res
 res(1)
 //│ ╔══[ERROR] identifier `res` not found
-//│ ║  l.601: 	res(1)
+//│ ║  l.598: 	res(1)
 //│ ╙──       	^^^
 //│ ╔══[ERROR] identifier not found: res
-//│ ║  l.601: 	res(1)
+//│ ║  l.598: 	res(1)
 //│ ╙──       	^^^
 //│ error
 
 // Uninstantiable
 Int
 //│ ╔══[ERROR] identifier `Int` is resolved to a type
-//│ ║  l.611: 	Int
+//│ ║  l.608: 	Int
 //│ ╙──       	^^^
 //│ ╔══[ERROR] Class Int is abstract and cannot be instantiated
-//│ ║  l.611: 	Int
+//│ ║  l.608: 	Int
 //│ ╙──       	^^^
 //│ ╔══[ERROR] Class Int cannot be instantiated as it exposes no constructor
-//│ ║  l.611: 	Int
+//│ ║  l.608: 	Int
 //│ ╙──       	^^^
 //│ error
 
 // Uninstantiable
 Int()
 //│ ╔══[ERROR] identifier `Int` is resolved to a type
-//│ ║  l.624: 	Int()
+//│ ║  l.621: 	Int()
 //│ ╙──       	^^^
 //│ ╔══[ERROR] Class Int is abstract and cannot be instantiated
-//│ ║  l.624: 	Int()
+//│ ║  l.621: 	Int()
 //│ ╙──       	^^^
 //│ ╔══[ERROR] Class Int cannot be instantiated as it exposes no constructor
-//│ ║  l.624: 	Int()
+//│ ║  l.621: 	Int()
 //│ ╙──       	^^^
 //│ error
 
 // Uninstantiable
 new Int
 //│ ╔══[ERROR] identifier `Int` is resolved to a type
-//│ ║  l.637: 	new Int
+//│ ║  l.634: 	new Int
 //│ ╙──       	    ^^^
 //│ ╔══[ERROR] Class Int is abstract and cannot be instantiated
-//│ ║  l.637: 	new Int
+//│ ║  l.634: 	new Int
 //│ ╙──       	    ^^^
 //│ Int
 
 // Unit
 (1, 2) => 3
 //│ ╔══[WARNING] literal patterns are ignored
-//│ ║  l.647: 	(1, 2) => 3
+//│ ║  l.644: 	(1, 2) => 3
 //│ ╙──       	 ^
 //│ ╔══[WARNING] literal patterns are ignored
-//│ ║  l.647: 	(1, 2) => 3
+//│ ║  l.644: 	(1, 2) => 3
 //│ ╙──       	    ^
 //│ (1, 2) -> 3
 
 // Unit
 1 => (2, 3)
 //│ ╔══[WARNING] literal patterns are ignored
-//│ ║  l.657: 	1 => (2, 3)
+//│ ║  l.654: 	1 => (2, 3)
 //│ ╙──       	^
 //│ 1 -> 3
 
@@ -669,23 +666,23 @@ val d = 1
 // Varargs
 fun test(...xs) = xs.length
 //│ ╔══[PARSE ERROR] Unexpected operator here
-//│ ║  l.670: 	fun test(...xs) = xs.length
+//│ ║  l.667: 	fun test(...xs) = xs.length
 //│ ╙──       	         ^^^
 //│ ╔══[ERROR] identifier `xs` not found
-//│ ║  l.670: 	fun test(...xs) = xs.length
+//│ ║  l.667: 	fun test(...xs) = xs.length
 //│ ╙──       	                  ^^
 //│ ╔══[ERROR] identifier not found: xs
-//│ ║  l.670: 	fun test(...xs) = xs.length
+//│ ║  l.667: 	fun test(...xs) = xs.length
 //│ ╙──       	                  ^^
 //│ fun test: () -> error
 
 // WeirdDefs
 fun fst[x, _] = x
 //│ ╔══[ERROR] identifier `x` not found
-//│ ║  l.683: 	fun fst[x, _] = x
+//│ ║  l.680: 	fun fst[x, _] = x
 //│ ╙──       	                ^
 //│ ╔══[ERROR] identifier not found: x
-//│ ║  l.683: 	fun fst[x, _] = x
+//│ ║  l.680: 	fun fst[x, _] = x
 //│ ╙──       	                ^
 //│ fun fst: error
 
@@ -698,7 +695,7 @@ module EvalAddLit {
 }
 let res = EvalAddLit.eval(add11)
 //│ ╔══[ERROR] identifier `add11` not found
-//│ ║  l.694: 	val add11 = Add(add11)
+//│ ║  l.691: 	val add11 = Add(add11)
 //│ ╙──       	                ^^^^^
 //│ class Add[E](lhs: E)
 //│ val add11: 'E
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index 746cdee4a4..709b7eeacb 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -1170,6 +1170,7 @@ object DiffTests {
     private val pattern = "^ducs(?::(\\s*(?:[A-Za-z\\.-]+)(?:,\\s*[A-Za-z\\.-]+)*))?$".r
     def unapply(flagsString: Str): Opt[Set[Str]] =
       flagsString match {
+        case "ducs" => S(Set.empty)
         case pattern(flags) => Option(flags).map(_.split(",\\s*").toSet)
         case _ => N
       }

From 3a1a8839e3c478327d30a64f583d50f34c7ac424 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Mon, 29 Apr 2024 03:27:29 +0800
Subject: [PATCH 121/147] Report desugaring errors if syntax tree nodes are
 reused

---
 .../test/diff/Defunctionalize/OldMonoList.mls | 28 +++++++++++--------
 .../main/scala/mlscript/ucs/Desugarer.scala   |  9 ++++++
 2 files changed, 26 insertions(+), 11 deletions(-)

diff --git a/compiler/shared/test/diff/Defunctionalize/OldMonoList.mls b/compiler/shared/test/diff/Defunctionalize/OldMonoList.mls
index 856ea86ac4..0f87a8577a 100644
--- a/compiler/shared/test/diff/Defunctionalize/OldMonoList.mls
+++ b/compiler/shared/test/diff/Defunctionalize/OldMonoList.mls
@@ -42,17 +42,23 @@ fun add2(x) = x+2
 //│   fun apply$Lambda1$2$3 = (this, x,) => +(x, 1,)
 //│   Code(List(main$$5()))
 //│ }
-//│ /!!!\ Uncaught error: java.lang.Exception: Internal Error: Symbol already set for obj
-//│ 	at: mlscript.utils.package$.lastWords(package.scala:227)
-//│ 	at: mlscript.VarImpl.symbol_$eq(helpers.scala:870)
-//│ 	at: mlscript.VarImpl.symbol_$eq$(helpers.scala:864)
-//│ 	at: mlscript.Var.symbol_$eq(syntax.scala:67)
-//│ 	at: mlscript.ucs.Desugarer$VarOps.resolveTermSymbol(Desugarer.scala:124)
-//│ 	at: mlscript.ucs.Desugarer$VarOps.withResolvedTermSymbol(Desugarer.scala:129)
-//│ 	at: mlscript.ucs.stages.Desugaring.desugarPatternSplit(Desugaring.scala:432)
-//│ 	at: mlscript.ucs.stages.Desugaring.$anonfun$desugarTermBranch$2(Desugaring.scala:101)
-//│ 	at: mlscript.pretyper.Traceable.trace(Traceable.scala:39)
-//│ 	at: mlscript.pretyper.Traceable.trace$(Traceable.scala:36)
+//│ ╔══[ERROR] the `if` expression has already been desugared
+//│ ║  l.7: 	  fun map(f)= new List(f(e), tail.map(f))
+//│ ║       	                         ^
+//│ ╙── please make sure that the objects are copied
+//│ class Lambda1$3$4()
+//│ class Nil$2()
+//│ class List$1(e: Int, tail: List$1 | Nil$2)
+//│ class Lambda1$2$3()
+//│ fun map$List$1: (Object, Object) -> List$1
+//│ fun add2$1: Int -> Int
+//│ fun main$$5: () -> List$1
+//│ fun apply$Lambda1$3$4: (anything, Int) -> Int
+//│ fun map$Nil$2: forall 'a. ('a & (List$1 | Nil$2), anything) -> (Nil$2 | 'a)
+//│ fun apply$Lambda1$2$3: (anything, Int) -> Int
+//│ List$1
+//│ res
+//│     = List$1 {}
 
 :mono
 class List(e: Int, tail: List | Nil) {
diff --git a/shared/src/main/scala/mlscript/ucs/Desugarer.scala b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
index 6b5f14b371..cc42ad36d0 100644
--- a/shared/src/main/scala/mlscript/ucs/Desugarer.scala
+++ b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
@@ -196,6 +196,15 @@ trait Desugarer extends Transformation
     * @param scope the scope of the `If` node
     */
   protected def traverseIf(`if`: If)(implicit scope: Scope): Unit = {
+    `if`.desugaredTerm match {
+      case S(desugaredTerm) =>
+        raiseDesugaringError(
+          msg"the `if` expression has already been desugared" -> `if`.getLoc,
+          msg"please make sure that the objects are copied" -> N,
+        )
+        return
+      case N => ()
+    }
     implicit val context: Context = new Context(`if`)
     trace("traverseIf") {
       // Stage 0: Transformation

From 21ee9739182f94d4f857a501d7749aaa14be5cbb Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Mon, 29 Apr 2024 03:44:24 +0800
Subject: [PATCH 122/147] Rewrite package declarations to simplify import
 statements

---
 .../scala/mlscript/pretyper/Diagnosable.scala  |  5 +++--
 .../scala/mlscript/pretyper/PreTyper.scala     |  5 +++--
 .../main/scala/mlscript/pretyper/Scope.scala   | 10 ++++------
 .../main/scala/mlscript/pretyper/Symbol.scala  | 15 +++++----------
 .../scala/mlscript/pretyper/Traceable.scala    |  6 +++---
 .../main/scala/mlscript/ucs/Desugarer.scala    | 18 +++++++++---------
 .../scala/mlscript/ucs/context/Context.scala   | 15 +++++++--------
 .../scala/mlscript/ucs/context/Pattern.scala   |  9 ++++-----
 .../scala/mlscript/ucs/context/Scrutinee.scala | 12 +++---------
 .../src/main/scala/mlscript/ucs/display.scala  | 14 ++++++--------
 .../mlscript/ucs/stages/CoverageChecking.scala | 17 +++++++----------
 .../scala/mlscript/ucs/stages/Desugaring.scala | 15 +++++++--------
 .../mlscript/ucs/stages/Normalization.scala    | 17 +++++++----------
 .../mlscript/ucs/stages/PartialTerm.scala      |  5 +++--
 .../mlscript/ucs/stages/PostProcessing.scala   | 16 +++++++---------
 .../mlscript/ucs/stages/Transformation.scala   | 12 +++++-------
 .../scala/mlscript/ucs/stages/package.scala    |  9 ++++-----
 17 files changed, 87 insertions(+), 113 deletions(-)

diff --git a/shared/src/main/scala/mlscript/pretyper/Diagnosable.scala b/shared/src/main/scala/mlscript/pretyper/Diagnosable.scala
index 36cc640635..8757c6629f 100644
--- a/shared/src/main/scala/mlscript/pretyper/Diagnosable.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Diagnosable.scala
@@ -1,7 +1,8 @@
-package mlscript.pretyper
+package mlscript
+package pretyper
 
 import scala.collection.mutable.Buffer
-import mlscript.{Diagnostic, ErrorReport, Loc, Message, WarningReport}, Diagnostic.Source, Message.MessageContext
+import Diagnostic.Source, Message.MessageContext
 import mlscript.utils._, shorthands._
 
 /**
diff --git a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
index f46752d1c6..da58f2827e 100644
--- a/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
+++ b/shared/src/main/scala/mlscript/pretyper/PreTyper.scala
@@ -1,7 +1,8 @@
-package mlscript.pretyper
+package mlscript
+package pretyper
 
 import annotation.tailrec, collection.mutable.{Set => MutSet}, collection.immutable.SortedMap, util.chaining._
-import mlscript._, utils._, shorthands._, Diagnostic.PreTyping, Message.MessageContext, symbol._, ucs.Desugarer
+import utils._, shorthands._, Diagnostic.PreTyping, Message.MessageContext, symbol._, ucs.Desugarer
 
 class PreTyper extends Traceable with Diagnosable with Desugarer {
   /** A shorthand function to raise errors without specifying the source. */
diff --git a/shared/src/main/scala/mlscript/pretyper/Scope.scala b/shared/src/main/scala/mlscript/pretyper/Scope.scala
index 1baa04a515..678e4a6dae 100644
--- a/shared/src/main/scala/mlscript/pretyper/Scope.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Scope.scala
@@ -1,10 +1,8 @@
-package mlscript.pretyper
+package mlscript
+package pretyper
 
-import collection.immutable.Map
-import mlscript.utils._, shorthands._
-import mlscript.{Als, Mod, NuTypeDef, TypeName, TypingUnit, Var}
-import scala.annotation.tailrec
-import symbol._
+import annotation.tailrec, collection.immutable.Map
+import utils._, shorthands._, symbol._
 
 final class Scope(val enclosing: Opt[Scope], val types: Map[Str, TypeSymbol], val terms: Map[Str, TermSymbol]) {
   import Scope._
diff --git a/shared/src/main/scala/mlscript/pretyper/Symbol.scala b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
index 451b89a023..aead66b90a 100644
--- a/shared/src/main/scala/mlscript/pretyper/Symbol.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Symbol.scala
@@ -1,13 +1,8 @@
-package mlscript.pretyper
-
-import collection.mutable.{Buffer, Map => MutMap, Set => MutSet}
-import mlscript.{Loc, NuFunDef, NuTypeDef, Term, Type, TypeName, Var}
-import mlscript.{App, TyApp, Tup}
-import mlscript.{Cls, Trt, Mxn, Als, Mod}
-import mlscript.utils._, shorthands._
-import mlscript.ucs.context.Matchable
-import scala.annotation.tailrec
-import scala.collection.immutable.SortedSet
+package mlscript
+package pretyper
+
+import annotation.tailrec, collection.immutable.SortedSet
+import utils._, shorthands._, ucs.context.Matchable
 
 package object symbol {
   sealed trait Symbol {
diff --git a/shared/src/main/scala/mlscript/pretyper/Traceable.scala b/shared/src/main/scala/mlscript/pretyper/Traceable.scala
index df7aee9d7a..49f6827f34 100644
--- a/shared/src/main/scala/mlscript/pretyper/Traceable.scala
+++ b/shared/src/main/scala/mlscript/pretyper/Traceable.scala
@@ -1,7 +1,7 @@
-package mlscript.pretyper
+package mlscript
+package pretyper
 
-import mlscript.Diagnostic
-import mlscript.utils._, shorthands._
+import utils._, shorthands._
 
 trait Traceable {
   /**
diff --git a/shared/src/main/scala/mlscript/ucs/Desugarer.scala b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
index cc42ad36d0..461df9ae0f 100644
--- a/shared/src/main/scala/mlscript/ucs/Desugarer.scala
+++ b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
@@ -1,13 +1,13 @@
-package mlscript.ucs
+package mlscript
+package ucs
 
 import collection.mutable.{Map => MutMap}
 import syntax.{source => s, core => c}, stages._, context.{Context, Scrutinee}
 import mlscript.ucs.display.{showNormalizedTerm, showSplit}
 import mlscript.pretyper.{PreTyper, Scope}
 import mlscript.pretyper.symbol._
-import mlscript.{If, Loc, Located, Message, Var}, Message.MessageContext, mlscript.Diagnostic
-import mlscript.utils._, shorthands._
-import syntax.core.{Branch, Split}
+import Message.MessageContext
+import utils._, shorthands._
 
 /**
   * The main class of the UCS desugaring.
@@ -266,18 +266,18 @@ trait Desugarer extends Transformation
     * Traverse a desugared _core abstract syntax_ tree. The function takes care
     * of let bindings and resolves variables.
     */
-  private def traverseSplit(split: syntax.core.Split)(implicit scope: Scope): Unit =
+  private def traverseSplit(split: c.Split)(implicit scope: Scope): Unit =
     split match {
-      case Split.Cons(Branch(scrutinee, pattern, continuation), tail) => 
+      case c.Split.Cons(c.Branch(scrutinee, pattern, continuation), tail) => 
         traverseTerm(scrutinee)
         val patternSymbols = pattern.declaredVars.map(nme => nme -> nme.symbol)
         traverseSplit(continuation)(scope.withEntries(patternSymbols))
         traverseSplit(tail)
-      case Split.Let(isRec, name, rhs, tail) =>
+      case c.Split.Let(isRec, name, rhs, tail) =>
         val recScope = scope + name.symbol
         traverseTerm(rhs)(if (isRec) recScope else scope)
         traverseSplit(tail)(recScope)
-      case Split.Else(default) => traverseTerm(default)
-      case Split.Nil => ()
+      case c.Split.Else(default) => traverseTerm(default)
+      case c.Split.Nil => ()
     }
 }
diff --git a/shared/src/main/scala/mlscript/ucs/context/Context.scala b/shared/src/main/scala/mlscript/ucs/context/Context.scala
index c3f21d3754..65fa9a58e1 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Context.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Context.scala
@@ -1,12 +1,11 @@
-package mlscript.ucs.context
+package mlscript
+package ucs
+package context
 
-import collection.mutable.{Buffer, Map => MutMap, SortedMap => MutSortedMap}
-import mlscript.{If, Loc, Var}
-import mlscript.pretyper.symbol.TypeSymbol
-import mlscript.pretyper.Scope
-import mlscript.ucs.VariableGenerator
-import mlscript.utils._, shorthands._
-import mlscript.pretyper.symbol.DummyClassSymbol
+import collection.mutable.{Buffer, Map => MutMap}
+import utils._, shorthands._
+import pretyper.symbol.{DummyClassSymbol, TypeSymbol}
+import pretyper.Scope
 
 class Context(originalTerm: If) {
   /** The prefix of all prefixes. */
diff --git a/shared/src/main/scala/mlscript/ucs/context/Pattern.scala b/shared/src/main/scala/mlscript/ucs/context/Pattern.scala
index dce9622c61..d5a7e65d96 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Pattern.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Pattern.scala
@@ -1,10 +1,9 @@
-package mlscript.ucs.context
+package mlscript
+package ucs.context
 
 import collection.mutable.{Buffer, SortedMap => MutSortedMap}
-import mlscript.{Lit, Loc, Located, SimpleTerm, TypeName, Var}
-import mlscript.pretyper.symbol.TypeSymbol
-import mlscript.utils._, shorthands._
-import mlscript.pretyper.symbol.{ClassLikeSymbol, DummyClassSymbol, ModuleSymbol}
+import utils._, shorthands._
+import pretyper.symbol.{ClassLikeSymbol, DummyClassSymbol, ModuleSymbol, TypeSymbol}
 
 sealed abstract class Pattern {
   private val locationsBuffer: Buffer[Loc] = Buffer.empty
diff --git a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
index a34808ce89..b8777655f3 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
@@ -1,10 +1,8 @@
-package mlscript.ucs.context
+package mlscript
+package ucs.context
 
 import collection.mutable.{Buffer, SortedMap => MutSortedMap, SortedSet => MutSortedSet}
-import mlscript.{Lit, Loc, Var}
-import mlscript.pretyper.symbol.{ClassLikeSymbol, TypeSymbol}
-import mlscript.utils._, shorthands._
-import mlscript.{DecLit, IntLit, StrLit, UnitLit}
+import pretyper.symbol.{ClassLikeSymbol, TermSymbol, TypeSymbol}, utils._, shorthands._
 
 class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
   import Scrutinee._
@@ -105,10 +103,6 @@ class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
 object Scrutinee {
   // We might need to move these method to a private `VarOps` because they may
   // emit diagnostics.
-
-  import mlscript.Term
-  import mlscript.pretyper.symbol.TermSymbol
-
   def unapply(term: Term)(implicit context: Context): Opt[Scrutinee] = term match {
     case v: Var => v.symbol match {
       case symbol: TermSymbol => symbol.getScrutinee
diff --git a/shared/src/main/scala/mlscript/ucs/display.scala b/shared/src/main/scala/mlscript/ucs/display.scala
index dd34398454..f6ff2952d0 100644
--- a/shared/src/main/scala/mlscript/ucs/display.scala
+++ b/shared/src/main/scala/mlscript/ucs/display.scala
@@ -1,12 +1,10 @@
-package mlscript.ucs
+package mlscript
+package ucs
 
-import mlscript.ucs.syntax.{core => c, source => s}
-import mlscript.ucs.context.{Context}
-import mlscript.pretyper.symbol.{TermSymbol, TypeSymbol}
-import mlscript.{App, CaseOf, Fld, FldFlags, Let, Loc, Sel, SimpleTerm, Term, Tup, Var}
-import mlscript.{CaseBranches, Case, Wildcard, NoCases}
-import mlscript.utils._, shorthands._
-import syntax.core.{Branch, Split}
+import syntax.{core => c, source => s}
+import context.{Context}
+import pretyper.symbol.{TermSymbol, TypeSymbol}
+import utils._, shorthands._
 
 /** All the pretty-printing stuff go here. */
 package object display {
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index e570aa5aa1..8f3d3e8389 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -1,13 +1,10 @@
-package mlscript.ucs.stages
-
-import mlscript.{Case, CaseBranches, CaseOf, Let, Lit, Loc, NoCases, Term, Var, Wildcard}
-import mlscript.{Diagnostic, ErrorReport, WarningReport}
-import mlscript.Message, Message.MessageContext
-import mlscript.ucs.Desugarer
-import mlscript.ucs.context.{Context, Pattern, Scrutinee}
-import mlscript.pretyper.Traceable
-import mlscript.pretyper.symbol._
-import mlscript.utils._, shorthands._
+package mlscript
+package ucs
+package stages
+
+import utils._, shorthands._, Message.MessageContext
+import ucs.context.{Context, Pattern, Scrutinee}
+import pretyper.Traceable, pretyper.symbol._
 
 trait CoverageChecking { self: Desugarer with Traceable =>
   import CoverageChecking._
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
index 0d651bf898..fe452ed99e 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Desugaring.scala
@@ -1,12 +1,11 @@
-package mlscript.ucs.stages
+package mlscript
+package ucs
+package stages
 
-import mlscript.{App, Asc, Fld, FldFlags, Lit, Sel, PlainTup, Term, Tup, TypeName, Var}
-import mlscript.ucs.syntax.{core => c, source => s}
-import mlscript.ucs.context.{Context, Scrutinee}
-import mlscript.utils._, shorthands._
-import mlscript.pretyper.symbol._
-import mlscript.pretyper.{PreTyper, Scope}
-import mlscript.Message, Message.MessageContext
+import syntax.{core => c, source => s}
+import context.{Context, Scrutinee}
+import utils._, shorthands._, Message.MessageContext
+import pretyper.symbol._, pretyper.{PreTyper, Scope}
 
 /**
   * The desugaring stage of UCS. In this stage, we transform the source abstract
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index efb77b7fa4..92ba151231 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -1,14 +1,11 @@
-package mlscript.ucs.stages
+package mlscript
+package ucs
+package stages
 
-import mlscript.{App, CaseOf, DecLit, Fld, FldFlags, IntLit, Let, Lit, Loc, Sel, Term, Tup, Var, StrLit}
-import mlscript.{CaseBranches, Case, Wildcard, NoCases}
-import mlscript.Message, Message.MessageContext
-import mlscript.utils._, shorthands._
-import mlscript.ucs, mlscript.pretyper
-import ucs.{Desugarer, Lines, LinesOps, VariableGenerator}
-import ucs.context.{Context, Scrutinee}
-import ucs.display.{showNormalizedTerm, showSplit}
-import ucs.syntax.core.{Pattern, Branch, Split}
+import mlscript.utils._, shorthands._, Message.MessageContext
+import context.{Context, Scrutinee}
+import display.{showNormalizedTerm, showSplit}
+import syntax.core.{Pattern, Branch, Split}
 import pretyper.symbol._
 import pretyper.{Diagnosable, Scope, Traceable}
 
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PartialTerm.scala b/shared/src/main/scala/mlscript/ucs/stages/PartialTerm.scala
index dc13f689f0..04be763f35 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PartialTerm.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PartialTerm.scala
@@ -1,6 +1,7 @@
-package mlscript.ucs.stages
+package mlscript
+package ucs.stages
 
-import mlscript.{App, PlainTup, Term, Var}, mlscript.utils._, shorthands._
+import utils._, shorthands._
 
 /**
   * A `PartialTerm` represents a possibly incomplete term.
diff --git a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
index 6a5e3c25f4..232726b3c0 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/PostProcessing.scala
@@ -1,13 +1,11 @@
-package mlscript.ucs.stages
+package mlscript
+package ucs
+package stages
 
-import mlscript.{Case, CaseBranches, CaseOf, Let, Lit, Loc, NoCases, Term, Var, Wildcard}
-import mlscript.ucs.Desugarer
-import mlscript.ucs.context.{Context, Pattern, Scrutinee}
-import mlscript.pretyper.symbol._
-import mlscript.utils._, shorthands._
-import mlscript.Message, Message.MessageContext
-import scala.annotation.tailrec
-import mlscript.ucs.context.Pattern.ClassLike
+import annotation.tailrec
+import context.{Context, Pattern, Scrutinee}
+import pretyper.symbol._
+import utils._, shorthands._, Message.MessageContext
 
 trait PostProcessing { self: Desugarer with mlscript.pretyper.Traceable =>
   import PostProcessing._
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
index d5d3a967e1..be070bc0c8 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Transformation.scala
@@ -1,12 +1,10 @@
-package mlscript.ucs.stages
+package mlscript
+package ucs
+package stages
 
-import mlscript.ucs, ucs.Desugarer, ucs.syntax.source._
-import mlscript.{If, IfBody, IfBlock, IfElse, IfLet, IfOpApp, IfOpsApp, IfThen}
-import mlscript.{Blk, Bra, Term, Var, App, Tup, Lit, Fld, Loc, NuFunDef, TyApp, PlainTup}
-import mlscript.pretyper.Traceable
-import mlscript.Message, Message._
-import mlscript.utils._, shorthands._
 import collection.immutable, annotation.tailrec, util.chaining._
+import utils._, shorthands._, Message._
+import syntax.source._, pretyper.Traceable
 
 /**
   * Transform the parsed AST into an AST similar to the one in the paper.
diff --git a/shared/src/main/scala/mlscript/ucs/stages/package.scala b/shared/src/main/scala/mlscript/ucs/stages/package.scala
index 3d232a8705..b6a5abf7de 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/package.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/package.scala
@@ -1,9 +1,8 @@
-package mlscript.ucs
+package mlscript
+package ucs
 
-import mlscript.{App, DecLit, Fld, FldFlags, IntLit, Lit, PlainTup, StrLit, Term, Tup, Var}
-import mlscript.pretyper.symbol.TypeSymbol
-import mlscript.utils._, shorthands._
-import mlscript.pretyper.symbol.ClassLikeSymbol
+import utils._, shorthands._
+import pretyper.symbol.{ClassLikeSymbol, TypeSymbol}
 
 package object stages {
   /**

From 4923fb85b29e448a2716f56b749a6a1b5ffd75d5 Mon Sep 17 00:00:00 2001
From: Lionel Parreaux <lionel.parreaux@gmail.com>
Date: Wed, 1 May 2024 15:39:03 +0800
Subject: [PATCH 123/147] Add interesting extrusion test

---
 .../src/main/scala/mlscript/NuTypeDefs.scala  |  2 +-
 shared/src/test/diff/nu/TrickyExtrusion2.mls  | 47 +++++++++++++++++++
 2 files changed, 48 insertions(+), 1 deletion(-)
 create mode 100644 shared/src/test/diff/nu/TrickyExtrusion2.mls

diff --git a/shared/src/main/scala/mlscript/NuTypeDefs.scala b/shared/src/main/scala/mlscript/NuTypeDefs.scala
index 0ce7f326c5..3470c6807b 100644
--- a/shared/src/main/scala/mlscript/NuTypeDefs.scala
+++ b/shared/src/main/scala/mlscript/NuTypeDefs.scala
@@ -1073,7 +1073,7 @@ class NuTypeDefs extends ConstraintSolver { self: Typer =>
     private lazy val isGeneralized: Bool = decl match {
       case fd: NuFunDef =>
         println(s"Type ${fd.nme.name} polymorphically? ${fd.isGeneralized} && (${ctx.lvl} === 0 || ${
-          fd.signature.nonEmpty} || ${fd.outer.exists(_.kind isnt Mxn)}")
+          fd.signature.nonEmpty} || ${fd.outer.exists(_.kind isnt Mxn)})")
         // * We only type polymorphically:
         // * definitions that can be generalized (ie `fun`s or function-valued `let`s and `val`s); and
         fd.isGeneralized && (
diff --git a/shared/src/test/diff/nu/TrickyExtrusion2.mls b/shared/src/test/diff/nu/TrickyExtrusion2.mls
new file mode 100644
index 0000000000..ede1d7d4da
--- /dev/null
+++ b/shared/src/test/diff/nu/TrickyExtrusion2.mls
@@ -0,0 +1,47 @@
+:NewDefs
+
+:DontDistributeForalls
+
+
+// * This test reproduces a situation where ?A <: ?B <: ?A and we extrude both ?A and ?B to a lower level.
+// * The goal was to check how the resulting approximants were related.
+// * It turns out that in the current implementation,
+// * since we (arbitrarily) only register upper bounds in this case (i.e., ?B ∈ UB(?A) and ?A ∈ UB(?B))
+// * then the lower approximants end up being subtypes of each other,
+// * which happens when they are extruded negatively and their corresponding bounds are copied,
+// * but the upper approximants remain unrelated.
+// * This is sound, but the extra lower approximants bounds are not necessary,
+// * and indeed the SuperF constraining specification will not add them.
+
+
+class Invar[X, Y] { fun x: X -> X = id; fun y: Y -> Y = id }
+//│ class Invar[X, Y] {
+//│   constructor()
+//│   fun x: X -> X
+//│   fun y: Y -> Y
+//│ }
+
+fun bar[A, B]: () -> [A -> A, (B -> B) -> Invar[A, B]] = () => [id, _ => new Invar]
+//│ fun bar: forall 'A 'B. () -> ['A -> 'A, ('B -> 'B) -> Invar['A, 'B]]
+
+// :d
+:ns
+fun foo(x) =
+  let inner() =
+    let tmp = bar()
+    let r = tmp.1(tmp.0)
+    x(r)
+    r
+//│ fun foo: forall 'a 'b 'A 'B 'A0 'B0 'c. 'a -> ()
+//│   where
+//│     'a <: 'b -> 'c
+//│     'c <: ()
+//│     'b :> Invar[in 'A out 'A0, in 'B out 'B0]
+//│     'B0 :> 'B
+//│     'A0 :> 'A
+//│     'A <: 'B
+//│     'B <: 'A
+
+// * Above, 'A and 'B are the lower approximants and 'A0 and 'B0 are the upper approximants.
+
+

From ee4d5357856adf6ddeeda530a079c1e02e4180d1 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Mon, 6 May 2024 23:33:41 +0800
Subject: [PATCH 124/147] Refactor `specialize` & disable duplication check

---
 .../src/main/scala/mlscript/ucs/display.scala |  15 +-
 .../mlscript/ucs/stages/Normalization.scala   | 165 ++++++++++------
 .../main/scala/mlscript/ucs/syntax/core.scala |  22 +++
 shared/src/test/diff/mlscript/Repro.mls       |  66 -------
 .../ucs/coverage/ConflictedCoveredCases.mls   |  81 ++++++++
 .../ucs/coverage/ConflictedPatterns.mls       | 121 ++++++++++++
 .../pretyper/ucs/coverage/CoveredCases.mls    |  77 ++++++++
 .../pretyper/ucs/coverage/DuplicatedCases.mls | 183 ++++++++++++++++++
 shared/src/test/diff/ucs/InterleavedLet.mls   |  20 +-
 shared/src/test/diff/ucs/SimpleUCS.mls        |  14 +-
 shared/src/test/diff/ucs/SplitAroundOp.mls    |   2 -
 11 files changed, 619 insertions(+), 147 deletions(-)
 create mode 100644 shared/src/test/diff/pretyper/ucs/coverage/ConflictedCoveredCases.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/coverage/ConflictedPatterns.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/coverage/CoveredCases.mls
 create mode 100644 shared/src/test/diff/pretyper/ucs/coverage/DuplicatedCases.mls

diff --git a/shared/src/main/scala/mlscript/ucs/display.scala b/shared/src/main/scala/mlscript/ucs/display.scala
index f6ff2952d0..77650f7f7e 100644
--- a/shared/src/main/scala/mlscript/ucs/display.scala
+++ b/shared/src/main/scala/mlscript/ucs/display.scala
@@ -71,9 +71,10 @@ package object display {
     ("if" #: termSplit(split, true, true)).toIndentedString
   }
 
-  @inline def showSplit(s: c.Split)(implicit context: Context): Str = showSplit("if", s)
+  @inline def showSplit(s: c.Split, showFirstLevel: Bool = false)(implicit context: Context): Str =
+    showSplit("if", s, showFirstLevel)
 
-  def showSplit(prefix: Str, s: c.Split)(implicit context: Context): Str = {
+  def showSplit(prefix: Str, s: c.Split, showFirstLevel: Bool)(implicit context: Context): Str = {
     def split(s: c.Split, isFirst: Bool, isTopLevel: Bool): Lines = s match {
       case c.Split.Cons(head, tail) => (branch(head, isTopLevel) match {
         case (n, line) :: tail => (n, (if (isTopLevel) "" else "and ") + s"$line") :: tail
@@ -87,7 +88,15 @@ package object display {
     }
     def branch(b: c.Branch, isTopLevel: Bool): Lines = {
       val c.Branch(scrutinee, pattern, continuation) = b
-      s"${showVar(scrutinee)} is $pattern" #: split(continuation, true, isTopLevel)
+      if (showFirstLevel) {
+        val continuation = b.continuation match {
+          case c.Split.Nil => "empty"
+          case c.Split.Else(_) => "then ..."
+          case _ => "and ..."
+        }
+        (0, s"${showVar(scrutinee)} is $pattern " + continuation) :: Nil
+      }
+      else s"${showVar(scrutinee)} is $pattern" #: split(continuation, true, isTopLevel)
     }
     val lines = split(s, true, true)
     (if (prefix.isEmpty) lines else prefix #: lines).toIndentedString
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 92ba151231..e02794e3ce 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -32,7 +32,7 @@ trait Normalization { self: Desugarer with Traceable =>
           these.copy(tail = fillImpl(tail, those)(scope, context, declaredVars + nme, false))
         }
       case _: Split.Else => these
-      case Split.Nil => those.withoutBindings(declaredVars)
+      case Split.Nil => those.withoutBindings(declaredVars).markAsFallback()
     })
 
   private implicit class SplitOps(these: Split) {
@@ -49,7 +49,7 @@ trait Normalization { self: Desugarer with Traceable =>
         scope: Scope,
         context: Context,
     ): Split =
-      trace(s"fill <== ${declaredVars.iterator.map(_.name).mkString("{", ", ", "}")}") {
+      trace(s"fill <== vars = ${declaredVars.iterator.map(_.name).mkString("{", ", ", "}")}") {
         println(s"LHS: ${showSplit(these)}")
         println(s"RHS: ${showSplit(those)}")
         fillImpl(these, those)(scope, context, declaredVars, shouldReportDiscarded)
@@ -121,7 +121,7 @@ trait Normalization { self: Desugarer with Traceable =>
   private def normalizeToTerm(split: Split, declaredVars: Set[Var])(implicit
       scope: Scope,
       context: Context,
-  ): Term = trace("normalizeToTerm <==") {
+  ): Term = trace(s"normalizeToTerm <== ${showSplit(split)}") {
     split match {
       case Split.Cons(Branch(scrutinee, Pattern.Name(nme), continuation), tail) =>
         println(s"ALIAS: ${scrutinee.name} is ${nme.name}")
@@ -138,15 +138,15 @@ trait Normalization { self: Desugarer with Traceable =>
         println(s"entire split: ${showSplit(split)}")
         val concatenatedTrueBranch = continuation.fill(tail, declaredVars, false)
         // println(s"true branch: ${showSplit(concatenatedTrueBranch)}")
-        val trueBranch = normalizeToTerm(specialize(concatenatedTrueBranch, true)(scrutineeVar, scrutinee, pattern, context), declaredVars)
+        val trueBranch = normalizeToTerm(specialize(concatenatedTrueBranch, true, scrutineeVar, scrutinee, pattern), declaredVars)
         // println(s"false branch: ${showSplit(tail)}")
-        val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context), declaredVars)
+        val falseBranch = normalizeToCaseBranches(specialize(tail, false, scrutineeVar, scrutinee, pattern), declaredVars)
         CaseOf(scrutineeVar, Case(literal, trueBranch, falseBranch)(refined = false))
       case Split.Cons(Branch(Scrutinee.WithVar(scrutineeVar, scrutinee), pattern @ Pattern.Class(nme, _, rfd), continuation), tail) =>
         println(s"CLASS: ${scrutineeVar.name} is ${nme.name}")
         // println(s"match ${scrutineeVar.name} with $nme (has location: ${nme.toLoc.isDefined})")
-        val trueBranch = normalizeToTerm(specialize(continuation.fill(tail, declaredVars, false), true)(scrutineeVar, scrutinee, pattern, context), declaredVars)
-        val falseBranch = normalizeToCaseBranches(specialize(tail, false)(scrutineeVar, scrutinee, pattern, context), declaredVars)
+        val trueBranch = normalizeToTerm(specialize(continuation.fill(tail, declaredVars, false), true, scrutineeVar, scrutinee, pattern), declaredVars)
+        val falseBranch = normalizeToCaseBranches(specialize(tail, false, scrutineeVar, scrutinee, pattern), declaredVars)
         CaseOf(scrutineeVar, Case(nme, trueBranch, falseBranch)(refined = pattern.refined))
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
         raiseDesugaringError(msg"unsupported pattern: ${pattern.toString}" -> pattern.toLoc)
@@ -164,7 +164,7 @@ trait Normalization { self: Desugarer with Traceable =>
         println(s"DFLT: ${default.showDbg}")
         default
       case Split.Nil =>
-        raiseDesugaringError(msg"unexpected empty split found" -> N)
+        // raiseDesugaringError(msg"unexpected empty split found" -> N)
         errorTerm
     }
   }(split => "normalizeToTerm ==> " + showNormalizedTerm(split))
@@ -197,57 +197,108 @@ trait Normalization { self: Desugarer with Traceable =>
     * `scrutinee` matches `pattern`. Otherwise, the function _removes_ branches
     * that agree on `scrutinee` matches `pattern`.
     */
-  private def specialize
-      (split: Split, matchOrNot: Bool)
-      (implicit scrutineeVar: Var, scrutinee: Scrutinee, pattern: Pattern, context: Context): Split =
-  trace[Split](s"S${if (matchOrNot) "+" else "-"} <== ${scrutineeVar.name} is ${pattern}") {
-    (matchOrNot, split) match {
-      // Name patterns are translated to let bindings.
-      case (m, Split.Cons(Branch(otherScrutineeVar, Pattern.Name(alias), continuation), tail)) =>
-        Split.Let(false, alias, otherScrutineeVar, specialize(continuation, m))
-      case (m, Split.Cons(head @ Branch(test, Pattern.Class(Var("true"), _, _), continuation), tail)) if context.isTestVar(test) =>
-        println(s"TEST: ${test.name} is true")
-        head.copy(continuation = specialize(continuation, m)) :: specialize(tail, m)
-      case (true, split @ Split.Cons(head @ Branch(Scrutinee.WithVar(otherScrutineeVar, otherScrutinee), otherPattern, continuation), tail)) =>
-        if (scrutinee === otherScrutinee) {
-          println(s"Case 1: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
-          if (otherPattern =:= pattern) {
-            println(s"Case 1.1: $pattern =:= $otherPattern")
-            otherPattern reportInconsistentRefinedWith pattern
-            specialize(continuation, true) :++ specialize(tail, true)
-          } else if (otherPattern <:< pattern) {
-            println(s"Case 1.2: $pattern <:< $otherPattern")
-            pattern.markAsRefined; split
-          } else {
-            println(s"Case 1.3: $pattern are unrelated with $otherPattern")
-            specialize(tail, true)
-          }
-        } else {
-          println(s"Case 2: ${scrutineeVar.name} =/= ${otherScrutineeVar.name}")
-          head.copy(continuation = specialize(continuation, true)) :: specialize(tail, true)
-        }
-      case (false, split @ Split.Cons(head @ Branch(Scrutinee.WithVar(otherScrutineeVar, otherScrutinee), otherPattern, continuation), tail)) =>
-        if (scrutinee === otherScrutinee) {
-          println(s"Case 1: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
-          otherPattern reportInconsistentRefinedWith pattern
-          if (otherPattern =:= pattern || otherPattern <:< pattern) {
-            println(s"Case 1.1: $pattern =:= (or <:<) $otherPattern")
-            specialize(tail, false)
+  private def specialize(
+      split: Split,
+      matchOrNot: Bool,
+      scrutineeVar: Var,
+      scrutinee: Scrutinee,
+      pattern: Pattern
+  )(implicit context: Context): Split = 
+    trace(s"S${if (matchOrNot) "+" else "-"} <== ${scrutineeVar.name} is ${pattern} : ${showSplit(split, true)}"){
+      val specialized = specializeImpl(split)(matchOrNot, scrutineeVar, scrutinee, pattern, context)
+      // if (split =/= Split.Nil && specialized === Split.Nil && !split.isFallback) {
+      //   raiseDesugaringWarning(msg"the case is unreachable" -> split.toLoc)
+      // }
+      specialized
+    }(r => s"S${if (matchOrNot) "+" else "-"} ==> ${showSplit(r, true)}")
+
+  /** This function does not trace. Call it when handling `tail`s. */
+  private def specializeImpl(split: Split)(implicit
+      keepOrRemove: Bool,
+      scrutineeVar: Var,
+      scrutinee: Scrutinee,
+      pattern: Pattern,
+      context: Context): Split =split match {
+    case split @ Split.Cons(head, tail) =>
+      println(s"CASE Cons ${head.showDbg}")
+      lazy val continuation = specialize(head.continuation, keepOrRemove, scrutineeVar, scrutinee, pattern)
+      head match {
+        case Branch(otherScrutineeVar, Pattern.Name(alias), _) =>
+          Split.Let(false, alias, otherScrutineeVar, continuation)
+        case Branch(test, Pattern.Class(Var("true"), _, _), _) if context.isTestVar(test) =>
+          head.copy(continuation = continuation) :: specializeImpl(tail)
+        case Branch(Scrutinee.WithVar(otherScrutineeVar, otherScrutinee), otherPattern, _) =>
+          if (scrutinee === otherScrutinee) {
+            if (keepOrRemove) {
+              println(s"Case 1.1: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
+              if (otherPattern =:= pattern) {
+                println(s"Case 1.1.1: $pattern =:= $otherPattern")
+                otherPattern reportInconsistentRefinedWith pattern
+                continuation :++ specializeImpl(tail)
+              } else if (otherPattern <:< pattern) {
+                println(s"Case 1.1.2: $pattern <:< $otherPattern")
+                pattern.markAsRefined; split
+              } else {
+                println(s"Case 1.1.3: $pattern is unrelated with $otherPattern")
+                // The `continuation` is discarded because `otherPattern` is unrelated
+                // to the specialization topic.
+                if (!split.isFallback) {
+                  println(s"report warning")
+                  if (pattern <:< otherPattern) {
+                    raiseDesugaringWarning(
+                      msg"the pattern always matches" -> otherPattern.toLoc,
+                      msg"the scrutinee was matched against ${pattern.toString}" -> pattern.toLoc,
+                      msg"which is a subtype of ${otherPattern.toString}" -> (pattern match {
+                        case Pattern.Class(_, symbol, _) => symbol.defn.toLoc
+                        case _ => otherPattern.getLoc
+                      }))
+                    continuation :++ specializeImpl(tail)
+                  } else {
+                    raiseDesugaringWarning(
+                      msg"possibly conflicted patterns" -> otherPattern.toLoc,
+                      msg"the scrutinee was matched against ${pattern.toString}" -> pattern.toLoc,
+                      msg"which is unrelated with ${otherPattern.toString}" -> otherPattern.toLoc)
+                    specializeImpl(tail)
+                  }
+                } else {
+                  specializeImpl(tail)
+                }
+              }
+            } else {
+              println(s"Case 1.2: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
+              otherPattern reportInconsistentRefinedWith pattern
+              if (otherPattern =:= pattern || otherPattern <:< pattern) {
+                println(s"Case 1.2.1: $pattern =:= (or <:<) $otherPattern")
+                // The `continuation` is discarded because `otherPattern` is related
+                // to the specialization topic.
+                // println(s"is fallback = ${split.isFallback}")
+                // if (!split.isFallback) {
+                //   println(s"report warning")
+                //   raiseDesugaringWarning(
+                //     msg"possibly duplicated cases" -> otherPattern.toLoc,
+                //     msg"the case can be covered by ${pattern.toString}" -> pattern.toLoc,
+                //   )
+                // }
+                specializeImpl(tail)
+              } else {
+                println(s"Case 1.2.2: $pattern are unrelated with $otherPattern")
+                split.copy(tail = specializeImpl(tail))
+              }
+            }
           } else {
-            println(s"Case 1.2: $pattern are unrelated with $otherPattern")
-            split.copy(tail = specialize(tail, false))
+            println(s"Case 2: ${scrutineeVar.name} =/= ${otherScrutineeVar.name}")
+            head.copy(continuation = continuation) :: specializeImpl(tail)
           }
-        } else {
-          println(s"Case 2: ${scrutineeVar.name} =/= ${otherScrutineeVar.name}")
-          head.copy(continuation = specialize(continuation, false)) :: specialize(tail, false)
-        }
-      case (_, split @ Split.Cons(Branch(_, pattern, _), _)) =>
-        raiseDesugaringError(msg"unsupported pattern" -> pattern.toLoc)
-        split
-      case (m, let @ Split.Let(_, nme, _, tail)) => let.copy(tail = specialize(tail, m))
-      case (_, end @ (Split.Else(_) | Split.Nil)) => println("the end"); end
-    }
-  }()
+        case _ =>
+          raiseDesugaringError(msg"unsupported pattern" -> pattern.toLoc)
+          split
+      }
+    case split @ Split.Let(_, nme, _, tail) =>
+      println(s"CASE Let ${nme.name}")
+      split.copy(tail = specializeImpl(tail))
+    case Split.Else(_) => println("CASE Else"); split
+    case Split.Nil => println("CASE Nil"); split
+  }
 
   /**
     * If you want to prepend `tail` to another `Split` where the `nme` takes
diff --git a/shared/src/main/scala/mlscript/ucs/syntax/core.scala b/shared/src/main/scala/mlscript/ucs/syntax/core.scala
index fa73d74e19..3d6fe9c9dc 100644
--- a/shared/src/main/scala/mlscript/ucs/syntax/core.scala
+++ b/shared/src/main/scala/mlscript/ucs/syntax/core.scala
@@ -43,6 +43,8 @@ package object core {
 
   final case class Branch(scrutinee: Var, pattern: Pattern, continuation: Split) extends Located {
     override def children: List[Located] = scrutinee :: pattern :: continuation :: Nil
+
+    def showDbg: String = s"${scrutinee.showDbg} is $pattern"
   }
 
   sealed abstract class Split extends Located {
@@ -84,6 +86,26 @@ package object core {
       case Split.Else(default) => default :: Nil
       case Split.Nil => Nil
     }
+
+    // TODO: Make the following flag temporary. It is only meaningful in a
+    // single run of specialization. The flag is useless outside specialization
+    // functions.
+
+    private var _fallback: Bool = false
+
+    def isFallback: Bool = _fallback
+
+    def markAsFallback(): this.type = {
+      _fallback = true;
+      this match {
+        case Split.Cons(head, tail) =>
+          head.continuation.markAsFallback()
+          tail.markAsFallback()
+        case Split.Let(_, _, _, tail) => tail.markAsFallback()
+        case _: Split.Else | Split.Nil => ()
+      }
+      this
+    }
   }
 
   object Split {
diff --git a/shared/src/test/diff/mlscript/Repro.mls b/shared/src/test/diff/mlscript/Repro.mls
index 5f633779eb..34d9bdfef7 100644
--- a/shared/src/test/diff/mlscript/Repro.mls
+++ b/shared/src/test/diff/mlscript/Repro.mls
@@ -1,67 +1 @@
 :NewDefs
-
-class A()
-class B() extends A()
-//│ class A()
-//│ class B() extends A
-
-fun p(x) = true
-//│ fun p: anything -> true
-
-fun f(x) = if
-  x is B and
-    x is A then 1
-    p(x) then 2
-  x is A then 31
-  x is B then 3
-  else 4
-//│ fun f: (B | Object & ~#B) -> (2 | 3 | 31 | 4)
-
-
-
-// FIXME should warn about unreachable code (3 disappears)
-:ducs:postprocess.result
-fun f(x) = if
-  x is A and
-    x is B then 1
-    p(x) then 2
-  x is B then 3
-  else 4
-//│ Post-processed UCS term:
-//│ case x*‡ of
-//│   refined A*◊ ->
-//│     case x*‡ of
-//│       B*◊ -> 1
-//│       _ ->
-//│         let ucs$test$0*† = p(x,) : Bool
-//│         case ucs$test$0*† of
-//│           true*† -> 2
-//│           _ -> 4
-//│   _ -> 4
-//│ fun f: Object -> (1 | 2 | 4)
-
-
-class X()
-class Y()
-//│ class X()
-//│ class Y()
-
-// FIXME should warn about unreachable code (1 disappears)
-:ducs:postprocess.result
-fun f(x) = if
-  x is X and
-    x is Y then 1
-    p(x) then 2
-  x is Y then 3
-  else 4
-//│ Post-processed UCS term:
-//│ case x*‡ of
-//│   X*◊ ->
-//│     let ucs$test$0*† = p(x,) : Bool
-//│     case ucs$test$0*† of
-//│       true*† -> 2
-//│       _ -> 4
-//│   Y*◊ -> 3
-//│   _ -> 4
-//│ fun f: Object -> (2 | 3 | 4)
-
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/ConflictedCoveredCases.mls b/shared/src/test/diff/pretyper/ucs/coverage/ConflictedCoveredCases.mls
new file mode 100644
index 0000000000..fcd0d521be
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/coverage/ConflictedCoveredCases.mls
@@ -0,0 +1,81 @@
+:NewDefs
+
+class A()
+class B() extends A()
+//│ class A()
+//│ class B() extends A
+
+fun p(x) = true
+//│ fun p: anything -> true
+
+:w
+:ducs:normalize.result
+fun f(x) = if
+  x is B and
+    x is A then 1
+  x is A then 31
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   B*◊ -> 1
+//│   _ ->
+//│     case x*‡ of
+//│       A*◊ -> 31
+//│ ╔══[WARNING] the pattern always matches
+//│ ║  l.15: 	    x is A then 1
+//│ ║        	         ^
+//│ ╟── the scrutinee was matched against B
+//│ ║  l.14: 	  x is B and
+//│ ║        	       ^
+//│ ╟── which is a subtype of A
+//│ ║  l.4: 	class B() extends A()
+//│ ╙──     	^^^^^^^^^^^^^^^^^^^^^
+//│ fun f: (A & ~#B | B) -> (1 | 31)
+
+// FIXME: wrong missing cases
+:w
+:ducs:normalize.result
+fun f(x) = if
+  x is 1 and
+    x is Int then true
+  x is 2 then false
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   1 -> true
+//│   _ ->
+//│     case x*‡ of
+//│       2 -> false
+//│ ╔══[WARNING] the pattern always matches
+//│ ║  l.39: 	    x is Int then true
+//│ ║        	         ^^^
+//│ ╟── the scrutinee was matched against 1
+//│ ║  l.38: 	  x is 1 and
+//│ ║        	       ^
+//│ ╟── which is a subtype of Int
+//│ ║  l.39: 	    x is Int then true
+//│ ╙──      	         ^^^
+//│ ╔══[ERROR] `x` has 1 missing case
+//│ ║  l.38: 	  x is 1 and
+//│ ║        	  ^
+//│ ╟── it can be class `Int`
+//│ ║  l.39: 	    x is Int then true
+//│ ╙──      	         ^^^
+//│ fun f: (1 | 2) -> Bool
+
+:w
+fun f(x) = if
+  x is B and
+    x is A then 1
+    p(x) then 2
+  x is A then 31
+  x is B then 3
+  else 4
+//│ ╔══[WARNING] the pattern always matches
+//│ ║  l.67: 	    x is A then 1
+//│ ║        	         ^
+//│ ╟── the scrutinee was matched against B
+//│ ║  l.66: 	  x is B and
+//│ ║        	       ^
+//│ ╟── which is a subtype of A
+//│ ║  l.4: 	class B() extends A()
+//│ ╙──     	^^^^^^^^^^^^^^^^^^^^^
+//│ fun f: (B | Object & ~#B) -> (1 | 31 | 4)
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/ConflictedPatterns.mls b/shared/src/test/diff/pretyper/ucs/coverage/ConflictedPatterns.mls
new file mode 100644
index 0000000000..727a3ab274
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/coverage/ConflictedPatterns.mls
@@ -0,0 +1,121 @@
+:NewDefs
+
+// This test file contains the cases where inner cases are conflicting with outer cases.
+
+class X
+class Y
+class Z
+//│ class X {
+//│   constructor()
+//│ }
+//│ class Y {
+//│   constructor()
+//│ }
+//│ class Z {
+//│   constructor()
+//│ }
+
+:w
+:ducs:normalize.result
+fun f(x) = if
+  x is X and x is Y then 1
+  else 2
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   X*◊ -> 2
+//│   _ -> 2
+//│ ╔══[WARNING] possibly conflicted patterns
+//│ ║  l.21: 	  x is X and x is Y then 1
+//│ ║        	                  ^
+//│ ╟── the scrutinee was matched against X
+//│ ║  l.21: 	  x is X and x is Y then 1
+//│ ║        	       ^
+//│ ╟── which is unrelated with Y
+//│ ║  l.21: 	  x is X and x is Y then 1
+//│ ╙──      	                  ^
+//│ fun f: Object -> 2
+
+
+:w
+:ducs:normalize.result
+fun f(x) = if
+  x is X and
+    x is Y then 1
+    x is Y then 2
+  else 3
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   X*◊ -> 3
+//│   _ -> 3
+//│ ╔══[WARNING] possibly conflicted patterns
+//│ ║  l.43: 	    x is Y then 1
+//│ ║        	         ^
+//│ ╟── the scrutinee was matched against X
+//│ ║  l.42: 	  x is X and
+//│ ║        	       ^
+//│ ╟── which is unrelated with Y
+//│ ║  l.43: 	    x is Y then 1
+//│ ╙──      	         ^
+//│ ╔══[WARNING] possibly conflicted patterns
+//│ ║  l.44: 	    x is Y then 2
+//│ ║        	         ^
+//│ ╟── the scrutinee was matched against X
+//│ ║  l.42: 	  x is X and
+//│ ║        	       ^
+//│ ╟── which is unrelated with Y
+//│ ║  l.44: 	    x is Y then 2
+//│ ╙──      	         ^
+//│ fun f: Object -> 3
+
+:w
+:ducs:normalize.result
+fun f(x) = if
+  x is X and
+    x is Y then 1
+    x is Z then 2
+  else 3
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   X*◊ -> 3
+//│   _ -> 3
+//│ ╔══[WARNING] possibly conflicted patterns
+//│ ║  l.74: 	    x is Y then 1
+//│ ║        	         ^
+//│ ╟── the scrutinee was matched against X
+//│ ║  l.73: 	  x is X and
+//│ ║        	       ^
+//│ ╟── which is unrelated with Y
+//│ ║  l.74: 	    x is Y then 1
+//│ ╙──      	         ^
+//│ ╔══[WARNING] possibly conflicted patterns
+//│ ║  l.75: 	    x is Z then 2
+//│ ║        	         ^
+//│ ╟── the scrutinee was matched against X
+//│ ║  l.73: 	  x is X and
+//│ ║        	       ^
+//│ ╟── which is unrelated with Z
+//│ ║  l.75: 	    x is Z then 2
+//│ ╙──      	         ^
+//│ fun f: Object -> 3
+
+:w
+:ducs:normalize.result
+fun f(x) = if
+  x is X and
+    x is Y and
+      x is Z then 1
+  else 2
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   X*◊ -> 2
+//│   _ -> 2
+//│ ╔══[WARNING] possibly conflicted patterns
+//│ ║  l.105: 	    x is Y and
+//│ ║         	         ^
+//│ ╟── the scrutinee was matched against X
+//│ ║  l.104: 	  x is X and
+//│ ║         	       ^
+//│ ╟── which is unrelated with Y
+//│ ║  l.105: 	    x is Y and
+//│ ╙──       	         ^
+//│ fun f: Object -> 2
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/CoveredCases.mls b/shared/src/test/diff/pretyper/ucs/coverage/CoveredCases.mls
new file mode 100644
index 0000000000..12119e25a3
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/coverage/CoveredCases.mls
@@ -0,0 +1,77 @@
+:NewDefs
+
+// This test file contains the cases where latter cases are covered by the former cases.
+
+// B <: A
+class A()
+class B() extends A()
+//│ class A()
+//│ class B() extends A
+
+:w
+fun f(x) = if
+  x is A then 1
+  x is A then 2
+//│ fun f: A -> 1
+//│ TEST CASE FAILURE: There was an unexpected lack of warning
+
+:w
+:ducs:normalize.result
+fun f(x) = if
+  x is A then 1
+  x is B then 2
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   A*◊ -> 1
+//│ fun f: A -> 1
+//│ TEST CASE FAILURE: There was an unexpected lack of warning
+
+:ducs:normalize.result
+fun f(x) = if
+  x is A and
+    x is B then 1
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   refined A*◊ ->
+//│     case x*‡ of
+//│       B*◊ -> 1
+//│ fun f: B -> 1
+
+:w
+:ducs:normalize.result
+fun f(x) = if
+  x is A and
+    x is B then 1
+  x is B then 2
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   refined A*◊ ->
+//│     case x*‡ of
+//│       B*◊ -> 1
+//│ fun f: B -> 1
+//│ TEST CASE FAILURE: There was an unexpected lack of warning
+
+fun p(x) = true: Bool
+//│ fun p: anything -> Bool
+
+:w
+:ducs:normalize.result
+fun f(x) = if
+  x is A and
+    x is B then 1
+    p(x) then 2
+  x is B then 3
+  else 4
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   refined A*◊ ->
+//│     case x*‡ of
+//│       B*◊ -> 1
+//│       _ ->
+//│         let ucs$test$0*† = p(x,) : Bool
+//│         case ucs$test$0*† of
+//│           true*† -> 2
+//│           _ -> 4
+//│   _ -> 4
+//│ fun f: Object -> (1 | 2 | 4)
+//│ TEST CASE FAILURE: There was an unexpected lack of warning
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/DuplicatedCases.mls b/shared/src/test/diff/pretyper/ucs/coverage/DuplicatedCases.mls
new file mode 100644
index 0000000000..3fd1bb8c4a
--- /dev/null
+++ b/shared/src/test/diff/pretyper/ucs/coverage/DuplicatedCases.mls
@@ -0,0 +1,183 @@
+:NewDefs
+
+// This test file contains the cases containing cases with identical patterns.
+
+:w
+:ducs:normalize.result
+fun f(x) = if x is
+  "a" then 1
+  "b" then 2
+  "a" then 3
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   "a" -> 1
+//│   _ ->
+//│     case x*‡ of
+//│       "b" -> 2
+//│ fun f: ("a" | "b") -> (1 | 2)
+//│ TEST CASE FAILURE: There was an unexpected lack of warning
+
+class X
+class Y
+//│ class X {
+//│   constructor()
+//│ }
+//│ class Y {
+//│   constructor()
+//│ }
+
+:w
+:ducs:normalize.result
+fun f(x) = if x is
+  X then 1
+  X then 2
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   X*◊ -> 1
+//│ fun f: X -> 1
+//│ TEST CASE FAILURE: There was an unexpected lack of warning
+
+:w
+:ducs:normalize.result
+fun f(x) = if x is
+  X then 1
+  Y then 2
+  X then 3
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   X*◊ -> 1
+//│   _ ->
+//│     case x*‡ of
+//│       Y*◊ -> 2
+//│ fun f: (X | Y) -> (1 | 2)
+//│ TEST CASE FAILURE: There was an unexpected lack of warning
+
+class Box[T](value: T)
+//│ class Box[T](value: T)
+
+:ducs:normalize,normalize.result
+fun f(x) = if x is
+  Box(1) then true
+  Box then false
+//│ | | | | | STEP 2
+//│ | | | | | normalizeToTerm <== if
+//│ | | | | |   x*‡ is Box
+//│ | | | | |     let ucs$args_x$Box*† = (Box).unapply(x,)
+//│ | | | | |     let x$Box_0*‡ = (ucs$args_x$Box).0
+//│ | | | | |     x$Box_0*‡ is 1 then true
+//│ | | | | |   x*‡ is Box then false
+//│ | | | | | | CLASS: x is Box
+//│ | | | | | | fill <== vars = {}
+//│ | | | | | | | LHS: if
+//│ | | | | | | |   let ucs$args_x$Box*† = (Box).unapply(x,)
+//│ | | | | | | |   let x$Box_0*‡ = (ucs$args_x$Box).0
+//│ | | | | | | |   x$Box_0*‡ is 1 then true
+//│ | | | | | | | RHS: if x*‡ is Box then false
+//│ | | | | | | | fill let binding ucs$args_x$Box
+//│ | | | | | | | fill let binding x$Box_0
+//│ | | | | | | fill ==> if
+//│ | | | | | |   let ucs$args_x$Box*† = (Box).unapply(x,)
+//│ | | | | | |   let x$Box_0*‡ = (ucs$args_x$Box).0
+//│ | | | | | |   x$Box_0*‡ is 1 then true
+//│ | | | | | |   x*‡ is Box then false
+//│ | | | | | | S+ <== x is Box : if
+//│ | | | | | |   let ucs$args_x$Box*† = (Box).unapply(x,)
+//│ | | | | | |   let x$Box_0*‡ = (ucs$args_x$Box).0
+//│ | | | | | |   x$Box_0*‡ is 1 then ...
+//│ | | | | | |   x*‡ is Box then ...
+//│ | | | | | | | CASE Let ucs$args_x$Box
+//│ | | | | | | | CASE Let x$Box_0
+//│ | | | | | | | CASE Cons x$Box_0 is 1
+//│ | | | | | | | Case 2: x =/= x$Box_0
+//│ | | | | | | | S+ <== x is Box : if then true
+//│ | | | | | | | | CASE Else
+//│ | | | | | | | S+ ==> if then true
+//│ | | | | | | | CASE Cons x is Box
+//│ | | | | | | | Case 1.1: x === x
+//│ | | | | | | | Case 1.1.1: Box =:= Box
+//│ | | | | | | | S+ <== x is Box : if then false
+//│ | | | | | | | | CASE Else
+//│ | | | | | | | S+ ==> if then false
+//│ | | | | | | | tail is discarded
+//│ | | | | | | S+ ==> if
+//│ | | | | | |   let ucs$args_x$Box*† = (Box).unapply(x,)
+//│ | | | | | |   let x$Box_0*‡ = (ucs$args_x$Box).0
+//│ | | | | | |   x$Box_0*‡ is 1 then ...
+//│ | | | | | |   else false
+//│ | | | | | | normalizeToTerm <== if
+//│ | | | | | |   let ucs$args_x$Box*† = (Box).unapply(x,)
+//│ | | | | | |   let x$Box_0*‡ = (ucs$args_x$Box).0
+//│ | | | | | |   x$Box_0*‡ is 1 then true
+//│ | | | | | |   else false
+//│ | | | | | | | LET: generated ucs$args_x$Box
+//│ | | | | | | | normalizeToTerm <== if
+//│ | | | | | | |   let x$Box_0*‡ = (ucs$args_x$Box).0
+//│ | | | | | | |   x$Box_0*‡ is 1 then true
+//│ | | | | | | |   else false
+//│ | | | | | | | | LET: x$Box_0
+//│ | | | | | | | | normalizeToTerm <== if
+//│ | | | | | | | |   x$Box_0*‡ is 1 then true
+//│ | | | | | | | |   else false
+//│ | | | | | | | | | LITERAL: x$Box_0 is 1
+//│ | | | | | | | | | entire split: if
+//│ | | | | | | | | |   x$Box_0*‡ is 1 then true
+//│ | | | | | | | | |   else false
+//│ | | | | | | | | | fill <== vars = {ucs$args_x$Box}
+//│ | | | | | | | | | | LHS: if then true
+//│ | | | | | | | | | | RHS: if then false
+//│ | | | | | | | | | fill ==> if then true
+//│ | | | | | | | | | S+ <== x$Box_0 is 1 : if then true
+//│ | | | | | | | | | | CASE Else
+//│ | | | | | | | | | S+ ==> if then true
+//│ | | | | | | | | | normalizeToTerm <== if then true
+//│ | | | | | | | | | | DFLT: true
+//│ | | | | | | | | | normalizeToTerm ==> true
+//│ | | | | | | | | | S- <== x$Box_0 is 1 : if then false
+//│ | | | | | | | | | | CASE Else
+//│ | | | | | | | | | S- ==> if then false
+//│ | | | | | | | | | normalizeToCaseBranches <==
+//│ | | | | | | | | | normalizeToCaseBranches ==>
+//│ | | | | | | | | normalizeToTerm ==> case x$Box_0*‡ of
+//│ | | | | | | | |   1 -> true
+//│ | | | | | | | |   _ -> false
+//│ | | | | | | | normalizeToTerm ==> let x$Box_0*‡ = (ucs$args_x$Box).0
+//│ | | | | | | | case x$Box_0*‡ of
+//│ | | | | | | |   1 -> true
+//│ | | | | | | |   _ -> false
+//│ | | | | | | normalizeToTerm ==> let ucs$args_x$Box*† = (Box).unapply(x,)
+//│ | | | | | | let x$Box_0*‡ = (ucs$args_x$Box).0
+//│ | | | | | | case x$Box_0*‡ of
+//│ | | | | | |   1 -> true
+//│ | | | | | |   _ -> false
+//│ | | | | | | S- <== x is Box : if x*‡ is Box then ...
+//│ | | | | | | | CASE Cons x is Box
+//│ | | | | | | | Case 1.2: x === x
+//│ | | | | | | | Case 1.2.1: Box =:= (or <:<) Box
+//│ | | | | | | | CASE Nil
+//│ | | | | | | S- ==> if
+//│ | | | | | | normalizeToCaseBranches <==
+//│ | | | | | | normalizeToCaseBranches ==>
+//│ | | | | | normalizeToTerm ==> case x*‡ of
+//│ | | | | |   Box*◊ ->
+//│ | | | | |     let ucs$args_x$Box*† = (Box).unapply(x,)
+//│ | | | | |     let x$Box_0*‡ = (ucs$args_x$Box).0
+//│ | | | | |     case x$Box_0*‡ of
+//│ | | | | |       1 -> true
+//│ | | | | |       _ -> false
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   Box*◊ ->
+//│     let ucs$args_x$Box*† = (Box).unapply(x,)
+//│     let x$Box_0*‡ = (ucs$args_x$Box).0
+//│     case x$Box_0*‡ of
+//│       1 -> true
+//│       _ -> false
+//│ fun f: Box[Object] -> Bool
+
+f(Box(0))
+f(Box(1))
+//│ Bool
+//│ res
+//│     = false
+//│ res
+//│     = true
diff --git a/shared/src/test/diff/ucs/InterleavedLet.mls b/shared/src/test/diff/ucs/InterleavedLet.mls
index 7f8eb6e3db..22f6a2aa2e 100644
--- a/shared/src/test/diff/ucs/InterleavedLet.mls
+++ b/shared/src/test/diff/ucs/InterleavedLet.mls
@@ -37,8 +37,6 @@ fun p(x, y) =
     x is Some and y is None then 0
     y is Some and x is Some then 1
     x is Some and y is Some then 0
-//│ ╔══[ERROR] unexpected empty split found
-//│ ╙──
 //│ ╔══[ERROR] `y` has 1 missing case
 //│ ║  l.38: 	    y is Some and x is Some then 1
 //│ ║        	    ^
@@ -75,10 +73,10 @@ fun f(a, y) =
       Right(x) then x + y
     else 0
 //│ ╔══[ERROR] Type mismatch in operator application:
-//│ ║  l.74: 	      let y = v + 1
+//│ ║  l.72: 	      let y = v + 1
 //│ ║        	              ^^^^^
 //│ ╟── reference of type `Right[?B]` is not an instance of type `Int`
-//│ ║  l.74: 	      let y = v + 1
+//│ ║  l.72: 	      let y = v + 1
 //│ ╙──      	              ^
 //│ fun f: forall 'a. (Object & ~#Some | Some[Int | Left['a] | Right[Int]], anything) -> (Int | 'a)
 
@@ -89,9 +87,9 @@ fun q(a) =
     let y = a + 1
     then y
 //│ ╔══[PARSE ERROR] Expected an expression; found a 'then'/'else' clause instead
-//│ ║  l.89: 	    let y = a + 1
+//│ ║  l.87: 	    let y = a + 1
 //│ ║        	            ^^^^^
-//│ ║  l.90: 	    then y
+//│ ║  l.88: 	    then y
 //│ ╙──      	^^^^^^^^^^
 //│ fun q: forall 'a. (Left['a] | Object & ~#Left) -> (() | 'a)
 
@@ -108,11 +106,11 @@ fun w() =
     B then "B"
     else "?"
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.106: 	    A then "A"
+//│ ║  l.104: 	    A then "A"
 //│ ║         	    ^
 //│ ╙── reference of type `() -> A` is not an instance of type `Bool`
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.108: 	    B then "B"
+//│ ║  l.106: 	    B then "B"
 //│ ║         	    ^
 //│ ╙── reference of type `() -> B` is not an instance of type `Bool`
 //│ fun w: () -> ("?" | "A" | "B")
@@ -169,13 +167,13 @@ fun ip(y) =
     y == z * z then "bruh"
   else "rocks"
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.167: 	  if q(y) and
+//│ ║  l.165: 	  if q(y) and
 //│ ║         	     ^^^^
 //│ ╟── undefined literal of type `()` is not an instance of type `Bool`
-//│ ║  l.90: 	    then y
+//│ ║  l.88: 	    then y
 //│ ║        	          ^
 //│ ╟── but it flows into application with expected type `Bool`
-//│ ║  l.167: 	  if q(y) and
+//│ ║  l.165: 	  if q(y) and
 //│ ╙──       	     ^^^^
 //│ fun ip: Int -> ("bruh" | "rocks")
 
diff --git a/shared/src/test/diff/ucs/SimpleUCS.mls b/shared/src/test/diff/ucs/SimpleUCS.mls
index b09105b2f1..c233a88c9f 100644
--- a/shared/src/test/diff/ucs/SimpleUCS.mls
+++ b/shared/src/test/diff/ucs/SimpleUCS.mls
@@ -327,8 +327,6 @@ fun f(x) =
 //│ ╔══[ERROR] Syntactic split of patterns are not supported
 //│ ║  l.325: 	    0 ::
 //│ ╙──       	      ^^
-//│ ╔══[ERROR] unexpected empty split found
-//│ ╙──
 //│ fun f: anything -> nothing
 
 fun f(x) =
@@ -370,22 +368,22 @@ test(false)
 test(0)
 test(1)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.370: 	test(0)
+//│ ║  l.368: 	test(0)
 //│ ║         	^^^^^^^
 //│ ╟── integer literal of type `0` is not an instance of type `Bool`
-//│ ║  l.370: 	test(0)
+//│ ║  l.368: 	test(0)
 //│ ║         	     ^
 //│ ╟── Note: constraint arises from reference:
-//│ ║  l.358: 	fun test(x) = if x then 0 else "oops"
+//│ ║  l.356: 	fun test(x) = if x then 0 else "oops"
 //│ ╙──       	                 ^
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.371: 	test(1)
+//│ ║  l.369: 	test(1)
 //│ ║         	^^^^^^^
 //│ ╟── integer literal of type `1` is not an instance of type `Bool`
-//│ ║  l.371: 	test(1)
+//│ ║  l.369: 	test(1)
 //│ ║         	     ^
 //│ ╟── Note: constraint arises from reference:
-//│ ║  l.358: 	fun test(x) = if x then 0 else "oops"
+//│ ║  l.356: 	fun test(x) = if x then 0 else "oops"
 //│ ╙──       	                 ^
 //│ "oops" | 0 | error
 //│ res
diff --git a/shared/src/test/diff/ucs/SplitAroundOp.mls b/shared/src/test/diff/ucs/SplitAroundOp.mls
index 75f038b276..3b0619ae6d 100644
--- a/shared/src/test/diff/ucs/SplitAroundOp.mls
+++ b/shared/src/test/diff/ucs/SplitAroundOp.mls
@@ -61,8 +61,6 @@ if x is
 //│ ╔══[ERROR] identifier `x` not found
 //│ ║  l.38: 	if x is
 //│ ╙──      	   ^
-//│ ╔══[ERROR] unexpected empty split found
-//│ ╙──
 //│ ╔══[ERROR] identifier not found: x
 //│ ║  l.38: 	if x is
 //│ ╙──      	   ^

From 67793371388121f4e603940bd08545a547b5778d Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 7 May 2024 00:07:21 +0800
Subject: [PATCH 125/147] Refine `Pattern.Class` constructor parameter types

---
 shared/src/main/scala/mlscript/ucs/syntax/core.scala | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/syntax/core.scala b/shared/src/main/scala/mlscript/ucs/syntax/core.scala
index 3d6fe9c9dc..996d960cb5 100644
--- a/shared/src/main/scala/mlscript/ucs/syntax/core.scala
+++ b/shared/src/main/scala/mlscript/ucs/syntax/core.scala
@@ -1,8 +1,7 @@
-package mlscript.ucs.syntax
+package mlscript
+package ucs.syntax
 
-import mlscript.{Diagnostic, Lit, Loc, Located, Message, Term, Var}
-import mlscript.utils._, shorthands._
-import mlscript.pretyper.symbol.TypeSymbol
+import utils._, shorthands._, pretyper.symbol.ClassLikeSymbol
 
 package object core {
   sealed abstract class Pattern extends Located {
@@ -28,7 +27,7 @@ package object core {
       * @param originallyRefined whether the class is marked as refined from
       *                          in source AST
       */
-    final case class Class(nme: Var, symbol: TypeSymbol, originallyRefined: Bool) extends Pattern {
+    final case class Class(nme: Var, symbol: ClassLikeSymbol, originallyRefined: Bool) extends Pattern {
       override def children: Ls[Located] = nme :: Nil
 
       /**

From 67ca7637a55316e671d460ace73ea496d663e2f2 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Tue, 7 May 2024 00:12:52 +0800
Subject: [PATCH 126/147] Function `hasElse` is renamed `isFull`

---
 .../src/main/scala/mlscript/ucs/stages/Normalization.scala  | 4 ++--
 shared/src/main/scala/mlscript/ucs/syntax/core.scala        | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index e02794e3ce..454a187f0c 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -16,7 +16,7 @@ trait Normalization { self: Desugarer with Traceable =>
       declaredVars: Set[Var],
       shouldReportDiscarded: Bool
   ): Split =
-    if (these.hasElse) {
+    if (these.isFull) {
       reportUnreachableCase(those, these, onlyIf = those =/= Split.Nil && shouldReportDiscarded)
     } else (these match {
       case these @ Split.Cons(head, tail) =>
@@ -56,7 +56,7 @@ trait Normalization { self: Desugarer with Traceable =>
       }(sp => s"fill ==> ${showSplit(sp)}")
 
     def :++(tail: => Split): Split = {
-      if (these.hasElse) {
+      if (these.isFull) {
         println("tail is discarded")
         // raiseDesugaringWarning(msg"Discarded split because of else branch" -> these.toLoc)
         these
diff --git a/shared/src/main/scala/mlscript/ucs/syntax/core.scala b/shared/src/main/scala/mlscript/ucs/syntax/core.scala
index 996d960cb5..c752e624ab 100644
--- a/shared/src/main/scala/mlscript/ucs/syntax/core.scala
+++ b/shared/src/main/scala/mlscript/ucs/syntax/core.scala
@@ -52,9 +52,9 @@ package object core {
     /**
       * Returns true if the split has an else branch.
       */
-    lazy val hasElse: Bool = this match {
-      case Split.Cons(_, tail) => tail.hasElse
-      case Split.Let(_, _, _, tail) => tail.hasElse
+    lazy val isFull: Bool = this match {
+      case Split.Cons(_, tail) => tail.isFull
+      case Split.Let(_, _, _, tail) => tail.isFull
       case Split.Else(_) => true
       case Split.Nil => false
     }

From 10fc090bf43704ba65721773cbc6615829430dc6 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 8 May 2024 03:13:26 +0800
Subject: [PATCH 127/147] Cherry-picked minor fixes

---
 .../main/scala/mlscript/ucs/context/Scrutinee.scala  |  2 +-
 shared/src/main/scala/mlscript/ucs/display.scala     |  2 +-
 shared/src/main/scala/mlscript/utils/package.scala   |  1 +
 shared/src/test/diff/nu/ArrayProg.mls                | 12 ++++++------
 shared/src/test/diff/ucs/Humiliation.mls             | 10 +++++-----
 5 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
index b8777655f3..464926e936 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
@@ -93,7 +93,7 @@ class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
         parentScrutinee.classLikePatterns.iterator.flatMap { case (symbol, pattern) =>
           pattern.findSubScrutinee(this).map(_ -> symbol.name)
         }.nextOption() match {
-          case S(index -> typeName) => s"${index.toOrdinalWord} argument of `${typeName}`"
+          case S(index -> typeName) => s"the ${index.toOrdinalWord} argument of `${typeName}`"
           case N => s"`${scrutineeVar.name}`" // Still not the best.
         }
     }
diff --git a/shared/src/main/scala/mlscript/ucs/display.scala b/shared/src/main/scala/mlscript/ucs/display.scala
index 77650f7f7e..38d8c14876 100644
--- a/shared/src/main/scala/mlscript/ucs/display.scala
+++ b/shared/src/main/scala/mlscript/ucs/display.scala
@@ -77,7 +77,7 @@ package object display {
   def showSplit(prefix: Str, s: c.Split, showFirstLevel: Bool)(implicit context: Context): Str = {
     def split(s: c.Split, isFirst: Bool, isTopLevel: Bool): Lines = s match {
       case c.Split.Cons(head, tail) => (branch(head, isTopLevel) match {
-        case (n, line) :: tail => (n, (if (isTopLevel) "" else "and ") + s"$line") :: tail
+        case (n, line) :: tail => (n, (if (isTopLevel) "" else "and ") + line) :: tail
         case Nil => Nil
       }) ::: split(tail, false, isTopLevel)
       case c.Split.Let(_, nme, rhs, tail) =>
diff --git a/shared/src/main/scala/mlscript/utils/package.scala b/shared/src/main/scala/mlscript/utils/package.scala
index e8bb4c46fc..309ddb4fc9 100644
--- a/shared/src/main/scala/mlscript/utils/package.scala
+++ b/shared/src/main/scala/mlscript/utils/package.scala
@@ -29,6 +29,7 @@ package object utils {
         case 1 => "first"
         case 2 => "second"
         case 3 => "third"
+        case n @ (11 | 12 | 13) => s"${n}th"
         case n => self.toString + (n % 10 match {
           case 1 => "st"
           case 2 => "nd"
diff --git a/shared/src/test/diff/nu/ArrayProg.mls b/shared/src/test/diff/nu/ArrayProg.mls
index 89d7e91979..e75f0fddfb 100644
--- a/shared/src/test/diff/nu/ArrayProg.mls
+++ b/shared/src/test/diff/nu/ArrayProg.mls
@@ -192,10 +192,10 @@ fun add(e) =
 //│ ╔══[ERROR] when `e` is `Pair`, and
 //│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
 //│ ║        	    ^^^^
-//│ ╟── first argument of `Pair` is `Numbr`,
+//│ ╟── the first argument of `Pair` is `Numbr`,
 //│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
 //│ ║        	         ^^^^^
-//│ ╟── second argument of `Pair` has 1 missing case
+//│ ╟── the second argument of `Pair` has 1 missing case
 //│ ╟── it can be class `Vectr`
 //│ ║  l.+4: 	    Pair(Vectr(xs),  Vectr(ys)) then 1
 //│ ╙──      	                     ^^^^^
@@ -209,20 +209,20 @@ fun add(e) =
 //│ ╔══[ERROR] when `e` is `Pair`, and
 //│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
 //│ ║        	    ^^^^
-//│ ╟── first argument of `Pair` is `Numbr`,
+//│ ╟── the first argument of `Pair` is `Numbr`,
 //│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
 //│ ║        	         ^^^^^
-//│ ╟── second argument of `Pair` has 1 missing case
+//│ ╟── the second argument of `Pair` has 1 missing case
 //│ ╟── it can be class `Vectr`
 //│ ║  l.+4: 	    Pair(Vectr(xs),  Vectr(ys)) then 1
 //│ ╙──      	                     ^^^^^
 //│ ╔══[ERROR] when `e` is `Pair`, and
 //│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
 //│ ║        	    ^^^^
-//│ ╟── first argument of `Pair` is `Vectr`,
+//│ ╟── the first argument of `Pair` is `Vectr`,
 //│ ║  l.+4: 	    Pair(Vectr(xs),  Vectr(ys)) then 1
 //│ ║        	         ^^^^^
-//│ ╟── second argument of `Pair` has 1 missing case
+//│ ╟── the second argument of `Pair` has 1 missing case
 //│ ╟── it can be class `Numbr`
 //│ ║  l.+3: 	    Pair(Numbr(n), Numbr(m))    then 0
 //│ ╙──      	                   ^^^^^
diff --git a/shared/src/test/diff/ucs/Humiliation.mls b/shared/src/test/diff/ucs/Humiliation.mls
index e4b0a5d9ca..da7dfbbcd2 100644
--- a/shared/src/test/diff/ucs/Humiliation.mls
+++ b/shared/src/test/diff/ucs/Humiliation.mls
@@ -52,20 +52,20 @@ fun foo(x) = if x is
 //│ ╔══[ERROR] when `x` is `Pair`, and
 //│ ║  l.50: 	  Pair(Z(), Z()) then "zeros"
 //│ ║        	  ^^^^
-//│ ╟── first argument of `Pair` is `Z`,
+//│ ╟── the first argument of `Pair` is `Z`,
 //│ ║  l.50: 	  Pair(Z(), Z()) then "zeros"
 //│ ║        	       ^
-//│ ╟── second argument of `Pair` has 1 missing case
+//│ ╟── the second argument of `Pair` has 1 missing case
 //│ ╟── it can be class `O`
 //│ ║  l.51: 	  Pair(O(), O()) then "ones"
 //│ ╙──      	            ^
 //│ ╔══[ERROR] when `x` is `Pair`, and
 //│ ║  l.50: 	  Pair(Z(), Z()) then "zeros"
 //│ ║        	  ^^^^
-//│ ╟── first argument of `Pair` is `O`,
+//│ ╟── the first argument of `Pair` is `O`,
 //│ ║  l.51: 	  Pair(O(), O()) then "ones"
 //│ ║        	       ^
-//│ ╟── second argument of `Pair` has 1 missing case
+//│ ╟── the second argument of `Pair` has 1 missing case
 //│ ╟── it can be class `Z`
 //│ ║  l.50: 	  Pair(Z(), Z()) then "zeros"
 //│ ╙──      	            ^
@@ -139,7 +139,7 @@ fun foo(x) = if x is
 //│ ╔══[ERROR] when `x` is `Pair`
 //│ ║  l.136: 	  Pair(Z(), Z()) then "zeros"
 //│ ║         	  ^^^^
-//│ ╟── second argument of `Pair` has 1 missing case
+//│ ╟── the second argument of `Pair` has 1 missing case
 //│ ╟── it can be class `Z`
 //│ ║  l.136: 	  Pair(Z(), Z()) then "zeros"
 //│ ╙──       	            ^

From 4a45caa1b136a598e43030531934adc23f792eae Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 8 May 2024 03:39:03 +0800
Subject: [PATCH 128/147] A still imperfect solution

---
 .../mlscript/ucs/context/Scrutinee.scala      |   7 +
 .../src/main/scala/mlscript/ucs/display.scala |   2 +-
 .../mlscript/ucs/stages/Normalization.scala   | 184 +++--
 .../main/scala/mlscript/ucs/syntax/core.scala |  70 +-
 .../pretyper/ucs/coverage/CoveredCases.mls    |  14 +-
 .../pretyper/ucs/coverage/DuplicatedCases.mls | 747 +++++++++++++++---
 shared/src/test/diff/ucs/Humiliation.mls      |  29 +-
 shared/src/test/diff/ucs/InterleavedLet.mls   |  24 +-
 .../src/test/diff/ucs/OverlappedBranches.mls  |  20 +-
 9 files changed, 880 insertions(+), 217 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
index 464926e936..9fba232a40 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Scrutinee.scala
@@ -3,6 +3,7 @@ package ucs.context
 
 import collection.mutable.{Buffer, SortedMap => MutSortedMap, SortedSet => MutSortedSet}
 import pretyper.symbol.{ClassLikeSymbol, TermSymbol, TypeSymbol}, utils._, shorthands._
+import scala.annotation.tailrec
 
 class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
   import Scrutinee._
@@ -98,6 +99,12 @@ class Scrutinee(val context: Context, parent: Opt[Scrutinee]) {
         }
     }
   }
+
+  @tailrec
+  final def isSubScrutineeOf(scrutinee: Scrutinee): Bool = this === scrutinee || (parent match {
+    case Some(parentScrutinee) => parentScrutinee.isSubScrutineeOf(scrutinee)
+    case N => false
+  })
 }
 
 object Scrutinee {
diff --git a/shared/src/main/scala/mlscript/ucs/display.scala b/shared/src/main/scala/mlscript/ucs/display.scala
index 38d8c14876..56cb97205f 100644
--- a/shared/src/main/scala/mlscript/ucs/display.scala
+++ b/shared/src/main/scala/mlscript/ucs/display.scala
@@ -77,7 +77,7 @@ package object display {
   def showSplit(prefix: Str, s: c.Split, showFirstLevel: Bool)(implicit context: Context): Str = {
     def split(s: c.Split, isFirst: Bool, isTopLevel: Bool): Lines = s match {
       case c.Split.Cons(head, tail) => (branch(head, isTopLevel) match {
-        case (n, line) :: tail => (n, (if (isTopLevel) "" else "and ") + line) :: tail
+        case (n, line) :: tail => (n, (if (isTopLevel) "" else "and ") + (if (s.isFallback) "?" else "") + line) :: tail
         case Nil => Nil
       }) ::: split(tail, false, isTopLevel)
       case c.Split.Let(_, nme, rhs, tail) =>
diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 454a187f0c..7efa02124b 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -10,6 +10,8 @@ import pretyper.symbol._
 import pretyper.{Diagnosable, Scope, Traceable}
 
 trait Normalization { self: Desugarer with Traceable =>
+  import Normalization._
+
   private def fillImpl(these: Split, those: Split)(implicit
       scope: Scope,
       context: Context,
@@ -45,7 +47,11 @@ trait Normalization { self: Desugarer with Traceable =>
       * @param declaredVars the generated variables which have been declared
       * @return the concatenated split
       */
-    def fill(those: Split, declaredVars: Set[Var], shouldReportDiscarded: Bool)(implicit
+    def fill(
+        those: Split,
+        declaredVars: Set[Var],
+        shouldReportDiscarded: Bool,
+    )(implicit
         scope: Scope,
         context: Context,
     ): Split =
@@ -122,44 +128,47 @@ trait Normalization { self: Desugarer with Traceable =>
       scope: Scope,
       context: Context,
   ): Term = trace(s"normalizeToTerm <== ${showSplit(split)}") {
+    normalizeToTermImpl(split, declaredVars)
+  }(split => "normalizeToTerm ==> " + showNormalizedTerm(split))
+
+  private def normalizeToTermImpl(split: Split, declaredVars: Set[Var])(implicit
+      scope: Scope,
+      context: Context,
+  ): Term =
     split match {
-      case Split.Cons(Branch(scrutinee, Pattern.Name(nme), continuation), tail) =>
-        println(s"ALIAS: ${scrutinee.name} is ${nme.name}")
-        val (wrap, realTail) = preventShadowing(nme, tail)
-        wrap(Let(false, nme, scrutinee, normalizeToTerm(continuation.fill(realTail, declaredVars, true), declaredVars)))
-      // Skip Boolean conditions as scrutinees, because they only appear once.
-      case Split.Cons(Branch(test, pattern @ Pattern.Class(nme @ Var("true"), _, _), continuation), tail) if context.isTestVar(test) =>
-        println(s"TRUE: ${test.name} is true")
-        val trueBranch = normalizeToTerm(continuation.fill(tail, declaredVars, false), declaredVars)
-        val falseBranch = normalizeToCaseBranches(tail, declaredVars)
-        CaseOf(test, Case(nme, trueBranch, falseBranch)(refined = false))
-      case Split.Cons(Branch(Scrutinee.WithVar(scrutineeVar, scrutinee), pattern @ Pattern.Literal(literal), continuation), tail) =>
-        println(s"LITERAL: ${scrutineeVar.name} is ${literal.idStr}")
-        println(s"entire split: ${showSplit(split)}")
-        val concatenatedTrueBranch = continuation.fill(tail, declaredVars, false)
-        // println(s"true branch: ${showSplit(concatenatedTrueBranch)}")
-        val trueBranch = normalizeToTerm(specialize(concatenatedTrueBranch, true, scrutineeVar, scrutinee, pattern), declaredVars)
-        // println(s"false branch: ${showSplit(tail)}")
-        val falseBranch = normalizeToCaseBranches(specialize(tail, false, scrutineeVar, scrutinee, pattern), declaredVars)
-        CaseOf(scrutineeVar, Case(literal, trueBranch, falseBranch)(refined = false))
-      case Split.Cons(Branch(Scrutinee.WithVar(scrutineeVar, scrutinee), pattern @ Pattern.Class(nme, _, rfd), continuation), tail) =>
-        println(s"CLASS: ${scrutineeVar.name} is ${nme.name}")
-        // println(s"match ${scrutineeVar.name} with $nme (has location: ${nme.toLoc.isDefined})")
-        val trueBranch = normalizeToTerm(specialize(continuation.fill(tail, declaredVars, false), true, scrutineeVar, scrutinee, pattern), declaredVars)
-        val falseBranch = normalizeToCaseBranches(specialize(tail, false, scrutineeVar, scrutinee, pattern), declaredVars)
-        CaseOf(scrutineeVar, Case(nme, trueBranch, falseBranch)(refined = pattern.refined))
-      case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
-        raiseDesugaringError(msg"unsupported pattern: ${pattern.toString}" -> pattern.toLoc)
-        errorTerm
+      case Split.Cons(head, tail) =>
+        head match {
+          case Branch(scrutinee, Pattern.Name(nme), _) =>
+            println(s"ALIAS: ${scrutinee.name} is ${nme.name}")
+            val (wrap, realTail) = preventShadowing(nme, tail)
+            val continuation = head.continuation.fill(realTail, declaredVars, true)
+            wrap(Let(false, nme, scrutinee, normalizeToTermImpl(continuation, declaredVars)))
+          // Skip Boolean conditions as scrutinees, because they only appear once.
+          case Branch(test, pattern @ Pattern.Class(nme @ Var("true"), _, _), _) if context.isTestVar(test) =>
+            println(s"TRUE: ${test.name} is true")
+            val continuation = head.continuation.fill(tail, declaredVars, false)
+            val whenTrue = normalizeToTerm(continuation, declaredVars)
+            val whenFalse = normalizeToCaseBranches(tail, declaredVars)
+            CaseOf(test, Case(nme, whenTrue, whenFalse)(refined = false))
+          case Branch(Scrutinee.WithVar(scrutineeVar, scrutinee), pattern @ (Pattern.Literal(_) | Pattern.Class(_, _, _)), _) =>
+            println(s"CONS: ${scrutineeVar.name} is $pattern")
+            val continuation = head.continuation.fill(tail, declaredVars, false)
+            val whenTrue = normalizeToTerm(specialize(continuation, +, scrutineeVar, scrutinee, pattern), declaredVars)
+            val whenFalse = normalizeToCaseBranches(specialize(tail, `-`(head.continuation.isFull), scrutineeVar, scrutinee, pattern).clearFallback(), declaredVars)
+            CaseOf(scrutineeVar, Case(pattern.toSimpleTerm, whenTrue, whenFalse)(refined = pattern.refined))
+          case Branch(scrutinee, pattern, _) =>
+            raiseDesugaringError(msg"unsupported pattern matching: ${scrutinee.name} is ${pattern.toString}" -> pattern.toLoc)
+            errorTerm
+        }
       case Split.Let(_, nme, _, tail) if context.isScrutineeVar(nme) && declaredVars.contains(nme) =>
         println(s"LET: SKIP already declared scrutinee ${nme.name}")
-        normalizeToTerm(tail, declaredVars)
+        normalizeToTermImpl(tail, declaredVars)
       case Split.Let(rec, nme, rhs, tail) if context.isGeneratedVar(nme) =>
         println(s"LET: generated ${nme.name}")
-        Let(rec, nme, rhs, normalizeToTerm(tail, declaredVars + nme)(scope, context))
+        Let(rec, nme, rhs, normalizeToTermImpl(tail, declaredVars + nme)(scope, context))
       case Split.Let(rec, nme, rhs, tail) =>
         println(s"LET: ${nme.name}")
-        Let(rec, nme, rhs, normalizeToTerm(tail, declaredVars))
+        Let(rec, nme, rhs, normalizeToTermImpl(tail, declaredVars))
       case Split.Else(default) =>
         println(s"DFLT: ${default.showDbg}")
         default
@@ -167,7 +176,6 @@ trait Normalization { self: Desugarer with Traceable =>
         // raiseDesugaringError(msg"unexpected empty split found" -> N)
         errorTerm
     }
-  }(split => "normalizeToTerm ==> " + showNormalizedTerm(split))
 
   private def normalizeToCaseBranches(split: Split, declaredVars: Set[Var])(implicit
       scope: Scope,
@@ -199,94 +207,103 @@ trait Normalization { self: Desugarer with Traceable =>
     */
   private def specialize(
       split: Split,
-      matchOrNot: Bool,
+      mode: Mode,
       scrutineeVar: Var,
       scrutinee: Scrutinee,
       pattern: Pattern
   )(implicit context: Context): Split = 
-    trace(s"S${if (matchOrNot) "+" else "-"} <== ${scrutineeVar.name} is ${pattern} : ${showSplit(split, true)}"){
-      val specialized = specializeImpl(split)(matchOrNot, scrutineeVar, scrutinee, pattern, context)
+    trace(s"S$mode <== ${scrutineeVar.name} is ${pattern} : ${showSplit(split, true)}"){
+      val specialized = specializeImpl(split)(mode, scrutineeVar, scrutinee, pattern, context)
       // if (split =/= Split.Nil && specialized === Split.Nil && !split.isFallback) {
       //   raiseDesugaringWarning(msg"the case is unreachable" -> split.toLoc)
       // }
       specialized
-    }(r => s"S${if (matchOrNot) "+" else "-"} ==> ${showSplit(r, true)}")
+    }(r => s"S$mode ==> ${showSplit(r, true)}")
 
-  /** This function does not trace. Call it when handling `tail`s. */
+  /**
+   * This function does not trace. Call it when handling `tail`s, so we can get
+   * flattened debug logs.
+   * @param keepOrRemove `N` if S+ or `S(...)` if S-. If we don't need to track
+   *                     duplication information, this parameter can be denoted
+   *                     by just a Boolean variable.
+   */
   private def specializeImpl(split: Split)(implicit
-      keepOrRemove: Bool,
+      mode: Mode,
       scrutineeVar: Var,
       scrutinee: Scrutinee,
       pattern: Pattern,
-      context: Context): Split =split match {
+      context: Context): Split = split match {
     case split @ Split.Cons(head, tail) =>
       println(s"CASE Cons ${head.showDbg}")
-      lazy val continuation = specialize(head.continuation, keepOrRemove, scrutineeVar, scrutinee, pattern)
+      lazy val continuation = specialize(head.continuation, mode, scrutineeVar, scrutinee, pattern)
       head match {
-        case Branch(otherScrutineeVar, Pattern.Name(alias), _) =>
-          Split.Let(false, alias, otherScrutineeVar, continuation)
+        case Branch(thatScrutineeVar, Pattern.Name(alias), _) =>
+          Split.Let(false, alias, thatScrutineeVar, continuation)
         case Branch(test, Pattern.Class(Var("true"), _, _), _) if context.isTestVar(test) =>
           head.copy(continuation = continuation) :: specializeImpl(tail)
-        case Branch(Scrutinee.WithVar(otherScrutineeVar, otherScrutinee), otherPattern, _) =>
-          if (scrutinee === otherScrutinee) {
-            if (keepOrRemove) {
-              println(s"Case 1.1: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
-              if (otherPattern =:= pattern) {
-                println(s"Case 1.1.1: $pattern =:= $otherPattern")
-                otherPattern reportInconsistentRefinedWith pattern
+        case Branch(Scrutinee.WithVar(thatScrutineeVar, thatScrutinee), thatPattern, _) =>
+          if (scrutinee === thatScrutinee) mode match {
+            case + =>
+              println(s"Case 1.1: ${scrutineeVar.name} === ${thatScrutineeVar.name}")
+              if (thatPattern =:= pattern) {
+                println(s"Case 1.1.1: $pattern =:= $thatPattern")
+                thatPattern reportInconsistentRefinedWith pattern
                 continuation :++ specializeImpl(tail)
-              } else if (otherPattern <:< pattern) {
-                println(s"Case 1.1.2: $pattern <:< $otherPattern")
+              } else if (thatPattern <:< pattern) {
+                println(s"Case 1.1.2: $pattern <:< $thatPattern")
                 pattern.markAsRefined; split
               } else {
-                println(s"Case 1.1.3: $pattern is unrelated with $otherPattern")
-                // The `continuation` is discarded because `otherPattern` is unrelated
+                println(s"Case 1.1.3: $pattern is unrelated with $thatPattern")
+                // The `continuation` is discarded because `thatPattern` is unrelated
                 // to the specialization topic.
                 if (!split.isFallback) {
                   println(s"report warning")
-                  if (pattern <:< otherPattern) {
+                  if (pattern <:< thatPattern) {
                     raiseDesugaringWarning(
-                      msg"the pattern always matches" -> otherPattern.toLoc,
+                      msg"the pattern always matches" -> thatPattern.toLoc,
                       msg"the scrutinee was matched against ${pattern.toString}" -> pattern.toLoc,
-                      msg"which is a subtype of ${otherPattern.toString}" -> (pattern match {
+                      msg"which is a subtype of ${thatPattern.toString}" -> (pattern match {
                         case Pattern.Class(_, symbol, _) => symbol.defn.toLoc
-                        case _ => otherPattern.getLoc
+                        case _ => thatPattern.getLoc
                       }))
                     continuation :++ specializeImpl(tail)
                   } else {
                     raiseDesugaringWarning(
-                      msg"possibly conflicted patterns" -> otherPattern.toLoc,
+                      msg"possibly conflicted patterns" -> thatPattern.toLoc,
                       msg"the scrutinee was matched against ${pattern.toString}" -> pattern.toLoc,
-                      msg"which is unrelated with ${otherPattern.toString}" -> otherPattern.toLoc)
+                      msg"which is unrelated with ${thatPattern.toString}" -> thatPattern.toLoc)
                     specializeImpl(tail)
                   }
                 } else {
                   specializeImpl(tail)
                 }
               }
-            } else {
-              println(s"Case 1.2: ${scrutineeVar.name} === ${otherScrutineeVar.name}")
-              otherPattern reportInconsistentRefinedWith pattern
-              if (otherPattern =:= pattern || otherPattern <:< pattern) {
-                println(s"Case 1.2.1: $pattern =:= (or <:<) $otherPattern")
-                // The `continuation` is discarded because `otherPattern` is related
+            case -(full) =>
+              println(s"Case 1.2: ${scrutineeVar.name} === ${thatScrutineeVar.name}")
+              thatPattern reportInconsistentRefinedWith pattern
+              val samePattern = thatPattern =:= pattern
+              if (samePattern || thatPattern <:< pattern) {
+                println(s"Case 1.2.1: $pattern =:= (or <:<) $thatPattern")
+                // The `continuation` is discarded because `thatPattern` is related
                 // to the specialization topic.
-                // println(s"is fallback = ${split.isFallback}")
-                // if (!split.isFallback) {
-                //   println(s"report warning")
-                //   raiseDesugaringWarning(
-                //     msg"possibly duplicated cases" -> otherPattern.toLoc,
-                //     msg"the case can be covered by ${pattern.toString}" -> pattern.toLoc,
-                //   )
-                // }
-                specializeImpl(tail)
+                println(s"`${thatScrutineeVar.name} is ${thatPattern}` is${if (split.isFallback) " " else " not "}fallback")
+                println(s"already removed = $full")
+                if (!split.isFallback && full && !head.continuation.isEmpty) {
+                  println(s"report warning")
+                  raiseDesugaringWarning(
+                    msg"found a duplicated case" -> thatPattern.toLoc,
+                    msg"the case is covered by pattern ${pattern.toString}" -> pattern.toLoc,
+                  )
+                }
+                specializeImpl(tail)(
+                  `-`(if (samePattern) continuation.isFull else full),
+                  scrutineeVar, scrutinee, pattern, context)
               } else {
-                println(s"Case 1.2.2: $pattern are unrelated with $otherPattern")
+                println(s"Case 1.2.2: $pattern are unrelated with $thatPattern")
                 split.copy(tail = specializeImpl(tail))
               }
-            }
           } else {
-            println(s"Case 2: ${scrutineeVar.name} =/= ${otherScrutineeVar.name}")
+            println(s"Case 2: ${scrutineeVar.name} =/= ${thatScrutineeVar.name}")
             head.copy(continuation = continuation) :: specializeImpl(tail)
           }
         case _ =>
@@ -315,3 +332,14 @@ trait Normalization { self: Desugarer with Traceable =>
     case S(_) | N => identity[Term] _ -> tail
   }
 }
+
+object Normalization {
+  /** Specialization mode */
+  sealed abstract class Mode
+  final case object + extends Mode {
+    override def toString(): String = "+"
+  }
+  final case class -(full: Bool) extends Mode {
+    override def toString(): String = s"-($full)"
+  }
+}
diff --git a/shared/src/main/scala/mlscript/ucs/syntax/core.scala b/shared/src/main/scala/mlscript/ucs/syntax/core.scala
index c752e624ab..403ea2f892 100644
--- a/shared/src/main/scala/mlscript/ucs/syntax/core.scala
+++ b/shared/src/main/scala/mlscript/ucs/syntax/core.scala
@@ -1,10 +1,18 @@
 package mlscript
-package ucs.syntax
+package ucs
+package syntax
 
-import utils._, shorthands._, pretyper.symbol.ClassLikeSymbol
+import collection.mutable.{Set => MutSet}
+import utils._, shorthands._, pretyper.symbol.ClassLikeSymbol, context.Scrutinee
 
 package object core {
   sealed abstract class Pattern extends Located {
+    def refined: Bool
+    def toSimpleTerm: SimpleTerm = this match {
+      case Pattern.Literal(literal) => literal
+      case Pattern.Class(nme, _, _) => nme
+      case Pattern.Name(_) => die
+    }
     def declaredVars: Iterator[Var] = this match {
       case _: Pattern.Literal | _: Pattern.Class => Iterator.empty
       case Pattern.Name(nme) => Iterator.single(nme)
@@ -17,9 +25,11 @@ package object core {
   }
   object Pattern {
     final case class Literal(literal: Lit) extends Pattern {
+      override def refined: Bool = false
       override def children: Ls[Located] = literal :: Nil
     }
     final case class Name(nme: Var) extends Pattern {
+      override def refined: Bool = false
       override def children: Ls[Located] = nme :: Nil
     }
     /**
@@ -47,7 +57,11 @@ package object core {
   }
 
   sealed abstract class Split extends Located {
-    @inline def ::(head: Branch): Split = Split.Cons(head, this)
+    @inline def ::(head: Branch): Split = {
+      val res = Split.Cons(head, this)
+      // res.withFallbackOf(head.continuation)
+      if (head.continuation.isFallback) res.markAsFallback() else res
+    }
     
     /**
       * Returns true if the split has an else branch.
@@ -59,6 +73,12 @@ package object core {
       case Split.Nil => false
     }
 
+    lazy val isEmpty: Bool = this match {
+      case Split.Let(_, _, _, tail) => tail.isEmpty
+      case Split.Else(_) | Split.Cons(_, _) => false
+      case Split.Nil => true
+    }
+
     override lazy val freeVars: Set[Var] = this match {
       case Split.Cons(Branch(scrutinee, pattern, continuation), tail) =>
         continuation.freeVars ++ tail.freeVars
@@ -90,12 +110,17 @@ package object core {
     // single run of specialization. The flag is useless outside specialization
     // functions.
 
+    /**
+     * The split is concatenated as a fallback when specializing the given
+     * scrutinee and pattern.
+     */
+
     private var _fallback: Bool = false
 
     def isFallback: Bool = _fallback
 
     def markAsFallback(): this.type = {
-      _fallback = true;
+      _fallback = true
       this match {
         case Split.Cons(head, tail) =>
           head.continuation.markAsFallback()
@@ -105,6 +130,43 @@ package object core {
       }
       this
     }
+
+    def clearFallback(): this.type = {
+      _fallback = false
+      this match {
+        case Split.Cons(head, tail) =>
+          head.continuation.clearFallback()
+          tail.clearFallback()
+        case Split.Let(_, _, _, tail) => tail.clearFallback()
+        case _: Split.Else | Split.Nil => ()
+      }
+      this
+    }
+
+    // private val _fallbackSource = MutSet.empty[(Scrutinee, Pattern)]
+
+    // def isFallbackOf(scrutinee: Scrutinee, pattern: Pattern): Bool =
+    //   _fallbackSource.contains((scrutinee, pattern))
+
+    // def markAsFallback(target: Opt[(Scrutinee, Pattern)]): this.type =
+    //   target.fold[this.type](this)(this.markAsFallback)
+
+    // def markAsFallback(target: (Scrutinee, Pattern)): this.type = {
+    //   _fallbackSource += target
+    //   this match {
+    //     case Split.Cons(head, tail) =>
+    //       head.continuation.markAsFallback(target)
+    //       tail.markAsFallback(target)
+    //     case Split.Let(_, _, _, tail) => tail.markAsFallback(target)
+    //     case _: Split.Else | Split.Nil => ()
+    //   }
+    //   this
+    // }
+
+    // def withFallbackOf(that: Split): this.type = {
+    //   _fallbackSource ++= that._fallbackSource
+    //   this
+    // }
   }
 
   object Split {
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/CoveredCases.mls b/shared/src/test/diff/pretyper/ucs/coverage/CoveredCases.mls
index 12119e25a3..cfccce1f98 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/CoveredCases.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/CoveredCases.mls
@@ -12,8 +12,13 @@ class B() extends A()
 fun f(x) = if
   x is A then 1
   x is A then 2
+//│ ╔══[WARNING] found a duplicated case
+//│ ║  l.14: 	  x is A then 2
+//│ ║        	       ^
+//│ ╟── the case is covered by pattern A
+//│ ║  l.13: 	  x is A then 1
+//│ ╙──      	       ^
 //│ fun f: A -> 1
-//│ TEST CASE FAILURE: There was an unexpected lack of warning
 
 :w
 :ducs:normalize.result
@@ -23,8 +28,13 @@ fun f(x) = if
 //│ Normalized UCS term:
 //│ case x*‡ of
 //│   A*◊ -> 1
+//│ ╔══[WARNING] found a duplicated case
+//│ ║  l.27: 	  x is B then 2
+//│ ║        	       ^
+//│ ╟── the case is covered by pattern A
+//│ ║  l.26: 	  x is A then 1
+//│ ╙──      	       ^
 //│ fun f: A -> 1
-//│ TEST CASE FAILURE: There was an unexpected lack of warning
 
 :ducs:normalize.result
 fun f(x) = if
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/DuplicatedCases.mls b/shared/src/test/diff/pretyper/ucs/coverage/DuplicatedCases.mls
index 3fd1bb8c4a..97509585df 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/DuplicatedCases.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/DuplicatedCases.mls
@@ -14,8 +14,13 @@ fun f(x) = if x is
 //│   _ ->
 //│     case x*‡ of
 //│       "b" -> 2
+//│ ╔══[WARNING] found a duplicated case
+//│ ║  l.10: 	  "a" then 3
+//│ ║        	  ^^^
+//│ ╟── the case is covered by pattern "a"
+//│ ║  l.8: 	  "a" then 1
+//│ ╙──     	  ^^^
 //│ fun f: ("a" | "b") -> (1 | 2)
-//│ TEST CASE FAILURE: There was an unexpected lack of warning
 
 class X
 class Y
@@ -34,8 +39,13 @@ fun f(x) = if x is
 //│ Normalized UCS term:
 //│ case x*‡ of
 //│   X*◊ -> 1
+//│ ╔══[WARNING] found a duplicated case
+//│ ║  l.38: 	  X then 2
+//│ ║        	  ^
+//│ ╟── the case is covered by pattern X
+//│ ║  l.37: 	  X then 1
+//│ ╙──      	  ^
 //│ fun f: X -> 1
-//│ TEST CASE FAILURE: There was an unexpected lack of warning
 
 :w
 :ducs:normalize.result
@@ -49,121 +59,21 @@ fun f(x) = if x is
 //│   _ ->
 //│     case x*‡ of
 //│       Y*◊ -> 2
+//│ ╔══[WARNING] found a duplicated case
+//│ ║  l.55: 	  X then 3
+//│ ║        	  ^
+//│ ╟── the case is covered by pattern X
+//│ ║  l.53: 	  X then 1
+//│ ╙──      	  ^
 //│ fun f: (X | Y) -> (1 | 2)
-//│ TEST CASE FAILURE: There was an unexpected lack of warning
 
 class Box[T](value: T)
 //│ class Box[T](value: T)
 
-:ducs:normalize,normalize.result
+:ducs:normalize.result
 fun f(x) = if x is
   Box(1) then true
   Box then false
-//│ | | | | | STEP 2
-//│ | | | | | normalizeToTerm <== if
-//│ | | | | |   x*‡ is Box
-//│ | | | | |     let ucs$args_x$Box*† = (Box).unapply(x,)
-//│ | | | | |     let x$Box_0*‡ = (ucs$args_x$Box).0
-//│ | | | | |     x$Box_0*‡ is 1 then true
-//│ | | | | |   x*‡ is Box then false
-//│ | | | | | | CLASS: x is Box
-//│ | | | | | | fill <== vars = {}
-//│ | | | | | | | LHS: if
-//│ | | | | | | |   let ucs$args_x$Box*† = (Box).unapply(x,)
-//│ | | | | | | |   let x$Box_0*‡ = (ucs$args_x$Box).0
-//│ | | | | | | |   x$Box_0*‡ is 1 then true
-//│ | | | | | | | RHS: if x*‡ is Box then false
-//│ | | | | | | | fill let binding ucs$args_x$Box
-//│ | | | | | | | fill let binding x$Box_0
-//│ | | | | | | fill ==> if
-//│ | | | | | |   let ucs$args_x$Box*† = (Box).unapply(x,)
-//│ | | | | | |   let x$Box_0*‡ = (ucs$args_x$Box).0
-//│ | | | | | |   x$Box_0*‡ is 1 then true
-//│ | | | | | |   x*‡ is Box then false
-//│ | | | | | | S+ <== x is Box : if
-//│ | | | | | |   let ucs$args_x$Box*† = (Box).unapply(x,)
-//│ | | | | | |   let x$Box_0*‡ = (ucs$args_x$Box).0
-//│ | | | | | |   x$Box_0*‡ is 1 then ...
-//│ | | | | | |   x*‡ is Box then ...
-//│ | | | | | | | CASE Let ucs$args_x$Box
-//│ | | | | | | | CASE Let x$Box_0
-//│ | | | | | | | CASE Cons x$Box_0 is 1
-//│ | | | | | | | Case 2: x =/= x$Box_0
-//│ | | | | | | | S+ <== x is Box : if then true
-//│ | | | | | | | | CASE Else
-//│ | | | | | | | S+ ==> if then true
-//│ | | | | | | | CASE Cons x is Box
-//│ | | | | | | | Case 1.1: x === x
-//│ | | | | | | | Case 1.1.1: Box =:= Box
-//│ | | | | | | | S+ <== x is Box : if then false
-//│ | | | | | | | | CASE Else
-//│ | | | | | | | S+ ==> if then false
-//│ | | | | | | | tail is discarded
-//│ | | | | | | S+ ==> if
-//│ | | | | | |   let ucs$args_x$Box*† = (Box).unapply(x,)
-//│ | | | | | |   let x$Box_0*‡ = (ucs$args_x$Box).0
-//│ | | | | | |   x$Box_0*‡ is 1 then ...
-//│ | | | | | |   else false
-//│ | | | | | | normalizeToTerm <== if
-//│ | | | | | |   let ucs$args_x$Box*† = (Box).unapply(x,)
-//│ | | | | | |   let x$Box_0*‡ = (ucs$args_x$Box).0
-//│ | | | | | |   x$Box_0*‡ is 1 then true
-//│ | | | | | |   else false
-//│ | | | | | | | LET: generated ucs$args_x$Box
-//│ | | | | | | | normalizeToTerm <== if
-//│ | | | | | | |   let x$Box_0*‡ = (ucs$args_x$Box).0
-//│ | | | | | | |   x$Box_0*‡ is 1 then true
-//│ | | | | | | |   else false
-//│ | | | | | | | | LET: x$Box_0
-//│ | | | | | | | | normalizeToTerm <== if
-//│ | | | | | | | |   x$Box_0*‡ is 1 then true
-//│ | | | | | | | |   else false
-//│ | | | | | | | | | LITERAL: x$Box_0 is 1
-//│ | | | | | | | | | entire split: if
-//│ | | | | | | | | |   x$Box_0*‡ is 1 then true
-//│ | | | | | | | | |   else false
-//│ | | | | | | | | | fill <== vars = {ucs$args_x$Box}
-//│ | | | | | | | | | | LHS: if then true
-//│ | | | | | | | | | | RHS: if then false
-//│ | | | | | | | | | fill ==> if then true
-//│ | | | | | | | | | S+ <== x$Box_0 is 1 : if then true
-//│ | | | | | | | | | | CASE Else
-//│ | | | | | | | | | S+ ==> if then true
-//│ | | | | | | | | | normalizeToTerm <== if then true
-//│ | | | | | | | | | | DFLT: true
-//│ | | | | | | | | | normalizeToTerm ==> true
-//│ | | | | | | | | | S- <== x$Box_0 is 1 : if then false
-//│ | | | | | | | | | | CASE Else
-//│ | | | | | | | | | S- ==> if then false
-//│ | | | | | | | | | normalizeToCaseBranches <==
-//│ | | | | | | | | | normalizeToCaseBranches ==>
-//│ | | | | | | | | normalizeToTerm ==> case x$Box_0*‡ of
-//│ | | | | | | | |   1 -> true
-//│ | | | | | | | |   _ -> false
-//│ | | | | | | | normalizeToTerm ==> let x$Box_0*‡ = (ucs$args_x$Box).0
-//│ | | | | | | | case x$Box_0*‡ of
-//│ | | | | | | |   1 -> true
-//│ | | | | | | |   _ -> false
-//│ | | | | | | normalizeToTerm ==> let ucs$args_x$Box*† = (Box).unapply(x,)
-//│ | | | | | | let x$Box_0*‡ = (ucs$args_x$Box).0
-//│ | | | | | | case x$Box_0*‡ of
-//│ | | | | | |   1 -> true
-//│ | | | | | |   _ -> false
-//│ | | | | | | S- <== x is Box : if x*‡ is Box then ...
-//│ | | | | | | | CASE Cons x is Box
-//│ | | | | | | | Case 1.2: x === x
-//│ | | | | | | | Case 1.2.1: Box =:= (or <:<) Box
-//│ | | | | | | | CASE Nil
-//│ | | | | | | S- ==> if
-//│ | | | | | | normalizeToCaseBranches <==
-//│ | | | | | | normalizeToCaseBranches ==>
-//│ | | | | | normalizeToTerm ==> case x*‡ of
-//│ | | | | |   Box*◊ ->
-//│ | | | | |     let ucs$args_x$Box*† = (Box).unapply(x,)
-//│ | | | | |     let x$Box_0*‡ = (ucs$args_x$Box).0
-//│ | | | | |     case x$Box_0*‡ of
-//│ | | | | |       1 -> true
-//│ | | | | |       _ -> false
 //│ Normalized UCS term:
 //│ case x*‡ of
 //│   Box*◊ ->
@@ -181,3 +91,622 @@ f(Box(1))
 //│     = false
 //│ res
 //│     = true
+
+:ducs:postprocess.result
+fun a_tale_of_scrutinees(x, y) =
+  if
+    x is "A" and y is "B" then "AB"
+    y is "A" and x is "B" then "BA"
+    y is "A" and x is "A" then "AA"
+    x is "B" and y is "B" then "BB"
+//│ Post-processed UCS term:
+//│ case x*‡ of
+//│   "A" ->
+//│     case y*‡ of
+//│       "B" -> "AB"
+//│       "A" -> "AA"
+//│   "B" ->
+//│     case y*‡ of
+//│       "A" -> "BA"
+//│       "B" -> "BB"
+//│ fun a_tale_of_scrutinees: ("A" | "B", "A" | "B") -> ("AA" | "AB" | "BA" | "BB")
+
+:ducs:normalize.result
+fun test(x, p) = if x is
+  Bool and p(x) then "great"
+  true then "false"
+  false then "true"
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   refined Bool*◊ ->
+//│     let ucs$test$0*† = p(x,) : Bool
+//│     case ucs$test$0*† of
+//│       true*† -> "great"
+//│       _ ->
+//│         case x*‡ of
+//│           true*† -> "false"
+//│           _ ->
+//│             case x*‡ of
+//│               false*† -> "true"
+//│ fun test: forall 'a. ('a & Bool, (Bool & 'a) -> Bool) -> ("false" | "great" | "true")
+
+class P[A](x: A)
+class Q[A, B](x: A, y: B)
+//│ class P[A](x: A)
+//│ class Q[A, B](x: A, y: B)
+
+fun f(x) =
+  if x is
+    P(1) then 1
+    P(y) then 2
+//│ fun f: P[Object] -> (1 | 2)
+
+:ducs:normalize.result
+fun f(x) =
+  if x is
+    Q(a, b) and a is 1 and b is 1 then 1
+    Q(a, b) and b is 1 then 2
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   Q*◊ ->
+//│     let ucs$args_x$Q*† = (Q).unapply(x,)
+//│     let a*‡ = (ucs$args_x$Q).0
+//│     let b*‡ = (ucs$args_x$Q).1
+//│     case a*‡ of
+//│       1 ->
+//│         case b*‡ of
+//│           1 -> 1
+//│       _ ->
+//│         case b*‡ of
+//│           1 -> 2
+//│ fun f: Q[Object, 1] -> (1 | 2)
+
+:e
+fun f(x) =
+  if x is
+    Q(a, b) and a is 1 and b is 2 then 1
+    Q(a, b) and b is 1 then 2
+//│ ╔══[ERROR] when `x` is `Q`
+//│ ║  l.167: 	    Q(a, b) and a is 1 and b is 2 then 1
+//│ ║         	    ^
+//│ ╟── the second argument of `Q` has 1 missing case
+//│ ║  l.168: 	    Q(a, b) and b is 1 then 2
+//│ ║         	                ^
+//│ ╟── it can be literal 2
+//│ ║  l.167: 	    Q(a, b) and a is 1 and b is 2 then 1
+//│ ╙──       	                                ^
+//│ fun f: Q[Object, 1] -> (1 | 2)
+
+:ducs:normalize.result
+fun f(x) =
+  if x is
+    Q(1, 1) then 1
+    Q(y, 1) then 2
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   Q*◊ ->
+//│     let ucs$args_x$Q*† = (Q).unapply(x,)
+//│     let x$Q_0*‡ = (ucs$args_x$Q).0
+//│     let x$Q_1*‡ = (ucs$args_x$Q).1
+//│     case x$Q_0*‡ of
+//│       1 ->
+//│         case x$Q_1*‡ of
+//│           1 -> 1
+//│           _ -> (ucs$args_x$Q).0
+//│       _ ->
+//│         let y*‡ = (ucs$args_x$Q).0
+//│         case x$Q_1*‡ of
+//│           1 -> 2
+//│ fun f: forall 'a. Q[Object & 'a, 1] -> (1 | 2 | 'a)
+
+:ducs:normalize
+fun f(x) =
+  if x is
+    Q(0, 0) then 1
+    Q(1, 1) then 2
+    Q(y, 1) then 3
+    _       then 4
+//│ | | | | | | | STEP 2
+//│ | | | | | | | normalizeToTerm <== if
+//│ | | | | | | |   x*‡ is Q
+//│ | | | | | | |     let ucs$args_x$Q*† = (Q).unapply(x,)
+//│ | | | | | | |     let x$Q_0*‡ = (ucs$args_x$Q).0
+//│ | | | | | | |     let x$Q_1*‡ = (ucs$args_x$Q).1
+//│ | | | | | | |     x$Q_0*‡ is 0 x$Q_1*‡ is 0 then 1
+//│ | | | | | | |   x*‡ is Q
+//│ | | | | | | |     let ucs$args_x$Q*† = (Q).unapply(x,)
+//│ | | | | | | |     let x$Q_0*‡ = (ucs$args_x$Q).0
+//│ | | | | | | |     let x$Q_1*‡ = (ucs$args_x$Q).1
+//│ | | | | | | |     x$Q_0*‡ is 1 x$Q_1*‡ is 1 then 2
+//│ | | | | | | |   x*‡ is Q
+//│ | | | | | | |     let ucs$args_x$Q*† = (Q).unapply(x,)
+//│ | | | | | | |     let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | |     let x$Q_1*‡ = (ucs$args_x$Q).1
+//│ | | | | | | |     x$Q_1*‡ is 1 then 3
+//│ | | | | | | |   else 4
+//│ | | | | | | | | CONS: x is Q
+//│ | | | | | | | | fill <== vars = {}
+//│ | | | | | | | | | LHS: if
+//│ | | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
+//│ | | | | | | | | |   let x$Q_0*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
+//│ | | | | | | | | |   x$Q_0*‡ is 0 x$Q_1*‡ is 0 then 1
+//│ | | | | | | | | | RHS: if
+//│ | | | | | | | | |   x*‡ is Q
+//│ | | | | | | | | |     let ucs$args_x$Q*† = (Q).unapply(x,)
+//│ | | | | | | | | |     let x$Q_0*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | |     let x$Q_1*‡ = (ucs$args_x$Q).1
+//│ | | | | | | | | |     x$Q_0*‡ is 1 x$Q_1*‡ is 1 then 2
+//│ | | | | | | | | |   x*‡ is Q
+//│ | | | | | | | | |     let ucs$args_x$Q*† = (Q).unapply(x,)
+//│ | | | | | | | | |     let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | |     let x$Q_1*‡ = (ucs$args_x$Q).1
+//│ | | | | | | | | |     x$Q_1*‡ is 1 then 3
+//│ | | | | | | | | |   else 4
+//│ | | | | | | | | | fill let binding ucs$args_x$Q
+//│ | | | | | | | | | fill let binding x$Q_0
+//│ | | | | | | | | | fill let binding x$Q_1
+//│ | | | | | | | | fill ==> if
+//│ | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
+//│ | | | | | | | |   let x$Q_0*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
+//│ | | | | | | | |   x$Q_0*‡ is 0 x$Q_1*‡ is 0 then 1
+//│ | | | | | | | |   ?x*‡ is Q ?x$Q_0*‡ is 1 ?x$Q_1*‡ is 1 then 2
+//│ | | | | | | | |   ?x*‡ is Q
+//│ | | | | | | | |     let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | |     ?x$Q_1*‡ is 1 then 3
+//│ | | | | | | | |   else 4
+//│ | | | | | | | | S+ <== x is Q : if
+//│ | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
+//│ | | | | | | | |   let x$Q_0*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
+//│ | | | | | | | |   x$Q_0*‡ is 0 and ...
+//│ | | | | | | | |   ?x*‡ is Q and ...
+//│ | | | | | | | |   ?x*‡ is Q and ...
+//│ | | | | | | | |   else 4
+//│ | | | | | | | | | CASE Let ucs$args_x$Q
+//│ | | | | | | | | | CASE Let x$Q_0
+//│ | | | | | | | | | CASE Let x$Q_1
+//│ | | | | | | | | | CASE Cons x$Q_0 is 0
+//│ | | | | | | | | | Case 2: x =/= x$Q_0
+//│ | | | | | | | | | S+ <== x is Q : if x$Q_1*‡ is 0 then ...
+//│ | | | | | | | | | | CASE Cons x$Q_1 is 0
+//│ | | | | | | | | | | Case 2: x =/= x$Q_1
+//│ | | | | | | | | | | S+ <== x is Q : if then 1
+//│ | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | S+ ==> if then 1
+//│ | | | | | | | | | | CASE Nil
+//│ | | | | | | | | | S+ ==> if x$Q_1*‡ is 0 then ...
+//│ | | | | | | | | | CASE Cons x is Q
+//│ | | | | | | | | | Case 1.1: x === x
+//│ | | | | | | | | | Case 1.1.1: Q =:= Q
+//│ | | | | | | | | | S+ <== x is Q : if ?x$Q_0*‡ is 1 and ...
+//│ | | | | | | | | | | CASE Cons x$Q_0 is 1
+//│ | | | | | | | | | | Case 2: x =/= x$Q_0
+//│ | | | | | | | | | | S+ <== x is Q : if ?x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | | | | CASE Cons x$Q_1 is 1
+//│ | | | | | | | | | | | Case 2: x =/= x$Q_1
+//│ | | | | | | | | | | | S+ <== x is Q : if then 2
+//│ | | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | | S+ ==> if then 2
+//│ | | | | | | | | | | | CASE Nil
+//│ | | | | | | | | | | S+ ==> if ?x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | | | CASE Nil
+//│ | | | | | | | | | S+ ==> if ?x$Q_0*‡ is 1 and ...
+//│ | | | | | | | | | CASE Cons x is Q
+//│ | | | | | | | | | Case 1.1: x === x
+//│ | | | | | | | | | Case 1.1.1: Q =:= Q
+//│ | | | | | | | | | S+ <== x is Q : if
+//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | | | CASE Let y
+//│ | | | | | | | | | | CASE Cons x$Q_1 is 1
+//│ | | | | | | | | | | Case 2: x =/= x$Q_1
+//│ | | | | | | | | | | S+ <== x is Q : if then 3
+//│ | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | S+ ==> if then 3
+//│ | | | | | | | | | | CASE Nil
+//│ | | | | | | | | | S+ ==> if
+//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | | CASE Else
+//│ | | | | | | | | S+ ==> if
+//│ | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
+//│ | | | | | | | |   let x$Q_0*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
+//│ | | | | | | | |   x$Q_0*‡ is 0 and ...
+//│ | | | | | | | |   x$Q_0*‡ is 1 and ...
+//│ | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | |   x$Q_1*‡ is 1 then ...
+//│ | | | | | | | |   else 4
+//│ | | | | | | | | normalizeToTerm <== if
+//│ | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
+//│ | | | | | | | |   let x$Q_0*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
+//│ | | | | | | | |   x$Q_0*‡ is 0 x$Q_1*‡ is 0 then 1
+//│ | | | | | | | |   x$Q_0*‡ is 1 ?x$Q_1*‡ is 1 then 2
+//│ | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | |   x$Q_1*‡ is 1 then 3
+//│ | | | | | | | |   else 4
+//│ | | | | | | | | | LET: generated ucs$args_x$Q
+//│ | | | | | | | | | LET: x$Q_0
+//│ | | | | | | | | | LET: x$Q_1
+//│ | | | | | | | | | CONS: x$Q_0 is 0
+//│ | | | | | | | | | fill <== vars = {ucs$args_x$Q}
+//│ | | | | | | | | | | LHS: if x$Q_1*‡ is 0 then 1
+//│ | | | | | | | | | | RHS: if
+//│ | | | | | | | | | |   x$Q_0*‡ is 1 ?x$Q_1*‡ is 1 then 2
+//│ | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | |   x$Q_1*‡ is 1 then 3
+//│ | | | | | | | | | |   else 4
+//│ | | | | | | | | | fill ==> if
+//│ | | | | | | | | |   x$Q_1*‡ is 0 then 1
+//│ | | | | | | | | |   ?x$Q_0*‡ is 1 ?x$Q_1*‡ is 1 then 2
+//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | |   ?x$Q_1*‡ is 1 then 3
+//│ | | | | | | | | |   else 4
+//│ | | | | | | | | | S+ <== x$Q_0 is 0 : if
+//│ | | | | | | | | |   x$Q_1*‡ is 0 then ...
+//│ | | | | | | | | |   ?x$Q_0*‡ is 1 and ...
+//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | |   else 4
+//│ | | | | | | | | | | CASE Cons x$Q_1 is 0
+//│ | | | | | | | | | | Case 2: x$Q_0 =/= x$Q_1
+//│ | | | | | | | | | | S+ <== x$Q_0 is 0 : if then 1
+//│ | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | S+ ==> if then 1
+//│ | | | | | | | | | | CASE Cons x$Q_0 is 1
+//│ | | | | | | | | | | Case 1.1: x$Q_0 === x$Q_0
+//│ | | | | | | | | | | Case 1.1.3: 0 is unrelated with 1
+//│ | | | | | | | | | | CASE Let y
+//│ | | | | | | | | | | CASE Cons x$Q_1 is 1
+//│ | | | | | | | | | | Case 2: x$Q_0 =/= x$Q_1
+//│ | | | | | | | | | | S+ <== x$Q_0 is 0 : if then 3
+//│ | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | S+ ==> if then 3
+//│ | | | | | | | | | | CASE Else
+//│ | | | | | | | | | S+ ==> if
+//│ | | | | | | | | |   x$Q_1*‡ is 0 then ...
+//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | |   else 4
+//│ | | | | | | | | | normalizeToTerm <== if
+//│ | | | | | | | | |   x$Q_1*‡ is 0 then 1
+//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | |   ?x$Q_1*‡ is 1 then 3
+//│ | | | | | | | | |   else 4
+//│ | | | | | | | | | | CONS: x$Q_1 is 0
+//│ | | | | | | | | | | fill <== vars = {ucs$args_x$Q}
+//│ | | | | | | | | | | | LHS: if then 1
+//│ | | | | | | | | | | | RHS: if
+//│ | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | | |   ?x$Q_1*‡ is 1 then 3
+//│ | | | | | | | | | | |   else 4
+//│ | | | | | | | | | | fill ==> if then 1
+//│ | | | | | | | | | | S+ <== x$Q_1 is 0 : if then 1
+//│ | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | S+ ==> if then 1
+//│ | | | | | | | | | | normalizeToTerm <== if then 1
+//│ | | | | | | | | | | | DFLT: 1
+//│ | | | | | | | | | | normalizeToTerm ==> 1
+//│ | | | | | | | | | | S-(true) <== x$Q_1 is 0 : if
+//│ | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | | |   else 4
+//│ | | | | | | | | | | | CASE Let y
+//│ | | | | | | | | | | | CASE Cons x$Q_1 is 1
+//│ | | | | | | | | | | | Case 1.2: x$Q_1 === x$Q_1
+//│ | | | | | | | | | | | Case 1.2.2: 0 are unrelated with 1
+//│ | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | S-(true) ==> if
+//│ | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | |   x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | | |   else 4
+//│ | | | | | | | | | | normalizeToCaseBranches <==
+//│ | | | | | | | | | | | normalizeToCaseBranches <==
+//│ | | | | | | | | | | | | normalizeToTerm <== if
+//│ | | | | | | | | | | | |   x$Q_1*‡ is 1 then 3
+//│ | | | | | | | | | | | |   else 4
+//│ | | | | | | | | | | | | | CONS: x$Q_1 is 1
+//│ | | | | | | | | | | | | | fill <== vars = {ucs$args_x$Q}
+//│ | | | | | | | | | | | | | | LHS: if then 3
+//│ | | | | | | | | | | | | | | RHS: if then 4
+//│ | | | | | | | | | | | | | fill ==> if then 3
+//│ | | | | | | | | | | | | | S+ <== x$Q_1 is 1 : if then 3
+//│ | | | | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | | | | S+ ==> if then 3
+//│ | | | | | | | | | | | | | normalizeToTerm <== if then 3
+//│ | | | | | | | | | | | | | | DFLT: 3
+//│ | | | | | | | | | | | | | normalizeToTerm ==> 3
+//│ | | | | | | | | | | | | | S-(true) <== x$Q_1 is 1 : if then 4
+//│ | | | | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | | | | S-(true) ==> if then 4
+//│ | | | | | | | | | | | | | normalizeToCaseBranches <==
+//│ | | | | | | | | | | | | | normalizeToCaseBranches ==>
+//│ | | | | | | | | | | | | normalizeToTerm ==> case x$Q_1*‡ of
+//│ | | | | | | | | | | | |   1 -> 3
+//│ | | | | | | | | | | | |   _ -> 4
+//│ | | | | | | | | | | | normalizeToCaseBranches ==>
+//│ | | | | | | | | | | normalizeToCaseBranches ==>
+//│ | | | | | | | | | normalizeToTerm ==> case x$Q_1*‡ of
+//│ | | | | | | | | |   0 -> 1
+//│ | | | | | | | | |   _ ->
+//│ | | | | | | | | |     let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | |     case x$Q_1*‡ of
+//│ | | | | | | | | |       1 -> 3
+//│ | | | | | | | | |       _ -> 4
+//│ | | | | | | | | | S-(false) <== x$Q_0 is 0 : if
+//│ | | | | | | | | |   x$Q_0*‡ is 1 and ...
+//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | |   x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | |   else 4
+//│ | | | | | | | | | | CASE Cons x$Q_0 is 1
+//│ | | | | | | | | | | Case 1.2: x$Q_0 === x$Q_0
+//│ | | | | | | | | | | Case 1.2.2: 0 are unrelated with 1
+//│ | | | | | | | | | | CASE Let y
+//│ | | | | | | | | | | CASE Cons x$Q_1 is 1
+//│ | | | | | | | | | | Case 2: x$Q_0 =/= x$Q_1
+//│ | | | | | | | | | | S-(false) <== x$Q_0 is 0 : if then 3
+//│ | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | S-(false) ==> if then 3
+//│ | | | | | | | | | | CASE Else
+//│ | | | | | | | | | S-(false) ==> if
+//│ | | | | | | | | |   x$Q_0*‡ is 1 and ...
+//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | |   x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | |   else 4
+//│ | | | | | | | | | normalizeToCaseBranches <==
+//│ | | | | | | | | | | normalizeToTerm <== if
+//│ | | | | | | | | | |   x$Q_0*‡ is 1 x$Q_1*‡ is 1 then 2
+//│ | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | |   x$Q_1*‡ is 1 then 3
+//│ | | | | | | | | | |   else 4
+//│ | | | | | | | | | | | CONS: x$Q_0 is 1
+//│ | | | | | | | | | | | fill <== vars = {ucs$args_x$Q}
+//│ | | | | | | | | | | | | LHS: if x$Q_1*‡ is 1 then 2
+//│ | | | | | | | | | | | | RHS: if
+//│ | | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | | | |   x$Q_1*‡ is 1 then 3
+//│ | | | | | | | | | | | |   else 4
+//│ | | | | | | | | | | | fill ==> if
+//│ | | | | | | | | | | |   x$Q_1*‡ is 1 then 2
+//│ | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | | |   ?x$Q_1*‡ is 1 then 3
+//│ | | | | | | | | | | |   else 4
+//│ | | | | | | | | | | | S+ <== x$Q_0 is 1 : if
+//│ | | | | | | | | | | |   x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | | | |   else 4
+//│ | | | | | | | | | | | | CASE Cons x$Q_1 is 1
+//│ | | | | | | | | | | | | Case 2: x$Q_0 =/= x$Q_1
+//│ | | | | | | | | | | | | S+ <== x$Q_0 is 1 : if then 2
+//│ | | | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | | | S+ ==> if then 2
+//│ | | | | | | | | | | | | CASE Let y
+//│ | | | | | | | | | | | | CASE Cons x$Q_1 is 1
+//│ | | | | | | | | | | | | Case 2: x$Q_0 =/= x$Q_1
+//│ | | | | | | | | | | | | S+ <== x$Q_0 is 1 : if then 3
+//│ | | | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | | | S+ ==> if then 3
+//│ | | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | | S+ ==> if
+//│ | | | | | | | | | | |   x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | | | |   else 4
+//│ | | | | | | | | | | | normalizeToTerm <== if
+//│ | | | | | | | | | | |   x$Q_1*‡ is 1 then 2
+//│ | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | | |   ?x$Q_1*‡ is 1 then 3
+//│ | | | | | | | | | | |   else 4
+//│ | | | | | | | | | | | | CONS: x$Q_1 is 1
+//│ | | | | | | | | | | | | fill <== vars = {ucs$args_x$Q}
+//│ | | | | | | | | | | | | | LHS: if then 2
+//│ | | | | | | | | | | | | | RHS: if
+//│ | | | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | | | | |   ?x$Q_1*‡ is 1 then 3
+//│ | | | | | | | | | | | | |   else 4
+//│ | | | | | | | | | | | | fill ==> if then 2
+//│ | | | | | | | | | | | | S+ <== x$Q_1 is 1 : if then 2
+//│ | | | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | | | S+ ==> if then 2
+//│ | | | | | | | | | | | | normalizeToTerm <== if then 2
+//│ | | | | | | | | | | | | | DFLT: 2
+//│ | | | | | | | | | | | | normalizeToTerm ==> 2
+//│ | | | | | | | | | | | | S-(true) <== x$Q_1 is 1 : if
+//│ | | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | | | | |   else 4
+//│ | | | | | | | | | | | | | CASE Let y
+//│ | | | | | | | | | | | | | CASE Cons x$Q_1 is 1
+//│ | | | | | | | | | | | | | Case 1.2: x$Q_1 === x$Q_1
+//│ | | | | | | | | | | | | | Case 1.2.1: 1 =:= (or <:<) 1
+//│ | | | | | | | | | | | | | `x$Q_1 is 1` is fallback
+//│ | | | | | | | | | | | | | already removed = true
+//│ | | | | | | | | | | | | | S-(true) <== x$Q_1 is 1 : if then 3
+//│ | | | | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | | | | S-(true) ==> if then 3
+//│ | | | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | | | S-(true) ==> if
+//│ | | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | | | |   else 4
+//│ | | | | | | | | | | | | normalizeToCaseBranches <==
+//│ | | | | | | | | | | | | | normalizeToCaseBranches <==
+//│ | | | | | | | | | | | | | normalizeToCaseBranches ==>
+//│ | | | | | | | | | | | | normalizeToCaseBranches ==>
+//│ | | | | | | | | | | | normalizeToTerm ==> case x$Q_1*‡ of
+//│ | | | | | | | | | | |   1 -> 2
+//│ | | | | | | | | | | |   _ ->
+//│ | | | | | | | | | | |     let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | | |     4
+//│ | | | | | | | | | | | S-(false) <== x$Q_0 is 1 : if
+//│ | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | | |   x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | | | |   else 4
+//│ | | | | | | | | | | | | CASE Let y
+//│ | | | | | | | | | | | | CASE Cons x$Q_1 is 1
+//│ | | | | | | | | | | | | Case 2: x$Q_0 =/= x$Q_1
+//│ | | | | | | | | | | | | S-(false) <== x$Q_0 is 1 : if then 3
+//│ | | | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | | | S-(false) ==> if then 3
+//│ | | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | | S-(false) ==> if
+//│ | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | | | |   else 4
+//│ | | | | | | | | | | | normalizeToCaseBranches <==
+//│ | | | | | | | | | | | | normalizeToCaseBranches <==
+//│ | | | | | | | | | | | | | normalizeToTerm <== if
+//│ | | | | | | | | | | | | |   x$Q_1*‡ is 1 then 3
+//│ | | | | | | | | | | | | |   else 4
+//│ | | | | | | | | | | | | | | CONS: x$Q_1 is 1
+//│ | | | | | | | | | | | | | | fill <== vars = {ucs$args_x$Q}
+//│ | | | | | | | | | | | | | | | LHS: if then 3
+//│ | | | | | | | | | | | | | | | RHS: if then 4
+//│ | | | | | | | | | | | | | | fill ==> if then 3
+//│ | | | | | | | | | | | | | | S+ <== x$Q_1 is 1 : if then 3
+//│ | | | | | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | | | | | S+ ==> if then 3
+//│ | | | | | | | | | | | | | | normalizeToTerm <== if then 3
+//│ | | | | | | | | | | | | | | | DFLT: 3
+//│ | | | | | | | | | | | | | | normalizeToTerm ==> 3
+//│ | | | | | | | | | | | | | | S-(true) <== x$Q_1 is 1 : if then 4
+//│ | | | | | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | | | | | S-(true) ==> if then 4
+//│ | | | | | | | | | | | | | | normalizeToCaseBranches <==
+//│ | | | | | | | | | | | | | | normalizeToCaseBranches ==>
+//│ | | | | | | | | | | | | | normalizeToTerm ==> case x$Q_1*‡ of
+//│ | | | | | | | | | | | | |   1 -> 3
+//│ | | | | | | | | | | | | |   _ -> 4
+//│ | | | | | | | | | | | | normalizeToCaseBranches ==>
+//│ | | | | | | | | | | | normalizeToCaseBranches ==>
+//│ | | | | | | | | | | normalizeToTerm ==> case x$Q_0*‡ of
+//│ | | | | | | | | | |   1 ->
+//│ | | | | | | | | | |     case x$Q_1*‡ of
+//│ | | | | | | | | | |       1 -> 2
+//│ | | | | | | | | | |       _ ->
+//│ | | | | | | | | | |         let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | |         4
+//│ | | | | | | | | | |   _ ->
+//│ | | | | | | | | | |     let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | | |     case x$Q_1*‡ of
+//│ | | | | | | | | | |       1 -> 3
+//│ | | | | | | | | | |       _ -> 4
+//│ | | | | | | | | | normalizeToCaseBranches ==>
+//│ | | | | | | | | normalizeToTerm ==> let ucs$args_x$Q*† = (Q).unapply(x,)
+//│ | | | | | | | | let x$Q_0*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | let x$Q_1*‡ = (ucs$args_x$Q).1
+//│ | | | | | | | | case x$Q_0*‡ of
+//│ | | | | | | | |   0 ->
+//│ | | | | | | | |     case x$Q_1*‡ of
+//│ | | | | | | | |       0 -> 1
+//│ | | | | | | | |       _ ->
+//│ | | | | | | | |         let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | |         case x$Q_1*‡ of
+//│ | | | | | | | |           1 -> 3
+//│ | | | | | | | |           _ -> 4
+//│ | | | | | | | |   _ ->
+//│ | | | | | | | |     case x$Q_0*‡ of
+//│ | | | | | | | |       1 ->
+//│ | | | | | | | |         case x$Q_1*‡ of
+//│ | | | | | | | |           1 -> 2
+//│ | | | | | | | |           _ ->
+//│ | | | | | | | |             let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | |             4
+//│ | | | | | | | |       _ ->
+//│ | | | | | | | |         let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | |         case x$Q_1*‡ of
+//│ | | | | | | | |           1 -> 3
+//│ | | | | | | | |           _ -> 4
+//│ | | | | | | | | S-(false) <== x is Q : if
+//│ | | | | | | | |   x*‡ is Q and ...
+//│ | | | | | | | |   x*‡ is Q and ...
+//│ | | | | | | | |   else 4
+//│ | | | | | | | | | CASE Cons x is Q
+//│ | | | | | | | | | Case 1.2: x === x
+//│ | | | | | | | | | Case 1.2.1: Q =:= (or <:<) Q
+//│ | | | | | | | | | `x is Q` is not fallback
+//│ | | | | | | | | | already removed = false
+//│ | | | | | | | | | S-(false) <== x is Q : if
+//│ | | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
+//│ | | | | | | | | |   let x$Q_0*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
+//│ | | | | | | | | |   x$Q_0*‡ is 1 and ...
+//│ | | | | | | | | | | CASE Let ucs$args_x$Q
+//│ | | | | | | | | | | CASE Let x$Q_0
+//│ | | | | | | | | | | CASE Let x$Q_1
+//│ | | | | | | | | | | CASE Cons x$Q_0 is 1
+//│ | | | | | | | | | | Case 2: x =/= x$Q_0
+//│ | | | | | | | | | | S-(false) <== x is Q : if x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | | | | CASE Cons x$Q_1 is 1
+//│ | | | | | | | | | | | Case 2: x =/= x$Q_1
+//│ | | | | | | | | | | | S-(false) <== x is Q : if then 2
+//│ | | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | | S-(false) ==> if then 2
+//│ | | | | | | | | | | | CASE Nil
+//│ | | | | | | | | | | S-(false) ==> if x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | | | CASE Nil
+//│ | | | | | | | | | S-(false) ==> if
+//│ | | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
+//│ | | | | | | | | |   let x$Q_0*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
+//│ | | | | | | | | |   x$Q_0*‡ is 1 and ...
+//│ | | | | | | | | | CASE Cons x is Q
+//│ | | | | | | | | | Case 1.2: x === x
+//│ | | | | | | | | | Case 1.2.1: Q =:= (or <:<) Q
+//│ | | | | | | | | | `x is Q` is not fallback
+//│ | | | | | | | | | already removed = false
+//│ | | | | | | | | | S-(false) <== x is Q : if
+//│ | | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
+//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
+//│ | | | | | | | | |   x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | | | CASE Let ucs$args_x$Q
+//│ | | | | | | | | | | CASE Let y
+//│ | | | | | | | | | | CASE Let x$Q_1
+//│ | | | | | | | | | | CASE Cons x$Q_1 is 1
+//│ | | | | | | | | | | Case 2: x =/= x$Q_1
+//│ | | | | | | | | | | S-(false) <== x is Q : if then 3
+//│ | | | | | | | | | | | CASE Else
+//│ | | | | | | | | | | S-(false) ==> if then 3
+//│ | | | | | | | | | | CASE Nil
+//│ | | | | | | | | | S-(false) ==> if
+//│ | | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
+//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
+//│ | | | | | | | | |   x$Q_1*‡ is 1 then ...
+//│ | | | | | | | | | CASE Else
+//│ | | | | | | | | S-(false) ==> if then 4
+//│ | | | | | | | | normalizeToCaseBranches <==
+//│ | | | | | | | | normalizeToCaseBranches ==>
+//│ | | | | | | | normalizeToTerm ==> case x*‡ of
+//│ | | | | | | |   Q*◊ ->
+//│ | | | | | | |     let ucs$args_x$Q*† = (Q).unapply(x,)
+//│ | | | | | | |     let x$Q_0*‡ = (ucs$args_x$Q).0
+//│ | | | | | | |     let x$Q_1*‡ = (ucs$args_x$Q).1
+//│ | | | | | | |     case x$Q_0*‡ of
+//│ | | | | | | |       0 ->
+//│ | | | | | | |         case x$Q_1*‡ of
+//│ | | | | | | |           0 -> 1
+//│ | | | | | | |           _ ->
+//│ | | | | | | |             let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | |             case x$Q_1*‡ of
+//│ | | | | | | |               1 -> 3
+//│ | | | | | | |               _ -> 4
+//│ | | | | | | |       _ ->
+//│ | | | | | | |         case x$Q_0*‡ of
+//│ | | | | | | |           1 ->
+//│ | | | | | | |             case x$Q_1*‡ of
+//│ | | | | | | |               1 -> 2
+//│ | | | | | | |               _ ->
+//│ | | | | | | |                 let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | |                 4
+//│ | | | | | | |           _ ->
+//│ | | | | | | |             let y*‡ = (ucs$args_x$Q).0
+//│ | | | | | | |             case x$Q_1*‡ of
+//│ | | | | | | |               1 -> 3
+//│ | | | | | | |               _ -> 4
+//│ | | | | | | |   _ -> 4
+//│ fun f: (Object & ~#Q | Q[Object, Object]) -> (1 | 2 | 3 | 4)
diff --git a/shared/src/test/diff/ucs/Humiliation.mls b/shared/src/test/diff/ucs/Humiliation.mls
index da7dfbbcd2..34fb50a565 100644
--- a/shared/src/test/diff/ucs/Humiliation.mls
+++ b/shared/src/test/diff/ucs/Humiliation.mls
@@ -12,11 +12,16 @@ if 1 is 1 then 1 else 0
 fun test(x) = if x is 1 then 0 else 1
 //│ fun test: Object -> (0 | 1)
 
-// :w
-// FIXME: It should report duplicated branches.
+:w
 fun testF(x) = if x is
   Foo(a) then a
   Foo(a) then a
+//│ ╔══[WARNING] found a duplicated case
+//│ ║  l.18: 	  Foo(a) then a
+//│ ║        	  ^^^
+//│ ╟── the case is covered by pattern Foo
+//│ ║  l.17: 	  Foo(a) then a
+//│ ╙──      	  ^^^
 //│ fun testF: forall 'a. Foo['a] -> 'a
 
 class Bar[Y, Z](y: Y, z: Z)
@@ -50,24 +55,24 @@ fun foo(x) = if x is
   Pair(Z(), Z()) then "zeros"
   Pair(O(), O()) then "ones"
 //│ ╔══[ERROR] when `x` is `Pair`, and
-//│ ║  l.50: 	  Pair(Z(), Z()) then "zeros"
+//│ ║  l.55: 	  Pair(Z(), Z()) then "zeros"
 //│ ║        	  ^^^^
 //│ ╟── the first argument of `Pair` is `Z`,
-//│ ║  l.50: 	  Pair(Z(), Z()) then "zeros"
+//│ ║  l.55: 	  Pair(Z(), Z()) then "zeros"
 //│ ║        	       ^
 //│ ╟── the second argument of `Pair` has 1 missing case
 //│ ╟── it can be class `O`
-//│ ║  l.51: 	  Pair(O(), O()) then "ones"
+//│ ║  l.56: 	  Pair(O(), O()) then "ones"
 //│ ╙──      	            ^
 //│ ╔══[ERROR] when `x` is `Pair`, and
-//│ ║  l.50: 	  Pair(Z(), Z()) then "zeros"
+//│ ║  l.55: 	  Pair(Z(), Z()) then "zeros"
 //│ ║        	  ^^^^
 //│ ╟── the first argument of `Pair` is `O`,
-//│ ║  l.51: 	  Pair(O(), O()) then "ones"
+//│ ║  l.56: 	  Pair(O(), O()) then "ones"
 //│ ║        	       ^
 //│ ╟── the second argument of `Pair` has 1 missing case
 //│ ╟── it can be class `Z`
-//│ ║  l.50: 	  Pair(Z(), Z()) then "zeros"
+//│ ║  l.55: 	  Pair(Z(), Z()) then "zeros"
 //│ ╙──      	            ^
 //│ fun foo: Pair[O | Z, nothing] -> ("ones" | "zeros")
 
@@ -77,11 +82,11 @@ fun foo(x) = if x is
   [Z(), Z()] then "zeros"
   [O(), O()] then "ones"
 //│ ╔══[ERROR] when `x$Tuple$2_0` is `O`
-//│ ║  l.78: 	  [O(), O()] then "ones"
+//│ ║  l.83: 	  [O(), O()] then "ones"
 //│ ║        	   ^
 //│ ╟── `x$Tuple$2_1` has 1 missing case
 //│ ╟── it can be class `Z`
-//│ ║  l.77: 	  [Z(), Z()] then "zeros"
+//│ ║  l.82: 	  [Z(), Z()] then "zeros"
 //│ ╙──      	        ^
 //│ fun foo: forall 'a. {0: O | Z, 1: O & 'a} -> ("ones" | "zeros" | 'a)
 
@@ -137,11 +142,11 @@ fun foo(x) = if x is
   Pair(O(), O()) then "ones"
   Pair(y, O()) then x
 //│ ╔══[ERROR] when `x` is `Pair`
-//│ ║  l.136: 	  Pair(Z(), Z()) then "zeros"
+//│ ║  l.141: 	  Pair(Z(), Z()) then "zeros"
 //│ ║         	  ^^^^
 //│ ╟── the second argument of `Pair` has 1 missing case
 //│ ╟── it can be class `Z`
-//│ ║  l.136: 	  Pair(Z(), Z()) then "zeros"
+//│ ║  l.141: 	  Pair(Z(), Z()) then "zeros"
 //│ ╙──       	            ^
 //│ fun foo: forall 'A 'B. Pair['A, O & 'B] -> ("ones" | "zeros" | Pair['A, 'B] | 'A)
 //│   where
diff --git a/shared/src/test/diff/ucs/InterleavedLet.mls b/shared/src/test/diff/ucs/InterleavedLet.mls
index 22f6a2aa2e..1366c27893 100644
--- a/shared/src/test/diff/ucs/InterleavedLet.mls
+++ b/shared/src/test/diff/ucs/InterleavedLet.mls
@@ -37,6 +37,12 @@ fun p(x, y) =
     x is Some and y is None then 0
     y is Some and x is Some then 1
     x is Some and y is Some then 0
+//│ ╔══[WARNING] found a duplicated case
+//│ ║  l.39: 	    x is Some and y is Some then 0
+//│ ║        	                       ^^^^
+//│ ╟── the case is covered by pattern Some
+//│ ║  l.38: 	    y is Some and x is Some then 1
+//│ ╙──      	         ^^^^
 //│ ╔══[ERROR] `y` has 1 missing case
 //│ ║  l.38: 	    y is Some and x is Some then 1
 //│ ║        	    ^
@@ -73,10 +79,10 @@ fun f(a, y) =
       Right(x) then x + y
     else 0
 //│ ╔══[ERROR] Type mismatch in operator application:
-//│ ║  l.72: 	      let y = v + 1
+//│ ║  l.78: 	      let y = v + 1
 //│ ║        	              ^^^^^
 //│ ╟── reference of type `Right[?B]` is not an instance of type `Int`
-//│ ║  l.72: 	      let y = v + 1
+//│ ║  l.78: 	      let y = v + 1
 //│ ╙──      	              ^
 //│ fun f: forall 'a. (Object & ~#Some | Some[Int | Left['a] | Right[Int]], anything) -> (Int | 'a)
 
@@ -87,9 +93,9 @@ fun q(a) =
     let y = a + 1
     then y
 //│ ╔══[PARSE ERROR] Expected an expression; found a 'then'/'else' clause instead
-//│ ║  l.87: 	    let y = a + 1
+//│ ║  l.93: 	    let y = a + 1
 //│ ║        	            ^^^^^
-//│ ║  l.88: 	    then y
+//│ ║  l.94: 	    then y
 //│ ╙──      	^^^^^^^^^^
 //│ fun q: forall 'a. (Left['a] | Object & ~#Left) -> (() | 'a)
 
@@ -106,11 +112,11 @@ fun w() =
     B then "B"
     else "?"
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.104: 	    A then "A"
+//│ ║  l.110: 	    A then "A"
 //│ ║         	    ^
 //│ ╙── reference of type `() -> A` is not an instance of type `Bool`
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.106: 	    B then "B"
+//│ ║  l.112: 	    B then "B"
 //│ ║         	    ^
 //│ ╙── reference of type `() -> B` is not an instance of type `Bool`
 //│ fun w: () -> ("?" | "A" | "B")
@@ -167,13 +173,13 @@ fun ip(y) =
     y == z * z then "bruh"
   else "rocks"
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.165: 	  if q(y) and
+//│ ║  l.171: 	  if q(y) and
 //│ ║         	     ^^^^
 //│ ╟── undefined literal of type `()` is not an instance of type `Bool`
-//│ ║  l.88: 	    then y
+//│ ║  l.94: 	    then y
 //│ ║        	          ^
 //│ ╟── but it flows into application with expected type `Bool`
-//│ ║  l.165: 	  if q(y) and
+//│ ║  l.171: 	  if q(y) and
 //│ ╙──       	     ^^^^
 //│ fun ip: Int -> ("bruh" | "rocks")
 
diff --git a/shared/src/test/diff/ucs/OverlappedBranches.mls b/shared/src/test/diff/ucs/OverlappedBranches.mls
index 679ccddcfd..a6ed55f88d 100644
--- a/shared/src/test/diff/ucs/OverlappedBranches.mls
+++ b/shared/src/test/diff/ucs/OverlappedBranches.mls
@@ -10,12 +10,28 @@ class Derived3() extends Derived2()
 //│ class Derived3() extends Base, Derived2
 
 // The very basic case.
-// :w
-// Should warn about that the last two cases are unreachable.
+// It should warn about that the last two cases are unreachable.
+:w
+:ducs:normalize.result
 fun f1(x) = if x is
   Base then "b"
   Derived1 then "d1"
   Derived2 then "d2"
+//│ Normalized UCS term:
+//│ case x*‡ of
+//│   Base*◊ -> "b"
+//│ ╔══[WARNING] found a duplicated case
+//│ ║  l.18: 	  Derived1 then "d1"
+//│ ║        	  ^^^^^^^^
+//│ ╟── the case is covered by pattern Base
+//│ ║  l.17: 	  Base then "b"
+//│ ╙──      	  ^^^^
+//│ ╔══[WARNING] found a duplicated case
+//│ ║  l.19: 	  Derived2 then "d2"
+//│ ║        	  ^^^^^^^^
+//│ ╟── the case is covered by pattern Base
+//│ ║  l.17: 	  Base then "b"
+//│ ╙──      	  ^^^^
 //│ fun f1: Base -> "b"
 
 f1(Base())

From 022094728259d2ce66fdaec8e3d6f55440d0f8b6 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 8 May 2024 04:23:13 +0800
Subject: [PATCH 129/147] Improve warning messages

---
 .../mlscript/ucs/stages/Normalization.scala   |  19 +-
 .../pretyper/ucs/coverage/CoveredCases.mls    |   8 +-
 .../pretyper/ucs/coverage/DuplicatedCases.mls | 517 +-----------------
 shared/src/test/diff/ucs/Humiliation.mls      |   2 +-
 shared/src/test/diff/ucs/InterleavedLet.mls   |   2 +-
 .../src/test/diff/ucs/OverlappedBranches.mls  |  10 +-
 6 files changed, 41 insertions(+), 517 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 7efa02124b..69fc7a00f2 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -290,10 +290,21 @@ trait Normalization { self: Desugarer with Traceable =>
                 println(s"already removed = $full")
                 if (!split.isFallback && full && !head.continuation.isEmpty) {
                   println(s"report warning")
-                  raiseDesugaringWarning(
-                    msg"found a duplicated case" -> thatPattern.toLoc,
-                    msg"the case is covered by pattern ${pattern.toString}" -> pattern.toLoc,
-                  )
+                  if (pattern === thatPattern) {
+                    raiseDesugaringWarning(
+                      msg"found a duplicated case" -> thatPattern.toLoc,
+                      msg"there is an identical pattern ${pattern.toString}" -> pattern.toLoc,
+                    )
+                  } else {
+                    raiseDesugaringWarning(
+                      msg"found a duplicated case" -> thatPattern.toLoc,
+                      msg"the case is covered by pattern ${pattern.toString}" -> pattern.toLoc,
+                      msg"due to the subtyping relation" -> (thatPattern match {
+                        case Pattern.Class(_, symbol, _) => symbol.defn.getLoc
+                        case _ => thatPattern.toLoc
+                      })
+                    )
+                  }
                 }
                 specializeImpl(tail)(
                   `-`(if (samePattern) continuation.isFull else full),
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/CoveredCases.mls b/shared/src/test/diff/pretyper/ucs/coverage/CoveredCases.mls
index cfccce1f98..6895da0d0b 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/CoveredCases.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/CoveredCases.mls
@@ -15,7 +15,7 @@ fun f(x) = if
 //│ ╔══[WARNING] found a duplicated case
 //│ ║  l.14: 	  x is A then 2
 //│ ║        	       ^
-//│ ╟── the case is covered by pattern A
+//│ ╟── there is an identical pattern A
 //│ ║  l.13: 	  x is A then 1
 //│ ╙──      	       ^
 //│ fun f: A -> 1
@@ -33,7 +33,10 @@ fun f(x) = if
 //│ ║        	       ^
 //│ ╟── the case is covered by pattern A
 //│ ║  l.26: 	  x is A then 1
-//│ ╙──      	       ^
+//│ ║        	       ^
+//│ ╟── due to the subtyping relation
+//│ ║  l.7: 	class B() extends A()
+//│ ╙──     	^^^^^^^^^^^^^^^^^^^^^
 //│ fun f: A -> 1
 
 :ducs:normalize.result
@@ -85,3 +88,4 @@ fun f(x) = if
 //│   _ -> 4
 //│ fun f: Object -> (1 | 2 | 4)
 //│ TEST CASE FAILURE: There was an unexpected lack of warning
+
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/DuplicatedCases.mls b/shared/src/test/diff/pretyper/ucs/coverage/DuplicatedCases.mls
index 97509585df..261ca4db78 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/DuplicatedCases.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/DuplicatedCases.mls
@@ -17,7 +17,7 @@ fun f(x) = if x is
 //│ ╔══[WARNING] found a duplicated case
 //│ ║  l.10: 	  "a" then 3
 //│ ║        	  ^^^
-//│ ╟── the case is covered by pattern "a"
+//│ ╟── there is an identical pattern "a"
 //│ ║  l.8: 	  "a" then 1
 //│ ╙──     	  ^^^
 //│ fun f: ("a" | "b") -> (1 | 2)
@@ -42,7 +42,7 @@ fun f(x) = if x is
 //│ ╔══[WARNING] found a duplicated case
 //│ ║  l.38: 	  X then 2
 //│ ║        	  ^
-//│ ╟── the case is covered by pattern X
+//│ ╟── there is an identical pattern X
 //│ ║  l.37: 	  X then 1
 //│ ╙──      	  ^
 //│ fun f: X -> 1
@@ -62,7 +62,7 @@ fun f(x) = if x is
 //│ ╔══[WARNING] found a duplicated case
 //│ ║  l.55: 	  X then 3
 //│ ║        	  ^
-//│ ╟── the case is covered by pattern X
+//│ ╟── there is an identical pattern X
 //│ ║  l.53: 	  X then 1
 //│ ╙──      	  ^
 //│ fun f: (X | Y) -> (1 | 2)
@@ -199,514 +199,17 @@ fun f(x) =
 //│           1 -> 2
 //│ fun f: forall 'a. Q[Object & 'a, 1] -> (1 | 2 | 'a)
 
-:ducs:normalize
 fun f(x) =
   if x is
     Q(0, 0) then 1
     Q(1, 1) then 2
     Q(y, 1) then 3
     _       then 4
-//│ | | | | | | | STEP 2
-//│ | | | | | | | normalizeToTerm <== if
-//│ | | | | | | |   x*‡ is Q
-//│ | | | | | | |     let ucs$args_x$Q*† = (Q).unapply(x,)
-//│ | | | | | | |     let x$Q_0*‡ = (ucs$args_x$Q).0
-//│ | | | | | | |     let x$Q_1*‡ = (ucs$args_x$Q).1
-//│ | | | | | | |     x$Q_0*‡ is 0 x$Q_1*‡ is 0 then 1
-//│ | | | | | | |   x*‡ is Q
-//│ | | | | | | |     let ucs$args_x$Q*† = (Q).unapply(x,)
-//│ | | | | | | |     let x$Q_0*‡ = (ucs$args_x$Q).0
-//│ | | | | | | |     let x$Q_1*‡ = (ucs$args_x$Q).1
-//│ | | | | | | |     x$Q_0*‡ is 1 x$Q_1*‡ is 1 then 2
-//│ | | | | | | |   x*‡ is Q
-//│ | | | | | | |     let ucs$args_x$Q*† = (Q).unapply(x,)
-//│ | | | | | | |     let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | |     let x$Q_1*‡ = (ucs$args_x$Q).1
-//│ | | | | | | |     x$Q_1*‡ is 1 then 3
-//│ | | | | | | |   else 4
-//│ | | | | | | | | CONS: x is Q
-//│ | | | | | | | | fill <== vars = {}
-//│ | | | | | | | | | LHS: if
-//│ | | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
-//│ | | | | | | | | |   let x$Q_0*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
-//│ | | | | | | | | |   x$Q_0*‡ is 0 x$Q_1*‡ is 0 then 1
-//│ | | | | | | | | | RHS: if
-//│ | | | | | | | | |   x*‡ is Q
-//│ | | | | | | | | |     let ucs$args_x$Q*† = (Q).unapply(x,)
-//│ | | | | | | | | |     let x$Q_0*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | |     let x$Q_1*‡ = (ucs$args_x$Q).1
-//│ | | | | | | | | |     x$Q_0*‡ is 1 x$Q_1*‡ is 1 then 2
-//│ | | | | | | | | |   x*‡ is Q
-//│ | | | | | | | | |     let ucs$args_x$Q*† = (Q).unapply(x,)
-//│ | | | | | | | | |     let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | |     let x$Q_1*‡ = (ucs$args_x$Q).1
-//│ | | | | | | | | |     x$Q_1*‡ is 1 then 3
-//│ | | | | | | | | |   else 4
-//│ | | | | | | | | | fill let binding ucs$args_x$Q
-//│ | | | | | | | | | fill let binding x$Q_0
-//│ | | | | | | | | | fill let binding x$Q_1
-//│ | | | | | | | | fill ==> if
-//│ | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
-//│ | | | | | | | |   let x$Q_0*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
-//│ | | | | | | | |   x$Q_0*‡ is 0 x$Q_1*‡ is 0 then 1
-//│ | | | | | | | |   ?x*‡ is Q ?x$Q_0*‡ is 1 ?x$Q_1*‡ is 1 then 2
-//│ | | | | | | | |   ?x*‡ is Q
-//│ | | | | | | | |     let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | |     ?x$Q_1*‡ is 1 then 3
-//│ | | | | | | | |   else 4
-//│ | | | | | | | | S+ <== x is Q : if
-//│ | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
-//│ | | | | | | | |   let x$Q_0*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
-//│ | | | | | | | |   x$Q_0*‡ is 0 and ...
-//│ | | | | | | | |   ?x*‡ is Q and ...
-//│ | | | | | | | |   ?x*‡ is Q and ...
-//│ | | | | | | | |   else 4
-//│ | | | | | | | | | CASE Let ucs$args_x$Q
-//│ | | | | | | | | | CASE Let x$Q_0
-//│ | | | | | | | | | CASE Let x$Q_1
-//│ | | | | | | | | | CASE Cons x$Q_0 is 0
-//│ | | | | | | | | | Case 2: x =/= x$Q_0
-//│ | | | | | | | | | S+ <== x is Q : if x$Q_1*‡ is 0 then ...
-//│ | | | | | | | | | | CASE Cons x$Q_1 is 0
-//│ | | | | | | | | | | Case 2: x =/= x$Q_1
-//│ | | | | | | | | | | S+ <== x is Q : if then 1
-//│ | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | S+ ==> if then 1
-//│ | | | | | | | | | | CASE Nil
-//│ | | | | | | | | | S+ ==> if x$Q_1*‡ is 0 then ...
-//│ | | | | | | | | | CASE Cons x is Q
-//│ | | | | | | | | | Case 1.1: x === x
-//│ | | | | | | | | | Case 1.1.1: Q =:= Q
-//│ | | | | | | | | | S+ <== x is Q : if ?x$Q_0*‡ is 1 and ...
-//│ | | | | | | | | | | CASE Cons x$Q_0 is 1
-//│ | | | | | | | | | | Case 2: x =/= x$Q_0
-//│ | | | | | | | | | | S+ <== x is Q : if ?x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | | | | CASE Cons x$Q_1 is 1
-//│ | | | | | | | | | | | Case 2: x =/= x$Q_1
-//│ | | | | | | | | | | | S+ <== x is Q : if then 2
-//│ | | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | | S+ ==> if then 2
-//│ | | | | | | | | | | | CASE Nil
-//│ | | | | | | | | | | S+ ==> if ?x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | | | CASE Nil
-//│ | | | | | | | | | S+ ==> if ?x$Q_0*‡ is 1 and ...
-//│ | | | | | | | | | CASE Cons x is Q
-//│ | | | | | | | | | Case 1.1: x === x
-//│ | | | | | | | | | Case 1.1.1: Q =:= Q
-//│ | | | | | | | | | S+ <== x is Q : if
-//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | | | CASE Let y
-//│ | | | | | | | | | | CASE Cons x$Q_1 is 1
-//│ | | | | | | | | | | Case 2: x =/= x$Q_1
-//│ | | | | | | | | | | S+ <== x is Q : if then 3
-//│ | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | S+ ==> if then 3
-//│ | | | | | | | | | | CASE Nil
-//│ | | | | | | | | | S+ ==> if
-//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | | CASE Else
-//│ | | | | | | | | S+ ==> if
-//│ | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
-//│ | | | | | | | |   let x$Q_0*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
-//│ | | | | | | | |   x$Q_0*‡ is 0 and ...
-//│ | | | | | | | |   x$Q_0*‡ is 1 and ...
-//│ | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | |   x$Q_1*‡ is 1 then ...
-//│ | | | | | | | |   else 4
-//│ | | | | | | | | normalizeToTerm <== if
-//│ | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
-//│ | | | | | | | |   let x$Q_0*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
-//│ | | | | | | | |   x$Q_0*‡ is 0 x$Q_1*‡ is 0 then 1
-//│ | | | | | | | |   x$Q_0*‡ is 1 ?x$Q_1*‡ is 1 then 2
-//│ | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | |   x$Q_1*‡ is 1 then 3
-//│ | | | | | | | |   else 4
-//│ | | | | | | | | | LET: generated ucs$args_x$Q
-//│ | | | | | | | | | LET: x$Q_0
-//│ | | | | | | | | | LET: x$Q_1
-//│ | | | | | | | | | CONS: x$Q_0 is 0
-//│ | | | | | | | | | fill <== vars = {ucs$args_x$Q}
-//│ | | | | | | | | | | LHS: if x$Q_1*‡ is 0 then 1
-//│ | | | | | | | | | | RHS: if
-//│ | | | | | | | | | |   x$Q_0*‡ is 1 ?x$Q_1*‡ is 1 then 2
-//│ | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | |   x$Q_1*‡ is 1 then 3
-//│ | | | | | | | | | |   else 4
-//│ | | | | | | | | | fill ==> if
-//│ | | | | | | | | |   x$Q_1*‡ is 0 then 1
-//│ | | | | | | | | |   ?x$Q_0*‡ is 1 ?x$Q_1*‡ is 1 then 2
-//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | |   ?x$Q_1*‡ is 1 then 3
-//│ | | | | | | | | |   else 4
-//│ | | | | | | | | | S+ <== x$Q_0 is 0 : if
-//│ | | | | | | | | |   x$Q_1*‡ is 0 then ...
-//│ | | | | | | | | |   ?x$Q_0*‡ is 1 and ...
-//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | |   else 4
-//│ | | | | | | | | | | CASE Cons x$Q_1 is 0
-//│ | | | | | | | | | | Case 2: x$Q_0 =/= x$Q_1
-//│ | | | | | | | | | | S+ <== x$Q_0 is 0 : if then 1
-//│ | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | S+ ==> if then 1
-//│ | | | | | | | | | | CASE Cons x$Q_0 is 1
-//│ | | | | | | | | | | Case 1.1: x$Q_0 === x$Q_0
-//│ | | | | | | | | | | Case 1.1.3: 0 is unrelated with 1
-//│ | | | | | | | | | | CASE Let y
-//│ | | | | | | | | | | CASE Cons x$Q_1 is 1
-//│ | | | | | | | | | | Case 2: x$Q_0 =/= x$Q_1
-//│ | | | | | | | | | | S+ <== x$Q_0 is 0 : if then 3
-//│ | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | S+ ==> if then 3
-//│ | | | | | | | | | | CASE Else
-//│ | | | | | | | | | S+ ==> if
-//│ | | | | | | | | |   x$Q_1*‡ is 0 then ...
-//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | |   else 4
-//│ | | | | | | | | | normalizeToTerm <== if
-//│ | | | | | | | | |   x$Q_1*‡ is 0 then 1
-//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | |   ?x$Q_1*‡ is 1 then 3
-//│ | | | | | | | | |   else 4
-//│ | | | | | | | | | | CONS: x$Q_1 is 0
-//│ | | | | | | | | | | fill <== vars = {ucs$args_x$Q}
-//│ | | | | | | | | | | | LHS: if then 1
-//│ | | | | | | | | | | | RHS: if
-//│ | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | | |   ?x$Q_1*‡ is 1 then 3
-//│ | | | | | | | | | | |   else 4
-//│ | | | | | | | | | | fill ==> if then 1
-//│ | | | | | | | | | | S+ <== x$Q_1 is 0 : if then 1
-//│ | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | S+ ==> if then 1
-//│ | | | | | | | | | | normalizeToTerm <== if then 1
-//│ | | | | | | | | | | | DFLT: 1
-//│ | | | | | | | | | | normalizeToTerm ==> 1
-//│ | | | | | | | | | | S-(true) <== x$Q_1 is 0 : if
-//│ | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | | |   else 4
-//│ | | | | | | | | | | | CASE Let y
-//│ | | | | | | | | | | | CASE Cons x$Q_1 is 1
-//│ | | | | | | | | | | | Case 1.2: x$Q_1 === x$Q_1
-//│ | | | | | | | | | | | Case 1.2.2: 0 are unrelated with 1
-//│ | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | S-(true) ==> if
-//│ | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | |   x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | | |   else 4
-//│ | | | | | | | | | | normalizeToCaseBranches <==
-//│ | | | | | | | | | | | normalizeToCaseBranches <==
-//│ | | | | | | | | | | | | normalizeToTerm <== if
-//│ | | | | | | | | | | | |   x$Q_1*‡ is 1 then 3
-//│ | | | | | | | | | | | |   else 4
-//│ | | | | | | | | | | | | | CONS: x$Q_1 is 1
-//│ | | | | | | | | | | | | | fill <== vars = {ucs$args_x$Q}
-//│ | | | | | | | | | | | | | | LHS: if then 3
-//│ | | | | | | | | | | | | | | RHS: if then 4
-//│ | | | | | | | | | | | | | fill ==> if then 3
-//│ | | | | | | | | | | | | | S+ <== x$Q_1 is 1 : if then 3
-//│ | | | | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | | | | S+ ==> if then 3
-//│ | | | | | | | | | | | | | normalizeToTerm <== if then 3
-//│ | | | | | | | | | | | | | | DFLT: 3
-//│ | | | | | | | | | | | | | normalizeToTerm ==> 3
-//│ | | | | | | | | | | | | | S-(true) <== x$Q_1 is 1 : if then 4
-//│ | | | | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | | | | S-(true) ==> if then 4
-//│ | | | | | | | | | | | | | normalizeToCaseBranches <==
-//│ | | | | | | | | | | | | | normalizeToCaseBranches ==>
-//│ | | | | | | | | | | | | normalizeToTerm ==> case x$Q_1*‡ of
-//│ | | | | | | | | | | | |   1 -> 3
-//│ | | | | | | | | | | | |   _ -> 4
-//│ | | | | | | | | | | | normalizeToCaseBranches ==>
-//│ | | | | | | | | | | normalizeToCaseBranches ==>
-//│ | | | | | | | | | normalizeToTerm ==> case x$Q_1*‡ of
-//│ | | | | | | | | |   0 -> 1
-//│ | | | | | | | | |   _ ->
-//│ | | | | | | | | |     let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | |     case x$Q_1*‡ of
-//│ | | | | | | | | |       1 -> 3
-//│ | | | | | | | | |       _ -> 4
-//│ | | | | | | | | | S-(false) <== x$Q_0 is 0 : if
-//│ | | | | | | | | |   x$Q_0*‡ is 1 and ...
-//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | |   x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | |   else 4
-//│ | | | | | | | | | | CASE Cons x$Q_0 is 1
-//│ | | | | | | | | | | Case 1.2: x$Q_0 === x$Q_0
-//│ | | | | | | | | | | Case 1.2.2: 0 are unrelated with 1
-//│ | | | | | | | | | | CASE Let y
-//│ | | | | | | | | | | CASE Cons x$Q_1 is 1
-//│ | | | | | | | | | | Case 2: x$Q_0 =/= x$Q_1
-//│ | | | | | | | | | | S-(false) <== x$Q_0 is 0 : if then 3
-//│ | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | S-(false) ==> if then 3
-//│ | | | | | | | | | | CASE Else
-//│ | | | | | | | | | S-(false) ==> if
-//│ | | | | | | | | |   x$Q_0*‡ is 1 and ...
-//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | |   x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | |   else 4
-//│ | | | | | | | | | normalizeToCaseBranches <==
-//│ | | | | | | | | | | normalizeToTerm <== if
-//│ | | | | | | | | | |   x$Q_0*‡ is 1 x$Q_1*‡ is 1 then 2
-//│ | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | |   x$Q_1*‡ is 1 then 3
-//│ | | | | | | | | | |   else 4
-//│ | | | | | | | | | | | CONS: x$Q_0 is 1
-//│ | | | | | | | | | | | fill <== vars = {ucs$args_x$Q}
-//│ | | | | | | | | | | | | LHS: if x$Q_1*‡ is 1 then 2
-//│ | | | | | | | | | | | | RHS: if
-//│ | | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | | | |   x$Q_1*‡ is 1 then 3
-//│ | | | | | | | | | | | |   else 4
-//│ | | | | | | | | | | | fill ==> if
-//│ | | | | | | | | | | |   x$Q_1*‡ is 1 then 2
-//│ | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | | |   ?x$Q_1*‡ is 1 then 3
-//│ | | | | | | | | | | |   else 4
-//│ | | | | | | | | | | | S+ <== x$Q_0 is 1 : if
-//│ | | | | | | | | | | |   x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | | | |   else 4
-//│ | | | | | | | | | | | | CASE Cons x$Q_1 is 1
-//│ | | | | | | | | | | | | Case 2: x$Q_0 =/= x$Q_1
-//│ | | | | | | | | | | | | S+ <== x$Q_0 is 1 : if then 2
-//│ | | | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | | | S+ ==> if then 2
-//│ | | | | | | | | | | | | CASE Let y
-//│ | | | | | | | | | | | | CASE Cons x$Q_1 is 1
-//│ | | | | | | | | | | | | Case 2: x$Q_0 =/= x$Q_1
-//│ | | | | | | | | | | | | S+ <== x$Q_0 is 1 : if then 3
-//│ | | | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | | | S+ ==> if then 3
-//│ | | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | | S+ ==> if
-//│ | | | | | | | | | | |   x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | | | |   else 4
-//│ | | | | | | | | | | | normalizeToTerm <== if
-//│ | | | | | | | | | | |   x$Q_1*‡ is 1 then 2
-//│ | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | | |   ?x$Q_1*‡ is 1 then 3
-//│ | | | | | | | | | | |   else 4
-//│ | | | | | | | | | | | | CONS: x$Q_1 is 1
-//│ | | | | | | | | | | | | fill <== vars = {ucs$args_x$Q}
-//│ | | | | | | | | | | | | | LHS: if then 2
-//│ | | | | | | | | | | | | | RHS: if
-//│ | | | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | | | | |   ?x$Q_1*‡ is 1 then 3
-//│ | | | | | | | | | | | | |   else 4
-//│ | | | | | | | | | | | | fill ==> if then 2
-//│ | | | | | | | | | | | | S+ <== x$Q_1 is 1 : if then 2
-//│ | | | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | | | S+ ==> if then 2
-//│ | | | | | | | | | | | | normalizeToTerm <== if then 2
-//│ | | | | | | | | | | | | | DFLT: 2
-//│ | | | | | | | | | | | | normalizeToTerm ==> 2
-//│ | | | | | | | | | | | | S-(true) <== x$Q_1 is 1 : if
-//│ | | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | | | | |   else 4
-//│ | | | | | | | | | | | | | CASE Let y
-//│ | | | | | | | | | | | | | CASE Cons x$Q_1 is 1
-//│ | | | | | | | | | | | | | Case 1.2: x$Q_1 === x$Q_1
-//│ | | | | | | | | | | | | | Case 1.2.1: 1 =:= (or <:<) 1
-//│ | | | | | | | | | | | | | `x$Q_1 is 1` is fallback
-//│ | | | | | | | | | | | | | already removed = true
-//│ | | | | | | | | | | | | | S-(true) <== x$Q_1 is 1 : if then 3
-//│ | | | | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | | | | S-(true) ==> if then 3
-//│ | | | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | | | S-(true) ==> if
-//│ | | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | | | |   else 4
-//│ | | | | | | | | | | | | normalizeToCaseBranches <==
-//│ | | | | | | | | | | | | | normalizeToCaseBranches <==
-//│ | | | | | | | | | | | | | normalizeToCaseBranches ==>
-//│ | | | | | | | | | | | | normalizeToCaseBranches ==>
-//│ | | | | | | | | | | | normalizeToTerm ==> case x$Q_1*‡ of
-//│ | | | | | | | | | | |   1 -> 2
-//│ | | | | | | | | | | |   _ ->
-//│ | | | | | | | | | | |     let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | | |     4
-//│ | | | | | | | | | | | S-(false) <== x$Q_0 is 1 : if
-//│ | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | | |   x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | | | |   else 4
-//│ | | | | | | | | | | | | CASE Let y
-//│ | | | | | | | | | | | | CASE Cons x$Q_1 is 1
-//│ | | | | | | | | | | | | Case 2: x$Q_0 =/= x$Q_1
-//│ | | | | | | | | | | | | S-(false) <== x$Q_0 is 1 : if then 3
-//│ | | | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | | | S-(false) ==> if then 3
-//│ | | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | | S-(false) ==> if
-//│ | | | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | | |   ?x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | | | |   else 4
-//│ | | | | | | | | | | | normalizeToCaseBranches <==
-//│ | | | | | | | | | | | | normalizeToCaseBranches <==
-//│ | | | | | | | | | | | | | normalizeToTerm <== if
-//│ | | | | | | | | | | | | |   x$Q_1*‡ is 1 then 3
-//│ | | | | | | | | | | | | |   else 4
-//│ | | | | | | | | | | | | | | CONS: x$Q_1 is 1
-//│ | | | | | | | | | | | | | | fill <== vars = {ucs$args_x$Q}
-//│ | | | | | | | | | | | | | | | LHS: if then 3
-//│ | | | | | | | | | | | | | | | RHS: if then 4
-//│ | | | | | | | | | | | | | | fill ==> if then 3
-//│ | | | | | | | | | | | | | | S+ <== x$Q_1 is 1 : if then 3
-//│ | | | | | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | | | | | S+ ==> if then 3
-//│ | | | | | | | | | | | | | | normalizeToTerm <== if then 3
-//│ | | | | | | | | | | | | | | | DFLT: 3
-//│ | | | | | | | | | | | | | | normalizeToTerm ==> 3
-//│ | | | | | | | | | | | | | | S-(true) <== x$Q_1 is 1 : if then 4
-//│ | | | | | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | | | | | S-(true) ==> if then 4
-//│ | | | | | | | | | | | | | | normalizeToCaseBranches <==
-//│ | | | | | | | | | | | | | | normalizeToCaseBranches ==>
-//│ | | | | | | | | | | | | | normalizeToTerm ==> case x$Q_1*‡ of
-//│ | | | | | | | | | | | | |   1 -> 3
-//│ | | | | | | | | | | | | |   _ -> 4
-//│ | | | | | | | | | | | | normalizeToCaseBranches ==>
-//│ | | | | | | | | | | | normalizeToCaseBranches ==>
-//│ | | | | | | | | | | normalizeToTerm ==> case x$Q_0*‡ of
-//│ | | | | | | | | | |   1 ->
-//│ | | | | | | | | | |     case x$Q_1*‡ of
-//│ | | | | | | | | | |       1 -> 2
-//│ | | | | | | | | | |       _ ->
-//│ | | | | | | | | | |         let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | |         4
-//│ | | | | | | | | | |   _ ->
-//│ | | | | | | | | | |     let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | | |     case x$Q_1*‡ of
-//│ | | | | | | | | | |       1 -> 3
-//│ | | | | | | | | | |       _ -> 4
-//│ | | | | | | | | | normalizeToCaseBranches ==>
-//│ | | | | | | | | normalizeToTerm ==> let ucs$args_x$Q*† = (Q).unapply(x,)
-//│ | | | | | | | | let x$Q_0*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | let x$Q_1*‡ = (ucs$args_x$Q).1
-//│ | | | | | | | | case x$Q_0*‡ of
-//│ | | | | | | | |   0 ->
-//│ | | | | | | | |     case x$Q_1*‡ of
-//│ | | | | | | | |       0 -> 1
-//│ | | | | | | | |       _ ->
-//│ | | | | | | | |         let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | |         case x$Q_1*‡ of
-//│ | | | | | | | |           1 -> 3
-//│ | | | | | | | |           _ -> 4
-//│ | | | | | | | |   _ ->
-//│ | | | | | | | |     case x$Q_0*‡ of
-//│ | | | | | | | |       1 ->
-//│ | | | | | | | |         case x$Q_1*‡ of
-//│ | | | | | | | |           1 -> 2
-//│ | | | | | | | |           _ ->
-//│ | | | | | | | |             let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | |             4
-//│ | | | | | | | |       _ ->
-//│ | | | | | | | |         let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | |         case x$Q_1*‡ of
-//│ | | | | | | | |           1 -> 3
-//│ | | | | | | | |           _ -> 4
-//│ | | | | | | | | S-(false) <== x is Q : if
-//│ | | | | | | | |   x*‡ is Q and ...
-//│ | | | | | | | |   x*‡ is Q and ...
-//│ | | | | | | | |   else 4
-//│ | | | | | | | | | CASE Cons x is Q
-//│ | | | | | | | | | Case 1.2: x === x
-//│ | | | | | | | | | Case 1.2.1: Q =:= (or <:<) Q
-//│ | | | | | | | | | `x is Q` is not fallback
-//│ | | | | | | | | | already removed = false
-//│ | | | | | | | | | S-(false) <== x is Q : if
-//│ | | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
-//│ | | | | | | | | |   let x$Q_0*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
-//│ | | | | | | | | |   x$Q_0*‡ is 1 and ...
-//│ | | | | | | | | | | CASE Let ucs$args_x$Q
-//│ | | | | | | | | | | CASE Let x$Q_0
-//│ | | | | | | | | | | CASE Let x$Q_1
-//│ | | | | | | | | | | CASE Cons x$Q_0 is 1
-//│ | | | | | | | | | | Case 2: x =/= x$Q_0
-//│ | | | | | | | | | | S-(false) <== x is Q : if x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | | | | CASE Cons x$Q_1 is 1
-//│ | | | | | | | | | | | Case 2: x =/= x$Q_1
-//│ | | | | | | | | | | | S-(false) <== x is Q : if then 2
-//│ | | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | | S-(false) ==> if then 2
-//│ | | | | | | | | | | | CASE Nil
-//│ | | | | | | | | | | S-(false) ==> if x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | | | CASE Nil
-//│ | | | | | | | | | S-(false) ==> if
-//│ | | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
-//│ | | | | | | | | |   let x$Q_0*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
-//│ | | | | | | | | |   x$Q_0*‡ is 1 and ...
-//│ | | | | | | | | | CASE Cons x is Q
-//│ | | | | | | | | | Case 1.2: x === x
-//│ | | | | | | | | | Case 1.2.1: Q =:= (or <:<) Q
-//│ | | | | | | | | | `x is Q` is not fallback
-//│ | | | | | | | | | already removed = false
-//│ | | | | | | | | | S-(false) <== x is Q : if
-//│ | | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
-//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
-//│ | | | | | | | | |   x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | | | CASE Let ucs$args_x$Q
-//│ | | | | | | | | | | CASE Let y
-//│ | | | | | | | | | | CASE Let x$Q_1
-//│ | | | | | | | | | | CASE Cons x$Q_1 is 1
-//│ | | | | | | | | | | Case 2: x =/= x$Q_1
-//│ | | | | | | | | | | S-(false) <== x is Q : if then 3
-//│ | | | | | | | | | | | CASE Else
-//│ | | | | | | | | | | S-(false) ==> if then 3
-//│ | | | | | | | | | | CASE Nil
-//│ | | | | | | | | | S-(false) ==> if
-//│ | | | | | | | | |   let ucs$args_x$Q*† = (Q).unapply(x,)
-//│ | | | | | | | | |   let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | | | |   let x$Q_1*‡ = (ucs$args_x$Q).1
-//│ | | | | | | | | |   x$Q_1*‡ is 1 then ...
-//│ | | | | | | | | | CASE Else
-//│ | | | | | | | | S-(false) ==> if then 4
-//│ | | | | | | | | normalizeToCaseBranches <==
-//│ | | | | | | | | normalizeToCaseBranches ==>
-//│ | | | | | | | normalizeToTerm ==> case x*‡ of
-//│ | | | | | | |   Q*◊ ->
-//│ | | | | | | |     let ucs$args_x$Q*† = (Q).unapply(x,)
-//│ | | | | | | |     let x$Q_0*‡ = (ucs$args_x$Q).0
-//│ | | | | | | |     let x$Q_1*‡ = (ucs$args_x$Q).1
-//│ | | | | | | |     case x$Q_0*‡ of
-//│ | | | | | | |       0 ->
-//│ | | | | | | |         case x$Q_1*‡ of
-//│ | | | | | | |           0 -> 1
-//│ | | | | | | |           _ ->
-//│ | | | | | | |             let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | |             case x$Q_1*‡ of
-//│ | | | | | | |               1 -> 3
-//│ | | | | | | |               _ -> 4
-//│ | | | | | | |       _ ->
-//│ | | | | | | |         case x$Q_0*‡ of
-//│ | | | | | | |           1 ->
-//│ | | | | | | |             case x$Q_1*‡ of
-//│ | | | | | | |               1 -> 2
-//│ | | | | | | |               _ ->
-//│ | | | | | | |                 let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | |                 4
-//│ | | | | | | |           _ ->
-//│ | | | | | | |             let y*‡ = (ucs$args_x$Q).0
-//│ | | | | | | |             case x$Q_1*‡ of
-//│ | | | | | | |               1 -> 3
-//│ | | | | | | |               _ -> 4
-//│ | | | | | | |   _ -> 4
 //│ fun f: (Object & ~#Q | Q[Object, Object]) -> (1 | 2 | 3 | 4)
+
+fun f(x) =
+  if x is
+    P(P(P(1))) then 1
+    P(P(1)) then 2
+    P(1) then 3
+//│ fun f: P[1 | P[1 | P[1]]] -> (1 | 2 | 3)
diff --git a/shared/src/test/diff/ucs/Humiliation.mls b/shared/src/test/diff/ucs/Humiliation.mls
index 34fb50a565..37850b4e39 100644
--- a/shared/src/test/diff/ucs/Humiliation.mls
+++ b/shared/src/test/diff/ucs/Humiliation.mls
@@ -19,7 +19,7 @@ fun testF(x) = if x is
 //│ ╔══[WARNING] found a duplicated case
 //│ ║  l.18: 	  Foo(a) then a
 //│ ║        	  ^^^
-//│ ╟── the case is covered by pattern Foo
+//│ ╟── there is an identical pattern Foo
 //│ ║  l.17: 	  Foo(a) then a
 //│ ╙──      	  ^^^
 //│ fun testF: forall 'a. Foo['a] -> 'a
diff --git a/shared/src/test/diff/ucs/InterleavedLet.mls b/shared/src/test/diff/ucs/InterleavedLet.mls
index 1366c27893..a39cc5f1a6 100644
--- a/shared/src/test/diff/ucs/InterleavedLet.mls
+++ b/shared/src/test/diff/ucs/InterleavedLet.mls
@@ -40,7 +40,7 @@ fun p(x, y) =
 //│ ╔══[WARNING] found a duplicated case
 //│ ║  l.39: 	    x is Some and y is Some then 0
 //│ ║        	                       ^^^^
-//│ ╟── the case is covered by pattern Some
+//│ ╟── there is an identical pattern Some
 //│ ║  l.38: 	    y is Some and x is Some then 1
 //│ ╙──      	         ^^^^
 //│ ╔══[ERROR] `y` has 1 missing case
diff --git a/shared/src/test/diff/ucs/OverlappedBranches.mls b/shared/src/test/diff/ucs/OverlappedBranches.mls
index a6ed55f88d..8d06b58398 100644
--- a/shared/src/test/diff/ucs/OverlappedBranches.mls
+++ b/shared/src/test/diff/ucs/OverlappedBranches.mls
@@ -25,13 +25,19 @@ fun f1(x) = if x is
 //│ ║        	  ^^^^^^^^
 //│ ╟── the case is covered by pattern Base
 //│ ║  l.17: 	  Base then "b"
-//│ ╙──      	  ^^^^
+//│ ║        	  ^^^^
+//│ ╟── due to the subtyping relation
+//│ ║  l.4: 	class Derived1() extends Base()
+//│ ╙──     	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╔══[WARNING] found a duplicated case
 //│ ║  l.19: 	  Derived2 then "d2"
 //│ ║        	  ^^^^^^^^
 //│ ╟── the case is covered by pattern Base
 //│ ║  l.17: 	  Base then "b"
-//│ ╙──      	  ^^^^
+//│ ║        	  ^^^^
+//│ ╟── due to the subtyping relation
+//│ ║  l.5: 	class Derived2() extends Base()
+//│ ╙──     	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ fun f1: Base -> "b"
 
 f1(Base())

From 3fb6755c134ab960fa7ddbf94b4bf19f5ac2702d Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 8 May 2024 04:24:13 +0800
Subject: [PATCH 130/147] Mark the cases that are powerless to deal with

---
 .../src/test/diff/pretyper/ucs/coverage/CoveredCases.mls  | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/shared/src/test/diff/pretyper/ucs/coverage/CoveredCases.mls b/shared/src/test/diff/pretyper/ucs/coverage/CoveredCases.mls
index 6895da0d0b..50d8b3125b 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/CoveredCases.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/CoveredCases.mls
@@ -50,7 +50,8 @@ fun f(x) = if
 //│       B*◊ -> 1
 //│ fun f: B -> 1
 
-:w
+// :w
+// FIXME
 :ducs:normalize.result
 fun f(x) = if
   x is A and
@@ -62,12 +63,12 @@ fun f(x) = if
 //│     case x*‡ of
 //│       B*◊ -> 1
 //│ fun f: B -> 1
-//│ TEST CASE FAILURE: There was an unexpected lack of warning
 
 fun p(x) = true: Bool
 //│ fun p: anything -> Bool
 
-:w
+// :w
+// FIXME
 :ducs:normalize.result
 fun f(x) = if
   x is A and
@@ -87,5 +88,4 @@ fun f(x) = if
 //│           _ -> 4
 //│   _ -> 4
 //│ fun f: Object -> (1 | 2 | 4)
-//│ TEST CASE FAILURE: There was an unexpected lack of warning
 

From af6966ec718f6a018cad598182fe245909e23716 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Wed, 8 May 2024 04:29:33 +0800
Subject: [PATCH 131/147] Remove the cyclic node warning and mark the case

---
 .../test/diff/Defunctionalize/OldMonoList.mls | 19 ++-----------------
 .../main/scala/mlscript/ucs/Desugarer.scala   |  7 +------
 2 files changed, 3 insertions(+), 23 deletions(-)

diff --git a/compiler/shared/test/diff/Defunctionalize/OldMonoList.mls b/compiler/shared/test/diff/Defunctionalize/OldMonoList.mls
index 0f87a8577a..93b44c0b1b 100644
--- a/compiler/shared/test/diff/Defunctionalize/OldMonoList.mls
+++ b/compiler/shared/test/diff/Defunctionalize/OldMonoList.mls
@@ -1,6 +1,7 @@
 :NewDefs
 :AllowRuntimeErrors
 
+// FIXME
 :mono
 class List(e: Int, tail: List | Nil) {
   fun map: (Int -> Int) -> List 
@@ -42,23 +43,7 @@ fun add2(x) = x+2
 //│   fun apply$Lambda1$2$3 = (this, x,) => +(x, 1,)
 //│   Code(List(main$$5()))
 //│ }
-//│ ╔══[ERROR] the `if` expression has already been desugared
-//│ ║  l.7: 	  fun map(f)= new List(f(e), tail.map(f))
-//│ ║       	                         ^
-//│ ╙── please make sure that the objects are copied
-//│ class Lambda1$3$4()
-//│ class Nil$2()
-//│ class List$1(e: Int, tail: List$1 | Nil$2)
-//│ class Lambda1$2$3()
-//│ fun map$List$1: (Object, Object) -> List$1
-//│ fun add2$1: Int -> Int
-//│ fun main$$5: () -> List$1
-//│ fun apply$Lambda1$3$4: (anything, Int) -> Int
-//│ fun map$Nil$2: forall 'a. ('a & (List$1 | Nil$2), anything) -> (Nil$2 | 'a)
-//│ fun apply$Lambda1$2$3: (anything, Int) -> Int
-//│ List$1
-//│ res
-//│     = List$1 {}
+//│ /!!!\ Uncaught error: java.lang.Exception: Internal Error: the `if` expression has already been desugared, please make sure that the objects are copied
 
 :mono
 class List(e: Int, tail: List | Nil) {
diff --git a/shared/src/main/scala/mlscript/ucs/Desugarer.scala b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
index 461df9ae0f..a3b70eb226 100644
--- a/shared/src/main/scala/mlscript/ucs/Desugarer.scala
+++ b/shared/src/main/scala/mlscript/ucs/Desugarer.scala
@@ -197,12 +197,7 @@ trait Desugarer extends Transformation
     */
   protected def traverseIf(`if`: If)(implicit scope: Scope): Unit = {
     `if`.desugaredTerm match {
-      case S(desugaredTerm) =>
-        raiseDesugaringError(
-          msg"the `if` expression has already been desugared" -> `if`.getLoc,
-          msg"please make sure that the objects are copied" -> N,
-        )
-        return
+      case S(desugaredTerm) => lastWords("the `if` expression has already been desugared, please make sure that the objects are copied")
       case N => ()
     }
     implicit val context: Context = new Context(`if`)

From e7580b1956a938cf947f9f1ff29f759c3b4aacee Mon Sep 17 00:00:00 2001
From: Luyu Cheng <luyu.cheng@connect.ust.hk>
Date: Thu, 9 May 2024 04:08:57 +0800
Subject: [PATCH 132/147] Improve messages by applying suggestions

Co-authored-by: Lionel Parreaux <lionel.parreaux@gmail.com>
---
 shared/src/main/scala/mlscript/ucs/stages/Normalization.scala | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 69fc7a00f2..85712c640b 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -269,7 +269,7 @@ trait Normalization { self: Desugarer with Traceable =>
                     continuation :++ specializeImpl(tail)
                   } else {
                     raiseDesugaringWarning(
-                      msg"possibly conflicted patterns" -> thatPattern.toLoc,
+                      msg"possibly conflicting patterns" -> thatPattern.toLoc,
                       msg"the scrutinee was matched against ${pattern.toString}" -> pattern.toLoc,
                       msg"which is unrelated with ${thatPattern.toString}" -> thatPattern.toLoc)
                     specializeImpl(tail)
@@ -310,7 +310,7 @@ trait Normalization { self: Desugarer with Traceable =>
                   `-`(if (samePattern) continuation.isFull else full),
                   scrutineeVar, scrutinee, pattern, context)
               } else {
-                println(s"Case 1.2.2: $pattern are unrelated with $thatPattern")
+                println(s"Case 1.2.2: $pattern are unrelated to $thatPattern")
                 split.copy(tail = specializeImpl(tail))
               }
           } else {

From cc2ea600a1149a9a63e6e0392ab8c677cc49427f Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Thu, 9 May 2024 04:16:17 +0800
Subject: [PATCH 133/147] Commit changes to the test output

---
 .../pretyper/ucs/coverage/ConflictedPatterns.mls     | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/shared/src/test/diff/pretyper/ucs/coverage/ConflictedPatterns.mls b/shared/src/test/diff/pretyper/ucs/coverage/ConflictedPatterns.mls
index 727a3ab274..77194e9a67 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/ConflictedPatterns.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/ConflictedPatterns.mls
@@ -24,7 +24,7 @@ fun f(x) = if
 //│ case x*‡ of
 //│   X*◊ -> 2
 //│   _ -> 2
-//│ ╔══[WARNING] possibly conflicted patterns
+//│ ╔══[WARNING] possibly conflicting patterns
 //│ ║  l.21: 	  x is X and x is Y then 1
 //│ ║        	                  ^
 //│ ╟── the scrutinee was matched against X
@@ -47,7 +47,7 @@ fun f(x) = if
 //│ case x*‡ of
 //│   X*◊ -> 3
 //│   _ -> 3
-//│ ╔══[WARNING] possibly conflicted patterns
+//│ ╔══[WARNING] possibly conflicting patterns
 //│ ║  l.43: 	    x is Y then 1
 //│ ║        	         ^
 //│ ╟── the scrutinee was matched against X
@@ -56,7 +56,7 @@ fun f(x) = if
 //│ ╟── which is unrelated with Y
 //│ ║  l.43: 	    x is Y then 1
 //│ ╙──      	         ^
-//│ ╔══[WARNING] possibly conflicted patterns
+//│ ╔══[WARNING] possibly conflicting patterns
 //│ ║  l.44: 	    x is Y then 2
 //│ ║        	         ^
 //│ ╟── the scrutinee was matched against X
@@ -78,7 +78,7 @@ fun f(x) = if
 //│ case x*‡ of
 //│   X*◊ -> 3
 //│   _ -> 3
-//│ ╔══[WARNING] possibly conflicted patterns
+//│ ╔══[WARNING] possibly conflicting patterns
 //│ ║  l.74: 	    x is Y then 1
 //│ ║        	         ^
 //│ ╟── the scrutinee was matched against X
@@ -87,7 +87,7 @@ fun f(x) = if
 //│ ╟── which is unrelated with Y
 //│ ║  l.74: 	    x is Y then 1
 //│ ╙──      	         ^
-//│ ╔══[WARNING] possibly conflicted patterns
+//│ ╔══[WARNING] possibly conflicting patterns
 //│ ║  l.75: 	    x is Z then 2
 //│ ║        	         ^
 //│ ╟── the scrutinee was matched against X
@@ -109,7 +109,7 @@ fun f(x) = if
 //│ case x*‡ of
 //│   X*◊ -> 2
 //│   _ -> 2
-//│ ╔══[WARNING] possibly conflicted patterns
+//│ ╔══[WARNING] possibly conflicting patterns
 //│ ║  l.105: 	    x is Y and
 //│ ║         	         ^
 //│ ╟── the scrutinee was matched against X

From 6030ae7230477e8ae8367ce738fbcfd69e5771f7 Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Thu, 9 May 2024 10:39:16 +0800
Subject: [PATCH 134/147] Rm repeated locations in warning messages

---
 .../mlscript/ucs/stages/Normalization.scala   |  2 +-
 .../ucs/coverage/ConflictedPatterns.mls       | 34 +++++++++----------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
index 85712c640b..f603764720 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/Normalization.scala
@@ -269,7 +269,7 @@ trait Normalization { self: Desugarer with Traceable =>
                     continuation :++ specializeImpl(tail)
                   } else {
                     raiseDesugaringWarning(
-                      msg"possibly conflicting patterns" -> thatPattern.toLoc,
+                      msg"possibly conflicting patterns for this scrutinee" -> scrutineeVar.toLoc,
                       msg"the scrutinee was matched against ${pattern.toString}" -> pattern.toLoc,
                       msg"which is unrelated with ${thatPattern.toString}" -> thatPattern.toLoc)
                     specializeImpl(tail)
diff --git a/shared/src/test/diff/pretyper/ucs/coverage/ConflictedPatterns.mls b/shared/src/test/diff/pretyper/ucs/coverage/ConflictedPatterns.mls
index 77194e9a67..be741c8dcf 100644
--- a/shared/src/test/diff/pretyper/ucs/coverage/ConflictedPatterns.mls
+++ b/shared/src/test/diff/pretyper/ucs/coverage/ConflictedPatterns.mls
@@ -24,9 +24,9 @@ fun f(x) = if
 //│ case x*‡ of
 //│   X*◊ -> 2
 //│   _ -> 2
-//│ ╔══[WARNING] possibly conflicting patterns
+//│ ╔══[WARNING] possibly conflicting patterns for this scrutinee
 //│ ║  l.21: 	  x is X and x is Y then 1
-//│ ║        	                  ^
+//│ ║        	  ^
 //│ ╟── the scrutinee was matched against X
 //│ ║  l.21: 	  x is X and x is Y then 1
 //│ ║        	       ^
@@ -47,18 +47,18 @@ fun f(x) = if
 //│ case x*‡ of
 //│   X*◊ -> 3
 //│   _ -> 3
-//│ ╔══[WARNING] possibly conflicting patterns
-//│ ║  l.43: 	    x is Y then 1
-//│ ║        	         ^
+//│ ╔══[WARNING] possibly conflicting patterns for this scrutinee
+//│ ║  l.42: 	  x is X and
+//│ ║        	  ^
 //│ ╟── the scrutinee was matched against X
 //│ ║  l.42: 	  x is X and
 //│ ║        	       ^
 //│ ╟── which is unrelated with Y
 //│ ║  l.43: 	    x is Y then 1
 //│ ╙──      	         ^
-//│ ╔══[WARNING] possibly conflicting patterns
-//│ ║  l.44: 	    x is Y then 2
-//│ ║        	         ^
+//│ ╔══[WARNING] possibly conflicting patterns for this scrutinee
+//│ ║  l.42: 	  x is X and
+//│ ║        	  ^
 //│ ╟── the scrutinee was matched against X
 //│ ║  l.42: 	  x is X and
 //│ ║        	       ^
@@ -78,18 +78,18 @@ fun f(x) = if
 //│ case x*‡ of
 //│   X*◊ -> 3
 //│   _ -> 3
-//│ ╔══[WARNING] possibly conflicting patterns
-//│ ║  l.74: 	    x is Y then 1
-//│ ║        	         ^
+//│ ╔══[WARNING] possibly conflicting patterns for this scrutinee
+//│ ║  l.73: 	  x is X and
+//│ ║        	  ^
 //│ ╟── the scrutinee was matched against X
 //│ ║  l.73: 	  x is X and
 //│ ║        	       ^
 //│ ╟── which is unrelated with Y
 //│ ║  l.74: 	    x is Y then 1
 //│ ╙──      	         ^
-//│ ╔══[WARNING] possibly conflicting patterns
-//│ ║  l.75: 	    x is Z then 2
-//│ ║        	         ^
+//│ ╔══[WARNING] possibly conflicting patterns for this scrutinee
+//│ ║  l.73: 	  x is X and
+//│ ║        	  ^
 //│ ╟── the scrutinee was matched against X
 //│ ║  l.73: 	  x is X and
 //│ ║        	       ^
@@ -109,9 +109,9 @@ fun f(x) = if
 //│ case x*‡ of
 //│   X*◊ -> 2
 //│   _ -> 2
-//│ ╔══[WARNING] possibly conflicting patterns
-//│ ║  l.105: 	    x is Y and
-//│ ║         	         ^
+//│ ╔══[WARNING] possibly conflicting patterns for this scrutinee
+//│ ║  l.104: 	  x is X and
+//│ ║         	  ^
 //│ ╟── the scrutinee was matched against X
 //│ ║  l.104: 	  x is X and
 //│ ║         	       ^

From a1de9b6bdb4776fa85bb88dddeae33ba1c00838f Mon Sep 17 00:00:00 2001
From: Fa1sePRoMiSe <neilkleist@gmail.com>
Date: Fri, 17 May 2024 17:45:14 +0800
Subject: [PATCH 135/147] Fix statement desugar in `Unquote` (#221)

---
 .../src/main/scala/mlscript/JSBackend.scala   |  35 ++++-
 shared/src/test/diff/qq/Codegen.mls           | 132 ++++++++++++++++++
 2 files changed, 163 insertions(+), 4 deletions(-)

diff --git a/shared/src/main/scala/mlscript/JSBackend.scala b/shared/src/main/scala/mlscript/JSBackend.scala
index c52ba44d63..07197e0388 100644
--- a/shared/src/main/scala/mlscript/JSBackend.scala
+++ b/shared/src/main/scala/mlscript/JSBackend.scala
@@ -298,13 +298,16 @@ abstract class JSBackend {
       else Let(rec, Var(name), desugarQuote(value), desugarQuote(body)(letScope, isQuoted, freeVars))
     case Blk(stmts) =>
       val blkScope = scope.derive("blk")
-      val res = stmts.map {
+      if (isQuoted) createASTCall("Blk", stmts.map {
         case t: Term =>
           desugarQuote(t)(blkScope, isQuoted, freeVars)
         case s => throw CodeGenError(s"statement $s is not supported in quasiquotes")
-      }
-      if (isQuoted) createASTCall("Blk", res)
-      else Blk(res)
+      })
+      else Blk(stmts.map {
+        case t: Term =>
+          desugarQuote(t)(blkScope, isQuoted, freeVars)
+        case s => desugarStatementInUnquote(s)(blkScope, freeVars)
+      })
     case Tup(eles) =>
       def toVar(b: Bool) = if (b) Var("true") else Var("false")
       def toVars(flg: FldFlags) = toVar(flg.mut) :: toVar(flg.spec) :: toVar(flg.genGetter) :: Nil
@@ -345,6 +348,30 @@ abstract class JSBackend {
       throw CodeGenError("this quote syntax is not supported yet.")
   }
 
+  // * Statements inside **Unquote** can refer to quoted code fragments.
+  // * Desugar them recursively.
+  private def desugarStatementInUnquote(s: Statement)(implicit scope: Scope, freeVars: FreeVars): Statement = {
+    implicit val isQuoted: Bool = false
+    s match {
+      case nd @ NuFunDef(isLetRec, nme, symbol, tparams, rhs) =>
+        NuFunDef(isLetRec, nme, symbol, tparams, rhs match {
+          case L(t) => L(desugarQuote(t))
+          case R(t) => R(t)
+        })(nd.declareLoc, nd.virtualLoc, nd.mutLoc, nd.signature, nd.outer, nd.genField, nd.annotations)
+      case nt @ NuTypeDef(kind, nme, tparams, params, ctor, sig, parents, superAnnot, thisAnnot, TypingUnit(body)) =>
+        NuTypeDef(kind, nme, tparams, params, ctor.map(c => desugarStatementInUnquote(c) match {
+          case c: Constructor => c
+          case _ => die
+        }), sig, parents.map(p => desugarQuote(p)), superAnnot, thisAnnot, TypingUnit(body.map(s => desugarStatementInUnquote(s))))(nt.declareLoc, nt.abstractLoc, nt.annotations)
+      case Constructor(ps, body) => Constructor(ps, desugarQuote(body) match {
+        case b: Blk => b
+        case _ => die
+      })
+      case t: Term => desugarQuote(t)
+      case _: LetS | _: DataDefn | _: DatatypeDefn | _: TypeDef | _: Def => die // * Impossible. newDef is true
+    }
+  }
+
   /**
     * Translate MLscript terms into JavaScript expressions.
     */
diff --git a/shared/src/test/diff/qq/Codegen.mls b/shared/src/test/diff/qq/Codegen.mls
index 3665fac844..1eade84a29 100644
--- a/shared/src/test/diff/qq/Codegen.mls
+++ b/shared/src/test/diff/qq/Codegen.mls
@@ -358,3 +358,135 @@ fun foo(dbg) =
 :ne
 code"x => let c = 42 in ${code"x"}"
 //│ Code[forall 'a. 'a -> 'a, nothing]
+
+class Ref[A](init: A) { mut val value: A = init }
+//│ class Ref[A](init: A) {
+//│   mut val value: A
+//│ }
+
+:ne
+:js
+x `=>
+  let v = Ref(x)
+  let _ = y `=>
+    set v.value = y
+    `0
+  v.value
+//│ Code[forall 'a. 'a -> 'a, ??y & ~??x]
+//│ // Prelude
+//│ class TypingUnit30 {}
+//│ const typing_unit30 = new TypingUnit30;
+//│ // Query 1
+//│ res = ((x1) => Lam(Var(x1), (() => {
+//│   let v = Ref(Var(x1));
+//│   let _ = ((y1) => Lam(Var(y1), (() => {
+//│     void(v.value = Var(y1));
+//│     return IntLit(0);
+//│   })()))(freshName("y"));
+//│   return v.value;
+//│ })()))(freshName("x"));
+//│ // End of generated code
+
+:ne
+:js
+x `=>
+  class A(y: Code[Int, nothing]) {
+    val z = x `+ y
+  }
+  A(`0).z
+//│ Code[Int -> Int, nothing]
+//│ // Prelude
+//│ class TypingUnit31 {}
+//│ const typing_unit31 = new TypingUnit31;
+//│ // Query 1
+//│ res = ((x1) => Lam(Var(x1), (() => {
+//│   const A = (() => {
+//│     class A {
+//│       #y;
+//│       #z;
+//│       get z() { return this.#z; }
+//│       constructor(y) {
+//│         this.#y = y;
+//│         this.#z = App(Var("+"), Var(x1), y);
+//│         const z = this.#z;
+//│       }
+//│     static
+//│       unapply(x) {
+//│         return [x.#y];
+//│       }
+//│     }
+//│     let ctor;
+//│     ctor = ((y) => new A(y));
+//│     ctor.class = A;
+//│     return ctor;
+//│   })();
+//│   return A(IntLit(0)).z;
+//│ })()))(freshName("x"));
+//│ // End of generated code
+
+:ne
+:js
+x `=>
+  class A() {
+    constructor() {
+      log(x)
+    }
+  }
+  new A(), x
+//│ Code[forall 'a. 'a -> 'a, nothing]
+//│ // Prelude
+//│ class TypingUnit32 {}
+//│ const typing_unit32 = new TypingUnit32;
+//│ // Query 1
+//│ res = ((x1) => Lam(Var(x1), (() => {
+//│   const A = (() => {
+//│     class A {
+//│       constructor() {
+//│         log(Var(x1));
+//│       }
+//│     static
+//│       unapply(x) {
+//│         return [];
+//│       }
+//│     }
+//│     let ctor;
+//│     ctor = (() => new A());
+//│     ctor.class = A;
+//│     return ctor;
+//│   })();
+//│   return new A.class() , Var(x1);
+//│ })()))(freshName("x"));
+//│ // End of generated code
+
+class Foo(x: Code[Int, anything])
+//│ class Foo(x: Code[Int, anything])
+
+:ne
+:js
+x `=>
+  class B() extends Foo(x)
+  `x
+//│ Code[forall 'a. (Int & 'a) -> 'a, nothing]
+//│ // Prelude
+//│ class TypingUnit34 {}
+//│ const typing_unit34 = new TypingUnit34;
+//│ // Query 1
+//│ res = ((x1) => Lam(Var(x1), (() => {
+//│   const B = (() => {
+//│     class B extends Foo.class {
+//│       constructor() {
+//│         super(Var(x1));
+//│       }
+//│     static
+//│       unapply(x) {
+//│         return [];
+//│       }
+//│     }
+//│     let ctor;
+//│     ctor = (() => new B());
+//│     ctor.class = B;
+//│     return ctor;
+//│   })();
+//│   return Var(x1);
+//│ })()))(freshName("x"));
+//│ // End of generated code

From f8cd23f3a462b2d27221b7e3efd94c835721959a Mon Sep 17 00:00:00 2001
From: Luyu Cheng <chengluyu@live.cn>
Date: Thu, 23 May 2024 11:36:08 +0800
Subject: [PATCH 136/147] Address remaining issues mentioned in the PR

---
 .../scala/mlscript/ucs/context/Context.scala  |  4 +-
 .../ucs/stages/CoverageChecking.scala         |  2 +-
 .../pretyper/ucs/SpecilizationCollision.mls   | 55 +++++++------------
 3 files changed, 23 insertions(+), 38 deletions(-)

diff --git a/shared/src/main/scala/mlscript/ucs/context/Context.scala b/shared/src/main/scala/mlscript/ucs/context/Context.scala
index 65fa9a58e1..870113eda0 100644
--- a/shared/src/main/scala/mlscript/ucs/context/Context.scala
+++ b/shared/src/main/scala/mlscript/ucs/context/Context.scala
@@ -9,7 +9,7 @@ import pretyper.Scope
 
 class Context(originalTerm: If) {
   /** The prefix of all prefixes. */
-  private val prefix = Context.freshPrefix()
+  private val prefix = Context.freshPrefix
   private val cachePrefix = prefix + "$cache$"
   private val scrutineePrefix = prefix + "$scrut$"
   private val testPrefix = prefix + "$test$"
@@ -60,5 +60,5 @@ class Context(originalTerm: If) {
 }
 
 object Context {
-  private def freshPrefix(): Str = "ucs"
+  private val freshPrefix: Str = "ucs"
 }
diff --git a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
index 8f3d3e8389..13baf2eac4 100644
--- a/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
+++ b/shared/src/main/scala/mlscript/ucs/stages/CoverageChecking.scala
@@ -3,7 +3,7 @@ package ucs
 package stages
 
 import utils._, shorthands._, Message.MessageContext
-import ucs.context.{Context, Pattern, Scrutinee}
+import context.{Context, Pattern, Scrutinee}
 import pretyper.Traceable, pretyper.symbol._
 
 trait CoverageChecking { self: Desugarer with Traceable =>
diff --git a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
index 5caea1d3bf..3d900e5f63 100644
--- a/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
+++ b/shared/src/test/diff/pretyper/ucs/SpecilizationCollision.mls
@@ -38,7 +38,8 @@ class Derived(y: Int) extends Base(y + 1)
 //│ class Base(x: Int)
 //│ class Derived(y: Int) extends Base
 
-:ducs:postprocess.result,coverage
+// Notice that Derived is not in the inferred type.
+:ducs:postprocess.result
 fun example3(t) =
   if t is
     Base(x) and p1(x) then x
@@ -60,42 +61,13 @@ fun example3(t) =
 //│             y
 //│           _ -> 42
 //│   _ -> 42
-//│ | | | | | | | STEP 4
-//│ | | | | | | | collected match registry: 
-//│ | | | | | | | >>> t => [class `Base`, class `Derived`]
-//│ | | | | | | | >>> x => []
-//│ | | | | | | | >>> y => []
-//│ | | | | | | | checkCoverage <== 0 pending, 3 working, 0 seen
-//│ | | | | | | | | CASE t
-//│ | | | | | | | | SEEN: empty
-//│ | | | | | | | | class symbol: `Base`
-//│ | | | | | | | | REMOVE `Base` from working
-//│ | | | | | | | | unseen: [class `Base`, class `Derived`]
-//│ | | | | | | | | remaining: []
-//│ | | | | | | | | checkCoverage <== LET `ucs$args_t$Base`
-//│ | | | | | | | | checkCoverage <== LET `x`
-//│ | | | | | | | | checkCoverage <== LET `ucs$test$0`
-//│ | | | | | | | | checkCoverage <== TEST `ucs$test$0`
-//│ | | | | | | | | checkCoverage <== TERM x
-//│ | | | | | | | | checkCoverage <== 0 pending, 2 working, 1 seen
-//│ | | | | | | | | | CASE t
-//│ | | | | | | | | | SEEN: t is Base
-//│ | | | | | | | | | class symbol: `Derived`
-//│ | | | | | | | | | REMOVE `Derived` from working
-//│ | | | | | | | | | unseen: [class `Derived`]
-//│ | | | | | | | | | remaining: []
-//│ | | | | | | | | | checkCoverage <== LET `ucs$args_t$Derived`
-//│ | | | | | | | | | checkCoverage <== LET `y`
-//│ | | | | | | | | | checkCoverage <== TERM y
-//│ | | | | | | | | | remaining cases should be covered by the wildcard
-//│ | | | | | | | | | checkCoverage <== TERM 42
-//│ | | | | | | | | checkCoverage ==> 0 diagnostics
-//│ | | | | | | | | remaining cases should be covered by the wildcard
-//│ | | | | | | | | checkCoverage <== TERM 42
-//│ | | | | | | | checkCoverage ==> 0 diagnostics
-//│ | | | | | | | Coverage checking result: 0 errors
 //│ fun example3: forall 'a. (Base & {#x: Num & 'a} | Object & ~#Base) -> (Int | 'a)
 
+example3(Derived(1))
+//│ Int
+//│ res
+//│     = 1
+
 fun example4(t, x) =
   if t is
     Base(x) and p1(x) then x
@@ -119,3 +91,16 @@ example4(Derived(1), 4) ~~> 5
 //│ "passed"
 //│ res
 //│     = 'passed'
+
+class Base(x: Int)
+class Derived[A](y: A) extends Base(1)
+//│ class Base(x: Int)
+//│ class Derived[A](y: A) extends Base
+
+// Notice that now Derived is generic, so it's appear in the inferred type.
+fun example5(t) =
+  if t is
+    Base(x) and p1(x) then x
+    Derived(y) then y
+    else 42
+//│ fun example5: forall 'a 'b. (Base & {#x: Num & 'a} & ~#Derived | Derived['b] & {#x: Num & 'a} | Object & ~#Base) -> (42 | 'a | 'b)

From 69738faa577ca3052a590fae931acd44bd60cf89 Mon Sep 17 00:00:00 2001
From: Lionel Parreaux <lionel.parreaux@gmail.com>
Date: Thu, 23 May 2024 21:53:11 +0800
Subject: [PATCH 137/147] Add test to point out current limitation in `unapply`
 support

---
 shared/src/test/diff/nu/Unapply.mls | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/shared/src/test/diff/nu/Unapply.mls b/shared/src/test/diff/nu/Unapply.mls
index ea8edd658d..a74556a84c 100644
--- a/shared/src/test/diff/nu/Unapply.mls
+++ b/shared/src/test/diff/nu/Unapply.mls
@@ -66,6 +66,20 @@ DT.unapply({ x: 42 })
 //│   TypeError: Cannot read private member #x from an object whose class did not declare it
 
 
+// * Currently, support for unapply is pretty broken: it accesses an _unqualified_ private field
+// * although the same private field may be defined in different classes of the same hierarchy,
+// * which leads to unsoundness:
+
+class DS(x: Int) extends DT[Str]("a")
+//│ class DS(x: Int) extends DT
+
+// * Wrong type!
+DT.unapply(DS(42))
+//│ [Int]
+//│ res
+//│     = [ 'a' ]
+
+
 // * TODO improve `unapply` logic: currently it picks up shadowing fields/methods
 
 class Foo(x: Int) {
@@ -98,8 +112,8 @@ if Foo(123) is Foo(a) then a
 fun D(x: Int) = {x}
 module D { fun unapply(a) = [a.x] }
 //│ ╔══[ERROR] Redefinition of 'D'
-//│ ║  l.99: 	module D { fun unapply(a) = [a.x] }
-//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.113: 	module D { fun unapply(a) = [a.x] }
+//│ ╙──       	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ fun D: (x: Int) -> {x: Int}
 //│ module D {
 //│   fun unapply: forall 'x. {x: 'x} -> ['x]

From 211430d1ada45861743d3840020e2676c0e4ed18 Mon Sep 17 00:00:00 2001
From: HarrisL2 <harris.yh.lau@gmail.com>
Date: Tue, 18 Jun 2024 13:27:06 +0800
Subject: [PATCH 138/147] Defunctionalization with simple-sub Control-flow
 Analysis (#222)

---
 .../scala/mlscript/compiler/ClassLifter.scala |  21 +-
 .../scala/mlscript/compiler/Helpers.scala     |  70 ---
 .../mlscript/compiler/mono/Monomorph.scala    | 268 -----------
 .../compiler/mono/MonomorphError.scala        |   3 -
 .../mono/specializer/BoundedTerm.scala        | 180 -------
 .../mono/specializer/Specializer.scala        | 248 ----------
 .../compiler/simpledef/Simpledef.scala        | 455 ++++++++++++++++++
 .../mlscript/compiler/simpledef/Uid.scala     |  18 +
 .../diff/Defunctionalize/ClassConstructor.mls |  82 ++++
 .../test/diff/Defunctionalize/Classes.mls     |  70 +--
 .../diff/Defunctionalize/ClosureCapture.mls   |  65 +--
 .../test/diff/Defunctionalize/Constructor.mls |  57 +--
 .../Defunctionalize/DelayedEvaluation.mls     |  67 +--
 .../diff/Defunctionalize/Differentiation.mls  | 160 +++---
 .../diff/Defunctionalize/FreeVariables.mls    |  29 +-
 .../diff/Defunctionalize/FuncsWithParams.mls  |  53 +-
 .../test/diff/Defunctionalize/Inheritance.mls |  45 +-
 .../test/diff/Defunctionalize/Lambda.mls      |  22 +
 .../test/diff/Defunctionalize/Lambdas.mls     |  47 +-
 .../diff/Defunctionalize/ListConstruction.mls |  80 ++-
 .../test/diff/Defunctionalize/Modules.mls     |  38 +-
 .../diff/Defunctionalize/MonoNonLambda.mls    |  68 ++-
 .../diff/Defunctionalize/MonoTupSelect.mls    |  35 +-
 .../diff/Defunctionalize/MutableParams.mls    |   4 -
 .../test/diff/Defunctionalize/MutualRec.mls   |  35 +-
 .../test/diff/Defunctionalize/NewOperator.mls |  29 +-
 .../test/diff/Defunctionalize/NuMono.mls      |  83 ++--
 .../diff/Defunctionalize/ObjFieldAccess.mls   | 214 ++++----
 .../test/diff/Defunctionalize/ObjFields.mls   |  34 ++
 .../diff/Defunctionalize/ObjMultiFields.mls   |  40 ++
 .../diff/Defunctionalize/ObjsSelection.mls    |  42 ++
 .../test/diff/Defunctionalize/OldMonoList.mls | 252 ++++------
 .../test/diff/Defunctionalize/Polymorphic.mls |  49 +-
 .../test/diff/Defunctionalize/Record.mls      |  31 ++
 .../diff/Defunctionalize/RecursiveFunc.mls    |  45 +-
 .../diff/Defunctionalize/SelfReference.mls    |  26 +-
 .../diff/Defunctionalize/SimpleClasses.mls    |  63 +--
 .../Defunctionalize/SimpleConditionals.mls    |  46 +-
 .../test/diff/Defunctionalize/SimpleFunc.mls  |  73 ++-
 .../test/diff/Defunctionalize/Simpledef.mls   |  82 ++++
 .../test/diff/Defunctionalize/TupleSelect.mls |  12 +
 .../diff/Lifter/FunctionTypeAnnotations.mls   |  34 +-
 compiler/shared/test/diff/Lifter/LambLift.mls |  39 +-
 compiler/shared/test/diff/Lifter/LiftNew.mls  |   4 -
 compiler/shared/test/diff/Lifter/LiftType.mls |   5 +
 compiler/shared/test/diff/Lifter/Lifter.mls   |  25 +-
 .../shared/test/diff/Lifter/LifterBlks.mls    |  36 +-
 .../shared/test/diff/Lifter/NestedClasses.mls |   4 -
 .../shared/test/diff/Lifter/NestedFuncs.mls   |   4 -
 .../diff/Lifter/ParameterizedInheritance.mls  |  54 +--
 .../test/diff/Lifter/TypedClassParams.mls     |   1 -
 .../test/scala/mlscript/compiler/Test.scala   |  45 +-
 .../src/test/scala/mlscript/DiffTests.scala   |  23 +-
 53 files changed, 1603 insertions(+), 2012 deletions(-)
 delete mode 100644 compiler/shared/main/scala/mlscript/compiler/Helpers.scala
 delete mode 100644 compiler/shared/main/scala/mlscript/compiler/mono/Monomorph.scala
 delete mode 100644 compiler/shared/main/scala/mlscript/compiler/mono/MonomorphError.scala
 delete mode 100644 compiler/shared/main/scala/mlscript/compiler/mono/specializer/BoundedTerm.scala
 delete mode 100644 compiler/shared/main/scala/mlscript/compiler/mono/specializer/Specializer.scala
 create mode 100644 compiler/shared/main/scala/mlscript/compiler/simpledef/Simpledef.scala
 create mode 100644 compiler/shared/main/scala/mlscript/compiler/simpledef/Uid.scala
 create mode 100644 compiler/shared/test/diff/Defunctionalize/ClassConstructor.mls
 create mode 100644 compiler/shared/test/diff/Defunctionalize/Lambda.mls
 create mode 100644 compiler/shared/test/diff/Defunctionalize/ObjFields.mls
 create mode 100644 compiler/shared/test/diff/Defunctionalize/ObjMultiFields.mls
 create mode 100644 compiler/shared/test/diff/Defunctionalize/ObjsSelection.mls
 create mode 100644 compiler/shared/test/diff/Defunctionalize/Record.mls
 create mode 100644 compiler/shared/test/diff/Defunctionalize/Simpledef.mls
 create mode 100644 compiler/shared/test/diff/Defunctionalize/TupleSelect.mls

diff --git a/compiler/shared/main/scala/mlscript/compiler/ClassLifter.scala b/compiler/shared/main/scala/mlscript/compiler/ClassLifter.scala
index 1447af75d4..533ab83b16 100644
--- a/compiler/shared/main/scala/mlscript/compiler/ClassLifter.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/ClassLifter.scala
@@ -8,7 +8,8 @@ import scala.collection.mutable.Map as MutMap
 import scala.collection.mutable.Set as MutSet
 import scala.collection.mutable.ArrayBuffer as ArrayBuffer
 import mlscript.codegen.CodeGenError
-import mlscript.compiler.mono.MonomorphError
+
+class CompilerError(error: String) extends Error(error)
 
 class ClassLifter(logDebugMsg: Boolean = false) {
   type ClassName = String
@@ -249,7 +250,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
       val nE = liftTerm(expr)
       val nR = liftTerm(rhs)
       (IfThen(nE._1, nR._1), nE._2 ++ nR._2)
-    case _ => throw MonomorphError(s"Unknown IfBody: ${body}")
+    case _ => throw CompilerError(s"Unknown IfBody: ${body}")
   }
 
   private def liftTuple(tup: Tup)(using ctx: LocalContext, cache: ClassCache, globFuncs: Map[Var, (Var, LocalContext)], outer: Option[ClassInfoCache]): (Tup, LocalContext) = {
@@ -399,7 +400,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
     case Sel(receiver, fieldName) =>
       val nRec = liftTerm(receiver)
       (Sel(nRec._1, fieldName), nRec._2)
-    case Splc(fields) => throw MonomorphError(s"Unimplemented liftTerm: ${target}")
+    case Splc(fields) => throw CompilerError(s"Unimplemented liftTerm: ${target}")
     case Subs(arr, idx) =>
       val (ltrm, lctx) = liftTerm(arr)
       val (rtrm, rctx) = liftTerm(idx)
@@ -412,7 +413,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
       val ret = liftTerm(lhs)
       val nTs = targs.map(liftType).unzip
       (TyApp(ret._1, nTs._1), nTs._2.fold(ret._2)(_ ++ _))
-    case With(trm, fields) => throw MonomorphError(s"Unimplemented liftTerm: ${target}")
+    case With(trm, fields) => throw CompilerError(s"Unimplemented liftTerm: ${target}")
     case New(Some((t: TypeName, prm: Tup)), TypingUnit(Nil)) =>
       val ret = liftConstr(t, prm)
       (New(Some((ret._1, ret._2)), TypingUnit(Nil)), ret._3)
@@ -432,7 +433,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
       val nSta = New(Some((nTpNm, Tup(Nil))), TypingUnit(Nil))
       val ret = liftEntities(List(anoCls, nSta))
       (Blk(ret._1), ret._2)
-    case New(head, body) => throw MonomorphError(s"Unimplemented liftTerm: ${target}")
+    case New(head, body) => throw CompilerError(s"Unimplemented liftTerm: ${target}")
     case Blk(stmts) =>
       val ret = liftEntities(stmts)
       (Blk(ret._1), ret._2)
@@ -447,7 +448,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
       val (bod2, ctx) = liftTerm(bod)
       val (sts2, ctx2) = liftEntities(sts)
       (Where(bod2, sts2), ctx2)
-    case _: Eqn | _: Super | _: Rft | _: While | _: Quoted | _: Unquoted | _: Ann => throw MonomorphError(s"Unimplemented liftTerm: ${target}") // TODO
+    case _: Eqn | _: Super | _: Rft | _: While | _: Quoted | _: Unquoted | _: Ann => throw CompilerError(s"Unimplemented liftTerm: ${target}") // TODO
     case patmat: AdtMatchWith => lastWords(s"Cannot liftTermNew ${patmat}")
   }
 
@@ -484,7 +485,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
           ((v, Fld(flags, tmp._1)), tmp._2)
       }.unzip
       (Rcd(ret._1), ret._2.fold(emptyCtx)(_ ++ _))
-    case _ => throw MonomorphError(s"Unimplemented liftTermAsType: ${target}")
+    case _ => throw CompilerError(s"Unimplemented liftTermAsType: ${target}")
   }
 
   private def liftTypeName(target: TypeName)(using ctx: LocalContext, cache: ClassCache, globFuncs: Map[Var, (Var, LocalContext)], outer: Option[ClassInfoCache]): (TypeName, LocalContext) = {
@@ -578,7 +579,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
       val (body2, ctx) = liftType(body)
       PolyType(targs, body2) -> ctx
     case Top | Bot | _: Literal | _: TypeTag | _: TypeVar => target.asInstanceOf[Type] -> emptyCtx
-    case _: Selection => throw MonomorphError(s"Unimplemented liftType: ${target}") // TODO
+    case _: Selection => throw CompilerError(s"Unimplemented liftType: ${target}") // TODO
   }
   
 
@@ -602,7 +603,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
         }.unzip
         (func.copy(rhs = Right(PolyType(nTargs._1, nBody._1)))(func.declareLoc, func.virtualLoc, func.mutLoc, func.signature, func.outer, func.genField, func.annotations),
           nTargs._2.fold(nBody._2)(_ ++ _))
-      case _ => throw MonomorphError(s"Unimplemented liftMemberFunc: ${func}") // TODO
+      case _ => throw CompilerError(s"Unimplemented liftMemberFunc: ${func}") // TODO
     }
   }
 
@@ -629,7 +630,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
               case (tn, ctx) => (L(tn), ctx)
           case R(tv) => R(tv) -> emptyCtx}).unzip
         NuFunDef(rec, globFuncs.get(nm).get._1, N, nTpVs, Right(PolyType(nTargs._1, nBody._1)))(N, N, N, N, N, true, Nil) 
-      case _ => throw MonomorphError(s"Unimplemented liftGlobalFunc: ${func}")
+      case _ => throw CompilerError(s"Unimplemented liftGlobalFunc: ${func}")
     })
   }
   
diff --git a/compiler/shared/main/scala/mlscript/compiler/Helpers.scala b/compiler/shared/main/scala/mlscript/compiler/Helpers.scala
deleted file mode 100644
index 627b2b7963..0000000000
--- a/compiler/shared/main/scala/mlscript/compiler/Helpers.scala
+++ /dev/null
@@ -1,70 +0,0 @@
-package mlscript
-package compiler
-
-import mlscript.compiler.mono.*
-import scala.collection.mutable.ArrayBuffer
-
-type NuParameter = (FldFlags, Var, Option[Term])
-
-object Helpers:
-  /**
-   * Extract parameters for monomorphization from a `Tup`.
-   */  
-  def extractLamParams(term: Term): Option[List[NuParameter]] = term match
-    case Lam(Tup(fields), _) => Some(fields.flatMap {
-      case (_, Fld(FldFlags(_, _, _), UnitLit(true))) => None
-      case (None, Fld(flags, name: Var)) => Some((flags, name, None))
-      case (None, Fld(flags, Bra(_, name: Var))) => Some((flags, name, None))
-      case (Some(name: Var), Fld(flags, typename: Term)) => Some((flags, name, Some(typename)))
-      case _ => throw MonomorphError(
-        s"Encountered unexpected structure when extracting parameters: ${term}"
-      )
-    })
-    case _ => None //FIXME: Silent failure? Improve semantics
-
-  def extractObjParams(term: Term): Iterator[NuParameter] = term match
-    case Tup(fields) => fields.iterator.flatMap {
-      case (_, Fld(FldFlags(_, _, _), UnitLit(true))) => None
-      case (None, Fld(flags, name: Var)) => Some((flags, name, None))
-      case (None, Fld(flags, Bra(_, name: Var))) => Some((flags, name, None))
-      case (Some(name: Var), Fld(flags, typename: Term)) => Some((flags, name, Some(typename)))
-      case _ => throw MonomorphError(s"Encountered unexpected structure when extracting parameters: ${term}")
-    }
-    case _ => throw MonomorphError(s"Encountered unexpected structure when extracting parameters: ${term}")
-
-  def extractLamBody(term: Term): Term = term match
-    case Lam(_, body) => body
-    case _ => throw MonomorphError(s"Attempted to extract Lambda Body from ${term}")
-
-  def toTuple(args: List[Term]): Tup =
-    Tup(args.map{term => (None, Fld(FldFlags.empty, term))})
-
-  def paramToTuple(args: List[NuParameter]): Tup = 
-  Tup(args.map{
-    case (flags, name, None) => (None, Fld(flags, name))
-    case (flags, name, Some(typename)) => (Some(name), Fld(flags, typename))
-  })
-  
-  /*
-  * If term is not a Lambda, turn it into a lambda with a "this" parameter
-  * If term is already a Lambda, add a "this" parameter to the front of the parameter list
-  */
-  def addThisParam(term: Term): Term = term match
-    case Lam(Tup(fields), rhs) => Lam(Tup((None, Fld(FldFlags.empty, Var("this")))::fields), rhs)
-    case rhs => Lam(Tup((None, Fld(FldFlags.empty, Var("this")))::Nil), rhs)
-
-  // OLD FIXME: Loses tuple information in conversion
-  def toFuncArgs(term: Term): IterableOnce[Term] = term match
-    // The new parser generates `(undefined, )` when no arguments.
-    // Let's do this temporary fix.
-    case Tup((_, Fld(FldFlags(_, _, _), UnitLit(true))) :: Nil) => Iterable.empty
-    case Tup(fields) => fields.iterator.map(_._2.value)
-    case _ => Some(term)
-  
-  def extractFuncArgs(term: Term): List[Term] = term match
-    // The new parser generates `(undefined, )` when no arguments.
-    // Let's do this temporary fix.
-    case Tup((_, Fld(FldFlags(_, _, _), UnitLit(true))) :: Nil) => ???
-    case Tup(fields) => fields.map(_._2.value)
-    case _ => throw MonomorphError("Unknown structure in FuncArgs")
-  
diff --git a/compiler/shared/main/scala/mlscript/compiler/mono/Monomorph.scala b/compiler/shared/main/scala/mlscript/compiler/mono/Monomorph.scala
deleted file mode 100644
index 930a3f0d34..0000000000
--- a/compiler/shared/main/scala/mlscript/compiler/mono/Monomorph.scala
+++ /dev/null
@@ -1,268 +0,0 @@
-package mlscript
-package compiler
-package mono
-
-import scala.collection.immutable.{HashMap, ListMap}
-import scala.collection.mutable.{Map as MutMap, Set as MutSet}
-import scala.collection.mutable.ListBuffer
-import java.util.IdentityHashMap
-import scala.collection.JavaConverters._
-import mlscript.Mod
-
-class Monomorph(debug: Debug = DummyDebug):
-  import Helpers._
-  import Monomorph._
-
-  /**
-   * Specialized implementations of function declarations.
-   * function name -> (function, mutable parameters (?), parameters, output value)
-   */
-  private val funImpls = MutMap[String, (NuFunDef, MutMap[String, NuFunDef], Option[List[BoundedTerm]], VarVal)]()
-
-  private val funDependence = MutMap[String, Set[String]]()
-
-  val evalQueue = MutSet[String]()
-  val evalCnt = MutMap[String, Int]()
-  
-  private val allTypeImpls = MutMap[String, NuTypeDef]()
-
-  private def addType(typeDef: NuTypeDef) =
-    allTypeImpls.addOne(typeDef.name, typeDef)
-  
-  val specializer = new Specializer(this)(using debug)
-
-
-  object VarValMap {
-    var vxCnt: Int = 0
-    val vMap: MutMap[Int, BoundedTerm] = MutMap[Int, BoundedTerm]()
-    def get(v: VarVal): BoundedTerm = vMap.get(v.vx) match 
-      case Some(value) => value
-      case None => ???
-    def refresh(): VarVal = {
-      vxCnt += 1
-      val ret = VarVal(vxCnt, 0, get)
-      vMap.addOne(vxCnt -> BoundedTerm(ret))
-      ret
-    }
-    def update(v: VarVal, s: BoundedTerm): Unit = {
-      debug.writeLine(s"Updating vMap ${v.vx} with ${s}")
-      vMap.update(v.vx, s)
-    }
-  }
-
-  val evaluationMap = new IdentityHashMap[Term, BoundedTerm]().asScala
-  def getRes(term: Term): BoundedTerm = evaluationMap.getOrElse(term, throw MonomorphError(s"Bounds for ${term} not found."))
-
-  private def addFunction(func: NuFunDef): Unit = {
-    debug.writeLine(s"Adding Function ${func}")
-    funImpls.addOne(func.name, (func, MutMap(), func.body match
-      case Lam(Tup(params), body) => Some(params.map(_ => BoundedTerm()))
-      case _ => None
-    , VarValMap.refresh()))
-    funDependence.addOne(func.name, Set())
-  }
-
-  private def getResult(mains: List[Statement]): List[Statement] = 
-    List[Statement]()
-    .concat(allTypeImpls.values.map(_.copy(body = TypingUnit(Nil))(None, None, Nil)))
-    .concat(funImpls.values.map(_._1))
-    .concat(mains)
-  
-  def defunctionalize(tu: TypingUnit): TypingUnit =
-    val nuTerms = tu.entities.zipWithIndex.flatMap {
-      case (term: Term, i) =>
-        val mainFunc = NuFunDef(None, Var(s"main$$$$$i"), None, Nil, Left(Lam(Tup(Nil), term)))(None, None, None, None, None, false, Nil)
-        addFunction(mainFunc)
-        evalQueue.add(mainFunc.name)
-        Some(App(Var(s"main$$$$$i"), Tup(Nil)))
-      case (tyDef: NuTypeDef, _) =>
-        addType(tyDef)
-        None
-      case (funDef: NuFunDef, _) =>
-        funDef.rhs match
-          case Left(value) => addFunction(funDef)
-          case Right(value) => ??? 
-        None
-      case _ => ???
-    }
-    while (!evalQueue.isEmpty) {
-      debug.writeLine(s"Queue: ${evalQueue}")
-      val next = evalQueue.head
-      evalQueue.remove(next)
-      updateFunc(next)
-    }
-    debug.writeLine(s"${PrettyPrinter.showTypingUnit(TypingUnit(getResult(nuTerms)))}")
-    debug.writeLine(s"========DEFUNC PHASE========")
-    funImpls.mapValuesInPlace{
-      case (_, (func@NuFunDef(isLetRec, nm, sn, tp, rhs), mp, la, lr)) =>
-        rhs match 
-          case Left(Lam(lhs, rhs)) =>
-            (NuFunDef(isLetRec, nm, sn, tp, Left(Lam(lhs,specializer.defunctionalize(rhs)(using evaluationMap))))(None, None, None, None, None, false, Nil), mp, la, lr)
-          case Left(body) => 
-            (NuFunDef(isLetRec, nm, sn, tp, Left(specializer.defunctionalize(body)(using evaluationMap)))(None, None, None, None, None, false, Nil), mp, la, lr)
-          case Right(tp) => ???
-    }
-    val ret = getResult(nuTerms)
-    TypingUnit(ret)
-
-  def getFuncRetVal(name: String, args: Option[List[BoundedTerm]])(using evalCtx: Map[String, BoundedTerm], callingStack: List[String]): BoundedTerm = {
-    funImpls.get(name) match
-      case None => throw MonomorphError(s"Function ${name} does not exist")
-      case Some((funDef, mp, oldArgs, vals)) => 
-        funDef.rhs match
-          case Left(body) => 
-            funDependence.update(name, funDependence.getOrElse(name, Set()) ++ callingStack.headOption)
-            val hasArgs = oldArgs.isDefined
-            val params = extractLamParams(body)
-            val mergedArgs = oldArgs.map(old => (old zip (args.get)).map(_ ++ _).zip(params.get).map(
-              (x,y) => /*if(y._1.spec) then x else x.literals2Prims*/ x // TODO: Specialization for literals
-            ))
-            debug.writeLine(s"old args ${oldArgs}")
-            debug.writeLine(s"new args ${args}")
-            debug.writeLine(s"merged args ${mergedArgs}")
-            // FIXME: do paramless funcs need multiple evaluations? currently only eval paramless funcs once
-            if (!evalCnt.contains(name) || (hasArgs && (oldArgs.get zip mergedArgs.get).exists(x => x._1.compare(x._2)))) {
-              funImpls.update(name, (funDef, mp, mergedArgs, vals))
-              if(!evalQueue.contains(name))
-                if(!evalCnt.contains(name))
-                  then 
-                    debug.writeLine(s"first time eval function ${name}")
-                    updateFunc(name)
-                  else 
-                    debug.writeLine(s"new arg eval function ${name}")
-                    evalQueue.add(name)
-            }
-            BoundedTerm(funImpls.get(name).get._4)
-          case Right(tp) => ???
-  }
-
-  private def updateFunc(funcName: String): Unit = {
-    val updateCount = evalCnt.get(funcName).getOrElse(0)
-    if(updateCount > 10){
-      throw new MonomorphError("stack overflow!!!")
-    }
-    debug.writeLine(s"updating ${funcName} for ${updateCount}th time")
-    evalCnt.update(funcName, updateCount+1)
-    debug.writeLine(s"Evaluating ${funcName}")
-    val (func, mps, args, res) = funImpls.get(funcName).get
-    debug.writeLine(s"args = ${args}")
-    func.rhs match
-      case Left(value) =>
-        val params = extractLamParams(value) 
-        val body = params match 
-          case Some(_) => extractLamBody(value) 
-          case None => value
-        val ctx = params match
-          case Some(p) => 
-            if p.length != args.get.length
-            then throw MonomorphError("Argument length mismatch in function update")
-            else (p.map(_._2.name) zip args.get).toMap
-          case None => Map()
-        specializer.evaluate(body)(using ctx, List(func.name), evaluationMap)
-        evaluationMap.addOne(value, getRes(body))
-        val oldExp = VarValMap.get(funImpls.get(funcName).get._4)
-        if (oldExp.compare(getRes(value))) {
-          debug.writeLine(s"Bounds of ${funcName} changed, adding dependent functions to evalQueue")
-          debug.writeLine(s"Before: ${oldExp}")
-          debug.writeLine(s"After : ${getRes(value)}")
-          funDependence.get(funcName).get.foreach(x => if !evalQueue.contains(x) then {
-            debug.writeLine(s"Added ${x}")
-            evalQueue.add(x)
-          })
-        } else {
-          debug.writeLine(s"No change in bounds of ${funcName}")
-        }
-        //debug.writeLine(s"old body: ${showStructure(value)} => new body: ${showStructure(nuBody)}")
-        funImpls.updateWith(funcName)(_.map(x => {
-          VarValMap.update(x._4, getRes(value))
-          (x._1, x._2, x._3, x._4)
-        }))
-      case Right(value) => throw MonomorphError("Should not update function typeDef")
-  }
-
-  /*
-    Find a variable in the global env 
-  */
-  def findVar(name: String)(using evalCtx: Map[String, BoundedTerm], callingStack: List[String]): BoundedTerm =
-    funImpls.get(name) match
-      case Some(res) =>
-        val (func, _, _, _) = res
-        funDependence.update(name, funDependence.get(name).get ++ callingStack.headOption)
-        val params = func.rhs match
-          case Left(body) => extractLamParams(body).map(_.map(_._2.name).toList)
-          case Right(tp) => ???
-        params match 
-          case Some(p) => BoundedTerm(FuncVal(name, params, Nil))
-          case None => 
-            val res = getFuncRetVal(name, None)
-            res
-      case None => 
-        allTypeImpls.get(name) match
-          case Some(res) if res.kind == Cls => BoundedTerm(TypeVal(name))
-          case Some(res) if res.kind == Mod => BoundedTerm(createObjValue(name, Nil))
-          case None => throw MonomorphError(s"Variable ${name} not found during evaluation")
-          case _ => throw MonomorphError(s"Variable ${name} unhandled")
-
-  def createObjValue(tpName: String, args: List[BoundedTerm]): MonoVal = 
-    allTypeImpls.get(tpName) match
-      case Some(NuTypeDef(kind, nme, tparams, params, ctor, sig, parents, _, _, body)) => 
-        debug.writeLine(s"Creating Object Value for ${tpName} with arguments ${args}")
-        debug.indent()
-        val ags = (params match
-          case Some(p) => 
-            if (extractObjParams(p).length != args.length) throw MonomorphError("ObjValue param mismatch")
-            extractObjParams(p).map(_._2.name).zip(args).toList // FIXME: Different structure for Obj Params
-          case None => Nil)
-        val obj = ObjVal(tpName, ags.map((p, _) => p), MutMap(ags: _*)) // TODO: parent object fields
-        debug.writeLine(s"Parents term is ${parents}")
-        val parentObjs = parents.map{
-          case Var(name) => BoundedTerm(createObjValue(name, Nil))
-          case App(Var(name), t: Tup) => 
-            specializer.evaluate(t)(using Map("this"->BoundedTerm(obj)) ++ ags, List(tpName), evaluationMap)
-            BoundedTerm(createObjValue(name, extractFuncArgs(t).map(getRes)))
-          case other => throw MonomorphError(s"Unexpected parent object format ${other}")
-        }
-        debug.writeLine(s"Parent objects are ${parentObjs}")
-        obj.fields.addAll(parentObjs.zipWithIndex.map((e, i) => s"sup$$$i" -> e))
-        debug.writeLine(s"Created Object Value ${obj}")
-        debug.outdent()
-        obj
-      case None => throw MonomorphError(s"TypeName ${tpName} not found in implementations ${allTypeImpls}")
-
-  def createTupVal(fields: List[BoundedTerm]): TupVal = 
-    TupVal(fields.zipWithIndex.map((term, i) => (Var(i.toString()) -> term)).toMap)
-
-  def getFieldVal(obj: ObjVal, field: String): BoundedTerm =
-    debug.writeLine(s"select ${field} from ${obj.name}")
-    allTypeImpls.get(obj.name) match
-      case None => throw MonomorphError(s"ObjectValue ${obj} not found in implementations ${allTypeImpls}")
-      case Some(typeDef) => 
-        typeDef.body.entities.flatMap{
-          case func@NuFunDef(_, Var(nme), _, _, Left(_)) if nme.equals(field) => Some(func)
-          case _ => None
-        }.headOption match
-        case Some(NuFunDef(isLetRec, Var(nme), sn, tp, Left(body))) => 
-          debug.writeLine(s"found some func")
-          val nuFuncName = s"${nme}$$${obj.name}"
-          if (!funImpls.contains(nuFuncName)) {
-            addFunction(NuFunDef(isLetRec, Var(nuFuncName), sn, tp, Left(addThisParam(body)))(None, None, None, None, None, false, Nil))
-          } 
-          BoundedTerm(FuncVal(nuFuncName, extractLamParams(body).map(_.map(_._2.name).toList), List("this" -> BoundedTerm(obj))))
-        case _ => 
-          debug.writeLine(s"did not find func, try obj fields")
-          obj.fields.get(field) match
-          case Some(value) => value
-          case None => 
-            debug.writeLine(s"did not find in fields, try superclass")
-            obj.fields.flatMap(x => {
-              if (x._1.matches("sup\\$[0-9]+")) {
-                x._2.asValue match{
-                  case Some(o: ObjVal) => 
-                    Some(getFieldVal(o, field))
-                  case _ => None
-                }
-              }
-              else None
-            }).headOption match
-              case Some(value) => value
-              case None => throw MonomorphError(s"Field value ${field} not found in ObjectValue ${obj}")
\ No newline at end of file
diff --git a/compiler/shared/main/scala/mlscript/compiler/mono/MonomorphError.scala b/compiler/shared/main/scala/mlscript/compiler/mono/MonomorphError.scala
deleted file mode 100644
index e7ef0305e5..0000000000
--- a/compiler/shared/main/scala/mlscript/compiler/mono/MonomorphError.scala
+++ /dev/null
@@ -1,3 +0,0 @@
-package mlscript.compiler.mono
-
-class MonomorphError(message: String) extends Error(message)
diff --git a/compiler/shared/main/scala/mlscript/compiler/mono/specializer/BoundedTerm.scala b/compiler/shared/main/scala/mlscript/compiler/mono/specializer/BoundedTerm.scala
deleted file mode 100644
index 301c2c1a2b..0000000000
--- a/compiler/shared/main/scala/mlscript/compiler/mono/specializer/BoundedTerm.scala
+++ /dev/null
@@ -1,180 +0,0 @@
-package mlscript.compiler.mono
-import mlscript.{Var, Lit}
-import scala.collection.mutable.{Map => MutMap}
-import scala.collection.immutable.ListMap
-
-
-sealed abstract class MonoVal extends MonoValImpl
-final case class TypeVal(name: String) extends MonoVal
-final case class ObjVal(name: String, params: List[String], fields: MutMap[String, BoundedTerm]) extends MonoVal with ObjValImpl
-final case class FuncVal(name: String, params: Option[List[String]], ctx: List[(String, BoundedTerm)]) extends MonoVal
-final case class UnknownVal() extends MonoVal
-/* 
- * VarVal represents the evaluation bounds of a function, which can change 
- * as we progress through evaluation.
- * TODO: Terribly unintuitive implementation, should attempt to refactor.
- */
-final case class VarVal(vx: Int, version: Int, val getter: VarVal => BoundedTerm) extends MonoVal with VarValImpl
-final case class LiteralVal(i: Lit | Boolean) extends MonoVal with LitValImpl
-final case class PrimVal() extends MonoVal
-final case class TupVal(fields: Map[Var, BoundedTerm]) extends MonoVal
-
-
-class BoundedTerm(val values: Set[MonoVal]) extends BoundedTermImpl
-
-object BoundedTerm {
-  def apply(): BoundedTerm = new BoundedTerm(Set())
-  def apply(singleVal: MonoVal): BoundedTerm = new BoundedTerm(Set(singleVal))
-  def apply(valSet: Set[MonoVal]): BoundedTerm = new BoundedTerm(valSet)
-}
-
-trait MonoValImpl { self: MonoVal =>
-  override def toString: String = this match {
-    case FuncVal(name, params, ctx) => s"FuncVal(${name}, ${params.map(_.mkString("(",",",")")).getOrElse("None")}, ${ctx})"
-    case LiteralVal(i) => s"LiteralVal(${i})"
-    case ObjVal(name, params, fields) => s"ObjVal(${name}, ${fields})"
-    case TypeVal(name) => s"TypeVal(${name})"
-    case TupVal(fields) => s"TupVal(${fields})"
-    case UnknownVal() =>  s"UnknownVal"
-    case PrimVal() => s"PrimVal()"
-    case VarVal(vx, version, _) => s"VarVal(${vx})"
-  }
-}
-
-trait VarValImpl { 
-  
-}
-
-trait LitValImpl { self: LiteralVal =>
-  def asBoolean(): Option[Boolean] = self match {
-    case LiteralVal(b: Boolean) => Some(b)
-    case _ => None
-  }
-}
-
-trait ObjValImpl { self: ObjVal =>
-  def merge(other: ObjVal)(implicit instackExps: Set[Int]): ObjVal = {
-    val allKeys = self.fields.keys
-    val nFlds = allKeys.map(k => {
-      val s1 = self.fields.get(k).get
-      val s2 = other.fields.get(k).get
-      if(instackExps.contains(s1.hashCode()) && instackExps.contains(s2.hashCode()))
-        (k -> s1)
-      else (k -> (s1 ++ s2))
-    })
-    ObjVal(self.name, self.params, MutMap(nFlds.toList: _*))
-  }
-
-}
-
-trait BoundedTermImpl { self: BoundedTerm =>
-  override def toString: String = self.values.map(_.toString).mkString(";")
-  def getObjNames(): Set[String] = self.values.flatMap{
-    case ObjVal(name, _, _) => Some(name)
-    case _ => None
-  }
-
-  private def splitSpecifiedObjects(vs: Set[MonoVal], nms: Set[String]): (Set[MonoVal], Map[String, ObjVal]) = {
-      val ret = vs.map{
-        case o@ObjVal(name, params, fields) => 
-          if (nms.contains(name)) {
-            (None, Some(name -> o))
-          } else {
-            (Some(o), None)
-          }
-        case x => (Some(x), None)
-      }.unzip
-      val ret1 = ret._1.flatten
-      val ret2 = ret._2.flatten.toMap
-      (ret1, ret2)
-    }
-  
-  /* 
-   * Unfold VarVals into primitive values recursively.
-   */
-  def unfoldVars(implicit instackExps: Set[Int] = Set()): BoundedTerm = { 
-    val (vars, others) = self.values.toList.map{
-      case vx: VarVal => (Some(vx), None)
-      case others => (None, Some(others))
-    }.unzip
-    val varSets: List[BoundedTerm] = vars.flatten.map(x => {
-      val vSet = x.getter(x)
-      if(!instackExps.contains(vSet.hashCode())) {
-        vSet.unfoldVars(instackExps + vSet.hashCode())
-      }
-      else BoundedTerm(x)
-    })
-    varSets.foldLeft(BoundedTerm(others.flatten.toSet))((x, y) => (x ++ y)(instackExps + y.hashCode))
-  }
-
-  def asValue: Option[MonoVal] = {
-    val tmp = this.unfoldVars
-    if (tmp.values.size == 1) {
-      Some(tmp.values.head)
-    }
-    else None
-  }
-
-  def getValue: Set[MonoVal] = {
-    unfoldVars.values.filterNot(_.isInstanceOf[VarVal])
-  }
-
-  def literals2Prims: BoundedTerm = {
-    val hasPrim = values.find(x => x.isInstanceOf[PrimVal] || x.isInstanceOf[LiteralVal]).isDefined
-    if(hasPrim)
-      BoundedTerm(values.filterNot(x => x.isInstanceOf[PrimVal] || x.isInstanceOf[LiteralVal])/* + PrimVal()*/)
-    else this
-  }
-
-  /* 
-   * Merge two BoundedTerms together recursively, including its component values & objects.
-   */
-  def ++(other: BoundedTerm)(implicit instackExps: Set[Int] = Set()): BoundedTerm = {
-    if (this == other) this
-    else {
-      val mergingValNms = self.getObjNames().intersect(other.getObjNames())
-      val (restVals1, mergingVals1) = splitSpecifiedObjects(self.values, mergingValNms)
-      val (restVals2, mergingVals2) = splitSpecifiedObjects(other.values, mergingValNms)
-
-      val ret = mergingValNms.map(nm => (mergingVals1.get(nm), mergingVals2.get(nm)) match {
-        case (Some(x1: ObjVal), Some(x2: ObjVal)) => x1.merge(x2)(instackExps ++ Set(self.hashCode(), other.hashCode()))
-        case _ => ???
-      })
-
-      var ret2 = restVals1 ++ restVals2
-      // TODO: eliminate redundant values
-      val retVals = BoundedTerm(ret ++ ret2)
-      retVals
-    }
-  }
-
-  def size: Int = values.size
-
-  /*
-   * Returns true if the bounds of other is larger than this.
-   */
-  def compare(other: BoundedTerm)(implicit instackExps: Set[Int] = Set()): Boolean = {
-    if (instackExps.contains(this.hashCode()) && instackExps.contains(other.hashCode()))
-      false
-    else {
-      if (this.values.find(_.isInstanceOf[PrimVal]).isEmpty && other.values.find(_.isInstanceOf[PrimVal]).isDefined)
-        true
-      else if (this.size != other.size)
-        this.size < other.size
-      else {
-        val nms1 = this.getObjNames()
-        val nms2 = other.getObjNames()
-        if(nms1.equals(nms2)){
-          val (rests1, objs1) = splitSpecifiedObjects(this.values, nms1)
-          val (rests2, objs2) = splitSpecifiedObjects(other.values, nms1)
-          nms1.find(nm => {
-            val v1s = objs1.get(nm).get.fields
-            val v2s = objs2.get(nm).get.fields
-            v1s.keySet.find(k => v1s.get(k).get.compare(v2s.get(k).get)(using instackExps + this.hashCode() + other.hashCode())).isDefined
-          }).isDefined
-        }
-        else true
-      }
-    }
-  }
-}
\ No newline at end of file
diff --git a/compiler/shared/main/scala/mlscript/compiler/mono/specializer/Specializer.scala b/compiler/shared/main/scala/mlscript/compiler/mono/specializer/Specializer.scala
deleted file mode 100644
index be98f2eefc..0000000000
--- a/compiler/shared/main/scala/mlscript/compiler/mono/specializer/Specializer.scala
+++ /dev/null
@@ -1,248 +0,0 @@
-package mlscript
-package compiler
-package mono
-
-import scala.collection.mutable.ArrayBuffer
-import scala.collection.mutable.Map as MutMap
-import scala.collection.mutable.ArrayBuffer
-import mlscript.compiler.Helpers.*
-class Specializer(monoer: Monomorph)(using debug: Debug){
-
-  /*
-    Evaluate a Term given an evaluation Context and update its result in the term map
-  */
-  val builtInOps: Set[String] = Set("+", "-", ">", "<", "*", "==", "concat", "toString", "log") 
-  def evaluate(term: Term)(using evalCtx: Map[String, BoundedTerm], callingStack: List[String], termMap: MutMap[Term, BoundedTerm]): Unit =
-    def getRes(term: Term): BoundedTerm = termMap.getOrElse(term, throw MonomorphError(s"Bounds for ${term} not found during eval."))
-    debug.writeLine(s"╓Eval ${term}:")
-    debug.indent()
-    term match
-      case lit: Lit => 
-        termMap.addOne(term, BoundedTerm(LiteralVal(lit)))
-        term
-      case Var(name) => 
-        debug.writeLine(s"evalCtx: ${evalCtx}")
-        termMap.addOne(term, 
-          if name == "true"
-          then BoundedTerm(LiteralVal(true))
-          else if name == "false"
-          then BoundedTerm(LiteralVal(false))
-          else evalCtx.getOrElse(name, monoer.findVar(name)))
-        term
-      // case Lam(lhs, rhs) => throw MonomorphError("Should not encounter lambda during evaluation process")
-      case App(lhs@Var(name), rhs) if builtInOps.contains(name) => 
-        evaluate(rhs)
-        termMap.addOne(term, extractFuncArgs(rhs).map(getRes).fold(BoundedTerm())(_ ++ _))
-      case App(lhs@NuNew(cls), args) =>
-        (cls, args) match {
-          case (v: Var, args: Tup) =>
-            evaluate(args)
-            termMap.addOne(term, BoundedTerm(monoer.createObjValue(v.name, extractFuncArgs(args).map(getRes))))
-          case _ => ???
-        }
-      case App(lhs, rhs) => 
-        evaluate(lhs)
-        evaluate(rhs)
-        termMap.addOne(term, getRes(lhs).getValue.map{ 
-          case FuncVal(name, prm, ctx) =>
-              debug.writeLine(s"Apply Function ${name}") 
-              monoer.getFuncRetVal(name, Some(ctx.unzip._2 ++ extractFuncArgs(rhs).map(getRes)))
-          case o: ObjVal => monoer.getFieldVal(o, "apply").asValue match
-            case Some(FuncVal(name, prm, ctx)) => 
-              monoer.getFuncRetVal(name, Some(ctx.unzip._2 ++ extractFuncArgs(rhs).map(getRes))) // Unzipping ctx gives implicit "this"
-            case other => throw MonomorphError(s"Encountered unknown value ${other} when evaluating object application")
-          case TypeVal(name) => 
-            BoundedTerm(monoer.createObjValue(name, extractFuncArgs(rhs).map(getRes).toList))
-          case l@LiteralVal(i) => BoundedTerm(l)
-          case _ => utils.die
-        }.fold(BoundedTerm())(_ ++ _))
-      case New(Some((constructor, args)), body) => 
-        evaluate(args)
-        termMap.addOne(term, BoundedTerm(monoer.createObjValue(constructor.base.name, extractFuncArgs(args).map(getRes))))
-      case Sel(receiver, fieldName) => 
-        evaluate(receiver)
-        termMap.addOne(term, getRes(receiver).getValue.map{
-          case obj: ObjVal => 
-            obj.fields.get(fieldName.name) match
-              case Some(fld) => 
-                debug.writeLine("direct select")
-                fld
-              case None => 
-                debug.writeLine("other select")
-                debug.indent()
-                val res = monoer.getFieldVal(obj, fieldName.name).getValue.map {
-                  case f@FuncVal(name, None, ctx) => 
-                    debug.writeLine(s"got paramless func ${f}")
-                    monoer.getFuncRetVal(name, Some(ctx.unzip._2))
-                  case other => BoundedTerm(other)
-                }.fold(BoundedTerm())(_ ++ _)
-                debug.outdent()
-                res
-          case tup: TupVal =>
-            tup.fields.get(fieldName) match
-              case Some(fld) => fld
-              case None => throw MonomorphError(s"Invalid selction ${fieldName} from Tuple")
-          // case func: FuncVal =>
-          //   monoer.nuGetFuncRetVal(func.name, None)
-          case other => throw MonomorphError(s"Cannot select from non-object value ${other}")
-        }.fold(BoundedTerm())(_ ++ _))
-      case Let(rec, Var(name), rhs, body) =>
-        if !rec
-        then 
-          evaluate(rhs)
-          evaluate(body)(using evalCtx + (name -> getRes(rhs)))
-          termMap.addOne(term, getRes(body))
-        else ??? //TODO: letrec
-      case Blk(stmts) => 
-        stmts.map{
-          case t: Term => evaluate(t)
-          case other => throw MonomorphError(s"Encountered unlifted non-term ${other} in block ")
-        }
-        termMap.addOne(term, {
-          if stmts.length == 0 
-          then BoundedTerm(LiteralVal(UnitLit(false)))
-          else stmts.reverse.head match 
-            case t: Term => getRes(t)
-            case _ => utils.die
-        })
-      case If(body, alternate) => 
-        val res = body match
-          case IfThen(condition, consequent) => 
-            evaluate(consequent)
-            alternate.map(alt => evaluate(alt))
-            evaluate(condition)
-            termMap.addOne(term, getRes(condition).asValue match {
-              // TODO: redundant branch elimination
-              // case Some(x: LiteralVal) if x.asBoolean().isDefined =>
-              //   if x.asBoolean().get
-              //   then nuConsequent.evaledTerm
-              //   else nuAlternate.map(_.evaledTerm).getOrElse(BoundedTerm(UnknownVal()))
-              case _ => getRes(consequent) ++ alternate.map(getRes).getOrElse(BoundedTerm(UnknownVal()))
-            })
-          case other => throw MonomorphError(s"IfBody ${body} not handled")
-        res
-      case Asc(t, ty) => 
-        evaluate(t)
-        termMap.addOne(term, getRes(t))
-      case Tup(fields) => 
-        fields.map{
-          case (name, Fld(flags, value)) => evaluate(value)
-        }
-        termMap.addOne(term, BoundedTerm(monoer.createTupVal(fields.map{case (name, Fld(flags, value)) => getRes(value)})))
-      case Bra(rcd, t) => 
-        evaluate(t)
-        termMap.addOne(term, getRes(t))
-      // case _: Bind => ???
-      // case _: Test => ???
-      // case With(term, Rcd(fields)) => ???
-      // case CaseOf(term, cases) => ???     
-      // case Subs(array, index) => ???
-      // case Assign(lhs, rhs) => ???
-      // case New(None, body) => ???
-      // case Rcd(fields) => ???
-      case _ => utils.die
-    debug.outdent()
-    debug.writeLine(s"╙Result ${getRes(term).getValue.map(_.toString).toList}:")
-
-  def defunctionalize(term: Term)(using termMap: MutMap[Term, BoundedTerm]): Term = {
-    def getRes(term: Term): BoundedTerm = termMap.getOrElse(term, throw MonomorphError(s"Bounds for ${term} not found during defunc."))
-    // TODO: Change to use basic pattern match instead of UCS
-    def valSetToBranches(vals: List[MonoVal], acc: List[Either[IfBody,Statement]] = List(Left(IfElse(Var("error")))))(using field: Var, args: Option[List[Term]]): List[Either[IfBody,Statement]] = 
-      debug.writeLine(s"Expanding ${vals}")
-      vals match
-      case Nil => acc
-      case head :: next => head match
-        case o@ObjVal(name, params, fields) =>
-          val selValue = monoer.getFieldVal(o, field.name)
-          debug.writeLine(s"selected value: ${selValue.asValue}")
-          val branchCase = selValue.asValue match {
-            case Some(f: FuncVal) =>
-              IfThen(Var(name), App(Var(f.name), toTuple(Var("obj") :: args.getOrElse(Nil))))
-            case Some(o@ObjVal(subName, subParams, subFields)) => 
-              args match
-                case Some(a) => //FIXME: Unverified
-                  val scrut = Sel(Var("obj"), field)
-                  val branches = selValue.getValue.toList.map(_.asInstanceOf[ObjVal])
-                    .flatMap(o => {
-                      val lambdaMemFunc = monoer.getFieldVal(o, "apply").asValue.get.asInstanceOf[FuncVal]
-                      val caseVarNm: Var = Var(s"obj$$${o.name}")
-                      Right(NuFunDef(Some(false), Var("obj"), None, Nil, Left(Var(o.name)))(None, None, None, None, None, false, Nil)) :: 
-                        List[Either[IfBody,Statement]](Left(IfThen(Var(o.name), App(Var(lambdaMemFunc.name), toTuple(caseVarNm :: a)))))
-                    })
-                  IfOpApp(scrut, Var("is"), IfBlock(branches))
-                case None => 
-                  IfThen(App(Var(name), toTuple(params.map(k => Var(k)).toList)), field)
-            case Some(LiteralVal(v)) =>
-              IfThen(Var(name), v match
-                case lit: Lit => lit
-                case bool: Boolean => if bool then Var("true") else Var("false"))
-            case None =>
-              if selValue.getValue.size > 1 
-              then 
-                IfThen(App(Var(name), toTuple(params.map(k => Var(k)).toList)), field)
-              else throw MonomorphError(s"Selection of field ${field} from object ${o} results in no values")
-            case _ => utils.die
-          }
-          valSetToBranches(next, Left(branchCase) :: acc)
-        // case t@TupVal(fields) =>
-        //   val selValue = fields.getOrElse(field, throw MonomorphError(s"Invalid field selection ${field} from Tuple"))
-        case _ => utils.die
-
-
-    val ret = term match
-      case x: (Lit | Var) => x
-      case App(sel@Sel(receiver, field), args) => 
-        debug.writeLine(s"Specializing ${term}")
-        debug.indent()
-        val nuReceiver = defunctionalize(receiver)
-        val nuArgs = defunctionalize(args)
-        val ifBlockLines = valSetToBranches(getRes(receiver).getValue.toList)(using field, Some(extractFuncArgs(nuArgs)))
-        val ifBlk = IfBlock(ifBlockLines)
-        val res = Let(false, Var("obj"), nuReceiver,
-            If(IfOpApp(Var("obj"), Var("is"), ifBlk), None))
-        debug.writeLine(s"Result: ${res}")
-        debug.outdent()
-        res
-      case App(op@Var(name), args) if builtInOps.contains(name) =>
-          App(op, defunctionalize(args))
-      case App(lhs@NuNew(cls), args) =>
-        (cls, args) match {
-          case (v: Var, args: Tup) =>
-            App(lhs, defunctionalize(args))
-          case _ => ???
-        }
-      case App(callee, args) => 
-        if(getRes(callee).getValue.find(_.isInstanceOf[ObjVal]).isDefined)
-          defunctionalize(App(Sel(callee, Var("apply")), args))
-        else 
-          App(defunctionalize(callee), defunctionalize(args))
-      case Tup(fields) => Tup(fields.map{
-        case (name, Fld(flags, value)) => (name, Fld(flags, defunctionalize(value)))})
-      case If(IfThen(expr, rhs), els) => If(IfThen(defunctionalize(expr), defunctionalize(rhs)), els.map(defunctionalize))
-      case New(Some((constructor, args)), body) => New(Some((constructor, defunctionalize(args))), body)
-      case Sel(receiver, fieldName) => 
-        val nuReceiver = defunctionalize(receiver)
-        if (getRes(receiver).getValue.forall(_.isInstanceOf[ObjVal]))
-        then
-          debug.writeLine(s"Specializing ${term}")
-          debug.indent()
-          val ifBlockLines = valSetToBranches(getRes(receiver).getValue.toList.sortWith((x, y) => (x.toString > y.toString)))(using fieldName, None)
-          val ifBlk = IfBlock(ifBlockLines)
-          val res = Let(false, Var("obj"), nuReceiver,
-            If(IfOpApp(Var("obj"), Var("is"), ifBlk), None)
-          )
-          debug.writeLine(s"Result: ${res}")
-          debug.outdent()
-          res
-        else 
-          Sel(nuReceiver, fieldName)
-      case Blk(stmts) => 
-        Blk(stmts.map{
-          case t: Term => defunctionalize(t)
-          case other => other
-        })
-      case Bra(false, term) => Bra(false, defunctionalize(term))
-      case _ => throw MonomorphError(s"Cannot Defunctionalize ${term}")
-    ret
-  }
-}
diff --git a/compiler/shared/main/scala/mlscript/compiler/simpledef/Simpledef.scala b/compiler/shared/main/scala/mlscript/compiler/simpledef/Simpledef.scala
new file mode 100644
index 0000000000..4b59f69499
--- /dev/null
+++ b/compiler/shared/main/scala/mlscript/compiler/simpledef/Simpledef.scala
@@ -0,0 +1,455 @@
+package mlscript
+package compiler
+package simpledef
+
+import mlscript.utils.*, shorthands.*
+import scala.collection.mutable
+import java.util.IdentityHashMap
+import scala.collection.JavaConverters._
+
+type TypeVar
+type TermId = Uid[Term]
+type TypeVarId = Uid[TypeVar]
+type Cnstr = ProdStrat -> ConsStrat
+
+/** Performs defunctionalization on selections on objects using simple-sub as for control-flow analysis.
+ *  First we traverse the program and process all terms, constraining them to Producers and Consumers.
+ *  During the constraining, we keep track of the input points of selection terms.
+ *  Lastly, we rewrite selection terms by generating pattern matches on their possible inputs.
+ */
+
+enum ProdStrat(using val euid: TermId) {
+  case NoProd()(using TermId) 
+  case ProdObj(ctor: Option[Var], fields: Ls[Var -> ProdStrat], parents: Ls[ProdStrat] = Nil)(using TermId) extends ProdStrat, ProdObjImpl
+  case ProdFun(lhs: ConsStrat, rhs: ProdStrat)(using TermId) 
+  case ProdVar(uid: TypeVarId, name: String)(boundary: Option[Var] = None)(using TermId) 
+  case ProdTup(fields: Ls[ProdStrat])(using TermId) 
+}
+enum ConsStrat(using val euid: TermId) {
+  case NoCons()(using TermId) 
+  case ConsObj(name: Option[Var], fields: Ls[Var -> ConsStrat])(using TermId) extends ConsStrat, ConsObjImpl
+  case ConsFun(lhs: ProdStrat, rhs: ConsStrat)(using TermId) 
+  case ConsVar(uid: TypeVarId, name: String)(boundary: Option[Var] = None)(using TermId) 
+  case ConsTup(fields: Ls[ConsStrat])(using TermId) 
+}
+import ProdStrat.*, ConsStrat.*
+
+trait ConsObjImpl { self: ConsObj =>
+  var selectionSource: Set[ProdStrat] = Set()
+}
+
+trait ProdObjImpl { self: ProdObj =>
+  var objDestination: Set[ConsStrat] = Set()
+}
+
+class Context(
+  variables: Map[Var, ProdVar],
+  classes: Map[Var, ProdObj],
+) {
+  def apply(v: Var): ProdVar =
+    variables(v)
+  def ++(other: IterableOnce[(Var, ProdVar)]): Context =
+    Context(variables ++ other, classes)
+  def +(other: (Var -> ProdVar)): Context =
+    Context(variables + other, classes)
+  override def toString(): String =
+    s"${variables}"
+}
+
+class SimpleDef(debug: Debug) {
+  
+  extension (t: Term) {
+    def uid = termMap.getOrElse(t, {
+      val id = euid.nextUid
+      termMap.addOne((t, euid.nextUid))
+      id
+    })
+  }
+
+  val termMap = new IdentityHashMap[Term, TermId]().asScala
+  val varsName = mutable.Map.empty[TypeVarId, Str]
+  val vuid = Uid.TypeVar.State()
+  val euid = Uid.Term.State()
+  val noExprId = euid.nextUid
+
+  def freshVar(n: String)(using TermId): (ProdVar, ConsVar) =
+    val vid = vuid.nextUid
+    val pv = ProdVar(vid, n)()
+    val cv = ConsVar(vid, n)()
+    varsName += vid -> n
+    (pv, cv)
+  def freshVar(n: Var)(using TermId): (ProdVar, ConsVar) =
+   freshVar(n.name)
+
+  def apply(p: TypingUnit)(using ctx: Context = Context(Map(), Map())): (Ls[Var -> ProdStrat], ProdStrat) = 
+    // Top-level def prototypes
+    val vars: Map[Var, ProdVar] = p.rawEntities.collect { 
+      case fun: NuFunDef =>
+        fun.nme -> freshVar(fun.name)(using noExprId)._1
+    }.toMap
+    // Top-level constructor prototypes
+    val constructorPrototypes: Map[Var, Cnstr] = p.rawEntities.collect { 
+      case ty: NuTypeDef =>
+        ty.nameVar -> freshVar(ty.nameVar)(using noExprId)
+    }.toMap
+    // Prototypes of constructor outputs, used for inheritance
+    val objectPrototypes: Map[Var, Cnstr] = p.rawEntities.collect { 
+      case ty: NuTypeDef =>
+        ty.nameVar -> freshVar(ty.nameVar)(using noExprId)
+    }.toMap
+    val fullCtx = ctx ++ vars ++ constructorPrototypes.map((v, s) => (v, s._1.asInstanceOf[ProdVar]))
+    val classes: Map[Var, ProdObj] = p.rawEntities.collect { 
+      case ty: NuTypeDef =>
+        debug.writeLine(s"Completing type info for class ${ty.nameVar} with ctors ${constructorPrototypes.map((v, s) => (v, s._1))}")
+        given TermId = noExprId
+        val argTup = ty.params.getOrElse(Tup(Nil))
+        val (pList, cList) = argTup.fields.map{
+          case (Some(v), Fld(flags, _)) if flags.genGetter =>
+            val fldVar = freshVar(s"${argTup.uid}_${v.name}")(using noExprId)
+            ((v, fldVar._1), (v, fldVar._2))
+          case (Some(v), Fld(flags, _)) if !flags.genGetter => 
+            lastWords(s"Non val ${v} class parameter is not supported.")
+          case other =>
+            lastWords(s"${other} class parameter is not supported.")
+        }.unzip
+        val bodyStrats = apply(ty.body)(using fullCtx ++ pList.toMap)
+        val parents = ty.parents.map{
+          case v: Var => objectPrototypes(v)._1
+          case App(v: Var, _) => objectPrototypes(v)._1
+          case other => lastWords(s"Unsupported inheritance pattern ${other}")
+        }
+        if parents.length > 1 then lastWords(s"Multiple Inheritance at ${ty} not supported yet")
+        ty.kind match
+          case Cls => 
+            ty.ctor match
+              case None => 
+                val obj = ProdObj(Some(ty.nameVar), bodyStrats._1 ++ pList, parents)
+                val func = ProdFun(ConsTup(cList.map(_._2)),obj)
+                constrain(func, constructorPrototypes(ty.nameVar)._2)
+                constrain(obj, objectPrototypes(ty.nameVar)._2)
+                ty.nameVar -> obj
+              case Some(Constructor(t @ Tup(params), body)) =>
+                val mapping = params.map{
+                  case (None, Fld(_, v: Var)) =>
+                    (v, freshVar(s"${t.uid}_${v.name}")(using noExprId))
+                  case (Some(v1: Var), Fld(_, v2: Var)) =>
+                    (v1, freshVar(s"${t.uid}_${v1.name}")(using noExprId))
+                  case other => 
+                    lastWords(s"Unsupported term ${other}")
+                }
+                process(body)(using fullCtx ++ pList.toMap ++ mapping.map((i, s) => (i, s._1)))
+                val obj = ProdObj(Some(ty.nameVar), bodyStrats._1 ++ pList, parents)
+                val func = ProdFun(ConsTup(mapping.map(_._2._2)),obj)
+                constrain(func, constructorPrototypes(ty.nameVar)._2)
+                constrain(obj, objectPrototypes(ty.nameVar)._2)
+                ty.nameVar -> obj
+          case Mod =>
+            val obj = ProdObj(Some(ty.nameVar), bodyStrats._1 ++ pList, parents) 
+            constrain(obj, constructorPrototypes(ty.nameVar)._2)
+            constrain(obj, objectPrototypes(ty.nameVar)._2)
+            ty.nameVar -> obj
+          case other => 
+            lastWords(s"Unsupported class kind ${other}")
+    }.toMap
+    val tys = p.rawEntities.flatMap{
+      case f: NuFunDef => {
+        f.rhs match 
+          case Left(value) => 
+            val p = process(value)(using fullCtx)
+            val v = vars(f.nme)
+            constrain(p, ConsVar(v.uid, v.name)()(using noExprId))
+            Some(p)
+          case Right(value) => None
+      }
+      case t: Term => {
+        val topLevelProd = process(t)(using fullCtx)
+        Some(topLevelProd)
+      }
+      case other => {
+        debug.writeLine(s"Skipping ${other}")
+        None
+      }
+    }
+    (vars.toList, tys.lastOption.getOrElse(ProdObj(Some(Var("prim$Unit")), Nil)(using noExprId)))
+  
+  val termToProdType = mutable.Map.empty[TermId, ProdStrat]
+  // Selection terms -> Object types that they Consume
+  val selTermToType = mutable.Map.empty[TermId, ConsObj]
+
+  def builtinOps: Map[Var, ProdFun] = {
+    given TermId = noExprId
+    Map(
+      (Var("+") -> ProdFun(ConsTup(List(ConsObj(Some(Var("prim$Int")), Nil),ConsObj(Some(Var("prim$Int")), Nil))), ProdObj(Some(Var("prim$Int")), Nil))),
+      (Var("-") -> ProdFun(ConsTup(List(ConsObj(Some(Var("prim$Int")), Nil),ConsObj(Some(Var("prim$Int")), Nil))), ProdObj(Some(Var("prim$Int")), Nil))),
+      (Var("*") -> ProdFun(ConsTup(List(ConsObj(Some(Var("prim$Int")), Nil),ConsObj(Some(Var("prim$Int")), Nil))), ProdObj(Some(Var("prim$Int")), Nil))),
+      (Var(">") -> ProdFun(ConsTup(List(ConsObj(Some(Var("prim$Int")), Nil),ConsObj(Some(Var("prim$Int")), Nil))), ProdObj(Some(Var("prim$Bool")), Nil))),
+      (Var("==") -> ProdFun(ConsTup(List(ConsObj(Some(Var("prim$Int")), Nil),ConsObj(Some(Var("prim$Int")), Nil))), ProdObj(Some(Var("prim$Bool")), Nil))),
+      (Var("is") -> ProdFun(ConsTup(List(freshVar("is$rhs")._2,freshVar("is$lhs")._2)), ProdObj(Some(Var("prim$Bool")), Nil))),
+      (Var("concat") -> ProdFun(ConsTup(List(ConsObj(Some(Var("prim$String")), Nil))), ProdFun(ConsTup(List(ConsObj(Some(Var("prim$String")), Nil))), ProdObj(Some(Var("prim$String")), Nil)))),
+      (Var("log") -> ProdFun(ConsTup(List(ConsObj(Some(Var("prim$String")), Nil))), ProdObj(Some(Var("prim$Unit")), Nil))),
+      (Var("toString") -> ProdFun(ConsTup(List(ConsObj(Some(Var("prim$Int")), Nil))), ProdObj(Some(Var("prim$String")), Nil)))
+    )
+  }
+
+  def process(t: Term)(using ctx: Context): ProdStrat = 
+    debug.writeLine(s"Processing term ${t}")
+    debug.indent()
+    val res: ProdStrat = t match
+      case IntLit(_) => ProdObj(Some(Var("prim$Int")), Nil)(using t.uid)
+      case StrLit(_) => ProdObj(Some(Var("prim$String")), Nil)(using t.uid)
+      case UnitLit(_) => ProdObj(Some(Var("prim$Unit")), Nil)(using t.uid)
+      case Var("true") | Var("false") => ProdObj(Some(Var("prim$Bool")), Nil)(using t.uid)
+      case v @ Var(id) if builtinOps.contains(v) =>
+        builtinOps(v)
+      case v @ Var(id) =>
+        ctx(v).copy()(Some(v))(using t.uid)
+      case Asc(trm, ty) =>
+        // TODO: Enforce type ascription?
+        process(trm)
+      case Let(isRec, nme, rhs, body) =>
+        val rhsRes = process(rhs)
+        val sv = freshVar(s"${t.uid}_let")(using t.uid)
+        constrain(rhsRes, sv._2)
+        process(body)(using ctx + (nme -> sv._1))
+      case NuNew(cls) =>
+        process(App(NuNew(cls), Tup(Nil).withLoc(t.toLoc.map(_.right))))
+      case App(NuNew(cls), arg) => 
+        val clsRes = process(cls)
+        val argRes = process(arg)
+        val sv = freshVar(s"${t.uid}_callres")(using t.uid)
+        constrain(clsRes, ConsFun(argRes, sv._2)(using noExprId))
+        sv._1
+      case App(func, arg) => 
+        val funcRes = process(func)
+        val argRes = process(arg)
+        val sv = freshVar(s"${t.uid}_callres")(using t.uid)
+        constrain(funcRes, ConsFun(argRes, sv._2)(using noExprId))
+        sv._1
+      case Lam(t @ Tup(args), body) =>
+        val mapping = args.map{
+          case (None, Fld(_, v: Var)) =>
+            (v, freshVar(s"${t.uid}_${v.name}")(using noExprId))
+          case (Some(v1: Var), Fld(_, v2: Var)) =>
+            (v1, freshVar(s"${t.uid}_${v1.name}")(using noExprId))
+          case other => 
+            lastWords(s"Unsupported term ${other}")
+        }
+        ProdFun(ConsTup(mapping.map(_._2._2))(using t.uid),
+          process(body)(using ctx ++ mapping.map((i, s) => (i, s._1))))(using t.uid)
+      case If(IfThen(scrut, thenn), S(elze)) =>
+        constrain(process(scrut), ConsObj(Some(Var("prim$Bool")), Nil)(using noExprId))
+        val res = freshVar(s"${t.uid}_ifres")(using t.uid)
+        constrain(process(thenn), res._2)
+        constrain(process(elze), res._2)
+        res._1
+      case elf: If =>
+        elf.desugaredTerm match {
+          case S(desugared) => process(desugared)
+          case N => lastWords(s"Undesugared UCS term ${t} found")
+        }
+      case Tup(fields) =>
+        val mapping = fields.map{
+          case (None, Fld(_, fieldTerm: Term)) =>
+            process(fieldTerm)
+          case other => lastWords(s"Unsupported tuple structure ${other}") 
+        }
+        ProdTup(mapping)(using t.uid)
+      case Sel(receiver, fieldName) =>
+        val selRes = freshVar(s"${t.uid}_selres")(using t.uid)
+        val selector = ConsObj(None, List(fieldName -> selRes._2))(using t.uid)
+        constrain(process(receiver), selector)
+        selTermToType += (t.uid -> selector.asInstanceOf[ConsObj])
+        selRes._1
+      case Bra(true, t) =>
+        process(t)
+      case Rcd(fields) =>
+        ProdObj(None, fields.map{
+          case (v, Fld(_, t)) => (v -> process(t))
+        })(using t.uid)
+      case Blk(stmts) => 
+        apply(TypingUnit(stmts))._2
+      case Bra(false, term) =>
+        process(term)
+      case CaseOf(trm, cases) => // TODO: Complete constraining in conjunction with processCases
+        ???
+      case Eqn(lhs, rhs) =>
+        process(lhs)
+        process(rhs)
+      case other => lastWords(s"Unsupported term ${other}")
+
+    debug.outdent()
+    registerTermToType(t, res)
+
+  // TODO: Complete constraining for CaseBranches after implementing negative types and intersections
+  def processCases(scrut: ProdVar, cs: CaseBranches)(using ctx: Context, resCons: ConsVar): Unit =
+    cs match
+      case Wildcard(body) => 
+        constrain(process(body), resCons)
+      case NoCases => ()
+      case Case(pat, body, rest) => ???
+
+  
+  val constraintCache = mutable.Set.empty[(ProdStrat, ConsStrat)]
+  val upperBounds = mutable.Map.empty[TypeVarId, Ls[ConsStrat]].withDefaultValue(Nil)
+  val lowerBounds = mutable.Map.empty[TypeVarId, Ls[ProdStrat]].withDefaultValue(Nil)
+
+  def constrain(prod: ProdStrat, cons: ConsStrat): Unit = {
+    debug.writeLine(s"constraining ${prod} -> ${cons}")
+    if (constraintCache.contains(prod -> cons)) return () else constraintCache += (prod -> cons)
+    
+    (prod, cons) match
+        case (ProdVar(v, pn), ConsVar(w, cn))
+          if v === w => ()
+        case (pv@ProdVar(v, _), _) =>
+          cons match {
+            case c: ConsObj if lowerBounds(v).isEmpty =>
+              c.selectionSource = c.selectionSource + pv
+            case _ => ()
+          }
+          upperBounds += v -> (cons :: upperBounds(v))
+          lowerBounds(v).foreach(lb_strat => constrain(lb_strat, cons))
+        case (_, cv@ConsVar(v, _)) =>
+          prod match {
+            case p: ProdObj if upperBounds(v).isEmpty =>
+              p.objDestination = p.objDestination + cv
+            case _ => ()
+          }
+          lowerBounds += v -> (prod :: lowerBounds(v))
+          upperBounds(v).foreach(ub_strat => constrain(prod, ub_strat))
+        case (ProdFun(lhs1, rhs1), ConsFun(lhs2, rhs2)) =>
+          constrain(lhs2, lhs1)
+          constrain(rhs1, rhs2)
+        case (pt@ProdTup(fields1), ct@ConsTup(fields2)) =>
+          if pt.fields.length != ct.fields.length
+          then lastWords("Tuple size mismatch")
+          (fields1 zip fields2).map((p, c) =>
+            constrain(p, c)
+          )
+        case (pv@ProdObj(nme1, fields1, parents), cv@ConsObj(nme2, fields2)) =>
+          nme2 match 
+            case Some(name) if name != nme1.get => lastWords(s"Could not constrain ${(prod -> cons)}")
+            case _ => ()
+          fields2.map((key, res2) => {
+            fields1.find(_._1 == key) match 
+              case None => 
+                debug.writeLine("field not found, try parent") 
+                // TODO: Handle multiple inheritance properly, currently assume only one parent
+                parents match
+                  case head :: next => 
+                    constrain(head, cv)
+                  case Nil => 
+                    lastWords(s"Could not constrain ${(prod -> cons)}")
+              case Some((_, res1)) => 
+                cv.selectionSource = cv.selectionSource + pv
+                pv.objDestination = pv.objDestination + cv
+                constrain(res1, res2)
+          })
+        case (pv@ProdTup(fields1), cv@ConsObj(nme2, fields2)) =>
+          nme2 match 
+            case Some(name) => lastWords(s"Could not constrain ${(prod -> cons)}")
+            case _ => ()
+          fields2.map((key, res2) => {
+            cv.selectionSource = cv.selectionSource + pv
+            constrain(fields1(key.name.toInt), res2)
+          })
+        case other => lastWords(s"Could not constrain ${other}")
+  }
+
+  // Selection terms -> Producers that they consume
+  lazy val selToResTypes: Map[TermId, Set[ProdStrat]] = selTermToType.map((termId, cons) =>
+    (termId, cons.selectionSource)
+  ).toMap
+
+  // Rewrite terms, replacing selections with pattern matches if they only select on objects
+  def rewriteTerm(t: Term): Term = 
+    def objSetToMatchBranches(receiver: Var, fieldName: Var, objSet: List[ProdObj], acc: CaseBranches = NoCases)(using funcApp: Option[Term] = None): CaseBranches =
+      objSet match 
+        case Nil => acc
+        case (p :: rest) if p.ctor.isDefined => 
+          if funcApp.isDefined 
+          then objSetToMatchBranches(receiver, fieldName, rest, Case(p.ctor.get, App(Sel(receiver, fieldName), funcApp.get), acc)(false))
+          else objSetToMatchBranches(receiver, fieldName, rest, Case(p.ctor.get, Sel(receiver, fieldName), acc)(false))
+        case other => lastWords(s"Unexpected  ${other}")
+    t match
+      case Var(_) | IntLit(_) | UnitLit(_) | StrLit(_) => t
+      // TODO: Remove the following case when eta expansion is supported, currently a workaround.
+      case App(t @ Sel(receiver, fieldName), arg) => 
+        if (selToResTypes(t.uid).forall{
+          case _: ProdVar => true
+          case x: ProdObj if x.ctor.isDefined => true
+          case _ => false
+        }) {
+          val letName = Var(s"selRes$$${t.uid}")
+          Let(false, letName, rewriteTerm(receiver),
+            CaseOf(letName, objSetToMatchBranches(letName, fieldName, selToResTypes(t.uid).collect{case x: ProdObj => x}.toList)(using Some(rewriteTerm(arg))))
+          )
+        } else {
+          debug.writeLine(s"${selToResTypes(t.uid)}")
+          Sel(rewriteTerm(receiver), fieldName)
+        }
+      case App(func, arg) => 
+        App(rewriteTerm(func), rewriteTerm(arg))
+      case Lam(t @ Tup(args), body) =>
+        Lam(rewriteTerm(t), rewriteTerm(body))
+      case If(IfThen(scrut, thenn), S(elze)) =>
+        If(IfThen(rewriteTerm(scrut), rewriteTerm(thenn)), S(rewriteTerm(elze)))
+      case Tup(fields) =>
+        Tup(fields.map{
+          case (x, Fld(flags, fieldTerm: Term)) =>
+            (x, Fld(flags, rewriteTerm(fieldTerm)))
+        })
+      case Sel(receiver, fieldName) =>
+        if (selToResTypes(t.uid).forall{
+          case _: ProdVar => true
+          case x: ProdObj if x.ctor.isDefined => true
+          case _ => false
+        }) {
+          val letName = Var(s"selRes$$${t.uid}")
+          Let(false, letName, rewriteTerm(receiver),
+            CaseOf(letName, objSetToMatchBranches(letName, fieldName, selToResTypes(t.uid).collect{case x: ProdObj => x}.toList))
+          )
+        } else {
+          debug.writeLine(s"${selToResTypes(t.uid)}")
+          Sel(rewriteTerm(receiver), fieldName)
+        }
+      case Bra(true, t) =>
+        Bra(true, rewriteTerm(t))
+      case Rcd(fields) =>
+        Rcd(fields.map{
+          case (v, Fld(flags, t)) => (v, Fld(flags, rewriteTerm(t)))
+        })
+      case Blk(stmts) => 
+        Blk(rewriteStatements(stmts))
+      case Bra(false, term) =>
+        Bra(false, rewriteTerm(term))
+      case NuNew(cls) => 
+        NuNew(rewriteTerm(cls))
+      case other => lastWords(s"Unsupported term ${other}")
+    
+  def rewriteStatements(stmts: List[Statement]): List[Statement] =
+    stmts.map{
+      case ty: NuTypeDef => 
+        ty.copy(body = rewriteProgram(ty.body))(ty.declareLoc, ty.abstractLoc, ty.annotations)
+      case f: NuFunDef => 
+        f.copy(rhs = f.rhs match
+          case Left(t) => Left(rewriteTerm(t))
+          case Right(_) => f.rhs
+        )(f.declareLoc, f.virtualLoc, f.mutLoc, f.signature, f.outer, f.genField, f.annotations)
+      case t: Term => 
+        rewriteTerm(t)
+      case other => lastWords(s"Unsupported term ${other}")
+    }
+  def rewriteProgram(t: TypingUnit): TypingUnit = 
+    TypingUnit(rewriteStatements(t.rawEntities))
+
+  private def registerTermToType(t: Term, s: ProdStrat) = {
+    termToProdType.get(t.uid) match {
+      case None => {
+        termToProdType += t.uid -> s
+        s
+      }
+      case Some(value) =>
+        lastWords(s"${t} registered two prod strategies:\n already has ${value}, but got ${s}")
+    }
+  }
+}
diff --git a/compiler/shared/main/scala/mlscript/compiler/simpledef/Uid.scala b/compiler/shared/main/scala/mlscript/compiler/simpledef/Uid.scala
new file mode 100644
index 0000000000..2d2c4ade25
--- /dev/null
+++ b/compiler/shared/main/scala/mlscript/compiler/simpledef/Uid.scala
@@ -0,0 +1,18 @@
+package mlscript
+package compiler
+package simpledef
+
+opaque type Uid[T] = Int
+
+object Uid:
+  class Handler[T]:
+    class State:
+      private val uidStore = scala.collection.mutable.Map.empty[String, Uid[T]]
+      def nextUid: Uid[T] = nextUid("")
+      def nextUid(key: String): Uid[T] =
+        uidStore.updateWith(key) {
+          case None => Some(0)
+          case Some(v) => Some(v + 1)
+        }.get
+  object TypeVar extends Handler[TypeVar]
+  object Term extends Handler[Term]
\ No newline at end of file
diff --git a/compiler/shared/test/diff/Defunctionalize/ClassConstructor.mls b/compiler/shared/test/diff/Defunctionalize/ClassConstructor.mls
new file mode 100644
index 0000000000..b511441e39
--- /dev/null
+++ b/compiler/shared/test/diff/Defunctionalize/ClassConstructor.mls
@@ -0,0 +1,82 @@
+:NewDefs
+
+class X {
+    val num = 5
+}
+class Y(val num: Int) {
+    constructor(y: Int) {
+        num = y+5
+    }
+}
+let y = new Y(6)
+let x = new X
+(if true then y else x).num
+//│ class X {
+//│   constructor()
+//│   val num: 5
+//│ }
+//│ class Y(num: Int) {
+//│   constructor(y: Int)
+//│ }
+//│ let y: Y
+//│ let x: X
+//│ Int
+//│ 
+//│ Simpledef:
+//│ {class X {let num = 5}
+//│  class Y(val num: Int,) {}
+//│  let y = (new Y)(6,)
+//│  let x = new X
+//│  let selRes$40 = '(' if (true) then y else x ')' in case selRes$40 of { Y => (selRes$40).num
+//│  X => (selRes$40).num }}
+//│ End simpledef
+//│ 
+//│ y
+//│   = Y {}
+//│ x
+//│   = X {}
+//│ res
+//│     = 11
+
+class Z(val num1: Int) {
+    constructor(y, x) {
+        num1 = y+x
+    }
+}
+class W(val num1: Int, val num2: Int) {
+    constructor(w) {
+        num1 = w
+        num2 = w
+    }
+}
+val w = new W(3)
+val z = new Z(6, 11)
+(if true then w else z).num1
+//│ class Z(num1: Int) {
+//│   constructor(y: Int, x: Int)
+//│ }
+//│ class W(num1: Int, num2: Int) {
+//│   constructor(w: Int)
+//│ }
+//│ val w: W
+//│ val z: Z
+//│ Int
+//│ 
+//│ Simpledef:
+//│ {class Z(val num1: Int,) {}
+//│  class W(val num1: Int, val num2: Int,) {}
+//│  let w = (new W)(3,)
+//│  let z = (new Z)(6, 11,)
+//│  let selRes$58 = '(' if (true) then w else z ')' in case selRes$58 of { W => (selRes$58).num1
+//│  Z => (selRes$58).num1 }}
+//│ End simpledef
+//│ 
+//│ w
+//│   = W {}
+//│ z
+//│   = Z {}
+//│ res
+//│     = 3
+
+
+
diff --git a/compiler/shared/test/diff/Defunctionalize/Classes.mls b/compiler/shared/test/diff/Defunctionalize/Classes.mls
index 880e899334..2074af8a8a 100644
--- a/compiler/shared/test/diff/Defunctionalize/Classes.mls
+++ b/compiler/shared/test/diff/Defunctionalize/Classes.mls
@@ -1,12 +1,11 @@
 :NewDefs
 
-:mono
-class Bar(x: Int) {
+class Bar(val x: Int) {
   fun foo(x) = x
   fun FooMinus(y: Int) = x + y
   fun car = foo(2)
 }
-class Car {
+class Car() {
   fun da(b: Bar) = b.foo(2)
 }
 fun baz(b: Bar) = b.foo(2)
@@ -14,49 +13,32 @@ let bar = Bar(42)
 baz(bar)
 (Car()).da(Bar(1337))
 bar.car
-//│ Lifted:
-//│ TypingUnit {
-//│   class Bar$1([x: Int,]) {
-//│     fun foo = (x,) => x
-//│     fun FooMinus = (y: Int,) => +((this).x, y,)
-//│     fun car = (this).foo(2,)
-//│   }
-//│   class Car$2([]) {fun da = (b: Bar$1,) => (b).foo(2,)}
-//│   fun baz$2 = (b: Bar$1,) => (b).foo(2,)
-//│   let bar$1 = Bar$1(42,)
-//│   Code(List(baz$2(bar$1,)))
-//│   Code(List(('(' Car$2() ')').da(Bar$1(1337,),)))
-//│   Code(List((bar$1).car))
+//│ class Bar(x: Int) {
+//│   fun FooMinus: (y: Int) -> Int
+//│   fun car: 2
+//│   fun foo: forall 'a. 'a -> 'a
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Bar$1([x: Int,]) {}
-//│   class Car$2([]) {}
-//│   let bar$1 = Bar$1(42,)
-//│   fun da$Car$2 = (this, b: Bar$1,) => let obj = b in if obj is ‹(Bar$1) then foo$Bar$1(obj, 2,); else error›
-//│   fun main$$6 = () => let obj = bar$1 in if obj is ‹(Bar$1) then car$Bar$1(obj,); else error›
-//│   fun foo$Bar$1 = (this, x,) => x
-//│   fun baz$2 = (b: Bar$1,) => let obj = b in if obj is ‹(Bar$1) then foo$Bar$1(obj, 2,); else error›
-//│   fun main$$5 = () => let obj = '(' Car$2() ')' in if obj is ‹(Car$2) then da$Car$2(obj, Bar$1(1337,),); else error›
-//│   fun main$$4 = () => baz$2(bar$1,)
-//│   fun car$Bar$1 = (this,) => let obj = this in if obj is ‹(Bar$1) then foo$Bar$1(obj, 2,); else error›
-//│   Code(List(main$$4()))
-//│   Code(List(main$$5()))
-//│   Code(List(main$$6()))
+//│ class Car() {
+//│   fun da: (b: Bar) -> 2
 //│ }
-//│ class Bar$1(x: Int)
-//│ class Car$2()
-//│ let bar$1: Bar$1
-//│ fun da$Car$2: forall 'a. (anything, b: Bar$1) -> (2 | 'a)
-//│ fun main$$6: forall 'a. () -> (2 | 'a)
-//│ fun foo$Bar$1: forall 'a. (anything, 'a) -> (2 | 'a)
-//│ fun baz$2: (b: Bar$1) -> 2
-//│ fun main$$5: () -> 2
-//│ fun main$$4: () -> 2
-//│ fun car$Bar$1: forall 'a. Object -> (2 | 'a)
-//│ forall 'a. 2 | 'a
-//│ bar$1
-//│       = Bar$1 {}
+//│ fun baz: (b: Bar) -> 2
+//│ let bar: Bar
+//│ 2
+//│ 
+//│ Simpledef:
+//│ {class Bar(val x: Int,) {fun foo = (x::0,) => x
+//│  fun FooMinus = (y: Int,) => +(x, y,)
+//│  fun car = foo(2,)}
+//│  class Car() {fun da = (b: Bar,) => let selRes$34 = b in case selRes$34 of { Bar => (selRes$34).foo(2,) }}
+//│  fun baz = (b: Bar,) => let selRes$48 = b in case selRes$48 of { Bar => (selRes$48).foo(2,) }
+//│  let bar = Bar(42,)
+//│  baz(bar,)
+//│  let selRes$76 = '(' Car() ')' in case selRes$76 of { Car => (selRes$76).da(Bar(1337,),) }
+//│  let selRes$98 = bar in case selRes$98 of { Bar => (selRes$98).car }}
+//│ End simpledef
+//│ 
+//│ bar
+//│     = Bar {}
 //│ res
 //│     = 2
 //│ res
diff --git a/compiler/shared/test/diff/Defunctionalize/ClosureCapture.mls b/compiler/shared/test/diff/Defunctionalize/ClosureCapture.mls
index 70023100d0..cecf289a36 100644
--- a/compiler/shared/test/diff/Defunctionalize/ClosureCapture.mls
+++ b/compiler/shared/test/diff/Defunctionalize/ClosureCapture.mls
@@ -1,68 +1,31 @@
 :NewDefs
 :AllowRuntimeErrors
 
-// FIXME: Class parameters not annotated
-:mono
 fun foo(x) = 
   (f => f(x))(z => z+1)
 foo(2)
-//│ Lifted:
-//│ TypingUnit {
-//│   class Lambda1$2$1([x,]) {fun apply = (f,) => f((this).x,)}
-//│   class Lambda1$3$2([]) {fun apply = (z,) => +(z, 1,)}
-//│   fun foo$1 = (x,) => {'(' {Lambda1$2$1(x,)} ')'({Lambda1$3$2()},)}
-//│   Code(List(foo$1(2,)))
-//│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Lambda1$2$1([x,]) {}
-//│   class Lambda1$3$2([]) {}
-//│   fun apply$Lambda1$2$1 = (this, f,) => let obj = f in if obj is ‹(Lambda1$3$2) then apply$Lambda1$3$2(obj, let obj = this in if obj is ‹(Lambda1$2$1) then 2; else error›,); else error›
-//│   fun foo$1 = (x,) => {let obj = '(' {Lambda1$2$1(x,)} ')' in if obj is ‹(Lambda1$2$1) then apply$Lambda1$2$1(obj, {Lambda1$3$2()},); else error›}
-//│   fun main$$3 = () => foo$1(2,)
-//│   fun apply$Lambda1$3$2 = (this, z,) => +(z, 1,)
-//│   Code(List(main$$3()))
-//│ }
-//│ ╔══[ERROR] Class parameters currently need type annotations
-//│ ║  l.7: 	  (f => f(x))(z => z+1)
-//│ ╙──     	          ^
-//│ class Lambda1$2$1(x: error)
-//│ class Lambda1$3$2()
-//│ fun apply$Lambda1$2$1: (Object, Object) -> Int
-//│ fun foo$1: error -> Int
-//│ fun main$$3: () -> Int
-//│ fun apply$Lambda1$3$2: (anything, Int) -> Int
+//│ fun foo: Int -> Int
 //│ Int
+//│ 
+//│ Simpledef:
+//│ {fun foo = (x::0,) => {'(' (f::1,) => f(x,) ')'((z::2,) => +(z, 1,),)}
+//│  foo(2,)}
+//│ End simpledef
+//│ 
 //│ res
 //│     = 3
 
-// FIXME: Class parameters not annotated
-:mono
 fun f(x) =
   (y => f(x+y))(x+1)
 f(1)
-//│ Lifted:
-//│ TypingUnit {
-//│   class Lambda1$2$1([x,]) {fun apply = (y,) => f$1(+((this).x, y,),)}
-//│   fun f$1 = (x,) => {'(' {Lambda1$2$1(x,)} ')'(+(x, 1,),)}
-//│   Code(List(f$1(1,)))
-//│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Lambda1$2$1([x,]) {}
-//│   fun apply$Lambda1$2$1 = (this, y,) => f$1(+(let obj = this in if obj is ‹(Lambda1$2$1) then 1; else error›, y,),)
-//│   fun f$1 = (x,) => {let obj = '(' {Lambda1$2$1(x,)} ')' in if obj is ‹(Lambda1$2$1) then apply$Lambda1$2$1(obj, +(x, 1,),); else error›}
-//│   fun main$$2 = () => f$1(1,)
-//│   Code(List(main$$2()))
-//│ }
-//│ ╔══[ERROR] Class parameters currently need type annotations
-//│ ║  l.42: 	  (y => f(x+y))(x+1)
-//│ ╙──      	          ^
-//│ class Lambda1$2$1(x: error)
-//│ fun apply$Lambda1$2$1: (Object, Int) -> nothing
-//│ fun f$1: nothing -> nothing
-//│ fun main$$2: () -> nothing
+//│ fun f: Int -> nothing
 //│ nothing
+//│ 
+//│ Simpledef:
+//│ {fun f = (x::3,) => {'(' (y::4,) => f(+(x, y,),) ')'(+(x, 1,),)}
+//│  f(1,)}
+//│ End simpledef
+//│ 
 //│ res
 //│ Runtime error:
 //│   RangeError: Maximum call stack size exceeded
diff --git a/compiler/shared/test/diff/Defunctionalize/Constructor.mls b/compiler/shared/test/diff/Defunctionalize/Constructor.mls
index 0df2adb230..3c29d5fe10 100644
--- a/compiler/shared/test/diff/Defunctionalize/Constructor.mls
+++ b/compiler/shared/test/diff/Defunctionalize/Constructor.mls
@@ -1,7 +1,5 @@
 :NewDefs
 
-// FIXME: Preserve local state in classes
-:mono
 class X() {
     val a = 
         log("ok")
@@ -12,43 +10,24 @@ val object = X()
 (new X()).a
 object.a
 object.a
-//│ Lifted:
-//│ TypingUnit {
-//│   class X$1([]) {let a = {log("ok",); 6}}
-//│   let object$1 = X$1()
-//│   Code(List(('(' (new X$1)() ')').a))
-//│   Code(List(('(' (new X$1)() ')').a))
-//│   Code(List((object$1).a))
-//│   Code(List((object$1).a))
+//│ class X() {
+//│   val a: 6
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class X$1([]) {}
-//│   let object$1 = X$1()
-//│   let a$X$1 = (this,) => {log("ok",); 6}
-//│   fun main$$5 = () => let obj = object$1 in if obj is ‹(X$1) then a$X$1(obj,); else error›
-//│   fun main$$4 = () => let obj = object$1 in if obj is ‹(X$1) then a$X$1(obj,); else error›
-//│   fun main$$3 = () => let obj = '(' (new X$1)() ')' in if obj is ‹(X$1) then a$X$1(obj,); else error›
-//│   fun main$$2 = () => let obj = '(' (new X$1)() ')' in if obj is ‹(X$1) then a$X$1(obj,); else error›
-//│   Code(List(main$$2()))
-//│   Code(List(main$$3()))
-//│   Code(List(main$$4()))
-//│   Code(List(main$$5()))
-//│ }
-//│ class X$1()
-//│ let object$1: X$1
-//│ let a$X$1: anything -> 6
-//│ fun main$$5: () -> 6
-//│ fun main$$4: () -> 6
-//│ fun main$$3: () -> 6
-//│ fun main$$2: () -> 6
+//│ val object: X
 //│ 6
-//│ object$1
-//│          = X$1 {}
-//│ a$X$1
-//│       = [Function: a$X$1]
-//│ res
-//│     = 6
+//│ 
+//│ Simpledef:
+//│ {class X() {let a = {log("ok",)
+//│  6}}
+//│  let object = X()
+//│  let selRes$20 = '(' (new X)() ')' in case selRes$20 of { X => (selRes$20).a }
+//│  let selRes$30 = '(' (new X)() ')' in case selRes$30 of { X => (selRes$30).a }
+//│  let selRes$40 = object in case selRes$40 of { X => (selRes$40).a }
+//│  let selRes$44 = object in case selRes$44 of { X => (selRes$44).a }}
+//│ End simpledef
+//│ 
+//│ object
+//│        = X {}
 //│ // Output
 //│ ok
 //│ res
@@ -61,5 +40,5 @@ object.a
 //│ ok
 //│ res
 //│     = 6
-//│ // Output
-//│ ok
+//│ res
+//│     = 6
diff --git a/compiler/shared/test/diff/Defunctionalize/DelayedEvaluation.mls b/compiler/shared/test/diff/Defunctionalize/DelayedEvaluation.mls
index abe59b8b02..4e41336167 100644
--- a/compiler/shared/test/diff/Defunctionalize/DelayedEvaluation.mls
+++ b/compiler/shared/test/diff/Defunctionalize/DelayedEvaluation.mls
@@ -1,7 +1,5 @@
 :NewDefs
 
-// FIXME: Preserve local state in classes
-:mono
 class G(val num: Int) {
     val x = 
         log("once on construction")
@@ -15,61 +13,38 @@ g.y()
 g.x
 g.y()
 g.x
-//│ Lifted:
-//│ TypingUnit {
-//│   class G$1([val num: Int,]) {
-//│     let x = {log("once on construction",); +((this).num, 2,)}
-//│     let y = () => {log("once every call",); +((this).num, 2,)}
-//│   }
-//│   let g$1 = (new G$1)(6,)
-//│   Code(List((g$1).y()))
-//│   Code(List((g$1).x))
-//│   Code(List((g$1).y()))
-//│   Code(List((g$1).x))
+//│ class G(num: Int) {
+//│   val x: Int
+//│   val y: () -> Int
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class G$1([val num: Int,]) {}
-//│   let y$G$1 = (this,) => {log("once every call",); +(let obj = this in if obj is ‹(G$1) then 6; else error›, 2,)}
-//│   let x$G$1 = (this,) => {log("once on construction",); +(let obj = this in if obj is ‹(G$1) then 6; else error›, 2,)}
-//│   let g$1 = (new G$1)(6,)
-//│   fun main$$5 = () => let obj = g$1 in if obj is ‹(G$1) then x$G$1(obj,); else error›
-//│   fun main$$4 = () => let obj = g$1 in if obj is ‹(G$1) then y$G$1(obj,); else error›
-//│   fun main$$3 = () => let obj = g$1 in if obj is ‹(G$1) then x$G$1(obj,); else error›
-//│   fun main$$2 = () => let obj = g$1 in if obj is ‹(G$1) then y$G$1(obj,); else error›
-//│   Code(List(main$$2()))
-//│   Code(List(main$$3()))
-//│   Code(List(main$$4()))
-//│   Code(List(main$$5()))
-//│ }
-//│ class G$1(num: Int)
-//│ let y$G$1: Object -> Int
-//│ let x$G$1: Object -> Int
-//│ let g$1: G$1
-//│ fun main$$5: () -> Int
-//│ fun main$$4: () -> Int
-//│ fun main$$3: () -> Int
-//│ fun main$$2: () -> Int
+//│ val g: G
 //│ Int
-//│ y$G$1
-//│       = [Function: y$G$1]
-//│ x$G$1
-//│       = [Function: x$G$1]
-//│ g$1
-//│     = G$1 {}
+//│ 
+//│ Simpledef:
+//│ {class G(val num: Int,) {let x = {log("once on construction",)
+//│  +(num, 2,)}
+//│  let y = () => {log("once every call",)
+//│  +(num, 2,)}}
+//│  let g = (new G)(6,)
+//│  let selRes$56 = g in case selRes$56 of { G => (selRes$56).y() }
+//│  let selRes$64 = g in case selRes$64 of { G => (selRes$64).x }
+//│  let selRes$68 = g in case selRes$68 of { G => (selRes$68).y() }
+//│  let selRes$76 = g in case selRes$76 of { G => (selRes$76).x }}
+//│ End simpledef
+//│ 
+//│ g
+//│   = G {}
+//│ // Output
+//│ once on construction
 //│ res
 //│     = 8
 //│ // Output
 //│ once every call
 //│ res
 //│     = 8
-//│ // Output
-//│ once on construction
 //│ res
 //│     = 8
 //│ // Output
 //│ once every call
 //│ res
 //│     = 8
-//│ // Output
-//│ once on construction
diff --git a/compiler/shared/test/diff/Defunctionalize/Differentiation.mls b/compiler/shared/test/diff/Defunctionalize/Differentiation.mls
index 0386e7d924..56a42ef6db 100644
--- a/compiler/shared/test/diff/Defunctionalize/Differentiation.mls
+++ b/compiler/shared/test/diff/Defunctionalize/Differentiation.mls
@@ -2,31 +2,29 @@
 
 :NewDefs
 
-:mono
+
 abstract class Exp() {
     virtual fun derive(): Exp
-    virtual fun derive() = Exp()
     virtual fun getVal: Str
-    virtual fun getVal = ""
 }
-class Numeric(i: Int) extends Exp {
+class Numeric(val i: Int) extends Exp {
     fun derive() = Numeric(0)
     fun getNum = i
     fun getVal = toString(i)
 }
-class Variable(nm: Str) extends Exp {
+class Variable(val nm: Str) extends Exp {
     fun derive() = Numeric(1)
     fun getVal = nm
 }
-class Sum(lhs: Exp, rhs: Exp) extends Exp {
+class Sum(val lhs: Exp, val rhs: Exp) extends Exp {
     fun derive() = Sum(lhs.derive(), rhs.derive())
     fun getVal = concat("(")(concat(concat(concat(lhs.getVal)(" + "))(rhs.getVal))(")"))
 }
-class Mul(lhs: Exp, rhs: Exp) extends Exp {
+class Mul(val lhs: Exp, val rhs: Exp) extends Exp {
     fun derive() = Sum(Mul(lhs.derive(), rhs), Mul(lhs, rhs.derive()))
     fun getVal = concat("(")(concat(concat(concat(lhs.getVal)(" * "))(rhs.getVal))(")"))
 }
-class Pow(lhs: Variable, rhs: Numeric) extends Exp {
+class Pow(val lhs: Variable, val rhs: Numeric) extends Exp {
     fun derive() = Mul(rhs, Pow(lhs, Numeric(rhs.getNum - 1)))
     fun getVal = concat("(")(concat(concat(concat(lhs.getVal)(" ^ "))(rhs.getVal))(")"))
 }
@@ -34,87 +32,77 @@ Sum(Variable("x"), Numeric(3)).derive().getVal
 Mul(Variable("x"), Numeric(3)).derive().getVal
 Pow(Variable("x"), Numeric(3)).derive().getVal
 Mul(Pow(Variable("x"), Numeric(2)), Pow(Variable("y"), Numeric(2))).derive().getVal
-//│ Lifted:
-//│ TypingUnit {
-//│   class Exp$1([]) {
-//│     fun derive = () -> Exp$1
-//│     fun derive = () => Exp$1()
-//│     fun getVal = Str
-//│     fun getVal = ""
-//│   }
-//│   class Numeric$2([i: Int,]): Exp$1 {
-//│     fun derive = () => Numeric$2(0,)
-//│     fun getNum = (this).i
-//│     fun getVal = toString((this).i,)
-//│   }
-//│   class Variable$3([nm: Str,]): Exp$1 {fun derive = () => Numeric$2(1,); fun getVal = (this).nm}
-//│   class Sum$4([lhs: Exp$1, rhs: Exp$1,]): Exp$1 {
-//│     fun derive = () => Sum$4(((this).lhs).derive(), ((this).rhs).derive(),)
-//│     fun getVal = concat("(",)(concat(concat(concat(((this).lhs).getVal,)(" + ",),)(((this).rhs).getVal,),)(")",),)
-//│   }
-//│   class Mul$5([lhs: Exp$1, rhs: Exp$1,]): Exp$1 {
-//│     fun derive = () => Sum$4(Mul$5(((this).lhs).derive(), (this).rhs,), Mul$5((this).lhs, ((this).rhs).derive(),),)
-//│     fun getVal = concat("(",)(concat(concat(concat(((this).lhs).getVal,)(" * ",),)(((this).rhs).getVal,),)(")",),)
-//│   }
-//│   class Pow$6([lhs: Variable$3, rhs: Numeric$2,]): Exp$1 {
-//│     fun derive = () => Mul$5((this).rhs, Pow$6((this).lhs, Numeric$2(-(((this).rhs).getNum, 1,),),),)
-//│     fun getVal = concat("(",)(concat(concat(concat(((this).lhs).getVal,)(" ^ ",),)(((this).rhs).getVal,),)(")",),)
-//│   }
-//│   Code(List(((Sum$4(Variable$3("x",), Numeric$2(3,),)).derive()).getVal))
-//│   Code(List(((Mul$5(Variable$3("x",), Numeric$2(3,),)).derive()).getVal))
-//│   Code(List(((Pow$6(Variable$3("x",), Numeric$2(3,),)).derive()).getVal))
-//│   Code(List(((Mul$5(Pow$6(Variable$3("x",), Numeric$2(2,),), Pow$6(Variable$3("y",), Numeric$2(2,),),)).derive()).getVal))
+//│ abstract class Exp() {
+//│   fun derive: () -> Exp
+//│   fun getVal: Str
+//│ }
+//│ class Numeric(i: Int) extends Exp {
+//│   fun derive: () -> Numeric
+//│   fun getNum: Int
+//│   fun getVal: Str
+//│ }
+//│ class Variable(nm: Str) extends Exp {
+//│   fun derive: () -> Numeric
+//│   fun getVal: Str
+//│ }
+//│ class Sum(lhs: Exp, rhs: Exp) extends Exp {
+//│   fun derive: () -> Sum
+//│   fun getVal: Str
+//│ }
+//│ class Mul(lhs: Exp, rhs: Exp) extends Exp {
+//│   fun derive: () -> Sum
+//│   fun getVal: Str
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Numeric$2([i: Int,]): Exp$1 {}
-//│   class Pow$6([lhs: Variable$3, rhs: Numeric$2,]): Exp$1 {}
-//│   class Sum$4([lhs: Exp$1, rhs: Exp$1,]): Exp$1 {}
-//│   class Mul$5([lhs: Exp$1, rhs: Exp$1,]): Exp$1 {}
-//│   class Variable$3([nm: Str,]): Exp$1 {}
-//│   class Exp$1([]) {}
-//│   fun getVal$Sum$4 = (this,) => concat("(",)(concat(concat(concat(let obj = let obj = this in if obj is ‹(Sum$4(lhs, rhs,)) then lhs; else error› in if obj is ‹(Mul$5) then getVal$Mul$5(obj,); (Numeric$2) then getVal$Numeric$2(obj,); else error›,)(" + ",),)(let obj = let obj = this in if obj is ‹(Sum$4(lhs, rhs,)) then rhs; else error› in if obj is ‹(Mul$5) then getVal$Mul$5(obj,); (Numeric$2) then getVal$Numeric$2(obj,); else error›,),)(")",),)
-//│   fun derive$Pow$6 = (this,) => Mul$5(let obj = this in if obj is ‹(Pow$6(lhs, rhs,)) then rhs; else error›, Pow$6(let obj = this in if obj is ‹(Pow$6(lhs, rhs,)) then lhs; else error›, Numeric$2(-(let obj = let obj = this in if obj is ‹(Pow$6(lhs, rhs,)) then rhs; else error› in if obj is ‹(Numeric$2) then getNum$Numeric$2(obj,); else error›, 1,),),),)
-//│   fun getVal$Pow$6 = (this,) => concat("(",)(concat(concat(concat(let obj = let obj = this in if obj is ‹(Pow$6(lhs, rhs,)) then lhs; else error› in if obj is ‹(Variable$3) then getVal$Variable$3(obj,); else error›,)(" ^ ",),)(let obj = let obj = this in if obj is ‹(Pow$6(lhs, rhs,)) then rhs; else error› in if obj is ‹(Numeric$2) then getVal$Numeric$2(obj,); else error›,),)(")",),)
-//│   fun derive$Sum$4 = (this,) => Sum$4(let obj = let obj = this in if obj is ‹(Sum$4(lhs, rhs,)) then lhs; else error› in if obj is ‹(Variable$3) then derive$Variable$3(obj,); else error›, let obj = let obj = this in if obj is ‹(Sum$4(lhs, rhs,)) then rhs; else error› in if obj is ‹(Numeric$2) then derive$Numeric$2(obj,); else error›,)
-//│   fun main$$9 = () => let obj = let obj = Mul$5(Pow$6(Variable$3("x",), Numeric$2(2,),), Pow$6(Variable$3("y",), Numeric$2(2,),),) in if obj is ‹(Mul$5) then derive$Mul$5(obj,); else error› in if obj is ‹(Sum$4) then getVal$Sum$4(obj,); else error›
-//│   fun derive$Numeric$2 = (this,) => Numeric$2(0,)
-//│   fun getNum$Numeric$2 = (this,) => let obj = this in if obj is ‹(Numeric$2(i,)) then i; else error›
-//│   fun derive$Variable$3 = (this,) => Numeric$2(1,)
-//│   fun getVal$Mul$5 = (this,) => concat("(",)(concat(concat(concat(let obj = let obj = this in if obj is ‹(Mul$5(lhs, rhs,)) then lhs; else error› in if obj is ‹(Mul$5) then getVal$Mul$5(obj,); (Numeric$2) then getVal$Numeric$2(obj,); (Pow$6) then getVal$Pow$6(obj,); (Variable$3) then getVal$Variable$3(obj,); else error›,)(" * ",),)(let obj = let obj = this in if obj is ‹(Mul$5(lhs, rhs,)) then rhs; else error› in if obj is ‹(Mul$5) then getVal$Mul$5(obj,); (Numeric$2) then getVal$Numeric$2(obj,); (Pow$6) then getVal$Pow$6(obj,); else error›,),)(")",),)
-//│   fun main$$8 = () => let obj = let obj = Pow$6(Variable$3("x",), Numeric$2(3,),) in if obj is ‹(Pow$6) then derive$Pow$6(obj,); else error› in if obj is ‹(Mul$5) then getVal$Mul$5(obj,); else error›
-//│   fun main$$7 = () => let obj = let obj = Mul$5(Variable$3("x",), Numeric$2(3,),) in if obj is ‹(Mul$5) then derive$Mul$5(obj,); else error› in if obj is ‹(Sum$4) then getVal$Sum$4(obj,); else error›
-//│   fun main$$6 = () => let obj = let obj = Sum$4(Variable$3("x",), Numeric$2(3,),) in if obj is ‹(Sum$4) then derive$Sum$4(obj,); else error› in if obj is ‹(Sum$4) then getVal$Sum$4(obj,); else error›
-//│   fun getVal$Variable$3 = (this,) => let obj = this in if obj is ‹(Variable$3(nm,)) then nm; else error›
-//│   fun getVal$Numeric$2 = (this,) => toString(let obj = this in if obj is ‹(Numeric$2(i,)) then i; else error›,)
-//│   fun derive$Mul$5 = (this,) => Sum$4(Mul$5(let obj = let obj = this in if obj is ‹(Mul$5(lhs, rhs,)) then lhs; else error› in if obj is ‹(Variable$3) then derive$Variable$3(obj,); (Pow$6) then derive$Pow$6(obj,); else error›, let obj = this in if obj is ‹(Mul$5(lhs, rhs,)) then rhs; else error›,), Mul$5(let obj = this in if obj is ‹(Mul$5(lhs, rhs,)) then lhs; else error›, let obj = let obj = this in if obj is ‹(Mul$5(lhs, rhs,)) then rhs; else error› in if obj is ‹(Numeric$2) then derive$Numeric$2(obj,); (Pow$6) then derive$Pow$6(obj,); else error›,),)
-//│   Code(List(main$$6()))
-//│   Code(List(main$$7()))
-//│   Code(List(main$$8()))
-//│   Code(List(main$$9()))
+//│ class Pow(lhs: Variable, rhs: Numeric) extends Exp {
+//│   fun derive: () -> Mul
+//│   fun getVal: Str
 //│ }
-//│ class Numeric$2(i: Int) extends Exp$1
-//│ class Pow$6(lhs: Variable$3, rhs: Numeric$2) extends Exp$1
-//│ class Sum$4(lhs: Exp$1, rhs: Exp$1) extends Exp$1
-//│ class Mul$5(lhs: Exp$1, rhs: Exp$1) extends Exp$1
-//│ class Variable$3(nm: Str) extends Exp$1
-//│ class Exp$1()
-//│ fun getVal$Sum$4: Object -> Str
-//│ fun derive$Pow$6: Object -> Mul$5
-//│ fun getVal$Pow$6: Object -> Str
-//│ fun derive$Sum$4: Object -> Sum$4
-//│ fun main$$9: () -> Str
-//│ fun derive$Numeric$2: anything -> Numeric$2
-//│ fun getNum$Numeric$2: Object -> Int
-//│ fun derive$Variable$3: anything -> Numeric$2
-//│ fun getVal$Mul$5: Object -> Str
-//│ fun main$$8: () -> Str
-//│ fun main$$7: () -> Str
-//│ fun main$$6: () -> Str
-//│ fun getVal$Variable$3: Object -> Str
-//│ fun getVal$Numeric$2: Object -> Str
-//│ fun derive$Mul$5: Object -> Sum$4
 //│ Str
+//│ 
+//│ Simpledef:
+//│ {class Exp() {fun derive: () -> Exp
+//│  fun getVal: Str}
+//│  class Numeric(val i: Int,): Exp {fun derive = () => Numeric(0,)
+//│  fun getNum = i
+//│  fun getVal = toString(i,)}
+//│  class Variable(val nm: Str,): Exp {fun derive = () => Numeric(1,)
+//│  fun getVal = nm}
+//│  class Sum(val lhs: Exp, val rhs: Exp,): Exp {fun derive = () => Sum(let selRes$48 = lhs in case selRes$48 of { Variable => (selRes$48).derive()
+//│  Mul => (selRes$48).derive()
+//│  Sum => (selRes$48).derive()
+//│  Numeric => (selRes$48).derive() }, let selRes$56 = rhs in case selRes$56 of { Numeric => (selRes$56).derive()
+//│  Sum => (selRes$56).derive()
+//│  Mul => (selRes$56).derive() },)
+//│  fun getVal = concat("(",)(concat(concat(concat(let selRes$84 = lhs in case selRes$84 of { Variable => (selRes$84).getVal
+//│  Mul => (selRes$84).getVal
+//│  Sum => (selRes$84).getVal
+//│  Numeric => (selRes$84).getVal },)(" + ",),)(let selRes$102 = rhs in case selRes$102 of { Numeric => (selRes$102).getVal
+//│  Sum => (selRes$102).getVal
+//│  Mul => (selRes$102).getVal },),)(")",),)}
+//│  class Mul(val lhs: Exp, val rhs: Exp,): Exp {fun derive = () => Sum(Mul(let selRes$132 = lhs in case selRes$132 of { Variable => (selRes$132).derive()
+//│  Mul => (selRes$132).derive()
+//│  Sum => (selRes$132).derive()
+//│  Numeric => (selRes$132).derive()
+//│  Pow => (selRes$132).derive() }, rhs,), Mul(lhs, let selRes$150 = rhs in case selRes$150 of { Mul => (selRes$150).derive()
+//│  Sum => (selRes$150).derive()
+//│  Numeric => (selRes$150).derive()
+//│  Pow => (selRes$150).derive() },),)
+//│  fun getVal = concat("(",)(concat(concat(concat(let selRes$182 = lhs in case selRes$182 of { Variable => (selRes$182).getVal
+//│  Mul => (selRes$182).getVal
+//│  Sum => (selRes$182).getVal
+//│  Numeric => (selRes$182).getVal
+//│  Pow => (selRes$182).getVal },)(" * ",),)(let selRes$200 = rhs in case selRes$200 of { Mul => (selRes$200).getVal
+//│  Sum => (selRes$200).getVal
+//│  Numeric => (selRes$200).getVal
+//│  Pow => (selRes$200).getVal },),)(")",),)}
+//│  class Pow(val lhs: Variable, val rhs: Numeric,): Exp {fun derive = () => Mul(rhs, Pow(lhs, Numeric(-(let selRes$238 = rhs in case selRes$238 of { Numeric => (selRes$238).getNum }, 1,),),),)
+//│  fun getVal = concat("(",)(concat(concat(concat(let selRes$276 = lhs in case selRes$276 of { Variable => (selRes$276).getVal },)(" ^ ",),)(let selRes$294 = rhs in case selRes$294 of { Numeric => (selRes$294).getVal },),)(")",),)}
+//│  let selRes$316 = let selRes$318 = Sum(Variable("x",), Numeric(3,),) in case selRes$318 of { Sum => (selRes$318).derive() } in case selRes$316 of { Sum => (selRes$316).getVal }
+//│  let selRes$346 = let selRes$348 = Mul(Variable("x",), Numeric(3,),) in case selRes$348 of { Mul => (selRes$348).derive() } in case selRes$346 of { Sum => (selRes$346).getVal }
+//│  let selRes$376 = let selRes$378 = Pow(Variable("x",), Numeric(3,),) in case selRes$378 of { Pow => (selRes$378).derive() } in case selRes$376 of { Mul => (selRes$376).getVal }
+//│  let selRes$406 = let selRes$408 = Mul(Pow(Variable("x",), Numeric(2,),), Pow(Variable("y",), Numeric(2,),),) in case selRes$408 of { Mul => (selRes$408).derive() } in case selRes$406 of { Sum => (selRes$406).getVal }}
+//│ End simpledef
+//│ 
 //│ res
 //│     = '(1 + 0)'
 //│ res
diff --git a/compiler/shared/test/diff/Defunctionalize/FreeVariables.mls b/compiler/shared/test/diff/Defunctionalize/FreeVariables.mls
index d1590eecb7..6755160599 100644
--- a/compiler/shared/test/diff/Defunctionalize/FreeVariables.mls
+++ b/compiler/shared/test/diff/Defunctionalize/FreeVariables.mls
@@ -1,30 +1,21 @@
 :NewDefs
 
-:mono
 class X() {
     val num = 5
     fun get() = num
 }
 X().get()
-//│ Lifted:
-//│ TypingUnit {
-//│   class X$1([]) {let num = 5; fun get = () => (this).num}
-//│   Code(List((X$1()).get()))
+//│ class X() {
+//│   fun get: () -> 5
+//│   val num: 5
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class X$1([]) {}
-//│   let num$X$1 = (this,) => 5
-//│   fun get$X$1 = (this,) => let obj = this in if obj is ‹(X$1) then num$X$1(obj,); else error›
-//│   fun main$$1 = () => let obj = X$1() in if obj is ‹(X$1) then get$X$1(obj,); else error›
-//│   Code(List(main$$1()))
-//│ }
-//│ class X$1()
-//│ let num$X$1: anything -> 5
-//│ fun get$X$1: Object -> 5
-//│ fun main$$1: () -> 5
 //│ 5
-//│ num$X$1
-//│         = [Function: num$X$1]
+//│ 
+//│ Simpledef:
+//│ {class X() {let num = 5
+//│  fun get = () => num}
+//│  let selRes$10 = X() in case selRes$10 of { X => (selRes$10).get() }}
+//│ End simpledef
+//│ 
 //│ res
 //│     = 5
diff --git a/compiler/shared/test/diff/Defunctionalize/FuncsWithParams.mls b/compiler/shared/test/diff/Defunctionalize/FuncsWithParams.mls
index b87a3902bc..6713e10166 100644
--- a/compiler/shared/test/diff/Defunctionalize/FuncsWithParams.mls
+++ b/compiler/shared/test/diff/Defunctionalize/FuncsWithParams.mls
@@ -1,9 +1,8 @@
 :NewDefs
 
 
-:mono
-class Arithmetic() {
-    fun use(num1, num2) = 0
+abstract class Arithmetic() {
+    virtual fun use(num1: Int, num2: Int): Int
 }
 class Add() extends Arithmetic {
     fun use(num1, num2) = num1+num2
@@ -14,37 +13,29 @@ class Sub() extends Arithmetic {
 fun getArith(choice) = if choice == 1 then Add() else Sub()
 getArith(1).use(4,6)
 getArith(2).use(4,6)
-//│ Lifted:
-//│ TypingUnit {
-//│   class Arithmetic$1([]) {fun use = (num1, num2,) => 0}
-//│   class Add$2([]): Arithmetic$1 {fun use = (num1, num2,) => +(num1, num2,)}
-//│   class Sub$3([]): Arithmetic$1 {fun use = (num1, num2,) => -(num1, num2,)}
-//│   fun getArith$1 = (choice,) => if (==(choice, 1,)) then Add$2() else Sub$3()
-//│   Code(List((getArith$1(1,)).use(4, 6,)))
-//│   Code(List((getArith$1(2,)).use(4, 6,)))
+//│ abstract class Arithmetic() {
+//│   fun use: (num1: Int, num2: Int) -> Int
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Arithmetic$1([]) {}
-//│   class Sub$3([]): Arithmetic$1 {}
-//│   class Add$2([]): Arithmetic$1 {}
-//│   fun getArith$1 = (choice,) => if (==(choice, 1,)) then Add$2() else Sub$3()
-//│   fun use$Add$2 = (this, num1, num2,) => +(num1, num2,)
-//│   fun use$Sub$3 = (this, num1, num2,) => -(num1, num2,)
-//│   fun main$$5 = () => let obj = getArith$1(2,) in if obj is ‹(Sub$3) then use$Sub$3(obj, 4, 6,); (Add$2) then use$Add$2(obj, 4, 6,); else error›
-//│   fun main$$4 = () => let obj = getArith$1(1,) in if obj is ‹(Sub$3) then use$Sub$3(obj, 4, 6,); (Add$2) then use$Add$2(obj, 4, 6,); else error›
-//│   Code(List(main$$4()))
-//│   Code(List(main$$5()))
+//│ class Add() extends Arithmetic {
+//│   fun use: (Int, Int) -> Int
 //│ }
-//│ class Arithmetic$1()
-//│ class Sub$3() extends Arithmetic$1
-//│ class Add$2() extends Arithmetic$1
-//│ fun getArith$1: Num -> (Add$2 | Sub$3)
-//│ fun use$Add$2: (anything, Int, Int) -> Int
-//│ fun use$Sub$3: (anything, Int, Int) -> Int
-//│ fun main$$5: () -> Int
-//│ fun main$$4: () -> Int
+//│ class Sub() extends Arithmetic {
+//│   fun use: (Int, Int) -> Int
+//│ }
+//│ fun getArith: Num -> (Add | Sub)
 //│ Int
+//│ 
+//│ Simpledef:
+//│ {class Arithmetic() {fun use: (num1: Int, num2: Int) -> Int}
+//│  class Add(): Arithmetic {fun use = (num1::0, num2::1,) => +(num1, num2,)}
+//│  class Sub(): Arithmetic {fun use = (num1::2, num2::3,) => -(num1, num2,)}
+//│  fun getArith = (choice::4,) => if (==(choice, 1,)) then Add() else Sub()
+//│  let selRes$58 = getArith(1,) in case selRes$58 of { Sub => (selRes$58).use(4, 6,)
+//│  Add => (selRes$58).use(4, 6,) }
+//│  let selRes$76 = getArith(2,) in case selRes$76 of { Sub => (selRes$76).use(4, 6,)
+//│  Add => (selRes$76).use(4, 6,) }}
+//│ End simpledef
+//│ 
 //│ res
 //│     = 10
 //│ res
diff --git a/compiler/shared/test/diff/Defunctionalize/Inheritance.mls b/compiler/shared/test/diff/Defunctionalize/Inheritance.mls
index aa12c5fb2c..b0954aa1fa 100644
--- a/compiler/shared/test/diff/Defunctionalize/Inheritance.mls
+++ b/compiler/shared/test/diff/Defunctionalize/Inheritance.mls
@@ -1,39 +1,32 @@
 :NewDefs
 
-:mono
-class Sup {
+// FIXME: Pattern matches on superclass instead of subclass
+class Sup() {
     fun add(num1, num2) = num1+num2
 }
-class Sub1() extends Sup {}
+class Sub1() extends Sup() {}
 class Sub2() extends Sub1() {}
 Sub1().add(3,4)
 Sub2().add(5,6)
-//│ Lifted:
-//│ TypingUnit {
-//│   class Sup$1([]) {fun add = (num1, num2,) => +(num1, num2,)}
-//│   class Sub1$2([]): Sup$1 {}
-//│   class Sub2$3([]): Sub1$2() {}
-//│   Code(List((Sub1$2()).add(3, 4,)))
-//│   Code(List((Sub2$3()).add(5, 6,)))
+//│ class Sup() {
+//│   fun add: (Int, Int) -> Int
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Sub2$3([]): Sub1$2() {}
-//│   class Sup$1([]) {}
-//│   class Sub1$2([]): Sup$1 {}
-//│   fun add$Sup$1 = (this, num1, num2,) => +(num1, num2,)
-//│   fun main$$4 = () => let obj = Sub2$3() in if obj is ‹(Sub2$3) then add$Sup$1(obj, 5, 6,); else error›
-//│   fun main$$3 = () => let obj = Sub1$2() in if obj is ‹(Sub1$2) then add$Sup$1(obj, 3, 4,); else error›
-//│   Code(List(main$$3()))
-//│   Code(List(main$$4()))
+//│ class Sub1() extends Sup {
+//│   fun add: (Int, Int) -> Int
+//│ }
+//│ class Sub2() extends Sub1, Sup {
+//│   fun add: (Int, Int) -> Int
 //│ }
-//│ class Sub2$3() extends Sub1$2, Sup$1
-//│ class Sup$1()
-//│ class Sub1$2() extends Sup$1
-//│ fun add$Sup$1: (anything, Int, Int) -> Int
-//│ fun main$$4: () -> Int
-//│ fun main$$3: () -> Int
 //│ Int
+//│ 
+//│ Simpledef:
+//│ {class Sup() {fun add = (num1::0, num2::1,) => +(num1, num2,)}
+//│  class Sub1(): Sup() {}
+//│  class Sub2(): Sub1() {}
+//│  let selRes$16 = Sub1() in case selRes$16 of { Sup => (selRes$16).add(3, 4,) }
+//│  let selRes$32 = Sub2() in case selRes$32 of { Sup => (selRes$32).add(5, 6,) }}
+//│ End simpledef
+//│ 
 //│ res
 //│     = 7
 //│ res
diff --git a/compiler/shared/test/diff/Defunctionalize/Lambda.mls b/compiler/shared/test/diff/Defunctionalize/Lambda.mls
new file mode 100644
index 0000000000..c20c3305cd
--- /dev/null
+++ b/compiler/shared/test/diff/Defunctionalize/Lambda.mls
@@ -0,0 +1,22 @@
+:NewDefs
+
+
+class X(val foo: Int => Int){}
+class Y(val foo: Int => Bool){}
+fun x(pred) = if pred then X(x => x+1) else Y(x => true)
+x(true).foo(5)
+//│ class X(foo: Int -> Int)
+//│ class Y(foo: Int -> Bool)
+//│ fun x: Bool -> (X | Y)
+//│ Int | false | true
+//│ 
+//│ Simpledef:
+//│ {class X(val foo: (Int,) => Int,) {}
+//│  class Y(val foo: (Int,) => Bool,) {}
+//│  fun x = (pred::0,) => if (pred) then X((x::1,) => +(x, 1,),) else Y((x::2,) => true,)
+//│  let selRes$46 = x(true,) in case selRes$46 of { Y => (selRes$46).foo(5,)
+//│  X => (selRes$46).foo(5,) }}
+//│ End simpledef
+//│ 
+//│ res
+//│     = 6
diff --git a/compiler/shared/test/diff/Defunctionalize/Lambdas.mls b/compiler/shared/test/diff/Defunctionalize/Lambdas.mls
index 50471c0c23..8244f6018b 100644
--- a/compiler/shared/test/diff/Defunctionalize/Lambdas.mls
+++ b/compiler/shared/test/diff/Defunctionalize/Lambdas.mls
@@ -1,49 +1,22 @@
 :NewDefs
 
-:mono
 ((f, g) => f(g))(f => f, true)
-//│ Lifted:
-//│ TypingUnit {
-//│   class Lambda2$1$1([]) {fun apply = (f, g,) => f(g,)}
-//│   class Lambda1$2$2([]) {fun apply = (f,) => f}
-//│   Code(List('(' {Lambda2$1$1()} ')'({Lambda1$2$2()}, true,)))
-//│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Lambda2$1$1([]) {}
-//│   class Lambda1$2$2([]) {}
-//│   fun apply$Lambda2$1$1 = (this, f, g,) => let obj = f in if obj is ‹(Lambda1$2$2) then apply$Lambda1$2$2(obj, g,); else error›
-//│   fun main$$2 = () => let obj = '(' {Lambda2$1$1()} ')' in if obj is ‹(Lambda2$1$1) then apply$Lambda2$1$1(obj, {Lambda1$2$2()}, true,); else error›
-//│   fun apply$Lambda1$2$2 = (this, f,) => f
-//│   Code(List(main$$2()))
-//│ }
-//│ class Lambda2$1$1()
-//│ class Lambda1$2$2()
-//│ fun apply$Lambda2$1$1: forall 'a. (anything, Object, 'a) -> 'a
-//│ fun main$$2: () -> true
-//│ fun apply$Lambda1$2$2: forall 'a. (anything, 'a) -> 'a
 //│ true
+//│ 
+//│ Simpledef:
+//│ {'(' (f::0, g::1,) => f(g,) ')'((f::2,) => f, true,)}
+//│ End simpledef
+//│ 
 //│ res
 //│     = true
 
-:mono
 (b => if b then true else false) (true)
-//│ Lifted:
-//│ TypingUnit {
-//│   class Lambda1$1$1([]) {fun apply = (b,) => if (b) then true else false}
-//│   Code(List('(' {Lambda1$1$1()} ')'(true,)))
-//│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Lambda1$1$1([]) {}
-//│   fun apply$Lambda1$1$1 = (this, b,) => if (b) then true else false
-//│   fun main$$1 = () => let obj = '(' {Lambda1$1$1()} ')' in if obj is ‹(Lambda1$1$1) then apply$Lambda1$1$1(obj, true,); else error›
-//│   Code(List(main$$1()))
-//│ }
-//│ class Lambda1$1$1()
-//│ fun apply$Lambda1$1$1: (anything, Bool) -> Bool
-//│ fun main$$1: () -> Bool
 //│ Bool
+//│ 
+//│ Simpledef:
+//│ {'(' (b::3,) => if (b) then true else false ')'(true,)}
+//│ End simpledef
+//│ 
 //│ res
 //│     = true
 
diff --git a/compiler/shared/test/diff/Defunctionalize/ListConstruction.mls b/compiler/shared/test/diff/Defunctionalize/ListConstruction.mls
index 2f40742daa..62197c0daa 100644
--- a/compiler/shared/test/diff/Defunctionalize/ListConstruction.mls
+++ b/compiler/shared/test/diff/Defunctionalize/ListConstruction.mls
@@ -1,12 +1,11 @@
 :NewDefs
 
-:mono
-class List {
+
+abstract class List() {
     fun getRes: Str
-    fun getRes = ""
-    fun map(f) = error
+    fun map: error
 }
-class Cons(x: Int, xs: List) extends List {
+class Cons(val x: Int, val xs: List) extends List {
     fun getRes = concat(concat(toString(x))(" :: "))(xs.getRes)
     fun map(f) = Cons(f(x), xs.map(f))
 }
@@ -14,52 +13,39 @@ class Nil() extends List {
     fun getRes = "Nil"
     fun map(f) = Nil()
 }
-fun mkList(len: Int) =
+fun mkList(len) =
     if len == 0 then Nil()
     else Cons(len, mkList(len-1))
-mkList(5).map((x) => x*2).getRes
-//│ Lifted:
-//│ TypingUnit {
-//│   class List$1([]) {
-//│     fun getRes = Str
-//│     fun getRes = ""
-//│     fun map = (f,) => error
-//│   }
-//│   class Cons$2([x: Int, xs: List$1,]): List$1 {
-//│     fun getRes = concat(concat(toString((this).x,),)(" :: ",),)(((this).xs).getRes,)
-//│     fun map = (f,) => Cons$2(f((this).x,), ((this).xs).map(f,),)
-//│   }
-//│   class Nil$3([]): List$1 {fun getRes = "Nil"; fun map = (f,) => Nil$3()}
-//│   class Lambda1$2$4([]) {fun apply = ('(' x ')',) => *(x, 2,)}
-//│   fun mkList$1 = (len: Int,) => {if (==(len, 0,)) then Nil$3() else Cons$2(len, mkList$1(-(len, 1,),),)}
-//│   Code(List(((mkList$1(5,)).map({Lambda1$2$4()},)).getRes))
+mkList(5).map(x => x*2).getRes
+//│ abstract class List() {
+//│   fun getRes: Str
+//│   fun map: error
+//│ }
+//│ class Cons(x: Int, xs: List) extends List {
+//│   fun getRes: Str
+//│   fun map: (Int -> Int) -> Cons
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Lambda1$2$4([]) {}
-//│   class List$1([]) {}
-//│   class Cons$2([x: Int, xs: List$1,]): List$1 {}
-//│   class Nil$3([]): List$1 {}
-//│   fun mkList$1 = (len: Int,) => {if (==(len, 0,)) then Nil$3() else Cons$2(len, mkList$1(-(len, 1,),),)}
-//│   fun map$Nil$3 = (this, f,) => Nil$3()
-//│   fun getRes$Nil$3 = (this,) => "Nil"
-//│   fun getRes$Cons$2 = (this,) => concat(concat(toString(let obj = this in if obj is ‹(Cons$2(x, xs,)) then x; else error›,),)(" :: ",),)(let obj = let obj = this in if obj is ‹(Cons$2(x, xs,)) then xs; else error› in if obj is ‹(Cons$2) then getRes$Cons$2(obj,); (Nil$3) then getRes$Nil$3(obj,); else error›,)
-//│   fun main$$5 = () => let obj = let obj = mkList$1(5,) in if obj is ‹(Cons$2) then map$Cons$2(obj, {Lambda1$2$4()},); (Nil$3) then map$Nil$3(obj, {Lambda1$2$4()},); else error› in if obj is ‹(Cons$2) then getRes$Cons$2(obj,); (Nil$3) then getRes$Nil$3(obj,); else error›
-//│   fun map$Cons$2 = (this, f,) => Cons$2(let obj = f in if obj is ‹(Lambda1$2$4) then apply$Lambda1$2$4(obj, let obj = this in if obj is ‹(Cons$2(x, xs,)) then x; else error›,); else error›, let obj = let obj = this in if obj is ‹(Cons$2(x, xs,)) then xs; else error› in if obj is ‹(Cons$2) then map$Cons$2(obj, f,); (Nil$3) then map$Nil$3(obj, f,); else error›,)
-//│   fun apply$Lambda1$2$4 = (this, '(' x ')',) => *(x, 2,)
-//│   Code(List(main$$5()))
+//│ class Nil() extends List {
+//│   fun getRes: "Nil"
+//│   fun map: anything -> Nil
 //│ }
-//│ class Lambda1$2$4()
-//│ class List$1()
-//│ class Cons$2(x: Int, xs: List$1) extends List$1
-//│ class Nil$3() extends List$1
-//│ fun mkList$1: (len: Int) -> (Cons$2 | Nil$3)
-//│ fun map$Nil$3: (anything, anything) -> Nil$3
-//│ fun getRes$Nil$3: anything -> "Nil"
-//│ fun getRes$Cons$2: Object -> Str
-//│ fun main$$5: () -> Str
-//│ fun map$Cons$2: (Object, Object) -> Cons$2
-//│ fun apply$Lambda1$2$4: (anything, Int) -> Int
+//│ fun mkList: Int -> (Cons | Nil)
 //│ Str
+//│ 
+//│ Simpledef:
+//│ {class List() {fun getRes: Str
+//│  fun map: error}
+//│  class Cons(val x: Int, val xs: List,): List {fun getRes = concat(concat(toString(x,),)(" :: ",),)(let selRes$30 = xs in case selRes$30 of { Nil => (selRes$30).getRes
+//│  Cons => (selRes$30).getRes },)
+//│  fun map = (f::0,) => Cons(f(x,), let selRes$50 = xs in case selRes$50 of { Nil => (selRes$50).map(f,)
+//│  Cons => (selRes$50).map(f,) },)}
+//│  class Nil(): List {fun getRes = "Nil"
+//│  fun map = (f::1,) => Nil()}
+//│  fun mkList = (len::2,) => {if (==(len, 0,)) then Nil() else Cons(len, mkList(-(len, 1,),),)}
+//│  let selRes$126 = let selRes$128 = mkList(5,) in case selRes$128 of { Cons => (selRes$128).map((x::3,) => *(x, 2,),)
+//│  Nil => (selRes$128).map((x::3,) => *(x, 2,),) } in case selRes$126 of { Cons => (selRes$126).getRes
+//│  Nil => (selRes$126).getRes }}
+//│ End simpledef
+//│ 
 //│ res
 //│     = '10 :: 8 :: 6 :: 4 :: 2 :: Nil'
diff --git a/compiler/shared/test/diff/Defunctionalize/Modules.mls b/compiler/shared/test/diff/Defunctionalize/Modules.mls
index 48f5a7548b..6967753a4e 100644
--- a/compiler/shared/test/diff/Defunctionalize/Modules.mls
+++ b/compiler/shared/test/diff/Defunctionalize/Modules.mls
@@ -1,36 +1,22 @@
 :NewDefs
 
-:w
-:mono
+
 class Foo() {fun f = 0}
 module x { val y = Foo() }
 x.y.f
-//│ Lifted:
-//│ TypingUnit {
-//│   class Foo$1([]) {fun f = 0}
-//│   module x$2 {let y = Foo$1()}
-//│   Code(List(((x$2).y).f))
+//│ class Foo() {
+//│   fun f: 0
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   module x$2 {}
-//│   class Foo$1([]) {}
-//│   let y$x$2 = (this,) => Foo$1()
-//│   fun f$Foo$1 = (this,) => 0
-//│   fun main$$2 = () => let obj = let obj = x$2 in if obj is ‹(x$2) then y$x$2(obj,); else error› in if obj is ‹(Foo$1) then f$Foo$1(obj,); else error›
-//│   Code(List(main$$2()))
+//│ module x {
+//│   val y: Foo
 //│ }
-//│ ╔══[WARNING] the outer binding `x$2`
-//│ ╙── is shadowed by name pattern `x$2`
-//│ ╔══[WARNING] this case is unreachable
-//│ ╙── because it is subsumed by the branch
-//│ module x$2
-//│ class Foo$1()
-//│ let y$x$2: anything -> Foo$1
-//│ fun f$Foo$1: anything -> 0
-//│ fun main$$2: () -> 0
 //│ 0
-//│ y$x$2
-//│       = [Function: y$x$2]
+//│ 
+//│ Simpledef:
+//│ {class Foo() {fun f = 0}
+//│  module x {let y = Foo()}
+//│  let selRes$10 = let selRes$12 = x in case selRes$12 of { x => (selRes$12).y } in case selRes$10 of { Foo => (selRes$10).f }}
+//│ End simpledef
+//│ 
 //│ res
 //│     = 0
diff --git a/compiler/shared/test/diff/Defunctionalize/MonoNonLambda.mls b/compiler/shared/test/diff/Defunctionalize/MonoNonLambda.mls
index 847f6dd55f..531810864e 100644
--- a/compiler/shared/test/diff/Defunctionalize/MonoNonLambda.mls
+++ b/compiler/shared/test/diff/Defunctionalize/MonoNonLambda.mls
@@ -1,7 +1,5 @@
 :NewDefs
 
-:ge // TODO: Wrap resulting statements in module
-:mono
 class A() {
     val x = 2
     val y() = 3
@@ -13,42 +11,34 @@ a.x
 a.y()
 a.z
 a.w()
-//│ Lifted:
-//│ TypingUnit {
-//│   class A$1([]) {let x = 2; let y = () => 3; fun z = 4; fun w = () => 5}
-//│   let a$1 = A$1()
-//│   Code(List((a$1).x))
-//│   Code(List((a$1).y()))
-//│   Code(List((a$1).z))
-//│   Code(List((a$1).w()))
+//│ class A() {
+//│   fun w: () -> 5
+//│   val x: 2
+//│   val y: () -> 3
+//│   fun z: 4
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class A$1([]) {}
-//│   let y$A$1 = (this,) => 3
-//│   fun main$$5 = () => let obj = a$1 in if obj is ‹(A$1) then w$A$1(obj,); else error›
-//│   fun z$A$1 = (this,) => 4
-//│   fun main$$4 = () => let obj = a$1 in if obj is ‹(A$1) then z$A$1(obj,); else error›
-//│   fun main$$3 = () => let obj = a$1 in if obj is ‹(A$1) then y$A$1(obj,); else error›
-//│   let x$A$1 = (this,) => 2
-//│   fun main$$2 = () => let obj = a$1 in if obj is ‹(A$1) then x$A$1(obj,); else error›
-//│   let a$1 = A$1()
-//│   fun w$A$1 = (this,) => 5
-//│   Code(List(main$$2()))
-//│   Code(List(main$$3()))
-//│   Code(List(main$$4()))
-//│   Code(List(main$$5()))
-//│ }
-//│ class A$1()
-//│ let y$A$1: anything -> 3
-//│ fun main$$5: () -> 5
-//│ fun z$A$1: anything -> 4
-//│ fun main$$4: () -> 4
-//│ fun main$$3: () -> 3
-//│ let x$A$1: anything -> 2
-//│ fun main$$2: () -> 2
-//│ let a$1: A$1
-//│ fun w$A$1: anything -> 5
+//│ val a: A
 //│ 5
-//│ Code generation encountered an error:
-//│   unguarded recursive use of by-value binding a$1
+//│ 
+//│ Simpledef:
+//│ {class A() {let x = 2
+//│  let y = () => 3
+//│  fun z = 4
+//│  fun w = () => 5}
+//│  let a = A()
+//│  let selRes$24 = a in case selRes$24 of { A => (selRes$24).x }
+//│  let selRes$28 = a in case selRes$28 of { A => (selRes$28).y() }
+//│  let selRes$36 = a in case selRes$36 of { A => (selRes$36).z }
+//│  let selRes$40 = a in case selRes$40 of { A => (selRes$40).w() }}
+//│ End simpledef
+//│ 
+//│ a
+//│   = A {}
+//│ res
+//│     = 2
+//│ res
+//│     = 3
+//│ res
+//│     = 4
+//│ res
+//│     = 5
diff --git a/compiler/shared/test/diff/Defunctionalize/MonoTupSelect.mls b/compiler/shared/test/diff/Defunctionalize/MonoTupSelect.mls
index 6ce35afc85..a3f5cd8227 100644
--- a/compiler/shared/test/diff/Defunctionalize/MonoTupSelect.mls
+++ b/compiler/shared/test/diff/Defunctionalize/MonoTupSelect.mls
@@ -1,35 +1,24 @@
 :NewDefs
 
-:mono
 class Foo() {fun f() = 0}
 class Bar() {fun f = 0}
 [Foo(), Bar()].0.f()
 [Foo(), Bar()].1.f
-//│ Lifted:
-//│ TypingUnit {
-//│   class Foo$1([]) {fun f = () => 0}
-//│   class Bar$2([]) {fun f = 0}
-//│   Code(List((([Foo$1(), Bar$2(),]).0).f()))
-//│   Code(List((([Foo$1(), Bar$2(),]).1).f))
+//│ class Foo() {
+//│   fun f: () -> 0
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Foo$1([]) {}
-//│   class Bar$2([]) {}
-//│   fun f$Bar$2 = (this,) => 0
-//│   fun main$$3 = () => let obj = ([Foo$1(), Bar$2(),]).1 in if obj is ‹(Bar$2) then f$Bar$2(obj,); else error›
-//│   fun f$Foo$1 = (this,) => 0
-//│   fun main$$2 = () => let obj = ([Foo$1(), Bar$2(),]).0 in if obj is ‹(Foo$1) then f$Foo$1(obj,); else error›
-//│   Code(List(main$$2()))
-//│   Code(List(main$$3()))
+//│ class Bar() {
+//│   fun f: 0
 //│ }
-//│ class Foo$1()
-//│ class Bar$2()
-//│ fun f$Bar$2: anything -> 0
-//│ fun main$$3: () -> 0
-//│ fun f$Foo$1: anything -> 0
-//│ fun main$$2: () -> 0
 //│ 0
+//│ 
+//│ Simpledef:
+//│ {class Foo() {fun f = () => 0}
+//│  class Bar() {fun f = 0}
+//│  let selRes$10 = ([Foo(), Bar(),]).0 in case selRes$10 of { Foo => (selRes$10).f() }
+//│  let selRes$32 = ([Foo(), Bar(),]).1 in case selRes$32 of { Bar => (selRes$32).f }}
+//│ End simpledef
+//│ 
 //│ res
 //│     = 0
 //│ res
diff --git a/compiler/shared/test/diff/Defunctionalize/MutableParams.mls b/compiler/shared/test/diff/Defunctionalize/MutableParams.mls
index d652f6d0b7..871b563d62 100644
--- a/compiler/shared/test/diff/Defunctionalize/MutableParams.mls
+++ b/compiler/shared/test/diff/Defunctionalize/MutableParams.mls
@@ -1,25 +1,21 @@
 :NewDefs // TODO: Mutable Parameters
 
-//:mono
 //class Bar(#x)
 //fun foo(#b) = b
 //let a = foo(new Bar(1))
 //let b = foo(new Bar(2))
 
-//:mono
 //class OneInt(#a){
 //  fun inc() = a+1
 //}
 //(new OneInt(1)).inc()
 
-//:mono
 //class OneInt(#a){
 //  fun add(x) = 
 //    new OneInt(a+x.a)
 //}
 //(new OneInt(1)).add(new OneInt(2))
 
-//:mono
 //trait AnyFoo {
 //}
 //class FooPlus(#a): AnyFoo {
diff --git a/compiler/shared/test/diff/Defunctionalize/MutualRec.mls b/compiler/shared/test/diff/Defunctionalize/MutualRec.mls
index d1f31ec1ab..d0d30678b2 100644
--- a/compiler/shared/test/diff/Defunctionalize/MutualRec.mls
+++ b/compiler/shared/test/diff/Defunctionalize/MutualRec.mls
@@ -1,7 +1,6 @@
 :NewDefs
 :AllowRuntimeErrors
 
-:mono
 val any = -20
 fun f(x) = 
   if x > any then 0
@@ -10,28 +9,20 @@ fun g(x) =
   if x > any then g(x - 1)
   else f(x - 2)
 g(1)
-//│ Lifted:
-//│ TypingUnit {
-//│   let any$3 = -20
-//│   fun f$1 = (x,) => {if (>(x, any$3,)) then 0 else g$2(-(x, 1,),)}
-//│   fun g$2 = (x,) => {if (>(x, any$3,)) then g$2(-(x, 1,),) else f$1(-(x, 2,),)}
-//│   Code(List(g$2(1,)))
-//│ }
-//│ Mono:
-//│ TypingUnit {
-//│   let any$3 = -20
-//│   fun f$1 = (x,) => {if (>(x, any$3,)) then 0 else g$2(-(x, 1,),)}
-//│   fun g$2 = (x,) => {if (>(x, any$3,)) then g$2(-(x, 1,),) else f$1(-(x, 2,),)}
-//│   fun main$$3 = () => g$2(1,)
-//│   Code(List(main$$3()))
-//│ }
-//│ let any$3: -20
-//│ fun f$1: Int -> 0
-//│ fun g$2: Int -> 0
-//│ fun main$$3: () -> 0
+//│ val any: -20
+//│ fun f: Int -> 0
+//│ fun g: Int -> 0
 //│ 0
-//│ any$3
-//│       = -20
+//│ 
+//│ Simpledef:
+//│ {let any = -20
+//│  fun f = (x::0,) => {if (>(x, any,)) then 0 else g(-(x, 1,),)}
+//│  fun g = (x::1,) => {if (>(x, any,)) then g(-(x, 1,),) else f(-(x, 2,),)}
+//│  g(1,)}
+//│ End simpledef
+//│ 
+//│ any
+//│     = -20
 //│ res
 //│ Runtime error:
 //│   RangeError: Maximum call stack size exceeded
diff --git a/compiler/shared/test/diff/Defunctionalize/NewOperator.mls b/compiler/shared/test/diff/Defunctionalize/NewOperator.mls
index 773bc72b88..fbb8043137 100644
--- a/compiler/shared/test/diff/Defunctionalize/NewOperator.mls
+++ b/compiler/shared/test/diff/Defunctionalize/NewOperator.mls
@@ -1,22 +1,15 @@
 :NewDefs
 
-:mono
-class Foo(x: Int) {
+class Foo(val x: Int) {
 }
-new Foo(5)
-//│ Lifted:
-//│ TypingUnit {
-//│   class Foo$1([x: Int,]) {}
-//│   Code(List((new Foo$1)(5,)))
-//│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Foo$1([x: Int,]) {}
-//│   fun main$$1 = () => (new Foo$1)(5,)
-//│   Code(List(main$$1()))
-//│ }
-//│ class Foo$1(x: Int)
-//│ fun main$$1: () -> Foo$1
-//│ Foo$1
+new Foo(5).x
+//│ class Foo(x: Int)
+//│ Int
+//│ 
+//│ Simpledef:
+//│ {class Foo(val x: Int,) {}
+//│  let selRes$4 = (new Foo)(5,) in case selRes$4 of { Foo => (selRes$4).x }}
+//│ End simpledef
+//│ 
 //│ res
-//│     = Foo$1 {}
+//│     = 5
diff --git a/compiler/shared/test/diff/Defunctionalize/NuMono.mls b/compiler/shared/test/diff/Defunctionalize/NuMono.mls
index 5d820d3e64..4146999791 100644
--- a/compiler/shared/test/diff/Defunctionalize/NuMono.mls
+++ b/compiler/shared/test/diff/Defunctionalize/NuMono.mls
@@ -1,7 +1,6 @@
 :NewDefs
 
 // old "new" syntax
-//:mono
 //class A() {
 //    val num() = 0
 //}
@@ -12,7 +11,6 @@
 //foo(10).num()
 
 
-:mono
 class A() {
     val num() = 0
 }
@@ -21,39 +19,27 @@ class B() {
 }
 fun foo(num: Int) = if num > 5 then A() else B()
 foo(10).num()
-//│ Lifted:
-//│ TypingUnit {
-//│   class A$1([]) {let num = () => 0}
-//│   class B$2([]) {let num = () => 1}
-//│   fun foo$1 = (num: Int,) => if (>(num, 5,)) then A$1() else B$2()
-//│   Code(List((foo$1(10,)).num()))
+//│ class A() {
+//│   val num: () -> 0
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class B$2([]) {}
-//│   class A$1([]) {}
-//│   fun foo$1 = (num: Int,) => if (>(num, 5,)) then A$1() else B$2()
-//│   let num$A$1 = (this,) => 0
-//│   let num$B$2 = (this,) => 1
-//│   fun main$$3 = () => let obj = foo$1(10,) in if obj is ‹(B$2) then num$B$2(obj,); (A$1) then num$A$1(obj,); else error›
-//│   Code(List(main$$3()))
+//│ class B() {
+//│   val num: () -> 1
 //│ }
-//│ class B$2()
-//│ class A$1()
-//│ fun foo$1: (num: Int) -> (A$1 | B$2)
-//│ let num$A$1: anything -> 0
-//│ let num$B$2: anything -> 1
-//│ fun main$$3: () -> (0 | 1)
+//│ fun foo: (num: Int) -> (A | B)
 //│ 0 | 1
-//│ num$A$1
-//│         = [Function: num$A$1]
-//│ num$B$2
-//│         = [Function: num$B$2]
+//│ 
+//│ Simpledef:
+//│ {class A() {let num = () => 0}
+//│  class B() {let num = () => 1}
+//│  fun foo = (num: Int,) => if (>(num, 5,)) then A() else B()
+//│  let selRes$42 = foo(10,) in case selRes$42 of { B => (selRes$42).num()
+//│  A => (selRes$42).num() }}
+//│ End simpledef
+//│ 
 //│ res
 //│     = 0
 
 
-:mono
 class A(val num1: Int, val num2: Int) {
     fun foo() = num1-num2
 }
@@ -63,34 +49,25 @@ class B(val num1: Int, val num2: Int) {
 fun foo(num: Int) = if num > 5 then A(10,6) else B(8,7)
 foo(10).foo()
 foo(0).foo()
-//│ Lifted:
-//│ TypingUnit {
-//│   class A$1([val num1: Int, val num2: Int,]) {fun foo = () => -((this).num1, (this).num2,)}
-//│   class B$2([val num1: Int, val num2: Int,]) {fun foo = () => +((this).num1, (this).num2,)}
-//│   fun foo$1 = (num: Int,) => if (>(num, 5,)) then A$1(10, 6,) else B$2(8, 7,)
-//│   Code(List((foo$1(10,)).foo()))
-//│   Code(List((foo$1(0,)).foo()))
+//│ class A(num1: Int, num2: Int) {
+//│   fun foo: () -> Int
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class B$2([val num1: Int, val num2: Int,]) {}
-//│   class A$1([val num1: Int, val num2: Int,]) {}
-//│   fun foo$B$2 = (this,) => +(let obj = this in if obj is ‹(B$2) then 8; else error›, let obj = this in if obj is ‹(B$2) then 7; else error›,)
-//│   fun foo$1 = (num: Int,) => if (>(num, 5,)) then A$1(10, 6,) else B$2(8, 7,)
-//│   fun foo$A$1 = (this,) => -(let obj = this in if obj is ‹(A$1) then 10; else error›, let obj = this in if obj is ‹(A$1) then 6; else error›,)
-//│   fun main$$4 = () => let obj = foo$1(0,) in if obj is ‹(B$2) then foo$B$2(obj,); (A$1) then foo$A$1(obj,); else error›
-//│   fun main$$3 = () => let obj = foo$1(10,) in if obj is ‹(B$2) then foo$B$2(obj,); (A$1) then foo$A$1(obj,); else error›
-//│   Code(List(main$$3()))
-//│   Code(List(main$$4()))
+//│ class B(num1: Int, num2: Int) {
+//│   fun foo: () -> Int
 //│ }
-//│ class B$2(num1: Int, num2: Int)
-//│ class A$1(num1: Int, num2: Int)
-//│ fun foo$B$2: Object -> Int
-//│ fun foo$1: (num: Int) -> (A$1 | B$2)
-//│ fun foo$A$1: Object -> Int
-//│ fun main$$4: () -> Int
-//│ fun main$$3: () -> Int
+//│ fun foo: (num: Int) -> (A | B)
 //│ Int
+//│ 
+//│ Simpledef:
+//│ {class A(val num1: Int, val num2: Int,) {fun foo = () => -(num1, num2,)}
+//│  class B(val num1: Int, val num2: Int,) {fun foo = () => +(num1, num2,)}
+//│  fun foo = (num: Int,) => if (>(num, 5,)) then A(10, 6,) else B(8, 7,)
+//│  let selRes$70 = foo(10,) in case selRes$70 of { B => (selRes$70).foo()
+//│  A => (selRes$70).foo() }
+//│  let selRes$84 = foo(0,) in case selRes$84 of { B => (selRes$84).foo()
+//│  A => (selRes$84).foo() }}
+//│ End simpledef
+//│ 
 //│ res
 //│     = 4
 //│ res
diff --git a/compiler/shared/test/diff/Defunctionalize/ObjFieldAccess.mls b/compiler/shared/test/diff/Defunctionalize/ObjFieldAccess.mls
index 3020a56d5d..5a2d163c39 100644
--- a/compiler/shared/test/diff/Defunctionalize/ObjFieldAccess.mls
+++ b/compiler/shared/test/diff/Defunctionalize/ObjFieldAccess.mls
@@ -1,164 +1,126 @@
 :NewDefs
 
-:ge // TODO: Wrap resulting statements in module
-:mono
-class A(i: Int) {
+class A(val i: Int) {
     fun get1() = i
     fun get2 = i
 }
 val a = A(6)
 a.get1()
 a.get2
-//│ Lifted:
-//│ TypingUnit {
-//│   class A$1([i: Int,]) {fun get1 = () => (this).i; fun get2 = (this).i}
-//│   let a$1 = A$1(6,)
-//│   Code(List((a$1).get1()))
-//│   Code(List((a$1).get2))
+//│ class A(i: Int) {
+//│   fun get1: () -> Int
+//│   fun get2: Int
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class A$1([i: Int,]) {}
-//│   fun get1$A$1 = (this,) => let obj = this in if obj is ‹(A$1) then 6; else error›
-//│   fun get2$A$1 = (this,) => let obj = this in if obj is ‹(A$1) then 6; else error›
-//│   fun main$$3 = () => let obj = a$1 in if obj is ‹(A$1) then get2$A$1(obj,); else error›
-//│   fun main$$2 = () => let obj = a$1 in if obj is ‹(A$1) then get1$A$1(obj,); else error›
-//│   let a$1 = A$1(6,)
-//│   Code(List(main$$2()))
-//│   Code(List(main$$3()))
-//│ }
-//│ class A$1(i: Int)
-//│ fun get1$A$1: Object -> 6
-//│ fun get2$A$1: Object -> 6
-//│ fun main$$3: () -> 6
-//│ fun main$$2: () -> 6
-//│ let a$1: A$1
-//│ 6
-//│ Code generation encountered an error:
-//│   unguarded recursive use of by-value binding a$1
+//│ val a: A
+//│ Int
+//│ 
+//│ Simpledef:
+//│ {class A(val i: Int,) {fun get1 = () => i
+//│  fun get2 = i}
+//│  let a = A(6,)
+//│  let selRes$20 = a in case selRes$20 of { A => (selRes$20).get1() }
+//│  let selRes$28 = a in case selRes$28 of { A => (selRes$28).get2 }}
+//│ End simpledef
+//│ 
+//│ a
+//│   = A {}
+//│ res
+//│     = 6
+//│ res
+//│     = 6
 
-:ge // TODO: Wrap resulting statements in module
-:mono
-class A(i: Str) {
+class A(val i: Str) {
     fun get1() = i
     fun get2 = i
 }
 val a = A("6")
 a.get1()
 a.get2
-//│ Lifted:
-//│ TypingUnit {
-//│   class A$1([i: Str,]) {fun get1 = () => (this).i; fun get2 = (this).i}
-//│   let a$1 = A$1("6",)
-//│   Code(List((a$1).get1()))
-//│   Code(List((a$1).get2))
+//│ class A(i: Str) {
+//│   fun get1: () -> Str
+//│   fun get2: Str
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class A$1([i: Str,]) {}
-//│   fun get1$A$1 = (this,) => let obj = this in if obj is ‹(A$1) then "6"; else error›
-//│   fun get2$A$1 = (this,) => let obj = this in if obj is ‹(A$1) then "6"; else error›
-//│   fun main$$3 = () => let obj = a$1 in if obj is ‹(A$1) then get2$A$1(obj,); else error›
-//│   fun main$$2 = () => let obj = a$1 in if obj is ‹(A$1) then get1$A$1(obj,); else error›
-//│   let a$1 = A$1("6",)
-//│   Code(List(main$$2()))
-//│   Code(List(main$$3()))
-//│ }
-//│ class A$1(i: Str)
-//│ fun get1$A$1: Object -> "6"
-//│ fun get2$A$1: Object -> "6"
-//│ fun main$$3: () -> "6"
-//│ fun main$$2: () -> "6"
-//│ let a$1: A$1
-//│ "6"
-//│ Code generation encountered an error:
-//│   unguarded recursive use of by-value binding a$1
+//│ val a: A
+//│ Str
+//│ 
+//│ Simpledef:
+//│ {class A(val i: Str,) {fun get1 = () => i
+//│  fun get2 = i}
+//│  let a = A("6",)
+//│  let selRes$20 = a in case selRes$20 of { A => (selRes$20).get1() }
+//│  let selRes$28 = a in case selRes$28 of { A => (selRes$28).get2 }}
+//│ End simpledef
+//│ 
+//│ a
+//│   = A {}
+//│ res
+//│     = '6'
+//│ res
+//│     = '6'
 
-:ge //TODO: Wrap resulting statements in module
-:mono
 class X()
-class Y(foo: X) {
+class Y(val foo: X) {
     fun get1() = foo
     fun get2 = foo
 }
 val a = Y(X())
 a.get1()
 a.get2
-//│ Lifted:
-//│ TypingUnit {
-//│   class X$1([]) {}
-//│   class Y$2([foo: X$1,]) {fun get1 = () => (this).foo; fun get2 = (this).foo}
-//│   let a$1 = Y$2(X$1(),)
-//│   Code(List((a$1).get1()))
-//│   Code(List((a$1).get2))
-//│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class X$1([]) {}
-//│   class Y$2([foo: X$1,]) {}
-//│   fun get1$Y$2 = (this,) => let obj = this in if obj is ‹(Y$2(foo,)) then foo; else error›
-//│   fun main$$4 = () => let obj = a$1 in if obj is ‹(Y$2) then get2$Y$2(obj,); else error›
-//│   fun main$$3 = () => let obj = a$1 in if obj is ‹(Y$2) then get1$Y$2(obj,); else error›
-//│   fun get2$Y$2 = (this,) => let obj = this in if obj is ‹(Y$2(foo,)) then foo; else error›
-//│   let a$1 = Y$2(X$1(),)
-//│   Code(List(main$$3()))
-//│   Code(List(main$$4()))
+//│ class X()
+//│ class Y(foo: X) {
+//│   fun get1: () -> X
+//│   fun get2: X
 //│ }
-//│ class X$1()
-//│ class Y$2(foo: X$1)
-//│ fun get1$Y$2: Object -> X$1
-//│ fun main$$4: () -> X$1
-//│ fun main$$3: () -> X$1
-//│ fun get2$Y$2: Object -> X$1
-//│ let a$1: Y$2
-//│ X$1
-//│ Code generation encountered an error:
-//│   unguarded recursive use of by-value binding a$1
+//│ val a: Y
+//│ X
+//│ 
+//│ Simpledef:
+//│ {class X() {}
+//│  class Y(val foo: X,) {fun get1 = () => foo
+//│  fun get2 = foo}
+//│  let a = Y(X(),)
+//│  let selRes$24 = a in case selRes$24 of { Y => (selRes$24).get1() }
+//│  let selRes$32 = a in case selRes$32 of { Y => (selRes$32).get2 }}
+//│ End simpledef
+//│ 
+//│ a
+//│   = Y {}
+//│ res
+//│     = X {}
+//│ res
+//│     = X {}
 
-:mono
 class I() {}
 class J() {}
-class K(foo: I, bar: J) {
+class K(val foo: I, val bar: J) {
     fun getFoo = foo
     fun getBar = bar
 }
 val k = K(I(), J())
 k.getFoo
 k.getBar
-//│ Lifted:
-//│ TypingUnit {
-//│   class I$1([]) {}
-//│   class J$2([]) {}
-//│   class K$3([foo: I$1, bar: J$2,]) {fun getFoo = (this).foo; fun getBar = (this).bar}
-//│   let k$1 = K$3(I$1(), J$2(),)
-//│   Code(List((k$1).getFoo))
-//│   Code(List((k$1).getBar))
-//│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class I$1([]) {}
-//│   class J$2([]) {}
-//│   class K$3([foo: I$1, bar: J$2,]) {}
-//│   fun getFoo$K$3 = (this,) => let obj = this in if obj is ‹(K$3(foo, bar,)) then foo; else error›
-//│   let k$1 = K$3(I$1(), J$2(),)
-//│   fun main$$5 = () => let obj = k$1 in if obj is ‹(K$3) then getBar$K$3(obj,); else error›
-//│   fun main$$4 = () => let obj = k$1 in if obj is ‹(K$3) then getFoo$K$3(obj,); else error›
-//│   fun getBar$K$3 = (this,) => let obj = this in if obj is ‹(K$3(foo, bar,)) then bar; else error›
-//│   Code(List(main$$4()))
-//│   Code(List(main$$5()))
+//│ class I()
+//│ class J()
+//│ class K(foo: I, bar: J) {
+//│   fun getBar: J
+//│   fun getFoo: I
 //│ }
-//│ class I$1()
-//│ class J$2()
-//│ class K$3(foo: I$1, bar: J$2)
-//│ fun getFoo$K$3: Object -> I$1
-//│ let k$1: K$3
-//│ fun main$$5: () -> J$2
-//│ fun main$$4: () -> I$1
-//│ fun getBar$K$3: Object -> J$2
-//│ J$2
-//│ k$1
-//│     = K$3 {}
+//│ val k: K
+//│ J
+//│ 
+//│ Simpledef:
+//│ {class I() {}
+//│  class J() {}
+//│  class K(val foo: I, val bar: J,) {fun getFoo = foo
+//│  fun getBar = bar}
+//│  let k = K(I(), J(),)
+//│  let selRes$26 = k in case selRes$26 of { K => (selRes$26).getFoo }
+//│  let selRes$30 = k in case selRes$30 of { K => (selRes$30).getBar }}
+//│ End simpledef
+//│ 
+//│ k
+//│   = K {}
 //│ res
-//│     = I$1 {}
+//│     = I {}
 //│ res
-//│     = J$2 {}
+//│     = J {}
diff --git a/compiler/shared/test/diff/Defunctionalize/ObjFields.mls b/compiler/shared/test/diff/Defunctionalize/ObjFields.mls
new file mode 100644
index 0000000000..970a87b45c
--- /dev/null
+++ b/compiler/shared/test/diff/Defunctionalize/ObjFields.mls
@@ -0,0 +1,34 @@
+:NewDefs
+
+
+class X(val bar: Int) {}
+class Y(val bar: Str) {}
+class A(val foo: X) {}
+class B(val foo: Y) {}
+fun getObj(pred) = if pred then A(X(1)) else B(Y("abc"))
+val x = getObj(true)
+x.foo.bar
+//│ class X(bar: Int)
+//│ class Y(bar: Str)
+//│ class A(foo: X)
+//│ class B(foo: Y)
+//│ fun getObj: Bool -> (A | B)
+//│ val x: A | B
+//│ Int | Str
+//│ 
+//│ Simpledef:
+//│ {class X(val bar: Int,) {}
+//│  class Y(val bar: Str,) {}
+//│  class A(val foo: X,) {}
+//│  class B(val foo: Y,) {}
+//│  fun getObj = (pred::0,) => if (pred) then A(X(1,),) else B(Y("abc",),)
+//│  let x = getObj(true,)
+//│  let selRes$54 = let selRes$56 = x in case selRes$56 of { A => (selRes$56).foo
+//│  B => (selRes$56).foo } in case selRes$54 of { Y => (selRes$54).bar
+//│  X => (selRes$54).bar }}
+//│ End simpledef
+//│ 
+//│ x
+//│   = A {}
+//│ res
+//│     = 1
diff --git a/compiler/shared/test/diff/Defunctionalize/ObjMultiFields.mls b/compiler/shared/test/diff/Defunctionalize/ObjMultiFields.mls
new file mode 100644
index 0000000000..5e4d46a154
--- /dev/null
+++ b/compiler/shared/test/diff/Defunctionalize/ObjMultiFields.mls
@@ -0,0 +1,40 @@
+:NewDefs
+
+
+class X(val foo: Int, val bar: Bool) {}
+class Y(val foo: Str, val bar: Int) {}
+class A(val foo: X) {}
+class B(val foo: Y) {}
+fun foo(pred) = if pred then A(X(1, false)) else B(Y("abc", 5))
+val x = foo(true)
+x.foo.bar
+foo(false).foo.bar
+//│ class X(foo: Int, bar: Bool)
+//│ class Y(foo: Str, bar: Int)
+//│ class A(foo: X)
+//│ class B(foo: Y)
+//│ fun foo: Bool -> (A | B)
+//│ val x: A | B
+//│ Int | false | true
+//│ 
+//│ Simpledef:
+//│ {class X(val foo: Int, val bar: Bool,) {}
+//│  class Y(val foo: Str, val bar: Int,) {}
+//│  class A(val foo: X,) {}
+//│  class B(val foo: Y,) {}
+//│  fun foo = (pred::0,) => if (pred) then A(X(1, false,),) else B(Y("abc", 5,),)
+//│  let x = foo(true,)
+//│  let selRes$58 = let selRes$60 = x in case selRes$60 of { A => (selRes$60).foo
+//│  B => (selRes$60).foo } in case selRes$58 of { Y => (selRes$58).bar
+//│  X => (selRes$58).bar }
+//│  let selRes$64 = let selRes$66 = foo(false,) in case selRes$66 of { B => (selRes$66).foo
+//│  A => (selRes$66).foo } in case selRes$64 of { X => (selRes$64).bar
+//│  Y => (selRes$64).bar }}
+//│ End simpledef
+//│ 
+//│ x
+//│   = A {}
+//│ res
+//│     = false
+//│ res
+//│     = 5
diff --git a/compiler/shared/test/diff/Defunctionalize/ObjsSelection.mls b/compiler/shared/test/diff/Defunctionalize/ObjsSelection.mls
new file mode 100644
index 0000000000..8fa4f5e55f
--- /dev/null
+++ b/compiler/shared/test/diff/Defunctionalize/ObjsSelection.mls
@@ -0,0 +1,42 @@
+:NewDefs
+
+class X() {
+    val num = 6
+}
+class Y() {
+    val num = true
+}
+fun foo(pred) = if pred then X() else Y()
+fun id(x) = x
+val a = foo(true)
+val b = id(a)
+b.num
+//│ class X() {
+//│   val num: 6
+//│ }
+//│ class Y() {
+//│   val num: true
+//│ }
+//│ fun foo: Bool -> (X | Y)
+//│ fun id: forall 'a. 'a -> 'a
+//│ val a: X | Y
+//│ val b: X | Y
+//│ 6 | true
+//│ 
+//│ Simpledef:
+//│ {class X() {let num = 6}
+//│  class Y() {let num = true}
+//│  fun foo = (pred::0,) => if (pred) then X() else Y()
+//│  fun id = (x::1,) => x
+//│  let a = foo(true,)
+//│  let b = id(a,)
+//│  let selRes$48 = b in case selRes$48 of { Y => (selRes$48).num
+//│  X => (selRes$48).num }}
+//│ End simpledef
+//│ 
+//│ a
+//│   = X {}
+//│ b
+//│   = X {}
+//│ res
+//│     = 6
diff --git a/compiler/shared/test/diff/Defunctionalize/OldMonoList.mls b/compiler/shared/test/diff/Defunctionalize/OldMonoList.mls
index 93b44c0b1b..82a68fd53b 100644
--- a/compiler/shared/test/diff/Defunctionalize/OldMonoList.mls
+++ b/compiler/shared/test/diff/Defunctionalize/OldMonoList.mls
@@ -1,52 +1,45 @@
 :NewDefs
-:AllowRuntimeErrors
 
-// FIXME
-:mono
-class List(e: Int, tail: List | Nil) {
+class List(val e: Int, val tail: List | Nil) {
   fun map: (Int -> Int) -> List 
-  fun map(f)= new List(f(e), tail.map(f))
+  fun map(f)= List(f(e), tail.map(f))
   fun count(): Int
   fun count() = 1 + tail.count()
 }
 class Nil() {
-  fun map(f) = this
+  fun map(f) = Nil()
   fun count() = 0
 }
 fun add2(x) = x+2
-(new List(1, new List(2, new Nil()))).map(x => x+1).map(x => add2(x))
-//│ Lifted:
-//│ TypingUnit {
-//│   class List$1([e: Int, tail: |(List$1, Nil$2,),]) {
-//│     fun map = (Int -> Int) -> List$1
-//│     fun map = (f,) => (new List$1)(f((this).e,), ((this).tail).map(f,),)
-//│     fun count = () -> Int
-//│     fun count = () => +(1, ((this).tail).count(),)
-//│   }
-//│   class Nil$2([]) {fun map = (f,) => this; fun count = () => 0}
-//│   class Lambda1$2$3([]) {fun apply = (x,) => +(x, 1,)}
-//│   class Lambda1$3$4([]) {fun apply = (x,) => add2$1(x,)}
-//│   fun add2$1 = (x,) => +(x, 2,)
-//│   Code(List((('(' (new List$1)(1, (new List$1)(2, (new Nil$2)(),),) ')').map({Lambda1$2$3()},)).map({Lambda1$3$4()},)))
+(List(1, List(2, Nil()))).map(x => x+1).map(x => add2(x))
+//│ class List(e: Int, tail: List | Nil) {
+//│   fun count: () -> Int
+//│   fun map: (Int -> Int) -> List
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Lambda1$3$4([]) {}
-//│   class Nil$2([]) {}
-//│   class List$1([e: Int, tail: |(List$1, Nil$2,),]) {}
-//│   class Lambda1$2$3([]) {}
-//│   fun map$List$1 = (this, f,) => (new List$1)(let obj = f in if obj is ‹(Lambda1$3$4) then apply$Lambda1$3$4(obj, let obj = this in if obj is ‹(List$1(e, tail,)) then e; else error›,); (Lambda1$2$3) then apply$Lambda1$2$3(obj, let obj = this in if obj is ‹(List$1(e, tail,)) then e; else error›,); else error›, let obj = let obj = this in if obj is ‹(List$1(e, tail,)) then tail; else error› in if obj is ‹(List$1) then map$List$1(obj, f,); (Nil$2) then map$Nil$2(obj, f,); else error›,)
-//│   fun add2$1 = (x,) => +(x, 2,)
-//│   fun main$$5 = () => let obj = let obj = '(' (new List$1)(1, (new List$1)(2, (new Nil$2)(),),) ')' in if obj is ‹(List$1) then map$List$1(obj, {Lambda1$2$3()},); else error› in if obj is ‹(List$1) then map$List$1(obj, {Lambda1$3$4()},); else error›
-//│   fun apply$Lambda1$3$4 = (this, x,) => add2$1(x,)
-//│   fun map$Nil$2 = (this, f,) => this
-//│   fun apply$Lambda1$2$3 = (this, x,) => +(x, 1,)
-//│   Code(List(main$$5()))
+//│ class Nil() {
+//│   fun count: () -> 0
+//│   fun map: anything -> Nil
 //│ }
-//│ /!!!\ Uncaught error: java.lang.Exception: Internal Error: the `if` expression has already been desugared, please make sure that the objects are copied
+//│ fun add2: Int -> Int
+//│ List
+//│ 
+//│ Simpledef:
+//│ {class List(val e: Int, val tail: |(List, Nil,),) {fun map: (Int -> Int) -> List
+//│  fun map = (f::0,) => List(f(e,), let selRes$16 = tail in case selRes$16 of { List => (selRes$16).map(f,)
+//│  Nil => (selRes$16).map(f,) },)
+//│  fun count: () -> Int
+//│  fun count = () => +(1, let selRes$38 = tail in case selRes$38 of { List => (selRes$38).count()
+//│  Nil => (selRes$38).count() },)}
+//│  class Nil() {fun map = (f::1,) => Nil()
+//│  fun count = () => 0}
+//│  fun add2 = (x::2,) => +(x, 2,)
+//│  let selRes$82 = let selRes$84 = '(' List(1, List(2, Nil(),),) ')' in case selRes$84 of { List => (selRes$84).map((x::3,) => +(x, 1,),) } in case selRes$82 of { List => (selRes$82).map((x::4,) => add2(x,),) }}
+//│ End simpledef
+//│ 
+//│ res
+//│     = List {}
 
-:mono
-class List(e: Int, tail: List | Nil) {
+class List(val e: Int, val tail: List | Nil) {
   fun count(): Int
   fun count() = 1 + tail.count()
 }
@@ -55,51 +48,37 @@ class Nil() {
 }
 fun foo(x) = x.count()
 fun generate(x) = 
-  if x > 0 then new List(x, generate(x+1)) else new Nil()
+  if x > 0 then List(x, generate(x-1)) else Nil()
 foo(List(1, List(2, Nil())))
-foo(generate(1))
-//│ Lifted:
-//│ TypingUnit {
-//│   class List$1([e: Int, tail: |(List$1, Nil$2,),]) {
-//│     fun count = () -> Int
-//│     fun count = () => +(1, ((this).tail).count(),)
-//│   }
-//│   class Nil$2([]) {fun count = () => 0}
-//│   fun foo$1 = (x,) => (x).count()
-//│   fun generate$2 = (x,) => {if (>(x, 0,)) then (new List$1)(x, generate$2(+(x, 1,),),) else (new Nil$2)()}
-//│   Code(List(foo$1(List$1(1, List$1(2, Nil$2(),),),)))
-//│   Code(List(foo$1(generate$2(1,),)))
+foo(generate(50))
+//│ class List(e: Int, tail: List | Nil) {
+//│   fun count: () -> Int
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Nil$2([]) {}
-//│   class List$1([e: Int, tail: |(List$1, Nil$2,),]) {}
-//│   fun foo$1 = (x,) => let obj = x in if obj is ‹(Nil$2) then count$Nil$2(obj,); (List$1) then count$List$1(obj,); else error›
-//│   fun count$Nil$2 = (this,) => 0
-//│   fun count$List$1 = (this,) => +(1, let obj = let obj = this in if obj is ‹(List$1(e, tail,)) then tail; else error› in if obj is ‹(Nil$2) then count$Nil$2(obj,); (List$1) then count$List$1(obj,); else error›,)
-//│   fun generate$2 = (x,) => {if (>(x, 0,)) then (new List$1)(x, generate$2(+(x, 1,),),) else (new Nil$2)()}
-//│   fun main$$5 = () => foo$1(generate$2(1,),)
-//│   fun main$$4 = () => foo$1(List$1(1, List$1(2, Nil$2(),),),)
-//│   Code(List(main$$4()))
-//│   Code(List(main$$5()))
+//│ class Nil() {
+//│   fun count: () -> 0
 //│ }
-//│ class Nil$2()
-//│ class List$1(e: Int, tail: List$1 | Nil$2)
-//│ fun foo$1: Object -> Int
-//│ fun count$Nil$2: anything -> 0
-//│ fun count$List$1: Object -> Int
-//│ fun generate$2: Int -> (List$1 | Nil$2)
-//│ fun main$$5: () -> Int
-//│ fun main$$4: () -> Int
+//│ fun foo: forall 'a. {count: () -> 'a} -> 'a
+//│ fun generate: Int -> (List | Nil)
 //│ Int
+//│ 
+//│ Simpledef:
+//│ {class List(val e: Int, val tail: |(List, Nil,),) {fun count: () -> Int
+//│  fun count = () => +(1, let selRes$10 = tail in case selRes$10 of { List => (selRes$10).count()
+//│  Nil => (selRes$10).count() },)}
+//│  class Nil() {fun count = () => 0}
+//│  fun foo = (x::5,) => let selRes$32 = x in case selRes$32 of { Nil => (selRes$32).count()
+//│  List => (selRes$32).count() }
+//│  fun generate = (x::6,) => {if (>(x, 0,)) then List(x, generate(-(x, 1,),),) else Nil()}
+//│  foo(List(1, List(2, Nil(),),),)
+//│  foo(generate(50,),)}
+//│ End simpledef
+//│ 
 //│ res
 //│     = 2
 //│ res
-//│ Runtime error:
-//│   RangeError: Maximum call stack size exceeded
+//│     = 50
 
-:mono
-class Cons(e: 'A, tail: Cons | Nil) {
+class Cons(val e: 'A, val tail: Cons | Nil) {
   fun count(): Int
   fun count() = 1 + tail.count()
 }
@@ -110,7 +89,7 @@ class Lambda(){
   fun apply(l) = 
     l.count()
 }
-class Lambda2(a: Int){
+class Lambda2(val a: Int){
   fun apply(l) = 
     ( Cons(a, l)).count()
 }
@@ -118,56 +97,42 @@ fun foo(x) =
   x.apply(Cons(1, Nil())) + x.apply(Nil())
 foo(Lambda())
 foo(Lambda2(2))
-//│ Lifted:
-//│ TypingUnit {
-//│   class Cons$1([e: 'A, tail: |(Cons$1, Nil$2,),]) {
-//│     fun count = () -> Int
-//│     fun count = () => +(1, ((this).tail).count(),)
-//│   }
-//│   class Nil$2([]) {fun count = () => 0}
-//│   class Lambda$3([]) {fun apply = (l,) => {(l).count()}}
-//│   class Lambda2$4([a: Int,]) {
-//│     fun apply = (l,) => {('(' Cons$1((this).a, l,) ')').count()}
-//│   }
-//│   fun foo$1 = (x,) => {+((x).apply(Cons$1(1, Nil$2(),),), (x).apply(Nil$2(),),)}
-//│   Code(List(foo$1(Lambda$3(),)))
-//│   Code(List(foo$1(Lambda2$4(2,),)))
+//│ class Cons(e: nothing, tail: Cons | Nil) {
+//│   fun count: () -> Int
+//│ }
+//│ class Nil() {
+//│   fun count: () -> 0
+//│ }
+//│ class Lambda() {
+//│   fun apply: forall 'a. {count: () -> 'a} -> 'a
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Nil$2([]) {}
-//│   class Lambda2$4([a: Int,]) {}
-//│   class Cons$1([e: 'A, tail: |(Cons$1, Nil$2,),]) {}
-//│   class Lambda$3([]) {}
-//│   fun count$Cons$1 = (this,) => +(1, let obj = let obj = this in if obj is ‹(Cons$1(e, tail,)) then tail; else error› in if obj is ‹(Nil$2) then count$Nil$2(obj,); (Cons$1) then count$Cons$1(obj,); else error›,)
-//│   fun foo$1 = (x,) => {+(let obj = x in if obj is ‹(Lambda$3) then apply$Lambda$3(obj, Cons$1(1, Nil$2(),),); (Lambda2$4) then apply$Lambda2$4(obj, Cons$1(1, Nil$2(),),); else error›, let obj = x in if obj is ‹(Lambda$3) then apply$Lambda$3(obj, Nil$2(),); (Lambda2$4) then apply$Lambda2$4(obj, Nil$2(),); else error›,)}
-//│   fun apply$Lambda$3 = (this, l,) => {let obj = l in if obj is ‹(Nil$2) then count$Nil$2(obj,); (Cons$1) then count$Cons$1(obj,); else error›}
-//│   fun count$Nil$2 = (this,) => 0
-//│   fun apply$Lambda2$4 = (this, l,) => {let obj = '(' Cons$1(let obj = this in if obj is ‹(Lambda2$4) then 2; else error›, l,) ')' in if obj is ‹(Cons$1) then count$Cons$1(obj,); else error›}
-//│   fun main$$6 = () => foo$1(Lambda2$4(2,),)
-//│   fun main$$5 = () => foo$1(Lambda$3(),)
-//│   Code(List(main$$5()))
-//│   Code(List(main$$6()))
+//│ class Lambda2(a: Int) {
+//│   fun apply: (Cons | Nil) -> Int
 //│ }
-//│ class Nil$2()
-//│ class Lambda2$4(a: Int)
-//│ class Cons$1(e: nothing, tail: Cons$1 | Nil$2)
-//│ class Lambda$3()
-//│ fun count$Cons$1: Object -> Int
-//│ fun foo$1: Object -> Int
-//│ fun apply$Lambda$3: (anything, Object) -> Int
-//│ fun count$Nil$2: anything -> 0
-//│ fun apply$Lambda2$4: (Object, Cons$1 | Nil$2) -> Int
-//│ fun main$$6: () -> Int
-//│ fun main$$5: () -> Int
+//│ fun foo: {apply: (Cons | Nil) -> Int} -> Int
 //│ Int
+//│ 
+//│ Simpledef:
+//│ {class Cons(val e: 'A, val tail: |(Cons, Nil,),) {fun count: () -> Int
+//│  fun count = () => +(1, let selRes$10 = tail in case selRes$10 of { Cons => (selRes$10).count()
+//│  Nil => (selRes$10).count() },)}
+//│  class Nil() {fun count = () => 0}
+//│  class Lambda() {fun apply = (l::7,) => {let selRes$32 = l in case selRes$32 of { Cons => (selRes$32).count()
+//│  Nil => (selRes$32).count() }}}
+//│  class Lambda2(val a: Int,) {fun apply = (l::8,) => {let selRes$48 = '(' Cons(a, l,) ')' in case selRes$48 of { Cons => (selRes$48).count() }}}
+//│  fun foo = (x::9,) => {+(let selRes$74 = x in case selRes$74 of { Lambda2 => (selRes$74).apply(Cons(1, Nil(),),)
+//│  Lambda => (selRes$74).apply(Cons(1, Nil(),),) }, let selRes$96 = x in case selRes$96 of { Lambda2 => (selRes$96).apply(Nil(),)
+//│  Lambda => (selRes$96).apply(Nil(),) },)}
+//│  foo(Lambda(),)
+//│  foo(Lambda2(2,),)}
+//│ End simpledef
+//│ 
 //│ res
 //│     = 1
 //│ res
 //│     = 3
 
-:mono
-class Cons(e: Int, tail: Cons | Nil) {
+class Cons(val e: Int, val tail: Cons | Nil) {
   fun count(): Int
   fun count() = 1 + tail.count()
 }
@@ -178,47 +143,26 @@ fun foo(x) =
   x(Cons(1, Nil())) + x(Nil())
 foo(l => l.count())
 foo(l => (Cons(2, l)).count())
-//│ Lifted:
-//│ TypingUnit {
-//│   class Cons$1([e: Int, tail: |(Cons$1, Nil$2,),]) {
-//│     fun count = () -> Int
-//│     fun count = () => +(1, ((this).tail).count(),)
-//│   }
-//│   class Nil$2([]) {fun count = () => 0}
-//│   class Lambda1$2$3([]) {fun apply = (l,) => (l).count()}
-//│   class Lambda1$3$4([]) {fun apply = (l,) => ('(' Cons$1(2, l,) ')').count()}
-//│   fun foo$1 = (x,) => {+(x(Cons$1(1, Nil$2(),),), x(Nil$2(),),)}
-//│   Code(List(foo$1({Lambda1$2$3()},)))
-//│   Code(List(foo$1({Lambda1$3$4()},)))
+//│ class Cons(e: Int, tail: Cons | Nil) {
+//│   fun count: () -> Int
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Lambda1$3$4([]) {}
-//│   class Nil$2([]) {}
-//│   class Cons$1([e: Int, tail: |(Cons$1, Nil$2,),]) {}
-//│   class Lambda1$2$3([]) {}
-//│   fun count$Cons$1 = (this,) => +(1, let obj = let obj = this in if obj is ‹(Cons$1(e, tail,)) then tail; else error› in if obj is ‹(Nil$2) then count$Nil$2(obj,); (Cons$1) then count$Cons$1(obj,); else error›,)
-//│   fun foo$1 = (x,) => {+(let obj = x in if obj is ‹(Lambda1$2$3) then apply$Lambda1$2$3(obj, Cons$1(1, Nil$2(),),); (Lambda1$3$4) then apply$Lambda1$3$4(obj, Cons$1(1, Nil$2(),),); else error›, let obj = x in if obj is ‹(Lambda1$2$3) then apply$Lambda1$2$3(obj, Nil$2(),); (Lambda1$3$4) then apply$Lambda1$3$4(obj, Nil$2(),); else error›,)}
-//│   fun count$Nil$2 = (this,) => 0
-//│   fun main$$6 = () => foo$1({Lambda1$3$4()},)
-//│   fun main$$5 = () => foo$1({Lambda1$2$3()},)
-//│   fun apply$Lambda1$3$4 = (this, l,) => let obj = '(' Cons$1(2, l,) ')' in if obj is ‹(Cons$1) then count$Cons$1(obj,); else error›
-//│   fun apply$Lambda1$2$3 = (this, l,) => let obj = l in if obj is ‹(Nil$2) then count$Nil$2(obj,); (Cons$1) then count$Cons$1(obj,); else error›
-//│   Code(List(main$$5()))
-//│   Code(List(main$$6()))
+//│ class Nil() {
+//│   fun count: () -> 0
 //│ }
-//│ class Lambda1$3$4()
-//│ class Nil$2()
-//│ class Cons$1(e: Int, tail: Cons$1 | Nil$2)
-//│ class Lambda1$2$3()
-//│ fun count$Cons$1: Object -> Int
-//│ fun foo$1: Object -> Int
-//│ fun count$Nil$2: anything -> 0
-//│ fun main$$6: () -> Int
-//│ fun main$$5: () -> Int
-//│ fun apply$Lambda1$3$4: (anything, Cons$1 | Nil$2) -> Int
-//│ fun apply$Lambda1$2$3: (anything, Object) -> Int
+//│ fun foo: ((Cons | Nil) -> Int) -> Int
 //│ Int
+//│ 
+//│ Simpledef:
+//│ {class Cons(val e: Int, val tail: |(Cons, Nil,),) {fun count: () -> Int
+//│  fun count = () => +(1, let selRes$10 = tail in case selRes$10 of { Cons => (selRes$10).count()
+//│  Nil => (selRes$10).count() },)}
+//│  class Nil() {fun count = () => 0}
+//│  fun foo = (x::10,) => {+(x(Cons(1, Nil(),),), x(Nil(),),)}
+//│  foo((l::11,) => let selRes$78 = l in case selRes$78 of { Cons => (selRes$78).count()
+//│  Nil => (selRes$78).count() },)
+//│  foo((l::12,) => let selRes$96 = '(' Cons(2, l,) ')' in case selRes$96 of { Cons => (selRes$96).count() },)}
+//│ End simpledef
+//│ 
 //│ res
 //│     = 1
 //│ res
diff --git a/compiler/shared/test/diff/Defunctionalize/Polymorphic.mls b/compiler/shared/test/diff/Defunctionalize/Polymorphic.mls
index 7ea506964b..9f288de564 100644
--- a/compiler/shared/test/diff/Defunctionalize/Polymorphic.mls
+++ b/compiler/shared/test/diff/Defunctionalize/Polymorphic.mls
@@ -1,38 +1,31 @@
 :NewDefs
 
-:ge //TODO: Wrap resulting statements in module
-:mono
 let b = true
-class OneInt(a: Int){
+class OneInt(val a: Int){
   fun get = () -> a
 }
-class OneBool(b: Bool){
+class OneBool(val b: Bool){
   fun get = () -> b
 }
 (if b then OneInt(1) else OneBool(true)).get()
-//│ Lifted:
-//│ TypingUnit {
-//│   class OneInt$1([a: Int,]) {fun get = () => (this).a}
-//│   class OneBool$2([b: Bool,]) {fun get = () => b$1}
-//│   let b$1 = true
-//│   Code(List(('(' if (b$1) then OneInt$1(1,) else OneBool$2(true,) ')').get()))
+//│ let b: true
+//│ class OneInt(a: Int) {
+//│   fun get: () -> Int
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class OneInt$1([a: Int,]) {}
-//│   class OneBool$2([b: Bool,]) {}
-//│   fun get$OneInt$1 = (this,) => let obj = this in if obj is ‹(OneInt$1) then 1; else error›
-//│   fun get$OneBool$2 = (this,) => b$1
-//│   fun main$$3 = () => let obj = '(' if (b$1) then OneInt$1(1,) else OneBool$2(true,) ')' in if obj is ‹(OneBool$2) then get$OneBool$2(obj,); (OneInt$1) then get$OneInt$1(obj,); else error›
-//│   let b$1 = true
-//│   Code(List(main$$3()))
+//│ class OneBool(b: Bool) {
+//│   fun get: () -> Bool
 //│ }
-//│ class OneInt$1(a: Int)
-//│ class OneBool$2(b: Bool)
-//│ fun get$OneInt$1: Object -> 1
-//│ fun get$OneBool$2: anything -> true
-//│ fun main$$3: () -> (1 | true)
-//│ let b$1: true
-//│ 1 | true
-//│ Code generation encountered an error:
-//│   unguarded recursive use of by-value binding b$1
+//│ Int | false | true
+//│ 
+//│ Simpledef:
+//│ {let b = true
+//│  class OneInt(val a: Int,) {fun get = () => a}
+//│  class OneBool(val b: Bool,) {fun get = () => b}
+//│  let selRes$20 = '(' if (b) then OneInt(1,) else OneBool(true,) ')' in case selRes$20 of { OneInt => (selRes$20).get()
+//│  OneBool => (selRes$20).get() }}
+//│ End simpledef
+//│ 
+//│ b
+//│   = true
+//│ res
+//│     = 1
diff --git a/compiler/shared/test/diff/Defunctionalize/Record.mls b/compiler/shared/test/diff/Defunctionalize/Record.mls
new file mode 100644
index 0000000000..999b5be058
--- /dev/null
+++ b/compiler/shared/test/diff/Defunctionalize/Record.mls
@@ -0,0 +1,31 @@
+:NewDefs
+
+
+class K() {
+    val f = true
+}
+val x = {
+    5: "five",
+    7: "seven",
+    f: 6
+}
+fun muddle(pred) = if pred then K() else x
+muddle(false).f
+//│ class K() {
+//│   val f: true
+//│ }
+//│ val x: {5: "five", 7: "seven", f: 6}
+//│ fun muddle: Bool -> (K | {5: "five", 7: "seven", f: 6})
+//│ 6 | true
+//│ 
+//│ Simpledef:
+//│ {class K() {let f = true}
+//│  let x = '{' {5: "five", 7: "seven", f: 6} '}'
+//│  fun muddle = (pred::0,) => if (pred) then K() else x
+//│  (muddle(false,)).f}
+//│ End simpledef
+//│ 
+//│ x
+//│   = { '5': 'five', '7': 'seven', f: 6 }
+//│ res
+//│     = 6
diff --git a/compiler/shared/test/diff/Defunctionalize/RecursiveFunc.mls b/compiler/shared/test/diff/Defunctionalize/RecursiveFunc.mls
index efa36b2e69..0953f49180 100644
--- a/compiler/shared/test/diff/Defunctionalize/RecursiveFunc.mls
+++ b/compiler/shared/test/diff/Defunctionalize/RecursiveFunc.mls
@@ -1,28 +1,22 @@
 :NewDefs
 
-:mono
 fun fac(n) = 
   if (n > 1) then fac(n - 1) * n else 1
 fac(5)
-//│ Lifted:
-//│ TypingUnit {
-//│   fun fac$1 = (n,) => {if ('(' >(n, 1,) ')') then *(fac$1(-(n, 1,),), n,) else 1}
-//│   Code(List(fac$1(5,)))
-//│ }
-//│ Mono:
-//│ TypingUnit {
-//│   fun fac$1 = (n,) => {if ('(' >(n, 1,) ')') then *(fac$1(-(n, 1,),), n,) else 1}
-//│   fun main$$1 = () => fac$1(5,)
-//│   Code(List(main$$1()))
-//│ }
-//│ fun fac$1: Int -> Int
-//│ fun main$$1: () -> Int
+//│ fun fac: Int -> Int
 //│ Int
+//│ 
+//│ Simpledef:
+//│ {fun fac = (n::0,) => {if ('(' >(n, 1,) ')') then *(fac(-(n, 1,),), n,) else 1}
+//│  fac(5,)}
+//│ End simpledef
+//│ 
 //│ res
 //│     = 120
 
-// FIXME: Strange syntax
-:mono
+// TODO: Support for specialized pattern matching types
+// In this example, the type of l in count(l) would need to be constrained to
+// object & ~(), which requires implementing neg types, intersections, etc.
 class List(val l: List | Nil | undefined, val hasTail: Bool)  {}
 class Nil(val l: List | Nil | undefined, val hasTail: Bool)  {}
 fun count(lst) =
@@ -31,15 +25,12 @@ fun count(lst) =
     if l is undefined then 1 else count(l)+1
   else 0
 count(new List(new List(new Nil(undefined, false), true), true))
-//│ Lifted:
-//│ TypingUnit {
-//│   class List$1([val l: |(|(List$1, Nil$2,), undefined,), val hasTail: Bool,]) {}
-//│   class Nil$2([val l: |(|(List$1, Nil$2,), undefined,), val hasTail: Bool,]) {}
-//│   let l$2 = (lst).l
-//│   fun count$1 = (lst,) => {if ((lst).hasTail) then {if (is(l$2, undefined,)) then 1 else +(count$1(l$2,), 1,)} else 0}
-//│   Code(List(count$1((new List$1)((new List$1)((new Nil$2)(undefined, false,), true,), true,),)))
-//│ }
-//│ Mono:
-//│ ╔══[ERROR] Post-process failed to produce AST.
-//│ ╙──
+//│ class List(l: List | Nil | (), hasTail: Bool)
+//│ class Nil(l: List | Nil | (), hasTail: Bool)
+//│ fun count: forall 'a. 'a -> Int
+//│ Int
+//│ where
+//│   'a <: {hasTail: Bool, l: Object & 'a & ~() | ()}
 //│ 
+//│ Simpledef:
+//│ /!!!\ Uncaught error: java.lang.Exception: Internal Error: Could not constrain (ProdObj(Some(Var(prim$Unit)),List(),List()),ConsObj(None,List((Var(l),ConsVar(15,13_selres)))))
diff --git a/compiler/shared/test/diff/Defunctionalize/SelfReference.mls b/compiler/shared/test/diff/Defunctionalize/SelfReference.mls
index 6f1a2ceb99..06e711e6c7 100644
--- a/compiler/shared/test/diff/Defunctionalize/SelfReference.mls
+++ b/compiler/shared/test/diff/Defunctionalize/SelfReference.mls
@@ -1,28 +1,18 @@
 :NewDefs
 :AllowRuntimeErrors
 
-:mono
 fun f(x) = f(x)
 f(0)
 f(1)
-//│ Lifted:
-//│ TypingUnit {
-//│   fun f$1 = (x,) => f$1(x,)
-//│   Code(List(f$1(0,)))
-//│   Code(List(f$1(1,)))
-//│ }
-//│ Mono:
-//│ TypingUnit {
-//│   fun f$1 = (x,) => f$1(x,)
-//│   fun main$$2 = () => f$1(1,)
-//│   fun main$$1 = () => f$1(0,)
-//│   Code(List(main$$1()))
-//│   Code(List(main$$2()))
-//│ }
-//│ fun f$1: anything -> nothing
-//│ fun main$$2: () -> nothing
-//│ fun main$$1: () -> nothing
+//│ fun f: anything -> nothing
 //│ nothing
+//│ 
+//│ Simpledef:
+//│ {fun f = (x::0,) => f(x,)
+//│  f(0,)
+//│  f(1,)}
+//│ End simpledef
+//│ 
 //│ res
 //│ Runtime error:
 //│   RangeError: Maximum call stack size exceeded
diff --git a/compiler/shared/test/diff/Defunctionalize/SimpleClasses.mls b/compiler/shared/test/diff/Defunctionalize/SimpleClasses.mls
index a5bf393653..1ae858a63c 100644
--- a/compiler/shared/test/diff/Defunctionalize/SimpleClasses.mls
+++ b/compiler/shared/test/diff/Defunctionalize/SimpleClasses.mls
@@ -1,60 +1,41 @@
 :NewDefs
 
-:mono
-class Foo(x: Int){
+class Foo(val x: Int){
   fun bar(y) = x+y
   fun boo(z) = bar(z)+x
 }
 (Foo(1)).boo(2)
-//│ Lifted:
-//│ TypingUnit {
-//│   class Foo$1([x: Int,]) {
-//│     fun bar = (y,) => +((this).x, y,)
-//│     fun boo = (z,) => +((this).bar(z,), (this).x,)
-//│   }
-//│   Code(List(('(' Foo$1(1,) ')').boo(2,)))
+//│ class Foo(x: Int) {
+//│   fun bar: Int -> Int
+//│   fun boo: Int -> Int
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Foo$1([x: Int,]) {}
-//│   fun boo$Foo$1 = (this, z,) => +(let obj = this in if obj is ‹(Foo$1) then bar$Foo$1(obj, z,); else error›, let obj = this in if obj is ‹(Foo$1) then 1; else error›,)
-//│   fun bar$Foo$1 = (this, y,) => +(let obj = this in if obj is ‹(Foo$1) then 1; else error›, y,)
-//│   fun main$$1 = () => let obj = '(' Foo$1(1,) ')' in if obj is ‹(Foo$1) then boo$Foo$1(obj, 2,); else error›
-//│   Code(List(main$$1()))
-//│ }
-//│ class Foo$1(x: Int)
-//│ fun boo$Foo$1: (Object, Int) -> Int
-//│ fun bar$Foo$1: (Object, Int) -> Int
-//│ fun main$$1: () -> Int
 //│ Int
+//│ 
+//│ Simpledef:
+//│ {class Foo(val x: Int,) {fun bar = (y::0,) => +(x, y,)
+//│  fun boo = (z::1,) => +(bar(z,), x,)}
+//│  let selRes$38 = '(' Foo(1,) ')' in case selRes$38 of { Foo => (selRes$38).boo(2,) }}
+//│ End simpledef
+//│ 
 //│ res
 //│     = 4
 
-:mono
-class OneInt(a: Int){
+class OneInt(val a: Int){
   fun fac: () -> Int
   fun fac = () ->
     if(a > 0) then (OneInt(a - 1)).fac() else 1 
 }
 (OneInt(10)).fac()
-//│ Lifted:
-//│ TypingUnit {
-//│   class OneInt$1([a: Int,]) {
-//│     fun fac = () -> Int
-//│     fun fac = () => {if ('(' >((this).a, 0,) ')') then ('(' OneInt$1(-((this).a, 1,),) ')').fac() else 1}
-//│   }
-//│   Code(List(('(' OneInt$1(10,) ')').fac()))
-//│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class OneInt$1([a: Int,]) {}
-//│   fun fac$OneInt$1 = (this,) => {if ('(' >(let obj = this in if obj is ‹(OneInt$1(a,)) then a; else error›, 0,) ')') then let obj = '(' OneInt$1(-(let obj = this in if obj is ‹(OneInt$1(a,)) then a; else error›, 1,),) ')' in if obj is ‹(OneInt$1) then fac$OneInt$1(obj,); else error› else 1}
-//│   fun main$$1 = () => let obj = '(' OneInt$1(10,) ')' in if obj is ‹(OneInt$1) then fac$OneInt$1(obj,); else error›
-//│   Code(List(main$$1()))
+//│ class OneInt(a: Int) {
+//│   fun fac: () -> Int
 //│ }
-//│ class OneInt$1(a: Int)
-//│ fun fac$OneInt$1: Object -> 1
-//│ fun main$$1: () -> 1
-//│ 1
+//│ Int
+//│ 
+//│ Simpledef:
+//│ {class OneInt(val a: Int,) {fun fac: () -> Int
+//│  fun fac = () => {if ('(' >(a, 0,) ')') then let selRes$20 = '(' OneInt(-(a, 1,),) ')' in case selRes$20 of { OneInt => (selRes$20).fac() } else 1}}
+//│  let selRes$50 = '(' OneInt(10,) ')' in case selRes$50 of { OneInt => (selRes$50).fac() }}
+//│ End simpledef
+//│ 
 //│ res
 //│     = 1
diff --git a/compiler/shared/test/diff/Defunctionalize/SimpleConditionals.mls b/compiler/shared/test/diff/Defunctionalize/SimpleConditionals.mls
index 275a86a1fe..9813462e6d 100644
--- a/compiler/shared/test/diff/Defunctionalize/SimpleConditionals.mls
+++ b/compiler/shared/test/diff/Defunctionalize/SimpleConditionals.mls
@@ -1,45 +1,29 @@
 :NewDefs
-:mono
 if true then 1 else 0
 if 1+1 > 1 then 1 - 1 else 1*1
-//│ Lifted:
-//│ TypingUnit {
-//│   Code(List(if (true) then 1 else 0))
-//│   Code(List(if (>(+(1, 1,), 1,)) then -(1, 1,) else *(1, 1,)))
-//│ }
-//│ Mono:
-//│ TypingUnit {
-//│   fun main$$0 = () => if (true) then 1 else 0
-//│   fun main$$1 = () => if (>(+(1, 1,), 1,)) then -(1, 1,) else *(1, 1,)
-//│   Code(List(main$$0()))
-//│   Code(List(main$$1()))
-//│ }
-//│ fun main$$0: () -> (0 | 1)
-//│ fun main$$1: () -> Int
 //│ Int
+//│ 
+//│ Simpledef:
+//│ {if (true) then 1 else 0
+//│  if (>(+(1, 1,), 1,)) then -(1, 1,) else *(1, 1,)}
+//│ End simpledef
+//│ 
 //│ res
 //│     = 1
 //│ res
 //│     = 0
 
-:mono
 let b = true
 if(b) then 1 else 2
-//│ Lifted:
-//│ TypingUnit {
-//│   let b$1 = true
-//│   Code(List(if ('(' b$1 ')') then 1 else 2))
-//│ }
-//│ Mono:
-//│ TypingUnit {
-//│   let b$1 = true
-//│   fun main$$1 = () => if ('(' b$1 ')') then 1 else 2
-//│   Code(List(main$$1()))
-//│ }
-//│ let b$1: true
-//│ fun main$$1: () -> (1 | 2)
+//│ let b: true
 //│ 1 | 2
-//│ b$1
-//│     = true
+//│ 
+//│ Simpledef:
+//│ {let b = true
+//│  if ('(' b ')') then 1 else 2}
+//│ End simpledef
+//│ 
+//│ b
+//│   = true
 //│ res
 //│     = 1
diff --git a/compiler/shared/test/diff/Defunctionalize/SimpleFunc.mls b/compiler/shared/test/diff/Defunctionalize/SimpleFunc.mls
index dbf5455518..e39c192c46 100644
--- a/compiler/shared/test/diff/Defunctionalize/SimpleFunc.mls
+++ b/compiler/shared/test/diff/Defunctionalize/SimpleFunc.mls
@@ -1,58 +1,49 @@
 :NewDefs
 
-:mono
 fun f(x: Bool) = if x then 42 else 1337
-//│ Lifted:
-//│ TypingUnit {
-//│   fun f$1 = (x: Bool,) => if (x) then 42 else 1337
-//│ }
-//│ Mono:
-//│ TypingUnit {
-//│   fun f$1 = (x: Bool,) => if (x) then 42 else 1337
-//│ }
-//│ fun f$1: (x: Bool) -> (1337 | 42)
+//│ fun f: (x: Bool) -> (1337 | 42)
+//│ 
+//│ Simpledef:
+//│ {fun f = (x: Bool,) => if (x) then 42 else 1337}
+//│ End simpledef
+//│ 
 
-:mono
 fun foo() = 42
-//│ Lifted:
-//│ TypingUnit {fun foo$1 = () => 42}
-//│ Mono:
-//│ TypingUnit {fun foo$1 = () => 42}
-//│ fun foo$1: () -> 42
+//│ fun foo: () -> 42
+//│ 
+//│ Simpledef:
+//│ {fun foo = () => 42}
+//│ End simpledef
+//│ 
 
-:mono
 fun f(x) =
   if(x > 0) then x+1 else x - 1
 f(2)+3
-//│ Lifted:
-//│ TypingUnit {
-//│   fun f$1 = (x,) => {if ('(' >(x, 0,) ')') then +(x, 1,) else -(x, 1,)}
-//│   Code(List(+(f$1(2,), 3,)))
-//│ }
-//│ Mono:
-//│ TypingUnit {
-//│   fun f$1 = (x,) => {if ('(' >(x, 0,) ')') then +(x, 1,) else -(x, 1,)}
-//│   fun main$$1 = () => +(f$1(2,), 3,)
-//│   Code(List(main$$1()))
-//│ }
-//│ fun f$1: Int -> Int
-//│ fun main$$1: () -> Int
+//│ fun f: Int -> Int
 //│ Int
+//│ 
+//│ Simpledef:
+//│ {fun f = (x::0,) => {if ('(' >(x, 0,) ')') then +(x, 1,) else -(x, 1,)}
+//│  +(f(2,), 3,)}
+//│ End simpledef
+//│ 
 //│ res
 //│     = 6
 
-// TODO: Evaluate unused terms
-:mono 
 fun foo(x, #b) = if b then x else 1337
 let a = foo(42, true)
 let b = foo(23, false)
-//│ Lifted:
-//│ TypingUnit {
-//│   fun foo$3 = (x, #b$2,) => if (b$2) then x else 1337
-//│   let a$1 = foo$3(42, true,)
-//│   let b$2 = foo$3(23, false,)
-//│ }
-//│ Mono:
-//│ ╔══[ERROR] Post-process failed to produce AST.
-//│ ╙──
+//│ fun foo: forall 'a. ('a, Bool) -> (1337 | 'a)
+//│ let a: 1337 | 42
+//│ let b: 1337 | 23
+//│ 
+//│ Simpledef:
+//│ {fun foo = (x::1, #b::2,) => if (b) then x else 1337
+//│  let a = foo(42, true,)
+//│  let b = foo(23, false,)}
+//│ End simpledef
 //│ 
+//│ a
+//│   = 42
+//│ b
+//│   = 1337
diff --git a/compiler/shared/test/diff/Defunctionalize/Simpledef.mls b/compiler/shared/test/diff/Defunctionalize/Simpledef.mls
new file mode 100644
index 0000000000..5a9efa243b
--- /dev/null
+++ b/compiler/shared/test/diff/Defunctionalize/Simpledef.mls
@@ -0,0 +1,82 @@
+:NewDefs
+
+class X() {
+    val num = 6
+}
+class Y() {
+    val num = true
+}
+fun foo(pred) = if pred then X() else Y()
+foo(true).num
+//│ class X() {
+//│   val num: 6
+//│ }
+//│ class Y() {
+//│   val num: true
+//│ }
+//│ fun foo: Bool -> (X | Y)
+//│ 6 | true
+//│ 
+//│ Simpledef:
+//│ {class X() {let num = 6}
+//│  class Y() {let num = true}
+//│  fun foo = (pred::0,) => if (pred) then X() else Y()
+//│  let selRes$26 = foo(true,) in case selRes$26 of { Y => (selRes$26).num
+//│  X => (selRes$26).num }}
+//│ End simpledef
+//│ 
+//│ res
+//│     = 6
+
+class X() {
+    val num = 6
+}
+class Y() {
+    val num = true
+}
+class A() {
+    val num = X()
+}
+class B() {
+    val num = Y()
+}
+class C() {
+    val num = X()
+}
+fun foo(pred) =
+    if pred == 1 then A() else 
+        if pred == 2 then B() else C()
+foo(5).num.num
+//│ class X() {
+//│   val num: 6
+//│ }
+//│ class Y() {
+//│   val num: true
+//│ }
+//│ class A() {
+//│   val num: X
+//│ }
+//│ class B() {
+//│   val num: Y
+//│ }
+//│ class C() {
+//│   val num: X
+//│ }
+//│ fun foo: Num -> (A | B | C)
+//│ 6 | true
+//│ 
+//│ Simpledef:
+//│ {class X() {let num = 6}
+//│  class Y() {let num = true}
+//│  class A() {let num = X()}
+//│  class B() {let num = Y()}
+//│  class C() {let num = X()}
+//│  fun foo = (pred::1,) => {if (==(pred, 1,)) then A() else {if (==(pred, 2,)) then B() else C()}}
+//│  let selRes$74 = let selRes$76 = foo(5,) in case selRes$76 of { B => (selRes$76).num
+//│  C => (selRes$76).num
+//│  A => (selRes$76).num } in case selRes$74 of { X => (selRes$74).num
+//│  Y => (selRes$74).num }}
+//│ End simpledef
+//│ 
+//│ res
+//│     = 6
diff --git a/compiler/shared/test/diff/Defunctionalize/TupleSelect.mls b/compiler/shared/test/diff/Defunctionalize/TupleSelect.mls
new file mode 100644
index 0000000000..b5b3325465
--- /dev/null
+++ b/compiler/shared/test/diff/Defunctionalize/TupleSelect.mls
@@ -0,0 +1,12 @@
+:NewDefs
+
+
+[0,"abc",()].2
+//│ ()
+//│ 
+//│ Simpledef:
+//│ {([0, "abc", undefined,]).2}
+//│ End simpledef
+//│ 
+//│ res
+//│     = undefined
diff --git a/compiler/shared/test/diff/Lifter/FunctionTypeAnnotations.mls b/compiler/shared/test/diff/Lifter/FunctionTypeAnnotations.mls
index 6e84cfca3d..4eeb76d395 100644
--- a/compiler/shared/test/diff/Lifter/FunctionTypeAnnotations.mls
+++ b/compiler/shared/test/diff/Lifter/FunctionTypeAnnotations.mls
@@ -1,38 +1,18 @@
 :NewDefs 
+:ParseOnly
 
-:e // TODO: Preserve type annotations in lifting
-:mono
-fun foo(x: Int) =
+:lift
+fun foo(x) =
     (y) => x+y
 foo(1)(2)
 foo(2)(2)
+//│ |#fun| |foo|(|x|)| |#=|→|(|y|)| |#=>| |x|+|y|←|↵|foo|(|1|)|(|2|)|↵|foo|(|2|)|(|2|)|
+//│ Parsed: {fun foo = (x,) => {('(' y ')',) => +(x, y,)}; foo(1,)(2,); foo(2,)(2,)}
 //│ Lifted:
 //│ TypingUnit {
 //│   class Lambda1$2$1([x,]) {fun apply = ('(' y ')',) => +((this).x, y,)}
-//│   fun foo$1 = (x: Int,) => {{Lambda1$2$1(x,)}}
+//│   fun foo$1 = (x,) => {{Lambda1$2$1(x,)}}
 //│   Code(List(foo$1(1,)(2,)))
 //│   Code(List(foo$1(2,)(2,)))
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Lambda1$2$1([x,]) {}
-//│   fun apply$Lambda1$2$1 = (this, '(' y ')',) => +(let obj = this in if obj is ‹(Lambda1$2$1(x,)) then x; else error›, y,)
-//│   fun foo$1 = (x: Int,) => {{Lambda1$2$1(x,)}}
-//│   fun main$$3 = () => let obj = foo$1(2,) in if obj is ‹(Lambda1$2$1) then apply$Lambda1$2$1(obj, 2,); else error›
-//│   fun main$$2 = () => let obj = foo$1(1,) in if obj is ‹(Lambda1$2$1) then apply$Lambda1$2$1(obj, 2,); else error›
-//│   Code(List(main$$2()))
-//│   Code(List(main$$3()))
-//│ }
-//│ ╔══[ERROR] Class parameters currently need type annotations
-//│ ║  l.6: 	    (y) => x+y
-//│ ╙──     	           ^
-//│ class Lambda1$2$1(x: error)
-//│ fun apply$Lambda1$2$1: (Object, Int) -> Int
-//│ fun foo$1: (x: Int) -> Lambda1$2$1
-//│ fun main$$3: () -> Int
-//│ fun main$$2: () -> Int
-//│ Int
-//│ res
-//│     = 3
-//│ res
-//│     = 4
+//│ 
diff --git a/compiler/shared/test/diff/Lifter/LambLift.mls b/compiler/shared/test/diff/Lifter/LambLift.mls
index 31916a6f10..403013ae2f 100644
--- a/compiler/shared/test/diff/Lifter/LambLift.mls
+++ b/compiler/shared/test/diff/Lifter/LambLift.mls
@@ -1,6 +1,7 @@
 :NewDefs
-:AllowRuntimeErrors
+:ParseOnly
 
+:lift
 fun foo() =
   let local(x) =
     class Foo {
@@ -9,6 +10,8 @@ fun foo() =
     (new Foo()).bar
   local(1)
 foo()
+//│ |#fun| |foo|(||)| |#=|→|#let| |local|(|x|)| |#=|→|#class| |Foo| |{|→|#fun| |bar| |#=| |x| |+| |foo|(||)|←|↵|}|↵|(|#new| |Foo|(||)|)|.bar|←|↵|local|(|1|)|←|↵|foo|(||)|
+//│ Parsed: {fun foo = () => {let local = (x,) => {class Foo {fun bar = +(x, foo(),)}; ('(' (new Foo)() ')').bar}; local(1,)}; foo()}
 //│ Lifted:
 //│ TypingUnit {
 //│   class Foo$1([x,]) {fun bar = +((this).x, foo$1(),)}
@@ -16,31 +19,30 @@ foo()
 //│   fun foo$1 = () => {local$2(1,)}
 //│   Code(List(foo$1()))
 //│ }
-//│ fun foo: () -> Int
-//│ Int
-//│ res
-//│ Runtime error:
-//│   RangeError: Maximum call stack size exceeded
+//│ 
 
+:lift
 fun foo(f) = 
   f(1)
 foo(x => x+1)
+//│ |#fun| |foo|(|f|)| |#=| |→|f|(|1|)|←|↵|foo|(|x| |#=>| |x|+|1|)|
+//│ Parsed: {fun foo = (f,) => {f(1,)}; foo((x,) => +(x, 1,),)}
 //│ Lifted:
 //│ TypingUnit {
 //│   class Lambda1$2$1([]) {fun apply = (x,) => +(x, 1,)}
 //│   fun foo$1 = (f,) => {f(1,)}
 //│   Code(List(foo$1({Lambda1$2$1()},)))
 //│ }
-//│ fun foo: forall 'a. (1 -> 'a) -> 'a
-//│ Int
-//│ res
-//│     = 2
+//│ 
 
+:lift
 fun foo(x) = 
   let bar(f) = 
     f(x)
   bar(y => y+x)
 foo(1)
+//│ |#fun| |foo|(|x|)| |#=| |→|#let| |bar|(|f|)| |#=| |→|f|(|x|)|←|↵|bar|(|y| |#=>| |y|+|x|)|←|↵|foo|(|1|)|
+//│ Parsed: {fun foo = (x,) => {let bar = (f,) => {f(x,)}; bar((y,) => +(y, x,),)}; foo(1,)}
 //│ Lifted:
 //│ TypingUnit {
 //│   class Lambda1$3$1([x,]) {fun apply = (y,) => +(y, (this).x,)}
@@ -48,11 +50,9 @@ foo(1)
 //│   fun foo$1 = (x,) => {bar$2({Lambda1$3$1(x,)}, x,)}
 //│   Code(List(foo$1(1,)))
 //│ }
-//│ fun foo: Int -> Int
-//│ Int
-//│ res
-//│     = 2
+//│ 
 
+:lift
 fun foo(f) = 
     f(1)
 class A(y: Int){
@@ -61,6 +61,8 @@ class A(y: Int){
 fun app(a) = 
   foo(z => a.bar(z))
 app(new A(1))
+//│ |#fun| |foo|(|f|)| |#=| |→|f|(|1|)|←|↵|#class| |A|(|y|#:| |Int|)|{|→|#fun| |bar|(|z|)| |#=| |y|+|z|←|↵|}|↵|#fun| |app|(|a|)| |#=| |→|foo|(|z| |#=>| |a|.bar|(|z|)|)|←|↵|app|(|#new| |A|(|1|)|)|
+//│ Parsed: {fun foo = (f,) => {f(1,)}; class A(y: Int,) {fun bar = (z,) => +(y, z,)}; fun app = (a,) => {foo((z,) => (a).bar(z,),)}; app((new A)(1,),)}
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1([y: Int,]) {fun bar = (z,) => +((this).y, z,)}
@@ -69,11 +71,4 @@ app(new A(1))
 //│   fun app$1 = (a,) => {foo$2({Lambda1$3$2(a,)},)}
 //│   Code(List(app$1((new A$1)(1,),)))
 //│ }
-//│ fun foo: forall 'a. (1 -> 'a) -> 'a
-//│ class A(y: Int) {
-//│   fun bar: Int -> Int
-//│ }
-//│ fun app: forall 'b. {bar: 1 -> 'b} -> 'b
-//│ Int
-//│ res
-//│     = 2
+//│ 
diff --git a/compiler/shared/test/diff/Lifter/LiftNew.mls b/compiler/shared/test/diff/Lifter/LiftNew.mls
index 62188389ed..2058910ba7 100644
--- a/compiler/shared/test/diff/Lifter/LiftNew.mls
+++ b/compiler/shared/test/diff/Lifter/LiftNew.mls
@@ -4,10 +4,6 @@
 class A(num: Int) {
 }
 new A(5)
-//│ TypingUnit {
-//│   class A([num: Int,]) {}
-//│   Code(List((new A)(5,)))
-//│ }
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1([num: Int,]) {}
diff --git a/compiler/shared/test/diff/Lifter/LiftType.mls b/compiler/shared/test/diff/Lifter/LiftType.mls
index dab9423195..27312abaf8 100644
--- a/compiler/shared/test/diff/Lifter/LiftType.mls
+++ b/compiler/shared/test/diff/Lifter/LiftType.mls
@@ -1,6 +1,7 @@
 :NewDefs
 :ParseOnly
 
+:lift
 class CTX{
   class A {}
   fun foo(f: A => A): (A => A) => A = f(new A)
@@ -16,6 +17,7 @@ class CTX{
 //│ }
 //│ 
 
+:lift
 class CTX(x, y){
   class A{ fun foo = x}
   class B: A { fun foo = y}
@@ -33,6 +35,7 @@ class CTX(x, y){
 //│ }
 //│ 
 
+:lift
 class CTX(x, y){
   class A{ fun foo = x}
   class B: A { fun foo = y}
@@ -50,6 +53,7 @@ class CTX(x, y){
 //│ }
 //│ 
 
+:lift
 class CTX(x, y){
   class A{ fun foo = x}
   class B<T> { fun foo = y}
@@ -67,6 +71,7 @@ class CTX(x, y){
 //│ }
 //│ 
 
+:lift
 class CTX{
   fun ctx(x,y) = 
     class A{ fun foo = x }
diff --git a/compiler/shared/test/diff/Lifter/Lifter.mls b/compiler/shared/test/diff/Lifter/Lifter.mls
index 41030a1013..4ba2f65198 100644
--- a/compiler/shared/test/diff/Lifter/Lifter.mls
+++ b/compiler/shared/test/diff/Lifter/Lifter.mls
@@ -1,6 +1,7 @@
 :NewDefs
 :ParseOnly
 
+:lift
 class A(x) {
   class B(y) {
     fun getX = x
@@ -56,6 +57,7 @@ class A(x) {
 //│ }
 //│ 
 
+:lift
 class A(x) {
   class B(y) {
     class C(z) {
@@ -75,7 +77,7 @@ class A(x) {
 //│ }
 //│ 
 
-
+:lift
 class A(x) {
   class B{
     fun foo = 1
@@ -108,7 +110,7 @@ new C{
 //│ 
 
 
-
+:lift
 class Parent<T, U, V>(x) { 
   fun foo(x: Int): T = x+1
   class Inner<W>(y: Int){
@@ -128,7 +130,7 @@ class Parent<T, U, V>(x) {
 //│ }
 //│ 
 
-
+:lift
 class B<T> {}
 class C {}
 class D(y: Int) {}
@@ -149,6 +151,7 @@ class A<T, U>(x: Int): ({a1: Int} & B<T> & D(x)) {
 //│ 
 // │ TypingUnit(NuTypeDef(class, B, (TypeName(T)), Tup(), (), TypingUnit()), NuTypeDef(class, C, (), Tup(), (), TypingUnit()), NuTypeDef(class, A, (TypeName(T), TypeName(U)), Tup(x: Var(Int)), (App(App(Var(&), Tup(_: Bra(rcd = true, Rcd(Var(a1) = Var(Int)})))), Tup(_: TyApp(Var(B), List(TypeName(T)))))), TypingUnit(NuFunDef(None, getA, [], Lam(Tup(), New(Some((TypeName(C),)), TypingUnit(List(fun foo = x: T, => x))))))))
 
+:lift
 class B<T> {}
 class C {}
 class D(y: Int) {}
@@ -168,6 +171,7 @@ class A<T, U>(x: Int) extends {a1: Int}, B<T>, D(x){
 //│ }
 //│ 
 
+:lift
 class Child<T, U>(x): ({ age: T } & { name: String}) {
   class Inner{
     fun foo = age
@@ -187,7 +191,7 @@ class Child<T, U>(x): ({ age: T } & { name: String}) {
 //│ }
 //│ 
 
-
+:lift
 class A(x: Int) {
   fun getA: Int = 0
   fun getA1 = 1
@@ -206,7 +210,7 @@ new A(0) {
 //│ }
 //│ 
 
-
+:lift
 class A(x) {
   class B(y) {  }
 }
@@ -228,7 +232,7 @@ new A(1) {
 //│ 
 
 
-
+:lift
 class A {
   fun getA = 0
   fun funcA = 10
@@ -260,7 +264,7 @@ new B{
 //│ }
 //│ 
 
-
+:lift
 class A{
   class B{
     fun funB = 1
@@ -296,7 +300,7 @@ class A{
 //│ }
 //│ 
 
-
+:lift
 class A{
   class B{
     fun funB = 1
@@ -349,7 +353,7 @@ class A{
 //│ }
 //│ 
 
-
+:lift
 class A{
   class B{
     fun foo = 1
@@ -367,7 +371,7 @@ new A
 //│ }
 //│ 
 
-
+:lift
 class A(x) {
   fun foo = 0
   fun bar = x
@@ -389,6 +393,7 @@ let x = new A{
 //│ }
 //│ 
 
+:lift
 class A {}
 new A{
   fun foo = 1
diff --git a/compiler/shared/test/diff/Lifter/LifterBlks.mls b/compiler/shared/test/diff/Lifter/LifterBlks.mls
index 2b1736fcec..d6ee6a1f13 100644
--- a/compiler/shared/test/diff/Lifter/LifterBlks.mls
+++ b/compiler/shared/test/diff/Lifter/LifterBlks.mls
@@ -1,6 +1,7 @@
 :NewDefs
 :ParseOnly
 
+:lift
 fun foo =
   print("ok")
   print("ko")
@@ -10,6 +11,7 @@ fun foo =
 //│ TypingUnit {fun foo$1 = {print("ok",); print("ko",)}}
 //│ 
 
+:lift
 class A{
   class B {}
   fun foo(x: B) = (x : B)
@@ -23,6 +25,7 @@ class A{
 //│ }
 //│ 
 
+:lift
 fun foo =
   let local(x) =
     class Foo {
@@ -45,6 +48,7 @@ fun foo =
 //│ }
 //│ 
 
+:lift
 class A(y){}
 let f = x => new A(0){fun bar = x+y}
 f(0)
@@ -59,6 +63,7 @@ f(0)
 //│ }
 //│ 
 
+:lift
 class A(x){
   fun w = x
   fun foo(y) = 
@@ -82,6 +87,7 @@ class A(x){
 //│ }
 //│ 
 
+:lift
 fun f(x,y,z) = 
   class A{
     fun foo = new B
@@ -111,6 +117,7 @@ fun f(x,y,z) =
 //│ }
 //│ 
 
+:lift
 fun f(x,y,z) = 
   class C{
     class A{
@@ -142,33 +149,25 @@ fun f(x,y,z) =
 //│ }
 //│ 
 
+:lift
 fun f(y) =
   let g(x) = x + y + 1
   class Foo(x) {
     fun h = g(x)
   }
-//│ |#fun| |f|(|y|)| |#=|→|#let| |g|(|x|)| |#=| |x| |+| |y| |+| |1|↵|#class| |Foo|(|x|)| |{|→|#fun| |h| |#=| |g|(|x|)|←|↵|}|←|
-//│ Parsed: {fun f = (y,) => {let g = (x,) => +(+(x, y,), 1,); class Foo(x,) {fun h = g(x,)}}}
+  Foo(1).h 
+  Foo(x).h
+//│ |#fun| |f|(|y|)| |#=|→|#let| |g|(|x|)| |#=| |x| |+| |y| |+| |1|↵|#class| |Foo|(|x|)| |{|→|#fun| |h| |#=| |g|(|x|)|←|↵|}|↵|Foo|(|1|)|.h| |↵|Foo|(|x|)|.h|←|
+//│ Parsed: {fun f = (y,) => {let g = (x,) => +(+(x, y,), 1,); class Foo(x,) {fun h = g(x,)}; (Foo(1,)).h; (Foo(x,)).h}}
 //│ Lifted:
 //│ TypingUnit {
 //│   class Foo$1([x, y,]) {fun h = g$2((this).x, y,)}
 //│   let g$2 = (x, y,) => +(+(x, y,), 1,)
-//│   fun f$1 = (y,) => {}
+//│   fun f$1 = (y,) => {(Foo$1(1, y,)).h; (Foo$1(x, y,)).h}
 //│ }
-//│ 
-  Foo(1).h
-//│ | |Foo|(|1|)|.h|
-//│ Parsed: {(Foo(1,)).h}
-//│ Lifted:
-//│ TypingUnit {Code(List((Foo(1,)).h))}
-//│ 
-  Foo(x).h
-//│ | |Foo|(|x|)|.h|
-//│ Parsed: {(Foo(x,)).h}
-//│ Lifted:
-//│ TypingUnit {Code(List((Foo(x,)).h))}
 //│ 
 
+:lift
 fun f(x) =
   let g(x) = 
     let h(x) = x + 2
@@ -188,6 +187,7 @@ fun f(x) =
 //│ }
 //│ 
 
+:lift
 class Foo(x, y) extends Bar(y, x), Baz(x + y)
 //│ |#class| |Foo|(|x|,| |y|)| |#extends| |Bar|(|y|,| |x|)|,| |Baz|(|x| |+| |y|)|
 //│ Parsed: {class Foo(x, y,): Bar(y, x,), Baz(+(x, y,),) {}}
@@ -197,6 +197,7 @@ class Foo(x, y) extends Bar(y, x), Baz(x + y)
 //│ }
 //│ 
 
+:lift
 fun foo<T, U>(x: T): string = 
   class A(y) extends B<T>, C(y: U) {
     fun bar = this
@@ -211,6 +212,7 @@ fun foo<T, U>(x: T): string =
 //│ }
 //│ 
 
+:lift
 class A<T>{
   class B{
     fun f = x => y => x
@@ -230,6 +232,7 @@ class A<T>{
 //│ }
 //│ 
 
+:lift
 class Foo<T>{
   class RectangleBox: Box<T> & { breadth: T }
   class StackedRectangleBoxes<N> : RectangleBox<T> & { size: N }
@@ -246,6 +249,7 @@ class Foo<T>{
 //│ }
 //│ 
 
+:lift
 class Func<T, U> {
   fun apply: T => U
 }
@@ -267,6 +271,7 @@ fun ctx(a,b) =
 //│ }
 //│ 
 
+:lift
 fun f(T) = 
   new T()
 f(MyClass)
@@ -276,6 +281,7 @@ f(MyClass)
 //│ Lifting failed: mlscript.codegen.CodeGenError: Cannot find type T. Class values are not supported in lifter. 
 //│ 
 
+:lift
 class A {
   fun foo = 
     fun bar = foo()
diff --git a/compiler/shared/test/diff/Lifter/NestedClasses.mls b/compiler/shared/test/diff/Lifter/NestedClasses.mls
index 73eefcbb9d..ab0ca6dfe4 100644
--- a/compiler/shared/test/diff/Lifter/NestedClasses.mls
+++ b/compiler/shared/test/diff/Lifter/NestedClasses.mls
@@ -6,10 +6,6 @@ class X() {
     class Y() {}
 }
 X.Y()
-//│ TypingUnit {
-//│   class X([]) {class Y([]) {}}
-//│   Code(List((X).Y()))
-//│ }
 //│ Lifted:
 //│ TypingUnit {
 //│   class X$1_Y$2([par$X$1,]) {}
diff --git a/compiler/shared/test/diff/Lifter/NestedFuncs.mls b/compiler/shared/test/diff/Lifter/NestedFuncs.mls
index 09d7c9e55e..fc2b38b5b8 100644
--- a/compiler/shared/test/diff/Lifter/NestedFuncs.mls
+++ b/compiler/shared/test/diff/Lifter/NestedFuncs.mls
@@ -6,10 +6,6 @@ fun test(a) =
   let f(x) = a + x
   f
 test(6)(4)
-//│ TypingUnit {
-//│   fun test = (a,) => {let f = (x,) => +(a, x,); f}
-//│   Code(List(test(6,)(4,)))
-//│ }
 //│ Lifted:
 //│ TypingUnit {
 //│   let f$2 = (x, a,) => +(a, x,)
diff --git a/compiler/shared/test/diff/Lifter/ParameterizedInheritance.mls b/compiler/shared/test/diff/Lifter/ParameterizedInheritance.mls
index 2c68f1f148..da0a73949c 100644
--- a/compiler/shared/test/diff/Lifter/ParameterizedInheritance.mls
+++ b/compiler/shared/test/diff/Lifter/ParameterizedInheritance.mls
@@ -1,63 +1,41 @@
 :NewDefs
 
-:mono
-:e
+// FIXME: correctly lift parameterized inheritance
+:lift
 val c = 5
-class Sup(a: Int){
+class Sup(val a: Int){
   virtual fun foo = () -> a
 }
 class Sub(b: Int) extends Sup(b+b){
 }
 class Sub2(c: Int) extends Sub(c+c){
-  fun foo = () -> a+c
+  fun foo = () -> c+c
 }
 (Sub(10)).foo()
 (Sub2(c)).foo()
 //│ Lifted:
 //│ TypingUnit {
-//│   class Sup$1([a: Int,]) {fun foo = () => (this).a}
+//│   class Sup$1([val a: Int,]) {fun foo = () => (this).a}
 //│   class Sub$2([b: Int,]): Sup$1(+((this).b, (this).b,),) {}
-//│   class Sub2$3([c: Int,]): Sub$2(+(c$1, c$1,),) {fun foo = () => +((this).a, c$1,)}
+//│   class Sub2$3([c: Int,]): Sub$2(+(c$1, c$1,),) {fun foo = () => +(c$1, c$1,)}
 //│   let c$1 = 5
 //│   Code(List(('(' Sub$2(10,) ')').foo()))
 //│   Code(List(('(' Sub2$3(c$1,) ')').foo()))
 //│ }
-//│ Mono:
-//│ TypingUnit {
-//│   class Sub2$3([c: Int,]): Sub$2(+(c$1, c$1,),) {}
-//│   class Sup$1([a: Int,]) {}
-//│   class Sub$2([b: Int,]): Sup$1(+((this).b, (this).b,),) {}
-//│   let c$1 = 5
-//│   fun main$$5 = () => let obj = '(' Sub2$3(c$1,) ')' in if obj is ‹(Sub2$3) then foo$Sub2$3(obj,); else error›
-//│   fun main$$4 = () => let obj = '(' Sub$2(10,) ')' in if obj is ‹(Sub$2) then foo$Sup$1(obj,); else error›
-//│   fun foo$Sup$1 = (this,) => let obj = this in if obj is ‹(Sup$1) then 10; else error›
-//│   fun foo$Sub2$3 = (this,) => +(let obj = this in if obj is ‹(Sub2$3) then 5; else error›, c$1,)
-//│   Code(List(main$$4()))
-//│   Code(List(main$$5()))
-//│ }
 //│ ╔══[ERROR] identifier not found: this
 //│ ╙──
 //│ ╔══[ERROR] identifier not found: this
 //│ ╙──
-//│ class Sub2$3(c: Int) extends Sub$2, Sup$1
-//│ class Sup$1(a: Int)
-//│ class Sub$2(b: Int) extends Sup$1
-//│ let c$1: 5
-//│ fun main$$5: () -> Int
-//│ fun main$$4: () -> 10
-//│ fun foo$Sup$1: Object -> 10
-//│ fun foo$Sub2$3: Object -> Int
+//│ class Sup$1(a: Int) {
+//│   fun foo: () -> Int
+//│ }
+//│ class Sub$2(b: Int) extends Sup$1 {
+//│   fun foo: () -> Int
+//│ }
+//│ class Sub2$3(c: Int) extends Sub$2, Sup$1 {
+//│   fun foo: () -> Int
+//│ }
+//│ val c$1: 5
 //│ Int
 //│ Code generation encountered an error:
 //│   unguarded recursive use of by-value binding c$1
-
-// TODO: Handle recursive references in closure
-//:mono
-//:e 
-//class Foo(f: Int -> Int){
-//  fun foo = () -> f(1)
-//}
-//class F1() extends Foo(x => x+1){}
-//class F2() extends Foo(x => x+2){}
-//(new F1()).foo()
-//(new F2()).foo()
diff --git a/compiler/shared/test/diff/Lifter/TypedClassParams.mls b/compiler/shared/test/diff/Lifter/TypedClassParams.mls
index 7b32b6b49c..b8b006e101 100644
--- a/compiler/shared/test/diff/Lifter/TypedClassParams.mls
+++ b/compiler/shared/test/diff/Lifter/TypedClassParams.mls
@@ -3,7 +3,6 @@
 :lift
 class A() {}
 class B(foo: A) {}
-//│ TypingUnit {class A([]) {}; class B([foo: A,]) {}}
 //│ Lifted:
 //│ TypingUnit {class A$1([]) {}; class B$2([foo: A$1,]) {}}
 //│ class A$1()
diff --git a/compiler/shared/test/scala/mlscript/compiler/Test.scala b/compiler/shared/test/scala/mlscript/compiler/Test.scala
index 2738c2f011..2875eb95e9 100644
--- a/compiler/shared/test/scala/mlscript/compiler/Test.scala
+++ b/compiler/shared/test/scala/mlscript/compiler/Test.scala
@@ -5,52 +5,49 @@ import scala.util.control.NonFatal
 import scala.collection.mutable.StringBuilder
 import mlscript.{DiffTests, ModeType, TypingUnit}
 import mlscript.compiler.TreeDebug
-import mlscript.compiler.mono.Monomorph
-import mlscript.compiler.mono.MonomorphError
+import mlscript.Polyfill
+import simpledef.SimpleDef
 
 class DiffTestCompiler extends DiffTests {
   import DiffTestCompiler.*
   override def postProcess(mode: ModeType, basePath: List[Str], testName: Str, unit: TypingUnit, output: Str => Unit): (List[Str], Option[TypingUnit]) = 
     val outputBuilder = StringBuilder()
-    if (mode.lift) output(PrettyPrinter.showTypingUnit(unit))
 
-    output("Lifted:")
     var rstUnit = unit;
     try
       val lifter = ClassLifter(mode.fullExceptionStack)
-      if (!mode.nolift) rstUnit = lifter.liftTypingUnit(unit)
+      if (mode.lift) {
+        output("Lifted:")
+        rstUnit = lifter.liftTypingUnit(unit)
+        output(PrettyPrinter.showTypingUnit(rstUnit))
+      }
       if (mode.showParse) output(rstUnit.toString())
-      output(PrettyPrinter.showTypingUnit(rstUnit))
       if (mode.dbgLifting) 
         output(lifter.getLog)
     catch
       case NonFatal(err) =>
         output("Lifting failed: " ++ err.toString())
         if mode.fullExceptionStack then 
-          output("\n" ++ err.getStackTrace().map(_.toString()).mkString("\n"))
-    if(mode.mono){
-      output("Mono:")
-      val treeDebug = new TreeDebug(if mode.dbgDefunc then output else (str) => ())
-      try{
-        val monomorph = new Monomorph(treeDebug)
-        val defuncAST = monomorph.defunctionalize(rstUnit)
-        if (mode.showParse) output(defuncAST.toString())
-        output(PrettyPrinter.showTypingUnit(defuncAST))
-        return (outputBuilder.toString().linesIterator.toList, Some(defuncAST))
-      }catch{
-        case error: MonomorphError => 
-          if (mode.expectCodeGenErrors)
-            output(error.getMessage() ++ "\n" ++ (error.getStackTrace().take(10).map(_.toString()).toList).mkString("\n"))
-        return (Nil, None)
-        // case error: StackOverflowError => outputBuilder ++= (error.getMessage() :: error.getStackTrace().take(40).map(_.toString()).toList).mkString("\n")
-      }
-    }
+          outputBuilder ++= "\n" ++ err.getStackTrace().map(_.toString()).mkString("\n")
     if (mode.lift) {
       (outputBuilder.toString().linesIterator.toList, Some(rstUnit))  
     } else {
       (outputBuilder.toString().linesIterator.toList, None)
     }
   
+  override def postTypingProcess(mode: ModeType, basePath: List[Str], testName: Str, unit: TypingUnit, output: Str => Unit): Option[TypingUnit] = 
+    if(mode.simpledef || basePath.contains("Defunctionalize")) {
+      output("\nSimpledef:")
+      val treeDebug = new TreeDebug(if mode.dbgSimpledef then output else (str) => ())
+      val pd = SimpleDef(treeDebug)
+      pd(unit)
+      val defuncAST = pd.rewriteProgram(unit)
+      output(defuncAST.showDbg.replace(";", "\n"))
+      output("End simpledef\n")
+      return Some(defuncAST)
+    }
+    None
+    
   override protected lazy val files = allFiles.filter { file =>
       val fileName = file.baseName
       validExt(file.ext) && filter(file.relativeTo(pwd))
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index 709b7eeacb..4e765b5871 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -28,6 +28,7 @@ abstract class ModeType {
   def dbgUCS: Opt[Set[Str]]
   def dbgLifting: Bool
   def dbgDefunc: Bool
+  def dbgSimpledef: Bool
   def fullExceptionStack: Bool
   def stats: Bool
   def stdout: Bool
@@ -40,10 +41,10 @@ abstract class ModeType {
   def expectCodeGenErrors: Bool
   def showRepl: Bool
   def allowEscape: Bool
-  def mono: Bool
   def useIR: Bool
   def interpIR: Bool
   def irVerbose: Bool
+  def simpledef: Bool
   def lift: Bool
   def nolift: Bool
 }
@@ -57,6 +58,7 @@ class DiffTests
   
   /**  Hook for dependent projects, like the monomorphizer. */
   def postProcess(mode: ModeType, basePath: Ls[Str], testName: Str, unit: TypingUnit, output: Str => Unit): (Ls[Str], Option[TypingUnit]) = (Nil, None)
+  def postTypingProcess(mode: ModeType, basePath: Ls[Str], testName: Str, unit: TypingUnit, output: Str => Unit): Option[TypingUnit] = None
   
   
   @SuppressWarnings(Array("org.wartremover.warts.RedundantIsInstanceOf"))
@@ -161,6 +163,7 @@ class DiffTests
       dbgUCS: Opt[Set[Str]] = N,
       dbgLifting: Bool = false,
       dbgDefunc: Bool = false,
+      dbgSimpledef: Bool = false,
       fullExceptionStack: Bool = false,
       stats: Bool = false,
       stdout: Bool = false,
@@ -174,7 +177,7 @@ class DiffTests
       expectCodeGenErrors: Bool = false,
       showRepl: Bool = false,
       allowEscape: Bool = false,
-      mono: Bool = false,
+      simpledef: Bool = false,
       lift: Bool = false,
       nolift: Bool = false,
       // noProvs: Bool = false,
@@ -235,6 +238,7 @@ class DiffTests
           case "ds" => mode.copy(dbgSimplif = true)
           case "dl" => mode.copy(dbgLifting = true)
           case "dd" => mode.copy(dbgDefunc = true)
+          case "dsd" => mode.copy(dbgSimpledef = true)
           case "s" => mode.copy(fullExceptionStack = true)
           case "v" | "verbose" => mode.copy(verbose = true)
           case "ex" | "explain" => mode.copy(expectTypeErrors = true, explainErrors = true)
@@ -289,7 +293,7 @@ class DiffTests
           case "re" => mode.copy(expectRuntimeErrors = true)
           case "r" | "showRepl" => mode.copy(showRepl = true)
           case "escape" => mode.copy(allowEscape = true)
-          case "mono" => {mode.copy(mono = true)}
+          case "sd" => {mode.copy(simpledef = true)}
           case "lift" => {mode.copy(lift = true)}
           case "nolift" => {mode.copy(nolift = true)}
           case "exit" =>
@@ -463,14 +467,14 @@ class DiffTests
             
             if (mode.showParse)
               output(s"AST: $res")
-            
             val newMode = if (useIR) { mode.copy(useIR = true) } else mode
-            val (postLines, nuRes) = postProcess(newMode, basePath, testName, res, output)
-            postLines.foreach(output)  
+            val (postLines, nuRes) = 
+              postProcess(newMode, basePath, testName, res, output)
+            postLines.foreach(output)            
             
             if (parseOnly)
               Success(Pgrm(Nil), 0)
-            else if (mode.mono || mode.lift) {
+            else if (mode.lift) {
               import Message._
               Success(Pgrm(nuRes.getOrElse({
                 raise(ErrorReport(msg"Post-process failed to produce AST." -> None :: Nil, true, Diagnostic.Compilation))
@@ -902,6 +906,11 @@ class DiffTests
             val executionResults: Result \/ Ls[(ReplHost.Reply, Str)] = if (!allowTypeErrors &&
                 file.ext =:= "mls" && !mode.noGeneration && !noJavaScript) {
               import codeGenTestHelpers._
+              val pp = 
+                postTypingProcess(mode, basePath, testName, TypingUnit(p.tops), output) match {
+                  case Some(stmts) => Pgrm(stmts.entities)
+                  case _ => p
+                }
               backend(p, mode.allowEscape, newDefs && newParser, prettyPrintQQ) match {
                 case testCode @ TestCode(prelude, queries) => {
                   // Display the generated code.

From 13ba521ef821d5b2c0b1713a6e9280b13b3a3894 Mon Sep 17 00:00:00 2001
From: Mark Ng <55091936+CAG2Mark@users.noreply.github.com>
Date: Thu, 20 Jun 2024 11:56:24 +0800
Subject: [PATCH 139/147] Tail Recursion Optimization (#218)

---
 .../scala/mlscript/compiler/ir/Builder.scala  |  106 +-
 .../compiler/ir/DefnRefResolver.scala         |    2 +-
 .../main/scala/mlscript/compiler/ir/IR.scala  |   40 +-
 .../scala/mlscript/compiler/ir/Interp.scala   |   29 +-
 .../mlscript/compiler/ir/Validator.scala      |    2 +-
 .../compiler/optimizer/Analysis.scala         |   11 +-
 .../compiler/optimizer/TailRecOpt.scala       | 1085 +++++++
 compiler/shared/test/diff-ir/IR.mls           |  333 +-
 compiler/shared/test/diff-ir/IRComplex.mls    |  255 +-
 compiler/shared/test/diff-ir/IRRec.mls        |  989 +-----
 compiler/shared/test/diff-ir/IRTailRec.mls    | 2669 +++++++++++++++++
 compiler/shared/test/diff-ir/NuScratch.mls    |    3 +
 .../test/scala/mlscript/compiler/Test.scala   |    9 +-
 .../test/scala/mlscript/compiler/TestIR.scala |   43 +-
 .../src/main/scala/mlscript/NewParser.scala   |    5 +-
 shared/src/main/scala/mlscript/Typer.scala    |    6 +-
 shared/src/test/diff/nu/Annotations.mls       |   34 +
 .../src/test/scala/mlscript/DiffTests.scala   |   24 +-
 18 files changed, 4074 insertions(+), 1571 deletions(-)
 create mode 100644 compiler/shared/main/scala/mlscript/compiler/optimizer/TailRecOpt.scala
 create mode 100644 compiler/shared/test/diff-ir/IRTailRec.mls
 create mode 100644 compiler/shared/test/diff-ir/NuScratch.mls

diff --git a/compiler/shared/main/scala/mlscript/compiler/ir/Builder.scala b/compiler/shared/main/scala/mlscript/compiler/ir/Builder.scala
index 59227ca644..c80a698f6f 100644
--- a/compiler/shared/main/scala/mlscript/compiler/ir/Builder.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/ir/Builder.scala
@@ -4,11 +4,12 @@ import mlscript.compiler.optimizer.FreeVarAnalysis
 import mlscript.utils.shorthands._
 import mlscript.utils._
 import mlscript._
+import mlscript.Message._
 import collection.mutable.ListBuffer
 
 final val ops = Set("+", "-", "*", "/", ">", "<", ">=", "<=", "!=", "==")
 
-final class Builder(fresh: Fresh, fnUid: FreshInt, classUid: FreshInt, tag: FreshInt):
+final class Builder(fresh: Fresh, fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diagnostic => Unit):
   import Node._
   import Expr._
   
@@ -72,6 +73,33 @@ final class Builder(fresh: Fresh, fnUid: FreshInt, classUid: FreshInt, tag: Fres
     tm
 
   private def buildResultFromTerm(using ctx: Ctx)(tm: Term)(k: Node => Node): Node =
+    def buildLetCall(f: Term, xs: Tup, ann: Option[Term]) =
+      buildResultFromTerm(f) { node => node match
+        case Result(Ref(g) :: Nil) if ctx.fnCtx.contains(g.str) => buildResultFromTerm(xs) {
+          case Result(args) =>
+            val v = fresh.make
+            
+            ann match
+              case Some(ann @ Var(nme)) =>
+                if nme === "tailcall" then 
+                  LetCall(List(v), DefnRef(Right(g.str)), args, true, v |> ref |> sresult |> k)(f.toLoc).attachTag(tag)
+                else
+                  if nme === "tailrec" then
+                    raise(ErrorReport(List(msg"@tailrec is for annotating functions; try @tailcall instead" -> ann.toLoc), true, Diagnostic.Compilation))
+                  LetCall(List(v), DefnRef(Right(g.str)), args, false, v |> ref |> sresult |> k)(f.toLoc).attachTag(tag) 
+              case Some(_) => node |> unexpectedNode
+              case None => LetCall(List(v), DefnRef(Right(g.str)), args, false, v |> ref |> sresult |> k)(f.toLoc).attachTag(tag)   
+            
+          case node @ _ => node |> unexpectedNode
+        }
+        case Result(Ref(f) :: Nil) => buildResultFromTerm(xs) {
+          case Result(args) =>
+            throw IRError(s"not supported: apply")
+          case node @ _ => node |> unexpectedNode
+        }
+        case node @ _ => node |> unexpectedNode
+      }
+
     val res = tm match
       case lit: Lit => Literal(lit) |> sresult |> k
       case v @ Var(name) =>
@@ -114,21 +142,16 @@ final class Builder(fresh: Fresh, fnUid: FreshInt, classUid: FreshInt, tag: Fres
           case node @ _ => node |> unexpectedNode
         }
 
-      case App(f, xs @ Tup(_)) =>
-        buildResultFromTerm(f) {
-        case Result(Ref(f) :: Nil) if ctx.fnCtx.contains(f.str) => buildResultFromTerm(xs) {
-          case Result(args) =>
-            val v = fresh.make
-            LetCall(List(v), DefnRef(Right(f.str)), args, v |> ref |> sresult |> k).attachTag(tag)
-          case node @ _ => node |> unexpectedNode
-        }
-        case Result(Ref(f) :: Nil) => buildResultFromTerm(xs) {
-          case Result(args) =>
-            throw IRError(s"not supported: apply")
-          case node @ _ => node |> unexpectedNode
-        }
-        case node @ _ => node |> unexpectedNode
-      }
+      case App(f, xs @ Tup(_)) => buildLetCall(f, xs, None)
+      case Ann(ann, App(f, xs @ Tup(_))) => buildLetCall(f, xs, Some(ann))
+
+      case Ann(ann @ Var(name), recv) =>
+        if name === "tailcall" then
+          raise(ErrorReport(List(msg"@tailcall may only be used to annotate function calls" -> ann.toLoc), true, Diagnostic.Compilation))
+        else if name === "tailrec" then
+          raise(ErrorReport(List(msg"@tailrec may only be used to annotate functions" -> ann.toLoc), true, Diagnostic.Compilation))
+
+        buildResultFromTerm(recv)(k)
 
       case Let(false, Var(name), rhs, body) => 
         buildBinding(name, rhs, body)(k)
@@ -147,7 +170,9 @@ final class Builder(fresh: Fresh, fnUid: FreshInt, classUid: FreshInt, tag: Fres
               jp.str,
               params = res :: fvs.map(x => Name(x)),
               resultNum = 1,
-              jpbody
+              jpbody,
+              false,
+              None
             )
             ctx.jpAcc.addOne(jpdef)
             val tru2 = buildResultFromTerm(tru) {
@@ -180,6 +205,8 @@ final class Builder(fresh: Fresh, fnUid: FreshInt, classUid: FreshInt, tag: Fres
               params = res :: fvs.map(x => Name(x)),
               resultNum = 1,
               jpbody,
+              false,
+              None
             )
             ctx.jpAcc.addOne(jpdef)
             val cases: Ls[(ClassInfo, Node)] = lines map {
@@ -234,20 +261,31 @@ final class Builder(fresh: Fresh, fnUid: FreshInt, classUid: FreshInt, tag: Fres
     res
   
   private def buildDefFromNuFunDef(using ctx: Ctx)(nfd: Statement): Defn = nfd match
-    case NuFunDef(_, Var(name), None, Nil, L(Lam(Tup(fields), body))) =>
-      val strs = fields map {
-          case N -> Fld(FldFlags.empty, Var(x)) => x
-          case _ => throw IRError("unsupported field") 
-        }
-      val names = strs map (fresh.make(_))
-      given Ctx = ctx.copy(nameCtx = ctx.nameCtx ++ (strs zip names))
-      Defn(
-        fnUid.make,
-        name,
-        params = names,
-        resultNum = 1,
-        buildResultFromTerm(body) { x => x }
-      )
+    case nfd: NuFunDef => nfd match
+      case NuFunDef(_, Var(name), None, Nil, L(Lam(Tup(fields), body))) =>
+        val strs = fields map {
+            case N -> Fld(FldFlags.empty, Var(x)) => x
+            case _ => throw IRError("unsupported field") 
+          }
+        val names = strs map (fresh.make(_))
+        given Ctx = ctx.copy(nameCtx = ctx.nameCtx ++ (strs zip names))
+        val trAnn = nfd.annotations.find { 
+          case Var("tailrec") => true
+          case ann @ Var("tailcall") =>
+            raise(ErrorReport(List(msg"@tailcall is for annotating function calls; try @tailrec instead" -> ann.toLoc), true, Diagnostic.Compilation))
+            false
+          case _ => false }
+
+        Defn(
+          fnUid.make,
+          name,
+          params = names,
+          resultNum = 1,
+          buildResultFromTerm(body) { x => x },
+          trAnn.isDefined,
+          trAnn.flatMap(_.toLoc)
+        )
+      case _ => throw IRError("unsupported NuFunDef")
     case _ => throw IRError("unsupported NuFunDef")
   
   private def buildClassInfo(ntd: Statement): ClassInfo = ntd match
@@ -288,7 +326,11 @@ final class Builder(fresh: Fresh, fnUid: FreshInt, classUid: FreshInt, tag: Fres
 
       import scala.collection.mutable.{ HashSet => MutHSet }
 
-      val cls = grouped.getOrElse(0, Nil).map(buildClassInfo)
+      // TODO: properly add prelude classes such as "True" and "False" rather than this hacky method
+      val cls = ClassInfo(classUid.make, "True", List())
+        :: ClassInfo(classUid.make, "False", List()) 
+        :: grouped.getOrElse(0, Nil).map(buildClassInfo)
+
       cls.foldLeft(Set.empty)(checkDuplicateField(_, _))
 
       val clsinfo = cls.toSet
diff --git a/compiler/shared/main/scala/mlscript/compiler/ir/DefnRefResolver.scala b/compiler/shared/main/scala/mlscript/compiler/ir/DefnRefResolver.scala
index d49e1fb38a..96ee1d635d 100644
--- a/compiler/shared/main/scala/mlscript/compiler/ir/DefnRefResolver.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/ir/DefnRefResolver.scala
@@ -11,7 +11,7 @@ private final class DefnRefResolver(defs: Set[Defn], allowInlineJp: Bool):
     case Result(res) =>
     case Case(scrut, cases) => cases map { (_, body) => f(body) }
     case LetExpr(name, expr, body) => f(body)
-    case LetCall(resultNames, defnref, args, body) =>
+    case LetCall(resultNames, defnref, args, _, body) =>
       defs.find{_.getName == defnref.getName} match
         case Some(defn) => defnref.defn = Left(defn)
         case None => throw IRError(f"unknown function ${defnref.getName} in ${defs.map{_.getName}.mkString(",")}")
diff --git a/compiler/shared/main/scala/mlscript/compiler/ir/IR.scala b/compiler/shared/main/scala/mlscript/compiler/ir/IR.scala
index e699379d24..a84f48fd36 100644
--- a/compiler/shared/main/scala/mlscript/compiler/ir/IR.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/ir/IR.scala
@@ -6,6 +6,8 @@ import mlscript.utils.shorthands._
 import mlscript.compiler.ir._
 import mlscript.compiler.optimizer._
 
+import mlscript.Loc
+
 import collection.mutable.{Map as MutMap, Set as MutSet, HashMap, ListBuffer}
 import annotation.unused
 import util.Sorting
@@ -67,7 +69,9 @@ case class Defn(
   val name: Str,
   val params: Ls[Name],
   val resultNum: Int,
-  val body: Node
+  val body: Node,
+  val isTailRec: Bool,
+  val loc: Opt[Loc] = None
 ):
   override def hashCode: Int = id
   def getName: String = name
@@ -96,6 +100,7 @@ enum Expr:
   case CtorApp(name: ClassInfo, args: Ls[TrivialExpr])
   case Select(name: Name, cls: ClassInfo, field: Str)
   case BasicOp(name: Str, args: Ls[TrivialExpr])
+  case AssignField(assignee: Name, clsInfo: ClassInfo, fieldName: Str, value: TrivialExpr)
   
   override def toString: String = show
 
@@ -107,13 +112,20 @@ enum Expr:
     case Literal(IntLit(lit)) => s"$lit" |> raw
     case Literal(DecLit(lit)) => s"$lit" |> raw
     case Literal(StrLit(lit)) => s"$lit" |> raw
-    case Literal(UnitLit(lit)) => s"$lit" |> raw
+    case Literal(UnitLit(lit)) => (if lit then "undefined" else "null") |> raw
     case CtorApp(ClassInfo(_, name, _), args) =>
       raw(name) <#> raw("(") <#> raw(args |> show_args) <#> raw(")")
     case Select(s, _, fld) =>
       raw(s.toString) <#> raw(".") <#> raw(fld)
     case BasicOp(name: Str, args) =>
       raw(name) <#> raw("(") <#> raw(args |> show_args) <#> raw(")")
+    case AssignField(assignee, clsInfo, fieldName, value) => 
+      stack(
+        raw("assign")
+          <:> raw(assignee.toString + "." + fieldName)
+          <:> raw(":=")
+          <:> value.toDocument
+        )
 
   def mapName(f: Name => Name): Expr = this match
     case Ref(name) => Ref(f(name))
@@ -121,6 +133,7 @@ enum Expr:
     case CtorApp(cls, args) => CtorApp(cls, args.map(_.mapNameOfTrivialExpr(f)))
     case Select(x, cls, field) => Select(f(x), cls, field)
     case BasicOp(name, args) => BasicOp(name, args.map(_.mapNameOfTrivialExpr(f)))
+    case AssignField(assignee, clsInfo, fieldName, value) => AssignField(f(assignee), clsInfo, fieldName, value.mapNameOfTrivialExpr(f))
 
   def locMarker: LocMarker = this match
     case Ref(name) => LocMarker.MRef(name.str)
@@ -128,7 +141,7 @@ enum Expr:
     case CtorApp(name, args) => LocMarker.MCtorApp(name, args.map(_.toExpr.locMarker))
     case Select(name, cls, field) => LocMarker.MSelect(name.str, cls, field)
     case BasicOp(name, args) => LocMarker.MBasicOp(name, args.map(_.toExpr.locMarker))
-  
+    case AssignField(assignee, clsInfo, fieldName, value) => LocMarker.MAssignField(assignee.str, fieldName, value.toExpr.locMarker)
 
 enum Node:
   // Terminal forms:
@@ -137,7 +150,7 @@ enum Node:
   case Case(scrut: Name, cases: Ls[(ClassInfo, Node)])
   // Intermediate forms:
   case LetExpr(name: Name, expr: Expr, body: Node)
-  case LetCall(names: Ls[Name], defn: DefnRef, args: Ls[TrivialExpr], body: Node)
+  case LetCall(names: Ls[Name], defn: DefnRef, args: Ls[TrivialExpr], isTailRec: Bool, body: Node)(val loc: Opt[Loc] = None)
 
   var tag = DefnTag(-1)
 
@@ -160,7 +173,9 @@ enum Node:
     case Jump(defn, args) => Jump(defn, args.map(_.mapNameOfTrivialExpr(f)))
     case Case(scrut, cases) => Case(f(scrut), cases.map { (cls, arm) => (cls, arm.mapName(f)) })
     case LetExpr(name, expr, body) => LetExpr(f(name), expr.mapName(f), body.mapName(f))
-    case LetCall(names, defn, args, body) => LetCall(names.map(f), defn, args.map(_.mapNameOfTrivialExpr(f)), body.mapName(f))  
+    case x: LetCall => 
+      val LetCall(names, defn, args, isTailRec, body) = x
+      LetCall(names.map(f), defn, args.map(_.mapNameOfTrivialExpr(f)), isTailRec, body.mapName(f))(x.loc)
   
   def copy(ctx: Map[Str, Name]): Node = this match
     case Result(res) => Result(res.map(_.mapNameOfTrivialExpr(_.trySubst(ctx))))
@@ -169,9 +184,10 @@ enum Node:
     case LetExpr(name, expr, body) => 
       val name_copy = name.copy
       LetExpr(name_copy, expr.mapName(_.trySubst(ctx)), body.copy(ctx + (name_copy.str -> name_copy)))
-    case LetCall(names, defn, args, body) => 
+    case x: LetCall => 
+      val LetCall(names, defn, args, isTailRec, body) = x
       val names_copy = names.map(_.copy)
-      LetCall(names_copy, defn, args.map(_.mapNameOfTrivialExpr(_.trySubst(ctx))), body.copy(ctx ++ names_copy.map(x => x.str -> x)))
+      LetCall(names_copy, defn, args.map(_.mapNameOfTrivialExpr(_.trySubst(ctx))), isTailRec, body.copy(ctx ++ names_copy.map(x => x.str -> x)))(x.loc)
 
   private def toDocument: Document = this match
     case Result(res) => raw(res |> show_args) <:> raw(s"-- $tag")
@@ -203,28 +219,27 @@ enum Node:
           <:> raw("in")
           <:> raw(s"-- $tag"),
         body.toDocument)
-    case LetCall(xs, defn, args, body) => 
+    case LetCall(xs, defn, args, isTailRec, body) => 
       stack(
         raw("let*")
           <:> raw("(")
           <#> raw(xs.map(_.toString).mkString(","))
           <#> raw(")")
           <:> raw("=")
-          <:> raw(defn.getName)
+          <:> raw((if isTailRec then "@tailcall " else "") + defn.getName)
           <#> raw("(")
           <#> raw(args.map{ x => x.toString }.mkString(","))
           <#> raw(")")
           <:> raw("in") 
           <:> raw(s"-- $tag"),
         body.toDocument)
-
   def locMarker: LocMarker =
     val marker = this match
       case Result(res) => LocMarker.MResult(res.map(_.toExpr.locMarker))
       case Jump(defn, args) => LocMarker.MJump(defn.getName, args.map(_.toExpr.locMarker))
       case Case(scrut, cases) => LocMarker.MCase(scrut.str, cases.map(_._1))
       case LetExpr(name, expr, _) => LocMarker.MLetExpr(name.str, expr.locMarker)
-      case LetCall(names, defn, args, _) => LocMarker.MLetCall(names.map(_.str), defn.getName, args.map(_.toExpr.locMarker))
+      case LetCall(names, defn, args, _, _) => LocMarker.MLetCall(names.map(_.str), defn.getName, args.map(_.toExpr.locMarker))
     marker.tag = this.tag
     marker
 
@@ -252,6 +267,7 @@ enum LocMarker:
   case MCase(scrut: Str, cases: Ls[ClassInfo])
   case MLetExpr(name: Str, expr: LocMarker)
   case MLetCall(names: Ls[Str], defn: Str, args: Ls[LocMarker])
+  case MAssignField(assignee: Str, field: Str, value: LocMarker)
   var tag = DefnTag(-1)
 
   def toDocument: Document = this match
@@ -281,7 +297,7 @@ enum LocMarker:
     case MLit(IntLit(lit)) => s"$lit" |> raw
     case MLit(DecLit(lit)) => s"$lit" |> raw
     case MLit(StrLit(lit)) => s"$lit" |> raw
-    case MLit(UnitLit(lit)) => s"$lit" |> raw
+    case MLit(UnitLit(lit)) => (if lit then "undefined" else "null") |> raw
     case _ => raw("...")
 
   def show = s"$tag-" + toDocument.print
diff --git a/compiler/shared/main/scala/mlscript/compiler/ir/Interp.scala b/compiler/shared/main/scala/mlscript/compiler/ir/Interp.scala
index fb4bce250b..016ab09938 100644
--- a/compiler/shared/main/scala/mlscript/compiler/ir/Interp.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/ir/Interp.scala
@@ -39,9 +39,10 @@ class Interpreter(verbose: Bool):
   private enum Expr:
     case Ref(name: Name)
     case Literal(lit: Lit)
-    case CtorApp(name: ClassInfo, args: Ls[Expr])
+    case CtorApp(name: ClassInfo, var args: Ls[Expr])
     case Select(name: Name, cls: ClassInfo, field: Str)
     case BasicOp(name: Str, args: Ls[Expr])
+    case AssignField(assignee: Name, clsInfo: ClassInfo, fieldName: Str, value: Expr)
   
     def show: Str =
       document.print
@@ -60,6 +61,15 @@ class Interpreter(verbose: Bool):
         raw(s) <#> raw(".") <#> raw(fld)
       case BasicOp(name: Str, args) =>
         raw(name) <#> raw("(") <#> raw(args |> show_args) <#> raw(")")
+      case AssignField(Name(assignee), clsInfo, fieldName, value) =>
+        stack(
+          raw("assign") 
+            <:> raw(assignee)
+            <#> raw(".")
+            <#> raw(fieldName)
+            <:> raw("=")
+            <:> value.document,
+        )
 
   private enum Node:
     case Result(res: Ls[Expr])
@@ -147,13 +157,14 @@ class Interpreter(verbose: Bool):
     case IExpr.CtorApp(name, args) => CtorApp(name, args |> convertArgs)
     case IExpr.Select(name, cls, field) => Select(name, cls, field)
     case IExpr.BasicOp(name, args) => BasicOp(name, args |> convertArgs)
+    case IExpr.AssignField(assignee, clsInfo, fieldName, value) => AssignField(assignee, clsInfo, fieldName, value |> convert)
 
   private def convert(node: INode): Node = node match
     case INode.Result(xs) => Result(xs |> convertArgs)
     case INode.Jump(defnref, args) => Jump(DefnRef(Right(defnref.getName)), args |> convertArgs)
     case INode.Case(scrut, cases) => Case(scrut, cases.map{(cls, node) => (cls, node |> convert)})
     case INode.LetExpr(name, expr, body) => LetExpr(name, expr |> convert, body |> convert)
-    case INode.LetCall(xs, defnref, args, body) =>
+    case INode.LetCall(xs, defnref, args, _, body) =>
       LetCall(xs, DefnRef(Right(defnref.getName)), args |> convertArgs, body |> convert)
 
   private def convert(defn: IDefn): Defn =
@@ -210,6 +221,7 @@ class Interpreter(verbose: Bool):
 
   private def evalArgs(using ctx: Ctx, clsctx: ClassCtx)(exprs: Ls[Expr]): Either[Ls[Expr], Ls[Expr]] = 
     var changed = false
+
     val xs = exprs.map {
       arg => eval(arg) match
         case Left(expr) => changed = true; expr
@@ -230,7 +242,7 @@ class Interpreter(verbose: Bool):
     case CtorApp(name, args) =>
       evalArgs(args) match
         case Left(xs) => Left(CtorApp(name, xs)) 
-        case _ => Right(expr)
+        case Right(xs) => Right(CtorApp(name, xs)) // TODO: This makes recursion modulo cons work, but should be investigated further.
     case Select(name, cls, field) => 
       ctx.get(name.str).map {
         case CtorApp(cls2, xs) if cls == cls2 =>
@@ -246,6 +258,17 @@ class Interpreter(verbose: Bool):
           eval(using ctx, clsctx)(name, xs.head, xs.tail.head)
         case _ => throw IRInterpreterError("unexpected basic operation")
       x.toLeft(expr)
+    case AssignField(assignee, clsInfo, fieldName, expr) =>
+      val value = evalMayNotProgress(expr)
+      ctx.get(assignee.str) match
+        case Some(x: CtorApp) =>
+          val CtorApp(cls, args) = x
+          val idx = cls.fields.indexOf(fieldName)
+          val newArgs = args.updated(idx, value)
+          x.args = newArgs
+          Left(x)
+        case Some(_) => throw IRInterpreterError("tried to assign a field of a non-ctor")
+        case None => throw IRInterpreterError("could not find value " + assignee)
 
   private def expectDefn(r: DefnRef) = r.defn match
     case Left(value) => value
diff --git a/compiler/shared/main/scala/mlscript/compiler/ir/Validator.scala b/compiler/shared/main/scala/mlscript/compiler/ir/Validator.scala
index 8977a2ebd4..ce7f09c2c9 100644
--- a/compiler/shared/main/scala/mlscript/compiler/ir/Validator.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/ir/Validator.scala
@@ -11,7 +11,7 @@ private final class DefnRefInSet(defs: Set[Defn]):
     case Jump(defn, args) =>
     case Case(scrut, cases) => cases map { (_, body) => f(body) }
     case LetExpr(name, expr, body) => f(body)
-    case LetCall(res, defnref, args, body) =>
+    case LetCall(res, defnref, args, _, body) =>
       defnref.getDefn match {
         case Some(real_defn) => if (!defs.exists(_ eq real_defn)) throw IRError("ref is not in the set")
         case _ =>
diff --git a/compiler/shared/main/scala/mlscript/compiler/optimizer/Analysis.scala b/compiler/shared/main/scala/mlscript/compiler/optimizer/Analysis.scala
index e277196e98..f0b02d2777 100644
--- a/compiler/shared/main/scala/mlscript/compiler/optimizer/Analysis.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/optimizer/Analysis.scala
@@ -39,13 +39,16 @@ class UsefulnessAnalysis(verbose: Bool = false):
     case CtorApp(name, args) => args.foreach(f)
     case Select(name, cls, field) => addUse(name)
     case BasicOp(name, args) => args.foreach(f)
+    case AssignField(assignee, _, _, value) =>
+      addUse(assignee)
+      f(value)
   
   private def f(x: Node): Unit = x match
     case Result(res) => res.foreach(f)
     case Jump(defn, args) => args.foreach(f)
     case Case(scrut, cases) => addUse(scrut); cases.foreach { case (cls, body) => f(body) }
     case LetExpr(name, expr, body) => f(expr); addDef(name); f(body)
-    case LetCall(names, defn, args, body) => args.foreach(f); names.foreach(addDef); f(body)
+    case LetCall(names, defn, args, _, body) => args.foreach(f); names.foreach(addDef); f(body)
   
   def run(x: Defn) =
     x.params.foreach(addDef)
@@ -66,6 +69,10 @@ class FreeVarAnalysis(extended_scope: Bool = true, verbose: Bool = false):
     case CtorApp(name, args) => args.foldLeft(fv)((acc, arg) => f(using defined)(arg.toExpr, acc))
     case Select(name, cls, field) => if (defined.contains(name.str)) fv else fv + name.str
     case BasicOp(name, args) => args.foldLeft(fv)((acc, arg) => f(using defined)(arg.toExpr, acc))
+    case AssignField(assignee, _, _, value) => f(using defined)(
+      value.toExpr, 
+      if defined.contains(assignee.str) then fv + assignee.str else fv
+    ) 
   private def f(using defined: Set[Str])(node: Node, fv: Set[Str]): Set[Str] = node match
     case Result(res) => res.foldLeft(fv)((acc, arg) => f(using defined)(arg.toExpr, acc))
     case Jump(defnref, args) =>
@@ -85,7 +92,7 @@ class FreeVarAnalysis(extended_scope: Bool = true, verbose: Bool = false):
       val fv2 = f(using defined)(expr, fv)
       val defined2 = defined + name.str
       f(using defined2)(body, fv2)
-    case LetCall(resultNames, defnref, args, body) =>
+    case LetCall(resultNames, defnref, args, _, body) =>
       var fv2 = args.foldLeft(fv)((acc, arg) => f(using defined)(arg.toExpr, acc))
       val defined2 = resultNames.foldLeft(defined)((acc, name) => acc + name.str)
       if (extended_scope && !visited.contains(defnref.getName))
diff --git a/compiler/shared/main/scala/mlscript/compiler/optimizer/TailRecOpt.scala b/compiler/shared/main/scala/mlscript/compiler/optimizer/TailRecOpt.scala
new file mode 100644
index 0000000000..1405e45765
--- /dev/null
+++ b/compiler/shared/main/scala/mlscript/compiler/optimizer/TailRecOpt.scala
@@ -0,0 +1,1085 @@
+package mlscript
+package compiler.optimizer
+
+import scala.annotation.tailrec
+
+import utils.shorthands._
+import Message.MessageContext
+
+import compiler.ir._
+import compiler.ir.Node._
+
+/*
+
+DOCUMENTATION OF SEMANTICS OF @tailcall and @tailrec
+
+@tailcall: Used to annotate specific function calls. Calls annotated with @tailcall 
+must be tail calls or tail modulo-cons calls. These calls must be optimized to not
+consume additional stack space. If such an optimization is not possible, then the
+compiler will throw an error.
+
+If there are multiple possible candidates for tail modulo-cons calls in a single
+branch of an expression, then @tailcall can be uesd to indicate which one will be
+optimized. For instance in
+
+fun foo() =
+  A(foo(), bar())
+
+we can use @tailcall to annotate the call foo() or bar(). If a call other than the
+last call is annotated with @tailcall, then the remaining functions must be pure
+to ensure that reordering computations does not change the result.
+
+If bar() is impure but you still want to optimize the call foo(), then you can do
+
+fun foo() =
+  let b = bar()
+  let a = @tailcall foo()
+  A(a, b)
+
+because here, you are taking responsibility for the reordering of the computations.
+
+@tailrec: Used to annotate functions. When this annotation is used on a function, say
+@tailrec fun foo(), the compiler will ensure no sequence of direct recursive calls back 
+to foo() consume stack space, i.e. they are all tail calls. Note that a call to foo() 
+may consume an arbitrary amount of stack space as long as foo() is only consuming finite
+stack space. For example,
+
+@tailrec fun foo() = bar()
+fun bar() =
+  bar()
+  bar()
+
+is valid. However,
+
+@tailrec fun foo() = bar()
+fun bar() =
+  foo()
+  bar()
+
+is invalid. If we swap the position of foo() and bar() in the body of bar, it is still invalid.
+
+Equivalently, if fun foo() is annotated with @tailrec, let S be the largest strongly
+connected component in the call-graph of the program that contains foo. Then an error
+will be thrown unless all edges (calls) connecting the nodes of the strongly
+connected component are tail calls or tail modulo-cons calls.
+
+*/
+
+// fnUid should be the same FreshInt that was used to build the graph being passed into this class
+class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diagnostic => Unit):
+  case class LetCtorNodeInfo(node: LetExpr, ctor: Expr.CtorApp, cls: ClassInfo, ctorValName: Name, fieldName: String, idx: Int)
+
+  enum CallInfo:
+    case NormalCallInfo(src: Defn, defn: Defn)(val loc: Option[Loc]) extends CallInfo
+    case TailCallInfo(src: Defn, defn: Defn) extends CallInfo
+    case ModConsCallInfo(src: Defn, startNode: Node, defn: Defn, letCallNode: LetCall, letCtorNode: LetCtorNodeInfo, retName: Name, retNode: Node) extends CallInfo
+
+    override def toString(): String = this match
+      case NormalCallInfo(src, defn) =>
+        f"Call { ${src.name}$$${src.id} -> ${defn.name}$$${defn.id} }"
+      case TailCallInfo(src, defn) => 
+        f"TailCall { ${src.name}$$${src.id} -> ${defn.name}$$${defn.id} }"
+      case ModConsCallInfo(src, startNode, defn, letCallNode, letCtorNode, _, _) =>
+        f"ModConsCall { ${src.name}$$${src.id} -> ${defn.name}$$${defn.id}, class: ${letCtorNode.cls.ident}, field: ${letCtorNode.fieldName} }"
+
+    def getSrc = this match
+      case NormalCallInfo(src, _) => src 
+      case TailCallInfo(src, _) => src
+      case ModConsCallInfo(src, _, _, _, _, _, _) => src 
+
+    def getDefn = this match
+      case NormalCallInfo(_, defn) => defn
+      case TailCallInfo(_, defn) => defn
+      case ModConsCallInfo(_, _, defn, _, _, _, _) => defn
+    
+  private class DefnGraph(val nodes: Set[DefnNode], val edges: Set[CallInfo], val joinPoints: Set[Defn]):
+    def removeMetadata: ScComponent = ScComponent(nodes.map(_.defn), edges, joinPoints)
+  
+  private class ScComponent(val nodes: Set[Defn], val edges: Set[CallInfo], val joinPoints: Set[Defn])
+
+  import CallInfo._
+
+  def filterOptCalls(calls: Iterable[CallInfo]) =
+    calls.collect { case c: TailCallInfo => c; case c: ModConsCallInfo => c }
+
+  def filterNormalCalls(calls: Iterable[CallInfo]) =
+    calls.collect { case c: NormalCallInfo => c }
+
+  // Hack to make scala think discoverJoinPoints is tail recursive and be
+  // partially optimized :P
+  def casesToJps(cases: List[(ClassInfo, Node)], acc: Set[Defn]): Set[Defn] =
+    cases.foldLeft(acc)((jps, branch) => discoverJoinPoints(branch._2, jps))
+  
+  def discoverJoinPointsCont(defn: Defn, acc: Set[Defn]) =
+    discoverJoinPoints(defn.body, acc) + defn
+
+  // TODO: implement proper purity checking. This is a very simple purity check that only allows the last
+  // parameter of a mod cons call to be optimised.
+  private val pureCache: scala.collection.mutable.Map[Int, Bool] = scala.collection.mutable.Map[Int, Bool]()
+  private def isPure(node: Node): Bool = 
+    pureCache.get(node.tag.inner) match
+      case None => 
+        val ret = node match
+          case Jump(defn, args) => isIdentityJp(defn.expectDefn)
+          case _: LetCall => false
+          case Case(scrut, cases) => cases.foldLeft(true)((value, branch) => value && isPure(branch._2))
+          case LetExpr(name, expr: Expr.AssignField, body) => false
+          case x: LetExpr => true
+          case Result(res) => true
+        pureCache.put(node.tag.inner, ret)
+        ret
+    
+      case Some(value) => value
+
+    
+
+
+  // do a DFS to discover join points
+  @tailrec
+  private def discoverJoinPoints(node: Node, acc: Set[Defn]): Set[Defn] =
+    node match
+      case Result(res) => Set()
+      case Jump(defn_, args) => 
+        val defn = defn_.expectDefn
+        if isIdentityJp(defn) then acc
+        else if acc.contains(defn) then acc
+        else discoverJoinPointsCont(defn, acc + defn)
+      case Case(scrut, cases) => casesToJps(cases, acc)
+      case LetExpr(name, expr, body) => discoverJoinPoints(body, acc)
+      case LetCall(names, defn, args, isTailRec, body) => discoverJoinPoints(body, acc)
+
+  private def getRetName(names: Set[Name], retVals: List[TrivialExpr]): Option[Name] =
+    val names = retVals.collect { case Expr.Ref(nme) => nme }
+    if names.length != 1 then None
+    else
+      val nme = names.head
+      if names.contains(nme) then Some(nme)
+      else None
+
+  // would prefer to have this inside discoverOptCalls, but scala does not support partially tail recursive functions directly
+  def shadowAndCont(next: Node, nme: Name)(implicit
+    acc: Set[CallInfo],
+    src: Defn,
+    scc: Set[Defn],
+    start: Node,
+    calledDefn: Option[Defn],
+    letCallNode: Option[LetCall],
+    letCtorNode: Option[LetCtorNodeInfo],
+    containingCtors: Set[Name]
+  ) = searchOptCalls(next)(acc, src, scc, start, calledDefn, letCallNode, letCtorNode, containingCtors - nme) 
+
+  // same here...
+  def invalidateAndCont(body: Node)(implicit
+    acc: Set[CallInfo],
+    src: Defn,
+    scc: Set[Defn],
+    start: Node,
+    calledDefn: Option[Defn],
+    letCallNode: Option[LetCall],
+    letCtorNode: Option[LetCtorNodeInfo],
+    containingCtors: Set[Name]
+  ) =
+    letCallNode match
+      case None => searchOptCalls(body)(acc, src, scc, start, None, None, None, Set()) // invalidate everything that's been discovered
+      case Some(x: LetCall) =>
+        val LetCall(_, defn, _, isTailRec, _) = x
+        if isTailRec then 
+          raise(ErrorReport(List(msg"not a tail call" -> x.loc), true, Diagnostic.Compilation))
+
+        val newAcc = acc + NormalCallInfo(src, defn.expectDefn)(x.loc)
+        searchOptCalls(body)(newAcc, src, scc, start, None, None, None, Set()) // invalidate everything that's been discovered
+  
+  @tailrec
+  private def searchOptCalls(node: Node)(implicit
+    acc: Set[CallInfo],
+    src: Defn,
+    scc: Set[Defn],
+    start: Node,
+    calledDefn: Option[Defn], // The definition that was called in a tailrec mod cons call
+    letCallNode: Option[LetCall], // The place where that definition was called
+    letCtorNode: Option[LetCtorNodeInfo], // The place where the result from that call was put into a constructor
+    containingCtors: Set[Name], // Value names of ctors containing the constructor containing the result from the call
+  ): Either[Set[CallInfo], List[Node]] = 
+
+    def updateMapSimple(c: CallInfo) = acc + c
+
+    def returnNoneCont = calledDefn match
+      case None => Left(acc)
+      case Some(dest) => 
+        Left(updateMapSimple(NormalCallInfo(src, dest)(letCallNode.flatMap(_.loc)))) // treat the discovered call as a normal call
+
+    def returnNone = letCallNode match
+      case Some(x: LetCall) =>
+        val LetCall(_, _, _, isTailRec, _) = x
+        if isTailRec then
+          raise(ErrorReport(List(msg"not a tail call" -> x.loc), true, Diagnostic.Compilation))
+        returnNoneCont
+      case _ => returnNoneCont
+
+    node match // Left if mod cons call found, Right if none was found -- we return the next nodes to be scanned 
+      case Result(res) =>
+        (calledDefn, letCallNode, letCtorNode) match
+          case (Some(defn), Some(letCallNode), Some(letCtorName)) =>
+            getRetName(containingCtors, res) match
+              case None => returnNone
+              case Some(value) => Left(updateMapSimple(ModConsCallInfo(src, start, defn, letCallNode, letCtorName, value, node)))
+          case _ => returnNone
+      case Jump(jp, args) => 
+        // different cases
+        (calledDefn, letCallNode, letCtorNode) match
+          case (Some(defn), Some(letCallNode), Some(letCtorName)) =>
+            getRetName(containingCtors, args) match
+              case Some(value) if isIdentityJp(jp.expectDefn) => 
+                Left(updateMapSimple(ModConsCallInfo(src, start, defn, letCallNode, letCtorName, value, node)))
+              case _ => returnNone
+          case _ => returnNone
+        
+      case Case(scrut, cases) => Right(cases.map(_._2))
+      case x @ LetExpr(name, expr, body) =>
+        expr match
+          // Check if this let binding references the mod cons call.
+          case Expr.Ref(name) => 
+            letCallNode match
+              case None => 
+                shadowAndCont(body, name) // OK
+              case Some(LetCall(names, _, _, isTailRec, _)) =>
+                // for it to be mod cons, other values cannot use the return value from the call.
+                if names.contains(name) then
+                  // if the is marked as tail recursive, we must use that call as the mod cons call, so error. otherwise,
+                  // invalidate the discovered call and continue
+                  invalidateAndCont(body)
+                else
+                  shadowAndCont(body, name) // OK
+          
+          case Expr.Literal(lit) => shadowAndCont(body, name) // OK
+          case y @ Expr.CtorApp(clsInfo, ctorArgs) =>
+            // if expr is a constructor with a call to some function as a parameter
+            letCallNode match
+              case None => shadowAndCont(body, name) // OK
+              case Some(LetCall(letCallNames, _, _, isTailRec, _)) => // there was a previous call
+                // 1. Check if the ctor application contains this call
+                val argNames = ctorArgs.collect { case Expr.Ref(name) => name }.toSet
+                val namesSet = letCallNames.toSet
+                val inters = argNames.intersect(namesSet)
+
+                if inters.isEmpty then
+                  // OK, this constructor does not use the mod cons call
+                  // Now check if the constructor uses any previous ctor containing the call.
+                  // If it does, then add this name to the list of constructors containing the call
+                  val inters = containingCtors.intersect(argNames)
+                  
+                  if inters.isEmpty then
+                    shadowAndCont(body, name) // does not use, OK to ignore this one
+                  else 
+                    // add this name to the list of constructors containing the call
+                    searchOptCalls(body)(acc, src, scc, start, calledDefn, letCallNode, letCtorNode, containingCtors + name) 
+                else
+                  // it does use it, further analyse
+                  letCtorNode match
+                    case None => 
+                      // First constructor discovered using this call as a parameter.
+                      // This is OK. Add this discovered information
+                      
+                      // TODO: for now, assume functions return only one value. handling multiple
+                      // values is a bit more complicated
+                      val ctorArgName = inters.head
+                      val ctorArgIndex = ctorArgs.indexWhere { 
+                        case Expr.Ref(nme) => nme == ctorArgName
+                        case _ => false 
+                      }
+
+                      val fieldName = clsInfo.fields(ctorArgIndex)
+                      
+                      // populate required values
+                      searchOptCalls(body)(acc, src, scc, start, calledDefn, letCallNode, Some(LetCtorNodeInfo(x, y, clsInfo, name, fieldName, ctorArgIndex)), Set(name))
+                    case Some(_) =>
+                      // another constructor is already using the call. Not OK
+
+                      // if the is marked as tail recursive, we must use that call as the mod cons call, so error. otherwise,
+                      // invalidate the discovered call and continue
+                      invalidateAndCont(body)
+
+          case Expr.Select(name, cls, field) =>
+            letCallNode match
+              case None => shadowAndCont(body, name) // OK
+              case Some(LetCall(names, _, _, isTailRec, _)) =>
+                // for it to be mod cons, other values cannot use the return value from the call.
+                if names.contains(name) then
+                  // if the is marked as tail recursive, we must use that call as the mod cons call, so error. otherwise,
+                  // invalidate the discovered call and continue
+                  invalidateAndCont(body)
+                else
+                  shadowAndCont(body, name) // OK
+          case Expr.BasicOp(_, args) =>
+            letCallNode match
+              case None => shadowAndCont(body, name) // OK
+              case Some(LetCall(names, _, _, isTailRec, _)) =>
+                // for it to be mod cons, other values cannot use the return value from the call.
+                val argNames = args.collect { case Expr.Ref(name) => name }.toSet
+                val namesSet = names.toSet
+                val inters = argNames.intersect(namesSet)
+
+                if inters.isEmpty then
+                  shadowAndCont(body, name) // OK
+                else
+                  // if the is marked as tail recursive, we must use that call as the mod cons call, so error. otherwise,
+                  // invalidate the discovered call and continue
+                  invalidateAndCont(body)
+          case Expr.AssignField(assignee, clsInfo, assignmentFieldName, value) =>
+            // make sure `value` is not the mod cons call
+            letCallNode match
+              case None => searchOptCalls(body) // OK
+              case Some(LetCall(names, defn, args, isTailRec, _)) =>
+                value match
+                  case Expr.Ref(name) =>
+                    invalidateAndCont(body)
+                  case _ =>
+                    letCtorNode match
+                      case None => searchOptCalls(body) // OK
+                      case Some(LetCtorNodeInfo(_, ctor, _, name, fieldName, _)) =>
+                        // If this assignment overwrites the mod cons value, forget it
+                        if containingCtors.contains(assignee) then invalidateAndCont(body)
+                        else searchOptCalls(body)
+      case x @ LetCall(names, defn, args, isTailRec, body) =>
+        val callInScc = scc.contains(defn.expectDefn)
+        
+        // Only deal with calls in the scc
+        if callInScc && isTailCall(x) then
+          // If there is an old call marked as @tailcall, it cannot be a tail call, error
+
+          val updatedMap = letCallNode match
+            case Some(y) =>
+              // If both these calls are marked @tailrec, error
+              if y.isTailRec && x.isTailRec then
+                raise(ErrorReport(
+                  List(
+                    msg"multiple calls in the same branch marked with @tailcall" -> None,
+                    msg"first call" -> y.loc,
+                    msg"second call" -> x.loc,
+                  ),
+                  true,
+                  Diagnostic.Compilation
+                  )
+                )
+              if y.isTailRec then
+                raise(ErrorReport(List(msg"not a tail call" -> y.loc), true, Diagnostic.Compilation)) 
+
+              updateMapSimple(NormalCallInfo(src, y.defn.expectDefn)(y.loc))
+
+            case None => acc
+            
+          Left(updatedMap + TailCallInfo(src, defn.expectDefn))
+        else
+          val restIsPure = isPure(body)
+          letCallNode match
+            case None => // OK, we may use this LetCall as the mod cons
+              // For now, only optimize functions which return one value
+              if callInScc && defn.expectDefn.resultNum == 1 && restIsPure then
+                searchOptCalls(body)(acc, src, scc, start, Some(defn.expectDefn), Some(x), None, Set())
+              else
+                if isTailRec then
+                  if !restIsPure then
+                    raise(ErrorReport(List(msg"not a tail call, as the remaining functions may be impure" -> x.loc), true, Diagnostic.Compilation))
+                  else
+                    raise(ErrorReport(List(msg"not a tail call" -> x.loc), true, Diagnostic.Compilation)) 
+                  
+                // Treat this as a normal call
+                val newMap = updateMapSimple(NormalCallInfo(src, defn.expectDefn)(x.loc))
+                searchOptCalls(body)(newMap, src, scc, start, calledDefn, letCallNode, letCtorNode, containingCtors)
+            case Some(y: LetCall) =>
+              val LetCall(namesOld, defnOld, argsOld, isTailRecOld, bodyOld) = y
+              if isTailRecOld then
+                // 1. If both the old and newly discovered call are marked with tailrec, error
+                if isTailRec then 
+                  raise(ErrorReport(
+                    List(
+                      msg"multiple calls in the same branch marked with @tailcall" -> None,
+                      msg"first call" -> y.loc,
+                      msg"second call" -> x.loc,
+                    ),
+                    true,
+                    Diagnostic.Compilation
+                    )
+                  )
+                // 2. old call is marked as tailrec so we must continue using it as the mod cons call.
+                // make sure the newly discovered call does not use the current call as a parameter
+                val argNames = args.collect { case Expr.Ref(name) => name }.toSet
+                val namesSet = namesOld.toSet
+                val inters = argNames.intersect(namesSet)
+
+                if !inters.isEmpty then
+                  raise(ErrorReport(List(msg"not a tail call" -> y.loc), true, Diagnostic.Compilation)) 
+                // Treat new call as a normal call
+                val newMap = updateMapSimple(NormalCallInfo(src, defn.expectDefn)(x.loc))
+                searchOptCalls(body)(newMap, src, scc, start, calledDefn, letCallNode, letCtorNode, containingCtors) // OK
+              else
+                // only include mod cons calls that have one return value
+                if callInScc && defn.expectDefn.resultNum == 1 && restIsPure then 
+                  // old call is not tailrec, so we can override it however we want
+                  // we take a lucky guess and mark this as the mod cons call, but the
+                  // user really should mark which calls should be tailrec
+                    
+                  // Treat the old call as a normal call
+                  val newMap = updateMapSimple(NormalCallInfo(src, defnOld.expectDefn)(y.loc))
+                  searchOptCalls(body)(newMap, src, scc, start, Some(defn.expectDefn), Some(x), None, Set())
+                else
+                  if isTailRec then
+                    if !restIsPure then
+                      raise(ErrorReport(List(msg"not a tail call, as the remaining functions may be impure" -> x.loc), true, Diagnostic.Compilation))
+                    else
+                      raise(ErrorReport(List(msg"not a tail call" -> x.loc), true, Diagnostic.Compilation)) 
+                  // shadow all the variables in this letcall
+                  
+                  // Treat this as a normal call
+                  val newMap = updateMapSimple(NormalCallInfo(src, defn.expectDefn)(x.loc))
+                  searchOptCalls(body)(acc, src, scc, start, calledDefn, letCallNode, letCtorNode, containingCtors -- names)
+
+  // checks whether a list of names is equal to a list of trivial expressions referencing those names
+  private def argsListEqual(names: List[Name], exprs: List[TrivialExpr]) =
+    if names.length == exprs.length then
+      val results = exprs.collect { case Expr.Ref(name) => name }
+      names == results
+    else
+      false
+
+  private def isIdentityJp(d: Defn): Bool = d.body match
+    case Result(res) => argsListEqual(d.params, res)
+    case Jump(defn, args) => argsListEqual(d.params, args) && isIdentityJp(defn.expectDefn)
+    case _ => false
+
+  private def isTailCall(node: Node): Boolean = node match
+    case LetCall(names, defn, args, _, body) =>
+      body match
+        case Result(res)      => argsListEqual(names, res)
+        case Jump(defn, args) => argsListEqual(names, args) && isIdentityJp(defn.expectDefn)
+        case _                => false
+    case _ => false
+
+  private def discoverOptCallsNode(node: Node)(implicit src: Defn, scc: Set[Defn], acc: Set[CallInfo]): Set[CallInfo] = 
+    searchOptCalls(node)(acc, src, scc, node, None, None, None, Set()) match
+      case Left(acc) => acc
+      case Right(nodes) => nodes.foldLeft(acc)((acc, node) => discoverOptCallsNode(node)(src, scc, acc))
+
+  private def discoverOptCalls(defn: Defn, jps: Set[Defn])(implicit scc: Set[Defn], acc: Set[CallInfo]): Set[CallInfo] =
+    val combined = jps + defn
+    combined.foldLeft(acc)((acc, defn_) => discoverOptCallsNode(defn_.body)(defn, scc, acc))
+
+  private def searchCalls(node: Node)(implicit src: Defn, acc: Map[Int, Set[Defn]]): Map[Int, Set[Defn]] =
+    node match
+      case Result(res) => acc
+      case Jump(defn, args) => acc
+      case Case(scrut, cases) => cases.foldLeft(acc)((acc, item) => searchCalls(item._2)(src, acc))
+      case LetExpr(name, expr, body) => searchCalls(body)
+      case LetCall(names, defn, args, isTailRec, body) => 
+        val newSet = acc.get(src.id) match
+          case None => Set(defn.expectDefn)
+          case Some(defns) => defns + defn.expectDefn
+        searchCalls(body)(src, acc + (src.id -> newSet))
+    
+
+  private def discoverCalls(defn: Defn, jps: Set[Defn])(implicit acc: Map[Int, Set[Defn]]): Map[Int, Set[Defn]] =
+    val combined = jps + defn
+    combined.foldLeft(acc)((acc, defn_) => searchCalls(defn_.body)(defn, acc))
+  
+  // Partions a tail recursive call graph into strongly connected components
+  // Refernece: https://en.wikipedia.org/wiki/Strongly_connected_component
+
+  // Implements Tarjan's algorithm.
+  // Wikipedia: https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
+  // Implementation Reference: https://www.baeldung.com/cs/scc-tarjans-algorithm
+
+  private class DefnNode(val defn: Defn):
+    override def hashCode(): Int = defn.hashCode
+
+    var num: Int = Int.MaxValue
+    var lowest: Int = Int.MaxValue
+    var visited: Boolean = false
+    var processed: Boolean = false
+
+  private def partitionNodes(implicit nodeMap: Map[Int, DefnNode]): List[DefnGraph] =
+    val defns = nodeMap.values.toSet
+    val inital = Map[Int, Set[Defn]]()
+    val joinPoints = defns.map(d => (d.defn.id -> discoverJoinPoints(d.defn.body, Set()))).toMap
+    val allJoinPoints = joinPoints.values.flatMap(x => x).toSet
+    val edges = defns.foldLeft(inital)((acc, defn) => discoverCalls(defn.defn, joinPoints(defn.defn.id))(acc)).withDefaultValue(Set())
+
+    var ctr = 0
+    // nodes, edges
+    var stack: List[DefnNode] = Nil
+    var sccs: List[DefnGraph] = Nil
+
+    def dfs(src: DefnNode): Unit =
+      src.num = ctr
+      src.lowest = ctr
+      ctr += 1
+      src.visited = true
+      
+      val tailCalls = edges(src.defn.id)
+      stack = src :: stack
+      for u <- tailCalls do
+        val neighbour = nodeMap(u.id)
+        if (neighbour.visited) then
+          if (!neighbour.processed)
+            src.lowest = neighbour.num.min(src.lowest)
+        else
+          dfs(neighbour)
+          src.lowest = neighbour.lowest.min(src.lowest)
+      
+
+      src.processed = true
+
+      if (src.num == src.lowest) then
+        var scc: Set[DefnNode] = Set()
+
+        def pop(): DefnNode =
+          val ret = stack.head
+          stack = stack.tail
+          ret
+        
+
+        var vertex = pop()
+
+        while (vertex != src) {
+          scc = scc + vertex
+          
+          val next = pop()
+          vertex = next
+        }
+
+        scc = scc + vertex
+
+        val sccIds = scc.map { d => d.defn.id }
+
+        val sccJoinPoints = scc.foldLeft(Set[Defn]())((jps, defn) => joinPoints(defn.defn.id))
+
+        val sccDefns = scc.map(d => d.defn)
+
+        val categorizedEdges = scc
+          .foldLeft(Set[CallInfo]())(
+            (calls, defn) => discoverOptCalls(defn.defn, joinPoints(defn.defn.id))(sccDefns, calls)
+          )
+          .filter(c => sccDefns.contains(c.getDefn))
+
+        sccs = DefnGraph(scc, categorizedEdges, sccJoinPoints) :: sccs
+      
+    for v <- defns do
+      if !allJoinPoints.contains(v.defn) && !v.visited then
+        dfs(v)
+
+    sccs
+  
+
+  private case class DefnInfo(defn: Defn, stackFrameIdx: Int)
+
+  def asLit(x: Int) = Expr.Literal(IntLit(x))
+
+  private def makeSwitch(scrutName: Name, cases: List[(Int, Node)], default: Node)(implicit trueClass: ClassInfo, falseClass: ClassInfo): Node =
+    // given expressions value, e1, e2, transform it into
+    // let scrut = tailrecBranch == value
+    // in case scrut of True  -> e1
+    //                  False -> e2
+    def makeCaseBranch(value: Int, e1: Node, e2: Node): Node =
+      val name = Name("scrut")
+      val cases = Case(name, List((trueClass, e1), (falseClass, e2))).attachTag(tag)
+      LetExpr(
+        name,
+        Expr.BasicOp("==", List(asLit(value), Expr.Ref(scrutName))),
+        cases
+      ).attachTag(tag)
+      
+    cases.foldLeft(default)((elz, item) => 
+      val cmpValue = item._1
+      val nodeIfTrue = item._2
+      makeCaseBranch(cmpValue, nodeIfTrue, elz)
+    )
+  
+  // TAIL RECURSION MOD CONS
+  // Uses the ideas in section 2.2 of the paper `Tail Recursion Modulo Context` 
+  // by Leijen and Lorenzen: https://dl.acm.org/doi/abs/10.1145/3571233
+  // of whom attribute the method to Risch, Friedman, Wise, Minamide.
+
+  final val ID_CONTEXT_NAME = "_IdContext"
+  final val CONTEXT_NAME = "_Context"
+
+  // `ctx` class for tailrec mod cons.
+  // The paper uses two values `res: T` and `hole: ptr<T>` to represent the context. 
+  // We represent the context as three values instead of two to avoid needing pointers:
+  //
+  // acc:       The accumulated value. This is the same as `res`  in the paper. If the functions f1, ..., fn
+  //            in the compoennt return type T1, ..., Tn, then acc has type T1 | ... | Tn. 
+  //
+  // The following together represent `hole` in the paper:
+  // ptr:       Represents the object containing the "hole" to be written to.
+  // field:     Integer representing which class and field the "hole" belongs to. Which class and field this
+  //            represents is different for each strongly connected component.
+  //
+  // The idea to use `ptr` and `field` to represent a pointer is by @LPTK.
+  final val ID_CTX_CLASS = ClassInfo(classUid.make, ID_CONTEXT_NAME, Nil)
+  final val CTX_CLASS = ClassInfo(classUid.make, CONTEXT_NAME, List("acc", "ptr", "field"))
+  
+  // Given a strongly connected component `defns` of mutually
+  // tail recursive functions, returns a strongly connected component contaning the
+  // optimized functions and their associated join points, and also
+  // new function definitions not in this component, such as the
+  // original functions pointing to an optimized function and the context
+  // composition and application functions.
+  private def optimizeModCons(component: ScComponent, classes: Set[ClassInfo]): (ScComponent, Set[Defn]) = 
+    val modConsCalls = component.edges.collect { case x: ModConsCallInfo => x }
+    val defns = component.nodes
+    val defnsIdSet = defns.map(_.id).toSet
+
+    // no mod cons, just return the original
+    if modConsCalls.isEmpty then
+      (component, Set())
+    else
+      val trueClass = classes.find(c => c.ident == "True").get
+      val falseClass = classes.find(c => c.ident == "False").get
+      
+      // CONTEXT APPLICATION
+      
+      val mergedNames = defns.foldLeft("")(_ + "_" + _.name)
+      
+      val ctxAppId = fnUid.make
+      val ctxAppName = mergedNames + "_ctx_app$" + ctxAppId
+      val ctxCompId = fnUid.make
+      val ctxCompName = mergedNames + "_ctx_comp$" + ctxCompId
+      
+      // map integers to classes and fields which will be assigned to
+      val classIdMap = classes.map(c => c.id -> c).toMap
+      val possibleAssigns = modConsCalls.map(call => (call.letCtorNode.cls.id, call.letCtorNode.fieldName)).toSet
+      val possibleAssignsIdxes = possibleAssigns.toList.zipWithIndex
+
+      val assignToIdx = possibleAssignsIdxes.map((item, idx) => item -> idx).toMap
+
+      // fun app(ctx, x: T): T
+      val appCtxName = Name("ctx")
+      val appValName = Name("x")
+
+      val assignmentCases = possibleAssignsIdxes.map((item, idx) =>
+        val clsId = item._1
+        val fieldName = item._2
+        val cls = classIdMap(clsId)
+        
+        // let ptr = ctx.ptr in
+        // ptr.<fieldName> = x in
+        // let acc = ctx.acc
+        // acc
+        val node = LetExpr(
+          Name("ptr"), 
+          Expr.Select(appCtxName, CTX_CLASS, "ptr"),
+          LetExpr(
+            Name("_"), 
+            Expr.AssignField(
+              Name("ptr"), 
+              cls, 
+              fieldName, 
+              Expr.Ref(appValName)
+            ),
+            LetExpr(
+              Name("acc"), 
+              Expr.Select(appCtxName, CTX_CLASS, "acc"), // this could be a join point but it's not that bad
+              Result(
+                List(Expr.Ref(Name("acc")))
+              ).attachTag(tag)
+            ).attachTag(tag)
+          ).attachTag(tag)
+        ).attachTag(tag)
+
+        (idx, node)
+      )
+      
+      
+      val ctxBranch = LetExpr(
+        Name("field"), Expr.Select(appCtxName, CTX_CLASS, "field"),
+        makeSwitch(Name("field"), assignmentCases.tail, assignmentCases.head._2)(trueClass, falseClass)
+      ).attachTag(tag)
+      
+      val idBranch = Result(List(Expr.Ref(appValName))).attachTag(tag)
+
+      val appNode = Case(appCtxName,
+        List(
+          (ID_CTX_CLASS, idBranch),
+          (CTX_CLASS, ctxBranch)
+        )
+      ).attachTag(tag)
+
+      val appDefn = Defn(ctxAppId, ctxAppName, List(appCtxName, appValName), 1, appNode, false)
+
+      // CONTEXT COMPOSITION
+      val cmpCtx1Name = Name("ctx1")
+      val cmpCtx2Name = Name("ctx2")
+
+      // Note that ctx2 may never be an identity context. If we ever want to compose ctx1 and ctx2
+      // where ctx2 is the identity, just use ctx1 directly.
+      
+      // Ctx(app(ctx1, ctx2), ctx2.ptr, ctx2.field) ->
+      // let ctx2acc = ctx2.acc in
+      // let ctx2ptr = ctx2.ptr in
+      // let ctx2field = ctx2.field in
+      // let newAcc = app(ctx1, ctx2acc) in
+      // let ret = Ctx(newAcc, ctx2ptr, ctx2field) in
+      // ret
+      val cmpNode = LetExpr(
+        Name("ctx2acc"), 
+        Expr.Select(cmpCtx2Name, CTX_CLASS, "acc"),
+        LetExpr(
+          Name("ctx2ptr"), 
+          Expr.Select(cmpCtx2Name, CTX_CLASS, "ptr"),
+          LetExpr(
+            Name("ctx2field"), 
+            Expr.Select(cmpCtx2Name, CTX_CLASS, "field"),
+            LetCall(
+              List(Name("newAcc")), 
+              DefnRef(Left(appDefn)), List(Expr.Ref(cmpCtx1Name), Expr.Ref(Name("ctx2acc"))),
+              false,
+              LetExpr(
+                Name("ret"), 
+                Expr.CtorApp(CTX_CLASS, List("newAcc", "ctx2ptr", "ctx2field").map(n => Expr.Ref(Name(n)))),
+                Result(
+                  List(Expr.Ref(Name("ret")))
+                ).attachTag(tag)
+              ).attachTag(tag),
+            )().attachTag(tag)
+          ).attachTag(tag)
+        ).attachTag(tag)
+      ).attachTag(tag)
+
+      val cmpDefn = Defn(ctxCompId, ctxCompName, List(cmpCtx1Name, cmpCtx2Name), 1, cmpNode, false)
+
+      // We use tags to identify nodes
+      // a bit hacky but it's the most elegant way
+      // First, build a map of all branches that contain a mod cons call
+      val modConsBranches = modConsCalls.toList.map(call => (call.startNode.tag.inner -> call)).toMap
+
+      val modConsRefs = defns.map(d => d.id -> DefnRef(Right(d.name + "_modcons"))).toMap
+      val jpRefs = component.joinPoints.map(jp => jp.id -> DefnRef(Right(jp.name + "_modcons"))).toMap
+
+      def makeRet(ret: TrivialExpr): Node =
+        LetCall(
+          List(Name("res")),
+          DefnRef(Left(appDefn)),
+          List(Expr.Ref(Name("ctx")), ret),
+          false,
+          Result(List(Expr.Ref(Name("res")))).attachTag(tag)
+        )().attachTag(tag)
+      
+      // Here, we assume we are inside the modcons version of the function and hence have an extra
+      // `ctx` parameter at the start.
+      def transformNode(node: Node): Node = 
+        modConsBranches.get(node.tag.inner) match
+          case Some(call) => transformModConsBranch(node)(call)
+          case None => node match
+            case Result(res) => 
+              makeRet(res.head)
+            case Jump(defn, args) => 
+              if isIdentityJp(defn.expectDefn) then makeRet(args.head) 
+              else jpRefs.get(defn.expectDefn.id) match
+                case None => throw IRError("could not find jump point with id" + defn.expectDefn.id)
+                case Some(value) => Jump(value, Expr.Ref(Name("ctx")) :: args)
+              
+            case Case(scrut, cases) => Case(scrut, cases.map { (cls, body) => (cls, transformNode(body)) }).attachTag(tag)
+            case LetExpr(name, expr, body) => LetExpr(name, expr, transformNode(body)).attachTag(tag)
+            case LetCall(names, defn, args, isTailRec, body) =>
+              // Handle the case when we see a tail call.
+              // This case is not handled by the paper. The way to transform this is: 
+              // let res = foo(*args) in res
+              // --> let res = foo_modcons(ctx, *args) in res
+              if isTailCall(node) && defnsIdSet.contains(defn.expectDefn.id) then
+                // Transform it into a tail recursive call where we pass on the current context
+                LetCall(
+                  List(Name("res")), 
+                  modConsRefs(defn.expectDefn.id), Expr.Ref(Name("ctx")) :: args, 
+                  isTailRec,
+                  Result(List(Expr.Ref(Name("res")))).attachTag(tag)
+                )().attachTag(tag)
+              else 
+                LetCall(names, defn, args, isTailRec, transformNode(body))().attachTag(tag)
+
+      def transformModConsBranch(node: Node)(implicit call: ModConsCallInfo): Node = 
+        def makeCall =
+          val field = assignToIdx((call.letCtorNode.cls.id, call.letCtorNode.fieldName))
+          
+          // let composed = comp(ctx, Ctx(retVal, ptr, field)) in
+          // f(composed, *args)
+          LetExpr(
+            Name("ctx2"),
+            Expr.CtorApp(CTX_CLASS, List(Expr.Ref(call.retName), Expr.Ref(call.letCtorNode.ctorValName), asLit(field))),
+            LetCall(
+              List(Name("composed")),
+              DefnRef(Left(cmpDefn)),
+              List("ctx", "ctx2").map(n => Expr.Ref(Name(n))),
+              false,
+              LetCall(
+                List(Name("res")), 
+                modConsRefs(call.defn.id),
+                Expr.Ref(Name("composed")) :: call.letCallNode.args,
+                false,
+                Result(
+                  List(Expr.Ref(Name("res")))
+                ).attachTag(tag)
+              )().attachTag(tag)
+            )().attachTag(tag)
+          ).attachTag(tag)
+
+        node match
+          case Result(res) if node.tag.inner == call.retNode.tag.inner =>
+            makeCall
+          case Jump(defn, args) if node.tag.inner == call.retNode.tag.inner =>
+            makeCall
+          case LetExpr(name, expr, body) => 
+            if node.tag.inner == call.letCtorNode.node.tag.inner then
+              // rewrite the ctor, but set the field containing the call as to 0
+              val idx = call.letCtorNode.idx
+              val argsList = call.letCtorNode.ctor.args.updated(idx, asLit(0))
+              LetExpr(name, Expr.CtorApp(call.letCtorNode.cls, argsList), transformModConsBranch(body)).attachTag(tag)
+            else
+              LetExpr(name, expr, transformModConsBranch(body)).attachTag(tag)
+          case LetCall(names, defn, args, isTailRec, body) =>
+            if node.tag.inner == call.letCallNode.tag.inner then
+              // discard it
+              transformModConsBranch(body)
+            else
+              LetCall(names, defn, args, isTailRec, transformModConsBranch(body))().attachTag(tag)
+          case _ => throw IRError("unreachable case when transforming mod cons call")
+
+      def rewriteDefn(d: Defn): Defn =
+        val transformed = transformNode(d.body)
+        val id = fnUid.make
+        Defn(id, d.name + "_modcons$" + id, Name("ctx") :: d.params, d.resultNum, transformed, d.isTailRec)
+      
+      // returns (new defn, mod cons defn)
+      // where new defn has the same signature and ids as the original, but immediately calls the mod cons defn
+      // and mod cons defn is the rewritten definition
+      def replaceDefn(d: Defn): (Defn, Defn) =
+        val modConsDefn = rewriteDefn(d)
+        val modConsCall = 
+          LetExpr(
+            Name("idCtx"),
+            Expr.CtorApp(ID_CTX_CLASS, Nil),
+              LetCall(
+              List(Name("res")), 
+              DefnRef(Left(modConsDefn)),
+              Expr.Ref(Name("idCtx")) :: d.params.map(Expr.Ref(_)),
+              false,
+              Result(List(Expr.Ref(Name("res")))).attachTag(tag)
+            )().attachTag(tag)
+          ).attachTag(tag)
+        val newDefn = Defn(d.id, d.name, d.params, d.resultNum, modConsCall, false)
+        (newDefn, modConsDefn)
+
+      val jpsTransformed = component.joinPoints.map(d => d.id -> rewriteDefn(d)).toMap
+      val defnsTransformed = component.nodes.map(d => d.id -> replaceDefn(d)).toMap
+
+      // update defn refs
+      for (id, ref) <- jpRefs do
+        ref.defn = Left(jpsTransformed(id))
+      
+      for (id, ref) <- modConsRefs do
+        ref.defn = Left(defnsTransformed(id)._2) // set it to the mod cons defn, not the one with the original signature
+
+      val jps = jpsTransformed.values.toSet
+      val modConsDefs = defnsTransformed.values.map((a, b) => b).toSet 
+      val normalDefs = defnsTransformed.values.map((a, b) => a).toSet + appDefn + cmpDefn
+
+      // the edges are not used later, but still, rewrite them for correctness
+      val newEdges = component.edges.map { c =>
+        val src = c.getSrc
+        val defn = c.getDefn
+        TailCallInfo(defnsTransformed(src.id)._2, defnsTransformed(defn.id)._2) 
+      }
+
+      (ScComponent(modConsDefs, newEdges, jps), normalDefs)
+
+  // Given a strongly connected component `defns` of mutually
+  // tail recursive functions, returns a set containing the optimized function and the
+  // original functions pointing to an optimized function.
+  // Explicitly returns the merged function in case tailrec needs to be checked.
+  private def optimizeTailRec(component: ScComponent, classes: Set[ClassInfo]): (Set[Defn], Defn) = 
+    // To build the case block, we need to compare integers and check if the result is "True"
+    val trueClass = classes.find(c => c.ident == "True").get
+    val falseClass = classes.find(c => c.ident == "False").get
+    // undefined for dummy values
+    val dummyVal = Expr.Literal(UnitLit(true))
+    
+    // join points need to be rewritten. For now, just combine them into the rest of the function. They will be inlined anyways
+    val defns = component.nodes ++ component.joinPoints
+    val defnsNoJp = component.nodes
+    val edges = component.edges
+
+    // dummy case, should not happen
+    if (defns.size == 0)
+      throw IRError("strongly connected component was empty")
+
+    // for single tail recursive functions, just move the body into a join point
+    if (defns.size <= 1)
+      val defn = defns.head
+      
+      // if the function does not even tail call itself, just return
+      if filterOptCalls(edges).size == 0 then
+        return (defns, defns.head)
+      
+      val jpName = defn.name + "_jp"
+      val jpDefnRef = DefnRef(Right(jpName))
+      
+      def transformNode(node: Node): Node = node match
+        case Result(res) => node.attachTag(tag)
+        case Jump(defn, args) => node.attachTag(tag)
+        case Case(scrut, cases) => Case(scrut, cases.map((cls, body) => (cls, transformNode(body)))).attachTag(tag)
+        case LetExpr(name, expr, body) => LetExpr(name, expr, transformNode(body)).attachTag(tag)
+        case LetCall(names, defn_, args, isTailRec, body) =>
+          if isTailCall(node) && defn_.expectDefn.id == defn.id then
+            Jump(jpDefnRef, args).attachTag(tag)
+          else
+            LetCall(names, defn_, args, isTailRec, transformNode(body))().attachTag(tag)
+      
+      val jpDef = Defn(fnUid.make, jpName, defn.params, defn.resultNum, transformNode(defn.body), false)
+      
+      val rets = (0 until defn.resultNum).map(n => Name("r" + n.toString)).toList
+      val callJpNode = LetCall(
+        rets, 
+        DefnRef(Left(jpDef)),
+        defn.params.map(Expr.Ref(_)),
+        false,
+        Result(rets.map(Expr.Ref(_))).attachTag(tag),
+      )().attachTag(tag)
+      
+      val newDefn = Defn(fnUid.make, defn.name, defn.params, defn.resultNum, callJpNode, true)
+      (Set(newDefn, jpDef), newDefn)
+
+    else
+      // Note that we do not use the actual edges in ScCompoennt here.
+      // We assume the only things we can optimize are tail calls, which
+      // are cheap to identify, and nothing else.
+
+      // concretely order the functions as soon as possible, since the order of the functions matter
+      val defnsList = defns.toList
+
+      // assume all defns have the same number of results
+      // in fact, they should theoretically have the same return type if the program type checked
+      val resultNum = defnsList.head.resultNum
+
+      val trName = Name("tailrecBranch$");
+
+      // To be used to replace variable names inside a definition to avoid variable name clashes
+      val nameMaps: Map[Int, Map[Name, Name]] = defnsList.map(defn => defn.id -> defn.params.map(n => n -> Name(defn.name + "_" + n.str)).toMap).toMap
+
+      val stackFrameIdxes = defnsList.foldLeft(1 :: Nil)((ls, defn) => defn.params.size + ls.head :: ls).drop(1).reverse
+
+      val defnInfoMap: Map[Int, DefnInfo] = (defnsList zip stackFrameIdxes)
+        .foldLeft(Map.empty)((map, item) => map + (item._1.id -> DefnInfo(item._1, item._2)))
+
+      val stackFrame = trName :: defnsList.flatMap(d => d.params.map(n => nameMaps(d.id)(n))) // take union of stack frames
+
+      val newId = fnUid.make
+      val newName = defns.foldLeft("")(_ + "_" + _.name) + "_opt$" + newId
+      val jpId = fnUid.make
+      val jpName = defns.foldLeft("")(_ + "_" + _.name) + "_opt_jp$" + jpId
+
+      val newDefnRef = DefnRef(Right(newName))
+      val jpDefnRef = DefnRef(Right(jpName))
+
+      def transformStackFrame(args: List[TrivialExpr], info: DefnInfo) =
+        val start = stackFrame.take(info.stackFrameIdx).drop(1).map { Expr.Ref(_) } // we drop tailrecBranch and replace it with the defn id
+        val end = stackFrame.drop(info.stackFrameIdx + args.size).map { Expr.Ref(_) }
+        asLit(info.defn.id) :: start ::: args ::: end
+
+      // Build the node which will be contained inside the jump point.
+      def transformNode(node: Node): Node = node match
+        case Jump(defn, args)          =>
+          if defnInfoMap.contains(defn.expectDefn.id) then
+            Jump(jpDefnRef, transformStackFrame(args, defnInfoMap(defn.expectDefn.id))).attachTag(tag)
+          else
+            node.attachTag(tag)
+        case Result(_)                 => node.attachTag(tag)
+        case Case(scrut, cases)        => Case(scrut, cases.map(n => (n._1, transformNode(n._2)))).attachTag(tag)
+        case LetExpr(name, expr, body) => LetExpr(name, expr, transformNode(body)).attachTag(tag)
+        case LetCall(names, defn, args, isTailRec, body) =>
+          if isTailCall(node) && defnInfoMap.contains(defn.expectDefn.id) then
+            Jump(jpDefnRef, transformStackFrame(args, defnInfoMap(defn.expectDefn.id))).attachTag(tag)
+          else LetCall(names, defn, args, isTailRec, transformNode(body))().attachTag(tag)
+
+      // Tail calls to another function in the component will be replaced with a call
+      // to the merged function
+      // i.e. for mutually tailrec functions f(a, b) and g(c, d),
+      // f's body will be replaced with a call f_g(a, b, *, *), where * is a dummy value
+      def transformDefn(defn: Defn): Defn =
+        val info = defnInfoMap(defn.id)
+
+        val start =
+          stackFrame.take(info.stackFrameIdx).drop(1).map { _ => dummyVal } // we drop tailrecBranch and replace it with the defn id
+        val end = stackFrame.drop(info.stackFrameIdx + defn.params.size).map { _ => dummyVal }
+        val args = asLit(info.defn.id) :: start ::: defn.params.map(Expr.Ref(_)) ::: end
+
+        // We use a let call instead of a jump to avoid newDefn from being turned into a join point,
+        // which would cause it to be inlined and result in code duplication.
+        val names = (0 until resultNum).map(i => Name("r" + i.toString())).toList
+        val namesExpr = names.map(Expr.Ref(_))
+        val res = Result(namesExpr).attachTag(tag)
+        val call = LetCall(names, newDefnRef, args, false, res)().attachTag(tag)
+        Defn(defn.id, defn.name, defn.params, defn.resultNum, call, false)
+
+      def getOrKey[T](m: Map[T, T])(key: T): T = m.get(key) match
+        case None        => key
+        case Some(value) => value
+
+      val first = defnsList.head;
+      val firstMap = nameMaps(first.id)
+      val firstBodyRenamed = first.body.mapName(getOrKey(firstMap))
+      val firstNode = transformNode(firstBodyRenamed)
+
+      val valsAndNodes = defnsList.map(defn =>
+        val nmeMap = nameMaps(defn.id)
+        val renamed = defn.body.mapName(getOrKey(nmeMap))
+        val transformed = transformNode(renamed)
+        (defn.id, transformed)
+      )
+
+      val newNode = makeSwitch(trName, valsAndNodes.tail, valsAndNodes.head._2)(trueClass, falseClass)
+
+      val jpDefn = Defn(jpId, jpName, stackFrame, resultNum, newNode, false)
+
+      val jmp = Jump(jpDefnRef, stackFrame.map(Expr.Ref(_))).attachTag(tag)
+      val newDefn = Defn(newId, newName, stackFrame, resultNum, jmp, defnsNoJp.find { _.isTailRec }.isDefined )
+
+      jpDefnRef.defn = Left(jpDefn)
+      newDefnRef.defn = Left(newDefn)
+
+      (defnsNoJp.map { d => transformDefn(d) } + newDefn + jpDefn, newDefn)
+  
+  private def partition(defns: Set[Defn]): List[ScComponent] = 
+    val nodeMap: Map[Int, DefnNode] = defns.foldLeft(Map.empty)((m, d) => m + (d.id -> DefnNode(d)))
+    partitionNodes(nodeMap).map(_.removeMetadata)
+
+  private def optimizeParition(component: ScComponent, classes: Set[ClassInfo]): Set[Defn] =
+    val trFn = component.nodes.find { _.isTailRec }.headOption
+    val normalCall = filterNormalCalls(component.edges).headOption
+    
+    (trFn, normalCall) match
+      case (Some(fn), Some(call)) => 
+        raise(ErrorReport(
+          List(
+            msg"function `${fn.name}` is not tail-recursive, but is marked as @tailrec" -> fn.loc,
+            msg"it could self-recurse through this call, which may not be a tail-call" -> call.loc
+          ), 
+          true, Diagnostic.Compilation)
+        )
+      case _ =>
+
+    val (modConsComp, other) = optimizeModCons(component, classes)
+    val (trOpt, mergedDefn) = optimizeTailRec(modConsComp, classes)
+    other ++ trOpt
+
+  def apply(p: Program) = run(p)
+
+  def run_debug(p: Program): (Program, List[Set[String]]) = 
+    val partitions = partition(p.defs)
+
+    val newDefs = partitions.flatMap { optimizeParition(_, p.classes) }.toSet
+
+    // update the definition refs
+    newDefs.foreach { defn => resolveDefnRef(defn.body, newDefs, true) }
+    resolveDefnRef(p.main, newDefs, true)
+
+    (Program(p.classes + ID_CTX_CLASS + CTX_CLASS, newDefs, p.main), partitions.map(t => t.nodes.map(f => f.name)))
+
+  def run(p: Program): Program = run_debug(p)._1
\ No newline at end of file
diff --git a/compiler/shared/test/diff-ir/IR.mls b/compiler/shared/test/diff-ir/IR.mls
index 1900d8e732..b5b44bbcf9 100644
--- a/compiler/shared/test/diff-ir/IR.mls
+++ b/compiler/shared/test/diff-ir/IR.mls
@@ -1,6 +1,7 @@
 :NewParser
 :ParseOnly
 :UseIR
+:NoTailRec
 
 :interpIR
 class Pair(x, y)
@@ -12,30 +13,8 @@ foo()
 //│ |#class| |Pair|(|x|,| |y|)|↵|#fun| |mktup2|(|x|,| |y|)| |#=| |mktup|(|x|,| |y|)|↵|#fun| |mktup|(|x|,| |y|)| |#=| |Pair|(|x|,| |y|)|↵|#fun| |foo|(||)| |#=|→|mktup2|(|1|,| |2|)|←|↵|foo|(||)|
 //│ Parsed: {class Pair(x, y,) {}; fun mktup2 = (x, y,) => mktup(x, y,); fun mktup = (x, y,) => Pair(x, y,); fun foo = () => {mktup2(1, 2,)}; foo()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, Pair, [x,y])}, {
-//│ Def(0, mktup2, [x$0,y$0],
-//│ 1, 
-//│ let* (x$1) = mktup(x$0,y$0) in -- #7
-//│ x$1 -- #6
-//│ )
-//│ Def(1, mktup, [x$2,y$1],
-//│ 1, 
-//│ let x$3 = Pair(x$2,y$1) in -- #14
-//│ x$3 -- #13
-//│ )
-//│ Def(2, foo, [],
-//│ 1, 
-//│ let* (x$4) = mktup2(1,2) in -- #22
-//│ x$4 -- #21
-//│ )
-//│ },
-//│ let* (x$5) = foo() in -- #26
-//│ x$5 -- #25)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, Pair, [x,y])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Pair, [x,y])}, {
 //│ Def(0, mktup2, [x$0,y$0],
 //│ 1, 
 //│ let* (x$1) = mktup(x$0,y$0) in -- #7
@@ -69,34 +48,8 @@ bar()
 //│ |#class| |Pair|(|x|,| |y|)|↵|#fun| |foo|(|pair|)| |#=|→|#if| |pair| |is|→|Pair|(|x|,| |y|)| |#then| |Pair|(|x|,| |y|)|←|←|↵|#fun| |bar|(||)| |#=|→|foo|(|Pair|(|1|,| |2|)|)|←|↵|bar|(||)|
 //│ Parsed: {class Pair(x, y,) {}; fun foo = (pair,) => {if pair is ‹(Pair(x, y,)) then Pair(x, y,)›}; fun bar = () => {foo(Pair(1, 2,),)}; bar()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, Pair, [x,y])}, {
-//│ Def(0, foo, [pair$0],
-//│ 1, 
-//│ case pair$0 of -- #16
-//│   Pair =>
-//│     let x$1 = pair$0.y in -- #15
-//│     let x$2 = pair$0.x in -- #14
-//│     let x$3 = Pair(x$2,x$1) in -- #13
-//│     jump j$0(x$3) -- #12
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, bar, [],
-//│ 1, 
-//│ let x$4 = Pair(1,2) in -- #28
-//│ let* (x$5) = foo(x$4) in -- #27
-//│ x$5 -- #26
-//│ )
-//│ },
-//│ let* (x$6) = bar() in -- #32
-//│ x$6 -- #31)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, Pair, [x,y])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Pair, [x,y])}, {
 //│ Def(0, foo, [pair$0],
 //│ 1, 
 //│ case pair$0 of -- #16
@@ -142,44 +95,8 @@ foo()
 //│ |#class| |Pair|(|x|,| |y|)| |{||}|↵|#fun| |silly|(|pair|)| |#=|→|#let| |_| |#=| |0|↵|#let| |n| |#=| |#if| |pair| |is|→|Pair|(|x1|,| |x2|)| |#then|→|#if| |pair| |is|→|Pair| |(|x3|,| |x4|)| |#then| |x3| |+| |1|←|←|←|↵|n| |+| |1|←|↵|#fun| |foo|(||)| |#=|→|#let| |a| |#=| |Pair|(|0|,| |1|)|↵|#let| |b| |#=| |silly|(|a|)|↵|b|←|↵|foo|(||)|
 //│ Parsed: {class Pair(x, y,) {}; fun silly = (pair,) => {let _ = 0; let n = if pair is ‹(Pair(x1, x2,)) then {if pair is ‹(Pair(x3, x4,)) then +(x3,)(1,)›}›; +(n,)(1,)}; fun foo = () => {let a = Pair(0, 1,); let b = silly(a,); b}; foo()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, Pair, [x,y])}, {
-//│ Def(0, silly, [pair$0],
-//│ 1, 
-//│ let x$0 = 0 in -- #29
-//│ case pair$0 of -- #28
-//│   Pair =>
-//│     let x$3 = pair$0.y in -- #27
-//│     let x$4 = pair$0.x in -- #26
-//│     case pair$0 of -- #25
-//│       Pair =>
-//│         let x$6 = pair$0.y in -- #24
-//│         let x$7 = pair$0.x in -- #23
-//│         let x$8 = +(x$7,1) in -- #22
-//│         jump j$1(x$8) -- #21
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ let x$2 = +(x$1,1) in -- #6
-//│ x$2 -- #5
-//│ )
-//│ Def(2, j$1, [x$5],
-//│ 1, 
-//│ jump j$0(x$5) -- #13
-//│ )
-//│ Def(3, foo, [],
-//│ 1, 
-//│ let x$9 = Pair(0,1) in -- #43
-//│ let* (x$10) = silly(x$9) in -- #42
-//│ x$10 -- #41
-//│ )
-//│ },
-//│ let* (x$11) = foo() in -- #47
-//│ x$11 -- #46)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, Pair, [x,y])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Pair, [x,y])}, {
 //│ Def(0, silly, [pair$0],
 //│ 1, 
 //│ let x$0 = 0 in -- #29
@@ -233,35 +150,8 @@ foo()
 //│ |#class| |Pair|(|x|,| |y|)|↵|#fun| |inc_fst|(|pair|)| |#=|→|#let| |c| |#=| |2|↵|#if| |pair| |is|→|Pair|(|x1|,| |x2|)| |#then| |x1| |+| |c|←|←|↵|#fun| |foo|(||)| |#=|→|#let| |a| |#=| |Pair|(|0|,| |1|)|↵|#let| |b| |#=| |inc_fst|(|a|)|↵|b|←|↵|foo|(||)|
 //│ Parsed: {class Pair(x, y,) {}; fun inc_fst = (pair,) => {let c = 2; if pair is ‹(Pair(x1, x2,)) then +(x1,)(c,)›}; fun foo = () => {let a = Pair(0, 1,); let b = inc_fst(a,); b}; foo()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, Pair, [x,y])}, {
-//│ Def(0, inc_fst, [pair$0],
-//│ 1, 
-//│ let x$0 = 2 in -- #15
-//│ case pair$0 of -- #14
-//│   Pair =>
-//│     let x$2 = pair$0.y in -- #13
-//│     let x$3 = pair$0.x in -- #12
-//│     let x$4 = +(x$3,x$0) in -- #11
-//│     jump j$0(x$4) -- #10
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #2
-//│ )
-//│ Def(2, foo, [],
-//│ 1, 
-//│ let x$5 = Pair(0,1) in -- #29
-//│ let* (x$6) = inc_fst(x$5) in -- #28
-//│ x$6 -- #27
-//│ )
-//│ },
-//│ let* (x$7) = foo() in -- #33
-//│ x$7 -- #32)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, Pair, [x,y])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Pair, [x,y])}, {
 //│ Def(0, inc_fst, [pair$0],
 //│ 1, 
 //│ let x$0 = 2 in -- #15
@@ -302,35 +192,8 @@ foo()
 //│ |#class| |Pair|(|x|,| |y|)|↵|#fun| |inc_fst|(|pair|)| |#=|→|#let| |_| |#=| |0|↵|#if| |pair| |is|→|Pair|(|x1|,| |x2|)| |#then| |x2| |+| |1|←|←|↵|#fun| |foo|(||)| |#=|→|#let| |b| |#=| |inc_fst|(|Pair|(|0|,| |1|)|)|↵|b|←|↵|foo|(||)|
 //│ Parsed: {class Pair(x, y,) {}; fun inc_fst = (pair,) => {let _ = 0; if pair is ‹(Pair(x1, x2,)) then +(x2,)(1,)›}; fun foo = () => {let b = inc_fst(Pair(0, 1,),); b}; foo()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, Pair, [x,y])}, {
-//│ Def(0, inc_fst, [pair$0],
-//│ 1, 
-//│ let x$0 = 0 in -- #15
-//│ case pair$0 of -- #14
-//│   Pair =>
-//│     let x$2 = pair$0.y in -- #13
-//│     let x$3 = pair$0.x in -- #12
-//│     let x$4 = +(x$2,1) in -- #11
-//│     jump j$0(x$4) -- #10
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #2
-//│ )
-//│ Def(2, foo, [],
-//│ 1, 
-//│ let x$5 = Pair(0,1) in -- #28
-//│ let* (x$6) = inc_fst(x$5) in -- #27
-//│ x$6 -- #26
-//│ )
-//│ },
-//│ let* (x$7) = foo() in -- #32
-//│ x$7 -- #31)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, Pair, [x,y])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Pair, [x,y])}, {
 //│ Def(0, inc_fst, [pair$0],
 //│ 1, 
 //│ let x$0 = 0 in -- #15
@@ -374,48 +237,8 @@ bar()
 //│ |#class| |Left|(|x|)|↵|#class| |Right|(|y|)|↵|#fun| |foo|(|a|,| |b|)| |#=|→|#let| |t| |#=| |#if| |a| |is|→|Left|(|x|)| |#then| |Left|(|x| |+| |1|)|↵|Right|(|y|)| |#then| |Right|(|b|)|←|↵|#if| |t| |is|→|Left|(|x|)| |#then| |x|↵|Right|(|y|)| |#then| |y|←|←|↵|#fun| |bar|(||)| |#=|→|foo|(|Right|(|2|)|,| |2|)|←|↵|bar|(||)|
 //│ Parsed: {class Left(x,) {}; class Right(y,) {}; fun foo = (a, b,) => {let t = if a is ‹(Left(x,)) then Left(+(x,)(1,),); (Right(y,)) then Right(b,)›; if t is ‹(Left(x,)) then x; (Right(y,)) then y›}; fun bar = () => {foo(Right(2,), 2,)}; bar()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, Left, [x]),ClassInfo(1, Right, [y])}, {
-//│ Def(0, foo, [a$0,b$0],
-//│ 1, 
-//│ case a$0 of -- #36
-//│   Left =>
-//│     let x$4 = a$0.x in -- #26
-//│     let x$5 = +(x$4,1) in -- #25
-//│     let x$6 = Left(x$5) in -- #24
-//│     jump j$0(x$6) -- #23
-//│   Right =>
-//│     let x$7 = a$0.y in -- #35
-//│     let x$8 = Right(b$0) in -- #34
-//│     jump j$0(x$8) -- #33
-//│ )
-//│ Def(1, j$1, [x$1],
-//│ 1, 
-//│ x$1 -- #3
-//│ )
-//│ Def(2, j$0, [x$0],
-//│ 1, 
-//│ case x$0 of -- #14
-//│   Left =>
-//│     let x$2 = x$0.x in -- #8
-//│     jump j$1(x$2) -- #7
-//│   Right =>
-//│     let x$3 = x$0.y in -- #13
-//│     jump j$1(x$3) -- #12
-//│ )
-//│ Def(3, bar, [],
-//│ 1, 
-//│ let x$9 = Right(2) in -- #48
-//│ let* (x$10) = foo(x$9,2) in -- #47
-//│ x$10 -- #46
-//│ )
-//│ },
-//│ let* (x$11) = bar() in -- #52
-//│ x$11 -- #51)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, Left, [x]),ClassInfo(1, Right, [y])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Left, [x]),ClassInfo(3, Right, [y])}, {
 //│ Def(0, foo, [a$0,b$0],
 //│ 1, 
 //│ case a$0 of -- #36
@@ -457,35 +280,13 @@ bar()
 //│ 2
 
 :interpIR
-class True
-class False
 class Pair(x, y)
 fun foo(a) = a.x + a.y
 fun bar() =
   foo(Pair(1, 0))
 bar()
-//│ |#class| |True|↵|#class| |False|↵|#class| |Pair|(|x|,| |y|)|↵|#fun| |foo|(|a|)| |#=| |a|.x| |+| |a|.y|↵|#fun| |bar|(||)| |#=|→|foo|(|Pair|(|1|,| |0|)|)|←|↵|bar|(||)|
-//│ Parsed: {class True {}; class False {}; class Pair(x, y,) {}; fun foo = (a,) => +((a).x,)((a).y,); fun bar = () => {foo(Pair(1, 0,),)}; bar()}
-//│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Pair, [x,y])}, {
-//│ Def(0, foo, [a$0],
-//│ 1, 
-//│ let x$0 = a$0.x in -- #7
-//│ let x$1 = a$0.y in -- #6
-//│ let x$2 = +(x$0,x$1) in -- #5
-//│ x$2 -- #4
-//│ )
-//│ Def(1, bar, [],
-//│ 1, 
-//│ let x$3 = Pair(1,0) in -- #19
-//│ let* (x$4) = foo(x$3) in -- #18
-//│ x$4 -- #17
-//│ )
-//│ },
-//│ let* (x$5) = bar() in -- #23
-//│ x$5 -- #22)
+//│ |#class| |Pair|(|x|,| |y|)|↵|#fun| |foo|(|a|)| |#=| |a|.x| |+| |a|.y|↵|#fun| |bar|(||)| |#=|→|foo|(|Pair|(|1|,| |0|)|)|←|↵|bar|(||)|
+//│ Parsed: {class Pair(x, y,) {}; fun foo = (a,) => +((a).x,)((a).y,); fun bar = () => {foo(Pair(1, 0,),)}; bar()}
 //│ 
 //│ Promoted:
 //│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Pair, [x,y])}, {
@@ -522,36 +323,8 @@ bar()
 //│ |#class| |C1|(|x|,| |y|)|↵|#class| |C2|(|z|)|↵|#fun| |foo|(|a|)| |#=| |#if| |a| |is|→|C1|(|x|,| |y|)| |#then| |x|↵|C2|(|z|)| |#then| |z|←|↵|#fun| |bar|(||)| |#=|→|foo|(|C1|(|0|,| |1|)|)|←|↵|bar|(||)|
 //│ Parsed: {class C1(x, y,) {}; class C2(z,) {}; fun foo = (a,) => if a is ‹(C1(x, y,)) then x; (C2(z,)) then z›; fun bar = () => {foo(C1(0, 1,),)}; bar()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, C1, [x,y]),ClassInfo(1, C2, [z])}, {
-//│ Def(0, foo, [a$0],
-//│ 1, 
-//│ case a$0 of -- #15
-//│   C1 =>
-//│     let x$1 = a$0.y in -- #9
-//│     let x$2 = a$0.x in -- #8
-//│     jump j$0(x$2) -- #7
-//│   C2 =>
-//│     let x$3 = a$0.z in -- #14
-//│     jump j$0(x$3) -- #13
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, bar, [],
-//│ 1, 
-//│ let x$4 = C1(0,1) in -- #27
-//│ let* (x$5) = foo(x$4) in -- #26
-//│ x$5 -- #25
-//│ )
-//│ },
-//│ let* (x$6) = bar() in -- #31
-//│ x$6 -- #30)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, C1, [x,y]),ClassInfo(1, C2, [z])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, C1, [x,y]),ClassInfo(3, C2, [z])}, {
 //│ Def(0, foo, [a$0],
 //│ 1, 
 //│ case a$0 of -- #15
@@ -598,43 +371,8 @@ baz()
 //│ |#class| |Pair|(|x|,| |y|)|↵|#fun| |foo|(|a|,| |b|)| |#=|→|#let| |x1| |#=| |a|.x|↵|#let| |y1| |#=| |a|.y|↵|#let| |x2| |#=| |b|.x|↵|#let| |y2| |#=| |b|.y|↵|x1| |+| |y1| |+| |x2| |+| |y2|←|↵|#fun| |bar|(|c|)| |#=|→|foo|(|Pair|(|0|,| |1|)|,| |c|)|↵|foo|(|c|,| |Pair|(|2|,| |3|)|)|↵|foo|(|Pair|(|0|,| |1|)|,| |Pair|(|2|,| |3|)|)|←|↵|#fun| |baz|(||)| |#=|→|bar|(|Pair|(|4|,|5|)|)|←|↵|baz|(||)|
 //│ Parsed: {class Pair(x, y,) {}; fun foo = (a, b,) => {let x1 = (a).x; let y1 = (a).y; let x2 = (b).x; let y2 = (b).y; +(+(+(x1,)(y1,),)(x2,),)(y2,)}; fun bar = (c,) => {foo(Pair(0, 1,), c,); foo(c, Pair(2, 3,),); foo(Pair(0, 1,), Pair(2, 3,),)}; fun baz = () => {bar(Pair(4, 5,),)}; baz()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, Pair, [x,y])}, {
-//│ Def(0, foo, [a$0,b$0],
-//│ 1, 
-//│ let x$0 = a$0.x in -- #21
-//│ let x$1 = a$0.y in -- #20
-//│ let x$2 = b$0.x in -- #19
-//│ let x$3 = b$0.y in -- #18
-//│ let x$4 = +(x$0,x$1) in -- #17
-//│ let x$5 = +(x$4,x$2) in -- #16
-//│ let x$6 = +(x$5,x$3) in -- #15
-//│ x$6 -- #14
-//│ )
-//│ Def(1, bar, [c$0],
-//│ 1, 
-//│ let x$7 = Pair(0,1) in -- #69
-//│ let* (x$8) = foo(x$7,c$0) in -- #68
-//│ let x$9 = Pair(2,3) in -- #67
-//│ let* (x$10) = foo(c$0,x$9) in -- #66
-//│ let x$11 = Pair(0,1) in -- #65
-//│ let x$12 = Pair(2,3) in -- #64
-//│ let* (x$13) = foo(x$11,x$12) in -- #63
-//│ x$13 -- #62
-//│ )
-//│ Def(2, baz, [],
-//│ 1, 
-//│ let x$14 = Pair(4,5) in -- #81
-//│ let* (x$15) = bar(x$14) in -- #80
-//│ x$15 -- #79
-//│ )
-//│ },
-//│ let* (x$16) = baz() in -- #85
-//│ x$16 -- #84)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, Pair, [x,y])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Pair, [x,y])}, {
 //│ Def(0, foo, [a$0,b$0],
 //│ 1, 
 //│ let x$0 = a$0.x in -- #21
@@ -680,21 +418,8 @@ foo()
 //│ |#class| |Pair|(|x|,| |y|)|↵|#fun| |foo|(||)| |#=|→|#let| |p| |#=| |Pair|(|0|,| |1|)|↵|#let| |b| |#=| |p|.x|↵|b|←|↵|foo|(||)|
 //│ Parsed: {class Pair(x, y,) {}; fun foo = () => {let p = Pair(0, 1,); let b = (p).x; b}; foo()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, Pair, [x,y])}, {
-//│ Def(0, foo, [],
-//│ 1, 
-//│ let x$0 = Pair(0,1) in -- #10
-//│ let x$1 = x$0.x in -- #9
-//│ x$1 -- #8
-//│ )
-//│ },
-//│ let* (x$2) = foo() in -- #14
-//│ x$2 -- #13)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, Pair, [x,y])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Pair, [x,y])}, {
 //│ Def(0, foo, [],
 //│ 1, 
 //│ let x$0 = Pair(0,1) in -- #10
@@ -723,40 +448,8 @@ foo()
 //│ |#class| |S|(|s|)|↵|#class| |O|↵|#fun| |foo|(||)| |#=|→|bar|(|S|(|O|)|)|←|↵|#fun| |bar|(|x|)| |#=|→|baz|(|x|)|←|↵|#fun| |baz|(|x|)| |#=|→|#if| |x| |is|→|S|(|s|)| |#then| |s|↵|O| |#then| |x|←|←|↵|foo|(||)|
 //│ Parsed: {class S(s,) {}; class O {}; fun foo = () => {bar(S(O,),)}; fun bar = (x,) => {baz(x,)}; fun baz = (x,) => {if x is ‹(S(s,)) then s; (O) then x›}; foo()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, S, [s]),ClassInfo(1, O, [])}, {
-//│ Def(0, foo, [],
-//│ 1, 
-//│ let x$0 = O() in -- #10
-//│ let x$1 = S(x$0) in -- #9
-//│ let* (x$2) = bar(x$1) in -- #8
-//│ x$2 -- #7
-//│ )
-//│ Def(1, bar, [x$3],
-//│ 1, 
-//│ let* (x$4) = baz(x$3) in -- #16
-//│ x$4 -- #15
-//│ )
-//│ Def(2, baz, [x$5],
-//│ 1, 
-//│ case x$5 of -- #26
-//│   S =>
-//│     let x$7 = x$5.s in -- #23
-//│     jump j$0(x$7) -- #22
-//│   O =>
-//│     jump j$0(x$5) -- #25
-//│ )
-//│ Def(3, j$0, [x$6],
-//│ 1, 
-//│ x$6 -- #18
-//│ )
-//│ },
-//│ let* (x$8) = foo() in -- #30
-//│ x$8 -- #29)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, S, [s]),ClassInfo(1, O, [])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, S, [s]),ClassInfo(3, O, [])}, {
 //│ Def(0, foo, [],
 //│ 1, 
 //│ let x$0 = O() in -- #10
diff --git a/compiler/shared/test/diff-ir/IRComplex.mls b/compiler/shared/test/diff-ir/IRComplex.mls
index 5e8d6ebbbe..e6df8a88ec 100644
--- a/compiler/shared/test/diff-ir/IRComplex.mls
+++ b/compiler/shared/test/diff-ir/IRComplex.mls
@@ -1,6 +1,7 @@
 :NewParser
 :ParseOnly
 :UseIR
+:NoTailRec
 
 :interpIR
 class A(x, y, z)
@@ -21,58 +22,8 @@ bar()
 //│ |#class| |A|(|x|,| |y|,| |z|)|↵|#class| |B|(|m|,| |n|)|↵|#fun| |complex_foo|(|t|)| |#=|→|#let| |r| |#=| |#if| |t| |is|→|A|(|x|,| |y|,| |z|)| |#then| |x| |+| |y| |*| |z|↵|B|(|m|,| |n|)| |#then| |m| |-| |n|←|↵|#let| |s| |#=| |B|(|1|,| |2|)|↵|#let| |u| |#=| |#if| |s| |is|→|A|(|x|,| |y|,| |z|)| |#then| |3|↵|B|(|m|,| |n|)| |#then| |4|←|↵|r| |+| |u|←|↵|#fun| |bar|(||)| |#=|→|complex_foo|(|A|(|6|,| |7|,| |8|)|)|↵|complex_foo|(|B|(|9|,| |10|)|)|←|↵|bar|(||)|
 //│ Parsed: {class A(x, y, z,) {}; class B(m, n,) {}; fun complex_foo = (t,) => {let r = if t is ‹(A(x, y, z,)) then +(x,)(*(y,)(z,),); (B(m, n,)) then -(m,)(n,)›; let s = B(1, 2,); let u = if s is ‹(A(x, y, z,)) then 3; (B(m, n,)) then 4›; +(r,)(u,)}; fun bar = () => {complex_foo(A(6, 7, 8,),); complex_foo(B(9, 10,),)}; bar()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, A, [x,y,z]),ClassInfo(1, B, [m,n])}, {
-//│ Def(0, complex_foo, [t$0],
-//│ 1, 
-//│ case t$0 of -- #63
-//│   A =>
-//│     let x$9 = t$0.z in -- #51
-//│     let x$10 = t$0.y in -- #50
-//│     let x$11 = t$0.x in -- #49
-//│     let x$12 = *(x$10,x$9) in -- #48
-//│     let x$13 = +(x$11,x$12) in -- #47
-//│     jump j$0(x$13) -- #46
-//│   B =>
-//│     let x$14 = t$0.n in -- #62
-//│     let x$15 = t$0.m in -- #61
-//│     let x$16 = -(x$15,x$14) in -- #60
-//│     jump j$0(x$16) -- #59
-//│ )
-//│ Def(1, j$1, [x$2,x$0],
-//│ 1, 
-//│ let x$3 = +(x$0,x$2) in -- #13
-//│ x$3 -- #12
-//│ )
-//│ Def(2, j$0, [x$0],
-//│ 1, 
-//│ let x$1 = B(1,2) in -- #34
-//│ case x$1 of -- #33
-//│   A =>
-//│     let x$4 = x$1.z in -- #24
-//│     let x$5 = x$1.y in -- #23
-//│     let x$6 = x$1.x in -- #22
-//│     jump j$1(3,x$0) -- #21
-//│   B =>
-//│     let x$7 = x$1.n in -- #32
-//│     let x$8 = x$1.m in -- #31
-//│     jump j$1(4,x$0) -- #30
-//│ )
-//│ Def(3, bar, [],
-//│ 1, 
-//│ let x$17 = A(6,7,8) in -- #89
-//│ let* (x$18) = complex_foo(x$17) in -- #88
-//│ let x$19 = B(9,10) in -- #87
-//│ let* (x$20) = complex_foo(x$19) in -- #86
-//│ x$20 -- #85
-//│ )
-//│ },
-//│ let* (x$21) = bar() in -- #93
-//│ x$21 -- #92)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, A, [x,y,z]),ClassInfo(1, B, [m,n])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [x,y,z]),ClassInfo(3, B, [m,n])}, {
 //│ Def(0, complex_foo, [t$0],
 //│ 1, 
 //│ case t$0 of -- #63
@@ -159,106 +110,8 @@ bar()
 //│ |#class| |A|(|w|,| |x|)|↵|#class| |B|(|y|)|↵|#class| |C|(|z|)|↵|#fun| |complex_foo|(|t|)| |#=|→|#let| |a| |#=| |1| |+| |2|↵|#let| |b| |#=| |1| |*| |2|↵|#let| |x| |#=| |#if| |t| |is|→|A|(|x|,| |y|)| |#then| |y|↵|B|(|x|)| |#then| |B|(|x| |+| |b|)|↵|C|(|x|)| |#then| |C|(|0|)|←|↵|#let| |z| |#=| |A|(|5|,| |x|)|↵|#let| |v| |#=| |B|(|6|)|↵|#let| |y| |#=| |#if| |x| |is|→|A|(|x|,| |y|)| |#then|→|#let| |m| |#=| |x| |+| |a| |+| |b|↵|#if| |y| |is|→|A|(|x|,| |y|)| |#then| |x|↵|B|(|x|)| |#then| |m|↵|C|(|x|)| |#then| |0|←|←|↵|B|(|x|)| |#then| |2|↵|C|(|x|)| |#then| |3|←|↵|#if| |z| |is|→|A|(|x|,| |y|)| |#then| |x|↵|B|(|x|)| |#then| |4|↵|C|(|x|)| |#then|→|#if| |v| |is|→|A|(|x|,| |y|)| |#then| |x|↵|B|(|x|)| |#then| |7|↵|C|(|x|)| |#then| |8|←|←|←|←|↵|#fun| |bar|(||)| |#=|→|complex_foo|(|A|(|10|,| |A|(|9|,| |B|(|10|)|)|)|)|←|↵|bar|(||)|
 //│ Parsed: {class A(w, x,) {}; class B(y,) {}; class C(z,) {}; fun complex_foo = (t,) => {let a = +(1,)(2,); let b = *(1,)(2,); let x = if t is ‹(A(x, y,)) then y; (B(x,)) then B(+(x,)(b,),); (C(x,)) then C(0,)›; let z = A(5, x,); let v = B(6,); let y = if x is ‹(A(x, y,)) then {let m = +(+(x,)(a,),)(b,); if y is ‹(A(x, y,)) then x; (B(x,)) then m; (C(x,)) then 0›}; (B(x,)) then 2; (C(x,)) then 3›; if z is ‹(A(x, y,)) then x; (B(x,)) then 4; (C(x,)) then {if v is ‹(A(x, y,)) then x; (B(x,)) then 7; (C(x,)) then 8›}›}; fun bar = () => {complex_foo(A(10, A(9, B(10,),),),)}; bar()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, A, [w,x]),ClassInfo(1, B, [y]),ClassInfo(2, C, [z])}, {
-//│ Def(0, complex_foo, [t$0],
-//│ 1, 
-//│ let x$0 = +(1,2) in -- #140
-//│ let x$1 = *(1,2) in -- #139
-//│ case t$0 of -- #138
-//│   A =>
-//│     let x$27 = t$0.x in -- #116
-//│     let x$28 = t$0.w in -- #115
-//│     jump j$0(x$27,x$0,x$1) -- #114
-//│   B =>
-//│     let x$29 = t$0.y in -- #128
-//│     let x$30 = +(x$29,x$1) in -- #127
-//│     let x$31 = B(x$30) in -- #126
-//│     jump j$0(x$31,x$0,x$1) -- #125
-//│   C =>
-//│     let x$32 = t$0.z in -- #137
-//│     let x$33 = C(0) in -- #136
-//│     jump j$0(x$33,x$0,x$1) -- #135
-//│ )
-//│ Def(1, j$2, [x$6],
-//│ 1, 
-//│ x$6 -- #21
-//│ )
-//│ Def(2, j$3, [x$11],
-//│ 1, 
-//│ jump j$2(x$11) -- #39
-//│ )
-//│ Def(3, j$1, [x$5,x$3,x$4],
-//│ 1, 
-//│ case x$3 of -- #60
-//│   A =>
-//│     let x$7 = x$3.x in -- #29
-//│     let x$8 = x$3.w in -- #28
-//│     jump j$2(x$8) -- #27
-//│   B =>
-//│     let x$9 = x$3.y in -- #34
-//│     jump j$2(4) -- #33
-//│   C =>
-//│     let x$10 = x$3.z in -- #59
-//│     case x$4 of -- #58
-//│       A =>
-//│         let x$12 = x$4.x in -- #47
-//│         let x$13 = x$4.w in -- #46
-//│         jump j$3(x$13) -- #45
-//│       B =>
-//│         let x$14 = x$4.y in -- #52
-//│         jump j$3(7) -- #51
-//│       C =>
-//│         let x$15 = x$4.z in -- #57
-//│         jump j$3(8) -- #56
-//│ )
-//│ Def(4, j$4, [x$20,x$3,x$4],
-//│ 1, 
-//│ jump j$1(x$20,x$3,x$4) -- #72
-//│ )
-//│ Def(5, j$0, [x$2,x$0,x$1],
-//│ 1, 
-//│ let x$3 = A(5,x$2) in -- #108
-//│ let x$4 = B(6) in -- #107
-//│ case x$2 of -- #106
-//│   A =>
-//│     let x$16 = x$2.x in -- #95
-//│     let x$17 = x$2.w in -- #94
-//│     let x$18 = +(x$17,x$0) in -- #93
-//│     let x$19 = +(x$18,x$1) in -- #92
-//│     case x$16 of -- #91
-//│       A =>
-//│         let x$21 = x$16.x in -- #80
-//│         let x$22 = x$16.w in -- #79
-//│         jump j$4(x$22,x$3,x$4) -- #78
-//│       B =>
-//│         let x$23 = x$16.y in -- #85
-//│         jump j$4(x$19,x$3,x$4) -- #84
-//│       C =>
-//│         let x$24 = x$16.z in -- #90
-//│         jump j$4(0,x$3,x$4) -- #89
-//│   B =>
-//│     let x$25 = x$2.y in -- #100
-//│     jump j$1(2,x$3,x$4) -- #99
-//│   C =>
-//│     let x$26 = x$2.z in -- #105
-//│     jump j$1(3,x$3,x$4) -- #104
-//│ )
-//│ Def(6, bar, [],
-//│ 1, 
-//│ let x$34 = B(10) in -- #162
-//│ let x$35 = A(9,x$34) in -- #161
-//│ let x$36 = A(10,x$35) in -- #160
-//│ let* (x$37) = complex_foo(x$36) in -- #159
-//│ x$37 -- #158
-//│ )
-//│ },
-//│ let* (x$38) = bar() in -- #166
-//│ x$38 -- #165)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, A, [w,x]),ClassInfo(1, B, [y]),ClassInfo(2, C, [z])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [w,x]),ClassInfo(3, B, [y]),ClassInfo(4, C, [z])}, {
 //│ Def(0, complex_foo, [t$0],
 //│ 1, 
 //│ let x$0 = +(1,2) in -- #140
@@ -393,108 +246,8 @@ bar()
 //│ |#class| |A|(|w|,| |x|)|↵|#class| |B|(|y|)|↵|#class| |C|(|z|)|↵|#fun| |complex_foo|(|t|)| |#=|→|#let| |a| |#=| |1| |+| |2|↵|#let| |b| |#=| |1| |*| |2|↵|#let| |x| |#=| |#if| |t| |is|→|A|(|x|,| |y|)| |#then| |A|(|x|,| |C|(|0|)|)|↵|B|(|x|)| |#then| |B|(|x| |+| |b|)|↵|C|(|x|)| |#then| |C|(|0|)|←|↵|#let| |z| |#=| |A|(|5|,| |x|)|↵|#let| |v| |#=| |B|(|6|)|↵|#let| |y| |#=| |#if| |x| |is|→|A|(|x|,| |y|)| |#then|→|#let| |m| |#=| |x| |+| |a| |+| |b|↵|#if| |y| |is|→|A|(|x|,| |y|)| |#then| |x|↵|B|(|x|)| |#then| |m|↵|C|(|x|)| |#then| |0|←|←|↵|B|(|x|)| |#then| |2|↵|C|(|x|)| |#then| |3|←|↵|#if| |z| |is|→|A|(|x|,| |y|)| |#then| |x|↵|B|(|x|)| |#then| |4|↵|C|(|x|)| |#then|→|#if| |v| |is|→|A|(|x|,| |y|)| |#then| |x|↵|B|(|x|)| |#then| |7|↵|C|(|x|)| |#then| |8|←|←|←|←|↵|#fun| |bar|(||)| |#=|→|complex_foo|(|A|(|10|,| |A|(|9|,| |B|(|10|)|)|)|)|←|↵|bar|(||)|
 //│ Parsed: {class A(w, x,) {}; class B(y,) {}; class C(z,) {}; fun complex_foo = (t,) => {let a = +(1,)(2,); let b = *(1,)(2,); let x = if t is ‹(A(x, y,)) then A(x, C(0,),); (B(x,)) then B(+(x,)(b,),); (C(x,)) then C(0,)›; let z = A(5, x,); let v = B(6,); let y = if x is ‹(A(x, y,)) then {let m = +(+(x,)(a,),)(b,); if y is ‹(A(x, y,)) then x; (B(x,)) then m; (C(x,)) then 0›}; (B(x,)) then 2; (C(x,)) then 3›; if z is ‹(A(x, y,)) then x; (B(x,)) then 4; (C(x,)) then {if v is ‹(A(x, y,)) then x; (B(x,)) then 7; (C(x,)) then 8›}›}; fun bar = () => {complex_foo(A(10, A(9, B(10,),),),)}; bar()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, A, [w,x]),ClassInfo(1, B, [y]),ClassInfo(2, C, [z])}, {
-//│ Def(0, complex_foo, [t$0],
-//│ 1, 
-//│ let x$0 = +(1,2) in -- #150
-//│ let x$1 = *(1,2) in -- #149
-//│ case t$0 of -- #148
-//│   A =>
-//│     let x$27 = t$0.x in -- #126
-//│     let x$28 = t$0.w in -- #125
-//│     let x$29 = C(0) in -- #124
-//│     let x$30 = A(x$28,x$29) in -- #123
-//│     jump j$0(x$30,x$0,x$1) -- #122
-//│   B =>
-//│     let x$31 = t$0.y in -- #138
-//│     let x$32 = +(x$31,x$1) in -- #137
-//│     let x$33 = B(x$32) in -- #136
-//│     jump j$0(x$33,x$0,x$1) -- #135
-//│   C =>
-//│     let x$34 = t$0.z in -- #147
-//│     let x$35 = C(0) in -- #146
-//│     jump j$0(x$35,x$0,x$1) -- #145
-//│ )
-//│ Def(1, j$2, [x$6],
-//│ 1, 
-//│ x$6 -- #21
-//│ )
-//│ Def(2, j$3, [x$11],
-//│ 1, 
-//│ jump j$2(x$11) -- #39
-//│ )
-//│ Def(3, j$1, [x$5,x$3,x$4],
-//│ 1, 
-//│ case x$3 of -- #60
-//│   A =>
-//│     let x$7 = x$3.x in -- #29
-//│     let x$8 = x$3.w in -- #28
-//│     jump j$2(x$8) -- #27
-//│   B =>
-//│     let x$9 = x$3.y in -- #34
-//│     jump j$2(4) -- #33
-//│   C =>
-//│     let x$10 = x$3.z in -- #59
-//│     case x$4 of -- #58
-//│       A =>
-//│         let x$12 = x$4.x in -- #47
-//│         let x$13 = x$4.w in -- #46
-//│         jump j$3(x$13) -- #45
-//│       B =>
-//│         let x$14 = x$4.y in -- #52
-//│         jump j$3(7) -- #51
-//│       C =>
-//│         let x$15 = x$4.z in -- #57
-//│         jump j$3(8) -- #56
-//│ )
-//│ Def(4, j$4, [x$20,x$3,x$4],
-//│ 1, 
-//│ jump j$1(x$20,x$3,x$4) -- #72
-//│ )
-//│ Def(5, j$0, [x$2,x$0,x$1],
-//│ 1, 
-//│ let x$3 = A(5,x$2) in -- #108
-//│ let x$4 = B(6) in -- #107
-//│ case x$2 of -- #106
-//│   A =>
-//│     let x$16 = x$2.x in -- #95
-//│     let x$17 = x$2.w in -- #94
-//│     let x$18 = +(x$17,x$0) in -- #93
-//│     let x$19 = +(x$18,x$1) in -- #92
-//│     case x$16 of -- #91
-//│       A =>
-//│         let x$21 = x$16.x in -- #80
-//│         let x$22 = x$16.w in -- #79
-//│         jump j$4(x$22,x$3,x$4) -- #78
-//│       B =>
-//│         let x$23 = x$16.y in -- #85
-//│         jump j$4(x$19,x$3,x$4) -- #84
-//│       C =>
-//│         let x$24 = x$16.z in -- #90
-//│         jump j$4(0,x$3,x$4) -- #89
-//│   B =>
-//│     let x$25 = x$2.y in -- #100
-//│     jump j$1(2,x$3,x$4) -- #99
-//│   C =>
-//│     let x$26 = x$2.z in -- #105
-//│     jump j$1(3,x$3,x$4) -- #104
-//│ )
-//│ Def(6, bar, [],
-//│ 1, 
-//│ let x$36 = B(10) in -- #172
-//│ let x$37 = A(9,x$36) in -- #171
-//│ let x$38 = A(10,x$37) in -- #170
-//│ let* (x$39) = complex_foo(x$38) in -- #169
-//│ x$39 -- #168
-//│ )
-//│ },
-//│ let* (x$40) = bar() in -- #176
-//│ x$40 -- #175)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, A, [w,x]),ClassInfo(1, B, [y]),ClassInfo(2, C, [z])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [w,x]),ClassInfo(3, B, [y]),ClassInfo(4, C, [z])}, {
 //│ Def(0, complex_foo, [t$0],
 //│ 1, 
 //│ let x$0 = +(1,2) in -- #150
diff --git a/compiler/shared/test/diff-ir/IRRec.mls b/compiler/shared/test/diff-ir/IRRec.mls
index 0275612d6a..a56f53a9e7 100644
--- a/compiler/shared/test/diff-ir/IRRec.mls
+++ b/compiler/shared/test/diff-ir/IRRec.mls
@@ -1,6 +1,7 @@
 :NewParser
 :ParseOnly
 :UseIR
+:NoTailRec
 
 :interpIR
 class True
@@ -10,33 +11,8 @@ fib(20)
 //│ |#class| |True|↵|#class| |False|↵|#fun| |fib|(|n|)| |#=| |#if| |n| |<| |2| |#then| |n| |#else| |fib|(|n|-|1|)| |+| |fib|(|n|-|2|)|↵|fib|(|20|)|
 //│ Parsed: {class True {}; class False {}; fun fib = (n,) => if (<(n,)(2,)) then n else +(fib(-(n,)(1,),),)(fib(-(n,)(2,),),); fib(20,)}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
-//│ Def(0, fib, [n$0],
-//│ 1, 
-//│ let x$0 = <(n$0,2) in -- #28
-//│ if x$0 -- #27
-//│   true =>
-//│     jump j$0(n$0) -- #5
-//│   false =>
-//│     let x$2 = -(n$0,1) in -- #26
-//│     let* (x$3) = fib(x$2) in -- #25
-//│     let x$4 = -(n$0,2) in -- #24
-//│     let* (x$5) = fib(x$4) in -- #23
-//│     let x$6 = +(x$3,x$5) in -- #22
-//│     jump j$0(x$6) -- #21
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #3
-//│ )
-//│ },
-//│ let* (x$7) = fib(20) in -- #34
-//│ x$7 -- #33)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, [])}, {
 //│ Def(0, fib, [n$0],
 //│ 1, 
 //│ let x$0 = <(n$0,2) in -- #28
@@ -72,52 +48,8 @@ foo()
 //│ |#class| |True|↵|#class| |False|↵|#fun| |odd|(|x|)| |#=| |#if| |x| |==| |0| |#then| |False| |#else| |even|(|x|-|1|)|↵|#fun| |even|(|x|)| |#=| |#if| |x| |==| |0| |#then| |True| |#else| |odd|(|x|-|1|)|↵|#fun| |foo|(||)| |#=| |odd|(|10|)|↵|foo|(||)|
 //│ Parsed: {class True {}; class False {}; fun odd = (x,) => if (==(x,)(0,)) then False else even(-(x,)(1,),); fun even = (x,) => if (==(x,)(0,)) then True else odd(-(x,)(1,),); fun foo = () => odd(10,); foo()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
-//│ Def(0, odd, [x$0],
-//│ 1, 
-//│ let x$1 = ==(x$0,0) in -- #18
-//│ if x$1 -- #17
-//│   true =>
-//│     let x$3 = False() in -- #6
-//│     jump j$0(x$3) -- #5
-//│   false =>
-//│     let x$4 = -(x$0,1) in -- #16
-//│     let* (x$5) = even(x$4) in -- #15
-//│     jump j$0(x$5) -- #14
-//│ )
-//│ Def(1, j$0, [x$2],
-//│ 1, 
-//│ x$2 -- #3
-//│ )
-//│ Def(2, even, [x$6],
-//│ 1, 
-//│ let x$7 = ==(x$6,0) in -- #37
-//│ if x$7 -- #36
-//│   true =>
-//│     let x$9 = True() in -- #25
-//│     jump j$1(x$9) -- #24
-//│   false =>
-//│     let x$10 = -(x$6,1) in -- #35
-//│     let* (x$11) = odd(x$10) in -- #34
-//│     jump j$1(x$11) -- #33
-//│ )
-//│ Def(3, j$1, [x$8],
-//│ 1, 
-//│ x$8 -- #22
-//│ )
-//│ Def(4, foo, [],
-//│ 1, 
-//│ let* (x$12) = odd(10) in -- #43
-//│ x$12 -- #42
-//│ )
-//│ },
-//│ let* (x$13) = foo() in -- #47
-//│ x$13 -- #46)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, [])}, {
 //│ Def(0, odd, [x$0],
 //│ 1, 
 //│ let x$1 = ==(x$0,0) in -- #18
@@ -177,51 +109,8 @@ main()
 //│ |#class| |True|↵|#class| |False|↵|#class| |A|↵|#class| |B|(|b|)|↵|#fun| |not|(|x|)| |#=|→|#if| |x| |#then| |False| |#else| |True|←|↵|#fun| |foo|(|x|)| |#=|→|#if| |x| |#then| |A|→|#else| |B|(|foo|(|not|(|x|)|)|)|←|←|↵|#fun| |main|(||)| |#=| |foo|(|False|)|↵|main|(||)|
 //│ Parsed: {class True {}; class False {}; class A {}; class B(b,) {}; fun not = (x,) => {if (x) then False else True}; fun foo = (x,) => {if (x) then A else B(foo(not(x,),),)}; fun main = () => foo(False,); main()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, []),ClassInfo(3, B, [b])}, {
-//│ Def(0, not, [x$0],
-//│ 1, 
-//│ if x$0 -- #8
-//│   true =>
-//│     let x$2 = False() in -- #4
-//│     jump j$0(x$2) -- #3
-//│   false =>
-//│     let x$3 = True() in -- #7
-//│     jump j$0(x$3) -- #6
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #1
-//│ )
-//│ Def(2, foo, [x$4],
-//│ 1, 
-//│ if x$4 -- #30
-//│   true =>
-//│     let x$6 = A() in -- #13
-//│     jump j$1(x$6) -- #12
-//│   false =>
-//│     let* (x$7) = not(x$4) in -- #29
-//│     let* (x$8) = foo(x$7) in -- #28
-//│     let x$9 = B(x$8) in -- #27
-//│     jump j$1(x$9) -- #26
-//│ )
-//│ Def(3, j$1, [x$5],
-//│ 1, 
-//│ x$5 -- #10
-//│ )
-//│ Def(4, main, [],
-//│ 1, 
-//│ let x$10 = False() in -- #37
-//│ let* (x$11) = foo(x$10) in -- #36
-//│ x$11 -- #35
-//│ )
-//│ },
-//│ let* (x$12) = main() in -- #41
-//│ x$12 -- #40)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, []),ClassInfo(3, B, [b])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, A, []),ClassInfo(5, B, [b])}, {
 //│ Def(0, not, [x$0],
 //│ 1, 
 //│ if x$0 -- #8
@@ -293,80 +182,8 @@ main()
 //│ |#class| |True|↵|#class| |False|↵|#class| |A|(||)|↵|#class| |B|(|b|)|↵|#fun| |aaa|(||)| |#=|→|#let| |m| |#=| |1|↵|#let| |n| |#=| |2|↵|#let| |p| |#=| |3|↵|#let| |q| |#=| |4|↵|m| |+| |n| |-| |p| |+| |q|←|↵|#fun| |bbb|(||)| |#=|→|#let| |x| |#=| |aaa|(||)|↵|x| |*| |100| |+| |4|←|↵|#fun| |not|(|x|)| |#=|→|#if| |x| |#then| |False| |#else| |True|←|↵|#fun| |foo|(|x|)| |#=|→|#if| |x| |#then| |A|→|#else| |B|(|foo|(|not|(|x|)|)|)|←|←|↵|#fun| |main|(||)| |#=|→|#let| |x| |#=| |foo|(|False|)|↵|#if| |x| |is|→|A| |#then| |aaa|(||)|↵|B|(|b1|)| |#then| |bbb|(||)|←|←|↵|main|(||)|
 //│ Parsed: {class True {}; class False {}; class A() {}; class B(b,) {}; fun aaa = () => {let m = 1; let n = 2; let p = 3; let q = 4; +(-(+(m,)(n,),)(p,),)(q,)}; fun bbb = () => {let x = aaa(); +(*(x,)(100,),)(4,)}; fun not = (x,) => {if (x) then False else True}; fun foo = (x,) => {if (x) then A else B(foo(not(x,),),)}; fun main = () => {let x = foo(False,); if x is ‹(A) then aaa(); (B(b1,)) then bbb()›}; main()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, []),ClassInfo(3, B, [b])}, {
-//│ Def(0, aaa, [],
-//│ 1, 
-//│ let x$0 = 1 in -- #17
-//│ let x$1 = 2 in -- #16
-//│ let x$2 = 3 in -- #15
-//│ let x$3 = 4 in -- #14
-//│ let x$4 = +(x$0,x$1) in -- #13
-//│ let x$5 = -(x$4,x$2) in -- #12
-//│ let x$6 = +(x$5,x$3) in -- #11
-//│ x$6 -- #10
-//│ )
-//│ Def(1, bbb, [],
-//│ 1, 
-//│ let* (x$7) = aaa() in -- #28
-//│ let x$8 = *(x$7,100) in -- #27
-//│ let x$9 = +(x$8,4) in -- #26
-//│ x$9 -- #25
-//│ )
-//│ Def(2, not, [x$10],
-//│ 1, 
-//│ if x$10 -- #37
-//│   true =>
-//│     let x$12 = False() in -- #33
-//│     jump j$0(x$12) -- #32
-//│   false =>
-//│     let x$13 = True() in -- #36
-//│     jump j$0(x$13) -- #35
-//│ )
-//│ Def(3, j$0, [x$11],
-//│ 1, 
-//│ x$11 -- #30
-//│ )
-//│ Def(4, foo, [x$14],
-//│ 1, 
-//│ if x$14 -- #59
-//│   true =>
-//│     let x$16 = A() in -- #42
-//│     jump j$1(x$16) -- #41
-//│   false =>
-//│     let* (x$17) = not(x$14) in -- #58
-//│     let* (x$18) = foo(x$17) in -- #57
-//│     let x$19 = B(x$18) in -- #56
-//│     jump j$1(x$19) -- #55
-//│ )
-//│ Def(5, j$1, [x$15],
-//│ 1, 
-//│ x$15 -- #39
-//│ )
-//│ Def(6, main, [],
-//│ 1, 
-//│ let x$20 = False() in -- #82
-//│ let* (x$21) = foo(x$20) in -- #81
-//│ case x$21 of -- #80
-//│   A =>
-//│     let* (x$23) = aaa() in -- #71
-//│     jump j$2(x$23) -- #70
-//│   B =>
-//│     let x$24 = x$21.b in -- #79
-//│     let* (x$25) = bbb() in -- #78
-//│     jump j$2(x$25) -- #77
-//│ )
-//│ Def(7, j$2, [x$22],
-//│ 1, 
-//│ x$22 -- #66
-//│ )
-//│ },
-//│ let* (x$26) = main() in -- #86
-//│ x$26 -- #85)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, []),ClassInfo(3, B, [b])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, A, []),ClassInfo(5, B, [b])}, {
 //│ Def(0, aaa, [],
 //│ 1, 
 //│ let x$0 = 1 in -- #17
@@ -458,54 +275,8 @@ foo()
 //│ |#class| |True|↵|#class| |False|↵|#class| |S|(|s|)|↵|#class| |O|↵|#fun| |odd|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |False|↵|S|(|s|)| |#then| |even|(|s|)|←|←|↵|#fun| |even|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |True|↵|S|(|s|)| |#then| |odd|(|s|)|←|←|↵|#fun| |foo|(||)| |#=| |odd|(|S|(|S|(|S|(|O|)|)|)|)|↵|foo|(||)|
 //│ Parsed: {class True {}; class False {}; class S(s,) {}; class O {}; fun odd = (x,) => {if x is ‹(O) then False; (S(s,)) then even(s,)›}; fun even = (x,) => {if x is ‹(O) then True; (S(s,)) then odd(s,)›}; fun foo = () => odd(S(S(S(O,),),),); foo()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, S, [s]),ClassInfo(3, O, [])}, {
-//│ Def(0, odd, [x$0],
-//│ 1, 
-//│ case x$0 of -- #15
-//│   O =>
-//│     let x$2 = False() in -- #4
-//│     jump j$0(x$2) -- #3
-//│   S =>
-//│     let x$3 = x$0.s in -- #14
-//│     let* (x$4) = even(x$3) in -- #13
-//│     jump j$0(x$4) -- #12
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #1
-//│ )
-//│ Def(2, even, [x$5],
-//│ 1, 
-//│ case x$5 of -- #31
-//│   O =>
-//│     let x$7 = True() in -- #20
-//│     jump j$1(x$7) -- #19
-//│   S =>
-//│     let x$8 = x$5.s in -- #30
-//│     let* (x$9) = odd(x$8) in -- #29
-//│     jump j$1(x$9) -- #28
-//│ )
-//│ Def(3, j$1, [x$6],
-//│ 1, 
-//│ x$6 -- #17
-//│ )
-//│ Def(4, foo, [],
-//│ 1, 
-//│ let x$10 = O() in -- #50
-//│ let x$11 = S(x$10) in -- #49
-//│ let x$12 = S(x$11) in -- #48
-//│ let x$13 = S(x$12) in -- #47
-//│ let* (x$14) = odd(x$13) in -- #46
-//│ x$14 -- #45
-//│ )
-//│ },
-//│ let* (x$15) = foo() in -- #54
-//│ x$15 -- #53)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, S, [s]),ClassInfo(3, O, [])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, S, [s]),ClassInfo(5, O, [])}, {
 //│ Def(0, odd, [x$0],
 //│ 1, 
 //│ case x$0 of -- #15
@@ -571,9 +342,8 @@ foo()
 //│ |#class| |True|↵|#class| |False|↵|#class| |S|(|s|)|↵|#class| |O|↵|#fun| |odd|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |False|↵|S|(|s|)| |#then| |even|(|s|)|←|←|↵|#fun| |even|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |True|↵|S|(|s|)| |#then| |odd|(|s|)|←|←|↵|#fun| |mk|(|n|)| |#=| |#if| |n| |>| |0| |#then| |S|(|mk|(|n| |-| |1|)|)| |#else| |O|↵|#fun| |foo|(||)| |#=| |odd|(|mk|(|10|)|)|↵|foo|(||)| |
 //│ Parsed: {class True {}; class False {}; class S(s,) {}; class O {}; fun odd = (x,) => {if x is ‹(O) then False; (S(s,)) then even(s,)›}; fun even = (x,) => {if x is ‹(O) then True; (S(s,)) then odd(s,)›}; fun mk = (n,) => if (>(n,)(0,)) then S(mk(-(n,)(1,),),) else O; fun foo = () => odd(mk(10,),); foo()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, S, [s]),ClassInfo(3, O, [])}, {
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, S, [s]),ClassInfo(5, O, [])}, {
 //│ Def(0, odd, [x$0],
 //│ 1, 
 //│ case x$0 of -- #15
@@ -631,8 +401,31 @@ foo()
 //│ let* (x$18) = foo() in -- #69
 //│ x$18 -- #68)
 //│ 
+//│ Interpreted:
+//│ 
+//│ IR Processing Failed: can not find the matched case, ClassInfo(0, True, []) expected
+
+:interpIR
+class True
+class False
+class S(s)
+class O
+fun odd(x) =
+  if x is
+    O then False
+    S(s) then even(s)
+fun even(x) =
+  if x is
+    O then True
+    S(s) then odd(s)
+fun mk(n) = if n > 0 then S(mk(n - 1)) else O
+fun foo() = odd(S(S(mk(10))))
+foo()
+//│ |#class| |True|↵|#class| |False|↵|#class| |S|(|s|)|↵|#class| |O|↵|#fun| |odd|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |False|↵|S|(|s|)| |#then| |even|(|s|)|←|←|↵|#fun| |even|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |True|↵|S|(|s|)| |#then| |odd|(|s|)|←|←|↵|#fun| |mk|(|n|)| |#=| |#if| |n| |>| |0| |#then| |S|(|mk|(|n| |-| |1|)|)| |#else| |O|↵|#fun| |foo|(||)| |#=| |odd|(|S|(|S|(|mk|(|10|)|)|)|)|↵|foo|(||)|
+//│ Parsed: {class True {}; class False {}; class S(s,) {}; class O {}; fun odd = (x,) => {if x is ‹(O) then False; (S(s,)) then even(s,)›}; fun even = (x,) => {if x is ‹(O) then True; (S(s,)) then odd(s,)›}; fun mk = (n,) => if (>(n,)(0,)) then S(mk(-(n,)(1,),),) else O; fun foo = () => odd(S(S(mk(10,),),),); foo()}
+//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, S, [s]),ClassInfo(3, O, [])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, S, [s]),ClassInfo(5, O, [])}, {
 //│ Def(0, odd, [x$0],
 //│ 1, 
 //│ case x$0 of -- #15
@@ -682,161 +475,19 @@ foo()
 //│ )
 //│ Def(6, foo, [],
 //│ 1, 
-//│ let* (x$16) = mk(10) in -- #65
-//│ let* (x$17) = odd(x$16) in -- #64
-//│ x$17 -- #63
+//│ let* (x$16) = mk(10) in -- #73
+//│ let x$17 = S(x$16) in -- #72
+//│ let x$18 = S(x$17) in -- #71
+//│ let* (x$19) = odd(x$18) in -- #70
+//│ x$19 -- #69
 //│ )
 //│ },
-//│ let* (x$18) = foo() in -- #69
-//│ x$18 -- #68)
+//│ let* (x$20) = foo() in -- #77
+//│ x$20 -- #76)
 //│ 
 //│ Interpreted:
-//│ False()
-
-:interpIR
-class True
-class False
-class S(s)
-class O
-fun odd(x) =
-  if x is
-    O then False
-    S(s) then even(s)
-fun even(x) =
-  if x is
-    O then True
-    S(s) then odd(s)
-fun mk(n) = if n > 0 then S(mk(n - 1)) else O
-fun foo() = odd(S(S(mk(10))))
-foo()
-//│ |#class| |True|↵|#class| |False|↵|#class| |S|(|s|)|↵|#class| |O|↵|#fun| |odd|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |False|↵|S|(|s|)| |#then| |even|(|s|)|←|←|↵|#fun| |even|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |True|↵|S|(|s|)| |#then| |odd|(|s|)|←|←|↵|#fun| |mk|(|n|)| |#=| |#if| |n| |>| |0| |#then| |S|(|mk|(|n| |-| |1|)|)| |#else| |O|↵|#fun| |foo|(||)| |#=| |odd|(|S|(|S|(|mk|(|10|)|)|)|)|↵|foo|(||)|
-//│ Parsed: {class True {}; class False {}; class S(s,) {}; class O {}; fun odd = (x,) => {if x is ‹(O) then False; (S(s,)) then even(s,)›}; fun even = (x,) => {if x is ‹(O) then True; (S(s,)) then odd(s,)›}; fun mk = (n,) => if (>(n,)(0,)) then S(mk(-(n,)(1,),),) else O; fun foo = () => odd(S(S(mk(10,),),),); foo()}
-//│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, S, [s]),ClassInfo(3, O, [])}, {
-//│ Def(0, odd, [x$0],
-//│ 1, 
-//│ case x$0 of -- #15
-//│   O =>
-//│     let x$2 = False() in -- #4
-//│     jump j$0(x$2) -- #3
-//│   S =>
-//│     let x$3 = x$0.s in -- #14
-//│     let* (x$4) = even(x$3) in -- #13
-//│     jump j$0(x$4) -- #12
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #1
-//│ )
-//│ Def(2, even, [x$5],
-//│ 1, 
-//│ case x$5 of -- #31
-//│   O =>
-//│     let x$7 = True() in -- #20
-//│     jump j$1(x$7) -- #19
-//│   S =>
-//│     let x$8 = x$5.s in -- #30
-//│     let* (x$9) = odd(x$8) in -- #29
-//│     jump j$1(x$9) -- #28
-//│ )
-//│ Def(3, j$1, [x$6],
-//│ 1, 
-//│ x$6 -- #17
-//│ )
-//│ Def(4, mk, [n$0],
-//│ 1, 
-//│ let x$10 = >(n$0,0) in -- #54
-//│ if x$10 -- #53
-//│   true =>
-//│     let x$12 = -(n$0,1) in -- #49
-//│     let* (x$13) = mk(x$12) in -- #48
-//│     let x$14 = S(x$13) in -- #47
-//│     jump j$2(x$14) -- #46
-//│   false =>
-//│     let x$15 = O() in -- #52
-//│     jump j$2(x$15) -- #51
-//│ )
-//│ Def(5, j$2, [x$11],
-//│ 1, 
-//│ x$11 -- #35
-//│ )
-//│ Def(6, foo, [],
-//│ 1, 
-//│ let* (x$16) = mk(10) in -- #73
-//│ let x$17 = S(x$16) in -- #72
-//│ let x$18 = S(x$17) in -- #71
-//│ let* (x$19) = odd(x$18) in -- #70
-//│ x$19 -- #69
-//│ )
-//│ },
-//│ let* (x$20) = foo() in -- #77
-//│ x$20 -- #76)
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, S, [s]),ClassInfo(3, O, [])}, {
-//│ Def(0, odd, [x$0],
-//│ 1, 
-//│ case x$0 of -- #15
-//│   O =>
-//│     let x$2 = False() in -- #4
-//│     jump j$0(x$2) -- #3
-//│   S =>
-//│     let x$3 = x$0.s in -- #14
-//│     let* (x$4) = even(x$3) in -- #13
-//│     jump j$0(x$4) -- #12
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #1
-//│ )
-//│ Def(2, even, [x$5],
-//│ 1, 
-//│ case x$5 of -- #31
-//│   O =>
-//│     let x$7 = True() in -- #20
-//│     jump j$1(x$7) -- #19
-//│   S =>
-//│     let x$8 = x$5.s in -- #30
-//│     let* (x$9) = odd(x$8) in -- #29
-//│     jump j$1(x$9) -- #28
-//│ )
-//│ Def(3, j$1, [x$6],
-//│ 1, 
-//│ x$6 -- #17
-//│ )
-//│ Def(4, mk, [n$0],
-//│ 1, 
-//│ let x$10 = >(n$0,0) in -- #54
-//│ if x$10 -- #53
-//│   true =>
-//│     let x$12 = -(n$0,1) in -- #49
-//│     let* (x$13) = mk(x$12) in -- #48
-//│     let x$14 = S(x$13) in -- #47
-//│     jump j$2(x$14) -- #46
-//│   false =>
-//│     let x$15 = O() in -- #52
-//│     jump j$2(x$15) -- #51
-//│ )
-//│ Def(5, j$2, [x$11],
-//│ 1, 
-//│ x$11 -- #35
-//│ )
-//│ Def(6, foo, [],
-//│ 1, 
-//│ let* (x$16) = mk(10) in -- #73
-//│ let x$17 = S(x$16) in -- #72
-//│ let x$18 = S(x$17) in -- #71
-//│ let* (x$19) = odd(x$18) in -- #70
-//│ x$19 -- #69
-//│ )
-//│ },
-//│ let* (x$20) = foo() in -- #77
-//│ x$20 -- #76)
 //│ 
-//│ Interpreted:
-//│ False()
+//│ IR Processing Failed: can not find the matched case, ClassInfo(0, True, []) expected
 
 :interpIR
 class True
@@ -860,86 +511,8 @@ main()
 //│ |#class| |True|↵|#class| |False|↵|#class| |S|(|s|)|↵|#class| |O|↵|#fun| |odd|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |False|↵|S|(|s|)| |#then| |even|(|s|)|←|←|↵|#fun| |even|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |True|↵|S|(|s|)| |#then| |odd|(|s|)|←|←|↵|#fun| |foo|(||)| |#=| |odd|(|#if| |10| |>| |0| |#then| |S|(|O|)| |#else| |O|)|↵|#fun| |bar|(||)| |#=| |#if| |10| |>| |0| |#then| |odd|(|S|(|O|)|)| |#else| |odd|(|O|)|↵|#fun| |main|(||)| |#=|→|foo|(||)|↵|bar|(||)|←|↵|main|(||)|
 //│ Parsed: {class True {}; class False {}; class S(s,) {}; class O {}; fun odd = (x,) => {if x is ‹(O) then False; (S(s,)) then even(s,)›}; fun even = (x,) => {if x is ‹(O) then True; (S(s,)) then odd(s,)›}; fun foo = () => odd(if (>(10,)(0,)) then S(O,) else O,); fun bar = () => if (>(10,)(0,)) then odd(S(O,),) else odd(O,); fun main = () => {foo(); bar()}; main()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, S, [s]),ClassInfo(3, O, [])}, {
-//│ Def(0, odd, [x$0],
-//│ 1, 
-//│ case x$0 of -- #15
-//│   O =>
-//│     let x$2 = False() in -- #4
-//│     jump j$0(x$2) -- #3
-//│   S =>
-//│     let x$3 = x$0.s in -- #14
-//│     let* (x$4) = even(x$3) in -- #13
-//│     jump j$0(x$4) -- #12
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #1
-//│ )
-//│ Def(2, even, [x$5],
-//│ 1, 
-//│ case x$5 of -- #31
-//│   O =>
-//│     let x$7 = True() in -- #20
-//│     jump j$1(x$7) -- #19
-//│   S =>
-//│     let x$8 = x$5.s in -- #30
-//│     let* (x$9) = odd(x$8) in -- #29
-//│     jump j$1(x$9) -- #28
-//│ )
-//│ Def(3, j$1, [x$6],
-//│ 1, 
-//│ x$6 -- #17
-//│ )
-//│ Def(4, foo, [],
-//│ 1, 
-//│ let x$10 = >(10,0) in -- #52
-//│ if x$10 -- #51
-//│   true =>
-//│     let x$13 = O() in -- #47
-//│     let x$14 = S(x$13) in -- #46
-//│     jump j$2(x$14) -- #45
-//│   false =>
-//│     let x$15 = O() in -- #50
-//│     jump j$2(x$15) -- #49
-//│ )
-//│ Def(5, j$2, [x$11],
-//│ 1, 
-//│ let* (x$12) = odd(x$11) in -- #40
-//│ x$12 -- #39
-//│ )
-//│ Def(6, bar, [],
-//│ 1, 
-//│ let x$16 = >(10,0) in -- #78
-//│ if x$16 -- #77
-//│   true =>
-//│     let x$18 = O() in -- #68
-//│     let x$19 = S(x$18) in -- #67
-//│     let* (x$20) = odd(x$19) in -- #66
-//│     jump j$3(x$20) -- #65
-//│   false =>
-//│     let x$21 = O() in -- #76
-//│     let* (x$22) = odd(x$21) in -- #75
-//│     jump j$3(x$22) -- #74
-//│ )
-//│ Def(7, j$3, [x$17],
-//│ 1, 
-//│ x$17 -- #56
-//│ )
-//│ Def(8, main, [],
-//│ 1, 
-//│ let* (x$23) = foo() in -- #86
-//│ let* (x$24) = bar() in -- #85
-//│ x$24 -- #84
-//│ )
-//│ },
-//│ let* (x$25) = main() in -- #90
-//│ x$25 -- #89)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, S, [s]),ClassInfo(3, O, [])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, S, [s]),ClassInfo(5, O, [])}, {
 //│ Def(0, odd, [x$0],
 //│ 1, 
 //│ case x$0 of -- #15
@@ -1016,7 +589,8 @@ main()
 //│ x$25 -- #89)
 //│ 
 //│ Interpreted:
-//│ True()
+//│ 
+//│ IR Processing Failed: can not find the matched case, ClassInfo(0, True, []) expected
 
 :interpIR
 class True
@@ -1045,80 +619,8 @@ main(False)
 //│ |#class| |True|↵|#class| |False|↵|#class| |A|(||)|↵|#class| |B|(|b|)|↵|#fun| |aaa|(||)| |#=|→|#let| |m| |#=| |1|↵|#let| |n| |#=| |2|↵|#let| |p| |#=| |3|↵|#let| |q| |#=| |4|↵|m| |+| |n| |-| |p| |+| |q|←|↵|#fun| |bbb|(||)| |#=|→|#let| |x| |#=| |aaa|(||)|↵|x| |*| |100| |+| |4|←|↵|#fun| |not|(|x|)| |#=|→|#if| |x| |#then| |False| |#else| |True|←|↵|#fun| |foo|(|x|)| |#=|→|#if| |x| |#then| |A| |#else| |B|(|foo|(|not|(|x|)|)|)|←|↵|#fun| |main|(|flag|)| |#=|→|#let| |x| |#=| |foo|(|flag|)|↵|#if| |x| |is|→|A| |#then| |aaa|(||)|↵|B|(|b1|)| |#then| |bbb|(||)|←|←|↵|main|(|False|)|
 //│ Parsed: {class True {}; class False {}; class A() {}; class B(b,) {}; fun aaa = () => {let m = 1; let n = 2; let p = 3; let q = 4; +(-(+(m,)(n,),)(p,),)(q,)}; fun bbb = () => {let x = aaa(); +(*(x,)(100,),)(4,)}; fun not = (x,) => {if (x) then False else True}; fun foo = (x,) => {if (x) then A else B(foo(not(x,),),)}; fun main = (flag,) => {let x = foo(flag,); if x is ‹(A) then aaa(); (B(b1,)) then bbb()›}; main(False,)}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, []),ClassInfo(3, B, [b])}, {
-//│ Def(0, aaa, [],
-//│ 1, 
-//│ let x$0 = 1 in -- #17
-//│ let x$1 = 2 in -- #16
-//│ let x$2 = 3 in -- #15
-//│ let x$3 = 4 in -- #14
-//│ let x$4 = +(x$0,x$1) in -- #13
-//│ let x$5 = -(x$4,x$2) in -- #12
-//│ let x$6 = +(x$5,x$3) in -- #11
-//│ x$6 -- #10
-//│ )
-//│ Def(1, bbb, [],
-//│ 1, 
-//│ let* (x$7) = aaa() in -- #28
-//│ let x$8 = *(x$7,100) in -- #27
-//│ let x$9 = +(x$8,4) in -- #26
-//│ x$9 -- #25
-//│ )
-//│ Def(2, not, [x$10],
-//│ 1, 
-//│ if x$10 -- #37
-//│   true =>
-//│     let x$12 = False() in -- #33
-//│     jump j$0(x$12) -- #32
-//│   false =>
-//│     let x$13 = True() in -- #36
-//│     jump j$0(x$13) -- #35
-//│ )
-//│ Def(3, j$0, [x$11],
-//│ 1, 
-//│ x$11 -- #30
-//│ )
-//│ Def(4, foo, [x$14],
-//│ 1, 
-//│ if x$14 -- #59
-//│   true =>
-//│     let x$16 = A() in -- #42
-//│     jump j$1(x$16) -- #41
-//│   false =>
-//│     let* (x$17) = not(x$14) in -- #58
-//│     let* (x$18) = foo(x$17) in -- #57
-//│     let x$19 = B(x$18) in -- #56
-//│     jump j$1(x$19) -- #55
-//│ )
-//│ Def(5, j$1, [x$15],
-//│ 1, 
-//│ x$15 -- #39
-//│ )
-//│ Def(6, main, [flag$0],
-//│ 1, 
-//│ let* (x$20) = foo(flag$0) in -- #81
-//│ case x$20 of -- #80
-//│   A =>
-//│     let* (x$22) = aaa() in -- #71
-//│     jump j$2(x$22) -- #70
-//│   B =>
-//│     let x$23 = x$20.b in -- #79
-//│     let* (x$24) = bbb() in -- #78
-//│     jump j$2(x$24) -- #77
-//│ )
-//│ Def(7, j$2, [x$21],
-//│ 1, 
-//│ x$21 -- #66
-//│ )
-//│ },
-//│ let x$25 = False() in -- #88
-//│ let* (x$26) = main(x$25) in -- #87
-//│ x$26 -- #86)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, []),ClassInfo(3, B, [b])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, A, []),ClassInfo(5, B, [b])}, {
 //│ Def(0, aaa, [],
 //│ 1, 
 //│ let x$0 = 1 in -- #17
@@ -1215,60 +717,8 @@ main()
 //│ |#class| |True|↵|#class| |False|↵|#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|#class| |Some|(|x|)|↵|#class| |None|↵|#fun| |head_opt|(|l|)| |#=|→|#if| |l| |is|→|Nil| |#then| |None|↵|Cons|(|h|,| |t|)| |#then| |Some|(|h|)|←|←|↵|#fun| |is_none|(|o|)| |#=|→|#if| |o| |is|→|None| |#then| |True|↵|Some|(|x|)| |#then| |False|←|←|↵|#fun| |is_empty|(|l|)| |#=|→|is_none|(|head_opt|(|l|)|)|←|↵|#fun| |main|(||)| |#=|→|is_empty|(|Cons|(|1|,| |Cons|(|2|,| |Nil|)|)|)|←|↵|main|(||)|
 //│ Parsed: {class True {}; class False {}; class Cons(h, t,) {}; class Nil {}; class Some(x,) {}; class None {}; fun head_opt = (l,) => {if l is ‹(Nil) then None; (Cons(h, t,)) then Some(h,)›}; fun is_none = (o,) => {if o is ‹(None) then True; (Some(x,)) then False›}; fun is_empty = (l,) => {is_none(head_opt(l,),)}; fun main = () => {is_empty(Cons(1, Cons(2, Nil,),),)}; main()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, Some, [x]),ClassInfo(5, None, [])}, {
-//│ Def(0, head_opt, [l$0],
-//│ 1, 
-//│ case l$0 of -- #17
-//│   Nil =>
-//│     let x$1 = None() in -- #4
-//│     jump j$0(x$1) -- #3
-//│   Cons =>
-//│     let x$2 = l$0.t in -- #16
-//│     let x$3 = l$0.h in -- #15
-//│     let x$4 = Some(x$3) in -- #14
-//│     jump j$0(x$4) -- #13
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, is_none, [o$0],
-//│ 1, 
-//│ case o$0 of -- #29
-//│   None =>
-//│     let x$6 = True() in -- #22
-//│     jump j$1(x$6) -- #21
-//│   Some =>
-//│     let x$7 = o$0.x in -- #28
-//│     let x$8 = False() in -- #27
-//│     jump j$1(x$8) -- #26
-//│ )
-//│ Def(3, j$1, [x$5],
-//│ 1, 
-//│ x$5 -- #19
-//│ )
-//│ Def(4, is_empty, [l$1],
-//│ 1, 
-//│ let* (x$9) = head_opt(l$1) in -- #40
-//│ let* (x$10) = is_none(x$9) in -- #39
-//│ x$10 -- #38
-//│ )
-//│ Def(5, main, [],
-//│ 1, 
-//│ let x$11 = Nil() in -- #59
-//│ let x$12 = Cons(2,x$11) in -- #58
-//│ let x$13 = Cons(1,x$12) in -- #57
-//│ let* (x$14) = is_empty(x$13) in -- #56
-//│ x$14 -- #55
-//│ )
-//│ },
-//│ let* (x$15) = main() in -- #63
-//│ x$15 -- #62)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, Some, [x]),ClassInfo(5, None, [])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, Cons, [h,t]),ClassInfo(5, Nil, []),ClassInfo(6, Some, [x]),ClassInfo(7, None, [])}, {
 //│ Def(0, head_opt, [l$0],
 //│ 1, 
 //│ case l$0 of -- #17
@@ -1338,83 +788,16 @@ fun is_none(o) =
   if o is
     None then True
     Some(x) then False
-fun is_empty(l) =
-  is_none(head_opt(l))
-fun main() =
-  is_empty(mk_list(10))
-main()
-//│ |#class| |True|↵|#class| |False|↵|#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|#class| |Some|(|x|)|↵|#class| |None|↵|#fun| |mk_list|(|n|)| |#=|→|#if| |n| |==| |0| |#then| |Nil| |#else| |Cons|(|n|,| |mk_list|(|n| |-| |1|)|)|←|↵|#fun| |head_opt|(|l|)| |#=|→|#if| |l| |is|→|Nil| |#then| |None|↵|Cons|(|h|,| |t|)| |#then| |Some|(|h|)|←|←|↵|#fun| |is_none|(|o|)| |#=|→|#if| |o| |is|→|None| |#then| |True|↵|Some|(|x|)| |#then| |False|←|←|↵|#fun| |is_empty|(|l|)| |#=|→|is_none|(|head_opt|(|l|)|)|←|↵|#fun| |main|(||)| |#=|→|is_empty|(|mk_list|(|10|)|)|←|↵|main|(||)|
-//│ Parsed: {class True {}; class False {}; class Cons(h, t,) {}; class Nil {}; class Some(x,) {}; class None {}; fun mk_list = (n,) => {if (==(n,)(0,)) then Nil else Cons(n, mk_list(-(n,)(1,),),)}; fun head_opt = (l,) => {if l is ‹(Nil) then None; (Cons(h, t,)) then Some(h,)›}; fun is_none = (o,) => {if o is ‹(None) then True; (Some(x,)) then False›}; fun is_empty = (l,) => {is_none(head_opt(l,),)}; fun main = () => {is_empty(mk_list(10,),)}; main()}
-//│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, Some, [x]),ClassInfo(5, None, [])}, {
-//│ Def(0, mk_list, [n$0],
-//│ 1, 
-//│ let x$0 = ==(n$0,0) in -- #24
-//│ if x$0 -- #23
-//│   true =>
-//│     let x$2 = Nil() in -- #6
-//│     jump j$0(x$2) -- #5
-//│   false =>
-//│     let x$3 = -(n$0,1) in -- #22
-//│     let* (x$4) = mk_list(x$3) in -- #21
-//│     let x$5 = Cons(n$0,x$4) in -- #20
-//│     jump j$0(x$5) -- #19
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #3
-//│ )
-//│ Def(2, head_opt, [l$0],
-//│ 1, 
-//│ case l$0 of -- #42
-//│   Nil =>
-//│     let x$7 = None() in -- #29
-//│     jump j$1(x$7) -- #28
-//│   Cons =>
-//│     let x$8 = l$0.t in -- #41
-//│     let x$9 = l$0.h in -- #40
-//│     let x$10 = Some(x$9) in -- #39
-//│     jump j$1(x$10) -- #38
-//│ )
-//│ Def(3, j$1, [x$6],
-//│ 1, 
-//│ x$6 -- #26
-//│ )
-//│ Def(4, is_none, [o$0],
-//│ 1, 
-//│ case o$0 of -- #54
-//│   None =>
-//│     let x$12 = True() in -- #47
-//│     jump j$2(x$12) -- #46
-//│   Some =>
-//│     let x$13 = o$0.x in -- #53
-//│     let x$14 = False() in -- #52
-//│     jump j$2(x$14) -- #51
-//│ )
-//│ Def(5, j$2, [x$11],
-//│ 1, 
-//│ x$11 -- #44
-//│ )
-//│ Def(6, is_empty, [l$1],
-//│ 1, 
-//│ let* (x$15) = head_opt(l$1) in -- #65
-//│ let* (x$16) = is_none(x$15) in -- #64
-//│ x$16 -- #63
-//│ )
-//│ Def(7, main, [],
-//│ 1, 
-//│ let* (x$17) = mk_list(10) in -- #76
-//│ let* (x$18) = is_empty(x$17) in -- #75
-//│ x$18 -- #74
-//│ )
-//│ },
-//│ let* (x$19) = main() in -- #80
-//│ x$19 -- #79)
+fun is_empty(l) =
+  is_none(head_opt(l))
+fun main() =
+  is_empty(mk_list(10))
+main()
+//│ |#class| |True|↵|#class| |False|↵|#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|#class| |Some|(|x|)|↵|#class| |None|↵|#fun| |mk_list|(|n|)| |#=|→|#if| |n| |==| |0| |#then| |Nil| |#else| |Cons|(|n|,| |mk_list|(|n| |-| |1|)|)|←|↵|#fun| |head_opt|(|l|)| |#=|→|#if| |l| |is|→|Nil| |#then| |None|↵|Cons|(|h|,| |t|)| |#then| |Some|(|h|)|←|←|↵|#fun| |is_none|(|o|)| |#=|→|#if| |o| |is|→|None| |#then| |True|↵|Some|(|x|)| |#then| |False|←|←|↵|#fun| |is_empty|(|l|)| |#=|→|is_none|(|head_opt|(|l|)|)|←|↵|#fun| |main|(||)| |#=|→|is_empty|(|mk_list|(|10|)|)|←|↵|main|(||)|
+//│ Parsed: {class True {}; class False {}; class Cons(h, t,) {}; class Nil {}; class Some(x,) {}; class None {}; fun mk_list = (n,) => {if (==(n,)(0,)) then Nil else Cons(n, mk_list(-(n,)(1,),),)}; fun head_opt = (l,) => {if l is ‹(Nil) then None; (Cons(h, t,)) then Some(h,)›}; fun is_none = (o,) => {if o is ‹(None) then True; (Some(x,)) then False›}; fun is_empty = (l,) => {is_none(head_opt(l,),)}; fun main = () => {is_empty(mk_list(10,),)}; main()}
 //│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, Some, [x]),ClassInfo(5, None, [])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, Cons, [h,t]),ClassInfo(5, Nil, []),ClassInfo(6, Some, [x]),ClassInfo(7, None, [])}, {
 //│ Def(0, mk_list, [n$0],
 //│ 1, 
 //│ let x$0 = ==(n$0,0) in -- #24
@@ -1480,7 +863,8 @@ main()
 //│ x$19 -- #79)
 //│ 
 //│ Interpreted:
-//│ False()
+//│ 
+//│ IR Processing Failed: can not find the matched case, ClassInfo(1, False, []) expected
 
 :interpIR
 class True
@@ -1504,65 +888,8 @@ main()
 //│ |#class| |True|↵|#class| |False|↵|#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|#class| |Some|(|x|)|↵|#class| |None|↵|#fun| |mk_list|(|n|)| |#=|→|#if| |n| |==| |0| |#then| |Nil| |#else| |Cons|(|n|,| |mk_list|(|n| |-| |1|)|)|←|↵|#fun| |last_opt|(|l|)| |#=|→|#if| |l| |is|→|Nil| |#then| |None|↵|Cons|(|h|,| |t|)| |#then|→|#if| |t| |is|→|Nil| |#then| |Some|(|h|)|↵|Cons|(|h2|,| |t2|)| |#then| |last_opt|(|t|)|←|←|←|←|↵|#fun| |main|(||)| |#=|→|last_opt|(|mk_list|(|10|)|)|←|↵|main|(||)|
 //│ Parsed: {class True {}; class False {}; class Cons(h, t,) {}; class Nil {}; class Some(x,) {}; class None {}; fun mk_list = (n,) => {if (==(n,)(0,)) then Nil else Cons(n, mk_list(-(n,)(1,),),)}; fun last_opt = (l,) => {if l is ‹(Nil) then None; (Cons(h, t,)) then {if t is ‹(Nil) then Some(h,); (Cons(h2, t2,)) then last_opt(t,)›}›}; fun main = () => {last_opt(mk_list(10,),)}; main()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, Some, [x]),ClassInfo(5, None, [])}, {
-//│ Def(0, mk_list, [n$0],
-//│ 1, 
-//│ let x$0 = ==(n$0,0) in -- #24
-//│ if x$0 -- #23
-//│   true =>
-//│     let x$2 = Nil() in -- #6
-//│     jump j$0(x$2) -- #5
-//│   false =>
-//│     let x$3 = -(n$0,1) in -- #22
-//│     let* (x$4) = mk_list(x$3) in -- #21
-//│     let x$5 = Cons(n$0,x$4) in -- #20
-//│     jump j$0(x$5) -- #19
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #3
-//│ )
-//│ Def(2, last_opt, [l$0],
-//│ 1, 
-//│ case l$0 of -- #59
-//│   Nil =>
-//│     let x$7 = None() in -- #29
-//│     jump j$1(x$7) -- #28
-//│   Cons =>
-//│     let x$8 = l$0.t in -- #58
-//│     let x$9 = l$0.h in -- #57
-//│     case x$8 of -- #56
-//│       Nil =>
-//│         let x$11 = Some(x$9) in -- #42
-//│         jump j$2(x$11) -- #41
-//│       Cons =>
-//│         let x$12 = x$8.t in -- #55
-//│         let x$13 = x$8.h in -- #54
-//│         let* (x$14) = last_opt(x$8) in -- #53
-//│         jump j$2(x$14) -- #52
-//│ )
-//│ Def(3, j$1, [x$6],
-//│ 1, 
-//│ x$6 -- #26
-//│ )
-//│ Def(4, j$2, [x$10],
-//│ 1, 
-//│ jump j$1(x$10) -- #36
-//│ )
-//│ Def(5, main, [],
-//│ 1, 
-//│ let* (x$15) = mk_list(10) in -- #70
-//│ let* (x$16) = last_opt(x$15) in -- #69
-//│ x$16 -- #68
-//│ )
-//│ },
-//│ let* (x$17) = main() in -- #74
-//│ x$17 -- #73)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, Some, [x]),ClassInfo(5, None, [])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, Cons, [h,t]),ClassInfo(5, Nil, []),ClassInfo(6, Some, [x]),ClassInfo(7, None, [])}, {
 //│ Def(0, mk_list, [n$0],
 //│ 1, 
 //│ let x$0 = ==(n$0,0) in -- #24
@@ -1618,7 +945,8 @@ main()
 //│ x$17 -- #73)
 //│ 
 //│ Interpreted:
-//│ Some(1)
+//│ 
+//│ IR Processing Failed: can not find the matched case, ClassInfo(1, False, []) expected
 
 :interpIR
 class True
@@ -1656,101 +984,8 @@ main()
 //│ |#class| |True|↵|#class| |False|↵|#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|#class| |Some|(|x|)|↵|#class| |None|↵|#fun| |is_some|(|o|)| |#=|→|#if| |o| |is|→|Some|(|x|)| |#then| |True|↵|None| |#then| |False|←|←|↵|#fun| |e0|(|w|)| |#=|→|w| |+| |8| |+| |9| |+| |10|←|↵|#fun| |e1|(|a|,| |c|)| |#=|→|a| |+| |1| |+| |2| |+| |3| |+| |4|←|↵|#fun| |e3|(|c|)| |#=|→|#let| |m| |#=| |4|↵|#let| |n| |#=| |5|↵|#let| |p| |#=| |6|↵|#let| |q| |#=| |7|↵|#if| |c| |#then| |m| |+| |n| |+| |p| |+| |q| |#else| |m| |+| |n| |-| |p| |+| |q|←|↵|#fun| |e2|(|x|)| |#=|→|x| |+| |12| |+| |13| |+| |14|←|↵|#fun| |f|(|x|)| |#=|→|#let| |c1| |#=| |is_some|(|x|)|↵|#let| |z| |#=| |e3|(|c1|)|↵|#let| |w| |#=| |#if| |x| |is|→|Some|(|a|)| |#then| |e1|(|a|,| |z|)|↵|None| |#then| |e2|(|z|)|←|↵|e0|(|w|)|←|↵|#fun| |main|(||)| |#=|→|f|(|Some|(|2|)|)| |+| |f|(|None|)|←|↵|main|(||)|
 //│ Parsed: {class True {}; class False {}; class Cons(h, t,) {}; class Nil {}; class Some(x,) {}; class None {}; fun is_some = (o,) => {if o is ‹(Some(x,)) then True; (None) then False›}; fun e0 = (w,) => {+(+(+(w,)(8,),)(9,),)(10,)}; fun e1 = (a, c,) => {+(+(+(+(a,)(1,),)(2,),)(3,),)(4,)}; fun e3 = (c,) => {let m = 4; let n = 5; let p = 6; let q = 7; if (c) then +(+(+(m,)(n,),)(p,),)(q,) else +(-(+(m,)(n,),)(p,),)(q,)}; fun e2 = (x,) => {+(+(+(x,)(12,),)(13,),)(14,)}; fun f = (x,) => {let c1 = is_some(x,); let z = e3(c1,); let w = if x is ‹(Some(a,)) then e1(a, z,); (None) then e2(z,)›; e0(w,)}; fun main = () => {+(f(Some(2,),),)(f(None,),)}; main()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, Some, [x]),ClassInfo(5, None, [])}, {
-//│ Def(0, is_some, [o$0],
-//│ 1, 
-//│ case o$0 of -- #11
-//│   Some =>
-//│     let x$1 = o$0.x in -- #7
-//│     let x$2 = True() in -- #6
-//│     jump j$0(x$2) -- #5
-//│   None =>
-//│     let x$3 = False() in -- #10
-//│     jump j$0(x$3) -- #9
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, e0, [w$0],
-//│ 1, 
-//│ let x$4 = +(w$0,8) in -- #21
-//│ let x$5 = +(x$4,9) in -- #20
-//│ let x$6 = +(x$5,10) in -- #19
-//│ x$6 -- #18
-//│ )
-//│ Def(3, e1, [a$0,c$0],
-//│ 1, 
-//│ let x$7 = +(a$0,1) in -- #34
-//│ let x$8 = +(x$7,2) in -- #33
-//│ let x$9 = +(x$8,3) in -- #32
-//│ let x$10 = +(x$9,4) in -- #31
-//│ x$10 -- #30
-//│ )
-//│ Def(4, e3, [c$1],
-//│ 1, 
-//│ let x$11 = 4 in -- #67
-//│ let x$12 = 5 in -- #66
-//│ let x$13 = 6 in -- #65
-//│ let x$14 = 7 in -- #64
-//│ if c$1 -- #63
-//│   true =>
-//│     let x$16 = +(x$11,x$12) in -- #51
-//│     let x$17 = +(x$16,x$13) in -- #50
-//│     let x$18 = +(x$17,x$14) in -- #49
-//│     jump j$1(x$18) -- #48
-//│   false =>
-//│     let x$19 = +(x$11,x$12) in -- #62
-//│     let x$20 = -(x$19,x$13) in -- #61
-//│     let x$21 = +(x$20,x$14) in -- #60
-//│     jump j$1(x$21) -- #59
-//│ )
-//│ Def(5, j$1, [x$15],
-//│ 1, 
-//│ x$15 -- #40
-//│ )
-//│ Def(6, e2, [x$22],
-//│ 1, 
-//│ let x$23 = +(x$22,12) in -- #77
-//│ let x$24 = +(x$23,13) in -- #76
-//│ let x$25 = +(x$24,14) in -- #75
-//│ x$25 -- #74
-//│ )
-//│ Def(7, f, [x$26],
-//│ 1, 
-//│ let* (x$27) = is_some(x$26) in -- #117
-//│ let* (x$28) = e3(x$27) in -- #116
-//│ case x$26 of -- #115
-//│   Some =>
-//│     let x$31 = x$26.x in -- #107
-//│     let* (x$32) = e1(x$31,x$28) in -- #106
-//│     jump j$2(x$32) -- #105
-//│   None =>
-//│     let* (x$33) = e2(x$28) in -- #114
-//│     jump j$2(x$33) -- #113
-//│ )
-//│ Def(8, j$2, [x$29],
-//│ 1, 
-//│ let* (x$30) = e0(x$29) in -- #95
-//│ x$30 -- #94
-//│ )
-//│ Def(9, main, [],
-//│ 1, 
-//│ let x$34 = Some(2) in -- #136
-//│ let* (x$35) = f(x$34) in -- #135
-//│ let x$36 = None() in -- #134
-//│ let* (x$37) = f(x$36) in -- #133
-//│ let x$38 = +(x$35,x$37) in -- #132
-//│ x$38 -- #131
-//│ )
-//│ },
-//│ let* (x$39) = main() in -- #140
-//│ x$39 -- #139)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, Some, [x]),ClassInfo(5, None, [])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, Cons, [h,t]),ClassInfo(5, Nil, []),ClassInfo(6, Some, [x]),ClassInfo(7, None, [])}, {
 //│ Def(0, is_some, [o$0],
 //│ 1, 
 //│ case o$0 of -- #11
@@ -1880,109 +1115,8 @@ main()
 //│ |#class| |True|↵|#class| |False|↵|#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|#class| |Some|(|x|)|↵|#class| |None|↵|#fun| |is_some|(|o|)| |#=|→|#if| |o| |is|→|Some|(|x|)| |#then| |True|↵|None| |#then| |False|←|←|↵|#fun| |e0|(|w|)| |#=|→|w| |+| |8| |+| |9| |+| |10|←|↵|#fun| |e1|(|a|,| |z|)| |#=|→|#if| |a| |>| |0| |#then| |f|(|Some|(|a| |-| |1|)|)| |#else| |z|←|↵|#fun| |e3|(|c|)| |#=|→|#let| |m| |#=| |4|↵|#let| |n| |#=| |5|↵|#let| |p| |#=| |6|↵|#let| |q| |#=| |7|↵|#if| |c| |#then| |m| |+| |n| |+| |p| |+| |q| |#else| |m| |+| |n| |-| |p| |+| |q|←|↵|#fun| |e2|(|x|)| |#=|→|x| |+| |12| |+| |13| |+| |14|←|↵|#fun| |f|(|x|)| |#=|→|#let| |c1| |#=| |is_some|(|x|)|↵|#let| |z| |#=| |e3|(|c1|)|↵|#let| |w| |#=| |#if| |x| |is|→|Some|(|a|)| |#then| |e1|(|a|,| |z|)|↵|None| |#then| |e2|(|z|)|←|↵|e0|(|w|)|←|↵|#fun| |main|(||)| |#=|→|f|(|Some|(|2|)|)| |+| |f|(|None|)|←|↵|main|(||)|
 //│ Parsed: {class True {}; class False {}; class Cons(h, t,) {}; class Nil {}; class Some(x,) {}; class None {}; fun is_some = (o,) => {if o is ‹(Some(x,)) then True; (None) then False›}; fun e0 = (w,) => {+(+(+(w,)(8,),)(9,),)(10,)}; fun e1 = (a, z,) => {if (>(a,)(0,)) then f(Some(-(a,)(1,),),) else z}; fun e3 = (c,) => {let m = 4; let n = 5; let p = 6; let q = 7; if (c) then +(+(+(m,)(n,),)(p,),)(q,) else +(-(+(m,)(n,),)(p,),)(q,)}; fun e2 = (x,) => {+(+(+(x,)(12,),)(13,),)(14,)}; fun f = (x,) => {let c1 = is_some(x,); let z = e3(c1,); let w = if x is ‹(Some(a,)) then e1(a, z,); (None) then e2(z,)›; e0(w,)}; fun main = () => {+(f(Some(2,),),)(f(None,),)}; main()}
 //│ 
-//│ 
-//│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, Some, [x]),ClassInfo(5, None, [])}, {
-//│ Def(0, is_some, [o$0],
-//│ 1, 
-//│ case o$0 of -- #11
-//│   Some =>
-//│     let x$1 = o$0.x in -- #7
-//│     let x$2 = True() in -- #6
-//│     jump j$0(x$2) -- #5
-//│   None =>
-//│     let x$3 = False() in -- #10
-//│     jump j$0(x$3) -- #9
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, e0, [w$0],
-//│ 1, 
-//│ let x$4 = +(w$0,8) in -- #21
-//│ let x$5 = +(x$4,9) in -- #20
-//│ let x$6 = +(x$5,10) in -- #19
-//│ x$6 -- #18
-//│ )
-//│ Def(3, e1, [a$0,z$0],
-//│ 1, 
-//│ let x$7 = >(a$0,0) in -- #43
-//│ if x$7 -- #42
-//│   true =>
-//│     let x$9 = -(a$0,1) in -- #39
-//│     let x$10 = Some(x$9) in -- #38
-//│     let* (x$11) = f(x$10) in -- #37
-//│     jump j$1(x$11) -- #36
-//│   false =>
-//│     jump j$1(z$0) -- #41
-//│ )
-//│ Def(4, j$1, [x$8],
-//│ 1, 
-//│ x$8 -- #25
-//│ )
-//│ Def(5, e3, [c$0],
-//│ 1, 
-//│ let x$12 = 4 in -- #76
-//│ let x$13 = 5 in -- #75
-//│ let x$14 = 6 in -- #74
-//│ let x$15 = 7 in -- #73
-//│ if c$0 -- #72
-//│   true =>
-//│     let x$17 = +(x$12,x$13) in -- #60
-//│     let x$18 = +(x$17,x$14) in -- #59
-//│     let x$19 = +(x$18,x$15) in -- #58
-//│     jump j$2(x$19) -- #57
-//│   false =>
-//│     let x$20 = +(x$12,x$13) in -- #71
-//│     let x$21 = -(x$20,x$14) in -- #70
-//│     let x$22 = +(x$21,x$15) in -- #69
-//│     jump j$2(x$22) -- #68
-//│ )
-//│ Def(6, j$2, [x$16],
-//│ 1, 
-//│ x$16 -- #49
-//│ )
-//│ Def(7, e2, [x$23],
-//│ 1, 
-//│ let x$24 = +(x$23,12) in -- #86
-//│ let x$25 = +(x$24,13) in -- #85
-//│ let x$26 = +(x$25,14) in -- #84
-//│ x$26 -- #83
-//│ )
-//│ Def(8, f, [x$27],
-//│ 1, 
-//│ let* (x$28) = is_some(x$27) in -- #126
-//│ let* (x$29) = e3(x$28) in -- #125
-//│ case x$27 of -- #124
-//│   Some =>
-//│     let x$32 = x$27.x in -- #116
-//│     let* (x$33) = e1(x$32,x$29) in -- #115
-//│     jump j$3(x$33) -- #114
-//│   None =>
-//│     let* (x$34) = e2(x$29) in -- #123
-//│     jump j$3(x$34) -- #122
-//│ )
-//│ Def(9, j$3, [x$30],
-//│ 1, 
-//│ let* (x$31) = e0(x$30) in -- #104
-//│ x$31 -- #103
-//│ )
-//│ Def(10, main, [],
-//│ 1, 
-//│ let x$35 = Some(2) in -- #145
-//│ let* (x$36) = f(x$35) in -- #144
-//│ let x$37 = None() in -- #143
-//│ let* (x$38) = f(x$37) in -- #142
-//│ let x$39 = +(x$36,x$38) in -- #141
-//│ x$39 -- #140
-//│ )
-//│ },
-//│ let* (x$40) = main() in -- #149
-//│ x$40 -- #148)
-//│ 
 //│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, Some, [x]),ClassInfo(5, None, [])}, {
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, Cons, [h,t]),ClassInfo(5, Nil, []),ClassInfo(6, Some, [x]),ClassInfo(7, None, [])}, {
 //│ Def(0, is_some, [o$0],
 //│ 1, 
 //│ case o$0 of -- #11
@@ -2082,4 +1216,5 @@ main()
 //│ x$40 -- #148)
 //│ 
 //│ Interpreted:
-//│ 179
+//│ 
+//│ IR Processing Failed: can not find the matched case, ClassInfo(0, True, []) expected
diff --git a/compiler/shared/test/diff-ir/IRTailRec.mls b/compiler/shared/test/diff-ir/IRTailRec.mls
new file mode 100644
index 0000000000..de30850804
--- /dev/null
+++ b/compiler/shared/test/diff-ir/IRTailRec.mls
@@ -0,0 +1,2669 @@
+:NewParser
+:ParseOnly
+:UseIR
+
+:noTailRec
+:interpIR
+fun fact(acc, n) =
+  if n == 0 then acc
+  else fact(acc * n, n - 1)
+fact(1, 5)
+//│ |#fun| |fact|(|acc|,| |n|)| |#=|→|#if| |n| |==| |0| |#then| |acc|↵|#else| |fact|(|acc| |*| |n|,| |n| |-| |1|)|←|↵|fact|(|1|,| |5|)|
+//│ Parsed: {fun fact = (acc, n,) => {if (==(n,)(0,)) then acc else fact(*(acc,)(n,), -(n,)(1,),)}; fact(1, 5,)}
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
+//│ Def(0, fact, [acc$0,n$0],
+//│ 1, 
+//│ let x$0 = ==(n$0,0) in -- #22
+//│ if x$0 -- #21
+//│   true =>
+//│     jump j$0(acc$0) -- #5
+//│   false =>
+//│     let x$2 = *(acc$0,n$0) in -- #20
+//│     let x$3 = -(n$0,1) in -- #19
+//│     let* (x$4) = fact(x$2,x$3) in -- #18
+//│     jump j$0(x$4) -- #17
+//│ )
+//│ Def(1, j$0, [x$1],
+//│ 1, 
+//│ x$1 -- #3
+//│ )
+//│ },
+//│ let* (x$5) = fact(1,5) in -- #30
+//│ x$5 -- #29)
+//│ 
+//│ Interpreted:
+//│ 120
+
+:interpIR
+@tailrec
+fun fact(acc, n) =
+  if n == 0 then acc
+  else fact(acc * n, n - 1)
+fact(1, 5)
+//│ |@|tailrec|↵|#fun| |fact|(|acc|,| |n|)| |#=|→|#if| |n| |==| |0| |#then| |acc|↵|#else| |fact|(|acc| |*| |n|,| |n| |-| |1|)|←|↵|fact|(|1|,| |5|)|
+//│ Parsed: {fun fact = (acc, n,) => {if (==(n,)(0,)) then acc else fact(*(acc,)(n,), -(n,)(1,),)}; fact(1, 5,)}
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
+//│ Def(0, fact, [acc$0,n$0],
+//│ 1, 
+//│ let x$0 = ==(n$0,0) in -- #22
+//│ if x$0 -- #21
+//│   true =>
+//│     jump j$0(acc$0) -- #5
+//│   false =>
+//│     let x$2 = *(acc$0,n$0) in -- #20
+//│     let x$3 = -(n$0,1) in -- #19
+//│     let* (x$4) = fact(x$2,x$3) in -- #18
+//│     jump j$0(x$4) -- #17
+//│ )
+//│ Def(1, j$0, [x$1],
+//│ 1, 
+//│ x$1 -- #3
+//│ )
+//│ },
+//│ let* (x$5) = fact(1,5) in -- #30
+//│ x$5 -- #29)
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(j$0), Set(fact))
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(1, j$0, [x$1],
+//│ 1, 
+//│ x$1 -- #3
+//│ )
+//│ Def(2, fact_jp, [acc$0,n$0],
+//│ 1, 
+//│ let x$0 = ==(n$0,0) in -- #36
+//│ if x$0 -- #35
+//│   true =>
+//│     jump j$0(acc$0) -- #31
+//│   false =>
+//│     let x$2 = *(acc$0,n$0) in -- #34
+//│     let x$3 = -(n$0,1) in -- #33
+//│     jump fact_jp(x$2,x$3) -- #32
+//│ )
+//│ Def(3, fact, [acc$0,n$0],
+//│ 1, 
+//│ let* (r0) = fact_jp(acc$0,n$0) in -- #38
+//│ r0 -- #37
+//│ )
+//│ },
+//│ let* (x$5) = fact(1,5) in -- #30
+//│ x$5 -- #29)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(1, j$0, [x$1],
+//│ 1, 
+//│ x$1 -- #3
+//│ )
+//│ Def(2, fact_jp, [acc$0,n$0],
+//│ 1, 
+//│ let x$0 = ==(n$0,0) in -- #36
+//│ if x$0 -- #35
+//│   true =>
+//│     jump j$0(acc$0) -- #31
+//│   false =>
+//│     let x$2 = *(acc$0,n$0) in -- #34
+//│     let x$3 = -(n$0,1) in -- #33
+//│     jump fact_jp(x$2,x$3) -- #32
+//│ )
+//│ Def(3, fact, [acc$0,n$0],
+//│ 1, 
+//│ let* (r0) = fact_jp(acc$0,n$0) in -- #38
+//│ r0 -- #37
+//│ )
+//│ },
+//│ let* (x$5) = fact(1,5) in -- #30
+//│ x$5 -- #29)
+//│ 
+//│ Interpreted:
+//│ 120
+
+:interpIR
+@tailrec
+fun fact(acc, n) =
+  val x = if n > 0 then n - 1
+    else 0
+  if x <= 0 then
+    acc
+  else 
+    @tailcall fact(n * acc, x) 
+fact(1, 5)
+//│ |@|tailrec|↵|#fun| |fact|(|acc|,| |n|)| |#=|→|#val| |x| |#=| |#if| |n| |>| |0| |#then| |n| |-| |1|→|#else| |0|←|↵|#if| |x| |<=| |0| |#then|→|acc|←|↵|#else| |→|@|tailcall| |fact|(|n| |*| |acc|,| |x|)| |←|←|↵|fact|(|1|,| |5|)|
+//│ Parsed: {fun fact = (acc, n,) => {let x = if (>(n,)(0,)) then -(n,)(1,) else 0; if (<=(x,)(0,)) then {acc} else {@tailcall fact(*(n,)(acc,), x,)}}; fact(1, 5,)}
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
+//│ Def(0, fact, [acc$0,n$0],
+//│ 1, 
+//│ let x$0 = >(n$0,0) in -- #32
+//│ if x$0 -- #31
+//│   true =>
+//│     let x$6 = -(n$0,1) in -- #28
+//│     jump j$0(x$6,acc$0,n$0) -- #27
+//│   false =>
+//│     jump j$0(0,acc$0,n$0) -- #30
+//│ )
+//│ Def(1, j$1, [x$3],
+//│ 1, 
+//│ x$3 -- #7
+//│ )
+//│ Def(2, j$0, [x$1,acc$0,n$0],
+//│ 1, 
+//│ let x$2 = <=(x$1,0) in -- #23
+//│ if x$2 -- #22
+//│   true =>
+//│     jump j$1(acc$0) -- #9
+//│   false =>
+//│     let x$4 = *(n$0,acc$0) in -- #21
+//│     let* (x$5) = @tailcall fact(x$4,x$1) in -- #20
+//│     jump j$1(x$5) -- #19
+//│ )
+//│ },
+//│ let* (x$7) = fact(1,5) in -- #40
+//│ x$7 -- #39)
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(j$1), Set(fact))
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(0, fact, [acc$0,n$0],
+//│ 1, 
+//│ let* (r0) = _fact_j$0_opt$3(0,acc$0,n$0,undefined,undefined,undefined) in -- #60
+//│ r0 -- #59
+//│ )
+//│ Def(1, j$1, [x$3],
+//│ 1, 
+//│ x$3 -- #7
+//│ )
+//│ Def(3, _fact_j$0_opt$3, [tailrecBranch$,fact_acc$0,fact_n$0,j$0_x$1,j$0_acc$0,j$0_n$0],
+//│ 1, 
+//│ jump _fact_j$0_opt_jp$4(tailrecBranch$,fact_acc$0,fact_n$0,j$0_x$1,j$0_acc$0,j$0_n$0) -- #58
+//│ )
+//│ Def(4, _fact_j$0_opt_jp$4, [tailrecBranch$,fact_acc$0,fact_n$0,j$0_x$1,j$0_acc$0,j$0_n$0],
+//│ 1, 
+//│ let scrut = ==(2,tailrecBranch$) in -- #57
+//│ if scrut -- #56
+//│   true =>
+//│     let x$2 = <=(j$0_x$1,0) in -- #55
+//│     if x$2 -- #54
+//│       true =>
+//│         jump j$1(j$0_acc$0) -- #51
+//│       false =>
+//│         let x$4 = *(j$0_n$0,j$0_acc$0) in -- #53
+//│         jump _fact_j$0_opt_jp$4(0,x$4,j$0_x$1,j$0_x$1,j$0_acc$0,j$0_n$0) -- #52
+//│   false =>
+//│     let x$0 = >(fact_n$0,0) in -- #50
+//│     if x$0 -- #49
+//│       true =>
+//│         let x$6 = -(fact_n$0,1) in -- #47
+//│         jump _fact_j$0_opt_jp$4(2,fact_acc$0,fact_n$0,x$6,fact_acc$0,fact_n$0) -- #46
+//│       false =>
+//│         jump _fact_j$0_opt_jp$4(2,fact_acc$0,fact_n$0,0,fact_acc$0,fact_n$0) -- #48
+//│ )
+//│ },
+//│ let* (x$7) = fact(1,5) in -- #40
+//│ x$7 -- #39)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(0, fact, [acc$0,n$0],
+//│ 1, 
+//│ let* (r0) = _fact_j$0_opt$3(0,acc$0,n$0,undefined,undefined,undefined) in -- #60
+//│ r0 -- #59
+//│ )
+//│ Def(1, j$1, [x$3],
+//│ 1, 
+//│ x$3 -- #7
+//│ )
+//│ Def(3, _fact_j$0_opt$3, [tailrecBranch$,fact_acc$0,fact_n$0,j$0_x$1,j$0_acc$0,j$0_n$0],
+//│ 1, 
+//│ jump _fact_j$0_opt_jp$4(tailrecBranch$,fact_acc$0,fact_n$0,j$0_x$1,j$0_acc$0,j$0_n$0) -- #58
+//│ )
+//│ Def(4, _fact_j$0_opt_jp$4, [tailrecBranch$,fact_acc$0,fact_n$0,j$0_x$1,j$0_acc$0,j$0_n$0],
+//│ 1, 
+//│ let scrut = ==(2,tailrecBranch$) in -- #57
+//│ if scrut -- #56
+//│   true =>
+//│     let x$2 = <=(j$0_x$1,0) in -- #55
+//│     if x$2 -- #54
+//│       true =>
+//│         jump j$1(j$0_acc$0) -- #51
+//│       false =>
+//│         let x$4 = *(j$0_n$0,j$0_acc$0) in -- #53
+//│         jump _fact_j$0_opt_jp$4(0,x$4,j$0_x$1,j$0_x$1,j$0_acc$0,j$0_n$0) -- #52
+//│   false =>
+//│     let x$0 = >(fact_n$0,0) in -- #50
+//│     if x$0 -- #49
+//│       true =>
+//│         let x$6 = -(fact_n$0,1) in -- #47
+//│         jump _fact_j$0_opt_jp$4(2,fact_acc$0,fact_n$0,x$6,fact_acc$0,fact_n$0) -- #46
+//│       false =>
+//│         jump _fact_j$0_opt_jp$4(2,fact_acc$0,fact_n$0,0,fact_acc$0,fact_n$0) -- #48
+//│ )
+//│ },
+//│ let* (x$7) = fact(1,5) in -- #40
+//│ x$7 -- #39)
+//│ 
+//│ Interpreted:
+//│ 120
+
+:noTailRec
+:interpIR
+fun double(x) = x * 2
+fun f(n, acc) = if n == 0 then double(acc) else g(n - 1, acc + 1)
+fun g(m, acc) = if m == 0 then -double(acc) else f(m - 1, acc + 1)
+g(6, 0)
+//│ |#fun| |double|(|x|)| |#=| |x| |*| |2|↵|#fun| |f|(|n|,| |acc|)| |#=| |#if| |n| |==| |0| |#then| |double|(|acc|)| |#else| |g|(|n| |-| |1|,| |acc| |+| |1|)|↵|#fun| |g|(|m|,| |acc|)| |#=| |#if| |m| |==| |0| |#then| |-|double|(|acc|)| |#else| |f|(|m| |-| |1|,| |acc| |+| |1|)|↵|g|(|6|,| |0|)|
+//│ Parsed: {fun double = (x,) => *(x,)(2,); fun f = (n, acc,) => if (==(n,)(0,)) then double(acc,) else g(-(n,)(1,), +(acc,)(1,),); fun g = (m, acc,) => if (==(m,)(0,)) then -(0,)(double(acc,),) else f(-(m,)(1,), +(acc,)(1,),); g(6, 0,)}
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
+//│ Def(0, double, [x$0],
+//│ 1, 
+//│ let x$1 = *(x$0,2) in -- #3
+//│ x$1 -- #2
+//│ )
+//│ Def(1, f, [n$0,acc$0],
+//│ 1, 
+//│ let x$2 = ==(n$0,0) in -- #31
+//│ if x$2 -- #30
+//│   true =>
+//│     let* (x$4) = double(acc$0) in -- #14
+//│     jump j$0(x$4) -- #13
+//│   false =>
+//│     let x$5 = -(n$0,1) in -- #29
+//│     let x$6 = +(acc$0,1) in -- #28
+//│     let* (x$7) = g(x$5,x$6) in -- #27
+//│     jump j$0(x$7) -- #26
+//│ )
+//│ Def(2, j$0, [x$3],
+//│ 1, 
+//│ x$3 -- #7
+//│ )
+//│ Def(3, g, [m$0,acc$1],
+//│ 1, 
+//│ let x$8 = ==(m$0,0) in -- #62
+//│ if x$8 -- #61
+//│   true =>
+//│     let* (x$10) = double(acc$1) in -- #45
+//│     let x$11 = -(0,x$10) in -- #44
+//│     jump j$1(x$11) -- #43
+//│   false =>
+//│     let x$12 = -(m$0,1) in -- #60
+//│     let x$13 = +(acc$1,1) in -- #59
+//│     let* (x$14) = f(x$12,x$13) in -- #58
+//│     jump j$1(x$14) -- #57
+//│ )
+//│ Def(4, j$1, [x$9],
+//│ 1, 
+//│ x$9 -- #35
+//│ )
+//│ },
+//│ let* (x$15) = g(6,0) in -- #70
+//│ x$15 -- #69)
+//│ 
+//│ Interpreted:
+//│ -12
+
+:interpIR
+fun double(x) = x * 2
+@tailrec fun f(n, acc) = if n == 0 then double(acc) else g(n - 1, acc + 1)
+@tailrec fun g(m, acc) = if m == 0 then -double(acc) else f(m - 1, acc + 1)
+g(6, 0)
+//│ |#fun| |double|(|x|)| |#=| |x| |*| |2|↵|@|tailrec| |#fun| |f|(|n|,| |acc|)| |#=| |#if| |n| |==| |0| |#then| |double|(|acc|)| |#else| |g|(|n| |-| |1|,| |acc| |+| |1|)|↵|@|tailrec| |#fun| |g|(|m|,| |acc|)| |#=| |#if| |m| |==| |0| |#then| |-|double|(|acc|)| |#else| |f|(|m| |-| |1|,| |acc| |+| |1|)|↵|g|(|6|,| |0|)|
+//│ Parsed: {fun double = (x,) => *(x,)(2,); fun f = (n, acc,) => if (==(n,)(0,)) then double(acc,) else g(-(n,)(1,), +(acc,)(1,),); fun g = (m, acc,) => if (==(m,)(0,)) then -(0,)(double(acc,),) else f(-(m,)(1,), +(acc,)(1,),); g(6, 0,)}
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
+//│ Def(0, double, [x$0],
+//│ 1, 
+//│ let x$1 = *(x$0,2) in -- #3
+//│ x$1 -- #2
+//│ )
+//│ Def(1, f, [n$0,acc$0],
+//│ 1, 
+//│ let x$2 = ==(n$0,0) in -- #31
+//│ if x$2 -- #30
+//│   true =>
+//│     let* (x$4) = double(acc$0) in -- #14
+//│     jump j$0(x$4) -- #13
+//│   false =>
+//│     let x$5 = -(n$0,1) in -- #29
+//│     let x$6 = +(acc$0,1) in -- #28
+//│     let* (x$7) = g(x$5,x$6) in -- #27
+//│     jump j$0(x$7) -- #26
+//│ )
+//│ Def(2, j$0, [x$3],
+//│ 1, 
+//│ x$3 -- #7
+//│ )
+//│ Def(3, g, [m$0,acc$1],
+//│ 1, 
+//│ let x$8 = ==(m$0,0) in -- #62
+//│ if x$8 -- #61
+//│   true =>
+//│     let* (x$10) = double(acc$1) in -- #45
+//│     let x$11 = -(0,x$10) in -- #44
+//│     jump j$1(x$11) -- #43
+//│   false =>
+//│     let x$12 = -(m$0,1) in -- #60
+//│     let x$13 = +(acc$1,1) in -- #59
+//│     let* (x$14) = f(x$12,x$13) in -- #58
+//│     jump j$1(x$14) -- #57
+//│ )
+//│ Def(4, j$1, [x$9],
+//│ 1, 
+//│ x$9 -- #35
+//│ )
+//│ },
+//│ let* (x$15) = g(6,0) in -- #70
+//│ x$15 -- #69)
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(j$1), Set(j$0), Set(g, f), Set(double))
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(0, double, [x$0],
+//│ 1, 
+//│ let x$1 = *(x$0,2) in -- #3
+//│ x$1 -- #2
+//│ )
+//│ Def(1, f, [n$0,acc$0],
+//│ 1, 
+//│ let* (r0) = _g_f_opt$5(1,undefined,undefined,n$0,acc$0) in -- #100
+//│ r0 -- #99
+//│ )
+//│ Def(2, j$0, [x$3],
+//│ 1, 
+//│ x$3 -- #7
+//│ )
+//│ Def(3, g, [m$0,acc$1],
+//│ 1, 
+//│ let* (r0) = _g_f_opt$5(3,m$0,acc$1,undefined,undefined) in -- #98
+//│ r0 -- #97
+//│ )
+//│ Def(4, j$1, [x$9],
+//│ 1, 
+//│ x$9 -- #35
+//│ )
+//│ Def(5, _g_f_opt$5, [tailrecBranch$,g_m$0,g_acc$1,f_n$0,f_acc$0],
+//│ 1, 
+//│ jump _g_f_opt_jp$6(tailrecBranch$,g_m$0,g_acc$1,f_n$0,f_acc$0) -- #96
+//│ )
+//│ Def(6, _g_f_opt_jp$6, [tailrecBranch$,g_m$0,g_acc$1,f_n$0,f_acc$0],
+//│ 1, 
+//│ let scrut = ==(1,tailrecBranch$) in -- #95
+//│ if scrut -- #94
+//│   true =>
+//│     let x$2 = ==(f_n$0,0) in -- #93
+//│     if x$2 -- #92
+//│       true =>
+//│         let* (x$4) = double(f_acc$0) in -- #88
+//│         jump j$0(x$4) -- #87
+//│       false =>
+//│         let x$5 = -(f_n$0,1) in -- #91
+//│         let x$6 = +(f_acc$0,1) in -- #90
+//│         jump _g_f_opt_jp$6(3,x$5,x$6,f_n$0,f_acc$0) -- #89
+//│   false =>
+//│     let x$8 = ==(g_m$0,0) in -- #86
+//│     if x$8 -- #85
+//│       true =>
+//│         let* (x$10) = double(g_acc$1) in -- #81
+//│         let x$11 = -(0,x$10) in -- #80
+//│         jump j$1(x$11) -- #79
+//│       false =>
+//│         let x$12 = -(g_m$0,1) in -- #84
+//│         let x$13 = +(g_acc$1,1) in -- #83
+//│         jump _g_f_opt_jp$6(1,g_m$0,g_acc$1,x$12,x$13) -- #82
+//│ )
+//│ },
+//│ let* (x$15) = g(6,0) in -- #70
+//│ x$15 -- #69)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(0, double, [x$0],
+//│ 1, 
+//│ let x$1 = *(x$0,2) in -- #3
+//│ x$1 -- #2
+//│ )
+//│ Def(1, f, [n$0,acc$0],
+//│ 1, 
+//│ let* (r0) = _g_f_opt$5(1,undefined,undefined,n$0,acc$0) in -- #100
+//│ r0 -- #99
+//│ )
+//│ Def(2, j$0, [x$3],
+//│ 1, 
+//│ x$3 -- #7
+//│ )
+//│ Def(3, g, [m$0,acc$1],
+//│ 1, 
+//│ let* (r0) = _g_f_opt$5(3,m$0,acc$1,undefined,undefined) in -- #98
+//│ r0 -- #97
+//│ )
+//│ Def(4, j$1, [x$9],
+//│ 1, 
+//│ x$9 -- #35
+//│ )
+//│ Def(5, _g_f_opt$5, [tailrecBranch$,g_m$0,g_acc$1,f_n$0,f_acc$0],
+//│ 1, 
+//│ jump _g_f_opt_jp$6(tailrecBranch$,g_m$0,g_acc$1,f_n$0,f_acc$0) -- #96
+//│ )
+//│ Def(6, _g_f_opt_jp$6, [tailrecBranch$,g_m$0,g_acc$1,f_n$0,f_acc$0],
+//│ 1, 
+//│ let scrut = ==(1,tailrecBranch$) in -- #95
+//│ if scrut -- #94
+//│   true =>
+//│     let x$2 = ==(f_n$0,0) in -- #93
+//│     if x$2 -- #92
+//│       true =>
+//│         let* (x$4) = double(f_acc$0) in -- #88
+//│         jump j$0(x$4) -- #87
+//│       false =>
+//│         let x$5 = -(f_n$0,1) in -- #91
+//│         let x$6 = +(f_acc$0,1) in -- #90
+//│         jump _g_f_opt_jp$6(3,x$5,x$6,f_n$0,f_acc$0) -- #89
+//│   false =>
+//│     let x$8 = ==(g_m$0,0) in -- #86
+//│     if x$8 -- #85
+//│       true =>
+//│         let* (x$10) = double(g_acc$1) in -- #81
+//│         let x$11 = -(0,x$10) in -- #80
+//│         jump j$1(x$11) -- #79
+//│       false =>
+//│         let x$12 = -(g_m$0,1) in -- #84
+//│         let x$13 = +(g_acc$1,1) in -- #83
+//│         jump _g_f_opt_jp$6(1,g_m$0,g_acc$1,x$12,x$13) -- #82
+//│ )
+//│ },
+//│ let* (x$15) = g(6,0) in -- #70
+//│ x$15 -- #69)
+//│ 
+//│ Interpreted:
+//│ -12
+
+@tailrec fun f(a, b, c) = g(0, 0)
+@tailrec fun g(d, e) = h(0, 0, 0, 0)
+@tailrec fun h(p, q, r, s) = f(0, 0, 0)
+2 
+//│ |@|tailrec| |#fun| |f|(|a|,| |b|,| |c|)| |#=| |g|(|0|,| |0|)|↵|@|tailrec| |#fun| |g|(|d|,| |e|)| |#=| |h|(|0|,| |0|,| |0|,| |0|)|↵|@|tailrec| |#fun| |h|(|p|,| |q|,| |r|,| |s|)| |#=| |f|(|0|,| |0|,| |0|)|↵|2| |
+//│ Parsed: {fun f = (a, b, c,) => g(0, 0,); fun g = (d, e,) => h(0, 0, 0, 0,); fun h = (p, q, r, s,) => f(0, 0, 0,); 2}
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
+//│ Def(0, f, [a$0,b$0,c$0],
+//│ 1, 
+//│ let* (x$0) = g(0,0) in -- #7
+//│ x$0 -- #6
+//│ )
+//│ Def(1, g, [d$0,e$0],
+//│ 1, 
+//│ let* (x$1) = h(0,0,0,0) in -- #19
+//│ x$1 -- #18
+//│ )
+//│ Def(2, h, [p$0,q$0,r$0,s$0],
+//│ 1, 
+//│ let* (x$2) = f(0,0,0) in -- #29
+//│ x$2 -- #28
+//│ )
+//│ },
+//│ 2 -- #30)
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(h, g, f))
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(0, f, [a$0,b$0,c$0],
+//│ 1, 
+//│ let* (r0) = _h_g_f_opt$3(0,undefined,undefined,undefined,undefined,undefined,undefined,a$0,b$0,c$0) in -- #45
+//│ r0 -- #44
+//│ )
+//│ Def(1, g, [d$0,e$0],
+//│ 1, 
+//│ let* (r0) = _h_g_f_opt$3(1,undefined,undefined,undefined,undefined,d$0,e$0,undefined,undefined,undefined) in -- #43
+//│ r0 -- #42
+//│ )
+//│ Def(2, h, [p$0,q$0,r$0,s$0],
+//│ 1, 
+//│ let* (r0) = _h_g_f_opt$3(2,p$0,q$0,r$0,s$0,undefined,undefined,undefined,undefined,undefined) in -- #41
+//│ r0 -- #40
+//│ )
+//│ Def(3, _h_g_f_opt$3, [tailrecBranch$,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0],
+//│ 1, 
+//│ jump _h_g_f_opt_jp$4(tailrecBranch$,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0) -- #39
+//│ )
+//│ Def(4, _h_g_f_opt_jp$4, [tailrecBranch$,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0],
+//│ 1, 
+//│ let scrut = ==(0,tailrecBranch$) in -- #38
+//│ if scrut -- #37
+//│   true =>
+//│     jump _h_g_f_opt_jp$4(1,h_p$0,h_q$0,h_r$0,h_s$0,0,0,f_a$0,f_b$0,f_c$0) -- #34
+//│   false =>
+//│     let scrut = ==(1,tailrecBranch$) in -- #36
+//│     if scrut -- #35
+//│       true =>
+//│         jump _h_g_f_opt_jp$4(2,0,0,0,0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0) -- #33
+//│       false =>
+//│         jump _h_g_f_opt_jp$4(0,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,0,0,0) -- #32
+//│ )
+//│ },
+//│ 2 -- #30)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(0, f, [a$0,b$0,c$0],
+//│ 1, 
+//│ let* (r0) = _h_g_f_opt$3(0,undefined,undefined,undefined,undefined,undefined,undefined,a$0,b$0,c$0) in -- #45
+//│ r0 -- #44
+//│ )
+//│ Def(1, g, [d$0,e$0],
+//│ 1, 
+//│ let* (r0) = _h_g_f_opt$3(1,undefined,undefined,undefined,undefined,d$0,e$0,undefined,undefined,undefined) in -- #43
+//│ r0 -- #42
+//│ )
+//│ Def(2, h, [p$0,q$0,r$0,s$0],
+//│ 1, 
+//│ let* (r0) = _h_g_f_opt$3(2,p$0,q$0,r$0,s$0,undefined,undefined,undefined,undefined,undefined) in -- #41
+//│ r0 -- #40
+//│ )
+//│ Def(3, _h_g_f_opt$3, [tailrecBranch$,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0],
+//│ 1, 
+//│ jump _h_g_f_opt_jp$4(tailrecBranch$,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0) -- #39
+//│ )
+//│ Def(4, _h_g_f_opt_jp$4, [tailrecBranch$,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0],
+//│ 1, 
+//│ let scrut = ==(0,tailrecBranch$) in -- #38
+//│ if scrut -- #37
+//│   true =>
+//│     jump _h_g_f_opt_jp$4(1,h_p$0,h_q$0,h_r$0,h_s$0,0,0,f_a$0,f_b$0,f_c$0) -- #34
+//│   false =>
+//│     let scrut = ==(1,tailrecBranch$) in -- #36
+//│     if scrut -- #35
+//│       true =>
+//│         jump _h_g_f_opt_jp$4(2,0,0,0,0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0) -- #33
+//│       false =>
+//│         jump _h_g_f_opt_jp$4(0,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,0,0,0) -- #32
+//│ )
+//│ },
+//│ 2 -- #30)
+
+:ce
+fun hello() =
+    @tailcall hello()
+    @tailcall hello()
+    2
+hello() 
+//│ |#fun| |hello|(||)| |#=|→|@|tailcall| |hello|(||)|↵|@|tailcall| |hello|(||)|↵|2|←|↵|hello|(||)| |
+//│ Parsed: {fun hello = () => {@tailcall hello(); @tailcall hello(); 2}; hello()}
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
+//│ Def(0, hello, [],
+//│ 1, 
+//│ let* (x$0) = @tailcall hello() in -- #8
+//│ let* (x$1) = @tailcall hello() in -- #7
+//│ 2 -- #6
+//│ )
+//│ },
+//│ let* (x$2) = hello() in -- #12
+//│ x$2 -- #11)
+//│ ╔══[COMPILATION ERROR] not a tail call, as the remaining functions may be impure
+//│ ║  l.594: 	    @tailcall hello()
+//│ ╙──       	              ^^^^^
+//│ ╔══[COMPILATION ERROR] not a tail call
+//│ ║  l.595: 	    @tailcall hello()
+//│ ╙──       	              ^^^^^
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(hello))
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(0, hello, [],
+//│ 1, 
+//│ let* (x$0) = @tailcall hello() in -- #8
+//│ let* (x$1) = @tailcall hello() in -- #7
+//│ 2 -- #6
+//│ )
+//│ },
+//│ let* (x$2) = hello() in -- #12
+//│ x$2 -- #11)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(0, hello, [],
+//│ 1, 
+//│ let* (x$0) = @tailcall hello() in -- #8
+//│ let* (x$1) = @tailcall hello() in -- #7
+//│ 2 -- #6
+//│ )
+//│ },
+//│ let* (x$2) = hello() in -- #12
+//│ x$2 -- #11)
+
+:ce
+fun hello() =
+    @tailcall hello()
+    2
+hello() 
+//│ |#fun| |hello|(||)| |#=|→|@|tailcall| |hello|(||)|↵|2|←|↵|hello|(||)| |
+//│ Parsed: {fun hello = () => {@tailcall hello(); 2}; hello()}
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
+//│ Def(0, hello, [],
+//│ 1, 
+//│ let* (x$0) = @tailcall hello() in -- #4
+//│ 2 -- #3
+//│ )
+//│ },
+//│ let* (x$1) = hello() in -- #8
+//│ x$1 -- #7)
+//│ ╔══[COMPILATION ERROR] not a tail call
+//│ ║  l.646: 	    @tailcall hello()
+//│ ╙──       	              ^^^^^
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(hello))
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(0, hello, [],
+//│ 1, 
+//│ let* (x$0) = @tailcall hello() in -- #4
+//│ 2 -- #3
+//│ )
+//│ },
+//│ let* (x$1) = hello() in -- #8
+//│ x$1 -- #7)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(0, hello, [],
+//│ 1, 
+//│ let* (x$0) = @tailcall hello() in -- #4
+//│ 2 -- #3
+//│ )
+//│ },
+//│ let* (x$1) = hello() in -- #8
+//│ x$1 -- #7)
+
+:interpIR
+class Cons(h, t)
+class Nil
+@tailrec fun addOne(xs) =
+  if xs is
+    Cons(h, t) then Cons(h + 1, @tailcall addOne(t))
+    Nil then Nil
+addOne(Cons(1, Cons(2, Cons(3, Nil))))
+//│ |#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|@|tailrec| |#fun| |addOne|(|xs|)| |#=|→|#if| |xs| |is|→|Cons|(|h|,| |t|)| |#then| |Cons|(|h| |+| |1|,| |@|tailcall| |addOne|(|t|)|)|↵|Nil| |#then| |Nil|←|←|↵|addOne|(|Cons|(|1|,| |Cons|(|2|,| |Cons|(|3|,| |Nil|)|)|)|)|
+//│ Parsed: {class Cons(h, t,) {}; class Nil {}; fun addOne = (xs,) => {if xs is ‹(Cons(h, t,)) then Cons(+(h,)(1,), @tailcall addOne(t,),); (Nil) then Nil›}; addOne(Cons(1, Cons(2, Cons(3, Nil,),),),)}
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, [])}, {
+//│ Def(0, addOne, [xs$0],
+//│ 1, 
+//│ case xs$0 of -- #27
+//│   Cons =>
+//│     let x$1 = xs$0.t in -- #23
+//│     let x$2 = xs$0.h in -- #22
+//│     let x$3 = +(x$2,1) in -- #21
+//│     let* (x$4) = @tailcall addOne(x$1) in -- #20
+//│     let x$5 = Cons(x$3,x$4) in -- #19
+//│     jump j$0(x$5) -- #18
+//│   Nil =>
+//│     let x$6 = Nil() in -- #26
+//│     jump j$0(x$6) -- #25
+//│ )
+//│ Def(1, j$0, [x$0],
+//│ 1, 
+//│ x$0 -- #1
+//│ )
+//│ },
+//│ let x$7 = Nil() in -- #52
+//│ let x$8 = Cons(3,x$7) in -- #51
+//│ let x$9 = Cons(2,x$8) in -- #50
+//│ let x$10 = Cons(1,x$9) in -- #49
+//│ let* (x$11) = addOne(x$10) in -- #48
+//│ x$11 -- #47)
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(j$0), Set(addOne))
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
+//│ Def(0, addOne, [xs$0],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #80
+//│ let* (res) = addOne_modcons$4(idCtx,xs$0) in -- #79
+//│ res -- #78
+//│ )
+//│ Def(1, j$0, [x$0],
+//│ 1, 
+//│ x$0 -- #1
+//│ )
+//│ Def(2, _addOne_ctx_app$2, [ctx,x],
+//│ 1, 
+//│ case ctx of -- #59
+//│   _IdContext =>
+//│     x -- #58
+//│   _Context =>
+//│     let field = ctx.field in -- #57
+//│     let ptr = ctx.ptr in -- #56
+//│     let _ = assign ptr.t := x in -- #55
+//│     let acc = ctx.acc in -- #54
+//│     acc -- #53
+//│ )
+//│ Def(3, _addOne_ctx_comp$3, [ctx1,ctx2],
+//│ 1, 
+//│ let ctx2acc = ctx2.acc in -- #65
+//│ let ctx2ptr = ctx2.ptr in -- #64
+//│ let ctx2field = ctx2.field in -- #63
+//│ let* (newAcc) = _addOne_ctx_app$2(ctx1,ctx2acc) in -- #62
+//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #61
+//│ ret -- #60
+//│ )
+//│ Def(5, addOne_modcons$4_jp, [ctx,xs$0],
+//│ 1, 
+//│ case xs$0 of -- #91
+//│   Cons =>
+//│     let x$1 = xs$0.t in -- #87
+//│     let x$2 = xs$0.h in -- #86
+//│     let x$3 = +(x$2,1) in -- #85
+//│     let x$5 = Cons(x$3,0) in -- #84
+//│     let ctx2 = _Context(x$5,x$5,0) in -- #83
+//│     let* (composed) = _addOne_ctx_comp$3(ctx,ctx2) in -- #82
+//│     jump addOne_modcons$4_jp(composed,x$1) -- #81
+//│   Nil =>
+//│     let x$6 = Nil() in -- #90
+//│     let* (res) = _addOne_ctx_app$2(ctx,x$6) in -- #89
+//│     res -- #88
+//│ )
+//│ Def(6, addOne_modcons$4, [ctx,xs$0],
+//│ 1, 
+//│ let* (r0) = addOne_modcons$4_jp(ctx,xs$0) in -- #93
+//│ r0 -- #92
+//│ )
+//│ },
+//│ let x$7 = Nil() in -- #52
+//│ let x$8 = Cons(3,x$7) in -- #51
+//│ let x$9 = Cons(2,x$8) in -- #50
+//│ let x$10 = Cons(1,x$9) in -- #49
+//│ let* (x$11) = addOne(x$10) in -- #48
+//│ x$11 -- #47)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
+//│ Def(0, addOne, [xs$0],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #80
+//│ let* (res) = addOne_modcons$4(idCtx,xs$0) in -- #79
+//│ res -- #78
+//│ )
+//│ Def(1, j$0, [x$0],
+//│ 1, 
+//│ x$0 -- #1
+//│ )
+//│ Def(2, _addOne_ctx_app$2, [ctx,x],
+//│ 1, 
+//│ case ctx of -- #59
+//│   _IdContext =>
+//│     x -- #58
+//│   _Context =>
+//│     let field = ctx.field in -- #57
+//│     let ptr = ctx.ptr in -- #56
+//│     let _ = assign ptr.t := x in -- #55
+//│     let acc = ctx.acc in -- #54
+//│     acc -- #53
+//│ )
+//│ Def(3, _addOne_ctx_comp$3, [ctx1,ctx2],
+//│ 1, 
+//│ let ctx2acc = ctx2.acc in -- #65
+//│ let ctx2ptr = ctx2.ptr in -- #64
+//│ let ctx2field = ctx2.field in -- #63
+//│ let* (newAcc) = _addOne_ctx_app$2(ctx1,ctx2acc) in -- #62
+//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #61
+//│ ret -- #60
+//│ )
+//│ Def(5, addOne_modcons$4_jp, [ctx,xs$0],
+//│ 1, 
+//│ case xs$0 of -- #91
+//│   Cons =>
+//│     let x$1 = xs$0.t in -- #87
+//│     let x$2 = xs$0.h in -- #86
+//│     let x$3 = +(x$2,1) in -- #85
+//│     let x$5 = Cons(x$3,0) in -- #84
+//│     let ctx2 = _Context(x$5,x$5,0) in -- #83
+//│     let* (composed) = _addOne_ctx_comp$3(ctx,ctx2) in -- #82
+//│     jump addOne_modcons$4_jp(composed,x$1) -- #81
+//│   Nil =>
+//│     let x$6 = Nil() in -- #90
+//│     let* (res) = _addOne_ctx_app$2(ctx,x$6) in -- #89
+//│     res -- #88
+//│ )
+//│ Def(6, addOne_modcons$4, [ctx,xs$0],
+//│ 1, 
+//│ let* (r0) = addOne_modcons$4_jp(ctx,xs$0) in -- #93
+//│ r0 -- #92
+//│ )
+//│ },
+//│ let x$7 = Nil() in -- #52
+//│ let x$8 = Cons(3,x$7) in -- #51
+//│ let x$9 = Cons(2,x$8) in -- #50
+//│ let x$10 = Cons(1,x$9) in -- #49
+//│ let* (x$11) = addOne(x$10) in -- #48
+//│ x$11 -- #47)
+//│ 
+//│ Interpreted:
+//│ Cons(2,Cons(3,Cons(4,Nil())))
+
+:noTailRec
+:interpIR
+class Zero
+class S(x)
+fun a(n) =
+  if n is
+    S(x) then S(@tailcall b(x))
+    Zero then S(Zero)
+fun b(n) =
+  if n is
+    S(x) then S(S(@tailcall a(x)))
+    Zero then S(S(Zero))
+a(S(S(S(Zero))))
+//│ |#class| |Zero|↵|#class| |S|(|x|)|↵|#fun| |a|(|n|)| |#=|→|#if| |n| |is|→|S|(|x|)| |#then| |S|(|@|tailcall| |b|(|x|)|)|↵|Zero| |#then| |S|(|Zero|)|←|←|↵|#fun| |b|(|n|)| |#=|→|#if| |n| |is|→|S|(|x|)| |#then| |S|(|S|(|@|tailcall| |a|(|x|)|)|)|↵|Zero| |#then| |S|(|S|(|Zero|)|)|←|←|↵|a|(|S|(|S|(|S|(|Zero|)|)|)|)|
+//│ Parsed: {class Zero {}; class S(x,) {}; fun a = (n,) => {if n is ‹(S(x,)) then S(@tailcall b(x,),); (Zero) then S(Zero,)›}; fun b = (n,) => {if n is ‹(S(x,)) then S(S(@tailcall a(x,),),); (Zero) then S(S(Zero,),)›}; a(S(S(S(Zero,),),),)}
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Zero, []),ClassInfo(3, S, [x])}, {
+//│ Def(0, a, [n$0],
+//│ 1, 
+//│ case n$0 of -- #23
+//│   S =>
+//│     let x$1 = n$0.x in -- #15
+//│     let* (x$2) = @tailcall b(x$1) in -- #14
+//│     let x$3 = S(x$2) in -- #13
+//│     jump j$0(x$3) -- #12
+//│   Zero =>
+//│     let x$4 = Zero() in -- #22
+//│     let x$5 = S(x$4) in -- #21
+//│     jump j$0(x$5) -- #20
+//│ )
+//│ Def(1, j$0, [x$0],
+//│ 1, 
+//│ x$0 -- #1
+//│ )
+//│ Def(2, b, [n$1],
+//│ 1, 
+//│ case n$1 of -- #55
+//│   S =>
+//│     let x$7 = n$1.x in -- #43
+//│     let* (x$8) = @tailcall a(x$7) in -- #42
+//│     let x$9 = S(x$8) in -- #41
+//│     let x$10 = S(x$9) in -- #40
+//│     jump j$1(x$10) -- #39
+//│   Zero =>
+//│     let x$11 = Zero() in -- #54
+//│     let x$12 = S(x$11) in -- #53
+//│     let x$13 = S(x$12) in -- #52
+//│     jump j$1(x$13) -- #51
+//│ )
+//│ Def(3, j$1, [x$6],
+//│ 1, 
+//│ x$6 -- #25
+//│ )
+//│ },
+//│ let x$14 = Zero() in -- #74
+//│ let x$15 = S(x$14) in -- #73
+//│ let x$16 = S(x$15) in -- #72
+//│ let x$17 = S(x$16) in -- #71
+//│ let* (x$18) = a(x$17) in -- #70
+//│ x$18 -- #69)
+//│ 
+//│ Interpreted:
+//│ S(S(S(S(S(S(Zero()))))))
+
+:interpIR
+class Zero
+class S(x)
+@tailrec fun a(n) =
+  if n is
+    S(x) then S(@tailcall b(x))
+    Zero then S(Zero)
+@tailrec fun b(n) =
+  if n is
+    S(x) then S(S(@tailcall a(x)))
+    Zero then S(S(Zero))
+a(S(S(S(Zero))))
+//│ |#class| |Zero|↵|#class| |S|(|x|)|↵|@|tailrec| |#fun| |a|(|n|)| |#=|→|#if| |n| |is|→|S|(|x|)| |#then| |S|(|@|tailcall| |b|(|x|)|)|↵|Zero| |#then| |S|(|Zero|)|←|←|↵|@|tailrec| |#fun| |b|(|n|)| |#=|→|#if| |n| |is|→|S|(|x|)| |#then| |S|(|S|(|@|tailcall| |a|(|x|)|)|)|↵|Zero| |#then| |S|(|S|(|Zero|)|)|←|←|↵|a|(|S|(|S|(|S|(|Zero|)|)|)|)|
+//│ Parsed: {class Zero {}; class S(x,) {}; fun a = (n,) => {if n is ‹(S(x,)) then S(@tailcall b(x,),); (Zero) then S(Zero,)›}; fun b = (n,) => {if n is ‹(S(x,)) then S(S(@tailcall a(x,),),); (Zero) then S(S(Zero,),)›}; a(S(S(S(Zero,),),),)}
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Zero, []),ClassInfo(3, S, [x])}, {
+//│ Def(0, a, [n$0],
+//│ 1, 
+//│ case n$0 of -- #23
+//│   S =>
+//│     let x$1 = n$0.x in -- #15
+//│     let* (x$2) = @tailcall b(x$1) in -- #14
+//│     let x$3 = S(x$2) in -- #13
+//│     jump j$0(x$3) -- #12
+//│   Zero =>
+//│     let x$4 = Zero() in -- #22
+//│     let x$5 = S(x$4) in -- #21
+//│     jump j$0(x$5) -- #20
+//│ )
+//│ Def(1, j$0, [x$0],
+//│ 1, 
+//│ x$0 -- #1
+//│ )
+//│ Def(2, b, [n$1],
+//│ 1, 
+//│ case n$1 of -- #55
+//│   S =>
+//│     let x$7 = n$1.x in -- #43
+//│     let* (x$8) = @tailcall a(x$7) in -- #42
+//│     let x$9 = S(x$8) in -- #41
+//│     let x$10 = S(x$9) in -- #40
+//│     jump j$1(x$10) -- #39
+//│   Zero =>
+//│     let x$11 = Zero() in -- #54
+//│     let x$12 = S(x$11) in -- #53
+//│     let x$13 = S(x$12) in -- #52
+//│     jump j$1(x$13) -- #51
+//│ )
+//│ Def(3, j$1, [x$6],
+//│ 1, 
+//│ x$6 -- #25
+//│ )
+//│ },
+//│ let x$14 = Zero() in -- #74
+//│ let x$15 = S(x$14) in -- #73
+//│ let x$16 = S(x$15) in -- #72
+//│ let x$17 = S(x$16) in -- #71
+//│ let* (x$18) = a(x$17) in -- #70
+//│ x$18 -- #69)
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(j$1), Set(j$0), Set(b, a))
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Zero, []),ClassInfo(3, S, [x]),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
+//│ Def(0, a, [n$0],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #117
+//│ let* (res) = a_modcons$7(idCtx,n$0) in -- #116
+//│ res -- #115
+//│ )
+//│ Def(1, j$0, [x$0],
+//│ 1, 
+//│ x$0 -- #1
+//│ )
+//│ Def(2, b, [n$1],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #103
+//│ let* (res) = b_modcons$6(idCtx,n$1) in -- #102
+//│ res -- #101
+//│ )
+//│ Def(3, j$1, [x$6],
+//│ 1, 
+//│ x$6 -- #25
+//│ )
+//│ Def(4, _b_a_ctx_app$4, [ctx,x],
+//│ 1, 
+//│ case ctx of -- #81
+//│   _IdContext =>
+//│     x -- #80
+//│   _Context =>
+//│     let field = ctx.field in -- #79
+//│     let ptr = ctx.ptr in -- #78
+//│     let _ = assign ptr.x := x in -- #77
+//│     let acc = ctx.acc in -- #76
+//│     acc -- #75
+//│ )
+//│ Def(5, _b_a_ctx_comp$5, [ctx1,ctx2],
+//│ 1, 
+//│ let ctx2acc = ctx2.acc in -- #87
+//│ let ctx2ptr = ctx2.ptr in -- #86
+//│ let ctx2field = ctx2.field in -- #85
+//│ let* (newAcc) = _b_a_ctx_app$4(ctx1,ctx2acc) in -- #84
+//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #83
+//│ ret -- #82
+//│ )
+//│ Def(6, b_modcons$6, [ctx,n$1],
+//│ 1, 
+//│ let* (r0) = _b_modcons$6_a_modcons$7_opt$8(6,ctx,n$1,undefined,undefined) in -- #156
+//│ r0 -- #155
+//│ )
+//│ Def(7, a_modcons$7, [ctx,n$0],
+//│ 1, 
+//│ let* (r0) = _b_modcons$6_a_modcons$7_opt$8(7,undefined,undefined,ctx,n$0) in -- #158
+//│ r0 -- #157
+//│ )
+//│ Def(8, _b_modcons$6_a_modcons$7_opt$8, [tailrecBranch$,b_modcons$6_ctx,b_modcons$6_n$1,a_modcons$7_ctx,a_modcons$7_n$0],
+//│ 1, 
+//│ jump _b_modcons$6_a_modcons$7_opt_jp$9(tailrecBranch$,b_modcons$6_ctx,b_modcons$6_n$1,a_modcons$7_ctx,a_modcons$7_n$0) -- #154
+//│ )
+//│ Def(9, _b_modcons$6_a_modcons$7_opt_jp$9, [tailrecBranch$,b_modcons$6_ctx,b_modcons$6_n$1,a_modcons$7_ctx,a_modcons$7_n$0],
+//│ 1, 
+//│ let scrut = ==(7,tailrecBranch$) in -- #153
+//│ if scrut -- #152
+//│   true =>
+//│     case a_modcons$7_n$0 of -- #151
+//│       S =>
+//│         let x$1 = a_modcons$7_n$0.x in -- #146
+//│         let x$3 = S(0) in -- #145
+//│         let ctx2 = _Context(x$3,x$3,0) in -- #144
+//│         let* (composed) = _b_a_ctx_comp$5(a_modcons$7_ctx,ctx2) in -- #143
+//│         jump _b_modcons$6_a_modcons$7_opt_jp$9(6,composed,x$1,a_modcons$7_ctx,a_modcons$7_n$0) -- #142
+//│       Zero =>
+//│         let x$4 = Zero() in -- #150
+//│         let x$5 = S(x$4) in -- #149
+//│         let* (res) = _b_a_ctx_app$4(a_modcons$7_ctx,x$5) in -- #148
+//│         res -- #147
+//│   false =>
+//│     case b_modcons$6_n$1 of -- #141
+//│       S =>
+//│         let x$7 = b_modcons$6_n$1.x in -- #135
+//│         let x$9 = S(0) in -- #134
+//│         let x$10 = S(x$9) in -- #133
+//│         let ctx2 = _Context(x$10,x$9,0) in -- #132
+//│         let* (composed) = _b_a_ctx_comp$5(b_modcons$6_ctx,ctx2) in -- #131
+//│         jump _b_modcons$6_a_modcons$7_opt_jp$9(7,b_modcons$6_ctx,b_modcons$6_n$1,composed,x$7) -- #130
+//│       Zero =>
+//│         let x$11 = Zero() in -- #140
+//│         let x$12 = S(x$11) in -- #139
+//│         let x$13 = S(x$12) in -- #138
+//│         let* (res) = _b_a_ctx_app$4(b_modcons$6_ctx,x$13) in -- #137
+//│         res -- #136
+//│ )
+//│ },
+//│ let x$14 = Zero() in -- #74
+//│ let x$15 = S(x$14) in -- #73
+//│ let x$16 = S(x$15) in -- #72
+//│ let x$17 = S(x$16) in -- #71
+//│ let* (x$18) = a(x$17) in -- #70
+//│ x$18 -- #69)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Zero, []),ClassInfo(3, S, [x]),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
+//│ Def(0, a, [n$0],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #117
+//│ let* (res) = a_modcons$7(idCtx,n$0) in -- #116
+//│ res -- #115
+//│ )
+//│ Def(1, j$0, [x$0],
+//│ 1, 
+//│ x$0 -- #1
+//│ )
+//│ Def(2, b, [n$1],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #103
+//│ let* (res) = b_modcons$6(idCtx,n$1) in -- #102
+//│ res -- #101
+//│ )
+//│ Def(3, j$1, [x$6],
+//│ 1, 
+//│ x$6 -- #25
+//│ )
+//│ Def(4, _b_a_ctx_app$4, [ctx,x],
+//│ 1, 
+//│ case ctx of -- #81
+//│   _IdContext =>
+//│     x -- #80
+//│   _Context =>
+//│     let field = ctx.field in -- #79
+//│     let ptr = ctx.ptr in -- #78
+//│     let _ = assign ptr.x := x in -- #77
+//│     let acc = ctx.acc in -- #76
+//│     acc -- #75
+//│ )
+//│ Def(5, _b_a_ctx_comp$5, [ctx1,ctx2],
+//│ 1, 
+//│ let ctx2acc = ctx2.acc in -- #87
+//│ let ctx2ptr = ctx2.ptr in -- #86
+//│ let ctx2field = ctx2.field in -- #85
+//│ let* (newAcc) = _b_a_ctx_app$4(ctx1,ctx2acc) in -- #84
+//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #83
+//│ ret -- #82
+//│ )
+//│ Def(6, b_modcons$6, [ctx,n$1],
+//│ 1, 
+//│ let* (r0) = _b_modcons$6_a_modcons$7_opt$8(6,ctx,n$1,undefined,undefined) in -- #156
+//│ r0 -- #155
+//│ )
+//│ Def(7, a_modcons$7, [ctx,n$0],
+//│ 1, 
+//│ let* (r0) = _b_modcons$6_a_modcons$7_opt$8(7,undefined,undefined,ctx,n$0) in -- #158
+//│ r0 -- #157
+//│ )
+//│ Def(8, _b_modcons$6_a_modcons$7_opt$8, [tailrecBranch$,b_modcons$6_ctx,b_modcons$6_n$1,a_modcons$7_ctx,a_modcons$7_n$0],
+//│ 1, 
+//│ jump _b_modcons$6_a_modcons$7_opt_jp$9(tailrecBranch$,b_modcons$6_ctx,b_modcons$6_n$1,a_modcons$7_ctx,a_modcons$7_n$0) -- #154
+//│ )
+//│ Def(9, _b_modcons$6_a_modcons$7_opt_jp$9, [tailrecBranch$,b_modcons$6_ctx,b_modcons$6_n$1,a_modcons$7_ctx,a_modcons$7_n$0],
+//│ 1, 
+//│ let scrut = ==(7,tailrecBranch$) in -- #153
+//│ if scrut -- #152
+//│   true =>
+//│     case a_modcons$7_n$0 of -- #151
+//│       S =>
+//│         let x$1 = a_modcons$7_n$0.x in -- #146
+//│         let x$3 = S(0) in -- #145
+//│         let ctx2 = _Context(x$3,x$3,0) in -- #144
+//│         let* (composed) = _b_a_ctx_comp$5(a_modcons$7_ctx,ctx2) in -- #143
+//│         jump _b_modcons$6_a_modcons$7_opt_jp$9(6,composed,x$1,a_modcons$7_ctx,a_modcons$7_n$0) -- #142
+//│       Zero =>
+//│         let x$4 = Zero() in -- #150
+//│         let x$5 = S(x$4) in -- #149
+//│         let* (res) = _b_a_ctx_app$4(a_modcons$7_ctx,x$5) in -- #148
+//│         res -- #147
+//│   false =>
+//│     case b_modcons$6_n$1 of -- #141
+//│       S =>
+//│         let x$7 = b_modcons$6_n$1.x in -- #135
+//│         let x$9 = S(0) in -- #134
+//│         let x$10 = S(x$9) in -- #133
+//│         let ctx2 = _Context(x$10,x$9,0) in -- #132
+//│         let* (composed) = _b_a_ctx_comp$5(b_modcons$6_ctx,ctx2) in -- #131
+//│         jump _b_modcons$6_a_modcons$7_opt_jp$9(7,b_modcons$6_ctx,b_modcons$6_n$1,composed,x$7) -- #130
+//│       Zero =>
+//│         let x$11 = Zero() in -- #140
+//│         let x$12 = S(x$11) in -- #139
+//│         let x$13 = S(x$12) in -- #138
+//│         let* (res) = _b_a_ctx_app$4(b_modcons$6_ctx,x$13) in -- #137
+//│         res -- #136
+//│ )
+//│ },
+//│ let x$14 = Zero() in -- #74
+//│ let x$15 = S(x$14) in -- #73
+//│ let x$16 = S(x$15) in -- #72
+//│ let x$17 = S(x$16) in -- #71
+//│ let* (x$18) = a(x$17) in -- #70
+//│ x$18 -- #69)
+//│ 
+//│ Interpreted:
+//│ S(S(S(S(S(S(Zero()))))))
+
+:interpIR
+class Cons(h, t)
+class Nil
+@tailrec fun addOne(xs) =
+  if xs is 
+    Cons(h, t) then
+      val next = @tailcall addOne(t)
+      val ret = Cons(h + 1, next)
+      val rett = ret
+      rett
+    Nil then 
+      Nil
+addOne(Cons(1, Cons(2, Cons(3, Nil))))
+//│ |#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|@|tailrec| |#fun| |addOne|(|xs|)| |#=|→|#if| |xs| |is| |→|Cons|(|h|,| |t|)| |#then|→|#val| |next| |#=| |@|tailcall| |addOne|(|t|)|↵|#val| |ret| |#=| |Cons|(|h| |+| |1|,| |next|)|↵|#val| |rett| |#=| |ret|↵|rett|←|↵|Nil| |#then| |→|Nil|←|←|←|↵|addOne|(|Cons|(|1|,| |Cons|(|2|,| |Cons|(|3|,| |Nil|)|)|)|)|
+//│ Parsed: {class Cons(h, t,) {}; class Nil {}; fun addOne = (xs,) => {if xs is ‹(Cons(h, t,)) then {let next = @tailcall addOne(t,); let ret = Cons(+(h,)(1,), next,); let rett = ret; rett}; (Nil) then {Nil}›}; addOne(Cons(1, Cons(2, Cons(3, Nil,),),),)}
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, [])}, {
+//│ Def(0, addOne, [xs$0],
+//│ 1, 
+//│ case xs$0 of -- #30
+//│   Cons =>
+//│     let x$1 = xs$0.t in -- #26
+//│     let x$2 = xs$0.h in -- #25
+//│     let* (x$3) = @tailcall addOne(x$1) in -- #24
+//│     let x$4 = +(x$2,1) in -- #23
+//│     let x$5 = Cons(x$4,x$3) in -- #22
+//│     jump j$0(x$5) -- #21
+//│   Nil =>
+//│     let x$6 = Nil() in -- #29
+//│     jump j$0(x$6) -- #28
+//│ )
+//│ Def(1, j$0, [x$0],
+//│ 1, 
+//│ x$0 -- #1
+//│ )
+//│ },
+//│ let x$7 = Nil() in -- #55
+//│ let x$8 = Cons(3,x$7) in -- #54
+//│ let x$9 = Cons(2,x$8) in -- #53
+//│ let x$10 = Cons(1,x$9) in -- #52
+//│ let* (x$11) = addOne(x$10) in -- #51
+//│ x$11 -- #50)
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(j$0), Set(addOne))
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
+//│ Def(0, addOne, [xs$0],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #83
+//│ let* (res) = addOne_modcons$4(idCtx,xs$0) in -- #82
+//│ res -- #81
+//│ )
+//│ Def(1, j$0, [x$0],
+//│ 1, 
+//│ x$0 -- #1
+//│ )
+//│ Def(2, _addOne_ctx_app$2, [ctx,x],
+//│ 1, 
+//│ case ctx of -- #62
+//│   _IdContext =>
+//│     x -- #61
+//│   _Context =>
+//│     let field = ctx.field in -- #60
+//│     let ptr = ctx.ptr in -- #59
+//│     let _ = assign ptr.t := x in -- #58
+//│     let acc = ctx.acc in -- #57
+//│     acc -- #56
+//│ )
+//│ Def(3, _addOne_ctx_comp$3, [ctx1,ctx2],
+//│ 1, 
+//│ let ctx2acc = ctx2.acc in -- #68
+//│ let ctx2ptr = ctx2.ptr in -- #67
+//│ let ctx2field = ctx2.field in -- #66
+//│ let* (newAcc) = _addOne_ctx_app$2(ctx1,ctx2acc) in -- #65
+//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #64
+//│ ret -- #63
+//│ )
+//│ Def(5, addOne_modcons$4_jp, [ctx,xs$0],
+//│ 1, 
+//│ case xs$0 of -- #94
+//│   Cons =>
+//│     let x$1 = xs$0.t in -- #90
+//│     let x$2 = xs$0.h in -- #89
+//│     let x$4 = +(x$2,1) in -- #88
+//│     let x$5 = Cons(x$4,0) in -- #87
+//│     let ctx2 = _Context(x$5,x$5,0) in -- #86
+//│     let* (composed) = _addOne_ctx_comp$3(ctx,ctx2) in -- #85
+//│     jump addOne_modcons$4_jp(composed,x$1) -- #84
+//│   Nil =>
+//│     let x$6 = Nil() in -- #93
+//│     let* (res) = _addOne_ctx_app$2(ctx,x$6) in -- #92
+//│     res -- #91
+//│ )
+//│ Def(6, addOne_modcons$4, [ctx,xs$0],
+//│ 1, 
+//│ let* (r0) = addOne_modcons$4_jp(ctx,xs$0) in -- #96
+//│ r0 -- #95
+//│ )
+//│ },
+//│ let x$7 = Nil() in -- #55
+//│ let x$8 = Cons(3,x$7) in -- #54
+//│ let x$9 = Cons(2,x$8) in -- #53
+//│ let x$10 = Cons(1,x$9) in -- #52
+//│ let* (x$11) = addOne(x$10) in -- #51
+//│ x$11 -- #50)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
+//│ Def(0, addOne, [xs$0],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #83
+//│ let* (res) = addOne_modcons$4(idCtx,xs$0) in -- #82
+//│ res -- #81
+//│ )
+//│ Def(1, j$0, [x$0],
+//│ 1, 
+//│ x$0 -- #1
+//│ )
+//│ Def(2, _addOne_ctx_app$2, [ctx,x],
+//│ 1, 
+//│ case ctx of -- #62
+//│   _IdContext =>
+//│     x -- #61
+//│   _Context =>
+//│     let field = ctx.field in -- #60
+//│     let ptr = ctx.ptr in -- #59
+//│     let _ = assign ptr.t := x in -- #58
+//│     let acc = ctx.acc in -- #57
+//│     acc -- #56
+//│ )
+//│ Def(3, _addOne_ctx_comp$3, [ctx1,ctx2],
+//│ 1, 
+//│ let ctx2acc = ctx2.acc in -- #68
+//│ let ctx2ptr = ctx2.ptr in -- #67
+//│ let ctx2field = ctx2.field in -- #66
+//│ let* (newAcc) = _addOne_ctx_app$2(ctx1,ctx2acc) in -- #65
+//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #64
+//│ ret -- #63
+//│ )
+//│ Def(5, addOne_modcons$4_jp, [ctx,xs$0],
+//│ 1, 
+//│ case xs$0 of -- #94
+//│   Cons =>
+//│     let x$1 = xs$0.t in -- #90
+//│     let x$2 = xs$0.h in -- #89
+//│     let x$4 = +(x$2,1) in -- #88
+//│     let x$5 = Cons(x$4,0) in -- #87
+//│     let ctx2 = _Context(x$5,x$5,0) in -- #86
+//│     let* (composed) = _addOne_ctx_comp$3(ctx,ctx2) in -- #85
+//│     jump addOne_modcons$4_jp(composed,x$1) -- #84
+//│   Nil =>
+//│     let x$6 = Nil() in -- #93
+//│     let* (res) = _addOne_ctx_app$2(ctx,x$6) in -- #92
+//│     res -- #91
+//│ )
+//│ Def(6, addOne_modcons$4, [ctx,xs$0],
+//│ 1, 
+//│ let* (r0) = addOne_modcons$4_jp(ctx,xs$0) in -- #96
+//│ r0 -- #95
+//│ )
+//│ },
+//│ let x$7 = Nil() in -- #55
+//│ let x$8 = Cons(3,x$7) in -- #54
+//│ let x$9 = Cons(2,x$8) in -- #53
+//│ let x$10 = Cons(1,x$9) in -- #52
+//│ let* (x$11) = addOne(x$10) in -- #51
+//│ x$11 -- #50)
+//│ 
+//│ Interpreted:
+//│ Cons(2,Cons(3,Cons(4,Nil())))
+
+:interpIR
+class Nil
+class Cons(m, n)
+@tailrec fun a(x) =
+  if x is
+    Cons(m, n) then
+      if m < 0 then
+        Cons(-1, Nil)
+      else 
+        Cons(m * 4, b(m - 2))
+    Nil then Nil
+@tailrec fun b(n) =
+  if n <= 0 then 
+    Cons(0, Nil)
+  else 
+    a(Cons(n, Nil))
+b(16)
+//│ |#class| |Nil|↵|#class| |Cons|(|m|,| |n|)|↵|@|tailrec| |#fun| |a|(|x|)| |#=|→|#if| |x| |is|→|Cons|(|m|,| |n|)| |#then|→|#if| |m| |<| |0| |#then|→|Cons|(|-|1|,| |Nil|)|←|↵|#else| |→|Cons|(|m| |*| |4|,| |b|(|m| |-| |2|)|)|←|←|↵|Nil| |#then| |Nil|←|←|↵|@|tailrec| |#fun| |b|(|n|)| |#=|→|#if| |n| |<=| |0| |#then| |→|Cons|(|0|,| |Nil|)|←|↵|#else| |→|a|(|Cons|(|n|,| |Nil|)|)|←|←|↵|b|(|16|)|
+//│ Parsed: {class Nil {}; class Cons(m, n,) {}; fun a = (x,) => {if x is ‹(Cons(m, n,)) then {if (<(m,)(0,)) then {Cons(-1, Nil,)} else {Cons(*(m,)(4,), b(-(m,)(2,),),)}}; (Nil) then Nil›}; fun b = (n,) => {if (<=(n,)(0,)) then {Cons(0, Nil,)} else {a(Cons(n, Nil,),)}}; b(16,)}
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Nil, []),ClassInfo(3, Cons, [m,n])}, {
+//│ Def(0, a, [x$0],
+//│ 1, 
+//│ case x$0 of -- #46
+//│   Cons =>
+//│     let x$2 = x$0.n in -- #42
+//│     let x$3 = x$0.m in -- #41
+//│     let x$4 = <(x$3,0) in -- #40
+//│     if x$4 -- #39
+//│       true =>
+//│         let x$6 = Nil() in -- #19
+//│         let x$7 = Cons(-1,x$6) in -- #18
+//│         jump j$1(x$7) -- #17
+//│       false =>
+//│         let x$8 = *(x$3,4) in -- #38
+//│         let x$9 = -(x$3,2) in -- #37
+//│         let* (x$10) = b(x$9) in -- #36
+//│         let x$11 = Cons(x$8,x$10) in -- #35
+//│         jump j$1(x$11) -- #34
+//│   Nil =>
+//│     let x$12 = Nil() in -- #45
+//│     jump j$0(x$12) -- #44
+//│ )
+//│ Def(1, j$0, [x$1],
+//│ 1, 
+//│ x$1 -- #1
+//│ )
+//│ Def(2, j$1, [x$5],
+//│ 1, 
+//│ jump j$0(x$5) -- #10
+//│ )
+//│ Def(3, b, [n$0],
+//│ 1, 
+//│ let x$13 = <=(n$0,0) in -- #75
+//│ if x$13 -- #74
+//│   true =>
+//│     let x$15 = Nil() in -- #59
+//│     let x$16 = Cons(0,x$15) in -- #58
+//│     jump j$2(x$16) -- #57
+//│   false =>
+//│     let x$17 = Nil() in -- #73
+//│     let x$18 = Cons(n$0,x$17) in -- #72
+//│     let* (x$19) = a(x$18) in -- #71
+//│     jump j$2(x$19) -- #70
+//│ )
+//│ Def(4, j$2, [x$14],
+//│ 1, 
+//│ x$14 -- #50
+//│ )
+//│ },
+//│ let* (x$20) = b(16) in -- #81
+//│ x$20 -- #80)
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(j$2), Set(j$1), Set(j$0), Set(b, a))
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Nil, []),ClassInfo(3, Cons, [m,n]),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
+//│ Def(0, a, [x$0],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #129
+//│ let* (res) = a_modcons$8(idCtx,x$0) in -- #128
+//│ res -- #127
+//│ )
+//│ Def(1, j$0, [x$1],
+//│ 1, 
+//│ x$1 -- #1
+//│ )
+//│ Def(2, j$1, [x$5],
+//│ 1, 
+//│ jump j$0(x$5) -- #10
+//│ )
+//│ Def(3, b, [n$0],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #107
+//│ let* (res) = b_modcons$7(idCtx,n$0) in -- #106
+//│ res -- #105
+//│ )
+//│ Def(4, j$2, [x$14],
+//│ 1, 
+//│ x$14 -- #50
+//│ )
+//│ Def(5, _b_a_ctx_app$5, [ctx,x],
+//│ 1, 
+//│ case ctx of -- #88
+//│   _IdContext =>
+//│     x -- #87
+//│   _Context =>
+//│     let field = ctx.field in -- #86
+//│     let ptr = ctx.ptr in -- #85
+//│     let _ = assign ptr.n := x in -- #84
+//│     let acc = ctx.acc in -- #83
+//│     acc -- #82
+//│ )
+//│ Def(6, _b_a_ctx_comp$6, [ctx1,ctx2],
+//│ 1, 
+//│ let ctx2acc = ctx2.acc in -- #94
+//│ let ctx2ptr = ctx2.ptr in -- #93
+//│ let ctx2field = ctx2.field in -- #92
+//│ let* (newAcc) = _b_a_ctx_app$5(ctx1,ctx2acc) in -- #91
+//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #90
+//│ ret -- #89
+//│ )
+//│ Def(7, b_modcons$7, [ctx,n$0],
+//│ 1, 
+//│ let* (r0) = _b_modcons$7_a_modcons$8_opt$9(7,ctx,n$0,undefined,undefined) in -- #170
+//│ r0 -- #169
+//│ )
+//│ Def(8, a_modcons$8, [ctx,x$0],
+//│ 1, 
+//│ let* (r0) = _b_modcons$7_a_modcons$8_opt$9(8,undefined,undefined,ctx,x$0) in -- #172
+//│ r0 -- #171
+//│ )
+//│ Def(9, _b_modcons$7_a_modcons$8_opt$9, [tailrecBranch$,b_modcons$7_ctx,b_modcons$7_n$0,a_modcons$8_ctx,a_modcons$8_x$0],
+//│ 1, 
+//│ jump _b_modcons$7_a_modcons$8_opt_jp$10(tailrecBranch$,b_modcons$7_ctx,b_modcons$7_n$0,a_modcons$8_ctx,a_modcons$8_x$0) -- #168
+//│ )
+//│ Def(10, _b_modcons$7_a_modcons$8_opt_jp$10, [tailrecBranch$,b_modcons$7_ctx,b_modcons$7_n$0,a_modcons$8_ctx,a_modcons$8_x$0],
+//│ 1, 
+//│ let scrut = ==(8,tailrecBranch$) in -- #167
+//│ if scrut -- #166
+//│   true =>
+//│     case a_modcons$8_x$0 of -- #165
+//│       Cons =>
+//│         let x$2 = a_modcons$8_x$0.n in -- #161
+//│         let x$3 = a_modcons$8_x$0.m in -- #160
+//│         let x$4 = <(x$3,0) in -- #159
+//│         if x$4 -- #158
+//│           true =>
+//│             let x$6 = Nil() in -- #151
+//│             let x$7 = Cons(-1,x$6) in -- #150
+//│             let* (res) = _b_a_ctx_app$5(a_modcons$8_ctx,x$7) in -- #149
+//│             res -- #148
+//│           false =>
+//│             let x$8 = *(x$3,4) in -- #157
+//│             let x$9 = -(x$3,2) in -- #156
+//│             let x$11 = Cons(x$8,0) in -- #155
+//│             let ctx2 = _Context(x$11,x$11,0) in -- #154
+//│             let* (composed) = _b_a_ctx_comp$6(a_modcons$8_ctx,ctx2) in -- #153
+//│             jump _b_modcons$7_a_modcons$8_opt_jp$10(7,composed,x$9,a_modcons$8_ctx,a_modcons$8_x$0) -- #152
+//│       Nil =>
+//│         let x$12 = Nil() in -- #164
+//│         let* (res) = _b_a_ctx_app$5(a_modcons$8_ctx,x$12) in -- #163
+//│         res -- #162
+//│   false =>
+//│     let x$13 = <=(b_modcons$7_n$0,0) in -- #147
+//│     if x$13 -- #146
+//│       true =>
+//│         let x$15 = Nil() in -- #142
+//│         let x$16 = Cons(0,x$15) in -- #141
+//│         let* (res) = _b_a_ctx_app$5(b_modcons$7_ctx,x$16) in -- #140
+//│         res -- #139
+//│       false =>
+//│         let x$17 = Nil() in -- #145
+//│         let x$18 = Cons(b_modcons$7_n$0,x$17) in -- #144
+//│         jump _b_modcons$7_a_modcons$8_opt_jp$10(8,b_modcons$7_ctx,b_modcons$7_n$0,b_modcons$7_ctx,x$18) -- #143
+//│ )
+//│ },
+//│ let* (x$20) = b(16) in -- #81
+//│ x$20 -- #80)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Nil, []),ClassInfo(3, Cons, [m,n]),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
+//│ Def(0, a, [x$0],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #129
+//│ let* (res) = a_modcons$8(idCtx,x$0) in -- #128
+//│ res -- #127
+//│ )
+//│ Def(1, j$0, [x$1],
+//│ 1, 
+//│ x$1 -- #1
+//│ )
+//│ Def(2, j$1, [x$5],
+//│ 1, 
+//│ jump j$0(x$5) -- #10
+//│ )
+//│ Def(3, b, [n$0],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #107
+//│ let* (res) = b_modcons$7(idCtx,n$0) in -- #106
+//│ res -- #105
+//│ )
+//│ Def(4, j$2, [x$14],
+//│ 1, 
+//│ x$14 -- #50
+//│ )
+//│ Def(5, _b_a_ctx_app$5, [ctx,x],
+//│ 1, 
+//│ case ctx of -- #88
+//│   _IdContext =>
+//│     x -- #87
+//│   _Context =>
+//│     let field = ctx.field in -- #86
+//│     let ptr = ctx.ptr in -- #85
+//│     let _ = assign ptr.n := x in -- #84
+//│     let acc = ctx.acc in -- #83
+//│     acc -- #82
+//│ )
+//│ Def(6, _b_a_ctx_comp$6, [ctx1,ctx2],
+//│ 1, 
+//│ let ctx2acc = ctx2.acc in -- #94
+//│ let ctx2ptr = ctx2.ptr in -- #93
+//│ let ctx2field = ctx2.field in -- #92
+//│ let* (newAcc) = _b_a_ctx_app$5(ctx1,ctx2acc) in -- #91
+//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #90
+//│ ret -- #89
+//│ )
+//│ Def(7, b_modcons$7, [ctx,n$0],
+//│ 1, 
+//│ let* (r0) = _b_modcons$7_a_modcons$8_opt$9(7,ctx,n$0,undefined,undefined) in -- #170
+//│ r0 -- #169
+//│ )
+//│ Def(8, a_modcons$8, [ctx,x$0],
+//│ 1, 
+//│ let* (r0) = _b_modcons$7_a_modcons$8_opt$9(8,undefined,undefined,ctx,x$0) in -- #172
+//│ r0 -- #171
+//│ )
+//│ Def(9, _b_modcons$7_a_modcons$8_opt$9, [tailrecBranch$,b_modcons$7_ctx,b_modcons$7_n$0,a_modcons$8_ctx,a_modcons$8_x$0],
+//│ 1, 
+//│ jump _b_modcons$7_a_modcons$8_opt_jp$10(tailrecBranch$,b_modcons$7_ctx,b_modcons$7_n$0,a_modcons$8_ctx,a_modcons$8_x$0) -- #168
+//│ )
+//│ Def(10, _b_modcons$7_a_modcons$8_opt_jp$10, [tailrecBranch$,b_modcons$7_ctx,b_modcons$7_n$0,a_modcons$8_ctx,a_modcons$8_x$0],
+//│ 1, 
+//│ let scrut = ==(8,tailrecBranch$) in -- #167
+//│ if scrut -- #166
+//│   true =>
+//│     case a_modcons$8_x$0 of -- #165
+//│       Cons =>
+//│         let x$2 = a_modcons$8_x$0.n in -- #161
+//│         let x$3 = a_modcons$8_x$0.m in -- #160
+//│         let x$4 = <(x$3,0) in -- #159
+//│         if x$4 -- #158
+//│           true =>
+//│             let x$6 = Nil() in -- #151
+//│             let x$7 = Cons(-1,x$6) in -- #150
+//│             let* (res) = _b_a_ctx_app$5(a_modcons$8_ctx,x$7) in -- #149
+//│             res -- #148
+//│           false =>
+//│             let x$8 = *(x$3,4) in -- #157
+//│             let x$9 = -(x$3,2) in -- #156
+//│             let x$11 = Cons(x$8,0) in -- #155
+//│             let ctx2 = _Context(x$11,x$11,0) in -- #154
+//│             let* (composed) = _b_a_ctx_comp$6(a_modcons$8_ctx,ctx2) in -- #153
+//│             jump _b_modcons$7_a_modcons$8_opt_jp$10(7,composed,x$9,a_modcons$8_ctx,a_modcons$8_x$0) -- #152
+//│       Nil =>
+//│         let x$12 = Nil() in -- #164
+//│         let* (res) = _b_a_ctx_app$5(a_modcons$8_ctx,x$12) in -- #163
+//│         res -- #162
+//│   false =>
+//│     let x$13 = <=(b_modcons$7_n$0,0) in -- #147
+//│     if x$13 -- #146
+//│       true =>
+//│         let x$15 = Nil() in -- #142
+//│         let x$16 = Cons(0,x$15) in -- #141
+//│         let* (res) = _b_a_ctx_app$5(b_modcons$7_ctx,x$16) in -- #140
+//│         res -- #139
+//│       false =>
+//│         let x$17 = Nil() in -- #145
+//│         let x$18 = Cons(b_modcons$7_n$0,x$17) in -- #144
+//│         jump _b_modcons$7_a_modcons$8_opt_jp$10(8,b_modcons$7_ctx,b_modcons$7_n$0,b_modcons$7_ctx,x$18) -- #143
+//│ )
+//│ },
+//│ let* (x$20) = b(16) in -- #81
+//│ x$20 -- #80)
+//│ 
+//│ Interpreted:
+//│ Cons(64,Cons(56,Cons(48,Cons(40,Cons(32,Cons(24,Cons(16,Cons(8,Cons(0,Nil())))))))))
+
+:noTailRec
+:interpIR
+class Cons(h, t)
+class Nil
+fun foo(xs) =
+  if xs is 
+    Cons(h, t) then
+      if h > 5 then foo(t)
+      else 
+        val item = if h < 3 then -1 else 100 
+        Cons(item, Cons(h, foo(t)))
+    Nil then 
+      Nil
+foo(Cons(1, Cons(6, Cons(7, Cons(4, Cons(2, Cons(3, Cons(9, Nil))))))))
+//│ |#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|#fun| |foo|(|xs|)| |#=|→|#if| |xs| |is| |→|Cons|(|h|,| |t|)| |#then|→|#if| |h| |>| |5| |#then| |foo|(|t|)|↵|#else| |→|#val| |item| |#=| |#if| |h| |<| |3| |#then| |-|1| |#else| |100| |↵|Cons|(|item|,| |Cons|(|h|,| |foo|(|t|)|)|)|←|←|↵|Nil| |#then| |→|Nil|←|←|←|↵|foo|(|Cons|(|1|,| |Cons|(|6|,| |Cons|(|7|,| |Cons|(|4|,| |Cons|(|2|,| |Cons|(|3|,| |Cons|(|9|,| |Nil|)|)|)|)|)|)|)|)|
+//│ Parsed: {class Cons(h, t,) {}; class Nil {}; fun foo = (xs,) => {if xs is ‹(Cons(h, t,)) then {if (>(h,)(5,)) then foo(t,) else {let item = if (<(h,)(3,)) then -1 else 100; Cons(item, Cons(h, foo(t,),),)}}; (Nil) then {Nil}›}; foo(Cons(1, Cons(6, Cons(7, Cons(4, Cons(2, Cons(3, Cons(9, Nil,),),),),),),),)}
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, [])}, {
+//│ Def(0, foo, [xs$0],
+//│ 1, 
+//│ case xs$0 of -- #54
+//│   Cons =>
+//│     let x$1 = xs$0.t in -- #50
+//│     let x$2 = xs$0.h in -- #49
+//│     let x$3 = >(x$2,5) in -- #48
+//│     if x$3 -- #47
+//│       true =>
+//│         let* (x$5) = foo(x$1) in -- #17
+//│         jump j$1(x$5) -- #16
+//│       false =>
+//│         let x$6 = <(x$2,3) in -- #46
+//│         if x$6 -- #45
+//│           true =>
+//│             jump j$2(-1,x$1,x$2) -- #42
+//│           false =>
+//│             jump j$2(100,x$1,x$2) -- #44
+//│   Nil =>
+//│     let x$11 = Nil() in -- #53
+//│     jump j$0(x$11) -- #52
+//│ )
+//│ Def(1, j$0, [x$0],
+//│ 1, 
+//│ x$0 -- #1
+//│ )
+//│ Def(2, j$1, [x$4],
+//│ 1, 
+//│ jump j$0(x$4) -- #10
+//│ )
+//│ Def(3, j$2, [x$7,x$1,x$2],
+//│ 1, 
+//│ let* (x$8) = foo(x$1) in -- #40
+//│ let x$9 = Cons(x$2,x$8) in -- #39
+//│ let x$10 = Cons(x$7,x$9) in -- #38
+//│ jump j$1(x$10) -- #37
+//│ )
+//│ },
+//│ let x$12 = Nil() in -- #103
+//│ let x$13 = Cons(9,x$12) in -- #102
+//│ let x$14 = Cons(3,x$13) in -- #101
+//│ let x$15 = Cons(2,x$14) in -- #100
+//│ let x$16 = Cons(4,x$15) in -- #99
+//│ let x$17 = Cons(7,x$16) in -- #98
+//│ let x$18 = Cons(6,x$17) in -- #97
+//│ let x$19 = Cons(1,x$18) in -- #96
+//│ let* (x$20) = foo(x$19) in -- #95
+//│ x$20 -- #94)
+//│ 
+//│ Interpreted:
+//│ Cons(-1,Cons(1,Cons(100,Cons(4,Cons(-1,Cons(2,Cons(100,Cons(3,Nil()))))))))
+
+:interpIR
+class Cons(h, t)
+class Nil
+@tailrec fun foo(xs) =
+  if xs is 
+    Cons(h, t) then
+      if h > 5 then @tailcall foo(t)
+      else 
+        val item = if h < 3 then -1 else 100 
+        Cons(item, Cons(h, @tailcall foo(t)))
+    Nil then 
+      Nil
+foo(Cons(1, Cons(6, Cons(7, Cons(4, Cons(2, Cons(3, Cons(9, Nil))))))))
+//│ |#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|@|tailrec| |#fun| |foo|(|xs|)| |#=|→|#if| |xs| |is| |→|Cons|(|h|,| |t|)| |#then|→|#if| |h| |>| |5| |#then| |@|tailcall| |foo|(|t|)|↵|#else| |→|#val| |item| |#=| |#if| |h| |<| |3| |#then| |-|1| |#else| |100| |↵|Cons|(|item|,| |Cons|(|h|,| |@|tailcall| |foo|(|t|)|)|)|←|←|↵|Nil| |#then| |→|Nil|←|←|←|↵|foo|(|Cons|(|1|,| |Cons|(|6|,| |Cons|(|7|,| |Cons|(|4|,| |Cons|(|2|,| |Cons|(|3|,| |Cons|(|9|,| |Nil|)|)|)|)|)|)|)|)|
+//│ Parsed: {class Cons(h, t,) {}; class Nil {}; fun foo = (xs,) => {if xs is ‹(Cons(h, t,)) then {if (>(h,)(5,)) then @tailcall foo(t,) else {let item = if (<(h,)(3,)) then -1 else 100; Cons(item, Cons(h, @tailcall foo(t,),),)}}; (Nil) then {Nil}›}; foo(Cons(1, Cons(6, Cons(7, Cons(4, Cons(2, Cons(3, Cons(9, Nil,),),),),),),),)}
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, [])}, {
+//│ Def(0, foo, [xs$0],
+//│ 1, 
+//│ case xs$0 of -- #54
+//│   Cons =>
+//│     let x$1 = xs$0.t in -- #50
+//│     let x$2 = xs$0.h in -- #49
+//│     let x$3 = >(x$2,5) in -- #48
+//│     if x$3 -- #47
+//│       true =>
+//│         let* (x$5) = @tailcall foo(x$1) in -- #17
+//│         jump j$1(x$5) -- #16
+//│       false =>
+//│         let x$6 = <(x$2,3) in -- #46
+//│         if x$6 -- #45
+//│           true =>
+//│             jump j$2(-1,x$1,x$2) -- #42
+//│           false =>
+//│             jump j$2(100,x$1,x$2) -- #44
+//│   Nil =>
+//│     let x$11 = Nil() in -- #53
+//│     jump j$0(x$11) -- #52
+//│ )
+//│ Def(1, j$0, [x$0],
+//│ 1, 
+//│ x$0 -- #1
+//│ )
+//│ Def(2, j$1, [x$4],
+//│ 1, 
+//│ jump j$0(x$4) -- #10
+//│ )
+//│ Def(3, j$2, [x$7,x$1,x$2],
+//│ 1, 
+//│ let* (x$8) = @tailcall foo(x$1) in -- #40
+//│ let x$9 = Cons(x$2,x$8) in -- #39
+//│ let x$10 = Cons(x$7,x$9) in -- #38
+//│ jump j$1(x$10) -- #37
+//│ )
+//│ },
+//│ let x$12 = Nil() in -- #103
+//│ let x$13 = Cons(9,x$12) in -- #102
+//│ let x$14 = Cons(3,x$13) in -- #101
+//│ let x$15 = Cons(2,x$14) in -- #100
+//│ let x$16 = Cons(4,x$15) in -- #99
+//│ let x$17 = Cons(7,x$16) in -- #98
+//│ let x$18 = Cons(6,x$17) in -- #97
+//│ let x$19 = Cons(1,x$18) in -- #96
+//│ let* (x$20) = foo(x$19) in -- #95
+//│ x$20 -- #94)
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(j$1), Set(j$0), Set(foo))
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
+//│ Def(0, foo, [xs$0],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #137
+//│ let* (res) = foo_modcons$7(idCtx,xs$0) in -- #136
+//│ res -- #135
+//│ )
+//│ Def(1, j$0, [x$0],
+//│ 1, 
+//│ x$0 -- #1
+//│ )
+//│ Def(2, j$1, [x$4],
+//│ 1, 
+//│ jump j$0(x$4) -- #10
+//│ )
+//│ Def(4, _foo_ctx_app$4, [ctx,x],
+//│ 1, 
+//│ case ctx of -- #110
+//│   _IdContext =>
+//│     x -- #109
+//│   _Context =>
+//│     let field = ctx.field in -- #108
+//│     let ptr = ctx.ptr in -- #107
+//│     let _ = assign ptr.t := x in -- #106
+//│     let acc = ctx.acc in -- #105
+//│     acc -- #104
+//│ )
+//│ Def(5, _foo_ctx_comp$5, [ctx1,ctx2],
+//│ 1, 
+//│ let ctx2acc = ctx2.acc in -- #116
+//│ let ctx2ptr = ctx2.ptr in -- #115
+//│ let ctx2field = ctx2.field in -- #114
+//│ let* (newAcc) = _foo_ctx_app$4(ctx1,ctx2acc) in -- #113
+//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #112
+//│ ret -- #111
+//│ )
+//│ Def(7, foo_modcons$7, [ctx,xs$0],
+//│ 1, 
+//│ let* (r0) = _foo_modcons$7_j$2_modcons$6_opt$8(7,ctx,xs$0,undefined,undefined,undefined,undefined) in -- #173
+//│ r0 -- #172
+//│ )
+//│ Def(8, _foo_modcons$7_j$2_modcons$6_opt$8, [tailrecBranch$,foo_modcons$7_ctx,foo_modcons$7_xs$0,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2],
+//│ 1, 
+//│ jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(tailrecBranch$,foo_modcons$7_ctx,foo_modcons$7_xs$0,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2) -- #171
+//│ )
+//│ Def(9, _foo_modcons$7_j$2_modcons$6_opt_jp$9, [tailrecBranch$,foo_modcons$7_ctx,foo_modcons$7_xs$0,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2],
+//│ 1, 
+//│ let scrut = ==(6,tailrecBranch$) in -- #170
+//│ if scrut -- #169
+//│   true =>
+//│     let x$9 = Cons(j$2_modcons$6_x$2,0) in -- #168
+//│     let x$10 = Cons(j$2_modcons$6_x$7,x$9) in -- #167
+//│     let ctx2 = _Context(x$10,x$9,0) in -- #166
+//│     let* (composed) = _foo_ctx_comp$5(j$2_modcons$6_ctx,ctx2) in -- #165
+//│     jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(7,composed,j$2_modcons$6_x$1,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2) -- #164
+//│   false =>
+//│     case foo_modcons$7_xs$0 of -- #163
+//│       Cons =>
+//│         let x$1 = foo_modcons$7_xs$0.t in -- #159
+//│         let x$2 = foo_modcons$7_xs$0.h in -- #158
+//│         let x$3 = >(x$2,5) in -- #157
+//│         if x$3 -- #156
+//│           true =>
+//│             jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(7,foo_modcons$7_ctx,x$1,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2) -- #151
+//│           false =>
+//│             let x$6 = <(x$2,3) in -- #155
+//│             if x$6 -- #154
+//│               true =>
+//│                 jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(6,foo_modcons$7_ctx,foo_modcons$7_xs$0,foo_modcons$7_ctx,-1,x$1,x$2) -- #152
+//│               false =>
+//│                 jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(6,foo_modcons$7_ctx,foo_modcons$7_xs$0,foo_modcons$7_ctx,100,x$1,x$2) -- #153
+//│       Nil =>
+//│         let x$11 = Nil() in -- #162
+//│         let* (res) = _foo_ctx_app$4(foo_modcons$7_ctx,x$11) in -- #161
+//│         res -- #160
+//│ )
+//│ },
+//│ let x$12 = Nil() in -- #103
+//│ let x$13 = Cons(9,x$12) in -- #102
+//│ let x$14 = Cons(3,x$13) in -- #101
+//│ let x$15 = Cons(2,x$14) in -- #100
+//│ let x$16 = Cons(4,x$15) in -- #99
+//│ let x$17 = Cons(7,x$16) in -- #98
+//│ let x$18 = Cons(6,x$17) in -- #97
+//│ let x$19 = Cons(1,x$18) in -- #96
+//│ let* (x$20) = foo(x$19) in -- #95
+//│ x$20 -- #94)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
+//│ Def(0, foo, [xs$0],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #137
+//│ let* (res) = foo_modcons$7(idCtx,xs$0) in -- #136
+//│ res -- #135
+//│ )
+//│ Def(1, j$0, [x$0],
+//│ 1, 
+//│ x$0 -- #1
+//│ )
+//│ Def(2, j$1, [x$4],
+//│ 1, 
+//│ jump j$0(x$4) -- #10
+//│ )
+//│ Def(4, _foo_ctx_app$4, [ctx,x],
+//│ 1, 
+//│ case ctx of -- #110
+//│   _IdContext =>
+//│     x -- #109
+//│   _Context =>
+//│     let field = ctx.field in -- #108
+//│     let ptr = ctx.ptr in -- #107
+//│     let _ = assign ptr.t := x in -- #106
+//│     let acc = ctx.acc in -- #105
+//│     acc -- #104
+//│ )
+//│ Def(5, _foo_ctx_comp$5, [ctx1,ctx2],
+//│ 1, 
+//│ let ctx2acc = ctx2.acc in -- #116
+//│ let ctx2ptr = ctx2.ptr in -- #115
+//│ let ctx2field = ctx2.field in -- #114
+//│ let* (newAcc) = _foo_ctx_app$4(ctx1,ctx2acc) in -- #113
+//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #112
+//│ ret -- #111
+//│ )
+//│ Def(7, foo_modcons$7, [ctx,xs$0],
+//│ 1, 
+//│ let* (r0) = _foo_modcons$7_j$2_modcons$6_opt$8(7,ctx,xs$0,undefined,undefined,undefined,undefined) in -- #173
+//│ r0 -- #172
+//│ )
+//│ Def(8, _foo_modcons$7_j$2_modcons$6_opt$8, [tailrecBranch$,foo_modcons$7_ctx,foo_modcons$7_xs$0,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2],
+//│ 1, 
+//│ jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(tailrecBranch$,foo_modcons$7_ctx,foo_modcons$7_xs$0,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2) -- #171
+//│ )
+//│ Def(9, _foo_modcons$7_j$2_modcons$6_opt_jp$9, [tailrecBranch$,foo_modcons$7_ctx,foo_modcons$7_xs$0,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2],
+//│ 1, 
+//│ let scrut = ==(6,tailrecBranch$) in -- #170
+//│ if scrut -- #169
+//│   true =>
+//│     let x$9 = Cons(j$2_modcons$6_x$2,0) in -- #168
+//│     let x$10 = Cons(j$2_modcons$6_x$7,x$9) in -- #167
+//│     let ctx2 = _Context(x$10,x$9,0) in -- #166
+//│     let* (composed) = _foo_ctx_comp$5(j$2_modcons$6_ctx,ctx2) in -- #165
+//│     jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(7,composed,j$2_modcons$6_x$1,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2) -- #164
+//│   false =>
+//│     case foo_modcons$7_xs$0 of -- #163
+//│       Cons =>
+//│         let x$1 = foo_modcons$7_xs$0.t in -- #159
+//│         let x$2 = foo_modcons$7_xs$0.h in -- #158
+//│         let x$3 = >(x$2,5) in -- #157
+//│         if x$3 -- #156
+//│           true =>
+//│             jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(7,foo_modcons$7_ctx,x$1,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2) -- #151
+//│           false =>
+//│             let x$6 = <(x$2,3) in -- #155
+//│             if x$6 -- #154
+//│               true =>
+//│                 jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(6,foo_modcons$7_ctx,foo_modcons$7_xs$0,foo_modcons$7_ctx,-1,x$1,x$2) -- #152
+//│               false =>
+//│                 jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(6,foo_modcons$7_ctx,foo_modcons$7_xs$0,foo_modcons$7_ctx,100,x$1,x$2) -- #153
+//│       Nil =>
+//│         let x$11 = Nil() in -- #162
+//│         let* (res) = _foo_ctx_app$4(foo_modcons$7_ctx,x$11) in -- #161
+//│         res -- #160
+//│ )
+//│ },
+//│ let x$12 = Nil() in -- #103
+//│ let x$13 = Cons(9,x$12) in -- #102
+//│ let x$14 = Cons(3,x$13) in -- #101
+//│ let x$15 = Cons(2,x$14) in -- #100
+//│ let x$16 = Cons(4,x$15) in -- #99
+//│ let x$17 = Cons(7,x$16) in -- #98
+//│ let x$18 = Cons(6,x$17) in -- #97
+//│ let x$19 = Cons(1,x$18) in -- #96
+//│ let* (x$20) = foo(x$19) in -- #95
+//│ x$20 -- #94)
+//│ 
+//│ Interpreted:
+//│ Cons(-1,Cons(1,Cons(100,Cons(4,Cons(-1,Cons(2,Cons(100,Cons(3,Nil()))))))))
+
+:ce
+fun b() =
+  a()
+  a()
+@tailrec 
+fun a() = 
+  if 0 < 1 then a()
+  else b()
+a()
+//│ |#fun| |b|(||)| |#=|→|a|(||)|↵|a|(||)|←|↵|@|tailrec| |↵|#fun| |a|(||)| |#=| |→|#if| |0| |<| |1| |#then| |a|(||)|↵|#else| |b|(||)|←|↵|a|(||)|
+//│ Parsed: {fun b = () => {a(); a()}; fun a = () => {if (<(0,)(1,)) then a() else b()}; a()}
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
+//│ Def(0, b, [],
+//│ 1, 
+//│ let* (x$0) = a() in -- #7
+//│ let* (x$1) = a() in -- #6
+//│ x$1 -- #5
+//│ )
+//│ Def(1, a, [],
+//│ 1, 
+//│ let x$2 = <(0,1) in -- #23
+//│ if x$2 -- #22
+//│   true =>
+//│     let* (x$4) = a() in -- #16
+//│     jump j$0(x$4) -- #15
+//│   false =>
+//│     let* (x$5) = b() in -- #21
+//│     jump j$0(x$5) -- #20
+//│ )
+//│ Def(2, j$0, [x$3],
+//│ 1, 
+//│ x$3 -- #11
+//│ )
+//│ },
+//│ let* (x$6) = a() in -- #27
+//│ x$6 -- #26)
+//│ ╔══[COMPILATION ERROR] function `a` is not tail-recursive, but is marked as @tailrec
+//│ ║  l.1966: 	@tailrec 
+//│ ║          	 ^^^^^^^
+//│ ╟── it could self-recurse through this call, which may not be a tail-call
+//│ ║  l.1964: 	  a()
+//│ ╙──        	  ^
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(j$0), Set(a, b))
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(0, b, [],
+//│ 1, 
+//│ let* (r0) = _a_b_opt$3(0) in -- #44
+//│ r0 -- #43
+//│ )
+//│ Def(1, a, [],
+//│ 1, 
+//│ let* (r0) = _a_b_opt$3(1) in -- #42
+//│ r0 -- #41
+//│ )
+//│ Def(2, j$0, [x$3],
+//│ 1, 
+//│ x$3 -- #11
+//│ )
+//│ Def(3, _a_b_opt$3, [tailrecBranch$],
+//│ 1, 
+//│ jump _a_b_opt_jp$4(tailrecBranch$) -- #40
+//│ )
+//│ Def(4, _a_b_opt_jp$4, [tailrecBranch$],
+//│ 1, 
+//│ let scrut = ==(0,tailrecBranch$) in -- #39
+//│ if scrut -- #38
+//│   true =>
+//│     let* (x$0) = a() in -- #37
+//│     jump _a_b_opt_jp$4(1) -- #36
+//│   false =>
+//│     let x$2 = <(0,1) in -- #35
+//│     if x$2 -- #34
+//│       true =>
+//│         jump _a_b_opt_jp$4(1) -- #32
+//│       false =>
+//│         jump _a_b_opt_jp$4(0) -- #33
+//│ )
+//│ },
+//│ let* (x$6) = a() in -- #27
+//│ x$6 -- #26)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(0, b, [],
+//│ 1, 
+//│ let* (r0) = _a_b_opt$3(0) in -- #44
+//│ r0 -- #43
+//│ )
+//│ Def(1, a, [],
+//│ 1, 
+//│ let* (r0) = _a_b_opt$3(1) in -- #42
+//│ r0 -- #41
+//│ )
+//│ Def(2, j$0, [x$3],
+//│ 1, 
+//│ x$3 -- #11
+//│ )
+//│ Def(3, _a_b_opt$3, [tailrecBranch$],
+//│ 1, 
+//│ jump _a_b_opt_jp$4(tailrecBranch$) -- #40
+//│ )
+//│ Def(4, _a_b_opt_jp$4, [tailrecBranch$],
+//│ 1, 
+//│ let scrut = ==(0,tailrecBranch$) in -- #39
+//│ if scrut -- #38
+//│   true =>
+//│     let* (x$0) = a() in -- #37
+//│     jump _a_b_opt_jp$4(1) -- #36
+//│   false =>
+//│     let x$2 = <(0,1) in -- #35
+//│     if x$2 -- #34
+//│       true =>
+//│         jump _a_b_opt_jp$4(1) -- #32
+//│       false =>
+//│         jump _a_b_opt_jp$4(0) -- #33
+//│ )
+//│ },
+//│ let* (x$6) = a() in -- #27
+//│ x$6 -- #26)
+
+:ce
+class A(a, b)
+@tailrec
+fun a() = A(b(), 1)
+fun b() = A(c(), @tailcall a())
+fun c() = A(b(), 1)
+a()
+//│ |#class| |A|(|a|,| |b|)|↵|@|tailrec|↵|#fun| |a|(||)| |#=| |A|(|b|(||)|,| |1|)|↵|#fun| |b|(||)| |#=| |A|(|c|(||)|,| |@|tailcall| |a|(||)|)|↵|#fun| |c|(||)| |#=| |A|(|b|(||)|,| |1|)|↵|a|(||)|
+//│ Parsed: {class A(a, b,) {}; fun a = () => A(b(), 1,); fun b = () => A(c(), @tailcall a(),); fun c = () => A(b(), 1,); a()}
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [a,b])}, {
+//│ Def(0, a, [],
+//│ 1, 
+//│ let* (x$0) = b() in -- #9
+//│ let x$1 = A(x$0,1) in -- #8
+//│ x$1 -- #7
+//│ )
+//│ Def(1, b, [],
+//│ 1, 
+//│ let* (x$2) = c() in -- #22
+//│ let* (x$3) = @tailcall a() in -- #21
+//│ let x$4 = A(x$2,x$3) in -- #20
+//│ x$4 -- #19
+//│ )
+//│ Def(2, c, [],
+//│ 1, 
+//│ let* (x$5) = b() in -- #32
+//│ let x$6 = A(x$5,1) in -- #31
+//│ x$6 -- #30
+//│ )
+//│ },
+//│ let* (x$7) = a() in -- #36
+//│ x$7 -- #35)
+//│ ╔══[COMPILATION ERROR] function `a` is not tail-recursive, but is marked as @tailrec
+//│ ║  l.2088: 	@tailrec
+//│ ║          	 ^^^^^^^
+//│ ╟── it could self-recurse through this call, which may not be a tail-call
+//│ ║  l.2090: 	fun b() = A(c(), @tailcall a())
+//│ ╙──        	            ^
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(c, b, a))
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [a,b]),ClassInfo(3, _IdContext, []),ClassInfo(4, _Context, [acc,ptr,field])}, {
+//│ Def(0, a, [],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #80
+//│ let* (res) = a_modcons$7(idCtx) in -- #79
+//│ res -- #78
+//│ )
+//│ Def(1, b, [],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #72
+//│ let* (res) = b_modcons$6(idCtx) in -- #71
+//│ res -- #70
+//│ )
+//│ Def(2, c, [],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #63
+//│ let* (res) = c_modcons$5(idCtx) in -- #62
+//│ res -- #61
+//│ )
+//│ Def(3, _c_b_a_ctx_app$3, [ctx,x],
+//│ 1, 
+//│ case ctx of -- #49
+//│   _IdContext =>
+//│     x -- #48
+//│   _Context =>
+//│     let field = ctx.field in -- #47
+//│     let scrut = ==(1,field) in -- #46
+//│     if scrut -- #45
+//│       true =>
+//│         let ptr = ctx.ptr in -- #44
+//│         let _ = assign ptr.b := x in -- #43
+//│         let acc = ctx.acc in -- #42
+//│         acc -- #41
+//│       false =>
+//│         let ptr = ctx.ptr in -- #40
+//│         let _ = assign ptr.a := x in -- #39
+//│         let acc = ctx.acc in -- #38
+//│         acc -- #37
+//│ )
+//│ Def(4, _c_b_a_ctx_comp$4, [ctx1,ctx2],
+//│ 1, 
+//│ let ctx2acc = ctx2.acc in -- #55
+//│ let ctx2ptr = ctx2.ptr in -- #54
+//│ let ctx2field = ctx2.field in -- #53
+//│ let* (newAcc) = _c_b_a_ctx_app$3(ctx1,ctx2acc) in -- #52
+//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #51
+//│ ret -- #50
+//│ )
+//│ Def(5, c_modcons$5, [ctx],
+//│ 1, 
+//│ let* (r0) = _c_modcons$5_b_modcons$6_a_modcons$7_opt$8(5,ctx,undefined,undefined) in -- #104
+//│ r0 -- #103
+//│ )
+//│ Def(6, b_modcons$6, [ctx],
+//│ 1, 
+//│ let* (r0) = _c_modcons$5_b_modcons$6_a_modcons$7_opt$8(6,undefined,ctx,undefined) in -- #106
+//│ r0 -- #105
+//│ )
+//│ Def(7, a_modcons$7, [ctx],
+//│ 1, 
+//│ let* (r0) = _c_modcons$5_b_modcons$6_a_modcons$7_opt$8(7,undefined,undefined,ctx) in -- #108
+//│ r0 -- #107
+//│ )
+//│ Def(8, _c_modcons$5_b_modcons$6_a_modcons$7_opt$8, [tailrecBranch$,c_modcons$5_ctx,b_modcons$6_ctx,a_modcons$7_ctx],
+//│ 1, 
+//│ jump _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9(tailrecBranch$,c_modcons$5_ctx,b_modcons$6_ctx,a_modcons$7_ctx) -- #102
+//│ )
+//│ Def(9, _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9, [tailrecBranch$,c_modcons$5_ctx,b_modcons$6_ctx,a_modcons$7_ctx],
+//│ 1, 
+//│ let scrut = ==(7,tailrecBranch$) in -- #101
+//│ if scrut -- #100
+//│   true =>
+//│     let x$1 = A(0,1) in -- #97
+//│     let ctx2 = _Context(x$1,x$1,0) in -- #96
+//│     let* (composed) = _c_b_a_ctx_comp$4(a_modcons$7_ctx,ctx2) in -- #95
+//│     jump _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9(6,c_modcons$5_ctx,composed,a_modcons$7_ctx) -- #94
+//│   false =>
+//│     let scrut = ==(6,tailrecBranch$) in -- #99
+//│     if scrut -- #98
+//│       true =>
+//│         let* (x$2) = c() in -- #93
+//│         let x$4 = A(x$2,0) in -- #92
+//│         let ctx2 = _Context(x$4,x$4,1) in -- #91
+//│         let* (composed) = _c_b_a_ctx_comp$4(b_modcons$6_ctx,ctx2) in -- #90
+//│         jump _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9(7,c_modcons$5_ctx,b_modcons$6_ctx,composed) -- #89
+//│       false =>
+//│         let x$6 = A(0,1) in -- #88
+//│         let ctx2 = _Context(x$6,x$6,0) in -- #87
+//│         let* (composed) = _c_b_a_ctx_comp$4(c_modcons$5_ctx,ctx2) in -- #86
+//│         jump _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9(6,c_modcons$5_ctx,composed,a_modcons$7_ctx) -- #85
+//│ )
+//│ },
+//│ let* (x$7) = a() in -- #36
+//│ x$7 -- #35)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [a,b]),ClassInfo(3, _IdContext, []),ClassInfo(4, _Context, [acc,ptr,field])}, {
+//│ Def(0, a, [],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #80
+//│ let* (res) = a_modcons$7(idCtx) in -- #79
+//│ res -- #78
+//│ )
+//│ Def(1, b, [],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #72
+//│ let* (res) = b_modcons$6(idCtx) in -- #71
+//│ res -- #70
+//│ )
+//│ Def(2, c, [],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #63
+//│ let* (res) = c_modcons$5(idCtx) in -- #62
+//│ res -- #61
+//│ )
+//│ Def(3, _c_b_a_ctx_app$3, [ctx,x],
+//│ 1, 
+//│ case ctx of -- #49
+//│   _IdContext =>
+//│     x -- #48
+//│   _Context =>
+//│     let field = ctx.field in -- #47
+//│     let scrut = ==(1,field) in -- #46
+//│     if scrut -- #45
+//│       true =>
+//│         let ptr = ctx.ptr in -- #44
+//│         let _ = assign ptr.b := x in -- #43
+//│         let acc = ctx.acc in -- #42
+//│         acc -- #41
+//│       false =>
+//│         let ptr = ctx.ptr in -- #40
+//│         let _ = assign ptr.a := x in -- #39
+//│         let acc = ctx.acc in -- #38
+//│         acc -- #37
+//│ )
+//│ Def(4, _c_b_a_ctx_comp$4, [ctx1,ctx2],
+//│ 1, 
+//│ let ctx2acc = ctx2.acc in -- #55
+//│ let ctx2ptr = ctx2.ptr in -- #54
+//│ let ctx2field = ctx2.field in -- #53
+//│ let* (newAcc) = _c_b_a_ctx_app$3(ctx1,ctx2acc) in -- #52
+//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #51
+//│ ret -- #50
+//│ )
+//│ Def(5, c_modcons$5, [ctx],
+//│ 1, 
+//│ let* (r0) = _c_modcons$5_b_modcons$6_a_modcons$7_opt$8(5,ctx,undefined,undefined) in -- #104
+//│ r0 -- #103
+//│ )
+//│ Def(6, b_modcons$6, [ctx],
+//│ 1, 
+//│ let* (r0) = _c_modcons$5_b_modcons$6_a_modcons$7_opt$8(6,undefined,ctx,undefined) in -- #106
+//│ r0 -- #105
+//│ )
+//│ Def(7, a_modcons$7, [ctx],
+//│ 1, 
+//│ let* (r0) = _c_modcons$5_b_modcons$6_a_modcons$7_opt$8(7,undefined,undefined,ctx) in -- #108
+//│ r0 -- #107
+//│ )
+//│ Def(8, _c_modcons$5_b_modcons$6_a_modcons$7_opt$8, [tailrecBranch$,c_modcons$5_ctx,b_modcons$6_ctx,a_modcons$7_ctx],
+//│ 1, 
+//│ jump _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9(tailrecBranch$,c_modcons$5_ctx,b_modcons$6_ctx,a_modcons$7_ctx) -- #102
+//│ )
+//│ Def(9, _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9, [tailrecBranch$,c_modcons$5_ctx,b_modcons$6_ctx,a_modcons$7_ctx],
+//│ 1, 
+//│ let scrut = ==(7,tailrecBranch$) in -- #101
+//│ if scrut -- #100
+//│   true =>
+//│     let x$1 = A(0,1) in -- #97
+//│     let ctx2 = _Context(x$1,x$1,0) in -- #96
+//│     let* (composed) = _c_b_a_ctx_comp$4(a_modcons$7_ctx,ctx2) in -- #95
+//│     jump _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9(6,c_modcons$5_ctx,composed,a_modcons$7_ctx) -- #94
+//│   false =>
+//│     let scrut = ==(6,tailrecBranch$) in -- #99
+//│     if scrut -- #98
+//│       true =>
+//│         let* (x$2) = c() in -- #93
+//│         let x$4 = A(x$2,0) in -- #92
+//│         let ctx2 = _Context(x$4,x$4,1) in -- #91
+//│         let* (composed) = _c_b_a_ctx_comp$4(b_modcons$6_ctx,ctx2) in -- #90
+//│         jump _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9(7,c_modcons$5_ctx,b_modcons$6_ctx,composed) -- #89
+//│       false =>
+//│         let x$6 = A(0,1) in -- #88
+//│         let ctx2 = _Context(x$6,x$6,0) in -- #87
+//│         let* (composed) = _c_b_a_ctx_comp$4(c_modcons$5_ctx,ctx2) in -- #86
+//│         jump _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9(6,c_modcons$5_ctx,composed,a_modcons$7_ctx) -- #85
+//│ )
+//│ },
+//│ let* (x$7) = a() in -- #36
+//│ x$7 -- #35)
+
+// TODO: Purity check
+class A(a, b)
+@tailrec
+fun a() = A(b(), 1)
+fun b() = A(@tailcall a(), c())
+fun c() = A(0, 1)
+a()
+//│ |#class| |A|(|a|,| |b|)|↵|@|tailrec|↵|#fun| |a|(||)| |#=| |A|(|b|(||)|,| |1|)|↵|#fun| |b|(||)| |#=| |A|(|@|tailcall| |a|(||)|,| |c|(||)|)|↵|#fun| |c|(||)| |#=| |A|(|0|,| |1|)|↵|a|(||)|
+//│ Parsed: {class A(a, b,) {}; fun a = () => A(b(), 1,); fun b = () => A(@tailcall a(), c(),); fun c = () => A(0, 1,); a()}
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [a,b])}, {
+//│ Def(0, a, [],
+//│ 1, 
+//│ let* (x$0) = b() in -- #9
+//│ let x$1 = A(x$0,1) in -- #8
+//│ x$1 -- #7
+//│ )
+//│ Def(1, b, [],
+//│ 1, 
+//│ let* (x$2) = @tailcall a() in -- #22
+//│ let* (x$3) = c() in -- #21
+//│ let x$4 = A(x$2,x$3) in -- #20
+//│ x$4 -- #19
+//│ )
+//│ Def(2, c, [],
+//│ 1, 
+//│ let x$5 = A(0,1) in -- #29
+//│ x$5 -- #28
+//│ )
+//│ },
+//│ let* (x$6) = a() in -- #33
+//│ x$6 -- #32)
+//│ ╔══[COMPILATION ERROR] not a tail call, as the remaining functions may be impure
+//│ ║  l.2324: 	fun b() = A(@tailcall a(), c())
+//│ ╙──        	                      ^
+//│ ╔══[COMPILATION ERROR] function `a` is not tail-recursive, but is marked as @tailrec
+//│ ║  l.2322: 	@tailrec
+//│ ║          	 ^^^^^^^
+//│ ╟── it could self-recurse through this call, which may not be a tail-call
+//│ ║  l.2324: 	fun b() = A(@tailcall a(), c())
+//│ ╙──        	                      ^
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(b, a), Set(c))
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [a,b]),ClassInfo(3, _IdContext, []),ClassInfo(4, _Context, [acc,ptr,field])}, {
+//│ Def(0, a, [],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #62
+//│ let* (res) = a_modcons$6(idCtx) in -- #61
+//│ res -- #60
+//│ )
+//│ Def(1, b, [],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #54
+//│ let* (res) = b_modcons$5(idCtx) in -- #53
+//│ res -- #52
+//│ )
+//│ Def(2, c, [],
+//│ 1, 
+//│ let x$5 = A(0,1) in -- #29
+//│ x$5 -- #28
+//│ )
+//│ Def(3, _b_a_ctx_app$3, [ctx,x],
+//│ 1, 
+//│ case ctx of -- #40
+//│   _IdContext =>
+//│     x -- #39
+//│   _Context =>
+//│     let field = ctx.field in -- #38
+//│     let ptr = ctx.ptr in -- #37
+//│     let _ = assign ptr.a := x in -- #36
+//│     let acc = ctx.acc in -- #35
+//│     acc -- #34
+//│ )
+//│ Def(4, _b_a_ctx_comp$4, [ctx1,ctx2],
+//│ 1, 
+//│ let ctx2acc = ctx2.acc in -- #46
+//│ let ctx2ptr = ctx2.ptr in -- #45
+//│ let ctx2field = ctx2.field in -- #44
+//│ let* (newAcc) = _b_a_ctx_app$3(ctx1,ctx2acc) in -- #43
+//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #42
+//│ ret -- #41
+//│ )
+//│ Def(5, b_modcons$5, [ctx],
+//│ 1, 
+//│ let* (r0) = _b_modcons$5_a_modcons$6_opt$7(5,ctx,undefined) in -- #81
+//│ r0 -- #80
+//│ )
+//│ Def(6, a_modcons$6, [ctx],
+//│ 1, 
+//│ let* (r0) = _b_modcons$5_a_modcons$6_opt$7(6,undefined,ctx) in -- #83
+//│ r0 -- #82
+//│ )
+//│ Def(7, _b_modcons$5_a_modcons$6_opt$7, [tailrecBranch$,b_modcons$5_ctx,a_modcons$6_ctx],
+//│ 1, 
+//│ jump _b_modcons$5_a_modcons$6_opt_jp$8(tailrecBranch$,b_modcons$5_ctx,a_modcons$6_ctx) -- #79
+//│ )
+//│ Def(8, _b_modcons$5_a_modcons$6_opt_jp$8, [tailrecBranch$,b_modcons$5_ctx,a_modcons$6_ctx],
+//│ 1, 
+//│ let scrut = ==(6,tailrecBranch$) in -- #78
+//│ if scrut -- #77
+//│   true =>
+//│     let x$1 = A(0,1) in -- #76
+//│     let ctx2 = _Context(x$1,x$1,0) in -- #75
+//│     let* (composed) = _b_a_ctx_comp$4(a_modcons$6_ctx,ctx2) in -- #74
+//│     jump _b_modcons$5_a_modcons$6_opt_jp$8(5,composed,a_modcons$6_ctx) -- #73
+//│   false =>
+//│     let* (x$2) = @tailcall a() in -- #72
+//│     let* (x$3) = c() in -- #71
+//│     let x$4 = A(x$2,x$3) in -- #70
+//│     let* (res) = _b_a_ctx_app$3(b_modcons$5_ctx,x$4) in -- #69
+//│     res -- #68
+//│ )
+//│ },
+//│ let* (x$6) = a() in -- #33
+//│ x$6 -- #32)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [a,b]),ClassInfo(3, _IdContext, []),ClassInfo(4, _Context, [acc,ptr,field])}, {
+//│ Def(0, a, [],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #62
+//│ let* (res) = a_modcons$6(idCtx) in -- #61
+//│ res -- #60
+//│ )
+//│ Def(1, b, [],
+//│ 1, 
+//│ let idCtx = _IdContext() in -- #54
+//│ let* (res) = b_modcons$5(idCtx) in -- #53
+//│ res -- #52
+//│ )
+//│ Def(2, c, [],
+//│ 1, 
+//│ let x$5 = A(0,1) in -- #29
+//│ x$5 -- #28
+//│ )
+//│ Def(3, _b_a_ctx_app$3, [ctx,x],
+//│ 1, 
+//│ case ctx of -- #40
+//│   _IdContext =>
+//│     x -- #39
+//│   _Context =>
+//│     let field = ctx.field in -- #38
+//│     let ptr = ctx.ptr in -- #37
+//│     let _ = assign ptr.a := x in -- #36
+//│     let acc = ctx.acc in -- #35
+//│     acc -- #34
+//│ )
+//│ Def(4, _b_a_ctx_comp$4, [ctx1,ctx2],
+//│ 1, 
+//│ let ctx2acc = ctx2.acc in -- #46
+//│ let ctx2ptr = ctx2.ptr in -- #45
+//│ let ctx2field = ctx2.field in -- #44
+//│ let* (newAcc) = _b_a_ctx_app$3(ctx1,ctx2acc) in -- #43
+//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #42
+//│ ret -- #41
+//│ )
+//│ Def(5, b_modcons$5, [ctx],
+//│ 1, 
+//│ let* (r0) = _b_modcons$5_a_modcons$6_opt$7(5,ctx,undefined) in -- #81
+//│ r0 -- #80
+//│ )
+//│ Def(6, a_modcons$6, [ctx],
+//│ 1, 
+//│ let* (r0) = _b_modcons$5_a_modcons$6_opt$7(6,undefined,ctx) in -- #83
+//│ r0 -- #82
+//│ )
+//│ Def(7, _b_modcons$5_a_modcons$6_opt$7, [tailrecBranch$,b_modcons$5_ctx,a_modcons$6_ctx],
+//│ 1, 
+//│ jump _b_modcons$5_a_modcons$6_opt_jp$8(tailrecBranch$,b_modcons$5_ctx,a_modcons$6_ctx) -- #79
+//│ )
+//│ Def(8, _b_modcons$5_a_modcons$6_opt_jp$8, [tailrecBranch$,b_modcons$5_ctx,a_modcons$6_ctx],
+//│ 1, 
+//│ let scrut = ==(6,tailrecBranch$) in -- #78
+//│ if scrut -- #77
+//│   true =>
+//│     let x$1 = A(0,1) in -- #76
+//│     let ctx2 = _Context(x$1,x$1,0) in -- #75
+//│     let* (composed) = _b_a_ctx_comp$4(a_modcons$6_ctx,ctx2) in -- #74
+//│     jump _b_modcons$5_a_modcons$6_opt_jp$8(5,composed,a_modcons$6_ctx) -- #73
+//│   false =>
+//│     let* (x$2) = @tailcall a() in -- #72
+//│     let* (x$3) = c() in -- #71
+//│     let x$4 = A(x$2,x$3) in -- #70
+//│     let* (res) = _b_a_ctx_app$3(b_modcons$5_ctx,x$4) in -- #69
+//│     res -- #68
+//│ )
+//│ },
+//│ let* (x$6) = a() in -- #33
+//│ x$6 -- #32)
+
+:ce
+@tailcall 1
+//│ |@|tailcall| |1|
+//│ Parsed: {@tailcall 1}
+//│ ╔══[COMPILATION ERROR] @tailcall may only be used to annotate function calls
+//│ ║  l.2513: 	@tailcall 1
+//│ ╙──        	 ^^^^^^^^
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
+//│ 
+//│ },
+//│ 1 -- #0)
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List()
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ 
+//│ },
+//│ 1 -- #0)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ 
+//│ },
+//│ 1 -- #0)
+
+:ce
+@tailrec 1
+//│ |@|tailrec| |1|
+//│ Parsed: {@tailrec 1}
+//│ ╔══[COMPILATION ERROR] @tailrec may only be used to annotate functions
+//│ ║  l.2540: 	@tailrec 1
+//│ ╙──        	 ^^^^^^^
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
+//│ 
+//│ },
+//│ 1 -- #0)
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List()
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ 
+//│ },
+//│ 1 -- #0)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ 
+//│ },
+//│ 1 -- #0)
+
+:ce
+fun foo() =
+  @tailrec foo()
+foo()
+//│ |#fun| |foo|(||)| |#=|→|@|tailrec| |foo|(||)|←|↵|foo|(||)|
+//│ Parsed: {fun foo = () => {@tailrec foo()}; foo()}
+//│ ╔══[COMPILATION ERROR] @tailrec is for annotating functions; try @tailcall instead
+//│ ║  l.2568: 	  @tailrec foo()
+//│ ╙──        	   ^^^^^^^
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
+//│ Def(0, foo, [],
+//│ 1, 
+//│ let* (x$0) = foo() in -- #3
+//│ x$0 -- #2
+//│ )
+//│ },
+//│ let* (x$1) = foo() in -- #7
+//│ x$1 -- #6)
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(foo))
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(1, foo_jp, [],
+//│ 1, 
+//│ jump foo_jp() -- #8
+//│ )
+//│ Def(2, foo, [],
+//│ 1, 
+//│ let* (r0) = foo_jp() in -- #10
+//│ r0 -- #9
+//│ )
+//│ },
+//│ let* (x$1) = foo() in -- #7
+//│ x$1 -- #6)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(1, foo_jp, [],
+//│ 1, 
+//│ jump foo_jp() -- #8
+//│ )
+//│ Def(2, foo, [],
+//│ 1, 
+//│ let* (r0) = foo_jp() in -- #10
+//│ r0 -- #9
+//│ )
+//│ },
+//│ let* (x$1) = foo() in -- #7
+//│ x$1 -- #6)
+
+:ce
+@tailcall
+fun foo() =
+  foo()
+foo()
+//│ |@|tailcall|↵|#fun| |foo|(||)| |#=|→|foo|(||)|←|↵|foo|(||)|
+//│ Parsed: {fun foo = () => {foo()}; foo()}
+//│ ╔══[COMPILATION ERROR] @tailcall is for annotating function calls; try @tailrec instead
+//│ ║  l.2619: 	@tailcall
+//│ ╙──        	 ^^^^^^^^
+//│ 
+//│ IR:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
+//│ Def(0, foo, [],
+//│ 1, 
+//│ let* (x$0) = foo() in -- #3
+//│ x$0 -- #2
+//│ )
+//│ },
+//│ let* (x$1) = foo() in -- #7
+//│ x$1 -- #6)
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(foo))
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(1, foo_jp, [],
+//│ 1, 
+//│ jump foo_jp() -- #8
+//│ )
+//│ Def(2, foo, [],
+//│ 1, 
+//│ let* (r0) = foo_jp() in -- #10
+//│ r0 -- #9
+//│ )
+//│ },
+//│ let* (x$1) = foo() in -- #7
+//│ x$1 -- #6)
+//│ 
+//│ Promoted:
+//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Def(1, foo_jp, [],
+//│ 1, 
+//│ jump foo_jp() -- #8
+//│ )
+//│ Def(2, foo, [],
+//│ 1, 
+//│ let* (r0) = foo_jp() in -- #10
+//│ r0 -- #9
+//│ )
+//│ },
+//│ let* (x$1) = foo() in -- #7
+//│ x$1 -- #6)
diff --git a/compiler/shared/test/diff-ir/NuScratch.mls b/compiler/shared/test/diff-ir/NuScratch.mls
new file mode 100644
index 0000000000..907012746a
--- /dev/null
+++ b/compiler/shared/test/diff-ir/NuScratch.mls
@@ -0,0 +1,3 @@
+:NewParser
+:ParseOnly
+:UseIR
diff --git a/compiler/shared/test/scala/mlscript/compiler/Test.scala b/compiler/shared/test/scala/mlscript/compiler/Test.scala
index 2875eb95e9..3707a54692 100644
--- a/compiler/shared/test/scala/mlscript/compiler/Test.scala
+++ b/compiler/shared/test/scala/mlscript/compiler/Test.scala
@@ -1,16 +1,15 @@
-package mlscript.compiler
+package mlscript
+package compiler
 
-import mlscript.utils.shorthands.*
+import utils.shorthands.*
 import scala.util.control.NonFatal
 import scala.collection.mutable.StringBuilder
-import mlscript.{DiffTests, ModeType, TypingUnit}
 import mlscript.compiler.TreeDebug
-import mlscript.Polyfill
 import simpledef.SimpleDef
 
 class DiffTestCompiler extends DiffTests {
   import DiffTestCompiler.*
-  override def postProcess(mode: ModeType, basePath: List[Str], testName: Str, unit: TypingUnit, output: Str => Unit): (List[Str], Option[TypingUnit]) = 
+  override def postProcess(mode: ModeType, basePath: List[Str], testName: Str, unit: TypingUnit, output: Str => Unit, raise: Diagnostic => Unit): (List[Str], Option[TypingUnit]) = 
     val outputBuilder = StringBuilder()
 
     var rstUnit = unit;
diff --git a/compiler/shared/test/scala/mlscript/compiler/TestIR.scala b/compiler/shared/test/scala/mlscript/compiler/TestIR.scala
index 1d6ac40f10..94dcacae44 100644
--- a/compiler/shared/test/scala/mlscript/compiler/TestIR.scala
+++ b/compiler/shared/test/scala/mlscript/compiler/TestIR.scala
@@ -1,23 +1,42 @@
-package mlscript.compiler
-
+package mlscript
+package compiler
 
 import mlscript.utils.shorthands._
 import mlscript.compiler.ir._
 import scala.collection.mutable.StringBuilder
-import mlscript.{DiffTests, ModeType, TypingUnit}
-import mlscript.compiler.ir.{Interpreter, Fresh, FreshInt, Builder}
+import mlscript.compiler.optimizer.TailRecOpt
 
 class IRDiffTestCompiler extends DiffTests {
   import IRDiffTestCompiler.*
 
-  override def postProcess(mode: ModeType, basePath: List[Str], testName: Str, unit: TypingUnit, output: Str => Unit): (List[Str], Option[TypingUnit]) = 
+  override def postProcess(mode: ModeType, basePath: List[Str], testName: Str, unit: TypingUnit, output: Str => Unit, raise: Diagnostic => Unit): (List[Str], Option[TypingUnit]) = 
     val outputBuilder = StringBuilder()
     if (mode.useIR || mode.irVerbose)
       try
-        output("\n\nIR:")
-        val gb = Builder(Fresh(), FreshInt(),  FreshInt(), FreshInt())
-        val graph = gb.buildGraph(unit)
-        output(graph.toString())
+        val fnUid = FreshInt()
+        val classUid = FreshInt()
+        val tag = FreshInt()
+
+        val gb = Builder(Fresh(), fnUid, classUid, tag, raise)
+        val graph_ = gb.buildGraph(unit)
+        
+        if !mode.noTailRecOpt then 
+          output("\nIR:")
+          output(graph_.toString())
+
+        val graph = 
+          if !mode.noTailRecOpt then
+            val tailRecOpt = new TailRecOpt(fnUid, classUid, tag, raise)
+            val (g, comps) = tailRecOpt.run_debug(graph_)
+            output("\nStrongly Connected Tail Calls:")
+            output(comps.toString)
+            g
+          else
+            graph_
+
+        if !mode.noTailRecOpt then
+          output(graph.toString())
+        
         output("\nPromoted:")
         output(graph.toString())
         var interp_result: Opt[Str] = None
@@ -30,10 +49,12 @@ class IRDiffTestCompiler extends DiffTests {
       catch
         case err: Exception =>
           output(s"\nIR Processing Failed: ${err.getMessage()}")
-          output("\n" ++ err.getStackTrace().map(_.toString()).mkString("\n"))
+          if (mode.irVerbose) then
+            output("\n" ++ err.getStackTrace().map(_.toString()).mkString("\n"))
         case err: StackOverflowError =>
           output(s"\nIR Processing Failed: ${err.getMessage()}")
-          output("\n" ++ err.getStackTrace().map(_.toString()).mkString("\n"))
+          if (mode.irVerbose) then
+            output("\n" ++ err.getStackTrace().map(_.toString()).mkString("\n"))
       
     (outputBuilder.toString().linesIterator.toList, None)
   
diff --git a/shared/src/main/scala/mlscript/NewParser.scala b/shared/src/main/scala/mlscript/NewParser.scala
index 23366eeaa0..4024d653cb 100644
--- a/shared/src/main/scala/mlscript/NewParser.scala
+++ b/shared/src/main/scala/mlscript/NewParser.scala
@@ -1385,6 +1385,8 @@ abstract class NewParser(origin: Origin, tokens: Ls[Stroken -> Loc], newDefs: Bo
   final def argsOrIf(acc: Ls[Opt[Var] -> (IfBody \/ Fld)], seqAcc: Ls[Statement], allowNewlines: Bool, prec: Int = NoElsePrec)
         (implicit fe: FoundErr, et: ExpectThen): Ls[Opt[Var] -> (IfBody \/ Fld)] =
       wrap(acc, seqAcc) { l =>
+      
+    val anns = parseAnnotations(false)
     
     cur match {
       case Nil =>
@@ -1436,8 +1438,9 @@ abstract class NewParser(origin: Origin, tokens: Ls[Stroken -> Loc], newDefs: Bo
         S(Var(i.toString).withLoc(S(l0)))
       case _ => N
     }
+
     // val e = expr(NoElsePrec) -> argMut.isDefined
-    val e = exprOrIf(prec).map(Fld(FldFlags(argMut.isDefined, argSpec.isDefined, argVal.isDefined), _))
+    val e = exprOrIf(prec, true, anns).map(Fld(FldFlags(argMut.isDefined, argSpec.isDefined, argVal.isDefined), _))
     
     def mkSeq = if (seqAcc.isEmpty) argName -> e else e match {
       case L(_) => ???
diff --git a/shared/src/main/scala/mlscript/Typer.scala b/shared/src/main/scala/mlscript/Typer.scala
index b487476c8c..ad79b34a47 100644
--- a/shared/src/main/scala/mlscript/Typer.scala
+++ b/shared/src/main/scala/mlscript/Typer.scala
@@ -301,9 +301,9 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
     NuTypeDef(Als, TN("null"), Nil, N, N, S(Literal(UnitLit(false))), Nil, N, N, TypingUnit(Nil))(N, S(preludeLoc), Nil),
     NuTypeDef(Cls, TN("Annotation"), Nil, N, N, N, Nil, N, N, TypingUnit(Nil))(N, S(preludeLoc), Nil),
     NuTypeDef(Cls, TN("Code"), (S(VarianceInfo.co) -> TN("T")) :: (S(VarianceInfo.co) -> TN("C")) :: Nil, N, N, N, Nil, N, N, TypingUnit(Nil))(N, S(preludeLoc), Nil),
-    NuTypeDef(Cls, TN("Var"), (S(VarianceInfo.in) -> TN("T")) :: (S(VarianceInfo.in) -> TN("C")) :: Nil, N, N, N, TyApp(Var("Code"), TN("T") :: TN("C") :: Nil) :: Nil, N, N, TypingUnit(Nil))(N, S(preludeLoc), Nil)
-    // Not yet implemented, so we do not define it yet
-    // NuTypeDef(Mod, TN("tailrec"), Nil, N, N, N, Var("Annotation") :: Nil, N, N, TypingUnit(Nil))(N, N, Nil),
+    NuTypeDef(Cls, TN("Var"), (S(VarianceInfo.in) -> TN("T")) :: (S(VarianceInfo.in) -> TN("C")) :: Nil, N, N, N, TyApp(Var("Code"), TN("T") :: TN("C") :: Nil) :: Nil, N, N, TypingUnit(Nil))(N, S(preludeLoc), Nil),
+    NuTypeDef(Mod, TN("tailrec"), Nil, N, N, N, Var("Annotation") :: Nil, N, N, TypingUnit(Nil))(N, N, Nil),
+    NuTypeDef(Mod, TN("tailcall"), Nil, N, N, N, Var("Annotation") :: Nil, N, N, TypingUnit(Nil))(N, N, Nil),
   )
   val builtinTypes: Ls[TypeDef] =
     TypeDef(Cls, TN("?"), Nil, TopType, Nil, Nil, Set.empty, N, Nil) :: // * Dummy for pretty-printing unknown type locations
diff --git a/shared/src/test/diff/nu/Annotations.mls b/shared/src/test/diff/nu/Annotations.mls
index be99f9cf45..e85bb285d3 100644
--- a/shared/src/test/diff/nu/Annotations.mls
+++ b/shared/src/test/diff/nu/Annotations.mls
@@ -40,6 +40,40 @@ Foo
 //│ res
 //│     = 5
 
+:e
+let x = 1
+@x 2
+//│ ╔══[ERROR] Type mismatch in annotated integer literal:
+//│ ║  l.45: 	@x 2
+//│ ║        	 ^^^
+//│ ╟── integer literal of type `1` is not an instance of type `Annotation`
+//│ ║  l.44: 	let x = 1
+//│ ║        	        ^
+//│ ╟── but it flows into reference with expected type `Annotation`
+//│ ║  l.45: 	@x 2
+//│ ╙──      	 ^
+//│ let x: 1
+//│ 2
+//│ x
+//│   = 1
+//│ res
+//│     = 2
+
+:e
+let x = 1
+@x
+fun foo(x) = 1
+//│ ╔══[ERROR] Type mismatch in definition:
+//│ ║  l.65: 	fun foo(x) = 1
+//│ ║        	    ^^^^^^^^^^
+//│ ╟── integer literal of type `1` is not an instance of type `Annotation`
+//│ ║  l.63: 	let x = 1
+//│ ╙──      	        ^
+//│ let x: 1
+//│ fun foo: anything -> 1
+//│ x
+//│   = 1
+
 fun foo(n) =
   if n > 0.5 then
     log(join of "hi ", String(n))
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index 4e765b5871..e309a415da 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -42,6 +42,7 @@ abstract class ModeType {
   def showRepl: Bool
   def allowEscape: Bool
   def useIR: Bool
+  def noTailRecOpt: Bool
   def interpIR: Bool
   def irVerbose: Bool
   def simpledef: Bool
@@ -57,7 +58,7 @@ class DiffTests
   
   
   /**  Hook for dependent projects, like the monomorphizer. */
-  def postProcess(mode: ModeType, basePath: Ls[Str], testName: Str, unit: TypingUnit, output: Str => Unit): (Ls[Str], Option[TypingUnit]) = (Nil, None)
+  def postProcess(mode: ModeType, basePath: Ls[Str], testName: Str, unit: TypingUnit, output: Str => Unit, raise: Diagnostic => Unit): (Ls[Str], Option[TypingUnit]) = (Nil, None)
   def postTypingProcess(mode: ModeType, basePath: Ls[Str], testName: Str, unit: TypingUnit, output: Str => Unit): Option[TypingUnit] = None
   
   
@@ -150,6 +151,7 @@ class DiffTests
     
     case class Mode(
       expectTypeErrors: Bool = false,
+      expectCompileErrors: Bool = false,
       expectWarnings: Bool = false,
       expectParseErrors: Bool = false,
       fixme: Bool = false,
@@ -181,6 +183,7 @@ class DiffTests
       lift: Bool = false,
       nolift: Bool = false,
       // noProvs: Bool = false,
+      noTailRecOpt: Bool = false,
       useIR: Bool = false,
       interpIR: Bool = false,
       irVerbose: Bool = false,
@@ -191,6 +194,7 @@ class DiffTests
     
     var parseOnly = basePath.headOption.contains("parser")
     var allowTypeErrors = false
+    var allowCompileErrors = false
     var allowParseErrors = false
     var showRelativeLineNums = false
     var noJavaScript = false
@@ -209,6 +213,7 @@ class DiffTests
     var useIR = false
     // Enable this to see the errors from unfinished `PreTyper`.
     var showPreTyperErrors = false
+    var noTailRec = false
     
     // * This option makes some test cases pass which assume generalization should happen in arbitrary arguments
     // * but it's way too aggressive to be ON by default, as it leads to more extrusion, cycle errors, etc.
@@ -229,6 +234,7 @@ class DiffTests
         out.println(line)
         val newMode = line.tail.takeWhile(!_.isWhitespace) match {
           case "e" => mode.copy(expectTypeErrors = true)
+          case "ce" => mode.copy(expectCompileErrors = true)
           case "w" => mode.copy(expectWarnings = true)
           case "pe" => mode.copy(expectParseErrors = true)
           case "p" => mode.copy(showParse = true)
@@ -249,12 +255,14 @@ class DiffTests
           case "precise-rec-typing" => mode.copy(preciselyTypeRecursion = true)
           case "ParseOnly" => parseOnly = true; mode
           case "AllowTypeErrors" => allowTypeErrors = true; mode
+          case "AllowCompileErrors" => allowCompileErrors = true; mode
           case "AllowParseErrors" => allowParseErrors = true; mode
           case "AllowRuntimeErrors" => allowRuntimeErrors = true; mode
           case "ShowRelativeLineNums" => showRelativeLineNums = true; mode
           case "NewParser" => newParser = true; mode
           case "NewDefs" => newParser = true; newDefs = true; mode
           case "NoJS" => noJavaScript = true; mode
+          case "NoTailRec" => noTailRec = true; mode
           case "NoProvs" => noProvs = true; mode
           case "GeneralizeCurriedFunctions" => generalizeCurriedFunctions = true; mode
           case "DontGeneralizeCurriedFunctions" => generalizeCurriedFunctions = false; mode
@@ -295,6 +303,7 @@ class DiffTests
           case "escape" => mode.copy(allowEscape = true)
           case "sd" => {mode.copy(simpledef = true)}
           case "lift" => {mode.copy(lift = true)}
+          case "noTailRec" => mode.copy(noTailRecOpt = true)
           case "nolift" => {mode.copy(nolift = true)}
           case "exit" =>
             out.println(exitMarker)
@@ -359,6 +368,7 @@ class DiffTests
         
         var totalTypeErrors = 0
         var totalParseErrors = 0
+        var totalCompileErrors = 0
         var totalWarnings = 0
         var totalRuntimeErrors = 0
         var totalCodeGenErrors = 0
@@ -376,6 +386,9 @@ class DiffTests
                   case Diagnostic.Parsing =>
                     totalParseErrors += 1
                     s"╔══[PARSE ERROR] "
+                  case Diagnostic.Compilation =>
+                    totalCompileErrors += 1
+                    s"╔══[COMPILATION ERROR] "
                   case _ => // TODO customize too
                     totalTypeErrors += 1
                     s"╔══[ERROR] "
@@ -432,6 +445,9 @@ class DiffTests
               if (!allowParseErrors
                   && !mode.expectParseErrors && diag.isInstanceOf[ErrorReport] && (diag.source =:= Diagnostic.Lexing || diag.source =:= Diagnostic.Parsing))
                 { output("TEST CASE FAILURE: There was an unexpected parse error"); failures += globalLineNum }
+              if (!allowCompileErrors
+                  && !mode.expectCompileErrors && diag.isInstanceOf[ErrorReport] && diag.source =:= Diagnostic.Compilation)
+                { output("TEST CASE FAILURE: There was an unexpected compilation error"); failures += globalLineNum }
               if (!allowTypeErrors && !allowParseErrors
                   && !mode.expectWarnings && diag.isInstanceOf[WarningReport])
                 { output("TEST CASE FAILURE: There was an unexpected warning"); failures += globalLineNum }
@@ -468,8 +484,10 @@ class DiffTests
             if (mode.showParse)
               output(s"AST: $res")
             val newMode = if (useIR) { mode.copy(useIR = true) } else mode
+            val newNewMode = if (noTailRec) { newMode.copy(noTailRecOpt = true) } else newMode
+
             val (postLines, nuRes) = 
-              postProcess(newMode, basePath, testName, res, output)
+              postProcess(newNewMode, basePath, testName, res, output, raise)
             postLines.foreach(output)            
             
             if (parseOnly)
@@ -1062,6 +1080,8 @@ class DiffTests
               { output("TEST CASE FAILURE: There was an unexpected lack of parse error"); failures += blockLineNum }
             if (mode.expectTypeErrors && totalTypeErrors =:= 0)
               { output("TEST CASE FAILURE: There was an unexpected lack of type error"); failures += blockLineNum }
+            if (mode.expectCompileErrors && totalCompileErrors =:= 0)
+              { output("TEST CASE FAILURE: There was an unexpected lack of compilation error"); failures += blockLineNum }
             if (mode.expectWarnings && totalWarnings =:= 0)
               { output("TEST CASE FAILURE: There was an unexpected lack of warning"); failures += blockLineNum }
             if (mode.expectCodeGenErrors && totalCodeGenErrors =:= 0)

From f990dfee2878f111adb0e5ad6406270260608119 Mon Sep 17 00:00:00 2001
From: Lionel Parreaux <lionel.parreaux@gmail.com>
Date: Tue, 30 Jul 2024 16:20:09 +0800
Subject: [PATCH 140/147] Explicitly derive example of known unsoundness in
 normal forms

---
 shared/src/test/diff/mlscript/BooleanFail.mls | 89 +++++++++++++++++++
 1 file changed, 89 insertions(+)

diff --git a/shared/src/test/diff/mlscript/BooleanFail.mls b/shared/src/test/diff/mlscript/BooleanFail.mls
index fc8016dca0..c75abe8744 100644
--- a/shared/src/test/diff/mlscript/BooleanFail.mls
+++ b/shared/src/test/diff/mlscript/BooleanFail.mls
@@ -78,3 +78,92 @@ f (forall 'a. fun (x: 'a) -> x)
 //│    = [Function (anonymous)]
 
 
+// * Example 2
+
+def g(x: 'a | {f: nothing}) = x.f(0)
+//│ g: {f: 0 -> 'a} -> 'a
+//│  = [Function: g]
+
+foo = forall 'x. fun (x: 'x) -> g(x)
+//│ foo: anything -> nothing
+//│    = [Function: foo]
+
+:re
+foo 0
+//│ res: nothing
+//│ Runtime error:
+//│   TypeError: x.f is not a function
+
+
+
+// * Now let's consider why functions and classes can't intersect to nothing due to distributivity
+
+
+class Foo: { x: anything }
+//│ Defined class Foo
+
+
+// * These two types should be equivalent, but they visibly aren't:
+
+def a: (int -> int | {x: int}) & Foo
+def b: int -> int & Foo | {x: int} & Foo
+//│ a: Foo
+//│  = <missing implementation>
+//│ b: Foo & {x: int}
+//│  = <missing implementation>
+
+:ne
+ax = a.x
+bx = b.x
+//│ ax: anything
+//│ bx: int
+
+
+// * Yet, this does not immediately lead to unsoundness due to the aggressive normalization
+// * performed during constraint solving:
+
+:ne
+a = b
+//│ Foo & {x: int}
+//│   <:  a:
+//│ Foo
+
+:e
+:ne
+b = a
+//│ Foo
+//│   <:  b:
+//│ Foo & {x: int}
+//│ ╔══[ERROR] Type mismatch in def definition:
+//│ ║  l.133: 	b = a
+//│ ║         	^^^^^
+//│ ╟── expression of type `anything` is not an instance of type `int`
+//│ ╟── Note: constraint arises from type reference:
+//│ ║  l.109: 	def b: int -> int & Foo | {x: int} & Foo
+//│ ╙──       	                              ^^^
+
+
+// * To expose the unsoundness, we need some indirection with abstract types
+// * that prevent eagerly distributing the intersection type:
+
+class Test1[A, B]: { f: A & Foo }
+  method M: B & Foo | {x: int} & Foo
+//│ Defined class Test1[+A, +B]
+//│ Declared Test1.M: Test1[?, 'B] -> (Foo & 'B | Foo & {x: int})
+
+class Test2[B]: Test1[B | {x: int}, B]
+  method M = this.f : B & Foo | {x: int} & Foo
+//│ Defined class Test2[+B]
+//│ Defined Test2.M: Test2['B] -> (Foo & 'B | Foo & {x: int})
+
+oops = (Test2{f = Foo{x = "oops"}} : Test1[anything, int -> int]).M 
+//│ oops: Foo & {x: int}
+//│     = Foo { x: 'oops' }
+
+// * Notice the type confusion:
+oops.x + 1
+//│ res: int
+//│    = 'oops1'
+
+
+

From 05831320a5d6de263f5cbf4560ab35ae9534317f Mon Sep 17 00:00:00 2001
From: Lionel Parreaux <lionel.parreaux@gmail.com>
Date: Tue, 30 Jul 2024 16:30:05 +0800
Subject: [PATCH 141/147] Remove unsound simplification of negated record types
 in positive positions

---
 .../main/scala/mlscript/TyperHelpers.scala    |   3 -
 shared/src/test/diff/fcp/Overloads.mls        |  30 +++--
 shared/src/test/diff/mlscript/Annoying.mls    |   2 +-
 shared/src/test/diff/mlscript/BooleanFail.mls |  87 ++++++++----
 shared/src/test/diff/mlscript/ExprProb.mls    | 126 +++++++++++-------
 .../src/test/diff/mlscript/ExprProb_Inv.mls   | 126 +++++++++++-------
 shared/src/test/diff/mlscript/Neg.mls         |  22 ++-
 .../src/test/diff/mlscript/StressTraits.mls   |  24 ++--
 shared/src/test/diff/mlscript/StressUgly.mls  |   6 +-
 .../src/test/diff/mlscript/TraitMatching.mls  |  21 ++-
 shared/src/test/diff/nu/HeungTung.mls         |   2 +-
 11 files changed, 281 insertions(+), 168 deletions(-)

diff --git a/shared/src/main/scala/mlscript/TyperHelpers.scala b/shared/src/main/scala/mlscript/TyperHelpers.scala
index e76d3a5a5b..9b967a1d99 100644
--- a/shared/src/main/scala/mlscript/TyperHelpers.scala
+++ b/shared/src/main/scala/mlscript/TyperHelpers.scala
@@ -646,9 +646,6 @@ abstract class TyperHelpers { Typer: Typer =>
       case ComposedType(false, l, r) => l.negNormPos(f, p) | r.negNormPos(f, p)
       case NegType(n) => f(n).withProv(p)
       case tr: TypeRef if !preserveTypeRefs && tr.canExpand => tr.expandOrCrash.negNormPos(f, p)
-      case _: RecordType | _: FunctionType => BotType // Only valid in positive positions!
-        // Because Top<:{x:S}|{y:T}, any record type negation neg{x:S}<:{y:T} for any y=/=x,
-        // meaning negated records are basically bottoms.
       case rw => NegType(f(rw))(p)
     }
     def withProvOf(ty: SimpleType): ST = withProv(ty.prov)
diff --git a/shared/src/test/diff/fcp/Overloads.mls b/shared/src/test/diff/fcp/Overloads.mls
index 71a328bb55..2e0e51a78c 100644
--- a/shared/src/test/diff/fcp/Overloads.mls
+++ b/shared/src/test/diff/fcp/Overloads.mls
@@ -93,33 +93,43 @@ if true then IISS else BBNN
 //│ res: (0 | 1 | true) -> number
 
 
-// * Note that type normalization is currently very aggressive at approximating negative non-tag types, to simplify the result:
+// * Note that type normalization used to be very aggressive at approximating non-tag type negations,
+// * to simplify the result, but this was changed as it was unsound
 
 def test: ~(int -> int)
-//│ test: in ~(int -> int) out nothing
+//│ test: ~(int -> int)
 
-// * Note about this known unsoundness: see test file BooleanFail.mls
+// * See also test file BooleanFail.mls about this previous unsoundness
+:e
 test = 42
 not test
 //│ 42
 //│   <:  test:
 //│ ~(int -> int)
-//│ res: bool
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.105: 	not test
+//│ ║         	^^^^^^^^
+//│ ╟── type `~(int -> int)` is not an instance of type `bool`
+//│ ║  l.99: 	def test: ~(int -> int)
+//│ ║        	          ^^^^^^^^^^^^^
+//│ ╟── but it flows into reference with expected type `bool`
+//│ ║  l.105: 	not test
+//│ ╙──       	    ^^^^
+//│ res: bool | error
 
-// :ds
 def test: ~(int -> int) & ~bool
-//│ test: in ~bool & ~(int -> int) out nothing
+//│ test: ~bool & ~(int -> int)
 
 def test: ~(int -> int) & bool
-//│ test: in bool out nothing
+//│ test: bool
 
 def test: ~(int -> int) & ~(bool -> bool)
-//│ test: in ~(nothing -> (bool | int)) out nothing
+//│ test: ~(nothing -> (bool | int))
 
 def test: ~(int -> int | bool -> bool)
-//│ test: in ~(nothing -> (bool | int)) out nothing
+//│ test: ~(nothing -> (bool | int))
 
 def test: ~(int -> int & string -> string) & ~(bool -> bool & number -> number)
-//│ test: in ~(nothing -> (number | string) & int -> number & nothing -> (bool | string) & nothing -> (bool | int)) out nothing
+//│ test: in ~(nothing -> (number | string) & int -> number & nothing -> (bool | string) & nothing -> (bool | int)) out ~(nothing -> (bool | int) & nothing -> (bool | string) & int -> number & nothing -> (number | string))
 
 
diff --git a/shared/src/test/diff/mlscript/Annoying.mls b/shared/src/test/diff/mlscript/Annoying.mls
index 2a08eae7f7..7babae3c6a 100644
--- a/shared/src/test/diff/mlscript/Annoying.mls
+++ b/shared/src/test/diff/mlscript/Annoying.mls
@@ -190,7 +190,7 @@ id (error: A) with { x = 1 } : A | { x: 'a }
 //│ res: A | {x: nothing}
 
 def negWeird: ~(~(~(A & { x: int })))
-//│ negWeird: in ~(A & {x: int}) out ~A
+//│ negWeird: ~(A & {x: int})
 
 def v = negWeird with { x = 1 }
 //│ v: ~A\x & {x: 1} | {x: 1} & ~{x: int}
diff --git a/shared/src/test/diff/mlscript/BooleanFail.mls b/shared/src/test/diff/mlscript/BooleanFail.mls
index c75abe8744..aaccada66e 100644
--- a/shared/src/test/diff/mlscript/BooleanFail.mls
+++ b/shared/src/test/diff/mlscript/BooleanFail.mls
@@ -3,28 +3,52 @@
 
 // * The MLscript subtyping system is currently ill-formed in some corner cases.
 // * Notably, it considers functions and classes to intersect to nothing
-// * and also considers positive negated function/record types equivalent to nothing.
+// * and also used to considers positive negated function/record types equivalent to nothing.
 
 // * (This isn't the case in MLstruct, which has a sound subtyping lattice.)
 
 
-// * Example 1
+
+// * Example 1 – now fixed
+
 oops = 42 : ~(int -> int)
-not oops
-//│ oops: nothing
+//│ oops: ~(int -> int)
 //│     = 42
-//│ res: bool
+
+:e
+not oops
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.19: 	not oops
+//│ ║        	^^^^^^^^
+//│ ╟── type `~(int -> int)` is not an instance of type `bool`
+//│ ║  l.14: 	oops = 42 : ~(int -> int)
+//│ ║        	            ^^^^^^^^^^^^^
+//│ ╟── but it flows into reference with expected type `bool`
+//│ ║  l.19: 	not oops
+//│ ╙──      	    ^^^^
+//│ res: bool | error
 //│    = false
 
 
-// * OTOH, this doesn't lead to immediate unsoundness:
+// * This was accepted but didn't immediately lead to immediate unsoundness:
 def f: (~{x: int}) -> 'a
-f = id
-//│ f: in nothing -> nothing out ~{x: int} -> nothing
+//│ f: ~{x: int} -> nothing
 //│  = <missing implementation>
+
+:e
+f = id
 //│ 'a -> 'a
 //│   <:  f:
-//│ nothing -> nothing
+//│ ~{x: int} -> nothing
+//│ ╔══[ERROR] Type mismatch in def definition:
+//│ ║  l.39: 	f = id
+//│ ║        	^^^^^^
+//│ ╟── type `~{x: int}` does not match type `'a`
+//│ ║  l.34: 	def f: (~{x: int}) -> 'a
+//│ ║        	       ^^^^^^^^^^^
+//│ ╟── Note: constraint arises from type variable:
+//│ ║  l.34: 	def f: (~{x: int}) -> 'a
+//│ ╙──      	                      ^^
 //│  = [Function: id]
 
 :e
@@ -33,64 +57,75 @@ f id
 f {}
 f (forall 'a. fun (x: 'a) -> x)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.31: 	f 0
+//│ ║  l.55: 	f 0
 //│ ║        	^^^
 //│ ╟── integer literal of type `0` does not match type `~{x: int}`
-//│ ║  l.31: 	f 0
+//│ ║  l.55: 	f 0
 //│ ║        	  ^
 //│ ╟── Note: constraint arises from type negation:
-//│ ║  l.21: 	def f: (~{x: int}) -> 'a
+//│ ║  l.34: 	def f: (~{x: int}) -> 'a
 //│ ╙──      	       ^^^^^^^^^^^
 //│ res: error
 //│    = 0
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.32: 	f id
+//│ ║  l.56: 	f id
 //│ ║        	^^^^
 //│ ╟── reference of type `?a -> ?a` does not match type `~{x: int}`
-//│ ║  l.32: 	f id
+//│ ║  l.56: 	f id
 //│ ║        	  ^^
 //│ ╟── Note: constraint arises from type negation:
-//│ ║  l.21: 	def f: (~{x: int}) -> 'a
+//│ ║  l.34: 	def f: (~{x: int}) -> 'a
 //│ ╙──      	       ^^^^^^^^^^^
 //│ res: error
 //│    = [Function: id]
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.33: 	f {}
+//│ ║  l.57: 	f {}
 //│ ║        	^^^^
 //│ ╟── record literal of type `anything` does not match type `~{x: int}`
-//│ ║  l.33: 	f {}
+//│ ║  l.57: 	f {}
 //│ ║        	  ^^
 //│ ╟── Note: constraint arises from type negation:
-//│ ║  l.21: 	def f: (~{x: int}) -> 'a
+//│ ║  l.34: 	def f: (~{x: int}) -> 'a
 //│ ╙──      	       ^^^^^^^^^^^
 //│ res: error
 //│    = {}
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.34: 	f (forall 'a. fun (x: 'a) -> x)
+//│ ║  l.58: 	f (forall 'a. fun (x: 'a) -> x)
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── function of type `'a -> 'a` does not match type `~{x: int}`
-//│ ║  l.34: 	f (forall 'a. fun (x: 'a) -> x)
+//│ ║  l.58: 	f (forall 'a. fun (x: 'a) -> x)
 //│ ║        	              ^^^^^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from type negation:
-//│ ║  l.21: 	def f: (~{x: int}) -> 'a
+//│ ║  l.34: 	def f: (~{x: int}) -> 'a
 //│ ╙──      	       ^^^^^^^^^^^
 //│ res: error
 //│    = [Function (anonymous)]
 
 
-// * Example 2
+// * Example 2 – now fixed
 
 def g(x: 'a | {f: nothing}) = x.f(0)
 //│ g: {f: 0 -> 'a} -> 'a
 //│  = [Function: g]
 
+:e
 foo = forall 'x. fun (x: 'x) -> g(x)
-//│ foo: anything -> nothing
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.112: 	foo = forall 'x. fun (x: 'x) -> g(x)
+//│ ║         	                                ^^^^
+//│ ╟── expression of type `'x & ~{f: nothing}` does not have field 'f'
+//│ ╟── Note: constraint arises from field selection:
+//│ ║  l.107: 	def g(x: 'a | {f: nothing}) = x.f(0)
+//│ ║         	                              ^^^
+//│ ╟── from type variable:
+//│ ║  l.107: 	def g(x: 'a | {f: nothing}) = x.f(0)
+//│ ╙──       	         ^^
+//│ foo: anything -> error
 //│    = [Function: foo]
 
 :re
 foo 0
-//│ res: nothing
+//│ res: error
 //│ Runtime error:
 //│   TypeError: x.f is not a function
 
@@ -135,11 +170,11 @@ b = a
 //│   <:  b:
 //│ Foo & {x: int}
 //│ ╔══[ERROR] Type mismatch in def definition:
-//│ ║  l.133: 	b = a
+//│ ║  l.168: 	b = a
 //│ ║         	^^^^^
 //│ ╟── expression of type `anything` is not an instance of type `int`
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.109: 	def b: int -> int & Foo | {x: int} & Foo
+//│ ║  l.144: 	def b: int -> int & Foo | {x: int} & Foo
 //│ ╙──       	                              ^^^
 
 
diff --git a/shared/src/test/diff/mlscript/ExprProb.mls b/shared/src/test/diff/mlscript/ExprProb.mls
index d960f926d0..d092b113ab 100644
--- a/shared/src/test/diff/mlscript/ExprProb.mls
+++ b/shared/src/test/diff/mlscript/ExprProb.mls
@@ -142,20 +142,6 @@ eval1_ty_ugly
 //│    = <no result>
 //│      eval1_ty_ugly is not implemented
 
-:stats
-def eval1_ty_ugly = eval1
-//│ ('a -> int) -> 'b -> int
-//│   where
-//│     'b <: Add[?] & {lhs: 'b, rhs: 'b} | Lit | 'a & ~#Add & ~#Lit
-//│   <:  eval1_ty_ugly:
-//│ ('a -> int) -> 'b -> int
-//│   where
-//│     'b <: Add['b] | Lit | 'a & ~Add[?] & ~Lit
-//│              = [Function: eval1_ty_ugly]
-//│ constrain calls  : 71
-//│ annoying  calls  : 37
-//│ subtyping calls  : 580
-
 :ns
 def eval1_ty: ('a -> int) -> (Lit | Add['b] | 'a & ~lit & ~add as 'b) -> int
 //│ eval1_ty: forall 'a 'b. ('a -> int) -> 'b -> int
@@ -184,20 +170,6 @@ def eval1_ty = eval1
 //│ annoying  calls  : 37
 //│ subtyping calls  : 576
 
-:stats
-eval1_ty_ugly = eval1_ty
-//│ ('a -> int) -> 'b -> int
-//│   where
-//│     'b <: Add['b] | Lit | 'a & ~#Add & ~#Lit
-//│   <:  eval1_ty_ugly:
-//│ ('a -> int) -> 'b -> int
-//│   where
-//│     'b <: Add['b] | Lit | 'a & ~Add[?] & ~Lit
-//│              = [Function: eval1]
-//│ constrain calls  : 36
-//│ annoying  calls  : 33
-//│ subtyping calls  : 372
-
 :stats
 eval1_ty = eval1_ty_ugly
 //│ ('a -> int) -> 'b -> int
@@ -207,10 +179,11 @@ eval1_ty = eval1_ty_ugly
 //│ ('a -> int) -> 'b -> int
 //│   where
 //│     'b <: Add['b] | Lit | 'a & ~#Add & ~#Lit
-//│         = [Function: eval1]
-//│ constrain calls  : 208
-//│ annoying  calls  : 529
-//│ subtyping calls  : 2710
+//│         = <no result>
+//│           eval1_ty_ugly is not implemented
+//│ constrain calls  : 238
+//│ annoying  calls  : 565
+//│ subtyping calls  : 5737
 
 
 // Workaround:
@@ -233,7 +206,7 @@ def eval1_ty = eval1
 //│     'b <: Add[?] & {lhs: 'b, rhs: 'b} | Lit | 'a & ~#Add & ~#Lit
 //│   <:  eval1_ty:
 //│ ('a -> int) -> E1['a] -> int
-//│         = [Function: eval1_ty2]
+//│         = [Function: eval1_ty1]
 //│ constrain calls  : 67
 //│ annoying  calls  : 37
 //│ subtyping calls  : 471
@@ -570,13 +543,64 @@ prettier22 done (eval2 done) d2
 :ShowRelativeLineNums
 
 
+:stats
+:e
+def eval1_ty_ugly = eval1
+//│ ('a -> int) -> 'b -> int
+//│   where
+//│     'b <: Add[?] & {lhs: 'b, rhs: 'b} | Lit | 'a & ~#Add & ~#Lit
+//│   <:  eval1_ty_ugly:
+//│ ('a -> int) -> 'b -> int
+//│   where
+//│     'b <: Add['b] | Lit | 'a & ~Add[?] & ~Lit
+//│ ╔══[ERROR] Type mismatch in def definition:
+//│ ║  l.+1: 	def eval1_ty_ugly = eval1
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── expression of type `'a & (Add[?] & ~{val: int} & ~#Add | Lit & ~{val: int} | ~{val: int} & ~#Add & ~?a)` does not have field 'val'
+//│ ╟── Note: constraint arises from field selection:
+//│ ║  l.71: 	  | Lit -> e.val
+//│ ║        	           ^^^^^
+//│ ╟── from refined scrutinee:
+//│ ║  l.70: 	rec def eval1 k e = case e of {
+//│ ╙──      	                         ^
+//│              = [Function: eval1_ty_ugly]
+//│ constrain calls  : 105
+//│ annoying  calls  : 121
+//│ subtyping calls  : 3819
+
+:stats
+:e
+eval1_ty_ugly = eval1_ty
+//│ ('a -> int) -> E1['a] -> int
+//│   <:  eval1_ty_ugly:
+//│ ('a -> int) -> 'b -> int
+//│   where
+//│     'b <: Add['b] | Lit | 'a & ~Add[?] & ~Lit
+//│ ╔══[ERROR] Type mismatch in def definition:
+//│ ║  l.+1: 	eval1_ty_ugly = eval1_ty
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── type `'a & ~Add[?] & ~Lit` does not match type `Add[E1['a0]] | Lit | 'a0 & ~#Add & ~#Lit`
+//│ ║  l.132: 	def eval1_ty_ugly: ('a -> int) -> (Lit | Add['b] | 'a & ~Lit & ~Add[?] as 'b) -> int
+//│ ║         	                                                   ^^^^^^^^^^^^^^^^^^^
+//│ ╟── Note: constraint arises from union type:
+//│ ║  l.191: 	type E1[A] = Lit | Add[E1[A]] | A & ~lit & ~add
+//│ ║         	             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── from applied type reference:
+//│ ║  l.192: 	def eval1_ty: ('a -> int) -> E1['a] -> int
+//│ ╙──       	                             ^^^^^^
+//│              = [Function: eval1]
+//│ constrain calls  : 53
+//│ annoying  calls  : 182
+//│ subtyping calls  : 1809
+
+
 :e
 eval1 done e2
 //│ ╔══[ERROR] Type mismatch in application:
 //│ ║  l.+1: 	eval1 done e2
 //│ ║        	^^^^^^^^^^^^^
 //│ ╟── application of type `Nega[?E] & {Nega#E = ?E, arg: ?arg}` does not match type `nothing`
-//│ ║  l.370: 	def nega arg = Nega { arg }
+//│ ║  l.343: 	def nega arg = Nega { arg }
 //│ ║         	               ^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from reference:
 //│ ║  l.4: 	def done x = case x of {}
@@ -606,7 +630,7 @@ prettier2 done eval1 e1
 //│ ║  l.74: 	  }
 //│ ║        	^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.262: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.235: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	              ^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in application:
 //│ ║  l.+1: 	prettier2 done eval1 e1
@@ -618,7 +642,7 @@ prettier2 done eval1 e1
 //│ ║  l.73: 	  | _ -> k e
 //│ ║        	         ^^^
 //│ ╟── from field selection:
-//│ ║  l.262: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.235: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	                 ^^^^^
 //│ res: error
 //│    = '123'
@@ -631,13 +655,13 @@ prettier2 done (eval1 done) e2
 //│ ║  l.+1: 	prettier2 done (eval1 done) e2
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── application of type `Nega[?E] & {Nega#E = ?E, arg: ?arg}` does not match type `nothing`
-//│ ║  l.370: 	def nega arg = Nega { arg }
+//│ ║  l.343: 	def nega arg = Nega { arg }
 //│ ║         	               ^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from reference:
 //│ ║  l.4: 	def done x = case x of {}
 //│ ║       	                  ^
 //│ ╟── from field selection:
-//│ ║  l.262: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.235: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	                 ^^^^^
 //│ res: error | string
 //│ Runtime error:
@@ -664,7 +688,7 @@ prettier2 done eval2
 //│ ║  l.74: 	  }
 //│ ║        	^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.262: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.235: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	              ^^^^^^^^
 //│ res: error | 'a -> string
 //│   where
@@ -694,7 +718,7 @@ prettier2 done eval2 e1
 //│ ║  l.74: 	  }
 //│ ║        	^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.262: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.235: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	              ^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in application:
 //│ ║  l.+1: 	prettier2 done eval2 e1
@@ -703,10 +727,10 @@ prettier2 done eval2 e1
 //│ ║  l.18: 	def lit val = Lit { val }
 //│ ║        	              ^^^^^^^^^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.379: 	  | _ -> k x
+//│ ║  l.352: 	  | _ -> k x
 //│ ║         	         ^^^
 //│ ╟── from field selection:
-//│ ║  l.262: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.235: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	                 ^^^^^
 //│ res: error
 //│    = '123'
@@ -732,7 +756,7 @@ prettier2 done eval2 e2
 //│ ║  l.74: 	  }
 //│ ║        	^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.262: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.235: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	              ^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in application:
 //│ ║  l.+1: 	prettier2 done eval2 e2
@@ -741,10 +765,10 @@ prettier2 done eval2 e2
 //│ ║  l.18: 	def lit val = Lit { val }
 //│ ║        	              ^^^^^^^^^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.379: 	  | _ -> k x
+//│ ║  l.352: 	  | _ -> k x
 //│ ║         	         ^^^
 //│ ╟── from field selection:
-//│ ║  l.262: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.235: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	                 ^^^^^
 //│ res: error
 //│    = '1-123'
@@ -770,19 +794,19 @@ prettier2 done eval2 d2
 //│ ║  l.74: 	  }
 //│ ║        	^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.262: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.235: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	              ^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in application:
 //│ ║  l.+1: 	prettier2 done eval2 d2
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── application of type `Nega[?E] & {Nega#E = ?E, arg: ?arg}` is not a function
-//│ ║  l.370: 	def nega arg = Nega { arg }
+//│ ║  l.343: 	def nega arg = Nega { arg }
 //│ ║         	               ^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.379: 	  | _ -> k x
+//│ ║  l.352: 	  | _ -> k x
 //│ ║         	         ^^^
 //│ ╟── from field selection:
-//│ ║  l.262: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.235: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	                 ^^^^^
 //│ res: error | string
 //│    = '-1-1'
@@ -808,7 +832,7 @@ prettier2 done eval1 e2
 //│ ║  l.74: 	  }
 //│ ║        	^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.262: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.235: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	              ^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in application:
 //│ ║  l.+1: 	prettier2 done eval1 e2
@@ -820,7 +844,7 @@ prettier2 done eval1 e2
 //│ ║  l.73: 	  | _ -> k e
 //│ ║        	         ^^^
 //│ ╟── from field selection:
-//│ ║  l.262: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.235: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	                 ^^^^^
 //│ res: error
 //│    = '1-123'
diff --git a/shared/src/test/diff/mlscript/ExprProb_Inv.mls b/shared/src/test/diff/mlscript/ExprProb_Inv.mls
index 782e1a91b6..b9a37de688 100644
--- a/shared/src/test/diff/mlscript/ExprProb_Inv.mls
+++ b/shared/src/test/diff/mlscript/ExprProb_Inv.mls
@@ -144,20 +144,6 @@ eval1_ty_ugly
 //│    = <no result>
 //│      eval1_ty_ugly is not implemented
 
-:stats
-def eval1_ty_ugly = eval1
-//│ ('a -> int) -> 'b -> int
-//│   where
-//│     'b <: (Add[?] with {lhs: 'b, rhs: 'b}) | Lit | 'a & ~#Add & ~#Lit
-//│   <:  eval1_ty_ugly:
-//│ ('a -> int) -> 'b -> int
-//│   where
-//│     'b := Add['b] | Lit | 'a & ~Add[?] & ~Lit
-//│              = [Function: eval1_ty_ugly]
-//│ constrain calls  : 71
-//│ annoying  calls  : 37
-//│ subtyping calls  : 596
-
 :ns
 def eval1_ty: ('a -> int) -> (Lit | Add['b] | 'a & ~lit & ~add as 'b) -> int
 //│ eval1_ty: forall 'a 'b. ('a -> int) -> 'b -> int
@@ -186,20 +172,6 @@ def eval1_ty = eval1
 //│ annoying  calls  : 37
 //│ subtyping calls  : 588
 
-:stats
-eval1_ty_ugly = eval1_ty
-//│ ('a -> int) -> 'b -> int
-//│   where
-//│     'b := Add['b] | Lit | 'a & ~#Add & ~#Lit
-//│   <:  eval1_ty_ugly:
-//│ ('a -> int) -> 'b -> int
-//│   where
-//│     'b := Add['b] | Lit | 'a & ~Add[?] & ~Lit
-//│              = [Function: eval1]
-//│ constrain calls  : 150
-//│ annoying  calls  : 1810
-//│ subtyping calls  : 2699
-
 :stats
 eval1_ty = eval1_ty_ugly
 //│ ('a -> int) -> 'b -> int
@@ -209,10 +181,11 @@ eval1_ty = eval1_ty_ugly
 //│ ('a -> int) -> 'b -> int
 //│   where
 //│     'b := Add['b] | Lit | 'a & ~#Add & ~#Lit
-//│         = [Function: eval1]
-//│ constrain calls  : 752
-//│ annoying  calls  : 674
-//│ subtyping calls  : 71116
+//│         = <no result>
+//│           eval1_ty_ugly is not implemented
+//│ constrain calls  : 4870
+//│ annoying  calls  : 1519
+//│ subtyping calls  : 668110
 
 
 // Workaround:
@@ -235,7 +208,7 @@ def eval1_ty = eval1
 //│     'b <: (Add[?] with {lhs: 'b, rhs: 'b}) | Lit | 'a & ~#Add & ~#Lit
 //│   <:  eval1_ty:
 //│ ('a -> int) -> E1['a] -> int
-//│         = [Function: eval1_ty2]
+//│         = [Function: eval1_ty1]
 //│ constrain calls  : 67
 //│ annoying  calls  : 37
 //│ subtyping calls  : 487
@@ -571,13 +544,64 @@ prettier22 done (eval2 done) d2
 :ShowRelativeLineNums
 
 
+:stats
+:e
+def eval1_ty_ugly = eval1
+//│ ('a -> int) -> 'b -> int
+//│   where
+//│     'b <: (Add[?] with {lhs: 'b, rhs: 'b}) | Lit | 'a & ~#Add & ~#Lit
+//│   <:  eval1_ty_ugly:
+//│ ('a -> int) -> 'b -> int
+//│   where
+//│     'b := Add['b] | Lit | 'a & ~Add[?] & ~Lit
+//│ ╔══[ERROR] Type mismatch in def definition:
+//│ ║  l.+1: 	def eval1_ty_ugly = eval1
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── expression of type `'a & (Add[?] & ~{val: int} & ~#Add | Lit & ~{val: int} | ~{val: int} & ~#Add & ~?a)` does not have field 'val'
+//│ ╟── Note: constraint arises from field selection:
+//│ ║  l.73: 	  | Lit -> e.val
+//│ ║        	           ^^^^^
+//│ ╟── from refined scrutinee:
+//│ ║  l.72: 	rec def eval1 k e = case e of {
+//│ ╙──      	                         ^
+//│              = [Function: eval1_ty_ugly]
+//│ constrain calls  : 105
+//│ annoying  calls  : 121
+//│ subtyping calls  : 3763
+
+:stats
+:e
+eval1_ty_ugly = eval1_ty
+//│ ('a -> int) -> E1['a] -> int
+//│   <:  eval1_ty_ugly:
+//│ ('a -> int) -> 'b -> int
+//│   where
+//│     'b := Add['b] | Lit | 'a & ~Add[?] & ~Lit
+//│ ╔══[ERROR] Type mismatch in def definition:
+//│ ║  l.+1: 	eval1_ty_ugly = eval1_ty
+//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── type `'a & ~Add[?] & ~Lit` does not match type `Add[E1['a0]] | Lit | 'a0 & ~#Add & ~#Lit`
+//│ ║  l.134: 	def eval1_ty_ugly: ('a -> int) -> (Lit | Add['b] | 'a & ~Lit & ~Add[?] as 'b) -> int
+//│ ║         	                                                   ^^^^^^^^^^^^^^^^^^^
+//│ ╟── Note: constraint arises from union type:
+//│ ║  l.193: 	type E1[A] = Lit | Add[E1[A]] | A & ~lit & ~add
+//│ ║         	             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── from applied type reference:
+//│ ║  l.194: 	def eval1_ty: ('a -> int) -> E1['a] -> int
+//│ ╙──       	                             ^^^^^^
+//│              = [Function: eval1]
+//│ constrain calls  : 200
+//│ annoying  calls  : 9801
+//│ subtyping calls  : 21512
+
+
 :e
 eval1 done e2
 //│ ╔══[ERROR] Type mismatch in application:
 //│ ║  l.+1: 	eval1 done e2
 //│ ║        	^^^^^^^^^^^^^
 //│ ╟── application of type `Nega[?E] & {Nega#E = ?E, arg: ?arg}` does not match type `nothing`
-//│ ║  l.372: 	def nega arg = Nega { arg }
+//│ ║  l.345: 	def nega arg = Nega { arg }
 //│ ║         	               ^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from reference:
 //│ ║  l.4: 	def done x = case x of {}
@@ -607,7 +631,7 @@ prettier2 done eval1 e1
 //│ ║  l.76: 	  }
 //│ ║        	^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.264: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.237: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	              ^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in application:
 //│ ║  l.+1: 	prettier2 done eval1 e1
@@ -619,7 +643,7 @@ prettier2 done eval1 e1
 //│ ║  l.75: 	  | _ -> k e
 //│ ║        	         ^^^
 //│ ╟── from field selection:
-//│ ║  l.264: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.237: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	                 ^^^^^
 //│ res: error
 //│    = '123'
@@ -632,13 +656,13 @@ prettier2 done (eval1 done) e2
 //│ ║  l.+1: 	prettier2 done (eval1 done) e2
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── application of type `Nega[?E] & {Nega#E = ?E, arg: ?arg}` does not match type `nothing`
-//│ ║  l.372: 	def nega arg = Nega { arg }
+//│ ║  l.345: 	def nega arg = Nega { arg }
 //│ ║         	               ^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from reference:
 //│ ║  l.4: 	def done x = case x of {}
 //│ ║       	                  ^
 //│ ╟── from field selection:
-//│ ║  l.264: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.237: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	                 ^^^^^
 //│ res: error | string
 //│ Runtime error:
@@ -665,7 +689,7 @@ prettier2 done eval2
 //│ ║  l.76: 	  }
 //│ ║        	^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.264: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.237: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	              ^^^^^^^^
 //│ res: error | 'a -> string
 //│   where
@@ -695,7 +719,7 @@ prettier2 done eval2 e1
 //│ ║  l.76: 	  }
 //│ ║        	^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.264: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.237: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	              ^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in application:
 //│ ║  l.+1: 	prettier2 done eval2 e1
@@ -704,10 +728,10 @@ prettier2 done eval2 e1
 //│ ║  l.19: 	def lit val = Lit { val }
 //│ ║        	              ^^^^^^^^^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.381: 	  | _ -> k x
+//│ ║  l.354: 	  | _ -> k x
 //│ ║         	         ^^^
 //│ ╟── from field selection:
-//│ ║  l.264: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.237: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	                 ^^^^^
 //│ res: error
 //│    = '123'
@@ -733,7 +757,7 @@ prettier2 done eval2 e2
 //│ ║  l.76: 	  }
 //│ ║        	^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.264: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.237: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	              ^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in application:
 //│ ║  l.+1: 	prettier2 done eval2 e2
@@ -742,10 +766,10 @@ prettier2 done eval2 e2
 //│ ║  l.19: 	def lit val = Lit { val }
 //│ ║        	              ^^^^^^^^^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.381: 	  | _ -> k x
+//│ ║  l.354: 	  | _ -> k x
 //│ ║         	         ^^^
 //│ ╟── from field selection:
-//│ ║  l.264: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.237: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	                 ^^^^^
 //│ res: error
 //│    = '1-123'
@@ -771,19 +795,19 @@ prettier2 done eval2 d2
 //│ ║  l.76: 	  }
 //│ ║        	^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.264: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.237: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	              ^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in application:
 //│ ║  l.+1: 	prettier2 done eval2 d2
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── application of type `Nega[?E] & {Nega#E = ?E, arg: ?arg}` is not a function
-//│ ║  l.372: 	def nega arg = Nega { arg }
+//│ ║  l.345: 	def nega arg = Nega { arg }
 //│ ║         	               ^^^^^^^^^^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.381: 	  | _ -> k x
+//│ ║  l.354: 	  | _ -> k x
 //│ ║         	         ^^^
 //│ ╟── from field selection:
-//│ ║  l.264: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.237: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	                 ^^^^^
 //│ res: error | string
 //│    = '-1-1'
@@ -809,7 +833,7 @@ prettier2 done eval1 e2
 //│ ║  l.76: 	  }
 //│ ║        	^^^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.264: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.237: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	              ^^^^^^^^
 //│ ╔══[ERROR] Type mismatch in application:
 //│ ║  l.+1: 	prettier2 done eval1 e2
@@ -821,7 +845,7 @@ prettier2 done eval1 e2
 //│ ║  l.75: 	  | _ -> k e
 //│ ║        	         ^^^
 //│ ╟── from field selection:
-//│ ║  l.264: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
+//│ ║  l.237: 	      else if ev e.rhs == 0 then prettier1 k ev e.lhs
 //│ ╙──       	                 ^^^^^
 //│ res: error
 //│    = '1-123'
diff --git a/shared/src/test/diff/mlscript/Neg.mls b/shared/src/test/diff/mlscript/Neg.mls
index e3f02f9719..dca2ae637d 100644
--- a/shared/src/test/diff/mlscript/Neg.mls
+++ b/shared/src/test/diff/mlscript/Neg.mls
@@ -128,25 +128,37 @@ def f: (~Foo[1 | 2] & 'a | ~Foo[2 | 3] & 'a) -> 'a
 //│ f: ('a & ~Foo[?]) -> 'a
 //│  = <missing implementation>
 
-// * Notice the weird negative (in) type, and also see BooleanFail.mls
+// * Type ~{x: 1 | 2} & 'a | ~{x: 2 | 3} & 'a
+// *   is ~({x: 1 | 2} & {x: 2 | 3}) & 'a
+// *   is ~{x: 2}) & 'a
 def f: (~{x: 1 | 2} & 'a | ~{x: 2 | 3} & 'a) -> 'a
-//│ f: in forall 'a. nothing -> 'a out forall 'a. ('a & ~{x: 2}) -> 'a
+//│ f: ('a & ~{x: 2}) -> 'a
 //│  = <missing implementation>
 
 f = id
 //│ 'a -> 'a
 //│   <:  f:
-//│ nothing -> nothing
+//│ ('a & ~{x: 2}) -> 'a
 //│  = [Function: id]
 
+:e
 f x = case x of {}
 //│ nothing -> nothing
 //│   <:  f:
-//│ nothing -> nothing
+//│ ('a & ~{x: 2}) -> 'a
+//│ ╔══[ERROR] Type mismatch in def definition:
+//│ ║  l.145: 	f x = case x of {}
+//│ ║         	^^^^^^^^^^^^^^^^^^
+//│ ╟── type `'a & ~{x: 1 | 2}` does not match type `nothing`
+//│ ║  l.134: 	def f: (~{x: 1 | 2} & 'a | ~{x: 2 | 3} & 'a) -> 'a
+//│ ║         	        ^^^^^^^^^^^^^^^^
+//│ ╟── Note: constraint arises from reference:
+//│ ║  l.145: 	f x = case x of {}
+//│ ╙──       	           ^
 //│  = [Function: f2]
 
 def f: (~{x: 1 | 2} & ~lit & 'a | ~{x: 2 | 3} & ~lit & 'a) -> 'a
-//│ f: in forall 'a. nothing -> 'a out forall 'a. ('a & ~{x: 2} & ~#Lit) -> 'a
+//│ f: ('a & ~{x: 2} & ~#Lit) -> 'a
 //│  = <missing implementation>
 
 
diff --git a/shared/src/test/diff/mlscript/StressTraits.mls b/shared/src/test/diff/mlscript/StressTraits.mls
index df63bffef4..93910bee47 100644
--- a/shared/src/test/diff/mlscript/StressTraits.mls
+++ b/shared/src/test/diff/mlscript/StressTraits.mls
@@ -63,7 +63,7 @@ foo arg
 //│ res: error | int
 //│ constrain calls  : 36
 //│ annoying  calls  : 31
-//│ subtyping calls  : 698
+//│ subtyping calls  : 724
 
 :stats
 :e
@@ -83,7 +83,7 @@ foo arg
 //│ res: error | int
 //│ constrain calls  : 65
 //│ annoying  calls  : 90
-//│ subtyping calls  : 3208
+//│ subtyping calls  : 3498
 
 :stats
 :e
@@ -103,7 +103,7 @@ foo arg
 //│ res: error
 //│ constrain calls  : 82
 //│ annoying  calls  : 209
-//│ subtyping calls  : 16245
+//│ subtyping calls  : 17621
 
 
 // ====== 2 ====== //
@@ -131,7 +131,7 @@ foo arg
 //│ res: error | int
 //│ constrain calls  : 44
 //│ annoying  calls  : 31
-//│ subtyping calls  : 494
+//│ subtyping calls  : 520
 
 
 // ====== 3 ====== //
@@ -160,7 +160,7 @@ foo arg
 //│ res: error | int
 //│ constrain calls  : 76
 //│ annoying  calls  : 90
-//│ subtyping calls  : 2989
+//│ subtyping calls  : 3279
 
 
 // ====== 4 ====== //
@@ -190,7 +190,7 @@ foo arg
 //│ res: error
 //│ constrain calls  : 94
 //│ annoying  calls  : 131
-//│ subtyping calls  : 3984
+//│ subtyping calls  : 4350
 
 :stats
 :e
@@ -208,7 +208,7 @@ foo (arg with { x = 1} with { y = 2 })
 //│ res: error
 //│ constrain calls  : 69
 //│ annoying  calls  : 128
-//│ subtyping calls  : 3450
+//│ subtyping calls  : 3820
 
 :stats
 :e
@@ -226,7 +226,7 @@ foo (arg with { x = 1; y = 2; z = 3 })
 //│ res: error
 //│ constrain calls  : 69
 //│ annoying  calls  : 128
-//│ subtyping calls  : 3450
+//│ subtyping calls  : 3820
 
 
 // ====== 5 ====== //
@@ -257,7 +257,7 @@ foo arg
 //│ res: error
 //│ constrain calls  : 98
 //│ annoying  calls  : 131
-//│ subtyping calls  : 4272
+//│ subtyping calls  : 4638
 
 
 // ====== 6 ====== //
@@ -289,7 +289,7 @@ foo arg
 //│ res: error
 //│ constrain calls  : 102
 //│ annoying  calls  : 131
-//│ subtyping calls  : 4618
+//│ subtyping calls  : 4984
 
 
 // ====== 7 ====== //
@@ -322,7 +322,7 @@ foo arg
 //│ res: error
 //│ constrain calls  : 106
 //│ annoying  calls  : 131
-//│ subtyping calls  : 5027
+//│ subtyping calls  : 5393
 
 def foo_manual: ({fA: 'a} & a | {fB: 'a} & b & ~a | {fC: 'a} & c & ~a & ~b | {fD: 'a} & d & ~a & ~b & ~c | {fE: 'a} & e & ~a & ~b & ~c & ~d | {fF: 'a} & f & ~a & ~b & ~c & ~d & ~e | {fG: 'a} & g & ~a & ~b & ~c & ~d & ~e & ~f) -> 'a
 //│ foo_manual: ({fA: 'a} & #A | ~#A & ({fB: 'a} & #B | ~#B & ({fC: 'a} & #C | ~#C & ({fD: 'a} & #D | ~#D & ({fE: 'a} & #E | ~#E & ({fF: 'a} & #F | {fG: 'a} & #G & ~#F)))))) -> 'a
@@ -388,6 +388,6 @@ foo arg
 //│ res: error
 //│ constrain calls  : 110
 //│ annoying  calls  : 131
-//│ subtyping calls  : 5504
+//│ subtyping calls  : 5870
 
 
diff --git a/shared/src/test/diff/mlscript/StressUgly.mls b/shared/src/test/diff/mlscript/StressUgly.mls
index e5d4c5688c..b25c5562ed 100644
--- a/shared/src/test/diff/mlscript/StressUgly.mls
+++ b/shared/src/test/diff/mlscript/StressUgly.mls
@@ -44,7 +44,7 @@ eval1_ty = eval1_ty_ugly
 //│ ╙──      	                  ^^^
 //│         = <no result>
 //│           eval1_ty_ugly is not implemented
-//│ constrain calls  : 49
-//│ annoying  calls  : 42
-//│ subtyping calls  : 397
+//│ constrain calls  : 54
+//│ annoying  calls  : 46
+//│ subtyping calls  : 433
 
diff --git a/shared/src/test/diff/mlscript/TraitMatching.mls b/shared/src/test/diff/mlscript/TraitMatching.mls
index 9604faa444..e95a3cdd96 100644
--- a/shared/src/test/diff/mlscript/TraitMatching.mls
+++ b/shared/src/test/diff/mlscript/TraitMatching.mls
@@ -144,8 +144,19 @@ def strawman: C2 & ~MyTrait[anything]
 //│ strawman: C2 & ~MyTrait[?]
 //│         = <missing implementation>
 
+:e
 test2 strawman
-//│ res: string
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.148: 	test2 strawman
+//│ ║         	^^^^^^^^^^^^^^
+//│ ╟── expression of type `C2 & ~{value: anything} & ~?a | C2 & #MyTrait & ~{value: anything}` does not have field 'value'
+//│ ╟── Note: constraint arises from field selection:
+//│ ║  l.45: 	def test2 x = case x of { MyTrait -> x.value | _ -> x.default }
+//│ ║        	                                     ^^^^^^^
+//│ ╟── from refined scrutinee:
+//│ ║  l.45: 	def test2 x = case x of { MyTrait -> x.value | _ -> x.default }
+//│ ╙──      	                   ^
+//│ res: error | string
 //│    = <no result>
 //│      strawman is not implemented
 
@@ -157,18 +168,18 @@ strawman: C2
 :e
 strawman: ~{ value: anything }
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.158: 	strawman: ~{ value: anything }
+//│ ║  l.169: 	strawman: ~{ value: anything }
 //│ ║         	^^^^^^^^
 //│ ╟── type `C2 & ~MyTrait[?]` does not match type `~{value: anything}`
 //│ ║  l.143: 	def strawman: C2 & ~MyTrait[anything]
 //│ ║         	              ^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── but it flows into reference with expected type `~{value: anything}`
-//│ ║  l.158: 	strawman: ~{ value: anything }
+//│ ║  l.169: 	strawman: ~{ value: anything }
 //│ ║         	^^^^^^^^
 //│ ╟── Note: constraint arises from type negation:
-//│ ║  l.158: 	strawman: ~{ value: anything }
+//│ ║  l.169: 	strawman: ~{ value: anything }
 //│ ╙──       	          ^^^^^^^^^^^^^^^^^^^^
-//│ res: nothing
+//│ res: ~{value: anything}
 //│    = <no result>
 //│      strawman is not implemented
 
diff --git a/shared/src/test/diff/nu/HeungTung.mls b/shared/src/test/diff/nu/HeungTung.mls
index 3b0c9c2480..cace8c821d 100644
--- a/shared/src/test/diff/nu/HeungTung.mls
+++ b/shared/src/test/diff/nu/HeungTung.mls
@@ -251,7 +251,7 @@ f: (Int -> Int) & (Bool -> Bool)
 
 // * Notice: in positive position, this is equivalent to Bottom
 fun x: ~{ a: Int }
-//│ fun x: nothing
+//│ fun x: ~{a: Int}
 
 
 class A()

From dd9a0cdac766f08aab0a39f3cf7e039cab0fd62c Mon Sep 17 00:00:00 2001
From: Lionel Parreaux <lionel.parreaux@gmail.com>
Date: Tue, 30 Jul 2024 16:55:10 +0800
Subject: [PATCH 142/147] Update NodeTests

---
 shared/src/test/scala/mlscript/NodeTest.scala | 1 +
 1 file changed, 1 insertion(+)

diff --git a/shared/src/test/scala/mlscript/NodeTest.scala b/shared/src/test/scala/mlscript/NodeTest.scala
index f10b7d895e..f0de650dd3 100644
--- a/shared/src/test/scala/mlscript/NodeTest.scala
+++ b/shared/src/test/scala/mlscript/NodeTest.scala
@@ -18,6 +18,7 @@ class NodeTests extends org.scalatest.funsuite.AnyFunSuite {
       ||  v.startsWith("v19")
       ||  v.startsWith("v20")
       ||  v.startsWith("v21")
+      ||  v.startsWith("v22")
     )
     
   }

From 4a5a0387a6bd12c93de153a6c510f868f7342aa2 Mon Sep 17 00:00:00 2001
From: Lionel Parreaux <lionel.parreaux@gmail.com>
Date: Tue, 30 Jul 2024 17:32:14 +0800
Subject: [PATCH 143/147] Clean up DiffTests and fix its use in `compiler`
 subproject

---
 build.sbt                                     |  2 +
 .../test/scala/mlscript/compiler/Test.scala   | 20 ++--
 .../test/scala/mlscript/compiler/TestIR.scala | 19 +---
 .../src/test/scala/mlscript/DiffTests.scala   | 95 ++++++++-----------
 4 files changed, 51 insertions(+), 85 deletions(-)

diff --git a/build.sbt b/build.sbt
index 458788c522..883cb517fa 100644
--- a/build.sbt
+++ b/build.sbt
@@ -83,6 +83,8 @@ lazy val compiler = crossProject(JSPlatform, JVMPlatform).in(file("compiler"))
     sourceDirectory := baseDirectory.value.getParentFile()/"shared",
     watchSources += WatchSource(
       baseDirectory.value.getParentFile()/"shared"/"test"/"diff", "*.mls", NothingFilter),
+    watchSources += WatchSource(
+      baseDirectory.value.getParentFile()/"shared"/"test"/"diff-ir", "*.mls", NothingFilter),
   )
   .dependsOn(mlscript % "compile->compile;test->test")
 
diff --git a/compiler/shared/test/scala/mlscript/compiler/Test.scala b/compiler/shared/test/scala/mlscript/compiler/Test.scala
index 3707a54692..752dc909e2 100644
--- a/compiler/shared/test/scala/mlscript/compiler/Test.scala
+++ b/compiler/shared/test/scala/mlscript/compiler/Test.scala
@@ -7,8 +7,10 @@ import scala.collection.mutable.StringBuilder
 import mlscript.compiler.TreeDebug
 import simpledef.SimpleDef
 
-class DiffTestCompiler extends DiffTests {
-  import DiffTestCompiler.*
+import DiffTestCompiler.*
+
+class DiffTestCompiler extends DiffTests(State) {
+  
   override def postProcess(mode: ModeType, basePath: List[Str], testName: Str, unit: TypingUnit, output: Str => Unit, raise: Diagnostic => Unit): (List[Str], Option[TypingUnit]) = 
     val outputBuilder = StringBuilder()
 
@@ -47,21 +49,11 @@ class DiffTestCompiler extends DiffTests {
     }
     None
     
-  override protected lazy val files = allFiles.filter { file =>
-      val fileName = file.baseName
-      validExt(file.ext) && filter(file.relativeTo(pwd))
-  }
 }
 
 object DiffTestCompiler {
-
-  private val pwd = os.pwd
-  private val dir = pwd/"compiler"/"shared"/"test"/"diff"
   
-  private val allFiles = os.walk(dir).filter(_.toIO.isFile)
-  
-  private val validExt = Set("fun", "mls")
-
-  private def filter(file: os.RelPath) = DiffTests.filter(file)
+  lazy val State =
+    new DiffTests.State(DiffTests.pwd/"compiler"/"shared"/"test"/"diff")
   
 }
diff --git a/compiler/shared/test/scala/mlscript/compiler/TestIR.scala b/compiler/shared/test/scala/mlscript/compiler/TestIR.scala
index 94dcacae44..565769be1d 100644
--- a/compiler/shared/test/scala/mlscript/compiler/TestIR.scala
+++ b/compiler/shared/test/scala/mlscript/compiler/TestIR.scala
@@ -6,8 +6,9 @@ import mlscript.compiler.ir._
 import scala.collection.mutable.StringBuilder
 import mlscript.compiler.optimizer.TailRecOpt
 
-class IRDiffTestCompiler extends DiffTests {
-  import IRDiffTestCompiler.*
+import IRDiffTestCompiler.*
+
+class IRDiffTestCompiler extends DiffTests(State) {
 
   override def postProcess(mode: ModeType, basePath: List[Str], testName: Str, unit: TypingUnit, output: Str => Unit, raise: Diagnostic => Unit): (List[Str], Option[TypingUnit]) = 
     val outputBuilder = StringBuilder()
@@ -58,21 +59,11 @@ class IRDiffTestCompiler extends DiffTests {
       
     (outputBuilder.toString().linesIterator.toList, None)
   
-  override protected lazy val files = allFiles.filter { file =>
-      val fileName = file.baseName
-      validExt(file.ext) && filter(file.relativeTo(pwd))
-  }
 }
 
 object IRDiffTestCompiler {
-
-  private val pwd = os.pwd
-  private val dir = pwd/"compiler"/"shared"/"test"/"diff-ir"
   
-  private val allFiles = os.walk(dir).filter(_.toIO.isFile)
-  
-  private val validExt = Set("fun", "mls")
-
-  private def filter(file: os.RelPath) = DiffTests.filter(file)
+  lazy val State =
+    new DiffTests.State(DiffTests.pwd/"compiler"/"shared"/"test"/"diff-ir")
   
 }
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index e309a415da..8fb9ad1c2e 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -12,6 +12,7 @@ import org.scalatest.{funsuite, ParallelTestExecution}
 import org.scalatest.time._
 import org.scalatest.concurrent.{TimeLimitedTests, Signaler}
 import pretyper.PreTyper
+import os.Path
 
 abstract class ModeType {
   def expectTypeErrors: Bool
@@ -50,12 +51,15 @@ abstract class ModeType {
   def nolift: Bool
 }
 
-class DiffTests
+class DiffTests(state: DiffTests.State)
   extends funsuite.AnyFunSuite
   with ParallelTestExecution
   with TimeLimitedTests
 {
   
+  def this() = this(DiffTests.State)
+  
+  import state._
   
   /**  Hook for dependent projects, like the monomorphizer. */
   def postProcess(mode: ModeType, basePath: Ls[Str], testName: Str, unit: TypingUnit, output: Str => Unit, raise: Diagnostic => Unit): (Ls[Str], Option[TypingUnit]) = (Nil, None)
@@ -65,14 +69,12 @@ class DiffTests
   @SuppressWarnings(Array("org.wartremover.warts.RedundantIsInstanceOf"))
   private val inParallel = isInstanceOf[ParallelTestExecution]
   
-  import DiffTests._
-
   // scala test will not execute a test if the test class has constructor parameters.
   // override this to get the correct paths of test files.
   protected lazy val files = allFiles.filter { file =>
       val fileName = file.baseName
       // validExt(file.ext) && filter(fileName)
-      validExt(file.ext) && filter(file.relativeTo(pwd))
+      validExt(file.ext) && filter(file.relativeTo(DiffTests.pwd))
   }
   
   val timeLimit = TimeLimit
@@ -240,7 +242,7 @@ class DiffTests
           case "p" => mode.copy(showParse = true)
           case "d" => mode.copy(dbg = true)
           case "dp" => mode.copy(dbgParsing = true)
-          case DebugUCSFlags(x) => mode.copy(dbgUCS = mode.dbgUCS.fold(S(x))(y => S(y ++ x)))
+          case DiffTests.DebugUCSFlags(x) => mode.copy(dbgUCS = mode.dbgUCS.fold(S(x))(y => S(y ++ x)))
           case "ds" => mode.copy(dbgSimplif = true)
           case "dl" => mode.copy(dbgLifting = true)
           case "dd" => mode.copy(dbgDefunc = true)
@@ -1139,61 +1141,40 @@ class DiffTests
 
 object DiffTests {
   
-  private val TimeLimit =
-    if (sys.env.get("CI").isDefined) Span(60, Seconds)
-    else Span(30, Seconds)
-  
-  private val pwd = os.pwd
-  private val dir = pwd/"shared"/"src"/"test"/"diff"
-  
-  private val allFiles = os.walk(dir).filter(_.toIO.isFile)
+  val pwd: Path = os.pwd
   
-  private val validExt = Set("fun", "mls")
+  lazy val State = new State(pwd/"shared"/"src"/"test"/"diff")
   
-  // Aggregate unstaged modified files to only run the tests on them, if there are any
-  private val modified: Set[os.RelPath] =
-    try os.proc("git", "status", "--porcelain", dir).call().out.lines().iterator.flatMap { gitStr =>
-      println(" [git] " + gitStr)
-      val prefix = gitStr.take(2)
-      val filePath = os.RelPath(gitStr.drop(3))
-      if (prefix =:= "A " || prefix =:= "M " || prefix =:= "R " || prefix =:= "D ")
-        N // * Disregard modified files that are staged
-      else S(filePath)
-    }.toSet catch {
-      case err: Throwable => System.err.println("/!\\ git command failed with: " + err)
-      Set.empty
-    }
-  
-  // Allow overriding which specific tests to run, sometimes easier for development:
-  private val focused = Set[Str](
-    // "LetRec"
-    // "Ascribe",
-    // "Repro",
-    // "RecursiveTypes",
-    // "Simple",
-    // "Inherit",
-    // "Basics",
-    // "Paper",
-    // "Negations",
-    // "RecFuns",
-    // "With",
-    // "Annoying",
-    // "Tony",
-    // "Lists",
-    // "Traits",
-    // "BadTraits",
-    // "TraitMatching",
-    // "Subsume",
-    // "Methods",
-  ).map(os.RelPath(_))
-  // private def filter(name: Str): Bool =
-  def filter(file: os.RelPath): Bool = {
-    if (focused.nonEmpty) focused(file) else modified(file) || modified.isEmpty &&
-      true
-      // name.startsWith("new/")
-      // file.segments.toList.init.lastOption.contains("parser")
+  class State(val dir: Path) {
+      
+    val TimeLimit: Span =
+      if (sys.env.get("CI").isDefined) Span(60, Seconds)
+      else Span(30, Seconds)
+    
+    val allFiles: IndexedSeq[Path] = os.walk(dir).filter(_.toIO.isFile)
+    
+    val validExt: Set[String] = Set("fun", "mls")
+    
+    // Aggregate unstaged modified files to only run the tests on them, if there are any
+    val modified: Set[os.RelPath] =
+      try os.proc("git", "status", "--porcelain", dir).call().out.lines().iterator.flatMap { gitStr =>
+        println(" [git] " + gitStr)
+        val prefix = gitStr.take(2)
+        val filePath = os.RelPath(gitStr.drop(3))
+        if (prefix =:= "A " || prefix =:= "M " || prefix =:= "R " || prefix =:= "D ")
+          N // * Disregard modified files that are staged
+        else S(filePath)
+      }.toSet catch {
+        case err: Throwable => System.err.println("/!\\ git command failed with: " + err)
+        Set.empty
+      }
+    
+    // private def filter(name: Str): Bool =
+    def filter(file: os.RelPath): Bool =
+      modified(file) || modified.isEmpty
+    
   }
-
+  
   object DebugUCSFlags {
     // E.g. "ducs", "ducs:foo", "ducs:foo,bar", "ducs:a.b.c,foo"
     private val pattern = "^ducs(?::(\\s*(?:[A-Za-z\\.-]+)(?:,\\s*[A-Za-z\\.-]+)*))?$".r

From aa182b165c56126d3aed2a59dc703da5b0389d25 Mon Sep 17 00:00:00 2001
From: Lionel Parreaux <lionel.parreaux@gmail.com>
Date: Thu, 12 Sep 2024 21:41:21 +0800
Subject: [PATCH 144/147] Add test from ICFP interaction

---
 shared/src/test/diff/nu/Sidney.mls | 53 ++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 shared/src/test/diff/nu/Sidney.mls

diff --git a/shared/src/test/diff/nu/Sidney.mls b/shared/src/test/diff/nu/Sidney.mls
new file mode 100644
index 0000000000..164fa7d0d4
--- /dev/null
+++ b/shared/src/test/diff/nu/Sidney.mls
@@ -0,0 +1,53 @@
+:NewDefs
+
+
+fun swapMaybe(x, y) =
+  if true then [x, y] else [y, x]
+//│ fun swapMaybe: forall 'a. ('a, 'a) -> ['a, 'a]
+
+swapMaybe : forall 'a, 'b: ('a, 'b) -> ['a | 'b, 'b | 'a]
+//│ forall 'a. ('a, 'a) -> ['a, 'a]
+//│ res
+//│     = [Function: swapMaybe]
+
+
+fun test(x, y, z) =
+  let xy = swapMaybe(x, y)
+  let yz = swapMaybe(xy.1, z)
+  [xy.0, yz.0, yz.1]
+//│ fun test: forall 'a 'b. ('a, 'a, 'b) -> ['a, 'a | 'b, 'b | 'a]
+
+:e
+test : forall 'a, 'b: ('a, 'b, 'b) -> ['a | 'b, 'a | 'b, 'b]
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.21: 	test : forall 'a, 'b: ('a, 'b, 'b) -> ['a | 'b, 'a | 'b, 'b]
+//│ ║        	^^^^
+//│ ╟── type `'a` does not match type `'b`
+//│ ║  l.21: 	test : forall 'a, 'b: ('a, 'b, 'b) -> ['a | 'b, 'a | 'b, 'b]
+//│ ║        	                       ^^
+//│ ╟── Note: constraint arises from type variable:
+//│ ║  l.21: 	test : forall 'a, 'b: ('a, 'b, 'b) -> ['a | 'b, 'a | 'b, 'b]
+//│ ║        	                                                         ^^
+//│ ╟── Note: quantified type variable 'a is defined at:
+//│ ║  l.21: 	test : forall 'a, 'b: ('a, 'b, 'b) -> ['a | 'b, 'a | 'b, 'b]
+//│ ╙──      	              ^^
+//│ forall 'a 'b. ('a, 'b, 'b) -> ['a | 'b, 'a | 'b, 'b]
+//│ res
+//│     = [Function: test]
+
+
+fun test(x, y, z) =
+  if true then
+    let xy = swapMaybe(x, y)
+    [xy.0, xy.1, z]
+  else
+    let yz = swapMaybe(y, z)
+    [x, yz.0, yz.1]
+//│ fun test: forall 'a 'b. ('a, 'a & 'b, 'b) -> ['a, 'a | 'b, 'b]
+
+test : forall 'a: ('a, 'a, 'a) -> ['a, 'a, 'a]
+//│ forall 'a. ('a, 'a, 'a) -> ['a, 'a, 'a]
+//│ res
+//│     = [Function: test1]
+
+

From c389926fa4ec63779bd0906c67a0ef1261baf4bf Mon Sep 17 00:00:00 2001
From: Waterlens <waterlens@waterlens.moe>
Date: Thu, 3 Oct 2024 17:25:33 +0800
Subject: [PATCH 145/147] Sync IR changes (#225)

---
 .github/workflows/nix.yml                     |   23 +
 .github/workflows/scala.yml                   |   27 -
 build.sbt                                     |    6 +-
 .../compiler/{optimizer => }/Document.scala   |    4 +-
 .../mlscript/compiler/codegen/CppAst.scala    |  210 +
 .../compiler/codegen/CppCodeGen.scala         |  234 ++
 .../compiler/codegen/CppCompilerHost.scala    |   44 +
 .../scala/mlscript/compiler/ir/Builder.scala  |  779 +++-
 .../compiler/ir/DefnRefResolver.scala         |   33 -
 .../scala/mlscript/compiler/ir/Fresh.scala    |    5 +-
 .../main/scala/mlscript/compiler/ir/IR.scala  |  438 ++-
 .../scala/mlscript/compiler/ir/Interp.scala   |  475 +--
 .../mlscript/compiler/ir/RefResolver.scala    |   55 +
 .../mlscript/compiler/ir/Validator.scala      |   31 +-
 .../compiler/optimizer/Analysis.scala         |   16 +-
 .../compiler/optimizer/TailRecOpt.scala       |   85 +-
 .../compiler/simpledef/Simpledef.scala        |    2 +-
 compiler/shared/test/diff-ir/Class.mls        |  182 +
 compiler/shared/test/diff-ir/Currying.mls     |   95 +
 compiler/shared/test/diff-ir/IR.mls           |  635 ++-
 compiler/shared/test/diff-ir/IRComplex.mls    |  473 +--
 compiler/shared/test/diff-ir/IRRec.mls        | 1845 +++++----
 compiler/shared/test/diff-ir/IRTailRec.mls    | 3455 ++++++-----------
 compiler/shared/test/diff-ir/LiftClass.mls    |  158 +
 compiler/shared/test/diff-ir/LiftFun.mls      |  186 +
 compiler/shared/test/diff-ir/LiftLambda.mls   |   87 +
 compiler/shared/test/diff-ir/Override.mls     |   48 +
 compiler/shared/test/diff-ir/cpp/Makefile     |   26 +
 compiler/shared/test/diff-ir/cpp/mlsprelude.h |  568 +++
 compiler/shared/test/diff-ir/gcd.mls          |  823 ++++
 .../test/scala/mlscript/compiler/Test.scala   |    2 +-
 .../test/scala/mlscript/compiler/TestIR.scala |   90 +-
 flake.lock                                    |   97 +
 flake.nix                                     |   34 +
 project/build.properties                      |    2 +-
 project/plugins.sbt                           |    4 +-
 shared/src/main/scala/mlscript/NewLexer.scala |   54 +
 .../src/test/scala/mlscript/DiffTests.scala   |   29 +-
 38 files changed, 6780 insertions(+), 4580 deletions(-)
 create mode 100644 .github/workflows/nix.yml
 delete mode 100644 .github/workflows/scala.yml
 rename compiler/shared/main/scala/mlscript/compiler/{optimizer => }/Document.scala (95%)
 create mode 100644 compiler/shared/main/scala/mlscript/compiler/codegen/CppAst.scala
 create mode 100644 compiler/shared/main/scala/mlscript/compiler/codegen/CppCodeGen.scala
 create mode 100644 compiler/shared/main/scala/mlscript/compiler/codegen/CppCompilerHost.scala
 delete mode 100644 compiler/shared/main/scala/mlscript/compiler/ir/DefnRefResolver.scala
 create mode 100644 compiler/shared/main/scala/mlscript/compiler/ir/RefResolver.scala
 create mode 100644 compiler/shared/test/diff-ir/Class.mls
 create mode 100644 compiler/shared/test/diff-ir/Currying.mls
 create mode 100644 compiler/shared/test/diff-ir/LiftClass.mls
 create mode 100644 compiler/shared/test/diff-ir/LiftFun.mls
 create mode 100644 compiler/shared/test/diff-ir/LiftLambda.mls
 create mode 100644 compiler/shared/test/diff-ir/Override.mls
 create mode 100644 compiler/shared/test/diff-ir/cpp/Makefile
 create mode 100644 compiler/shared/test/diff-ir/cpp/mlsprelude.h
 create mode 100644 compiler/shared/test/diff-ir/gcd.mls
 create mode 100644 flake.lock
 create mode 100644 flake.nix

diff --git a/.github/workflows/nix.yml b/.github/workflows/nix.yml
new file mode 100644
index 0000000000..2623f85c29
--- /dev/null
+++ b/.github/workflows/nix.yml
@@ -0,0 +1,23 @@
+name: Cpp Backend CI with Nix
+
+on:
+  pull_request:
+  push:
+    branches: [ mlscript ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Nix
+        uses: DeterminateSystems/nix-installer-action@main
+      - uses: rrbutani/use-nix-shell-action@v1
+        with:
+          devShell: .#default
+      - name: Install TypeScript
+        run: npm ci
+      - name: Run test
+        run: sbt -J-Xmx4096M -J-Xss4M test
+      - name: Check no changes
+        run: git diff-files -p --exit-code
diff --git a/.github/workflows/scala.yml b/.github/workflows/scala.yml
deleted file mode 100644
index 42559c2da7..0000000000
--- a/.github/workflows/scala.yml
+++ /dev/null
@@ -1,27 +0,0 @@
-name: Scala CI
-
-on:
-  push:
-    branches: [ mlscript ]
-  pull_request:
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up JDK 1.8
-      uses: actions/setup-java@v1
-      with:
-        java-version: 1.8
-    - uses: actions/setup-node@v3
-      with:
-        node-version: '17.x'
-    - name: Install TypeScript
-      run: npm ci
-    - name: Run tests
-      run: sbt -J-Xmx4096M -J-Xss4M test
-    - name: Check no changes
-      run: git diff-files -p --exit-code
diff --git a/build.sbt b/build.sbt
index 883cb517fa..bf2fb754d8 100644
--- a/build.sbt
+++ b/build.sbt
@@ -2,7 +2,7 @@ import Wart._
 
 enablePlugins(ScalaJSPlugin)
 
-ThisBuild / scalaVersion     := "2.13.12"
+ThisBuild / scalaVersion     := "2.13.14"
 ThisBuild / version          := "0.1.0-SNAPSHOT"
 ThisBuild / organization     := "io.lptk"
 ThisBuild / organizationName := "LPTK"
@@ -52,7 +52,7 @@ lazy val mlscript = crossProject(JSPlatform, JVMPlatform).in(file("."))
   )
   .jsSettings(
     scalaJSUseMainModuleInitializer := true,
-    libraryDependencies += "org.scala-js" %%% "scalajs-dom" % "2.1.0",
+    libraryDependencies += "org.scala-js" %%% "scalajs-dom" % "2.2.0",
   )
 
 lazy val mlscriptJVM = mlscript.jvm
@@ -79,7 +79,7 @@ lazy val ts2mlsTest = project.in(file("ts2mls"))
 lazy val compiler = crossProject(JSPlatform, JVMPlatform).in(file("compiler"))
   .settings(
     name := "mlscript-compiler",
-    scalaVersion := "3.1.3",
+    scalaVersion := "3.3.3",
     sourceDirectory := baseDirectory.value.getParentFile()/"shared",
     watchSources += WatchSource(
       baseDirectory.value.getParentFile()/"shared"/"test"/"diff", "*.mls", NothingFilter),
diff --git a/compiler/shared/main/scala/mlscript/compiler/optimizer/Document.scala b/compiler/shared/main/scala/mlscript/compiler/Document.scala
similarity index 95%
rename from compiler/shared/main/scala/mlscript/compiler/optimizer/Document.scala
rename to compiler/shared/main/scala/mlscript/compiler/Document.scala
index d5add5617b..22c938e4e4 100644
--- a/compiler/shared/main/scala/mlscript/compiler/optimizer/Document.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/Document.scala
@@ -1,4 +1,4 @@
-package mlscript.compiler.optimizer
+package mlscript.compiler.utils
 
 enum Document:
   case Indented(content: Document)
@@ -10,7 +10,7 @@ enum Document:
   def <:>(other: Document) = line(List(this, other))
   def <#>(other: Document) = line(List(this, other), sep = "")
 
-  override def toString(): String = print
+  override def toString: String = print
 
   def print: String = {
     val sb = StringBuffer()
diff --git a/compiler/shared/main/scala/mlscript/compiler/codegen/CppAst.scala b/compiler/shared/main/scala/mlscript/compiler/codegen/CppAst.scala
new file mode 100644
index 0000000000..ef054b0268
--- /dev/null
+++ b/compiler/shared/main/scala/mlscript/compiler/codegen/CppAst.scala
@@ -0,0 +1,210 @@
+package mlscript.compiler.codegen.cpp
+
+import mlscript._
+import mlscript.utils._
+import mlscript.utils.shorthands._
+import mlscript.compiler.utils._
+
+import scala.language.implicitConversions
+
+given Conversion[String, Document] = raw
+
+enum Specifier:
+  case Extern
+  case Static
+  case Inline
+
+  def toDocument = raw:
+    this match
+    case Extern => "extern"
+    case Static => "static"
+    case Inline => "inline"
+
+  override def toString: Str = toDocument.print
+
+object Type:
+  def toDocuments(args: Ls[Type], sep: Document, extraTypename: Bool = false): Document =
+    args.iterator.zipWithIndex.map {
+      case (x, 0) =>
+        x.toDocument(extraTypename)
+      case (x, _) =>
+        sep <#> x.toDocument(extraTypename)
+    }.fold(raw(""))(_ <#> _)
+
+  def toDocuments(args: Ls[(Str, Type)], sep: Document): Document =
+    args.iterator.zipWithIndex.map {
+      case (x, 0) =>
+        x._2.toDocument() <:> raw(x._1)
+      case (x, _) =>
+        sep <#> x._2.toDocument() <:> raw(x._1)
+    }.fold(raw(""))(_ <#> _)
+
+enum Type:
+  case Prim(name: Str)
+  case Ptr(inner: Type)
+  case Ref(inner: Type)
+  case Array(inner: Type, size: Opt[Int])
+  case FuncPtr(ret: Type, args: List[Type])
+  case Struct(name: Str)
+  case Enum(name: Str)
+  case Template(name: Str, args: List[Type])
+  case Var(name: Str)
+  case Qualifier(inner: Type, qual: Str)
+
+  def toDocument(extraTypename: Bool = false): Document =
+    def aux(x: Type): Document = x match
+      case Prim(name) => name
+      case Ptr(inner) => aux(inner) <#> "*" 
+      case Ref(inner) => aux(inner) <#> "&"
+      case Array(inner, size) => aux(inner) <#> "[" <#> size.fold(raw(""))(x => x.toString) <#> "]"
+      case FuncPtr(ret, args) => aux(ret) <#> "(" <#> Type.toDocuments(args, sep = ", ") <#> ")"
+      case Struct(name) => s"struct $name"
+      case Enum(name) => s"enum $name"
+      case Template(name, args) => s"$name" <#> "<" <#> Type.toDocuments(args, sep = ", ") <#> ">"
+      case Var(name) => name
+      case Qualifier(inner, qual) => aux(inner) <:> qual
+    aux(this)
+
+  override def toString: Str = toDocument().print
+
+object Stmt:
+  def toDocuments(decl: Ls[Decl], stmts: Ls[Stmt]): Document =
+    stack_list(decl.map(_.toDocument) ++ stmts.map(_.toDocument))
+
+enum Stmt:
+  case AutoBind(lhs: Ls[Str], rhs: Expr)
+  case Assign(lhs: Str, rhs: Expr)
+  case Return(expr: Expr)
+  case If(cond: Expr, thenStmt: Stmt, elseStmt: Opt[Stmt])
+  case While(cond: Expr, body: Stmt)
+  case For(init: Stmt, cond: Expr, update: Stmt, body: Stmt)
+  case ExprStmt(expr: Expr)
+  case Break
+  case Continue
+  case Block(decl: Ls[Decl], stmts: Ls[Stmt])
+  case Switch(expr: Expr, cases: Ls[(Expr, Stmt)])
+  case Raw(stmt: Str)
+
+  def toDocument: Document =
+    def aux(x: Stmt): Document = x match
+      case AutoBind(lhs, rhs) =>
+        lhs match
+          case Nil => rhs.toDocument
+          case x :: Nil => "auto" <:> x <:> "=" <:> rhs.toDocument <#> ";"
+          case _ => "auto" <:> lhs.mkString("[", ",", "]") <:> "=" <:> rhs.toDocument <#> ";"
+      case Assign(lhs, rhs) => lhs <#> " = " <#> rhs.toDocument <#> ";"
+      case Return(expr) => "return " <#> expr.toDocument <#> ";"
+      case If(cond, thenStmt, elseStmt) =>
+        "if (" <#> cond.toDocument <#> ")" <#> thenStmt.toDocument <:> elseStmt.fold(raw(""))(x => "else" <:> x.toDocument)
+      case While(cond, body) =>
+        "while (" <#> cond.toDocument <#> ")" <#> body.toDocument
+      case For(init, cond, update, body) =>
+        "for (" <#> init.toDocument <#> "; " <#> cond.toDocument <#> "; " <#> update.toDocument <#> ")" <#> body.toDocument
+      case ExprStmt(expr) => expr.toDocument <#> ";"
+      case Break => "break;"
+      case Continue => "continue;"
+      case Block(decl, stmts) => 
+        stack(
+          "{",
+          Stmt.toDocuments(decl, stmts) |> indent,
+          "}")
+      case Switch(expr, cases) =>
+        "switch (" <#> expr.toDocument <#> ")" <#> "{" <#> stack_list(cases.map {
+          case (cond, stmt) => "case " <#> cond.toDocument <#> ":" <#> stmt.toDocument
+        }) <#> "}"
+      case Raw(stmt) => stmt
+    aux(this)
+
+object Expr:
+  def toDocuments(args: Ls[Expr], sep: Document): Document =
+    args.zipWithIndex.map {
+      case (x, i) =>
+        if i == 0 then x.toDocument
+        else sep <#> x.toDocument
+    }.fold(raw(""))(_ <#> _)
+  
+enum Expr:
+  case Var(name: Str)
+  case IntLit(value: BigInt)
+  case DoubleLit(value: Double)
+  case StrLit(value: Str)
+  case CharLit(value: Char)
+  case Call(func: Expr, args: Ls[Expr])
+  case Member(expr: Expr, member: Str)
+  case Index(expr: Expr, index: Expr)
+  case Unary(op: Str, expr: Expr)
+  case Binary(op: Str, lhs: Expr, rhs: Expr)
+  case Initializer(exprs: Ls[Expr])
+  case Constructor(name: Str, init: Expr)
+
+  def toDocument: Document =
+    def aux(x: Expr): Document = x match
+      case Var(name) => name
+      case IntLit(value) => value.toString
+      case DoubleLit(value) => value.toString
+      case StrLit(value) => s"\"$value\"" // need more reliable escape utils
+      case CharLit(value) => value.toInt.toString
+      case Call(func, args) => aux(func) <#> "(" <#> Expr.toDocuments(args, sep = ", ") <#> ")"
+      case Member(expr, member) => aux(expr) <#> "->" <#> member
+      case Index(expr, index) => aux(expr) <#> "[" <#> aux(index) <#> "]"
+      case Unary(op, expr) => "(" <#> op <#> aux(expr) <#> ")"
+      case Binary(op, lhs, rhs) => "(" <#> aux(lhs) <#> op <#> aux(rhs) <#> ")"
+      case Initializer(exprs) => "{" <#> Expr.toDocuments(exprs, sep = ", ") <#> "}"
+      case Constructor(name, init) => name <#> init.toDocument
+    aux(this)
+
+case class CompilationUnit(includes: Ls[Str], decls: Ls[Decl], defs: Ls[Def]):
+  def toDocument: Document =
+    stack_list(includes.map(x => raw(x)) ++ decls.map(_.toDocument) ++ defs.map(_.toDocument))
+  def toDocumentWithoutHidden: Document =
+    val hiddenNames = Set(
+      "HiddenTheseEntities", "True", "False", "Callable", "List", "Cons", "Nil", "Option", "Some", "None", "Pair", "Tuple2", "Tuple3", "Nat", "S", "O"
+    )
+    stack_list(defs.filterNot { 
+      case Def.StructDef(name, _, _, _) => hiddenNames.contains(name.stripPrefix("_mls_"))
+      case _ => false
+    }.map(_.toDocument))
+
+enum Decl:
+  case StructDecl(name: Str)
+  case EnumDecl(name: Str)
+  case FuncDecl(ret: Type, name: Str, args: Ls[Type])
+  case VarDecl(name: Str, typ: Type)
+
+  def toDocument: Document =
+    def aux(x: Decl): Document = x match
+      case StructDecl(name) => s"struct $name;"
+      case EnumDecl(name) => s"enum $name;"
+      case FuncDecl(ret, name, args) => ret.toDocument() <#> s" $name(" <#> Type.toDocuments(args, sep = ", ")  <#> ");"
+      case VarDecl(name, typ) => typ.toDocument() <#> s" $name;"
+    aux(this)
+
+enum Def:
+  case StructDef(name: Str, fields: Ls[(Str, Type)], inherit: Opt[Ls[Str]], methods: Ls[Def] = Ls.empty)
+  case EnumDef(name: Str, fields: Ls[(Str, Opt[Int])])
+  case FuncDef(specret: Type, name: Str, args: Ls[(Str, Type)], body: Stmt.Block, or: Bool = false, virt: Bool = false)
+  case VarDef(typ: Type, name: Str, init: Opt[Expr])
+  case RawDef(raw: Str)
+
+  def toDocument: Document =
+    def aux(x: Def): Document = x match
+      case StructDef(name, fields, inherit, defs) =>
+        stack(
+          s"struct $name" <#> (if inherit.nonEmpty then ": public" <:> inherit.get.mkString(", ") else "" ) <:> "{",
+            stack_list(fields.map {
+                case (name, typ) => typ.toDocument() <#> " " <#> name <#> ";"
+            }) |> indent,
+            stack_list(defs.map(_.toDocument)) |> indent,
+          "};"
+        )
+      case EnumDef(name, fields) =>
+        s"enum $name" <:> "{" <#> stack_list(fields.map {
+          case (name, value) => value.fold(s"$name")(x => s"$name = $x")
+        }) <#> "};"
+      case FuncDef(specret, name, args, body, or, virt) =>
+        (if virt then "virtual " else "") 
+        <#> specret.toDocument() <#> s" $name(" <#> Type.toDocuments(args, sep = ", ") <#> ")" <#> (if or then " override" else "") <#> body.toDocument
+      case VarDef(typ, name, init) =>
+        typ.toDocument() <#> s" $name" <#> init.fold(raw(""))(x => " = " <#> x.toDocument) <#> raw(";")
+      case RawDef(x) => x
+    aux(this)
\ No newline at end of file
diff --git a/compiler/shared/main/scala/mlscript/compiler/codegen/CppCodeGen.scala b/compiler/shared/main/scala/mlscript/compiler/codegen/CppCodeGen.scala
new file mode 100644
index 0000000000..20d08050d2
--- /dev/null
+++ b/compiler/shared/main/scala/mlscript/compiler/codegen/CppCodeGen.scala
@@ -0,0 +1,234 @@
+package mlscript.compiler.codegen.cpp
+
+import mlscript.compiler.ir.{Expr => IExpr, _}
+import mlscript.compiler.utils._
+import mlscript.utils._
+import mlscript.utils.shorthands._
+import scala.collection.mutable.ListBuffer
+
+def codegen(prog: Program): CompilationUnit =
+  val codegen = CppCodeGen()
+  codegen.codegen(prog)
+
+private class CppCodeGen:
+  def mapName(name: Name): Str = "_mls_" + name.str.replace('$', '_').replace('\'', '_')
+  def mapName(name: Str): Str = "_mls_" + name.replace('$', '_').replace('\'', '_')
+  val freshName = Fresh(div = '_');
+  val mlsValType = Type.Prim("_mlsValue")
+  val mlsUnitValue = Expr.Call(Expr.Var("_mlsValue::create<_mls_Unit>"), Ls());
+  val mlsRetValue  = "_mls_retval"
+  val mlsRetValueDecl = Decl.VarDecl(mlsRetValue, mlsValType)
+  val mlsMainName = "_mlsMain"
+  val mlsPrelude = "#include \"mlsprelude.h\""
+  val mlsPreludeImpl = "#include \"mlsprelude.cpp\""
+  val mlsInternalClass = Set("True", "False", "Boolean", "Callable")
+  val mlsObject = "_mlsObject"
+  val mlsBuiltin = "builtin"
+  val mlsEntryPoint = s"int main() { return _mlsLargeStack(_mlsMainWrapper); }";
+  def mlsIntLit(x: BigInt) = Expr.Call(Expr.Var("_mlsValue::fromIntLit"), Ls(Expr.IntLit(x)))
+  def mlsStrLit(x: Str) = Expr.Call(Expr.Var("_mlsValue::fromStrLit"), Ls(Expr.StrLit(x)))
+  def mlsCharLit(x: Char) = Expr.Call(Expr.Var("_mlsValue::fromIntLit"), Ls(Expr.CharLit(x)))
+  def mlsNewValue(cls: Str, args: Ls[Expr]) = Expr.Call(Expr.Var(s"_mlsValue::create<$cls>"), args)
+  def mlsIsValueOf(cls: Str, scrut: Expr) = Expr.Call(Expr.Var(s"_mlsValue::isValueOf<$cls>"), Ls(scrut))
+  def mlsIsIntLit(scrut: Expr, lit: mlscript.IntLit) = Expr.Call(Expr.Var("_mlsValue::isIntLit"), Ls(scrut, Expr.IntLit(lit.value)))
+  def mlsDebugPrint(x: Expr) = Expr.Call(Expr.Var("_mlsValue::print"), Ls(x))
+  def mlsTupleValue(init: Expr) = Expr.Constructor("_mlsValue::tuple", init)
+  def mlsAs(name: Str, cls: Str) = Expr.Var(s"_mlsValue::as<$cls>($name)")
+  def mlsAsUnchecked(name: Str, cls: Str) = Expr.Var(s"_mlsValue::cast<$cls>($name)")
+  def mlsObjectNameMethod(name: Str) = s"constexpr static inline const char *typeName = \"${name}\";"
+  def mlsTypeTag() = s"constexpr static inline uint32_t typeTag = nextTypeTag();"
+  def mlsTypeTag(n: Int) = s"constexpr static inline uint32_t typeTag = $n;"
+  def mlsCommonCreateMethod(cls: Str, fields: Ls[Str], id: Int) =
+    val parameters = fields.map{x => s"_mlsValue $x"}.mkString(", ")
+    val fieldsAssignment = fields.map{x => s"_mlsVal->$x = $x; "}.mkString
+    s"static _mlsValue create($parameters) { auto _mlsVal = new (std::align_val_t(_mlsAlignment)) $cls; _mlsVal->refCount = 1; _mlsVal->tag = typeTag; $fieldsAssignment return _mlsValue(_mlsVal); }"
+  def mlsCommonPrintMethod(fields: Ls[Str]) =
+    if fields.isEmpty then s"virtual void print() const override { std::printf(\"%s\", typeName); }"
+    else
+      val fieldsPrint = fields.map{x => s"this->$x.print(); "}.mkString("std::printf(\", \"); ")
+      s"virtual void print() const override { std::printf(\"%s\", typeName); std::printf(\"(\"); $fieldsPrint std::printf(\")\"); }"
+  def mlsCommonDestructorMethod(cls: Str, fields: Ls[Str]) = 
+    val fieldsDeletion = fields.map{x => s"_mlsValue::destroy(this->$x); "}.mkString
+    s"virtual void destroy() override { $fieldsDeletion operator delete (this, std::align_val_t(_mlsAlignment)); }"
+  def mlsThrowNonExhaustiveMatch = Stmt.Raw("_mlsNonExhaustiveMatch();");
+  def mlsCall(fn: Str, args: Ls[Expr]) = Expr.Call(Expr.Var("_mlsCall"), Expr.Var(fn) :: args)
+  def mlsMethodCall(cls: ClassRef, method: Str, args: Ls[Expr]) =
+    Expr.Call(Expr.Member(Expr.Call(Expr.Var(s"_mlsMethodCall<${cls.name |> mapName}>"), Ls(args.head)), method), args.tail)
+  def mlsFnWrapperName(fn: Str) = s"_mlsFn_$fn"
+  def mlsFnCreateMethod(fn: Str) = s"static _mlsValue create() { static _mlsFn_$fn mlsFn alignas(_mlsAlignment); mlsFn.refCount = stickyRefCount; mlsFn.tag = typeTag; return _mlsValue(&mlsFn); }"
+  def mlsNeverValue(n: Int) = if (n <= 1) then Expr.Call(Expr.Var(s"_mlsValue::never"), Ls()) else Expr.Call(Expr.Var(s"_mlsValue::never<$n>"), Ls())
+
+  case class Ctx(
+    defnCtx: Set[Str],
+  )
+
+  def codegenClassInfo(using ctx: Ctx)(cls: ClassInfo): (Opt[Def], Decl) =
+    val fields = cls.fields.map{x => (x |> mapName, mlsValType)}
+    val parents = if cls.parents.nonEmpty then cls.parents.toList.map(mapName) else mlsObject :: Nil
+    val decl = Decl.StructDecl(cls.name |> mapName)
+    if mlsInternalClass.contains(cls.name) then return (None, decl)
+    val theDef = Def.StructDef(
+      cls.name |> mapName, fields,
+      if parents.nonEmpty then Some(parents) else None,
+      Ls(Def.RawDef(mlsObjectNameMethod(cls.name)),
+         Def.RawDef(mlsTypeTag()),
+         Def.RawDef(mlsCommonPrintMethod(cls.fields.map(mapName))),
+         Def.RawDef(mlsCommonDestructorMethod(cls.name |> mapName, cls.fields.map(mapName))),
+         Def.RawDef(mlsCommonCreateMethod(cls.name |> mapName, cls.fields.map(mapName), cls.id)))
+      ++ cls.methods.map{case (name, defn) => {
+        val (theDef, decl) = codegenDefn(using Ctx(ctx.defnCtx + cls.name))(defn)
+        theDef match
+          case x @ Def.FuncDef(_, name, _, _, _, _) => x.copy(virt = true)
+          case _ => theDef
+      }}
+    )
+    (S(theDef), decl)
+  
+  def toExpr(texpr: TrivialExpr, reifyUnit: Bool = false)(using ctx: Ctx): Opt[Expr] = texpr match
+    case IExpr.Ref(name) => S(Expr.Var(name |> mapName))
+    case IExpr.Literal(mlscript.IntLit(x)) => S(mlsIntLit(x))
+    case IExpr.Literal(mlscript.DecLit(x)) => S(mlsIntLit(x.toBigInt))
+    case IExpr.Literal(mlscript.StrLit(x)) => S(mlsStrLit(x))
+    case IExpr.Literal(mlscript.UnitLit(_)) => if reifyUnit then S(mlsUnitValue) else None
+  
+  def toExpr(texpr: TrivialExpr)(using ctx: Ctx): Expr = texpr match
+    case IExpr.Ref(name) => Expr.Var(name |> mapName)
+    case IExpr.Literal(mlscript.IntLit(x)) => mlsIntLit(x)
+    case IExpr.Literal(mlscript.DecLit(x)) => mlsIntLit(x.toBigInt)
+    case IExpr.Literal(mlscript.StrLit(x)) => mlsStrLit(x)
+    case IExpr.Literal(mlscript.UnitLit(_)) => mlsUnitValue
+  
+
+  def wrapMultiValues(exprs: Ls[TrivialExpr])(using ctx: Ctx): Expr = exprs match
+    case x :: Nil => toExpr(x, reifyUnit = true).get
+    case _ => 
+      val init = Expr.Initializer(exprs.map{x => toExpr(x)})
+      mlsTupleValue(init)
+  
+  def codegenCaseWithIfs(scrut: Name, cases: Ls[(Pat, Node)], default: Opt[Node], storeInto: Str)(using decls: Ls[Decl], stmts: Ls[Stmt])(using ctx: Ctx): (Ls[Decl], Ls[Stmt]) =
+    val scrutName = mapName(scrut)
+    val init: Stmt = 
+      default.fold(mlsThrowNonExhaustiveMatch)(x => {
+        val (decls2, stmts2) = codegen(x, storeInto)(using Ls.empty, Ls.empty[Stmt])
+        Stmt.Block(decls2, stmts2)
+      })
+    val stmt = cases.foldRight(S(init)) {
+      case ((Pat.Class(cls), arm), nextarm) =>
+        val (decls2, stmts2) = codegen(arm, storeInto)(using Ls.empty, Ls.empty[Stmt])
+        val stmt = Stmt.If(mlsIsValueOf(cls.name |> mapName, Expr.Var(scrutName)), Stmt.Block(decls2, stmts2), nextarm)
+        S(stmt)
+      case ((Pat.Lit(i @ mlscript.IntLit(_)), arm), nextarm) =>
+        val (decls2, stmts2) = codegen(arm, storeInto)(using Ls.empty, Ls.empty[Stmt])
+        val stmt = Stmt.If(mlsIsIntLit(Expr.Var(scrutName), i), Stmt.Block(decls2, stmts2), nextarm)
+        S(stmt)
+      case _ => ???
+    }
+    (decls, stmt.fold(stmts)(x => stmts :+ x))
+
+  def codegenJumpWithCall(defn: DefnRef, args: Ls[TrivialExpr], storeInto: Opt[Str])(using decls: Ls[Decl], stmts: Ls[Stmt])(using ctx: Ctx): (Ls[Decl], Ls[Stmt]) =
+    val call = Expr.Call(Expr.Var(defn.name |> mapName), args.map(toExpr))
+    val stmts2 = stmts ++ Ls(storeInto.fold(Stmt.Return(call))(x => Stmt.Assign(x, call)))
+    (decls, stmts2)
+
+  def codegenOps(op: Str, args: Ls[TrivialExpr])(using ctx: Ctx) = op match
+    case "+" => Expr.Binary("+", toExpr(args(0)), toExpr(args(1)))
+    case "-" => Expr.Binary("-", toExpr(args(0)), toExpr(args(1)))
+    case "*" => Expr.Binary("*", toExpr(args(0)), toExpr(args(1)))
+    case "/" => Expr.Binary("/", toExpr(args(0)), toExpr(args(1)))
+    case "%" => Expr.Binary("%", toExpr(args(0)), toExpr(args(1)))
+    case "==" => Expr.Binary("==", toExpr(args(0)), toExpr(args(1)))
+    case "!=" => Expr.Binary("!=", toExpr(args(0)), toExpr(args(1)))
+    case "<" => Expr.Binary("<", toExpr(args(0)), toExpr(args(1)))
+    case "<=" => Expr.Binary("<=", toExpr(args(0)), toExpr(args(1)))
+    case ">" => Expr.Binary(">", toExpr(args(0)), toExpr(args(1)))
+    case ">=" => Expr.Binary(">=", toExpr(args(0)), toExpr(args(1)))
+    case "&&" => Expr.Binary("&&", toExpr(args(0)), toExpr(args(1)))
+    case "||" => Expr.Binary("||", toExpr(args(0)), toExpr(args(1)))
+    case "!" => Expr.Unary("!", toExpr(args(0)))
+    case _ => mlscript.utils.TODO("codegenOps")
+
+
+  def codegen(expr: IExpr)(using ctx: Ctx): Expr = expr match
+    case x @ (IExpr.Ref(_) | IExpr.Literal(_)) => toExpr(x, reifyUnit = true).get
+    case IExpr.CtorApp(cls, args) => mlsNewValue(cls.name |> mapName, args.map(toExpr))
+    case IExpr.Select(name, cls, field) => Expr.Member(mlsAsUnchecked(name |> mapName, cls.name |> mapName), field |> mapName)
+    case IExpr.BasicOp(name, args) => codegenOps(name, args)
+    case IExpr.AssignField(assignee, cls, field, value) => mlscript.utils.TODO("Assign field in the backend")
+
+  def codegenBuiltin(names: Ls[Name], builtin: Str, args: Ls[TrivialExpr])(using ctx: Ctx): Ls[Stmt] = builtin match
+    case "error" => Ls(Stmt.Raw("throw std::runtime_error(\"Error\");"), Stmt.AutoBind(names.map(mapName), mlsNeverValue(names.size)))
+    case _ => Ls(Stmt.AutoBind(names.map(mapName), Expr.Call(Expr.Var("_mls_builtin_" + builtin), args.map(toExpr))))
+
+  def codegen(body: Node, storeInto: Str)(using decls: Ls[Decl], stmts: Ls[Stmt])(using ctx: Ctx): (Ls[Decl], Ls[Stmt]) = body match
+    case Node.Result(res) => 
+      val expr = wrapMultiValues(res)
+      val stmts2 = stmts ++ Ls(Stmt.Assign(storeInto, expr))
+      (decls, stmts2)
+    case Node.Jump(defn, args) =>
+      codegenJumpWithCall(defn, args, S(storeInto))
+    case Node.LetExpr(name, expr, body) =>
+      val stmts2 = stmts ++ Ls(Stmt.AutoBind(Ls(name |> mapName), codegen(expr)))
+      codegen(body, storeInto)(using decls, stmts2)
+    case Node.LetMethodCall(names, cls, method, IExpr.Ref(Name("builtin")) :: args, body) =>
+      val stmts2 = stmts ++ codegenBuiltin(names, args.head.toString.replace("\"", ""), args.tail)
+      codegen(body, storeInto)(using decls, stmts2)
+    case Node.LetMethodCall(names, cls, method, args, body) =>
+      val call = mlsMethodCall(cls, method.str |> mapName, args.map(toExpr))
+      val stmts2 = stmts ++ Ls(Stmt.AutoBind(names.map(mapName), call))
+      codegen(body, storeInto)(using decls, stmts2)
+    case Node.LetCall(names, defn, args, _, body) =>
+      val call = Expr.Call(Expr.Var(defn.name |> mapName), args.map(toExpr))
+      val stmts2 = stmts ++ Ls(Stmt.AutoBind(names.map(mapName), call))
+      codegen(body, storeInto)(using decls, stmts2)
+    case Node.Case(scrut, cases, default) =>
+      codegenCaseWithIfs(scrut, cases, default, storeInto)
+    
+  private def codegenDefn(using ctx: Ctx)(defn: Defn): (Def, Decl) = defn match
+    case Defn(id, name, params, resultNum, body, _, _) =>
+      val decls = Ls(mlsRetValueDecl)
+      val stmts = Ls.empty[Stmt]
+      val (decls2, stmts2) = codegen(body, mlsRetValue)(using decls, stmts)
+      val stmtsWithReturn = stmts2 :+ Stmt.Return(Expr.Var(mlsRetValue))
+      val theDef = Def.FuncDef(mlsValType, name |> mapName, params.map(x => (x |> mapName, mlsValType)), Stmt.Block(decls2, stmtsWithReturn))
+      val decl = Decl.FuncDecl(mlsValType, name |> mapName, params.map(x => mlsValType))
+      (theDef, decl)
+
+  def codegenTopNode(node: Node)(using ctx: Ctx): (Def, Decl) =
+    val decls = Ls(mlsRetValueDecl)
+    val stmts = Ls.empty[Stmt]
+    val (decls2, stmts2) = codegen(node, mlsRetValue)(using decls, stmts)
+    val stmtsWithReturn = stmts2 :+ Stmt.Return(Expr.Var(mlsRetValue))
+    val theDef = Def.FuncDef(mlsValType, mlsMainName, Ls(), Stmt.Block(decls2, stmtsWithReturn))
+    val decl = Decl.FuncDecl(mlsValType, mlsMainName, Ls())
+    (theDef, decl)
+
+  // Topological sort of classes based on inheritance relationships
+  def sortClasses(prog: Program): Ls[ClassInfo] =
+    var depgraph = prog.classes.map(x => (x.name, x.parents)).toMap
+    var degree = depgraph.view.mapValues(_.size).toMap
+    def removeNode(node: Str) =
+      degree -= node
+      depgraph -= node
+      depgraph = depgraph.view.mapValues(_.filter(_ != node)).toMap
+      degree = depgraph.view.mapValues(_.size).toMap
+    val sorted = ListBuffer.empty[ClassInfo]
+    var work = degree.filter(_._2 == 0).keys.toSet
+    while work.nonEmpty do
+      val node = work.head
+      work -= node
+      sorted.addOne(prog.classes.find(_.name == node).get)
+      removeNode(node)
+      val next = degree.filter(_._2 == 0).keys
+      work ++= next
+    if depgraph.nonEmpty then
+      val cycle = depgraph.keys.mkString(", ")
+      throw new Exception(s"Cycle detected in class hierarchy: $cycle")
+    sorted.toList
+
+  def codegen(prog: Program): CompilationUnit =
+    val sortedClasses = sortClasses(prog)
+    val defnCtx = prog.defs.map(_.name)
+    val (defs, decls) = sortedClasses.map(codegenClassInfo(using Ctx(defnCtx))).unzip
+    val (defs2, decls2) = prog.defs.map(codegenDefn(using Ctx(defnCtx))).unzip
+    val (defMain, declMain) = codegenTopNode(prog.main)(using Ctx(defnCtx))
+    CompilationUnit(Ls(mlsPrelude), decls ++ decls2 :+ declMain, defs.flatten ++ defs2 :+ defMain :+ Def.RawDef(mlsEntryPoint))
diff --git a/compiler/shared/main/scala/mlscript/compiler/codegen/CppCompilerHost.scala b/compiler/shared/main/scala/mlscript/compiler/codegen/CppCompilerHost.scala
new file mode 100644
index 0000000000..3897648dbc
--- /dev/null
+++ b/compiler/shared/main/scala/mlscript/compiler/codegen/CppCompilerHost.scala
@@ -0,0 +1,44 @@
+package mlscript.compiler.codegen.cpp
+
+import mlscript._
+import mlscript.utils.shorthands._
+import scala.collection.mutable.ListBuffer
+
+final class CppCompilerHost(val auxPath: Str):
+  import scala.sys.process._
+  private def ifAnyCppCompilerExists(): Boolean =
+    Seq("g++", "--version").! == 0 || Seq("clang++", "--version").! == 0
+
+  private def isMakeExists(): Boolean =
+    import scala.sys.process._
+    Seq("make", "--version").! == 0
+
+  val ready = ifAnyCppCompilerExists() && isMakeExists()
+  
+  def compileAndRun(src: Str, output: Str => Unit): Unit =
+    if !ready then
+      return
+    val srcPath = os.temp(contents = src, suffix = ".cpp")
+    val binPath = os.temp(suffix = ".mls.out")
+    var stdout = ListBuffer[Str]()
+    var stderr = ListBuffer[Str]()
+    val buildLogger = ProcessLogger(stdout :+= _, stderr :+= _)
+    val buildResult = Seq("make", "-B", "-C", auxPath, "auto", s"SRC=$srcPath", s"DST=$binPath") ! buildLogger
+    if buildResult != 0 then
+      output("Compilation failed: ")
+      for line <- stdout do output(line)
+      for line <- stderr do output(line)
+      return
+  
+    stdout.clear()
+    stderr.clear()
+    val runCmd = Seq(binPath.toString)
+    val runResult = runCmd ! buildLogger
+    if runResult != 0 then
+      output("Execution failed: ")
+      for line <- stdout do output(line)
+      for line <- stderr do output(line)
+      return
+
+    output("Execution succeeded: ")
+    for line <- stdout do output(line)
\ No newline at end of file
diff --git a/compiler/shared/main/scala/mlscript/compiler/ir/Builder.scala b/compiler/shared/main/scala/mlscript/compiler/ir/Builder.scala
index c80a698f6f..86fb4986bc 100644
--- a/compiler/shared/main/scala/mlscript/compiler/ir/Builder.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/ir/Builder.scala
@@ -4,35 +4,72 @@ import mlscript.compiler.optimizer.FreeVarAnalysis
 import mlscript.utils.shorthands._
 import mlscript.utils._
 import mlscript._
-import mlscript.Message._
-import collection.mutable.ListBuffer
+import mlscript.Message.MessageContext
+import scala.collection.mutable.ListBuffer
 
 final val ops = Set("+", "-", "*", "/", ">", "<", ">=", "<=", "!=", "==")
+final val builtin = Set("builtin")
 
-final class Builder(fresh: Fresh, fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diagnostic => Unit):
+final class Builder(fresh: Fresh, fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diagnostic => Unit, verbose: Boolean = false):
   import Node._
   import Expr._
   
-  private type NameCtx = Map[Str, Name]
-  private type ClassCtx = Map[Str, ClassInfo]
-  private type FieldCtx = Map[Str, (Str, ClassInfo)]
-  private type FnCtx = Set[Str]
-  private type OpCtx = Set[Str]
+  private def log(x: Any) = if verbose then println(x)
+
+  private final case class ClassInfoPartial(name: Str, fields: Ls[Str], methods: Set[Str]):
+    var freeVars = Ls.empty[Str]
+    var ctx = ctxEmpty
+
+  private final case class DefnInfoPartial(name: Str, params: Ls[Str]):
+    var freeVars = Ls.empty[Str]
+    var ctx = ctxEmpty
+
+  private type NameCtx = Map[Str, Name] // name -> new name
+  private type ClassCtx = Map[Str, ClassInfoPartial] // class name -> partial class info
+  private type FnCtx = Map[Str, DefnInfoPartial]    // fn name -> partial defn info
+  private type OpCtx = Set[Str]         // op names
   
   private final case class Ctx(
-    val nameCtx: NameCtx = Map.empty,
-    val classCtx: ClassCtx = Map.empty,
-    val fieldCtx: FieldCtx = Map.empty,
-    val fnCtx: FnCtx = Set.empty,
-    val opCtx: OpCtx = Set.empty,
-    var jpAcc: ListBuffer[Defn],
+    nameCtx: NameCtx = Map.empty,
+    tyNameCtx: NameCtx = Map.empty,
+    classCtx: ClassCtx = Map.empty,
+    fnCtx: FnCtx = Map.empty,
+    opCtx: OpCtx = Set.empty,
+    jpAcc: ListBuffer[Defn],
+    defAcc: ListBuffer[NuFunDef],
+    lcAcc: ListBuffer[NuTypeDef],
+  ):
+    def hasClassLifted = lcAcc.nonEmpty
+    def hasLifted = jpAcc.nonEmpty || defAcc.nonEmpty || lcAcc.nonEmpty
+
+  private def ctxEmpty = Ctx(
+      nameCtx = Map.empty,
+      tyNameCtx = Map.empty,
+      classCtx = Map.empty,
+      fnCtx = Map.empty,
+      opCtx = ops,
+      jpAcc = ListBuffer.empty,
+      defAcc = ListBuffer.empty,
+      lcAcc = ListBuffer.empty,
   )
 
+  private def ctxJoin(c1: Ctx, c2: Ctx) =
+    Ctx(
+      nameCtx = c1.nameCtx ++ c2.nameCtx,
+      tyNameCtx = c1.tyNameCtx ++ c2.tyNameCtx,
+      classCtx = c1.classCtx ++ c2.classCtx,
+      fnCtx = c1.fnCtx ++ c2.fnCtx,
+      opCtx = c1.opCtx ++ c2.opCtx,
+      jpAcc = c1.jpAcc,
+      defAcc = c1.defAcc,
+      lcAcc = c1.lcAcc,
+    )
+
   private def ref(x: Name) = Ref(x)
   private def result(x: Ls[TrivialExpr]) = Result(x).attachTag(tag)
   private def sresult(x: TrivialExpr) = Result(Ls(x)).attachTag(tag)
   private def unexpectedNode(x: Node) = throw IRError(s"unsupported node $x")
-  private def unexpectedTerm(x: Term) = throw IRError(s"unsupported term $x")
+  private def unexpectedTerm(x: Statement) = throw IRError(s"unsupported term $x")
 
   private def buildBinding(using ctx: Ctx)(name: Str, e: Term, body: Term)(k: Node => Node): Node =
     buildResultFromTerm(e) {
@@ -60,64 +97,212 @@ final class Builder(fresh: Fresh, fnUid: FreshInt, classUid: FreshInt, tag: Fres
       }
       case Tup(Nil) => Nil |> result |> k
       
-  private def bindingPatternVariables(scrut: Str, tup: Tup, cls: ClassInfo, rhs: Term): Term =
-    val params = tup.fields.map {
-      case N -> Fld(FldFlags.empty, Var(name)) => name
-      case _ => throw IRError("unsupported field")
-    }
+  private def bindingPatternVariables(scrut: Str, tup: Tup, cls: ClassInfoPartial, rhs: Term): Term =
+    val params = tup |> getTupleFields
     val fields = cls.fields
     val tm = params.zip(fields).foldLeft(rhs) {
       case (tm, (param, field)) => 
-        Let(false, Var(param), Sel(Var(scrut), Var(field)), tm)
+        Let(false, Var(param), App(Sel(Var(cls.name), Var(field)), Tup(Ls(N -> Fld(FldFlags.empty, Var(scrut))))), tm)
     }
     tm
 
-  private def buildResultFromTerm(using ctx: Ctx)(tm: Term)(k: Node => Node): Node =
-    def buildLetCall(f: Term, xs: Tup, ann: Option[Term]) =
-      buildResultFromTerm(f) { node => node match
-        case Result(Ref(g) :: Nil) if ctx.fnCtx.contains(g.str) => buildResultFromTerm(xs) {
-          case Result(args) =>
-            val v = fresh.make
-            
-            ann match
-              case Some(ann @ Var(nme)) =>
-                if nme === "tailcall" then 
-                  LetCall(List(v), DefnRef(Right(g.str)), args, true, v |> ref |> sresult |> k)(f.toLoc).attachTag(tag)
-                else
-                  if nme === "tailrec" then
-                    raise(ErrorReport(List(msg"@tailrec is for annotating functions; try @tailcall instead" -> ann.toLoc), true, Diagnostic.Compilation))
-                  LetCall(List(v), DefnRef(Right(g.str)), args, false, v |> ref |> sresult |> k)(f.toLoc).attachTag(tag) 
-              case Some(_) => node |> unexpectedNode
-              case None => LetCall(List(v), DefnRef(Right(g.str)), args, false, v |> ref |> sresult |> k)(f.toLoc).attachTag(tag)   
-            
-          case node @ _ => node |> unexpectedNode
-        }
-        case Result(Ref(f) :: Nil) => buildResultFromTerm(xs) {
-          case Result(args) =>
-            throw IRError(s"not supported: apply")
-          case node @ _ => node |> unexpectedNode
+  private def freeVariablesIf(ucs: If): Set[Str] =
+    val ifbody: IfBody = ucs.body
+    val els: Opt[Term] = ucs.els
+
+    def f(ifbody: IfBody): Set[Str] = ifbody match
+      case IfBlock(lines) => lines.foldLeft(Set.empty[Str]) {
+        case (acc, Left(ifbody2)) => acc ++ f(ifbody2)
+        case (acc, Right(rhs)) => acc ++ freeVariables(rhs)._2
+      }
+      case IfElse(expr) => freeVariables(expr)
+      case IfLet(isRec, name, rhs, body) =>
+        if isRec then
+          (freeVariables(rhs) -- freeVariables(name)) ++ (f(body) -- freeVariables(name))
+        else
+          freeVariables(rhs) ++ (f(body) -- freeVariables(name))
+      case IfOpApp(lhs, op, rhs) => freeVariables(lhs) ++ f(rhs)
+      case IfOpsApp(lhs, opsRhss) => freeVariables(lhs) ++ opsRhss.foldLeft(Set.empty[Str]) {
+        case (acc, (op, rhs)) => acc ++ f(rhs)
+      }
+      case IfThen(expr, rhs) => freeVariables(rhs) -- freeVariables(expr)
+
+    val fvs1 = f(ifbody)
+    val fvs2 = els.fold(Set.empty[Str]) { freeVariables }
+
+    fvs1 ++ fvs2
+
+  private def freeVariables(tu: TypingUnit): Set[Str] =
+    var all_defined = tu.rawEntities.foldLeft(Set.empty[Str]) {
+      case (defined, stmt) => defined ++ freeVariables(stmt)._1
+    }
+    tu.rawEntities.foldLeft(Set.empty[Str]) {
+      case (acc, stmt) => acc ++ (freeVariables(stmt)._2 -- all_defined)
+    }
+
+    // for this fv analysis, we also need to return the variables that are defined in this statement
+  private def freeVariables(stmt: Statement): (Set[Str], Set[Str]) = stmt match
+    case DataDefn(body) => throw IRError("unsupported DataDefn")
+    case DatatypeDefn(head, body) => throw IRError("unsupported DatatypeDefn")
+    case LetS(isRec, pat, rhs) => throw IRError("unsupported LetS")
+    case ntd: NuTypeDef => 
+      val fvs = freeVariables(ntd.body) -- ntd.params.fold(Set.empty)(freeVariables)
+      (Set(ntd.nme.name), fvs)
+    case Constructor(params, body) => throw IRError("unsupported Constructor")
+    case nfd: NuFunDef =>
+      val fvs = nfd.isLetRec match
+        case None | Some(true) => nfd.rhs.fold(tm => freeVariables(tm) -- freeVariables(nfd.nme), ty => Set.empty)
+        case Some(false) => nfd.rhs.fold(tm => freeVariables(tm), ty => Set.empty)
+      (freeVariables(nfd.nme), fvs)
+    case Def(rec, nme, rhs, isByname) => throw IRError("unsupported Def")
+    case TypeDef(kind, nme, tparams, body, mthDecls, mthDefs, positionals, adtInfo) => throw IRError("unsupported TypeDef")
+    case x: Term =>
+      val fvs = freeVariables(x)
+      (Set.empty, fvs)
+
+  private def freeVariables(tm: Term): Set[Str] = tm match
+    case AdtMatchWith(cond, arms) =>
+      val inner: Set[Str] = arms.foldLeft(Set.empty){
+        case (acc, AdtMatchPat(pat, body)) => acc ++ freeVariables(body) -- freeVariables(pat)
+      }
+      freeVariables(cond) ++ inner
+    case Ann(ann, receiver) => freeVariables(receiver)
+    case App(lhs, rhs) => freeVariables(lhs) ++ freeVariables(rhs)
+    case Asc(trm, ty) => freeVariables(trm)
+    case Assign(lhs, rhs) => freeVariables(lhs) ++ freeVariables(rhs)
+    case Bind(lhs, rhs) => freeVariables(lhs)
+    case Blk(stmts) => 
+      var fvs = Set.empty[Str]
+      var defined = Set.empty[Str]
+      stmts.foreach {
+        stmt => {
+          val stmt_fvs = freeVariables(stmt)
+          fvs ++= stmt_fvs._2
+          fvs --= defined
+          defined ++= stmt_fvs._1
         }
+      }
+      fvs
+    case Bra(rcd, trm) => freeVariables(trm)
+    case CaseOf(trm, cases) =>
+      import mlscript.{Case => CCase}
+      def f(pat: CaseBranches): Set[Str] =
+        pat match
+          case CCase(pat, body, rest) => freeVariables(body) -- freeVariables(pat) ++ f(rest)
+          case NoCases => Set.empty
+          case Wildcard(body) => freeVariables(body)
+      freeVariables(trm) ++ f(cases)
+    case Eqn(lhs, rhs) => freeVariables(rhs)
+    case Forall(params, body) => freeVariables(body)
+    case x: If => freeVariablesIf(x)
+    case Inst(body) => freeVariables(body)
+    case Lam(lhs, rhs) => 
+      freeVariables(rhs) -- freeVariables(lhs)
+    case Let(isRec, name, rhs, body) => 
+      if isRec then
+        (freeVariables(rhs) -- freeVariables(name)) ++ (freeVariables(body) -- freeVariables(name))
+      else
+        freeVariables(rhs) ++ (freeVariables(body) -- freeVariables(name))
+    case New(head, body) => throw IRError("unsupported New")
+    case NuNew(cls) => freeVariables(cls)
+    case Quoted(body) => throw IRError("unsupported Quoted")
+    case Rcd(fields) => fields.foldLeft(Set.empty[Str]) {
+      case (acc, (_, Fld(_, trm))) => acc ++ freeVariables(trm)
+    }
+    case Rft(base, decls) => throw IRError("unsupported Rft")
+    case Sel(receiver, fieldName) => freeVariables(receiver)
+    case Splc(fields) => fields.foldLeft(Set.empty[Str]) {
+      case (acc, Left(trm)) => acc ++ freeVariables(trm) 
+      case (acc, Right(Fld(_, trm))) => acc ++ freeVariables(trm)
+    }
+    case Subs(arr, idx) => freeVariables(arr) ++ freeVariables(idx)
+    case Super() => Set.empty
+    case Test(trm, ty) => freeVariables(trm)
+    case Tup(fields) => fields.foldLeft(Set.empty[Str]) {
+      case (acc, (_, Fld(_, trm))) => acc ++ freeVariables(trm)
+    }
+    case TyApp(lhs, targs) => freeVariables(lhs)
+    case Unquoted(body) => throw IRError("unsupported Unquoted")
+    case Where(body, where) => throw IRError("unsupported Where")
+    case While(cond, body) => freeVariables(cond) ++ freeVariables(body)
+    case With(trm, fields) => freeVariables(trm) ++ freeVariables(fields: Term)
+    case Var(name) => Set(name)
+    case DecLit(value) => Set.empty
+    case IntLit(value) => Set.empty
+    case StrLit(value) => Set.empty
+    case UnitLit(undefinedOrNull) => Set.empty
+
+    private def buildLetCall(using ctx: Ctx)(f: Var, xs: Tup, ann: Option[Term])(k: Node => Node) =        
+      buildResultFromTup(xs) {
+        case Result(args) =>
+          val v = fresh.make
+          ctx.nameCtx.get(f.name) match
+            case None => throw IRError(s"unknown name $f in $ctx")
+            case Some(f2) =>
+              ctx.fnCtx.get(f2.str) match
+                case None => throw IRError(s"unknown function $f2 in $ctx")
+                case Some(dInfo) =>
+                  val args2 = 
+                    if args.size != dInfo.params.size then
+                      args ++ dInfo.freeVars.map(x => Ref(ctx.nameCtx(x))) // it's possible that the free vars as parameters have been filled when do eta expansion
+                    else
+                      args
+                  ann match
+                    case Some(ann @ Var(nme)) =>
+                      if nme === "tailcall" then 
+                        LetCall(List(v), DefnRef(Right(f2.str)), args2, true, v |> ref |> sresult |> k)(f.toLoc).attachTag(tag)
+                      else
+                        if nme === "tailrec" then
+                          raise(ErrorReport(List(msg"@tailrec is for annotating functions; try @tailcall instead" -> ann.toLoc), true, Diagnostic.Compilation))
+                        LetCall(List(v), DefnRef(Right(f2.str)), args2, false, v |> ref |> sresult |> k)(f.toLoc).attachTag(tag) 
+                    case Some(_) => throw IRError("unsupported annotation")
+                    case None => LetCall(List(v), DefnRef(Right(f2.str)), args2, false, v |> ref |> sresult |> k)(f.toLoc).attachTag(tag)
         case node @ _ => node |> unexpectedNode
       }
-
+  private def buildResultFromTerm(using ctx: Ctx)(tm: Statement)(k: Node => Node): Node =
     val res = tm match
       case lit: Lit => Literal(lit) |> sresult |> k
       case v @ Var(name) =>
         if (name.isCapitalized)
-          val v = fresh.make
-          LetExpr(v,
-            CtorApp(ctx.classCtx(name), Nil),
-            v |> ref |> sresult |> k).attachTag(tag)
+          ctx.tyNameCtx.get(name) match
+            case Some(x) => 
+              val v = fresh.make
+              ctx.classCtx.get(x.str) match
+                case Some(clsinfo) =>
+                  val args = (if clsinfo.freeVars.isEmpty then Nil else clsinfo.freeVars.map(x => Ref(ctx.nameCtx(x))))
+                  LetExpr(v,
+                    CtorApp(ClassRef(Right(x.str)), args),
+                    v |> ref |> sresult |> k).attachTag(tag)
+                case None => throw IRError(s"unknown class $name in $ctx")
+            case None => throw IRError(s"unknown type name $name in $ctx")
         else
           ctx.nameCtx.get(name) match {
-            case Some(x) => x |> ref |> sresult |> k
-            case _ => throw IRError(s"unknown name $name in $ctx")
+            case Some(x) =>
+              if (ctx.fnCtx.contains(x.str))
+                val info = ctx.fnCtx(x.str)
+                val arity = info.params.size - info.freeVars.size
+                val range = 0 until arity
+                val xs = range.map(_ => fresh.make.str).toList
+                val params = Tup(xs.map(x => N -> Fld(FldFlags.empty, Var(x))))
+                val args = Tup(params.fields ++ info.freeVars.map(x => N -> Fld(FldFlags.empty, Var(x))))
+                val lam = Lam(params, App(Var(x.str), args))
+                buildResultFromTerm(lam)(k)
+              else
+                x |> ref |> sresult |> k
+            case None => throw IRError(s"unknown name $name in $ctx")
           }
+      case lam @ Lam(Tup(fields), body) =>
+        val tmp = fresh.make
+        val lambdaName = fresh.make("Lambda")
+        val result = Var(lambdaName.str)
+        val localCls = Blk(
+          NuTypeDef(Cls, TypeName(lambdaName.str), Nil, N, N, N, Ls(Var("Callable")), N, N, TypingUnit(
+            NuFunDef(N, Var(s"apply${fields.size}"), None, Nil, L(Lam(Tup(fields), body)))(tm.getLoc, N, N, N, N, false, Nil) :: Nil
+          ))(tm.getLoc, tm.getLoc, Nil) :: result :: Nil)
+        buildResultFromTerm(localCls)(k)
 
-      case Lam(Tup(fields), body) =>
-        throw IRError("not supported: lambda")
       case App(
-        App(Var(name), Tup((_ -> Fld(_, e1)) :: Nil)), 
+        App(Var(name), Tup((_ -> Fld(_, e1)) :: Nil)),
         Tup((_ -> Fld(_, e2)) :: Nil)) if ctx.opCtx.contains(name) =>
         buildResultFromTerm(e1) {
           case Result(v1 :: Nil) =>
@@ -131,19 +316,68 @@ final class Builder(fresh: Fresh, fnUid: FreshInt, classUid: FreshInt, tag: Fres
             }
           case node @ _ => node |> unexpectedNode
         }
-        
-      case App(Var(name), xs @ Tup(_)) if name.isCapitalized =>
-        buildResultFromTerm(xs) {
-          case Result(args) => 
-            val v = fresh.make
-            LetExpr(v,
-              CtorApp(ctx.classCtx(name), args),
-              v |> ref |> sresult |> k).attachTag(tag)
+      case x @ App(Var(name), xs @ Tup(_)) if name.isCapitalized || ctx.opCtx.contains(name) =>
+        if name.isCapitalized then
+          buildResultFromTerm(xs) {
+            case Result(args) => 
+              ctx.tyNameCtx.get(name) match
+                case Some(x) =>
+                  val v = fresh.make
+                  ctx.classCtx.get(x.str) match
+                    case Some(clsinfo) =>
+                      val args2 = args ++ clsinfo.freeVars.map(x => Ref(ctx.nameCtx(x)))
+                      LetExpr(v,
+                        CtorApp(ClassRef(Right(x.str)), args2),
+                        v |> ref |> sresult |> k).attachTag(tag)
+                    case None => throw IRError(s"unknown class $name in $ctx")
+                case None => throw IRError(s"unknown type name $name in $ctx")
+            case node @ _ => node |> unexpectedNode
+          }
+        else
+          buildResultFromTerm(xs) {
+            case Result(args) =>
+              val v = fresh.make
+              LetExpr(v,
+                BasicOp(name, args),
+                v |> ref |> sresult |> k).attachTag(tag)
+            case node @ _ => node |> unexpectedNode
+          }
+      case App(
+        member @ Sel(Var(clsName), Var(fld)), 
+        xs @ Tup((_ -> Fld(_, Var(s))) :: _)) if clsName.isCapitalized =>
+        buildResultFromTup(xs) {
+          case Result(xs @ (Ref(name) :: args)) =>
+            ctx.tyNameCtx.get(clsName) match
+              case Some(x) => 
+                val v = fresh.make
+                val cls = ctx.classCtx(x.str)
+                val isField = cls.fields.contains(fld)
+                if isField then
+                  LetExpr(v, Select(name, ClassRef(Right(x.str)), fld),
+                    v |> ref |> sresult |> k).attachTag(tag)
+                else
+                  if cls.methods.contains(fld) then
+                    LetMethodCall(Ls(v), ClassRef(Right(x.str)), Name(fld), xs, v |> ref |> sresult |> k).attachTag(tag)
+                  else
+                    throw IRError(s"unknown field or method $fld in $cls")
+              case None => throw IRError(s"unknown type name $clsName in $ctx")
           case node @ _ => node |> unexpectedNode
         }
-
-      case App(f, xs @ Tup(_)) => buildLetCall(f, xs, None)
-      case Ann(ann, App(f, xs @ Tup(_))) => buildLetCall(f, xs, Some(ann))
+      case App(vf @ Var(f), xs @ Tup(_)) if ctx.fnCtx.contains(f) || ctx.nameCtx.get(f).fold(false)(x => ctx.fnCtx.contains(x.str)) => 
+        buildLetCall(vf, xs, None)(k)
+      case Ann(ann, App(vf @ Var(f), xs @ Tup(_))) if ctx.fnCtx.contains(f) || ctx.nameCtx.get(f).fold(false)(x => ctx.fnCtx.contains(x.str)) =>
+        buildLetCall(vf, xs, Some(ann))(k)
+      case App(f, xs @ Tup(_)) =>
+        buildResultFromTerm(f) {
+          case Result(Ref(f) :: Nil) => buildResultFromTerm(xs) {
+            case Result(args) =>
+              val v = fresh.make
+              // LetApply(List(v), f, args, v |> ref |> sresult |> k).attachTag(tag)
+              LetMethodCall(List(v), ClassRef(R("Callable")), Name("apply" + args.length), (Ref(f): TrivialExpr) :: args, v |> ref |> sresult |> k).attachTag(tag)
+            case node @ _ => node |> unexpectedNode
+          }
+          case node @ _ => node |> unexpectedNode
+      }
 
       case Ann(ann @ Var(name), recv) =>
         if name === "tailcall" then
@@ -152,7 +386,6 @@ final class Builder(fresh: Fresh, fnUid: FreshInt, classUid: FreshInt, tag: Fres
           raise(ErrorReport(List(msg"@tailrec may only be used to annotate functions" -> ann.toLoc), true, Diagnostic.Compilation))
 
         buildResultFromTerm(recv)(k)
-
       case Let(false, Var(name), rhs, body) => 
         buildBinding(name, rhs, body)(k)
 
@@ -183,16 +416,13 @@ final class Builder(fresh: Fresh, fnUid: FreshInt, classUid: FreshInt, tag: Fres
               case Result(xs) => Jump(DefnRef(Right(jp.str)), xs ++ fvs.map(x => Ref(Name(x)))).attachTag(tag)
               case node @ _ => node |> unexpectedNode
             }
-            Case(cond, Ls((ctx.classCtx("True"), tru2), (ctx.classCtx("False"), fls2))).attachTag(tag)
+            Case(cond, Ls(
+              (Pat.Class(ClassRef(Right("True"))), tru2),
+              (Pat.Class(ClassRef(Right("False"))), fls2)), None).attachTag(tag)
           case node @ _ => node |> unexpectedNode
         }
         
       case If(IfOpApp(lhs, Var("is"), IfBlock(lines)), N)
-        if lines forall {
-          case L(IfThen(App(Var(ctor), Tup((N -> Fld(FldFlags.empty, _: Var)) :: _)), _)) => ctor.isCapitalized
-          case L(IfThen(Var(ctor), _)) => ctor.isCapitalized || ctor == "_"
-          case _ => false
-        }
         => buildResultFromTerm(lhs) {
           case Result(Ref(scrut) :: Nil) =>
             val jp = fresh make "j"
@@ -206,12 +436,13 @@ final class Builder(fresh: Fresh, fnUid: FreshInt, classUid: FreshInt, tag: Fres
               resultNum = 1,
               jpbody,
               false,
-              None
+              None,
             )
             ctx.jpAcc.addOne(jpdef)
-            val cases: Ls[(ClassInfo, Node)] = lines map {
+            var defaultCase: Opt[Node] = None
+            val cases: Ls[(Pat, Node)] = lines flatMap {
               case L(IfThen(App(Var(ctor), params: Tup), rhs)) =>
-                ctx.classCtx(ctor) -> {
+                S(Pat.Class(ClassRef(Right(ctor))) -> {
                   // need this because we have built terms (selections in case arms) containing names that are not in the original term
                   given Ctx = ctx.copy(nameCtx = ctx.nameCtx + (scrut.str -> scrut))
                   buildResultFromTerm(
@@ -219,151 +450,303 @@ final class Builder(fresh: Fresh, fnUid: FreshInt, classUid: FreshInt, tag: Fres
                       case Result(xs) => Jump(DefnRef(Right(jp.str)), xs ++ fvs.map(x => Ref(Name(x)))).attachTag(tag)
                       case node @ _ => node |> unexpectedNode
                     }
-                }
+                })
+              case L(IfThen(lit @ IntLit(_), rhs)) =>
+                S(Pat.Lit(lit) -> buildResultFromTerm(rhs) {
+                  case Result(xs) => Jump(DefnRef(Right(jp.str)), xs ++ fvs.map(x => Ref(Name(x)))).attachTag(tag)
+                  case node @ _ => node |> unexpectedNode
+                })
+              case L(IfThen(Var("_"), rhs)) =>
+                defaultCase = Some(buildResultFromTerm(rhs) {
+                  case Result(xs) => Jump(DefnRef(Right(jp.str)), xs ++ fvs.map(x => Ref(Name(x)))).attachTag(tag)
+                  case node @ _ => node |> unexpectedNode
+                })
+                N
               case L(IfThen(Var(ctor), rhs)) =>
-                ctx.classCtx(ctor) -> buildResultFromTerm(rhs) {
+                S(Pat.Class(ClassRef(Right(ctor))) -> buildResultFromTerm(rhs) {
                   case Result(xs) => Jump(DefnRef(Right(jp.str)), xs ++ fvs.map(x => Ref(Name(x)))).attachTag(tag)
                   case node @ _ => node |> unexpectedNode
-                }
+                })
               case _ => throw IRError(s"not supported UCS")
             }
-            Case(scrut, cases).attachTag(tag)
+            Case(scrut, cases, defaultCase).attachTag(tag)
           case node @ _ => node |> unexpectedNode
         }
 
       case Bra(false, tm) => buildResultFromTerm(tm)(k)
 
-      case Blk((tm: Term) :: Nil) => buildResultFromTerm(tm)(k)
-      
-      case Blk((tm: Term) :: xs) => buildBinding("_", tm, Blk(xs))(k)
-
-      case Blk(NuFunDef(S(false), Var(name), None, _, L(tm)) :: Nil) =>
-        buildBinding(name, tm, Var(name))(k)
-
-      case Blk(NuFunDef(S(false), Var(name), None, _, L(tm)) :: xs) =>
-        buildBinding(name, tm, Blk(xs))(k)
-
-      case Sel(tm @ Var(name), Var(fld)) =>
-        buildResultFromTerm(tm) {
-          case Result(Ref(res) :: Nil) =>
-            val v = fresh.make
-            val cls = ctx.fieldCtx(fld)._2
-            LetExpr(v,
-              Select(res, cls, fld),
-              v |> ref |> sresult |> k).attachTag(tag)
-          case node @ _ => node |> unexpectedNode
-        }
+      case Blk(stmts) =>
+        val (nfds, ntds, terms) = collectInfo(stmts)
+        val (ctx2, nfds2, ntds2) = renameToBeLifted(nfds, ntds)
+        val ctx3 = initContextForStatementsFrom(
+          nfds2, ntds2, terms, scanNamesInThisScope(stmts)
+        )(using ctx2)
+
+        ctx.lcAcc.addAll(ntds2)
+        ctx.defAcc.addAll(nfds2)
+
+        buildResultFromTerms(using ctx3)(terms)(k)
 
       case tup: Tup => buildResultFromTup(tup)(k)
 
       case term => term |> unexpectedTerm
     
     res
-  
-  private def buildDefFromNuFunDef(using ctx: Ctx)(nfd: Statement): Defn = nfd match
-    case nfd: NuFunDef => nfd match
-      case NuFunDef(_, Var(name), None, Nil, L(Lam(Tup(fields), body))) =>
-        val strs = fields map {
-            case N -> Fld(FldFlags.empty, Var(x)) => x
-            case _ => throw IRError("unsupported field") 
+
+  private def buildResultFromTerms(using ctx: Ctx)(tms: Ls[Statement])(k: Node => Node): Node =
+    tms match
+      case Nil => throw IRError("empty term list")
+      case NuFunDef(S(false), Var(name), _, _, Left(tm)) :: xs =>
+        xs match
+          case Nil => throw IRError("unsupported NuFunDef at tail position")
+          case _ => buildResultFromTerm(tm) {
+            case Result((r: Ref) :: Nil) =>
+              given Ctx = ctx.copy(nameCtx = ctx.nameCtx + (name -> r.name))
+              buildResultFromTerms(xs)(k)
+            case Result((lit: Literal) :: Nil) =>
+              val v = fresh.make
+              given Ctx = ctx.copy(nameCtx = ctx.nameCtx + (name -> v))
+              LetExpr(v,
+                lit,
+                buildResultFromTerms(xs)(k)).attachTag(tag)
+            case node @ _ => node |> unexpectedNode
           }
-        val names = strs map (fresh.make(_))
-        given Ctx = ctx.copy(nameCtx = ctx.nameCtx ++ (strs zip names))
-        val trAnn = nfd.annotations.find { 
-          case Var("tailrec") => true
-          case ann @ Var("tailcall") =>
-            raise(ErrorReport(List(msg"@tailcall is for annotating function calls; try @tailrec instead" -> ann.toLoc), true, Diagnostic.Compilation))
-            false
-          case _ => false }
-
-        Defn(
-          fnUid.make,
-          name,
-          params = names,
-          resultNum = 1,
-          buildResultFromTerm(body) { x => x },
-          trAnn.isDefined,
-          trAnn.flatMap(_.toLoc)
-        )
-      case _ => throw IRError("unsupported NuFunDef")
-    case _ => throw IRError("unsupported NuFunDef")
-  
-  private def buildClassInfo(ntd: Statement): ClassInfo = ntd match
-    case NuTypeDef(Cls, TypeName(name), Nil, S(Tup(args)), N, N, Nil, N, N, TypingUnit(Nil)) =>
-      ClassInfo(
-        classUid.make,
-        name, 
-        args map {
-          case N -> Fld(FldFlags.empty, Var(name)) => name
-          case _ => throw IRError("unsupported field")
-        }
-      )
-    case NuTypeDef(Cls, TypeName(name), Nil, N, N, N, Nil, N, N, TypingUnit(Nil)) =>
-      ClassInfo(
-        classUid.make,
+      case x :: Nil => buildResultFromTerm(x)(k)
+      case x :: xs => buildResultFromTerm(x) {
+        case _ => buildResultFromTerms(xs)(k)
+      }
+
+  private def getTupleFields(tup: Tup) = tup.fields.map {
+    case N -> Fld(FldFlags.empty, Var(name)) => name
+    case S(Var(name)) -> Fld(_, ty) => name
+    case _ => throw IRError("unsupported field")
+  }
+
+  private def buildDefFromMethod(using ctx: Ctx)(fields: List[Str], nfd: Statement): Defn = nfd match
+    case nfd @ NuFunDef(_, Var(name), None, Nil, L(Lam(xs @ Tup(_), body))) =>
+      val defnInfoPartial = getDefnInfoPartial(ctx.fnCtx.keySet ++ ctx.classCtx.keySet ++ fields, ctx)(nfd).get
+      val params = defnInfoPartial.params
+      val names = params map (fresh.make(_))
+      val ctx2 =  ctxJoin(ctx, defnInfoPartial.ctx)
+      given Ctx = ctx2.copy(nameCtx = ctx2.nameCtx ++ (params zip names))
+      Defn(
+        fnUid.make,
         name,
-        Ls(),
+        params = names,
+        resultNum = 1,
+        body = buildResultFromTerm(body) { x => x },
+        isTailRec = false,
+        loc = nfd.getLoc,
       )
-    case x @ _ => throw IRError(f"unsupported NuTypeDef $x")
+    case fd @ _ => throw IRError("unsupported NuFunDef " + fd.toString)
 
-  private def checkDuplicateField(ctx: Set[Str], cls: ClassInfo): Set[Str] =
-    val u = cls.fields.toSet intersect ctx
-    if (u.nonEmpty) throw IRError(f"duplicate class field $u")
-    cls.fields.toSet union ctx
-
-  private def getDefinitionName(nfd: Statement): Str = nfd match
-    case NuFunDef(_, Var(name), _, _, _) => name
-    case _ => throw IRError("unsupported NuFunDef")
-
-  def buildGraph(unit: TypingUnit): Program = unit match
-    case TypingUnit(entities) =>
-      val grouped = entities groupBy {
-        case ntd: NuTypeDef => 0
-        case nfd: NuFunDef => 1
-        case tm: Term => 2
-        case _ => throw IRError("unsupported entity")
+  private def buildDefFromNuFunDef(using ctx: Ctx)(nfd: Statement): Defn = nfd match
+    case nfd @ NuFunDef(_, Var(name), None, Nil, L(Lam(xs @ Tup(_), body))) =>
+      val defnInfoPartial = getDefnInfoPartial(ctx.fnCtx.keySet ++ ctx.classCtx.keySet, ctx)(nfd).get
+      val params = defnInfoPartial.params
+      val names = params map (fresh.make(_))
+      val ctx2 =  ctxJoin(ctx, defnInfoPartial.ctx)
+      given Ctx = ctx2.copy(nameCtx = ctx2.nameCtx ++ (params zip names))
+      val trAnn = nfd.annotations.find { 
+        case Var("tailrec") => true
+        case ann @ Var("tailcall") =>
+          raise(ErrorReport(List(msg"@tailcall is for annotating function calls; try @tailrec instead" -> ann.toLoc), true, Diagnostic.Compilation))
+          false
+        case _ => false }
+      Defn(
+        fnUid.make,
+        name,
+        params = names,
+        resultNum = 1,
+        buildResultFromTerm(body) { x => x },
+        trAnn.isDefined,
+        trAnn.flatMap(_.toLoc)
+      )
+    case fd @ _ => throw IRError("unsupported NuFunDef " + fd.toString)
+
+  private def buildClassInfo(using ctx: Ctx)(ntd: Statement): ClassInfo = ntd match
+    case ntd @ NuTypeDef(Cls | Mod, TypeName(name), _, params, N, _, parents, N, N, TypingUnit(methods)) =>
+      val clsInfoPartial = getClassInfoPartial(ctx.classCtx.keySet ++ ctx.fnCtx.keySet, ctx)(ntd)
+      val cls = ClassInfo(classUid.make, name, clsInfoPartial.fields)
+      val ctx2 = ctxJoin(ctx, clsInfoPartial.ctx)
+      given Ctx = ctx2.copy(
+        nameCtx = ctx2.nameCtx ++ clsInfoPartial.fields.map(x => x -> Name(x)),
+        classCtx = ctx2.classCtx + (name -> clsInfoPartial)
+      )
+      def resolveParentName(parent: Term): String = parent match {
+        case Var(name) if name.isCapitalized => name
+        case TyApp(lhs, _) => resolveParentName(lhs)
+        case App(lhs, _) => resolveParentName(lhs)
+        case _ => throw IRError("unsupported parent")
       }
+      cls.parents = parents.map(resolveParentName).toSet
+      cls.methods = methods.map {
+        case x: NuFunDef => x.name -> buildDefFromMethod(clsInfoPartial.fields, x)
+        case x @ _ => throw IRError(f"unsupported method $x")
+      }.toMap
+      cls
+    case x @ _ => throw IRError(f"unsupported NuTypeDef $x")
 
-      import scala.collection.mutable.{ HashSet => MutHSet }
-
-      // TODO: properly add prelude classes such as "True" and "False" rather than this hacky method
-      val cls = ClassInfo(classUid.make, "True", List())
-        :: ClassInfo(classUid.make, "False", List()) 
-        :: grouped.getOrElse(0, Nil).map(buildClassInfo)
-
-      cls.foldLeft(Set.empty)(checkDuplicateField(_, _))
-
-      val clsinfo = cls.toSet
-      val defn_names = grouped.getOrElse(1, Nil).map(getDefinitionName)
-      val class_ctx: ClassCtx = cls.map { case ClassInfo(_, name, _) => name }.zip(cls).toMap
-      val field_ctx: FieldCtx = cls.flatMap { case ClassInfo(_, name, fields) => fields.map((_, (name, class_ctx(name)))) }.toMap
-      val fn_ctx: FnCtx = defn_names.toSet
-      var name_ctx: NameCtx = defn_names.zip(defn_names.map(Name(_))).toMap ++ ops.map { op => (op, Name(op)) }.toList
-
-      val jp_acc = ListBuffer.empty[Defn]
-      given Ctx = Ctx(
-        nameCtx = name_ctx,
-        classCtx = class_ctx,
-        fieldCtx = field_ctx,
-        fnCtx = fn_ctx,
-        opCtx = ops,
-        jpAcc = jp_acc,
-      )
 
-      var defs: Set[Defn] = grouped.getOrElse(1, Nil).map(buildDefFromNuFunDef).toSet
-      val terms: Ls[Term] = grouped.getOrElse(2, Nil).map {
-        case tm: Term => tm
-        case _ => ??? /* unreachable */
+  private def getDefnInfoPartial(names: Set[Str], ctx: Ctx)(nfd: NuFunDef): Opt[DefnInfoPartial] = nfd match
+    case NuFunDef(_, Var(name), _, _, Left(Lam(Var(x), _))) => 
+      val originalFvs = freeVariables(nfd)._2
+      val fvs = (originalFvs -- builtin -- ops -- names).toList
+      val params = x :: fvs
+      val dip = DefnInfoPartial(name, params)
+      dip.freeVars = fvs
+      dip.ctx = ctx
+      S(dip)
+    case NuFunDef(_, Var(name), _, _, Left(Lam(tp @ Tup(fields), _))) =>
+      val originalFvs = freeVariables(nfd)._2
+      val fvs = (originalFvs -- builtin -- ops -- names).toList
+      val params = getTupleFields(tp) ++ fvs
+      val dip = DefnInfoPartial(name, params)
+      dip.freeVars = fvs
+      dip.ctx = ctx
+      S(dip)
+    case NuFunDef(_, Var(name), _, _, _) => N
+
+
+  private def getClassInfoPartial(names: Set[Str], ctx: Ctx)(ntd: NuTypeDef): ClassInfoPartial = ntd match
+    case ntd @ NuTypeDef(Cls | Mod, TypeName(name), _, params, N, _, parents, N, N, TypingUnit(other)) =>
+      val originalFvs = freeVariables(ntd)._2
+      log(s"getClassInfoPartial $name")
+      log(originalFvs)
+      log(names)
+      val fvs = (originalFvs -- builtin -- ops -- names).toList
+      val fields = params.fold(fvs)(xs => getTupleFields(xs) ++ fvs)
+      val methods = other.map {
+        case x: NuFunDef => x.name
+        case x @ _ => throw IRError(f"unsupported method $x")
       }
+      val cls = ClassInfoPartial(name, fields, methods.toSet)
+      cls.freeVars = fvs
+      cls.ctx = ctx
+      cls
+    case x @ _ => throw IRError(f"unsupported NuTypeDef $x")
+  
+  private def collectInfo(stmts: Ls[Statement]): (Ls[NuFunDef], Ls[NuTypeDef], Ls[Statement]) =
+    var nfds = ListBuffer.empty[NuFunDef]
+    var ntds = ListBuffer.empty[NuTypeDef]
+    var terms = ListBuffer.empty[Statement]
+    stmts.foreach {
+      case tm @ NuFunDef(S(false), Var(_), _, _, Left(_)) =>
+        terms.addOne(tm)
+      case nfd: NuFunDef => nfds.addOne(nfd)
+      case ntd: NuTypeDef => ntds.addOne(ntd)
+      case tm: Term => terms.addOne(tm)
+      case _ => throw IRError("unsupported statement")
+    }
+    (nfds.toList, ntds.toList, terms.toList)
 
-      val main = buildResultFromTerm (terms match {
-        case x :: Nil => x
-        case _ => throw IRError("only one term is allowed in the top level scope")
-      }) { k => k }
-
-      defs ++= jp_acc.toList
+  private def makeNameMap(str: IterableOnce[Str]) = str.iterator.map(x => (x, Name(x))).toMap
 
-      resolveDefnRef(main, defs, true)
-      validate(main, defs)
-      
-      Program(clsinfo, defs, main)
+  private def scanNamesInThisScope(stmt: Ls[Statement]): Set[Str] =
+    val names = stmt flatMap {
+      case NuTypeDef(_, TypeName(name), _, _, _, _, _, _, _, _) => S(name)
+      case NuFunDef(_, Var(name), _, _, _) => S(name)
+      case _ => Nil
+    }
+    names.toSet
+  
+  private def renameToBeLifted(nfds: Ls[NuFunDef], ntds: Ls[NuTypeDef])(using ctx: Ctx): (Ctx, Ls[NuFunDef], Ls[NuTypeDef]) =
+    val oldFnNames = scanNamesInThisScope(nfds).toList
+    val oldTyNames = scanNamesInThisScope(ntds).toList
+    // TODO: currently, rename cause bugs
+    //val newFnNames = oldFnNames.map(x => fresh.make(x))
+    //val newTyNames = oldTyNames.map(x => if x.startsWith("Lambda$") then Name(x) else fresh.make(x))
+    val newFnNames = oldFnNames.map(Name(_))
+    val newTyNames = oldTyNames.map(Name(_))
+    val nameCtx = oldFnNames.zip(newFnNames).toMap
+    val tyNameCtx = oldTyNames.zip(newTyNames).toMap
+    val nfds2 = nfds.map(x => x.copy(nme = Var(nameCtx(x.name).str))(x.declareLoc, x.virtualLoc, x.mutLoc, x.signature, x.outer, x.genField, x.annotations))
+    val ntds2 = ntds.map(x => x.copy(nme = TypeName(tyNameCtx(x.name).str))(x.declareLoc, x.abstractLoc, x.annotations))
+
+    (ctx.copy(nameCtx = ctx.nameCtx ++ nameCtx, tyNameCtx = ctx.tyNameCtx ++ tyNameCtx), nfds2, ntds2)
+
+  private def initContextForStatementsFrom(nfds: Ls[NuFunDef], ntds: Ls[NuTypeDef], terms: Ls[Statement], excluded: Set[Str])(using ctx: Ctx): Ctx =
+    // they are in the same mutual group or higher group, mustn't capture them
+    val excludedNames = excluded ++ scanNamesInThisScope(nfds) ++ scanNamesInThisScope(ntds) ++ ctx.fnCtx.keySet ++ ctx.classCtx.keySet
+    val partialDefnInfo = nfds flatMap getDefnInfoPartial(excludedNames, ctx)
+    val partialClassInfo = ntds map getClassInfoPartial(excludedNames, ctx)
+    val fnNames = partialDefnInfo.map(_.name)
+    val fnCtx = fnNames.zip(partialDefnInfo).toMap
+    val nameCtx = makeNameMap(builtin) ++ makeNameMap(fnNames) ++ makeNameMap(ops)
+    val tyNames = partialClassInfo.map(_.name)
+    val tyNameCtx = makeNameMap(tyNames)
+    val classCtx = tyNames.zip(partialClassInfo).toMap
+
+    ctx.copy(
+      tyNameCtx = ctx.tyNameCtx ++ tyNameCtx,
+      nameCtx = ctx.nameCtx ++ nameCtx,
+      classCtx = ctx.classCtx ++ classCtx,
+      fnCtx = ctx.fnCtx ++ fnCtx,
+    )
+
+  private def initContextForStatements(nfds: Ls[NuFunDef], ntds: Ls[NuTypeDef], terms: Ls[Statement]): Ctx =
+    val ctx = Ctx(
+      nameCtx = Map.empty,
+      tyNameCtx = Map.empty,
+      classCtx = Map.empty,
+      fnCtx = Map.empty,
+      opCtx = ops,
+      jpAcc = ListBuffer.empty,
+      defAcc = ListBuffer.empty,
+      lcAcc = ListBuffer.empty,
+    )
+    initContextForStatementsFrom(nfds, ntds, terms, Set.empty)(using ctx)
+
+  def getHiddenNames(prelude: TypingUnit): Set[Str] =
+    def resolveTypeName(x: Term): Str = x match
+      case Var(name) => name
+      case TyApp(lhs, _) => resolveTypeName(lhs)
+      case App(lhs, _) => resolveTypeName(lhs)
+      case _ => throw IRError("unsupported type name")
+    val hidden = prelude.rawEntities.flatMap {
+      case NuFunDef(_, Var(name), _, _, _) => Nil
+      case NuTypeDef(_, TypeName(name), _, params, _, _, _, _, _, _) if name == "HiddenTheseEntities" =>
+        params.fold{Nil}{
+          x => x.fields.flatMap {
+            case S(Var(name)) -> Fld(FldFlags.empty, ty) => resolveTypeName(ty) :: Nil
+            case _ => Nil
+          }
+        }
+      case NuTypeDef(_, TypeName(name), _, _, _, _, _, _, _, _) => Nil
+      case _ => Nil
+    }
+    hidden.toSet
+
+  def buildGraph(unit: TypingUnit, prelude: TypingUnit, addPrelude: Boolean = true): Program =
+    val unit2 = if addPrelude then TypingUnit(prelude.rawEntities ++ unit.rawEntities) else unit
+    val hiddenNames = getHiddenNames(unit2)
+    val (nfds, ntds, terms) = collectInfo(unit2.rawEntities)
+    var ctx = initContextForStatements(nfds, ntds, terms)
+
+    val definitions = ListBuffer.empty[Defn]
+    val classes = ListBuffer.empty[ClassInfo]
+
+    var first = true
+
+    var curNfds = nfds
+    var curNtds = ntds
+    val main = buildResultFromTerm(using ctx)(Blk(terms)){ k => k }
+    while first || ctx.hasLifted do
+      first = false
+      ctx.jpAcc.clear()
+      ctx.defAcc.clear()
+      ctx.lcAcc.clear()
+      definitions.addAll(curNfds.map(buildDefFromNuFunDef(using ctx)))
+      definitions.addAll(ctx.jpAcc)
+      classes.addAll(curNtds.map(buildClassInfo(using ctx)))
+      curNfds = ctx.defAcc.toList
+      curNtds = ctx.lcAcc.toList
+      ctx = initContextForStatementsFrom(curNfds, curNtds, Nil, Set.empty)(using ctx)
+
+    val clsInfo = classes.toSet
+    val defs = definitions.toSet
+
+    resolveRef(main, defs, clsInfo, true)
+    validate(main, defs, clsInfo)
+    
+    Program(clsInfo, defs, main)
diff --git a/compiler/shared/main/scala/mlscript/compiler/ir/DefnRefResolver.scala b/compiler/shared/main/scala/mlscript/compiler/ir/DefnRefResolver.scala
deleted file mode 100644
index 96ee1d635d..0000000000
--- a/compiler/shared/main/scala/mlscript/compiler/ir/DefnRefResolver.scala
+++ /dev/null
@@ -1,33 +0,0 @@
-package mlscript.compiler.ir
-
-import mlscript.utils.shorthands._
-import mlscript.compiler.ir._
-
-import Node._
-
-// Resolves the definition references by turning them from Right(name) to Left(Defn).
-private final class DefnRefResolver(defs: Set[Defn], allowInlineJp: Bool):
-  private def f(x: Node): Unit = x match
-    case Result(res) =>
-    case Case(scrut, cases) => cases map { (_, body) => f(body) }
-    case LetExpr(name, expr, body) => f(body)
-    case LetCall(resultNames, defnref, args, _, body) =>
-      defs.find{_.getName == defnref.getName} match
-        case Some(defn) => defnref.defn = Left(defn)
-        case None => throw IRError(f"unknown function ${defnref.getName} in ${defs.map{_.getName}.mkString(",")}")
-        f(body)
-    case Jump(defnref, _) =>
-      // maybe not promoted yet
-      defs.find{_.getName == defnref.getName} match
-        case Some(defn) => defnref.defn = Left(defn)
-        case None =>
-          if (!allowInlineJp)
-            throw IRError(f"unknown function ${defnref.getName} in ${defs.map{_.getName}.mkString(",")}")
-  def run(node: Node) = f(node)
-  def run(node: Defn) = f(node.body)
-
-
-def resolveDefnRef(entry: Node, defs: Set[Defn], allowInlineJp: Bool = false): Unit  =
-  val rl = DefnRefResolver(defs, allowInlineJp)
-  rl.run(entry)
-  defs.foreach(rl.run(_))
diff --git a/compiler/shared/main/scala/mlscript/compiler/ir/Fresh.scala b/compiler/shared/main/scala/mlscript/compiler/ir/Fresh.scala
index de2ed437db..2ea438dc12 100644
--- a/compiler/shared/main/scala/mlscript/compiler/ir/Fresh.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/ir/Fresh.scala
@@ -3,13 +3,12 @@ package mlscript.compiler.ir
 import collection.mutable.{HashMap => MutHMap}
 import mlscript.utils.shorthands._
 
-final class Fresh:
+final class Fresh(div : Char = '$'):
   private val counter = MutHMap[Str, Int]()
-  private val div = '$' 
   private def gensym(s: Str) = {
     val n = s.lastIndexOf(div)
     val (ts, suffix) = s.splitAt(if n == -1 then s.length() else n)
-    var x = if suffix.stripPrefix(div.toString()).forall(_.isDigit) then ts else s
+    var x = if suffix.stripPrefix(div.toString).forall(_.isDigit) then ts else s
     val count = counter.getOrElse(x, 0)
     val tmp = s"$x$div$count"
     counter.update(x, count + 1)
diff --git a/compiler/shared/main/scala/mlscript/compiler/ir/IR.scala b/compiler/shared/main/scala/mlscript/compiler/ir/IR.scala
index a84f48fd36..5bc51bc59f 100644
--- a/compiler/shared/main/scala/mlscript/compiler/ir/IR.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/ir/IR.scala
@@ -3,8 +3,9 @@ package mlscript.compiler.ir
 import mlscript._
 import mlscript.utils._
 import mlscript.utils.shorthands._
-import mlscript.compiler.ir._
+import mlscript.compiler.utils._
 import mlscript.compiler.optimizer._
+import mlscript.compiler.ir._
 
 import mlscript.Loc
 
@@ -12,6 +13,7 @@ import collection.mutable.{Map as MutMap, Set as MutSet, HashMap, ListBuffer}
 import annotation.unused
 import util.Sorting
 import scala.collection.immutable.SortedSet
+import scala.language.implicitConversions
 
 final case class IRError(message: String) extends Exception(message)
 
@@ -25,7 +27,22 @@ case class Program(
     val t2 = defs.toArray
     Sorting.quickSort(t1)
     Sorting.quickSort(t2)
-    s"Program({${t1.mkString(",")}}, {\n${t2.mkString("\n")}\n},\n$main)"
+    s"Program({${t1.mkString(",\n")}}, {\n${t2.mkString("\n")}\n},\n$main)"
+
+  def show(hiddenNames: Set[Str] = Set.empty) = toDocument(hiddenNames).print
+
+  def toDocument(hiddenNames: Set[Str] = Set.empty) : Document =
+    val t1 = classes.toArray
+    val t2 = defs.toArray
+    Sorting.quickSort(t1)
+    Sorting.quickSort(t2)
+    given Conversion[String, Document] = raw
+    stack(
+      "Program:",
+      stack_list(t1.filter(x => !hiddenNames.contains(x.name)).map(_.toDocument).toList) |> indent,
+      stack_list(t2.map(_.toDocument).toList) |> indent,
+      main.toDocument |> indent
+    )
 
 implicit object ClassInfoOrdering extends Ordering[ClassInfo] {
   def compare(a: ClassInfo, b: ClassInfo) = a.id.compare(b.id)
@@ -33,99 +50,132 @@ implicit object ClassInfoOrdering extends Ordering[ClassInfo] {
 
 case class ClassInfo(
   id: Int,
-  ident: Str,
+  name: Str,
   fields: Ls[Str],
 ):
+  var parents: Set[Str] = Set.empty
+  var methods: Map[Str, Defn] = Map.empty
   override def hashCode: Int = id
   override def toString: String =
-    s"ClassInfo($id, $ident, [${fields mkString ","}])"
+    s"ClassInfo($id, $name, [${fields mkString ","}], parents: ${parents mkString ","}, methods:\n${methods mkString ",\n"})"
+
+  def show = toDocument.print
+  def toDocument: Document =
+    given Conversion[String, Document] = raw
+    val extension = if parents.isEmpty then "" else " extends " + parents.mkString(", ")
+    if methods.isEmpty then
+      "class" <:> name <#> "(" <#> fields.mkString(",") <#> ")" <#> extension
+    else
+      stack(
+        "class" <:> name <#> "(" <#> fields.mkString(",") <#> ")" <#> extension <:> "{",
+        stack_list( methods.map { (_, defn) => defn.toDocument |> indent }.toList),
+        "}"
+      )
 
-case class Name(str: Str):
+case class Name(val str: Str):
   def copy: Name = Name(str)
   def trySubst(map: Map[Str, Name]) = map.getOrElse(str, this)
-  
   override def toString: String =
     str
 
 class DefnRef(var defn: Either[Defn, Str]):
-  def getName: String = defn.fold(_.getName, x => x)
+  def name: String = defn.fold(_.name, x => x)
   def expectDefn: Defn = defn match {
-    case Left(godef) => godef
+    case Left(defn) => defn
     case Right(name) => throw Exception(s"Expected a def, but got $name")
   }
   def getDefn: Opt[Defn] = defn.left.toOption
   override def equals(o: Any): Bool = o match {
-    case o: DefnRef => o.getName == this.getName
+    case o: DefnRef => o.name == this.name
     case _ => false
   }
 
+class ClassRef(var cls: Either[ClassInfo, Str]):
+  def name: String = cls.fold(_.name, x => x)
+  def expectClass: ClassInfo = cls match {
+    case Left(cls) => cls
+    case Right(name) => throw Exception(s"Expected a class, but got $name")
+  }
+  def getClass: Opt[ClassInfo] = cls.left.toOption
+  override def equals(o: Any): Bool = o match {
+    case o: ClassRef => o.name == this.name
+    case _ => false
+  }
 
 implicit object DefOrdering extends Ordering[Defn] {
   def compare(a: Defn, b: Defn) = a.id.compare(b.id)
 }
 
 case class Defn(
-  val id: Int,
-  val name: Str,
-  val params: Ls[Name],
-  val resultNum: Int,
-  val body: Node,
-  val isTailRec: Bool,
-  val loc: Opt[Loc] = None
+  id: Int,
+  name: Str,
+  params: Ls[Name],
+  resultNum: Int,
+  body: Node,
+  isTailRec: Bool,
+  loc: Opt[Loc] = None
 ):
   override def hashCode: Int = id
-  def getName: String = name
 
   override def toString: String =
     val ps = params.map(_.toString).mkString("[", ",", "]")
     s"Def($id, $name, $ps,\n$resultNum, \n$body\n)"
 
+  def show = toDocument.print
+
+  def toDocument: Document =
+    given Conversion[String, Document] = raw
+    stack(
+      "def" <:> name <#> "(" <#> params.map(_.toString).mkString(",")  <#> ")" <:> "=",
+      body.toDocument |> indent
+    )
+
 sealed trait TrivialExpr:
   import Expr._
   override def toString: String
   def show: String
   def toDocument: Document
-
   def mapNameOfTrivialExpr(f: Name => Name): TrivialExpr = this match
     case x: Ref => Ref(f(x.name))
     case x: Literal => x
-
   def toExpr: Expr = this match { case x: Expr => x }
 
-private def show_args(args: Ls[TrivialExpr]) = args map (_.show) mkString ","
+private def showArguments(args: Ls[TrivialExpr]) = args map (_.show) mkString ","
 
 enum Expr:
   case Ref(name: Name) extends Expr, TrivialExpr 
   case Literal(lit: Lit) extends Expr, TrivialExpr
-  case CtorApp(name: ClassInfo, args: Ls[TrivialExpr])
-  case Select(name: Name, cls: ClassInfo, field: Str)
+  case CtorApp(cls: ClassRef, args: Ls[TrivialExpr])
+  case Select(name: Name, cls: ClassRef, field: Str)
   case BasicOp(name: Str, args: Ls[TrivialExpr])
-  case AssignField(assignee: Name, clsInfo: ClassInfo, fieldName: Str, value: TrivialExpr)
+  case AssignField(assignee: Name, cls: ClassRef, field: Str, value: TrivialExpr)
   
   override def toString: String = show
 
   def show: String =
     toDocument.print
   
-  def toDocument: Document = this match
-    case Ref(s) => s.toString |> raw
-    case Literal(IntLit(lit)) => s"$lit" |> raw
-    case Literal(DecLit(lit)) => s"$lit" |> raw
-    case Literal(StrLit(lit)) => s"$lit" |> raw
-    case Literal(UnitLit(lit)) => (if lit then "undefined" else "null") |> raw
-    case CtorApp(ClassInfo(_, name, _), args) =>
-      raw(name) <#> raw("(") <#> raw(args |> show_args) <#> raw(")")
-    case Select(s, _, fld) =>
-      raw(s.toString) <#> raw(".") <#> raw(fld)
+  def toDocument: Document = 
+    given Conversion[String, Document] = raw
+    this match
+    case Ref(s) => s.toString
+    case Literal(IntLit(lit)) => s"$lit"
+    case Literal(DecLit(lit)) => s"$lit"
+    case Literal(StrLit(lit)) => s"$lit"
+    case Literal(UnitLit(lit)) => s"$lit"
+    case CtorApp(cls, args) =>
+      cls.name <#> "(" <#> (args |> showArguments) <#> ")"
+    case Select(s, cls, fld) =>
+      cls.name <#> "." <#> fld <#> "(" <#> s.toString <#> ")"
     case BasicOp(name: Str, args) =>
-      raw(name) <#> raw("(") <#> raw(args |> show_args) <#> raw(")")
+      name <#> "(" <#> (args |> showArguments) <#> ")"
     case AssignField(assignee, clsInfo, fieldName, value) => 
       stack(
-        raw("assign")
-          <:> raw(assignee.toString + "." + fieldName)
-          <:> raw(":=")
-          <:> value.toDocument
-        )
+        "assign"
+        <:> (assignee.toString + "." + fieldName)
+        <:> ":="
+        <:> value.toDocument
+      )
 
   def mapName(f: Name => Name): Expr = this match
     case Ref(name) => Ref(f(name))
@@ -138,18 +188,38 @@ enum Expr:
   def locMarker: LocMarker = this match
     case Ref(name) => LocMarker.MRef(name.str)
     case Literal(lit) => LocMarker.MLit(lit)
-    case CtorApp(name, args) => LocMarker.MCtorApp(name, args.map(_.toExpr.locMarker))
+    case CtorApp(cls, args) => LocMarker.MCtorApp(cls, args.map(_.toExpr.locMarker))
     case Select(name, cls, field) => LocMarker.MSelect(name.str, cls, field)
     case BasicOp(name, args) => LocMarker.MBasicOp(name, args.map(_.toExpr.locMarker))
     case AssignField(assignee, clsInfo, fieldName, value) => LocMarker.MAssignField(assignee.str, fieldName, value.toExpr.locMarker)
 
+enum Pat:
+  case Lit(lit: mlscript.Lit)
+  case Class(cls: ClassRef)
+
+  def isTrue = this match
+    case Class(cls) => cls.name == "True"
+    case _ => false
+  
+  def isFalse = this match
+    case Class(cls) => cls.name == "False"
+    case _ => false
+
+  override def toString: String = this match
+    case Lit(lit) => s"$lit"
+    case Class(cls) => s"${cls.name}"
+
 enum Node:
   // Terminal forms:
   case Result(res: Ls[TrivialExpr])
   case Jump(defn: DefnRef, args: Ls[TrivialExpr])
-  case Case(scrut: Name, cases: Ls[(ClassInfo, Node)])
+  case Case(scrut: Name, cases: Ls[(Pat, Node)], default: Opt[Node])
   // Intermediate forms:
   case LetExpr(name: Name, expr: Expr, body: Node)
+  case LetMethodCall(names: Ls[Name], cls: ClassRef, method: Name, args: Ls[TrivialExpr], body: Node)
+  // Deprecated:
+  //   LetApply(names, fn, args, body) => LetMethodCall(names, ClassRef(R("Callable")), Name("apply" + args.length), (Ref(fn): TrivialExpr) :: args, body)
+  // case LetApply(names: Ls[Name], fn: Name, args: Ls[TrivialExpr], body: Node)
   case LetCall(names: Ls[Name], defn: DefnRef, args: Ls[TrivialExpr], isTailRec: Bool, body: Node)(val loc: Opt[Loc] = None)
 
   var tag = DefnTag(-1)
@@ -171,78 +241,197 @@ enum Node:
   def mapName(f: Name => Name): Node = this match
     case Result(res) => Result(res.map(_.mapNameOfTrivialExpr(f)))
     case Jump(defn, args) => Jump(defn, args.map(_.mapNameOfTrivialExpr(f)))
-    case Case(scrut, cases) => Case(f(scrut), cases.map { (cls, arm) => (cls, arm.mapName(f)) })
+    case Case(scrut, cases, default) => Case(f(scrut), cases.map { (cls, arm) => (cls, arm.mapName(f)) }, default.map(_.mapName(f)))
     case LetExpr(name, expr, body) => LetExpr(f(name), expr.mapName(f), body.mapName(f))
-    case x: LetCall => 
-      val LetCall(names, defn, args, isTailRec, body) = x
-      LetCall(names.map(f), defn, args.map(_.mapNameOfTrivialExpr(f)), isTailRec, body.mapName(f))(x.loc)
+    case LetMethodCall(names, cls, method, args, body) => LetMethodCall(names.map(f), cls, f(method), args.map(_.mapNameOfTrivialExpr(f)), body.mapName(f))
+    case lc @ LetCall(names, defn, args, itr, body) => LetCall(names.map(f), defn, args.map(_.mapNameOfTrivialExpr(f)), itr, body.mapName(f))(lc.loc)
   
   def copy(ctx: Map[Str, Name]): Node = this match
     case Result(res) => Result(res.map(_.mapNameOfTrivialExpr(_.trySubst(ctx))))
     case Jump(defn, args) => Jump(defn, args.map(_.mapNameOfTrivialExpr(_.trySubst(ctx))))
-    case Case(scrut, cases) => Case(ctx(scrut.str), cases.map { (cls, arm) => (cls, arm.copy(ctx)) })
+    case Case(scrut, cases, default) => Case(ctx(scrut.str), cases.map { (cls, arm) => (cls, arm.copy(ctx)) }, default.map(_.copy(ctx)))
     case LetExpr(name, expr, body) => 
       val name_copy = name.copy
       LetExpr(name_copy, expr.mapName(_.trySubst(ctx)), body.copy(ctx + (name_copy.str -> name_copy)))
-    case x: LetCall => 
-      val LetCall(names, defn, args, isTailRec, body) = x
+    case LetMethodCall(names, cls, method, args, body) =>
       val names_copy = names.map(_.copy)
-      LetCall(names_copy, defn, args.map(_.mapNameOfTrivialExpr(_.trySubst(ctx))), isTailRec, body.copy(ctx ++ names_copy.map(x => x.str -> x)))(x.loc)
+      LetMethodCall(names_copy, cls, method.copy, args.map(_.mapNameOfTrivialExpr(_.trySubst(ctx))), body.copy(ctx ++ names_copy.map(x => x.str -> x)))
+    case lc @ LetCall(names, defn, args, itr, body) =>
+      val names_copy = names.map(_.copy)
+      LetCall(names_copy, defn, args.map(_.mapNameOfTrivialExpr(_.trySubst(ctx))), itr, body.copy(ctx ++ names_copy.map(x => x.str -> x)))(lc.loc)
 
-  private def toDocument: Document = this match
-    case Result(res) => raw(res |> show_args) <:> raw(s"-- $tag")
+  def toDocument: Document =
+    given Conversion[String, Document] = raw
+    this match
+    case Result(res) => (res |> showArguments) <:> s"-- $tag"
     case Jump(jp, args) =>
-      raw("jump")
-      <:> raw(jp.getName)
-      <#> raw("(")
-      <#> raw(args |> show_args)
-      <#> raw(")")
-      <:> raw(s"-- $tag") 
-    case Case(x, Ls((tcls, tru), (fcls, fls))) if tcls.ident == "True" && fcls.ident == "False" =>
-      val first = raw("if") <:> raw(x.toString) <:> raw(s"-- $tag") 
-      val tru2 = indent(stack(raw("true") <:> raw ("=>"), tru.toDocument |> indent))
-      val fls2 = indent(stack(raw("false") <:> raw ("=>"), fls.toDocument |> indent))
+      "jump"
+      <:> jp.name
+      <#> "("
+      <#> (args |> showArguments)
+      <#> ")"
+      <:> s"-- $tag" 
+    case Case(x, Ls((tpat, tru), (fpat, fls)), N) if tpat.isTrue && fpat.isFalse =>
+      val first = "if" <:> x.toString <:> s"-- $tag" 
+      val tru2 = indent(stack("true" <:> "=>", tru.toDocument |> indent))
+      val fls2 = indent(stack("false" <:> "=>", fls.toDocument |> indent))
       Document.Stacked(Ls(first, tru2, fls2))
-    case Case(x, cases) =>
-      val first = raw("case") <:> raw(x.toString) <:> raw("of") <:> raw(s"-- $tag") 
-      val other = cases map {
-        case (ClassInfo(_, name, _), node) =>
-          indent(stack(raw(name) <:> raw("=>"), node.toDocument |> indent))
+    case Case(x, cases, default) =>
+      val first = "case" <:> x.toString <:> "of" <:> s"-- $tag" 
+      val other = cases flatMap {
+        case (pat, node) =>
+          Ls(pat.toString <:> "=>", node.toDocument |> indent)
       }
-      Document.Stacked(first :: other)
+      default match
+        case N => stack(first, (Document.Stacked(other) |> indent))
+        case S(dc) =>
+          val default = Ls("_" <:> "=>", dc.toDocument |> indent)
+          stack(first, (Document.Stacked(other ++ default) |> indent))
     case LetExpr(x, expr, body) => 
       stack(
-        raw("let")
-          <:> raw(x.toString)
-          <:> raw("=")
+        "let"
+          <:> x.toString
+          <:> "="
           <:> expr.toDocument
-          <:> raw("in")
-          <:> raw(s"-- $tag"),
+          <:> "in"
+          <:> s"-- $tag",
+        body.toDocument)
+    case LetMethodCall(xs, cls, method, args, body) =>
+      stack(
+        "let"
+          <:> xs.map(_.toString).mkString(",")
+          <:> "="
+          <:> cls.name
+          <#> "."
+          <#> method.toString
+          <#> "("
+          <#> args.map{ x => x.toString }.mkString(",")
+          <#> ")"
+          <:> "in" 
+          <:> s"-- $tag",
         body.toDocument)
-    case LetCall(xs, defn, args, isTailRec, body) => 
+    case LetCall(xs, defn, args, itr, body) => 
       stack(
-        raw("let*")
-          <:> raw("(")
-          <#> raw(xs.map(_.toString).mkString(","))
-          <#> raw(")")
-          <:> raw("=")
-          <:> raw((if isTailRec then "@tailcall " else "") + defn.getName)
-          <#> raw("(")
-          <#> raw(args.map{ x => x.toString }.mkString(","))
-          <#> raw(")")
-          <:> raw("in") 
-          <:> raw(s"-- $tag"),
+        "let*"
+          <:> "("
+          <#> xs.map(_.toString).mkString(",")
+          <#> ")"
+          <:> "="
+          <:> (if itr then "@tailcall " else "") + defn.name
+          <#> "("
+          <#> args.map{ x => x.toString }.mkString(",")
+          <#> ")"
+          <:> "in" 
+          <:> s"-- $tag",
         body.toDocument)
+  
   def locMarker: LocMarker =
     val marker = this match
       case Result(res) => LocMarker.MResult(res.map(_.toExpr.locMarker))
-      case Jump(defn, args) => LocMarker.MJump(defn.getName, args.map(_.toExpr.locMarker))
-      case Case(scrut, cases) => LocMarker.MCase(scrut.str, cases.map(_._1))
+      case Jump(defn, args) => LocMarker.MJump(defn.name, args.map(_.toExpr.locMarker))
+      case Case(scrut, cases, default) => LocMarker.MCase(scrut.str, cases.map(_._1), default.isDefined)
       case LetExpr(name, expr, _) => LocMarker.MLetExpr(name.str, expr.locMarker)
-      case LetCall(names, defn, args, _, _) => LocMarker.MLetCall(names.map(_.str), defn.getName, args.map(_.toExpr.locMarker))
+      case LetMethodCall(names, cls, method, args, _) => LocMarker.MLetMethodCall(names.map(_.str), cls, method.str, args.map(_.toExpr.locMarker))
+      case LetCall(names, defn, args, _, _) => LocMarker.MLetCall(names.map(_.str), defn.name, args.map(_.toExpr.locMarker))
     marker.tag = this.tag
     marker
 
+
+trait DefTraversalOrdering:
+  def ordered(entry: Node, defs: Set[Defn]): Ls[Defn]
+  def orderedNames(entry: Node, defs: Set[Defn]): Ls[Str]
+
+object DefDfs:
+  import Node._
+  
+  private object Successors:
+    def find(node: Node)(using acc: Ls[Defn]): Ls[Defn] =
+      node match
+        case Result(res) => acc
+        case Jump(defn, args) => defn.expectDefn :: acc
+        case Case(scrut, cases, default) =>
+          val acc2 = cases.map(_._2) ++ default.toList
+          acc2.foldLeft(acc)((acc, x) => find(x)(using acc))
+        case LetExpr(name, expr, body) => find(body)
+        case LetMethodCall(names, cls, method, args, body) => find(body)
+        case LetCall(names, defn, args, _, body) => find(body)(using defn.expectDefn :: acc)
+      
+    def find(defn: Defn)(using acc: Ls[Defn]): Ls[Defn] = find(defn.body)
+    def findNames(node: Node)(using acc: Ls[Str]): Ls[Str] =
+      node match
+        case Result(res) => acc
+        case Jump(defn, args) => defn.name :: acc
+        case Case(scrut, cases, default) =>
+          val acc2 = cases.map(_._2) ++ default.toList
+          acc2.foldLeft(acc)((acc, x) => findNames(x)(using acc))
+        case LetExpr(name, expr, body) => findNames(body)
+        case LetMethodCall(names, cls, method, args, body) => findNames(body)
+        case LetCall(names, defn, args, _, body) => findNames(body)(using defn.name :: acc)
+      
+    def findNames(defn: Defn)(using acc: Ls[Str]): Ls[Str] = findNames(defn.body)
+
+  private def dfs(using visited: HashMap[Str, Bool], out: ListBuffer[Defn], postfix: Bool)(x: Defn): Unit =
+    visited.update(x.name, true)
+    if (!postfix)
+      out += x
+    Successors.find(x)(using Nil).foreach { y =>
+      if (!visited(y.name))
+        dfs(y)
+    }
+    if (postfix)
+      out += x
+  
+  private def dfs(using visited: HashMap[Str, Bool], out: ListBuffer[Defn], postfix: Bool)(x: Node): Unit =
+    Successors.find(x)(using Nil).foreach { y =>
+      if (!visited(y.name))
+        dfs(y)
+    }
+
+  private def dfsNames(using visited: HashMap[Str, Bool], defs: Set[Defn], out: ListBuffer[Str], postfix: Bool)(x: Defn): Unit =
+    visited.update(x.name, true)
+    if (!postfix)
+      out += x.name
+    Successors.findNames(x)(using Nil).foreach { y =>
+      if (!visited(y))
+        dfsNames(defs.find(_.name == y).get)
+    }
+    if (postfix)
+      out += x.name
+  
+  private def dfsNames(using visited: HashMap[Str, Bool], defs: Set[Defn], out: ListBuffer[Str], postfix: Bool)(x: Node): Unit =
+    Successors.findNames(x)(using Nil).foreach { y =>
+      if (!visited(y))
+        dfsNames(defs.find(_.name == y).get)
+    }
+
+  def dfs(entry: Node, defs: Set[Defn], postfix: Bool): Ls[Defn] =
+    val visited = HashMap[Str, Bool]()
+    visited ++= defs.map(_.name -> false)
+    val out = ListBuffer[Defn]()
+    dfs(using visited, out, postfix)(entry)
+    out.toList
+
+  def dfsNames(entry: Node, defs: Set[Defn], postfix: Bool): Ls[Str] =
+    val visited = HashMap[Str, Bool]()
+    visited ++= defs.map(_.name -> false)
+    val out = ListBuffer[Str]()
+    dfsNames(using visited, defs, out, postfix)(entry)
+    out.toList
+    
+object DefRevPostOrdering extends DefTraversalOrdering:
+  def ordered(entry: Node, defs: Set[Defn]): Ls[Defn] =
+    DefDfs.dfs(entry, defs, true).reverse
+  def orderedNames(entry: Node, defs: Set[Defn]): Ls[Str] =
+    DefDfs.dfsNames(entry, defs, true).reverse
+
+object DefRevPreOrdering extends DefTraversalOrdering:
+  def ordered(entry: Node, defs: Set[Defn]): Ls[Defn] =
+    DefDfs.dfs(entry, defs, false).reverse
+  def orderedNames(entry: Node, defs: Set[Defn]): Ls[Str] =
+    DefDfs.dfsNames(entry, defs, false).reverse
+
+
+
 case class DefnTag(inner: Int):
   def is_valid = inner >= 0
   override def equals(x: Any): Bool = x match
@@ -250,7 +439,7 @@ case class DefnTag(inner: Int):
       (this, o) match
         case (DefnTag(a), DefnTag(b)) => this.is_valid && o.is_valid && a == b
     case _ => false
-  override def toString(): String = if is_valid then s"#$inner" else "#x"
+  override def toString: String = if is_valid then s"#$inner" else "#x"
 
 case class DefnLocMarker(val defn: Str, val marker: LocMarker):
   override def toString: String = s"$defn:$marker"
@@ -259,49 +448,60 @@ case class DefnLocMarker(val defn: Str, val marker: LocMarker):
 enum LocMarker:
   case MRef(name: Str)
   case MLit(lit: Lit)
-  case MCtorApp(name: ClassInfo, args: Ls[LocMarker])
-  case MSelect(name: Str, cls: ClassInfo, field: Str)
+  case MCtorApp(name: ClassRef, args: Ls[LocMarker])
+  case MSelect(name: Str, cls: ClassRef, field: Str)
   case MBasicOp(name: Str, args: Ls[LocMarker])
+  case MAssignField(assignee: Str, field: Str, value: LocMarker)
   case MResult(res: Ls[LocMarker])
   case MJump(name: Str, args: Ls[LocMarker])
-  case MCase(scrut: Str, cases: Ls[ClassInfo])
+  case MCase(scrut: Str, cases: Ls[Pat], default: Bool)
   case MLetExpr(name: Str, expr: LocMarker)
+  case MLetMethodCall(names: Ls[Str], cls: ClassRef, method: Str, args: Ls[LocMarker])
   case MLetCall(names: Ls[Str], defn: Str, args: Ls[LocMarker])
-  case MAssignField(assignee: Str, field: Str, value: LocMarker)
   var tag = DefnTag(-1)
 
-  def toDocument: Document = this match
-    case MResult(res) => raw("...")
+  def toDocument: Document = 
+    given Conversion[String, Document] = raw
+    this match
+    case MResult(res) => "..."
     case MJump(jp, args) =>
-      raw("jump")
-      <:> raw(jp)
-      <:> raw("...")
-    case MCase(x, Ls(tcls, fcls)) if tcls.ident == "True" && fcls.ident == "False" =>
-      raw("if") <:> raw(x.toString) <:> raw("...")
-    case MCase(x, cases) =>
-      raw("case") <:> raw(x.toString) <:> raw("of") <:> raw("...")
+      "jump"
+      <:> jp
+      <:> "..."
+    case MCase(x, Ls(tpat, fpat), false) if tpat.isTrue && fpat.isFalse =>
+      "if" <:> x.toString <:> "..."
+    case MCase(x, cases, default) =>
+      "case" <:> x.toString <:> "of" <:> "..."
     case MLetExpr(x, expr) => 
-      raw("let")
-        <:> raw(x.toString)
-        <:> raw("=")
-        <:> raw("...")
+      "let"
+        <:> x.toString
+        <:> "="
+        <:> "..."
+    case MLetMethodCall(xs, cls, method, args) =>
+      "let"
+        <:> xs.map(_.toString).mkString(",")
+        <:> "="
+        <:> cls.name
+        <:> "."
+        <:> method
+        <:> "..."
     case MLetCall(xs, defn, args) =>
-      raw("let*")
-        <:> raw("(")
-        <#> raw(xs.map(_.toString).mkString(","))
-        <#> raw(")")
-        <:> raw("=")
-        <:> raw(defn)
-        <:> raw("...")
-    case MRef(s) => s.toString |> raw
-    case MLit(IntLit(lit)) => s"$lit" |> raw
-    case MLit(DecLit(lit)) => s"$lit" |> raw
-    case MLit(StrLit(lit)) => s"$lit" |> raw
-    case MLit(UnitLit(lit)) => (if lit then "undefined" else "null") |> raw
-    case _ => raw("...")
+      "let*"
+        <:> "("
+        <#> xs.map(_.toString).mkString(",")
+        <#> ")"
+        <:> "="
+        <:> defn
+        <:> "..."
+    case MRef(s) => s.toString
+    case MLit(IntLit(lit)) => s"$lit"
+    case MLit(DecLit(lit)) => s"$lit"
+    case MLit(StrLit(lit)) => s"$lit"
+    case MLit(UnitLit(undefinedOrNull)) => if undefinedOrNull then "undefined" else "null"
+    case _ => "..."
 
   def show = s"$tag-" + toDocument.print
 
-  override def toString(): String = show
+  override def toString: String = show
 
   def matches(x: Node): Bool = this.tag == x.tag
diff --git a/compiler/shared/main/scala/mlscript/compiler/ir/Interp.scala b/compiler/shared/main/scala/mlscript/compiler/ir/Interp.scala
index 016ab09938..8ff52e4f64 100644
--- a/compiler/shared/main/scala/mlscript/compiler/ir/Interp.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/ir/Interp.scala
@@ -1,324 +1,207 @@
 package mlscript.compiler.ir
 
 import mlscript._
-import mlscript.compiler._
-import mlscript.compiler.ir.{Node => INode, Expr => IExpr, Program => IProgram, Defn => IDefn, DefnRef => IDefnRef}
+import mlscript.compiler.ir._
+import mlscript.compiler.utils._
 import mlscript.compiler.optimizer._
 import mlscript.utils._
 import scala.collection.immutable._
 import scala.annotation._
 import shorthands._
+import scala.collection.mutable.ListBuffer
+import scala.util.boundary, boundary.break
 
-final case class IRInterpreterError(message: String) extends Exception(message)
+enum Stuck:
+  case StuckExpr(expr: Expr, msg: Str)
+  case StuckNode(node: Node, msg: Str)
+
+  override def toString: String =
+    this match
+      case StuckExpr(expr, msg) => s"StuckExpr(${expr.show}, $msg)"
+      case StuckNode(node, msg) => s"StuckNode(${node.show}, $msg)"
+
+final case class InterpreterError(message: String) extends Exception(message)
 
 class Interpreter(verbose: Bool):
   private def log(x: Any) = if verbose then println(x)
+  import Stuck._
 
-  // We have a similar definition of IR here to represent the result of the interpreter.
-  // This is because IR itself is in A-normal form.
-  // It represent terms, e.g. "Pair(True, False)", like:
-  //   let x = CtorApp(True, []) in
-  //   let y = CtorApp(False, []) in
-  //   let z = CtorApp(Pair, [x, y]) in
-  //   z
-  // But I don't want the result of an interpreter to be like this.
-  // So we release the limitation of the ANF IR here and allow expressions in argument position.
-
-  private case class Program(
-    classes: Set[ClassInfo],
-    defs: Set[Defn],
-    main: Node,
+  private case class Configuration(
+    var context: Ctx
   )
 
-  private case class Defn(
-    val name: Str,
-    val params: Ls[Name],
-    val body: Node,
-  )
+  private type Result[T] = Either[Stuck, T]
 
-  private enum Expr:
-    case Ref(name: Name)
+  private enum Value:
+    case Class(cls: ClassInfo, var fields: Ls[Value])
     case Literal(lit: Lit)
-    case CtorApp(name: ClassInfo, var args: Ls[Expr])
-    case Select(name: Name, cls: ClassInfo, field: Str)
-    case BasicOp(name: Str, args: Ls[Expr])
-    case AssignField(assignee: Name, clsInfo: ClassInfo, fieldName: Str, value: Expr)
-  
-    def show: Str =
-      document.print
-  
-    private def show_args(args: Ls[Expr]) = args map { x => x.show } mkString ","
-
-    def document: Document = this match
-      case Ref(Name(s)) => s |> raw
-      case Literal(IntLit(lit)) => s"$lit" |> raw
-      case Literal(DecLit(lit)) => s"$lit" |> raw
-      case Literal(StrLit(lit)) => s"$lit" |> raw
-      case Literal(UnitLit(lit)) => s"$lit" |> raw
-      case CtorApp(ClassInfo(_, name, _), args) =>
-        raw(name) <#> raw("(") <#> raw(args |> show_args) <#> raw(")")
-      case Select(Name(s), _, fld) =>
-        raw(s) <#> raw(".") <#> raw(fld)
-      case BasicOp(name: Str, args) =>
-        raw(name) <#> raw("(") <#> raw(args |> show_args) <#> raw(")")
-      case AssignField(Name(assignee), clsInfo, fieldName, value) =>
-        stack(
-          raw("assign") 
-            <:> raw(assignee)
-            <#> raw(".")
-            <#> raw(fieldName)
-            <:> raw("=")
-            <:> value.document,
-        )
-
-  private enum Node:
-    case Result(res: Ls[Expr])
-    case Jump(defn: DefnRef, args: Ls[Expr])
-    case Case(scrut: Name, cases: Ls[(ClassInfo, Node)])
-    case LetExpr(name: Name, expr: Expr, body: Node)
-    case LetJoin(joinName: Name, params: Ls[Name], rhs: Node, body: Node)
-    case LetCall(resultNames: Ls[Name], defn: DefnRef, args: Ls[Expr], body: Node)
-
-    def show: Str =
-      document.print
-
-    private def showArgs(args: Ls[Expr]) = args map { x => x.show } mkString ","
 
-    def document: Document = this match
-      case Result(res) => raw(res |> showArgs)
-      case Jump(jp, args) =>
-        raw("jump")
-        <:> raw(jp.name)
-        <#> raw("(")
-        <#> raw(args |> showArgs)
-        <#> raw(")") 
-      case Case(Name(x), Ls((tcls, tru), (fcls, fls))) if tcls.ident == "True" && fcls.ident == "False" =>
-        val first = raw("if") <:> raw(x)
-        val tru2 = indent(raw("true") <:> raw ("=>") <:> tru.document)
-        val fls2 = indent(raw("false") <:> raw ("=>") <:> fls.document)
-        Document.Stacked(Ls(first, tru2, fls2))
-      case Case(Name(x), cases) =>
-        val first = raw("case") <:> raw(x) <:> raw("of")
-        val other = cases map {
-          case (ClassInfo(_, name, _), node) =>
-            indent(raw(name) <:> raw("=>") <:> node.document)
-        }
-        Document.Stacked(first :: other)
-      case LetExpr(Name(x), expr, body) => 
-        stack(
-          raw("let")
-            <:> raw(x)
-            <:> raw("=")
-            <:> expr.document,
-          raw("in") <:> body.document |> indent)
-      case LetJoin(Name(x), params, rhs, body) =>
-        stack(
-          raw("let")
-            <:> raw("join")
-            <:> raw(x)
-            <#> raw("(")
-            <#> raw(params.map{ x => x.toString }.mkString(","))
-            <#> raw(")")
-            <:> raw("=")
-            <:> (rhs.document |> indent |> indent),
-          raw("in") <:> body.document |> indent
-        )
-      case LetCall(resultNames, defn, args, body) => 
-        stack(
-          raw("let*")
-            <:> raw("(")
-            <#> raw(resultNames.map{ x => x.toString }.mkString(","))
-            <#> raw(")")
-            <:> raw("=")
-            <:> raw(defn.name)
-            <#> raw("(")
-            <#> raw(args.map{ x => x.toString }.mkString(","))
-            <#> raw(")"),
-          raw("in") <:> body.document |> indent
-        )
+    override def toString: String = 
+      this match
+        case Class(cls, fields) => s"${cls.name}(${fields.mkString(",")})"
+        case Literal(IntLit(lit)) => lit.toString
+        case Literal(DecLit(lit)) => lit.toString
+        case Literal(StrLit(lit)) => lit.toString
+        case Literal(UnitLit(undefinedOrNull)) => if undefinedOrNull then "undefined" else "null"
+
+  private final case class Ctx(
+    bindingCtx: Map[Str, Value],
+    classCtx: Map[Str, ClassInfo],
+    defnCtx: Map[Str, Defn],
+  )
   
-  private class DefnRef(var defn: Either[Defn, Str]):
-    def name = defn match
-      case Left(defn) => defn.name
-      case Right(name) => name
-
   import Node._
   import Expr._
 
-  private def convert(texpr: ir.TrivialExpr): Expr = texpr match
-    case IExpr.Ref(x) => Ref(x)
-    case IExpr.Literal(x) => Literal(x)
-
-  private def convertArgs(xs: Ls[ir.TrivialExpr]): Ls[Expr] = xs.map(convert)
-
-  private def convert(expr: IExpr): Expr = expr match
-    case IExpr.Ref(x) => Ref(x)
-    case IExpr.Literal(x) => Literal(x)
-    case IExpr.CtorApp(name, args) => CtorApp(name, args |> convertArgs)
-    case IExpr.Select(name, cls, field) => Select(name, cls, field)
-    case IExpr.BasicOp(name, args) => BasicOp(name, args |> convertArgs)
-    case IExpr.AssignField(assignee, clsInfo, fieldName, value) => AssignField(assignee, clsInfo, fieldName, value |> convert)
-
-  private def convert(node: INode): Node = node match
-    case INode.Result(xs) => Result(xs |> convertArgs)
-    case INode.Jump(defnref, args) => Jump(DefnRef(Right(defnref.getName)), args |> convertArgs)
-    case INode.Case(scrut, cases) => Case(scrut, cases.map{(cls, node) => (cls, node |> convert)})
-    case INode.LetExpr(name, expr, body) => LetExpr(name, expr |> convert, body |> convert)
-    case INode.LetCall(xs, defnref, args, _, body) =>
-      LetCall(xs, DefnRef(Right(defnref.getName)), args |> convertArgs, body |> convert)
-
-  private def convert(defn: IDefn): Defn =
-    Defn(defn.name, defn.params, defn.body |> convert)
-
-  private def resolveDefnRef(defs: Set[Defn], node: Node): Unit = node match
-    case Case(_, cases) => cases.foreach { case (cls, node) => resolveDefnRef(defs, node) }
-    case LetExpr(name, expr, body) => resolveDefnRef(defs, body)
-    case LetJoin(joinName, params, rhs, body) => resolveDefnRef(defs, body)
-    case Jump(defnref, args) => defnref.defn = Left(defs.find(_.name == defnref.name).get)
-    case LetCall(xs, defnref, args, body) =>
-      defnref.defn = Left(defs.find(_.name == defnref.name).get)
-      resolveDefnRef(defs, body)
-    case _ =>
-
-  private def convert(prog: IProgram): Program =
-    val classes = prog.classes
-    val old_defs = prog.defs
-    val old_main = prog.main
-
-    val defs: Set[Defn] = old_defs.map(convert)
-    defs.foreach {
-      case Defn(_, _, body) => resolveDefnRef(defs, body)
-    }
-
-    val main = convert(old_main)
-    resolveDefnRef(defs, main)
-
-    Program(classes, defs, main)
-
-  private type Ctx = Map[Str, Expr]
-  private type ClassCtx = Map[Str, ClassInfo]
-
-  private def getTrue(using clsctx: ClassCtx) = CtorApp(clsctx("True"), Ls.empty)
-  private def getFalse(using clsctx: ClassCtx) = CtorApp(clsctx("False"), Ls.empty)
-
-  private def eval(using ctx: Ctx, clsctx: ClassCtx)(op: Str, x1: Expr, x2: Expr): Opt[Expr] = (op, x1, x2) match
-    case ("+", Literal(IntLit(x)), Literal(IntLit(y))) => Some(Literal(IntLit(x + y)))
-    case ("-", Literal(IntLit(x)), Literal(IntLit(y))) => Some(Literal(IntLit(x - y)))
-    case ("*", Literal(IntLit(x)), Literal(IntLit(y))) => Some(Literal(IntLit(x * y)))
-    case ("/", Literal(IntLit(x)), Literal(IntLit(y))) => Some(Literal(IntLit(x / y)))
-    case ("==", Literal(IntLit(x)), Literal(IntLit(y))) => Some(if x == y then getTrue else getFalse)
-    case ("!=", Literal(IntLit(x)), Literal(IntLit(y))) => Some(if x != y then getTrue else getFalse)
-    case ("<=", Literal(IntLit(x)), Literal(IntLit(y))) => Some(if x <= y then getTrue else getFalse)
-    case (">=", Literal(IntLit(x)), Literal(IntLit(y))) => Some(if x >= y then getTrue else getFalse)
-    case (">", Literal(IntLit(x)), Literal(IntLit(y))) => Some(if x > y then getTrue else getFalse)
-    case ("<", Literal(IntLit(x)), Literal(IntLit(y))) => Some(if x < y then getTrue else getFalse)
-    case _ => None
-
-  private def unifyEvalResult[A](x: Either[A, A]) =
-    x match
-      case Left(expr) => expr
-      case Right(expr) => expr 
-
-  private def evalArgs(using ctx: Ctx, clsctx: ClassCtx)(exprs: Ls[Expr]): Either[Ls[Expr], Ls[Expr]] = 
-    var changed = false
-
-    val xs = exprs.map {
-      arg => eval(arg) match
-        case Left(expr) => changed = true; expr
-        case Right(expr) => expr
-    }
-    if (changed) Left(xs) else Right(exprs)
-
-  private def evalArgsMayNotProgress(using ctx: Ctx, clsctx: ClassCtx)(exprs: Ls[Expr]) = 
-    exprs.map {
-      arg => eval(arg) |> unifyEvalResult
-    }
-
-  private def evalMayNotProgress(using ctx: Ctx, clsctx: ClassCtx)(expr: Expr) = eval(expr) |> unifyEvalResult
-    
-  private def eval(using ctx: Ctx, clsctx: ClassCtx)(expr: Expr): Either[Expr, Expr] = expr match
-    case Ref(Name(x)) => ctx.get(x).toLeft(expr)
-    case Literal(x) => Right(expr)
-    case CtorApp(name, args) =>
-      evalArgs(args) match
-        case Left(xs) => Left(CtorApp(name, xs)) 
-        case Right(xs) => Right(CtorApp(name, xs)) // TODO: This makes recursion modulo cons work, but should be investigated further.
-    case Select(name, cls, field) => 
-      ctx.get(name.str).map {
-        case CtorApp(cls2, xs) if cls == cls2 =>
+  private def getTrue(using ctx: Ctx) = Value.Class(ctx.classCtx("True"), Ls.empty)
+  private def getFalse(using ctx: Ctx) = Value.Class(ctx.classCtx("False"), Ls.empty)
+  
+  private def eval(op: Str, x1: Value, x2: Value)(using ctx: Ctx): Opt[Value] =
+    import Value.{Literal => Li}
+    (op, x1, x2) match
+    case ("+", Li(IntLit(x)), Li(IntLit(y))) => S(Li(IntLit(x + y)))
+    case ("-", Li(IntLit(x)), Li(IntLit(y))) => S(Li(IntLit(x - y)))
+    case ("*", Li(IntLit(x)), Li(IntLit(y))) => S(Li(IntLit(x * y)))
+    case ("/", Li(IntLit(x)), Li(IntLit(y))) => S(Li(IntLit(x / y)))
+    case ("==", Li(IntLit(x)), Li(IntLit(y))) => S(if x == y then getTrue else getFalse)
+    case ("!=", Li(IntLit(x)), Li(IntLit(y))) => S(if x != y then getTrue else getFalse)
+    case ("<=", Li(IntLit(x)), Li(IntLit(y))) => S(if x <= y then getTrue else getFalse)
+    case (">=", Li(IntLit(x)), Li(IntLit(y))) => S(if x >= y then getTrue else getFalse)
+    case (">", Li(IntLit(x)), Li(IntLit(y))) => S(if x > y then getTrue else getFalse)
+    case ("<", Li(IntLit(x)), Li(IntLit(y))) => S(if x < y then getTrue else getFalse)
+    case _ => N
+
+  private def evalArgs(using ctx: Ctx)(exprs: Ls[TrivialExpr]): Result[Ls[Value]] =
+    var values = ListBuffer.empty[Value]
+    var stuck: Opt[Stuck] = None
+    exprs foreach { expr =>
+      stuck match
+        case None => eval(expr) match
+          case L(x) => stuck = Some(x)
+          case R(x) => values += x
+        case _ => ()
+    } 
+    stuck.toLeft(values.toList)
+
+  private def eval(expr: TrivialExpr)(using ctx: Ctx): Result[Value] = expr match
+    case e @ Ref(name) => ctx.bindingCtx.get(name.str).toRight(StuckExpr(e, s"undefined variable $name"))
+    case Literal(lit) => R(Value.Literal(lit))
+  
+  private def eval(expr: Expr)(using ctx: Ctx): Result[Value] = expr match
+    case Ref(Name(x)) => ctx.bindingCtx.get(x).toRight(StuckExpr(expr, s"undefined variable $x"))
+    case Literal(x) => R(Value.Literal(x))
+    case CtorApp(cls, args) => for {
+        xs <- evalArgs(args)
+        cls <- ctx.classCtx.get(cls.name).toRight(StuckExpr(expr, s"undefined class ${cls.name}"))
+      } yield Value.Class(cls, xs)
+    case Select(name, cls, field) =>
+      ctx.bindingCtx.get(name.str).toRight(StuckExpr(expr, s"undefined variable $name")).flatMap {
+        case Value.Class(cls2, xs) if cls.name == cls2.name =>
           xs.zip(cls2.fields).find{_._2 == field} match
-            case Some((x, _)) => x
-            case None => throw IRInterpreterError("unable to find selected field")
-        case x @ _ => throw IRInterpreterError(s"unexpected node: select $field but got $x when eval $expr")
-      }.toLeft(expr)
-    case BasicOp(name, args) =>
-      val xs = evalArgsMayNotProgress(args)
-      val x = name match
-        case "+" | "-" | "*" | "/" | "==" | "!=" | "<=" | ">=" | "<" | ">" => 
-          eval(using ctx, clsctx)(name, xs.head, xs.tail.head)
-        case _ => throw IRInterpreterError("unexpected basic operation")
-      x.toLeft(expr)
-    case AssignField(assignee, clsInfo, fieldName, expr) =>
-      val value = evalMayNotProgress(expr)
-      ctx.get(assignee.str) match
-        case Some(x: CtorApp) =>
-          val CtorApp(cls, args) = x
-          val idx = cls.fields.indexOf(fieldName)
-          val newArgs = args.updated(idx, value)
-          x.args = newArgs
-          Left(x)
-        case Some(_) => throw IRInterpreterError("tried to assign a field of a non-ctor")
-        case None => throw IRInterpreterError("could not find value " + assignee)
-
-  private def expectDefn(r: DefnRef) = r.defn match
-    case Left(value) => value
-    case Right(value) => throw IRInterpreterError("only has the name of definition")
-
-  private def evalMayNotProgress(using ctx: Ctx, clsctx: ClassCtx)(node: Node) = eval(node) |> unifyEvalResult
-
-  @tailrec
-  private def eval(using ctx: Ctx, clsctx: ClassCtx)(node: Node): Either[Node, Node] = node match
-    case Result(xs) =>
-      xs |> evalArgs match
-        case Left(xs) => Left(Result(xs))
-        case _ => Right(node)
-    case Jump(defnref, args) =>
-      val xs = args |> evalArgsMayNotProgress
-      val defn = defnref |> expectDefn
-      val ctx1 = ctx ++ defn.params.map{_.str}.zip(xs)
-      eval(using ctx1, clsctx)(defn.body)
-    case Case(scrut, cases) =>
-      val CtorApp(cls, xs) = (Ref(scrut):Expr) |> evalMayNotProgress(using ctx, clsctx) match {
-        case x: CtorApp => x
-        case x => throw IRInterpreterError(s"not a class $x")
+            case Some((x, _)) => R(x)
+            case None => L(StuckExpr(expr, s"unable to find selected field $field"))
+        case Value.Class(cls2, xs) => L(StuckExpr(expr, s"unexpected class $cls2"))
+        case x => L(StuckExpr(expr, s"unexpected value $x"))
       }
-      val arm = cases.find{_._1 == cls} match {
-        case Some((_, x)) => x
-        case _ => throw IRInterpreterError(s"can not find the matched case, $cls expected")
+    case BasicOp(name, args) => boundary:
+      evalArgs(args).flatMap(
+        xs => 
+          name match
+            case "+" | "-" | "*" | "/" | "==" | "!=" | "<=" | ">=" | "<" | ">" => 
+              if xs.length < 2 then break:
+                L(StuckExpr(expr, s"not enough arguments for basic operation $name"))
+              else eval(name, xs.head, xs.tail.head).toRight(StuckExpr(expr, s"unable to evaluate basic operation"))
+            case _ => L(StuckExpr(expr, s"unexpected basic operation $name")))
+    case AssignField(assignee, cls, field, value) =>
+      for {
+        x <- eval(Ref(assignee): TrivialExpr)
+        y <- eval(value)
+        res <- x match
+          case obj @ Value.Class(cls2, xs) if cls.name == cls2.name =>
+            xs.zip(cls2.fields).find{_._2 == field} match
+              case Some((_, _)) =>
+                obj.fields = xs.map(x => if x == obj then y else x)
+                // Ideally, we should return a unit value here, but here we return the assignee value for simplicity.
+                R(obj)
+              case None => L(StuckExpr(expr, s"unable to find selected field $field"))
+          case Value.Class(cls2, xs) => L(StuckExpr(expr, s"unexpected class $cls2"))
+          case x => L(StuckExpr(expr, s"unexpected value $x"))
+      } yield res
+
+  private def eval(node: Node)(using ctx: Ctx): Result[Ls[Value]] = node match
+    case Result(res) => evalArgs(res)
+    case Jump(defn, args) => for {
+        xs <- evalArgs(args)
+        defn <- ctx.defnCtx.get(defn.name).toRight(StuckNode(node, s"undefined function ${defn.name}"))
+        ctx1 = ctx.copy(bindingCtx = ctx.bindingCtx ++ defn.params.map{_.str}.zip(xs))
+        res <- eval(defn.body)(using ctx1)
+      } yield res
+    case Case(scrut, cases, default) =>
+      eval(Ref(scrut): Expr) flatMap {
+        case Value.Class(cls, fields) => 
+          cases.find {
+            case (Pat.Class(cls2), _) => cls.name == cls2.name
+            case _ => false
+          } match {
+            case Some((_, x)) => eval(x)
+            case None => 
+              default match
+                case S(x) => eval(x)
+                case N => L(StuckNode(node, s"can not find the matched case, ${cls.name} expected"))
+          }
+        case Value.Literal(lit) => 
+          cases.find {
+            case (Pat.Lit(lit2), _) => lit == lit2
+            case _ => false
+          } match {
+            case Some((_, x)) => eval(x)
+            case None => 
+              default match
+                case S(x) => eval(x)
+                case N => L(StuckNode(node, s"can not find the matched case, $lit expected"))
+          }
       }
-      eval(arm)
     case LetExpr(name, expr, body) =>
-      val x = evalMayNotProgress(expr)
-      val ctx1 = ctx + (name.str -> x)
-      eval(using ctx1, clsctx)(body)
-    case LetCall(xs, defnref, args, body) =>
-      val defn = defnref |> expectDefn
-      val ys = args |> evalArgsMayNotProgress
-      val ctx1 = ctx ++ defn.params.map{_.str}.zip(ys)
-      val res = evalMayNotProgress(using ctx1, clsctx)(defn.body) match {
-        case Result(xs) => xs
-        case _ => throw IRInterpreterError("unexpected node")
-      }
-      val ctx2 = ctx ++ xs.map{_.str}.zip(res)
-      eval(using ctx2, clsctx)(body)
-    case _ => throw IRInterpreterError("unexpected node")
-
-  private def interpret(prog: Program): Node =
+      for {
+        x <- eval(expr)
+        ctx1 = ctx.copy(bindingCtx = ctx.bindingCtx + (name.str -> x))
+        res <- eval(body)(using ctx1)
+      } yield res
+    case LetMethodCall(names, cls, method, args, body) =>
+      for {
+        ys <- evalArgs(args).flatMap {
+          case Value.Class(cls2, xs) :: args =>
+            cls2.methods.get(method.str).toRight(StuckNode(node, s"undefined method ${method.str}")).flatMap { method =>
+              val ctx1 = ctx.copy(bindingCtx = ctx.bindingCtx ++ cls2.fields.zip(xs) ++ method.params.map{_.str}.zip(args))
+              eval(method.body)(using ctx1)
+            }
+          case _ => L(StuckNode(node, s"not enough arguments for method call, or the first argument is not a class"))
+        }
+        ctx2 = ctx.copy(bindingCtx = ctx.bindingCtx ++ names.map{_.str}.zip(ys))
+        res <- eval(body)(using ctx2)
+      } yield res
+    // case LetApply(names, fn, args, body) => eval(LetMethodCall(names, ClassRef(R("Callable")), Name("apply" + args.length), (Ref(fn): TrivialExpr) :: args, body))
+    case LetCall(names, defn, args, _, body) =>
+      for {
+        xs <- evalArgs(args)
+        defn <- ctx.defnCtx.get(defn.name).toRight(StuckNode(node, s"undefined function ${defn.name}"))
+        ctx1 = ctx.copy(bindingCtx = ctx.bindingCtx ++ defn.params.map{_.str}.zip(xs))
+        ys <- eval(defn.body)(using ctx1)
+        ctx2 = ctx.copy(bindingCtx = ctx.bindingCtx ++ names.map{_.str}.zip(ys))
+        res <- eval(body)(using ctx2)
+      } yield res
+
+  private def f(prog: Program): Ls[Value] =
     val Program(classes, defs, main) = prog
-    val clsctx = classes.map(x => x.ident -> x).toMap
-    evalMayNotProgress(using Map.empty, clsctx)(main)
+    given Ctx = Ctx(
+      bindingCtx = Map.empty,
+      classCtx = classes.map{cls => cls.name -> cls}.toMap,
+      defnCtx = defs.map{defn => defn.name -> defn}.toMap,
+    )
+    eval(main) match
+      case R(x) => x
+      case L(x) => throw InterpreterError("Stuck evaluation: " + x.toString)
     
-  def interpret(irprog: ir.Program): Str =
-    val prog = convert(irprog)
-    val node = interpret(prog) 
-    node.show
+  def interpret(prog: Program): Str =
+    val node = f(prog) 
+    node.map(_.toString).mkString(",")
diff --git a/compiler/shared/main/scala/mlscript/compiler/ir/RefResolver.scala b/compiler/shared/main/scala/mlscript/compiler/ir/RefResolver.scala
new file mode 100644
index 0000000000..a1574137f9
--- /dev/null
+++ b/compiler/shared/main/scala/mlscript/compiler/ir/RefResolver.scala
@@ -0,0 +1,55 @@
+package mlscript.compiler.ir
+
+import mlscript.utils.shorthands._
+import mlscript.compiler.ir._
+
+import Node._
+
+// Resolves the definition references by turning them from Right(name) to Left(Defn).
+private final class RefResolver(defs: Map[Str, Defn], classes: Map[Str, ClassInfo], allowInlineJp: Bool):
+  private def f(x: Expr): Unit = x match
+    case Expr.Ref(name) => 
+    case Expr.Literal(lit) =>
+    case Expr.CtorApp(cls, args) => classes.get(cls.name) match
+      case None => throw IRError(f"unknown class ${cls.name} in ${classes.keySet.mkString(",")}")
+      case Some(value) => cls.cls = Left(value)
+    case Expr.Select(name, cls, field) => classes.get(cls.name) match
+      case None => throw IRError(f"unknown class ${cls.name} in ${classes.keySet.mkString(",")}")
+      case Some(value) => cls.cls = Left(value)
+    case Expr.BasicOp(name, args) =>
+    case Expr.AssignField(assigneee, cls, field, value) => classes.get(cls.name) match
+      case None => throw IRError(f"unknown class ${cls.name} in ${classes.keySet.mkString(",")}")
+      case Some(value) => cls.cls = Left(value)
+
+  private def f(x: Pat): Unit = x match
+    case Pat.Lit(lit) => 
+    case Pat.Class(cls) => classes.get(cls.name) match
+      case None => throw IRError(f"unknown class ${cls.name} in ${classes.keySet.mkString(",")}")
+      case Some(value) => cls.cls = Left(value)
+  
+  private def f(x: Node): Unit = x match
+    case Result(res) =>
+    case Case(scrut, cases, default) => cases foreach { (_, body) => f(body) }; default foreach f
+    case LetExpr(name, expr, body) => f(expr); f(body)
+    case LetMethodCall(names, cls, method, args, body) => f(body)
+    case LetCall(resultNames, defnref, args, _, body) =>
+      defs.get(defnref.name) match
+        case Some(defn) => defnref.defn = Left(defn)
+        case None => throw IRError(f"unknown function ${defnref.name} in ${defs.keySet.mkString(",")}")
+        f(body)
+    case Jump(defnref, _) =>
+      // maybe not promoted yet
+      defs.get(defnref.name) match
+        case Some(defn) => defnref.defn = Left(defn)
+        case None =>
+          if (!allowInlineJp)
+            throw IRError(f"unknown function ${defnref.name} in ${defs.keySet.mkString(",")}")
+  def run(node: Node) = f(node)
+  def run(node: Defn) = f(node.body)
+
+def resolveRef(entry: Node, defs: Set[Defn], classes: Set[ClassInfo], allowInlineJp: Bool = false): Unit  =
+  val defsMap = defs.map(x => x.name -> x).toMap
+  val classesMap = classes.map(x => x.name -> x).toMap
+  val rl = RefResolver(defsMap, classesMap, allowInlineJp)
+  rl.run(entry)
+  defs.foreach(rl.run(_))
diff --git a/compiler/shared/main/scala/mlscript/compiler/ir/Validator.scala b/compiler/shared/main/scala/mlscript/compiler/ir/Validator.scala
index ce7f09c2c9..2a9695c382 100644
--- a/compiler/shared/main/scala/mlscript/compiler/ir/Validator.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/ir/Validator.scala
@@ -3,14 +3,31 @@ package mlscript.compiler.ir
 import mlscript.utils.shorthands._
 import mlscript.compiler.ir._
 
-import Node._
 
-private final class DefnRefInSet(defs: Set[Defn]):
+private final class DefnRefInSet(defs: Set[Defn], classes: Set[ClassInfo]):
+  import Node._
+  import Expr._
+  
+  private def f(x: Expr): Unit = x match
+    case Ref(name) => 
+    case Literal(lit) =>
+    case CtorApp(name, args) =>
+    case Select(name, clsref, field) => clsref.getClass match {
+      case Some(real_class) => if (!classes.exists(_ eq real_class)) throw IRError("ref is not in the set")
+      case _ =>
+    }
+    case BasicOp(name, args) =>
+    case AssignField(assignee, clsref, _, value) => clsref.getClass match {
+      case Some(real_class) => if (!classes.exists(_ eq real_class)) throw IRError("ref is not in the set")
+      case _ =>
+    }
+  
   private def f(x: Node): Unit = x match
     case Result(res) => 
     case Jump(defn, args) =>
-    case Case(scrut, cases) => cases map { (_, body) => f(body) }
+    case Case(scrut, cases, default) => cases foreach { (_, body) => f(body) }; default foreach f
     case LetExpr(name, expr, body) => f(body)
+    case LetMethodCall(names, cls, method, args, body) => f(body)
     case LetCall(res, defnref, args, _, body) =>
       defnref.getDefn match {
         case Some(real_defn) => if (!defs.exists(_ eq real_defn)) throw IRError("ref is not in the set")
@@ -20,10 +37,10 @@ private final class DefnRefInSet(defs: Set[Defn]):
   def run(node: Node) = f(node)
   def run(defn: Defn) = f(defn.body)
 
-def validateDefnRefInSet(entry: Node, defs: Set[Defn]): Unit =
-  val dris = DefnRefInSet(defs)
+def validateRefInSet(entry: Node, defs: Set[Defn], classes: Set[ClassInfo]): Unit =
+  val dris = DefnRefInSet(defs, classes)
   defs.foreach(dris.run(_))
 
-def validate(entry: Node, defs: Set[Defn]): Unit =
-  validateDefnRefInSet(entry, defs)
+def validate(entry: Node, defs: Set[Defn], classes: Set[ClassInfo]): Unit =
+  validateRefInSet(entry, defs, classes)
 
diff --git a/compiler/shared/main/scala/mlscript/compiler/optimizer/Analysis.scala b/compiler/shared/main/scala/mlscript/compiler/optimizer/Analysis.scala
index f0b02d2777..b320a87fbf 100644
--- a/compiler/shared/main/scala/mlscript/compiler/optimizer/Analysis.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/optimizer/Analysis.scala
@@ -46,7 +46,8 @@ class UsefulnessAnalysis(verbose: Bool = false):
   private def f(x: Node): Unit = x match
     case Result(res) => res.foreach(f)
     case Jump(defn, args) => args.foreach(f)
-    case Case(scrut, cases) => addUse(scrut); cases.foreach { case (cls, body) => f(body) }
+    case Case(scrut, cases, default) => addUse(scrut); cases.foreach { case (cls, body) => f(body) }; default.foreach(f)
+    case LetMethodCall(names, cls, method, args, body) => addUse(method); args.foreach(f); names.foreach(addDef); f(body)
     case LetExpr(name, expr, body) => f(expr); addDef(name); f(body)
     case LetCall(names, defn, args, _, body) => args.foreach(f); names.foreach(addDef); f(body)
   
@@ -77,17 +78,22 @@ class FreeVarAnalysis(extended_scope: Bool = true, verbose: Bool = false):
     case Result(res) => res.foldLeft(fv)((acc, arg) => f(using defined)(arg.toExpr, acc))
     case Jump(defnref, args) =>
       var fv2 = args.foldLeft(fv)((acc, arg) => f(using defined)(arg.toExpr, acc))
-      if (extended_scope && !visited.contains(defnref.getName))
+      if (extended_scope && !visited.contains(defnref.name))
         val defn = defnref.expectDefn
         visited.add(defn.name)
         val defined2 = defn.params.foldLeft(defined)((acc, param) => acc + param.str)
         fv2 = f(using defined2)(defn, fv2)
       fv2
-    case Case(scrut, cases) =>
+    case Case(scrut, cases, default) =>
       val fv2 = if (defined.contains(scrut.str)) fv else fv + scrut.str
-      cases.foldLeft(fv2) {
+      val fv3 = cases.foldLeft(fv2) {
         case (acc, (cls, body)) => f(using defined)(body, acc)
       }
+      fv3
+    case LetMethodCall(resultNames, cls, method, args, body) =>
+      var fv2 = args.foldLeft(fv)((acc, arg) => f(using defined)(arg.toExpr, acc))
+      val defined2 = resultNames.foldLeft(defined)((acc, name) => acc + name.str)
+      f(using defined2)(body, fv2)
     case LetExpr(name, expr, body) =>
       val fv2 = f(using defined)(expr, fv)
       val defined2 = defined + name.str
@@ -95,7 +101,7 @@ class FreeVarAnalysis(extended_scope: Bool = true, verbose: Bool = false):
     case LetCall(resultNames, defnref, args, _, body) =>
       var fv2 = args.foldLeft(fv)((acc, arg) => f(using defined)(arg.toExpr, acc))
       val defined2 = resultNames.foldLeft(defined)((acc, name) => acc + name.str)
-      if (extended_scope && !visited.contains(defnref.getName))
+      if (extended_scope && !visited.contains(defnref.name))
         val defn = defnref.expectDefn
         visited.add(defn.name)
         val defined2 = defn.params.foldLeft(defined)((acc, param) => acc + param.str)
diff --git a/compiler/shared/main/scala/mlscript/compiler/optimizer/TailRecOpt.scala b/compiler/shared/main/scala/mlscript/compiler/optimizer/TailRecOpt.scala
index 1405e45765..3019421f8e 100644
--- a/compiler/shared/main/scala/mlscript/compiler/optimizer/TailRecOpt.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/optimizer/TailRecOpt.scala
@@ -80,7 +80,7 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
       case TailCallInfo(src, defn) => 
         f"TailCall { ${src.name}$$${src.id} -> ${defn.name}$$${defn.id} }"
       case ModConsCallInfo(src, startNode, defn, letCallNode, letCtorNode, _, _) =>
-        f"ModConsCall { ${src.name}$$${src.id} -> ${defn.name}$$${defn.id}, class: ${letCtorNode.cls.ident}, field: ${letCtorNode.fieldName} }"
+        f"ModConsCall { ${src.name}$$${src.id} -> ${defn.name}$$${defn.id}, class: ${letCtorNode.cls.name}, field: ${letCtorNode.fieldName} }"
 
     def getSrc = this match
       case NormalCallInfo(src, _) => src 
@@ -107,8 +107,8 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
 
   // Hack to make scala think discoverJoinPoints is tail recursive and be
   // partially optimized :P
-  def casesToJps(cases: List[(ClassInfo, Node)], acc: Set[Defn]): Set[Defn] =
-    cases.foldLeft(acc)((jps, branch) => discoverJoinPoints(branch._2, jps))
+  def casesToJps(cases: List[(Pat, Node)], default: Opt[Node], acc: Set[Defn]): Set[Defn] =
+    cases.foldLeft(default.fold(acc)(x => discoverJoinPoints(x, acc)))((jps, branch) => discoverJoinPoints(branch._2, jps))
   
   def discoverJoinPointsCont(defn: Defn, acc: Set[Defn]) =
     discoverJoinPoints(defn.body, acc) + defn
@@ -122,7 +122,8 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
         val ret = node match
           case Jump(defn, args) => isIdentityJp(defn.expectDefn)
           case _: LetCall => false
-          case Case(scrut, cases) => cases.foldLeft(true)((value, branch) => value && isPure(branch._2))
+          case LetMethodCall(names, cls, method, args, body) => false
+          case Case(scrut, cases, default) => cases.foldLeft(default.fold(false)(isPure))((value, branch) => value && isPure(branch._2))
           case LetExpr(name, expr: Expr.AssignField, body) => false
           case x: LetExpr => true
           case Result(res) => true
@@ -144,8 +145,9 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
         if isIdentityJp(defn) then acc
         else if acc.contains(defn) then acc
         else discoverJoinPointsCont(defn, acc + defn)
-      case Case(scrut, cases) => casesToJps(cases, acc)
+      case Case(scrut, cases, default) => casesToJps(cases, default, acc)
       case LetExpr(name, expr, body) => discoverJoinPoints(body, acc)
+      case LetMethodCall(names, cls, method, args, body) => discoverJoinPoints(body, acc)
       case LetCall(names, defn, args, isTailRec, body) => discoverJoinPoints(body, acc)
 
   private def getRetName(names: Set[Name], retVals: List[TrivialExpr]): Option[Name] =
@@ -234,7 +236,7 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
               case _ => returnNone
           case _ => returnNone
         
-      case Case(scrut, cases) => Right(cases.map(_._2))
+      case Case(scrut, cases, default) => Right(cases.map(_._2) ++ default.toList)
       case x @ LetExpr(name, expr, body) =>
         expr match
           // Check if this let binding references the mod cons call.
@@ -288,10 +290,10 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
                         case _ => false 
                       }
 
-                      val fieldName = clsInfo.fields(ctorArgIndex)
+                      val fieldName = clsInfo.expectClass.fields(ctorArgIndex)
                       
                       // populate required values
-                      searchOptCalls(body)(acc, src, scc, start, calledDefn, letCallNode, Some(LetCtorNodeInfo(x, y, clsInfo, name, fieldName, ctorArgIndex)), Set(name))
+                      searchOptCalls(body)(acc, src, scc, start, calledDefn, letCallNode, Some(LetCtorNodeInfo(x, y, clsInfo.expectClass, name, fieldName, ctorArgIndex)), Set(name))
                     case Some(_) =>
                       // another constructor is already using the call. Not OK
 
@@ -340,6 +342,10 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
                         // If this assignment overwrites the mod cons value, forget it
                         if containingCtors.contains(assignee) then invalidateAndCont(body)
                         else searchOptCalls(body)
+      case LetMethodCall(names, cls, method, args, body) =>
+        // method call is unresolved, just ignore it
+        // `containingCtors -- names.toSet` takes care of variable shadowing
+        searchOptCalls(body)(acc, src, scc, start, calledDefn, letCallNode, letCtorNode, containingCtors -- names.toSet)
       case x @ LetCall(names, defn, args, isTailRec, body) =>
         val callInScc = scc.contains(defn.expectDefn)
         
@@ -468,8 +474,9 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
     node match
       case Result(res) => acc
       case Jump(defn, args) => acc
-      case Case(scrut, cases) => cases.foldLeft(acc)((acc, item) => searchCalls(item._2)(src, acc))
+      case Case(scrut, cases, default) => cases.foldLeft(default.fold(acc)(x => searchCalls(x)(src, acc)))((acc, item) => searchCalls(item._2)(src, acc))
       case LetExpr(name, expr, body) => searchCalls(body)
+      case LetMethodCall(names, cls, method, args, body) => searchCalls(body)
       case LetCall(names, defn, args, isTailRec, body) => 
         val newSet = acc.get(src.id) match
           case None => Set(defn.expectDefn)
@@ -580,7 +587,7 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
     //                  False -> e2
     def makeCaseBranch(value: Int, e1: Node, e2: Node): Node =
       val name = Name("scrut")
-      val cases = Case(name, List((trueClass, e1), (falseClass, e2))).attachTag(tag)
+      val cases = Case(name, List((Pat.Class(ClassRef(L(trueClass))), e1), (Pat.Class(ClassRef(L(falseClass))), e2)), None).attachTag(tag)
       LetExpr(
         name,
         Expr.BasicOp("==", List(asLit(value), Expr.Ref(scrutName))),
@@ -616,6 +623,8 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
   // The idea to use `ptr` and `field` to represent a pointer is by @LPTK.
   final val ID_CTX_CLASS = ClassInfo(classUid.make, ID_CONTEXT_NAME, Nil)
   final val CTX_CLASS = ClassInfo(classUid.make, CONTEXT_NAME, List("acc", "ptr", "field"))
+  final val ID_CTX_CLASS_REF = ClassRef(L(ID_CTX_CLASS))
+  final val CTX_CLASS_REF = ClassRef(L(CTX_CLASS))
   
   // Given a strongly connected component `defns` of mutually
   // tail recursive functions, returns a strongly connected component contaning the
@@ -632,8 +641,8 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
     if modConsCalls.isEmpty then
       (component, Set())
     else
-      val trueClass = classes.find(c => c.ident == "True").get
-      val falseClass = classes.find(c => c.ident == "False").get
+      val trueClass = classes.find(c => c.name == "True").get
+      val falseClass = classes.find(c => c.name == "False").get
       
       // CONTEXT APPLICATION
       
@@ -666,18 +675,18 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
         // acc
         val node = LetExpr(
           Name("ptr"), 
-          Expr.Select(appCtxName, CTX_CLASS, "ptr"),
+          Expr.Select(appCtxName, CTX_CLASS_REF, "ptr"),
           LetExpr(
             Name("_"), 
             Expr.AssignField(
               Name("ptr"), 
-              cls, 
+              ClassRef(L(cls)), 
               fieldName, 
               Expr.Ref(appValName)
             ),
             LetExpr(
               Name("acc"), 
-              Expr.Select(appCtxName, CTX_CLASS, "acc"), // this could be a join point but it's not that bad
+              Expr.Select(appCtxName, CTX_CLASS_REF, "acc"), // this could be a join point but it's not that bad
               Result(
                 List(Expr.Ref(Name("acc")))
               ).attachTag(tag)
@@ -690,7 +699,7 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
       
       
       val ctxBranch = LetExpr(
-        Name("field"), Expr.Select(appCtxName, CTX_CLASS, "field"),
+        Name("field"), Expr.Select(appCtxName, CTX_CLASS_REF, "field"),
         makeSwitch(Name("field"), assignmentCases.tail, assignmentCases.head._2)(trueClass, falseClass)
       ).attachTag(tag)
       
@@ -698,9 +707,10 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
 
       val appNode = Case(appCtxName,
         List(
-          (ID_CTX_CLASS, idBranch),
-          (CTX_CLASS, ctxBranch)
-        )
+          (Pat.Class(ID_CTX_CLASS_REF), idBranch),
+          (Pat.Class(CTX_CLASS_REF), ctxBranch)
+        ),
+        None
       ).attachTag(tag)
 
       val appDefn = Defn(ctxAppId, ctxAppName, List(appCtxName, appValName), 1, appNode, false)
@@ -721,20 +731,20 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
       // ret
       val cmpNode = LetExpr(
         Name("ctx2acc"), 
-        Expr.Select(cmpCtx2Name, CTX_CLASS, "acc"),
+        Expr.Select(cmpCtx2Name, CTX_CLASS_REF, "acc"),
         LetExpr(
           Name("ctx2ptr"), 
-          Expr.Select(cmpCtx2Name, CTX_CLASS, "ptr"),
+          Expr.Select(cmpCtx2Name, CTX_CLASS_REF, "ptr"),
           LetExpr(
             Name("ctx2field"), 
-            Expr.Select(cmpCtx2Name, CTX_CLASS, "field"),
+            Expr.Select(cmpCtx2Name, CTX_CLASS_REF, "field"),
             LetCall(
               List(Name("newAcc")), 
               DefnRef(Left(appDefn)), List(Expr.Ref(cmpCtx1Name), Expr.Ref(Name("ctx2acc"))),
               false,
               LetExpr(
                 Name("ret"), 
-                Expr.CtorApp(CTX_CLASS, List("newAcc", "ctx2ptr", "ctx2field").map(n => Expr.Ref(Name(n)))),
+                Expr.CtorApp(CTX_CLASS_REF, List("newAcc", "ctx2ptr", "ctx2field").map(n => Expr.Ref(Name(n)))),
                 Result(
                   List(Expr.Ref(Name("ret")))
                 ).attachTag(tag)
@@ -777,8 +787,9 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
                 case None => throw IRError("could not find jump point with id" + defn.expectDefn.id)
                 case Some(value) => Jump(value, Expr.Ref(Name("ctx")) :: args)
               
-            case Case(scrut, cases) => Case(scrut, cases.map { (cls, body) => (cls, transformNode(body)) }).attachTag(tag)
+            case Case(scrut, cases, default) => Case(scrut, cases.map { (cls, body) => (cls, transformNode(body)) }, default.map(transformNode)).attachTag(tag)
             case LetExpr(name, expr, body) => LetExpr(name, expr, transformNode(body)).attachTag(tag)
+            case LetMethodCall(names, cls, method, args, body) => LetMethodCall(names, cls, method, args, transformNode(body)).attachTag(tag)
             case LetCall(names, defn, args, isTailRec, body) =>
               // Handle the case when we see a tail call.
               // This case is not handled by the paper. The way to transform this is: 
@@ -803,7 +814,7 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
           // f(composed, *args)
           LetExpr(
             Name("ctx2"),
-            Expr.CtorApp(CTX_CLASS, List(Expr.Ref(call.retName), Expr.Ref(call.letCtorNode.ctorValName), asLit(field))),
+            Expr.CtorApp(CTX_CLASS_REF, List(Expr.Ref(call.retName), Expr.Ref(call.letCtorNode.ctorValName), asLit(field))),
             LetCall(
               List(Name("composed")),
               DefnRef(Left(cmpDefn)),
@@ -831,7 +842,7 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
               // rewrite the ctor, but set the field containing the call as to 0
               val idx = call.letCtorNode.idx
               val argsList = call.letCtorNode.ctor.args.updated(idx, asLit(0))
-              LetExpr(name, Expr.CtorApp(call.letCtorNode.cls, argsList), transformModConsBranch(body)).attachTag(tag)
+              LetExpr(name, Expr.CtorApp(ClassRef(L(call.letCtorNode.cls)), argsList), transformModConsBranch(body)).attachTag(tag)
             else
               LetExpr(name, expr, transformModConsBranch(body)).attachTag(tag)
           case LetCall(names, defn, args, isTailRec, body) =>
@@ -855,7 +866,7 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
         val modConsCall = 
           LetExpr(
             Name("idCtx"),
-            Expr.CtorApp(ID_CTX_CLASS, Nil),
+            Expr.CtorApp(ID_CTX_CLASS_REF, Nil),
               LetCall(
               List(Name("res")), 
               DefnRef(Left(modConsDefn)),
@@ -896,8 +907,8 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
   // Explicitly returns the merged function in case tailrec needs to be checked.
   private def optimizeTailRec(component: ScComponent, classes: Set[ClassInfo]): (Set[Defn], Defn) = 
     // To build the case block, we need to compare integers and check if the result is "True"
-    val trueClass = classes.find(c => c.ident == "True").get
-    val falseClass = classes.find(c => c.ident == "False").get
+    val trueClass = classes.find(c => c.name == "True").get
+    val falseClass = classes.find(c => c.name == "False").get
     // undefined for dummy values
     val dummyVal = Expr.Literal(UnitLit(true))
     
@@ -924,8 +935,9 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
       def transformNode(node: Node): Node = node match
         case Result(res) => node.attachTag(tag)
         case Jump(defn, args) => node.attachTag(tag)
-        case Case(scrut, cases) => Case(scrut, cases.map((cls, body) => (cls, transformNode(body)))).attachTag(tag)
+        case Case(scrut, cases, default) => Case(scrut, cases.map((cls, body) => (cls, transformNode(body))), default.map(transformNode)).attachTag(tag)
         case LetExpr(name, expr, body) => LetExpr(name, expr, transformNode(body)).attachTag(tag)
+        case LetMethodCall(names, cls, method, args, body) => LetMethodCall(names, cls, method, args, transformNode(body)).attachTag(tag)
         case LetCall(names, defn_, args, isTailRec, body) =>
           if isTailCall(node) && defn_.expectDefn.id == defn.id then
             Jump(jpDefnRef, args).attachTag(tag)
@@ -990,9 +1002,11 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
             Jump(jpDefnRef, transformStackFrame(args, defnInfoMap(defn.expectDefn.id))).attachTag(tag)
           else
             node.attachTag(tag)
-        case Result(_)                 => node.attachTag(tag)
-        case Case(scrut, cases)        => Case(scrut, cases.map(n => (n._1, transformNode(n._2)))).attachTag(tag)
+        case Result(_) => node.attachTag(tag)
+        case Case(scrut, cases, default) => Case(scrut, cases.map(n => (n._1, transformNode(n._2))), default.map(transformNode)).attachTag(tag)
         case LetExpr(name, expr, body) => LetExpr(name, expr, transformNode(body)).attachTag(tag)
+        case LetMethodCall(names, cls, method, args, body) =>
+          LetMethodCall(names, cls, method, args, transformNode(body)).attachTag(tag)
         case LetCall(names, defn, args, isTailRec, body) =>
           if isTailCall(node) && defnInfoMap.contains(defn.expectDefn.id) then
             Jump(jpDefnRef, transformStackFrame(args, defnInfoMap(defn.expectDefn.id))).attachTag(tag)
@@ -1075,11 +1089,12 @@ class TailRecOpt(fnUid: FreshInt, classUid: FreshInt, tag: FreshInt, raise: Diag
     val partitions = partition(p.defs)
 
     val newDefs = partitions.flatMap { optimizeParition(_, p.classes) }.toSet
+    val newClasses = p.classes + ID_CTX_CLASS + CTX_CLASS
 
     // update the definition refs
-    newDefs.foreach { defn => resolveDefnRef(defn.body, newDefs, true) }
-    resolveDefnRef(p.main, newDefs, true)
+    newDefs.foreach { defn => resolveRef(defn.body, newDefs, newClasses, true) }
+    resolveRef(p.main, newDefs, newClasses, true)
 
-    (Program(p.classes + ID_CTX_CLASS + CTX_CLASS, newDefs, p.main), partitions.map(t => t.nodes.map(f => f.name)))
+    (Program(newClasses, newDefs, p.main), partitions.map(t => t.nodes.map(f => f.name)))
 
   def run(p: Program): Program = run_debug(p)._1
\ No newline at end of file
diff --git a/compiler/shared/main/scala/mlscript/compiler/simpledef/Simpledef.scala b/compiler/shared/main/scala/mlscript/compiler/simpledef/Simpledef.scala
index 4b59f69499..3b05c09669 100644
--- a/compiler/shared/main/scala/mlscript/compiler/simpledef/Simpledef.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/simpledef/Simpledef.scala
@@ -5,7 +5,7 @@ package simpledef
 import mlscript.utils.*, shorthands.*
 import scala.collection.mutable
 import java.util.IdentityHashMap
-import scala.collection.JavaConverters._
+import scala.jdk.CollectionConverters.*
 
 type TypeVar
 type TermId = Uid[Term]
diff --git a/compiler/shared/test/diff-ir/Class.mls b/compiler/shared/test/diff-ir/Class.mls
new file mode 100644
index 0000000000..9db12fc415
--- /dev/null
+++ b/compiler/shared/test/diff-ir/Class.mls
@@ -0,0 +1,182 @@
+:NewDefs
+:ParseOnly
+:UseIR
+:NoTailRec
+
+:prelude
+module True
+module False
+module Callable {
+  fun apply0() = 0
+  fun apply1(x0) = 0
+  fun apply2(x0,x1) = 0
+  fun apply3(x0,x1,x2) = 0
+  fun apply4(x0,x1,x2,x3) = 0
+  fun apply5(x0,x1,x2,x3,x4) = 0
+}
+module List[A, B]
+class Cons[A, B](h: A, t: Cons[A, B]) extends List[A, B]
+module Nil[A, B] extends List[A, B]
+module Option[A]
+class Some[A](x: A) extends Option[A]
+module None[A] extends Option[A]
+class Pair[A, B](x: A, y: B)
+class Tuple2[A, B](x: A, y: B)
+class Tuple3[A, B, C](x: A, y: B, z: C)
+module Nat
+class S(s: Nat) extends Nat
+module O extends Nat
+class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O)
+//│ |#module| |True|↵|#module| |False|↵|#module| |Callable| |{|→|#fun| |apply0|(||)| |#=| |0|↵|#fun| |apply1|(|x0|)| |#=| |0|↵|#fun| |apply2|(|x0|,|x1|)| |#=| |0|↵|#fun| |apply3|(|x0|,|x1|,|x2|)| |#=| |0|↵|#fun| |apply4|(|x0|,|x1|,|x2|,|x3|)| |#=| |0|↵|#fun| |apply5|(|x0|,|x1|,|x2|,|x3|,|x4|)| |#=| |0|←|↵|}|↵|#module| |List|[|A|,| |B|]|↵|#class| |Cons|[|A|,| |B|]|(|h|#:| |A|,| |t|#:| |Cons|[|A|,| |B|]|)| |#extends| |List|[|A|,| |B|]|↵|#module| |Nil|[|A|,| |B|]| |#extends| |List|[|A|,| |B|]|↵|#module| |Option|[|A|]|↵|#class| |Some|[|A|]|(|x|#:| |A|)| |#extends| |Option|[|A|]|↵|#module| |None|[|A|]| |#extends| |Option|[|A|]|↵|#class| |Pair|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple2|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple3|[|A|,| |B|,| |C|]|(|x|#:| |A|,| |y|#:| |B|,| |z|#:| |C|)|↵|#module| |Nat|↵|#class| |S|(|s|#:| |Nat|)| |#extends| |Nat|↵|#module| |O| |#extends| |Nat|↵|#class| |HiddenTheseEntities|(|_0|#:| |HiddenTheseEntities|,| |_1|#:| |True|,| |_2|#:| |False|,| |_3|#:| |Callable|,| |_4|#:| |List|,| |_5|#:| |Cons|,| |_6|#:| |Nil|,| |_7|#:| |Option|,| |_8|#:| |Some|,| |_9|#:| |None|,| |_10|#:| |Pair|,| |_11|#:| |Tuple2|,| |_12|#:| |Tuple3|,| |_13|#:| |Nat|,| |_14|#:| |S|,| |_15|#:| |O|)|
+//│ Parsed: {module True {}; module False {}; module Callable {fun apply0 = () => 0; fun apply1 = (x0,) => 0; fun apply2 = (x0, x1,) => 0; fun apply3 = (x0, x1, x2,) => 0; fun apply4 = (x0, x1, x2, x3,) => 0; fun apply5 = (x0, x1, x2, x3, x4,) => 0}; module List‹A, B› {}; class Cons‹A, B›(h: A, t: Cons‹A, B›,): List‹A, B› {}; module Nil‹A, B›: List‹A, B› {}; module Option‹A› {}; class Some‹A›(x: A,): Option‹A› {}; module None‹A›: Option‹A› {}; class Pair‹A, B›(x: A, y: B,) {}; class Tuple2‹A, B›(x: A, y: B,) {}; class Tuple3‹A, B, C›(x: A, y: B, z: C,) {}; module Nat {}; class S(s: Nat,): Nat {}; module O: Nat {}; class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O,) {}}
+//│ 
+//│ Preluded.
+//│ 
+
+:genCpp
+:runCpp
+:showCpp
+module Fn extends Callable {
+  fun apply1(x) = builtin("println", x)
+}
+class Fn2(a) extends Callable {
+  fun apply1(x) =
+    builtin("println", a)
+    builtin("println", x)
+}
+class Demo(n) {
+  fun x() = n
+}
+fun f(fn) = fn(1)
+fun main() =
+  let d1 = Demo(2)
+  Demo.x(d1)
+  let print = Fn()
+  Fn.apply1(print, 3)
+  f(print)
+  let print2 = Fn2(4)
+  Fn2.apply1(print2, 5)
+  print2(6)
+  f(print2)
+main()
+//│ |#module| |Fn| |#extends| |Callable| |{|→|#fun| |apply1|(|x|)| |#=| |builtin|(|"println"|,| |x|)|←|↵|}|↵|#class| |Fn2|(|a|)| |#extends| |Callable| |{|→|#fun| |apply1|(|x|)| |#=|→|builtin|(|"println"|,| |a|)|↵|builtin|(|"println"|,| |x|)|←|←|↵|}|↵|#class| |Demo|(|n|)| |{|→|#fun| |x|(||)| |#=| |n|←|↵|}|↵|#fun| |f|(|fn|)| |#=| |fn|(|1|)|↵|#fun| |main|(||)| |#=|→|#let| |d1| |#=| |Demo|(|2|)|↵|Demo|.x|(|d1|)|↵|#let| |print| |#=| |Fn|(||)|↵|Fn|.apply1|(|print|,| |3|)|↵|f|(|print|)|↵|#let| |print2| |#=| |Fn2|(|4|)|↵|Fn2|.apply1|(|print2|,| |5|)|↵|print2|(|6|)|↵|f|(|print2|)|←|↵|main|(||)|
+//│ Parsed: {module Fn: Callable {fun apply1 = (x,) => builtin("println", x,)}; class Fn2(a,): Callable {fun apply1 = (x,) => {builtin("println", a,); builtin("println", x,)}}; class Demo(n,) {fun x = () => n}; fun f = (fn,) => fn(1,); fun main = () => {let d1 = Demo(2,); (Demo).x(d1,); let print = Fn(); (Fn).apply1(print, 3,); f(print,); let print2 = Fn2(4,); (Fn2).apply1(print2, 5,); print2(6,); f(print2,)}; main()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│   class Fn() extends Callable {
+//│     def apply1(x$11) =
+//│       let x$12 = Callable.apply2(builtin,println,x$11) in -- #64
+//│       x$12 -- #63
+//│   }
+//│   class Fn2(a) extends Callable {
+//│     def apply1(x$13) =
+//│       let x$14 = Callable.apply2(builtin,println,a) in -- #80
+//│       let x$15 = Callable.apply2(builtin,println,x$13) in -- #79
+//│       x$15 -- #78
+//│   }
+//│   class Demo(n) {
+//│     def x() =
+//│       n -- #81
+//│   }
+//│   def f(fn$0) =
+//│     let x$1 = Callable.apply1(fn$0,1) in -- #8
+//│     x$1 -- #7
+//│   def main() =
+//│     let x$2 = Demo(2) in -- #56
+//│     let x$3 = Demo.x(x$2) in -- #55
+//│     let x$4 = Fn() in -- #54
+//│     let x$5 = Fn.apply1(x$4,3) in -- #53
+//│     let* (x$6) = f(x$4) in -- #52
+//│     let x$7 = Fn2(4) in -- #51
+//│     let x$8 = Fn2.apply1(x$7,5) in -- #50
+//│     let x$9 = Callable.apply1(x$7,6) in -- #49
+//│     let* (x$10) = f(x$7) in -- #48
+//│     x$10 -- #47
+//│   let* (x$0) = main() in -- #2
+//│   x$0 -- #1
+//│ 
+//│ Cpp:
+//│ struct _mls_Demo: public _mlsObject {
+//│   _mlsValue _mls_n;
+//│   constexpr static inline const char *typeName = "Demo";
+//│   constexpr static inline uint32_t typeTag = nextTypeTag();
+//│   virtual void print() const override { std::printf("%s", typeName); std::printf("("); this->_mls_n.print();  std::printf(")"); }
+//│   virtual void destroy() override { _mlsValue::destroy(this->_mls_n);  operator delete (this, std::align_val_t(_mlsAlignment)); }
+//│   static _mlsValue create(_mlsValue _mls_n) { auto _mlsVal = new (std::align_val_t(_mlsAlignment)) _mls_Demo; _mlsVal->refCount = 1; _mlsVal->tag = typeTag; _mlsVal->_mls_n = _mls_n;  return _mlsValue(_mlsVal); }
+//│   virtual _mlsValue _mls_x(){
+//│     _mlsValue _mls_retval;
+//│     _mls_retval = _mls_n;
+//│     return _mls_retval;
+//│   }
+//│ };
+//│ struct _mls_Fn: public _mls_Callable {
+//│ 
+//│   constexpr static inline const char *typeName = "Fn";
+//│   constexpr static inline uint32_t typeTag = nextTypeTag();
+//│   virtual void print() const override { std::printf("%s", typeName); }
+//│   virtual void destroy() override {  operator delete (this, std::align_val_t(_mlsAlignment)); }
+//│   static _mlsValue create() { auto _mlsVal = new (std::align_val_t(_mlsAlignment)) _mls_Fn; _mlsVal->refCount = 1; _mlsVal->tag = typeTag;  return _mlsValue(_mlsVal); }
+//│   virtual _mlsValue _mls_apply1(_mlsValue _mls_x_11){
+//│     _mlsValue _mls_retval;
+//│     auto _mls_x_12 = _mls_builtin_println(_mls_x_11);
+//│     _mls_retval = _mls_x_12;
+//│     return _mls_retval;
+//│   }
+//│ };
+//│ struct _mls_Fn2: public _mls_Callable {
+//│   _mlsValue _mls_a;
+//│   constexpr static inline const char *typeName = "Fn2";
+//│   constexpr static inline uint32_t typeTag = nextTypeTag();
+//│   virtual void print() const override { std::printf("%s", typeName); std::printf("("); this->_mls_a.print();  std::printf(")"); }
+//│   virtual void destroy() override { _mlsValue::destroy(this->_mls_a);  operator delete (this, std::align_val_t(_mlsAlignment)); }
+//│   static _mlsValue create(_mlsValue _mls_a) { auto _mlsVal = new (std::align_val_t(_mlsAlignment)) _mls_Fn2; _mlsVal->refCount = 1; _mlsVal->tag = typeTag; _mlsVal->_mls_a = _mls_a;  return _mlsValue(_mlsVal); }
+//│   virtual _mlsValue _mls_apply1(_mlsValue _mls_x_13){
+//│     _mlsValue _mls_retval;
+//│     auto _mls_x_14 = _mls_builtin_println(_mls_a);
+//│     auto _mls_x_15 = _mls_builtin_println(_mls_x_13);
+//│     _mls_retval = _mls_x_15;
+//│     return _mls_retval;
+//│   }
+//│ };
+//│ _mlsValue _mls_f(_mlsValue _mls_fn_0){
+//│   _mlsValue _mls_retval;
+//│   auto _mls_x_1 = _mlsMethodCall<_mls_Callable>(_mls_fn_0)->_mls_apply1(_mlsValue::fromIntLit(1));
+//│   _mls_retval = _mls_x_1;
+//│   return _mls_retval;
+//│ }
+//│ _mlsValue _mls_main(){
+//│   _mlsValue _mls_retval;
+//│   auto _mls_x_2 = _mlsValue::create<_mls_Demo>(_mlsValue::fromIntLit(2));
+//│   auto _mls_x_3 = _mlsMethodCall<_mls_Demo>(_mls_x_2)->_mls_x();
+//│   auto _mls_x_4 = _mlsValue::create<_mls_Fn>();
+//│   auto _mls_x_5 = _mlsMethodCall<_mls_Fn>(_mls_x_4)->_mls_apply1(_mlsValue::fromIntLit(3));
+//│   auto _mls_x_6 = _mls_f(_mls_x_4);
+//│   auto _mls_x_7 = _mlsValue::create<_mls_Fn2>(_mlsValue::fromIntLit(4));
+//│   auto _mls_x_8 = _mlsMethodCall<_mls_Fn2>(_mls_x_7)->_mls_apply1(_mlsValue::fromIntLit(5));
+//│   auto _mls_x_9 = _mlsMethodCall<_mls_Callable>(_mls_x_7)->_mls_apply1(_mlsValue::fromIntLit(6));
+//│   auto _mls_x_10 = _mls_f(_mls_x_7);
+//│   _mls_retval = _mls_x_10;
+//│   return _mls_retval;
+//│ }
+//│ _mlsValue _mlsMain(){
+//│   _mlsValue _mls_retval;
+//│   auto _mls_x_0 = _mls_main();
+//│   _mls_retval = _mls_x_0;
+//│   return _mls_retval;
+//│ }
+//│ int main() { return _mlsLargeStack(_mlsMainWrapper); }
+//│ 
+//│ 
+//│ Execution succeeded: 
+//│ 3
+//│ 1
+//│ 4
+//│ 5
+//│ 4
+//│ 6
+//│ 4
+//│ 1
+//│ Unit
+//│ 
diff --git a/compiler/shared/test/diff-ir/Currying.mls b/compiler/shared/test/diff-ir/Currying.mls
new file mode 100644
index 0000000000..313e1ea98f
--- /dev/null
+++ b/compiler/shared/test/diff-ir/Currying.mls
@@ -0,0 +1,95 @@
+:NewDefs
+:ParseOnly
+:UseIR
+:NoTailRec
+
+:prelude
+module True
+module False
+module Callable {
+  fun apply0() = 0
+  fun apply1(x0) = 0
+  fun apply2(x0,x1) = 0
+  fun apply3(x0,x1,x2) = 0
+  fun apply4(x0,x1,x2,x3) = 0
+  fun apply5(x0,x1,x2,x3,x4) = 0
+}
+module List[A, B]
+class Cons[A, B](h: A, t: Cons[A, B]) extends List[A, B]
+module Nil[A, B] extends List[A, B]
+module Option[A]
+class Some[A](x: A) extends Option[A]
+module None[A] extends Option[A]
+class Pair[A, B](x: A, y: B)
+class Tuple2[A, B](x: A, y: B)
+class Tuple3[A, B, C](x: A, y: B, z: C)
+module Nat
+class S(s: Nat) extends Nat
+module O extends Nat
+class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O)
+//│ |#module| |True|↵|#module| |False|↵|#module| |Callable| |{|→|#fun| |apply0|(||)| |#=| |0|↵|#fun| |apply1|(|x0|)| |#=| |0|↵|#fun| |apply2|(|x0|,|x1|)| |#=| |0|↵|#fun| |apply3|(|x0|,|x1|,|x2|)| |#=| |0|↵|#fun| |apply4|(|x0|,|x1|,|x2|,|x3|)| |#=| |0|↵|#fun| |apply5|(|x0|,|x1|,|x2|,|x3|,|x4|)| |#=| |0|←|↵|}|↵|#module| |List|[|A|,| |B|]|↵|#class| |Cons|[|A|,| |B|]|(|h|#:| |A|,| |t|#:| |Cons|[|A|,| |B|]|)| |#extends| |List|[|A|,| |B|]|↵|#module| |Nil|[|A|,| |B|]| |#extends| |List|[|A|,| |B|]|↵|#module| |Option|[|A|]|↵|#class| |Some|[|A|]|(|x|#:| |A|)| |#extends| |Option|[|A|]|↵|#module| |None|[|A|]| |#extends| |Option|[|A|]|↵|#class| |Pair|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple2|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple3|[|A|,| |B|,| |C|]|(|x|#:| |A|,| |y|#:| |B|,| |z|#:| |C|)|↵|#module| |Nat|↵|#class| |S|(|s|#:| |Nat|)| |#extends| |Nat|↵|#module| |O| |#extends| |Nat|↵|#class| |HiddenTheseEntities|(|_0|#:| |HiddenTheseEntities|,| |_1|#:| |True|,| |_2|#:| |False|,| |_3|#:| |Callable|,| |_4|#:| |List|,| |_5|#:| |Cons|,| |_6|#:| |Nil|,| |_7|#:| |Option|,| |_8|#:| |Some|,| |_9|#:| |None|,| |_10|#:| |Pair|,| |_11|#:| |Tuple2|,| |_12|#:| |Tuple3|,| |_13|#:| |Nat|,| |_14|#:| |S|,| |_15|#:| |O|)|
+//│ Parsed: {module True {}; module False {}; module Callable {fun apply0 = () => 0; fun apply1 = (x0,) => 0; fun apply2 = (x0, x1,) => 0; fun apply3 = (x0, x1, x2,) => 0; fun apply4 = (x0, x1, x2, x3,) => 0; fun apply5 = (x0, x1, x2, x3, x4,) => 0}; module List‹A, B› {}; class Cons‹A, B›(h: A, t: Cons‹A, B›,): List‹A, B› {}; module Nil‹A, B›: List‹A, B› {}; module Option‹A› {}; class Some‹A›(x: A,): Option‹A› {}; module None‹A›: Option‹A› {}; class Pair‹A, B›(x: A, y: B,) {}; class Tuple2‹A, B›(x: A, y: B,) {}; class Tuple3‹A, B, C›(x: A, y: B, z: C,) {}; module Nat {}; class S(s: Nat,): Nat {}; module O: Nat {}; class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O,) {}}
+//│ 
+//│ Preluded.
+//│ 
+
+:interpIR
+:genCpp
+:runCpp
+fun add2c(a)(b) = a + b
+fun add2(a, b) = a + b
+fun add3c(a)(b)(c) = a + b + c
+fun main() =
+  add2c(1)(2)
+  add2(1, 2)
+  add3c(1)(2)(3)
+main()
+//│ |#fun| |add2c|(|a|)|(|b|)| |#=| |a| |+| |b|↵|#fun| |add2|(|a|,| |b|)| |#=| |a| |+| |b|↵|#fun| |add3c|(|a|)|(|b|)|(|c|)| |#=| |a| |+| |b| |+| |c|↵|#fun| |main|(||)| |#=|→|add2c|(|1|)|(|2|)|↵|add2|(|1|,| |2|)|↵|add3c|(|1|)|(|2|)|(|3|)|←|↵|main|(||)|
+//│ Parsed: {fun add2c = (a,) => (b,) => +(a, b,); fun add2 = (a, b,) => +(a, b,); fun add3c = (a,) => (b,) => (c,) => +(+(a, b,), c,); fun main = () => {add2c(1,)(2,); add2(1, 2,); add3c(1,)(2,)(3,)}; main()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│   class Lambda$0(a) extends Callable {
+//│     def apply1(b$1) =
+//│       let x$12 = +(a,b$1) in -- #58
+//│       x$12 -- #57
+//│   }
+//│   class Lambda$1(a) extends Callable {
+//│     def apply1(b$2) =
+//│       let x$14 = Lambda$2(a,b$2) in -- #60
+//│       x$14 -- #59
+//│   }
+//│   class Lambda$2(a,b) extends Callable {
+//│     def apply1(c$0) =
+//│       let x$15 = +(a,b) in -- #73
+//│       let x$16 = +(x$15,c$0) in -- #72
+//│       x$16 -- #71
+//│   }
+//│   def add2c(a$0) =
+//│     let x$2 = Lambda$0(a$0) in -- #4
+//│     x$2 -- #3
+//│   def add2(a$1,b$0) =
+//│     let x$3 = +(a$1,b$0) in -- #11
+//│     x$3 -- #10
+//│   def add3c(a$2) =
+//│     let x$5 = Lambda$1(a$2) in -- #13
+//│     x$5 -- #12
+//│   def main() =
+//│     let* (x$6) = add2c(1) in -- #45
+//│     let x$7 = Callable.apply1(x$6,2) in -- #44
+//│     let* (x$8) = add2(1,2) in -- #43
+//│     let* (x$9) = add3c(1) in -- #42
+//│     let x$10 = Callable.apply1(x$9,2) in -- #41
+//│     let x$11 = Callable.apply1(x$10,3) in -- #40
+//│     x$11 -- #39
+//│   let* (x$0) = main() in -- #2
+//│   x$0 -- #1
+//│ 
+//│ Interpreted:
+//│ 6
+//│ 
+//│ 
+//│ Execution succeeded: 
+//│ 6
+//│ 
diff --git a/compiler/shared/test/diff-ir/IR.mls b/compiler/shared/test/diff-ir/IR.mls
index b5b44bbcf9..ce5dbd1641 100644
--- a/compiler/shared/test/diff-ir/IR.mls
+++ b/compiler/shared/test/diff-ir/IR.mls
@@ -1,85 +1,108 @@
-:NewParser
+:NewDefs
 :ParseOnly
 :UseIR
 :NoTailRec
 
+:prelude
+module True
+module False
+module Callable {
+  fun apply0() = 0
+  fun apply1(x0) = 0
+  fun apply2(x0,x1) = 0
+  fun apply3(x0,x1,x2) = 0
+  fun apply4(x0,x1,x2,x3) = 0
+  fun apply5(x0,x1,x2,x3,x4) = 0
+}
+module List[A, B]
+class Cons[A, B](h: A, t: Cons[A, B]) extends List[A, B]
+module Nil[A, B] extends List[A, B]
+module Option[A]
+class Some[A](x: A) extends Option[A]
+module None[A] extends Option[A]
+class Pair[A, B](x: A, y: B)
+class Tuple2[A, B](x: A, y: B)
+class Tuple3[A, B, C](x: A, y: B, z: C)
+module Nat
+class S(s: Nat) extends Nat
+module O extends Nat
+module Either[A, B]
+class Left[A, B](x: A) extends Either[A, B]
+class Right[A, B](y: B) extends Either[A, B]
+class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O, _16: Either, _17: Left, _18: Right)
+//│ |#module| |True|↵|#module| |False|↵|#module| |Callable| |{|→|#fun| |apply0|(||)| |#=| |0|↵|#fun| |apply1|(|x0|)| |#=| |0|↵|#fun| |apply2|(|x0|,|x1|)| |#=| |0|↵|#fun| |apply3|(|x0|,|x1|,|x2|)| |#=| |0|↵|#fun| |apply4|(|x0|,|x1|,|x2|,|x3|)| |#=| |0|↵|#fun| |apply5|(|x0|,|x1|,|x2|,|x3|,|x4|)| |#=| |0|←|↵|}|↵|#module| |List|[|A|,| |B|]|↵|#class| |Cons|[|A|,| |B|]|(|h|#:| |A|,| |t|#:| |Cons|[|A|,| |B|]|)| |#extends| |List|[|A|,| |B|]|↵|#module| |Nil|[|A|,| |B|]| |#extends| |List|[|A|,| |B|]|↵|#module| |Option|[|A|]|↵|#class| |Some|[|A|]|(|x|#:| |A|)| |#extends| |Option|[|A|]|↵|#module| |None|[|A|]| |#extends| |Option|[|A|]|↵|#class| |Pair|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple2|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple3|[|A|,| |B|,| |C|]|(|x|#:| |A|,| |y|#:| |B|,| |z|#:| |C|)|↵|#module| |Nat|↵|#class| |S|(|s|#:| |Nat|)| |#extends| |Nat|↵|#module| |O| |#extends| |Nat|↵|#module| |Either|[|A|,| |B|]|↵|#class| |Left|[|A|,| |B|]|(|x|#:| |A|)| |#extends| |Either|[|A|,| |B|]|↵|#class| |Right|[|A|,| |B|]|(|y|#:| |B|)| |#extends| |Either|[|A|,| |B|]|↵|#class| |HiddenTheseEntities|(|_0|#:| |HiddenTheseEntities|,| |_1|#:| |True|,| |_2|#:| |False|,| |_3|#:| |Callable|,| |_4|#:| |List|,| |_5|#:| |Cons|,| |_6|#:| |Nil|,| |_7|#:| |Option|,| |_8|#:| |Some|,| |_9|#:| |None|,| |_10|#:| |Pair|,| |_11|#:| |Tuple2|,| |_12|#:| |Tuple3|,| |_13|#:| |Nat|,| |_14|#:| |S|,| |_15|#:| |O|,| |_16|#:| |Either|,| |_17|#:| |Left|,| |_18|#:| |Right|)|
+//│ Parsed: {module True {}; module False {}; module Callable {fun apply0 = () => 0; fun apply1 = (x0,) => 0; fun apply2 = (x0, x1,) => 0; fun apply3 = (x0, x1, x2,) => 0; fun apply4 = (x0, x1, x2, x3,) => 0; fun apply5 = (x0, x1, x2, x3, x4,) => 0}; module List‹A, B› {}; class Cons‹A, B›(h: A, t: Cons‹A, B›,): List‹A, B› {}; module Nil‹A, B›: List‹A, B› {}; module Option‹A› {}; class Some‹A›(x: A,): Option‹A› {}; module None‹A›: Option‹A› {}; class Pair‹A, B›(x: A, y: B,) {}; class Tuple2‹A, B›(x: A, y: B,) {}; class Tuple3‹A, B, C›(x: A, y: B, z: C,) {}; module Nat {}; class S(s: Nat,): Nat {}; module O: Nat {}; module Either‹A, B› {}; class Left‹A, B›(x: A,): Either‹A, B› {}; class Right‹A, B›(y: B,): Either‹A, B› {}; class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O, _16: Either, _17: Left, _18: Right,) {}}
+//│ 
+//│ Preluded.
+//│ 
+
+
 :interpIR
-class Pair(x, y)
 fun mktup2(x, y) = mktup(x, y)
 fun mktup(x, y) = Pair(x, y)
 fun foo() =
   mktup2(1, 2)
 foo()
-//│ |#class| |Pair|(|x|,| |y|)|↵|#fun| |mktup2|(|x|,| |y|)| |#=| |mktup|(|x|,| |y|)|↵|#fun| |mktup|(|x|,| |y|)| |#=| |Pair|(|x|,| |y|)|↵|#fun| |foo|(||)| |#=|→|mktup2|(|1|,| |2|)|←|↵|foo|(||)|
-//│ Parsed: {class Pair(x, y,) {}; fun mktup2 = (x, y,) => mktup(x, y,); fun mktup = (x, y,) => Pair(x, y,); fun foo = () => {mktup2(1, 2,)}; foo()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Pair, [x,y])}, {
-//│ Def(0, mktup2, [x$0,y$0],
-//│ 1, 
-//│ let* (x$1) = mktup(x$0,y$0) in -- #7
-//│ x$1 -- #6
-//│ )
-//│ Def(1, mktup, [x$2,y$1],
-//│ 1, 
-//│ let x$3 = Pair(x$2,y$1) in -- #14
-//│ x$3 -- #13
-//│ )
-//│ Def(2, foo, [],
-//│ 1, 
-//│ let* (x$4) = mktup2(1,2) in -- #22
-//│ x$4 -- #21
-//│ )
-//│ },
-//│ let* (x$5) = foo() in -- #26
-//│ x$5 -- #25)
+//│ |#fun| |mktup2|(|x|,| |y|)| |#=| |mktup|(|x|,| |y|)|↵|#fun| |mktup|(|x|,| |y|)| |#=| |Pair|(|x|,| |y|)|↵|#fun| |foo|(||)| |#=|→|mktup2|(|1|,| |2|)|←|↵|foo|(||)|
+//│ Parsed: {fun mktup2 = (x, y,) => mktup(x, y,); fun mktup = (x, y,) => Pair(x, y,); fun foo = () => {mktup2(1, 2,)}; foo()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def mktup2(x$1,y$0) =
+//│     let* (x$2) = mktup(x$1,y$0) in -- #9
+//│     x$2 -- #8
+//│   def mktup(x$3,y$1) =
+//│     let x$4 = Pair(x$3,y$1) in -- #16
+//│     x$4 -- #15
+//│   def foo() =
+//│     let* (x$5) = mktup2(1,2) in -- #23
+//│     x$5 -- #22
+//│   let* (x$0) = foo() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ Pair(1,2)
+//│ 
 
 :interpIR
-class Pair(x, y)
 fun foo(pair) =
   if pair is
     Pair(x, y) then Pair(x, y)
 fun bar() =
   foo(Pair(1, 2))
 bar()
-//│ |#class| |Pair|(|x|,| |y|)|↵|#fun| |foo|(|pair|)| |#=|→|#if| |pair| |is|→|Pair|(|x|,| |y|)| |#then| |Pair|(|x|,| |y|)|←|←|↵|#fun| |bar|(||)| |#=|→|foo|(|Pair|(|1|,| |2|)|)|←|↵|bar|(||)|
-//│ Parsed: {class Pair(x, y,) {}; fun foo = (pair,) => {if pair is ‹(Pair(x, y,)) then Pair(x, y,)›}; fun bar = () => {foo(Pair(1, 2,),)}; bar()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Pair, [x,y])}, {
-//│ Def(0, foo, [pair$0],
-//│ 1, 
-//│ case pair$0 of -- #16
-//│   Pair =>
-//│     let x$1 = pair$0.y in -- #15
-//│     let x$2 = pair$0.x in -- #14
-//│     let x$3 = Pair(x$2,x$1) in -- #13
-//│     jump j$0(x$3) -- #12
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, bar, [],
-//│ 1, 
-//│ let x$4 = Pair(1,2) in -- #28
-//│ let* (x$5) = foo(x$4) in -- #27
-//│ x$5 -- #26
-//│ )
-//│ },
-//│ let* (x$6) = bar() in -- #32
-//│ x$6 -- #31)
+//│ |#fun| |foo|(|pair|)| |#=|→|#if| |pair| |is|→|Pair|(|x|,| |y|)| |#then| |Pair|(|x|,| |y|)|←|←|↵|#fun| |bar|(||)| |#=|→|foo|(|Pair|(|1|,| |2|)|)|←|↵|bar|(||)|
+//│ Parsed: {fun foo = (pair,) => {if pair is ‹(Pair(x, y,)) then Pair(x, y,)›}; fun bar = () => {foo(Pair(1, 2,),)}; bar()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def foo(pair$0) =
+//│     case pair$0 of -- #23
+//│       Pair =>
+//│         let x$2 = Pair.y(pair$0) in -- #22
+//│         let x$3 = Pair.x(pair$0) in -- #21
+//│         let x$4 = Pair(x$3,x$2) in -- #20
+//│         jump j$0(x$4) -- #19
+//│   def j$0(x$1) =
+//│     x$1 -- #4
+//│   def bar() =
+//│     let x$5 = Pair(1,2) in -- #34
+//│     let* (x$6) = foo(x$5) in -- #33
+//│     x$6 -- #32
+//│   let* (x$0) = bar() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ Pair(1,2)
+//│ 
 
 
 
 :interpIR
-class Pair(x, y) {}
 fun silly(pair) =
   let _ = 0
   let n = if pair is
@@ -92,52 +115,45 @@ fun foo() =
     let b = silly(a)
     b
 foo()
-//│ |#class| |Pair|(|x|,| |y|)| |{||}|↵|#fun| |silly|(|pair|)| |#=|→|#let| |_| |#=| |0|↵|#let| |n| |#=| |#if| |pair| |is|→|Pair|(|x1|,| |x2|)| |#then|→|#if| |pair| |is|→|Pair| |(|x3|,| |x4|)| |#then| |x3| |+| |1|←|←|←|↵|n| |+| |1|←|↵|#fun| |foo|(||)| |#=|→|#let| |a| |#=| |Pair|(|0|,| |1|)|↵|#let| |b| |#=| |silly|(|a|)|↵|b|←|↵|foo|(||)|
-//│ Parsed: {class Pair(x, y,) {}; fun silly = (pair,) => {let _ = 0; let n = if pair is ‹(Pair(x1, x2,)) then {if pair is ‹(Pair(x3, x4,)) then +(x3,)(1,)›}›; +(n,)(1,)}; fun foo = () => {let a = Pair(0, 1,); let b = silly(a,); b}; foo()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Pair, [x,y])}, {
-//│ Def(0, silly, [pair$0],
-//│ 1, 
-//│ let x$0 = 0 in -- #29
-//│ case pair$0 of -- #28
-//│   Pair =>
-//│     let x$3 = pair$0.y in -- #27
-//│     let x$4 = pair$0.x in -- #26
-//│     case pair$0 of -- #25
+//│ |#fun| |silly|(|pair|)| |#=|→|#let| |_| |#=| |0|↵|#let| |n| |#=| |#if| |pair| |is|→|Pair|(|x1|,| |x2|)| |#then|→|#if| |pair| |is|→|Pair| |(|x3|,| |x4|)| |#then| |x3| |+| |1|←|←|←|↵|n| |+| |1|←|↵|#fun| |foo|(||)| |#=|→|#let| |a| |#=| |Pair|(|0|,| |1|)|↵|#let| |b| |#=| |silly|(|a|)|↵|b|←|↵|foo|(||)|
+//│ Parsed: {fun silly = (pair,) => {let _ = 0; let n = if pair is ‹(Pair(x1, x2,)) then {if pair is ‹(Pair(x3, x4,)) then +(x3, 1,)›}›; +(n, 1,)}; fun foo = () => {let a = Pair(0, 1,); let b = silly(a,); b}; foo()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def silly(pair$0) =
+//│     let x$1 = 0 in -- #46
+//│     case pair$0 of -- #45
 //│       Pair =>
-//│         let x$6 = pair$0.y in -- #24
-//│         let x$7 = pair$0.x in -- #23
-//│         let x$8 = +(x$7,1) in -- #22
-//│         jump j$1(x$8) -- #21
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ let x$2 = +(x$1,1) in -- #6
-//│ x$2 -- #5
-//│ )
-//│ Def(2, j$1, [x$5],
-//│ 1, 
-//│ jump j$0(x$5) -- #13
-//│ )
-//│ Def(3, foo, [],
-//│ 1, 
-//│ let x$9 = Pair(0,1) in -- #43
-//│ let* (x$10) = silly(x$9) in -- #42
-//│ x$10 -- #41
-//│ )
-//│ },
-//│ let* (x$11) = foo() in -- #47
-//│ x$11 -- #46)
+//│         let x$4 = Pair.y(pair$0) in -- #44
+//│         let x$5 = Pair.x(pair$0) in -- #43
+//│         case pair$0 of -- #42
+//│           Pair =>
+//│             let x$7 = Pair.y(pair$0) in -- #41
+//│             let x$8 = Pair.x(pair$0) in -- #40
+//│             let x$9 = +(x$8,1) in -- #39
+//│             jump j$1(x$9) -- #38
+//│   def j$0(x$2) =
+//│     let x$3 = +(x$2,1) in -- #12
+//│     x$3 -- #11
+//│   def j$1(x$6) =
+//│     jump j$0(x$6) -- #23
+//│   def foo() =
+//│     let x$10 = Pair(0,1) in -- #59
+//│     let* (x$11) = silly(x$10) in -- #58
+//│     x$11 -- #57
+//│   let* (x$0) = foo() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ 2
+//│ 
 
 
 
 
 :interpIR
-class Pair(x, y)
 fun inc_fst(pair) =
   let c = 2
   if pair is
@@ -147,40 +163,35 @@ fun foo() =
     let b = inc_fst(a)
     b
 foo()
-//│ |#class| |Pair|(|x|,| |y|)|↵|#fun| |inc_fst|(|pair|)| |#=|→|#let| |c| |#=| |2|↵|#if| |pair| |is|→|Pair|(|x1|,| |x2|)| |#then| |x1| |+| |c|←|←|↵|#fun| |foo|(||)| |#=|→|#let| |a| |#=| |Pair|(|0|,| |1|)|↵|#let| |b| |#=| |inc_fst|(|a|)|↵|b|←|↵|foo|(||)|
-//│ Parsed: {class Pair(x, y,) {}; fun inc_fst = (pair,) => {let c = 2; if pair is ‹(Pair(x1, x2,)) then +(x1,)(c,)›}; fun foo = () => {let a = Pair(0, 1,); let b = inc_fst(a,); b}; foo()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Pair, [x,y])}, {
-//│ Def(0, inc_fst, [pair$0],
-//│ 1, 
-//│ let x$0 = 2 in -- #15
-//│ case pair$0 of -- #14
-//│   Pair =>
-//│     let x$2 = pair$0.y in -- #13
-//│     let x$3 = pair$0.x in -- #12
-//│     let x$4 = +(x$3,x$0) in -- #11
-//│     jump j$0(x$4) -- #10
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #2
-//│ )
-//│ Def(2, foo, [],
-//│ 1, 
-//│ let x$5 = Pair(0,1) in -- #29
-//│ let* (x$6) = inc_fst(x$5) in -- #28
-//│ x$6 -- #27
-//│ )
-//│ },
-//│ let* (x$7) = foo() in -- #33
-//│ x$7 -- #32)
+//│ |#fun| |inc_fst|(|pair|)| |#=|→|#let| |c| |#=| |2|↵|#if| |pair| |is|→|Pair|(|x1|,| |x2|)| |#then| |x1| |+| |c|←|←|↵|#fun| |foo|(||)| |#=|→|#let| |a| |#=| |Pair|(|0|,| |1|)|↵|#let| |b| |#=| |inc_fst|(|a|)|↵|b|←|↵|foo|(||)|
+//│ Parsed: {fun inc_fst = (pair,) => {let c = 2; if pair is ‹(Pair(x1, x2,)) then +(x1, c,)›}; fun foo = () => {let a = Pair(0, 1,); let b = inc_fst(a,); b}; foo()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def inc_fst(pair$0) =
+//│     let x$1 = 2 in -- #25
+//│     case pair$0 of -- #24
+//│       Pair =>
+//│         let x$3 = Pair.y(pair$0) in -- #23
+//│         let x$4 = Pair.x(pair$0) in -- #22
+//│         let x$5 = +(x$4,x$1) in -- #21
+//│         jump j$0(x$5) -- #20
+//│   def j$0(x$2) =
+//│     x$2 -- #5
+//│   def foo() =
+//│     let x$6 = Pair(0,1) in -- #38
+//│     let* (x$7) = inc_fst(x$6) in -- #37
+//│     x$7 -- #36
+//│   let* (x$0) = foo() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ 2
+//│ 
 
 :interpIR
-class Pair(x, y)
 fun inc_fst(pair) =
   let _ = 0
   if pair is
@@ -189,41 +200,35 @@ fun foo() =
     let b = inc_fst(Pair(0, 1))
     b
 foo()
-//│ |#class| |Pair|(|x|,| |y|)|↵|#fun| |inc_fst|(|pair|)| |#=|→|#let| |_| |#=| |0|↵|#if| |pair| |is|→|Pair|(|x1|,| |x2|)| |#then| |x2| |+| |1|←|←|↵|#fun| |foo|(||)| |#=|→|#let| |b| |#=| |inc_fst|(|Pair|(|0|,| |1|)|)|↵|b|←|↵|foo|(||)|
-//│ Parsed: {class Pair(x, y,) {}; fun inc_fst = (pair,) => {let _ = 0; if pair is ‹(Pair(x1, x2,)) then +(x2,)(1,)›}; fun foo = () => {let b = inc_fst(Pair(0, 1,),); b}; foo()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Pair, [x,y])}, {
-//│ Def(0, inc_fst, [pair$0],
-//│ 1, 
-//│ let x$0 = 0 in -- #15
-//│ case pair$0 of -- #14
-//│   Pair =>
-//│     let x$2 = pair$0.y in -- #13
-//│     let x$3 = pair$0.x in -- #12
-//│     let x$4 = +(x$2,1) in -- #11
-//│     jump j$0(x$4) -- #10
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #2
-//│ )
-//│ Def(2, foo, [],
-//│ 1, 
-//│ let x$5 = Pair(0,1) in -- #28
-//│ let* (x$6) = inc_fst(x$5) in -- #27
-//│ x$6 -- #26
-//│ )
-//│ },
-//│ let* (x$7) = foo() in -- #32
-//│ x$7 -- #31)
+//│ |#fun| |inc_fst|(|pair|)| |#=|→|#let| |_| |#=| |0|↵|#if| |pair| |is|→|Pair|(|x1|,| |x2|)| |#then| |x2| |+| |1|←|←|↵|#fun| |foo|(||)| |#=|→|#let| |b| |#=| |inc_fst|(|Pair|(|0|,| |1|)|)|↵|b|←|↵|foo|(||)|
+//│ Parsed: {fun inc_fst = (pair,) => {let _ = 0; if pair is ‹(Pair(x1, x2,)) then +(x2, 1,)›}; fun foo = () => {let b = inc_fst(Pair(0, 1,),); b}; foo()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def inc_fst(pair$0) =
+//│     let x$1 = 0 in -- #25
+//│     case pair$0 of -- #24
+//│       Pair =>
+//│         let x$3 = Pair.y(pair$0) in -- #23
+//│         let x$4 = Pair.x(pair$0) in -- #22
+//│         let x$5 = +(x$3,1) in -- #21
+//│         jump j$0(x$5) -- #20
+//│   def j$0(x$2) =
+//│     x$2 -- #5
+//│   def foo() =
+//│     let x$6 = Pair(0,1) in -- #37
+//│     let* (x$7) = inc_fst(x$6) in -- #36
+//│     x$7 -- #35
+//│   let* (x$0) = foo() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ 2
+//│ 
 
 :interpIR
-class Left(x)
-class Right(y)
 fun foo(a, b) =
   let t = if a is
     Left(x) then Left(x + 1)
@@ -234,132 +239,81 @@ fun foo(a, b) =
 fun bar() =
   foo(Right(2), 2)
 bar()
-//│ |#class| |Left|(|x|)|↵|#class| |Right|(|y|)|↵|#fun| |foo|(|a|,| |b|)| |#=|→|#let| |t| |#=| |#if| |a| |is|→|Left|(|x|)| |#then| |Left|(|x| |+| |1|)|↵|Right|(|y|)| |#then| |Right|(|b|)|←|↵|#if| |t| |is|→|Left|(|x|)| |#then| |x|↵|Right|(|y|)| |#then| |y|←|←|↵|#fun| |bar|(||)| |#=|→|foo|(|Right|(|2|)|,| |2|)|←|↵|bar|(||)|
-//│ Parsed: {class Left(x,) {}; class Right(y,) {}; fun foo = (a, b,) => {let t = if a is ‹(Left(x,)) then Left(+(x,)(1,),); (Right(y,)) then Right(b,)›; if t is ‹(Left(x,)) then x; (Right(y,)) then y›}; fun bar = () => {foo(Right(2,), 2,)}; bar()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Left, [x]),ClassInfo(3, Right, [y])}, {
-//│ Def(0, foo, [a$0,b$0],
-//│ 1, 
-//│ case a$0 of -- #36
-//│   Left =>
-//│     let x$4 = a$0.x in -- #26
-//│     let x$5 = +(x$4,1) in -- #25
-//│     let x$6 = Left(x$5) in -- #24
-//│     jump j$0(x$6) -- #23
-//│   Right =>
-//│     let x$7 = a$0.y in -- #35
-//│     let x$8 = Right(b$0) in -- #34
-//│     jump j$0(x$8) -- #33
-//│ )
-//│ Def(1, j$1, [x$1],
-//│ 1, 
-//│ x$1 -- #3
-//│ )
-//│ Def(2, j$0, [x$0],
-//│ 1, 
-//│ case x$0 of -- #14
-//│   Left =>
-//│     let x$2 = x$0.x in -- #8
-//│     jump j$1(x$2) -- #7
-//│   Right =>
-//│     let x$3 = x$0.y in -- #13
-//│     jump j$1(x$3) -- #12
-//│ )
-//│ Def(3, bar, [],
-//│ 1, 
-//│ let x$9 = Right(2) in -- #48
-//│ let* (x$10) = foo(x$9,2) in -- #47
-//│ x$10 -- #46
-//│ )
-//│ },
-//│ let* (x$11) = bar() in -- #52
-//│ x$11 -- #51)
+//│ |#fun| |foo|(|a|,| |b|)| |#=|→|#let| |t| |#=| |#if| |a| |is|→|Left|(|x|)| |#then| |Left|(|x| |+| |1|)|↵|Right|(|y|)| |#then| |Right|(|b|)|←|↵|#if| |t| |is|→|Left|(|x|)| |#then| |x|↵|Right|(|y|)| |#then| |y|←|←|↵|#fun| |bar|(||)| |#=|→|foo|(|Right|(|2|)|,| |2|)|←|↵|bar|(||)|
+//│ Parsed: {fun foo = (a, b,) => {let t = if a is ‹(Left(x,)) then Left(+(x, 1,),); (Right(y,)) then Right(b,)›; if t is ‹(Left(x,)) then x; (Right(y,)) then y›}; fun bar = () => {foo(Right(2,), 2,)}; bar()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def foo(a$0,b$0) =
+//│     case a$0 of -- #50
+//│       Left =>
+//│         let x$5 = Left.x(a$0) in -- #38
+//│         let x$6 = +(x$5,1) in -- #37
+//│         let x$7 = Left(x$6) in -- #36
+//│         jump j$0(x$7) -- #35
+//│       Right =>
+//│         let x$8 = Right.y(a$0) in -- #49
+//│         let x$9 = Right(b$0) in -- #48
+//│         jump j$0(x$9) -- #47
+//│   def j$1(x$2) =
+//│     x$2 -- #6
+//│   def j$0(x$1) =
+//│     case x$1 of -- #21
+//│       Left =>
+//│         let x$3 = Left.x(x$1) in -- #13
+//│         jump j$1(x$3) -- #12
+//│       Right =>
+//│         let x$4 = Right.y(x$1) in -- #20
+//│         jump j$1(x$4) -- #19
+//│   def bar() =
+//│     let x$10 = Right(2) in -- #61
+//│     let* (x$11) = foo(x$10,2) in -- #60
+//│     x$11 -- #59
+//│   let* (x$0) = bar() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ 2
+//│ 
 
 :interpIR
-class Pair(x, y)
-fun foo(a) = a.x + a.y
+fun foo(a) = Pair.x(a) + Pair.y(a)
 fun bar() =
   foo(Pair(1, 0))
 bar()
-//│ |#class| |Pair|(|x|,| |y|)|↵|#fun| |foo|(|a|)| |#=| |a|.x| |+| |a|.y|↵|#fun| |bar|(||)| |#=|→|foo|(|Pair|(|1|,| |0|)|)|←|↵|bar|(||)|
-//│ Parsed: {class Pair(x, y,) {}; fun foo = (a,) => +((a).x,)((a).y,); fun bar = () => {foo(Pair(1, 0,),)}; bar()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Pair, [x,y])}, {
-//│ Def(0, foo, [a$0],
-//│ 1, 
-//│ let x$0 = a$0.x in -- #7
-//│ let x$1 = a$0.y in -- #6
-//│ let x$2 = +(x$0,x$1) in -- #5
-//│ x$2 -- #4
-//│ )
-//│ Def(1, bar, [],
-//│ 1, 
-//│ let x$3 = Pair(1,0) in -- #19
-//│ let* (x$4) = foo(x$3) in -- #18
-//│ x$4 -- #17
-//│ )
-//│ },
-//│ let* (x$5) = bar() in -- #23
-//│ x$5 -- #22)
+//│ |#fun| |foo|(|a|)| |#=| |Pair|.x|(|a|)| |+| |Pair|.y|(|a|)|↵|#fun| |bar|(||)| |#=|→|foo|(|Pair|(|1|,| |0|)|)|←|↵|bar|(||)|
+//│ Parsed: {fun foo = (a,) => +((Pair).x(a,), (Pair).y(a,),); fun bar = () => {foo(Pair(1, 0,),)}; bar()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def foo(a$0) =
+//│     let x$1 = Pair.x(a$0) in -- #17
+//│     let x$2 = Pair.y(a$0) in -- #16
+//│     let x$3 = +(x$1,x$2) in -- #15
+//│     x$3 -- #14
+//│   def bar() =
+//│     let x$4 = Pair(1,0) in -- #28
+//│     let* (x$5) = foo(x$4) in -- #27
+//│     x$5 -- #26
+//│   let* (x$0) = bar() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ 1
+//│ 
 
 
-:interpIR
-class C1(x, y)
-class C2(z)
-fun foo(a) = if a is
-  C1(x, y) then x
-  C2(z) then z
-fun bar() =
-  foo(C1(0, 1))
-bar()
-//│ |#class| |C1|(|x|,| |y|)|↵|#class| |C2|(|z|)|↵|#fun| |foo|(|a|)| |#=| |#if| |a| |is|→|C1|(|x|,| |y|)| |#then| |x|↵|C2|(|z|)| |#then| |z|←|↵|#fun| |bar|(||)| |#=|→|foo|(|C1|(|0|,| |1|)|)|←|↵|bar|(||)|
-//│ Parsed: {class C1(x, y,) {}; class C2(z,) {}; fun foo = (a,) => if a is ‹(C1(x, y,)) then x; (C2(z,)) then z›; fun bar = () => {foo(C1(0, 1,),)}; bar()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, C1, [x,y]),ClassInfo(3, C2, [z])}, {
-//│ Def(0, foo, [a$0],
-//│ 1, 
-//│ case a$0 of -- #15
-//│   C1 =>
-//│     let x$1 = a$0.y in -- #9
-//│     let x$2 = a$0.x in -- #8
-//│     jump j$0(x$2) -- #7
-//│   C2 =>
-//│     let x$3 = a$0.z in -- #14
-//│     jump j$0(x$3) -- #13
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, bar, [],
-//│ 1, 
-//│ let x$4 = C1(0,1) in -- #27
-//│ let* (x$5) = foo(x$4) in -- #26
-//│ x$5 -- #25
-//│ )
-//│ },
-//│ let* (x$6) = bar() in -- #31
-//│ x$6 -- #30)
-//│ 
-//│ Interpreted:
-//│ 0
 
 :interpIR
-class Pair(x, y)
 fun foo(a, b) =
-  let x1 = a.x
-  let y1 = a.y
-  let x2 = b.x
-  let y2 = b.y
+  let x1 = Pair.x(a)
+  let y1 = Pair.y(a)
+  let x2 = Pair.x(b)
+  let y2 = Pair.y(b)
   x1 + y1 + x2 + y2
 fun bar(c) =
   foo(Pair(0, 1), c)
@@ -368,74 +322,67 @@ fun bar(c) =
 fun baz() =
   bar(Pair(4,5))
 baz()
-//│ |#class| |Pair|(|x|,| |y|)|↵|#fun| |foo|(|a|,| |b|)| |#=|→|#let| |x1| |#=| |a|.x|↵|#let| |y1| |#=| |a|.y|↵|#let| |x2| |#=| |b|.x|↵|#let| |y2| |#=| |b|.y|↵|x1| |+| |y1| |+| |x2| |+| |y2|←|↵|#fun| |bar|(|c|)| |#=|→|foo|(|Pair|(|0|,| |1|)|,| |c|)|↵|foo|(|c|,| |Pair|(|2|,| |3|)|)|↵|foo|(|Pair|(|0|,| |1|)|,| |Pair|(|2|,| |3|)|)|←|↵|#fun| |baz|(||)| |#=|→|bar|(|Pair|(|4|,|5|)|)|←|↵|baz|(||)|
-//│ Parsed: {class Pair(x, y,) {}; fun foo = (a, b,) => {let x1 = (a).x; let y1 = (a).y; let x2 = (b).x; let y2 = (b).y; +(+(+(x1,)(y1,),)(x2,),)(y2,)}; fun bar = (c,) => {foo(Pair(0, 1,), c,); foo(c, Pair(2, 3,),); foo(Pair(0, 1,), Pair(2, 3,),)}; fun baz = () => {bar(Pair(4, 5,),)}; baz()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Pair, [x,y])}, {
-//│ Def(0, foo, [a$0,b$0],
-//│ 1, 
-//│ let x$0 = a$0.x in -- #21
-//│ let x$1 = a$0.y in -- #20
-//│ let x$2 = b$0.x in -- #19
-//│ let x$3 = b$0.y in -- #18
-//│ let x$4 = +(x$0,x$1) in -- #17
-//│ let x$5 = +(x$4,x$2) in -- #16
-//│ let x$6 = +(x$5,x$3) in -- #15
-//│ x$6 -- #14
-//│ )
-//│ Def(1, bar, [c$0],
-//│ 1, 
-//│ let x$7 = Pair(0,1) in -- #69
-//│ let* (x$8) = foo(x$7,c$0) in -- #68
-//│ let x$9 = Pair(2,3) in -- #67
-//│ let* (x$10) = foo(c$0,x$9) in -- #66
-//│ let x$11 = Pair(0,1) in -- #65
-//│ let x$12 = Pair(2,3) in -- #64
-//│ let* (x$13) = foo(x$11,x$12) in -- #63
-//│ x$13 -- #62
-//│ )
-//│ Def(2, baz, [],
-//│ 1, 
-//│ let x$14 = Pair(4,5) in -- #81
-//│ let* (x$15) = bar(x$14) in -- #80
-//│ x$15 -- #79
-//│ )
-//│ },
-//│ let* (x$16) = baz() in -- #85
-//│ x$16 -- #84)
+//│ |#fun| |foo|(|a|,| |b|)| |#=|→|#let| |x1| |#=| |Pair|.x|(|a|)|↵|#let| |y1| |#=| |Pair|.y|(|a|)|↵|#let| |x2| |#=| |Pair|.x|(|b|)|↵|#let| |y2| |#=| |Pair|.y|(|b|)|↵|x1| |+| |y1| |+| |x2| |+| |y2|←|↵|#fun| |bar|(|c|)| |#=|→|foo|(|Pair|(|0|,| |1|)|,| |c|)|↵|foo|(|c|,| |Pair|(|2|,| |3|)|)|↵|foo|(|Pair|(|0|,| |1|)|,| |Pair|(|2|,| |3|)|)|←|↵|#fun| |baz|(||)| |#=|→|bar|(|Pair|(|4|,|5|)|)|←|↵|baz|(||)|
+//│ Parsed: {fun foo = (a, b,) => {let x1 = (Pair).x(a,); let y1 = (Pair).y(a,); let x2 = (Pair).x(b,); let y2 = (Pair).y(b,); +(+(+(x1, y1,), x2,), y2,)}; fun bar = (c,) => {foo(Pair(0, 1,), c,); foo(c, Pair(2, 3,),); foo(Pair(0, 1,), Pair(2, 3,),)}; fun baz = () => {bar(Pair(4, 5,),)}; baz()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def foo(a$0,b$0) =
+//│     let x$1 = Pair.x(a$0) in -- #41
+//│     let x$2 = Pair.y(a$0) in -- #40
+//│     let x$3 = Pair.x(b$0) in -- #39
+//│     let x$4 = Pair.y(b$0) in -- #38
+//│     let x$5 = +(x$1,x$2) in -- #37
+//│     let x$6 = +(x$5,x$3) in -- #36
+//│     let x$7 = +(x$6,x$4) in -- #35
+//│     x$7 -- #34
+//│   def bar(c$0) =
+//│     let x$8 = Pair(0,1) in -- #86
+//│     let* (x$9) = foo(x$8,c$0) in -- #85
+//│     let x$10 = Pair(2,3) in -- #84
+//│     let* (x$11) = foo(c$0,x$10) in -- #83
+//│     let x$12 = Pair(0,1) in -- #82
+//│     let x$13 = Pair(2,3) in -- #81
+//│     let* (x$14) = foo(x$12,x$13) in -- #80
+//│     x$14 -- #79
+//│   def baz() =
+//│     let x$15 = Pair(4,5) in -- #97
+//│     let* (x$16) = bar(x$15) in -- #96
+//│     x$16 -- #95
+//│   let* (x$0) = baz() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ 6
+//│ 
 
 :interpIR
-class Pair(x, y)
 fun foo() =
   let p = Pair(0, 1)
-  let b = p.x
+  let b = Pair.x(p)
   b
 foo()
-//│ |#class| |Pair|(|x|,| |y|)|↵|#fun| |foo|(||)| |#=|→|#let| |p| |#=| |Pair|(|0|,| |1|)|↵|#let| |b| |#=| |p|.x|↵|b|←|↵|foo|(||)|
-//│ Parsed: {class Pair(x, y,) {}; fun foo = () => {let p = Pair(0, 1,); let b = (p).x; b}; foo()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Pair, [x,y])}, {
-//│ Def(0, foo, [],
-//│ 1, 
-//│ let x$0 = Pair(0,1) in -- #10
-//│ let x$1 = x$0.x in -- #9
-//│ x$1 -- #8
-//│ )
-//│ },
-//│ let* (x$2) = foo() in -- #14
-//│ x$2 -- #13)
+//│ |#fun| |foo|(||)| |#=|→|#let| |p| |#=| |Pair|(|0|,| |1|)|↵|#let| |b| |#=| |Pair|.x|(|p|)|↵|b|←|↵|foo|(||)|
+//│ Parsed: {fun foo = () => {let p = Pair(0, 1,); let b = (Pair).x(p,); b}; foo()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def foo() =
+//│     let x$1 = Pair(0,1) in -- #15
+//│     let x$2 = Pair.x(x$1) in -- #14
+//│     x$2 -- #13
+//│   let* (x$0) = foo() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ 0
+//│ 
 
 :interpIR
-class S(s)
-class O
 fun foo() =
   bar(S(O))
 fun bar(x) =
@@ -445,39 +392,33 @@ fun baz(x) =
     S(s) then s
     O then x
 foo()
-//│ |#class| |S|(|s|)|↵|#class| |O|↵|#fun| |foo|(||)| |#=|→|bar|(|S|(|O|)|)|←|↵|#fun| |bar|(|x|)| |#=|→|baz|(|x|)|←|↵|#fun| |baz|(|x|)| |#=|→|#if| |x| |is|→|S|(|s|)| |#then| |s|↵|O| |#then| |x|←|←|↵|foo|(||)|
-//│ Parsed: {class S(s,) {}; class O {}; fun foo = () => {bar(S(O,),)}; fun bar = (x,) => {baz(x,)}; fun baz = (x,) => {if x is ‹(S(s,)) then s; (O) then x›}; foo()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, S, [s]),ClassInfo(3, O, [])}, {
-//│ Def(0, foo, [],
-//│ 1, 
-//│ let x$0 = O() in -- #10
-//│ let x$1 = S(x$0) in -- #9
-//│ let* (x$2) = bar(x$1) in -- #8
-//│ x$2 -- #7
-//│ )
-//│ Def(1, bar, [x$3],
-//│ 1, 
-//│ let* (x$4) = baz(x$3) in -- #16
-//│ x$4 -- #15
-//│ )
-//│ Def(2, baz, [x$5],
-//│ 1, 
-//│ case x$5 of -- #26
-//│   S =>
-//│     let x$7 = x$5.s in -- #23
-//│     jump j$0(x$7) -- #22
-//│   O =>
-//│     jump j$0(x$5) -- #25
-//│ )
-//│ Def(3, j$0, [x$6],
-//│ 1, 
-//│ x$6 -- #18
-//│ )
-//│ },
-//│ let* (x$8) = foo() in -- #30
-//│ x$8 -- #29)
+//│ |#fun| |foo|(||)| |#=|→|bar|(|S|(|O|)|)|←|↵|#fun| |bar|(|x|)| |#=|→|baz|(|x|)|←|↵|#fun| |baz|(|x|)| |#=|→|#if| |x| |is|→|S|(|s|)| |#then| |s|↵|O| |#then| |x|←|←|↵|foo|(||)|
+//│ Parsed: {fun foo = () => {bar(S(O,),)}; fun bar = (x,) => {baz(x,)}; fun baz = (x,) => {if x is ‹(S(s,)) then s; (O) then x›}; foo()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def foo() =
+//│     let x$1 = O() in -- #12
+//│     let x$2 = S(x$1) in -- #11
+//│     let* (x$3) = bar(x$2) in -- #10
+//│     x$3 -- #9
+//│   def bar(x$4) =
+//│     let* (x$5) = baz(x$4) in -- #17
+//│     x$5 -- #16
+//│   def baz(x$6) =
+//│     case x$6 of -- #29
+//│       S =>
+//│         let x$8 = S.s(x$6) in -- #26
+//│         jump j$0(x$8) -- #25
+//│       O =>
+//│         jump j$0(x$6) -- #28
+//│   def j$0(x$7) =
+//│     x$7 -- #19
+//│   let* (x$0) = foo() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ O()
+//│ 
diff --git a/compiler/shared/test/diff-ir/IRComplex.mls b/compiler/shared/test/diff-ir/IRComplex.mls
index e6df8a88ec..5e270c3d18 100644
--- a/compiler/shared/test/diff-ir/IRComplex.mls
+++ b/compiler/shared/test/diff-ir/IRComplex.mls
@@ -1,8 +1,38 @@
-:NewParser
+:NewDefs
 :ParseOnly
 :UseIR
 :NoTailRec
 
+:prelude
+module True
+module False
+module Callable {
+  fun apply0() = 0
+  fun apply1(x0) = 0
+  fun apply2(x0,x1) = 0
+  fun apply3(x0,x1,x2) = 0
+  fun apply4(x0,x1,x2,x3) = 0
+  fun apply5(x0,x1,x2,x3,x4) = 0
+}
+module List[A, B]
+class Cons[A, B](h: A, t: Cons[A, B]) extends List[A, B]
+module Nil[A, B] extends List[A, B]
+module Option[A]
+class Some[A](x: A) extends Option[A]
+module None[A] extends Option[A]
+class Pair[A, B](x: A, y: B)
+class Tuple2[A, B](x: A, y: B)
+class Tuple3[A, B, C](x: A, y: B, z: C)
+module Nat
+class S(s: Nat) extends Nat
+module O extends Nat
+class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O)
+//│ |#module| |True|↵|#module| |False|↵|#module| |Callable| |{|→|#fun| |apply0|(||)| |#=| |0|↵|#fun| |apply1|(|x0|)| |#=| |0|↵|#fun| |apply2|(|x0|,|x1|)| |#=| |0|↵|#fun| |apply3|(|x0|,|x1|,|x2|)| |#=| |0|↵|#fun| |apply4|(|x0|,|x1|,|x2|,|x3|)| |#=| |0|↵|#fun| |apply5|(|x0|,|x1|,|x2|,|x3|,|x4|)| |#=| |0|←|↵|}|↵|#module| |List|[|A|,| |B|]|↵|#class| |Cons|[|A|,| |B|]|(|h|#:| |A|,| |t|#:| |Cons|[|A|,| |B|]|)| |#extends| |List|[|A|,| |B|]|↵|#module| |Nil|[|A|,| |B|]| |#extends| |List|[|A|,| |B|]|↵|#module| |Option|[|A|]|↵|#class| |Some|[|A|]|(|x|#:| |A|)| |#extends| |Option|[|A|]|↵|#module| |None|[|A|]| |#extends| |Option|[|A|]|↵|#class| |Pair|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple2|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple3|[|A|,| |B|,| |C|]|(|x|#:| |A|,| |y|#:| |B|,| |z|#:| |C|)|↵|#module| |Nat|↵|#class| |S|(|s|#:| |Nat|)| |#extends| |Nat|↵|#module| |O| |#extends| |Nat|↵|#class| |HiddenTheseEntities|(|_0|#:| |HiddenTheseEntities|,| |_1|#:| |True|,| |_2|#:| |False|,| |_3|#:| |Callable|,| |_4|#:| |List|,| |_5|#:| |Cons|,| |_6|#:| |Nil|,| |_7|#:| |Option|,| |_8|#:| |Some|,| |_9|#:| |None|,| |_10|#:| |Pair|,| |_11|#:| |Tuple2|,| |_12|#:| |Tuple3|,| |_13|#:| |Nat|,| |_14|#:| |S|,| |_15|#:| |O|)|
+//│ Parsed: {module True {}; module False {}; module Callable {fun apply0 = () => 0; fun apply1 = (x0,) => 0; fun apply2 = (x0, x1,) => 0; fun apply3 = (x0, x1, x2,) => 0; fun apply4 = (x0, x1, x2, x3,) => 0; fun apply5 = (x0, x1, x2, x3, x4,) => 0}; module List‹A, B› {}; class Cons‹A, B›(h: A, t: Cons‹A, B›,): List‹A, B› {}; module Nil‹A, B›: List‹A, B› {}; module Option‹A› {}; class Some‹A›(x: A,): Option‹A› {}; module None‹A›: Option‹A› {}; class Pair‹A, B›(x: A, y: B,) {}; class Tuple2‹A, B›(x: A, y: B,) {}; class Tuple3‹A, B, C›(x: A, y: B, z: C,) {}; module Nat {}; class S(s: Nat,): Nat {}; module O: Nat {}; class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O,) {}}
+//│ 
+//│ Preluded.
+//│ 
+
 :interpIR
 class A(x, y, z)
 class B(m, n)
@@ -20,59 +50,54 @@ fun bar() =
   complex_foo(B(9, 10))
 bar()
 //│ |#class| |A|(|x|,| |y|,| |z|)|↵|#class| |B|(|m|,| |n|)|↵|#fun| |complex_foo|(|t|)| |#=|→|#let| |r| |#=| |#if| |t| |is|→|A|(|x|,| |y|,| |z|)| |#then| |x| |+| |y| |*| |z|↵|B|(|m|,| |n|)| |#then| |m| |-| |n|←|↵|#let| |s| |#=| |B|(|1|,| |2|)|↵|#let| |u| |#=| |#if| |s| |is|→|A|(|x|,| |y|,| |z|)| |#then| |3|↵|B|(|m|,| |n|)| |#then| |4|←|↵|r| |+| |u|←|↵|#fun| |bar|(||)| |#=|→|complex_foo|(|A|(|6|,| |7|,| |8|)|)|↵|complex_foo|(|B|(|9|,| |10|)|)|←|↵|bar|(||)|
-//│ Parsed: {class A(x, y, z,) {}; class B(m, n,) {}; fun complex_foo = (t,) => {let r = if t is ‹(A(x, y, z,)) then +(x,)(*(y,)(z,),); (B(m, n,)) then -(m,)(n,)›; let s = B(1, 2,); let u = if s is ‹(A(x, y, z,)) then 3; (B(m, n,)) then 4›; +(r,)(u,)}; fun bar = () => {complex_foo(A(6, 7, 8,),); complex_foo(B(9, 10,),)}; bar()}
+//│ Parsed: {class A(x, y, z,) {}; class B(m, n,) {}; fun complex_foo = (t,) => {let r = if t is ‹(A(x, y, z,)) then +(x, *(y, z,),); (B(m, n,)) then -(m, n,)›; let s = B(1, 2,); let u = if s is ‹(A(x, y, z,)) then 3; (B(m, n,)) then 4›; +(r, u,)}; fun bar = () => {complex_foo(A(6, 7, 8,),); complex_foo(B(9, 10,),)}; bar()}
 //│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [x,y,z]),ClassInfo(3, B, [m,n])}, {
-//│ Def(0, complex_foo, [t$0],
-//│ 1, 
-//│ case t$0 of -- #63
-//│   A =>
-//│     let x$9 = t$0.z in -- #51
-//│     let x$10 = t$0.y in -- #50
-//│     let x$11 = t$0.x in -- #49
-//│     let x$12 = *(x$10,x$9) in -- #48
-//│     let x$13 = +(x$11,x$12) in -- #47
-//│     jump j$0(x$13) -- #46
-//│   B =>
-//│     let x$14 = t$0.n in -- #62
-//│     let x$15 = t$0.m in -- #61
-//│     let x$16 = -(x$15,x$14) in -- #60
-//│     jump j$0(x$16) -- #59
-//│ )
-//│ Def(1, j$1, [x$2,x$0],
-//│ 1, 
-//│ let x$3 = +(x$0,x$2) in -- #13
-//│ x$3 -- #12
-//│ )
-//│ Def(2, j$0, [x$0],
-//│ 1, 
-//│ let x$1 = B(1,2) in -- #34
-//│ case x$1 of -- #33
-//│   A =>
-//│     let x$4 = x$1.z in -- #24
-//│     let x$5 = x$1.y in -- #23
-//│     let x$6 = x$1.x in -- #22
-//│     jump j$1(3,x$0) -- #21
-//│   B =>
-//│     let x$7 = x$1.n in -- #32
-//│     let x$8 = x$1.m in -- #31
-//│     jump j$1(4,x$0) -- #30
-//│ )
-//│ Def(3, bar, [],
-//│ 1, 
-//│ let x$17 = A(6,7,8) in -- #89
-//│ let* (x$18) = complex_foo(x$17) in -- #88
-//│ let x$19 = B(9,10) in -- #87
-//│ let* (x$20) = complex_foo(x$19) in -- #86
-//│ x$20 -- #85
-//│ )
-//│ },
-//│ let* (x$21) = bar() in -- #93
-//│ x$21 -- #92)
+//│ 
+//│ IR:
+//│ Program:
+//│   class A(x,y,z)
+//│   class B(m,n)
+//│   def complex_foo(t$0) =
+//│     case t$0 of -- #98
+//│       A =>
+//│         let x$10 = A.z(t$0) in -- #79
+//│         let x$11 = A.y(t$0) in -- #78
+//│         let x$12 = A.x(t$0) in -- #77
+//│         let x$13 = *(x$11,x$10) in -- #76
+//│         let x$14 = +(x$12,x$13) in -- #75
+//│         jump j$0(x$14) -- #74
+//│       B =>
+//│         let x$15 = B.n(t$0) in -- #97
+//│         let x$16 = B.m(t$0) in -- #96
+//│         let x$17 = -(x$16,x$15) in -- #95
+//│         jump j$0(x$17) -- #94
+//│   def j$1(x$3,x$1) =
+//│     let x$4 = +(x$1,x$3) in -- #19
+//│     x$4 -- #18
+//│   def j$0(x$1) =
+//│     let x$2 = B(1,2) in -- #50
+//│     case x$2 of -- #49
+//│       A =>
+//│         let x$5 = A.z(x$2) in -- #36
+//│         let x$6 = A.y(x$2) in -- #35
+//│         let x$7 = A.x(x$2) in -- #34
+//│         jump j$1(3,x$1) -- #33
+//│       B =>
+//│         let x$8 = B.n(x$2) in -- #48
+//│         let x$9 = B.m(x$2) in -- #47
+//│         jump j$1(4,x$1) -- #46
+//│   def bar() =
+//│     let x$18 = A(6,7,8) in -- #122
+//│     let* (x$19) = complex_foo(x$18) in -- #121
+//│     let x$20 = B(9,10) in -- #120
+//│     let* (x$21) = complex_foo(x$20) in -- #119
+//│     x$21 -- #118
+//│   let* (x$0) = bar() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ 3
+//│ 
 
 :interpIR
 class A(w, x)
@@ -108,107 +133,97 @@ fun bar() =
   complex_foo(A(10, A(9, B(10))))
 bar()
 //│ |#class| |A|(|w|,| |x|)|↵|#class| |B|(|y|)|↵|#class| |C|(|z|)|↵|#fun| |complex_foo|(|t|)| |#=|→|#let| |a| |#=| |1| |+| |2|↵|#let| |b| |#=| |1| |*| |2|↵|#let| |x| |#=| |#if| |t| |is|→|A|(|x|,| |y|)| |#then| |y|↵|B|(|x|)| |#then| |B|(|x| |+| |b|)|↵|C|(|x|)| |#then| |C|(|0|)|←|↵|#let| |z| |#=| |A|(|5|,| |x|)|↵|#let| |v| |#=| |B|(|6|)|↵|#let| |y| |#=| |#if| |x| |is|→|A|(|x|,| |y|)| |#then|→|#let| |m| |#=| |x| |+| |a| |+| |b|↵|#if| |y| |is|→|A|(|x|,| |y|)| |#then| |x|↵|B|(|x|)| |#then| |m|↵|C|(|x|)| |#then| |0|←|←|↵|B|(|x|)| |#then| |2|↵|C|(|x|)| |#then| |3|←|↵|#if| |z| |is|→|A|(|x|,| |y|)| |#then| |x|↵|B|(|x|)| |#then| |4|↵|C|(|x|)| |#then|→|#if| |v| |is|→|A|(|x|,| |y|)| |#then| |x|↵|B|(|x|)| |#then| |7|↵|C|(|x|)| |#then| |8|←|←|←|←|↵|#fun| |bar|(||)| |#=|→|complex_foo|(|A|(|10|,| |A|(|9|,| |B|(|10|)|)|)|)|←|↵|bar|(||)|
-//│ Parsed: {class A(w, x,) {}; class B(y,) {}; class C(z,) {}; fun complex_foo = (t,) => {let a = +(1,)(2,); let b = *(1,)(2,); let x = if t is ‹(A(x, y,)) then y; (B(x,)) then B(+(x,)(b,),); (C(x,)) then C(0,)›; let z = A(5, x,); let v = B(6,); let y = if x is ‹(A(x, y,)) then {let m = +(+(x,)(a,),)(b,); if y is ‹(A(x, y,)) then x; (B(x,)) then m; (C(x,)) then 0›}; (B(x,)) then 2; (C(x,)) then 3›; if z is ‹(A(x, y,)) then x; (B(x,)) then 4; (C(x,)) then {if v is ‹(A(x, y,)) then x; (B(x,)) then 7; (C(x,)) then 8›}›}; fun bar = () => {complex_foo(A(10, A(9, B(10,),),),)}; bar()}
+//│ Parsed: {class A(w, x,) {}; class B(y,) {}; class C(z,) {}; fun complex_foo = (t,) => {let a = +(1, 2,); let b = *(1, 2,); let x = if t is ‹(A(x, y,)) then y; (B(x,)) then B(+(x, b,),); (C(x,)) then C(0,)›; let z = A(5, x,); let v = B(6,); let y = if x is ‹(A(x, y,)) then {let m = +(+(x, a,), b,); if y is ‹(A(x, y,)) then x; (B(x,)) then m; (C(x,)) then 0›}; (B(x,)) then 2; (C(x,)) then 3›; if z is ‹(A(x, y,)) then x; (B(x,)) then 4; (C(x,)) then {if v is ‹(A(x, y,)) then x; (B(x,)) then 7; (C(x,)) then 8›}›}; fun bar = () => {complex_foo(A(10, A(9, B(10,),),),)}; bar()}
+//│ 
 //│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [w,x]),ClassInfo(3, B, [y]),ClassInfo(4, C, [z])}, {
-//│ Def(0, complex_foo, [t$0],
-//│ 1, 
-//│ let x$0 = +(1,2) in -- #140
-//│ let x$1 = *(1,2) in -- #139
-//│ case t$0 of -- #138
-//│   A =>
-//│     let x$27 = t$0.x in -- #116
-//│     let x$28 = t$0.w in -- #115
-//│     jump j$0(x$27,x$0,x$1) -- #114
-//│   B =>
-//│     let x$29 = t$0.y in -- #128
-//│     let x$30 = +(x$29,x$1) in -- #127
-//│     let x$31 = B(x$30) in -- #126
-//│     jump j$0(x$31,x$0,x$1) -- #125
-//│   C =>
-//│     let x$32 = t$0.z in -- #137
-//│     let x$33 = C(0) in -- #136
-//│     jump j$0(x$33,x$0,x$1) -- #135
-//│ )
-//│ Def(1, j$2, [x$6],
-//│ 1, 
-//│ x$6 -- #21
-//│ )
-//│ Def(2, j$3, [x$11],
-//│ 1, 
-//│ jump j$2(x$11) -- #39
-//│ )
-//│ Def(3, j$1, [x$5,x$3,x$4],
-//│ 1, 
-//│ case x$3 of -- #60
-//│   A =>
-//│     let x$7 = x$3.x in -- #29
-//│     let x$8 = x$3.w in -- #28
-//│     jump j$2(x$8) -- #27
-//│   B =>
-//│     let x$9 = x$3.y in -- #34
-//│     jump j$2(4) -- #33
-//│   C =>
-//│     let x$10 = x$3.z in -- #59
-//│     case x$4 of -- #58
+//│ IR:
+//│ Program:
+//│   class A(w,x)
+//│   class B(y)
+//│   class C(z)
+//│   def complex_foo(t$0) =
+//│     let x$1 = +(1,2) in -- #198
+//│     let x$2 = *(1,2) in -- #197
+//│     case t$0 of -- #196
 //│       A =>
-//│         let x$12 = x$4.x in -- #47
-//│         let x$13 = x$4.w in -- #46
-//│         jump j$3(x$13) -- #45
+//│         let x$28 = A.x(t$0) in -- #167
+//│         let x$29 = A.w(t$0) in -- #166
+//│         jump j$0(x$28,x$1,x$2) -- #165
 //│       B =>
-//│         let x$14 = x$4.y in -- #52
-//│         jump j$3(7) -- #51
+//│         let x$30 = B.y(t$0) in -- #184
+//│         let x$31 = +(x$30,x$2) in -- #183
+//│         let x$32 = B(x$31) in -- #182
+//│         jump j$0(x$32,x$1,x$2) -- #181
 //│       C =>
-//│         let x$15 = x$4.z in -- #57
-//│         jump j$3(8) -- #56
-//│ )
-//│ Def(4, j$4, [x$20,x$3,x$4],
-//│ 1, 
-//│ jump j$1(x$20,x$3,x$4) -- #72
-//│ )
-//│ Def(5, j$0, [x$2,x$0,x$1],
-//│ 1, 
-//│ let x$3 = A(5,x$2) in -- #108
-//│ let x$4 = B(6) in -- #107
-//│ case x$2 of -- #106
-//│   A =>
-//│     let x$16 = x$2.x in -- #95
-//│     let x$17 = x$2.w in -- #94
-//│     let x$18 = +(x$17,x$0) in -- #93
-//│     let x$19 = +(x$18,x$1) in -- #92
-//│     case x$16 of -- #91
+//│         let x$33 = C.z(t$0) in -- #195
+//│         let x$34 = C(0) in -- #194
+//│         jump j$0(x$34,x$1,x$2) -- #193
+//│   def j$2(x$7) =
+//│     x$7 -- #30
+//│   def j$3(x$12) =
+//│     jump j$2(x$12) -- #56
+//│   def j$1(x$6,x$4,x$5) =
+//│     case x$4 of -- #85
 //│       A =>
-//│         let x$21 = x$16.x in -- #80
-//│         let x$22 = x$16.w in -- #79
-//│         jump j$4(x$22,x$3,x$4) -- #78
+//│         let x$8 = A.x(x$4) in -- #42
+//│         let x$9 = A.w(x$4) in -- #41
+//│         jump j$2(x$9) -- #40
 //│       B =>
-//│         let x$23 = x$16.y in -- #85
-//│         jump j$4(x$19,x$3,x$4) -- #84
+//│         let x$10 = B.y(x$4) in -- #49
+//│         jump j$2(4) -- #48
 //│       C =>
-//│         let x$24 = x$16.z in -- #90
-//│         jump j$4(0,x$3,x$4) -- #89
-//│   B =>
-//│     let x$25 = x$2.y in -- #100
-//│     jump j$1(2,x$3,x$4) -- #99
-//│   C =>
-//│     let x$26 = x$2.z in -- #105
-//│     jump j$1(3,x$3,x$4) -- #104
-//│ )
-//│ Def(6, bar, [],
-//│ 1, 
-//│ let x$34 = B(10) in -- #162
-//│ let x$35 = A(9,x$34) in -- #161
-//│ let x$36 = A(10,x$35) in -- #160
-//│ let* (x$37) = complex_foo(x$36) in -- #159
-//│ x$37 -- #158
-//│ )
-//│ },
-//│ let* (x$38) = bar() in -- #166
-//│ x$38 -- #165)
+//│         let x$11 = C.z(x$4) in -- #84
+//│         case x$5 of -- #83
+//│           A =>
+//│             let x$13 = A.x(x$5) in -- #68
+//│             let x$14 = A.w(x$5) in -- #67
+//│             jump j$3(x$14) -- #66
+//│           B =>
+//│             let x$15 = B.y(x$5) in -- #75
+//│             jump j$3(7) -- #74
+//│           C =>
+//│             let x$16 = C.z(x$5) in -- #82
+//│             jump j$3(8) -- #81
+//│   def j$4(x$21,x$4,x$5) =
+//│     jump j$1(x$21,x$4,x$5) -- #107
+//│   def j$0(x$3,x$1,x$2) =
+//│     let x$4 = A(5,x$3) in -- #155
+//│     let x$5 = B(6) in -- #154
+//│     case x$3 of -- #153
+//│       A =>
+//│         let x$17 = A.x(x$3) in -- #138
+//│         let x$18 = A.w(x$3) in -- #137
+//│         let x$19 = +(x$18,x$1) in -- #136
+//│         let x$20 = +(x$19,x$2) in -- #135
+//│         case x$17 of -- #134
+//│           A =>
+//│             let x$22 = A.x(x$17) in -- #119
+//│             let x$23 = A.w(x$17) in -- #118
+//│             jump j$4(x$23,x$4,x$5) -- #117
+//│           B =>
+//│             let x$24 = B.y(x$17) in -- #126
+//│             jump j$4(x$20,x$4,x$5) -- #125
+//│           C =>
+//│             let x$25 = C.z(x$17) in -- #133
+//│             jump j$4(0,x$4,x$5) -- #132
+//│       B =>
+//│         let x$26 = B.y(x$3) in -- #145
+//│         jump j$1(2,x$4,x$5) -- #144
+//│       C =>
+//│         let x$27 = C.z(x$3) in -- #152
+//│         jump j$1(3,x$4,x$5) -- #151
+//│   def bar() =
+//│     let x$35 = B(10) in -- #219
+//│     let x$36 = A(9,x$35) in -- #218
+//│     let x$37 = A(10,x$36) in -- #217
+//│     let* (x$38) = complex_foo(x$37) in -- #216
+//│     x$38 -- #215
+//│   let* (x$0) = bar() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ 5
+//│ 
 
 :interpIR
 class A(w, x)
@@ -244,106 +259,96 @@ fun bar() =
   complex_foo(A(10, A(9, B(10))))
 bar()
 //│ |#class| |A|(|w|,| |x|)|↵|#class| |B|(|y|)|↵|#class| |C|(|z|)|↵|#fun| |complex_foo|(|t|)| |#=|→|#let| |a| |#=| |1| |+| |2|↵|#let| |b| |#=| |1| |*| |2|↵|#let| |x| |#=| |#if| |t| |is|→|A|(|x|,| |y|)| |#then| |A|(|x|,| |C|(|0|)|)|↵|B|(|x|)| |#then| |B|(|x| |+| |b|)|↵|C|(|x|)| |#then| |C|(|0|)|←|↵|#let| |z| |#=| |A|(|5|,| |x|)|↵|#let| |v| |#=| |B|(|6|)|↵|#let| |y| |#=| |#if| |x| |is|→|A|(|x|,| |y|)| |#then|→|#let| |m| |#=| |x| |+| |a| |+| |b|↵|#if| |y| |is|→|A|(|x|,| |y|)| |#then| |x|↵|B|(|x|)| |#then| |m|↵|C|(|x|)| |#then| |0|←|←|↵|B|(|x|)| |#then| |2|↵|C|(|x|)| |#then| |3|←|↵|#if| |z| |is|→|A|(|x|,| |y|)| |#then| |x|↵|B|(|x|)| |#then| |4|↵|C|(|x|)| |#then|→|#if| |v| |is|→|A|(|x|,| |y|)| |#then| |x|↵|B|(|x|)| |#then| |7|↵|C|(|x|)| |#then| |8|←|←|←|←|↵|#fun| |bar|(||)| |#=|→|complex_foo|(|A|(|10|,| |A|(|9|,| |B|(|10|)|)|)|)|←|↵|bar|(||)|
-//│ Parsed: {class A(w, x,) {}; class B(y,) {}; class C(z,) {}; fun complex_foo = (t,) => {let a = +(1,)(2,); let b = *(1,)(2,); let x = if t is ‹(A(x, y,)) then A(x, C(0,),); (B(x,)) then B(+(x,)(b,),); (C(x,)) then C(0,)›; let z = A(5, x,); let v = B(6,); let y = if x is ‹(A(x, y,)) then {let m = +(+(x,)(a,),)(b,); if y is ‹(A(x, y,)) then x; (B(x,)) then m; (C(x,)) then 0›}; (B(x,)) then 2; (C(x,)) then 3›; if z is ‹(A(x, y,)) then x; (B(x,)) then 4; (C(x,)) then {if v is ‹(A(x, y,)) then x; (B(x,)) then 7; (C(x,)) then 8›}›}; fun bar = () => {complex_foo(A(10, A(9, B(10,),),),)}; bar()}
+//│ Parsed: {class A(w, x,) {}; class B(y,) {}; class C(z,) {}; fun complex_foo = (t,) => {let a = +(1, 2,); let b = *(1, 2,); let x = if t is ‹(A(x, y,)) then A(x, C(0,),); (B(x,)) then B(+(x, b,),); (C(x,)) then C(0,)›; let z = A(5, x,); let v = B(6,); let y = if x is ‹(A(x, y,)) then {let m = +(+(x, a,), b,); if y is ‹(A(x, y,)) then x; (B(x,)) then m; (C(x,)) then 0›}; (B(x,)) then 2; (C(x,)) then 3›; if z is ‹(A(x, y,)) then x; (B(x,)) then 4; (C(x,)) then {if v is ‹(A(x, y,)) then x; (B(x,)) then 7; (C(x,)) then 8›}›}; fun bar = () => {complex_foo(A(10, A(9, B(10,),),),)}; bar()}
+//│ 
 //│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [w,x]),ClassInfo(3, B, [y]),ClassInfo(4, C, [z])}, {
-//│ Def(0, complex_foo, [t$0],
-//│ 1, 
-//│ let x$0 = +(1,2) in -- #150
-//│ let x$1 = *(1,2) in -- #149
-//│ case t$0 of -- #148
-//│   A =>
-//│     let x$27 = t$0.x in -- #126
-//│     let x$28 = t$0.w in -- #125
-//│     let x$29 = C(0) in -- #124
-//│     let x$30 = A(x$28,x$29) in -- #123
-//│     jump j$0(x$30,x$0,x$1) -- #122
-//│   B =>
-//│     let x$31 = t$0.y in -- #138
-//│     let x$32 = +(x$31,x$1) in -- #137
-//│     let x$33 = B(x$32) in -- #136
-//│     jump j$0(x$33,x$0,x$1) -- #135
-//│   C =>
-//│     let x$34 = t$0.z in -- #147
-//│     let x$35 = C(0) in -- #146
-//│     jump j$0(x$35,x$0,x$1) -- #145
-//│ )
-//│ Def(1, j$2, [x$6],
-//│ 1, 
-//│ x$6 -- #21
-//│ )
-//│ Def(2, j$3, [x$11],
-//│ 1, 
-//│ jump j$2(x$11) -- #39
-//│ )
-//│ Def(3, j$1, [x$5,x$3,x$4],
-//│ 1, 
-//│ case x$3 of -- #60
-//│   A =>
-//│     let x$7 = x$3.x in -- #29
-//│     let x$8 = x$3.w in -- #28
-//│     jump j$2(x$8) -- #27
-//│   B =>
-//│     let x$9 = x$3.y in -- #34
-//│     jump j$2(4) -- #33
-//│   C =>
-//│     let x$10 = x$3.z in -- #59
-//│     case x$4 of -- #58
+//│ IR:
+//│ Program:
+//│   class A(w,x)
+//│   class B(y)
+//│   class C(z)
+//│   def complex_foo(t$0) =
+//│     let x$1 = +(1,2) in -- #208
+//│     let x$2 = *(1,2) in -- #207
+//│     case t$0 of -- #206
 //│       A =>
-//│         let x$12 = x$4.x in -- #47
-//│         let x$13 = x$4.w in -- #46
-//│         jump j$3(x$13) -- #45
+//│         let x$28 = A.x(t$0) in -- #177
+//│         let x$29 = A.w(t$0) in -- #176
+//│         let x$30 = C(0) in -- #175
+//│         let x$31 = A(x$29,x$30) in -- #174
+//│         jump j$0(x$31,x$1,x$2) -- #173
 //│       B =>
-//│         let x$14 = x$4.y in -- #52
-//│         jump j$3(7) -- #51
+//│         let x$32 = B.y(t$0) in -- #194
+//│         let x$33 = +(x$32,x$2) in -- #193
+//│         let x$34 = B(x$33) in -- #192
+//│         jump j$0(x$34,x$1,x$2) -- #191
 //│       C =>
-//│         let x$15 = x$4.z in -- #57
-//│         jump j$3(8) -- #56
-//│ )
-//│ Def(4, j$4, [x$20,x$3,x$4],
-//│ 1, 
-//│ jump j$1(x$20,x$3,x$4) -- #72
-//│ )
-//│ Def(5, j$0, [x$2,x$0,x$1],
-//│ 1, 
-//│ let x$3 = A(5,x$2) in -- #108
-//│ let x$4 = B(6) in -- #107
-//│ case x$2 of -- #106
-//│   A =>
-//│     let x$16 = x$2.x in -- #95
-//│     let x$17 = x$2.w in -- #94
-//│     let x$18 = +(x$17,x$0) in -- #93
-//│     let x$19 = +(x$18,x$1) in -- #92
-//│     case x$16 of -- #91
+//│         let x$35 = C.z(t$0) in -- #205
+//│         let x$36 = C(0) in -- #204
+//│         jump j$0(x$36,x$1,x$2) -- #203
+//│   def j$2(x$7) =
+//│     x$7 -- #30
+//│   def j$3(x$12) =
+//│     jump j$2(x$12) -- #56
+//│   def j$1(x$6,x$4,x$5) =
+//│     case x$4 of -- #85
 //│       A =>
-//│         let x$21 = x$16.x in -- #80
-//│         let x$22 = x$16.w in -- #79
-//│         jump j$4(x$22,x$3,x$4) -- #78
+//│         let x$8 = A.x(x$4) in -- #42
+//│         let x$9 = A.w(x$4) in -- #41
+//│         jump j$2(x$9) -- #40
 //│       B =>
-//│         let x$23 = x$16.y in -- #85
-//│         jump j$4(x$19,x$3,x$4) -- #84
+//│         let x$10 = B.y(x$4) in -- #49
+//│         jump j$2(4) -- #48
 //│       C =>
-//│         let x$24 = x$16.z in -- #90
-//│         jump j$4(0,x$3,x$4) -- #89
-//│   B =>
-//│     let x$25 = x$2.y in -- #100
-//│     jump j$1(2,x$3,x$4) -- #99
-//│   C =>
-//│     let x$26 = x$2.z in -- #105
-//│     jump j$1(3,x$3,x$4) -- #104
-//│ )
-//│ Def(6, bar, [],
-//│ 1, 
-//│ let x$36 = B(10) in -- #172
-//│ let x$37 = A(9,x$36) in -- #171
-//│ let x$38 = A(10,x$37) in -- #170
-//│ let* (x$39) = complex_foo(x$38) in -- #169
-//│ x$39 -- #168
-//│ )
-//│ },
-//│ let* (x$40) = bar() in -- #176
-//│ x$40 -- #175)
+//│         let x$11 = C.z(x$4) in -- #84
+//│         case x$5 of -- #83
+//│           A =>
+//│             let x$13 = A.x(x$5) in -- #68
+//│             let x$14 = A.w(x$5) in -- #67
+//│             jump j$3(x$14) -- #66
+//│           B =>
+//│             let x$15 = B.y(x$5) in -- #75
+//│             jump j$3(7) -- #74
+//│           C =>
+//│             let x$16 = C.z(x$5) in -- #82
+//│             jump j$3(8) -- #81
+//│   def j$4(x$21,x$4,x$5) =
+//│     jump j$1(x$21,x$4,x$5) -- #107
+//│   def j$0(x$3,x$1,x$2) =
+//│     let x$4 = A(5,x$3) in -- #155
+//│     let x$5 = B(6) in -- #154
+//│     case x$3 of -- #153
+//│       A =>
+//│         let x$17 = A.x(x$3) in -- #138
+//│         let x$18 = A.w(x$3) in -- #137
+//│         let x$19 = +(x$18,x$1) in -- #136
+//│         let x$20 = +(x$19,x$2) in -- #135
+//│         case x$17 of -- #134
+//│           A =>
+//│             let x$22 = A.x(x$17) in -- #119
+//│             let x$23 = A.w(x$17) in -- #118
+//│             jump j$4(x$23,x$4,x$5) -- #117
+//│           B =>
+//│             let x$24 = B.y(x$17) in -- #126
+//│             jump j$4(x$20,x$4,x$5) -- #125
+//│           C =>
+//│             let x$25 = C.z(x$17) in -- #133
+//│             jump j$4(0,x$4,x$5) -- #132
+//│       B =>
+//│         let x$26 = B.y(x$3) in -- #145
+//│         jump j$1(2,x$4,x$5) -- #144
+//│       C =>
+//│         let x$27 = C.z(x$3) in -- #152
+//│         jump j$1(3,x$4,x$5) -- #151
+//│   def bar() =
+//│     let x$37 = B(10) in -- #229
+//│     let x$38 = A(9,x$37) in -- #228
+//│     let x$39 = A(10,x$38) in -- #227
+//│     let* (x$40) = complex_foo(x$39) in -- #226
+//│     x$40 -- #225
+//│   let* (x$0) = bar() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ 5
+//│ 
diff --git a/compiler/shared/test/diff-ir/IRRec.mls b/compiler/shared/test/diff-ir/IRRec.mls
index a56f53a9e7..45aaa77e0d 100644
--- a/compiler/shared/test/diff-ir/IRRec.mls
+++ b/compiler/shared/test/diff-ir/IRRec.mls
@@ -1,164 +1,168 @@
-:NewParser
+:NewDefs
 :ParseOnly
 :UseIR
 :NoTailRec
 
+:prelude
+module True
+module False
+module Callable {
+  fun apply0() = 0
+  fun apply1(x0) = 0
+  fun apply2(x0,x1) = 0
+  fun apply3(x0,x1,x2) = 0
+  fun apply4(x0,x1,x2,x3) = 0
+  fun apply5(x0,x1,x2,x3,x4) = 0
+}
+module List[A, B]
+class Cons[A, B](h: A, t: Cons[A, B]) extends List[A, B]
+module Nil[A, B] extends List[A, B]
+module Option[A]
+class Some[A](x: A) extends Option[A]
+module None[A] extends Option[A]
+class Pair[A, B](x: A, y: B)
+class Tuple2[A, B](x: A, y: B)
+class Tuple3[A, B, C](x: A, y: B, z: C)
+module Nat
+class S(s: Nat) extends Nat
+module O extends Nat
+class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O)
+//│ |#module| |True|↵|#module| |False|↵|#module| |Callable| |{|→|#fun| |apply0|(||)| |#=| |0|↵|#fun| |apply1|(|x0|)| |#=| |0|↵|#fun| |apply2|(|x0|,|x1|)| |#=| |0|↵|#fun| |apply3|(|x0|,|x1|,|x2|)| |#=| |0|↵|#fun| |apply4|(|x0|,|x1|,|x2|,|x3|)| |#=| |0|↵|#fun| |apply5|(|x0|,|x1|,|x2|,|x3|,|x4|)| |#=| |0|←|↵|}|↵|#module| |List|[|A|,| |B|]|↵|#class| |Cons|[|A|,| |B|]|(|h|#:| |A|,| |t|#:| |Cons|[|A|,| |B|]|)| |#extends| |List|[|A|,| |B|]|↵|#module| |Nil|[|A|,| |B|]| |#extends| |List|[|A|,| |B|]|↵|#module| |Option|[|A|]|↵|#class| |Some|[|A|]|(|x|#:| |A|)| |#extends| |Option|[|A|]|↵|#module| |None|[|A|]| |#extends| |Option|[|A|]|↵|#class| |Pair|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple2|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple3|[|A|,| |B|,| |C|]|(|x|#:| |A|,| |y|#:| |B|,| |z|#:| |C|)|↵|#module| |Nat|↵|#class| |S|(|s|#:| |Nat|)| |#extends| |Nat|↵|#module| |O| |#extends| |Nat|↵|#class| |HiddenTheseEntities|(|_0|#:| |HiddenTheseEntities|,| |_1|#:| |True|,| |_2|#:| |False|,| |_3|#:| |Callable|,| |_4|#:| |List|,| |_5|#:| |Cons|,| |_6|#:| |Nil|,| |_7|#:| |Option|,| |_8|#:| |Some|,| |_9|#:| |None|,| |_10|#:| |Pair|,| |_11|#:| |Tuple2|,| |_12|#:| |Tuple3|,| |_13|#:| |Nat|,| |_14|#:| |S|,| |_15|#:| |O|)|
+//│ Parsed: {module True {}; module False {}; module Callable {fun apply0 = () => 0; fun apply1 = (x0,) => 0; fun apply2 = (x0, x1,) => 0; fun apply3 = (x0, x1, x2,) => 0; fun apply4 = (x0, x1, x2, x3,) => 0; fun apply5 = (x0, x1, x2, x3, x4,) => 0}; module List‹A, B› {}; class Cons‹A, B›(h: A, t: Cons‹A, B›,): List‹A, B› {}; module Nil‹A, B›: List‹A, B› {}; module Option‹A› {}; class Some‹A›(x: A,): Option‹A› {}; module None‹A›: Option‹A› {}; class Pair‹A, B›(x: A, y: B,) {}; class Tuple2‹A, B›(x: A, y: B,) {}; class Tuple3‹A, B, C›(x: A, y: B, z: C,) {}; module Nat {}; class S(s: Nat,): Nat {}; module O: Nat {}; class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O,) {}}
+//│ 
+//│ Preluded.
+//│ 
+
 :interpIR
-class True
-class False
+:genCpp
 fun fib(n) = if n < 2 then n else fib(n-1) + fib(n-2)
 fib(20)
-//│ |#class| |True|↵|#class| |False|↵|#fun| |fib|(|n|)| |#=| |#if| |n| |<| |2| |#then| |n| |#else| |fib|(|n|-|1|)| |+| |fib|(|n|-|2|)|↵|fib|(|20|)|
-//│ Parsed: {class True {}; class False {}; fun fib = (n,) => if (<(n,)(2,)) then n else +(fib(-(n,)(1,),),)(fib(-(n,)(2,),),); fib(20,)}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, [])}, {
-//│ Def(0, fib, [n$0],
-//│ 1, 
-//│ let x$0 = <(n$0,2) in -- #28
-//│ if x$0 -- #27
-//│   true =>
-//│     jump j$0(n$0) -- #5
-//│   false =>
-//│     let x$2 = -(n$0,1) in -- #26
-//│     let* (x$3) = fib(x$2) in -- #25
-//│     let x$4 = -(n$0,2) in -- #24
-//│     let* (x$5) = fib(x$4) in -- #23
-//│     let x$6 = +(x$3,x$5) in -- #22
-//│     jump j$0(x$6) -- #21
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #3
-//│ )
-//│ },
-//│ let* (x$7) = fib(20) in -- #34
-//│ x$7 -- #33)
+//│ |#fun| |fib|(|n|)| |#=| |#if| |n| |<| |2| |#then| |n| |#else| |fib|(|n|-|1|)| |+| |fib|(|n|-|2|)|↵|fib|(|20|)|
+//│ Parsed: {fun fib = (n,) => if (<(n, 2,)) then n else +(fib(-(n, 1,),), fib(-(n, 2,),),); fib(20,)}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def fib(n$0) =
+//│     let x$1 = <(n$0,2) in -- #43
+//│     if x$1 -- #42
+//│       true =>
+//│         jump j$0(n$0) -- #13
+//│       false =>
+//│         let x$3 = -(n$0,1) in -- #41
+//│         let* (x$4) = fib(x$3) in -- #40
+//│         let x$5 = -(n$0,2) in -- #39
+//│         let* (x$6) = fib(x$5) in -- #38
+//│         let x$7 = +(x$4,x$6) in -- #37
+//│         jump j$0(x$7) -- #36
+//│   def j$0(x$2) =
+//│     x$2 -- #11
+//│   let* (x$0) = fib(20) in -- #4
+//│   x$0 -- #3
 //│ 
 //│ Interpreted:
 //│ 6765
+//│ 
 
 :interpIR
-class True
-class False
+:genCpp
 fun odd(x) = if x == 0 then False else even(x-1)
 fun even(x) = if x == 0 then True else odd(x-1)
 fun foo() = odd(10)
 foo()
-//│ |#class| |True|↵|#class| |False|↵|#fun| |odd|(|x|)| |#=| |#if| |x| |==| |0| |#then| |False| |#else| |even|(|x|-|1|)|↵|#fun| |even|(|x|)| |#=| |#if| |x| |==| |0| |#then| |True| |#else| |odd|(|x|-|1|)|↵|#fun| |foo|(||)| |#=| |odd|(|10|)|↵|foo|(||)|
-//│ Parsed: {class True {}; class False {}; fun odd = (x,) => if (==(x,)(0,)) then False else even(-(x,)(1,),); fun even = (x,) => if (==(x,)(0,)) then True else odd(-(x,)(1,),); fun foo = () => odd(10,); foo()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, [])}, {
-//│ Def(0, odd, [x$0],
-//│ 1, 
-//│ let x$1 = ==(x$0,0) in -- #18
-//│ if x$1 -- #17
-//│   true =>
-//│     let x$3 = False() in -- #6
-//│     jump j$0(x$3) -- #5
-//│   false =>
-//│     let x$4 = -(x$0,1) in -- #16
-//│     let* (x$5) = even(x$4) in -- #15
-//│     jump j$0(x$5) -- #14
-//│ )
-//│ Def(1, j$0, [x$2],
-//│ 1, 
-//│ x$2 -- #3
-//│ )
-//│ Def(2, even, [x$6],
-//│ 1, 
-//│ let x$7 = ==(x$6,0) in -- #37
-//│ if x$7 -- #36
-//│   true =>
-//│     let x$9 = True() in -- #25
-//│     jump j$1(x$9) -- #24
-//│   false =>
-//│     let x$10 = -(x$6,1) in -- #35
-//│     let* (x$11) = odd(x$10) in -- #34
-//│     jump j$1(x$11) -- #33
-//│ )
-//│ Def(3, j$1, [x$8],
-//│ 1, 
-//│ x$8 -- #22
-//│ )
-//│ Def(4, foo, [],
-//│ 1, 
-//│ let* (x$12) = odd(10) in -- #43
-//│ x$12 -- #42
-//│ )
-//│ },
-//│ let* (x$13) = foo() in -- #47
-//│ x$13 -- #46)
+//│ |#fun| |odd|(|x|)| |#=| |#if| |x| |==| |0| |#then| |False| |#else| |even|(|x|-|1|)|↵|#fun| |even|(|x|)| |#=| |#if| |x| |==| |0| |#then| |True| |#else| |odd|(|x|-|1|)|↵|#fun| |foo|(||)| |#=| |odd|(|10|)|↵|foo|(||)|
+//│ Parsed: {fun odd = (x,) => if (==(x, 0,)) then False else even(-(x, 1,),); fun even = (x,) => if (==(x, 0,)) then True else odd(-(x, 1,),); fun foo = () => odd(10,); foo()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def odd(x$1) =
+//│     let x$2 = ==(x$1,0) in -- #26
+//│     if x$2 -- #25
+//│       true =>
+//│         let x$4 = False() in -- #12
+//│         jump j$0(x$4) -- #11
+//│       false =>
+//│         let x$5 = -(x$1,1) in -- #24
+//│         let* (x$6) = even(x$5) in -- #23
+//│         jump j$0(x$6) -- #22
+//│   def j$0(x$3) =
+//│     x$3 -- #9
+//│   def even(x$7) =
+//│     let x$8 = ==(x$7,0) in -- #50
+//│     if x$8 -- #49
+//│       true =>
+//│         let x$10 = True() in -- #36
+//│         jump j$1(x$10) -- #35
+//│       false =>
+//│         let x$11 = -(x$7,1) in -- #48
+//│         let* (x$12) = odd(x$11) in -- #47
+//│         jump j$1(x$12) -- #46
+//│   def j$1(x$9) =
+//│     x$9 -- #33
+//│   def foo() =
+//│     let* (x$13) = odd(10) in -- #55
+//│     x$13 -- #54
+//│   let* (x$0) = foo() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ False()
+//│ 
 
 :interpIR
-class True
-class False
-class A
-class B(b)
+:genCpp
 fun not(x) =
   if x then False else True
 fun foo(x) =
-  if x then A
-       else B(foo(not(x)))
+  if x then None
+       else Some(foo(not(x)))
 fun main() = foo(False)
 main()
-//│ |#class| |True|↵|#class| |False|↵|#class| |A|↵|#class| |B|(|b|)|↵|#fun| |not|(|x|)| |#=|→|#if| |x| |#then| |False| |#else| |True|←|↵|#fun| |foo|(|x|)| |#=|→|#if| |x| |#then| |A|→|#else| |B|(|foo|(|not|(|x|)|)|)|←|←|↵|#fun| |main|(||)| |#=| |foo|(|False|)|↵|main|(||)|
-//│ Parsed: {class True {}; class False {}; class A {}; class B(b,) {}; fun not = (x,) => {if (x) then False else True}; fun foo = (x,) => {if (x) then A else B(foo(not(x,),),)}; fun main = () => foo(False,); main()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, A, []),ClassInfo(5, B, [b])}, {
-//│ Def(0, not, [x$0],
-//│ 1, 
-//│ if x$0 -- #8
-//│   true =>
-//│     let x$2 = False() in -- #4
-//│     jump j$0(x$2) -- #3
-//│   false =>
-//│     let x$3 = True() in -- #7
-//│     jump j$0(x$3) -- #6
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #1
-//│ )
-//│ Def(2, foo, [x$4],
-//│ 1, 
-//│ if x$4 -- #30
-//│   true =>
-//│     let x$6 = A() in -- #13
-//│     jump j$1(x$6) -- #12
-//│   false =>
-//│     let* (x$7) = not(x$4) in -- #29
-//│     let* (x$8) = foo(x$7) in -- #28
-//│     let x$9 = B(x$8) in -- #27
-//│     jump j$1(x$9) -- #26
-//│ )
-//│ Def(3, j$1, [x$5],
-//│ 1, 
-//│ x$5 -- #10
-//│ )
-//│ Def(4, main, [],
-//│ 1, 
-//│ let x$10 = False() in -- #37
-//│ let* (x$11) = foo(x$10) in -- #36
-//│ x$11 -- #35
-//│ )
-//│ },
-//│ let* (x$12) = main() in -- #41
-//│ x$12 -- #40)
+//│ |#fun| |not|(|x|)| |#=|→|#if| |x| |#then| |False| |#else| |True|←|↵|#fun| |foo|(|x|)| |#=|→|#if| |x| |#then| |None|→|#else| |Some|(|foo|(|not|(|x|)|)|)|←|←|↵|#fun| |main|(||)| |#=| |foo|(|False|)|↵|main|(||)|
+//│ Parsed: {fun not = (x,) => {if (x) then False else True}; fun foo = (x,) => {if (x) then None else Some(foo(not(x,),),)}; fun main = () => foo(False,); main()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def not(x$1) =
+//│     if x$1 -- #11
+//│       true =>
+//│         let x$3 = False() in -- #7
+//│         jump j$0(x$3) -- #6
+//│       false =>
+//│         let x$4 = True() in -- #10
+//│         jump j$0(x$4) -- #9
+//│   def j$0(x$2) =
+//│     x$2 -- #4
+//│   def foo(x$5) =
+//│     if x$5 -- #31
+//│       true =>
+//│         let x$7 = None() in -- #16
+//│         jump j$1(x$7) -- #15
+//│       false =>
+//│         let* (x$8) = not(x$5) in -- #30
+//│         let* (x$9) = foo(x$8) in -- #29
+//│         let x$10 = Some(x$9) in -- #28
+//│         jump j$1(x$10) -- #27
+//│   def j$1(x$6) =
+//│     x$6 -- #13
+//│   def main() =
+//│     let x$11 = False() in -- #37
+//│     let* (x$12) = foo(x$11) in -- #36
+//│     x$12 -- #35
+//│   let* (x$0) = main() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
-//│ B(A())
+//│ Some(None())
+//│ 
 
 :interpIR
-class True
-class False
-class A()
-class B(b)
+:genCpp
 fun aaa() =
   let m = 1
   let n = 2
@@ -171,97 +175,79 @@ fun bbb() =
 fun not(x) =
   if x then False else True
 fun foo(x) =
-  if x then A
-       else B(foo(not(x)))
+  if x then None
+       else Some(foo(not(x)))
 fun main() =
   let x = foo(False)
   if x is
-    A then aaa()
-    B(b1) then bbb()
+    None then aaa()
+    Some(b1) then bbb()
 main()
-//│ |#class| |True|↵|#class| |False|↵|#class| |A|(||)|↵|#class| |B|(|b|)|↵|#fun| |aaa|(||)| |#=|→|#let| |m| |#=| |1|↵|#let| |n| |#=| |2|↵|#let| |p| |#=| |3|↵|#let| |q| |#=| |4|↵|m| |+| |n| |-| |p| |+| |q|←|↵|#fun| |bbb|(||)| |#=|→|#let| |x| |#=| |aaa|(||)|↵|x| |*| |100| |+| |4|←|↵|#fun| |not|(|x|)| |#=|→|#if| |x| |#then| |False| |#else| |True|←|↵|#fun| |foo|(|x|)| |#=|→|#if| |x| |#then| |A|→|#else| |B|(|foo|(|not|(|x|)|)|)|←|←|↵|#fun| |main|(||)| |#=|→|#let| |x| |#=| |foo|(|False|)|↵|#if| |x| |is|→|A| |#then| |aaa|(||)|↵|B|(|b1|)| |#then| |bbb|(||)|←|←|↵|main|(||)|
-//│ Parsed: {class True {}; class False {}; class A() {}; class B(b,) {}; fun aaa = () => {let m = 1; let n = 2; let p = 3; let q = 4; +(-(+(m,)(n,),)(p,),)(q,)}; fun bbb = () => {let x = aaa(); +(*(x,)(100,),)(4,)}; fun not = (x,) => {if (x) then False else True}; fun foo = (x,) => {if (x) then A else B(foo(not(x,),),)}; fun main = () => {let x = foo(False,); if x is ‹(A) then aaa(); (B(b1,)) then bbb()›}; main()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, A, []),ClassInfo(5, B, [b])}, {
-//│ Def(0, aaa, [],
-//│ 1, 
-//│ let x$0 = 1 in -- #17
-//│ let x$1 = 2 in -- #16
-//│ let x$2 = 3 in -- #15
-//│ let x$3 = 4 in -- #14
-//│ let x$4 = +(x$0,x$1) in -- #13
-//│ let x$5 = -(x$4,x$2) in -- #12
-//│ let x$6 = +(x$5,x$3) in -- #11
-//│ x$6 -- #10
-//│ )
-//│ Def(1, bbb, [],
-//│ 1, 
-//│ let* (x$7) = aaa() in -- #28
-//│ let x$8 = *(x$7,100) in -- #27
-//│ let x$9 = +(x$8,4) in -- #26
-//│ x$9 -- #25
-//│ )
-//│ Def(2, not, [x$10],
-//│ 1, 
-//│ if x$10 -- #37
-//│   true =>
-//│     let x$12 = False() in -- #33
-//│     jump j$0(x$12) -- #32
-//│   false =>
-//│     let x$13 = True() in -- #36
-//│     jump j$0(x$13) -- #35
-//│ )
-//│ Def(3, j$0, [x$11],
-//│ 1, 
-//│ x$11 -- #30
-//│ )
-//│ Def(4, foo, [x$14],
-//│ 1, 
-//│ if x$14 -- #59
-//│   true =>
-//│     let x$16 = A() in -- #42
-//│     jump j$1(x$16) -- #41
-//│   false =>
-//│     let* (x$17) = not(x$14) in -- #58
-//│     let* (x$18) = foo(x$17) in -- #57
-//│     let x$19 = B(x$18) in -- #56
-//│     jump j$1(x$19) -- #55
-//│ )
-//│ Def(5, j$1, [x$15],
-//│ 1, 
-//│ x$15 -- #39
-//│ )
-//│ Def(6, main, [],
-//│ 1, 
-//│ let x$20 = False() in -- #82
-//│ let* (x$21) = foo(x$20) in -- #81
-//│ case x$21 of -- #80
-//│   A =>
-//│     let* (x$23) = aaa() in -- #71
-//│     jump j$2(x$23) -- #70
-//│   B =>
-//│     let x$24 = x$21.b in -- #79
-//│     let* (x$25) = bbb() in -- #78
-//│     jump j$2(x$25) -- #77
-//│ )
-//│ Def(7, j$2, [x$22],
-//│ 1, 
-//│ x$22 -- #66
-//│ )
-//│ },
-//│ let* (x$26) = main() in -- #86
-//│ x$26 -- #85)
+//│ |#fun| |aaa|(||)| |#=|→|#let| |m| |#=| |1|↵|#let| |n| |#=| |2|↵|#let| |p| |#=| |3|↵|#let| |q| |#=| |4|↵|m| |+| |n| |-| |p| |+| |q|←|↵|#fun| |bbb|(||)| |#=|→|#let| |x| |#=| |aaa|(||)|↵|x| |*| |100| |+| |4|←|↵|#fun| |not|(|x|)| |#=|→|#if| |x| |#then| |False| |#else| |True|←|↵|#fun| |foo|(|x|)| |#=|→|#if| |x| |#then| |None|→|#else| |Some|(|foo|(|not|(|x|)|)|)|←|←|↵|#fun| |main|(||)| |#=|→|#let| |x| |#=| |foo|(|False|)|↵|#if| |x| |is|→|None| |#then| |aaa|(||)|↵|Some|(|b1|)| |#then| |bbb|(||)|←|←|↵|main|(||)|
+//│ Parsed: {fun aaa = () => {let m = 1; let n = 2; let p = 3; let q = 4; +(-(+(m, n,), p,), q,)}; fun bbb = () => {let x = aaa(); +(*(x, 100,), 4,)}; fun not = (x,) => {if (x) then False else True}; fun foo = (x,) => {if (x) then None else Some(foo(not(x,),),)}; fun main = () => {let x = foo(False,); if x is ‹(None) then aaa(); (Some(b1,)) then bbb()›}; main()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def aaa() =
+//│     let x$1 = 1 in -- #29
+//│     let x$2 = 2 in -- #28
+//│     let x$3 = 3 in -- #27
+//│     let x$4 = 4 in -- #26
+//│     let x$5 = +(x$1,x$2) in -- #25
+//│     let x$6 = -(x$5,x$3) in -- #24
+//│     let x$7 = +(x$6,x$4) in -- #23
+//│     x$7 -- #22
+//│   def bbb() =
+//│     let* (x$8) = aaa() in -- #45
+//│     let x$9 = *(x$8,100) in -- #44
+//│     let x$10 = +(x$9,4) in -- #43
+//│     x$10 -- #42
+//│   def not(x$11) =
+//│     if x$11 -- #54
+//│       true =>
+//│         let x$13 = False() in -- #50
+//│         jump j$0(x$13) -- #49
+//│       false =>
+//│         let x$14 = True() in -- #53
+//│         jump j$0(x$14) -- #52
+//│   def j$0(x$12) =
+//│     x$12 -- #47
+//│   def foo(x$15) =
+//│     if x$15 -- #74
+//│       true =>
+//│         let x$17 = None() in -- #59
+//│         jump j$1(x$17) -- #58
+//│       false =>
+//│         let* (x$18) = not(x$15) in -- #73
+//│         let* (x$19) = foo(x$18) in -- #72
+//│         let x$20 = Some(x$19) in -- #71
+//│         jump j$1(x$20) -- #70
+//│   def j$1(x$16) =
+//│     x$16 -- #56
+//│   def main() =
+//│     let x$21 = False() in -- #96
+//│     let* (x$22) = foo(x$21) in -- #95
+//│     case x$22 of -- #94
+//│       None =>
+//│         let* (x$24) = aaa() in -- #84
+//│         jump j$2(x$24) -- #83
+//│       Some =>
+//│         let x$25 = Some.x(x$22) in -- #93
+//│         let* (x$26) = bbb() in -- #92
+//│         jump j$2(x$26) -- #91
+//│   def j$2(x$23) =
+//│     x$23 -- #80
+//│   let* (x$0) = main() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ 404
+//│ 
 
 
 :interpIR
-class True
-class False
-class S(s)
-class O
 fun odd(x) =
   if x is
     O then False
@@ -272,62 +258,51 @@ fun even(x) =
     S(s) then odd(s)
 fun foo() = odd(S(S(S(O))))
 foo()
-//│ |#class| |True|↵|#class| |False|↵|#class| |S|(|s|)|↵|#class| |O|↵|#fun| |odd|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |False|↵|S|(|s|)| |#then| |even|(|s|)|←|←|↵|#fun| |even|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |True|↵|S|(|s|)| |#then| |odd|(|s|)|←|←|↵|#fun| |foo|(||)| |#=| |odd|(|S|(|S|(|S|(|O|)|)|)|)|↵|foo|(||)|
-//│ Parsed: {class True {}; class False {}; class S(s,) {}; class O {}; fun odd = (x,) => {if x is ‹(O) then False; (S(s,)) then even(s,)›}; fun even = (x,) => {if x is ‹(O) then True; (S(s,)) then odd(s,)›}; fun foo = () => odd(S(S(S(O,),),),); foo()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, S, [s]),ClassInfo(5, O, [])}, {
-//│ Def(0, odd, [x$0],
-//│ 1, 
-//│ case x$0 of -- #15
-//│   O =>
-//│     let x$2 = False() in -- #4
-//│     jump j$0(x$2) -- #3
-//│   S =>
-//│     let x$3 = x$0.s in -- #14
-//│     let* (x$4) = even(x$3) in -- #13
-//│     jump j$0(x$4) -- #12
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #1
-//│ )
-//│ Def(2, even, [x$5],
-//│ 1, 
-//│ case x$5 of -- #31
-//│   O =>
-//│     let x$7 = True() in -- #20
-//│     jump j$1(x$7) -- #19
-//│   S =>
-//│     let x$8 = x$5.s in -- #30
-//│     let* (x$9) = odd(x$8) in -- #29
-//│     jump j$1(x$9) -- #28
-//│ )
-//│ Def(3, j$1, [x$6],
-//│ 1, 
-//│ x$6 -- #17
-//│ )
-//│ Def(4, foo, [],
-//│ 1, 
-//│ let x$10 = O() in -- #50
-//│ let x$11 = S(x$10) in -- #49
-//│ let x$12 = S(x$11) in -- #48
-//│ let x$13 = S(x$12) in -- #47
-//│ let* (x$14) = odd(x$13) in -- #46
-//│ x$14 -- #45
-//│ )
-//│ },
-//│ let* (x$15) = foo() in -- #54
-//│ x$15 -- #53)
+//│ |#fun| |odd|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |False|↵|S|(|s|)| |#then| |even|(|s|)|←|←|↵|#fun| |even|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |True|↵|S|(|s|)| |#then| |odd|(|s|)|←|←|↵|#fun| |foo|(||)| |#=| |odd|(|S|(|S|(|S|(|O|)|)|)|)|↵|foo|(||)|
+//│ Parsed: {fun odd = (x,) => {if x is ‹(O) then False; (S(s,)) then even(s,)›}; fun even = (x,) => {if x is ‹(O) then True; (S(s,)) then odd(s,)›}; fun foo = () => odd(S(S(S(O,),),),); foo()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def odd(x$1) =
+//│     case x$1 of -- #19
+//│       O =>
+//│         let x$3 = False() in -- #7
+//│         jump j$0(x$3) -- #6
+//│       S =>
+//│         let x$4 = S.s(x$1) in -- #18
+//│         let* (x$5) = even(x$4) in -- #17
+//│         jump j$0(x$5) -- #16
+//│   def j$0(x$2) =
+//│     x$2 -- #4
+//│   def even(x$6) =
+//│     case x$6 of -- #36
+//│       O =>
+//│         let x$8 = True() in -- #24
+//│         jump j$1(x$8) -- #23
+//│       S =>
+//│         let x$9 = S.s(x$6) in -- #35
+//│         let* (x$10) = odd(x$9) in -- #34
+//│         jump j$1(x$10) -- #33
+//│   def j$1(x$7) =
+//│     x$7 -- #21
+//│   def foo() =
+//│     let x$11 = O() in -- #54
+//│     let x$12 = S(x$11) in -- #53
+//│     let x$13 = S(x$12) in -- #52
+//│     let x$14 = S(x$13) in -- #51
+//│     let* (x$15) = odd(x$14) in -- #50
+//│     x$15 -- #49
+//│   let* (x$0) = foo() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ True()
+//│ 
 
 :interpIR
-class True
-class False
-class S(s)
-class O
+:genCpp
 fun odd(x) =
   if x is
     O then False
@@ -339,77 +314,61 @@ fun even(x) =
 fun mk(n) = if n > 0 then S(mk(n - 1)) else O
 fun foo() = odd(mk(10))
 foo() 
-//│ |#class| |True|↵|#class| |False|↵|#class| |S|(|s|)|↵|#class| |O|↵|#fun| |odd|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |False|↵|S|(|s|)| |#then| |even|(|s|)|←|←|↵|#fun| |even|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |True|↵|S|(|s|)| |#then| |odd|(|s|)|←|←|↵|#fun| |mk|(|n|)| |#=| |#if| |n| |>| |0| |#then| |S|(|mk|(|n| |-| |1|)|)| |#else| |O|↵|#fun| |foo|(||)| |#=| |odd|(|mk|(|10|)|)|↵|foo|(||)| |
-//│ Parsed: {class True {}; class False {}; class S(s,) {}; class O {}; fun odd = (x,) => {if x is ‹(O) then False; (S(s,)) then even(s,)›}; fun even = (x,) => {if x is ‹(O) then True; (S(s,)) then odd(s,)›}; fun mk = (n,) => if (>(n,)(0,)) then S(mk(-(n,)(1,),),) else O; fun foo = () => odd(mk(10,),); foo()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, S, [s]),ClassInfo(5, O, [])}, {
-//│ Def(0, odd, [x$0],
-//│ 1, 
-//│ case x$0 of -- #15
-//│   O =>
-//│     let x$2 = False() in -- #4
-//│     jump j$0(x$2) -- #3
-//│   S =>
-//│     let x$3 = x$0.s in -- #14
-//│     let* (x$4) = even(x$3) in -- #13
-//│     jump j$0(x$4) -- #12
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #1
-//│ )
-//│ Def(2, even, [x$5],
-//│ 1, 
-//│ case x$5 of -- #31
-//│   O =>
-//│     let x$7 = True() in -- #20
-//│     jump j$1(x$7) -- #19
-//│   S =>
-//│     let x$8 = x$5.s in -- #30
-//│     let* (x$9) = odd(x$8) in -- #29
-//│     jump j$1(x$9) -- #28
-//│ )
-//│ Def(3, j$1, [x$6],
-//│ 1, 
-//│ x$6 -- #17
-//│ )
-//│ Def(4, mk, [n$0],
-//│ 1, 
-//│ let x$10 = >(n$0,0) in -- #54
-//│ if x$10 -- #53
-//│   true =>
-//│     let x$12 = -(n$0,1) in -- #49
-//│     let* (x$13) = mk(x$12) in -- #48
-//│     let x$14 = S(x$13) in -- #47
-//│     jump j$2(x$14) -- #46
-//│   false =>
-//│     let x$15 = O() in -- #52
-//│     jump j$2(x$15) -- #51
-//│ )
-//│ Def(5, j$2, [x$11],
-//│ 1, 
-//│ x$11 -- #35
-//│ )
-//│ Def(6, foo, [],
-//│ 1, 
-//│ let* (x$16) = mk(10) in -- #65
-//│ let* (x$17) = odd(x$16) in -- #64
-//│ x$17 -- #63
-//│ )
-//│ },
-//│ let* (x$18) = foo() in -- #69
-//│ x$18 -- #68)
+//│ |#fun| |odd|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |False|↵|S|(|s|)| |#then| |even|(|s|)|←|←|↵|#fun| |even|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |True|↵|S|(|s|)| |#then| |odd|(|s|)|←|←|↵|#fun| |mk|(|n|)| |#=| |#if| |n| |>| |0| |#then| |S|(|mk|(|n| |-| |1|)|)| |#else| |O|↵|#fun| |foo|(||)| |#=| |odd|(|mk|(|10|)|)|↵|foo|(||)| |
+//│ Parsed: {fun odd = (x,) => {if x is ‹(O) then False; (S(s,)) then even(s,)›}; fun even = (x,) => {if x is ‹(O) then True; (S(s,)) then odd(s,)›}; fun mk = (n,) => if (>(n, 0,)) then S(mk(-(n, 1,),),) else O; fun foo = () => odd(mk(10,),); foo()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def odd(x$1) =
+//│     case x$1 of -- #19
+//│       O =>
+//│         let x$3 = False() in -- #7
+//│         jump j$0(x$3) -- #6
+//│       S =>
+//│         let x$4 = S.s(x$1) in -- #18
+//│         let* (x$5) = even(x$4) in -- #17
+//│         jump j$0(x$5) -- #16
+//│   def j$0(x$2) =
+//│     x$2 -- #4
+//│   def even(x$6) =
+//│     case x$6 of -- #36
+//│       O =>
+//│         let x$8 = True() in -- #24
+//│         jump j$1(x$8) -- #23
+//│       S =>
+//│         let x$9 = S.s(x$6) in -- #35
+//│         let* (x$10) = odd(x$9) in -- #34
+//│         jump j$1(x$10) -- #33
+//│   def j$1(x$7) =
+//│     x$7 -- #21
+//│   def mk(n$0) =
+//│     let x$11 = >(n$0,0) in -- #64
+//│     if x$11 -- #63
+//│       true =>
+//│         let x$13 = -(n$0,1) in -- #59
+//│         let* (x$14) = mk(x$13) in -- #58
+//│         let x$15 = S(x$14) in -- #57
+//│         jump j$2(x$15) -- #56
+//│       false =>
+//│         let x$16 = O() in -- #62
+//│         jump j$2(x$16) -- #61
+//│   def j$2(x$12) =
+//│     x$12 -- #43
+//│   def foo() =
+//│     let* (x$17) = mk(10) in -- #73
+//│     let* (x$18) = odd(x$17) in -- #72
+//│     x$18 -- #71
+//│   let* (x$0) = foo() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
+//│ False()
 //│ 
-//│ IR Processing Failed: can not find the matched case, ClassInfo(0, True, []) expected
 
 :interpIR
-class True
-class False
-class S(s)
-class O
+:genCpp
 fun odd(x) =
   if x is
     O then False
@@ -421,79 +380,63 @@ fun even(x) =
 fun mk(n) = if n > 0 then S(mk(n - 1)) else O
 fun foo() = odd(S(S(mk(10))))
 foo()
-//│ |#class| |True|↵|#class| |False|↵|#class| |S|(|s|)|↵|#class| |O|↵|#fun| |odd|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |False|↵|S|(|s|)| |#then| |even|(|s|)|←|←|↵|#fun| |even|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |True|↵|S|(|s|)| |#then| |odd|(|s|)|←|←|↵|#fun| |mk|(|n|)| |#=| |#if| |n| |>| |0| |#then| |S|(|mk|(|n| |-| |1|)|)| |#else| |O|↵|#fun| |foo|(||)| |#=| |odd|(|S|(|S|(|mk|(|10|)|)|)|)|↵|foo|(||)|
-//│ Parsed: {class True {}; class False {}; class S(s,) {}; class O {}; fun odd = (x,) => {if x is ‹(O) then False; (S(s,)) then even(s,)›}; fun even = (x,) => {if x is ‹(O) then True; (S(s,)) then odd(s,)›}; fun mk = (n,) => if (>(n,)(0,)) then S(mk(-(n,)(1,),),) else O; fun foo = () => odd(S(S(mk(10,),),),); foo()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, S, [s]),ClassInfo(5, O, [])}, {
-//│ Def(0, odd, [x$0],
-//│ 1, 
-//│ case x$0 of -- #15
-//│   O =>
-//│     let x$2 = False() in -- #4
-//│     jump j$0(x$2) -- #3
-//│   S =>
-//│     let x$3 = x$0.s in -- #14
-//│     let* (x$4) = even(x$3) in -- #13
-//│     jump j$0(x$4) -- #12
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #1
-//│ )
-//│ Def(2, even, [x$5],
-//│ 1, 
-//│ case x$5 of -- #31
-//│   O =>
-//│     let x$7 = True() in -- #20
-//│     jump j$1(x$7) -- #19
-//│   S =>
-//│     let x$8 = x$5.s in -- #30
-//│     let* (x$9) = odd(x$8) in -- #29
-//│     jump j$1(x$9) -- #28
-//│ )
-//│ Def(3, j$1, [x$6],
-//│ 1, 
-//│ x$6 -- #17
-//│ )
-//│ Def(4, mk, [n$0],
-//│ 1, 
-//│ let x$10 = >(n$0,0) in -- #54
-//│ if x$10 -- #53
-//│   true =>
-//│     let x$12 = -(n$0,1) in -- #49
-//│     let* (x$13) = mk(x$12) in -- #48
-//│     let x$14 = S(x$13) in -- #47
-//│     jump j$2(x$14) -- #46
-//│   false =>
-//│     let x$15 = O() in -- #52
-//│     jump j$2(x$15) -- #51
-//│ )
-//│ Def(5, j$2, [x$11],
-//│ 1, 
-//│ x$11 -- #35
-//│ )
-//│ Def(6, foo, [],
-//│ 1, 
-//│ let* (x$16) = mk(10) in -- #73
-//│ let x$17 = S(x$16) in -- #72
-//│ let x$18 = S(x$17) in -- #71
-//│ let* (x$19) = odd(x$18) in -- #70
-//│ x$19 -- #69
-//│ )
-//│ },
-//│ let* (x$20) = foo() in -- #77
-//│ x$20 -- #76)
+//│ |#fun| |odd|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |False|↵|S|(|s|)| |#then| |even|(|s|)|←|←|↵|#fun| |even|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |True|↵|S|(|s|)| |#then| |odd|(|s|)|←|←|↵|#fun| |mk|(|n|)| |#=| |#if| |n| |>| |0| |#then| |S|(|mk|(|n| |-| |1|)|)| |#else| |O|↵|#fun| |foo|(||)| |#=| |odd|(|S|(|S|(|mk|(|10|)|)|)|)|↵|foo|(||)|
+//│ Parsed: {fun odd = (x,) => {if x is ‹(O) then False; (S(s,)) then even(s,)›}; fun even = (x,) => {if x is ‹(O) then True; (S(s,)) then odd(s,)›}; fun mk = (n,) => if (>(n, 0,)) then S(mk(-(n, 1,),),) else O; fun foo = () => odd(S(S(mk(10,),),),); foo()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def odd(x$1) =
+//│     case x$1 of -- #19
+//│       O =>
+//│         let x$3 = False() in -- #7
+//│         jump j$0(x$3) -- #6
+//│       S =>
+//│         let x$4 = S.s(x$1) in -- #18
+//│         let* (x$5) = even(x$4) in -- #17
+//│         jump j$0(x$5) -- #16
+//│   def j$0(x$2) =
+//│     x$2 -- #4
+//│   def even(x$6) =
+//│     case x$6 of -- #36
+//│       O =>
+//│         let x$8 = True() in -- #24
+//│         jump j$1(x$8) -- #23
+//│       S =>
+//│         let x$9 = S.s(x$6) in -- #35
+//│         let* (x$10) = odd(x$9) in -- #34
+//│         jump j$1(x$10) -- #33
+//│   def j$1(x$7) =
+//│     x$7 -- #21
+//│   def mk(n$0) =
+//│     let x$11 = >(n$0,0) in -- #64
+//│     if x$11 -- #63
+//│       true =>
+//│         let x$13 = -(n$0,1) in -- #59
+//│         let* (x$14) = mk(x$13) in -- #58
+//│         let x$15 = S(x$14) in -- #57
+//│         jump j$2(x$15) -- #56
+//│       false =>
+//│         let x$16 = O() in -- #62
+//│         jump j$2(x$16) -- #61
+//│   def j$2(x$12) =
+//│     x$12 -- #43
+//│   def foo() =
+//│     let* (x$17) = mk(10) in -- #81
+//│     let x$18 = S(x$17) in -- #80
+//│     let x$19 = S(x$18) in -- #79
+//│     let* (x$20) = odd(x$19) in -- #78
+//│     x$20 -- #77
+//│   let* (x$0) = foo() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
+//│ False()
 //│ 
-//│ IR Processing Failed: can not find the matched case, ClassInfo(0, True, []) expected
 
 :interpIR
-class True
-class False
-class S(s)
-class O
+:genCpp
 fun odd(x) =
   if x is
     O then False
@@ -508,95 +451,75 @@ fun main() =
   foo()
   bar()
 main()
-//│ |#class| |True|↵|#class| |False|↵|#class| |S|(|s|)|↵|#class| |O|↵|#fun| |odd|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |False|↵|S|(|s|)| |#then| |even|(|s|)|←|←|↵|#fun| |even|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |True|↵|S|(|s|)| |#then| |odd|(|s|)|←|←|↵|#fun| |foo|(||)| |#=| |odd|(|#if| |10| |>| |0| |#then| |S|(|O|)| |#else| |O|)|↵|#fun| |bar|(||)| |#=| |#if| |10| |>| |0| |#then| |odd|(|S|(|O|)|)| |#else| |odd|(|O|)|↵|#fun| |main|(||)| |#=|→|foo|(||)|↵|bar|(||)|←|↵|main|(||)|
-//│ Parsed: {class True {}; class False {}; class S(s,) {}; class O {}; fun odd = (x,) => {if x is ‹(O) then False; (S(s,)) then even(s,)›}; fun even = (x,) => {if x is ‹(O) then True; (S(s,)) then odd(s,)›}; fun foo = () => odd(if (>(10,)(0,)) then S(O,) else O,); fun bar = () => if (>(10,)(0,)) then odd(S(O,),) else odd(O,); fun main = () => {foo(); bar()}; main()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, S, [s]),ClassInfo(5, O, [])}, {
-//│ Def(0, odd, [x$0],
-//│ 1, 
-//│ case x$0 of -- #15
-//│   O =>
-//│     let x$2 = False() in -- #4
-//│     jump j$0(x$2) -- #3
-//│   S =>
-//│     let x$3 = x$0.s in -- #14
-//│     let* (x$4) = even(x$3) in -- #13
-//│     jump j$0(x$4) -- #12
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #1
-//│ )
-//│ Def(2, even, [x$5],
-//│ 1, 
-//│ case x$5 of -- #31
-//│   O =>
-//│     let x$7 = True() in -- #20
-//│     jump j$1(x$7) -- #19
-//│   S =>
-//│     let x$8 = x$5.s in -- #30
-//│     let* (x$9) = odd(x$8) in -- #29
-//│     jump j$1(x$9) -- #28
-//│ )
-//│ Def(3, j$1, [x$6],
-//│ 1, 
-//│ x$6 -- #17
-//│ )
-//│ Def(4, foo, [],
-//│ 1, 
-//│ let x$10 = >(10,0) in -- #52
-//│ if x$10 -- #51
-//│   true =>
-//│     let x$13 = O() in -- #47
-//│     let x$14 = S(x$13) in -- #46
-//│     jump j$2(x$14) -- #45
-//│   false =>
-//│     let x$15 = O() in -- #50
-//│     jump j$2(x$15) -- #49
-//│ )
-//│ Def(5, j$2, [x$11],
-//│ 1, 
-//│ let* (x$12) = odd(x$11) in -- #40
-//│ x$12 -- #39
-//│ )
-//│ Def(6, bar, [],
-//│ 1, 
-//│ let x$16 = >(10,0) in -- #78
-//│ if x$16 -- #77
-//│   true =>
-//│     let x$18 = O() in -- #68
-//│     let x$19 = S(x$18) in -- #67
-//│     let* (x$20) = odd(x$19) in -- #66
-//│     jump j$3(x$20) -- #65
-//│   false =>
-//│     let x$21 = O() in -- #76
-//│     let* (x$22) = odd(x$21) in -- #75
-//│     jump j$3(x$22) -- #74
-//│ )
-//│ Def(7, j$3, [x$17],
-//│ 1, 
-//│ x$17 -- #56
-//│ )
-//│ Def(8, main, [],
-//│ 1, 
-//│ let* (x$23) = foo() in -- #86
-//│ let* (x$24) = bar() in -- #85
-//│ x$24 -- #84
-//│ )
-//│ },
-//│ let* (x$25) = main() in -- #90
-//│ x$25 -- #89)
+//│ |#fun| |odd|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |False|↵|S|(|s|)| |#then| |even|(|s|)|←|←|↵|#fun| |even|(|x|)| |#=|→|#if| |x| |is|→|O| |#then| |True|↵|S|(|s|)| |#then| |odd|(|s|)|←|←|↵|#fun| |foo|(||)| |#=| |odd|(|#if| |10| |>| |0| |#then| |S|(|O|)| |#else| |O|)|↵|#fun| |bar|(||)| |#=| |#if| |10| |>| |0| |#then| |odd|(|S|(|O|)|)| |#else| |odd|(|O|)|↵|#fun| |main|(||)| |#=|→|foo|(||)|↵|bar|(||)|←|↵|main|(||)|
+//│ Parsed: {fun odd = (x,) => {if x is ‹(O) then False; (S(s,)) then even(s,)›}; fun even = (x,) => {if x is ‹(O) then True; (S(s,)) then odd(s,)›}; fun foo = () => odd(if (>(10, 0,)) then S(O,) else O,); fun bar = () => if (>(10, 0,)) then odd(S(O,),) else odd(O,); fun main = () => {foo(); bar()}; main()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def odd(x$1) =
+//│     case x$1 of -- #19
+//│       O =>
+//│         let x$3 = False() in -- #7
+//│         jump j$0(x$3) -- #6
+//│       S =>
+//│         let x$4 = S.s(x$1) in -- #18
+//│         let* (x$5) = even(x$4) in -- #17
+//│         jump j$0(x$5) -- #16
+//│   def j$0(x$2) =
+//│     x$2 -- #4
+//│   def even(x$6) =
+//│     case x$6 of -- #36
+//│       O =>
+//│         let x$8 = True() in -- #24
+//│         jump j$1(x$8) -- #23
+//│       S =>
+//│         let x$9 = S.s(x$6) in -- #35
+//│         let* (x$10) = odd(x$9) in -- #34
+//│         jump j$1(x$10) -- #33
+//│   def j$1(x$7) =
+//│     x$7 -- #21
+//│   def foo() =
+//│     let x$11 = >(10,0) in -- #59
+//│     if x$11 -- #58
+//│       true =>
+//│         let x$14 = O() in -- #54
+//│         let x$15 = S(x$14) in -- #53
+//│         jump j$2(x$15) -- #52
+//│       false =>
+//│         let x$16 = O() in -- #57
+//│         jump j$2(x$16) -- #56
+//│   def j$2(x$12) =
+//│     let* (x$13) = odd(x$12) in -- #47
+//│     x$13 -- #46
+//│   def bar() =
+//│     let x$17 = >(10,0) in -- #86
+//│     if x$17 -- #85
+//│       true =>
+//│         let x$19 = O() in -- #77
+//│         let x$20 = S(x$19) in -- #76
+//│         let* (x$21) = odd(x$20) in -- #75
+//│         jump j$3(x$21) -- #74
+//│       false =>
+//│         let x$22 = O() in -- #84
+//│         let* (x$23) = odd(x$22) in -- #83
+//│         jump j$3(x$23) -- #82
+//│   def j$3(x$18) =
+//│     x$18 -- #66
+//│   def main() =
+//│     let* (x$24) = foo() in -- #92
+//│     let* (x$25) = bar() in -- #91
+//│     x$25 -- #90
+//│   let* (x$0) = main() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
+//│ True()
 //│ 
-//│ IR Processing Failed: can not find the matched case, ClassInfo(0, True, []) expected
 
 :interpIR
-class True
-class False
-class A()
-class B(b)
+:genCpp
 fun aaa() =
   let m = 1
   let n = 2
@@ -609,98 +532,79 @@ fun bbb() =
 fun not(x) =
   if x then False else True
 fun foo(x) =
-  if x then A else B(foo(not(x)))
+  if x then None else Some(foo(not(x)))
 fun main(flag) =
   let x = foo(flag)
   if x is
-    A then aaa()
-    B(b1) then bbb()
+    None then aaa()
+    Some(b1) then bbb()
 main(False)
-//│ |#class| |True|↵|#class| |False|↵|#class| |A|(||)|↵|#class| |B|(|b|)|↵|#fun| |aaa|(||)| |#=|→|#let| |m| |#=| |1|↵|#let| |n| |#=| |2|↵|#let| |p| |#=| |3|↵|#let| |q| |#=| |4|↵|m| |+| |n| |-| |p| |+| |q|←|↵|#fun| |bbb|(||)| |#=|→|#let| |x| |#=| |aaa|(||)|↵|x| |*| |100| |+| |4|←|↵|#fun| |not|(|x|)| |#=|→|#if| |x| |#then| |False| |#else| |True|←|↵|#fun| |foo|(|x|)| |#=|→|#if| |x| |#then| |A| |#else| |B|(|foo|(|not|(|x|)|)|)|←|↵|#fun| |main|(|flag|)| |#=|→|#let| |x| |#=| |foo|(|flag|)|↵|#if| |x| |is|→|A| |#then| |aaa|(||)|↵|B|(|b1|)| |#then| |bbb|(||)|←|←|↵|main|(|False|)|
-//│ Parsed: {class True {}; class False {}; class A() {}; class B(b,) {}; fun aaa = () => {let m = 1; let n = 2; let p = 3; let q = 4; +(-(+(m,)(n,),)(p,),)(q,)}; fun bbb = () => {let x = aaa(); +(*(x,)(100,),)(4,)}; fun not = (x,) => {if (x) then False else True}; fun foo = (x,) => {if (x) then A else B(foo(not(x,),),)}; fun main = (flag,) => {let x = foo(flag,); if x is ‹(A) then aaa(); (B(b1,)) then bbb()›}; main(False,)}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, A, []),ClassInfo(5, B, [b])}, {
-//│ Def(0, aaa, [],
-//│ 1, 
-//│ let x$0 = 1 in -- #17
-//│ let x$1 = 2 in -- #16
-//│ let x$2 = 3 in -- #15
-//│ let x$3 = 4 in -- #14
-//│ let x$4 = +(x$0,x$1) in -- #13
-//│ let x$5 = -(x$4,x$2) in -- #12
-//│ let x$6 = +(x$5,x$3) in -- #11
-//│ x$6 -- #10
-//│ )
-//│ Def(1, bbb, [],
-//│ 1, 
-//│ let* (x$7) = aaa() in -- #28
-//│ let x$8 = *(x$7,100) in -- #27
-//│ let x$9 = +(x$8,4) in -- #26
-//│ x$9 -- #25
-//│ )
-//│ Def(2, not, [x$10],
-//│ 1, 
-//│ if x$10 -- #37
-//│   true =>
-//│     let x$12 = False() in -- #33
-//│     jump j$0(x$12) -- #32
-//│   false =>
-//│     let x$13 = True() in -- #36
-//│     jump j$0(x$13) -- #35
-//│ )
-//│ Def(3, j$0, [x$11],
-//│ 1, 
-//│ x$11 -- #30
-//│ )
-//│ Def(4, foo, [x$14],
-//│ 1, 
-//│ if x$14 -- #59
-//│   true =>
-//│     let x$16 = A() in -- #42
-//│     jump j$1(x$16) -- #41
-//│   false =>
-//│     let* (x$17) = not(x$14) in -- #58
-//│     let* (x$18) = foo(x$17) in -- #57
-//│     let x$19 = B(x$18) in -- #56
-//│     jump j$1(x$19) -- #55
-//│ )
-//│ Def(5, j$1, [x$15],
-//│ 1, 
-//│ x$15 -- #39
-//│ )
-//│ Def(6, main, [flag$0],
-//│ 1, 
-//│ let* (x$20) = foo(flag$0) in -- #81
-//│ case x$20 of -- #80
-//│   A =>
-//│     let* (x$22) = aaa() in -- #71
-//│     jump j$2(x$22) -- #70
-//│   B =>
-//│     let x$23 = x$20.b in -- #79
-//│     let* (x$24) = bbb() in -- #78
-//│     jump j$2(x$24) -- #77
-//│ )
-//│ Def(7, j$2, [x$21],
-//│ 1, 
-//│ x$21 -- #66
-//│ )
-//│ },
-//│ let x$25 = False() in -- #88
-//│ let* (x$26) = main(x$25) in -- #87
-//│ x$26 -- #86)
+//│ |#fun| |aaa|(||)| |#=|→|#let| |m| |#=| |1|↵|#let| |n| |#=| |2|↵|#let| |p| |#=| |3|↵|#let| |q| |#=| |4|↵|m| |+| |n| |-| |p| |+| |q|←|↵|#fun| |bbb|(||)| |#=|→|#let| |x| |#=| |aaa|(||)|↵|x| |*| |100| |+| |4|←|↵|#fun| |not|(|x|)| |#=|→|#if| |x| |#then| |False| |#else| |True|←|↵|#fun| |foo|(|x|)| |#=|→|#if| |x| |#then| |None| |#else| |Some|(|foo|(|not|(|x|)|)|)|←|↵|#fun| |main|(|flag|)| |#=|→|#let| |x| |#=| |foo|(|flag|)|↵|#if| |x| |is|→|None| |#then| |aaa|(||)|↵|Some|(|b1|)| |#then| |bbb|(||)|←|←|↵|main|(|False|)|
+//│ Parsed: {fun aaa = () => {let m = 1; let n = 2; let p = 3; let q = 4; +(-(+(m, n,), p,), q,)}; fun bbb = () => {let x = aaa(); +(*(x, 100,), 4,)}; fun not = (x,) => {if (x) then False else True}; fun foo = (x,) => {if (x) then None else Some(foo(not(x,),),)}; fun main = (flag,) => {let x = foo(flag,); if x is ‹(None) then aaa(); (Some(b1,)) then bbb()›}; main(False,)}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def aaa() =
+//│     let x$2 = 1 in -- #32
+//│     let x$3 = 2 in -- #31
+//│     let x$4 = 3 in -- #30
+//│     let x$5 = 4 in -- #29
+//│     let x$6 = +(x$2,x$3) in -- #28
+//│     let x$7 = -(x$6,x$4) in -- #27
+//│     let x$8 = +(x$7,x$5) in -- #26
+//│     x$8 -- #25
+//│   def bbb() =
+//│     let* (x$9) = aaa() in -- #48
+//│     let x$10 = *(x$9,100) in -- #47
+//│     let x$11 = +(x$10,4) in -- #46
+//│     x$11 -- #45
+//│   def not(x$12) =
+//│     if x$12 -- #57
+//│       true =>
+//│         let x$14 = False() in -- #53
+//│         jump j$0(x$14) -- #52
+//│       false =>
+//│         let x$15 = True() in -- #56
+//│         jump j$0(x$15) -- #55
+//│   def j$0(x$13) =
+//│     x$13 -- #50
+//│   def foo(x$16) =
+//│     if x$16 -- #77
+//│       true =>
+//│         let x$18 = None() in -- #62
+//│         jump j$1(x$18) -- #61
+//│       false =>
+//│         let* (x$19) = not(x$16) in -- #76
+//│         let* (x$20) = foo(x$19) in -- #75
+//│         let x$21 = Some(x$20) in -- #74
+//│         jump j$1(x$21) -- #73
+//│   def j$1(x$17) =
+//│     x$17 -- #59
+//│   def main(flag$0) =
+//│     let* (x$22) = foo(flag$0) in -- #98
+//│     case x$22 of -- #97
+//│       None =>
+//│         let* (x$24) = aaa() in -- #87
+//│         jump j$2(x$24) -- #86
+//│       Some =>
+//│         let x$25 = Some.x(x$22) in -- #96
+//│         let* (x$26) = bbb() in -- #95
+//│         jump j$2(x$26) -- #94
+//│   def j$2(x$23) =
+//│     x$23 -- #83
+//│   let x$0 = False() in -- #5
+//│   let* (x$1) = main(x$0) in -- #4
+//│   x$1 -- #3
 //│ 
 //│ Interpreted:
 //│ 404
+//│ 
 
 
 :interpIR
-class True
-class False
-class Cons(h, t)
-class Nil
-class Some(x)
-class None
+:genCpp
 fun head_opt(l) =
   if l is
     Nil then None
@@ -714,70 +618,55 @@ fun is_empty(l) =
 fun main() =
   is_empty(Cons(1, Cons(2, Nil)))
 main()
-//│ |#class| |True|↵|#class| |False|↵|#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|#class| |Some|(|x|)|↵|#class| |None|↵|#fun| |head_opt|(|l|)| |#=|→|#if| |l| |is|→|Nil| |#then| |None|↵|Cons|(|h|,| |t|)| |#then| |Some|(|h|)|←|←|↵|#fun| |is_none|(|o|)| |#=|→|#if| |o| |is|→|None| |#then| |True|↵|Some|(|x|)| |#then| |False|←|←|↵|#fun| |is_empty|(|l|)| |#=|→|is_none|(|head_opt|(|l|)|)|←|↵|#fun| |main|(||)| |#=|→|is_empty|(|Cons|(|1|,| |Cons|(|2|,| |Nil|)|)|)|←|↵|main|(||)|
-//│ Parsed: {class True {}; class False {}; class Cons(h, t,) {}; class Nil {}; class Some(x,) {}; class None {}; fun head_opt = (l,) => {if l is ‹(Nil) then None; (Cons(h, t,)) then Some(h,)›}; fun is_none = (o,) => {if o is ‹(None) then True; (Some(x,)) then False›}; fun is_empty = (l,) => {is_none(head_opt(l,),)}; fun main = () => {is_empty(Cons(1, Cons(2, Nil,),),)}; main()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, Cons, [h,t]),ClassInfo(5, Nil, []),ClassInfo(6, Some, [x]),ClassInfo(7, None, [])}, {
-//│ Def(0, head_opt, [l$0],
-//│ 1, 
-//│ case l$0 of -- #17
-//│   Nil =>
-//│     let x$1 = None() in -- #4
-//│     jump j$0(x$1) -- #3
-//│   Cons =>
-//│     let x$2 = l$0.t in -- #16
-//│     let x$3 = l$0.h in -- #15
-//│     let x$4 = Some(x$3) in -- #14
-//│     jump j$0(x$4) -- #13
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, is_none, [o$0],
-//│ 1, 
-//│ case o$0 of -- #29
-//│   None =>
-//│     let x$6 = True() in -- #22
-//│     jump j$1(x$6) -- #21
-//│   Some =>
-//│     let x$7 = o$0.x in -- #28
-//│     let x$8 = False() in -- #27
-//│     jump j$1(x$8) -- #26
-//│ )
-//│ Def(3, j$1, [x$5],
-//│ 1, 
-//│ x$5 -- #19
-//│ )
-//│ Def(4, is_empty, [l$1],
-//│ 1, 
-//│ let* (x$9) = head_opt(l$1) in -- #40
-//│ let* (x$10) = is_none(x$9) in -- #39
-//│ x$10 -- #38
-//│ )
-//│ Def(5, main, [],
-//│ 1, 
-//│ let x$11 = Nil() in -- #59
-//│ let x$12 = Cons(2,x$11) in -- #58
-//│ let x$13 = Cons(1,x$12) in -- #57
-//│ let* (x$14) = is_empty(x$13) in -- #56
-//│ x$14 -- #55
-//│ )
-//│ },
-//│ let* (x$15) = main() in -- #63
-//│ x$15 -- #62)
+//│ |#fun| |head_opt|(|l|)| |#=|→|#if| |l| |is|→|Nil| |#then| |None|↵|Cons|(|h|,| |t|)| |#then| |Some|(|h|)|←|←|↵|#fun| |is_none|(|o|)| |#=|→|#if| |o| |is|→|None| |#then| |True|↵|Some|(|x|)| |#then| |False|←|←|↵|#fun| |is_empty|(|l|)| |#=|→|is_none|(|head_opt|(|l|)|)|←|↵|#fun| |main|(||)| |#=|→|is_empty|(|Cons|(|1|,| |Cons|(|2|,| |Nil|)|)|)|←|↵|main|(||)|
+//│ Parsed: {fun head_opt = (l,) => {if l is ‹(Nil) then None; (Cons(h, t,)) then Some(h,)›}; fun is_none = (o,) => {if o is ‹(None) then True; (Some(x,)) then False›}; fun is_empty = (l,) => {is_none(head_opt(l,),)}; fun main = () => {is_empty(Cons(1, Cons(2, Nil,),),)}; main()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def head_opt(l$0) =
+//│     case l$0 of -- #24
+//│       Nil =>
+//│         let x$2 = None() in -- #7
+//│         jump j$0(x$2) -- #6
+//│       Cons =>
+//│         let x$3 = Cons.t(l$0) in -- #23
+//│         let x$4 = Cons.h(l$0) in -- #22
+//│         let x$5 = Some(x$4) in -- #21
+//│         jump j$0(x$5) -- #20
+//│   def j$0(x$1) =
+//│     x$1 -- #4
+//│   def is_none(o$0) =
+//│     case o$0 of -- #38
+//│       None =>
+//│         let x$7 = True() in -- #29
+//│         jump j$1(x$7) -- #28
+//│       Some =>
+//│         let x$8 = Some.x(o$0) in -- #37
+//│         let x$9 = False() in -- #36
+//│         jump j$1(x$9) -- #35
+//│   def j$1(x$6) =
+//│     x$6 -- #26
+//│   def is_empty(l$1) =
+//│     let* (x$10) = head_opt(l$1) in -- #47
+//│     let* (x$11) = is_none(x$10) in -- #46
+//│     x$11 -- #45
+//│   def main() =
+//│     let x$12 = Nil() in -- #65
+//│     let x$13 = Cons(2,x$12) in -- #64
+//│     let x$14 = Cons(1,x$13) in -- #63
+//│     let* (x$15) = is_empty(x$14) in -- #62
+//│     x$15 -- #61
+//│   let* (x$0) = main() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ False()
+//│ 
 
 :interpIR
-class True
-class False
-class Cons(h, t)
-class Nil
-class Some(x)
-class None
+:genCpp
 fun mk_list(n) =
   if n == 0 then Nil else Cons(n, mk_list(n - 1))
 fun head_opt(l) =
@@ -793,86 +682,66 @@ fun is_empty(l) =
 fun main() =
   is_empty(mk_list(10))
 main()
-//│ |#class| |True|↵|#class| |False|↵|#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|#class| |Some|(|x|)|↵|#class| |None|↵|#fun| |mk_list|(|n|)| |#=|→|#if| |n| |==| |0| |#then| |Nil| |#else| |Cons|(|n|,| |mk_list|(|n| |-| |1|)|)|←|↵|#fun| |head_opt|(|l|)| |#=|→|#if| |l| |is|→|Nil| |#then| |None|↵|Cons|(|h|,| |t|)| |#then| |Some|(|h|)|←|←|↵|#fun| |is_none|(|o|)| |#=|→|#if| |o| |is|→|None| |#then| |True|↵|Some|(|x|)| |#then| |False|←|←|↵|#fun| |is_empty|(|l|)| |#=|→|is_none|(|head_opt|(|l|)|)|←|↵|#fun| |main|(||)| |#=|→|is_empty|(|mk_list|(|10|)|)|←|↵|main|(||)|
-//│ Parsed: {class True {}; class False {}; class Cons(h, t,) {}; class Nil {}; class Some(x,) {}; class None {}; fun mk_list = (n,) => {if (==(n,)(0,)) then Nil else Cons(n, mk_list(-(n,)(1,),),)}; fun head_opt = (l,) => {if l is ‹(Nil) then None; (Cons(h, t,)) then Some(h,)›}; fun is_none = (o,) => {if o is ‹(None) then True; (Some(x,)) then False›}; fun is_empty = (l,) => {is_none(head_opt(l,),)}; fun main = () => {is_empty(mk_list(10,),)}; main()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, Cons, [h,t]),ClassInfo(5, Nil, []),ClassInfo(6, Some, [x]),ClassInfo(7, None, [])}, {
-//│ Def(0, mk_list, [n$0],
-//│ 1, 
-//│ let x$0 = ==(n$0,0) in -- #24
-//│ if x$0 -- #23
-//│   true =>
-//│     let x$2 = Nil() in -- #6
-//│     jump j$0(x$2) -- #5
-//│   false =>
-//│     let x$3 = -(n$0,1) in -- #22
-//│     let* (x$4) = mk_list(x$3) in -- #21
-//│     let x$5 = Cons(n$0,x$4) in -- #20
-//│     jump j$0(x$5) -- #19
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #3
-//│ )
-//│ Def(2, head_opt, [l$0],
-//│ 1, 
-//│ case l$0 of -- #42
-//│   Nil =>
-//│     let x$7 = None() in -- #29
-//│     jump j$1(x$7) -- #28
-//│   Cons =>
-//│     let x$8 = l$0.t in -- #41
-//│     let x$9 = l$0.h in -- #40
-//│     let x$10 = Some(x$9) in -- #39
-//│     jump j$1(x$10) -- #38
-//│ )
-//│ Def(3, j$1, [x$6],
-//│ 1, 
-//│ x$6 -- #26
-//│ )
-//│ Def(4, is_none, [o$0],
-//│ 1, 
-//│ case o$0 of -- #54
-//│   None =>
-//│     let x$12 = True() in -- #47
-//│     jump j$2(x$12) -- #46
-//│   Some =>
-//│     let x$13 = o$0.x in -- #53
-//│     let x$14 = False() in -- #52
-//│     jump j$2(x$14) -- #51
-//│ )
-//│ Def(5, j$2, [x$11],
-//│ 1, 
-//│ x$11 -- #44
-//│ )
-//│ Def(6, is_empty, [l$1],
-//│ 1, 
-//│ let* (x$15) = head_opt(l$1) in -- #65
-//│ let* (x$16) = is_none(x$15) in -- #64
-//│ x$16 -- #63
-//│ )
-//│ Def(7, main, [],
-//│ 1, 
-//│ let* (x$17) = mk_list(10) in -- #76
-//│ let* (x$18) = is_empty(x$17) in -- #75
-//│ x$18 -- #74
-//│ )
-//│ },
-//│ let* (x$19) = main() in -- #80
-//│ x$19 -- #79)
+//│ |#fun| |mk_list|(|n|)| |#=|→|#if| |n| |==| |0| |#then| |Nil| |#else| |Cons|(|n|,| |mk_list|(|n| |-| |1|)|)|←|↵|#fun| |head_opt|(|l|)| |#=|→|#if| |l| |is|→|Nil| |#then| |None|↵|Cons|(|h|,| |t|)| |#then| |Some|(|h|)|←|←|↵|#fun| |is_none|(|o|)| |#=|→|#if| |o| |is|→|None| |#then| |True|↵|Some|(|x|)| |#then| |False|←|←|↵|#fun| |is_empty|(|l|)| |#=|→|is_none|(|head_opt|(|l|)|)|←|↵|#fun| |main|(||)| |#=|→|is_empty|(|mk_list|(|10|)|)|←|↵|main|(||)|
+//│ Parsed: {fun mk_list = (n,) => {if (==(n, 0,)) then Nil else Cons(n, mk_list(-(n, 1,),),)}; fun head_opt = (l,) => {if l is ‹(Nil) then None; (Cons(h, t,)) then Some(h,)›}; fun is_none = (o,) => {if o is ‹(None) then True; (Some(x,)) then False›}; fun is_empty = (l,) => {is_none(head_opt(l,),)}; fun main = () => {is_empty(mk_list(10,),)}; main()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def mk_list(n$0) =
+//│     let x$1 = ==(n$0,0) in -- #32
+//│     if x$1 -- #31
+//│       true =>
+//│         let x$3 = Nil() in -- #12
+//│         jump j$0(x$3) -- #11
+//│       false =>
+//│         let x$4 = -(n$0,1) in -- #30
+//│         let* (x$5) = mk_list(x$4) in -- #29
+//│         let x$6 = Cons(n$0,x$5) in -- #28
+//│         jump j$0(x$6) -- #27
+//│   def j$0(x$2) =
+//│     x$2 -- #9
+//│   def head_opt(l$0) =
+//│     case l$0 of -- #54
+//│       Nil =>
+//│         let x$8 = None() in -- #37
+//│         jump j$1(x$8) -- #36
+//│       Cons =>
+//│         let x$9 = Cons.t(l$0) in -- #53
+//│         let x$10 = Cons.h(l$0) in -- #52
+//│         let x$11 = Some(x$10) in -- #51
+//│         jump j$1(x$11) -- #50
+//│   def j$1(x$7) =
+//│     x$7 -- #34
+//│   def is_none(o$0) =
+//│     case o$0 of -- #68
+//│       None =>
+//│         let x$13 = True() in -- #59
+//│         jump j$2(x$13) -- #58
+//│       Some =>
+//│         let x$14 = Some.x(o$0) in -- #67
+//│         let x$15 = False() in -- #66
+//│         jump j$2(x$15) -- #65
+//│   def j$2(x$12) =
+//│     x$12 -- #56
+//│   def is_empty(l$1) =
+//│     let* (x$16) = head_opt(l$1) in -- #77
+//│     let* (x$17) = is_none(x$16) in -- #76
+//│     x$17 -- #75
+//│   def main() =
+//│     let* (x$18) = mk_list(10) in -- #86
+//│     let* (x$19) = is_empty(x$18) in -- #85
+//│     x$19 -- #84
+//│   let* (x$0) = main() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
+//│ False()
 //│ 
-//│ IR Processing Failed: can not find the matched case, ClassInfo(1, False, []) expected
 
 :interpIR
-class True
-class False
-class Cons(h, t)
-class Nil
-class Some(x)
-class None
+:genCpp
 fun mk_list(n) =
   if n == 0 then Nil else Cons(n, mk_list(n - 1))
 fun last_opt(l) =
@@ -885,76 +754,60 @@ fun last_opt(l) =
 fun main() =
   last_opt(mk_list(10))
 main()
-//│ |#class| |True|↵|#class| |False|↵|#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|#class| |Some|(|x|)|↵|#class| |None|↵|#fun| |mk_list|(|n|)| |#=|→|#if| |n| |==| |0| |#then| |Nil| |#else| |Cons|(|n|,| |mk_list|(|n| |-| |1|)|)|←|↵|#fun| |last_opt|(|l|)| |#=|→|#if| |l| |is|→|Nil| |#then| |None|↵|Cons|(|h|,| |t|)| |#then|→|#if| |t| |is|→|Nil| |#then| |Some|(|h|)|↵|Cons|(|h2|,| |t2|)| |#then| |last_opt|(|t|)|←|←|←|←|↵|#fun| |main|(||)| |#=|→|last_opt|(|mk_list|(|10|)|)|←|↵|main|(||)|
-//│ Parsed: {class True {}; class False {}; class Cons(h, t,) {}; class Nil {}; class Some(x,) {}; class None {}; fun mk_list = (n,) => {if (==(n,)(0,)) then Nil else Cons(n, mk_list(-(n,)(1,),),)}; fun last_opt = (l,) => {if l is ‹(Nil) then None; (Cons(h, t,)) then {if t is ‹(Nil) then Some(h,); (Cons(h2, t2,)) then last_opt(t,)›}›}; fun main = () => {last_opt(mk_list(10,),)}; main()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, Cons, [h,t]),ClassInfo(5, Nil, []),ClassInfo(6, Some, [x]),ClassInfo(7, None, [])}, {
-//│ Def(0, mk_list, [n$0],
-//│ 1, 
-//│ let x$0 = ==(n$0,0) in -- #24
-//│ if x$0 -- #23
-//│   true =>
-//│     let x$2 = Nil() in -- #6
-//│     jump j$0(x$2) -- #5
-//│   false =>
-//│     let x$3 = -(n$0,1) in -- #22
-//│     let* (x$4) = mk_list(x$3) in -- #21
-//│     let x$5 = Cons(n$0,x$4) in -- #20
-//│     jump j$0(x$5) -- #19
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #3
-//│ )
-//│ Def(2, last_opt, [l$0],
-//│ 1, 
-//│ case l$0 of -- #59
-//│   Nil =>
-//│     let x$7 = None() in -- #29
-//│     jump j$1(x$7) -- #28
-//│   Cons =>
-//│     let x$8 = l$0.t in -- #58
-//│     let x$9 = l$0.h in -- #57
-//│     case x$8 of -- #56
+//│ |#fun| |mk_list|(|n|)| |#=|→|#if| |n| |==| |0| |#then| |Nil| |#else| |Cons|(|n|,| |mk_list|(|n| |-| |1|)|)|←|↵|#fun| |last_opt|(|l|)| |#=|→|#if| |l| |is|→|Nil| |#then| |None|↵|Cons|(|h|,| |t|)| |#then|→|#if| |t| |is|→|Nil| |#then| |Some|(|h|)|↵|Cons|(|h2|,| |t2|)| |#then| |last_opt|(|t|)|←|←|←|←|↵|#fun| |main|(||)| |#=|→|last_opt|(|mk_list|(|10|)|)|←|↵|main|(||)|
+//│ Parsed: {fun mk_list = (n,) => {if (==(n, 0,)) then Nil else Cons(n, mk_list(-(n, 1,),),)}; fun last_opt = (l,) => {if l is ‹(Nil) then None; (Cons(h, t,)) then {if t is ‹(Nil) then Some(h,); (Cons(h2, t2,)) then last_opt(t,)›}›}; fun main = () => {last_opt(mk_list(10,),)}; main()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def mk_list(n$0) =
+//│     let x$1 = ==(n$0,0) in -- #32
+//│     if x$1 -- #31
+//│       true =>
+//│         let x$3 = Nil() in -- #12
+//│         jump j$0(x$3) -- #11
+//│       false =>
+//│         let x$4 = -(n$0,1) in -- #30
+//│         let* (x$5) = mk_list(x$4) in -- #29
+//│         let x$6 = Cons(n$0,x$5) in -- #28
+//│         jump j$0(x$6) -- #27
+//│   def j$0(x$2) =
+//│     x$2 -- #9
+//│   def last_opt(l$0) =
+//│     case l$0 of -- #74
 //│       Nil =>
-//│         let x$11 = Some(x$9) in -- #42
-//│         jump j$2(x$11) -- #41
+//│         let x$8 = None() in -- #37
+//│         jump j$1(x$8) -- #36
 //│       Cons =>
-//│         let x$12 = x$8.t in -- #55
-//│         let x$13 = x$8.h in -- #54
-//│         let* (x$14) = last_opt(x$8) in -- #53
-//│         jump j$2(x$14) -- #52
-//│ )
-//│ Def(3, j$1, [x$6],
-//│ 1, 
-//│ x$6 -- #26
-//│ )
-//│ Def(4, j$2, [x$10],
-//│ 1, 
-//│ jump j$1(x$10) -- #36
-//│ )
-//│ Def(5, main, [],
-//│ 1, 
-//│ let* (x$15) = mk_list(10) in -- #70
-//│ let* (x$16) = last_opt(x$15) in -- #69
-//│ x$16 -- #68
-//│ )
-//│ },
-//│ let* (x$17) = main() in -- #74
-//│ x$17 -- #73)
+//│         let x$9 = Cons.t(l$0) in -- #73
+//│         let x$10 = Cons.h(l$0) in -- #72
+//│         case x$9 of -- #71
+//│           Nil =>
+//│             let x$12 = Some(x$10) in -- #54
+//│             jump j$2(x$12) -- #53
+//│           Cons =>
+//│             let x$13 = Cons.t(x$9) in -- #70
+//│             let x$14 = Cons.h(x$9) in -- #69
+//│             let* (x$15) = last_opt(x$9) in -- #68
+//│             jump j$2(x$15) -- #67
+//│   def j$1(x$7) =
+//│     x$7 -- #34
+//│   def j$2(x$11) =
+//│     jump j$1(x$11) -- #48
+//│   def main() =
+//│     let* (x$16) = mk_list(10) in -- #83
+//│     let* (x$17) = last_opt(x$16) in -- #82
+//│     x$17 -- #81
+//│   let* (x$0) = main() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
+//│ Some(1)
 //│ 
-//│ IR Processing Failed: can not find the matched case, ClassInfo(1, False, []) expected
 
 :interpIR
-class True
-class False
-class Cons(h, t)
-class Nil
-class Some(x)
-class None
+:genCpp
 fun is_some(o) =
   if o is
     Some(x) then True
@@ -981,111 +834,88 @@ fun f(x) =
 fun main() =
   f(Some(2)) + f(None)
 main()
-//│ |#class| |True|↵|#class| |False|↵|#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|#class| |Some|(|x|)|↵|#class| |None|↵|#fun| |is_some|(|o|)| |#=|→|#if| |o| |is|→|Some|(|x|)| |#then| |True|↵|None| |#then| |False|←|←|↵|#fun| |e0|(|w|)| |#=|→|w| |+| |8| |+| |9| |+| |10|←|↵|#fun| |e1|(|a|,| |c|)| |#=|→|a| |+| |1| |+| |2| |+| |3| |+| |4|←|↵|#fun| |e3|(|c|)| |#=|→|#let| |m| |#=| |4|↵|#let| |n| |#=| |5|↵|#let| |p| |#=| |6|↵|#let| |q| |#=| |7|↵|#if| |c| |#then| |m| |+| |n| |+| |p| |+| |q| |#else| |m| |+| |n| |-| |p| |+| |q|←|↵|#fun| |e2|(|x|)| |#=|→|x| |+| |12| |+| |13| |+| |14|←|↵|#fun| |f|(|x|)| |#=|→|#let| |c1| |#=| |is_some|(|x|)|↵|#let| |z| |#=| |e3|(|c1|)|↵|#let| |w| |#=| |#if| |x| |is|→|Some|(|a|)| |#then| |e1|(|a|,| |z|)|↵|None| |#then| |e2|(|z|)|←|↵|e0|(|w|)|←|↵|#fun| |main|(||)| |#=|→|f|(|Some|(|2|)|)| |+| |f|(|None|)|←|↵|main|(||)|
-//│ Parsed: {class True {}; class False {}; class Cons(h, t,) {}; class Nil {}; class Some(x,) {}; class None {}; fun is_some = (o,) => {if o is ‹(Some(x,)) then True; (None) then False›}; fun e0 = (w,) => {+(+(+(w,)(8,),)(9,),)(10,)}; fun e1 = (a, c,) => {+(+(+(+(a,)(1,),)(2,),)(3,),)(4,)}; fun e3 = (c,) => {let m = 4; let n = 5; let p = 6; let q = 7; if (c) then +(+(+(m,)(n,),)(p,),)(q,) else +(-(+(m,)(n,),)(p,),)(q,)}; fun e2 = (x,) => {+(+(+(x,)(12,),)(13,),)(14,)}; fun f = (x,) => {let c1 = is_some(x,); let z = e3(c1,); let w = if x is ‹(Some(a,)) then e1(a, z,); (None) then e2(z,)›; e0(w,)}; fun main = () => {+(f(Some(2,),),)(f(None,),)}; main()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, Cons, [h,t]),ClassInfo(5, Nil, []),ClassInfo(6, Some, [x]),ClassInfo(7, None, [])}, {
-//│ Def(0, is_some, [o$0],
-//│ 1, 
-//│ case o$0 of -- #11
-//│   Some =>
-//│     let x$1 = o$0.x in -- #7
-//│     let x$2 = True() in -- #6
-//│     jump j$0(x$2) -- #5
-//│   None =>
-//│     let x$3 = False() in -- #10
-//│     jump j$0(x$3) -- #9
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, e0, [w$0],
-//│ 1, 
-//│ let x$4 = +(w$0,8) in -- #21
-//│ let x$5 = +(x$4,9) in -- #20
-//│ let x$6 = +(x$5,10) in -- #19
-//│ x$6 -- #18
-//│ )
-//│ Def(3, e1, [a$0,c$0],
-//│ 1, 
-//│ let x$7 = +(a$0,1) in -- #34
-//│ let x$8 = +(x$7,2) in -- #33
-//│ let x$9 = +(x$8,3) in -- #32
-//│ let x$10 = +(x$9,4) in -- #31
-//│ x$10 -- #30
-//│ )
-//│ Def(4, e3, [c$1],
-//│ 1, 
-//│ let x$11 = 4 in -- #67
-//│ let x$12 = 5 in -- #66
-//│ let x$13 = 6 in -- #65
-//│ let x$14 = 7 in -- #64
-//│ if c$1 -- #63
-//│   true =>
-//│     let x$16 = +(x$11,x$12) in -- #51
-//│     let x$17 = +(x$16,x$13) in -- #50
-//│     let x$18 = +(x$17,x$14) in -- #49
-//│     jump j$1(x$18) -- #48
-//│   false =>
-//│     let x$19 = +(x$11,x$12) in -- #62
-//│     let x$20 = -(x$19,x$13) in -- #61
-//│     let x$21 = +(x$20,x$14) in -- #60
-//│     jump j$1(x$21) -- #59
-//│ )
-//│ Def(5, j$1, [x$15],
-//│ 1, 
-//│ x$15 -- #40
-//│ )
-//│ Def(6, e2, [x$22],
-//│ 1, 
-//│ let x$23 = +(x$22,12) in -- #77
-//│ let x$24 = +(x$23,13) in -- #76
-//│ let x$25 = +(x$24,14) in -- #75
-//│ x$25 -- #74
-//│ )
-//│ Def(7, f, [x$26],
-//│ 1, 
-//│ let* (x$27) = is_some(x$26) in -- #117
-//│ let* (x$28) = e3(x$27) in -- #116
-//│ case x$26 of -- #115
-//│   Some =>
-//│     let x$31 = x$26.x in -- #107
-//│     let* (x$32) = e1(x$31,x$28) in -- #106
-//│     jump j$2(x$32) -- #105
-//│   None =>
-//│     let* (x$33) = e2(x$28) in -- #114
-//│     jump j$2(x$33) -- #113
-//│ )
-//│ Def(8, j$2, [x$29],
-//│ 1, 
-//│ let* (x$30) = e0(x$29) in -- #95
-//│ x$30 -- #94
-//│ )
-//│ Def(9, main, [],
-//│ 1, 
-//│ let x$34 = Some(2) in -- #136
-//│ let* (x$35) = f(x$34) in -- #135
-//│ let x$36 = None() in -- #134
-//│ let* (x$37) = f(x$36) in -- #133
-//│ let x$38 = +(x$35,x$37) in -- #132
-//│ x$38 -- #131
-//│ )
-//│ },
-//│ let* (x$39) = main() in -- #140
-//│ x$39 -- #139)
+//│ |#fun| |is_some|(|o|)| |#=|→|#if| |o| |is|→|Some|(|x|)| |#then| |True|↵|None| |#then| |False|←|←|↵|#fun| |e0|(|w|)| |#=|→|w| |+| |8| |+| |9| |+| |10|←|↵|#fun| |e1|(|a|,| |c|)| |#=|→|a| |+| |1| |+| |2| |+| |3| |+| |4|←|↵|#fun| |e3|(|c|)| |#=|→|#let| |m| |#=| |4|↵|#let| |n| |#=| |5|↵|#let| |p| |#=| |6|↵|#let| |q| |#=| |7|↵|#if| |c| |#then| |m| |+| |n| |+| |p| |+| |q| |#else| |m| |+| |n| |-| |p| |+| |q|←|↵|#fun| |e2|(|x|)| |#=|→|x| |+| |12| |+| |13| |+| |14|←|↵|#fun| |f|(|x|)| |#=|→|#let| |c1| |#=| |is_some|(|x|)|↵|#let| |z| |#=| |e3|(|c1|)|↵|#let| |w| |#=| |#if| |x| |is|→|Some|(|a|)| |#then| |e1|(|a|,| |z|)|↵|None| |#then| |e2|(|z|)|←|↵|e0|(|w|)|←|↵|#fun| |main|(||)| |#=|→|f|(|Some|(|2|)|)| |+| |f|(|None|)|←|↵|main|(||)|
+//│ Parsed: {fun is_some = (o,) => {if o is ‹(Some(x,)) then True; (None) then False›}; fun e0 = (w,) => {+(+(+(w, 8,), 9,), 10,)}; fun e1 = (a, c,) => {+(+(+(+(a, 1,), 2,), 3,), 4,)}; fun e3 = (c,) => {let m = 4; let n = 5; let p = 6; let q = 7; if (c) then +(+(+(m, n,), p,), q,) else +(-(+(m, n,), p,), q,)}; fun e2 = (x,) => {+(+(+(x, 12,), 13,), 14,)}; fun f = (x,) => {let c1 = is_some(x,); let z = e3(c1,); let w = if x is ‹(Some(a,)) then e1(a, z,); (None) then e2(z,)›; e0(w,)}; fun main = () => {+(f(Some(2,),), f(None,),)}; main()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def is_some(o$0) =
+//│     case o$0 of -- #16
+//│       Some =>
+//│         let x$2 = Some.x(o$0) in -- #12
+//│         let x$3 = True() in -- #11
+//│         jump j$0(x$3) -- #10
+//│       None =>
+//│         let x$4 = False() in -- #15
+//│         jump j$0(x$4) -- #14
+//│   def j$0(x$1) =
+//│     x$1 -- #4
+//│   def e0(w$0) =
+//│     let x$5 = +(w$0,8) in -- #35
+//│     let x$6 = +(x$5,9) in -- #34
+//│     let x$7 = +(x$6,10) in -- #33
+//│     x$7 -- #32
+//│   def e1(a$0,c$0) =
+//│     let x$8 = +(a$0,1) in -- #60
+//│     let x$9 = +(x$8,2) in -- #59
+//│     let x$10 = +(x$9,3) in -- #58
+//│     let x$11 = +(x$10,4) in -- #57
+//│     x$11 -- #56
+//│   def e3(c$1) =
+//│     let x$12 = 4 in -- #111
+//│     let x$13 = 5 in -- #110
+//│     let x$14 = 6 in -- #109
+//│     let x$15 = 7 in -- #108
+//│     if c$1 -- #107
+//│       true =>
+//│         let x$17 = +(x$12,x$13) in -- #86
+//│         let x$18 = +(x$17,x$14) in -- #85
+//│         let x$19 = +(x$18,x$15) in -- #84
+//│         jump j$1(x$19) -- #83
+//│       false =>
+//│         let x$20 = +(x$12,x$13) in -- #106
+//│         let x$21 = -(x$20,x$14) in -- #105
+//│         let x$22 = +(x$21,x$15) in -- #104
+//│         jump j$1(x$22) -- #103
+//│   def j$1(x$16) =
+//│     x$16 -- #66
+//│   def e2(x$23) =
+//│     let x$24 = +(x$23,12) in -- #130
+//│     let x$25 = +(x$24,13) in -- #129
+//│     let x$26 = +(x$25,14) in -- #128
+//│     x$26 -- #127
+//│   def f(x$27) =
+//│     let* (x$28) = is_some(x$27) in -- #167
+//│     let* (x$29) = e3(x$28) in -- #166
+//│     case x$27 of -- #165
+//│       Some =>
+//│         let x$32 = Some.x(x$27) in -- #158
+//│         let* (x$33) = e1(x$32,x$29) in -- #157
+//│         jump j$2(x$33) -- #156
+//│       None =>
+//│         let* (x$34) = e2(x$29) in -- #164
+//│         jump j$2(x$34) -- #163
+//│   def j$2(x$30) =
+//│     let* (x$31) = e0(x$30) in -- #145
+//│     x$31 -- #144
+//│   def main() =
+//│     let x$35 = Some(2) in -- #187
+//│     let* (x$36) = f(x$35) in -- #186
+//│     let x$37 = None() in -- #185
+//│     let* (x$38) = f(x$37) in -- #184
+//│     let x$39 = +(x$36,x$38) in -- #183
+//│     x$39 -- #182
+//│   let* (x$0) = main() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
 //│ 115
+//│ 
 
 :interpIR
-class True
-class False
-class Cons(h, t)
-class Nil
-class Some(x)
-class None
+:genCpp
 fun is_some(o) =
   if o is
     Some(x) then True
@@ -1112,109 +942,198 @@ fun f(x) =
 fun main() =
   f(Some(2)) + f(None)
 main()
-//│ |#class| |True|↵|#class| |False|↵|#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|#class| |Some|(|x|)|↵|#class| |None|↵|#fun| |is_some|(|o|)| |#=|→|#if| |o| |is|→|Some|(|x|)| |#then| |True|↵|None| |#then| |False|←|←|↵|#fun| |e0|(|w|)| |#=|→|w| |+| |8| |+| |9| |+| |10|←|↵|#fun| |e1|(|a|,| |z|)| |#=|→|#if| |a| |>| |0| |#then| |f|(|Some|(|a| |-| |1|)|)| |#else| |z|←|↵|#fun| |e3|(|c|)| |#=|→|#let| |m| |#=| |4|↵|#let| |n| |#=| |5|↵|#let| |p| |#=| |6|↵|#let| |q| |#=| |7|↵|#if| |c| |#then| |m| |+| |n| |+| |p| |+| |q| |#else| |m| |+| |n| |-| |p| |+| |q|←|↵|#fun| |e2|(|x|)| |#=|→|x| |+| |12| |+| |13| |+| |14|←|↵|#fun| |f|(|x|)| |#=|→|#let| |c1| |#=| |is_some|(|x|)|↵|#let| |z| |#=| |e3|(|c1|)|↵|#let| |w| |#=| |#if| |x| |is|→|Some|(|a|)| |#then| |e1|(|a|,| |z|)|↵|None| |#then| |e2|(|z|)|←|↵|e0|(|w|)|←|↵|#fun| |main|(||)| |#=|→|f|(|Some|(|2|)|)| |+| |f|(|None|)|←|↵|main|(||)|
-//│ Parsed: {class True {}; class False {}; class Cons(h, t,) {}; class Nil {}; class Some(x,) {}; class None {}; fun is_some = (o,) => {if o is ‹(Some(x,)) then True; (None) then False›}; fun e0 = (w,) => {+(+(+(w,)(8,),)(9,),)(10,)}; fun e1 = (a, z,) => {if (>(a,)(0,)) then f(Some(-(a,)(1,),),) else z}; fun e3 = (c,) => {let m = 4; let n = 5; let p = 6; let q = 7; if (c) then +(+(+(m,)(n,),)(p,),)(q,) else +(-(+(m,)(n,),)(p,),)(q,)}; fun e2 = (x,) => {+(+(+(x,)(12,),)(13,),)(14,)}; fun f = (x,) => {let c1 = is_some(x,); let z = e3(c1,); let w = if x is ‹(Some(a,)) then e1(a, z,); (None) then e2(z,)›; e0(w,)}; fun main = () => {+(f(Some(2,),),)(f(None,),)}; main()}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, True, []),ClassInfo(3, False, []),ClassInfo(4, Cons, [h,t]),ClassInfo(5, Nil, []),ClassInfo(6, Some, [x]),ClassInfo(7, None, [])}, {
-//│ Def(0, is_some, [o$0],
-//│ 1, 
-//│ case o$0 of -- #11
-//│   Some =>
-//│     let x$1 = o$0.x in -- #7
-//│     let x$2 = True() in -- #6
-//│     jump j$0(x$2) -- #5
-//│   None =>
-//│     let x$3 = False() in -- #10
-//│     jump j$0(x$3) -- #9
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, e0, [w$0],
-//│ 1, 
-//│ let x$4 = +(w$0,8) in -- #21
-//│ let x$5 = +(x$4,9) in -- #20
-//│ let x$6 = +(x$5,10) in -- #19
-//│ x$6 -- #18
-//│ )
-//│ Def(3, e1, [a$0,z$0],
-//│ 1, 
-//│ let x$7 = >(a$0,0) in -- #43
-//│ if x$7 -- #42
-//│   true =>
-//│     let x$9 = -(a$0,1) in -- #39
-//│     let x$10 = Some(x$9) in -- #38
-//│     let* (x$11) = f(x$10) in -- #37
-//│     jump j$1(x$11) -- #36
-//│   false =>
-//│     jump j$1(z$0) -- #41
-//│ )
-//│ Def(4, j$1, [x$8],
-//│ 1, 
-//│ x$8 -- #25
-//│ )
-//│ Def(5, e3, [c$0],
-//│ 1, 
-//│ let x$12 = 4 in -- #76
-//│ let x$13 = 5 in -- #75
-//│ let x$14 = 6 in -- #74
-//│ let x$15 = 7 in -- #73
-//│ if c$0 -- #72
-//│   true =>
-//│     let x$17 = +(x$12,x$13) in -- #60
-//│     let x$18 = +(x$17,x$14) in -- #59
-//│     let x$19 = +(x$18,x$15) in -- #58
-//│     jump j$2(x$19) -- #57
-//│   false =>
-//│     let x$20 = +(x$12,x$13) in -- #71
-//│     let x$21 = -(x$20,x$14) in -- #70
-//│     let x$22 = +(x$21,x$15) in -- #69
-//│     jump j$2(x$22) -- #68
-//│ )
-//│ Def(6, j$2, [x$16],
-//│ 1, 
-//│ x$16 -- #49
-//│ )
-//│ Def(7, e2, [x$23],
-//│ 1, 
-//│ let x$24 = +(x$23,12) in -- #86
-//│ let x$25 = +(x$24,13) in -- #85
-//│ let x$26 = +(x$25,14) in -- #84
-//│ x$26 -- #83
-//│ )
-//│ Def(8, f, [x$27],
-//│ 1, 
-//│ let* (x$28) = is_some(x$27) in -- #126
-//│ let* (x$29) = e3(x$28) in -- #125
-//│ case x$27 of -- #124
-//│   Some =>
-//│     let x$32 = x$27.x in -- #116
-//│     let* (x$33) = e1(x$32,x$29) in -- #115
-//│     jump j$3(x$33) -- #114
-//│   None =>
-//│     let* (x$34) = e2(x$29) in -- #123
-//│     jump j$3(x$34) -- #122
-//│ )
-//│ Def(9, j$3, [x$30],
-//│ 1, 
-//│ let* (x$31) = e0(x$30) in -- #104
-//│ x$31 -- #103
-//│ )
-//│ Def(10, main, [],
-//│ 1, 
-//│ let x$35 = Some(2) in -- #145
-//│ let* (x$36) = f(x$35) in -- #144
-//│ let x$37 = None() in -- #143
-//│ let* (x$38) = f(x$37) in -- #142
-//│ let x$39 = +(x$36,x$38) in -- #141
-//│ x$39 -- #140
-//│ )
-//│ },
-//│ let* (x$40) = main() in -- #149
-//│ x$40 -- #148)
+//│ |#fun| |is_some|(|o|)| |#=|→|#if| |o| |is|→|Some|(|x|)| |#then| |True|↵|None| |#then| |False|←|←|↵|#fun| |e0|(|w|)| |#=|→|w| |+| |8| |+| |9| |+| |10|←|↵|#fun| |e1|(|a|,| |z|)| |#=|→|#if| |a| |>| |0| |#then| |f|(|Some|(|a| |-| |1|)|)| |#else| |z|←|↵|#fun| |e3|(|c|)| |#=|→|#let| |m| |#=| |4|↵|#let| |n| |#=| |5|↵|#let| |p| |#=| |6|↵|#let| |q| |#=| |7|↵|#if| |c| |#then| |m| |+| |n| |+| |p| |+| |q| |#else| |m| |+| |n| |-| |p| |+| |q|←|↵|#fun| |e2|(|x|)| |#=|→|x| |+| |12| |+| |13| |+| |14|←|↵|#fun| |f|(|x|)| |#=|→|#let| |c1| |#=| |is_some|(|x|)|↵|#let| |z| |#=| |e3|(|c1|)|↵|#let| |w| |#=| |#if| |x| |is|→|Some|(|a|)| |#then| |e1|(|a|,| |z|)|↵|None| |#then| |e2|(|z|)|←|↵|e0|(|w|)|←|↵|#fun| |main|(||)| |#=|→|f|(|Some|(|2|)|)| |+| |f|(|None|)|←|↵|main|(||)|
+//│ Parsed: {fun is_some = (o,) => {if o is ‹(Some(x,)) then True; (None) then False›}; fun e0 = (w,) => {+(+(+(w, 8,), 9,), 10,)}; fun e1 = (a, z,) => {if (>(a, 0,)) then f(Some(-(a, 1,),),) else z}; fun e3 = (c,) => {let m = 4; let n = 5; let p = 6; let q = 7; if (c) then +(+(+(m, n,), p,), q,) else +(-(+(m, n,), p,), q,)}; fun e2 = (x,) => {+(+(+(x, 12,), 13,), 14,)}; fun f = (x,) => {let c1 = is_some(x,); let z = e3(c1,); let w = if x is ‹(Some(a,)) then e1(a, z,); (None) then e2(z,)›; e0(w,)}; fun main = () => {+(f(Some(2,),), f(None,),)}; main()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def is_some(o$0) =
+//│     case o$0 of -- #16
+//│       Some =>
+//│         let x$2 = Some.x(o$0) in -- #12
+//│         let x$3 = True() in -- #11
+//│         jump j$0(x$3) -- #10
+//│       None =>
+//│         let x$4 = False() in -- #15
+//│         jump j$0(x$4) -- #14
+//│   def j$0(x$1) =
+//│     x$1 -- #4
+//│   def e0(w$0) =
+//│     let x$5 = +(w$0,8) in -- #35
+//│     let x$6 = +(x$5,9) in -- #34
+//│     let x$7 = +(x$6,10) in -- #33
+//│     x$7 -- #32
+//│   def e1(a$0,z$0) =
+//│     let x$8 = >(a$0,0) in -- #62
+//│     if x$8 -- #61
+//│       true =>
+//│         let x$10 = -(a$0,1) in -- #58
+//│         let x$11 = Some(x$10) in -- #57
+//│         let* (x$12) = f(x$11) in -- #56
+//│         jump j$1(x$12) -- #55
+//│       false =>
+//│         jump j$1(z$0) -- #60
+//│   def j$1(x$9) =
+//│     x$9 -- #42
+//│   def e3(c$0) =
+//│     let x$13 = 4 in -- #113
+//│     let x$14 = 5 in -- #112
+//│     let x$15 = 6 in -- #111
+//│     let x$16 = 7 in -- #110
+//│     if c$0 -- #109
+//│       true =>
+//│         let x$18 = +(x$13,x$14) in -- #88
+//│         let x$19 = +(x$18,x$15) in -- #87
+//│         let x$20 = +(x$19,x$16) in -- #86
+//│         jump j$2(x$20) -- #85
+//│       false =>
+//│         let x$21 = +(x$13,x$14) in -- #108
+//│         let x$22 = -(x$21,x$15) in -- #107
+//│         let x$23 = +(x$22,x$16) in -- #106
+//│         jump j$2(x$23) -- #105
+//│   def j$2(x$17) =
+//│     x$17 -- #68
+//│   def e2(x$24) =
+//│     let x$25 = +(x$24,12) in -- #132
+//│     let x$26 = +(x$25,13) in -- #131
+//│     let x$27 = +(x$26,14) in -- #130
+//│     x$27 -- #129
+//│   def f(x$28) =
+//│     let* (x$29) = is_some(x$28) in -- #169
+//│     let* (x$30) = e3(x$29) in -- #168
+//│     case x$28 of -- #167
+//│       Some =>
+//│         let x$33 = Some.x(x$28) in -- #160
+//│         let* (x$34) = e1(x$33,x$30) in -- #159
+//│         jump j$3(x$34) -- #158
+//│       None =>
+//│         let* (x$35) = e2(x$30) in -- #166
+//│         jump j$3(x$35) -- #165
+//│   def j$3(x$31) =
+//│     let* (x$32) = e0(x$31) in -- #147
+//│     x$32 -- #146
+//│   def main() =
+//│     let x$36 = Some(2) in -- #189
+//│     let* (x$37) = f(x$36) in -- #188
+//│     let x$38 = None() in -- #187
+//│     let* (x$39) = f(x$38) in -- #186
+//│     let x$40 = +(x$37,x$39) in -- #185
+//│     x$40 -- #184
+//│   let* (x$0) = main() in -- #2
+//│   x$0 -- #1
 //│ 
 //│ Interpreted:
+//│ 179
+//│ 
+
+:genCpp
+fun pred(n) =
+  if n is
+    S(p) then p
+    O then O
+fun plus(n1, n2) =
+  if n1 is
+    O then n2
+    S(p) then S(plus(p, n2))
+fun fib(n) =
+  if n is
+    O then S(O)
+    S(p) then
+      if p is
+        O then S(O)
+        S(q) then plus(fib(p), fib(q))
+fun to_int(n) =
+  if n is
+    O then 0
+    S(p) then 1 + to_int(p)
+fun to_nat(n) =
+  if n == 0 then O
+  else S(to_nat(n - 1))
+fun main() =
+  to_int(fib(to_nat(30)))
+main()
+//│ |#fun| |pred|(|n|)| |#=|→|#if| |n| |is|→|S|(|p|)| |#then| |p|↵|O| |#then| |O|←|←|↵|#fun| |plus|(|n1|,| |n2|)| |#=|→|#if| |n1| |is|→|O| |#then| |n2|↵|S|(|p|)| |#then| |S|(|plus|(|p|,| |n2|)|)|←|←|↵|#fun| |fib|(|n|)| |#=|→|#if| |n| |is|→|O| |#then| |S|(|O|)|↵|S|(|p|)| |#then|→|#if| |p| |is|→|O| |#then| |S|(|O|)|↵|S|(|q|)| |#then| |plus|(|fib|(|p|)|,| |fib|(|q|)|)|←|←|←|←|↵|#fun| |to_int|(|n|)| |#=|→|#if| |n| |is|→|O| |#then| |0|↵|S|(|p|)| |#then| |1| |+| |to_int|(|p|)|←|←|↵|#fun| |to_nat|(|n|)| |#=|→|#if| |n| |==| |0| |#then| |O|↵|#else| |S|(|to_nat|(|n| |-| |1|)|)|←|↵|#fun| |main|(||)| |#=|→|to_int|(|fib|(|to_nat|(|30|)|)|)|←|↵|main|(||)|
+//│ Parsed: {fun pred = (n,) => {if n is ‹(S(p,)) then p; (O) then O›}; fun plus = (n1, n2,) => {if n1 is ‹(O) then n2; (S(p,)) then S(plus(p, n2,),)›}; fun fib = (n,) => {if n is ‹(O) then S(O,); (S(p,)) then {if p is ‹(O) then S(O,); (S(q,)) then plus(fib(p,), fib(q,),)›}›}; fun to_int = (n,) => {if n is ‹(O) then 0; (S(p,)) then +(1, to_int(p,),)›}; fun to_nat = (n,) => {if (==(n, 0,)) then O else S(to_nat(-(n, 1,),),)}; fun main = () => {to_int(fib(to_nat(30,),),)}; main()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def pred(n$0) =
+//│     case n$0 of -- #15
+//│       S =>
+//│         let x$2 = S.s(n$0) in -- #11
+//│         jump j$0(x$2) -- #10
+//│       O =>
+//│         let x$3 = O() in -- #14
+//│         jump j$0(x$3) -- #13
+//│   def j$0(x$1) =
+//│     x$1 -- #4
+//│   def plus(n1$0,n2$0) =
+//│     case n1$0 of -- #37
+//│       O =>
+//│         jump j$1(n2$0) -- #19
+//│       S =>
+//│         let x$5 = S.s(n1$0) in -- #36
+//│         let* (x$6) = plus(x$5,n2$0) in -- #35
+//│         let x$7 = S(x$6) in -- #34
+//│         jump j$1(x$7) -- #33
+//│   def j$1(x$4) =
+//│     x$4 -- #17
+//│   def fib(n$1) =
+//│     case n$1 of -- #84
+//│       O =>
+//│         let x$9 = O() in -- #46
+//│         let x$10 = S(x$9) in -- #45
+//│         jump j$2(x$10) -- #44
+//│       S =>
+//│         let x$11 = S.s(n$1) in -- #83
+//│         case x$11 of -- #82
+//│           O =>
+//│             let x$13 = O() in -- #60
+//│             let x$14 = S(x$13) in -- #59
+//│             jump j$3(x$14) -- #58
+//│           S =>
+//│             let x$15 = S.s(x$11) in -- #81
+//│             let* (x$16) = fib(x$11) in -- #80
+//│             let* (x$17) = fib(x$15) in -- #79
+//│             let* (x$18) = plus(x$16,x$17) in -- #78
+//│             jump j$3(x$18) -- #77
+//│   def j$2(x$8) =
+//│     x$8 -- #39
+//│   def j$3(x$12) =
+//│     jump j$2(x$12) -- #53
+//│   def to_int(n$2) =
+//│     case n$2 of -- #106
+//│       O =>
+//│         jump j$4(0) -- #88
+//│       S =>
+//│         let x$20 = S.s(n$2) in -- #105
+//│         let* (x$21) = to_int(x$20) in -- #104
+//│         let x$22 = +(1,x$21) in -- #103
+//│         jump j$4(x$22) -- #102
+//│   def j$4(x$19) =
+//│     x$19 -- #86
+//│   def to_nat(n$3) =
+//│     let x$23 = ==(n$3,0) in -- #134
+//│     if x$23 -- #133
+//│       true =>
+//│         let x$25 = O() in -- #116
+//│         jump j$5(x$25) -- #115
+//│       false =>
+//│         let x$26 = -(n$3,1) in -- #132
+//│         let* (x$27) = to_nat(x$26) in -- #131
+//│         let x$28 = S(x$27) in -- #130
+//│         jump j$5(x$28) -- #129
+//│   def j$5(x$24) =
+//│     x$24 -- #113
+//│   def main() =
+//│     let* (x$29) = to_nat(30) in -- #147
+//│     let* (x$30) = fib(x$29) in -- #146
+//│     let* (x$31) = to_int(x$30) in -- #145
+//│     x$31 -- #144
+//│   let* (x$0) = main() in -- #2
+//│   x$0 -- #1
 //│ 
-//│ IR Processing Failed: can not find the matched case, ClassInfo(0, True, []) expected
diff --git a/compiler/shared/test/diff-ir/IRTailRec.mls b/compiler/shared/test/diff-ir/IRTailRec.mls
index de30850804..4fb0b7e8cc 100644
--- a/compiler/shared/test/diff-ir/IRTailRec.mls
+++ b/compiler/shared/test/diff-ir/IRTailRec.mls
@@ -2,6 +2,35 @@
 :ParseOnly
 :UseIR
 
+:prelude
+module True
+module False
+module Callable {
+  fun apply0() = 0
+  fun apply1(x0) = 0
+  fun apply2(x0,x1) = 0
+  fun apply3(x0,x1,x2) = 0
+  fun apply4(x0,x1,x2,x3) = 0
+  fun apply5(x0,x1,x2,x3,x4) = 0
+}
+module List[A, B]
+class Cons[A, B](h: A, t: Cons[A, B]) extends List[A, B]
+module Nil[A, B] extends List[A, B]
+module Option[A]
+class Some[A](x: A) extends Option[A]
+module None[A] extends Option[A]
+class Pair[A, B](x: A, y: B)
+class Tuple2[A, B](x: A, y: B)
+class Tuple3[A, B, C](x: A, y: B, z: C)
+module Nat
+class S(s: Nat) extends Nat
+module O extends Nat
+class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O)
+//│ |#module| |True|↵|#module| |False|↵|#module| |Callable| |{|→|#fun| |apply0|(||)| |#=| |0|↵|#fun| |apply1|(|x0|)| |#=| |0|↵|#fun| |apply2|(|x0|,|x1|)| |#=| |0|↵|#fun| |apply3|(|x0|,|x1|,|x2|)| |#=| |0|↵|#fun| |apply4|(|x0|,|x1|,|x2|,|x3|)| |#=| |0|↵|#fun| |apply5|(|x0|,|x1|,|x2|,|x3|,|x4|)| |#=| |0|←|↵|}|↵|#module| |List|[|A|,| |B|]|↵|#class| |Cons|[|A|,| |B|]|(|h|#:| |A|,| |t|#:| |Cons|[|A|,| |B|]|)| |#extends| |List|[|A|,| |B|]|↵|#module| |Nil|[|A|,| |B|]| |#extends| |List|[|A|,| |B|]|↵|#module| |Option|[|A|]|↵|#class| |Some|[|A|]|(|x|#:| |A|)| |#extends| |Option|[|A|]|↵|#module| |None|[|A|]| |#extends| |Option|[|A|]|↵|#class| |Pair|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple2|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple3|[|A|,| |B|,| |C|]|(|x|#:| |A|,| |y|#:| |B|,| |z|#:| |C|)|↵|#module| |Nat|↵|#class| |S|(|s|#:| |Nat|)| |#extends| |Nat|↵|#module| |O| |#extends| |Nat|↵|#class| |HiddenTheseEntities|(|_0|#:| |HiddenTheseEntities|,| |_1|#:| |True|,| |_2|#:| |False|,| |_3|#:| |Callable|,| |_4|#:| |List|,| |_5|#:| |Cons|,| |_6|#:| |Nil|,| |_7|#:| |Option|,| |_8|#:| |Some|,| |_9|#:| |None|,| |_10|#:| |Pair|,| |_11|#:| |Tuple2|,| |_12|#:| |Tuple3|,| |_13|#:| |Nat|,| |_14|#:| |S|,| |_15|#:| |O|)|
+//│ Parsed: {module True {}; module False {}; module Callable {fun apply0 = () => 0; fun apply1 = (x0,) => 0; fun apply2 = (x0, x1,) => 0; fun apply3 = (x0, x1, x2,) => 0; fun apply4 = (x0, x1, x2, x3,) => 0; fun apply5 = (x0, x1, x2, x3, x4,) => 0}; module List‹A, B› {}; class Cons‹A, B›(h: A, t: Cons‹A, B›,): List‹A, B› {}; module Nil‹A, B›: List‹A, B› {}; module Option‹A› {}; class Some‹A›(x: A,): Option‹A› {}; module None‹A›: Option‹A› {}; class Pair‹A, B›(x: A, y: B,) {}; class Tuple2‹A, B›(x: A, y: B,) {}; class Tuple3‹A, B, C›(x: A, y: B, z: C,) {}; module Nat {}; class S(s: Nat,): Nat {}; module O: Nat {}; class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O,) {}}
+//│ 
+//│ Preluded.
+
 :noTailRec
 :interpIR
 fun fact(acc, n) =
@@ -11,27 +40,24 @@ fact(1, 5)
 //│ |#fun| |fact|(|acc|,| |n|)| |#=|→|#if| |n| |==| |0| |#then| |acc|↵|#else| |fact|(|acc| |*| |n|,| |n| |-| |1|)|←|↵|fact|(|1|,| |5|)|
 //│ Parsed: {fun fact = (acc, n,) => {if (==(n,)(0,)) then acc else fact(*(acc,)(n,), -(n,)(1,),)}; fact(1, 5,)}
 //│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
-//│ Def(0, fact, [acc$0,n$0],
-//│ 1, 
-//│ let x$0 = ==(n$0,0) in -- #22
-//│ if x$0 -- #21
-//│   true =>
-//│     jump j$0(acc$0) -- #5
-//│   false =>
-//│     let x$2 = *(acc$0,n$0) in -- #20
-//│     let x$3 = -(n$0,1) in -- #19
-//│     let* (x$4) = fact(x$2,x$3) in -- #18
-//│     jump j$0(x$4) -- #17
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #3
-//│ )
-//│ },
-//│ let* (x$5) = fact(1,5) in -- #30
-//│ x$5 -- #29)
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def fact(acc$0,n$0) =
+//│     let x$1 = ==(n$0,0) in -- #28
+//│     if x$1 -- #27
+//│       true =>
+//│         jump j$0(acc$0) -- #12
+//│       false =>
+//│         let x$3 = *(acc$0,n$0) in -- #26
+//│         let x$4 = -(n$0,1) in -- #25
+//│         let* (x$5) = fact(x$3,x$4) in -- #24
+//│         jump j$0(x$5) -- #23
+//│   def j$0(x$2) =
+//│     x$2 -- #10
+//│   let* (x$0) = fact(1,5) in -- #6
+//│   x$0 -- #5
 //│ 
 //│ Interpreted:
 //│ 120
@@ -45,80 +71,47 @@ fact(1, 5)
 //│ |@|tailrec|↵|#fun| |fact|(|acc|,| |n|)| |#=|→|#if| |n| |==| |0| |#then| |acc|↵|#else| |fact|(|acc| |*| |n|,| |n| |-| |1|)|←|↵|fact|(|1|,| |5|)|
 //│ Parsed: {fun fact = (acc, n,) => {if (==(n,)(0,)) then acc else fact(*(acc,)(n,), -(n,)(1,),)}; fact(1, 5,)}
 //│ 
+//│ 
 //│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
-//│ Def(0, fact, [acc$0,n$0],
-//│ 1, 
-//│ let x$0 = ==(n$0,0) in -- #22
-//│ if x$0 -- #21
-//│   true =>
-//│     jump j$0(acc$0) -- #5
-//│   false =>
-//│     let x$2 = *(acc$0,n$0) in -- #20
-//│     let x$3 = -(n$0,1) in -- #19
-//│     let* (x$4) = fact(x$2,x$3) in -- #18
-//│     jump j$0(x$4) -- #17
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #3
-//│ )
-//│ },
-//│ let* (x$5) = fact(1,5) in -- #30
-//│ x$5 -- #29)
+//│ Program:
+//│ 
+//│   def fact(acc$0,n$0) =
+//│     let x$1 = ==(n$0,0) in -- #28
+//│     if x$1 -- #27
+//│       true =>
+//│         jump j$0(acc$0) -- #12
+//│       false =>
+//│         let x$3 = *(acc$0,n$0) in -- #26
+//│         let x$4 = -(n$0,1) in -- #25
+//│         let* (x$5) = fact(x$3,x$4) in -- #24
+//│         jump j$0(x$5) -- #23
+//│   def j$0(x$2) =
+//│     x$2 -- #10
+//│   let* (x$0) = fact(1,5) in -- #6
+//│   x$0 -- #5
+//│ 
 //│ 
 //│ Strongly Connected Tail Calls:
 //│ List(Set(j$0), Set(fact))
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #3
-//│ )
-//│ Def(2, fact_jp, [acc$0,n$0],
-//│ 1, 
-//│ let x$0 = ==(n$0,0) in -- #36
-//│ if x$0 -- #35
-//│   true =>
-//│     jump j$0(acc$0) -- #31
-//│   false =>
-//│     let x$2 = *(acc$0,n$0) in -- #34
-//│     let x$3 = -(n$0,1) in -- #33
-//│     jump fact_jp(x$2,x$3) -- #32
-//│ )
-//│ Def(3, fact, [acc$0,n$0],
-//│ 1, 
-//│ let* (r0) = fact_jp(acc$0,n$0) in -- #38
-//│ r0 -- #37
-//│ )
-//│ },
-//│ let* (x$5) = fact(1,5) in -- #30
-//│ x$5 -- #29)
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #3
-//│ )
-//│ Def(2, fact_jp, [acc$0,n$0],
-//│ 1, 
-//│ let x$0 = ==(n$0,0) in -- #36
-//│ if x$0 -- #35
-//│   true =>
-//│     jump j$0(acc$0) -- #31
-//│   false =>
-//│     let x$2 = *(acc$0,n$0) in -- #34
-//│     let x$3 = -(n$0,1) in -- #33
-//│     jump fact_jp(x$2,x$3) -- #32
-//│ )
-//│ Def(3, fact, [acc$0,n$0],
-//│ 1, 
-//│ let* (r0) = fact_jp(acc$0,n$0) in -- #38
-//│ r0 -- #37
-//│ )
-//│ },
-//│ let* (x$5) = fact(1,5) in -- #30
-//│ x$5 -- #29)
+//│ Program:
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
+//│   def j$0(x$2) =
+//│     x$2 -- #10
+//│   def fact_jp(acc$0,n$0) =
+//│     let x$1 = ==(n$0,0) in -- #40
+//│     if x$1 -- #39
+//│       true =>
+//│         jump j$0(acc$0) -- #35
+//│       false =>
+//│         let x$3 = *(acc$0,n$0) in -- #38
+//│         let x$4 = -(n$0,1) in -- #37
+//│         jump fact_jp(x$3,x$4) -- #36
+//│   def fact(acc$0,n$0) =
+//│     let* (r0) = fact_jp(acc$0,n$0) in -- #42
+//│     r0 -- #41
+//│   let* (x$0) = fact(1,5) in -- #6
+//│   x$0 -- #5
 //│ 
 //│ Interpreted:
 //│ 120
@@ -136,117 +129,66 @@ fact(1, 5)
 //│ |@|tailrec|↵|#fun| |fact|(|acc|,| |n|)| |#=|→|#val| |x| |#=| |#if| |n| |>| |0| |#then| |n| |-| |1|→|#else| |0|←|↵|#if| |x| |<=| |0| |#then|→|acc|←|↵|#else| |→|@|tailcall| |fact|(|n| |*| |acc|,| |x|)| |←|←|↵|fact|(|1|,| |5|)|
 //│ Parsed: {fun fact = (acc, n,) => {let x = if (>(n,)(0,)) then -(n,)(1,) else 0; if (<=(x,)(0,)) then {acc} else {@tailcall fact(*(n,)(acc,), x,)}}; fact(1, 5,)}
 //│ 
+//│ 
 //│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
-//│ Def(0, fact, [acc$0,n$0],
-//│ 1, 
-//│ let x$0 = >(n$0,0) in -- #32
-//│ if x$0 -- #31
-//│   true =>
-//│     let x$6 = -(n$0,1) in -- #28
-//│     jump j$0(x$6,acc$0,n$0) -- #27
-//│   false =>
-//│     jump j$0(0,acc$0,n$0) -- #30
-//│ )
-//│ Def(1, j$1, [x$3],
-//│ 1, 
-//│ x$3 -- #7
-//│ )
-//│ Def(2, j$0, [x$1,acc$0,n$0],
-//│ 1, 
-//│ let x$2 = <=(x$1,0) in -- #23
-//│ if x$2 -- #22
-//│   true =>
-//│     jump j$1(acc$0) -- #9
-//│   false =>
-//│     let x$4 = *(n$0,acc$0) in -- #21
-//│     let* (x$5) = @tailcall fact(x$4,x$1) in -- #20
-//│     jump j$1(x$5) -- #19
-//│ )
-//│ },
-//│ let* (x$7) = fact(1,5) in -- #40
-//│ x$7 -- #39)
+//│ Program:
 //│ 
-//│ Strongly Connected Tail Calls:
-//│ List(Set(j$1), Set(fact))
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(0, fact, [acc$0,n$0],
-//│ 1, 
-//│ let* (r0) = _fact_j$0_opt$3(0,acc$0,n$0,undefined,undefined,undefined) in -- #60
-//│ r0 -- #59
-//│ )
-//│ Def(1, j$1, [x$3],
-//│ 1, 
-//│ x$3 -- #7
-//│ )
-//│ Def(3, _fact_j$0_opt$3, [tailrecBranch$,fact_acc$0,fact_n$0,j$0_x$1,j$0_acc$0,j$0_n$0],
-//│ 1, 
-//│ jump _fact_j$0_opt_jp$4(tailrecBranch$,fact_acc$0,fact_n$0,j$0_x$1,j$0_acc$0,j$0_n$0) -- #58
-//│ )
-//│ Def(4, _fact_j$0_opt_jp$4, [tailrecBranch$,fact_acc$0,fact_n$0,j$0_x$1,j$0_acc$0,j$0_n$0],
-//│ 1, 
-//│ let scrut = ==(2,tailrecBranch$) in -- #57
-//│ if scrut -- #56
-//│   true =>
-//│     let x$2 = <=(j$0_x$1,0) in -- #55
-//│     if x$2 -- #54
-//│       true =>
-//│         jump j$1(j$0_acc$0) -- #51
-//│       false =>
-//│         let x$4 = *(j$0_n$0,j$0_acc$0) in -- #53
-//│         jump _fact_j$0_opt_jp$4(0,x$4,j$0_x$1,j$0_x$1,j$0_acc$0,j$0_n$0) -- #52
-//│   false =>
-//│     let x$0 = >(fact_n$0,0) in -- #50
-//│     if x$0 -- #49
+//│   def fact(acc$0,n$0) =
+//│     let x$1 = >(n$0,0) in -- #38
+//│     if x$1 -- #37
 //│       true =>
-//│         let x$6 = -(fact_n$0,1) in -- #47
-//│         jump _fact_j$0_opt_jp$4(2,fact_acc$0,fact_n$0,x$6,fact_acc$0,fact_n$0) -- #46
+//│         let x$7 = -(n$0,1) in -- #34
+//│         jump j$0(x$7,acc$0,n$0) -- #33
 //│       false =>
-//│         jump _fact_j$0_opt_jp$4(2,fact_acc$0,fact_n$0,0,fact_acc$0,fact_n$0) -- #48
-//│ )
-//│ },
-//│ let* (x$7) = fact(1,5) in -- #40
-//│ x$7 -- #39)
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(0, fact, [acc$0,n$0],
-//│ 1, 
-//│ let* (r0) = _fact_j$0_opt$3(0,acc$0,n$0,undefined,undefined,undefined) in -- #60
-//│ r0 -- #59
-//│ )
-//│ Def(1, j$1, [x$3],
-//│ 1, 
-//│ x$3 -- #7
-//│ )
-//│ Def(3, _fact_j$0_opt$3, [tailrecBranch$,fact_acc$0,fact_n$0,j$0_x$1,j$0_acc$0,j$0_n$0],
-//│ 1, 
-//│ jump _fact_j$0_opt_jp$4(tailrecBranch$,fact_acc$0,fact_n$0,j$0_x$1,j$0_acc$0,j$0_n$0) -- #58
-//│ )
-//│ Def(4, _fact_j$0_opt_jp$4, [tailrecBranch$,fact_acc$0,fact_n$0,j$0_x$1,j$0_acc$0,j$0_n$0],
-//│ 1, 
-//│ let scrut = ==(2,tailrecBranch$) in -- #57
-//│ if scrut -- #56
-//│   true =>
-//│     let x$2 = <=(j$0_x$1,0) in -- #55
-//│     if x$2 -- #54
+//│         jump j$0(0,acc$0,n$0) -- #36
+//│   def j$1(x$4) =
+//│     x$4 -- #14
+//│   def j$0(x$2,acc$0,n$0) =
+//│     let x$3 = <=(x$2,0) in -- #29
+//│     if x$3 -- #28
 //│       true =>
-//│         jump j$1(j$0_acc$0) -- #51
+//│         jump j$1(acc$0) -- #16
 //│       false =>
-//│         let x$4 = *(j$0_n$0,j$0_acc$0) in -- #53
-//│         jump _fact_j$0_opt_jp$4(0,x$4,j$0_x$1,j$0_x$1,j$0_acc$0,j$0_n$0) -- #52
-//│   false =>
-//│     let x$0 = >(fact_n$0,0) in -- #50
-//│     if x$0 -- #49
+//│         let x$5 = *(n$0,acc$0) in -- #27
+//│         let* (x$6) = @tailcall fact(x$5,x$2) in -- #26
+//│         jump j$1(x$6) -- #25
+//│   let* (x$0) = fact(1,5) in -- #6
+//│   x$0 -- #5
+//│ 
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(j$1), Set(fact))
+//│ Program:
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
+//│   def fact(acc$0,n$0) =
+//│     let* (r0) = _fact_j$0_opt$9(0,acc$0,n$0,true,true,true) in -- #64
+//│     r0 -- #63
+//│   def j$1(x$4) =
+//│     x$4 -- #14
+//│   def _fact_j$0_opt$9(tailrecBranch$,fact_acc$0,fact_n$0,j$0_x$2,j$0_acc$0,j$0_n$0) =
+//│     jump _fact_j$0_opt_jp$10(tailrecBranch$,fact_acc$0,fact_n$0,j$0_x$2,j$0_acc$0,j$0_n$0) -- #62
+//│   def _fact_j$0_opt_jp$10(tailrecBranch$,fact_acc$0,fact_n$0,j$0_x$2,j$0_acc$0,j$0_n$0) =
+//│     let scrut = ==(2,tailrecBranch$) in -- #61
+//│     if scrut -- #60
 //│       true =>
-//│         let x$6 = -(fact_n$0,1) in -- #47
-//│         jump _fact_j$0_opt_jp$4(2,fact_acc$0,fact_n$0,x$6,fact_acc$0,fact_n$0) -- #46
+//│         let x$3 = <=(j$0_x$2,0) in -- #59
+//│         if x$3 -- #58
+//│           true =>
+//│             jump j$1(j$0_acc$0) -- #55
+//│           false =>
+//│             let x$5 = *(j$0_n$0,j$0_acc$0) in -- #57
+//│             jump _fact_j$0_opt_jp$10(0,x$5,j$0_x$2,j$0_x$2,j$0_acc$0,j$0_n$0) -- #56
 //│       false =>
-//│         jump _fact_j$0_opt_jp$4(2,fact_acc$0,fact_n$0,0,fact_acc$0,fact_n$0) -- #48
-//│ )
-//│ },
-//│ let* (x$7) = fact(1,5) in -- #40
-//│ x$7 -- #39)
+//│         let x$1 = >(fact_n$0,0) in -- #54
+//│         if x$1 -- #53
+//│           true =>
+//│             let x$7 = -(fact_n$0,1) in -- #51
+//│             jump _fact_j$0_opt_jp$10(2,fact_acc$0,fact_n$0,x$7,fact_acc$0,fact_n$0) -- #50
+//│           false =>
+//│             jump _fact_j$0_opt_jp$10(2,fact_acc$0,fact_n$0,0,fact_acc$0,fact_n$0) -- #52
+//│   let* (x$0) = fact(1,5) in -- #6
+//│   x$0 -- #5
 //│ 
 //│ Interpreted:
 //│ 120
@@ -260,51 +202,42 @@ g(6, 0)
 //│ |#fun| |double|(|x|)| |#=| |x| |*| |2|↵|#fun| |f|(|n|,| |acc|)| |#=| |#if| |n| |==| |0| |#then| |double|(|acc|)| |#else| |g|(|n| |-| |1|,| |acc| |+| |1|)|↵|#fun| |g|(|m|,| |acc|)| |#=| |#if| |m| |==| |0| |#then| |-|double|(|acc|)| |#else| |f|(|m| |-| |1|,| |acc| |+| |1|)|↵|g|(|6|,| |0|)|
 //│ Parsed: {fun double = (x,) => *(x,)(2,); fun f = (n, acc,) => if (==(n,)(0,)) then double(acc,) else g(-(n,)(1,), +(acc,)(1,),); fun g = (m, acc,) => if (==(m,)(0,)) then -(0,)(double(acc,),) else f(-(m,)(1,), +(acc,)(1,),); g(6, 0,)}
 //│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
-//│ Def(0, double, [x$0],
-//│ 1, 
-//│ let x$1 = *(x$0,2) in -- #3
-//│ x$1 -- #2
-//│ )
-//│ Def(1, f, [n$0,acc$0],
-//│ 1, 
-//│ let x$2 = ==(n$0,0) in -- #31
-//│ if x$2 -- #30
-//│   true =>
-//│     let* (x$4) = double(acc$0) in -- #14
-//│     jump j$0(x$4) -- #13
-//│   false =>
-//│     let x$5 = -(n$0,1) in -- #29
-//│     let x$6 = +(acc$0,1) in -- #28
-//│     let* (x$7) = g(x$5,x$6) in -- #27
-//│     jump j$0(x$7) -- #26
-//│ )
-//│ Def(2, j$0, [x$3],
-//│ 1, 
-//│ x$3 -- #7
-//│ )
-//│ Def(3, g, [m$0,acc$1],
-//│ 1, 
-//│ let x$8 = ==(m$0,0) in -- #62
-//│ if x$8 -- #61
-//│   true =>
-//│     let* (x$10) = double(acc$1) in -- #45
-//│     let x$11 = -(0,x$10) in -- #44
-//│     jump j$1(x$11) -- #43
-//│   false =>
-//│     let x$12 = -(m$0,1) in -- #60
-//│     let x$13 = +(acc$1,1) in -- #59
-//│     let* (x$14) = f(x$12,x$13) in -- #58
-//│     jump j$1(x$14) -- #57
-//│ )
-//│ Def(4, j$1, [x$9],
-//│ 1, 
-//│ x$9 -- #35
-//│ )
-//│ },
-//│ let* (x$15) = g(6,0) in -- #70
-//│ x$15 -- #69)
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def double(x$1) =
+//│     let x$2 = *(x$1,2) in -- #10
+//│     x$2 -- #9
+//│   def f(n$0,acc$0) =
+//│     let x$3 = ==(n$0,0) in -- #36
+//│     if x$3 -- #35
+//│       true =>
+//│         let* (x$5) = double(acc$0) in -- #20
+//│         jump j$0(x$5) -- #19
+//│       false =>
+//│         let x$6 = -(n$0,1) in -- #34
+//│         let x$7 = +(acc$0,1) in -- #33
+//│         let* (x$8) = g(x$6,x$7) in -- #32
+//│         jump j$0(x$8) -- #31
+//│   def j$0(x$4) =
+//│     x$4 -- #14
+//│   def g(m$0,acc$1) =
+//│     let x$9 = ==(m$0,0) in -- #65
+//│     if x$9 -- #64
+//│       true =>
+//│         let* (x$11) = double(acc$1) in -- #49
+//│         let x$12 = -(0,x$11) in -- #48
+//│         jump j$1(x$12) -- #47
+//│       false =>
+//│         let x$13 = -(m$0,1) in -- #63
+//│         let x$14 = +(acc$1,1) in -- #62
+//│         let* (x$15) = f(x$13,x$14) in -- #61
+//│         jump j$1(x$15) -- #60
+//│   def j$1(x$10) =
+//│     x$10 -- #40
+//│   let* (x$0) = g(6,0) in -- #6
+//│   x$0 -- #5
 //│ 
 //│ Interpreted:
 //│ -12
@@ -317,170 +250,90 @@ g(6, 0)
 //│ |#fun| |double|(|x|)| |#=| |x| |*| |2|↵|@|tailrec| |#fun| |f|(|n|,| |acc|)| |#=| |#if| |n| |==| |0| |#then| |double|(|acc|)| |#else| |g|(|n| |-| |1|,| |acc| |+| |1|)|↵|@|tailrec| |#fun| |g|(|m|,| |acc|)| |#=| |#if| |m| |==| |0| |#then| |-|double|(|acc|)| |#else| |f|(|m| |-| |1|,| |acc| |+| |1|)|↵|g|(|6|,| |0|)|
 //│ Parsed: {fun double = (x,) => *(x,)(2,); fun f = (n, acc,) => if (==(n,)(0,)) then double(acc,) else g(-(n,)(1,), +(acc,)(1,),); fun g = (m, acc,) => if (==(m,)(0,)) then -(0,)(double(acc,),) else f(-(m,)(1,), +(acc,)(1,),); g(6, 0,)}
 //│ 
-//│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
-//│ Def(0, double, [x$0],
-//│ 1, 
-//│ let x$1 = *(x$0,2) in -- #3
-//│ x$1 -- #2
-//│ )
-//│ Def(1, f, [n$0,acc$0],
-//│ 1, 
-//│ let x$2 = ==(n$0,0) in -- #31
-//│ if x$2 -- #30
-//│   true =>
-//│     let* (x$4) = double(acc$0) in -- #14
-//│     jump j$0(x$4) -- #13
-//│   false =>
-//│     let x$5 = -(n$0,1) in -- #29
-//│     let x$6 = +(acc$0,1) in -- #28
-//│     let* (x$7) = g(x$5,x$6) in -- #27
-//│     jump j$0(x$7) -- #26
-//│ )
-//│ Def(2, j$0, [x$3],
-//│ 1, 
-//│ x$3 -- #7
-//│ )
-//│ Def(3, g, [m$0,acc$1],
-//│ 1, 
-//│ let x$8 = ==(m$0,0) in -- #62
-//│ if x$8 -- #61
-//│   true =>
-//│     let* (x$10) = double(acc$1) in -- #45
-//│     let x$11 = -(0,x$10) in -- #44
-//│     jump j$1(x$11) -- #43
-//│   false =>
-//│     let x$12 = -(m$0,1) in -- #60
-//│     let x$13 = +(acc$1,1) in -- #59
-//│     let* (x$14) = f(x$12,x$13) in -- #58
-//│     jump j$1(x$14) -- #57
-//│ )
-//│ Def(4, j$1, [x$9],
-//│ 1, 
-//│ x$9 -- #35
-//│ )
-//│ },
-//│ let* (x$15) = g(6,0) in -- #70
-//│ x$15 -- #69)
 //│ 
-//│ Strongly Connected Tail Calls:
-//│ List(Set(j$1), Set(j$0), Set(g, f), Set(double))
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(0, double, [x$0],
-//│ 1, 
-//│ let x$1 = *(x$0,2) in -- #3
-//│ x$1 -- #2
-//│ )
-//│ Def(1, f, [n$0,acc$0],
-//│ 1, 
-//│ let* (r0) = _g_f_opt$5(1,undefined,undefined,n$0,acc$0) in -- #100
-//│ r0 -- #99
-//│ )
-//│ Def(2, j$0, [x$3],
-//│ 1, 
-//│ x$3 -- #7
-//│ )
-//│ Def(3, g, [m$0,acc$1],
-//│ 1, 
-//│ let* (r0) = _g_f_opt$5(3,m$0,acc$1,undefined,undefined) in -- #98
-//│ r0 -- #97
-//│ )
-//│ Def(4, j$1, [x$9],
-//│ 1, 
-//│ x$9 -- #35
-//│ )
-//│ Def(5, _g_f_opt$5, [tailrecBranch$,g_m$0,g_acc$1,f_n$0,f_acc$0],
-//│ 1, 
-//│ jump _g_f_opt_jp$6(tailrecBranch$,g_m$0,g_acc$1,f_n$0,f_acc$0) -- #96
-//│ )
-//│ Def(6, _g_f_opt_jp$6, [tailrecBranch$,g_m$0,g_acc$1,f_n$0,f_acc$0],
-//│ 1, 
-//│ let scrut = ==(1,tailrecBranch$) in -- #95
-//│ if scrut -- #94
-//│   true =>
-//│     let x$2 = ==(f_n$0,0) in -- #93
-//│     if x$2 -- #92
-//│       true =>
-//│         let* (x$4) = double(f_acc$0) in -- #88
-//│         jump j$0(x$4) -- #87
-//│       false =>
-//│         let x$5 = -(f_n$0,1) in -- #91
-//│         let x$6 = +(f_acc$0,1) in -- #90
-//│         jump _g_f_opt_jp$6(3,x$5,x$6,f_n$0,f_acc$0) -- #89
-//│   false =>
-//│     let x$8 = ==(g_m$0,0) in -- #86
-//│     if x$8 -- #85
+//│ IR:
+//│ Program:
+//│ 
+//│   def double(x$1) =
+//│     let x$2 = *(x$1,2) in -- #10
+//│     x$2 -- #9
+//│   def f(n$0,acc$0) =
+//│     let x$3 = ==(n$0,0) in -- #36
+//│     if x$3 -- #35
 //│       true =>
-//│         let* (x$10) = double(g_acc$1) in -- #81
-//│         let x$11 = -(0,x$10) in -- #80
-//│         jump j$1(x$11) -- #79
+//│         let* (x$5) = double(acc$0) in -- #20
+//│         jump j$0(x$5) -- #19
 //│       false =>
-//│         let x$12 = -(g_m$0,1) in -- #84
-//│         let x$13 = +(g_acc$1,1) in -- #83
-//│         jump _g_f_opt_jp$6(1,g_m$0,g_acc$1,x$12,x$13) -- #82
-//│ )
-//│ },
-//│ let* (x$15) = g(6,0) in -- #70
-//│ x$15 -- #69)
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(0, double, [x$0],
-//│ 1, 
-//│ let x$1 = *(x$0,2) in -- #3
-//│ x$1 -- #2
-//│ )
-//│ Def(1, f, [n$0,acc$0],
-//│ 1, 
-//│ let* (r0) = _g_f_opt$5(1,undefined,undefined,n$0,acc$0) in -- #100
-//│ r0 -- #99
-//│ )
-//│ Def(2, j$0, [x$3],
-//│ 1, 
-//│ x$3 -- #7
-//│ )
-//│ Def(3, g, [m$0,acc$1],
-//│ 1, 
-//│ let* (r0) = _g_f_opt$5(3,m$0,acc$1,undefined,undefined) in -- #98
-//│ r0 -- #97
-//│ )
-//│ Def(4, j$1, [x$9],
-//│ 1, 
-//│ x$9 -- #35
-//│ )
-//│ Def(5, _g_f_opt$5, [tailrecBranch$,g_m$0,g_acc$1,f_n$0,f_acc$0],
-//│ 1, 
-//│ jump _g_f_opt_jp$6(tailrecBranch$,g_m$0,g_acc$1,f_n$0,f_acc$0) -- #96
-//│ )
-//│ Def(6, _g_f_opt_jp$6, [tailrecBranch$,g_m$0,g_acc$1,f_n$0,f_acc$0],
-//│ 1, 
-//│ let scrut = ==(1,tailrecBranch$) in -- #95
-//│ if scrut -- #94
-//│   true =>
-//│     let x$2 = ==(f_n$0,0) in -- #93
-//│     if x$2 -- #92
+//│         let x$6 = -(n$0,1) in -- #34
+//│         let x$7 = +(acc$0,1) in -- #33
+//│         let* (x$8) = g(x$6,x$7) in -- #32
+//│         jump j$0(x$8) -- #31
+//│   def j$0(x$4) =
+//│     x$4 -- #14
+//│   def g(m$0,acc$1) =
+//│     let x$9 = ==(m$0,0) in -- #65
+//│     if x$9 -- #64
 //│       true =>
-//│         let* (x$4) = double(f_acc$0) in -- #88
-//│         jump j$0(x$4) -- #87
+//│         let* (x$11) = double(acc$1) in -- #49
+//│         let x$12 = -(0,x$11) in -- #48
+//│         jump j$1(x$12) -- #47
 //│       false =>
-//│         let x$5 = -(f_n$0,1) in -- #91
-//│         let x$6 = +(f_acc$0,1) in -- #90
-//│         jump _g_f_opt_jp$6(3,x$5,x$6,f_n$0,f_acc$0) -- #89
-//│   false =>
-//│     let x$8 = ==(g_m$0,0) in -- #86
-//│     if x$8 -- #85
+//│         let x$13 = -(m$0,1) in -- #63
+//│         let x$14 = +(acc$1,1) in -- #62
+//│         let* (x$15) = f(x$13,x$14) in -- #61
+//│         jump j$1(x$15) -- #60
+//│   def j$1(x$10) =
+//│     x$10 -- #40
+//│   let* (x$0) = g(6,0) in -- #6
+//│   x$0 -- #5
+//│ 
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(j$1), Set(j$0), Set(g, f), Set(double))
+//│ Program:
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
+//│   def double(x$1) =
+//│     let x$2 = *(x$1,2) in -- #10
+//│     x$2 -- #9
+//│   def f(n$0,acc$0) =
+//│     let* (r0) = _g_f_opt$11(1,true,true,n$0,acc$0) in -- #101
+//│     r0 -- #100
+//│   def j$0(x$4) =
+//│     x$4 -- #14
+//│   def g(m$0,acc$1) =
+//│     let* (r0) = _g_f_opt$11(3,m$0,acc$1,true,true) in -- #99
+//│     r0 -- #98
+//│   def j$1(x$10) =
+//│     x$10 -- #40
+//│   def _g_f_opt$11(tailrecBranch$,g_m$0,g_acc$1,f_n$0,f_acc$0) =
+//│     jump _g_f_opt_jp$12(tailrecBranch$,g_m$0,g_acc$1,f_n$0,f_acc$0) -- #97
+//│   def _g_f_opt_jp$12(tailrecBranch$,g_m$0,g_acc$1,f_n$0,f_acc$0) =
+//│     let scrut = ==(1,tailrecBranch$) in -- #96
+//│     if scrut -- #95
 //│       true =>
-//│         let* (x$10) = double(g_acc$1) in -- #81
-//│         let x$11 = -(0,x$10) in -- #80
-//│         jump j$1(x$11) -- #79
+//│         let x$3 = ==(f_n$0,0) in -- #94
+//│         if x$3 -- #93
+//│           true =>
+//│             let* (x$5) = double(f_acc$0) in -- #89
+//│             jump j$0(x$5) -- #88
+//│           false =>
+//│             let x$6 = -(f_n$0,1) in -- #92
+//│             let x$7 = +(f_acc$0,1) in -- #91
+//│             jump _g_f_opt_jp$12(3,x$6,x$7,f_n$0,f_acc$0) -- #90
 //│       false =>
-//│         let x$12 = -(g_m$0,1) in -- #84
-//│         let x$13 = +(g_acc$1,1) in -- #83
-//│         jump _g_f_opt_jp$6(1,g_m$0,g_acc$1,x$12,x$13) -- #82
-//│ )
-//│ },
-//│ let* (x$15) = g(6,0) in -- #70
-//│ x$15 -- #69)
+//│         let x$9 = ==(g_m$0,0) in -- #87
+//│         if x$9 -- #86
+//│           true =>
+//│             let* (x$11) = double(g_acc$1) in -- #82
+//│             let x$12 = -(0,x$11) in -- #81
+//│             jump j$1(x$12) -- #80
+//│           false =>
+//│             let x$13 = -(g_m$0,1) in -- #85
+//│             let x$14 = +(g_acc$1,1) in -- #84
+//│             jump _g_f_opt_jp$12(1,g_m$0,g_acc$1,x$13,x$14) -- #83
+//│   let* (x$0) = g(6,0) in -- #6
+//│   x$0 -- #5
 //│ 
 //│ Interpreted:
 //│ -12
@@ -492,102 +345,51 @@ g(6, 0)
 //│ |@|tailrec| |#fun| |f|(|a|,| |b|,| |c|)| |#=| |g|(|0|,| |0|)|↵|@|tailrec| |#fun| |g|(|d|,| |e|)| |#=| |h|(|0|,| |0|,| |0|,| |0|)|↵|@|tailrec| |#fun| |h|(|p|,| |q|,| |r|,| |s|)| |#=| |f|(|0|,| |0|,| |0|)|↵|2| |
 //│ Parsed: {fun f = (a, b, c,) => g(0, 0,); fun g = (d, e,) => h(0, 0, 0, 0,); fun h = (p, q, r, s,) => f(0, 0, 0,); 2}
 //│ 
+//│ 
 //│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
-//│ Def(0, f, [a$0,b$0,c$0],
-//│ 1, 
-//│ let* (x$0) = g(0,0) in -- #7
-//│ x$0 -- #6
-//│ )
-//│ Def(1, g, [d$0,e$0],
-//│ 1, 
-//│ let* (x$1) = h(0,0,0,0) in -- #19
-//│ x$1 -- #18
-//│ )
-//│ Def(2, h, [p$0,q$0,r$0,s$0],
-//│ 1, 
-//│ let* (x$2) = f(0,0,0) in -- #29
-//│ x$2 -- #28
-//│ )
-//│ },
-//│ 2 -- #30)
+//│ Program:
+//│ 
+//│   def f(a$0,b$0,c$0) =
+//│     let* (x$0) = g(0,0) in -- #7
+//│     x$0 -- #6
+//│   def g(d$0,e$0) =
+//│     let* (x$1) = h(0,0,0,0) in -- #18
+//│     x$1 -- #17
+//│   def h(p$0,q$0,r$0,s$0) =
+//│     let* (x$2) = f(0,0,0) in -- #27
+//│     x$2 -- #26
+//│   2 -- #0
+//│ 
 //│ 
 //│ Strongly Connected Tail Calls:
 //│ List(Set(h, g, f))
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(0, f, [a$0,b$0,c$0],
-//│ 1, 
-//│ let* (r0) = _h_g_f_opt$3(0,undefined,undefined,undefined,undefined,undefined,undefined,a$0,b$0,c$0) in -- #45
-//│ r0 -- #44
-//│ )
-//│ Def(1, g, [d$0,e$0],
-//│ 1, 
-//│ let* (r0) = _h_g_f_opt$3(1,undefined,undefined,undefined,undefined,d$0,e$0,undefined,undefined,undefined) in -- #43
-//│ r0 -- #42
-//│ )
-//│ Def(2, h, [p$0,q$0,r$0,s$0],
-//│ 1, 
-//│ let* (r0) = _h_g_f_opt$3(2,p$0,q$0,r$0,s$0,undefined,undefined,undefined,undefined,undefined) in -- #41
-//│ r0 -- #40
-//│ )
-//│ Def(3, _h_g_f_opt$3, [tailrecBranch$,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0],
-//│ 1, 
-//│ jump _h_g_f_opt_jp$4(tailrecBranch$,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0) -- #39
-//│ )
-//│ Def(4, _h_g_f_opt_jp$4, [tailrecBranch$,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0],
-//│ 1, 
-//│ let scrut = ==(0,tailrecBranch$) in -- #38
-//│ if scrut -- #37
-//│   true =>
-//│     jump _h_g_f_opt_jp$4(1,h_p$0,h_q$0,h_r$0,h_s$0,0,0,f_a$0,f_b$0,f_c$0) -- #34
-//│   false =>
-//│     let scrut = ==(1,tailrecBranch$) in -- #36
-//│     if scrut -- #35
-//│       true =>
-//│         jump _h_g_f_opt_jp$4(2,0,0,0,0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0) -- #33
-//│       false =>
-//│         jump _h_g_f_opt_jp$4(0,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,0,0,0) -- #32
-//│ )
-//│ },
-//│ 2 -- #30)
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(0, f, [a$0,b$0,c$0],
-//│ 1, 
-//│ let* (r0) = _h_g_f_opt$3(0,undefined,undefined,undefined,undefined,undefined,undefined,a$0,b$0,c$0) in -- #45
-//│ r0 -- #44
-//│ )
-//│ Def(1, g, [d$0,e$0],
-//│ 1, 
-//│ let* (r0) = _h_g_f_opt$3(1,undefined,undefined,undefined,undefined,d$0,e$0,undefined,undefined,undefined) in -- #43
-//│ r0 -- #42
-//│ )
-//│ Def(2, h, [p$0,q$0,r$0,s$0],
-//│ 1, 
-//│ let* (r0) = _h_g_f_opt$3(2,p$0,q$0,r$0,s$0,undefined,undefined,undefined,undefined,undefined) in -- #41
-//│ r0 -- #40
-//│ )
-//│ Def(3, _h_g_f_opt$3, [tailrecBranch$,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0],
-//│ 1, 
-//│ jump _h_g_f_opt_jp$4(tailrecBranch$,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0) -- #39
-//│ )
-//│ Def(4, _h_g_f_opt_jp$4, [tailrecBranch$,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0],
-//│ 1, 
-//│ let scrut = ==(0,tailrecBranch$) in -- #38
-//│ if scrut -- #37
-//│   true =>
-//│     jump _h_g_f_opt_jp$4(1,h_p$0,h_q$0,h_r$0,h_s$0,0,0,f_a$0,f_b$0,f_c$0) -- #34
-//│   false =>
-//│     let scrut = ==(1,tailrecBranch$) in -- #36
-//│     if scrut -- #35
+//│ Program:
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
+//│   def f(a$0,b$0,c$0) =
+//│     let* (r0) = _h_g_f_opt$9(0,true,true,true,true,true,true,a$0,b$0,c$0) in -- #48
+//│     r0 -- #47
+//│   def g(d$0,e$0) =
+//│     let* (r0) = _h_g_f_opt$9(1,true,true,true,true,d$0,e$0,true,true,true) in -- #46
+//│     r0 -- #45
+//│   def h(p$0,q$0,r$0,s$0) =
+//│     let* (r0) = _h_g_f_opt$9(2,p$0,q$0,r$0,s$0,true,true,true,true,true) in -- #44
+//│     r0 -- #43
+//│   def _h_g_f_opt$9(tailrecBranch$,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0) =
+//│     jump _h_g_f_opt_jp$10(tailrecBranch$,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0) -- #42
+//│   def _h_g_f_opt_jp$10(tailrecBranch$,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0) =
+//│     let scrut = ==(0,tailrecBranch$) in -- #41
+//│     if scrut -- #40
 //│       true =>
-//│         jump _h_g_f_opt_jp$4(2,0,0,0,0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0) -- #33
+//│         jump _h_g_f_opt_jp$10(1,h_p$0,h_q$0,h_r$0,h_s$0,0,0,f_a$0,f_b$0,f_c$0) -- #37
 //│       false =>
-//│         jump _h_g_f_opt_jp$4(0,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,0,0,0) -- #32
-//│ )
-//│ },
-//│ 2 -- #30)
+//│         let scrut = ==(1,tailrecBranch$) in -- #39
+//│         if scrut -- #38
+//│           true =>
+//│             jump _h_g_f_opt_jp$10(2,0,0,0,0,g_d$0,g_e$0,f_a$0,f_b$0,f_c$0) -- #36
+//│           false =>
+//│             jump _h_g_f_opt_jp$10(0,h_p$0,h_q$0,h_r$0,h_s$0,g_d$0,g_e$0,0,0,0) -- #35
+//│   2 -- #0
 
 :ce
 fun hello() =
@@ -598,48 +400,35 @@ hello()
 //│ |#fun| |hello|(||)| |#=|→|@|tailcall| |hello|(||)|↵|@|tailcall| |hello|(||)|↵|2|←|↵|hello|(||)| |
 //│ Parsed: {fun hello = () => {@tailcall hello(); @tailcall hello(); 2}; hello()}
 //│ 
+//│ 
 //│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
-//│ Def(0, hello, [],
-//│ 1, 
-//│ let* (x$0) = @tailcall hello() in -- #8
-//│ let* (x$1) = @tailcall hello() in -- #7
-//│ 2 -- #6
-//│ )
-//│ },
-//│ let* (x$2) = hello() in -- #12
-//│ x$2 -- #11)
+//│ Program:
+//│ 
+//│   def hello() =
+//│     let* (x$1) = @tailcall hello() in -- #9
+//│     let* (x$2) = @tailcall hello() in -- #8
+//│     2 -- #7
+//│   let* (x$0) = hello() in -- #2
+//│   x$0 -- #1
 //│ ╔══[COMPILATION ERROR] not a tail call, as the remaining functions may be impure
-//│ ║  l.594: 	    @tailcall hello()
+//│ ║  l.396: 	    @tailcall hello()
 //│ ╙──       	              ^^^^^
 //│ ╔══[COMPILATION ERROR] not a tail call
-//│ ║  l.595: 	    @tailcall hello()
+//│ ║  l.397: 	    @tailcall hello()
 //│ ╙──       	              ^^^^^
 //│ 
+//│ 
 //│ Strongly Connected Tail Calls:
 //│ List(Set(hello))
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(0, hello, [],
-//│ 1, 
-//│ let* (x$0) = @tailcall hello() in -- #8
-//│ let* (x$1) = @tailcall hello() in -- #7
-//│ 2 -- #6
-//│ )
-//│ },
-//│ let* (x$2) = hello() in -- #12
-//│ x$2 -- #11)
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(0, hello, [],
-//│ 1, 
-//│ let* (x$0) = @tailcall hello() in -- #8
-//│ let* (x$1) = @tailcall hello() in -- #7
-//│ 2 -- #6
-//│ )
-//│ },
-//│ let* (x$2) = hello() in -- #12
-//│ x$2 -- #11)
+//│ Program:
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
+//│   def hello() =
+//│     let* (x$1) = @tailcall hello() in -- #9
+//│     let* (x$2) = @tailcall hello() in -- #8
+//│     2 -- #7
+//│   let* (x$0) = hello() in -- #2
+//│   x$0 -- #1
 
 :ce
 fun hello() =
@@ -649,209 +438,120 @@ hello()
 //│ |#fun| |hello|(||)| |#=|→|@|tailcall| |hello|(||)|↵|2|←|↵|hello|(||)| |
 //│ Parsed: {fun hello = () => {@tailcall hello(); 2}; hello()}
 //│ 
+//│ 
 //│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
-//│ Def(0, hello, [],
-//│ 1, 
-//│ let* (x$0) = @tailcall hello() in -- #4
-//│ 2 -- #3
-//│ )
-//│ },
-//│ let* (x$1) = hello() in -- #8
-//│ x$1 -- #7)
+//│ Program:
+//│ 
+//│   def hello() =
+//│     let* (x$1) = @tailcall hello() in -- #6
+//│     2 -- #5
+//│   let* (x$0) = hello() in -- #2
+//│   x$0 -- #1
 //│ ╔══[COMPILATION ERROR] not a tail call
-//│ ║  l.646: 	    @tailcall hello()
+//│ ║  l.435: 	    @tailcall hello()
 //│ ╙──       	              ^^^^^
 //│ 
+//│ 
 //│ Strongly Connected Tail Calls:
 //│ List(Set(hello))
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(0, hello, [],
-//│ 1, 
-//│ let* (x$0) = @tailcall hello() in -- #4
-//│ 2 -- #3
-//│ )
-//│ },
-//│ let* (x$1) = hello() in -- #8
-//│ x$1 -- #7)
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(0, hello, [],
-//│ 1, 
-//│ let* (x$0) = @tailcall hello() in -- #4
-//│ 2 -- #3
-//│ )
-//│ },
-//│ let* (x$1) = hello() in -- #8
-//│ x$1 -- #7)
+//│ Program:
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
+//│   def hello() =
+//│     let* (x$1) = @tailcall hello() in -- #6
+//│     2 -- #5
+//│   let* (x$0) = hello() in -- #2
+//│   x$0 -- #1
 
 :interpIR
-class Cons(h, t)
-class Nil
 @tailrec fun addOne(xs) =
   if xs is
     Cons(h, t) then Cons(h + 1, @tailcall addOne(t))
     Nil then Nil
 addOne(Cons(1, Cons(2, Cons(3, Nil))))
-//│ |#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|@|tailrec| |#fun| |addOne|(|xs|)| |#=|→|#if| |xs| |is|→|Cons|(|h|,| |t|)| |#then| |Cons|(|h| |+| |1|,| |@|tailcall| |addOne|(|t|)|)|↵|Nil| |#then| |Nil|←|←|↵|addOne|(|Cons|(|1|,| |Cons|(|2|,| |Cons|(|3|,| |Nil|)|)|)|)|
-//│ Parsed: {class Cons(h, t,) {}; class Nil {}; fun addOne = (xs,) => {if xs is ‹(Cons(h, t,)) then Cons(+(h,)(1,), @tailcall addOne(t,),); (Nil) then Nil›}; addOne(Cons(1, Cons(2, Cons(3, Nil,),),),)}
+//│ |@|tailrec| |#fun| |addOne|(|xs|)| |#=|→|#if| |xs| |is|→|Cons|(|h|,| |t|)| |#then| |Cons|(|h| |+| |1|,| |@|tailcall| |addOne|(|t|)|)|↵|Nil| |#then| |Nil|←|←|↵|addOne|(|Cons|(|1|,| |Cons|(|2|,| |Cons|(|3|,| |Nil|)|)|)|)|
+//│ Parsed: {fun addOne = (xs,) => {if xs is ‹(Cons(h, t,)) then Cons(+(h,)(1,), @tailcall addOne(t,),); (Nil) then Nil›}; addOne(Cons(1, Cons(2, Cons(3, Nil,),),),)}
+//│ 
 //│ 
 //│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, [])}, {
-//│ Def(0, addOne, [xs$0],
-//│ 1, 
-//│ case xs$0 of -- #27
-//│   Cons =>
-//│     let x$1 = xs$0.t in -- #23
-//│     let x$2 = xs$0.h in -- #22
-//│     let x$3 = +(x$2,1) in -- #21
-//│     let* (x$4) = @tailcall addOne(x$1) in -- #20
-//│     let x$5 = Cons(x$3,x$4) in -- #19
-//│     jump j$0(x$5) -- #18
-//│   Nil =>
-//│     let x$6 = Nil() in -- #26
-//│     jump j$0(x$6) -- #25
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ },
-//│ let x$7 = Nil() in -- #52
-//│ let x$8 = Cons(3,x$7) in -- #51
-//│ let x$9 = Cons(2,x$8) in -- #50
-//│ let x$10 = Cons(1,x$9) in -- #49
-//│ let* (x$11) = addOne(x$10) in -- #48
-//│ x$11 -- #47)
+//│ Program:
+//│ 
+//│   def addOne(xs$0) =
+//│     case xs$0 of -- #54
+//│       Cons =>
+//│         let x$6 = Cons.t(xs$0) in -- #50
+//│         let x$7 = Cons.h(xs$0) in -- #49
+//│         let x$8 = +(x$7,1) in -- #48
+//│         let* (x$9) = @tailcall addOne(x$6) in -- #47
+//│         let x$10 = Cons(x$8,x$9) in -- #46
+//│         jump j$0(x$10) -- #45
+//│       Nil =>
+//│         let x$11 = Nil() in -- #53
+//│         jump j$0(x$11) -- #52
+//│   def j$0(x$5) =
+//│     x$5 -- #25
+//│   let x$0 = Nil() in -- #23
+//│   let x$1 = Cons(3,x$0) in -- #22
+//│   let x$2 = Cons(2,x$1) in -- #21
+//│   let x$3 = Cons(1,x$2) in -- #20
+//│   let* (x$4) = addOne(x$3) in -- #19
+//│   x$4 -- #18
+//│ 
 //│ 
 //│ Strongly Connected Tail Calls:
 //│ List(Set(j$0), Set(addOne))
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
-//│ Def(0, addOne, [xs$0],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #80
-//│ let* (res) = addOne_modcons$4(idCtx,xs$0) in -- #79
-//│ res -- #78
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, _addOne_ctx_app$2, [ctx,x],
-//│ 1, 
-//│ case ctx of -- #59
-//│   _IdContext =>
-//│     x -- #58
-//│   _Context =>
-//│     let field = ctx.field in -- #57
-//│     let ptr = ctx.ptr in -- #56
-//│     let _ = assign ptr.t := x in -- #55
-//│     let acc = ctx.acc in -- #54
-//│     acc -- #53
-//│ )
-//│ Def(3, _addOne_ctx_comp$3, [ctx1,ctx2],
-//│ 1, 
-//│ let ctx2acc = ctx2.acc in -- #65
-//│ let ctx2ptr = ctx2.ptr in -- #64
-//│ let ctx2field = ctx2.field in -- #63
-//│ let* (newAcc) = _addOne_ctx_app$2(ctx1,ctx2acc) in -- #62
-//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #61
-//│ ret -- #60
-//│ )
-//│ Def(5, addOne_modcons$4_jp, [ctx,xs$0],
-//│ 1, 
-//│ case xs$0 of -- #91
-//│   Cons =>
-//│     let x$1 = xs$0.t in -- #87
-//│     let x$2 = xs$0.h in -- #86
-//│     let x$3 = +(x$2,1) in -- #85
-//│     let x$5 = Cons(x$3,0) in -- #84
-//│     let ctx2 = _Context(x$5,x$5,0) in -- #83
-//│     let* (composed) = _addOne_ctx_comp$3(ctx,ctx2) in -- #82
-//│     jump addOne_modcons$4_jp(composed,x$1) -- #81
-//│   Nil =>
-//│     let x$6 = Nil() in -- #90
-//│     let* (res) = _addOne_ctx_app$2(ctx,x$6) in -- #89
-//│     res -- #88
-//│ )
-//│ Def(6, addOne_modcons$4, [ctx,xs$0],
-//│ 1, 
-//│ let* (r0) = addOne_modcons$4_jp(ctx,xs$0) in -- #93
-//│ r0 -- #92
-//│ )
-//│ },
-//│ let x$7 = Nil() in -- #52
-//│ let x$8 = Cons(3,x$7) in -- #51
-//│ let x$9 = Cons(2,x$8) in -- #50
-//│ let x$10 = Cons(1,x$9) in -- #49
-//│ let* (x$11) = addOne(x$10) in -- #48
-//│ x$11 -- #47)
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
-//│ Def(0, addOne, [xs$0],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #80
-//│ let* (res) = addOne_modcons$4(idCtx,xs$0) in -- #79
-//│ res -- #78
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, _addOne_ctx_app$2, [ctx,x],
-//│ 1, 
-//│ case ctx of -- #59
-//│   _IdContext =>
-//│     x -- #58
-//│   _Context =>
-//│     let field = ctx.field in -- #57
-//│     let ptr = ctx.ptr in -- #56
-//│     let _ = assign ptr.t := x in -- #55
-//│     let acc = ctx.acc in -- #54
-//│     acc -- #53
-//│ )
-//│ Def(3, _addOne_ctx_comp$3, [ctx1,ctx2],
-//│ 1, 
-//│ let ctx2acc = ctx2.acc in -- #65
-//│ let ctx2ptr = ctx2.ptr in -- #64
-//│ let ctx2field = ctx2.field in -- #63
-//│ let* (newAcc) = _addOne_ctx_app$2(ctx1,ctx2acc) in -- #62
-//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #61
-//│ ret -- #60
-//│ )
-//│ Def(5, addOne_modcons$4_jp, [ctx,xs$0],
-//│ 1, 
-//│ case xs$0 of -- #91
-//│   Cons =>
-//│     let x$1 = xs$0.t in -- #87
-//│     let x$2 = xs$0.h in -- #86
-//│     let x$3 = +(x$2,1) in -- #85
-//│     let x$5 = Cons(x$3,0) in -- #84
-//│     let ctx2 = _Context(x$5,x$5,0) in -- #83
-//│     let* (composed) = _addOne_ctx_comp$3(ctx,ctx2) in -- #82
-//│     jump addOne_modcons$4_jp(composed,x$1) -- #81
-//│   Nil =>
-//│     let x$6 = Nil() in -- #90
-//│     let* (res) = _addOne_ctx_app$2(ctx,x$6) in -- #89
-//│     res -- #88
-//│ )
-//│ Def(6, addOne_modcons$4, [ctx,xs$0],
-//│ 1, 
-//│ let* (r0) = addOne_modcons$4_jp(ctx,xs$0) in -- #93
-//│ r0 -- #92
-//│ )
-//│ },
-//│ let x$7 = Nil() in -- #52
-//│ let x$8 = Cons(3,x$7) in -- #51
-//│ let x$9 = Cons(2,x$8) in -- #50
-//│ let x$10 = Cons(1,x$9) in -- #49
-//│ let* (x$11) = addOne(x$10) in -- #48
-//│ x$11 -- #47)
+//│ Program:
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
+//│   def addOne(xs$0) =
+//│     let idCtx = _IdContext() in -- #88
+//│     let* (res) = addOne_modcons$10(idCtx,xs$0) in -- #87
+//│     res -- #86
+//│   def j$0(x$5) =
+//│     x$5 -- #25
+//│   def _addOne_ctx_app$8(ctx,x) =
+//│     case ctx of -- #67
+//│       _IdContext =>
+//│         x -- #66
+//│       _Context =>
+//│         let field = _Context.field(ctx) in -- #65
+//│         let ptr = _Context.ptr(ctx) in -- #64
+//│         let _ = assign ptr.t := x in -- #63
+//│         let acc = _Context.acc(ctx) in -- #62
+//│         acc -- #61
+//│   def _addOne_ctx_comp$9(ctx1,ctx2) =
+//│     let ctx2acc = _Context.acc(ctx2) in -- #73
+//│     let ctx2ptr = _Context.ptr(ctx2) in -- #72
+//│     let ctx2field = _Context.field(ctx2) in -- #71
+//│     let* (newAcc) = _addOne_ctx_app$8(ctx1,ctx2acc) in -- #70
+//│     let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #69
+//│     ret -- #68
+//│   def addOne_modcons$10_jp(ctx,xs$0) =
+//│     case xs$0 of -- #99
+//│       Cons =>
+//│         let x$6 = Cons.t(xs$0) in -- #95
+//│         let x$7 = Cons.h(xs$0) in -- #94
+//│         let x$8 = +(x$7,1) in -- #93
+//│         let x$10 = Cons(x$8,0) in -- #92
+//│         let ctx2 = _Context(x$10,x$10,0) in -- #91
+//│         let* (composed) = _addOne_ctx_comp$9(ctx,ctx2) in -- #90
+//│         jump addOne_modcons$10_jp(composed,x$6) -- #89
+//│       Nil =>
+//│         let x$11 = Nil() in -- #98
+//│         let* (res) = _addOne_ctx_app$8(ctx,x$11) in -- #97
+//│         res -- #96
+//│   def addOne_modcons$10(ctx,xs$0) =
+//│     let* (r0) = addOne_modcons$10_jp(ctx,xs$0) in -- #101
+//│     r0 -- #100
+//│   let x$0 = Nil() in -- #23
+//│   let x$1 = Cons(3,x$0) in -- #22
+//│   let x$2 = Cons(2,x$1) in -- #21
+//│   let x$3 = Cons(1,x$2) in -- #20
+//│   let* (x$4) = addOne(x$3) in -- #19
+//│   x$4 -- #18
 //│ 
 //│ Interpreted:
-//│ Cons(2,Cons(3,Cons(4,Nil())))
+//│ Cons(2,0)
 
 :noTailRec
 :interpIR
@@ -869,51 +569,44 @@ a(S(S(S(Zero))))
 //│ |#class| |Zero|↵|#class| |S|(|x|)|↵|#fun| |a|(|n|)| |#=|→|#if| |n| |is|→|S|(|x|)| |#then| |S|(|@|tailcall| |b|(|x|)|)|↵|Zero| |#then| |S|(|Zero|)|←|←|↵|#fun| |b|(|n|)| |#=|→|#if| |n| |is|→|S|(|x|)| |#then| |S|(|S|(|@|tailcall| |a|(|x|)|)|)|↵|Zero| |#then| |S|(|S|(|Zero|)|)|←|←|↵|a|(|S|(|S|(|S|(|Zero|)|)|)|)|
 //│ Parsed: {class Zero {}; class S(x,) {}; fun a = (n,) => {if n is ‹(S(x,)) then S(@tailcall b(x,),); (Zero) then S(Zero,)›}; fun b = (n,) => {if n is ‹(S(x,)) then S(S(@tailcall a(x,),),); (Zero) then S(S(Zero,),)›}; a(S(S(S(Zero,),),),)}
 //│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Zero, []),ClassInfo(3, S, [x])}, {
-//│ Def(0, a, [n$0],
-//│ 1, 
-//│ case n$0 of -- #23
-//│   S =>
-//│     let x$1 = n$0.x in -- #15
-//│     let* (x$2) = @tailcall b(x$1) in -- #14
-//│     let x$3 = S(x$2) in -- #13
-//│     jump j$0(x$3) -- #12
-//│   Zero =>
-//│     let x$4 = Zero() in -- #22
-//│     let x$5 = S(x$4) in -- #21
-//│     jump j$0(x$5) -- #20
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, b, [n$1],
-//│ 1, 
-//│ case n$1 of -- #55
-//│   S =>
-//│     let x$7 = n$1.x in -- #43
-//│     let* (x$8) = @tailcall a(x$7) in -- #42
-//│     let x$9 = S(x$8) in -- #41
-//│     let x$10 = S(x$9) in -- #40
-//│     jump j$1(x$10) -- #39
-//│   Zero =>
-//│     let x$11 = Zero() in -- #54
-//│     let x$12 = S(x$11) in -- #53
-//│     let x$13 = S(x$12) in -- #52
-//│     jump j$1(x$13) -- #51
-//│ )
-//│ Def(3, j$1, [x$6],
-//│ 1, 
-//│ x$6 -- #25
-//│ )
-//│ },
-//│ let x$14 = Zero() in -- #74
-//│ let x$15 = S(x$14) in -- #73
-//│ let x$16 = S(x$15) in -- #72
-//│ let x$17 = S(x$16) in -- #71
-//│ let* (x$18) = a(x$17) in -- #70
-//│ x$18 -- #69)
+//│ 
+//│ IR:
+//│ Program:
+//│   class Zero()
+//│   def a(n$0) =
+//│     case n$0 of -- #42
+//│       S =>
+//│         let x$6 = S.s(n$0) in -- #34
+//│         let* (x$7) = @tailcall b(x$6) in -- #33
+//│         let x$8 = S(x$7) in -- #32
+//│         jump j$0(x$8) -- #31
+//│       Zero =>
+//│         let x$9 = Zero() in -- #41
+//│         let x$10 = S(x$9) in -- #40
+//│         jump j$0(x$10) -- #39
+//│   def j$0(x$5) =
+//│     x$5 -- #19
+//│   def b(n$1) =
+//│     case n$1 of -- #75
+//│       S =>
+//│         let x$12 = S.s(n$1) in -- #63
+//│         let* (x$13) = @tailcall a(x$12) in -- #62
+//│         let x$14 = S(x$13) in -- #61
+//│         let x$15 = S(x$14) in -- #60
+//│         jump j$1(x$15) -- #59
+//│       Zero =>
+//│         let x$16 = Zero() in -- #74
+//│         let x$17 = S(x$16) in -- #73
+//│         let x$18 = S(x$17) in -- #72
+//│         jump j$1(x$18) -- #71
+//│   def j$1(x$11) =
+//│     x$11 -- #44
+//│   let x$0 = Zero() in -- #17
+//│   let x$1 = S(x$0) in -- #16
+//│   let x$2 = S(x$1) in -- #15
+//│   let x$3 = S(x$2) in -- #14
+//│   let* (x$4) = a(x$3) in -- #13
+//│   x$4 -- #12
 //│ 
 //│ Interpreted:
 //│ S(S(S(S(S(S(Zero()))))))
@@ -933,255 +626,131 @@ a(S(S(S(Zero))))
 //│ |#class| |Zero|↵|#class| |S|(|x|)|↵|@|tailrec| |#fun| |a|(|n|)| |#=|→|#if| |n| |is|→|S|(|x|)| |#then| |S|(|@|tailcall| |b|(|x|)|)|↵|Zero| |#then| |S|(|Zero|)|←|←|↵|@|tailrec| |#fun| |b|(|n|)| |#=|→|#if| |n| |is|→|S|(|x|)| |#then| |S|(|S|(|@|tailcall| |a|(|x|)|)|)|↵|Zero| |#then| |S|(|S|(|Zero|)|)|←|←|↵|a|(|S|(|S|(|S|(|Zero|)|)|)|)|
 //│ Parsed: {class Zero {}; class S(x,) {}; fun a = (n,) => {if n is ‹(S(x,)) then S(@tailcall b(x,),); (Zero) then S(Zero,)›}; fun b = (n,) => {if n is ‹(S(x,)) then S(S(@tailcall a(x,),),); (Zero) then S(S(Zero,),)›}; a(S(S(S(Zero,),),),)}
 //│ 
-//│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Zero, []),ClassInfo(3, S, [x])}, {
-//│ Def(0, a, [n$0],
-//│ 1, 
-//│ case n$0 of -- #23
-//│   S =>
-//│     let x$1 = n$0.x in -- #15
-//│     let* (x$2) = @tailcall b(x$1) in -- #14
-//│     let x$3 = S(x$2) in -- #13
-//│     jump j$0(x$3) -- #12
-//│   Zero =>
-//│     let x$4 = Zero() in -- #22
-//│     let x$5 = S(x$4) in -- #21
-//│     jump j$0(x$5) -- #20
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, b, [n$1],
-//│ 1, 
-//│ case n$1 of -- #55
-//│   S =>
-//│     let x$7 = n$1.x in -- #43
-//│     let* (x$8) = @tailcall a(x$7) in -- #42
-//│     let x$9 = S(x$8) in -- #41
-//│     let x$10 = S(x$9) in -- #40
-//│     jump j$1(x$10) -- #39
-//│   Zero =>
-//│     let x$11 = Zero() in -- #54
-//│     let x$12 = S(x$11) in -- #53
-//│     let x$13 = S(x$12) in -- #52
-//│     jump j$1(x$13) -- #51
-//│ )
-//│ Def(3, j$1, [x$6],
-//│ 1, 
-//│ x$6 -- #25
-//│ )
-//│ },
-//│ let x$14 = Zero() in -- #74
-//│ let x$15 = S(x$14) in -- #73
-//│ let x$16 = S(x$15) in -- #72
-//│ let x$17 = S(x$16) in -- #71
-//│ let* (x$18) = a(x$17) in -- #70
-//│ x$18 -- #69)
 //│ 
-//│ Strongly Connected Tail Calls:
-//│ List(Set(j$1), Set(j$0), Set(b, a))
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Zero, []),ClassInfo(3, S, [x]),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
-//│ Def(0, a, [n$0],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #117
-//│ let* (res) = a_modcons$7(idCtx,n$0) in -- #116
-//│ res -- #115
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, b, [n$1],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #103
-//│ let* (res) = b_modcons$6(idCtx,n$1) in -- #102
-//│ res -- #101
-//│ )
-//│ Def(3, j$1, [x$6],
-//│ 1, 
-//│ x$6 -- #25
-//│ )
-//│ Def(4, _b_a_ctx_app$4, [ctx,x],
-//│ 1, 
-//│ case ctx of -- #81
-//│   _IdContext =>
-//│     x -- #80
-//│   _Context =>
-//│     let field = ctx.field in -- #79
-//│     let ptr = ctx.ptr in -- #78
-//│     let _ = assign ptr.x := x in -- #77
-//│     let acc = ctx.acc in -- #76
-//│     acc -- #75
-//│ )
-//│ Def(5, _b_a_ctx_comp$5, [ctx1,ctx2],
-//│ 1, 
-//│ let ctx2acc = ctx2.acc in -- #87
-//│ let ctx2ptr = ctx2.ptr in -- #86
-//│ let ctx2field = ctx2.field in -- #85
-//│ let* (newAcc) = _b_a_ctx_app$4(ctx1,ctx2acc) in -- #84
-//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #83
-//│ ret -- #82
-//│ )
-//│ Def(6, b_modcons$6, [ctx,n$1],
-//│ 1, 
-//│ let* (r0) = _b_modcons$6_a_modcons$7_opt$8(6,ctx,n$1,undefined,undefined) in -- #156
-//│ r0 -- #155
-//│ )
-//│ Def(7, a_modcons$7, [ctx,n$0],
-//│ 1, 
-//│ let* (r0) = _b_modcons$6_a_modcons$7_opt$8(7,undefined,undefined,ctx,n$0) in -- #158
-//│ r0 -- #157
-//│ )
-//│ Def(8, _b_modcons$6_a_modcons$7_opt$8, [tailrecBranch$,b_modcons$6_ctx,b_modcons$6_n$1,a_modcons$7_ctx,a_modcons$7_n$0],
-//│ 1, 
-//│ jump _b_modcons$6_a_modcons$7_opt_jp$9(tailrecBranch$,b_modcons$6_ctx,b_modcons$6_n$1,a_modcons$7_ctx,a_modcons$7_n$0) -- #154
-//│ )
-//│ Def(9, _b_modcons$6_a_modcons$7_opt_jp$9, [tailrecBranch$,b_modcons$6_ctx,b_modcons$6_n$1,a_modcons$7_ctx,a_modcons$7_n$0],
-//│ 1, 
-//│ let scrut = ==(7,tailrecBranch$) in -- #153
-//│ if scrut -- #152
-//│   true =>
-//│     case a_modcons$7_n$0 of -- #151
-//│       S =>
-//│         let x$1 = a_modcons$7_n$0.x in -- #146
-//│         let x$3 = S(0) in -- #145
-//│         let ctx2 = _Context(x$3,x$3,0) in -- #144
-//│         let* (composed) = _b_a_ctx_comp$5(a_modcons$7_ctx,ctx2) in -- #143
-//│         jump _b_modcons$6_a_modcons$7_opt_jp$9(6,composed,x$1,a_modcons$7_ctx,a_modcons$7_n$0) -- #142
-//│       Zero =>
-//│         let x$4 = Zero() in -- #150
-//│         let x$5 = S(x$4) in -- #149
-//│         let* (res) = _b_a_ctx_app$4(a_modcons$7_ctx,x$5) in -- #148
-//│         res -- #147
-//│   false =>
-//│     case b_modcons$6_n$1 of -- #141
-//│       S =>
-//│         let x$7 = b_modcons$6_n$1.x in -- #135
-//│         let x$9 = S(0) in -- #134
-//│         let x$10 = S(x$9) in -- #133
-//│         let ctx2 = _Context(x$10,x$9,0) in -- #132
-//│         let* (composed) = _b_a_ctx_comp$5(b_modcons$6_ctx,ctx2) in -- #131
-//│         jump _b_modcons$6_a_modcons$7_opt_jp$9(7,b_modcons$6_ctx,b_modcons$6_n$1,composed,x$7) -- #130
-//│       Zero =>
-//│         let x$11 = Zero() in -- #140
-//│         let x$12 = S(x$11) in -- #139
-//│         let x$13 = S(x$12) in -- #138
-//│         let* (res) = _b_a_ctx_app$4(b_modcons$6_ctx,x$13) in -- #137
-//│         res -- #136
-//│ )
-//│ },
-//│ let x$14 = Zero() in -- #74
-//│ let x$15 = S(x$14) in -- #73
-//│ let x$16 = S(x$15) in -- #72
-//│ let x$17 = S(x$16) in -- #71
-//│ let* (x$18) = a(x$17) in -- #70
-//│ x$18 -- #69)
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Zero, []),ClassInfo(3, S, [x]),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
-//│ Def(0, a, [n$0],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #117
-//│ let* (res) = a_modcons$7(idCtx,n$0) in -- #116
-//│ res -- #115
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, b, [n$1],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #103
-//│ let* (res) = b_modcons$6(idCtx,n$1) in -- #102
-//│ res -- #101
-//│ )
-//│ Def(3, j$1, [x$6],
-//│ 1, 
-//│ x$6 -- #25
-//│ )
-//│ Def(4, _b_a_ctx_app$4, [ctx,x],
-//│ 1, 
-//│ case ctx of -- #81
-//│   _IdContext =>
-//│     x -- #80
-//│   _Context =>
-//│     let field = ctx.field in -- #79
-//│     let ptr = ctx.ptr in -- #78
-//│     let _ = assign ptr.x := x in -- #77
-//│     let acc = ctx.acc in -- #76
-//│     acc -- #75
-//│ )
-//│ Def(5, _b_a_ctx_comp$5, [ctx1,ctx2],
-//│ 1, 
-//│ let ctx2acc = ctx2.acc in -- #87
-//│ let ctx2ptr = ctx2.ptr in -- #86
-//│ let ctx2field = ctx2.field in -- #85
-//│ let* (newAcc) = _b_a_ctx_app$4(ctx1,ctx2acc) in -- #84
-//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #83
-//│ ret -- #82
-//│ )
-//│ Def(6, b_modcons$6, [ctx,n$1],
-//│ 1, 
-//│ let* (r0) = _b_modcons$6_a_modcons$7_opt$8(6,ctx,n$1,undefined,undefined) in -- #156
-//│ r0 -- #155
-//│ )
-//│ Def(7, a_modcons$7, [ctx,n$0],
-//│ 1, 
-//│ let* (r0) = _b_modcons$6_a_modcons$7_opt$8(7,undefined,undefined,ctx,n$0) in -- #158
-//│ r0 -- #157
-//│ )
-//│ Def(8, _b_modcons$6_a_modcons$7_opt$8, [tailrecBranch$,b_modcons$6_ctx,b_modcons$6_n$1,a_modcons$7_ctx,a_modcons$7_n$0],
-//│ 1, 
-//│ jump _b_modcons$6_a_modcons$7_opt_jp$9(tailrecBranch$,b_modcons$6_ctx,b_modcons$6_n$1,a_modcons$7_ctx,a_modcons$7_n$0) -- #154
-//│ )
-//│ Def(9, _b_modcons$6_a_modcons$7_opt_jp$9, [tailrecBranch$,b_modcons$6_ctx,b_modcons$6_n$1,a_modcons$7_ctx,a_modcons$7_n$0],
-//│ 1, 
-//│ let scrut = ==(7,tailrecBranch$) in -- #153
-//│ if scrut -- #152
-//│   true =>
-//│     case a_modcons$7_n$0 of -- #151
+//│ IR:
+//│ Program:
+//│   class Zero()
+//│   def a(n$0) =
+//│     case n$0 of -- #42
 //│       S =>
-//│         let x$1 = a_modcons$7_n$0.x in -- #146
-//│         let x$3 = S(0) in -- #145
-//│         let ctx2 = _Context(x$3,x$3,0) in -- #144
-//│         let* (composed) = _b_a_ctx_comp$5(a_modcons$7_ctx,ctx2) in -- #143
-//│         jump _b_modcons$6_a_modcons$7_opt_jp$9(6,composed,x$1,a_modcons$7_ctx,a_modcons$7_n$0) -- #142
+//│         let x$6 = S.s(n$0) in -- #34
+//│         let* (x$7) = @tailcall b(x$6) in -- #33
+//│         let x$8 = S(x$7) in -- #32
+//│         jump j$0(x$8) -- #31
 //│       Zero =>
-//│         let x$4 = Zero() in -- #150
-//│         let x$5 = S(x$4) in -- #149
-//│         let* (res) = _b_a_ctx_app$4(a_modcons$7_ctx,x$5) in -- #148
-//│         res -- #147
-//│   false =>
-//│     case b_modcons$6_n$1 of -- #141
+//│         let x$9 = Zero() in -- #41
+//│         let x$10 = S(x$9) in -- #40
+//│         jump j$0(x$10) -- #39
+//│   def j$0(x$5) =
+//│     x$5 -- #19
+//│   def b(n$1) =
+//│     case n$1 of -- #75
 //│       S =>
-//│         let x$7 = b_modcons$6_n$1.x in -- #135
-//│         let x$9 = S(0) in -- #134
-//│         let x$10 = S(x$9) in -- #133
-//│         let ctx2 = _Context(x$10,x$9,0) in -- #132
-//│         let* (composed) = _b_a_ctx_comp$5(b_modcons$6_ctx,ctx2) in -- #131
-//│         jump _b_modcons$6_a_modcons$7_opt_jp$9(7,b_modcons$6_ctx,b_modcons$6_n$1,composed,x$7) -- #130
+//│         let x$12 = S.s(n$1) in -- #63
+//│         let* (x$13) = @tailcall a(x$12) in -- #62
+//│         let x$14 = S(x$13) in -- #61
+//│         let x$15 = S(x$14) in -- #60
+//│         jump j$1(x$15) -- #59
 //│       Zero =>
-//│         let x$11 = Zero() in -- #140
-//│         let x$12 = S(x$11) in -- #139
-//│         let x$13 = S(x$12) in -- #138
-//│         let* (res) = _b_a_ctx_app$4(b_modcons$6_ctx,x$13) in -- #137
-//│         res -- #136
-//│ )
-//│ },
-//│ let x$14 = Zero() in -- #74
-//│ let x$15 = S(x$14) in -- #73
-//│ let x$16 = S(x$15) in -- #72
-//│ let x$17 = S(x$16) in -- #71
-//│ let* (x$18) = a(x$17) in -- #70
-//│ x$18 -- #69)
+//│         let x$16 = Zero() in -- #74
+//│         let x$17 = S(x$16) in -- #73
+//│         let x$18 = S(x$17) in -- #72
+//│         jump j$1(x$18) -- #71
+//│   def j$1(x$11) =
+//│     x$11 -- #44
+//│   let x$0 = Zero() in -- #17
+//│   let x$1 = S(x$0) in -- #16
+//│   let x$2 = S(x$1) in -- #15
+//│   let x$3 = S(x$2) in -- #14
+//│   let* (x$4) = a(x$3) in -- #13
+//│   x$4 -- #12
+//│ 
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(j$1), Set(j$0), Set(b, a))
+//│ Program:
+//│   class Zero()
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
+//│   def a(n$0) =
+//│     let idCtx = _IdContext() in -- #124
+//│     let* (res) = a_modcons$13(idCtx,n$0) in -- #123
+//│     res -- #122
+//│   def j$0(x$5) =
+//│     x$5 -- #19
+//│   def b(n$1) =
+//│     let idCtx = _IdContext() in -- #110
+//│     let* (res) = b_modcons$12(idCtx,n$1) in -- #109
+//│     res -- #108
+//│   def j$1(x$11) =
+//│     x$11 -- #44
+//│   def _b_a_ctx_app$10(ctx,x) =
+//│     case ctx of -- #88
+//│       _IdContext =>
+//│         x -- #87
+//│       _Context =>
+//│         let field = _Context.field(ctx) in -- #86
+//│         let ptr = _Context.ptr(ctx) in -- #85
+//│         let _ = assign ptr.s := x in -- #84
+//│         let acc = _Context.acc(ctx) in -- #83
+//│         acc -- #82
+//│   def _b_a_ctx_comp$11(ctx1,ctx2) =
+//│     let ctx2acc = _Context.acc(ctx2) in -- #94
+//│     let ctx2ptr = _Context.ptr(ctx2) in -- #93
+//│     let ctx2field = _Context.field(ctx2) in -- #92
+//│     let* (newAcc) = _b_a_ctx_app$10(ctx1,ctx2acc) in -- #91
+//│     let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #90
+//│     ret -- #89
+//│   def b_modcons$12(ctx,n$1) =
+//│     let* (r0) = _b_modcons$12_a_modcons$13_opt$14(12,ctx,n$1,true,true) in -- #163
+//│     r0 -- #162
+//│   def a_modcons$13(ctx,n$0) =
+//│     let* (r0) = _b_modcons$12_a_modcons$13_opt$14(13,true,true,ctx,n$0) in -- #165
+//│     r0 -- #164
+//│   def _b_modcons$12_a_modcons$13_opt$14(tailrecBranch$,b_modcons$12_ctx,b_modcons$12_n$1,a_modcons$13_ctx,a_modcons$13_n$0) =
+//│     jump _b_modcons$12_a_modcons$13_opt_jp$15(tailrecBranch$,b_modcons$12_ctx,b_modcons$12_n$1,a_modcons$13_ctx,a_modcons$13_n$0) -- #161
+//│   def _b_modcons$12_a_modcons$13_opt_jp$15(tailrecBranch$,b_modcons$12_ctx,b_modcons$12_n$1,a_modcons$13_ctx,a_modcons$13_n$0) =
+//│     let scrut = ==(13,tailrecBranch$) in -- #160
+//│     if scrut -- #159
+//│       true =>
+//│         case a_modcons$13_n$0 of -- #158
+//│           S =>
+//│             let x$6 = S.s(a_modcons$13_n$0) in -- #153
+//│             let x$8 = S(0) in -- #152
+//│             let ctx2 = _Context(x$8,x$8,0) in -- #151
+//│             let* (composed) = _b_a_ctx_comp$11(a_modcons$13_ctx,ctx2) in -- #150
+//│             jump _b_modcons$12_a_modcons$13_opt_jp$15(12,composed,x$6,a_modcons$13_ctx,a_modcons$13_n$0) -- #149
+//│           Zero =>
+//│             let x$9 = Zero() in -- #157
+//│             let x$10 = S(x$9) in -- #156
+//│             let* (res) = _b_a_ctx_app$10(a_modcons$13_ctx,x$10) in -- #155
+//│             res -- #154
+//│       false =>
+//│         case b_modcons$12_n$1 of -- #148
+//│           S =>
+//│             let x$12 = S.s(b_modcons$12_n$1) in -- #142
+//│             let x$14 = S(0) in -- #141
+//│             let x$15 = S(x$14) in -- #140
+//│             let ctx2 = _Context(x$15,x$14,0) in -- #139
+//│             let* (composed) = _b_a_ctx_comp$11(b_modcons$12_ctx,ctx2) in -- #138
+//│             jump _b_modcons$12_a_modcons$13_opt_jp$15(13,b_modcons$12_ctx,b_modcons$12_n$1,composed,x$12) -- #137
+//│           Zero =>
+//│             let x$16 = Zero() in -- #147
+//│             let x$17 = S(x$16) in -- #146
+//│             let x$18 = S(x$17) in -- #145
+//│             let* (res) = _b_a_ctx_app$10(b_modcons$12_ctx,x$18) in -- #144
+//│             res -- #143
+//│   let x$0 = Zero() in -- #17
+//│   let x$1 = S(x$0) in -- #16
+//│   let x$2 = S(x$1) in -- #15
+//│   let x$3 = S(x$2) in -- #14
+//│   let* (x$4) = a(x$3) in -- #13
+//│   x$4 -- #12
 //│ 
 //│ Interpreted:
-//│ S(S(S(S(S(S(Zero()))))))
+//│ S(0)
 
 :interpIR
-class Cons(h, t)
-class Nil
 @tailrec fun addOne(xs) =
   if xs is 
     Cons(h, t) then
@@ -1192,168 +761,91 @@ class Nil
     Nil then 
       Nil
 addOne(Cons(1, Cons(2, Cons(3, Nil))))
-//│ |#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|@|tailrec| |#fun| |addOne|(|xs|)| |#=|→|#if| |xs| |is| |→|Cons|(|h|,| |t|)| |#then|→|#val| |next| |#=| |@|tailcall| |addOne|(|t|)|↵|#val| |ret| |#=| |Cons|(|h| |+| |1|,| |next|)|↵|#val| |rett| |#=| |ret|↵|rett|←|↵|Nil| |#then| |→|Nil|←|←|←|↵|addOne|(|Cons|(|1|,| |Cons|(|2|,| |Cons|(|3|,| |Nil|)|)|)|)|
-//│ Parsed: {class Cons(h, t,) {}; class Nil {}; fun addOne = (xs,) => {if xs is ‹(Cons(h, t,)) then {let next = @tailcall addOne(t,); let ret = Cons(+(h,)(1,), next,); let rett = ret; rett}; (Nil) then {Nil}›}; addOne(Cons(1, Cons(2, Cons(3, Nil,),),),)}
+//│ |@|tailrec| |#fun| |addOne|(|xs|)| |#=|→|#if| |xs| |is| |→|Cons|(|h|,| |t|)| |#then|→|#val| |next| |#=| |@|tailcall| |addOne|(|t|)|↵|#val| |ret| |#=| |Cons|(|h| |+| |1|,| |next|)|↵|#val| |rett| |#=| |ret|↵|rett|←|↵|Nil| |#then| |→|Nil|←|←|←|↵|addOne|(|Cons|(|1|,| |Cons|(|2|,| |Cons|(|3|,| |Nil|)|)|)|)|
+//│ Parsed: {fun addOne = (xs,) => {if xs is ‹(Cons(h, t,)) then {let next = @tailcall addOne(t,); let ret = Cons(+(h,)(1,), next,); let rett = ret; rett}; (Nil) then {Nil}›}; addOne(Cons(1, Cons(2, Cons(3, Nil,),),),)}
+//│ 
 //│ 
 //│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, [])}, {
-//│ Def(0, addOne, [xs$0],
-//│ 1, 
-//│ case xs$0 of -- #30
-//│   Cons =>
-//│     let x$1 = xs$0.t in -- #26
-//│     let x$2 = xs$0.h in -- #25
-//│     let* (x$3) = @tailcall addOne(x$1) in -- #24
-//│     let x$4 = +(x$2,1) in -- #23
-//│     let x$5 = Cons(x$4,x$3) in -- #22
-//│     jump j$0(x$5) -- #21
-//│   Nil =>
-//│     let x$6 = Nil() in -- #29
-//│     jump j$0(x$6) -- #28
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ },
-//│ let x$7 = Nil() in -- #55
-//│ let x$8 = Cons(3,x$7) in -- #54
-//│ let x$9 = Cons(2,x$8) in -- #53
-//│ let x$10 = Cons(1,x$9) in -- #52
-//│ let* (x$11) = addOne(x$10) in -- #51
-//│ x$11 -- #50)
+//│ Program:
+//│ 
+//│   def addOne(xs$0) =
+//│     case xs$0 of -- #57
+//│       Cons =>
+//│         let x$6 = Cons.t(xs$0) in -- #53
+//│         let x$7 = Cons.h(xs$0) in -- #52
+//│         let* (x$8) = @tailcall addOne(x$6) in -- #51
+//│         let x$9 = +(x$7,1) in -- #50
+//│         let x$10 = Cons(x$9,x$8) in -- #49
+//│         jump j$0(x$10) -- #48
+//│       Nil =>
+//│         let x$11 = Nil() in -- #56
+//│         jump j$0(x$11) -- #55
+//│   def j$0(x$5) =
+//│     x$5 -- #25
+//│   let x$0 = Nil() in -- #23
+//│   let x$1 = Cons(3,x$0) in -- #22
+//│   let x$2 = Cons(2,x$1) in -- #21
+//│   let x$3 = Cons(1,x$2) in -- #20
+//│   let* (x$4) = addOne(x$3) in -- #19
+//│   x$4 -- #18
+//│ 
 //│ 
 //│ Strongly Connected Tail Calls:
 //│ List(Set(j$0), Set(addOne))
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
-//│ Def(0, addOne, [xs$0],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #83
-//│ let* (res) = addOne_modcons$4(idCtx,xs$0) in -- #82
-//│ res -- #81
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, _addOne_ctx_app$2, [ctx,x],
-//│ 1, 
-//│ case ctx of -- #62
-//│   _IdContext =>
-//│     x -- #61
-//│   _Context =>
-//│     let field = ctx.field in -- #60
-//│     let ptr = ctx.ptr in -- #59
-//│     let _ = assign ptr.t := x in -- #58
-//│     let acc = ctx.acc in -- #57
-//│     acc -- #56
-//│ )
-//│ Def(3, _addOne_ctx_comp$3, [ctx1,ctx2],
-//│ 1, 
-//│ let ctx2acc = ctx2.acc in -- #68
-//│ let ctx2ptr = ctx2.ptr in -- #67
-//│ let ctx2field = ctx2.field in -- #66
-//│ let* (newAcc) = _addOne_ctx_app$2(ctx1,ctx2acc) in -- #65
-//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #64
-//│ ret -- #63
-//│ )
-//│ Def(5, addOne_modcons$4_jp, [ctx,xs$0],
-//│ 1, 
-//│ case xs$0 of -- #94
-//│   Cons =>
-//│     let x$1 = xs$0.t in -- #90
-//│     let x$2 = xs$0.h in -- #89
-//│     let x$4 = +(x$2,1) in -- #88
-//│     let x$5 = Cons(x$4,0) in -- #87
-//│     let ctx2 = _Context(x$5,x$5,0) in -- #86
-//│     let* (composed) = _addOne_ctx_comp$3(ctx,ctx2) in -- #85
-//│     jump addOne_modcons$4_jp(composed,x$1) -- #84
-//│   Nil =>
-//│     let x$6 = Nil() in -- #93
-//│     let* (res) = _addOne_ctx_app$2(ctx,x$6) in -- #92
-//│     res -- #91
-//│ )
-//│ Def(6, addOne_modcons$4, [ctx,xs$0],
-//│ 1, 
-//│ let* (r0) = addOne_modcons$4_jp(ctx,xs$0) in -- #96
-//│ r0 -- #95
-//│ )
-//│ },
-//│ let x$7 = Nil() in -- #55
-//│ let x$8 = Cons(3,x$7) in -- #54
-//│ let x$9 = Cons(2,x$8) in -- #53
-//│ let x$10 = Cons(1,x$9) in -- #52
-//│ let* (x$11) = addOne(x$10) in -- #51
-//│ x$11 -- #50)
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
-//│ Def(0, addOne, [xs$0],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #83
-//│ let* (res) = addOne_modcons$4(idCtx,xs$0) in -- #82
-//│ res -- #81
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, _addOne_ctx_app$2, [ctx,x],
-//│ 1, 
-//│ case ctx of -- #62
-//│   _IdContext =>
-//│     x -- #61
-//│   _Context =>
-//│     let field = ctx.field in -- #60
-//│     let ptr = ctx.ptr in -- #59
-//│     let _ = assign ptr.t := x in -- #58
-//│     let acc = ctx.acc in -- #57
-//│     acc -- #56
-//│ )
-//│ Def(3, _addOne_ctx_comp$3, [ctx1,ctx2],
-//│ 1, 
-//│ let ctx2acc = ctx2.acc in -- #68
-//│ let ctx2ptr = ctx2.ptr in -- #67
-//│ let ctx2field = ctx2.field in -- #66
-//│ let* (newAcc) = _addOne_ctx_app$2(ctx1,ctx2acc) in -- #65
-//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #64
-//│ ret -- #63
-//│ )
-//│ Def(5, addOne_modcons$4_jp, [ctx,xs$0],
-//│ 1, 
-//│ case xs$0 of -- #94
-//│   Cons =>
-//│     let x$1 = xs$0.t in -- #90
-//│     let x$2 = xs$0.h in -- #89
-//│     let x$4 = +(x$2,1) in -- #88
-//│     let x$5 = Cons(x$4,0) in -- #87
-//│     let ctx2 = _Context(x$5,x$5,0) in -- #86
-//│     let* (composed) = _addOne_ctx_comp$3(ctx,ctx2) in -- #85
-//│     jump addOne_modcons$4_jp(composed,x$1) -- #84
-//│   Nil =>
-//│     let x$6 = Nil() in -- #93
-//│     let* (res) = _addOne_ctx_app$2(ctx,x$6) in -- #92
-//│     res -- #91
-//│ )
-//│ Def(6, addOne_modcons$4, [ctx,xs$0],
-//│ 1, 
-//│ let* (r0) = addOne_modcons$4_jp(ctx,xs$0) in -- #96
-//│ r0 -- #95
-//│ )
-//│ },
-//│ let x$7 = Nil() in -- #55
-//│ let x$8 = Cons(3,x$7) in -- #54
-//│ let x$9 = Cons(2,x$8) in -- #53
-//│ let x$10 = Cons(1,x$9) in -- #52
-//│ let* (x$11) = addOne(x$10) in -- #51
-//│ x$11 -- #50)
+//│ Program:
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
+//│   def addOne(xs$0) =
+//│     let idCtx = _IdContext() in -- #91
+//│     let* (res) = addOne_modcons$10(idCtx,xs$0) in -- #90
+//│     res -- #89
+//│   def j$0(x$5) =
+//│     x$5 -- #25
+//│   def _addOne_ctx_app$8(ctx,x) =
+//│     case ctx of -- #70
+//│       _IdContext =>
+//│         x -- #69
+//│       _Context =>
+//│         let field = _Context.field(ctx) in -- #68
+//│         let ptr = _Context.ptr(ctx) in -- #67
+//│         let _ = assign ptr.t := x in -- #66
+//│         let acc = _Context.acc(ctx) in -- #65
+//│         acc -- #64
+//│   def _addOne_ctx_comp$9(ctx1,ctx2) =
+//│     let ctx2acc = _Context.acc(ctx2) in -- #76
+//│     let ctx2ptr = _Context.ptr(ctx2) in -- #75
+//│     let ctx2field = _Context.field(ctx2) in -- #74
+//│     let* (newAcc) = _addOne_ctx_app$8(ctx1,ctx2acc) in -- #73
+//│     let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #72
+//│     ret -- #71
+//│   def addOne_modcons$10_jp(ctx,xs$0) =
+//│     case xs$0 of -- #102
+//│       Cons =>
+//│         let x$6 = Cons.t(xs$0) in -- #98
+//│         let x$7 = Cons.h(xs$0) in -- #97
+//│         let x$9 = +(x$7,1) in -- #96
+//│         let x$10 = Cons(x$9,0) in -- #95
+//│         let ctx2 = _Context(x$10,x$10,0) in -- #94
+//│         let* (composed) = _addOne_ctx_comp$9(ctx,ctx2) in -- #93
+//│         jump addOne_modcons$10_jp(composed,x$6) -- #92
+//│       Nil =>
+//│         let x$11 = Nil() in -- #101
+//│         let* (res) = _addOne_ctx_app$8(ctx,x$11) in -- #100
+//│         res -- #99
+//│   def addOne_modcons$10(ctx,xs$0) =
+//│     let* (r0) = addOne_modcons$10_jp(ctx,xs$0) in -- #104
+//│     r0 -- #103
+//│   let x$0 = Nil() in -- #23
+//│   let x$1 = Cons(3,x$0) in -- #22
+//│   let x$2 = Cons(2,x$1) in -- #21
+//│   let x$3 = Cons(1,x$2) in -- #20
+//│   let* (x$4) = addOne(x$3) in -- #19
+//│   x$4 -- #18
 //│ 
 //│ Interpreted:
-//│ Cons(2,Cons(3,Cons(4,Nil())))
+//│ Cons(2,0)
 
 :interpIR
-class Nil
-class Cons(m, n)
 @tailrec fun a(x) =
   if x is
     Cons(m, n) then
@@ -1368,281 +860,145 @@ class Cons(m, n)
   else 
     a(Cons(n, Nil))
 b(16)
-//│ |#class| |Nil|↵|#class| |Cons|(|m|,| |n|)|↵|@|tailrec| |#fun| |a|(|x|)| |#=|→|#if| |x| |is|→|Cons|(|m|,| |n|)| |#then|→|#if| |m| |<| |0| |#then|→|Cons|(|-|1|,| |Nil|)|←|↵|#else| |→|Cons|(|m| |*| |4|,| |b|(|m| |-| |2|)|)|←|←|↵|Nil| |#then| |Nil|←|←|↵|@|tailrec| |#fun| |b|(|n|)| |#=|→|#if| |n| |<=| |0| |#then| |→|Cons|(|0|,| |Nil|)|←|↵|#else| |→|a|(|Cons|(|n|,| |Nil|)|)|←|←|↵|b|(|16|)|
-//│ Parsed: {class Nil {}; class Cons(m, n,) {}; fun a = (x,) => {if x is ‹(Cons(m, n,)) then {if (<(m,)(0,)) then {Cons(-1, Nil,)} else {Cons(*(m,)(4,), b(-(m,)(2,),),)}}; (Nil) then Nil›}; fun b = (n,) => {if (<=(n,)(0,)) then {Cons(0, Nil,)} else {a(Cons(n, Nil,),)}}; b(16,)}
+//│ |@|tailrec| |#fun| |a|(|x|)| |#=|→|#if| |x| |is|→|Cons|(|m|,| |n|)| |#then|→|#if| |m| |<| |0| |#then|→|Cons|(|-|1|,| |Nil|)|←|↵|#else| |→|Cons|(|m| |*| |4|,| |b|(|m| |-| |2|)|)|←|←|↵|Nil| |#then| |Nil|←|←|↵|@|tailrec| |#fun| |b|(|n|)| |#=|→|#if| |n| |<=| |0| |#then| |→|Cons|(|0|,| |Nil|)|←|↵|#else| |→|a|(|Cons|(|n|,| |Nil|)|)|←|←|↵|b|(|16|)|
+//│ Parsed: {fun a = (x,) => {if x is ‹(Cons(m, n,)) then {if (<(m,)(0,)) then {Cons(-1, Nil,)} else {Cons(*(m,)(4,), b(-(m,)(2,),),)}}; (Nil) then Nil›}; fun b = (n,) => {if (<=(n,)(0,)) then {Cons(0, Nil,)} else {a(Cons(n, Nil,),)}}; b(16,)}
+//│ 
 //│ 
 //│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Nil, []),ClassInfo(3, Cons, [m,n])}, {
-//│ Def(0, a, [x$0],
-//│ 1, 
-//│ case x$0 of -- #46
-//│   Cons =>
-//│     let x$2 = x$0.n in -- #42
-//│     let x$3 = x$0.m in -- #41
-//│     let x$4 = <(x$3,0) in -- #40
-//│     if x$4 -- #39
-//│       true =>
-//│         let x$6 = Nil() in -- #19
-//│         let x$7 = Cons(-1,x$6) in -- #18
-//│         jump j$1(x$7) -- #17
-//│       false =>
-//│         let x$8 = *(x$3,4) in -- #38
-//│         let x$9 = -(x$3,2) in -- #37
-//│         let* (x$10) = b(x$9) in -- #36
-//│         let x$11 = Cons(x$8,x$10) in -- #35
-//│         jump j$1(x$11) -- #34
-//│   Nil =>
-//│     let x$12 = Nil() in -- #45
-//│     jump j$0(x$12) -- #44
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #1
-//│ )
-//│ Def(2, j$1, [x$5],
-//│ 1, 
-//│ jump j$0(x$5) -- #10
-//│ )
-//│ Def(3, b, [n$0],
-//│ 1, 
-//│ let x$13 = <=(n$0,0) in -- #75
-//│ if x$13 -- #74
-//│   true =>
-//│     let x$15 = Nil() in -- #59
-//│     let x$16 = Cons(0,x$15) in -- #58
-//│     jump j$2(x$16) -- #57
-//│   false =>
-//│     let x$17 = Nil() in -- #73
-//│     let x$18 = Cons(n$0,x$17) in -- #72
-//│     let* (x$19) = a(x$18) in -- #71
-//│     jump j$2(x$19) -- #70
-//│ )
-//│ Def(4, j$2, [x$14],
-//│ 1, 
-//│ x$14 -- #50
-//│ )
-//│ },
-//│ let* (x$20) = b(16) in -- #81
-//│ x$20 -- #80)
+//│ Program:
 //│ 
-//│ Strongly Connected Tail Calls:
-//│ List(Set(j$2), Set(j$1), Set(j$0), Set(b, a))
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Nil, []),ClassInfo(3, Cons, [m,n]),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
-//│ Def(0, a, [x$0],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #129
-//│ let* (res) = a_modcons$8(idCtx,x$0) in -- #128
-//│ res -- #127
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #1
-//│ )
-//│ Def(2, j$1, [x$5],
-//│ 1, 
-//│ jump j$0(x$5) -- #10
-//│ )
-//│ Def(3, b, [n$0],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #107
-//│ let* (res) = b_modcons$7(idCtx,n$0) in -- #106
-//│ res -- #105
-//│ )
-//│ Def(4, j$2, [x$14],
-//│ 1, 
-//│ x$14 -- #50
-//│ )
-//│ Def(5, _b_a_ctx_app$5, [ctx,x],
-//│ 1, 
-//│ case ctx of -- #88
-//│   _IdContext =>
-//│     x -- #87
-//│   _Context =>
-//│     let field = ctx.field in -- #86
-//│     let ptr = ctx.ptr in -- #85
-//│     let _ = assign ptr.n := x in -- #84
-//│     let acc = ctx.acc in -- #83
-//│     acc -- #82
-//│ )
-//│ Def(6, _b_a_ctx_comp$6, [ctx1,ctx2],
-//│ 1, 
-//│ let ctx2acc = ctx2.acc in -- #94
-//│ let ctx2ptr = ctx2.ptr in -- #93
-//│ let ctx2field = ctx2.field in -- #92
-//│ let* (newAcc) = _b_a_ctx_app$5(ctx1,ctx2acc) in -- #91
-//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #90
-//│ ret -- #89
-//│ )
-//│ Def(7, b_modcons$7, [ctx,n$0],
-//│ 1, 
-//│ let* (r0) = _b_modcons$7_a_modcons$8_opt$9(7,ctx,n$0,undefined,undefined) in -- #170
-//│ r0 -- #169
-//│ )
-//│ Def(8, a_modcons$8, [ctx,x$0],
-//│ 1, 
-//│ let* (r0) = _b_modcons$7_a_modcons$8_opt$9(8,undefined,undefined,ctx,x$0) in -- #172
-//│ r0 -- #171
-//│ )
-//│ Def(9, _b_modcons$7_a_modcons$8_opt$9, [tailrecBranch$,b_modcons$7_ctx,b_modcons$7_n$0,a_modcons$8_ctx,a_modcons$8_x$0],
-//│ 1, 
-//│ jump _b_modcons$7_a_modcons$8_opt_jp$10(tailrecBranch$,b_modcons$7_ctx,b_modcons$7_n$0,a_modcons$8_ctx,a_modcons$8_x$0) -- #168
-//│ )
-//│ Def(10, _b_modcons$7_a_modcons$8_opt_jp$10, [tailrecBranch$,b_modcons$7_ctx,b_modcons$7_n$0,a_modcons$8_ctx,a_modcons$8_x$0],
-//│ 1, 
-//│ let scrut = ==(8,tailrecBranch$) in -- #167
-//│ if scrut -- #166
-//│   true =>
-//│     case a_modcons$8_x$0 of -- #165
+//│   def a(x$1) =
+//│     case x$1 of -- #54
 //│       Cons =>
-//│         let x$2 = a_modcons$8_x$0.n in -- #161
-//│         let x$3 = a_modcons$8_x$0.m in -- #160
-//│         let x$4 = <(x$3,0) in -- #159
-//│         if x$4 -- #158
+//│         let x$3 = Cons.t(x$1) in -- #50
+//│         let x$4 = Cons.h(x$1) in -- #49
+//│         let x$5 = <(x$4,0) in -- #48
+//│         if x$5 -- #47
 //│           true =>
-//│             let x$6 = Nil() in -- #151
-//│             let x$7 = Cons(-1,x$6) in -- #150
-//│             let* (res) = _b_a_ctx_app$5(a_modcons$8_ctx,x$7) in -- #149
-//│             res -- #148
+//│             let x$7 = Nil() in -- #28
+//│             let x$8 = Cons(-1,x$7) in -- #27
+//│             jump j$1(x$8) -- #26
 //│           false =>
-//│             let x$8 = *(x$3,4) in -- #157
-//│             let x$9 = -(x$3,2) in -- #156
-//│             let x$11 = Cons(x$8,0) in -- #155
-//│             let ctx2 = _Context(x$11,x$11,0) in -- #154
-//│             let* (composed) = _b_a_ctx_comp$6(a_modcons$8_ctx,ctx2) in -- #153
-//│             jump _b_modcons$7_a_modcons$8_opt_jp$10(7,composed,x$9,a_modcons$8_ctx,a_modcons$8_x$0) -- #152
+//│             let x$9 = *(x$4,4) in -- #46
+//│             let x$10 = -(x$4,2) in -- #45
+//│             let* (x$11) = b(x$10) in -- #44
+//│             let x$12 = Cons(x$9,x$11) in -- #43
+//│             jump j$1(x$12) -- #42
 //│       Nil =>
-//│         let x$12 = Nil() in -- #164
-//│         let* (res) = _b_a_ctx_app$5(a_modcons$8_ctx,x$12) in -- #163
-//│         res -- #162
-//│   false =>
-//│     let x$13 = <=(b_modcons$7_n$0,0) in -- #147
-//│     if x$13 -- #146
+//│         let x$13 = Nil() in -- #53
+//│         jump j$0(x$13) -- #52
+//│   def j$0(x$2) =
+//│     x$2 -- #6
+//│   def j$1(x$6) =
+//│     jump j$0(x$6) -- #19
+//│   def b(n$0) =
+//│     let x$14 = <=(n$0,0) in -- #82
+//│     if x$14 -- #81
 //│       true =>
-//│         let x$15 = Nil() in -- #142
-//│         let x$16 = Cons(0,x$15) in -- #141
-//│         let* (res) = _b_a_ctx_app$5(b_modcons$7_ctx,x$16) in -- #140
-//│         res -- #139
+//│         let x$16 = Nil() in -- #67
+//│         let x$17 = Cons(0,x$16) in -- #66
+//│         jump j$2(x$17) -- #65
 //│       false =>
-//│         let x$17 = Nil() in -- #145
-//│         let x$18 = Cons(b_modcons$7_n$0,x$17) in -- #144
-//│         jump _b_modcons$7_a_modcons$8_opt_jp$10(8,b_modcons$7_ctx,b_modcons$7_n$0,b_modcons$7_ctx,x$18) -- #143
-//│ )
-//│ },
-//│ let* (x$20) = b(16) in -- #81
-//│ x$20 -- #80)
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Nil, []),ClassInfo(3, Cons, [m,n]),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
-//│ Def(0, a, [x$0],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #129
-//│ let* (res) = a_modcons$8(idCtx,x$0) in -- #128
-//│ res -- #127
-//│ )
-//│ Def(1, j$0, [x$1],
-//│ 1, 
-//│ x$1 -- #1
-//│ )
-//│ Def(2, j$1, [x$5],
-//│ 1, 
-//│ jump j$0(x$5) -- #10
-//│ )
-//│ Def(3, b, [n$0],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #107
-//│ let* (res) = b_modcons$7(idCtx,n$0) in -- #106
-//│ res -- #105
-//│ )
-//│ Def(4, j$2, [x$14],
-//│ 1, 
-//│ x$14 -- #50
-//│ )
-//│ Def(5, _b_a_ctx_app$5, [ctx,x],
-//│ 1, 
-//│ case ctx of -- #88
-//│   _IdContext =>
-//│     x -- #87
-//│   _Context =>
-//│     let field = ctx.field in -- #86
-//│     let ptr = ctx.ptr in -- #85
-//│     let _ = assign ptr.n := x in -- #84
-//│     let acc = ctx.acc in -- #83
-//│     acc -- #82
-//│ )
-//│ Def(6, _b_a_ctx_comp$6, [ctx1,ctx2],
-//│ 1, 
-//│ let ctx2acc = ctx2.acc in -- #94
-//│ let ctx2ptr = ctx2.ptr in -- #93
-//│ let ctx2field = ctx2.field in -- #92
-//│ let* (newAcc) = _b_a_ctx_app$5(ctx1,ctx2acc) in -- #91
-//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #90
-//│ ret -- #89
-//│ )
-//│ Def(7, b_modcons$7, [ctx,n$0],
-//│ 1, 
-//│ let* (r0) = _b_modcons$7_a_modcons$8_opt$9(7,ctx,n$0,undefined,undefined) in -- #170
-//│ r0 -- #169
-//│ )
-//│ Def(8, a_modcons$8, [ctx,x$0],
-//│ 1, 
-//│ let* (r0) = _b_modcons$7_a_modcons$8_opt$9(8,undefined,undefined,ctx,x$0) in -- #172
-//│ r0 -- #171
-//│ )
-//│ Def(9, _b_modcons$7_a_modcons$8_opt$9, [tailrecBranch$,b_modcons$7_ctx,b_modcons$7_n$0,a_modcons$8_ctx,a_modcons$8_x$0],
-//│ 1, 
-//│ jump _b_modcons$7_a_modcons$8_opt_jp$10(tailrecBranch$,b_modcons$7_ctx,b_modcons$7_n$0,a_modcons$8_ctx,a_modcons$8_x$0) -- #168
-//│ )
-//│ Def(10, _b_modcons$7_a_modcons$8_opt_jp$10, [tailrecBranch$,b_modcons$7_ctx,b_modcons$7_n$0,a_modcons$8_ctx,a_modcons$8_x$0],
-//│ 1, 
-//│ let scrut = ==(8,tailrecBranch$) in -- #167
-//│ if scrut -- #166
-//│   true =>
-//│     case a_modcons$8_x$0 of -- #165
-//│       Cons =>
-//│         let x$2 = a_modcons$8_x$0.n in -- #161
-//│         let x$3 = a_modcons$8_x$0.m in -- #160
-//│         let x$4 = <(x$3,0) in -- #159
-//│         if x$4 -- #158
-//│           true =>
-//│             let x$6 = Nil() in -- #151
-//│             let x$7 = Cons(-1,x$6) in -- #150
-//│             let* (res) = _b_a_ctx_app$5(a_modcons$8_ctx,x$7) in -- #149
-//│             res -- #148
-//│           false =>
-//│             let x$8 = *(x$3,4) in -- #157
-//│             let x$9 = -(x$3,2) in -- #156
-//│             let x$11 = Cons(x$8,0) in -- #155
-//│             let ctx2 = _Context(x$11,x$11,0) in -- #154
-//│             let* (composed) = _b_a_ctx_comp$6(a_modcons$8_ctx,ctx2) in -- #153
-//│             jump _b_modcons$7_a_modcons$8_opt_jp$10(7,composed,x$9,a_modcons$8_ctx,a_modcons$8_x$0) -- #152
-//│       Nil =>
-//│         let x$12 = Nil() in -- #164
-//│         let* (res) = _b_a_ctx_app$5(a_modcons$8_ctx,x$12) in -- #163
-//│         res -- #162
-//│   false =>
-//│     let x$13 = <=(b_modcons$7_n$0,0) in -- #147
-//│     if x$13 -- #146
+//│         let x$18 = Nil() in -- #80
+//│         let x$19 = Cons(n$0,x$18) in -- #79
+//│         let* (x$20) = a(x$19) in -- #78
+//│         jump j$2(x$20) -- #77
+//│   def j$2(x$15) =
+//│     x$15 -- #58
+//│   let* (x$0) = b(16) in -- #4
+//│   x$0 -- #3
+//│ 
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(j$2), Set(j$1), Set(j$0), Set(b, a))
+//│ Program:
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
+//│   def a(x$1) =
+//│     let idCtx = _IdContext() in -- #136
+//│     let* (res) = a_modcons$14(idCtx,x$1) in -- #135
+//│     res -- #134
+//│   def j$0(x$2) =
+//│     x$2 -- #6
+//│   def j$1(x$6) =
+//│     jump j$0(x$6) -- #19
+//│   def b(n$0) =
+//│     let idCtx = _IdContext() in -- #114
+//│     let* (res) = b_modcons$13(idCtx,n$0) in -- #113
+//│     res -- #112
+//│   def j$2(x$15) =
+//│     x$15 -- #58
+//│   def _b_a_ctx_app$11(ctx,x) =
+//│     case ctx of -- #95
+//│       _IdContext =>
+//│         x -- #94
+//│       _Context =>
+//│         let field = _Context.field(ctx) in -- #93
+//│         let ptr = _Context.ptr(ctx) in -- #92
+//│         let _ = assign ptr.t := x in -- #91
+//│         let acc = _Context.acc(ctx) in -- #90
+//│         acc -- #89
+//│   def _b_a_ctx_comp$12(ctx1,ctx2) =
+//│     let ctx2acc = _Context.acc(ctx2) in -- #101
+//│     let ctx2ptr = _Context.ptr(ctx2) in -- #100
+//│     let ctx2field = _Context.field(ctx2) in -- #99
+//│     let* (newAcc) = _b_a_ctx_app$11(ctx1,ctx2acc) in -- #98
+//│     let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #97
+//│     ret -- #96
+//│   def b_modcons$13(ctx,n$0) =
+//│     let* (r0) = _b_modcons$13_a_modcons$14_opt$15(13,ctx,n$0,true,true) in -- #177
+//│     r0 -- #176
+//│   def a_modcons$14(ctx,x$1) =
+//│     let* (r0) = _b_modcons$13_a_modcons$14_opt$15(14,true,true,ctx,x$1) in -- #179
+//│     r0 -- #178
+//│   def _b_modcons$13_a_modcons$14_opt$15(tailrecBranch$,b_modcons$13_ctx,b_modcons$13_n$0,a_modcons$14_ctx,a_modcons$14_x$1) =
+//│     jump _b_modcons$13_a_modcons$14_opt_jp$16(tailrecBranch$,b_modcons$13_ctx,b_modcons$13_n$0,a_modcons$14_ctx,a_modcons$14_x$1) -- #175
+//│   def _b_modcons$13_a_modcons$14_opt_jp$16(tailrecBranch$,b_modcons$13_ctx,b_modcons$13_n$0,a_modcons$14_ctx,a_modcons$14_x$1) =
+//│     let scrut = ==(14,tailrecBranch$) in -- #174
+//│     if scrut -- #173
 //│       true =>
-//│         let x$15 = Nil() in -- #142
-//│         let x$16 = Cons(0,x$15) in -- #141
-//│         let* (res) = _b_a_ctx_app$5(b_modcons$7_ctx,x$16) in -- #140
-//│         res -- #139
+//│         case a_modcons$14_x$1 of -- #172
+//│           Cons =>
+//│             let x$3 = Cons.t(a_modcons$14_x$1) in -- #168
+//│             let x$4 = Cons.h(a_modcons$14_x$1) in -- #167
+//│             let x$5 = <(x$4,0) in -- #166
+//│             if x$5 -- #165
+//│               true =>
+//│                 let x$7 = Nil() in -- #158
+//│                 let x$8 = Cons(-1,x$7) in -- #157
+//│                 let* (res) = _b_a_ctx_app$11(a_modcons$14_ctx,x$8) in -- #156
+//│                 res -- #155
+//│               false =>
+//│                 let x$9 = *(x$4,4) in -- #164
+//│                 let x$10 = -(x$4,2) in -- #163
+//│                 let x$12 = Cons(x$9,0) in -- #162
+//│                 let ctx2 = _Context(x$12,x$12,0) in -- #161
+//│                 let* (composed) = _b_a_ctx_comp$12(a_modcons$14_ctx,ctx2) in -- #160
+//│                 jump _b_modcons$13_a_modcons$14_opt_jp$16(13,composed,x$10,a_modcons$14_ctx,a_modcons$14_x$1) -- #159
+//│           Nil =>
+//│             let x$13 = Nil() in -- #171
+//│             let* (res) = _b_a_ctx_app$11(a_modcons$14_ctx,x$13) in -- #170
+//│             res -- #169
 //│       false =>
-//│         let x$17 = Nil() in -- #145
-//│         let x$18 = Cons(b_modcons$7_n$0,x$17) in -- #144
-//│         jump _b_modcons$7_a_modcons$8_opt_jp$10(8,b_modcons$7_ctx,b_modcons$7_n$0,b_modcons$7_ctx,x$18) -- #143
-//│ )
-//│ },
-//│ let* (x$20) = b(16) in -- #81
-//│ x$20 -- #80)
+//│         let x$14 = <=(b_modcons$13_n$0,0) in -- #154
+//│         if x$14 -- #153
+//│           true =>
+//│             let x$16 = Nil() in -- #149
+//│             let x$17 = Cons(0,x$16) in -- #148
+//│             let* (res) = _b_a_ctx_app$11(b_modcons$13_ctx,x$17) in -- #147
+//│             res -- #146
+//│           false =>
+//│             let x$18 = Nil() in -- #152
+//│             let x$19 = Cons(b_modcons$13_n$0,x$18) in -- #151
+//│             jump _b_modcons$13_a_modcons$14_opt_jp$16(14,b_modcons$13_ctx,b_modcons$13_n$0,b_modcons$13_ctx,x$19) -- #150
+//│   let* (x$0) = b(16) in -- #4
+//│   x$0 -- #3
 //│ 
 //│ Interpreted:
-//│ Cons(64,Cons(56,Cons(48,Cons(40,Cons(32,Cons(24,Cons(16,Cons(8,Cons(0,Nil())))))))))
+//│ Cons(64,0)
 
 :noTailRec
 :interpIR
-class Cons(h, t)
-class Nil
 fun foo(xs) =
   if xs is 
     Cons(h, t) then
@@ -1653,66 +1009,57 @@ fun foo(xs) =
     Nil then 
       Nil
 foo(Cons(1, Cons(6, Cons(7, Cons(4, Cons(2, Cons(3, Cons(9, Nil))))))))
-//│ |#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|#fun| |foo|(|xs|)| |#=|→|#if| |xs| |is| |→|Cons|(|h|,| |t|)| |#then|→|#if| |h| |>| |5| |#then| |foo|(|t|)|↵|#else| |→|#val| |item| |#=| |#if| |h| |<| |3| |#then| |-|1| |#else| |100| |↵|Cons|(|item|,| |Cons|(|h|,| |foo|(|t|)|)|)|←|←|↵|Nil| |#then| |→|Nil|←|←|←|↵|foo|(|Cons|(|1|,| |Cons|(|6|,| |Cons|(|7|,| |Cons|(|4|,| |Cons|(|2|,| |Cons|(|3|,| |Cons|(|9|,| |Nil|)|)|)|)|)|)|)|)|
-//│ Parsed: {class Cons(h, t,) {}; class Nil {}; fun foo = (xs,) => {if xs is ‹(Cons(h, t,)) then {if (>(h,)(5,)) then foo(t,) else {let item = if (<(h,)(3,)) then -1 else 100; Cons(item, Cons(h, foo(t,),),)}}; (Nil) then {Nil}›}; foo(Cons(1, Cons(6, Cons(7, Cons(4, Cons(2, Cons(3, Cons(9, Nil,),),),),),),),)}
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, [])}, {
-//│ Def(0, foo, [xs$0],
-//│ 1, 
-//│ case xs$0 of -- #54
-//│   Cons =>
-//│     let x$1 = xs$0.t in -- #50
-//│     let x$2 = xs$0.h in -- #49
-//│     let x$3 = >(x$2,5) in -- #48
-//│     if x$3 -- #47
-//│       true =>
-//│         let* (x$5) = foo(x$1) in -- #17
-//│         jump j$1(x$5) -- #16
-//│       false =>
-//│         let x$6 = <(x$2,3) in -- #46
-//│         if x$6 -- #45
+//│ |#fun| |foo|(|xs|)| |#=|→|#if| |xs| |is| |→|Cons|(|h|,| |t|)| |#then|→|#if| |h| |>| |5| |#then| |foo|(|t|)|↵|#else| |→|#val| |item| |#=| |#if| |h| |<| |3| |#then| |-|1| |#else| |100| |↵|Cons|(|item|,| |Cons|(|h|,| |foo|(|t|)|)|)|←|←|↵|Nil| |#then| |→|Nil|←|←|←|↵|foo|(|Cons|(|1|,| |Cons|(|6|,| |Cons|(|7|,| |Cons|(|4|,| |Cons|(|2|,| |Cons|(|3|,| |Cons|(|9|,| |Nil|)|)|)|)|)|)|)|)|
+//│ Parsed: {fun foo = (xs,) => {if xs is ‹(Cons(h, t,)) then {if (>(h,)(5,)) then foo(t,) else {let item = if (<(h,)(3,)) then -1 else 100; Cons(item, Cons(h, foo(t,),),)}}; (Nil) then {Nil}›}; foo(Cons(1, Cons(6, Cons(7, Cons(4, Cons(2, Cons(3, Cons(9, Nil,),),),),),),),)}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def foo(xs$0) =
+//│     case xs$0 of -- #104
+//│       Cons =>
+//│         let x$10 = Cons.t(xs$0) in -- #100
+//│         let x$11 = Cons.h(xs$0) in -- #99
+//│         let x$12 = >(x$11,5) in -- #98
+//│         if x$12 -- #97
 //│           true =>
-//│             jump j$2(-1,x$1,x$2) -- #42
+//│             let* (x$14) = foo(x$10) in -- #68
+//│             jump j$1(x$14) -- #67
 //│           false =>
-//│             jump j$2(100,x$1,x$2) -- #44
-//│   Nil =>
-//│     let x$11 = Nil() in -- #53
-//│     jump j$0(x$11) -- #52
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, j$1, [x$4],
-//│ 1, 
-//│ jump j$0(x$4) -- #10
-//│ )
-//│ Def(3, j$2, [x$7,x$1,x$2],
-//│ 1, 
-//│ let* (x$8) = foo(x$1) in -- #40
-//│ let x$9 = Cons(x$2,x$8) in -- #39
-//│ let x$10 = Cons(x$7,x$9) in -- #38
-//│ jump j$1(x$10) -- #37
-//│ )
-//│ },
-//│ let x$12 = Nil() in -- #103
-//│ let x$13 = Cons(9,x$12) in -- #102
-//│ let x$14 = Cons(3,x$13) in -- #101
-//│ let x$15 = Cons(2,x$14) in -- #100
-//│ let x$16 = Cons(4,x$15) in -- #99
-//│ let x$17 = Cons(7,x$16) in -- #98
-//│ let x$18 = Cons(6,x$17) in -- #97
-//│ let x$19 = Cons(1,x$18) in -- #96
-//│ let* (x$20) = foo(x$19) in -- #95
-//│ x$20 -- #94)
+//│             let x$15 = <(x$11,3) in -- #96
+//│             if x$15 -- #95
+//│               true =>
+//│                 jump j$2(-1,x$10,x$11) -- #92
+//│               false =>
+//│                 jump j$2(100,x$10,x$11) -- #94
+//│       Nil =>
+//│         let x$20 = Nil() in -- #103
+//│         jump j$0(x$20) -- #102
+//│   def j$0(x$9) =
+//│     x$9 -- #49
+//│   def j$1(x$13) =
+//│     jump j$0(x$13) -- #62
+//│   def j$2(x$16,x$10,x$11) =
+//│     let* (x$17) = foo(x$10) in -- #90
+//│     let x$18 = Cons(x$11,x$17) in -- #89
+//│     let x$19 = Cons(x$16,x$18) in -- #88
+//│     jump j$1(x$19) -- #87
+//│   let x$0 = Nil() in -- #47
+//│   let x$1 = Cons(9,x$0) in -- #46
+//│   let x$2 = Cons(3,x$1) in -- #45
+//│   let x$3 = Cons(2,x$2) in -- #44
+//│   let x$4 = Cons(4,x$3) in -- #43
+//│   let x$5 = Cons(7,x$4) in -- #42
+//│   let x$6 = Cons(6,x$5) in -- #41
+//│   let x$7 = Cons(1,x$6) in -- #40
+//│   let* (x$8) = foo(x$7) in -- #39
+//│   x$8 -- #38
 //│ 
 //│ Interpreted:
 //│ Cons(-1,Cons(1,Cons(100,Cons(4,Cons(-1,Cons(2,Cons(100,Cons(3,Nil()))))))))
 
 :interpIR
-class Cons(h, t)
-class Nil
 @tailrec fun foo(xs) =
   if xs is 
     Cons(h, t) then
@@ -1723,241 +1070,131 @@ class Nil
     Nil then 
       Nil
 foo(Cons(1, Cons(6, Cons(7, Cons(4, Cons(2, Cons(3, Cons(9, Nil))))))))
-//│ |#class| |Cons|(|h|,| |t|)|↵|#class| |Nil|↵|@|tailrec| |#fun| |foo|(|xs|)| |#=|→|#if| |xs| |is| |→|Cons|(|h|,| |t|)| |#then|→|#if| |h| |>| |5| |#then| |@|tailcall| |foo|(|t|)|↵|#else| |→|#val| |item| |#=| |#if| |h| |<| |3| |#then| |-|1| |#else| |100| |↵|Cons|(|item|,| |Cons|(|h|,| |@|tailcall| |foo|(|t|)|)|)|←|←|↵|Nil| |#then| |→|Nil|←|←|←|↵|foo|(|Cons|(|1|,| |Cons|(|6|,| |Cons|(|7|,| |Cons|(|4|,| |Cons|(|2|,| |Cons|(|3|,| |Cons|(|9|,| |Nil|)|)|)|)|)|)|)|)|
-//│ Parsed: {class Cons(h, t,) {}; class Nil {}; fun foo = (xs,) => {if xs is ‹(Cons(h, t,)) then {if (>(h,)(5,)) then @tailcall foo(t,) else {let item = if (<(h,)(3,)) then -1 else 100; Cons(item, Cons(h, @tailcall foo(t,),),)}}; (Nil) then {Nil}›}; foo(Cons(1, Cons(6, Cons(7, Cons(4, Cons(2, Cons(3, Cons(9, Nil,),),),),),),),)}
+//│ |@|tailrec| |#fun| |foo|(|xs|)| |#=|→|#if| |xs| |is| |→|Cons|(|h|,| |t|)| |#then|→|#if| |h| |>| |5| |#then| |@|tailcall| |foo|(|t|)|↵|#else| |→|#val| |item| |#=| |#if| |h| |<| |3| |#then| |-|1| |#else| |100| |↵|Cons|(|item|,| |Cons|(|h|,| |@|tailcall| |foo|(|t|)|)|)|←|←|↵|Nil| |#then| |→|Nil|←|←|←|↵|foo|(|Cons|(|1|,| |Cons|(|6|,| |Cons|(|7|,| |Cons|(|4|,| |Cons|(|2|,| |Cons|(|3|,| |Cons|(|9|,| |Nil|)|)|)|)|)|)|)|)|
+//│ Parsed: {fun foo = (xs,) => {if xs is ‹(Cons(h, t,)) then {if (>(h,)(5,)) then @tailcall foo(t,) else {let item = if (<(h,)(3,)) then -1 else 100; Cons(item, Cons(h, @tailcall foo(t,),),)}}; (Nil) then {Nil}›}; foo(Cons(1, Cons(6, Cons(7, Cons(4, Cons(2, Cons(3, Cons(9, Nil,),),),),),),),)}
+//│ 
 //│ 
 //│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, [])}, {
-//│ Def(0, foo, [xs$0],
-//│ 1, 
-//│ case xs$0 of -- #54
-//│   Cons =>
-//│     let x$1 = xs$0.t in -- #50
-//│     let x$2 = xs$0.h in -- #49
-//│     let x$3 = >(x$2,5) in -- #48
-//│     if x$3 -- #47
-//│       true =>
-//│         let* (x$5) = @tailcall foo(x$1) in -- #17
-//│         jump j$1(x$5) -- #16
-//│       false =>
-//│         let x$6 = <(x$2,3) in -- #46
-//│         if x$6 -- #45
-//│           true =>
-//│             jump j$2(-1,x$1,x$2) -- #42
-//│           false =>
-//│             jump j$2(100,x$1,x$2) -- #44
-//│   Nil =>
-//│     let x$11 = Nil() in -- #53
-//│     jump j$0(x$11) -- #52
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, j$1, [x$4],
-//│ 1, 
-//│ jump j$0(x$4) -- #10
-//│ )
-//│ Def(3, j$2, [x$7,x$1,x$2],
-//│ 1, 
-//│ let* (x$8) = @tailcall foo(x$1) in -- #40
-//│ let x$9 = Cons(x$2,x$8) in -- #39
-//│ let x$10 = Cons(x$7,x$9) in -- #38
-//│ jump j$1(x$10) -- #37
-//│ )
-//│ },
-//│ let x$12 = Nil() in -- #103
-//│ let x$13 = Cons(9,x$12) in -- #102
-//│ let x$14 = Cons(3,x$13) in -- #101
-//│ let x$15 = Cons(2,x$14) in -- #100
-//│ let x$16 = Cons(4,x$15) in -- #99
-//│ let x$17 = Cons(7,x$16) in -- #98
-//│ let x$18 = Cons(6,x$17) in -- #97
-//│ let x$19 = Cons(1,x$18) in -- #96
-//│ let* (x$20) = foo(x$19) in -- #95
-//│ x$20 -- #94)
+//│ Program:
 //│ 
-//│ Strongly Connected Tail Calls:
-//│ List(Set(j$1), Set(j$0), Set(foo))
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
-//│ Def(0, foo, [xs$0],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #137
-//│ let* (res) = foo_modcons$7(idCtx,xs$0) in -- #136
-//│ res -- #135
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, j$1, [x$4],
-//│ 1, 
-//│ jump j$0(x$4) -- #10
-//│ )
-//│ Def(4, _foo_ctx_app$4, [ctx,x],
-//│ 1, 
-//│ case ctx of -- #110
-//│   _IdContext =>
-//│     x -- #109
-//│   _Context =>
-//│     let field = ctx.field in -- #108
-//│     let ptr = ctx.ptr in -- #107
-//│     let _ = assign ptr.t := x in -- #106
-//│     let acc = ctx.acc in -- #105
-//│     acc -- #104
-//│ )
-//│ Def(5, _foo_ctx_comp$5, [ctx1,ctx2],
-//│ 1, 
-//│ let ctx2acc = ctx2.acc in -- #116
-//│ let ctx2ptr = ctx2.ptr in -- #115
-//│ let ctx2field = ctx2.field in -- #114
-//│ let* (newAcc) = _foo_ctx_app$4(ctx1,ctx2acc) in -- #113
-//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #112
-//│ ret -- #111
-//│ )
-//│ Def(7, foo_modcons$7, [ctx,xs$0],
-//│ 1, 
-//│ let* (r0) = _foo_modcons$7_j$2_modcons$6_opt$8(7,ctx,xs$0,undefined,undefined,undefined,undefined) in -- #173
-//│ r0 -- #172
-//│ )
-//│ Def(8, _foo_modcons$7_j$2_modcons$6_opt$8, [tailrecBranch$,foo_modcons$7_ctx,foo_modcons$7_xs$0,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2],
-//│ 1, 
-//│ jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(tailrecBranch$,foo_modcons$7_ctx,foo_modcons$7_xs$0,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2) -- #171
-//│ )
-//│ Def(9, _foo_modcons$7_j$2_modcons$6_opt_jp$9, [tailrecBranch$,foo_modcons$7_ctx,foo_modcons$7_xs$0,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2],
-//│ 1, 
-//│ let scrut = ==(6,tailrecBranch$) in -- #170
-//│ if scrut -- #169
-//│   true =>
-//│     let x$9 = Cons(j$2_modcons$6_x$2,0) in -- #168
-//│     let x$10 = Cons(j$2_modcons$6_x$7,x$9) in -- #167
-//│     let ctx2 = _Context(x$10,x$9,0) in -- #166
-//│     let* (composed) = _foo_ctx_comp$5(j$2_modcons$6_ctx,ctx2) in -- #165
-//│     jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(7,composed,j$2_modcons$6_x$1,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2) -- #164
-//│   false =>
-//│     case foo_modcons$7_xs$0 of -- #163
+//│   def foo(xs$0) =
+//│     case xs$0 of -- #104
 //│       Cons =>
-//│         let x$1 = foo_modcons$7_xs$0.t in -- #159
-//│         let x$2 = foo_modcons$7_xs$0.h in -- #158
-//│         let x$3 = >(x$2,5) in -- #157
-//│         if x$3 -- #156
+//│         let x$10 = Cons.t(xs$0) in -- #100
+//│         let x$11 = Cons.h(xs$0) in -- #99
+//│         let x$12 = >(x$11,5) in -- #98
+//│         if x$12 -- #97
 //│           true =>
-//│             jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(7,foo_modcons$7_ctx,x$1,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2) -- #151
+//│             let* (x$14) = @tailcall foo(x$10) in -- #68
+//│             jump j$1(x$14) -- #67
 //│           false =>
-//│             let x$6 = <(x$2,3) in -- #155
-//│             if x$6 -- #154
+//│             let x$15 = <(x$11,3) in -- #96
+//│             if x$15 -- #95
 //│               true =>
-//│                 jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(6,foo_modcons$7_ctx,foo_modcons$7_xs$0,foo_modcons$7_ctx,-1,x$1,x$2) -- #152
+//│                 jump j$2(-1,x$10,x$11) -- #92
 //│               false =>
-//│                 jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(6,foo_modcons$7_ctx,foo_modcons$7_xs$0,foo_modcons$7_ctx,100,x$1,x$2) -- #153
+//│                 jump j$2(100,x$10,x$11) -- #94
 //│       Nil =>
-//│         let x$11 = Nil() in -- #162
-//│         let* (res) = _foo_ctx_app$4(foo_modcons$7_ctx,x$11) in -- #161
-//│         res -- #160
-//│ )
-//│ },
-//│ let x$12 = Nil() in -- #103
-//│ let x$13 = Cons(9,x$12) in -- #102
-//│ let x$14 = Cons(3,x$13) in -- #101
-//│ let x$15 = Cons(2,x$14) in -- #100
-//│ let x$16 = Cons(4,x$15) in -- #99
-//│ let x$17 = Cons(7,x$16) in -- #98
-//│ let x$18 = Cons(6,x$17) in -- #97
-//│ let x$19 = Cons(1,x$18) in -- #96
-//│ let* (x$20) = foo(x$19) in -- #95
-//│ x$20 -- #94)
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, Cons, [h,t]),ClassInfo(3, Nil, []),ClassInfo(4, _IdContext, []),ClassInfo(5, _Context, [acc,ptr,field])}, {
-//│ Def(0, foo, [xs$0],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #137
-//│ let* (res) = foo_modcons$7(idCtx,xs$0) in -- #136
-//│ res -- #135
-//│ )
-//│ Def(1, j$0, [x$0],
-//│ 1, 
-//│ x$0 -- #1
-//│ )
-//│ Def(2, j$1, [x$4],
-//│ 1, 
-//│ jump j$0(x$4) -- #10
-//│ )
-//│ Def(4, _foo_ctx_app$4, [ctx,x],
-//│ 1, 
-//│ case ctx of -- #110
-//│   _IdContext =>
-//│     x -- #109
-//│   _Context =>
-//│     let field = ctx.field in -- #108
-//│     let ptr = ctx.ptr in -- #107
-//│     let _ = assign ptr.t := x in -- #106
-//│     let acc = ctx.acc in -- #105
-//│     acc -- #104
-//│ )
-//│ Def(5, _foo_ctx_comp$5, [ctx1,ctx2],
-//│ 1, 
-//│ let ctx2acc = ctx2.acc in -- #116
-//│ let ctx2ptr = ctx2.ptr in -- #115
-//│ let ctx2field = ctx2.field in -- #114
-//│ let* (newAcc) = _foo_ctx_app$4(ctx1,ctx2acc) in -- #113
-//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #112
-//│ ret -- #111
-//│ )
-//│ Def(7, foo_modcons$7, [ctx,xs$0],
-//│ 1, 
-//│ let* (r0) = _foo_modcons$7_j$2_modcons$6_opt$8(7,ctx,xs$0,undefined,undefined,undefined,undefined) in -- #173
-//│ r0 -- #172
-//│ )
-//│ Def(8, _foo_modcons$7_j$2_modcons$6_opt$8, [tailrecBranch$,foo_modcons$7_ctx,foo_modcons$7_xs$0,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2],
-//│ 1, 
-//│ jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(tailrecBranch$,foo_modcons$7_ctx,foo_modcons$7_xs$0,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2) -- #171
-//│ )
-//│ Def(9, _foo_modcons$7_j$2_modcons$6_opt_jp$9, [tailrecBranch$,foo_modcons$7_ctx,foo_modcons$7_xs$0,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2],
-//│ 1, 
-//│ let scrut = ==(6,tailrecBranch$) in -- #170
-//│ if scrut -- #169
-//│   true =>
-//│     let x$9 = Cons(j$2_modcons$6_x$2,0) in -- #168
-//│     let x$10 = Cons(j$2_modcons$6_x$7,x$9) in -- #167
-//│     let ctx2 = _Context(x$10,x$9,0) in -- #166
-//│     let* (composed) = _foo_ctx_comp$5(j$2_modcons$6_ctx,ctx2) in -- #165
-//│     jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(7,composed,j$2_modcons$6_x$1,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2) -- #164
-//│   false =>
-//│     case foo_modcons$7_xs$0 of -- #163
-//│       Cons =>
-//│         let x$1 = foo_modcons$7_xs$0.t in -- #159
-//│         let x$2 = foo_modcons$7_xs$0.h in -- #158
-//│         let x$3 = >(x$2,5) in -- #157
-//│         if x$3 -- #156
-//│           true =>
-//│             jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(7,foo_modcons$7_ctx,x$1,j$2_modcons$6_ctx,j$2_modcons$6_x$7,j$2_modcons$6_x$1,j$2_modcons$6_x$2) -- #151
-//│           false =>
-//│             let x$6 = <(x$2,3) in -- #155
-//│             if x$6 -- #154
+//│         let x$20 = Nil() in -- #103
+//│         jump j$0(x$20) -- #102
+//│   def j$0(x$9) =
+//│     x$9 -- #49
+//│   def j$1(x$13) =
+//│     jump j$0(x$13) -- #62
+//│   def j$2(x$16,x$10,x$11) =
+//│     let* (x$17) = @tailcall foo(x$10) in -- #90
+//│     let x$18 = Cons(x$11,x$17) in -- #89
+//│     let x$19 = Cons(x$16,x$18) in -- #88
+//│     jump j$1(x$19) -- #87
+//│   let x$0 = Nil() in -- #47
+//│   let x$1 = Cons(9,x$0) in -- #46
+//│   let x$2 = Cons(3,x$1) in -- #45
+//│   let x$3 = Cons(2,x$2) in -- #44
+//│   let x$4 = Cons(4,x$3) in -- #43
+//│   let x$5 = Cons(7,x$4) in -- #42
+//│   let x$6 = Cons(6,x$5) in -- #41
+//│   let x$7 = Cons(1,x$6) in -- #40
+//│   let* (x$8) = foo(x$7) in -- #39
+//│   x$8 -- #38
+//│ 
+//│ 
+//│ Strongly Connected Tail Calls:
+//│ List(Set(j$1), Set(j$0), Set(foo))
+//│ Program:
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
+//│   def foo(xs$0) =
+//│     let idCtx = _IdContext() in -- #144
+//│     let* (res) = foo_modcons$13(idCtx,xs$0) in -- #143
+//│     res -- #142
+//│   def j$0(x$9) =
+//│     x$9 -- #49
+//│   def j$1(x$13) =
+//│     jump j$0(x$13) -- #62
+//│   def _foo_ctx_app$10(ctx,x) =
+//│     case ctx of -- #117
+//│       _IdContext =>
+//│         x -- #116
+//│       _Context =>
+//│         let field = _Context.field(ctx) in -- #115
+//│         let ptr = _Context.ptr(ctx) in -- #114
+//│         let _ = assign ptr.t := x in -- #113
+//│         let acc = _Context.acc(ctx) in -- #112
+//│         acc -- #111
+//│   def _foo_ctx_comp$11(ctx1,ctx2) =
+//│     let ctx2acc = _Context.acc(ctx2) in -- #123
+//│     let ctx2ptr = _Context.ptr(ctx2) in -- #122
+//│     let ctx2field = _Context.field(ctx2) in -- #121
+//│     let* (newAcc) = _foo_ctx_app$10(ctx1,ctx2acc) in -- #120
+//│     let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #119
+//│     ret -- #118
+//│   def foo_modcons$13(ctx,xs$0) =
+//│     let* (r0) = _foo_modcons$13_j$2_modcons$12_opt$14(13,ctx,xs$0,true,true,true,true) in -- #180
+//│     r0 -- #179
+//│   def _foo_modcons$13_j$2_modcons$12_opt$14(tailrecBranch$,foo_modcons$13_ctx,foo_modcons$13_xs$0,j$2_modcons$12_ctx,j$2_modcons$12_x$16,j$2_modcons$12_x$10,j$2_modcons$12_x$11) =
+//│     jump _foo_modcons$13_j$2_modcons$12_opt_jp$15(tailrecBranch$,foo_modcons$13_ctx,foo_modcons$13_xs$0,j$2_modcons$12_ctx,j$2_modcons$12_x$16,j$2_modcons$12_x$10,j$2_modcons$12_x$11) -- #178
+//│   def _foo_modcons$13_j$2_modcons$12_opt_jp$15(tailrecBranch$,foo_modcons$13_ctx,foo_modcons$13_xs$0,j$2_modcons$12_ctx,j$2_modcons$12_x$16,j$2_modcons$12_x$10,j$2_modcons$12_x$11) =
+//│     let scrut = ==(12,tailrecBranch$) in -- #177
+//│     if scrut -- #176
+//│       true =>
+//│         let x$18 = Cons(j$2_modcons$12_x$11,0) in -- #175
+//│         let x$19 = Cons(j$2_modcons$12_x$16,x$18) in -- #174
+//│         let ctx2 = _Context(x$19,x$18,0) in -- #173
+//│         let* (composed) = _foo_ctx_comp$11(j$2_modcons$12_ctx,ctx2) in -- #172
+//│         jump _foo_modcons$13_j$2_modcons$12_opt_jp$15(13,composed,j$2_modcons$12_x$10,j$2_modcons$12_ctx,j$2_modcons$12_x$16,j$2_modcons$12_x$10,j$2_modcons$12_x$11) -- #171
+//│       false =>
+//│         case foo_modcons$13_xs$0 of -- #170
+//│           Cons =>
+//│             let x$10 = Cons.t(foo_modcons$13_xs$0) in -- #166
+//│             let x$11 = Cons.h(foo_modcons$13_xs$0) in -- #165
+//│             let x$12 = >(x$11,5) in -- #164
+//│             if x$12 -- #163
 //│               true =>
-//│                 jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(6,foo_modcons$7_ctx,foo_modcons$7_xs$0,foo_modcons$7_ctx,-1,x$1,x$2) -- #152
+//│                 jump _foo_modcons$13_j$2_modcons$12_opt_jp$15(13,foo_modcons$13_ctx,x$10,j$2_modcons$12_ctx,j$2_modcons$12_x$16,j$2_modcons$12_x$10,j$2_modcons$12_x$11) -- #158
 //│               false =>
-//│                 jump _foo_modcons$7_j$2_modcons$6_opt_jp$9(6,foo_modcons$7_ctx,foo_modcons$7_xs$0,foo_modcons$7_ctx,100,x$1,x$2) -- #153
-//│       Nil =>
-//│         let x$11 = Nil() in -- #162
-//│         let* (res) = _foo_ctx_app$4(foo_modcons$7_ctx,x$11) in -- #161
-//│         res -- #160
-//│ )
-//│ },
-//│ let x$12 = Nil() in -- #103
-//│ let x$13 = Cons(9,x$12) in -- #102
-//│ let x$14 = Cons(3,x$13) in -- #101
-//│ let x$15 = Cons(2,x$14) in -- #100
-//│ let x$16 = Cons(4,x$15) in -- #99
-//│ let x$17 = Cons(7,x$16) in -- #98
-//│ let x$18 = Cons(6,x$17) in -- #97
-//│ let x$19 = Cons(1,x$18) in -- #96
-//│ let* (x$20) = foo(x$19) in -- #95
-//│ x$20 -- #94)
+//│                 let x$15 = <(x$11,3) in -- #162
+//│                 if x$15 -- #161
+//│                   true =>
+//│                     jump _foo_modcons$13_j$2_modcons$12_opt_jp$15(12,foo_modcons$13_ctx,foo_modcons$13_xs$0,foo_modcons$13_ctx,-1,x$10,x$11) -- #159
+//│                   false =>
+//│                     jump _foo_modcons$13_j$2_modcons$12_opt_jp$15(12,foo_modcons$13_ctx,foo_modcons$13_xs$0,foo_modcons$13_ctx,100,x$10,x$11) -- #160
+//│           Nil =>
+//│             let x$20 = Nil() in -- #169
+//│             let* (res) = _foo_ctx_app$10(foo_modcons$13_ctx,x$20) in -- #168
+//│             res -- #167
+//│   let x$0 = Nil() in -- #47
+//│   let x$1 = Cons(9,x$0) in -- #46
+//│   let x$2 = Cons(3,x$1) in -- #45
+//│   let x$3 = Cons(2,x$2) in -- #44
+//│   let x$4 = Cons(4,x$3) in -- #43
+//│   let x$5 = Cons(7,x$4) in -- #42
+//│   let x$6 = Cons(6,x$5) in -- #41
+//│   let x$7 = Cons(1,x$6) in -- #40
+//│   let* (x$8) = foo(x$7) in -- #39
+//│   x$8 -- #38
 //│ 
 //│ Interpreted:
-//│ Cons(-1,Cons(1,Cons(100,Cons(4,Cons(-1,Cons(2,Cons(100,Cons(3,Nil()))))))))
+//│ Cons(-1,Cons(1,0))
 
 :ce
 fun b() =
@@ -1971,117 +1208,65 @@ a()
 //│ |#fun| |b|(||)| |#=|→|a|(||)|↵|a|(||)|←|↵|@|tailrec| |↵|#fun| |a|(||)| |#=| |→|#if| |0| |<| |1| |#then| |a|(||)|↵|#else| |b|(||)|←|↵|a|(||)|
 //│ Parsed: {fun b = () => {a(); a()}; fun a = () => {if (<(0,)(1,)) then a() else b()}; a()}
 //│ 
+//│ 
 //│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
-//│ Def(0, b, [],
-//│ 1, 
-//│ let* (x$0) = a() in -- #7
-//│ let* (x$1) = a() in -- #6
-//│ x$1 -- #5
-//│ )
-//│ Def(1, a, [],
-//│ 1, 
-//│ let x$2 = <(0,1) in -- #23
-//│ if x$2 -- #22
-//│   true =>
-//│     let* (x$4) = a() in -- #16
-//│     jump j$0(x$4) -- #15
-//│   false =>
-//│     let* (x$5) = b() in -- #21
-//│     jump j$0(x$5) -- #20
-//│ )
-//│ Def(2, j$0, [x$3],
-//│ 1, 
-//│ x$3 -- #11
-//│ )
-//│ },
-//│ let* (x$6) = a() in -- #27
-//│ x$6 -- #26)
+//│ Program:
+//│ 
+//│   def b() =
+//│     let* (x$1) = a() in -- #8
+//│     let* (x$2) = a() in -- #7
+//│     x$2 -- #6
+//│   def a() =
+//│     let x$3 = <(0,1) in -- #22
+//│     if x$3 -- #21
+//│       true =>
+//│         let* (x$5) = a() in -- #16
+//│         jump j$0(x$5) -- #15
+//│       false =>
+//│         let* (x$6) = b() in -- #20
+//│         jump j$0(x$6) -- #19
+//│   def j$0(x$4) =
+//│     x$4 -- #12
+//│   let* (x$0) = a() in -- #2
+//│   x$0 -- #1
 //│ ╔══[COMPILATION ERROR] function `a` is not tail-recursive, but is marked as @tailrec
-//│ ║  l.1966: 	@tailrec 
+//│ ║  l.1203: 	@tailrec 
 //│ ║          	 ^^^^^^^
 //│ ╟── it could self-recurse through this call, which may not be a tail-call
-//│ ║  l.1964: 	  a()
+//│ ║  l.1201: 	  a()
 //│ ╙──        	  ^
 //│ 
+//│ 
 //│ Strongly Connected Tail Calls:
 //│ List(Set(j$0), Set(a, b))
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(0, b, [],
-//│ 1, 
-//│ let* (r0) = _a_b_opt$3(0) in -- #44
-//│ r0 -- #43
-//│ )
-//│ Def(1, a, [],
-//│ 1, 
-//│ let* (r0) = _a_b_opt$3(1) in -- #42
-//│ r0 -- #41
-//│ )
-//│ Def(2, j$0, [x$3],
-//│ 1, 
-//│ x$3 -- #11
-//│ )
-//│ Def(3, _a_b_opt$3, [tailrecBranch$],
-//│ 1, 
-//│ jump _a_b_opt_jp$4(tailrecBranch$) -- #40
-//│ )
-//│ Def(4, _a_b_opt_jp$4, [tailrecBranch$],
-//│ 1, 
-//│ let scrut = ==(0,tailrecBranch$) in -- #39
-//│ if scrut -- #38
-//│   true =>
-//│     let* (x$0) = a() in -- #37
-//│     jump _a_b_opt_jp$4(1) -- #36
-//│   false =>
-//│     let x$2 = <(0,1) in -- #35
-//│     if x$2 -- #34
+//│ Program:
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
+//│   def b() =
+//│     let* (r0) = _a_b_opt$9(0) in -- #45
+//│     r0 -- #44
+//│   def a() =
+//│     let* (r0) = _a_b_opt$9(1) in -- #43
+//│     r0 -- #42
+//│   def j$0(x$4) =
+//│     x$4 -- #12
+//│   def _a_b_opt$9(tailrecBranch$) =
+//│     jump _a_b_opt_jp$10(tailrecBranch$) -- #41
+//│   def _a_b_opt_jp$10(tailrecBranch$) =
+//│     let scrut = ==(0,tailrecBranch$) in -- #40
+//│     if scrut -- #39
 //│       true =>
-//│         jump _a_b_opt_jp$4(1) -- #32
+//│         let* (x$1) = a() in -- #38
+//│         jump _a_b_opt_jp$10(1) -- #37
 //│       false =>
-//│         jump _a_b_opt_jp$4(0) -- #33
-//│ )
-//│ },
-//│ let* (x$6) = a() in -- #27
-//│ x$6 -- #26)
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(0, b, [],
-//│ 1, 
-//│ let* (r0) = _a_b_opt$3(0) in -- #44
-//│ r0 -- #43
-//│ )
-//│ Def(1, a, [],
-//│ 1, 
-//│ let* (r0) = _a_b_opt$3(1) in -- #42
-//│ r0 -- #41
-//│ )
-//│ Def(2, j$0, [x$3],
-//│ 1, 
-//│ x$3 -- #11
-//│ )
-//│ Def(3, _a_b_opt$3, [tailrecBranch$],
-//│ 1, 
-//│ jump _a_b_opt_jp$4(tailrecBranch$) -- #40
-//│ )
-//│ Def(4, _a_b_opt_jp$4, [tailrecBranch$],
-//│ 1, 
-//│ let scrut = ==(0,tailrecBranch$) in -- #39
-//│ if scrut -- #38
-//│   true =>
-//│     let* (x$0) = a() in -- #37
-//│     jump _a_b_opt_jp$4(1) -- #36
-//│   false =>
-//│     let x$2 = <(0,1) in -- #35
-//│     if x$2 -- #34
-//│       true =>
-//│         jump _a_b_opt_jp$4(1) -- #32
-//│       false =>
-//│         jump _a_b_opt_jp$4(0) -- #33
-//│ )
-//│ },
-//│ let* (x$6) = a() in -- #27
-//│ x$6 -- #26)
+//│         let x$3 = <(0,1) in -- #36
+//│         if x$3 -- #35
+//│           true =>
+//│             jump _a_b_opt_jp$10(1) -- #33
+//│           false =>
+//│             jump _a_b_opt_jp$10(0) -- #34
+//│   let* (x$0) = a() in -- #2
+//│   x$0 -- #1
 
 :ce
 class A(a, b)
@@ -2093,229 +1278,111 @@ a()
 //│ |#class| |A|(|a|,| |b|)|↵|@|tailrec|↵|#fun| |a|(||)| |#=| |A|(|b|(||)|,| |1|)|↵|#fun| |b|(||)| |#=| |A|(|c|(||)|,| |@|tailcall| |a|(||)|)|↵|#fun| |c|(||)| |#=| |A|(|b|(||)|,| |1|)|↵|a|(||)|
 //│ Parsed: {class A(a, b,) {}; fun a = () => A(b(), 1,); fun b = () => A(c(), @tailcall a(),); fun c = () => A(b(), 1,); a()}
 //│ 
+//│ 
 //│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [a,b])}, {
-//│ Def(0, a, [],
-//│ 1, 
-//│ let* (x$0) = b() in -- #9
-//│ let x$1 = A(x$0,1) in -- #8
-//│ x$1 -- #7
-//│ )
-//│ Def(1, b, [],
-//│ 1, 
-//│ let* (x$2) = c() in -- #22
-//│ let* (x$3) = @tailcall a() in -- #21
-//│ let x$4 = A(x$2,x$3) in -- #20
-//│ x$4 -- #19
-//│ )
-//│ Def(2, c, [],
-//│ 1, 
-//│ let* (x$5) = b() in -- #32
-//│ let x$6 = A(x$5,1) in -- #31
-//│ x$6 -- #30
-//│ )
-//│ },
-//│ let* (x$7) = a() in -- #36
-//│ x$7 -- #35)
+//│ Program:
+//│   class A(a,b)
+//│   def a() =
+//│     let* (x$1) = b() in -- #11
+//│     let x$2 = A(x$1,1) in -- #10
+//│     x$2 -- #9
+//│   def b() =
+//│     let* (x$3) = c() in -- #22
+//│     let* (x$4) = @tailcall a() in -- #21
+//│     let x$5 = A(x$3,x$4) in -- #20
+//│     x$5 -- #19
+//│   def c() =
+//│     let* (x$6) = b() in -- #31
+//│     let x$7 = A(x$6,1) in -- #30
+//│     x$7 -- #29
+//│   let* (x$0) = a() in -- #2
+//│   x$0 -- #1
 //│ ╔══[COMPILATION ERROR] function `a` is not tail-recursive, but is marked as @tailrec
-//│ ║  l.2088: 	@tailrec
+//│ ║  l.1273: 	@tailrec
 //│ ║          	 ^^^^^^^
 //│ ╟── it could self-recurse through this call, which may not be a tail-call
-//│ ║  l.2090: 	fun b() = A(c(), @tailcall a())
+//│ ║  l.1275: 	fun b() = A(c(), @tailcall a())
 //│ ╙──        	            ^
 //│ 
+//│ 
 //│ Strongly Connected Tail Calls:
 //│ List(Set(c, b, a))
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [a,b]),ClassInfo(3, _IdContext, []),ClassInfo(4, _Context, [acc,ptr,field])}, {
-//│ Def(0, a, [],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #80
-//│ let* (res) = a_modcons$7(idCtx) in -- #79
-//│ res -- #78
-//│ )
-//│ Def(1, b, [],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #72
-//│ let* (res) = b_modcons$6(idCtx) in -- #71
-//│ res -- #70
-//│ )
-//│ Def(2, c, [],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #63
-//│ let* (res) = c_modcons$5(idCtx) in -- #62
-//│ res -- #61
-//│ )
-//│ Def(3, _c_b_a_ctx_app$3, [ctx,x],
-//│ 1, 
-//│ case ctx of -- #49
-//│   _IdContext =>
-//│     x -- #48
-//│   _Context =>
-//│     let field = ctx.field in -- #47
-//│     let scrut = ==(1,field) in -- #46
-//│     if scrut -- #45
-//│       true =>
-//│         let ptr = ctx.ptr in -- #44
-//│         let _ = assign ptr.b := x in -- #43
-//│         let acc = ctx.acc in -- #42
-//│         acc -- #41
-//│       false =>
-//│         let ptr = ctx.ptr in -- #40
-//│         let _ = assign ptr.a := x in -- #39
-//│         let acc = ctx.acc in -- #38
-//│         acc -- #37
-//│ )
-//│ Def(4, _c_b_a_ctx_comp$4, [ctx1,ctx2],
-//│ 1, 
-//│ let ctx2acc = ctx2.acc in -- #55
-//│ let ctx2ptr = ctx2.ptr in -- #54
-//│ let ctx2field = ctx2.field in -- #53
-//│ let* (newAcc) = _c_b_a_ctx_app$3(ctx1,ctx2acc) in -- #52
-//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #51
-//│ ret -- #50
-//│ )
-//│ Def(5, c_modcons$5, [ctx],
-//│ 1, 
-//│ let* (r0) = _c_modcons$5_b_modcons$6_a_modcons$7_opt$8(5,ctx,undefined,undefined) in -- #104
-//│ r0 -- #103
-//│ )
-//│ Def(6, b_modcons$6, [ctx],
-//│ 1, 
-//│ let* (r0) = _c_modcons$5_b_modcons$6_a_modcons$7_opt$8(6,undefined,ctx,undefined) in -- #106
-//│ r0 -- #105
-//│ )
-//│ Def(7, a_modcons$7, [ctx],
-//│ 1, 
-//│ let* (r0) = _c_modcons$5_b_modcons$6_a_modcons$7_opt$8(7,undefined,undefined,ctx) in -- #108
-//│ r0 -- #107
-//│ )
-//│ Def(8, _c_modcons$5_b_modcons$6_a_modcons$7_opt$8, [tailrecBranch$,c_modcons$5_ctx,b_modcons$6_ctx,a_modcons$7_ctx],
-//│ 1, 
-//│ jump _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9(tailrecBranch$,c_modcons$5_ctx,b_modcons$6_ctx,a_modcons$7_ctx) -- #102
-//│ )
-//│ Def(9, _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9, [tailrecBranch$,c_modcons$5_ctx,b_modcons$6_ctx,a_modcons$7_ctx],
-//│ 1, 
-//│ let scrut = ==(7,tailrecBranch$) in -- #101
-//│ if scrut -- #100
-//│   true =>
-//│     let x$1 = A(0,1) in -- #97
-//│     let ctx2 = _Context(x$1,x$1,0) in -- #96
-//│     let* (composed) = _c_b_a_ctx_comp$4(a_modcons$7_ctx,ctx2) in -- #95
-//│     jump _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9(6,c_modcons$5_ctx,composed,a_modcons$7_ctx) -- #94
-//│   false =>
-//│     let scrut = ==(6,tailrecBranch$) in -- #99
-//│     if scrut -- #98
-//│       true =>
-//│         let* (x$2) = c() in -- #93
-//│         let x$4 = A(x$2,0) in -- #92
-//│         let ctx2 = _Context(x$4,x$4,1) in -- #91
-//│         let* (composed) = _c_b_a_ctx_comp$4(b_modcons$6_ctx,ctx2) in -- #90
-//│         jump _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9(7,c_modcons$5_ctx,b_modcons$6_ctx,composed) -- #89
-//│       false =>
-//│         let x$6 = A(0,1) in -- #88
-//│         let ctx2 = _Context(x$6,x$6,0) in -- #87
-//│         let* (composed) = _c_b_a_ctx_comp$4(c_modcons$5_ctx,ctx2) in -- #86
-//│         jump _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9(6,c_modcons$5_ctx,composed,a_modcons$7_ctx) -- #85
-//│ )
-//│ },
-//│ let* (x$7) = a() in -- #36
-//│ x$7 -- #35)
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [a,b]),ClassInfo(3, _IdContext, []),ClassInfo(4, _Context, [acc,ptr,field])}, {
-//│ Def(0, a, [],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #80
-//│ let* (res) = a_modcons$7(idCtx) in -- #79
-//│ res -- #78
-//│ )
-//│ Def(1, b, [],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #72
-//│ let* (res) = b_modcons$6(idCtx) in -- #71
-//│ res -- #70
-//│ )
-//│ Def(2, c, [],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #63
-//│ let* (res) = c_modcons$5(idCtx) in -- #62
-//│ res -- #61
-//│ )
-//│ Def(3, _c_b_a_ctx_app$3, [ctx,x],
-//│ 1, 
-//│ case ctx of -- #49
-//│   _IdContext =>
-//│     x -- #48
-//│   _Context =>
-//│     let field = ctx.field in -- #47
-//│     let scrut = ==(1,field) in -- #46
-//│     if scrut -- #45
-//│       true =>
-//│         let ptr = ctx.ptr in -- #44
-//│         let _ = assign ptr.b := x in -- #43
-//│         let acc = ctx.acc in -- #42
-//│         acc -- #41
-//│       false =>
-//│         let ptr = ctx.ptr in -- #40
-//│         let _ = assign ptr.a := x in -- #39
-//│         let acc = ctx.acc in -- #38
-//│         acc -- #37
-//│ )
-//│ Def(4, _c_b_a_ctx_comp$4, [ctx1,ctx2],
-//│ 1, 
-//│ let ctx2acc = ctx2.acc in -- #55
-//│ let ctx2ptr = ctx2.ptr in -- #54
-//│ let ctx2field = ctx2.field in -- #53
-//│ let* (newAcc) = _c_b_a_ctx_app$3(ctx1,ctx2acc) in -- #52
-//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #51
-//│ ret -- #50
-//│ )
-//│ Def(5, c_modcons$5, [ctx],
-//│ 1, 
-//│ let* (r0) = _c_modcons$5_b_modcons$6_a_modcons$7_opt$8(5,ctx,undefined,undefined) in -- #104
-//│ r0 -- #103
-//│ )
-//│ Def(6, b_modcons$6, [ctx],
-//│ 1, 
-//│ let* (r0) = _c_modcons$5_b_modcons$6_a_modcons$7_opt$8(6,undefined,ctx,undefined) in -- #106
-//│ r0 -- #105
-//│ )
-//│ Def(7, a_modcons$7, [ctx],
-//│ 1, 
-//│ let* (r0) = _c_modcons$5_b_modcons$6_a_modcons$7_opt$8(7,undefined,undefined,ctx) in -- #108
-//│ r0 -- #107
-//│ )
-//│ Def(8, _c_modcons$5_b_modcons$6_a_modcons$7_opt$8, [tailrecBranch$,c_modcons$5_ctx,b_modcons$6_ctx,a_modcons$7_ctx],
-//│ 1, 
-//│ jump _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9(tailrecBranch$,c_modcons$5_ctx,b_modcons$6_ctx,a_modcons$7_ctx) -- #102
-//│ )
-//│ Def(9, _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9, [tailrecBranch$,c_modcons$5_ctx,b_modcons$6_ctx,a_modcons$7_ctx],
-//│ 1, 
-//│ let scrut = ==(7,tailrecBranch$) in -- #101
-//│ if scrut -- #100
-//│   true =>
-//│     let x$1 = A(0,1) in -- #97
-//│     let ctx2 = _Context(x$1,x$1,0) in -- #96
-//│     let* (composed) = _c_b_a_ctx_comp$4(a_modcons$7_ctx,ctx2) in -- #95
-//│     jump _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9(6,c_modcons$5_ctx,composed,a_modcons$7_ctx) -- #94
-//│   false =>
-//│     let scrut = ==(6,tailrecBranch$) in -- #99
-//│     if scrut -- #98
+//│ Program:
+//│   class A(a,b)
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
+//│   def a() =
+//│     let idCtx = _IdContext() in -- #81
+//│     let* (res) = a_modcons$13(idCtx) in -- #80
+//│     res -- #79
+//│   def b() =
+//│     let idCtx = _IdContext() in -- #73
+//│     let* (res) = b_modcons$12(idCtx) in -- #72
+//│     res -- #71
+//│   def c() =
+//│     let idCtx = _IdContext() in -- #64
+//│     let* (res) = c_modcons$11(idCtx) in -- #63
+//│     res -- #62
+//│   def _c_b_a_ctx_app$9(ctx,x) =
+//│     case ctx of -- #50
+//│       _IdContext =>
+//│         x -- #49
+//│       _Context =>
+//│         let field = _Context.field(ctx) in -- #48
+//│         let scrut = ==(1,field) in -- #47
+//│         if scrut -- #46
+//│           true =>
+//│             let ptr = _Context.ptr(ctx) in -- #45
+//│             let _ = assign ptr.b := x in -- #44
+//│             let acc = _Context.acc(ctx) in -- #43
+//│             acc -- #42
+//│           false =>
+//│             let ptr = _Context.ptr(ctx) in -- #41
+//│             let _ = assign ptr.a := x in -- #40
+//│             let acc = _Context.acc(ctx) in -- #39
+//│             acc -- #38
+//│   def _c_b_a_ctx_comp$10(ctx1,ctx2) =
+//│     let ctx2acc = _Context.acc(ctx2) in -- #56
+//│     let ctx2ptr = _Context.ptr(ctx2) in -- #55
+//│     let ctx2field = _Context.field(ctx2) in -- #54
+//│     let* (newAcc) = _c_b_a_ctx_app$9(ctx1,ctx2acc) in -- #53
+//│     let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #52
+//│     ret -- #51
+//│   def c_modcons$11(ctx) =
+//│     let* (r0) = _c_modcons$11_b_modcons$12_a_modcons$13_opt$14(11,ctx,true,true) in -- #105
+//│     r0 -- #104
+//│   def b_modcons$12(ctx) =
+//│     let* (r0) = _c_modcons$11_b_modcons$12_a_modcons$13_opt$14(12,true,ctx,true) in -- #107
+//│     r0 -- #106
+//│   def a_modcons$13(ctx) =
+//│     let* (r0) = _c_modcons$11_b_modcons$12_a_modcons$13_opt$14(13,true,true,ctx) in -- #109
+//│     r0 -- #108
+//│   def _c_modcons$11_b_modcons$12_a_modcons$13_opt$14(tailrecBranch$,c_modcons$11_ctx,b_modcons$12_ctx,a_modcons$13_ctx) =
+//│     jump _c_modcons$11_b_modcons$12_a_modcons$13_opt_jp$15(tailrecBranch$,c_modcons$11_ctx,b_modcons$12_ctx,a_modcons$13_ctx) -- #103
+//│   def _c_modcons$11_b_modcons$12_a_modcons$13_opt_jp$15(tailrecBranch$,c_modcons$11_ctx,b_modcons$12_ctx,a_modcons$13_ctx) =
+//│     let scrut = ==(13,tailrecBranch$) in -- #102
+//│     if scrut -- #101
 //│       true =>
-//│         let* (x$2) = c() in -- #93
-//│         let x$4 = A(x$2,0) in -- #92
-//│         let ctx2 = _Context(x$4,x$4,1) in -- #91
-//│         let* (composed) = _c_b_a_ctx_comp$4(b_modcons$6_ctx,ctx2) in -- #90
-//│         jump _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9(7,c_modcons$5_ctx,b_modcons$6_ctx,composed) -- #89
+//│         let x$2 = A(0,1) in -- #98
+//│         let ctx2 = _Context(x$2,x$2,0) in -- #97
+//│         let* (composed) = _c_b_a_ctx_comp$10(a_modcons$13_ctx,ctx2) in -- #96
+//│         jump _c_modcons$11_b_modcons$12_a_modcons$13_opt_jp$15(12,c_modcons$11_ctx,composed,a_modcons$13_ctx) -- #95
 //│       false =>
-//│         let x$6 = A(0,1) in -- #88
-//│         let ctx2 = _Context(x$6,x$6,0) in -- #87
-//│         let* (composed) = _c_b_a_ctx_comp$4(c_modcons$5_ctx,ctx2) in -- #86
-//│         jump _c_modcons$5_b_modcons$6_a_modcons$7_opt_jp$9(6,c_modcons$5_ctx,composed,a_modcons$7_ctx) -- #85
-//│ )
-//│ },
-//│ let* (x$7) = a() in -- #36
-//│ x$7 -- #35)
+//│         let scrut = ==(12,tailrecBranch$) in -- #100
+//│         if scrut -- #99
+//│           true =>
+//│             let* (x$3) = c() in -- #94
+//│             let x$5 = A(x$3,0) in -- #93
+//│             let ctx2 = _Context(x$5,x$5,1) in -- #92
+//│             let* (composed) = _c_b_a_ctx_comp$10(b_modcons$12_ctx,ctx2) in -- #91
+//│             jump _c_modcons$11_b_modcons$12_a_modcons$13_opt_jp$15(13,c_modcons$11_ctx,b_modcons$12_ctx,composed) -- #90
+//│           false =>
+//│             let x$7 = A(0,1) in -- #89
+//│             let ctx2 = _Context(x$7,x$7,0) in -- #88
+//│             let* (composed) = _c_b_a_ctx_comp$10(c_modcons$11_ctx,ctx2) in -- #87
+//│             jump _c_modcons$11_b_modcons$12_a_modcons$13_opt_jp$15(12,c_modcons$11_ctx,composed,a_modcons$13_ctx) -- #86
+//│   let* (x$0) = a() in -- #2
+//│   x$0 -- #1
 
 // TODO: Purity check
 class A(a, b)
@@ -2327,241 +1394,141 @@ a()
 //│ |#class| |A|(|a|,| |b|)|↵|@|tailrec|↵|#fun| |a|(||)| |#=| |A|(|b|(||)|,| |1|)|↵|#fun| |b|(||)| |#=| |A|(|@|tailcall| |a|(||)|,| |c|(||)|)|↵|#fun| |c|(||)| |#=| |A|(|0|,| |1|)|↵|a|(||)|
 //│ Parsed: {class A(a, b,) {}; fun a = () => A(b(), 1,); fun b = () => A(@tailcall a(), c(),); fun c = () => A(0, 1,); a()}
 //│ 
+//│ 
 //│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [a,b])}, {
-//│ Def(0, a, [],
-//│ 1, 
-//│ let* (x$0) = b() in -- #9
-//│ let x$1 = A(x$0,1) in -- #8
-//│ x$1 -- #7
-//│ )
-//│ Def(1, b, [],
-//│ 1, 
-//│ let* (x$2) = @tailcall a() in -- #22
-//│ let* (x$3) = c() in -- #21
-//│ let x$4 = A(x$2,x$3) in -- #20
-//│ x$4 -- #19
-//│ )
-//│ Def(2, c, [],
-//│ 1, 
-//│ let x$5 = A(0,1) in -- #29
-//│ x$5 -- #28
-//│ )
-//│ },
-//│ let* (x$6) = a() in -- #33
-//│ x$6 -- #32)
+//│ Program:
+//│   class A(a,b)
+//│   def a() =
+//│     let* (x$1) = b() in -- #11
+//│     let x$2 = A(x$1,1) in -- #10
+//│     x$2 -- #9
+//│   def b() =
+//│     let* (x$3) = @tailcall a() in -- #22
+//│     let* (x$4) = c() in -- #21
+//│     let x$5 = A(x$3,x$4) in -- #20
+//│     x$5 -- #19
+//│   def c() =
+//│     let x$6 = A(0,1) in -- #29
+//│     x$6 -- #28
+//│   let* (x$0) = a() in -- #2
+//│   x$0 -- #1
 //│ ╔══[COMPILATION ERROR] not a tail call, as the remaining functions may be impure
-//│ ║  l.2324: 	fun b() = A(@tailcall a(), c())
+//│ ║  l.1391: 	fun b() = A(@tailcall a(), c())
 //│ ╙──        	                      ^
 //│ ╔══[COMPILATION ERROR] function `a` is not tail-recursive, but is marked as @tailrec
-//│ ║  l.2322: 	@tailrec
+//│ ║  l.1389: 	@tailrec
 //│ ║          	 ^^^^^^^
 //│ ╟── it could self-recurse through this call, which may not be a tail-call
-//│ ║  l.2324: 	fun b() = A(@tailcall a(), c())
+//│ ║  l.1391: 	fun b() = A(@tailcall a(), c())
 //│ ╙──        	                      ^
 //│ 
+//│ 
 //│ Strongly Connected Tail Calls:
 //│ List(Set(b, a), Set(c))
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [a,b]),ClassInfo(3, _IdContext, []),ClassInfo(4, _Context, [acc,ptr,field])}, {
-//│ Def(0, a, [],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #62
-//│ let* (res) = a_modcons$6(idCtx) in -- #61
-//│ res -- #60
-//│ )
-//│ Def(1, b, [],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #54
-//│ let* (res) = b_modcons$5(idCtx) in -- #53
-//│ res -- #52
-//│ )
-//│ Def(2, c, [],
-//│ 1, 
-//│ let x$5 = A(0,1) in -- #29
-//│ x$5 -- #28
-//│ )
-//│ Def(3, _b_a_ctx_app$3, [ctx,x],
-//│ 1, 
-//│ case ctx of -- #40
-//│   _IdContext =>
-//│     x -- #39
-//│   _Context =>
-//│     let field = ctx.field in -- #38
-//│     let ptr = ctx.ptr in -- #37
-//│     let _ = assign ptr.a := x in -- #36
-//│     let acc = ctx.acc in -- #35
-//│     acc -- #34
-//│ )
-//│ Def(4, _b_a_ctx_comp$4, [ctx1,ctx2],
-//│ 1, 
-//│ let ctx2acc = ctx2.acc in -- #46
-//│ let ctx2ptr = ctx2.ptr in -- #45
-//│ let ctx2field = ctx2.field in -- #44
-//│ let* (newAcc) = _b_a_ctx_app$3(ctx1,ctx2acc) in -- #43
-//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #42
-//│ ret -- #41
-//│ )
-//│ Def(5, b_modcons$5, [ctx],
-//│ 1, 
-//│ let* (r0) = _b_modcons$5_a_modcons$6_opt$7(5,ctx,undefined) in -- #81
-//│ r0 -- #80
-//│ )
-//│ Def(6, a_modcons$6, [ctx],
-//│ 1, 
-//│ let* (r0) = _b_modcons$5_a_modcons$6_opt$7(6,undefined,ctx) in -- #83
-//│ r0 -- #82
-//│ )
-//│ Def(7, _b_modcons$5_a_modcons$6_opt$7, [tailrecBranch$,b_modcons$5_ctx,a_modcons$6_ctx],
-//│ 1, 
-//│ jump _b_modcons$5_a_modcons$6_opt_jp$8(tailrecBranch$,b_modcons$5_ctx,a_modcons$6_ctx) -- #79
-//│ )
-//│ Def(8, _b_modcons$5_a_modcons$6_opt_jp$8, [tailrecBranch$,b_modcons$5_ctx,a_modcons$6_ctx],
-//│ 1, 
-//│ let scrut = ==(6,tailrecBranch$) in -- #78
-//│ if scrut -- #77
-//│   true =>
-//│     let x$1 = A(0,1) in -- #76
-//│     let ctx2 = _Context(x$1,x$1,0) in -- #75
-//│     let* (composed) = _b_a_ctx_comp$4(a_modcons$6_ctx,ctx2) in -- #74
-//│     jump _b_modcons$5_a_modcons$6_opt_jp$8(5,composed,a_modcons$6_ctx) -- #73
-//│   false =>
-//│     let* (x$2) = @tailcall a() in -- #72
-//│     let* (x$3) = c() in -- #71
-//│     let x$4 = A(x$2,x$3) in -- #70
-//│     let* (res) = _b_a_ctx_app$3(b_modcons$5_ctx,x$4) in -- #69
-//│     res -- #68
-//│ )
-//│ },
-//│ let* (x$6) = a() in -- #33
-//│ x$6 -- #32)
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, A, [a,b]),ClassInfo(3, _IdContext, []),ClassInfo(4, _Context, [acc,ptr,field])}, {
-//│ Def(0, a, [],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #62
-//│ let* (res) = a_modcons$6(idCtx) in -- #61
-//│ res -- #60
-//│ )
-//│ Def(1, b, [],
-//│ 1, 
-//│ let idCtx = _IdContext() in -- #54
-//│ let* (res) = b_modcons$5(idCtx) in -- #53
-//│ res -- #52
-//│ )
-//│ Def(2, c, [],
-//│ 1, 
-//│ let x$5 = A(0,1) in -- #29
-//│ x$5 -- #28
-//│ )
-//│ Def(3, _b_a_ctx_app$3, [ctx,x],
-//│ 1, 
-//│ case ctx of -- #40
-//│   _IdContext =>
-//│     x -- #39
-//│   _Context =>
-//│     let field = ctx.field in -- #38
-//│     let ptr = ctx.ptr in -- #37
-//│     let _ = assign ptr.a := x in -- #36
-//│     let acc = ctx.acc in -- #35
-//│     acc -- #34
-//│ )
-//│ Def(4, _b_a_ctx_comp$4, [ctx1,ctx2],
-//│ 1, 
-//│ let ctx2acc = ctx2.acc in -- #46
-//│ let ctx2ptr = ctx2.ptr in -- #45
-//│ let ctx2field = ctx2.field in -- #44
-//│ let* (newAcc) = _b_a_ctx_app$3(ctx1,ctx2acc) in -- #43
-//│ let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #42
-//│ ret -- #41
-//│ )
-//│ Def(5, b_modcons$5, [ctx],
-//│ 1, 
-//│ let* (r0) = _b_modcons$5_a_modcons$6_opt$7(5,ctx,undefined) in -- #81
-//│ r0 -- #80
-//│ )
-//│ Def(6, a_modcons$6, [ctx],
-//│ 1, 
-//│ let* (r0) = _b_modcons$5_a_modcons$6_opt$7(6,undefined,ctx) in -- #83
-//│ r0 -- #82
-//│ )
-//│ Def(7, _b_modcons$5_a_modcons$6_opt$7, [tailrecBranch$,b_modcons$5_ctx,a_modcons$6_ctx],
-//│ 1, 
-//│ jump _b_modcons$5_a_modcons$6_opt_jp$8(tailrecBranch$,b_modcons$5_ctx,a_modcons$6_ctx) -- #79
-//│ )
-//│ Def(8, _b_modcons$5_a_modcons$6_opt_jp$8, [tailrecBranch$,b_modcons$5_ctx,a_modcons$6_ctx],
-//│ 1, 
-//│ let scrut = ==(6,tailrecBranch$) in -- #78
-//│ if scrut -- #77
-//│   true =>
-//│     let x$1 = A(0,1) in -- #76
-//│     let ctx2 = _Context(x$1,x$1,0) in -- #75
-//│     let* (composed) = _b_a_ctx_comp$4(a_modcons$6_ctx,ctx2) in -- #74
-//│     jump _b_modcons$5_a_modcons$6_opt_jp$8(5,composed,a_modcons$6_ctx) -- #73
-//│   false =>
-//│     let* (x$2) = @tailcall a() in -- #72
-//│     let* (x$3) = c() in -- #71
-//│     let x$4 = A(x$2,x$3) in -- #70
-//│     let* (res) = _b_a_ctx_app$3(b_modcons$5_ctx,x$4) in -- #69
-//│     res -- #68
-//│ )
-//│ },
-//│ let* (x$6) = a() in -- #33
-//│ x$6 -- #32)
+//│ Program:
+//│   class A(a,b)
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
+//│   def a() =
+//│     let idCtx = _IdContext() in -- #64
+//│     let* (res) = a_modcons$12(idCtx) in -- #63
+//│     res -- #62
+//│   def b() =
+//│     let idCtx = _IdContext() in -- #56
+//│     let* (res) = b_modcons$11(idCtx) in -- #55
+//│     res -- #54
+//│   def c() =
+//│     let x$6 = A(0,1) in -- #29
+//│     x$6 -- #28
+//│   def _b_a_ctx_app$9(ctx,x) =
+//│     case ctx of -- #42
+//│       _IdContext =>
+//│         x -- #41
+//│       _Context =>
+//│         let field = _Context.field(ctx) in -- #40
+//│         let ptr = _Context.ptr(ctx) in -- #39
+//│         let _ = assign ptr.a := x in -- #38
+//│         let acc = _Context.acc(ctx) in -- #37
+//│         acc -- #36
+//│   def _b_a_ctx_comp$10(ctx1,ctx2) =
+//│     let ctx2acc = _Context.acc(ctx2) in -- #48
+//│     let ctx2ptr = _Context.ptr(ctx2) in -- #47
+//│     let ctx2field = _Context.field(ctx2) in -- #46
+//│     let* (newAcc) = _b_a_ctx_app$9(ctx1,ctx2acc) in -- #45
+//│     let ret = _Context(newAcc,ctx2ptr,ctx2field) in -- #44
+//│     ret -- #43
+//│   def b_modcons$11(ctx) =
+//│     let* (r0) = _b_modcons$11_a_modcons$12_opt$13(11,ctx,true) in -- #83
+//│     r0 -- #82
+//│   def a_modcons$12(ctx) =
+//│     let* (r0) = _b_modcons$11_a_modcons$12_opt$13(12,true,ctx) in -- #85
+//│     r0 -- #84
+//│   def _b_modcons$11_a_modcons$12_opt$13(tailrecBranch$,b_modcons$11_ctx,a_modcons$12_ctx) =
+//│     jump _b_modcons$11_a_modcons$12_opt_jp$14(tailrecBranch$,b_modcons$11_ctx,a_modcons$12_ctx) -- #81
+//│   def _b_modcons$11_a_modcons$12_opt_jp$14(tailrecBranch$,b_modcons$11_ctx,a_modcons$12_ctx) =
+//│     let scrut = ==(12,tailrecBranch$) in -- #80
+//│     if scrut -- #79
+//│       true =>
+//│         let x$2 = A(0,1) in -- #78
+//│         let ctx2 = _Context(x$2,x$2,0) in -- #77
+//│         let* (composed) = _b_a_ctx_comp$10(a_modcons$12_ctx,ctx2) in -- #76
+//│         jump _b_modcons$11_a_modcons$12_opt_jp$14(11,composed,a_modcons$12_ctx) -- #75
+//│       false =>
+//│         let* (x$3) = @tailcall a() in -- #74
+//│         let* (x$4) = c() in -- #73
+//│         let x$5 = A(x$3,x$4) in -- #72
+//│         let* (res) = _b_a_ctx_app$9(b_modcons$11_ctx,x$5) in -- #71
+//│         res -- #70
+//│   let* (x$0) = a() in -- #2
+//│   x$0 -- #1
 
 :ce
 @tailcall 1
 //│ |@|tailcall| |1|
 //│ Parsed: {@tailcall 1}
 //│ ╔══[COMPILATION ERROR] @tailcall may only be used to annotate function calls
-//│ ║  l.2513: 	@tailcall 1
+//│ ║  l.1486: 	@tailcall 1
 //│ ╙──        	 ^^^^^^^^
 //│ 
+//│ 
 //│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
+//│ Program:
 //│ 
-//│ },
-//│ 1 -- #0)
 //│ 
-//│ Strongly Connected Tail Calls:
-//│ List()
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│   1 -- #0
 //│ 
-//│ },
-//│ 1 -- #0)
 //│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Strongly Connected Tail Calls:
+//│ List()
+//│ Program:
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
 //│ 
-//│ },
-//│ 1 -- #0)
+//│   1 -- #0
 
 :ce
 @tailrec 1
 //│ |@|tailrec| |1|
 //│ Parsed: {@tailrec 1}
 //│ ╔══[COMPILATION ERROR] @tailrec may only be used to annotate functions
-//│ ║  l.2540: 	@tailrec 1
+//│ ║  l.1510: 	@tailrec 1
 //│ ╙──        	 ^^^^^^^
 //│ 
+//│ 
 //│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
+//│ Program:
 //│ 
-//│ },
-//│ 1 -- #0)
 //│ 
-//│ Strongly Connected Tail Calls:
-//│ List()
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│   1 -- #0
 //│ 
-//│ },
-//│ 1 -- #0)
 //│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
+//│ Strongly Connected Tail Calls:
+//│ List()
+//│ Program:
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
 //│ 
-//│ },
-//│ 1 -- #0)
+//│   1 -- #0
 
 :ce
 fun foo() =
@@ -2570,50 +1537,32 @@ foo()
 //│ |#fun| |foo|(||)| |#=|→|@|tailrec| |foo|(||)|←|↵|foo|(||)|
 //│ Parsed: {fun foo = () => {@tailrec foo()}; foo()}
 //│ ╔══[COMPILATION ERROR] @tailrec is for annotating functions; try @tailcall instead
-//│ ║  l.2568: 	  @tailrec foo()
+//│ ║  l.1535: 	  @tailrec foo()
 //│ ╙──        	   ^^^^^^^
 //│ 
+//│ 
 //│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
-//│ Def(0, foo, [],
-//│ 1, 
-//│ let* (x$0) = foo() in -- #3
-//│ x$0 -- #2
-//│ )
-//│ },
-//│ let* (x$1) = foo() in -- #7
-//│ x$1 -- #6)
+//│ Program:
+//│ 
+//│   def foo() =
+//│     let* (x$1) = foo() in -- #5
+//│     x$1 -- #4
+//│   let* (x$0) = foo() in -- #2
+//│   x$0 -- #1
+//│ 
 //│ 
 //│ Strongly Connected Tail Calls:
 //│ List(Set(foo))
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(1, foo_jp, [],
-//│ 1, 
-//│ jump foo_jp() -- #8
-//│ )
-//│ Def(2, foo, [],
-//│ 1, 
-//│ let* (r0) = foo_jp() in -- #10
-//│ r0 -- #9
-//│ )
-//│ },
-//│ let* (x$1) = foo() in -- #7
-//│ x$1 -- #6)
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(1, foo_jp, [],
-//│ 1, 
-//│ jump foo_jp() -- #8
-//│ )
-//│ Def(2, foo, [],
-//│ 1, 
-//│ let* (r0) = foo_jp() in -- #10
-//│ r0 -- #9
-//│ )
-//│ },
-//│ let* (x$1) = foo() in -- #7
-//│ x$1 -- #6)
+//│ Program:
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
+//│   def foo_jp() =
+//│     jump foo_jp() -- #12
+//│   def foo() =
+//│     let* (r0) = foo_jp() in -- #14
+//│     r0 -- #13
+//│   let* (x$0) = foo() in -- #2
+//│   x$0 -- #1
 
 :ce
 @tailcall
@@ -2623,47 +1572,29 @@ foo()
 //│ |@|tailcall|↵|#fun| |foo|(||)| |#=|→|foo|(||)|←|↵|foo|(||)|
 //│ Parsed: {fun foo = () => {foo()}; foo()}
 //│ ╔══[COMPILATION ERROR] @tailcall is for annotating function calls; try @tailrec instead
-//│ ║  l.2619: 	@tailcall
+//│ ║  l.1568: 	@tailcall
 //│ ╙──        	 ^^^^^^^^
 //│ 
+//│ 
 //│ IR:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, [])}, {
-//│ Def(0, foo, [],
-//│ 1, 
-//│ let* (x$0) = foo() in -- #3
-//│ x$0 -- #2
-//│ )
-//│ },
-//│ let* (x$1) = foo() in -- #7
-//│ x$1 -- #6)
+//│ Program:
+//│ 
+//│   def foo() =
+//│     let* (x$1) = foo() in -- #5
+//│     x$1 -- #4
+//│   let* (x$0) = foo() in -- #2
+//│   x$0 -- #1
+//│ 
 //│ 
 //│ Strongly Connected Tail Calls:
 //│ List(Set(foo))
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(1, foo_jp, [],
-//│ 1, 
-//│ jump foo_jp() -- #8
-//│ )
-//│ Def(2, foo, [],
-//│ 1, 
-//│ let* (r0) = foo_jp() in -- #10
-//│ r0 -- #9
-//│ )
-//│ },
-//│ let* (x$1) = foo() in -- #7
-//│ x$1 -- #6)
-//│ 
-//│ Promoted:
-//│ Program({ClassInfo(0, True, []),ClassInfo(1, False, []),ClassInfo(2, _IdContext, []),ClassInfo(3, _Context, [acc,ptr,field])}, {
-//│ Def(1, foo_jp, [],
-//│ 1, 
-//│ jump foo_jp() -- #8
-//│ )
-//│ Def(2, foo, [],
-//│ 1, 
-//│ let* (r0) = foo_jp() in -- #10
-//│ r0 -- #9
-//│ )
-//│ },
-//│ let* (x$1) = foo() in -- #7
-//│ x$1 -- #6)
+//│ Program:
+//│   class _IdContext()
+//│   class _Context(acc,ptr,field)
+//│   def foo_jp() =
+//│     jump foo_jp() -- #12
+//│   def foo() =
+//│     let* (r0) = foo_jp() in -- #14
+//│     r0 -- #13
+//│   let* (x$0) = foo() in -- #2
+//│   x$0 -- #1
diff --git a/compiler/shared/test/diff-ir/LiftClass.mls b/compiler/shared/test/diff-ir/LiftClass.mls
new file mode 100644
index 0000000000..05b2267a9b
--- /dev/null
+++ b/compiler/shared/test/diff-ir/LiftClass.mls
@@ -0,0 +1,158 @@
+:NewDefs
+:ParseOnly
+:UseIR
+:NoTailRec
+
+:prelude
+module True
+module False
+module Callable {
+  fun apply0() = 0
+  fun apply1(x0) = 0
+  fun apply2(x0,x1) = 0
+  fun apply3(x0,x1,x2) = 0
+  fun apply4(x0,x1,x2,x3) = 0
+  fun apply5(x0,x1,x2,x3,x4) = 0
+}
+module List[A, B]
+class Cons[A, B](h: A, t: Cons[A, B]) extends List[A, B]
+module Nil[A, B] extends List[A, B]
+module Option[A]
+class Some[A](x: A) extends Option[A]
+module None[A] extends Option[A]
+class Pair[A, B](x: A, y: B)
+class Tuple2[A, B](x: A, y: B)
+class Tuple3[A, B, C](x: A, y: B, z: C)
+module Nat
+class S(s: Nat) extends Nat
+module O extends Nat
+class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O)
+//│ |#module| |True|↵|#module| |False|↵|#module| |Callable| |{|→|#fun| |apply0|(||)| |#=| |0|↵|#fun| |apply1|(|x0|)| |#=| |0|↵|#fun| |apply2|(|x0|,|x1|)| |#=| |0|↵|#fun| |apply3|(|x0|,|x1|,|x2|)| |#=| |0|↵|#fun| |apply4|(|x0|,|x1|,|x2|,|x3|)| |#=| |0|↵|#fun| |apply5|(|x0|,|x1|,|x2|,|x3|,|x4|)| |#=| |0|←|↵|}|↵|#module| |List|[|A|,| |B|]|↵|#class| |Cons|[|A|,| |B|]|(|h|#:| |A|,| |t|#:| |Cons|[|A|,| |B|]|)| |#extends| |List|[|A|,| |B|]|↵|#module| |Nil|[|A|,| |B|]| |#extends| |List|[|A|,| |B|]|↵|#module| |Option|[|A|]|↵|#class| |Some|[|A|]|(|x|#:| |A|)| |#extends| |Option|[|A|]|↵|#module| |None|[|A|]| |#extends| |Option|[|A|]|↵|#class| |Pair|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple2|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple3|[|A|,| |B|,| |C|]|(|x|#:| |A|,| |y|#:| |B|,| |z|#:| |C|)|↵|#module| |Nat|↵|#class| |S|(|s|#:| |Nat|)| |#extends| |Nat|↵|#module| |O| |#extends| |Nat|↵|#class| |HiddenTheseEntities|(|_0|#:| |HiddenTheseEntities|,| |_1|#:| |True|,| |_2|#:| |False|,| |_3|#:| |Callable|,| |_4|#:| |List|,| |_5|#:| |Cons|,| |_6|#:| |Nil|,| |_7|#:| |Option|,| |_8|#:| |Some|,| |_9|#:| |None|,| |_10|#:| |Pair|,| |_11|#:| |Tuple2|,| |_12|#:| |Tuple3|,| |_13|#:| |Nat|,| |_14|#:| |S|,| |_15|#:| |O|)|
+//│ Parsed: {module True {}; module False {}; module Callable {fun apply0 = () => 0; fun apply1 = (x0,) => 0; fun apply2 = (x0, x1,) => 0; fun apply3 = (x0, x1, x2,) => 0; fun apply4 = (x0, x1, x2, x3,) => 0; fun apply5 = (x0, x1, x2, x3, x4,) => 0}; module List‹A, B› {}; class Cons‹A, B›(h: A, t: Cons‹A, B›,): List‹A, B› {}; module Nil‹A, B›: List‹A, B› {}; module Option‹A› {}; class Some‹A›(x: A,): Option‹A› {}; module None‹A›: Option‹A› {}; class Pair‹A, B›(x: A, y: B,) {}; class Tuple2‹A, B›(x: A, y: B,) {}; class Tuple3‹A, B, C›(x: A, y: B, z: C,) {}; module Nat {}; class S(s: Nat,): Nat {}; module O: Nat {}; class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O,) {}}
+//│ 
+//│ Preluded.
+//│ 
+
+:genCpp
+:runCpp
+:interpIR
+fun main(x) =
+  class InnerClass(y) extends Callable {
+    fun apply1(z) = x + y + z
+  }
+  let ic = InnerClass(1)
+  ic(2) + ic(3)
+main(4)
+//│ |#fun| |main|(|x|)| |#=|→|#class| |InnerClass|(|y|)| |#extends| |Callable| |{|→|#fun| |apply1|(|z|)| |#=| |x| |+| |y| |+| |z|←|↵|}|↵|#let| |ic| |#=| |InnerClass|(|1|)|↵|ic|(|2|)| |+| |ic|(|3|)|←|↵|main|(|4|)|
+//│ Parsed: {fun main = (x,) => {class InnerClass(y,): Callable {fun apply1 = (z,) => +(+(x, y,), z,)}; let ic = InnerClass(1,); +(ic(2,), ic(3,),)}; main(4,)}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│   class InnerClass(y,x) extends Callable {
+//│     def apply1(z$0) =
+//│       let x$6 = +(x,y) in -- #45
+//│       let x$7 = +(x$6,z$0) in -- #44
+//│       x$7 -- #43
+//│   }
+//│   def main(x$1) =
+//│     let x$2 = InnerClass(1,x$1) in -- #26
+//│     let x$3 = Callable.apply1(x$2,2) in -- #25
+//│     let x$4 = Callable.apply1(x$2,3) in -- #24
+//│     let x$5 = +(x$3,x$4) in -- #23
+//│     x$5 -- #22
+//│   let* (x$0) = main(4) in -- #4
+//│   x$0 -- #3
+//│ 
+//│ Interpreted:
+//│ 15
+//│ 
+//│ 
+//│ Execution succeeded: 
+//│ 15
+//│ 
+
+:genCpp
+:runCpp
+:interpIR
+fun main(x) =
+  class InnerClass(y) extends Callable {
+    fun apply1(z) =
+      module InnerClass2 extends Callable {
+        fun apply1(w) = w + z
+      }
+      InnerClass2
+  }
+  let ic = InnerClass(1)
+  ic(2)(2) + ic(3)(1)
+main(4)
+//│ |#fun| |main|(|x|)| |#=|→|#class| |InnerClass|(|y|)| |#extends| |Callable| |{|→|#fun| |apply1|(|z|)| |#=|→|#module| |InnerClass2| |#extends| |Callable| |{|→|#fun| |apply1|(|w|)| |#=| |w| |+| |z|←|↵|}|↵|InnerClass2|←|←|↵|}|↵|#let| |ic| |#=| |InnerClass|(|1|)|↵|ic|(|2|)|(|2|)| |+| |ic|(|3|)|(|1|)|←|↵|main|(|4|)|
+//│ Parsed: {fun main = (x,) => {class InnerClass(y,): Callable {fun apply1 = (z,) => {module InnerClass2: Callable {fun apply1 = (w,) => +(w, z,)}; InnerClass2}}; let ic = InnerClass(1,); +(ic(2,)(2,), ic(3,)(1,),)}; main(4,)}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│   class InnerClass(y) extends Callable {
+//│     def apply1(z$0) =
+//│       let x$8 = InnerClass2(z$0) in -- #44
+//│       x$8 -- #43
+//│   }
+//│   class InnerClass2(z) extends Callable {
+//│     def apply1(w$0) =
+//│       let x$9 = +(w$0,z) in -- #51
+//│       x$9 -- #50
+//│   }
+//│   def main(x$1) =
+//│     let x$2 = InnerClass(1) in -- #36
+//│     let x$3 = Callable.apply1(x$2,2) in -- #35
+//│     let x$4 = Callable.apply1(x$3,2) in -- #34
+//│     let x$5 = Callable.apply1(x$2,3) in -- #33
+//│     let x$6 = Callable.apply1(x$5,1) in -- #32
+//│     let x$7 = +(x$4,x$6) in -- #31
+//│     x$7 -- #30
+//│   let* (x$0) = main(4) in -- #4
+//│   x$0 -- #3
+//│ 
+//│ Interpreted:
+//│ 8
+//│ 
+//│ 
+//│ Execution succeeded: 
+//│ 8
+//│ 
+
+:genCpp
+:runCpp
+:interpIR
+fun main(x) =
+  class InnerClass(y) extends Callable {
+    fun f(x) = y
+  }
+  let ic = InnerClass(1)
+  InnerClass.f(ic, Nil)
+main(2)
+//│ |#fun| |main|(|x|)| |#=|→|#class| |InnerClass|(|y|)| |#extends| |Callable| |{|→|#fun| |f|(|x|)| |#=| |y|←|↵|}|↵|#let| |ic| |#=| |InnerClass|(|1|)|↵|InnerClass|.f|(|ic|,| |Nil|)|←|↵|main|(|2|)|
+//│ Parsed: {fun main = (x,) => {class InnerClass(y,): Callable {fun f = (x,) => y}; let ic = InnerClass(1,); (InnerClass).f(ic, Nil,)}; main(2,)}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│   class InnerClass(y) extends Callable {
+//│     def f(x$5) =
+//│       y -- #24
+//│   }
+//│   def main(x$1) =
+//│     let x$2 = InnerClass(1) in -- #17
+//│     let x$3 = Nil() in -- #16
+//│     let x$4 = InnerClass.f(x$2,x$3) in -- #15
+//│     x$4 -- #14
+//│   let* (x$0) = main(2) in -- #4
+//│   x$0 -- #3
+//│ 
+//│ Interpreted:
+//│ 1
+//│ 
+//│ 
+//│ Execution succeeded: 
+//│ 1
+//│ 
diff --git a/compiler/shared/test/diff-ir/LiftFun.mls b/compiler/shared/test/diff-ir/LiftFun.mls
new file mode 100644
index 0000000000..1d148b4551
--- /dev/null
+++ b/compiler/shared/test/diff-ir/LiftFun.mls
@@ -0,0 +1,186 @@
+:NewDefs
+:ParseOnly
+:UseIR
+:NoTailRec
+
+:prelude
+module True
+module False
+module Callable {
+  fun apply0() = 0
+  fun apply1(x0) = 0
+  fun apply2(x0,x1) = 0
+  fun apply3(x0,x1,x2) = 0
+  fun apply4(x0,x1,x2,x3) = 0
+  fun apply5(x0,x1,x2,x3,x4) = 0
+}
+module List[A, B]
+class Cons[A, B](h: A, t: Cons[A, B]) extends List[A, B]
+module Nil[A, B] extends List[A, B]
+module Option[A]
+class Some[A](x: A) extends Option[A]
+module None[A] extends Option[A]
+class Pair[A, B](x: A, y: B)
+class Tuple2[A, B](x: A, y: B)
+class Tuple3[A, B, C](x: A, y: B, z: C)
+module Nat
+class S(s: Nat) extends Nat
+module O extends Nat
+class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O)
+//│ |#module| |True|↵|#module| |False|↵|#module| |Callable| |{|→|#fun| |apply0|(||)| |#=| |0|↵|#fun| |apply1|(|x0|)| |#=| |0|↵|#fun| |apply2|(|x0|,|x1|)| |#=| |0|↵|#fun| |apply3|(|x0|,|x1|,|x2|)| |#=| |0|↵|#fun| |apply4|(|x0|,|x1|,|x2|,|x3|)| |#=| |0|↵|#fun| |apply5|(|x0|,|x1|,|x2|,|x3|,|x4|)| |#=| |0|←|↵|}|↵|#module| |List|[|A|,| |B|]|↵|#class| |Cons|[|A|,| |B|]|(|h|#:| |A|,| |t|#:| |Cons|[|A|,| |B|]|)| |#extends| |List|[|A|,| |B|]|↵|#module| |Nil|[|A|,| |B|]| |#extends| |List|[|A|,| |B|]|↵|#module| |Option|[|A|]|↵|#class| |Some|[|A|]|(|x|#:| |A|)| |#extends| |Option|[|A|]|↵|#module| |None|[|A|]| |#extends| |Option|[|A|]|↵|#class| |Pair|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple2|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple3|[|A|,| |B|,| |C|]|(|x|#:| |A|,| |y|#:| |B|,| |z|#:| |C|)|↵|#module| |Nat|↵|#class| |S|(|s|#:| |Nat|)| |#extends| |Nat|↵|#module| |O| |#extends| |Nat|↵|#class| |HiddenTheseEntities|(|_0|#:| |HiddenTheseEntities|,| |_1|#:| |True|,| |_2|#:| |False|,| |_3|#:| |Callable|,| |_4|#:| |List|,| |_5|#:| |Cons|,| |_6|#:| |Nil|,| |_7|#:| |Option|,| |_8|#:| |Some|,| |_9|#:| |None|,| |_10|#:| |Pair|,| |_11|#:| |Tuple2|,| |_12|#:| |Tuple3|,| |_13|#:| |Nat|,| |_14|#:| |S|,| |_15|#:| |O|)|
+//│ Parsed: {module True {}; module False {}; module Callable {fun apply0 = () => 0; fun apply1 = (x0,) => 0; fun apply2 = (x0, x1,) => 0; fun apply3 = (x0, x1, x2,) => 0; fun apply4 = (x0, x1, x2, x3,) => 0; fun apply5 = (x0, x1, x2, x3, x4,) => 0}; module List‹A, B› {}; class Cons‹A, B›(h: A, t: Cons‹A, B›,): List‹A, B› {}; module Nil‹A, B›: List‹A, B› {}; module Option‹A› {}; class Some‹A›(x: A,): Option‹A› {}; module None‹A›: Option‹A› {}; class Pair‹A, B›(x: A, y: B,) {}; class Tuple2‹A, B›(x: A, y: B,) {}; class Tuple3‹A, B, C›(x: A, y: B, z: C,) {}; module Nat {}; class S(s: Nat,): Nat {}; module O: Nat {}; class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O,) {}}
+//│ 
+//│ Preluded.
+//│ 
+
+:genCpp
+:runCpp
+:interpIR
+fun main(init, key) =
+  fun r(x) = if x <= 0 then key else r(x - 1)
+  r(init)
+main(1, 42)
+//│ |#fun| |main|(|init|,| |key|)| |#=|→|#fun| |r|(|x|)| |#=| |#if| |x| |<=| |0| |#then| |key| |#else| |r|(|x| |-| |1|)|↵|r|(|init|)|←|↵|main|(|1|,| |42|)|
+//│ Parsed: {fun main = (init, key,) => {fun r = (x,) => if (<=(x, 0,)) then key else r(-(x, 1,),); r(init,)}; main(1, 42,)}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def main(init$0,key$0) =
+//│     let* (x$1) = r(init$0,key$0) in -- #11
+//│     x$1 -- #10
+//│   def r(x$2,key$1) =
+//│     let x$3 = <=(x$2,0) in -- #40
+//│     if x$3 -- #39
+//│       true =>
+//│         jump j$0(key$1) -- #26
+//│       false =>
+//│         let x$5 = -(x$2,1) in -- #38
+//│         let* (x$6) = r(x$5,key$1) in -- #37
+//│         jump j$0(x$6) -- #36
+//│   def j$0(x$4) =
+//│     x$4 -- #24
+//│   let* (x$0) = main(1,42) in -- #6
+//│   x$0 -- #5
+//│ 
+//│ Interpreted:
+//│ 42
+//│ 
+//│ 
+//│ Execution succeeded: 
+//│ 42
+//│ 
+
+:genCpp
+:runCpp
+:interpIR
+fun main(init, key) =
+  fun ping(x) = if x <= 0 then key + 1 else pong(x - 1)
+  fun pong(x) = if x <= 0 then key + 2 else ping(x - 1)
+  ping(init)
+main(1, 42)
+//│ |#fun| |main|(|init|,| |key|)| |#=|→|#fun| |ping|(|x|)| |#=| |#if| |x| |<=| |0| |#then| |key| |+| |1| |#else| |pong|(|x| |-| |1|)|↵|#fun| |pong|(|x|)| |#=| |#if| |x| |<=| |0| |#then| |key| |+| |2| |#else| |ping|(|x| |-| |1|)|↵|ping|(|init|)|←|↵|main|(|1|,| |42|)|
+//│ Parsed: {fun main = (init, key,) => {fun ping = (x,) => if (<=(x, 0,)) then +(key, 1,) else pong(-(x, 1,),); fun pong = (x,) => if (<=(x, 0,)) then +(key, 2,) else ping(-(x, 1,),); ping(init,)}; main(1, 42,)}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│ 
+//│   def main(init$0,key$0) =
+//│     let* (x$1) = ping(init$0,key$0) in -- #11
+//│     x$1 -- #10
+//│   def ping(x$2,key$1) =
+//│     let x$3 = <=(x$2,0) in -- #46
+//│     if x$3 -- #45
+//│       true =>
+//│         let x$5 = +(key$1,1) in -- #32
+//│         jump j$0(x$5) -- #31
+//│       false =>
+//│         let x$6 = -(x$2,1) in -- #44
+//│         let* (x$7) = pong(x$6,key$1) in -- #43
+//│         jump j$0(x$7) -- #42
+//│   def j$0(x$4) =
+//│     x$4 -- #24
+//│   def pong(x$8,key$2) =
+//│     let x$9 = <=(x$8,0) in -- #75
+//│     if x$9 -- #74
+//│       true =>
+//│         let x$11 = +(key$2,2) in -- #61
+//│         jump j$1(x$11) -- #60
+//│       false =>
+//│         let x$12 = -(x$8,1) in -- #73
+//│         let* (x$13) = ping(x$12,key$2) in -- #72
+//│         jump j$1(x$13) -- #71
+//│   def j$1(x$10) =
+//│     x$10 -- #53
+//│   let* (x$0) = main(1,42) in -- #6
+//│   x$0 -- #5
+//│ 
+//│ Interpreted:
+//│ 44
+//│ 
+//│ 
+//│ Execution succeeded: 
+//│ 44
+//│ 
+
+:genCpp
+:runCpp
+:interpIR
+fun main(init, key) =
+  let ping =
+    fun ping(x) = if x <= 0 then key + 1 else pong(x - 1)
+    fun pong(x) = if x <= 0 then key + 2 else ping(x - 1)
+    ping
+  ping(init)
+main(1, 42)
+//│ |#fun| |main|(|init|,| |key|)| |#=|→|#let| |ping| |#=|→|#fun| |ping|(|x|)| |#=| |#if| |x| |<=| |0| |#then| |key| |+| |1| |#else| |pong|(|x| |-| |1|)|↵|#fun| |pong|(|x|)| |#=| |#if| |x| |<=| |0| |#then| |key| |+| |2| |#else| |ping|(|x| |-| |1|)|↵|ping|←|↵|ping|(|init|)|←|↵|main|(|1|,| |42|)|
+//│ Parsed: {fun main = (init, key,) => {let ping = {fun ping = (x,) => if (<=(x, 0,)) then +(key, 1,) else pong(-(x, 1,),); fun pong = (x,) => if (<=(x, 0,)) then +(key, 2,) else ping(-(x, 1,),); ping}; ping(init,)}; main(1, 42,)}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│   class Lambda$0(key) extends Callable {
+//│     def apply1(x$17) =
+//│       let* (x$18) = ping(x$17,key) in -- #85
+//│       x$18 -- #84
+//│   }
+//│   def main(init$0,key$0) =
+//│     let x$3 = Lambda$0(key$0) in -- #14
+//│     let x$4 = Callable.apply1(x$3,init$0) in -- #13
+//│     x$4 -- #12
+//│   def ping(x$5,key$1) =
+//│     let x$6 = <=(x$5,0) in -- #49
+//│     if x$6 -- #48
+//│       true =>
+//│         let x$8 = +(key$1,1) in -- #35
+//│         jump j$0(x$8) -- #34
+//│       false =>
+//│         let x$9 = -(x$5,1) in -- #47
+//│         let* (x$10) = pong(x$9,key$1) in -- #46
+//│         jump j$0(x$10) -- #45
+//│   def j$0(x$7) =
+//│     x$7 -- #27
+//│   def pong(x$11,key$2) =
+//│     let x$12 = <=(x$11,0) in -- #78
+//│     if x$12 -- #77
+//│       true =>
+//│         let x$14 = +(key$2,2) in -- #64
+//│         jump j$1(x$14) -- #63
+//│       false =>
+//│         let x$15 = -(x$11,1) in -- #76
+//│         let* (x$16) = ping(x$15,key$2) in -- #75
+//│         jump j$1(x$16) -- #74
+//│   def j$1(x$13) =
+//│     x$13 -- #56
+//│   let* (x$0) = main(1,42) in -- #6
+//│   x$0 -- #5
+//│ 
+//│ Interpreted:
+//│ 44
+//│ 
+//│ 
+//│ Execution succeeded: 
+//│ 44
+//│ 
diff --git a/compiler/shared/test/diff-ir/LiftLambda.mls b/compiler/shared/test/diff-ir/LiftLambda.mls
new file mode 100644
index 0000000000..9f397b3118
--- /dev/null
+++ b/compiler/shared/test/diff-ir/LiftLambda.mls
@@ -0,0 +1,87 @@
+:NewDefs
+:ParseOnly
+:UseIR
+:NoTailRec
+
+:prelude
+module True
+module False
+module Callable {
+  fun apply0() = 0
+  fun apply1(x0) = 0
+  fun apply2(x0,x1) = 0
+  fun apply3(x0,x1,x2) = 0
+  fun apply4(x0,x1,x2,x3) = 0
+  fun apply5(x0,x1,x2,x3,x4) = 0
+}
+module List[A, B]
+class Cons[A, B](h: A, t: Cons[A, B]) extends List[A, B]
+module Nil[A, B] extends List[A, B]
+module Option[A]
+class Some[A](x: A) extends Option[A]
+module None[A] extends Option[A]
+class Pair[A, B](x: A, y: B)
+class Tuple2[A, B](x: A, y: B)
+class Tuple3[A, B, C](x: A, y: B, z: C)
+module Nat
+class S(s: Nat) extends Nat
+module O extends Nat
+class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O)
+//│ |#module| |True|↵|#module| |False|↵|#module| |Callable| |{|→|#fun| |apply0|(||)| |#=| |0|↵|#fun| |apply1|(|x0|)| |#=| |0|↵|#fun| |apply2|(|x0|,|x1|)| |#=| |0|↵|#fun| |apply3|(|x0|,|x1|,|x2|)| |#=| |0|↵|#fun| |apply4|(|x0|,|x1|,|x2|,|x3|)| |#=| |0|↵|#fun| |apply5|(|x0|,|x1|,|x2|,|x3|,|x4|)| |#=| |0|←|↵|}|↵|#module| |List|[|A|,| |B|]|↵|#class| |Cons|[|A|,| |B|]|(|h|#:| |A|,| |t|#:| |Cons|[|A|,| |B|]|)| |#extends| |List|[|A|,| |B|]|↵|#module| |Nil|[|A|,| |B|]| |#extends| |List|[|A|,| |B|]|↵|#module| |Option|[|A|]|↵|#class| |Some|[|A|]|(|x|#:| |A|)| |#extends| |Option|[|A|]|↵|#module| |None|[|A|]| |#extends| |Option|[|A|]|↵|#class| |Pair|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple2|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple3|[|A|,| |B|,| |C|]|(|x|#:| |A|,| |y|#:| |B|,| |z|#:| |C|)|↵|#module| |Nat|↵|#class| |S|(|s|#:| |Nat|)| |#extends| |Nat|↵|#module| |O| |#extends| |Nat|↵|#class| |HiddenTheseEntities|(|_0|#:| |HiddenTheseEntities|,| |_1|#:| |True|,| |_2|#:| |False|,| |_3|#:| |Callable|,| |_4|#:| |List|,| |_5|#:| |Cons|,| |_6|#:| |Nil|,| |_7|#:| |Option|,| |_8|#:| |Some|,| |_9|#:| |None|,| |_10|#:| |Pair|,| |_11|#:| |Tuple2|,| |_12|#:| |Tuple3|,| |_13|#:| |Nat|,| |_14|#:| |S|,| |_15|#:| |O|)|
+//│ Parsed: {module True {}; module False {}; module Callable {fun apply0 = () => 0; fun apply1 = (x0,) => 0; fun apply2 = (x0, x1,) => 0; fun apply3 = (x0, x1, x2,) => 0; fun apply4 = (x0, x1, x2, x3,) => 0; fun apply5 = (x0, x1, x2, x3, x4,) => 0}; module List‹A, B› {}; class Cons‹A, B›(h: A, t: Cons‹A, B›,): List‹A, B› {}; module Nil‹A, B›: List‹A, B› {}; module Option‹A› {}; class Some‹A›(x: A,): Option‹A› {}; module None‹A›: Option‹A› {}; class Pair‹A, B›(x: A, y: B,) {}; class Tuple2‹A, B›(x: A, y: B,) {}; class Tuple3‹A, B, C›(x: A, y: B, z: C,) {}; module Nat {}; class S(s: Nat,): Nat {}; module O: Nat {}; class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O,) {}}
+//│ 
+//│ Preluded.
+//│ 
+
+:genCpp
+:runCpp
+:interpIR
+fun compose(f)(g)(x) = f(g(x))
+fun main(x) =
+  let y = 1
+  let lam = z => x + y + z
+  compose(lam)(lam)(2)
+main(3)
+//│ |#fun| |compose|(|f|)|(|g|)|(|x|)| |#=| |f|(|g|(|x|)|)|↵|#fun| |main|(|x|)| |#=|→|#let| |y| |#=| |1|↵|#let| |lam| |#=| |z| |#=>| |x| |+| |y| |+| |z|↵|compose|(|lam|)|(|lam|)|(|2|)|←|↵|main|(|3|)|
+//│ Parsed: {fun compose = (f,) => (g,) => (x,) => f(g(x,),); fun main = (x,) => {let y = 1; let lam = (z,) => +(+(x, y,), z,); compose(lam,)(lam,)(2,)}; main(3,)}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│   class Lambda$0(f) extends Callable {
+//│     def apply1(g$0) =
+//│       let x$11 = Lambda$2(f,g$0) in -- #33
+//│       x$11 -- #32
+//│   }
+//│   class Lambda$1(x,y) extends Callable {
+//│     def apply1(z$0) =
+//│       let x$12 = +(x,y) in -- #46
+//│       let x$13 = +(x$12,z$0) in -- #45
+//│       x$13 -- #44
+//│   }
+//│   class Lambda$2(f,g) extends Callable {
+//│     def apply1(x$14) =
+//│       let x$15 = Callable.apply1(g,x$14) in -- #57
+//│       let x$16 = Callable.apply1(f,x$15) in -- #56
+//│       x$16 -- #55
+//│   }
+//│   def compose(f$0) =
+//│     let x$2 = Lambda$0(f$0) in -- #6
+//│     x$2 -- #5
+//│   def main(x$3) =
+//│     let x$4 = 1 in -- #25
+//│     let x$6 = Lambda$1(x$3,x$4) in -- #24
+//│     let* (x$7) = compose(x$6) in -- #23
+//│     let x$8 = Callable.apply1(x$7,x$6) in -- #22
+//│     let x$9 = Callable.apply1(x$8,2) in -- #21
+//│     x$9 -- #20
+//│   let* (x$0) = main(3) in -- #4
+//│   x$0 -- #3
+//│ 
+//│ Interpreted:
+//│ 10
+//│ 
+//│ 
+//│ Execution succeeded: 
+//│ 10
+//│ 
diff --git a/compiler/shared/test/diff-ir/Override.mls b/compiler/shared/test/diff-ir/Override.mls
new file mode 100644
index 0000000000..7658c8a51f
--- /dev/null
+++ b/compiler/shared/test/diff-ir/Override.mls
@@ -0,0 +1,48 @@
+:NewDefs
+:ParseOnly
+:UseIR
+:NoTailRec
+
+:genCpp
+:runCpp
+:interpIR
+module Base {
+  fun f() = 1
+}
+module Child extends Base {
+  fun f() = 2
+}
+fun main() =
+  let c = Child()
+  Base.f(c)
+  Child.f(c)
+main()
+//│ |#module| |Base| |{|→|#fun| |f|(||)| |#=| |1|←|↵|}|↵|#module| |Child| |#extends| |Base| |{|→|#fun| |f|(||)| |#=| |2|←|↵|}|↵|#fun| |main|(||)| |#=|→|#let| |c| |#=| |Child|(||)|↵|Base|.f|(|c|)|↵|Child|.f|(|c|)|←|↵|main|(||)|
+//│ Parsed: {module Base {fun f = () => 1}; module Child: Base {fun f = () => 2}; fun main = () => {let c = Child(); (Base).f(c,); (Child).f(c,)}; main()}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│   class Base() {
+//│     def f() =
+//│       1 -- #16
+//│   }
+//│   class Child() extends Base {
+//│     def f() =
+//│       2 -- #17
+//│   }
+//│   def main() =
+//│     let x$1 = Child() in -- #15
+//│     let x$2 = Base.f(x$1) in -- #14
+//│     let x$3 = Child.f(x$1) in -- #13
+//│     x$3 -- #12
+//│   let* (x$0) = main() in -- #2
+//│   x$0 -- #1
+//│ 
+//│ Interpreted:
+//│ 2
+//│ 
+//│ 
+//│ Execution succeeded: 
+//│ 2
+//│ 
diff --git a/compiler/shared/test/diff-ir/cpp/Makefile b/compiler/shared/test/diff-ir/cpp/Makefile
new file mode 100644
index 0000000000..082a04fbea
--- /dev/null
+++ b/compiler/shared/test/diff-ir/cpp/Makefile
@@ -0,0 +1,26 @@
+CXX := g++
+CFLAGS := $(CFLAGS) -O3 -Wall -Wextra -std=c++20 -I. -Wno-inconsistent-missing-override
+LDFLAGS := $(LDFLAGS) -lmimalloc -lgmp
+SRC :=
+INCLUDES = mlsprelude.h
+DST :=
+DEFAULT_TARGET := mls
+TARGET := $(or $(DST),$(DEFAULT_TARGET))
+
+.PHONY: pre all run clean auto
+
+all: $(TARGET)
+
+run: $(TARGET) 
+	./$(TARGET)
+
+pre: $(SRC)
+	sed -i '' 's#^//│ ##g' $(SRC)
+
+clean:
+	rm -r $(TARGET) $(TARGET).dSYM
+
+auto: $(TARGET)
+
+$(TARGET): $(SRC) $(INCLUDES)
+	$(CXX) $(CFLAGS) $(LDFLAGS) $(SRC) -o $(TARGET)
diff --git a/compiler/shared/test/diff-ir/cpp/mlsprelude.h b/compiler/shared/test/diff-ir/cpp/mlsprelude.h
new file mode 100644
index 0000000000..8415951c93
--- /dev/null
+++ b/compiler/shared/test/diff-ir/cpp/mlsprelude.h
@@ -0,0 +1,568 @@
+#include <cassert>
+#include <cinttypes>
+#include <cstdint>
+#include <cstdio>
+#include <limits>
+#include <new>
+#include <pthread.h>
+#include <stdexcept>
+#include <sys/resource.h>
+#include <tuple>
+#include <typeinfo>
+#include <utility>
+
+constexpr std::size_t _mlsAlignment = 8;
+
+template <typename T, size_t N> class tuple_type {
+  template <typename = std::make_index_sequence<N>> struct impl;
+  template <size_t... Is> struct impl<std::index_sequence<Is...>> {
+    template <size_t> using wrap = T;
+    using type = std::tuple<wrap<Is>...>;
+  };
+
+public:
+  using type = typename impl<>::type;
+};
+template <auto Id> struct counter {
+  using tag = counter;
+
+  struct generator {
+    friend consteval auto is_defined(tag) { return true; }
+  };
+  friend consteval auto is_defined(tag);
+
+  template <typename Tag = tag, auto = is_defined(Tag{})>
+  static consteval auto exists(auto) {
+    return true;
+  }
+
+  static consteval auto exists(...) { return generator(), false; }
+};
+
+template <auto Id = int{}, typename = decltype([] {})>
+consteval auto nextTypeTag() {
+  if constexpr (not counter<Id>::exists(Id))
+    return Id;
+  else
+    return nextTypeTag<Id + 1>();
+}
+
+struct _mlsObject {
+  uint32_t refCount;
+  uint32_t tag;
+  constexpr static inline uint32_t stickyRefCount =
+      std::numeric_limits<decltype(refCount)>::max();
+
+  void incRef() {
+    if (refCount != stickyRefCount)
+      ++refCount;
+  }
+  bool decRef() {
+    if (refCount != stickyRefCount && --refCount == 0)
+      return true;
+    return false;
+  }
+
+  virtual void print() const = 0;
+  virtual void destroy() = 0;
+};
+
+struct _mls_True;
+struct _mls_False;
+
+class _mlsValue {
+  using uintptr_t = std::uintptr_t;
+  using uint64_t = std::uint64_t;
+
+  void *value alignas(_mlsAlignment);
+
+  bool isInt63() const { return (reinterpret_cast<uintptr_t>(value) & 1) == 1; }
+
+  bool isPtr() const { return (reinterpret_cast<uintptr_t>(value) & 1) == 0; }
+
+  uint64_t asInt63() const { return reinterpret_cast<uintptr_t>(value) >> 1; }
+
+  uintptr_t asRawInt() const { return reinterpret_cast<uintptr_t>(value); }
+
+  static _mlsValue fromRawInt(uintptr_t i) {
+    return _mlsValue(reinterpret_cast<void *>(i));
+  }
+
+  static _mlsValue fromInt63(uint64_t i) {
+    return _mlsValue(reinterpret_cast<void *>((i << 1) | 1));
+  }
+
+  void *asPtr() const {
+    assert(!isInt63());
+    return value;
+  }
+
+  _mlsObject *asObject() const {
+    assert(isPtr());
+    return static_cast<_mlsObject *>(value);
+  }
+
+  bool eqInt63(const _mlsValue &other) const {
+    return asRawInt() == other.asRawInt();
+  }
+
+  _mlsValue addInt63(const _mlsValue &other) const {
+    return fromRawInt(asRawInt() + other.asRawInt() - 1);
+  }
+
+  _mlsValue subInt63(const _mlsValue &other) const {
+    return fromRawInt(asRawInt() - other.asRawInt() + 1);
+  }
+
+  _mlsValue mulInt63(const _mlsValue &other) const {
+    return fromInt63(asInt63() * other.asInt63());
+  }
+
+  _mlsValue divInt63(const _mlsValue &other) const {
+    return fromInt63(asInt63() / other.asInt63());
+  }
+
+  _mlsValue gtInt63(const _mlsValue &other) const {
+    return asInt63() > other.asInt63() ? _mlsValue::create<_mls_True>()
+                                       : _mlsValue::create<_mls_False>();
+  }
+
+  _mlsValue ltInt63(const _mlsValue &other) const {
+    return asInt63() < other.asInt63() ? _mlsValue::create<_mls_True>()
+                                       : _mlsValue::create<_mls_False>();
+  }
+
+  _mlsValue geInt63(const _mlsValue &other) const {
+    return asInt63() >= other.asInt63() ? _mlsValue::create<_mls_True>()
+                                        : _mlsValue::create<_mls_False>();
+  }
+
+  _mlsValue leInt63(const _mlsValue &other) const {
+    return asInt63() <= other.asInt63() ? _mlsValue::create<_mls_True>()
+                                        : _mlsValue::create<_mls_False>();
+  }
+
+public:
+  explicit _mlsValue() : value(nullptr) {}
+  explicit _mlsValue(void *value) : value(value) {}
+  _mlsValue(const _mlsValue &other) : value(other.value) {
+    if (isPtr())
+      asObject()->incRef();
+  }
+
+  _mlsValue &operator=(const _mlsValue &other) {
+    if (value != nullptr && isPtr())
+      asObject()->decRef();
+    value = other.value;
+    if (isPtr())
+      asObject()->incRef();
+    return *this;
+  }
+
+  ~_mlsValue() {
+    if (isPtr())
+      if (asObject()->decRef()) {
+        asObject()->destroy();
+        value = nullptr;
+      }
+  }
+
+  uint64_t asInt() const {
+    assert(isInt63());
+    return asInt63();
+  }
+
+  static _mlsValue fromIntLit(uint64_t i) { return fromInt63(i); }
+
+  template <unsigned N> static tuple_type<_mlsValue, N> never() {
+    __builtin_unreachable();
+  }
+  static _mlsValue never() { __builtin_unreachable(); }
+
+  template <typename T, typename... U> static _mlsValue create(U... args) {
+    return _mlsValue(T::create(args...));
+  }
+
+  static void destroy(_mlsValue &v) { v.~_mlsValue(); }
+
+  template <typename T> static bool isValueOf(const _mlsValue &v) {
+    return v.asObject()->tag == T::typeTag;
+  }
+
+  static bool isIntLit(const _mlsValue &v, uint64_t n) {
+    return v.asInt63() == n;
+  }
+
+  static bool isIntLit(const _mlsValue &v) { return v.isInt63(); }
+
+  template <typename T> static T *as(const _mlsValue &v) {
+    return dynamic_cast<T *>(v.asObject());
+  }
+
+  template <typename T> static T *cast(_mlsValue &v) {
+    return static_cast<T *>(v.asObject());
+  }
+
+  // Operators
+
+  _mlsValue operator==(const _mlsValue &other) const {
+    if (isInt63() && other.isInt63())
+      return eqInt63(other) ? _mlsValue::create<_mls_True>()
+                            : _mlsValue::create<_mls_False>();
+    assert(false);
+  }
+
+  _mlsValue operator+(const _mlsValue &other) const {
+    if (isInt63() && other.isInt63())
+      return addInt63(other);
+    assert(false);
+  }
+
+  _mlsValue operator-(const _mlsValue &other) const {
+    if (isInt63() && other.isInt63())
+      return subInt63(other);
+    assert(false);
+  }
+
+  _mlsValue operator*(const _mlsValue &other) const {
+    if (isInt63() && other.isInt63())
+      return mulInt63(other);
+    assert(false);
+  }
+
+  _mlsValue operator/(const _mlsValue &other) const {
+    if (isInt63() && other.isInt63())
+      return divInt63(other);
+    assert(false);
+  }
+
+  _mlsValue operator>(const _mlsValue &other) const {
+    if (isInt63() && other.isInt63())
+      return gtInt63(other);
+    assert(false);
+  }
+
+  _mlsValue operator<(const _mlsValue &other) const {
+    if (isInt63() && other.isInt63())
+      return ltInt63(other);
+    assert(false);
+  }
+
+  _mlsValue operator>=(const _mlsValue &other) const {
+    if (isInt63() && other.isInt63())
+      return geInt63(other);
+    assert(false);
+  }
+
+  _mlsValue operator<=(const _mlsValue &other) const {
+    if (isInt63() && other.isInt63())
+      return leInt63(other);
+    assert(false);
+  }
+
+  // Auxiliary functions
+
+  void print() const {
+    if (isInt63())
+      std::printf("%" PRIu64, asInt63());
+    else if (isPtr() && asObject())
+      asObject()->print();
+  }
+};
+
+struct _mls_Callable : public _mlsObject {
+  virtual _mlsValue _mls_apply0() { throw std::runtime_error("Not implemented"); }
+  virtual _mlsValue _mls_apply1(_mlsValue) {
+    throw std::runtime_error("Not implemented");
+  }
+  virtual _mlsValue _mls_apply2(_mlsValue, _mlsValue) {
+    throw std::runtime_error("Not implemented");
+  }
+  virtual _mlsValue _mls_apply3(_mlsValue, _mlsValue, _mlsValue) {
+    throw std::runtime_error("Not implemented");
+  }
+  virtual _mlsValue _mls_apply4(_mlsValue, _mlsValue, _mlsValue, _mlsValue) {
+    throw std::runtime_error("Not implemented");
+  }
+  virtual void destroy() override {}
+};
+
+inline static _mls_Callable *_mlsToCallable(_mlsValue fn) {
+  auto *ptr = _mlsValue::as<_mls_Callable>(fn);
+  if (!ptr)
+    throw std::runtime_error("Not a callable object");
+  return ptr;
+}
+
+template <typename... U>
+inline static _mlsValue _mlsCall(_mlsValue f, U... args) {
+  static_assert(sizeof...(U) <= 4, "Too many arguments");
+  if constexpr (sizeof...(U) == 0)
+    return _mlsToCallable(f)->_mls_apply0();
+  else if constexpr (sizeof...(U) == 1)
+    return _mlsToCallable(f)->_mls_apply1(args...);
+  else if constexpr (sizeof...(U) == 2)
+    return _mlsToCallable(f)->_mls_apply2(args...);
+  else if constexpr (sizeof...(U) == 3)
+    return _mlsToCallable(f)->_mls_apply3(args...);
+  else if constexpr (sizeof...(U) == 4)
+    return _mlsToCallable(f)->_mls_apply4(args...);
+}
+
+template <typename T>
+inline static T *_mlsMethodCall(_mlsValue self) {
+  auto *ptr = _mlsValue::as<T>(self);
+  if (!ptr)
+    throw std::runtime_error("unable to convert object for method calls");
+  return ptr;
+}
+
+inline int _mlsLargeStack(void *(*fn)(void *)) {
+  pthread_t thread;
+  pthread_attr_t attr;
+
+  size_t stacksize = 512 * 1024 * 1024;
+  pthread_attr_init(&attr);
+  pthread_attr_setstacksize(&attr, stacksize);
+
+  int rc = pthread_create(&thread, &attr, fn, nullptr);
+  if (rc) {
+    printf("ERROR: return code from pthread_create() is %d\n", rc);
+    return 1;
+  }
+  pthread_join(thread, NULL);
+  return 0;
+}
+
+_mlsValue _mlsMain();
+
+inline void *_mlsMainWrapper(void *) {
+  _mlsValue res = _mlsMain();
+  res.print();
+  return nullptr;
+}
+
+struct _mls_Unit final : public _mlsObject {
+  constexpr static inline const char *typeName = "Unit";
+  constexpr static inline uint32_t typeTag = nextTypeTag();
+  virtual void print() const override { std::printf(typeName); }
+  static _mlsValue create() {
+    static _mls_Unit mlsUnit alignas(_mlsAlignment);
+    mlsUnit.refCount = stickyRefCount;
+    mlsUnit.tag = typeTag;
+    return _mlsValue(&mlsUnit);
+  }
+  virtual void destroy() override {}
+};
+
+struct _mls_Boolean : public _mlsObject {};
+
+struct _mls_True final : public _mls_Boolean {
+  constexpr static inline const char *typeName = "True";
+  constexpr static inline uint32_t typeTag = nextTypeTag();
+  virtual void print() const override { std::printf(typeName); }
+  static _mlsValue create() {
+    static _mls_True mlsTrue alignas(_mlsAlignment);
+    mlsTrue.refCount = stickyRefCount;
+    mlsTrue.tag = typeTag;
+    return _mlsValue(&mlsTrue);
+  }
+  virtual void destroy() override {}
+};
+
+struct _mls_False final : public _mls_Boolean {
+  constexpr static inline const char *typeName = "False";
+  constexpr static inline uint32_t typeTag = nextTypeTag();
+  virtual void print() const override { std::printf(typeName); }
+  static _mlsValue create() {
+    static _mls_False mlsFalse alignas(_mlsAlignment);
+    mlsFalse.refCount = stickyRefCount;
+    mlsFalse.tag = typeTag;
+    return _mlsValue(&mlsFalse);
+  }
+  virtual void destroy() override {}
+};
+
+#include <boost/multiprecision/gmp.hpp>
+
+struct _mls_ZInt final : public _mlsObject {
+  boost::multiprecision::mpz_int z;
+  constexpr static inline const char *typeName = "Z";
+  constexpr static inline uint32_t typeTag = nextTypeTag();
+  virtual void print() const override {
+    std::printf(typeName);
+    std::printf("(");
+    std::printf("%s", z.str().c_str());
+    std::printf(")");
+  }
+  virtual void destroy() override {
+    z.~number();
+    operator delete(this, std::align_val_t(_mlsAlignment));
+  }
+  static _mlsValue create() {
+    auto _mlsVal = new (std::align_val_t(_mlsAlignment)) _mls_ZInt;
+    _mlsVal->refCount = 1;
+    _mlsVal->tag = typeTag;
+    return _mlsValue(_mlsVal);
+  }
+  static _mlsValue create(_mlsValue z) {
+    auto _mlsVal = new (std::align_val_t(_mlsAlignment)) _mls_ZInt;
+    _mlsVal->z = z.asInt();
+    _mlsVal->refCount = 1;
+    _mlsVal->tag = typeTag;
+    return _mlsValue(_mlsVal);
+  }
+  _mlsValue operator+(const _mls_ZInt &other) const {
+    auto _mlsVal = _mlsValue::create<_mls_ZInt>();
+    _mlsValue::cast<_mls_ZInt>(_mlsVal)->z = z + other.z;
+    return _mlsVal;
+  }
+
+  _mlsValue operator-(const _mls_ZInt &other) const {
+    auto _mlsVal = _mlsValue::create<_mls_ZInt>();
+    _mlsValue::cast<_mls_ZInt>(_mlsVal)->z = z - other.z;
+    return _mlsVal;
+  }
+
+  _mlsValue operator*(const _mls_ZInt &other) const {
+    auto _mlsVal = _mlsValue::create<_mls_ZInt>();
+    _mlsValue::cast<_mls_ZInt>(_mlsVal)->z = z * other.z;
+    return _mlsVal;
+  }
+
+  _mlsValue operator/(const _mls_ZInt &other) const {
+    auto _mlsVal = _mlsValue::create<_mls_ZInt>();
+    _mlsValue::cast<_mls_ZInt>(_mlsVal)->z = z / other.z;
+    return _mlsVal;
+  }
+
+  _mlsValue operator%(const _mls_ZInt &other) const {
+    auto _mlsVal = _mlsValue::create<_mls_ZInt>();
+    _mlsValue::cast<_mls_ZInt>(_mlsVal)->z = z % other.z;
+    return _mlsVal;
+  }
+
+  _mlsValue operator==(const _mls_ZInt &other) const {
+    return z == other.z ? _mlsValue::create<_mls_True>()
+                        : _mlsValue::create<_mls_False>();
+  }
+
+  _mlsValue operator>(const _mls_ZInt &other) const {
+    return z > other.z ? _mlsValue::create<_mls_True>()
+                       : _mlsValue::create<_mls_False>();
+  }
+
+  _mlsValue operator<(const _mls_ZInt &other) const {
+    return z < other.z ? _mlsValue::create<_mls_True>()
+                       : _mlsValue::create<_mls_False>();
+  }
+
+  _mlsValue operator>=(const _mls_ZInt &other) const {
+    return z >= other.z ? _mlsValue::create<_mls_True>()
+                        : _mlsValue::create<_mls_False>();
+  }
+
+  _mlsValue operator<=(const _mls_ZInt &other) const {
+    return z <= other.z ? _mlsValue::create<_mls_True>()
+                        : _mlsValue::create<_mls_False>();
+  }
+
+  _mlsValue toInt() const {
+    return _mlsValue::fromIntLit(z.convert_to<uint64_t>());
+  }
+
+  static _mlsValue fromInt(uint64_t i) {
+    return _mlsValue::create<_mls_ZInt>(_mlsValue::fromIntLit(i));
+  }
+};
+
+__attribute__((noinline)) inline void _mlsNonExhaustiveMatch() {
+  throw std::runtime_error("Non-exhaustive match");
+}
+
+inline _mlsValue _mls_builtin_z_add(_mlsValue a, _mlsValue b) {
+  assert(_mlsValue::isValueOf<_mls_ZInt>(a));
+  assert(_mlsValue::isValueOf<_mls_ZInt>(b));
+  return *_mlsValue::cast<_mls_ZInt>(a) + *_mlsValue::cast<_mls_ZInt>(b);
+}
+
+inline _mlsValue _mls_builtin_z_sub(_mlsValue a, _mlsValue b) {
+  assert(_mlsValue::isValueOf<_mls_ZInt>(a));
+  assert(_mlsValue::isValueOf<_mls_ZInt>(b));
+  return *_mlsValue::cast<_mls_ZInt>(a) - *_mlsValue::cast<_mls_ZInt>(b);
+}
+
+inline _mlsValue _mls_builtin_z_mul(_mlsValue a, _mlsValue b) {
+  assert(_mlsValue::isValueOf<_mls_ZInt>(a));
+  assert(_mlsValue::isValueOf<_mls_ZInt>(b));
+  return *_mlsValue::cast<_mls_ZInt>(a) * *_mlsValue::cast<_mls_ZInt>(b);
+}
+
+inline _mlsValue _mls_builtin_z_div(_mlsValue a, _mlsValue b) {
+  assert(_mlsValue::isValueOf<_mls_ZInt>(a));
+  assert(_mlsValue::isValueOf<_mls_ZInt>(b));
+  return *_mlsValue::cast<_mls_ZInt>(a) / *_mlsValue::cast<_mls_ZInt>(b);
+}
+
+inline _mlsValue _mls_builtin_z_mod(_mlsValue a, _mlsValue b) {
+  assert(_mlsValue::isValueOf<_mls_ZInt>(a));
+  assert(_mlsValue::isValueOf<_mls_ZInt>(b));
+  return *_mlsValue::cast<_mls_ZInt>(a) % *_mlsValue::cast<_mls_ZInt>(b);
+}
+
+inline _mlsValue _mls_builtin_z_equal(_mlsValue a, _mlsValue b) {
+  assert(_mlsValue::isValueOf<_mls_ZInt>(a));
+  assert(_mlsValue::isValueOf<_mls_ZInt>(b));
+  return *_mlsValue::cast<_mls_ZInt>(a) == *_mlsValue::cast<_mls_ZInt>(b);
+}
+
+inline _mlsValue _mls_builtin_z_gt(_mlsValue a, _mlsValue b) {
+  assert(_mlsValue::isValueOf<_mls_ZInt>(a));
+  assert(_mlsValue::isValueOf<_mls_ZInt>(b));
+  return *_mlsValue::cast<_mls_ZInt>(a) > *_mlsValue::cast<_mls_ZInt>(b);
+}
+
+inline _mlsValue _mls_builtin_z_lt(_mlsValue a, _mlsValue b) {
+  assert(_mlsValue::isValueOf<_mls_ZInt>(a));
+  assert(_mlsValue::isValueOf<_mls_ZInt>(b));
+  return *_mlsValue::cast<_mls_ZInt>(a) < *_mlsValue::cast<_mls_ZInt>(b);
+}
+
+inline _mlsValue _mls_builtin_z_geq(_mlsValue a, _mlsValue b) {
+  assert(_mlsValue::isValueOf<_mls_ZInt>(a));
+  assert(_mlsValue::isValueOf<_mls_ZInt>(b));
+  return *_mlsValue::cast<_mls_ZInt>(a) >= *_mlsValue::cast<_mls_ZInt>(b);
+}
+
+inline _mlsValue _mls_builtin_z_leq(_mlsValue a, _mlsValue b) {
+  assert(_mlsValue::isValueOf<_mls_ZInt>(a));
+  assert(_mlsValue::isValueOf<_mls_ZInt>(b));
+  return *_mlsValue::cast<_mls_ZInt>(a) <= *_mlsValue::cast<_mls_ZInt>(b);
+}
+
+inline _mlsValue _mls_builtin_z_to_int(_mlsValue a) {
+  assert(_mlsValue::isValueOf<_mls_ZInt>(a));
+  return _mlsValue::cast<_mls_ZInt>(a)->toInt();
+}
+
+inline _mlsValue _mls_builtin_z_of_int(_mlsValue a) {
+  assert(_mlsValue::isIntLit(a));
+  return _mlsValue::create<_mls_ZInt>(a);
+}
+
+inline _mlsValue _mls_builtin_print(_mlsValue a) {
+  a.print();
+  return _mlsValue::create<_mls_Unit>();
+}
+
+inline _mlsValue _mls_builtin_println(_mlsValue a) {
+  a.print();
+  std::puts("");
+  return _mlsValue::create<_mls_Unit>();
+}
+
+inline _mlsValue _mls_builtin_debug(_mlsValue a) {
+  a.print();
+  std::puts("");
+  return a;
+}
diff --git a/compiler/shared/test/diff-ir/gcd.mls b/compiler/shared/test/diff-ir/gcd.mls
new file mode 100644
index 0000000000..1a1c3b6cf5
--- /dev/null
+++ b/compiler/shared/test/diff-ir/gcd.mls
@@ -0,0 +1,823 @@
+:NewDefs
+:ParseOnly
+:UseIR
+:NoTailRec
+
+:prelude
+module True
+module False
+module Callable {
+  fun apply0() = 0
+  fun apply1(x0) = 0
+  fun apply2(x0,x1) = 0
+  fun apply3(x0,x1,x2) = 0
+  fun apply4(x0,x1,x2,x3) = 0
+  fun apply5(x0,x1,x2,x3,x4) = 0
+}
+module List[A, B]
+class Cons[A, B](h: A, t: Cons[A, B]) extends List[A, B]
+module Nil[A, B] extends List[A, B]
+module Option[A]
+class Some[A](x: A) extends Option[A]
+module None[A] extends Option[A]
+class Pair[A, B](x: A, y: B)
+class Tuple2[A, B](x: A, y: B)
+class Tuple3[A, B, C](x: A, y: B, z: C)
+module Nat
+class S(s: Nat) extends Nat
+module O extends Nat
+class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O)
+//│ |#module| |True|↵|#module| |False|↵|#module| |Callable| |{|→|#fun| |apply0|(||)| |#=| |0|↵|#fun| |apply1|(|x0|)| |#=| |0|↵|#fun| |apply2|(|x0|,|x1|)| |#=| |0|↵|#fun| |apply3|(|x0|,|x1|,|x2|)| |#=| |0|↵|#fun| |apply4|(|x0|,|x1|,|x2|,|x3|)| |#=| |0|↵|#fun| |apply5|(|x0|,|x1|,|x2|,|x3|,|x4|)| |#=| |0|←|↵|}|↵|#module| |List|[|A|,| |B|]|↵|#class| |Cons|[|A|,| |B|]|(|h|#:| |A|,| |t|#:| |Cons|[|A|,| |B|]|)| |#extends| |List|[|A|,| |B|]|↵|#module| |Nil|[|A|,| |B|]| |#extends| |List|[|A|,| |B|]|↵|#module| |Option|[|A|]|↵|#class| |Some|[|A|]|(|x|#:| |A|)| |#extends| |Option|[|A|]|↵|#module| |None|[|A|]| |#extends| |Option|[|A|]|↵|#class| |Pair|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple2|[|A|,| |B|]|(|x|#:| |A|,| |y|#:| |B|)|↵|#class| |Tuple3|[|A|,| |B|,| |C|]|(|x|#:| |A|,| |y|#:| |B|,| |z|#:| |C|)|↵|#module| |Nat|↵|#class| |S|(|s|#:| |Nat|)| |#extends| |Nat|↵|#module| |O| |#extends| |Nat|↵|#class| |HiddenTheseEntities|(|_0|#:| |HiddenTheseEntities|,| |_1|#:| |True|,| |_2|#:| |False|,| |_3|#:| |Callable|,| |_4|#:| |List|,| |_5|#:| |Cons|,| |_6|#:| |Nil|,| |_7|#:| |Option|,| |_8|#:| |Some|,| |_9|#:| |None|,| |_10|#:| |Pair|,| |_11|#:| |Tuple2|,| |_12|#:| |Tuple3|,| |_13|#:| |Nat|,| |_14|#:| |S|,| |_15|#:| |O|)|
+//│ Parsed: {module True {}; module False {}; module Callable {fun apply0 = () => 0; fun apply1 = (x0,) => 0; fun apply2 = (x0, x1,) => 0; fun apply3 = (x0, x1, x2,) => 0; fun apply4 = (x0, x1, x2, x3,) => 0; fun apply5 = (x0, x1, x2, x3, x4,) => 0}; module List‹A, B› {}; class Cons‹A, B›(h: A, t: Cons‹A, B›,): List‹A, B› {}; module Nil‹A, B›: List‹A, B› {}; module Option‹A› {}; class Some‹A›(x: A,): Option‹A› {}; module None‹A›: Option‹A› {}; class Pair‹A, B›(x: A, y: B,) {}; class Tuple2‹A, B›(x: A, y: B,) {}; class Tuple3‹A, B, C›(x: A, y: B, z: C,) {}; module Nat {}; class S(s: Nat,): Nat {}; module O: Nat {}; class HiddenTheseEntities(_0: HiddenTheseEntities, _1: True, _2: False, _3: Callable, _4: List, _5: Cons, _6: Nil, _7: Option, _8: Some, _9: None, _10: Pair, _11: Tuple2, _12: Tuple3, _13: Nat, _14: S, _15: O,) {}}
+//│ 
+//│ Preluded.
+//│ 
+
+:genCpp
+:runCpp
+fun error() = builtin("error")
+fun z_of_int(x) = builtin("z_of_int", x)
+fun z_to_int(x) = builtin("z_to_int", x)
+fun z_add(x, y) = builtin("z_add", x, y)
+fun z_sub(x, y) = builtin("z_sub", x, y)
+fun z_div(x, y) = builtin("z_div", x, y)
+fun z_mul(x, y) = builtin("z_mul", x, y)
+fun z_mod(x, y) = builtin("z_mod", x, y)
+fun z_lt(x, y) = builtin("z_lt", x, y)
+fun z_leq(x, y) = builtin("z_leq", x, y)
+fun z_equal(x, y) = builtin("z_equal", x, y)
+fun z_gt(x, y) = builtin("z_gt", x, y)
+fun z_geq(x, y) = builtin("z_geq", x, y)
+fun println(x) = builtin("println", x)
+fun print(x) = builtin("print", x)
+fun debug(x) = builtin("debug", x)
+fun map(f, ls) =
+  if ls is
+    Cons (h, t) then
+      Cons (f(h), map(f, t))
+    Nil then
+      Nil
+fun filter(f_2, ls_2) =
+  if ls_2 is
+    Cons (h_2, t_2) then
+      if f_2(h_2) then
+        Cons (h_2, filter(f_2, t_2))
+      else
+        (filter(f_2, t_2))
+    Nil then
+      Nil
+fun foldl(f_4, i, ls_4) =
+  if ls_4 is
+    Cons (h_4, t_4) then
+      foldl(f_4, f_4(i, h_4), t_4)
+    Nil then
+      i
+fun foldr(f_5, i_1, ls_5) =
+  if ls_5 is
+    Cons (h_5, t_5) then
+      f_5(h_5, foldr(f_5, i_1, t_5))
+    Nil then
+      i_1
+fun zip(xs, ys) =
+  if xs is
+    Cons (hx, tx) then
+      if ys is
+        Cons (hy, ty) then
+          Cons (Tuple2 (hx, hy), zip(tx, ty))
+        Nil then
+          Nil
+    Nil then
+      Nil
+fun zipWith(f_7, xs_4, ys_4) =
+  if xs_4 is
+    Cons (hx_4, tx_4) then
+      if ys_4 is
+        Cons (hy_4, ty_4) then
+          Cons (f_7(hx_4, hy_4), zipWith(f_7, tx_4, ty_4))
+        Nil then
+          Nil
+    Nil then
+      Nil
+fun head(ls_7) =
+  if ls_7 is
+    Cons (h_7, t_7) then
+      h_7
+    Nil then
+      error
+fun tail(ls_9) =
+  if ls_9 is
+    Cons (h_9, t_9) then
+      t_9
+    Nil then
+      error
+fun enumFromTo(a, b) =
+  if a <= b then
+    Cons (a, enumFromTo(a + 1, b))
+  else
+    (Nil)
+fun enumFromThenTo(a_1, t_11, b_1) =
+  if a_1 <= b_1 then
+    Cons (a_1, enumFromThenTo(t_11, 2 * t_11 - a_1, b_1))
+  else
+    (Nil)
+fun take(n, ls_11) =
+  if n > 0 then
+    if ls_11 is
+      Cons (h_11, t_13) then
+        Cons (h_11, take(n - 1, t_13))
+      Nil then
+        Nil
+  else
+    (Nil)
+fun length(ls_13) =
+  if ls_13 is
+    Cons (h_13, t_15) then
+      1 + (length(t_15))
+    Nil then
+      0
+fun mappend(xs_8, ys_8) =
+  if xs_8 is
+    Cons (h_14, t_16) then
+      Cons (h_14, mappend(t_16, ys_8))
+    Nil then
+      ys_8
+fun sum(ls_14) =
+  sumAux(ls_14, 0)
+fun sumAux(ls_15, a_4) =
+  if ls_15 is
+    Nil then
+      a_4
+    Cons (h_15, t_17) then
+      sumAux(t_17, a_4 + h_15)
+fun atIndex(n_2, ls_16) =
+  if n_2 < 0 then
+    error
+  else
+    if ls_16 is
+      Cons (h_16, t_18) then
+        if n_2 == 0 then
+          h_16
+        else
+          (atIndex(n_2 - 1, t_18))
+      Nil then
+        error
+fun concat(lss) =
+  if lss is
+    Cons (h_18, t_20) then
+      mappend(h_18, concat(t_20))
+    Nil then
+      Nil
+fun reverse(ls_18) =
+  reverse_helper(ls_18, Nil)
+fun reverse_helper(ls_19, a_5) =
+  if ls_19 is
+    Cons (h_19, t_21) then
+      reverse_helper(t_21, Cons (h_19, a_5))
+    Nil then
+      a_5
+fun listcomp_fun1(ms, listcomp_fun_para) =
+  if listcomp_fun_para is
+      Cons(listcomp_fun_ls_h, listcomp_fun_ls_t) then
+        listcomp_fun2(ms, listcomp_fun_ls_h, listcomp_fun_ls_t, ms)
+      Nil then
+        Nil
+fun listcomp_fun2(ms, listcomp_fun_ls_h_out, listcomp_fun_ls_t_out, listcomp_fun_para) =
+  if listcomp_fun_para is
+    Cons(listcomp_fun_ls_h, listcomp_fun_ls_t) then
+      Cons(Tuple2 (listcomp_fun_ls_h_out, listcomp_fun_ls_h), listcomp_fun2(ms, listcomp_fun_ls_h_out, listcomp_fun_ls_t_out, listcomp_fun_ls_t))
+    Nil then
+      listcomp_fun1(ms, listcomp_fun_ls_t_out)
+fun test(test_arg1) =
+  let ns = z_enumFromTo(const5000(), z_add(const5000(), test_arg1))
+  let ms = z_enumFromTo(const10000(), z_add(const10000(), test_arg1))
+  let tripls = map(f1, listcomp_fun1(ms, ns))
+  let rs = map(f2, tripls)
+  max'(rs)
+fun const10000() =
+  z_of_int(10000)
+fun f1(f1_arg1) =
+  if f1_arg1 is
+    Tuple2 (f1_Tuple2_0, f1_Tuple2_1) then
+      Tuple3 (f1_Tuple2_0, f1_Tuple2_1, gcdE(f1_Tuple2_0, f1_Tuple2_1))
+fun quotRem(quotRem_arg1, quotRem_arg2) =
+  Tuple2 (z_div(quotRem_arg1, quotRem_arg2), z_mod(quotRem_arg1, quotRem_arg2))
+fun max'(max'_arg1) =
+  if max'_arg1 is
+    Cons (max'_Cons_0, max'_Cons_1) then
+      if max'_Cons_1 is
+        Nil then
+          max'_Cons_0
+        Cons (max'_Cons_0_1, max'_Cons_1_1) then
+          if z_lt(max'_Cons_0, max'_Cons_0_1) then
+            max'(Cons (max'_Cons_0_1, max'_Cons_1_1))
+          else
+            (max'(Cons (max'_Cons_0, max'_Cons_1_1)))
+fun g(g_arg1, g_arg2) =
+  if g_arg1 is
+    Tuple3 (g_Tuple3_0, g_Tuple3_1, g_Tuple3_2) then
+      if g_arg2 is
+        Tuple3 (g_Tuple3_0_1, g_Tuple3_1_1, g_Tuple3_2_1) then
+          if z_equal(g_Tuple3_2_1, const0()) then
+            Tuple3 (g_Tuple3_2, g_Tuple3_0, g_Tuple3_1)
+          else
+            let matchIdent = quotRem(g_Tuple3_2, g_Tuple3_2_1)
+            if matchIdent is
+              Tuple2 (g_Tuple2_0, g_Tuple2_1) then
+                g(Tuple3 (g_Tuple3_0_1, g_Tuple3_1_1, g_Tuple3_2_1), Tuple3 (z_sub(g_Tuple3_0, z_mul(g_Tuple2_0, g_Tuple3_0_1)), z_sub(g_Tuple3_1, z_mul(g_Tuple2_0, g_Tuple3_1_1)), g_Tuple2_1))
+fun abs(abs_arg1) =
+  if z_lt(abs_arg1, const0()) then
+    z_sub(const0(), abs_arg1)
+  else
+    abs_arg1
+fun f2(f2_arg1) =
+  if f2_arg1 is
+    Tuple3 (f2_Tuple3_0, f2_Tuple3_1, f2_Tuple3_2) then
+      if f2_Tuple3_2 is
+        Tuple3 (f2_Tuple3_0_1, f2_Tuple3_1_1, f2_Tuple3_2_1) then
+          abs(z_add(z_add(f2_Tuple3_0_1, f2_Tuple3_1_1), f2_Tuple3_2_1))
+fun const0() =
+  z_of_int(0)
+fun gcdE(gcdE_arg1, gcdE_arg2) =
+  if z_equal(gcdE_arg1, const0()) then
+    Tuple3 (gcdE_arg2, const0(), const1())
+  else
+    (g(Tuple3 (const1(), const0(), gcdE_arg1), Tuple3 (const0(), const1(), gcdE_arg2)))
+fun const1() =
+  z_of_int(1)
+fun const5000() =
+  z_of_int(5000)
+fun testGcd_nofib(testGcd_nofib_arg1) =
+  test(testGcd_nofib_arg1)
+fun z_enumFromTo(z_enumFromTo_arg1, z_enumFromTo_arg2) =
+  if z_leq(z_enumFromTo_arg1, z_enumFromTo_arg2) then
+    Cons (z_enumFromTo_arg1, z_enumFromTo(z_add(z_enumFromTo_arg1, const1()), z_enumFromTo_arg2))
+  else
+    (Nil)
+testGcd_nofib(z_of_int(400))
+//│ |#fun| |error|(||)| |#=| |builtin|(|"error"|)|↵|#fun| |z_of_int|(|x|)| |#=| |builtin|(|"z_of_int"|,| |x|)|↵|#fun| |z_to_int|(|x|)| |#=| |builtin|(|"z_to_int"|,| |x|)|↵|#fun| |z_add|(|x|,| |y|)| |#=| |builtin|(|"z_add"|,| |x|,| |y|)|↵|#fun| |z_sub|(|x|,| |y|)| |#=| |builtin|(|"z_sub"|,| |x|,| |y|)|↵|#fun| |z_div|(|x|,| |y|)| |#=| |builtin|(|"z_div"|,| |x|,| |y|)|↵|#fun| |z_mul|(|x|,| |y|)| |#=| |builtin|(|"z_mul"|,| |x|,| |y|)|↵|#fun| |z_mod|(|x|,| |y|)| |#=| |builtin|(|"z_mod"|,| |x|,| |y|)|↵|#fun| |z_lt|(|x|,| |y|)| |#=| |builtin|(|"z_lt"|,| |x|,| |y|)|↵|#fun| |z_leq|(|x|,| |y|)| |#=| |builtin|(|"z_leq"|,| |x|,| |y|)|↵|#fun| |z_equal|(|x|,| |y|)| |#=| |builtin|(|"z_equal"|,| |x|,| |y|)|↵|#fun| |z_gt|(|x|,| |y|)| |#=| |builtin|(|"z_gt"|,| |x|,| |y|)|↵|#fun| |z_geq|(|x|,| |y|)| |#=| |builtin|(|"z_geq"|,| |x|,| |y|)|↵|#fun| |println|(|x|)| |#=| |builtin|(|"println"|,| |x|)|↵|#fun| |print|(|x|)| |#=| |builtin|(|"print"|,| |x|)|↵|#fun| |debug|(|x|)| |#=| |builtin|(|"debug"|,| |x|)|↵|#fun| |map|(|f|,| |ls|)| |#=|→|#if| |ls| |is|→|Cons| |(|h|,| |t|)| |#then|→|Cons| |(|f|(|h|)|,| |map|(|f|,| |t|)|)|←|↵|Nil| |#then|→|Nil|←|←|←|↵|#fun| |filter|(|f_2|,| |ls_2|)| |#=|→|#if| |ls_2| |is|→|Cons| |(|h_2|,| |t_2|)| |#then|→|#if| |f_2|(|h_2|)| |#then|→|Cons| |(|h_2|,| |filter|(|f_2|,| |t_2|)|)|←|↵|#else|→|(|filter|(|f_2|,| |t_2|)|)|←|←|↵|Nil| |#then|→|Nil|←|←|←|↵|#fun| |foldl|(|f_4|,| |i|,| |ls_4|)| |#=|→|#if| |ls_4| |is|→|Cons| |(|h_4|,| |t_4|)| |#then|→|foldl|(|f_4|,| |f_4|(|i|,| |h_4|)|,| |t_4|)|←|↵|Nil| |#then|→|i|←|←|←|↵|#fun| |foldr|(|f_5|,| |i_1|,| |ls_5|)| |#=|→|#if| |ls_5| |is|→|Cons| |(|h_5|,| |t_5|)| |#then|→|f_5|(|h_5|,| |foldr|(|f_5|,| |i_1|,| |t_5|)|)|←|↵|Nil| |#then|→|i_1|←|←|←|↵|#fun| |zip|(|xs|,| |ys|)| |#=|→|#if| |xs| |is|→|Cons| |(|hx|,| |tx|)| |#then|→|#if| |ys| |is|→|Cons| |(|hy|,| |ty|)| |#then|→|Cons| |(|Tuple2| |(|hx|,| |hy|)|,| |zip|(|tx|,| |ty|)|)|←|↵|Nil| |#then|→|Nil|←|←|←|↵|Nil| |#then|→|Nil|←|←|←|↵|#fun| |zipWith|(|f_7|,| |xs_4|,| |ys_4|)| |#=|→|#if| |xs_4| |is|→|Cons| |(|hx_4|,| |tx_4|)| |#then|→|#if| |ys_4| |is|→|Cons| |(|hy_4|,| |ty_4|)| |#then|→|Cons| |(|f_7|(|hx_4|,| |hy_4|)|,| |zipWith|(|f_7|,| |tx_4|,| |ty_4|)|)|←|↵|Nil| |#then|→|Nil|←|←|←|↵|Nil| |#then|→|Nil|←|←|←|↵|#fun| |head|(|ls_7|)| |#=|→|#if| |ls_7| |is|→|Cons| |(|h_7|,| |t_7|)| |#then|→|h_7|←|↵|Nil| |#then|→|error|←|←|←|↵|#fun| |tail|(|ls_9|)| |#=|→|#if| |ls_9| |is|→|Cons| |(|h_9|,| |t_9|)| |#then|→|t_9|←|↵|Nil| |#then|→|error|←|←|←|↵|#fun| |enumFromTo|(|a|,| |b|)| |#=|→|#if| |a| |<=| |b| |#then|→|Cons| |(|a|,| |enumFromTo|(|a| |+| |1|,| |b|)|)|←|↵|#else|→|(|Nil|)|←|←|↵|#fun| |enumFromThenTo|(|a_1|,| |t_11|,| |b_1|)| |#=|→|#if| |a_1| |<=| |b_1| |#then|→|Cons| |(|a_1|,| |enumFromThenTo|(|t_11|,| |2| |*| |t_11| |-| |a_1|,| |b_1|)|)|←|↵|#else|→|(|Nil|)|←|←|↵|#fun| |take|(|n|,| |ls_11|)| |#=|→|#if| |n| |>| |0| |#then|→|#if| |ls_11| |is|→|Cons| |(|h_11|,| |t_13|)| |#then|→|Cons| |(|h_11|,| |take|(|n| |-| |1|,| |t_13|)|)|←|↵|Nil| |#then|→|Nil|←|←|←|↵|#else|→|(|Nil|)|←|←|↵|#fun| |length|(|ls_13|)| |#=|→|#if| |ls_13| |is|→|Cons| |(|h_13|,| |t_15|)| |#then|→|1| |+| |(|length|(|t_15|)|)|←|↵|Nil| |#then|→|0|←|←|←|↵|#fun| |mappend|(|xs_8|,| |ys_8|)| |#=|→|#if| |xs_8| |is|→|Cons| |(|h_14|,| |t_16|)| |#then|→|Cons| |(|h_14|,| |mappend|(|t_16|,| |ys_8|)|)|←|↵|Nil| |#then|→|ys_8|←|←|←|↵|#fun| |sum|(|ls_14|)| |#=|→|sumAux|(|ls_14|,| |0|)|←|↵|#fun| |sumAux|(|ls_15|,| |a_4|)| |#=|→|#if| |ls_15| |is|→|Nil| |#then|→|a_4|←|↵|Cons| |(|h_15|,| |t_17|)| |#then|→|sumAux|(|t_17|,| |a_4| |+| |h_15|)|←|←|←|↵|#fun| |atIndex|(|n_2|,| |ls_16|)| |#=|→|#if| |n_2| |<| |0| |#then|→|error|←|↵|#else|→|#if| |ls_16| |is|→|Cons| |(|h_16|,| |t_18|)| |#then|→|#if| |n_2| |==| |0| |#then|→|h_16|←|↵|#else|→|(|atIndex|(|n_2| |-| |1|,| |t_18|)|)|←|←|↵|Nil| |#then|→|error|←|←|←|←|↵|#fun| |concat|(|lss|)| |#=|→|#if| |lss| |is|→|Cons| |(|h_18|,| |t_20|)| |#then|→|mappend|(|h_18|,| |concat|(|t_20|)|)|←|↵|Nil| |#then|→|Nil|←|←|←|↵|#fun| |reverse|(|ls_18|)| |#=|→|reverse_helper|(|ls_18|,| |Nil|)|←|↵|#fun| |reverse_helper|(|ls_19|,| |a_5|)| |#=|→|#if| |ls_19| |is|→|Cons| |(|h_19|,| |t_21|)| |#then|→|reverse_helper|(|t_21|,| |Cons| |(|h_19|,| |a_5|)|)|←|↵|Nil| |#then|→|a_5|←|←|←|↵|#fun| |listcomp_fun1|(|ms|,| |listcomp_fun_para|)| |#=|→|#if| |listcomp_fun_para| |is|→|Cons|(|listcomp_fun_ls_h|,| |listcomp_fun_ls_t|)| |#then|→|listcomp_fun2|(|ms|,| |listcomp_fun_ls_h|,| |listcomp_fun_ls_t|,| |ms|)|←|↵|Nil| |#then|→|Nil|←|←|←|↵|#fun| |listcomp_fun2|(|ms|,| |listcomp_fun_ls_h_out|,| |listcomp_fun_ls_t_out|,| |listcomp_fun_para|)| |#=|→|#if| |listcomp_fun_para| |is|→|Cons|(|listcomp_fun_ls_h|,| |listcomp_fun_ls_t|)| |#then|→|Cons|(|Tuple2| |(|listcomp_fun_ls_h_out|,| |listcomp_fun_ls_h|)|,| |listcomp_fun2|(|ms|,| |listcomp_fun_ls_h_out|,| |listcomp_fun_ls_t_out|,| |listcomp_fun_ls_t|)|)|←|↵|Nil| |#then|→|listcomp_fun1|(|ms|,| |listcomp_fun_ls_t_out|)|←|←|←|↵|#fun| |test|(|test_arg1|)| |#=|→|#let| |ns| |#=| |z_enumFromTo|(|const5000|(||)|,| |z_add|(|const5000|(||)|,| |test_arg1|)|)|↵|#let| |ms| |#=| |z_enumFromTo|(|const10000|(||)|,| |z_add|(|const10000|(||)|,| |test_arg1|)|)|↵|#let| |tripls| |#=| |map|(|f1|,| |listcomp_fun1|(|ms|,| |ns|)|)|↵|#let| |rs| |#=| |map|(|f2|,| |tripls|)|↵|max'|(|rs|)|←|↵|#fun| |const10000|(||)| |#=|→|z_of_int|(|10000|)|←|↵|#fun| |f1|(|f1_arg1|)| |#=|→|#if| |f1_arg1| |is|→|Tuple2| |(|f1_Tuple2_0|,| |f1_Tuple2_1|)| |#then|→|Tuple3| |(|f1_Tuple2_0|,| |f1_Tuple2_1|,| |gcdE|(|f1_Tuple2_0|,| |f1_Tuple2_1|)|)|←|←|←|↵|#fun| |quotRem|(|quotRem_arg1|,| |quotRem_arg2|)| |#=|→|Tuple2| |(|z_div|(|quotRem_arg1|,| |quotRem_arg2|)|,| |z_mod|(|quotRem_arg1|,| |quotRem_arg2|)|)|←|↵|#fun| |max'|(|max'_arg1|)| |#=|→|#if| |max'_arg1| |is|→|Cons| |(|max'_Cons_0|,| |max'_Cons_1|)| |#then|→|#if| |max'_Cons_1| |is|→|Nil| |#then|→|max'_Cons_0|←|↵|Cons| |(|max'_Cons_0_1|,| |max'_Cons_1_1|)| |#then|→|#if| |z_lt|(|max'_Cons_0|,| |max'_Cons_0_1|)| |#then|→|max'|(|Cons| |(|max'_Cons_0_1|,| |max'_Cons_1_1|)|)|←|↵|#else|→|(|max'|(|Cons| |(|max'_Cons_0|,| |max'_Cons_1_1|)|)|)|←|←|←|←|←|←|↵|#fun| |g|(|g_arg1|,| |g_arg2|)| |#=|→|#if| |g_arg1| |is|→|Tuple3| |(|g_Tuple3_0|,| |g_Tuple3_1|,| |g_Tuple3_2|)| |#then|→|#if| |g_arg2| |is|→|Tuple3| |(|g_Tuple3_0_1|,| |g_Tuple3_1_1|,| |g_Tuple3_2_1|)| |#then|→|#if| |z_equal|(|g_Tuple3_2_1|,| |const0|(||)|)| |#then|→|Tuple3| |(|g_Tuple3_2|,| |g_Tuple3_0|,| |g_Tuple3_1|)|←|↵|#else|→|#let| |matchIdent| |#=| |quotRem|(|g_Tuple3_2|,| |g_Tuple3_2_1|)|↵|#if| |matchIdent| |is|→|Tuple2| |(|g_Tuple2_0|,| |g_Tuple2_1|)| |#then|→|g|(|Tuple3| |(|g_Tuple3_0_1|,| |g_Tuple3_1_1|,| |g_Tuple3_2_1|)|,| |Tuple3| |(|z_sub|(|g_Tuple3_0|,| |z_mul|(|g_Tuple2_0|,| |g_Tuple3_0_1|)|)|,| |z_sub|(|g_Tuple3_1|,| |z_mul|(|g_Tuple2_0|,| |g_Tuple3_1_1|)|)|,| |g_Tuple2_1|)|)|←|←|←|←|←|←|←|←|↵|#fun| |abs|(|abs_arg1|)| |#=|→|#if| |z_lt|(|abs_arg1|,| |const0|(||)|)| |#then|→|z_sub|(|const0|(||)|,| |abs_arg1|)|←|↵|#else|→|abs_arg1|←|←|↵|#fun| |f2|(|f2_arg1|)| |#=|→|#if| |f2_arg1| |is|→|Tuple3| |(|f2_Tuple3_0|,| |f2_Tuple3_1|,| |f2_Tuple3_2|)| |#then|→|#if| |f2_Tuple3_2| |is|→|Tuple3| |(|f2_Tuple3_0_1|,| |f2_Tuple3_1_1|,| |f2_Tuple3_2_1|)| |#then|→|abs|(|z_add|(|z_add|(|f2_Tuple3_0_1|,| |f2_Tuple3_1_1|)|,| |f2_Tuple3_2_1|)|)|←|←|←|←|←|↵|#fun| |const0|(||)| |#=|→|z_of_int|(|0|)|←|↵|#fun| |gcdE|(|gcdE_arg1|,| |gcdE_arg2|)| |#=|→|#if| |z_equal|(|gcdE_arg1|,| |const0|(||)|)| |#then|→|Tuple3| |(|gcdE_arg2|,| |const0|(||)|,| |const1|(||)|)|←|↵|#else|→|(|g|(|Tuple3| |(|const1|(||)|,| |const0|(||)|,| |gcdE_arg1|)|,| |Tuple3| |(|const0|(||)|,| |const1|(||)|,| |gcdE_arg2|)|)|)|←|←|↵|#fun| |const1|(||)| |#=|→|z_of_int|(|1|)|←|↵|#fun| |const5000|(||)| |#=|→|z_of_int|(|5000|)|←|↵|#fun| |testGcd_nofib|(|testGcd_nofib_arg1|)| |#=|→|test|(|testGcd_nofib_arg1|)|←|↵|#fun| |z_enumFromTo|(|z_enumFromTo_arg1|,| |z_enumFromTo_arg2|)| |#=|→|#if| |z_leq|(|z_enumFromTo_arg1|,| |z_enumFromTo_arg2|)| |#then|→|Cons| |(|z_enumFromTo_arg1|,| |z_enumFromTo|(|z_add|(|z_enumFromTo_arg1|,| |const1|(||)|)|,| |z_enumFromTo_arg2|)|)|←|↵|#else|→|(|Nil|)|←|←|↵|testGcd_nofib|(|z_of_int|(|400|)|)|
+//│ Parsed: {fun error = () => builtin("error",); fun z_of_int = (x,) => builtin("z_of_int", x,); fun z_to_int = (x,) => builtin("z_to_int", x,); fun z_add = (x, y,) => builtin("z_add", x, y,); fun z_sub = (x, y,) => builtin("z_sub", x, y,); fun z_div = (x, y,) => builtin("z_div", x, y,); fun z_mul = (x, y,) => builtin("z_mul", x, y,); fun z_mod = (x, y,) => builtin("z_mod", x, y,); fun z_lt = (x, y,) => builtin("z_lt", x, y,); fun z_leq = (x, y,) => builtin("z_leq", x, y,); fun z_equal = (x, y,) => builtin("z_equal", x, y,); fun z_gt = (x, y,) => builtin("z_gt", x, y,); fun z_geq = (x, y,) => builtin("z_geq", x, y,); fun println = (x,) => builtin("println", x,); fun print = (x,) => builtin("print", x,); fun debug = (x,) => builtin("debug", x,); fun map = (f, ls,) => {if ls is ‹(Cons(h, t,)) then {Cons(f(h,), map(f, t,),)}; (Nil) then {Nil}›}; fun filter = (f_2, ls_2,) => {if ls_2 is ‹(Cons(h_2, t_2,)) then {if (f_2(h_2,)) then {Cons(h_2, filter(f_2, t_2,),)} else {'(' filter(f_2, t_2,) ')'}}; (Nil) then {Nil}›}; fun foldl = (f_4, i, ls_4,) => {if ls_4 is ‹(Cons(h_4, t_4,)) then {foldl(f_4, f_4(i, h_4,), t_4,)}; (Nil) then {i}›}; fun foldr = (f_5, i_1, ls_5,) => {if ls_5 is ‹(Cons(h_5, t_5,)) then {f_5(h_5, foldr(f_5, i_1, t_5,),)}; (Nil) then {i_1}›}; fun zip = (xs, ys,) => {if xs is ‹(Cons(hx, tx,)) then {if ys is ‹(Cons(hy, ty,)) then {Cons(Tuple2(hx, hy,), zip(tx, ty,),)}; (Nil) then {Nil}›}; (Nil) then {Nil}›}; fun zipWith = (f_7, xs_4, ys_4,) => {if xs_4 is ‹(Cons(hx_4, tx_4,)) then {if ys_4 is ‹(Cons(hy_4, ty_4,)) then {Cons(f_7(hx_4, hy_4,), zipWith(f_7, tx_4, ty_4,),)}; (Nil) then {Nil}›}; (Nil) then {Nil}›}; fun head = (ls_7,) => {if ls_7 is ‹(Cons(h_7, t_7,)) then {h_7}; (Nil) then {error}›}; fun tail = (ls_9,) => {if ls_9 is ‹(Cons(h_9, t_9,)) then {t_9}; (Nil) then {error}›}; fun enumFromTo = (a, b,) => {if (<=(a, b,)) then {Cons(a, enumFromTo(+(a, 1,), b,),)} else {'(' Nil ')'}}; fun enumFromThenTo = (a_1, t_11, b_1,) => {if (<=(a_1, b_1,)) then {Cons(a_1, enumFromThenTo(t_11, -(*(2, t_11,), a_1,), b_1,),)} else {'(' Nil ')'}}; fun take = (n, ls_11,) => {if (>(n, 0,)) then {if ls_11 is ‹(Cons(h_11, t_13,)) then {Cons(h_11, take(-(n, 1,), t_13,),)}; (Nil) then {Nil}›} else {'(' Nil ')'}}; fun length = (ls_13,) => {if ls_13 is ‹(Cons(h_13, t_15,)) then {+(1, '(' length(t_15,) ')',)}; (Nil) then {0}›}; fun mappend = (xs_8, ys_8,) => {if xs_8 is ‹(Cons(h_14, t_16,)) then {Cons(h_14, mappend(t_16, ys_8,),)}; (Nil) then {ys_8}›}; fun sum = (ls_14,) => {sumAux(ls_14, 0,)}; fun sumAux = (ls_15, a_4,) => {if ls_15 is ‹(Nil) then {a_4}; (Cons(h_15, t_17,)) then {sumAux(t_17, +(a_4, h_15,),)}›}; fun atIndex = (n_2, ls_16,) => {if (<(n_2, 0,)) then {error} else {if ls_16 is ‹(Cons(h_16, t_18,)) then {if (==(n_2, 0,)) then {h_16} else {'(' atIndex(-(n_2, 1,), t_18,) ')'}}; (Nil) then {error}›}}; fun concat = (lss,) => {if lss is ‹(Cons(h_18, t_20,)) then {mappend(h_18, concat(t_20,),)}; (Nil) then {Nil}›}; fun reverse = (ls_18,) => {reverse_helper(ls_18, Nil,)}; fun reverse_helper = (ls_19, a_5,) => {if ls_19 is ‹(Cons(h_19, t_21,)) then {reverse_helper(t_21, Cons(h_19, a_5,),)}; (Nil) then {a_5}›}; fun listcomp_fun1 = (ms, listcomp_fun_para,) => {if listcomp_fun_para is ‹(Cons(listcomp_fun_ls_h, listcomp_fun_ls_t,)) then {listcomp_fun2(ms, listcomp_fun_ls_h, listcomp_fun_ls_t, ms,)}; (Nil) then {Nil}›}; fun listcomp_fun2 = (ms, listcomp_fun_ls_h_out, listcomp_fun_ls_t_out, listcomp_fun_para,) => {if listcomp_fun_para is ‹(Cons(listcomp_fun_ls_h, listcomp_fun_ls_t,)) then {Cons(Tuple2(listcomp_fun_ls_h_out, listcomp_fun_ls_h,), listcomp_fun2(ms, listcomp_fun_ls_h_out, listcomp_fun_ls_t_out, listcomp_fun_ls_t,),)}; (Nil) then {listcomp_fun1(ms, listcomp_fun_ls_t_out,)}›}; fun test = (test_arg1,) => {let ns = z_enumFromTo(const5000(), z_add(const5000(), test_arg1,),); let ms = z_enumFromTo(const10000(), z_add(const10000(), test_arg1,),); let tripls = map(f1, listcomp_fun1(ms, ns,),); let rs = map(f2, tripls,); max'(rs,)}; fun const10000 = () => {z_of_int(10000,)}; fun f1 = (f1_arg1,) => {if f1_arg1 is ‹(Tuple2(f1_Tuple2_0, f1_Tuple2_1,)) then {Tuple3(f1_Tuple2_0, f1_Tuple2_1, gcdE(f1_Tuple2_0, f1_Tuple2_1,),)}›}; fun quotRem = (quotRem_arg1, quotRem_arg2,) => {Tuple2(z_div(quotRem_arg1, quotRem_arg2,), z_mod(quotRem_arg1, quotRem_arg2,),)}; fun max' = (max'_arg1,) => {if max'_arg1 is ‹(Cons(max'_Cons_0, max'_Cons_1,)) then {if max'_Cons_1 is ‹(Nil) then {max'_Cons_0}; (Cons(max'_Cons_0_1, max'_Cons_1_1,)) then {if (z_lt(max'_Cons_0, max'_Cons_0_1,)) then {max'(Cons(max'_Cons_0_1, max'_Cons_1_1,),)} else {'(' max'(Cons(max'_Cons_0, max'_Cons_1_1,),) ')'}}›}›}; fun g = (g_arg1, g_arg2,) => {if g_arg1 is ‹(Tuple3(g_Tuple3_0, g_Tuple3_1, g_Tuple3_2,)) then {if g_arg2 is ‹(Tuple3(g_Tuple3_0_1, g_Tuple3_1_1, g_Tuple3_2_1,)) then {if (z_equal(g_Tuple3_2_1, const0(),)) then {Tuple3(g_Tuple3_2, g_Tuple3_0, g_Tuple3_1,)} else {let matchIdent = quotRem(g_Tuple3_2, g_Tuple3_2_1,); if matchIdent is ‹(Tuple2(g_Tuple2_0, g_Tuple2_1,)) then {g(Tuple3(g_Tuple3_0_1, g_Tuple3_1_1, g_Tuple3_2_1,), Tuple3(z_sub(g_Tuple3_0, z_mul(g_Tuple2_0, g_Tuple3_0_1,),), z_sub(g_Tuple3_1, z_mul(g_Tuple2_0, g_Tuple3_1_1,),), g_Tuple2_1,),)}›}}›}›}; fun abs = (abs_arg1,) => {if (z_lt(abs_arg1, const0(),)) then {z_sub(const0(), abs_arg1,)} else {abs_arg1}}; fun f2 = (f2_arg1,) => {if f2_arg1 is ‹(Tuple3(f2_Tuple3_0, f2_Tuple3_1, f2_Tuple3_2,)) then {if f2_Tuple3_2 is ‹(Tuple3(f2_Tuple3_0_1, f2_Tuple3_1_1, f2_Tuple3_2_1,)) then {abs(z_add(z_add(f2_Tuple3_0_1, f2_Tuple3_1_1,), f2_Tuple3_2_1,),)}›}›}; fun const0 = () => {z_of_int(0,)}; fun gcdE = (gcdE_arg1, gcdE_arg2,) => {if (z_equal(gcdE_arg1, const0(),)) then {Tuple3(gcdE_arg2, const0(), const1(),)} else {'(' g(Tuple3(const1(), const0(), gcdE_arg1,), Tuple3(const0(), const1(), gcdE_arg2,),) ')'}}; fun const1 = () => {z_of_int(1,)}; fun const5000 = () => {z_of_int(5000,)}; fun testGcd_nofib = (testGcd_nofib_arg1,) => {test(testGcd_nofib_arg1,)}; fun z_enumFromTo = (z_enumFromTo_arg1, z_enumFromTo_arg2,) => {if (z_leq(z_enumFromTo_arg1, z_enumFromTo_arg2,)) then {Cons(z_enumFromTo_arg1, z_enumFromTo(z_add(z_enumFromTo_arg1, const1(),), z_enumFromTo_arg2,),)} else {'(' Nil ')'}}; testGcd_nofib(z_of_int(400,),)}
+//│ 
+//│ 
+//│ IR:
+//│ Program:
+//│   class Lambda$0() extends Callable {
+//│     def apply0() =
+//│       let* (x$270) = error() in -- #1354
+//│       x$270 -- #1353
+//│   }
+//│   class Lambda$1() extends Callable {
+//│     def apply0() =
+//│       let* (x$271) = error() in -- #1357
+//│       x$271 -- #1356
+//│   }
+//│   class Lambda$2() extends Callable {
+//│     def apply0() =
+//│       let* (x$272) = error() in -- #1360
+//│       x$272 -- #1359
+//│   }
+//│   class Lambda$3() extends Callable {
+//│     def apply0() =
+//│       let* (x$273) = error() in -- #1363
+//│       x$273 -- #1362
+//│   }
+//│   class Lambda$4() extends Callable {
+//│     def apply1(x$274) =
+//│       let* (x$275) = f1(x$274) in -- #1368
+//│       x$275 -- #1367
+//│   }
+//│   class Lambda$5() extends Callable {
+//│     def apply1(x$276) =
+//│       let* (x$277) = f2(x$276) in -- #1373
+//│       x$277 -- #1372
+//│   }
+//│   def error() =
+//│     let x$2 = Callable.apply1(builtin,error) in -- #14
+//│     x$2 -- #13
+//│   def z_of_int(x$3) =
+//│     let x$4 = Callable.apply2(builtin,z_of_int,x$3) in -- #22
+//│     x$4 -- #21
+//│   def z_to_int(x$5) =
+//│     let x$6 = Callable.apply2(builtin,z_to_int,x$5) in -- #30
+//│     x$6 -- #29
+//│   def z_add(x$7,y$0) =
+//│     let x$8 = Callable.apply3(builtin,z_add,x$7,y$0) in -- #40
+//│     x$8 -- #39
+//│   def z_sub(x$9,y$1) =
+//│     let x$10 = Callable.apply3(builtin,z_sub,x$9,y$1) in -- #50
+//│     x$10 -- #49
+//│   def z_div(x$11,y$2) =
+//│     let x$12 = Callable.apply3(builtin,z_div,x$11,y$2) in -- #60
+//│     x$12 -- #59
+//│   def z_mul(x$13,y$3) =
+//│     let x$14 = Callable.apply3(builtin,z_mul,x$13,y$3) in -- #70
+//│     x$14 -- #69
+//│   def z_mod(x$15,y$4) =
+//│     let x$16 = Callable.apply3(builtin,z_mod,x$15,y$4) in -- #80
+//│     x$16 -- #79
+//│   def z_lt(x$17,y$5) =
+//│     let x$18 = Callable.apply3(builtin,z_lt,x$17,y$5) in -- #90
+//│     x$18 -- #89
+//│   def z_leq(x$19,y$6) =
+//│     let x$20 = Callable.apply3(builtin,z_leq,x$19,y$6) in -- #100
+//│     x$20 -- #99
+//│   def z_equal(x$21,y$7) =
+//│     let x$22 = Callable.apply3(builtin,z_equal,x$21,y$7) in -- #110
+//│     x$22 -- #109
+//│   def z_gt(x$23,y$8) =
+//│     let x$24 = Callable.apply3(builtin,z_gt,x$23,y$8) in -- #120
+//│     x$24 -- #119
+//│   def z_geq(x$25,y$9) =
+//│     let x$26 = Callable.apply3(builtin,z_geq,x$25,y$9) in -- #130
+//│     x$26 -- #129
+//│   def println(x$27) =
+//│     let x$28 = Callable.apply2(builtin,println,x$27) in -- #138
+//│     x$28 -- #137
+//│   def print(x$29) =
+//│     let x$30 = Callable.apply2(builtin,print,x$29) in -- #146
+//│     x$30 -- #145
+//│   def debug(x$31) =
+//│     let x$32 = Callable.apply2(builtin,debug,x$31) in -- #154
+//│     x$32 -- #153
+//│   def map(f$0,ls$0) =
+//│     case ls$0 of -- #189
+//│       Cons =>
+//│         let x$34 = Cons.t(ls$0) in -- #185
+//│         let x$35 = Cons.h(ls$0) in -- #184
+//│         let x$36 = Callable.apply1(f$0,x$35) in -- #183
+//│         let* (x$37) = map(f$0,x$34) in -- #182
+//│         let x$38 = Cons(x$36,x$37) in -- #181
+//│         jump j$0(x$38) -- #180
+//│       Nil =>
+//│         let x$39 = Nil() in -- #188
+//│         jump j$0(x$39) -- #187
+//│   def j$0(x$33) =
+//│     x$33 -- #156
+//│   def filter(f_2$0,ls_2$0) =
+//│     case ls_2$0 of -- #236
+//│       Cons =>
+//│         let x$41 = Cons.t(ls_2$0) in -- #232
+//│         let x$42 = Cons.h(ls_2$0) in -- #231
+//│         let x$43 = Callable.apply1(f_2$0,x$42) in -- #230
+//│         if x$43 -- #229
+//│           true =>
+//│             let* (x$45) = filter(f_2$0,x$41) in -- #220
+//│             let x$46 = Cons(x$42,x$45) in -- #219
+//│             jump j$2(x$46) -- #218
+//│           false =>
+//│             let* (x$47) = filter(f_2$0,x$41) in -- #228
+//│             jump j$2(x$47) -- #227
+//│       Nil =>
+//│         let x$48 = Nil() in -- #235
+//│         jump j$1(x$48) -- #234
+//│   def j$1(x$40) =
+//│     x$40 -- #191
+//│   def j$2(x$44) =
+//│     jump j$1(x$44) -- #206
+//│   def foldl(f_4$0,i$0,ls_4$0) =
+//│     case ls_4$0 of -- #268
+//│       Cons =>
+//│         let x$50 = Cons.t(ls_4$0) in -- #265
+//│         let x$51 = Cons.h(ls_4$0) in -- #264
+//│         let x$52 = Callable.apply2(f_4$0,i$0,x$51) in -- #263
+//│         let* (x$53) = foldl(f_4$0,x$52,x$50) in -- #262
+//│         jump j$3(x$53) -- #261
+//│       Nil =>
+//│         jump j$3(i$0) -- #267
+//│   def j$3(x$49) =
+//│     x$49 -- #238
+//│   def foldr(f_5$0,i_1$0,ls_5$0) =
+//│     case ls_5$0 of -- #300
+//│       Cons =>
+//│         let x$55 = Cons.t(ls_5$0) in -- #297
+//│         let x$56 = Cons.h(ls_5$0) in -- #296
+//│         let* (x$57) = foldr(f_5$0,i_1$0,x$55) in -- #295
+//│         let x$58 = Callable.apply2(f_5$0,x$56,x$57) in -- #294
+//│         jump j$4(x$58) -- #293
+//│       Nil =>
+//│         jump j$4(i_1$0) -- #299
+//│   def j$4(x$54) =
+//│     x$54 -- #270
+//│   def zip(xs$0,ys$0) =
+//│     case xs$0 of -- #353
+//│       Cons =>
+//│         let x$60 = Cons.t(xs$0) in -- #349
+//│         let x$61 = Cons.h(xs$0) in -- #348
+//│         case ys$0 of -- #347
+//│           Cons =>
+//│             let x$63 = Cons.t(ys$0) in -- #343
+//│             let x$64 = Cons.h(ys$0) in -- #342
+//│             let x$65 = Tuple2(x$61,x$64) in -- #341
+//│             let* (x$66) = zip(x$60,x$63) in -- #340
+//│             let x$67 = Cons(x$65,x$66) in -- #339
+//│             jump j$6(x$67) -- #338
+//│           Nil =>
+//│             let x$68 = Nil() in -- #346
+//│             jump j$6(x$68) -- #345
+//│       Nil =>
+//│         let x$69 = Nil() in -- #352
+//│         jump j$5(x$69) -- #351
+//│   def j$5(x$59) =
+//│     x$59 -- #302
+//│   def j$6(x$62) =
+//│     jump j$5(x$62) -- #313
+//│   def zipWith(f_7$0,xs_4$0,ys_4$0) =
+//│     case xs_4$0 of -- #409
+//│       Cons =>
+//│         let x$71 = Cons.t(xs_4$0) in -- #405
+//│         let x$72 = Cons.h(xs_4$0) in -- #404
+//│         case ys_4$0 of -- #403
+//│           Cons =>
+//│             let x$74 = Cons.t(ys_4$0) in -- #399
+//│             let x$75 = Cons.h(ys_4$0) in -- #398
+//│             let x$76 = Callable.apply2(f_7$0,x$72,x$75) in -- #397
+//│             let* (x$77) = zipWith(f_7$0,x$71,x$74) in -- #396
+//│             let x$78 = Cons(x$76,x$77) in -- #395
+//│             jump j$8(x$78) -- #394
+//│           Nil =>
+//│             let x$79 = Nil() in -- #402
+//│             jump j$8(x$79) -- #401
+//│       Nil =>
+//│         let x$80 = Nil() in -- #408
+//│         jump j$7(x$80) -- #407
+//│   def j$7(x$70) =
+//│     x$70 -- #355
+//│   def j$8(x$73) =
+//│     jump j$7(x$73) -- #366
+//│   def head(ls_7$0) =
+//│     case ls_7$0 of -- #427
+//│       Cons =>
+//│         let x$82 = Cons.t(ls_7$0) in -- #423
+//│         let x$83 = Cons.h(ls_7$0) in -- #422
+//│         jump j$9(x$83) -- #421
+//│       Nil =>
+//│         let x$85 = Lambda$0() in -- #426
+//│         jump j$9(x$85) -- #425
+//│   def j$9(x$81) =
+//│     x$81 -- #411
+//│   def tail(ls_9$0) =
+//│     case ls_9$0 of -- #445
+//│       Cons =>
+//│         let x$87 = Cons.t(ls_9$0) in -- #441
+//│         let x$88 = Cons.h(ls_9$0) in -- #440
+//│         jump j$10(x$87) -- #439
+//│       Nil =>
+//│         let x$90 = Lambda$1() in -- #444
+//│         jump j$10(x$90) -- #443
+//│   def j$10(x$86) =
+//│     x$86 -- #429
+//│   def enumFromTo(a$0,b$0) =
+//│     let x$91 = <=(a$0,b$0) in -- #477
+//│     if x$91 -- #476
+//│       true =>
+//│         let x$93 = +(a$0,1) in -- #472
+//│         let* (x$94) = enumFromTo(x$93,b$0) in -- #471
+//│         let x$95 = Cons(a$0,x$94) in -- #470
+//│         jump j$11(x$95) -- #469
+//│       false =>
+//│         let x$96 = Nil() in -- #475
+//│         jump j$11(x$96) -- #474
+//│   def j$11(x$92) =
+//│     x$92 -- #452
+//│   def enumFromThenTo(a_1$0,t_11$0,b_1$0) =
+//│     let x$97 = <=(a_1$0,b_1$0) in -- #517
+//│     if x$97 -- #516
+//│       true =>
+//│         let x$99 = *(2,t_11$0) in -- #512
+//│         let x$100 = -(x$99,a_1$0) in -- #511
+//│         let* (x$101) = enumFromThenTo(t_11$0,x$100,b_1$0) in -- #510
+//│         let x$102 = Cons(a_1$0,x$101) in -- #509
+//│         jump j$12(x$102) -- #508
+//│       false =>
+//│         let x$103 = Nil() in -- #515
+//│         jump j$12(x$103) -- #514
+//│   def j$12(x$98) =
+//│     x$98 -- #484
+//│   def take(n$0,ls_11$0) =
+//│     let x$104 = >(n$0,0) in -- #566
+//│     if x$104 -- #565
+//│       true =>
+//│         case ls_11$0 of -- #561
+//│           Cons =>
+//│             let x$107 = Cons.t(ls_11$0) in -- #557
+//│             let x$108 = Cons.h(ls_11$0) in -- #556
+//│             let x$109 = -(n$0,1) in -- #555
+//│             let* (x$110) = take(x$109,x$107) in -- #554
+//│             let x$111 = Cons(x$108,x$110) in -- #553
+//│             jump j$14(x$111) -- #552
+//│           Nil =>
+//│             let x$112 = Nil() in -- #560
+//│             jump j$14(x$112) -- #559
+//│       false =>
+//│         let x$113 = Nil() in -- #564
+//│         jump j$13(x$113) -- #563
+//│   def j$13(x$105) =
+//│     x$105 -- #524
+//│   def j$14(x$106) =
+//│     jump j$13(x$106) -- #527
+//│   def length(ls_13$0) =
+//│     case ls_13$0 of -- #593
+//│       Cons =>
+//│         let x$115 = Cons.t(ls_13$0) in -- #590
+//│         let x$116 = Cons.h(ls_13$0) in -- #589
+//│         let* (x$117) = length(x$115) in -- #588
+//│         let x$118 = +(1,x$117) in -- #587
+//│         jump j$15(x$118) -- #586
+//│       Nil =>
+//│         jump j$15(0) -- #592
+//│   def j$15(x$114) =
+//│     x$114 -- #568
+//│   def mappend(xs_8$0,ys_8$0) =
+//│     case xs_8$0 of -- #622
+//│       Cons =>
+//│         let x$120 = Cons.t(xs_8$0) in -- #619
+//│         let x$121 = Cons.h(xs_8$0) in -- #618
+//│         let* (x$122) = mappend(x$120,ys_8$0) in -- #617
+//│         let x$123 = Cons(x$121,x$122) in -- #616
+//│         jump j$16(x$123) -- #615
+//│       Nil =>
+//│         jump j$16(ys_8$0) -- #621
+//│   def j$16(x$119) =
+//│     x$119 -- #595
+//│   def sum(ls_14$0) =
+//│     let* (x$124) = sumAux(ls_14$0,0) in -- #629
+//│     x$124 -- #628
+//│   def sumAux(ls_15$0,a_4$0) =
+//│     case ls_15$0 of -- #658
+//│       Nil =>
+//│         jump j$17(a_4$0) -- #633
+//│       Cons =>
+//│         let x$126 = Cons.t(ls_15$0) in -- #657
+//│         let x$127 = Cons.h(ls_15$0) in -- #656
+//│         let x$128 = +(a_4$0,x$127) in -- #655
+//│         let* (x$129) = sumAux(x$126,x$128) in -- #654
+//│         jump j$17(x$129) -- #653
+//│   def j$17(x$125) =
+//│     x$125 -- #631
+//│   def atIndex(n_2$0,ls_16$0) =
+//│     let x$130 = <(n_2$0,0) in -- #713
+//│     if x$130 -- #712
+//│       true =>
+//│         let x$133 = Lambda$2() in -- #668
+//│         jump j$18(x$133) -- #667
+//│       false =>
+//│         case ls_16$0 of -- #711
+//│           Cons =>
+//│             let x$135 = Cons.t(ls_16$0) in -- #707
+//│             let x$136 = Cons.h(ls_16$0) in -- #706
+//│             let x$137 = ==(n_2$0,0) in -- #705
+//│             if x$137 -- #704
+//│               true =>
+//│                 jump j$20(x$136) -- #689
+//│               false =>
+//│                 let x$139 = -(n_2$0,1) in -- #703
+//│                 let* (x$140) = atIndex(x$139,x$135) in -- #702
+//│                 jump j$20(x$140) -- #701
+//│           Nil =>
+//│             let x$142 = Lambda$3() in -- #710
+//│             jump j$19(x$142) -- #709
+//│   def j$18(x$131) =
+//│     x$131 -- #665
+//│   def j$19(x$134) =
+//│     jump j$18(x$134) -- #671
+//│   def j$20(x$138) =
+//│     jump j$19(x$138) -- #687
+//│   def concat(lss$0) =
+//│     case lss$0 of -- #741
+//│       Cons =>
+//│         let x$144 = Cons.t(lss$0) in -- #737
+//│         let x$145 = Cons.h(lss$0) in -- #736
+//│         let* (x$146) = concat(x$144) in -- #735
+//│         let* (x$147) = mappend(x$145,x$146) in -- #734
+//│         jump j$21(x$147) -- #733
+//│       Nil =>
+//│         let x$148 = Nil() in -- #740
+//│         jump j$21(x$148) -- #739
+//│   def j$21(x$143) =
+//│     x$143 -- #715
+//│   def reverse(ls_18$0) =
+//│     let x$149 = Nil() in -- #749
+//│     let* (x$150) = reverse_helper(ls_18$0,x$149) in -- #748
+//│     x$150 -- #747
+//│   def reverse_helper(ls_19$0,a_5$0) =
+//│     case ls_19$0 of -- #778
+//│       Cons =>
+//│         let x$152 = Cons.t(ls_19$0) in -- #775
+//│         let x$153 = Cons.h(ls_19$0) in -- #774
+//│         let x$154 = Cons(x$153,a_5$0) in -- #773
+//│         let* (x$155) = reverse_helper(x$152,x$154) in -- #772
+//│         jump j$22(x$155) -- #771
+//│       Nil =>
+//│         jump j$22(a_5$0) -- #777
+//│   def j$22(x$151) =
+//│     x$151 -- #751
+//│   def listcomp_fun1(ms$0,listcomp_fun_para$0) =
+//│     case listcomp_fun_para$0 of -- #806
+//│       Cons =>
+//│         let x$157 = Cons.t(listcomp_fun_para$0) in -- #802
+//│         let x$158 = Cons.h(listcomp_fun_para$0) in -- #801
+//│         let* (x$159) = listcomp_fun2(ms$0,x$158,x$157,ms$0) in -- #800
+//│         jump j$23(x$159) -- #799
+//│       Nil =>
+//│         let x$160 = Nil() in -- #805
+//│         jump j$23(x$160) -- #804
+//│   def j$23(x$156) =
+//│     x$156 -- #780
+//│   def listcomp_fun2(ms$1,listcomp_fun_ls_h_out$0,listcomp_fun_ls_t_out$0,listcomp_fun_para$1) =
+//│     case listcomp_fun_para$1 of -- #851
+//│       Cons =>
+//│         let x$162 = Cons.t(listcomp_fun_para$1) in -- #842
+//│         let x$163 = Cons.h(listcomp_fun_para$1) in -- #841
+//│         let x$164 = Tuple2(listcomp_fun_ls_h_out$0,x$163) in -- #840
+//│         let* (x$165) = listcomp_fun2(ms$1,listcomp_fun_ls_h_out$0,listcomp_fun_ls_t_out$0,x$162) in -- #839
+//│         let x$166 = Cons(x$164,x$165) in -- #838
+//│         jump j$24(x$166) -- #837
+//│       Nil =>
+//│         let* (x$167) = listcomp_fun1(ms$1,listcomp_fun_ls_t_out$0) in -- #850
+//│         jump j$24(x$167) -- #849
+//│   def j$24(x$161) =
+//│     x$161 -- #808
+//│   def test(test_arg1$0) =
+//│     let* (x$168) = const5000() in -- #912
+//│     let* (x$169) = const5000() in -- #911
+//│     let* (x$170) = z_add(x$169,test_arg1$0) in -- #910
+//│     let* (x$171) = z_enumFromTo(x$168,x$170) in -- #909
+//│     let* (x$172) = const10000() in -- #908
+//│     let* (x$173) = const10000() in -- #907
+//│     let* (x$174) = z_add(x$173,test_arg1$0) in -- #906
+//│     let* (x$175) = z_enumFromTo(x$172,x$174) in -- #905
+//│     let x$178 = Lambda$4() in -- #904
+//│     let* (x$179) = listcomp_fun1(x$175,x$171) in -- #903
+//│     let* (x$180) = map(x$178,x$179) in -- #902
+//│     let x$183 = Lambda$5() in -- #901
+//│     let* (x$184) = map(x$183,x$180) in -- #900
+//│     let* (x$185) = max'(x$184) in -- #899
+//│     x$185 -- #898
+//│   def const10000() =
+//│     let* (x$186) = z_of_int(10000) in -- #917
+//│     x$186 -- #916
+//│   def f1(f1_arg1$0) =
+//│     case f1_arg1$0 of -- #946
+//│       Tuple2 =>
+//│         let x$188 = Tuple2.y(f1_arg1$0) in -- #945
+//│         let x$189 = Tuple2.x(f1_arg1$0) in -- #944
+//│         let* (x$190) = gcdE(x$189,x$188) in -- #943
+//│         let x$191 = Tuple3(x$189,x$188,x$190) in -- #942
+//│         jump j$25(x$191) -- #941
+//│   def j$25(x$187) =
+//│     x$187 -- #919
+//│   def quotRem(quotRem_arg1$0,quotRem_arg2$0) =
+//│     let* (x$192) = z_div(quotRem_arg1$0,quotRem_arg2$0) in -- #965
+//│     let* (x$193) = z_mod(quotRem_arg1$0,quotRem_arg2$0) in -- #964
+//│     let x$194 = Tuple2(x$192,x$193) in -- #963
+//│     x$194 -- #962
+//│   def max'(max'_arg1$0) =
+//│     case max'_arg1$0 of -- #1028
+//│       Cons =>
+//│         let x$196 = Cons.t(max'_arg1$0) in -- #1027
+//│         let x$197 = Cons.h(max'_arg1$0) in -- #1026
+//│         case x$196 of -- #1025
+//│           Nil =>
+//│             jump j$27(x$197) -- #980
+//│           Cons =>
+//│             let x$199 = Cons.t(x$196) in -- #1024
+//│             let x$200 = Cons.h(x$196) in -- #1023
+//│             let* (x$201) = z_lt(x$197,x$200) in -- #1022
+//│             if x$201 -- #1021
+//│               true =>
+//│                 let x$203 = Cons(x$200,x$199) in -- #1008
+//│                 let* (x$204) = max'(x$203) in -- #1007
+//│                 jump j$28(x$204) -- #1006
+//│               false =>
+//│                 let x$205 = Cons(x$197,x$199) in -- #1020
+//│                 let* (x$206) = max'(x$205) in -- #1019
+//│                 jump j$28(x$206) -- #1018
+//│   def j$26(x$195) =
+//│     x$195 -- #967
+//│   def j$27(x$198) =
+//│     jump j$26(x$198) -- #978
+//│   def j$28(x$202) =
+//│     jump j$27(x$202) -- #996
+//│   def g(g_arg1$0,g_arg2$0) =
+//│     case g_arg1$0 of -- #1156
+//│       Tuple3 =>
+//│         let x$208 = Tuple3.z(g_arg1$0) in -- #1155
+//│         let x$209 = Tuple3.y(g_arg1$0) in -- #1154
+//│         let x$210 = Tuple3.x(g_arg1$0) in -- #1153
+//│         case g_arg2$0 of -- #1152
+//│           Tuple3 =>
+//│             let x$212 = Tuple3.z(g_arg2$0) in -- #1151
+//│             let x$213 = Tuple3.y(g_arg2$0) in -- #1150
+//│             let x$214 = Tuple3.x(g_arg2$0) in -- #1149
+//│             let* (x$215) = const0() in -- #1148
+//│             let* (x$216) = z_equal(x$212,x$215) in -- #1147
+//│             if x$216 -- #1146
+//│               true =>
+//│                 let x$218 = Tuple3(x$208,x$210,x$209) in -- #1076
+//│                 jump j$31(x$218) -- #1075
+//│               false =>
+//│                 let* (x$219) = quotRem(x$208,x$212) in -- #1145
+//│                 case x$219 of -- #1144
+//│                   Tuple2 =>
+//│                     let x$221 = Tuple2.y(x$219) in -- #1143
+//│                     let x$222 = Tuple2.x(x$219) in -- #1142
+//│                     let x$223 = Tuple3(x$214,x$213,x$212) in -- #1141
+//│                     let* (x$224) = z_mul(x$222,x$214) in -- #1140
+//│                     let* (x$225) = z_sub(x$210,x$224) in -- #1139
+//│                     let* (x$226) = z_mul(x$222,x$213) in -- #1138
+//│                     let* (x$227) = z_sub(x$209,x$226) in -- #1137
+//│                     let x$228 = Tuple3(x$225,x$227,x$221) in -- #1136
+//│                     let* (x$229) = g(x$223,x$228) in -- #1135
+//│                     jump j$32(x$229) -- #1134
+//│   def j$29(x$207) =
+//│     x$207 -- #1030
+//│   def j$30(x$211) =
+//│     jump j$29(x$211) -- #1045
+//│   def j$31(x$217) =
+//│     jump j$30(x$217) -- #1066
+//│   def j$32(x$220) =
+//│     jump j$31(x$220) -- #1085
+//│   def abs(abs_arg1$0) =
+//│     let* (x$230) = const0() in -- #1179
+//│     let* (x$231) = z_lt(abs_arg1$0,x$230) in -- #1178
+//│     if x$231 -- #1177
+//│       true =>
+//│         let* (x$233) = const0() in -- #1174
+//│         let* (x$234) = z_sub(x$233,abs_arg1$0) in -- #1173
+//│         jump j$33(x$234) -- #1172
+//│       false =>
+//│         jump j$33(abs_arg1$0) -- #1176
+//│   def j$33(x$232) =
+//│     x$232 -- #1164
+//│   def f2(f2_arg1$0) =
+//│     case f2_arg1$0 of -- #1234
+//│       Tuple3 =>
+//│         let x$236 = Tuple3.z(f2_arg1$0) in -- #1233
+//│         let x$237 = Tuple3.y(f2_arg1$0) in -- #1232
+//│         let x$238 = Tuple3.x(f2_arg1$0) in -- #1231
+//│         case x$236 of -- #1230
+//│           Tuple3 =>
+//│             let x$240 = Tuple3.z(x$236) in -- #1229
+//│             let x$241 = Tuple3.y(x$236) in -- #1228
+//│             let x$242 = Tuple3.x(x$236) in -- #1227
+//│             let* (x$243) = z_add(x$242,x$241) in -- #1226
+//│             let* (x$244) = z_add(x$243,x$240) in -- #1225
+//│             let* (x$245) = abs(x$244) in -- #1224
+//│             jump j$35(x$245) -- #1223
+//│   def j$34(x$235) =
+//│     x$235 -- #1181
+//│   def j$35(x$239) =
+//│     jump j$34(x$239) -- #1196
+//│   def const0() =
+//│     let* (x$246) = z_of_int(0) in -- #1239
+//│     x$246 -- #1238
+//│   def gcdE(gcdE_arg1$0,gcdE_arg2$0) =
+//│     let* (x$247) = const0() in -- #1296
+//│     let* (x$248) = z_equal(gcdE_arg1$0,x$247) in -- #1295
+//│     if x$248 -- #1294
+//│       true =>
+//│         let* (x$250) = const0() in -- #1261
+//│         let* (x$251) = const1() in -- #1260
+//│         let x$252 = Tuple3(gcdE_arg2$0,x$250,x$251) in -- #1259
+//│         jump j$36(x$252) -- #1258
+//│       false =>
+//│         let* (x$253) = const1() in -- #1293
+//│         let* (x$254) = const0() in -- #1292
+//│         let x$255 = Tuple3(x$253,x$254,gcdE_arg1$0) in -- #1291
+//│         let* (x$256) = const0() in -- #1290
+//│         let* (x$257) = const1() in -- #1289
+//│         let x$258 = Tuple3(x$256,x$257,gcdE_arg2$0) in -- #1288
+//│         let* (x$259) = g(x$255,x$258) in -- #1287
+//│         jump j$36(x$259) -- #1286
+//│   def j$36(x$249) =
+//│     x$249 -- #1247
+//│   def const1() =
+//│     let* (x$260) = z_of_int(1) in -- #1301
+//│     x$260 -- #1300
+//│   def const5000() =
+//│     let* (x$261) = z_of_int(5000) in -- #1306
+//│     x$261 -- #1305
+//│   def testGcd_nofib(testGcd_nofib_arg1$0) =
+//│     let* (x$262) = test(testGcd_nofib_arg1$0) in -- #1311
+//│     x$262 -- #1310
+//│   def z_enumFromTo(z_enumFromTo_arg1$0,z_enumFromTo_arg2$0) =
+//│     let* (x$263) = z_leq(z_enumFromTo_arg1$0,z_enumFromTo_arg2$0) in -- #1345
+//│     if x$263 -- #1344
+//│       true =>
+//│         let* (x$265) = const1() in -- #1340
+//│         let* (x$266) = z_add(z_enumFromTo_arg1$0,x$265) in -- #1339
+//│         let* (x$267) = z_enumFromTo(x$266,z_enumFromTo_arg2$0) in -- #1338
+//│         let x$268 = Cons(z_enumFromTo_arg1$0,x$267) in -- #1337
+//│         jump j$37(x$268) -- #1336
+//│       false =>
+//│         let x$269 = Nil() in -- #1343
+//│         jump j$37(x$269) -- #1342
+//│   def j$37(x$264) =
+//│     x$264 -- #1318
+//│   let* (x$0) = z_of_int(400) in -- #8
+//│   let* (x$1) = testGcd_nofib(x$0) in -- #7
+//│   x$1 -- #6
+//│ 
+//│ 
+//│ Execution succeeded: 
+//│ Z(5201)
+//│ 
diff --git a/compiler/shared/test/scala/mlscript/compiler/Test.scala b/compiler/shared/test/scala/mlscript/compiler/Test.scala
index 752dc909e2..343de6b9f9 100644
--- a/compiler/shared/test/scala/mlscript/compiler/Test.scala
+++ b/compiler/shared/test/scala/mlscript/compiler/Test.scala
@@ -1,7 +1,7 @@
 package mlscript
 package compiler
 
-import utils.shorthands.*
+import mlscript.utils.shorthands._
 import scala.util.control.NonFatal
 import scala.collection.mutable.StringBuilder
 import mlscript.compiler.TreeDebug
diff --git a/compiler/shared/test/scala/mlscript/compiler/TestIR.scala b/compiler/shared/test/scala/mlscript/compiler/TestIR.scala
index 565769be1d..29f74f715c 100644
--- a/compiler/shared/test/scala/mlscript/compiler/TestIR.scala
+++ b/compiler/shared/test/scala/mlscript/compiler/TestIR.scala
@@ -1,63 +1,83 @@
-package mlscript
-package compiler
+package mlscript.compiler
+
 
 import mlscript.utils.shorthands._
 import mlscript.compiler.ir._
-import scala.collection.mutable.StringBuilder
+import scala.collection.mutable.{ListBuffer, StringBuilder}
+import mlscript.Statement
+import mlscript.{DiffTests, ModeType, TypingUnit}
+import mlscript.compiler.ir.{Fresh, FreshInt, Builder}
+import mlscript.compiler.codegen.cpp._
+import mlscript.Diagnostic
 import mlscript.compiler.optimizer.TailRecOpt
 
 import IRDiffTestCompiler.*
 
 class IRDiffTestCompiler extends DiffTests(State) {
+  def printToFile(f: java.io.File)(op: java.io.PrintWriter => Unit) = {
+    val p = new java.io.PrintWriter(f)
+    try { op(p) } finally { p.close() }
+  }
+
+  val preludeSource = ListBuffer[Statement]()
 
-  override def postProcess(mode: ModeType, basePath: List[Str], testName: Str, unit: TypingUnit, output: Str => Unit, raise: Diagnostic => Unit): (List[Str], Option[TypingUnit]) = 
+  override def postProcess(mode: ModeType, basePath: List[Str], testName: Str, originalUnit: TypingUnit, output: Str => Unit, raise: Diagnostic => Unit): (List[Str], Option[TypingUnit]) = 
     val outputBuilder = StringBuilder()
-    if (mode.useIR || mode.irVerbose)
+    if (mode.prelude)
+      preludeSource.addAll(originalUnit.rawEntities)
+      output("\nPreluded.")
+    else if (mode.useIR || mode.irVerbose)
       try
-        val fnUid = FreshInt()
-        val classUid = FreshInt()
-        val tag = FreshInt()
-
-        val gb = Builder(Fresh(), fnUid, classUid, tag, raise)
-        val graph_ = gb.buildGraph(unit)
-        
-        if !mode.noTailRecOpt then 
-          output("\nIR:")
-          output(graph_.toString())
-
-        val graph = 
-          if !mode.noTailRecOpt then
-            val tailRecOpt = new TailRecOpt(fnUid, classUid, tag, raise)
-            val (g, comps) = tailRecOpt.run_debug(graph_)
-            output("\nStrongly Connected Tail Calls:")
-            output(comps.toString)
-            g
-          else
-            graph_
+        val (fresh, freshFnId, freshClassId, freshTag) = (Fresh(), FreshInt(), FreshInt(), FreshInt())
+        val gb = Builder(fresh, freshFnId, freshClassId, freshTag, raise, mode.irVerbose)
+        val prelude = TypingUnit(preludeSource.toList)
+        var graph = gb.buildGraph(prelude, originalUnit)
+        val hiddenNames = gb.getHiddenNames(prelude)
 
+        output("\n\nIR:")
+        output(graph.show(hiddenNames))
         if !mode.noTailRecOpt then
-          output(graph.toString())
-        
-        output("\nPromoted:")
-        output(graph.toString())
+          val tailRecOpt = new TailRecOpt(freshFnId, freshClassId, freshTag, raise)
+          val (g, comps) = tailRecOpt.run_debug(graph)
+          output("\n\nStrongly Connected Tail Calls:")
+          output(comps.toString)
+          graph = g
+          output(graph.show(hiddenNames))
         var interp_result: Opt[Str] = None
         if (mode.interpIR)
           output("\nInterpreted:")
           val ir = Interpreter(mode.irVerbose).interpret(graph)
           interp_result = Some(ir)
           output(ir)
-
+        if (mode.genCpp)
+          val cpp = codegen(graph)
+          if (mode.showCpp)
+            output("\nCpp:")
+            if (mode.irVerbose)
+              output(cpp.toDocument.print)
+            else
+              output(cpp.toDocumentWithoutHidden.print)
+          if (mode.writeCpp)
+            printToFile(java.io.File(s"compiler/shared/test/diff-ir/cpp/${testName}.cpp")) { p =>
+              p.println(cpp.toDocument.print)
+            }
+          if (mode.runCpp)
+            val auxPath = os.pwd/"compiler"/"shared"/"test"/"diff-ir"/"cpp"
+            val cppHost = CppCompilerHost(auxPath.toString)
+            if !cppHost.ready then
+              output("\nCpp Compilation Failed: Cpp compiler or GNU Make not found")
+            else
+              output("\n")
+              cppHost.compileAndRun(cpp.toDocument.print, output)
       catch
         case err: Exception =>
           output(s"\nIR Processing Failed: ${err.getMessage()}")
-          if (mode.irVerbose) then
-            output("\n" ++ err.getStackTrace().map(_.toString()).mkString("\n"))
+          output("\n" ++ err.getStackTrace().mkString("\n"))
         case err: StackOverflowError =>
           output(s"\nIR Processing Failed: ${err.getMessage()}")
-          if (mode.irVerbose) then
-            output("\n" ++ err.getStackTrace().map(_.toString()).mkString("\n"))
+          output("\n" ++ err.getStackTrace().mkString("\n"))
       
-    (outputBuilder.toString().linesIterator.toList, None)
+    (outputBuilder.toString.linesIterator.toList, None)
   
 }
 
diff --git a/flake.lock b/flake.lock
new file mode 100644
index 0000000000..f4f8a7fafc
--- /dev/null
+++ b/flake.lock
@@ -0,0 +1,97 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1710146030,
+        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "flake-utils_2": {
+      "locked": {
+        "lastModified": 1667395993,
+        "narHash": "sha256-nuEHfE/LcWyuSWnS8t12N1wc105Qtau+/OdUAjtQ0rA=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "5aed5285a952e0b949eb3ba02c12fa4fcfef535f",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1723256269,
+        "narHash": "sha256-9jxxtPKq4n+F8+BPt706gtbdpDt8+DtmY8oDMi9Vh9Q=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "36d2587498cbb61b129149fb9050361d73e1f7c4",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs",
+        "sbt-deriv": "sbt-deriv"
+      }
+    },
+    "sbt-deriv": {
+      "inputs": {
+        "flake-utils": "flake-utils_2",
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1698464090,
+        "narHash": "sha256-Pnej7WZIPomYWg8f/CZ65sfW85IfIUjYhphMMg7/LT0=",
+        "owner": "zaninime",
+        "repo": "sbt-derivation",
+        "rev": "6762cf2c31de50efd9ff905cbcc87239995a4ef9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "zaninime",
+        "repo": "sbt-derivation",
+        "type": "github"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
diff --git a/flake.nix b/flake.nix
new file mode 100644
index 0000000000..5619a8410d
--- /dev/null
+++ b/flake.nix
@@ -0,0 +1,34 @@
+{
+  description = "mlscript";
+
+  inputs.nixpkgs.url = "github:NixOS/nixpkgs";
+  inputs.flake-utils.url = "github:numtide/flake-utils";
+  inputs.sbt-deriv.url = "github:zaninime/sbt-derivation";
+  inputs.sbt-deriv.inputs.nixpkgs.follows = "nixpkgs";
+
+  outputs = { self, nixpkgs, flake-utils, sbt-deriv }:
+    flake-utils.lib.eachDefaultSystem
+      (system:
+      let 
+        sbtOverlay = self: super: {
+          sbt = super.sbt.override { jre = super.jdk8_headless; };
+        };
+        pkgs = import nixpkgs { 
+          inherit system;
+          overlays = [ sbtOverlay ];
+        };
+      in with pkgs; {
+          devShells.default = mkShell {
+            buildInputs = [
+              clang
+              gcc
+              gnumake
+              boost
+              gmp
+              mimalloc
+              sbt
+              nodejs_22
+            ];
+          };
+      });
+}
\ No newline at end of file
diff --git a/project/build.properties b/project/build.properties
index e8a1e246e8..ee4c672cd0 100644
--- a/project/build.properties
+++ b/project/build.properties
@@ -1 +1 @@
-sbt.version=1.9.7
+sbt.version=1.10.1
diff --git a/project/plugins.sbt b/project/plugins.sbt
index 3d01a25463..6012dc30ef 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -1,3 +1,3 @@
-addSbtPlugin("org.wartremover" % "sbt-wartremover" % "3.1.5")
-addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.11.0")
+addSbtPlugin("org.wartremover" % "sbt-wartremover" % "3.2.0")
+addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.16.0")
 addSbtPlugin("org.portable-scala" % "sbt-scalajs-crossproject" % "1.2.0")
diff --git a/shared/src/main/scala/mlscript/NewLexer.scala b/shared/src/main/scala/mlscript/NewLexer.scala
index 0c6bc7d8e7..a42ffb7cad 100644
--- a/shared/src/main/scala/mlscript/NewLexer.scala
+++ b/shared/src/main/scala/mlscript/NewLexer.scala
@@ -161,6 +161,60 @@ class NewLexer(origin: Origin, raise: Diagnostic => Unit, dbg: Bool) {
     }
   }
 
+  final
+  def char(i: Int): (Char, Int) = {
+    if (i < length) {
+      bytes(i) match {
+        case '\\' => {
+          val j = i + 1
+          if (j < length)
+            bytes(j) match {
+              case 'n' => ('\n', j + 1)
+              case 't' => ('\t', j + 1)
+              case 'r' => ('\r', j + 1)
+              case 'b' => ('\b', j + 1)
+              case 'f' => ('\f', j + 1)
+              case '\'' => ('\'', j + 1)
+              case '"' => ('"', j + 1)
+              case '\\' => ('\\', j + 1)
+              case ch =>
+                raise(ErrorReport(msg"Invalid escape character" -> S(loc(j, j + 1)) :: Nil,
+                  newDefs = true, source = Lexing))
+                ('\u0000', j + 1)
+            }
+          else {
+            raise(ErrorReport(msg"Expect an escape character" -> S(loc(i, i + 1)) :: Nil,
+              newDefs = true, source = Lexing))
+            ('\u0000', i + 1)
+          }
+        }
+        case '\n' | '\r' =>
+          raise(ErrorReport(msg"Unexpected newline in a char literal" -> S(loc(i, i + 1)) :: Nil,
+            newDefs = true, source = Lexing))
+          ('\u0000', i + 1)
+        case '\"' =>
+          raise(ErrorReport(msg"Empty character literal" -> S(loc(i, i + 1)) :: Nil,
+            newDefs = true, source = Lexing))
+          ('\u0000', i + 1)
+        case ch =>
+          (ch, i + 1)
+      }
+    }
+    else {
+      raise(ErrorReport(msg"Expect a character literal" -> S(loc(i, i + 1)) :: Nil,
+        newDefs = true, source = Lexing))
+      ('\u0000', i)
+    }
+  }
+
+  final def closeChar(i: Int): Int =
+    if (bytes.lift(i) === Some('\"')) i + 1
+    else {
+      raise(ErrorReport(msg"Unclosed character literal" -> S(loc(i, i + 1)) :: Nil,
+        newDefs = true, source = Lexing))
+      i
+    }
+
   // * Check the end of a string (either single quotation or triple quotation)
   final def closeStr(i: Int, isTriple: Bool): Int =
     if (!isTriple && bytes.lift(i) === Some('"')) i + 1
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index 8fb9ad1c2e..5e3076d28f 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -43,12 +43,17 @@ abstract class ModeType {
   def showRepl: Bool
   def allowEscape: Bool
   def useIR: Bool
-  def noTailRecOpt: Bool
   def interpIR: Bool
   def irVerbose: Bool
+  def genCpp: Bool
+  def showCpp: Bool
+  def runCpp: Bool
+  def writeCpp: Bool
+  def noTailRecOpt: Bool
   def simpledef: Bool
   def lift: Bool
   def nolift: Bool
+  def prelude: Bool
 }
 
 class DiffTests(state: DiffTests.State)
@@ -185,10 +190,17 @@ class DiffTests(state: DiffTests.State)
       lift: Bool = false,
       nolift: Bool = false,
       // noProvs: Bool = false,
-      noTailRecOpt: Bool = false,
       useIR: Bool = false,
       interpIR: Bool = false,
       irVerbose: Bool = false,
+      irOpt: Bool = false,
+      irOptFuel: Int = 10,
+      genCpp: Bool = false,
+      showCpp: Bool = false,
+      runCpp: Bool = false,
+      writeCpp: Bool = false,
+      noTailRecOpt: Bool = false,
+      prelude: Bool = false,
     ) extends ModeType {
       def isDebugging: Bool = dbg || dbgSimplif
     }
@@ -319,6 +331,11 @@ class DiffTests(state: DiffTests.State)
           case "useIR" => mode.copy(useIR = true)
           case "interpIR" => mode.copy(interpIR = true)
           case "irVerbose" => mode.copy(irVerbose = true)
+          case "genCpp" => mode.copy(genCpp = true)
+          case "showCpp" => mode.copy(showCpp = true)
+          case "runCpp" => mode.copy(runCpp = true)
+          case "writeCpp" => mode.copy(writeCpp = true)
+          case "prelude" => mode.copy(prelude = true)
           case _ =>
             failures += allLines.size - lines.size
             output("/!\\ Unrecognized option " + line)
@@ -485,13 +502,13 @@ class DiffTests(state: DiffTests.State)
             
             if (mode.showParse)
               output(s"AST: $res")
+            
             val newMode = if (useIR) { mode.copy(useIR = true) } else mode
             val newNewMode = if (noTailRec) { newMode.copy(noTailRecOpt = true) } else newMode
 
-            val (postLines, nuRes) = 
-              postProcess(newNewMode, basePath, testName, res, output, raise)
-            postLines.foreach(output)            
-            
+            val (postLines, nuRes) = postProcess(newNewMode, basePath, testName, res, output, raise)
+            postLines.foreach(output)
+
             if (parseOnly)
               Success(Pgrm(Nil), 0)
             else if (mode.lift) {

From 5841627c91e3fe246cf33fb31ae491ec437a654e Mon Sep 17 00:00:00 2001
From: auht <101095686+auht@users.noreply.github.com>
Date: Fri, 4 Oct 2024 22:45:15 +0800
Subject: [PATCH 146/147] Constraint solving for function overloading (#213)

Co-authored-by: Lionel Parreaux <lionel.parreaux@gmail.com>
---
 .../scala/mlscript/compiler/ClassLifter.scala |  16 +-
 .../scala/mlscript/ConstraintSolver.scala     |  88 ++++
 .../src/main/scala/mlscript/NuTypeDefs.scala  |  14 +-
 .../main/scala/mlscript/TypeSimplifier.scala  |  48 ++-
 shared/src/main/scala/mlscript/Typer.scala    |  44 +-
 .../main/scala/mlscript/TyperDatatypes.scala  | 118 ++++-
 .../main/scala/mlscript/TyperHelpers.scala    |  48 +--
 .../codegen/typescript/TsTypegen.scala        |   2 +-
 shared/src/main/scala/mlscript/helpers.scala  |  14 +-
 shared/src/main/scala/mlscript/syntax.scala   |   2 +-
 shared/src/test/diff/fcp/Overloads.mls        |  63 ++-
 .../src/test/diff/fcp/Overloads_Precise.mls   | 197 +++++++++
 shared/src/test/diff/nu/HeungTung.mls         | 402 +++++++++++++++++-
 .../src/test/scala/mlscript/DiffTests.scala   |   5 +-
 14 files changed, 969 insertions(+), 92 deletions(-)
 create mode 100644 shared/src/test/diff/fcp/Overloads_Precise.mls

diff --git a/compiler/shared/main/scala/mlscript/compiler/ClassLifter.scala b/compiler/shared/main/scala/mlscript/compiler/ClassLifter.scala
index 533ab83b16..b6aa7bcce3 100644
--- a/compiler/shared/main/scala/mlscript/compiler/ClassLifter.scala
+++ b/compiler/shared/main/scala/mlscript/compiler/ClassLifter.scala
@@ -510,7 +510,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
       val nlhs = liftType(lb)
       val nrhs = liftType(ub)
       Bounds(nlhs._1, nrhs._1) -> (nlhs._2 ++ nrhs._2)
-    case Constrained(base: Type, bounds, where) =>
+    case Constrained(base: Type, bounds, where, tscs) =>
       val (nTargs, nCtx) = bounds.map { case (tv, Bounds(lb, ub)) =>
         val nlhs = liftType(lb)
         val nrhs = liftType(ub)
@@ -521,10 +521,18 @@ class ClassLifter(logDebugMsg: Boolean = false) {
         val nrhs = liftType(ub)
         Bounds(nlhs._1, nrhs._1) -> (nlhs._2 ++ nrhs._2)
       }.unzip
+      val (tscs0, nCtx3) = tscs.map { case (tvs, cs) =>
+        val (ntvs,c0) = tvs.map { case (p,v) =>
+          val (nv, c) = liftType(v)
+          (p,nv) -> c
+        }.unzip
+        val (ncs,c1) = cs.map(_.map(liftType).unzip).unzip
+        (ntvs,ncs) -> (c0 ++ c1.flatten)
+      }.unzip
       val (nBase, bCtx) = liftType(base)
-      Constrained(nBase, nTargs, bounds2) ->
-        ((nCtx ++ nCtx2).fold(emptyCtx)(_ ++ _) ++ bCtx)
-    case Constrained(_, _, _) => die
+      Constrained(nBase, nTargs, bounds2, tscs0) ->
+        ((nCtx ++ nCtx2 ++ nCtx3.flatten).fold(emptyCtx)(_ ++ _) ++ bCtx)
+    case Constrained(_, _, _, _) => die
     case Function(lhs, rhs) =>
       val nlhs = liftType(lhs)
       val nrhs = liftType(rhs)
diff --git a/shared/src/main/scala/mlscript/ConstraintSolver.scala b/shared/src/main/scala/mlscript/ConstraintSolver.scala
index 54b7e91210..5d60ac1ff5 100644
--- a/shared/src/main/scala/mlscript/ConstraintSolver.scala
+++ b/shared/src/main/scala/mlscript/ConstraintSolver.scala
@@ -627,6 +627,35 @@ class ConstraintSolver extends NormalForms { self: Typer =>
               recLb(ar.inner, b.inner)
               rec(b.inner.ub, ar.inner.ub, false)
             case (LhsRefined(S(b: ArrayBase), ts, r, _), _) => reportError()
+            case (LhsRefined(S(ov: Overload), ts, r, trs), RhsBases(_, S(L(f: FunctionType)), _)) if noApproximateOverload =>
+              TupleSetConstraints.mk(ov, f) match {
+                case S(tsc) =>
+                  if (tsc.tvs.nonEmpty) {
+                    tsc.tvs.mapValuesIter(_.unwrapProxies).zipWithIndex.flatMap {
+                      case ((true, tv: TV), i) => tv.lowerBounds.iterator.map((_,tv,i,true))
+                      case ((false, tv: TV), i) => tv.upperBounds.iterator.map((_,tv,i,false))
+                      case _ => Nil
+                    }.find {
+                      case (b,_,i,_) =>
+                        tsc.updateImpl(i,b)
+                        tsc.constraints.isEmpty
+                    }.foreach {
+                      case (b,tv,_,p) => if (p) rec(b,tv,false) else rec(tv,b,false)
+                    }
+                    if (tsc.constraints.sizeCompare(1) === 0) {
+                      tsc.tvs.values.map(_.unwrapProxies).foreach {
+                        case tv: TV => tv.tsc.remove(tsc)
+                        case _ => ()
+                      }
+                      tsc.constraints.head.iterator.zip(tsc.tvs).foreach {
+                        case (c, (pol, t)) =>
+                          if (!pol) rec(c, t, false)
+                          if (pol) rec(t, c, false)
+                      }
+                    }
+                  }
+                case N => reportError(S(msg"is not an instance of `${f.expNeg}`"))
+              }
             case (LhsRefined(S(ov: Overload), ts, r, trs), _) =>
               annoying(Nil, LhsRefined(S(ov.approximatePos), ts, r, trs), Nil, done_rs) // TODO remove approx. with ambiguous constraints
             case (LhsRefined(S(Without(b, ns)), ts, r, _), RhsBases(pts, N | S(L(_)), _)) =>
@@ -832,6 +861,28 @@ class ConstraintSolver extends NormalForms { self: Typer =>
             val newBound = (cctx._1 ::: cctx._2.reverse).foldRight(rhs)((c, ty) =>
               if (c.prov is noProv) ty else mkProxy(ty, c.prov))
             lhs.upperBounds ::= newBound // update the bound
+            if (noApproximateOverload) {
+              lhs.tsc.foreachEntry { (tsc, v) =>
+                v.foreach { i =>
+                  if (!tsc.tvs(i)._1) {
+                    tsc.updateOn(i, rhs)
+                    if (tsc.constraints.isEmpty) reportError()
+                  }
+                }
+              }
+              val u = lhs.tsc.keysIterator.filter(_.constraints.sizeCompare(1)===0).duplicate
+              u._1.foreach { k =>
+                k.tvs.mapValuesIter(_.unwrapProxies).foreach {
+                  case (_,tv: TV) => tv.tsc.remove(k)
+                  case _ => ()
+                }
+              }
+              u._2.foreach { k =>
+                k.constraints.head.iterator.zip(k.tvs).foreach {
+                  case (c, (pol, t)) => if (pol) rec(t, c, false) else rec(c, t, false)
+                }
+              }
+            }
             lhs.lowerBounds.foreach(rec(_, rhs, true)) // propagate from the bound
             
           case (lhs, rhs: TypeVariable) if lhs.level <= rhs.level =>
@@ -839,6 +890,28 @@ class ConstraintSolver extends NormalForms { self: Typer =>
             val newBound = (cctx._1 ::: cctx._2.reverse).foldLeft(lhs)((ty, c) =>
               if (c.prov is noProv) ty else mkProxy(ty, c.prov))
             rhs.lowerBounds ::= newBound // update the bound
+            if (noApproximateOverload) {
+              rhs.tsc.foreachEntry { (tsc, v) =>
+                v.foreach { i =>
+                  if(tsc.tvs(i)._1) {
+                    tsc.updateOn(i, lhs)
+                    if (tsc.constraints.isEmpty) reportError()
+                  }
+                }
+              }
+              val u = rhs.tsc.keysIterator.filter(_.constraints.sizeCompare(1)===0).duplicate
+              u._1.foreach { k =>
+                k.tvs.mapValuesIter(_.unwrapProxies).foreach {
+                  case (_,tv: TV) => tv.tsc.remove(k)
+                  case _ => ()
+                }
+              }
+              u._2.foreach { k =>
+                k.constraints.head.iterator.zip(k.tvs).foreach {
+                  case (c, (pol, t)) => if (pol) rec(t, c, false) else rec(c, t, false)
+                }
+              }
+            }
             rhs.upperBounds.foreach(rec(lhs, _, true)) // propagate from the bound
             
             
@@ -1562,9 +1635,24 @@ class ConstraintSolver extends NormalForms { self: Typer =>
             assert(lvl <= below, "this condition should be false for the result to be correct")
             lvl
           })
+          val freshentsc = tv.tsc.flatMap { case (tsc,_) =>
+            if (tsc.tvs.values.map(_.unwrapProxies).forall {
+              case tv: TV => !freshened.contains(tv)
+              case _ => true
+            }) S(tsc) else N
+          }
           freshened += tv -> v
           v.lowerBounds = tv.lowerBounds.mapConserve(freshen)
           v.upperBounds = tv.upperBounds.mapConserve(freshen)
+          freshentsc.foreach { tsc =>
+            val t = new TupleSetConstraints(tsc.constraints, tsc.tvs)
+            t.constraints = t.constraints.map(_.map(freshen))
+            t.tvs = t.tvs.map(x => (x._1,freshen(x._2)))
+            t.tvs.values.map(_.unwrapProxies).zipWithIndex.foreach {
+              case (tv: TV, i) => tv.tsc.updateWith(t)(_.map(_ + i).orElse(S(Set(i))))
+              case _ => ()
+            }
+          }
           v
       }
       
diff --git a/shared/src/main/scala/mlscript/NuTypeDefs.scala b/shared/src/main/scala/mlscript/NuTypeDefs.scala
index 3470c6807b..45a19986aa 100644
--- a/shared/src/main/scala/mlscript/NuTypeDefs.scala
+++ b/shared/src/main/scala/mlscript/NuTypeDefs.scala
@@ -1165,7 +1165,19 @@ class NuTypeDefs extends ConstraintSolver { self: Typer =>
                     ctx.nextLevel { implicit ctx: Ctx =>
                       assert(fd.tparams.sizeCompare(tparamsSkolems) === 0, (fd.tparams, tparamsSkolems))
                       vars ++ tparamsSkolems |> { implicit vars =>
-                        typeTerm(body)
+                        val ty = typeTerm(body)
+                        if (noApproximateOverload) {
+                          val ambiguous = ty.getVars.unsorted.flatMap(_.tsc.keys.flatMap(_.tvs))
+                            .groupBy(_._2)
+                            .filter { case (v,pvs) => pvs.sizeIs > 1 }
+                          if (ambiguous.nonEmpty) raise(ErrorReport(
+                            msg"ambiguous" -> N ::
+                              ambiguous.map { case (v,_) =>
+                                msg"cannot determine satisfiability of type ${v.expPos}" -> v.prov.loco
+                              }.toList
+                              , true))
+                        }
+                        ty
                       }
                     }
                   } else {
diff --git a/shared/src/main/scala/mlscript/TypeSimplifier.scala b/shared/src/main/scala/mlscript/TypeSimplifier.scala
index f444498dad..f5a0bd8136 100644
--- a/shared/src/main/scala/mlscript/TypeSimplifier.scala
+++ b/shared/src/main/scala/mlscript/TypeSimplifier.scala
@@ -25,6 +25,7 @@ trait TypeSimplifier { self: Typer =>
     println(s"allVarPols: ${printPols(allVarPols)}")
     
     val renewed = MutMap.empty[TypeVariable, TypeVariable]
+    val renewedtsc = MutMap.empty[TupleSetConstraints, TupleSetConstraints]
     
     def renew(tv: TypeVariable): TypeVariable =
       renewed.getOrElseUpdate(tv,
@@ -78,8 +79,17 @@ trait TypeSimplifier { self: Typer =>
               ).map(process(_, S(false -> tv)))
                 .reduceOption(_ &- _).filterNot(_.isTop).toList
             else Nil
+          if (noApproximateOverload)
+            nv.tsc ++= tv.tsc.iterator.map { case (tsc, i) => renewedtsc.get(tsc) match {
+              case S(tsc) => (tsc, i)
+              case N if inPlace => (tsc, i)
+              case N =>
+                val t = new TupleSetConstraints(tsc.constraints, tsc.tvs)
+                renewedtsc += tsc -> t
+                t.tvs = t.tvs.map(x => (x._1, process(x._2, N)))
+                (t, i)
+            }}
         }
-        
         nv
         
       case ComposedType(true, l, r) =>
@@ -549,9 +559,17 @@ trait TypeSimplifier { self: Typer =>
                 analyzed1.setAndIfUnset(tv -> pol(tv).getOrElse(false)) { apply(pol)(ty) }
               case N =>
                 if (pol(tv) =/= S(false))
-                  analyzed1.setAndIfUnset(tv -> true) { tv.lowerBounds.foreach(apply(pol.at(tv.level, true))) }
+                  analyzed1.setAndIfUnset(tv -> true) {
+                    tv.lowerBounds.foreach(apply(pol.at(tv.level, true)))
+                    if (noApproximateOverload)
+                      tv.tsc.keys.flatMap(_.tvs).foreach(u => apply(pol.at(tv.level,u._1))(u._2))
+                  }
                 if (pol(tv) =/= S(true))
-                  analyzed1.setAndIfUnset(tv -> false) { tv.upperBounds.foreach(apply(pol.at(tv.level, false))) }
+                  analyzed1.setAndIfUnset(tv -> false) {
+                    tv.upperBounds.foreach(apply(pol.at(tv.level, false)))
+                    if (noApproximateOverload)
+                      tv.tsc.keys.flatMap(_.tvs).foreach(u => apply(pol.at(tv.level,u._1))(u._2))
+                  }
             }
           case _ =>
             super.apply(pol)(st)
@@ -643,8 +661,11 @@ trait TypeSimplifier { self: Typer =>
             case tv: TypeVariable =>
               pol(tv) match {
                 case S(pol_tv) =>
-                  if (analyzed2.add(pol_tv -> tv))
+                  if (analyzed2.add(pol_tv -> tv)) {
                     processImpl(st, pol, pol_tv)
+                    if (noApproximateOverload)
+                      tv.tsc.keys.flatMap(_.tvs).foreach(u => processImpl(u._2,pol.at(tv.level,u._1),pol_tv))
+                  }
                 case N =>
                   if (analyzed2.add(true -> tv))
                     // * To compute the positive co-occurrences
@@ -690,6 +711,7 @@ trait TypeSimplifier { self: Typer =>
                 case S(p) =>
                   (if (p) tv2.lowerBounds else tv2.upperBounds).foreach(go)
                   // (if (p) getLbs(tv2) else getUbs(tv2)).foreach(go)
+                  if (noApproximateOverload) tv2.tsc.keys.flatMap(_.tvs).foreach(u => go(u._2))
                 case N =>
                   trace(s"Analyzing invar-occ of $tv2") {
                     analyze2(tv2, pol)
@@ -789,7 +811,7 @@ trait TypeSimplifier { self: Typer =>
     
     // * Remove variables that are 'dominated' by another type or variable
     // *  A variable v dominated by T if T is in both of v's positive and negative cooccurrences
-    allVars.foreach { case v => if (v.assignedTo.isEmpty && !varSubst.contains(v)) {
+    allVars.foreach { case v => if (v.assignedTo.isEmpty && !varSubst.contains(v) && v.tsc.isEmpty) {
       println(s"2[v] $v ${coOccurrences.get(true -> v)} ${coOccurrences.get(false -> v)}")
       
       coOccurrences.get(true -> v).iterator.flatMap(_.iterator).foreach {
@@ -807,6 +829,7 @@ trait TypeSimplifier { self: Typer =>
         
         case w: TV if !(w is v) && !varSubst.contains(w) && !varSubst.contains(v) && !recVars(v)
           && coOccurrences.get(false -> v).exists(_(w))
+          && w.tsc.isEmpty
         =>
           // * Here we know that v is 'dominated' by w, so v can be inlined.
           // * Note that we don't want to unify the two variables here
@@ -833,7 +856,7 @@ trait TypeSimplifier { self: Typer =>
     
     // * Unify equivalent variables based on polar co-occurrence analysis:
     allVars.foreach { case v =>
-      if (!v.assignedTo.isDefined && !varSubst.contains(v)) // TODO also handle v.assignedTo.isDefined?
+      if (!v.assignedTo.isDefined && !varSubst.contains(v) && v.tsc.isEmpty) // TODO also handle v.assignedTo.isDefined?
         trace(s"3[v] $v +${coOccurrences.get(true -> v).mkString} -${coOccurrences.get(false -> v).mkString}") {
         
         def go(pol: Bool): Unit = coOccurrences.get(pol -> v).iterator.flatMap(_.iterator).foreach {
@@ -850,6 +873,7 @@ trait TypeSimplifier { self: Typer =>
               )
               && (v.level === w.level)
               // ^ Don't merge variables of differing levels
+              && w.tsc.isEmpty
             =>
             trace(s"[w] $w ${printPol(S(pol))}${coOccurrences.get(pol -> w).mkString}") {
               
@@ -923,6 +947,7 @@ trait TypeSimplifier { self: Typer =>
     println(s"[rec] ${recVars}")
     
     val renewals = MutMap.empty[TypeVariable, TypeVariable]
+    val renewaltsc = MutMap.empty[TupleSetConstraints, TupleSetConstraints]
     
     val semp = Set.empty[TV]
     
@@ -999,7 +1024,7 @@ trait TypeSimplifier { self: Typer =>
               nv
             })
             pol(tv) match {
-              case S(p) if inlineBounds && !occursInvariantly(tv) && !recVars.contains(tv) =>
+              case S(p) if inlineBounds && !occursInvariantly(tv) && !recVars.contains(tv) && tv.tsc.isEmpty =>
                 // * Inline the bounds of non-rec non-invar-occ type variables
                 println(s"Inlining [${printPol(p)}] bounds of $tv (~> $res)")
                 // if (p) mergeTransform(true, pol, tv, Set.single(tv), canDistribForall) | res
@@ -1017,6 +1042,15 @@ trait TypeSimplifier { self: Typer =>
                           res.lowerBounds = tv.lowerBounds.map(transform(_, pol.at(tv.level, true), Set.single(tv)))
                         if (occNums.contains(false -> tv))
                           res.upperBounds = tv.upperBounds.map(transform(_, pol.at(tv.level, false), Set.single(tv)))
+                        if (noApproximateOverload)
+                          res.tsc ++= tv.tsc.map { case (tsc, i) => renewaltsc.get(tsc) match {
+                            case S(tsc) => (tsc, i)
+                            case N =>
+                              val t = new TupleSetConstraints(tsc.constraints, tsc.tvs)
+                              renewaltsc += tsc -> t
+                              t.tvs = t.tvs.map(x => (x._1, transform(x._2, PolMap.neu, Set.empty)))
+                              (t, i)
+                          }}
                     }
                     res
                   }()
diff --git a/shared/src/main/scala/mlscript/Typer.scala b/shared/src/main/scala/mlscript/Typer.scala
index ad79b34a47..af88e803bc 100644
--- a/shared/src/main/scala/mlscript/Typer.scala
+++ b/shared/src/main/scala/mlscript/Typer.scala
@@ -34,6 +34,7 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
   var constrainedTypes: Boolean = false
   
   var recordProvenances: Boolean = true
+  var noApproximateOverload: Boolean = false
   
   type Binding = Str -> SimpleType
   type Bindings = Map[Str, SimpleType]
@@ -168,7 +169,17 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
               assert(b.level > lvl)
               if (p) (b, tv) else (tv, b) }
           }.toList, innerTy)
-        
+
+        if (noApproximateOverload) {
+          val ambiguous = innerTy.getVars.unsorted.flatMap(_.tsc.keys.flatMap(_.tvs))
+            .groupBy(_._2)
+            .filter { case (v,pvs) => pvs.sizeIs > 1 }
+          if (ambiguous.nonEmpty) raise(ErrorReport(
+            msg"ambiguous" -> N ::
+              ambiguous.map { case (v,_) => msg"cannot determine satisfiability of type ${v.expPos}" -> v.prov.loco }.toList
+              , true))
+        }
+
         println(s"Inferred poly constr: $cty  —— where ${cty.showBounds}")
         
         val cty_fresh =
@@ -662,7 +673,7 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
         tv.assignedTo = S(bod)
         tv
       case Rem(base, fs) => Without(rec(base), fs.toSortedSet)(tyTp(ty.toLoc, "field removal type"))
-      case Constrained(base, tvbs, where) =>
+      case Constrained(base, tvbs, where, tscs) =>
         val res = rec(base match {
           case ty: Type => ty
           case _ => die
@@ -675,6 +686,14 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
           constrain(rec(lo), rec(hi))(raise,
             tp(mergeOptions(lo.toLoc, hi.toLoc)(_ ++ _), "constraint specifiation"), ctx)
         }
+        tscs.foreach { case (typevars, constrs) =>
+          val tvs = typevars.map(x => (x._1, rec(x._2)))
+          val tsc = new TupleSetConstraints(constrs.map(_.map(rec)), tvs)
+          tvs.values.map(_.unwrapProxies).zipWithIndex.foreach {
+            case (tv: TV, i) => tv.tsc.updateWith(tsc)(_.map(_ + i).orElse(S(Set(i))))
+            case _ => ()
+          }
+        }
         res
       case PolyType(vars, ty) =>
         val oldLvl = ctx.lvl
@@ -1860,8 +1879,10 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
     val expandType = ()
     
     var bounds: Ls[TypeVar -> Bounds] = Nil
+    var tscs: Ls[Ls[(Bool, Type)] -> Ls[Ls[Type]]] = Nil
     
     val seenVars = mutable.Set.empty[TV]
+    val seenTscs = mutable.Set.empty[TupleSetConstraints]
     
     def field(ft: FieldType)(implicit ectx: ExpCtx): Field = ft match {
       case FieldType(S(l: TV), u: TV) if l === u =>
@@ -1969,6 +1990,14 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
                 if (l =/= Bot || u =/= Top)
                   bounds ::= nv -> Bounds(l, u)
             }
+            tv.tsc.foreachEntry {
+              case (tsc, i) =>
+                if (seenTscs.add(tsc)) {
+                  val tvs = tsc.tvs.map(x => (x._1,go(x._2)))
+                  val constrs = tsc.constraints.map(_.map(go))
+                  tscs ::= tvs -> constrs
+                }
+            }
           }
           nv
         })
@@ -2018,17 +2047,20 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
         case Overload(as) => as.map(go).reduce(Inter)
         case PolymorphicType(lvl, bod) =>
           val boundsSize = bounds.size
+          val tscsSize = tscs.size
           val b = go(bod)
           
           // This is not completely correct: if we've already traversed TVs as part of a previous sibling PolymorphicType,
           // the bounds of these TVs won't be registered again...
           // FIXME in principle we'd want to compute a transitive closure...
           val newBounds = bounds.reverseIterator.drop(boundsSize).toBuffer
+          val newTscs = tscs.reverseIterator.drop(tscsSize).toBuffer
           
           val qvars = bod.varsBetween(lvl, MaxLevel).iterator
           val ftvs = b.freeTypeVariables ++
             newBounds.iterator.map(_._1) ++
-            newBounds.iterator.flatMap(_._2.freeTypeVariables)
+            newBounds.iterator.flatMap(_._2.freeTypeVariables) ++
+            newTscs.iterator.flatMap(_._1.map(_._2))
           val fvars = qvars.filter(tv => ftvs.contains(tv.asTypeVar))
           if (fvars.isEmpty) b else
             PolyType(fvars
@@ -2042,7 +2074,7 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
           val lbs = groups2.toList
           val bounds = (ubs.mapValues(_.reduce(_ &- _)) ++ lbs.mapValues(_.reduce(_ | _)).map(_.swap))
           val processed = bounds.map { case (lo, hi) => Bounds(go(lo), go(hi)) }
-          Constrained(go(bod), Nil, processed)
+          Constrained(go(bod), Nil, processed, Nil)
         
         // case DeclType(lvl, info) =>
           
@@ -2050,8 +2082,8 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
     // }(r => s"~> $r")
     
     val res = goLike(st)(new ExpCtx(Map.empty))
-    if (bounds.isEmpty) res
-    else Constrained(res, bounds, Nil)
+    if (bounds.isEmpty && tscs.isEmpty) res
+    else Constrained(res, bounds, Nil, tscs)
     
     // goLike(st)
   }
diff --git a/shared/src/main/scala/mlscript/TyperDatatypes.scala b/shared/src/main/scala/mlscript/TyperDatatypes.scala
index 755ba9bfe0..17a95fc8ff 100644
--- a/shared/src/main/scala/mlscript/TyperDatatypes.scala
+++ b/shared/src/main/scala/mlscript/TyperDatatypes.scala
@@ -1,7 +1,7 @@
 package mlscript
 
 import scala.collection.mutable
-import scala.collection.mutable.{Map => MutMap, Set => MutSet, Buffer}
+import scala.collection.mutable.{Map => MutMap, Set => MutSet, Buffer, LinkedHashMap}
 import scala.collection.immutable.{SortedSet, SortedMap}
 import scala.util.chaining._
 import scala.annotation.tailrec
@@ -558,6 +558,8 @@ abstract class TyperDatatypes extends TyperHelpers { Typer: Typer =>
       require(value.forall(_.level <= level))
       _assignedTo = value
     }
+
+    val tsc: LinkedHashMap[TupleSetConstraints, Set[Int]] = LinkedHashMap.empty
     
     // * Bounds should always be disregarded when `equatedTo` is defined, as they are then irrelevant:
     def lowerBounds: List[SimpleType] = { require(assignedTo.isEmpty, this); _lowerBounds }
@@ -670,5 +672,117 @@ abstract class TyperDatatypes extends TyperHelpers { Typer: Typer =>
     lazy val underlying: SimpleType = tt.neg()
     val prov = noProv
   }
-  
+
+  class TupleSetConstraints(var constraints: Ls[Ls[ST]], var tvs: Ls[(Bool, ST)]) {
+    def updateImpl(index: Int, bound: ST)(implicit raise: Raise, ctx: Ctx) : Unit = {
+      val u0 = constraints.flatMap { c =>
+        TupleSetConstraints.lcg(tvs(index)._1, bound, c(index)).map(tvs.zip(c)++_)
+      }
+      val u = u0.map { x =>
+        x.groupMap(_._1)(_._2).map { case (u@(p,_),l) =>
+          (u,l.reduce((x,y) => ComposedType(!p,x,y)(noProv)))
+        }
+      }
+      if (!u.isEmpty) {
+        tvs.values.map(_.unwrapProxies).foreach {
+          case tv: TV => tv.tsc += this -> Set.empty
+          case _ => ()
+        }
+        tvs = u.flatMap(_.keys).distinct
+        constraints = tvs.map(x => u.map(_.getOrElse(x,if (x._1) TopType else BotType))).transpose
+        tvs.values.map(_.unwrapProxies).zipWithIndex.foreach {
+          case (tv: TV, i) => tv.tsc.updateWith(this)(_.map(_ + i).orElse(S(Set(i))))
+          case _ => ()
+        }
+      } else {
+        constraints = Nil
+      }
+    }
+    def updateOn(index: Int, bound: ST)(implicit raise: Raise, ctx: Ctx) : Unit = {
+      updateImpl(index, bound)
+      println(s"TSC update: $tvs in $constraints")
+    }
+  }
+  object TupleSetConstraints {
+    def lcgField(pol: Bool, first: FieldType, rest: FieldType)(implicit ctx: Ctx)
+        : Opt[Ls[(Bool, ST) -> ST]] = {
+      for {
+        ubm <- lcg(pol, first.ub, rest.ub)
+        lbm <- {
+          if (first.lb.isEmpty && rest.lb.isEmpty)
+            S(Nil)
+          else
+            lcg(!pol, first.lb.getOrElse(BotType), rest.lb.getOrElse(BotType))
+        }
+      } yield {
+        ubm ++ lbm
+      }
+    }
+    def lcg(pol: Bool, first: ST, rest: ST)(implicit ctx: Ctx)
+        : Opt[Ls[(Bool, ST) -> ST]] = (first.unwrapProxies, rest.unwrapProxies) match {
+      case (a, ExtrType(p)) if p =/= pol => S(Nil)
+      case (a, ComposedType(p,l,r)) if p =/= pol =>
+        for {
+          lm <- lcg(pol,a,l)
+          rm <- lcg(pol,a,r)
+        } yield {
+          lm ++ rm
+        }
+      case (a: TV, b: TV) if a.compare(b) === 0 => S(Nil)
+      case (a: TV, b) => S(List((pol, first) -> rest))
+      case (a, b: TV) => S(List((pol, first) -> rest))
+      case (a: FT, b: FT) => lcgFunction(pol, a, b)
+      case (a: ArrayType, b: ArrayType) => lcgField(pol, a.inner, b.inner)
+      case (a: TupleType, b: TupleType) if a.fields.sizeCompare(b.fields) === 0 =>
+        val fs = a.fields.map(_._2).zip(b.fields.map(_._2)).map(u => lcgField(pol, u._1, u._2))
+        if (!fs.contains(N)) {
+          S(fs.flatten.reduce(_++_))
+        } else N
+      case (a: TupleType, b: RecordType) if pol => lcg(pol, a.toRecord, b)
+      case (a: RecordType, b: RecordType) =>
+        val default = FieldType(N, if (pol) TopType else BotType)(noProv)
+        if (b.fields.map(_._1).forall(a.fields.map(_._1).contains)) {
+          val u = a.fields.map {
+            case (v, f) => lcgField(pol, f, b.fields.find(_._1 === v).fold(default)(_._2))
+          }
+          if (!u.contains(N)) {
+            S(u.flatten.reduce(_++_))
+          } else N
+        } else N
+      case (a, b) if a === b => S(Nil)
+      case (a, b) =>
+        val dnf = DNF.mk(MaxLevel, Nil, if (pol) a & b.neg() else b & a.neg(), true)
+        if (dnf.isBot)
+          S(Nil)
+        else if (dnf.cs.forall(c => !(c.vars.isEmpty && c.nvars.isEmpty)))
+          S(List((pol, first) -> rest))
+        else N
+    }
+    def lcgFunction(pol: Bool, first: FT, rest: FT)(implicit ctx: Ctx)
+        : Opt[Ls[(Bool, ST) -> ST]] = {
+      for {
+        lm <- lcg(!pol, first.lhs, rest.lhs)
+        rm <- lcg(pol, first.rhs, rest.rhs)
+      } yield {
+        lm ++ rm
+      }
+    }
+    def mk(ov: Overload, f: FT)(implicit raise: Raise, ctx: Ctx): Opt[TupleSetConstraints] = {
+      val u = ov.alts.flatMap(lcgFunction(false, f, _)).map { x =>
+        x.groupMap(_._1)(_._2).map { case (u@(p,_),l) =>
+          (u,l.reduce((x,y) => ComposedType(!p,x,y)(noProv)))
+        }
+      }
+      if (u.isEmpty) { return N }
+      val tvs = u.flatMap(_.keys).distinct
+      val m = tvs.map(x => u.map(_.getOrElse(x,if (x._1) TopType else BotType)))
+      val tsc = new TupleSetConstraints(m.transpose, tvs)
+      tvs.values.map(_.unwrapProxies).zipWithIndex.foreach {
+        case (tv: TV, i) => tv.tsc.updateWith(tsc)(_.map(_ + i).orElse(S(Set(i))))
+        case _ => ()
+      }
+      println(s"TSC mk: ${tsc.tvs} in ${tsc.constraints}")
+      S(tsc)
+    }
+  }
 }
diff --git a/shared/src/main/scala/mlscript/TyperHelpers.scala b/shared/src/main/scala/mlscript/TyperHelpers.scala
index 9b967a1d99..c4e9c2299b 100644
--- a/shared/src/main/scala/mlscript/TyperHelpers.scala
+++ b/shared/src/main/scala/mlscript/TyperHelpers.scala
@@ -695,36 +695,6 @@ abstract class TyperHelpers { Typer: Typer =>
       case _ => this :: Nil
     }
     
-    def childrenPol(pol: Opt[Bool])(implicit ctx: Ctx): List[Opt[Bool] -> SimpleType] = {
-      def childrenPolField(fld: FieldType): List[Opt[Bool] -> SimpleType] =
-        fld.lb.map(pol.map(!_) -> _).toList ::: pol -> fld.ub :: Nil
-      this match {
-        case tv @ AssignedVariable(ty) =>
-          pol -> ty :: Nil
-        case tv: TypeVariable =>
-          (if (pol =/= S(false)) tv.lowerBounds.map(S(true) -> _) else Nil) :::
-          (if (pol =/= S(true)) tv.upperBounds.map(S(false) -> _) else Nil)
-        case FunctionType(l, r) => pol.map(!_) -> l :: pol -> r :: Nil
-        case Overload(as) => as.map(pol -> _)
-        case ComposedType(_, l, r) => pol -> l :: pol -> r :: Nil
-        case RecordType(fs) => fs.unzip._2.flatMap(childrenPolField)
-        case TupleType(fs) => fs.unzip._2.flatMap(childrenPolField)
-        case ArrayType(fld) => childrenPolField(fld)
-        case SpliceType(elems) => elems flatMap {case L(l) => pol -> l :: Nil case R(r) => childrenPolField(r)}
-        case NegType(n) => pol.map(!_) -> n :: Nil
-        case ExtrType(_) => Nil
-        case ProxyType(und) => pol -> und :: Nil
-        // case _: TypeTag => Nil
-        case _: ObjectTag | _: Extruded => Nil
-        case SkolemTag(id) => pol -> id :: Nil
-        case tr: TypeRef => tr.mapTargs(pol)(_ -> _)
-        case Without(b, ns) => pol -> b :: Nil
-        case TypeBounds(lb, ub) => S(false) -> lb :: S(true) -> ub :: Nil
-        case PolymorphicType(_, und) => pol -> und :: Nil
-        case ConstrainedType(cs, bod) =>
-          cs.flatMap(vbs => S(true) -> vbs._1 :: S(false) -> vbs._2 :: Nil) ::: pol -> bod :: Nil
-    }}
-    
     /** (exclusive, inclusive) */
     def varsBetween(lb: Level, ub: Level): Set[TV] = {
       val res = MutSet.empty[TypeVariable]
@@ -789,7 +759,8 @@ abstract class TyperHelpers { Typer: Typer =>
         case tv: TypeVariable =>
           val poltv = pol(tv)
           (if (poltv =/= S(false)) tv.lowerBounds.map(pol.at(tv.level, true) -> _) else Nil) :::
-          (if (poltv =/= S(true)) tv.upperBounds.map(pol.at(tv.level, false) -> _) else Nil)
+          (if (poltv =/= S(true)) tv.upperBounds.map(pol.at(tv.level, false) -> _) else Nil) ++
+          tv.tsc.keys.flatMap(_.tvs).map(u => pol.at(tv.level,u._1) -> u._2)
         case FunctionType(l, r) => pol.contravar -> l :: pol.covar -> r :: Nil
         case Overload(as) => as.map(pol -> _)
         case ComposedType(_, l, r) => pol -> l :: pol -> r :: Nil
@@ -946,7 +917,7 @@ abstract class TyperHelpers { Typer: Typer =>
     }
     def children(includeBounds: Bool): List[SimpleType] = this match {
       case tv @ AssignedVariable(ty) => if (includeBounds) ty :: Nil else Nil
-      case tv: TypeVariable => if (includeBounds) tv.lowerBounds ::: tv.upperBounds else Nil
+      case tv: TypeVariable => if (includeBounds) tv.lowerBounds ::: tv.upperBounds ++ tv.tsc.keys.flatMap(_.tvs.values) else Nil
       case FunctionType(l, r) => l :: r :: Nil
       case Overload(as) => as
       case ComposedType(_, l, r) => l :: r :: Nil
@@ -990,8 +961,16 @@ abstract class TyperHelpers { Typer: Typer =>
       case tv => ("\n\t\t" + tv.toString
           + (if (tv.lowerBounds.isEmpty) "" else " :> " + tv.lowerBounds.mkString(" | "))
           + (if (tv.upperBounds.isEmpty) "" else " <: " + tv.upperBounds.mkString(" & ")))
-      }.mkString
-    
+      }.mkString + {
+        val visited: MutSet[TupleSetConstraints] = MutSet.empty
+        getVars.iterator.flatMap(_.tsc).map { case (tsc, i) =>
+          if (visited.add(tsc))
+            ("\n\t\t[ "
+              + tsc.tvs.map(t => s"${printPol(t._1)}${t._2}").mkString(", ")
+              + " ] in { " + tsc.constraints.mkString(", ") + " }")
+          else ""
+        }.mkString
+      }
   }
   
   
@@ -1336,6 +1315,7 @@ abstract class TyperHelpers { Typer: Typer =>
         val poltv = pol(tv)
         if (poltv =/= S(false)) tv.lowerBounds.foreach(apply(pol.at(tv.level, true)))
         if (poltv =/= S(true)) tv.upperBounds.foreach(apply(pol.at(tv.level, false)))
+        tv.tsc.keys.flatMap(_.tvs).foreach(u => apply(pol.at(tv.level,u._1))(u._2))
       case FunctionType(l, r) => apply(pol.contravar)(l); apply(pol)(r)
       case Overload(as) => as.foreach(apply(pol))
       case ComposedType(_, l, r) => apply(pol)(l); apply(pol)(r)
diff --git a/shared/src/main/scala/mlscript/codegen/typescript/TsTypegen.scala b/shared/src/main/scala/mlscript/codegen/typescript/TsTypegen.scala
index 51a41cfa35..c75f8025e8 100644
--- a/shared/src/main/scala/mlscript/codegen/typescript/TsTypegen.scala
+++ b/shared/src/main/scala/mlscript/codegen/typescript/TsTypegen.scala
@@ -572,7 +572,7 @@ final class TsTypegenCodeBuilder {
         typeScope.getTypeAliasSymbol(tvarName).map { taliasInfo =>
           SourceCode(taliasInfo.lexicalName) ++ SourceCode.paramList(taliasInfo.params.map(SourceCode(_)))
         }.getOrElse(SourceCode(tvarName))
-      case Constrained(base, tvbs, where) =>
+      case Constrained(base, tvbs, where, _) =>
         throw CodeGenError(s"Cannot generate type for `where` clause $tvbs $where")
       case _: Splice | _: TypeTag | _: PolyType | _: Selection =>
         throw CodeGenError(s"Cannot yet generate type for: $mlType")
diff --git a/shared/src/main/scala/mlscript/helpers.scala b/shared/src/main/scala/mlscript/helpers.scala
index aa9505c371..8131ff246d 100644
--- a/shared/src/main/scala/mlscript/helpers.scala
+++ b/shared/src/main/scala/mlscript/helpers.scala
@@ -1,5 +1,4 @@
 package mlscript
-
 import scala.util.chaining._
 import scala.collection.mutable.{Map => MutMap, SortedMap => SortedMutMap, Set => MutSet, Buffer}
 import scala.collection.immutable.SortedMap
@@ -115,7 +114,7 @@ trait TypeLikeImpl extends Located { self: TypeLike =>
           .mkString("forall ", " ", ".")} ${body.showIn(0)}",
         outerPrec > 1 // or 0?
       )
-    case Constrained(b, bs, ws) =>
+    case Constrained(b, bs, ws, tscs) =>
       val oldCtx = ctx
       val bStr = b.showIn(0).stripSuffix("\n")
       val multiline = bStr.contains('\n')
@@ -138,6 +137,13 @@ trait TypeLikeImpl extends Located { self: TypeLike =>
         }.mkString
       }${ws.map{
           case Bounds(lo, hi) => s"\n${ctx.indStr}${lo.showIn(0)} <: ${hi.showIn(0)}" // TODO print differently from bs?
+        }.mkString
+      }${tscs.map{
+          case (tvs, constrs) =>
+            val s = tvs.map(u => (if (u._1) "+" else "-") ++ u._2.showIn(0))
+              .mkString("[", ", ", "]")
+            s"\n${ctx.indStr}" + s +
+            s" in ${constrs.map(_.map(_.showIn(0)).mkString("[", ", ", "]")).mkString("{", ", ", "}")}"
         }.mkString}"
       }, outerPrec > 0)
     case fd @ NuFunDef(isLetRec, nme, snme, targs, rhs) =>
@@ -207,7 +213,7 @@ trait TypeLikeImpl extends Located { self: TypeLike =>
     case WithExtension(b, r) => b :: r :: Nil
     case PolyType(targs, body) => targs.map(_.fold(identity, identity)) :+ body
     case Splice(fs) => fs.flatMap{ case L(l) => l :: Nil case R(r) => r.in.toList ++ (r.out :: Nil) }
-    case Constrained(b, bs, ws) => b :: bs.flatMap(c => c._1 :: c._2 :: Nil) ::: ws.flatMap(c => c.lb :: c.ub :: Nil)
+    case Constrained(b, bs, ws, tscs) => b :: bs.flatMap(c => c._1 :: c._2 :: Nil) ::: ws.flatMap(c => c.lb :: c.ub :: Nil) ::: tscs.flatMap(tsc => tsc._1.map(_._2) ::: tsc._2.flatten)
     case Signature(xs, res) => xs ::: res.toList
     case NuFunDef(isLetRec, nme, snme, targs, rhs) => targs ::: rhs.toOption.toList
     case NuTypeDef(kind, nme, tparams, params, ctor, sig, parents, sup, ths, body) =>
@@ -782,7 +788,7 @@ trait TermImpl extends StatementImpl { self: Term =>
       Constrained(body.toType_!, Nil, where.map {
         case Asc(l, r) => Bounds(l.toType_!, r)
         case s => throw new NotAType(s)
-      })
+      }, Nil)
     case Forall(ps, bod) =>
       PolyType(ps.map(R(_)), bod.toType_!)
     // 
diff --git a/shared/src/main/scala/mlscript/syntax.scala b/shared/src/main/scala/mlscript/syntax.scala
index 5cab302df7..44a57eeeee 100644
--- a/shared/src/main/scala/mlscript/syntax.scala
+++ b/shared/src/main/scala/mlscript/syntax.scala
@@ -161,7 +161,7 @@ final case class Rem(base: Type, names: Ls[Var])         extends Type
 final case class Bounds(lb: Type, ub: Type)              extends Type
 final case class WithExtension(base: Type, rcd: Record)  extends Type
 final case class Splice(fields: Ls[Either[Type, Field]]) extends Type
-final case class Constrained(base: TypeLike, tvBounds: Ls[TypeVar -> Bounds], where: Ls[Bounds]) extends Type
+final case class Constrained(base: TypeLike, tvBounds: Ls[TypeVar -> Bounds], where: Ls[Bounds], tscs: Ls[Ls[(Bool, Type)] -> Ls[Ls[Type]]]) extends Type
 // final case class FirstClassDefn(defn: NuTypeDef)         extends Type // TODO
 // final case class Refinement(base: Type, decls: TypingUnit) extends Type // TODO
 
diff --git a/shared/src/test/diff/fcp/Overloads.mls b/shared/src/test/diff/fcp/Overloads.mls
index 2e0e51a78c..770079c253 100644
--- a/shared/src/test/diff/fcp/Overloads.mls
+++ b/shared/src/test/diff/fcp/Overloads.mls
@@ -70,8 +70,51 @@ IISS 0
 (if true then IISS else BBNN) 0
 //│ res: bool | number | string
 
-fun x -> (if true then IISS else BBNN) x
-//│ res: int -> (bool | number | string)
+def f = fun x -> (if true then IISS else BBNN) x
+//│ f: int -> (bool | number | string)
+
+f(0)
+//│ res: bool | number | string
+
+:e
+f(0) + 1
+//│ ╔══[ERROR] Type mismatch in operator application:
+//│ ║  l.80: 	f(0) + 1
+//│ ║        	^^^^^^
+//│ ╟── type `bool` is not an instance of type `int`
+//│ ║  l.13: 	def BBNN: bool -> bool & number -> number
+//│ ║        	                  ^^^^
+//│ ╟── but it flows into application with expected type `int`
+//│ ║  l.80: 	f(0) + 1
+//│ ╙──      	^^^^
+//│ res: error | int
+
+:e
+f : int -> number
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.93: 	f : int -> number
+//│ ║        	^
+//│ ╟── type `bool` is not an instance of type `number`
+//│ ║  l.13: 	def BBNN: bool -> bool & number -> number
+//│ ║        	                  ^^^^
+//│ ╟── Note: constraint arises from type reference:
+//│ ║  l.93: 	f : int -> number
+//│ ╙──      	           ^^^^^^
+//│ res: int -> number
+
+:e
+f : number -> int
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.106: 	f : number -> int
+//│ ║         	^
+//│ ╟── type `number` does not match type `int | string`
+//│ ║  l.106: 	f : number -> int
+//│ ║         	    ^^^^^^
+//│ ╟── Note: constraint arises from reference:
+//│ ║  l.73: 	def f = fun x -> (if true then IISS else BBNN) x
+//│ ╙──      	                                               ^
+//│ res: number -> int
+
 
 if true then IISS else BBNN
 //│ res: bool -> bool & number -> number | int -> int & string -> string
@@ -85,11 +128,11 @@ if true then IISS else BBNN
 :e
 (if true then IISS else BBNN) : (0 | 1 | true) -> number
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.86: 	(if true then IISS else BBNN) : (0 | 1 | true) -> number
-//│ ║        	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ║  l.129: 	(if true then IISS else BBNN) : (0 | 1 | true) -> number
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── type `true` does not match type `int | string`
-//│ ║  l.86: 	(if true then IISS else BBNN) : (0 | 1 | true) -> number
-//│ ╙──      	                                         ^^^^
+//│ ║  l.129: 	(if true then IISS else BBNN) : (0 | 1 | true) -> number
+//│ ╙──       	                                         ^^^^
 //│ res: (0 | 1 | true) -> number
 
 
@@ -107,13 +150,13 @@ not test
 //│   <:  test:
 //│ ~(int -> int)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.105: 	not test
+//│ ║  l.148: 	not test
 //│ ║         	^^^^^^^^
 //│ ╟── type `~(int -> int)` is not an instance of type `bool`
-//│ ║  l.99: 	def test: ~(int -> int)
-//│ ║        	          ^^^^^^^^^^^^^
+//│ ║  l.142: 	def test: ~(int -> int)
+//│ ║         	          ^^^^^^^^^^^^^
 //│ ╟── but it flows into reference with expected type `bool`
-//│ ║  l.105: 	not test
+//│ ║  l.148: 	not test
 //│ ╙──       	    ^^^^
 //│ res: bool | error
 
diff --git a/shared/src/test/diff/fcp/Overloads_Precise.mls b/shared/src/test/diff/fcp/Overloads_Precise.mls
new file mode 100644
index 0000000000..d24fc5dfc0
--- /dev/null
+++ b/shared/src/test/diff/fcp/Overloads_Precise.mls
@@ -0,0 +1,197 @@
+
+:NoJS
+:NoApproximateOverload
+
+type IISS = int -> int & string -> string
+type BBNN = bool -> bool & number -> number
+type ZZII = 0 -> 0 & int -> int
+//│ Defined type alias IISS
+//│ Defined type alias BBNN
+//│ Defined type alias ZZII
+
+def IISS: int -> int & string -> string
+def BBNN: bool -> bool & number -> number
+def ZZII: 0 -> 0 & int -> int
+//│ IISS: int -> int & string -> string
+//│ BBNN: bool -> bool & number -> number
+//│ ZZII: 0 -> 0 & int -> int
+
+
+IISS : IISS
+//│ res: IISS
+
+IISS : int -> int & string -> string
+//│ res: int -> int & string -> string
+
+IISS : IISS | BBNN
+//│ res: BBNN | IISS
+
+:e
+IISS : ZZII
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.30: 	IISS : ZZII
+//│ ║        	^^^^
+//│ ╟── type `int -> int & string -> string` is not an instance of `0 -> 0`
+//│ ║  l.12: 	def IISS: int -> int & string -> string
+//│ ║        	          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── but it flows into reference with expected type `0 -> 0`
+//│ ║  l.30: 	IISS : ZZII
+//│ ║        	^^^^
+//│ ╟── Note: constraint arises from function type:
+//│ ║  l.7: 	type ZZII = 0 -> 0 & int -> int
+//│ ║       	            ^^^^^^
+//│ ╟── from type reference:
+//│ ║  l.30: 	IISS : ZZII
+//│ ╙──      	       ^^^^
+//│ res: ZZII
+
+:e
+IISS : BBNN
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.49: 	IISS : BBNN
+//│ ║        	^^^^
+//│ ╟── type `int -> int & string -> string` is not an instance of `bool -> bool`
+//│ ║  l.12: 	def IISS: int -> int & string -> string
+//│ ║        	          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── but it flows into reference with expected type `bool -> bool`
+//│ ║  l.49: 	IISS : BBNN
+//│ ║        	^^^^
+//│ ╟── Note: constraint arises from function type:
+//│ ║  l.6: 	type BBNN = bool -> bool & number -> number
+//│ ║       	            ^^^^^^^^^^^^
+//│ ╟── from type reference:
+//│ ║  l.49: 	IISS : BBNN
+//│ ╙──      	       ^^^^
+//│ res: BBNN
+
+
+// * These tests show that we currently throw away information when constraining LHS overloading sets:
+
+IISS : int -> int
+//│ res: int -> int
+
+IISS : (0 | 1) -> number
+//│ res: (0 | 1) -> number
+
+IISS : 'a -> 'a
+//│ res: 'a -> 'a
+//│   where
+//│     [-'a, +'a] in {[int, int], [string, string]}
+
+IISS 0
+//│ res: int
+
+(IISS : int -> int) 0
+//│ res: int
+
+(if true then IISS else BBNN) 0
+//│ res: number
+
+// * Note that this is not considered ambiguous
+// * because the type variable occurrences are polar,
+// * meaning that the TSCs are always trivially satisfiable
+// * and thus the code is well-typed.
+// * Conceptually, we'd expect this inferred type to reduce to `int -> number`,
+// * but it's tricky to do such simplifications in general.
+def f = fun x -> (if true then IISS else BBNN) x
+//│ f: 'a -> 'b
+//│   where
+//│     [+'a, -'b] in {[int, int], [string, string]}
+//│     [+'a, -'b] in {[bool, bool], [number, number]}
+
+f(0)
+//│ res: number
+
+:e
+f(0) + 1
+//│ ╔══[ERROR] Type mismatch in operator application:
+//│ ║  l.106: 	f(0) + 1
+//│ ║         	^^^^^^
+//│ ╟── type `number` is not an instance of type `int`
+//│ ║  l.13: 	def BBNN: bool -> bool & number -> number
+//│ ║        	                                   ^^^^^^
+//│ ╟── but it flows into application with expected type `int`
+//│ ║  l.106: 	f(0) + 1
+//│ ╙──       	^^^^
+//│ res: error | int
+
+f : int -> number
+//│ res: int -> number
+
+:e
+f : number -> int
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.122: 	f : number -> int
+//│ ║         	^
+//│ ╟── type `number` does not match type `?a`
+//│ ║  l.122: 	f : number -> int
+//│ ╙──       	    ^^^^^^
+//│ res: number -> int
+
+
+if true then IISS else BBNN
+//│ res: bool -> bool & number -> number | int -> int & string -> string
+
+(if true then IISS else ZZII) : int -> int
+//│ res: int -> int
+
+(if true then IISS else BBNN) : (0 | 1) -> number
+//│ res: (0 | 1) -> number
+
+:e
+(if true then IISS else BBNN) : (0 | 1 | true) -> number
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.142: 	(if true then IISS else BBNN) : (0 | 1 | true) -> number
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── type `int -> int & string -> string` is not an instance of `(0 | 1 | true) -> number`
+//│ ║  l.12: 	def IISS: int -> int & string -> string
+//│ ║        	          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── but it flows into reference with expected type `(0 | 1 | true) -> number`
+//│ ║  l.142: 	(if true then IISS else BBNN) : (0 | 1 | true) -> number
+//│ ║         	              ^^^^
+//│ ╟── Note: constraint arises from function type:
+//│ ║  l.142: 	(if true then IISS else BBNN) : (0 | 1 | true) -> number
+//│ ╙──       	                                ^^^^^^^^^^^^^^^^^^^^^^^^
+//│ res: (0 | 1 | true) -> number
+
+
+// * Note that type normalization used to be very aggressive at approximating non-tag type negations,
+// * to simplify the result, but this was changed as it was unsound
+
+def test: ~(int -> int)
+//│ test: ~(int -> int)
+
+// * See also test file BooleanFail.mls about this previous unsoundness
+:e
+test = 42
+not test
+//│ 42
+//│   <:  test:
+//│ ~(int -> int)
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.167: 	not test
+//│ ║         	^^^^^^^^
+//│ ╟── type `~(int -> int)` is not an instance of type `bool`
+//│ ║  l.161: 	def test: ~(int -> int)
+//│ ║         	          ^^^^^^^^^^^^^
+//│ ╟── but it flows into reference with expected type `bool`
+//│ ║  l.167: 	not test
+//│ ╙──       	    ^^^^
+//│ res: bool | error
+
+def test: ~(int -> int) & ~bool
+//│ test: ~bool & ~(int -> int)
+
+def test: ~(int -> int) & bool
+//│ test: bool
+
+def test: ~(int -> int) & ~(bool -> bool)
+//│ test: ~(nothing -> (bool | int))
+
+def test: ~(int -> int | bool -> bool)
+//│ test: ~(nothing -> (bool | int))
+
+def test: ~(int -> int & string -> string) & ~(bool -> bool & number -> number)
+//│ test: in ~(nothing -> (number | string) & int -> number & nothing -> (bool | string) & nothing -> (bool | int)) out ~(nothing -> (bool | int) & nothing -> (bool | string) & int -> number & nothing -> (number | string))
+
+
diff --git a/shared/src/test/diff/nu/HeungTung.mls b/shared/src/test/diff/nu/HeungTung.mls
index cace8c821d..3785f32dd9 100644
--- a/shared/src/test/diff/nu/HeungTung.mls
+++ b/shared/src/test/diff/nu/HeungTung.mls
@@ -1,4 +1,5 @@
 :NewDefs
+:NoApproximateOverload
 
 
 
@@ -66,8 +67,21 @@ fun g = h
 //│ fun g: (Int | false | true) -> (Int | false | true)
 
 // * In one step
+:e // TODO: argument of union type
 fun g: (Int | Bool) -> (Int | Bool)
 fun g = f
+//│ ╔══[ERROR] Type mismatch in definition:
+//│ ║  l.72: 	fun g = f
+//│ ║        	    ^^^^^
+//│ ╟── type `Int -> Int & Bool -> Bool` is not an instance of `(Int | false | true) -> (Int | false | true)`
+//│ ║  l.51: 	fun f: (Int -> Int) & (Bool -> Bool)
+//│ ║        	       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── but it flows into reference with expected type `(Int | false | true) -> (Int | false | true)`
+//│ ║  l.72: 	fun g = f
+//│ ║        	        ^
+//│ ╟── Note: constraint arises from function type:
+//│ ║  l.71: 	fun g: (Int | Bool) -> (Int | Bool)
+//│ ╙──      	       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ fun g: Int -> Int & Bool -> Bool
 //│ fun g: (Int | false | true) -> (Int | false | true)
 
@@ -88,9 +102,17 @@ fun j = i
 fun j: (Int & Bool) -> (Int & Bool)
 fun j = f
 //│ ╔══[ERROR] Type mismatch in definition:
-//│ ║  l.89: 	fun j = f
-//│ ║        	    ^^^^^
-//│ ╙── expression of type `Int` does not match type `nothing`
+//│ ║  l.103: 	fun j = f
+//│ ║         	    ^^^^^
+//│ ╟── type `Int -> Int & Bool -> Bool` is not an instance of `nothing -> nothing`
+//│ ║  l.51: 	fun f: (Int -> Int) & (Bool -> Bool)
+//│ ║        	       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── but it flows into reference with expected type `nothing -> nothing`
+//│ ║  l.103: 	fun j = f
+//│ ║         	        ^
+//│ ╟── Note: constraint arises from function type:
+//│ ║  l.102: 	fun j: (Int & Bool) -> (Int & Bool)
+//│ ╙──       	       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ fun j: Int -> Int & Bool -> Bool
 //│ fun j: nothing -> nothing
 
@@ -106,7 +128,7 @@ fun g = f
 // * With match-type-based constraint solving, we could return Int here
 
 f(0)
-//│ Int | false | true
+//│ Int
 //│ res
 //│     = 0
 
@@ -114,15 +136,26 @@ f(0)
 
 
 x => f(x)
-//│ (Int | false | true) -> (Int | false | true)
+//│ forall 'a 'b. 'a -> 'b
+//│   where
+//│     [+'a, -'b] in {[Int, Int], [Bool, Bool]}
 //│ res
 //│     = [Function: res]
 
 // : forall 'a: 'a -> case 'a of { Int => Int; Bool => Bool } where 'a <: Int | Bool
 
-
+:e
 f(if true then 0 else false)
-//│ Int | false | true
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.148: 	f(if true then 0 else false)
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── type `Int -> Int & Bool -> Bool` is not an instance of `(0 | false) -> ?a`
+//│ ║  l.51: 	fun f: (Int -> Int) & (Bool -> Bool)
+//│ ║        	       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── but it flows into reference with expected type `(0 | false) -> ?a`
+//│ ║  l.148: 	f(if true then 0 else false)
+//│ ╙──       	^
+//│ error
 //│ res
 //│     = 0
 
@@ -132,15 +165,25 @@ f(if true then 0 else false)
 :w
 f(refined if true then 0 else false) // this one can be precise again!
 //│ ╔══[WARNING] Paren-less applications should use the 'of' keyword
-//│ ║  l.133: 	f(refined if true then 0 else false) // this one can be precise again!
+//│ ║  l.166: 	f(refined if true then 0 else false) // this one can be precise again!
 //│ ╙──       	  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╔══[ERROR] Illegal use of reserved operator: refined
-//│ ║  l.133: 	f(refined if true then 0 else false) // this one can be precise again!
+//│ ║  l.166: 	f(refined if true then 0 else false) // this one can be precise again!
 //│ ╙──       	  ^^^^^^^
 //│ ╔══[ERROR] identifier not found: refined
-//│ ║  l.133: 	f(refined if true then 0 else false) // this one can be precise again!
+//│ ║  l.166: 	f(refined if true then 0 else false) // this one can be precise again!
 //│ ╙──       	  ^^^^^^^
-//│ Int | false | true
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.166: 	f(refined if true then 0 else false) // this one can be precise again!
+//│ ║         	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── application of type `error` does not match type `?a`
+//│ ║  l.166: 	f(refined if true then 0 else false) // this one can be precise again!
+//│ ╙──       	  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ 'a
+//│   where
+//│     'b :> error
+//│     'a :> error
+//│     [+'b, -'a] in {}
 //│ Code generation encountered an error:
 //│   unresolved symbol refined
 
@@ -196,7 +239,7 @@ type T = List[Int]
 :e // TODO application types
 type Res = M(T)
 //│ ╔══[ERROR] Wrong number of type arguments – expected 0, found 1
-//│ ║  l.197: 	type Res = M(T)
+//│ ║  l.240: 	type Res = M(T)
 //│ ╙──       	           ^^^^
 //│ type Res = M
 
@@ -219,7 +262,7 @@ fun f: Int -> Int
 fun f: Bool -> Bool
 fun f = id
 //│ ╔══[ERROR] A type signature for 'f' was already given
-//│ ║  l.219: 	fun f: Bool -> Bool
+//│ ║  l.262: 	fun f: Bool -> Bool
 //│ ╙──       	^^^^^^^^^^^^^^^^^^^
 //│ fun f: forall 'a. 'a -> 'a
 //│ fun f: Int -> Int
@@ -227,13 +270,13 @@ fun f = id
 :e // TODO support
 f: (Int -> Int) & (Bool -> Bool)
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.228: 	f: (Int -> Int) & (Bool -> Bool)
+//│ ║  l.271: 	f: (Int -> Int) & (Bool -> Bool)
 //│ ║         	^
 //│ ╟── type `Bool` is not an instance of type `Int`
-//│ ║  l.228: 	f: (Int -> Int) & (Bool -> Bool)
+//│ ║  l.271: 	f: (Int -> Int) & (Bool -> Bool)
 //│ ║         	                   ^^^^
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.218: 	fun f: Int -> Int
+//│ ║  l.261: 	fun f: Int -> Int
 //│ ╙──       	       ^^^
 //│ Int -> Int & Bool -> Bool
 //│ res
@@ -300,17 +343,17 @@ fun test(x) = refined if x is
   A then 0
   B then 1
 //│ ╔══[WARNING] Paren-less applications should use the 'of' keyword
-//│ ║  l.299: 	fun test(x) = refined if x is
+//│ ║  l.342: 	fun test(x) = refined if x is
 //│ ║         	              ^^^^^^^^^^^^^^^
-//│ ║  l.300: 	  A then 0
+//│ ║  l.343: 	  A then 0
 //│ ║         	^^^^^^^^^^
-//│ ║  l.301: 	  B then 1
+//│ ║  l.344: 	  B then 1
 //│ ╙──       	^^^^^^^^^^
 //│ ╔══[ERROR] Illegal use of reserved operator: refined
-//│ ║  l.299: 	fun test(x) = refined if x is
+//│ ║  l.342: 	fun test(x) = refined if x is
 //│ ╙──       	              ^^^^^^^
 //│ ╔══[ERROR] identifier not found: refined
-//│ ║  l.299: 	fun test(x) = refined if x is
+//│ ║  l.342: 	fun test(x) = refined if x is
 //│ ╙──       	              ^^^^^^^
 //│ fun test: (A | B) -> error
 //│ Code generation encountered an error:
@@ -320,3 +363,320 @@ fun test(x) = refined if x is
 
 
 
+fun q: (0|1) -> true & (1|2) -> false
+//│ fun q: (0 | 1) -> true & (1 | 2) -> false
+
+q(0)
+//│ true
+//│ res
+//│     = <no result>
+//│       q is not implemented
+
+q(0) : true
+//│ true
+//│ res
+//│     = <no result>
+//│       q is not implemented
+
+q(1)
+//│ 'a
+//│   where
+//│     [-'a] in {[true], [false]}
+//│ res
+//│     = <no result>
+//│       q is not implemented
+
+q(1) : Bool
+//│ Bool
+//│ res
+//│     = <no result>
+//│       q is not implemented
+
+x => q(x): true
+//│ (0 | 1) -> true
+//│ res
+//│     = <no result>
+//│       q is not implemented
+
+x => q(x)
+//│ forall 'a 'b. 'a -> 'b
+//│   where
+//│     [+'a, -'b] in {[0 | 1, true], [1 | 2, false]}
+//│ res
+//│     = <no result>
+//│       q is not implemented
+
+:e
+(x => q(x))(1):Int
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.410: 	(x => q(x))(1):Int
+//│ ║         	^^^^^^^^^^^^^^
+//│ ╟── application of type `?a` does not match type `Int`
+//│ ╟── Note: constraint arises from type reference:
+//│ ║  l.410: 	(x => q(x))(1):Int
+//│ ╙──       	               ^^^
+//│ Int
+//│ res
+//│     = <no result>
+//│       q is not implemented
+
+:e
+q(1):int
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.424: 	q(1):int
+//│ ║         	^^^^
+//│ ╟── application of type `?a` does not match type `int`
+//│ ╟── Note: constraint arises from type reference:
+//│ ║  l.424: 	q(1):int
+//│ ╙──       	     ^^^
+//│ int
+//│ res
+//│     = <no result>
+//│       q is not implemented
+
+fun w = x => q(x)
+//│ fun w: forall 'a 'b. 'a -> 'b
+//│   where
+//│     [+'a, -'b] in {[0 | 1, true], [1 | 2, false]}
+
+w(0)
+//│ true
+//│ res
+//│     = <no result>
+//│       w and q are not implemented
+
+x => (f: forall a: ((0, Int) -> 'a & (1, Str) -> ['a])) => f(0, x) + 1
+//│ Int -> (f: (0, Int) -> Int & (1, Str) -> [Int]) -> Int
+//│ res
+//│     = [Function: res]
+
+fun r: Int -> Int & Bool -> Bool
+//│ fun r: Int -> Int & Bool -> Bool
+
+:e
+x => r(r(x))
+//│ ╔══[ERROR] ambiguous
+//│ ╟── cannot determine satisfiability of type ?a
+//│ ║  l.457: 	x => r(r(x))
+//│ ╙──       	       ^^^^
+//│ forall 'a 'b 'c. 'a -> 'c
+//│   where
+//│     [+'a, -'b] in {[Int, Int], [Bool, Bool]}
+//│     [-'c, +'b] in {[Int, Int], [Bool, Bool]}
+//│ res
+//│     = <no result>
+//│       r is not implemented
+
+
+r(r(0))
+//│ Int
+//│ res
+//│     = <no result>
+//│       r is not implemented
+
+x => r(r(x))+1
+//│ Int -> Int
+//│ res
+//│     = <no result>
+//│       r is not implemented
+
+fun u: {x:0, y:Int} -> Int & {x:1, z: Str} -> Str
+//│ fun u: {x: 0, y: Int} -> Int & {x: 1, z: Str} -> Str
+
+(a, b, c) => u({x: a, y: b, z: c})
+//│ forall 'a 'b 'c 'd. ('a, 'c, 'd) -> 'b
+//│   where
+//│     [-'b, +'a, +'c, +'d] in {[Int, 0, Int, anything], [Str, 1, anything, Str]}
+//│ res
+//│     = <no result>
+//│       u is not implemented
+
+(a, b) => u({x: a, y: "abc", z: b})
+//│ (1, Str) -> Str
+//│ res
+//│     = <no result>
+//│       u is not implemented
+
+fun s: Str -> Str & AA -> AA
+//│ fun s: Str -> Str & AA -> AA
+
+:e
+let g = x => s(r(x))
+//│ ╔══[ERROR] ambiguous
+//│ ╟── cannot determine satisfiability of type ?a
+//│ ║  l.504: 	let g = x => s(r(x))
+//│ ╙──       	               ^^^^
+//│ let g: forall 'a 'b 'c. 'a -> 'c
+//│   where
+//│     [+'a, -'b] in {[Int, Int], [Bool, Bool]}
+//│     [+'b, -'c] in {[Str, Str], [AA, AA]}
+//│ g
+//│   = <no result>
+//│     s is not implemented
+
+:e
+fun g(x) = s(r(x))
+//│ ╔══[ERROR] ambiguous
+//│ ╟── cannot determine satisfiability of type ?a
+//│ ║  l.518: 	fun g(x) = s(r(x))
+//│ ╙──       	             ^^^^
+//│ fun g: forall 'a 'b 'c. 'a -> 'c
+//│   where
+//│     [+'a, -'b] in {[Int, Int], [Bool, Bool]}
+//│     [-'c, +'b] in {[Str, Str], [AA, AA]}
+
+:e
+x => s(r(x))
+//│ ╔══[ERROR] ambiguous
+//│ ╟── cannot determine satisfiability of type ?a
+//│ ║  l.529: 	x => s(r(x))
+//│ ╙──       	       ^^^^
+//│ forall 'a 'b 'c. 'a -> 'c
+//│   where
+//│     [+'a, -'b] in {[Int, Int], [Bool, Bool]}
+//│     [-'c, +'b] in {[Str, Str], [AA, AA]}
+//│ res
+//│     = <no result>
+//│       s is not implemented
+
+:e
+g(0)
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.543: 	g(0)
+//│ ║         	^^^^
+//│ ╟── expression of type `Int` does not match type `?a`
+//│ ╟── Note: constraint arises from application:
+//│ ║  l.518: 	fun g(x) = s(r(x))
+//│ ╙──       	             ^^^^
+//│ error
+//│ res
+//│     = <no result>
+//│       g and s are not implemented
+
+fun rt: {0: Int} -> Int & {0: Str} -> Str
+//│ fun rt: {0: Int} -> Int & {0: Str} -> Str
+
+rt([1,"str"])
+//│ Int
+//│ res
+//│     = <no result>
+//│       rt is not implemented
+
+rt(["str",1])
+//│ Str
+//│ res
+//│     = <no result>
+//│       rt is not implemented
+
+fun app2: ('a -> 'a -> 'a) -> 'a -> 'a
+//│ fun app2: forall 'a. ('a -> 'a -> 'a) -> 'a -> 'a
+
+fun snd: A -> Int -> Int & Str -> Str -> Str
+//│ fun snd: A -> Int -> Int & Str -> Str -> Str
+
+:e
+x => app2(snd)(x):Int
+//│ ╔══[ERROR] Type mismatch in type ascription:
+//│ ║  l.578: 	x => app2(snd)(x):Int
+//│ ║         	     ^^^^^^^^^^^^
+//│ ╟── type `Int` is not an instance of type `A`
+//│ ║  l.571: 	fun app2: ('a -> 'a -> 'a) -> 'a -> 'a
+//│ ║         	                       ^^
+//│ ╟── Note: constraint arises from type reference:
+//│ ║  l.574: 	fun snd: A -> Int -> Int & Str -> Str -> Str
+//│ ╙──       	         ^
+//│ nothing -> Int
+//│ res
+//│     = <no result>
+//│       app2 is not implemented
+
+fun app2_ (f:'a -> 'a -> 'a)(x) = f(x)(x)
+//│ fun app2_: forall 'a. (f: 'a -> 'a -> 'a) -> 'a -> 'a
+
+app2_(snd)
+//│ 'a -> 'b
+//│   where
+//│     'a <: 'b
+//│     [-'b, -'a, +'a] in {[Int, Int, A & Int], [Str, Str, Str]}
+//│ res
+//│     = <no result>
+//│       snd is not implemented
+
+// * Example from WeirdUnions.mls.
+// * This type merges the input tuples:
+fun f: (Str => Str) & ((Str, Int) => Str)
+//│ fun f: (...Array[Int | Str] & {0: Str}) -> Str
+
+f("abc", "abc")
+//│ Str
+//│ res
+//│     = <no result>
+//│       f is not implemented
+
+fun f: (Str => Str) & ((Str, Int) => Int)
+//│ fun f: Str -> Str & (Str, Int) -> Int
+
+// * Different from WeirdUnions.mls:
+:e
+f("abc", "abc")
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.621: 	f("abc", "abc")
+//│ ║         	^^^^^^^^^^^^^^^
+//│ ╟── type `Str -> Str & (Str, Int) -> Int` is not an instance of `("abc", "abc") -> ?a`
+//│ ║  l.616: 	fun f: (Str => Str) & ((Str, Int) => Int)
+//│ ║         	       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── but it flows into reference with expected type `("abc", "abc") -> ?a`
+//│ ║  l.621: 	f("abc", "abc")
+//│ ╙──       	^
+//│ error
+//│ res
+//│     = <no result>
+//│       f is not implemented
+
+f("abcabc")
+//│ Str
+//│ res
+//│     = <no result>
+//│       f is not implemented
+
+:e
+x => rt([not(x)])
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.643: 	x => rt([not(x)])
+//│ ║         	     ^^^^^^^^^^^^
+//│ ╟── application of type `Bool` does not match type `?a`
+//│ ║  l.643: 	x => rt([not(x)])
+//│ ╙──       	         ^^^^^^
+//│ forall 'a 'b. Bool -> 'a
+//│   where
+//│     'b :> Bool
+//│     'a :> error
+//│     [-'a, +'b] in {}
+//│ res
+//│     = <no result>
+//│       rt is not implemented
+
+:e
+rt(0)
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.660: 	rt(0)
+//│ ║         	^^^^^
+//│ ╟── type `{0: Int} -> Int & {0: Str} -> Str` is not an instance of `0 -> ?a`
+//│ ║  l.556: 	fun rt: {0: Int} -> Int & {0: Str} -> Str
+//│ ║         	        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── but it flows into reference with expected type `0 -> ?a`
+//│ ║  l.660: 	rt(0)
+//│ ╙──       	^^
+//│ error
+//│ res
+//│     = <no result>
+//│       rt is not implemented
+
+fun z: {0:Int} -> nothing & Str -> Str
+//│ fun z: {0: Int} -> nothing & Str -> Str
+
+z([1])
+//│ nothing
+//│ res
+//│     = <no result>
+//│       z is not implemented
diff --git a/shared/src/test/scala/mlscript/DiffTests.scala b/shared/src/test/scala/mlscript/DiffTests.scala
index 5e3076d28f..6965d73c28 100644
--- a/shared/src/test/scala/mlscript/DiffTests.scala
+++ b/shared/src/test/scala/mlscript/DiffTests.scala
@@ -228,6 +228,7 @@ class DiffTests(state: DiffTests.State)
     // Enable this to see the errors from unfinished `PreTyper`.
     var showPreTyperErrors = false
     var noTailRec = false
+    var noApproximateOverload = false
     
     // * This option makes some test cases pass which assume generalization should happen in arbitrary arguments
     // * but it's way too aggressive to be ON by default, as it leads to more extrusion, cycle errors, etc.
@@ -299,6 +300,7 @@ class DiffTests(state: DiffTests.State)
           case "GeneralizeArguments" => generalizeArguments = true; mode
           case "DontGeneralizeArguments" => generalizeArguments = false; mode
           case "IrregularTypes" => irregularTypes = true; mode
+          case "NoApproximateOverload" => noApproximateOverload = true; mode
           case str @ "Fuel" =>
             // println("'"+line.drop(str.length + 2)+"'")
             typer.startingFuel = line.drop(str.length + 2).toInt; mode
@@ -559,6 +561,7 @@ class DiffTests(state: DiffTests.State)
             typer.explainErrors = mode.explainErrors
             stdout = mode.stdout
             typer.preciselyTypeRecursion = mode.preciselyTypeRecursion
+            typer.noApproximateOverload = noApproximateOverload
             
             val oldCtx = ctx
             
@@ -588,7 +591,7 @@ class DiffTests(state: DiffTests.State)
                 exp match {
                   // * Strip top-level implicitly-quantified type variables
                   case pt: PolyType => stripPoly(pt)
-                  case Constrained(pt: PolyType, bs, cs) => Constrained(stripPoly(pt), bs, cs)
+                  case Constrained(pt: PolyType, bs, cs, tscs) => Constrained(stripPoly(pt), bs, cs, tscs)
                   case ty => ty
                 }
               }

From a7504bb818f21a802f2fc8a338888b67a7c87da5 Mon Sep 17 00:00:00 2001
From: Fa1sePRoMiSe <neilkleist@gmail.com>
Date: Thu, 10 Oct 2024 13:36:12 +0800
Subject: [PATCH 147/147] Fix missing annotation (#226)

---
 shared/src/main/scala/mlscript/NewParser.scala | 2 +-
 shared/src/test/diff/nu/Ascription.mls         | 7 +++++++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/shared/src/main/scala/mlscript/NewParser.scala b/shared/src/main/scala/mlscript/NewParser.scala
index 4024d653cb..2b26020097 100644
--- a/shared/src/main/scala/mlscript/NewParser.scala
+++ b/shared/src/main/scala/mlscript/NewParser.scala
@@ -522,7 +522,7 @@ abstract class NewParser(origin: Origin, tokens: Ls[Stroken -> Loc], newDefs: Bo
                       consume
                       if (tparams.nonEmpty) err(msg"Unsupported type parameters on 'let' binding" -> S(l1) :: Nil)
                       val rest = expr(0)
-                      R(Let(isLetRec.getOrElse(die), v, body, rest).withLoc(S(l0 ++ annotatedBody.toLoc)))
+                      R(Let(isLetRec.getOrElse(die), v, annotatedBody, rest).withLoc(S(l0 ++ annotatedBody.toLoc)))
                     case _ =>
                       R(NuFunDef(
                           isLetRec, v, opStr, tparams, L(ps.foldRight(annotatedBody)((i, acc) => Lam(i, acc)))
diff --git a/shared/src/test/diff/nu/Ascription.mls b/shared/src/test/diff/nu/Ascription.mls
index 7bc04929e6..69c7ce767a 100644
--- a/shared/src/test/diff/nu/Ascription.mls
+++ b/shared/src/test/diff/nu/Ascription.mls
@@ -49,3 +49,10 @@ foo(123:Int):Int
 //│ Code generation encountered an error:
 //│   unresolved symbol Int
 
+fun foo(f) =
+  let g = (x => f(x)): forall 'a : 'a -> 'a in g(123)
+//│ fun foo: (??a -> ??a0) -> 123
+
+fun foo(f) =
+  let g: forall 'a : 'a -> 'a = x => f(x) in g(123)
+//│ fun foo: (??a -> ??a0) -> 123